maintenance.execlocal

  1# -*- coding: utf-8 -*-
  2"""
  3Exécute localement les scripts préliminaires à la publication et à la contextualisation des sources d'un dépôt.
  4
  5Modifié le 30/03/23 @author: remy
  6
  7Traitements à effectuer sur les fichiers d'un dépôt : 
  8
  9- créer-modifier les sources avant compilation
 10- compiler
 11- établir des listes de fichiers images à publier
 12- établir des listes de données utiles lors de la contextualisation
 13
 14Le module `execlocal`
 15- Importe le sous-module [`scantex`](scantex.html) d'examen des fichiers LateX.
 16- Définit la classe `Execlocal`.
 17
 18Les traitements sont effectués lors de l'instanciation d'un objet `Execlocal`. Cette instanciation importe un module spécifique au dépôt.  
 19Actuellement, les sous-modules spécifiques sont 
 20[`exl_mathCours`](exl_mathCours.html), [`exl_mathExos`](exl_mathExos.html) et 
 21[`exl_mathPbs`](exl_mathPbs.html).
 22
 23Les commandes de compilation sont codées dans le fichier `init` (manifeste) du dépôt. Elles sont lancées par la méthode `compil()` de la classe `Execlocal`.  
 24Les données à publier sont extraites par `apublierImg()`.  
 25Les autres traitements sont définis dans la fonction `exec()` du sous-module spécifique.
 26
 27Principales propriétés d'un objet `Execlocal` :
 28
 29- `.log`: journal de l'exécution locale
 30- `.publiables`: liste des fichiers publiables
 31- `.specific_results`: dictionnaire présentant des données spécifiques au dépôt.
 32
 33
 34"""
 35import importlib
 36import subprocess
 37import glob
 38import os.path
 39
 40import scantex
 41
 42
 43class Execlocal:
 44    """Classe d'exécution locale."""
 45
 46    def __init__(self, data):
 47        """
 48        Instancie un objet `Execlocal`.
 49
 50        - récupère les paramètres du dépôt
 51        - initialise la propriété journal (`.log`)
 52        - importe le module spécifique au dépôt
 53        - exécute les traitements spécifiques
 54            - renseigne  `.specific_results`
 55        - exécute les commandes de compilation
 56            - renseigne `.publiables`
 57        
 58
 59        #### Parametres
 60
 61        data :
 62
 63        - TYPE dictionnaire
 64        - DESCRIPTION   codage du *manifeste* du dépôt
 65
 66        La structure de ce dictionnaire est précisée dans le fichier
 67        d'initialisation spécifique [`init_mathExos`](init_mathExos.html)
 68        [`init_mathPbs`](init_mathPbs.html)
 69
 70        #### Renvoie
 71
 72        None.
 73
 74
 75        """
 76        lineprefix = "\n \t \t"
 77        self.log = lineprefix + "Initialisation de la classe Execlocal."
 78        """
 79        Journal d'instanciation d'un objet `Execlocal`.
 80
 81        TYPE chaine de caractères.
 82        """
 83
 84        self.commandes = data['commandes']
 85        self.rel_path = data['relative_path']
 86        self.publish_data = data['publish_data']
 87        self.context_data = data['context_data']
 88
 89        # change de répertoire
 90        maintenance_path = os.getcwd()
 91        os.chdir(self.rel_path)
 92
 93        # importation du module spécifique
 94        module = data['modulespec']
 95        if module:
 96            try:
 97                specific = importlib.import_module(module)
 98                self.log += lineprefix
 99                self.log += "Importation du module spécifique " + module
100                # maintenance spécifique
101                truc = specific.exec(data)
102                self.log += truc['log'] 
103                self.specific_results = truc['specific_results']
104            except ImportError as error:
105                self.log += lineprefix + "Module " + error.name + " pas trouvé"
106
107        # liste des commandes de compilation à exécuter
108        self.cmds_list = self.aexecuter()
109
110        # compilations
111        # print('\n')
112        # for obj in self.cmds_list:
113        #    print(obj, '\n')
114        self.compil()
115
116        # renseigne la propriété .publiables
117        self.publiables = self.apublierImg()
118        # fichiers publiables dict path: date
119
120        # retour au répertoire de base
121        os.chdir(maintenance_path)
122
123    def aexecuter(self):
124        """
125        Renvoie une liste d'objets codant des commandes de compilation.
126
127        Associe à chaque type de commande la liste des fichiers sur lesquels
128        elle doit s'appliquer.
129
130        Structure de l'objet codant un type de commande:
131
132            obj = {'ext': type['ext'],
133                   'imgdir': type['imgdir'],
134                   'imgext': type['imgext'],
135                   'command': type['command'],
136                   'fics': []}
137
138
139        """
140        self.log += ("\n \t \t Formation de la liste "
141                     + "des commandes de compilation")
142        aexec = []
143        for type in self.commandes:
144            obj = {'ext': type['ext'],
145                   'imgdir': type['imgdir'],
146                   'imgext': type['imgext'],
147                   'command': type['command'],
148                   'fics': []}
149            imgext = type['imgext']
150            imgdir = type['imgdir']
151            fics = []
152            # print(obj['command'], type['patterns'])
153            for paty in type['patterns']:
154                paty = self.rel_path + paty
155                # print(paty, os.getcwd())
156                fics.extend(glob.glob(paty))
157                # print(fics,"\n")
158
159            for src in fics:
160                srcext = os.path.splitext(src)[1]
161                didi = os.path.dirname(src)
162                img = os.path.join(didi, imgdir, os.path.basename(src))
163                img = img.replace(srcext, imgext)
164                # if ("A_" in src):
165                #    print(src, img)
166                if scantex.acompiler(src, img):
167                    obj['fics'].append(src)
168            aexec.append(obj)
169        return aexec
170
171    def apublierImg(self):
172        """
173        Renvoie un dictionnaire de fichiers publiables.
174
175        - clé = chemin d'un fichier à publier
176        - valeur = timestamp du fichier
177        """
178        self.log += "\n \t \t Récup timesstamps"
179        self.log += " locaux des fichiers à publier \n"
180        docs_n = []
181        times = {}
182        for paty in self.publish_data['patterns']:
183            docs_n += glob.glob(paty)
184        for nom_doc in docs_n:
185            times[self.rel_path + nom_doc] = os.path.getmtime(nom_doc)
186        return times
187
188    def compil(self):
189        """
190        Exécute les commandes de compilation.
191
192        Elles sont codées dans `self.cmds_list`.
193        Un compte rendu est placé dans le journal `self.log`.
194        """
195        self.log += '\n \t \t Exécution des compilations \n'
196        log = ''
197        for obj in self.cmds_list:
198            log += '\t \t \t'
199            log += (str(len(obj['fics'])) + ' commandes '
200                    + str(obj['command']) + ' fichiers : \n')
201            for src in obj['fics']:
202                log += '\t \t \t \t' + src
203                command = obj['command'] + [src]
204                try:
205                    # print(command)
206                    subprocess.run(command)
207                    log += ' OK \n'
208                except subprocess.SubprocessError:
209                    log += ' ERREUR dans exécution de la commande \n'
210        self.log += log