244 lines
7.4 KiB
Python
Executable File
244 lines
7.4 KiB
Python
Executable File
#! /usr/bin/env python
|
|
|
|
# Mes classes
|
|
import lecon
|
|
import dev
|
|
import book
|
|
import divers
|
|
import config
|
|
|
|
# celles des autres
|
|
import glob
|
|
from operator import itemgetter
|
|
import os
|
|
import optparse
|
|
|
|
|
|
liste_lecon = ( 101 , 103 , 104 , 105 , 106 , 107 , 108 , 109 , 110 , 111 , 112 , 113 , 114 , 116 , 117 , 119 , 120 , 123 , 124 , 125 , 126 , 127 , 128 , 130 , 131 , 132 , 133 , 135 , 136 , 137 , 139 , 140 , 141 , 144 , 145 , 146 , 148 , 149 , 201 , 202 , 203 , 204 , 205 , 206 , 207 , 208 , 213 , 214 , 215 , 216 , 217 , 218 , 219 , 220 , 221 , 223 , 224 , 226 , 228 , 229 , 230 , 232 , 234 , 235 , 236 , 238 , 239 , 240 , 241 , 242 , 243 , 245 , 246 , 247 , 249 , 250 , 251 , 252 , 253 , 254 , 255 , 256 )
|
|
|
|
|
|
class Agreg():
|
|
""" Gere les bouquins, les developpements et les leçons
|
|
"""
|
|
|
|
def __init__(self, ):
|
|
"""
|
|
"""
|
|
|
|
self.book = []
|
|
self.dev = []
|
|
|
|
self.init_lecon()
|
|
|
|
|
|
def init_lecon(self):
|
|
""" Initialise la liste des lecons
|
|
|
|
Arguments:
|
|
- `self`:
|
|
"""
|
|
self.lecon = {}
|
|
|
|
for num in liste_lecon:
|
|
num = str(num)
|
|
l = lecon.Lecon()
|
|
l.from_scratch(num)
|
|
self.lecon[num] = l
|
|
|
|
# -------------------- Import et extraction
|
|
|
|
def import_dev(self, folder = ""):
|
|
""" Import les dev contenus dans folder
|
|
|
|
Arguments:
|
|
- `self`:
|
|
- `folder`: Dossier ou les developpements sont stockés
|
|
"""
|
|
|
|
# for d in glob.glob(folder + '*.agregDev'):
|
|
for d in glob.glob(folder + '*'):
|
|
devel = dev.Dev()
|
|
devel.from_file(d)
|
|
self.dev += [devel]
|
|
|
|
|
|
def extract_from_dev(self):
|
|
""" Remplit les liste lecon et book à partir des informations contenu dans dev
|
|
|
|
Arguments:
|
|
- `self`:
|
|
"""
|
|
for d in self.dev:
|
|
|
|
# Extraction des leçons
|
|
for l in d.lecon:
|
|
self.lecon[l].add_dev(d.nom)
|
|
|
|
# # Extraction des bouquins
|
|
# for b in d.book:
|
|
# self.book Faudra le faire mais j'ai la flemme pour le moment
|
|
|
|
|
|
def import_lecon(self, folder = ""):
|
|
""" Import les lecons contenus dans folder
|
|
|
|
Arguments:
|
|
- `self`:
|
|
- `folder`: Dossier ou les lecons sont stockés
|
|
"""
|
|
|
|
for l in glob.glob(folder + '*.agregLecon'):
|
|
le = lecon.Lecon()
|
|
le.from_file(l)
|
|
self.lecon += [le]
|
|
|
|
def import_book(self, folder = ""):
|
|
""" Import les bouquins contenus dans folder
|
|
|
|
Arguments:
|
|
- `self`:
|
|
- `folder`: Dossier ou les developpements sont stockés
|
|
"""
|
|
|
|
for b in glob.glob(folder + '*.agregBook'):
|
|
bo = book.Book()
|
|
bo.from_file(b)
|
|
self.book += [bo]
|
|
|
|
# -------------------- Analyse
|
|
|
|
def nbr_dev(self):
|
|
""" Calcul et trie le nombre de developpement par lecon et stock la liste dans lecon_nbr_dev
|
|
|
|
Arguments:
|
|
- `self`:
|
|
"""
|
|
self.lecon_nbr_dev = []
|
|
for l in self.lecon.values():
|
|
self.lecon_nbr_dev += [(l.num , len(l.dev))]
|
|
|
|
self.lecon_nbr_dev = sorted(self.lecon_nbr_dev, reverse=True, key=itemgetter(1))
|
|
|
|
def score_dev(self):
|
|
""" Calcul le score/avancement dans nos lecons
|
|
|
|
Arguments:
|
|
- `self`:
|
|
"""
|
|
|
|
# Calcul du nombre de développement effectué (pas plus de 2 par lecon sinon c'est triché!)
|
|
score = 0
|
|
for l in self.lecon.values():
|
|
score += min(2, len(l.dev))
|
|
|
|
# Nombre total de développement nécessaire
|
|
nbr_dev_tot = 2 * len(self.lecon)
|
|
|
|
self.score = score / nbr_dev_tot * 100
|
|
|
|
|
|
|
|
# -------------------- Affichage
|
|
|
|
def print_analyse_dev(self):
|
|
""" Affiche le nombre de developpement par lecon en ordre décroissant
|
|
|
|
Arguments:
|
|
- `self`:
|
|
"""
|
|
# On calcul et trie le nombre de dev
|
|
self.nbr_dev()
|
|
|
|
for i, n in self.lecon_nbr_dev:
|
|
self.lecon[i].print_nbr_dev()
|
|
|
|
self.score_dev()
|
|
if self.score != 100:
|
|
print("\n Courage! Ton score est de {score}% c'est déjà pas mal non?".format(score = self.score))
|
|
else:
|
|
print("\n Bien joué! Toutes les lecons au moins deux développements!")
|
|
|
|
def print_lecon_from_int(self, num = 101):
|
|
""" Écrit le nom des développements en relation avec la leçonà partir du numero de la lecon
|
|
|
|
Arguments:
|
|
- `self`:
|
|
- `num`: le numero d'une lecon
|
|
"""
|
|
num = str(num)
|
|
|
|
if num in self.lecon:
|
|
self.lecon[num].print_dev()
|
|
else:
|
|
print("Leçon inconnue!")
|
|
|
|
|
|
def print_lecon_from_name(self, chaine):
|
|
""" Écrit le nom des développements en relation avec la leçon à partir d'une partie du nom de la lecon
|
|
|
|
Arguments:
|
|
- `self`:
|
|
- `chaine`: Une partie du nom de la (ou des!) lecons
|
|
"""
|
|
|
|
for l in [l for l in self.lecon.values() if divers.normalise_str(chaine) in divers.normalise_str(l.nom)]:
|
|
l.print_dev()
|
|
|
|
|
|
def print_dev(self, chaine):
|
|
""" Affiche les informations sur les développements dont le nom contient "chaine"
|
|
|
|
Arguments:
|
|
- `self`:
|
|
- `chaine`: chaine de caracteres à partir duquel on va séléctionner les dév
|
|
"""
|
|
# Pour chaque nom de dev on selectionne ceux qui contienne la chaine
|
|
|
|
for d in [d for d in self.dev if divers.normalise_str(chaine) in divers.normalise_str(d.nom)]:
|
|
d.print_info()
|
|
|
|
|
|
|
|
if __name__ == '__main__':
|
|
# agreg = Agreg()
|
|
# agreg.import_dev('/media/documents/Cours/Agreg/developpement/mes_dev/')
|
|
# # agreg.analyse_dev()
|
|
# # for num in dico_nom_lecon:
|
|
# # agreg.print_lecon_dev(num)
|
|
# agreg.extract_from_dev()
|
|
# # agreg.print_analyse_dev()
|
|
# agreg.print_lecon_dev(213)
|
|
# agreg.print_lecon_dev(201)
|
|
# agreg.print_lecon_dev(234)
|
|
# agreg.print_lecon_dev(245)
|
|
|
|
# Pour analyser les options qu'on lui demande
|
|
parser = optparse.OptionParser()
|
|
|
|
# options proposée
|
|
parser.add_option("-a","--analyse",action="store_true",dest="analyse", help="Donne le nombre de developpement pour les leçons")
|
|
parser.add_option("-l","--lecon",action="store",type="string",dest="lecon", help="Affiche les développements associés à aux lecons qui contiennent la chaine mis en argument.")
|
|
parser.add_option("-L","--lecons",action="store",type="string",dest="list_lecons", help="Affiche les développements associés aux lecons mis en argument (Entre guillemets séparé par un espace ou sans rien s'il n'y a qu'une lecon)")
|
|
parser.add_option("-d","--dev",action="store",type="string",dest="dev", help="Affiche la liste des developpements et propose d'en selectionner une à décrire")
|
|
|
|
|
|
# Digestion
|
|
(options, args) = parser.parse_args()
|
|
|
|
agreg = Agreg()
|
|
agreg.import_dev(config.lieu_dev)
|
|
agreg.extract_from_dev()
|
|
|
|
if options.analyse:
|
|
agreg.print_analyse_dev()
|
|
|
|
if options.lecon:
|
|
agreg.print_lecon_from_name(options.lecon)
|
|
|
|
if options.list_lecons:
|
|
for l in options.list_lecons.split(" "):
|
|
agreg.print_lecon_from_int(str(l))
|
|
|
|
if options.dev:
|
|
agreg.print_dev(options.dev)
|