agreg/agreg.py

#! /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 
# Enfin on compte le nombre de dev par leçon. Puis on fait la somme des min avec 2 et on divise par le nombre de dévelloppement


    def compte_dev(self):
        """Crée un dictionnaire correspondant aux leçons
        dans le premier element on compte les devs possibles pour cette leçon
        dans le deuxième on ne compte que ceux qui sont sensé être connu
        
        Arguments:
        - `self`:
        """
        # Initialisation du dico des du nombre de dev par leçons
        self.nbr_dev_lecon = dict()
        for l in liste_lecon:
            self.nbr_dev_lecon[l] = [0,0]    

        for d in self.dev:
            for l in d.lecon:
                self.nbr_dev_lecon[int(l)][0] += 1

                if d.connu:
                    self.nbr_dev_lecon[int(l)][1] += 1

    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 de l'elaboration des leçons et de leurs connaissance (théorique)
        
        Arguments:
        - `self`:
        """
        
        # Calcul du nombre de développement effectué (pas plus de 2 par lecon sinon c'est triché!)
        score = 0
        score_connu = 0

        for n in self.nbr_dev_lecon.values():
            score += min(n[0],2)
            score_connu += min(n[1],2)

        # Nombre total de développement nécessaire
        nbr_dev_tot = 2 * len(self.lecon)

        self.score = score / nbr_dev_tot * 100
        self.score_connu = score_connu / 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.compte_dev()

        self.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!")

        if self.score_connu != 100:
            print("\n Courage! T'en connais déjà {score}% c'est déjà pas mal non?".format(score = self.score_connu))
        else:
            print("\n Bien joué! Toutes les lecons au moins deux développements! Et tu les connais!")

    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()

    
    def print_nbr_dev(self):
        """Affiche le nombre de dev et de dev connu pour les lecons"""
        print("Connue , Envisagée       numero: nom")
        for l,n in self.nbr_dev_lecon.items():

            color_defaut = "\033[00m"
            color_print = color_defaut
            if n[1] >= 2: # Chic j'ai deux dev pour cett lecon
                color_print = "\033[0,32m"
            if n[1] ==1: # Encore un de plus 
                color_print = "\033[0,33m"

            print(color_print + "{connu}      , {envi}          {num}: {nom}".format(connu = n[1] , envi = n[0] , num = l , nom=divers.dico_nom_lecon[str(l)]) + color_defaut )

        
if __name__ == '__main__':
    # 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)