Sépare le script de traitement en 2 : 1 pour le parsing -> yaml, 1 autre pour yaml -> latex

python/export_docx_to_yaml.py

@@ -61,7 +61,7 @@ for i in range(2, len(docu)): # A priori un tableau
         nom_ressource = res[0][1][0]
 
         # Création de la ressource
-        r = Ressource(nom_ressource, res)
+        r = RessourceDocx(nom_ressource, res)
         liste_ressources.append(r)
 
         # if len(res) != 15:
@@ -195,9 +195,3 @@ for sem in ressources:
             with open(fichier, "w", encoding="utf8") as fid:
                 fid.write(output)
 
-
-for sem in ressources:
-    for r in ressources[sem]:
-        fichieryaml = "export/{}.yml".format(r.code)
-        fichierlatex = "../latex/ressources/{}.tex".format(r.code)
-        convert_ressource_yml_to_latex(fichieryaml, fichierlatex, "pn/modele_ressource.tex")

python/export_yaml_to_latex.py

@@ -0,0 +1,28 @@
+
+import os
+from ressource import *
+
+import logging
+__LOGGER = logging.getLogger(__name__)
+
+# Chargement des ressources
+REPERTOIRE_RESSOURCES = "export"
+REPERTOIRE_LATEX = "../latex/ressources"
+fichiers = os.listdir(REPERTOIRE_RESSOURCES)
+fichiers = sorted(fichiers) # tri par ordre alphabétique
+
+ressources = {"S1": [], "S2": []}
+for file in fichiers:
+    fichieryaml = REPERTOIRE_RESSOURCES + "/" + file
+    r = Ressource(fichieryaml) # lecture du fichier
+    sem = "S" + str(r.ressource["semestre"])
+    ressources[sem].append(r)
+
+# Export latex
+for sem in ressources:
+    for r in ressources[sem]:
+        fichierlatex = REPERTOIRE_LATEX + "/" + "{}.tex".format(r.ressource["code"])
+        contenu = r.str_to_latex()
+        with open(fichierlatex, "w", encoding="utf8") as fid:
+            fid.write(contenu)
+        print(f"Export de {fichierlatex} ")

python/officiel.py

@@ -106,4 +106,15 @@ def get_officiel_sae_name_by_code(code):
     for sem in DATA_SAES:
         for rcode in DATA_SAES[sem]:
             if rcode==code:
-                return DATA_SAES[sem][code]
+                return DATA_SAES[sem][code]
+
+
+def get_code_from_nom(ressource):
+    """Récupère le code d'une ressource d'après son nom en utilisant les noms officiels
+    des ressources du yaml"""
+    nom = supprime_accent_espace(ressource.nom)
+    for sem in DATA_RESSOURCES:
+        for code in DATA_RESSOURCES[sem]:
+            nom_data = supprime_accent_espace(DATA_RESSOURCES[sem][code])
+            if nom.startswith(nom_data):
+                return code

python/ressource.py

@@ -1,15 +1,15 @@
 import re
 from officiel import *
 from modeles import *
-from officiel import supprime_accent_espace
+from officiel import supprime_accent_espace, get_code_from_nom
 import ruamel.yaml
 from ruamel.yaml.scalarstring import FoldedScalarString as folded
 
 __LOGGER = logging.getLogger(__name__)
 
 
-class Ressource():
+class RessourceDocx():
-    """Classe modélisant les ressources"""
+    """Classe modélisant les ressources, lorsqu'elles sont extraites du docx"""
     def __init__(self, nom, brute):
         self.nom = nom
         self.brute = brute # les données brutes de la ressource
@@ -188,15 +188,6 @@ def nettoie_mots_cles(r):
     mots = mots.replace(".", "")
     r.mots = mots
 
