From: pascale.noyret Date: Wed, 7 Mar 2018 09:34:40 +0000 (+0100) Subject: sauvegarde devlopptmt plus chgt Yoann X-Git-Tag: V8_5_0rc2a2~29 X-Git-Url: http://git.salome-platform.org/gitweb/?a=commitdiff_plain;h=feb88c9aa8a5847c263d13f43c91fa2f037e2305;p=modules%2Feficas.git sauvegarde devlopptmt plus chgt Yoann --- diff --git a/Efi2Xsd/V0readerEfficas.py b/Efi2Xsd/V0readerEfficas.py new file mode 100755 index 00000000..922d59e2 --- /dev/null +++ b/Efi2Xsd/V0readerEfficas.py @@ -0,0 +1,131 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +import sys,os +import raw.efficas as efficas +import types + +sys.path.insert(0,os.path.abspath(os.path.join(os.getcwd(),'..'))) +sys.path.insert(0,os.path.abspath(os.path.join(os.getcwd(),'..','UiQT5'))) + + +from Accas import * + + +# Attention pas d heritage possible (cf doc pyxbe) + +dictSIMPEficasXML= { 'typ' : 'typeAttendu', 'statut' : 'statut', + 'min_occurs': 'min' , 'max_occurs' : 'max', + 'homo' : 'homo' , 'position' : 'portee', + 'validators': 'validators' , 'sug' : 'valeur_sugg', + 'defaut' : 'ValeurDef' , 'into' : ('PlageValeur','into'), + 'val_min' : ('PlageValeur','borne_inf') , 'val_max' : ('PlageValeur','borne_sup'), + 'ang' : ('doc','ang') , 'fr' : ('doc','fr',) , + 'docu' : ('doc','docu'),} + +dictSIMPXMLEficas = {'doc' : {'fr' : 'fr' , 'ang' : 'ang' , 'docu' : 'docu' }, + 'PlageValeur' : {'borne_sup' : 'val_max' , 'into' : 'into' , 'borne_inf' : 'val_min' ,}, + 'statut' : 'statut' , 'validators' : 'validators' , 'homo' : 'homo' , + 'ValeurDef' : 'defaut' , 'min' : 'min_occurs' , + 'valeur_sugg' : 'sug' , 'portee' : 'position' , 'max' : 'max_occurs' , } + + +# ------------------------------ +class monSIMP (efficas.T_SIMP): +# ------------------------------ + + def explore(self): + #print "je passe dans explore pour SIMP ", self.nom + self.dictArgsEficas={} + self.dictArgsEficas['typ']=self.typeAttendu + for nomXMLArg in dir(self) : + if nomXMLArg in dictSIMPXMLEficas.keys() : + nomEficasArg=dictSIMPXMLEficas[nomXMLArg] + argu=getattr(self,nomXMLArg) + if argu==None : continue + if type(nomEficasArg) == types.DictionaryType: + for nomXML in nomEficasArg.keys(): + arguDecoupe=getattr(argu,nomXML) + nomEficasDecoupe=nomEficasArg[nomXML] + self.dictArgsEficas[nomEficasDecoupe]=arguDecoupe + else : + self.dictArgsEficas[nomEficasArg] = argu + + #if argNew != None : print argNew + self.objAccas=A_SIMP.SIMP(**self.dictArgsEficas) + self.objAccas.nom=self.nom + + def getAccasEquivalent(self): + return self.nom, self.objAccas + +# ------------------------------ +class monPROC(efficas.T_PROC): +# ------------------------------ + def explore(self): + #print "je passe dans explore pour PROC ", self.nom + #print self.content() + #print "________________" + self.dictConstruction={} + self.dictConstruction['nom']=self.nom + + for obj in self.content(): + #print obj + if hasattr(obj,'explore') : obj.explore() + if hasattr(obj,'getAccasEquivalent') : + nom,objetAccas=obj.getAccasEquivalent() + self.dictConstruction[nom]=objetAccas + self.dictConstruction['op']=None + self.objAccas=A_PROC.PROC(**self.dictConstruction) + + +# ------------------------------ +class monFACT(efficas.T_FACT): +# ------------------------------ + def explore(self): + #print "je passe dans explore pour FACT ", self.nom + #print self.content() + self.dictConstruction={} + for obj in self.content(): + if hasattr(obj,'explore') : obj.explore() + if hasattr(obj,'creeAccasEquivalent') : + nom,objetAccas=obj.creeAccasEquivalent() + self.dictConstruction[nom]=objetAccas + self.objAccas=A_FACT.FACT(**self.dictConstruction) + + def getAccasEquivalent(self): + return self.nom, self.objAccas + + +# ------------------------------ +class monCata(efficas.T_cata): +# ------------------------------ + def exploreCata(self): + # On positionne le contexte ACCAS + self.JdC = JDC_CATA (code = 'MED', execmodul = None,) + objAExplorer=self.commandes[0] + for obj in objAExplorer.content(): + if hasattr(obj,'explore') : obj.explore() + + + +efficas.T_SIMP._SetSupersedingClass(monSIMP) +efficas.T_FACT._SetSupersedingClass(monFACT) +efficas.T_PROC._SetSupersedingClass(monPROC) +efficas.T_cata._SetSupersedingClass(monCata) + +if __name__ == "__main__": +# print dir(efficas) +# print dir(efficas.T_SIMP) + + + xml = open('Cata_MED_FAM_test.xml').read() + SchemaMed = efficas.CreateFromDocument(xml) + SchemaMed.exploreCata() + + #print dir(efficas.T_SIMP) + #print dir(efficas.T_SIMP) + + #for maCommande in monCata.commandes : + # for monProc in maCommande.PROC: + # for monFact in monProc.FACT: + # for simp in monFact.SIMP: + # simp.creeAccasEquivalent() diff --git a/Efi2Xsd/V1readerEfficas.py b/Efi2Xsd/V1readerEfficas.py new file mode 100755 index 00000000..dac17d72 --- /dev/null +++ b/Efi2Xsd/V1readerEfficas.py @@ -0,0 +1,209 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +import sys,os +import raw.efficas as efficas +import types + +sys.path.insert(0,os.path.abspath(os.path.join(os.getcwd(),'..'))) + + +from Accas import * + +# traiter le cas des tuples + +# ds l init du SIMP il manque siValide et fenetreIhm + +from mapDesTypes import dictSIMPEficasXML, dictSIMPXMLEficas +from mapDesTypes import dictFACTEficasXML, dictFACTXMLEficas +from mapDesTypes import dictPROCEficasXML, dictPROCXMLEficas +from mapDesTypes import listeParamDeTypeTypeAttendu, listeParamDeTypeStr, dicoPourCast +from mapDesTypes import listeParamEnListeSiMax, listeParamTjsEnListe + + + +# ------------------------------ +class objetDefinitionAccas: +# ------------------------------ + + def argumentXMLToEficas(self): + # --------------------------- + # Attention, pas de validation pour l instant + # il faut verifier la coherence entre les types contenus dans defaut, sug ... et le typeAttendu + # tout cela dans une fonction verifie pas faite -) + + # Recuperation parametres + self.dictArgsEficas={} + for nomXMLArg in dir(self) : + if nomXMLArg in self.dictATraiter : + nomEficasArg=self.dictATraiter[nomXMLArg] + argu=getattr(self,nomXMLArg) + if argu==None : continue + + if type(nomEficasArg) == types.DictionaryType: + for nomXML in list(nomEficasArg.keys()): + arguDecoupe=getattr(argu,nomXML) + nomEficasDecoupe=nomEficasArg[nomXML] + if arguDecoupe == None : continue + self.dictArgsEficas[nomEficasDecoupe]=arguDecoupe + else : + self.dictArgsEficas[nomEficasArg] = argu + + # Cast dans le bon type des parametres si necessaire + if 'min' in list(self.dictArgsEficas.keys()): + self.dictArgsEficas['min']=int(self.dictArgsEficas['min']) + + if 'max' in list(self.dictArgsEficas.keys()): + if self.dictArgsEficas['max']== -1 : self.dictArgsEficas['max']="**" + else : self.dictArgsEficas['max']=int(self.dictArgsEficas['max']) + + for param in list(self.dictArgsEficas.keys()): + if param in listeParamDeTypeStr : + self.dictArgsEficas[param]=unicode(self.dictArgsEficas[param]) + + # En 2.7 a revoir en 3 ? necessaire + self.nomObj=str(self.nom) + + + + + def getAccasEquivalent(self): + # --------------------------- + return self.nomObj, self.objAccas +# + +# --------------------------------------------------------- +class objetComposeDefinitionAccas (objetDefinitionAccas): +# --------------------------------------------------------- + def exploreArbre(self): + # -------------------------- + liste=[] + for obj in self.content(): liste.append(obj) + #liste.reverse() + # PNPNPN essayer de comprendre reverse ou non + + for obj in liste: + if hasattr(obj,'explore') : obj.explore () + if hasattr(obj,'getAccasEquivalent') : + nom,objetAccas=obj.getAccasEquivalent() + self.dictArgsEficas[nom]=objetAccas + +# ---------------------------------------------------- +class monSIMP (efficas.T_SIMP, objetDefinitionAccas): +# ---------------------------------------------------- + + def explore(self): + # -------------------- + # 2 arguments pour ne pas avoir a differencier les appels explore + self.dictATraiter= dictSIMPXMLEficas + self.argumentXMLToEficas() + + self.objAccas=A_SIMP.SIMP(**self.dictArgsEficas) + self.objAccas.nom=self.nomObj + + def argumentXMLToEficas(self): + # ---------------------------- + objetDefinitionAccas.argumentXMLToEficas(self) + self.convertitEnListes() + self.convertitLesTypes() + + def estListe(self): + # --------------- + if hasattr(self,'max') and self.max > 1 : return True + else : return False + + def attendTuple(self): + # ------------------- + return False + + def convertitEnListes(self): + # ------------------------ + # Cas des Tuples non traites + for param in listeParamTjsEnListe : + if param in self.dictArgsEficas : + if not self.attendTuple() : + self.dictArgsEficas[param]=[self.dictArgsEficas[param],] + + if self.estListe() : + for param in listeParamEnListeSiMax: + if param in self.dictArgsEficas : + if not self.attendTuple() : + self.dictArgsEficas[param]=[self.dictArgsEficas[param],] + + def convertitLesTypes(self): + # ------------------------ + # Cas des Tuples non traites + + typeAttendu = self.dictArgsEficas['typ'] + if typeAttendu in list(dicoPourCast.keys()): + for param in listeParamDeTypeTypeAttendu : + if param in list(self.dictArgsEficas.keys()): + castDsLeTypeAttendu=dicoPourCast[typeAttendu] + valeurACaster=self.dictArgsEficas[param].typesimple + if not isinstance(valeurACaster, (list, tuple)) : + val=castDsLeTypeAttendu(valeurACaster) + self.dictArgsEficas[param]=val + else : + liste=[] + for val in valeurACaster : liste.append(castDsLeTypeAttendu(val)) + self.dictArgsEficas[param]=liste + + +# ------------------------------------------------------- +class monFACT(efficas.T_FACT, objetComposeDefinitionAccas): +# ------------------------------------------------------- + def explore(self): + # -------------------- + print "je passe dans explore pour FACT ", self.nom + + self.dictATraiter= dictFACTXMLEficas + self.argumentXMLToEficas() + self.exploreArbre() + self.objAccas=A_FACT.FACT(**self.dictArgsEficas) + + +# --------------------------------------------------------- +class monPROC(efficas.T_PROC, objetComposeDefinitionAccas): +# --------------------------------------------------------- + def explore(self,cata): + # -------------------- + print "je passe dans explore pour PROC ", self.nom + self.dictATraiter= dictPROCXMLEficas + self.argumentXMLToEficas() + self.exploreArbre() + self.dictArgsEficas['op']=None + + self.objAccas=A_PROC.PROC(**self.dictArgsEficas) + setattr(cata, self.nomObj,self.objAccas) + cata.contexteXML[self.nomObj]=self.objAccas + +# ------------------------------ +class monCata(efficas.T_cata): +# ------------------------------ + def exploreCata(self): + # On positionne le contexte ACCAS + self.JdC = JDC_CATA (code = 'MED', execmodul = None,) + self.contexteXML={} + objAExplorer=self.commandes[0] + for obj in objAExplorer.content(): + if hasattr(obj,'explore') : obj.explore(self) + #print dir(self.JdC) + + + def dumpXSD(self): + for etape in self.contexteXML.values() : + etape.dumpXSD() + +efficas.T_SIMP._SetSupersedingClass(monSIMP) +efficas.T_FACT._SetSupersedingClass(monFACT) +efficas.T_PROC._SetSupersedingClass(monPROC) +efficas.T_cata._SetSupersedingClass(monCata) + +if __name__ == "__main__": +# print dir(efficas) +# print dir(efficas.T_SIMP) + + xml = open('cata_test1.xml').read() + SchemaMed = efficas.CreateFromDocument(xml) + SchemaMed.exploreCata() + #SchemaMed.dumpXSD() + diff --git a/Efi2Xsd/mapDesTypes.py b/Efi2Xsd/mapDesTypes.py new file mode 100755 index 00000000..50d6d81a --- /dev/null +++ b/Efi2Xsd/mapDesTypes.py @@ -0,0 +1,85 @@ +def inverseDico(dicoSource) : +#--------------------------- + dicoInverse = {} + for (clef,valeur) in dicoSource.items(): + if not(type(valeur) is tuple): + dicoInverse[valeur]=clef + continue + (elt,att)=valeur + if elt not in dicoInverse : dicoInverse[elt]={} + dicoInverse[elt][att]=clef + return dicoInverse + +dictSIMPEficasXML= { 'typ' : 'typeAttendu', + 'statut' : 'statut', + 'min' : 'minOccurences', + 'max' : 'maxOccurences', + 'homo' : 'homo' , + 'position' : 'portee', + 'validators' : 'validators' , + 'sug' : 'valeurSugg', + 'defaut' : 'valeurDef' , + 'into' : ('plageValeur','into'), + 'val_min' : ('plageValeur','borneInf'), + 'val_max' : ('plageValeur','borneSup'), + 'ang' : ('doc','ang'), + 'fr' : ('doc','fr',), + 'docu' : ('doc','docu'), + } + +dictSIMPXMLEficas= inverseDico(dictSIMPEficasXML) + + + +dictFACTEficasXML = { 'statut' : 'statut', + 'min' : 'minOccurences', + 'max' : 'maxOccurences', + 'ang' : ('doc','ang'), + 'fr' : ('doc','fr',), + 'docu' : ('doc','docu'), + 'validators' : 'validators' , + } + +dictFACTXMLEficas = inverseDico(dictFACTEficasXML) + +dictPROCEficasXML = { 'nom' : 'nom', + 'regles' : 'regles', + 'ang' : ('doc','ang'), + 'fr' : ('doc','fr',), + 'docu' : ('doc','docu'), + } + # 'UIinfo' : 'UIinfo' + # 'reentrant' + # 'repetable' + # 'op_init' + # 'fenetreIhm' : 'fenetreIhm' + +dictPROCXMLEficas = inverseDico(dictPROCEficasXML) + +listeParamDeTypeTypeAttendu = ( 'defaut', 'sug', 'val_min', 'val_max', 'into') +listeParamDeTypeStr = ('fr', 'docu', 'ang', 'nom' ) +dicoPourCast = { 'I' : int, 'R' : float } + +listeParamTjsEnListe = ('into') +listeParamEnListeSiMax = ('defaut', 'into', 'sug') + +if __name__ == "__main__": + import pprint + pp=pprint.PrettyPrinter(indent=4) + print ('dictSIMPEficasXML') + pp.pprint(dictSIMPEficasXML) + print ('\n\n') + print ('dictSIMPXMLEficas') + pp.pprint(dictSIMPXMLEficas) + print ('\n\n') + print ('dictFACTEficasXML') + pp.pprint(dictFACTEficasXML) + print ('\n\n') + print ('dictFACTXMLEficas') + pp.pprint(dictFACTXMLEficas) + print ('\n\n') + print ('dictPROCEficasXML') + pp.pprint(dictPROCEficasXML) + print ('\n\n') + print ('dictPROCXMLEficas') + pp.pprint(dictPROCXMLEficas) diff --git a/Efi2Xsd/readerEfficas.py b/Efi2Xsd/readerEfficas.py index 036371d5..3d169fc3 100755 --- a/Efi2Xsd/readerEfficas.py +++ b/Efi2Xsd/readerEfficas.py @@ -19,6 +19,8 @@ from mapDesTypes import dictPROCEficasXML, dictPROCXMLEficas from mapDesTypes import listeParamDeTypeTypeAttendu, listeParamDeTypeStr, dicoPourCast from mapDesTypes import listeParamEnListeSiMax, listeParamTjsEnListe + + # ------------------------------ class objetDefinitionAccas: # ------------------------------ @@ -54,17 +56,19 @@ class objetDefinitionAccas: if self.dictArgsEficas['max']== -1 : self.dictArgsEficas['max']="**" else : self.dictArgsEficas['max']=int(self.dictArgsEficas['max']) - #for param in list(self.dictArgsEficas.keys()): - # if param in listeParamDeTypeStr : - # self.dictArgsEficas[param]=unicode(self.dictArgsEficas[param]) + for param in list(self.dictArgsEficas.keys()): + if param in listeParamDeTypeStr : + self.dictArgsEficas[param]=unicode(self.dictArgsEficas[param]) + + # En 2.7 a revoir en 3 ? necessaire + self.nomObj=str(self.nom) + - # Pour commodite ? pas sur que cela soit necessaire - #self.strNomObj=str(self.nom) def getAccasEquivalent(self): # --------------------------- - return self.nom, self.objAccas + return self.nomObj, self.objAccas # # --------------------------------------------------------- @@ -74,7 +78,7 @@ class objetComposeDefinitionAccas (objetDefinitionAccas): # -------------------------- liste=[] for obj in self.content(): liste.append(obj) - liste.reverse() + #liste.reverse() # PNPNPN essayer de comprendre reverse ou non for obj in liste: @@ -94,8 +98,7 @@ class monSIMP (efficas.T_SIMP, objetDefinitionAccas): self.argumentXMLToEficas() self.objAccas=A_SIMP.SIMP(**self.dictArgsEficas) - self.objAccas.nom=self.nom - #self.strNomObj=str(self.nom) + self.objAccas.nom=self.nomObj def argumentXMLToEficas(self): # ---------------------------- @@ -140,8 +143,9 @@ class monSIMP (efficas.T_SIMP, objetDefinitionAccas): val=castDsLeTypeAttendu(valeurACaster) self.dictArgsEficas[param]=val else : - print (dir(self.dictArgsEficas[param])) - print ('==========', self.dictArgsEficas) + liste=[] + for val in valeurACaster : liste.append(castDsLeTypeAttendu(val)) + self.dictArgsEficas[param]=liste # ------------------------------------------------------- @@ -149,7 +153,7 @@ class monFACT(efficas.T_FACT, objetComposeDefinitionAccas): # ------------------------------------------------------- def explore(self): # -------------------- - #print "je passe dans explore pour FACT ", self.nom + print "je passe dans explore pour FACT ", self.nom self.dictATraiter= dictFACTXMLEficas self.argumentXMLToEficas() @@ -162,30 +166,32 @@ class monPROC(efficas.T_PROC, objetComposeDefinitionAccas): # --------------------------------------------------------- def explore(self,cata): # -------------------- - #print "je passe dans explore pour PROC ", self.nom + print "je passe dans explore pour PROC ", self.nom self.dictATraiter= dictPROCXMLEficas self.argumentXMLToEficas() self.exploreArbre() self.dictArgsEficas['op']=None self.objAccas=A_PROC.PROC(**self.dictArgsEficas) - setattr(cata, self.nom,self.objAccas) - + setattr(cata, self.nomObj,self.objAccas) + cata.contexteXML[self.nomObj]=self.objAccas # ------------------------------ class monCata(efficas.T_cata): # ------------------------------ def exploreCata(self): # On positionne le contexte ACCAS - self.VERSION_CATALOGUE='V1' self.JdC = JDC_CATA (code = 'MED', execmodul = None,) - self.fromXML=1 + self.contexteXML={} objAExplorer=self.commandes[0] for obj in objAExplorer.content(): if hasattr(obj,'explore') : obj.explore(self) #print dir(self.JdC) + def dumpXSD(self): + for etape in self.contexteXML.values() : + etape.dumpXSD() efficas.T_SIMP._SetSupersedingClass(monSIMP) efficas.T_FACT._SetSupersedingClass(monFACT) @@ -196,20 +202,9 @@ if __name__ == "__main__": # print dir(efficas) # print dir(efficas.T_SIMP) - - xml = open('cata_test1.xml').read() - #xml = open('Cata_MED_FAM.xml').read() + #xml = open('cata_test1.xml').read() + xml = open('Cata_MED_FAM_test.xml').read() SchemaMed = efficas.CreateFromDocument(xml) SchemaMed.exploreCata() - #print dir(SchemaMed) - #print dir(SchemaMed.FAS) - #print SchemaMed.FAS - - #print dir(efficas.T_SIMP) - #print dir(efficas.T_SIMP) - - #for maCommande in monCata.commandes : - # for monProc in maCommande.PROC: - # for monFact in monProc.FACT: - # for simp in monFact.SIMP: - # simp.creeAccasEquivalent() + #SchemaMed.dumpXSD() + diff --git a/Efi2Xsd/writerEfficas.py b/Efi2Xsd/writerEfficas.py deleted file mode 100755 index 99cfcbd4..00000000 --- a/Efi2Xsd/writerEfficas.py +++ /dev/null @@ -1,168 +0,0 @@ -#!/usr/bin/env python -# -*- coding: utf-8 -*- -import sys,os -import raw.efficas as efficas -import types -import pyxb - -sys.path.insert(0,os.path.abspath(os.path.join(os.getcwd(),'..'))) - - -from Accas import * - - -# Attention pas d heritage possible (cf doc pyxbe) -# bizarre le comportement de max est different entre les facts et les simps ? - -dictSIMPEficasXML= { 'typ' : 'typeAttendu', 'statut' : 'statut', - 'min_occurs': 'min' , 'max_occurs' : 'max', - 'homo' : 'homo' , 'position' : 'portee', - 'validators': 'validators' , 'sug' : 'valeur_sugg', - 'defaut' : 'valeurDef' , 'into' : ('plageValeur','into'), - 'val_min' : ('plageValeur','borne_inf') , 'val_max' : ('plageValeur','borne_sup'), - 'ang' : ('doc','ang') , 'fr' : ('doc','fr',) , - 'docu' : ('doc','docu'),} - -dictSIMPXMLEficas = {'doc' : {'fr' : 'fr' , 'ang' : 'ang' , 'docu' : 'docu' }, - 'plageValeur' : {'borne_sup' : 'val_max' , 'into' : 'into' , 'borne_inf' : 'val_min' ,}, - 'statut' : 'statut' , 'validators' : 'validators' , 'homo' : 'homo' , - 'valeurDef' : 'defaut' , 'min_occurs' : 'min' , - 'valeur_sugg' : 'sug' , 'portee' : 'position' , 'max_occurs' : 'max' , } - -dictFACTXMLEficas = {'doc' : {'fr' : 'fr' , 'ang' : 'ang' , 'docu' : 'docu' }, - 'statut' : 'statut' , 'validators' : 'validators' , - 'min_occurs' : 'min' , 'max_occurs' : 'max' , } - -## ------------------------------ -#class monSIMP (efficas.T_SIMP): -## ------------------------------ -# -# def explore(self,cata): -# #print "je passe dans explore pour SIMP ", self.nom -# self.dictArgsEficas={} -# self.dictArgsEficas['typ']=self.typeAttendu -# for nomXMLArg in dir(self) : -# if nomXMLArg in dictSIMPXMLEficas.keys() : -# nomEficasArg=dictSIMPXMLEficas[nomXMLArg] -# argu=getattr(self,nomXMLArg) -# if argu==None : continue -# if nomEficasArg == 'defaut' : print (argu); -# if nomEficasArg == 'defaut' : print (dir(argu)); -# if nomEficasArg == 'defaut' : print (argu.value) -# #if nomEficasArg == 'defaut' : print (efficas.T_I(argu)) -# if nomEficasArg == 'defaut' : print (argu.content()) -# if type(nomEficasArg) == types.DictionaryType: -# for nomXML in nomEficasArg.keys(): -# arguDecoupe=getattr(argu,nomXML) -# nomEficasDecoupe=nomEficasArg[nomXML] -# self.dictArgsEficas[nomEficasDecoupe]=arguDecoupe -# else : -# self.dictArgsEficas[nomEficasArg] = argu -# -# if 'min' in self.dictArgsEficas.keys(): self.dictArgsEficas['min']=int(self.dictArgsEficas['min']) -# if 'max' in self.dictArgsEficas.keys(): -# if self.dictArgsEficas['max']== -1 : self.dictArgsEficas['max']="**" -# else : self.dictArgsEficas['max']=int(self.dictArgsEficas['max']) -# self.objAccas=A_SIMP.SIMP(**self.dictArgsEficas) -# self.objAccas.nom=self.nom -# self.strNomObj=str(self.nom) -# -# def getAccasEquivalent(self): -# return self.strNomObj, self.objAccas -# -## ------------------------------ -#class monPROC(efficas.T_PROC): -## ------------------------------ -# def explore(self,cata): -# #print "je passe dans explore pour PROC ", self.nom -# self.dictConstruction={} -# self.dictConstruction['nom']=self.nom -# liste=[] -# for obj in self.content(): liste.append(obj) -# liste.reverse() -# for obj in liste: -# if hasattr(obj,'explore') : obj.explore (cata) -# if hasattr(obj,'getAccasEquivalent') : -# nom,objetAccas=obj.getAccasEquivalent() -# self.dictConstruction[nom]=objetAccas -# self.dictConstruction['op']=None -# self.objAccas=A_PROC.PROC(**self.dictConstruction) -# self.strNomObj=str(self.nom) -# setattr(cata, self.strNomObj,self.objAccas) -# -# -## ------------------------------ -#class monFACT(efficas.T_FACT): -## ------------------------------ -# def explore(self,cata): -# #print "je passe dans explore pour FACT ", self.nom -# self.dictConstruction={} -# -# for nomXMLArg in dir(self) : -# if nomXMLArg in dictFACTXMLEficas.keys() : -# nomEficasArg=dictFACTXMLEficas[nomXMLArg] -# argu=getattr(self,nomXMLArg) -# if argu==None : continue -# argu=str(argu) -# if type(nomEficasArg) == types.DictionaryType: -# for nomXML in nomEficasArg.keys(): -# arguDecoupe=getattr(argu,nomXML) -# nomEficasDecoupe=nomEficasArg[nomXML] -# self.dictConstruction[nomEficasDecoupe]=arguDecoupe -# else : -# self.dictConstruction[nomEficasArg] = argu -# if 'min' in self.dictConstruction.keys(): self.dictConstruction['min']=int(self.dictConstruction['min']) -# if 'max' in self.dictConstruction.keys(): -# if self.dictConstruction['max']== '-1' : self.dictConstruction['max']="**" -# else : self.dictConstruction['max']=int(self.dictConstruction['max']) -# liste=[] -# for obj in self.content(): liste.append(obj) -# liste.reverse() -# for obj in liste: -# if hasattr(obj,'explore') : obj.explore(cata) -# if hasattr(obj,'getAccasEquivalent') : -# nom,objetAccas=obj.getAccasEquivalent() -# self.dictConstruction[nom]=objetAccas -# -# self.objAccas=A_FACT.FACT(**self.dictConstruction) -# self.strNomObj=str(self.nom) -# -# def getAccasEquivalent(self): -# return self.strNomObj, self.objAccas -# -# -## ------------------------------ -#class monCata(efficas.T_cata): -## ------------------------------ -# def exploreCata(self): -# # On positionne le contexte ACCAS -# self.VERSION_CATALOGUE='V1' -# self.JdC = JDC_CATA (code = 'MED', execmodul = None,) -# self.fromXML=1 -# objAExplorer=self.commandes[0] -# for obj in objAExplorer.content(): -# if hasattr(obj,'explore') : obj.explore(self) -# #print dir(self.JdC) -# -# -# -#efficas.T_SIMP._SetSupersedingClass(monSIMP) -#efficas.T_FACT._SetSupersedingClass(monFACT) -#efficas.T_PROC._SetSupersedingClass(monPROC) -#efficas.T_cata._SetSupersedingClass(monCata) -# -if __name__ == "__main__": - - #xml = open('Cata_MED_FAM.xml').read() - #Cata = efficas.T_cata() - #Commande=T_commandes() - #T_PROC() - #T_SIMP() - print (dir(efficas.T_SIMP)) - print (dir(efficas.T_PROC)) - print (dir(efficas.T_cata)) - - #pyxb.RequireValidWhenGenerating(False) - #print(SchemaMed.toxml("utf-8").decode('utf-8')) - - #SchemaMed.exploreCata() diff --git a/InterfaceQT4/browser.py b/InterfaceQT4/browser.py index 3ec33c24..6dd8c35f 100644 --- a/InterfaceQT4/browser.py +++ b/InterfaceQT4/browser.py @@ -373,7 +373,7 @@ class JDCNode(QTreeWidgetItem,GereRegles): #if self.editor.code == 'ASTER' and not(self.item.isActif()) : # posera des pb si un code decide d appeler FIN un mot clef # on resoudera a ce moment la - # pour l instant pas de poussiere sous le tapis + # pour l pas de poussiere sous le tapis #print ('_________________ds affichePanneau pour', self.item.nom) if not(self.item.isActif()) : from .monWidgetInactif import MonWidgetInactif diff --git a/InterfaceQT4/editor.py b/InterfaceQT4/editor.py index 970e359f..fc82e638 100755 --- a/InterfaceQT4/editor.py +++ b/InterfaceQT4/editor.py @@ -772,13 +772,13 @@ class JDCEditor(JDCEditorSsIhm,Ui_baseWidget,QWidget): #-----------------------------------------------------------------# - def saveFileLeger(self, path = None, saveas= 0,formatLigne="beautifie"): + def saveCompleteFile(self, path = None, saveas= 0,formatLigne="beautifie"): #-----------------------------------------------------------------# extension='.casR' - fn = self.fichier + fn = self.fichierComplet #saveas=True # Pour forcer le nom - self.generator=generator.plugins[self.format]() - if self.fichier is None or saveas: + self.generator=self.maConfiguration.mesGenerators.plugins[self.format]() + if self.fichierComplet is None or saveas: if path is None: path=self.maConfiguration.savedir bOK, fn=self.determineNomFichier(path,extension) if bOK == 0 : return (0, None) @@ -789,17 +789,17 @@ class JDCEditor(JDCEditorSsIhm,Ui_baseWidget,QWidget): self.appliEficas.maConfiguration.savedir=os.path.split(ulfile)[0] fn = six.text_type(QDir.toNativeSeparators(fn)) - self.fichier = os.path.splitext(fn)[0]+extension + self.fichierComplet = os.path.splitext(fn)[0]+extension - if hasattr(self.generator, "writeLeger"): - self.generator.writeLeger(self.fichier,self.jdc,config=self.appliEficas.maConfiguration,appli=self.appliEficas) + if hasattr(self.generator, "writeComplet"): + self.generator.writeComplet(self.fichierComplet,self.jdc,config=self.appliEficas.maConfiguration,appli=self.appliEficas) - if self.salome : self.appliEficas.addJdcInSalome( self.fichier) + if self.salome : self.appliEficas.addJdcInSalome( self.fichierComplet) self.modified = 0 - nouveauTitre=self.titre+" "+str(os.path.basename(self.fichier)) + nouveauTitre=self.titre+" "+str(os.path.basename(self.fichierComplet)) self.appliEficas.setWindowTitle(nouveauTitre) - return (1, self.fichier) + return (1, self.fichierComplet) #-----------------------------------------------------------------# def saveFile(self, path = None, saveas= 0,formatLigne="beautifie"): diff --git a/InterfaceQT4/editorSsIhm.py b/InterfaceQT4/editorSsIhm.py index 2ce4be78..264cc147 100755 --- a/InterfaceQT4/editorSsIhm.py +++ b/InterfaceQT4/editorSsIhm.py @@ -61,19 +61,18 @@ class JDCEditorSsIhm : if debug : print ('dans le init de JDCEditorSsIhm') self.appliEficas = appli - self.appli = appli + self.appli = appli self.fichier = fichier self.jdc = jdc self.first = True self.jdc_item = None - self.dicoNouveauxMC={} - self.dicoNouveauxFact={} - self.dict_reels={} - self.liste_simp_reel=[] - + self.dicoNouveauxMC = {} + self.dicoNouveauxFact = {} + self.dict_reels = {} + self.liste_simp_reel = [] if appli != None : self.salome = self.appliEficas.salome - else : self.salome=0 + else : self.salome = 0 # ces attributs sont mis a jour par definitCode appelee par newEditor self.code = self.appliEficas.maConfiguration.code @@ -107,7 +106,7 @@ class JDCEditorSsIhm : try: self.maConfiguration.generator_module _module = __import__(self.maConfiguration.generator_module) - info = _module.entryPoint() + info = _module.entryPoint() generator.plugins.addEntryPoint(info) except: pass @@ -121,6 +120,9 @@ class JDCEditorSsIhm : except : pass + self.maConfiguration.mesGenerators = generator + self.maConfiguration.mesconvertisseurs = convert + self.fileInfo = None self.lastModified = 0 @@ -422,17 +424,17 @@ class JDCEditorSsIhm : if pourRun : jdc_formate=self.generator.textePourRun if self.code == 'TELEMAC' : jdc_formate=self.generator.texteDico except ValueError as e: - self.afficheInfos( "Erreur a la generation",str(e),'red') + self.informe( "Erreur a la generation",str(e),'red') return if not self.generator.cr.estvide(): - self.afficheInfos("Erreur a la generation","EFICAS ne sait pas convertir ce JDC",'red') + self.informe("Erreur a la generation","EFICAS ne sait pas convertir ce JDC",'red') return "" else: return jdc_formate else: # Il n'existe pas c'est une erreur - self.afficheInfos("Format inconnu", self.format + " non reconnu" ) + self.informe("Format inconnu", self.format + " non reconnu" ) return "" #------------------------------# diff --git a/InterfaceQT4/gereListe.py b/InterfaceQT4/gereListe.py index 2b2de3f0..72b4adea 100644 --- a/InterfaceQT4/gereListe.py +++ b/InterfaceQT4/gereListe.py @@ -33,7 +33,7 @@ import traceback import six from six.moves import range from PyQt5.QtWidgets import QLineEdit, QLabel, QFileDialog -from PyQt5.QtCore import QEvent, Qt +from PyQt5.QtCore import QEvent, Qt, QTimer from PyQt5.QtGui import QIcon, QPalette from Extensions.i18n import tr @@ -231,13 +231,18 @@ class GereListe(object): return self.ajoutLineEdit() self.descendLesLignes() + self.chercheLigneVide() + QTimer.singleShot(1, self.rendVisibleLigne) def chercheLigneVide(self): for i in range(self.indexDernierLabel) : nomLineEdit=self.nomLine+str(i+1) courant=getattr(self,nomLineEdit) valeur=courant.getValeur() - if valeur=="" : courant.setFocus(7);return + if valeur=="" : + courant.setFocus(True) + self.estVisible=courant + return def descendLesLignes(self): diff --git a/InterfaceQT4/monWidgetCommandeDeplie1Niveau.py b/InterfaceQT4/monWidgetCommandeDeplie1Niveau.py index 0648a944..d23b6487 100644 --- a/InterfaceQT4/monWidgetCommandeDeplie1Niveau.py +++ b/InterfaceQT4/monWidgetCommandeDeplie1Niveau.py @@ -33,13 +33,15 @@ class MonWidgetCommandeDeplie1Niveau(MonWidgetCommande): # il faut donc surcharger un certain nb de fonction ici pour eux - - def __init__(self,node,editor,etape): + #print ("debut de ---------------------- init de MonWidgetCommandeDeplie1Niveau ",node.item.nom) MonWidgetCommande.__init__(self,node,editor,etape) self.node.plieToutEtReaffiche=self.plieToutEtReaffiche def afficheMots(self): + # Attention + # Attention --> cette methode surcharge les methodes des Nodes Fils + # Attention #print ("debut de ---------------------- ds afficheMots de MonWidgetCommandeDeplie1Niveau ",self.node.item.nom) #traceback.print_stack() repIcon=self.editor.appliEficas.repIcon @@ -85,6 +87,10 @@ class MonWidgetCommandeDeplie1Niveau(MonWidgetCommande): #print ("fin ------------------------ afficheMots de MonWidgetCommandeDeplie1Niveau ",self.node.item.nom) + def afficheSuivant(self,aAfficher): + fenetre=self.node.tree.itemCourant.fenetre + fenetre.afficheSuivant(aAfficher) + def setDepliePourNode(self): noeudCourant=self.node.tree.itemCourant noeudCourant.setDeplieChildren() @@ -92,6 +98,8 @@ class MonWidgetCommandeDeplie1Niveau(MonWidgetCommande): pass +# -------------------------------------------- Methodes qui surchargent les noeuds fils + def setDepliePourMCList(self): #print ('je surcharge setDeplie pour MCList') pass @@ -118,15 +126,21 @@ class MonWidgetCommandeDeplie1Niveau(MonWidgetCommande): def affichePanneau(self): #print ('je surcharge affichePanneau', self.node.tree.itemCourant.item.getLabelText()) - item=self.node.tree.itemCourant.item - self.setDepliePourNode() + node=self.node.tree.itemCourant + while ( not (hasattr(node,'fenetreIhm')) or node.treeParent.fenetreIhm != 'deplie1Niveau') : + node=node.treeParent + self.node.tree.setCurrentItem(node) + + item=node.item + if item.getLabelText()[0] == self.editor.fenetreCentraleAffichee.labelNomCommande.text(): + return + node.setDeplieChildren() + node.afficheCeNiveau() self.editor.fenetreCentraleAffichee.labelNomCommande.setText(item.getLabelText()[0]) self.editor.fenetreCentraleAffichee.labelDoc.setText(item.getFr()) - def afficheSuivant(self,aAfficher): - fenetre=self.node.tree.itemCourant.fenetre - fenetre.afficheSuivant(aAfficher) + def getPanel (self): - #print ('surcharge ds getPanel') + print ('surcharge ds getPanel') pass diff --git a/InterfaceQT4/monWidgetPlusieursBase.py b/InterfaceQT4/monWidgetPlusieursBase.py index 0a35f871..ff349a9b 100644 --- a/InterfaceQT4/monWidgetPlusieursBase.py +++ b/InterfaceQT4/monWidgetPlusieursBase.py @@ -151,7 +151,6 @@ class MonWidgetPlusieursBase (Ui_WidgetPlusieursBase,Feuille,GereListe,GerePlie) # deux lignes pour que le ensureVisible fonctionne self.estVisible=nouveauLE if self.inInit==False :QTimer.singleShot(1, self.rendVisibleLigne) - #if donneLeFocus==True : nouveauLE.setFocus() def etablitOrdre(self): i=0 diff --git a/InterfaceQT4/monWidgetPlusieursIntoOrdonne.py b/InterfaceQT4/monWidgetPlusieursIntoOrdonne.py index 549bb14e..d7f78f30 100644 --- a/InterfaceQT4/monWidgetPlusieursIntoOrdonne.py +++ b/InterfaceQT4/monWidgetPlusieursIntoOrdonne.py @@ -131,7 +131,6 @@ class MonWidgetPlusieursIntoOrdonne (Ui_WidgetPlusieursIntoOrdonne, Feuille,Gere if len(self.listeValeursCourantes) > aConstruire : aConstruire=len(self.listeValeursCourantes) self.indexDernierLabel = aConstruire for i in range(1,aConstruire+1): self.ajoutLEResultat(i) - else : self.indexDernierLabel= len(self.listeValeursCourantes) index=1 for val in self.listeValeursCourantes : nomLE="LEResultat"+str(index) @@ -139,6 +138,12 @@ class MonWidgetPlusieursIntoOrdonne (Ui_WidgetPlusieursIntoOrdonne, Feuille,Gere courant.setText(str(val)) courant.setReadOnly(True) index=index+1 + while (index < self.indexDernierLabel) : + nomLE="LEResultat"+str(index) + courant=getattr(self,nomLE) + courant.setText("") + courant.setReadOnly(True) + index=index+1 #self.prepareListeResultat() def moinsPushed(self): @@ -212,7 +217,7 @@ class MonWidgetPlusieursIntoOrdonne (Ui_WidgetPlusieursIntoOrdonne, Feuille,Gere setattr(self,nomLE,nouveauLE) def ajoutLineEdit(self): - #print ('ajoutLineEdit') + print ('ajoutLineEdit') self.indexDernierLabel=self.indexDernierLabel+1 self.ajoutLEResultat (self.indexDernierLabel) @@ -287,5 +292,8 @@ class MonWidgetPlusieursIntoOrdonne (Ui_WidgetPlusieursIntoOrdonne, Feuille,Gere self.estVisibleRE.setFocus() self.scrollArea.ensureWidgetVisible(self.estVisibleRE,0,0) # + def rendVisibleLigne(self): + self.estVisibleRE=self.estVisible + #rendVisibleLigneRE() diff --git a/InterfaceQT4/qtEficas.py b/InterfaceQT4/qtEficas.py index c05c0e4d..d76a51b6 100755 --- a/InterfaceQT4/qtEficas.py +++ b/InterfaceQT4/qtEficas.py @@ -314,12 +314,12 @@ class Appli(AppliSsIhm,Ui_Eficas,QMainWindow): self.rechercherDejaLa=True self.actionRechercherDsCatalogue.triggered.connect(self.handleRechercherDsCatalogue) - def ajoutSortieLegere(self): - if hasattr(self,'actionSortieLegere') : return - self.actionSortieLegere = QAction(self) - self.actionSortieLegere.setText(tr("Sortie Legere")) - self.menuFichier.insertAction(self.actionEnregistrer_sous,self.actionSortieLegere) - self.actionSortieLegere.triggered.connect(self.handleSortieLegere) + def ajoutSortieComplete(self): + if hasattr(self,'actionSortieComplete') : return + self.actionSortieComplete = QAction(self) + self.actionSortieComplete.setText(tr("Sortie Complete")) + self.menuFichier.insertAction(self.actionEnregistrer_sous,self.actionSortieComplete) + self.actionSortieComplete.triggered.connect(self.handleSortieComplete) def MT(self): @@ -407,7 +407,7 @@ class Appli(AppliSsIhm,Ui_Eficas,QMainWindow): self.enleverActionsStructures() self.enlevernewInclude() self.connectRechercherDsCatalogue() - self.ajoutSortieLegere() + self.ajoutSortieComplete() def lookSuiteTelemac(self): self.enleverActionsStructures() @@ -793,8 +793,8 @@ class Appli(AppliSsIhm,Ui_Eficas,QMainWindow): monOption=OptionPdf(parent=self,modal = 0 ,configuration=self.maConfiguration) monOption.show() - def handleSortieLegere(self): - return self.viewmanager.saveLegerCurrentEditor() + def handleSortieComplete(self): + return self.viewmanager.saveCompleteCurrentEditor() def handleShowRecentMenu(self): """ diff --git a/InterfaceQT4/readercata.py b/InterfaceQT4/readercata.py index 4135ea34..4984dea6 100644 --- a/InterfaceQT4/readercata.py +++ b/InterfaceQT4/readercata.py @@ -339,7 +339,7 @@ class ReaderCata (ReaderCataCommun): def dumpToXml(self): - #from Efi2Xsd import readerEfficas + from Efi2Xsd import readerEfficas print ('in dumpToXml') #newSchema= xml = open('Cata_MED_FAM.xml').read() #SchemaMed = efficas.CreateFromDocument(xml) diff --git a/InterfaceQT4/viewManager.py b/InterfaceQT4/viewManager.py index c2451259..e8f9917f 100644 --- a/InterfaceQT4/viewManager.py +++ b/InterfaceQT4/viewManager.py @@ -47,7 +47,7 @@ class MyViewManager(object): self.myQtab.currentChanged.connect(self.indexChanged) self.myQtab.tabCloseRequested.connect(self.closeTab) - + def indexChanged(self): index=self.myQtab.currentIndex() if index in self.dict_editors: @@ -60,10 +60,10 @@ class MyViewManager(object): def handleOpen(self,fichier=None,patron=0,units=None): result = None if fichier is None: - if self.appliEficas.demande==True : + if self.appliEficas.demande==True : self.appliEficas.definitCode(None,None) if self.appliEficas.code == None:return - + if self.appliEficas.code in DictExtensions: chaine="JDC (*"+DictExtensions[self.appliEficas.code]+");;" extensions=tr(chaine+ "All Files (*)") @@ -106,7 +106,7 @@ class MyViewManager(object): pass self.myQtab.removeTab(index) return res - + def run(self): index=self.myQtab.currentIndex() @@ -128,7 +128,7 @@ class MyViewManager(object): res=self.handleClose(0,texte) if res==2 : return res # l utilsateur a annule return res - + def handleRechercher(self): #print "passage dans handleRechercher" index=self.myQtab.currentIndex() @@ -148,7 +148,7 @@ class MyViewManager(object): if index < 0 : return editor=self.dict_editors[index] editor.handleDeplier() - + def handleEditCopy(self): #print "passage dans handleEditCopy" index=self.myQtab.currentIndex() @@ -184,7 +184,7 @@ class MyViewManager(object): def newEditor(self,include=0): - if self.appliEficas.demande==True : + if self.appliEficas.demande==True : self.appliEficas.definitCode(None,None) if self.appliEficas.code == None:return maPage=self.getEditor(include=include) @@ -220,7 +220,7 @@ class MyViewManager(object): def handleGestionParam(self): index=self.myQtab.currentIndex() - if index < 0 : + if index < 0 : QMessageBox.warning( self.appliEficas,tr(u"Creation Parametre indisponible"),tr(u"les parametres sont lies a un jeu de donnees")) return self.dict_editors[index].gestionParam() @@ -251,11 +251,11 @@ class MyViewManager(object): self.myQtab.setTabText(index,fileName) return ok - def saveLegerCurrentEditor(self): + def saveCompleteCurrentEditor(self): index=self.myQtab.currentIndex() if index < 0 : return editor=self.dict_editors[index] - ok, newName = editor.saveFileLeger() + ok, newName = editor.saveCompleteFile() return ok def sauveLigneCurrentEditor(self): @@ -317,7 +317,7 @@ class MyViewManager(object): else : from .editor import JDCEditor editor = JDCEditor(self.appliEficas,fichier, jdc, self.myQtab,units=units,include=include) - if double != None : + if double != None : self.doubles[editor]=double if editor.jdc: # le fichier est bien un jdc self.editors.append(editor) @@ -339,7 +339,8 @@ class MyViewManager(object): #PNPNPNPN --> a affiner if fichier is None: self.untitledCount += 1 - self.myQtab.addTab(win, tr("Fichier non encore nomme "+ self.appliEficas.readercata.versionCode, self.untitledCount)) + self.myQtab.addTab(win, tr("Fichier non encore nomme " + self.appliEficas.readercata.versionCode, self.untitledCount)) + #self.myQtab.addTab(win, str(self.appliEficas.code)) else: liste=fichier.split('/') txt = liste[-1] @@ -370,11 +371,11 @@ class MyViewManager(object): def checkDirty(self, editor,texte): """ Private method to check dirty status and open a message window. - + @param editor editor window to check @return flag indicating successful reset of the dirty flag (boolean) - """ - res=1 + """ + res=1 if (editor.modified) and (editor in self.doubles) : msgBox = QMessageBox(None) msgBox.setWindowTitle(tr("Fichier Duplique")) @@ -409,7 +410,7 @@ class MyViewManager(object): if index < 0 : return editor=self.dict_editors[index] editor.handleAjoutGroup(listeGroup) - + def handleFonctionUtilisateur(self,laFonctionUtilisateur, lesArguments): # Peut-etre a blinder un peu plus sur le nb d argument index=self.myQtab.currentIndex() @@ -420,7 +421,7 @@ class MyViewManager(object): tr("Selectionner une etape"), tr("Le texte sera inséré après l étape selectionnée")) - listeParam = [] + listeParam = [] for p in lesArguments: print (p) if hasattr(editor,p): listeParam.append(getattr(editor,p)) diff --git a/generator/Formatage.py b/generator/Formatage.py index b98325dd..d67ca525 100644 --- a/generator/Formatage.py +++ b/generator/Formatage.py @@ -142,7 +142,10 @@ class Formatage (object): # on écrit ses fils self.formateEtape(element[1:]) #elif type(element) == types.StringType: - elif type(element) == bytes: + #elif type(element) == bytes: + # PNPNPN -> marre du python 2 et 3 + # on remplace par else dans if + else : # il s'agit d'un mot-clé simple ou de ')' ou ');' ou '),' ou ');\n' diff --git a/generator/generator_TELEMAC.py b/generator/generator_TELEMAC.py index 57cfc12d..8a2328fb 100644 --- a/generator/generator_TELEMAC.py +++ b/generator/generator_TELEMAC.py @@ -58,7 +58,7 @@ class TELEMACGenerator(PythonGenerator): """ #---------------------------------------------------------------------------------------- - def gener(self,obj,format='brut',config=None,appli=None,statut="Entier"): + def gener(self,obj,format='brut',config=None,appli=None,statut="Leger"): self.statut = statut self.langue = appli.langue @@ -139,8 +139,8 @@ class TELEMACGenerator(PythonGenerator): # ecriture de Leger #---------------------------------------------------------------------------------------- - def writeLeger(self,fn,jdc,config,appli) : - jdc_formate=self.gener(jdc,config=config,appli=appli,statut="Leger") + def writeComplet(self,fn,jdc,config,appli) : + jdc_formate=self.gener(jdc,config=config,appli=appli,statut="Entier") self.writeDefault(fn)