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 

    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)