-def get_code_from_nom(ressource):
-    """Récupère le code d'une ressource d'après son nom en utilisant les noms officiels
-    des ressources du yaml"""
-    nom = supprime_accent_espace(ressource.nom)
-    for sem in DATA_RESSOURCES:
-        for code in DATA_RESSOURCES[sem]:
-            nom_data = supprime_accent_espace(DATA_RESSOURCES[sem][code])
-            if nom.startswith(nom_data):
-                return code
 
 def devine_acs_by_code(champ):
     """Recherche les codes ressources de la forme ACXXX ou AC0XXX dans champ ;
@@ -334,95 +325,103 @@ def nettoie_contenus(r):
 
     r.contenu = contenu
 
-def convert_ressource_yml_to_latex(fichieryaml, fichierlatex, modele):
+class Ressource():
-    modlatex = get_modele(modele) #"pn/modele_ressource.tex")
+    """Modélise une ressource lorsqu'elle est extraite d'un yaml"""
-    print(f"Export de {fichieryaml}")
+    __LOGGER = logging.getLogger(__name__)
-    with open(fichieryaml, "r", encoding="utf8") as fid:
-        yaml = ruamel.yaml.YAML()
-        ressource = yaml.load(fid.read())
 
-    # Préparation des ac
+    def __init__(self, fichieryaml):
-    ajoutac = "\\ajoutac{%s}{%s}"
+        with open(fichieryaml, "r", encoding="utf8") as fid:
-    compRT = []
+            yaml = ruamel.yaml.YAML()
-    for accomp in ressource["acs"]:
+            try:
-        comps = []
+                self.ressource = yaml.load(fid.read())
-        for no_ac in range(len(ressource["acs"][accomp])): # les ac de la comp
+            except:
-            comps.append( ajoutac % (accomp, DATA_ACS[accomp][ressource["acs"][accomp][no_ac]]) )
+                Ressource.__LOGGER.warning(f"Pb de chargement de {fichieryaml}")
-        compRT.append("\n".join(comps))
 
-    # Préparation des sae
+    def str_to_latex(self, modele="pn/modele_ressource.tex"):
-    ajoutsaes = "\\ajoutsae{%s}{%s}"
+        """Génère le code latex décrivant la ressource"""
-    saesRT = []
+        modlatex = get_modele(modele) #"pn/modele_ressource.tex")
-    for (i, sae) in enumerate(ressource["sae"]): # in range(len(self.apprentissages)):
-        saesRT.append(ajoutsaes % (sae, get_officiel_sae_name_by_code(sae)))
-    saes = "\n".join(saesRT)
 
-    ajoutprerequis = "\\ajoutprerequis{%s}{%s}"
+
-    prerequis = ""
+        # Préparation des ac
-    if ressource["prerequis"] == "Aucun":
+        ajoutac = "\\ajoutac{%s}{%s}"
+        compRT = []
+        for accomp in self.ressource["acs"]:
+            comps = []
+            for no_ac in range(len(self.ressource["acs"][accomp])): # les ac de la comp
+                comps.append( ajoutac % (accomp, DATA_ACS[accomp][self.ressource["acs"][accomp][no_ac]]) )
+            compRT.append("\n".join(comps))
+
+        # Préparation des sae
+        ajoutsaes = "\\ajoutsae{%s}{%s}"
+        saesRT = []
+        for (i, sae) in enumerate(self.ressource["sae"]): # in range(len(self.apprentissages)):
+            saesRT.append(ajoutsaes % (sae, get_officiel_sae_name_by_code(sae)))
+        saes = "\n".join(saesRT)
+
+        ajoutprerequis = "\\ajoutprerequis{%s}{%s}"
         prerequis = ""
-    else:
+        if self.ressource["prerequis"] == "Aucun":
-        liste = []
+            prerequis = ""
-        for (no, mod) in enumerate(ressource["prerequis"]):
+        else:
-            liste.append(ajoutprerequis % (mod, get_officiel_ressource_name_by_code(mod)))
+            liste = []
-        prerequis = "\n".join(liste)
+            for (no, mod) in enumerate(self.ressource["prerequis"]):
+                liste.append(ajoutprerequis % (mod, get_officiel_ressource_name_by_code(mod)))
+            prerequis = "\n".join(liste)
 
-    # préparation du contexte
+        # préparation du contexte
-    contexte = ressource["contexte"]
+        contexte = self.ressource["contexte"]
 
-    # préparation du contenu
+        # préparation du contenu
-    if ressource["code"] == "R107":
+        # if self.ressource["code"] == "R107":
-        print("ici")
+        #    print("ici")
 
-    contenu = ressource["contenu"] #supprime les passages à la ligne
+        contenu = self.ressource["contenu"] #supprime les passages à la ligne
-    marqueurs = ["*", "\t*"] # les marqueurs de Markdown
+        marqueurs = ["*", "\t*"] # les marqueurs de Markdown
 
-    for marq in marqueurs[::-1]:
+        for marq in marqueurs[::-1]:
-        premier_marqueur = False
+            premier_marqueur = False
-        contenu_balise = contenu.split("\n")
+            contenu_balise = contenu.split("\n")
-        contenu_latex = []
+            contenu_latex = []
 
-        for (i, ligne) in enumerate(contenu_balise): # pour le contenu latex actuel
+            for (i, ligne) in enumerate(contenu_balise): # pour le contenu latex actuel
-            un_marqueur = get_marqueur(ligne, [marq])
+                un_marqueur = get_marqueur(ligne, [marq])
-            if un_marqueur: # le marqueur est trouvé
+                if un_marqueur: # le marqueur est trouvé
-                if premier_marqueur == False:
+                    if premier_marqueur == False:
-                    contenu_latex.append("\\begin{itemize}")
+                        contenu_latex.append("\\begin{itemize}")
-                    premier_marqueur = True
+                        premier_marqueur = True
-                contenu_latex.append( ligne.replace(marq, "\\item"))
+                    contenu_latex.append( ligne.replace(marq, "\\item"))
-            elif premier_marqueur == True: # le marqueur n'est plus trouvé
+                elif premier_marqueur == True: # le marqueur n'est plus trouvé
-                contenu_latex.append( ligne.replace(marq, "\\item"))
+                    contenu_latex.append( ligne.replace(marq, "\\item"))
-                contenu_latex.append("\\end{itemize}")
+                    contenu_latex.append("\\end{itemize}")
-                premier_marqueur = False
+                    premier_marqueur = False
-            else:
+                else:
-                contenu_latex.append(ligne) # la ligne d'origine
+                    contenu_latex.append(ligne) # la ligne d'origine
-            if i == len(contenu_balise) -1 and premier_marqueur == True:
+                if i == len(contenu_balise) -1 and premier_marqueur == True:
-                contenu_latex.append("\\end{itemize}")
+                    contenu_latex.append("\\end{itemize}")
-                premier_marqueur = True # ferme la dernière balise
+                    premier_marqueur = True # ferme la dernière balise
 
-        # contenu_balise = contenu_latex[:]
+            # contenu_balise = contenu_latex[:]
-            contenu = "\n".join(contenu_latex) # stocke le contenu
+                contenu = "\n".join(contenu_latex) # stocke le contenu
 
-        contenu = "\n".join(contenu_latex)
+            contenu = "\n".join(contenu_latex)
 
-    chaine = ""
+        chaine = ""
-    chaine = TemplateLatex(modlatex).substitute(code=ressource["code"],
+        chaine = TemplateLatex(modlatex).substitute(code=self.ressource["code"],
-                                                   nom=ressource["nom"],
+                                                       nom=self.ressource["nom"],
-                                                   heures_formation=ressource["heures_formation"],
+                                                       heures_formation=self.ressource["heures_formation"],
-                                                   heures_tp=ressource["heures_tp"],
+                                                       heures_tp=self.ressource["heures_tp"],
-                                                   compRT1=compRT[0],
+                                                       compRT1=compRT[0],
-                                                   compRT2=compRT[1],
+                                                       compRT2=compRT[1],
-                                                   compRT3=compRT[2],
+                                                       compRT3=compRT[2],
-                                                   saes=saes,
+                                                       saes=saes,
-                                                   motscles=ressource["motscles"],
+                                                       motscles=self.ressource["motscles"],
-                                                   prerequis=prerequis,
+                                                       prerequis=prerequis,
-                                                   contexte=contexte,
+                                                       contexte=contexte,
-                                                   contenu=contenu
+                                                       contenu=contenu
-                                               )
+                                                   )
-    chaine = chaine.replace("&", "\&")
+        chaine = chaine.replace("&", "\&")
-    with open(fichierlatex, "w", encoding="utf8") as fid:
+        return chaine
-        fid.write(chaine)
 
-    return chaine
 
 if __name__=="__main__":
     # Eléments de test