From 845a173881f4aee1c4e11b11923987172744e1e1 Mon Sep 17 00:00:00 2001 From: "pascale.noyret" Date: Thu, 26 Apr 2018 16:26:41 +0200 Subject: [PATCH] sauvegarde du 26-04 --- Efi2Xsd/balises.py | 37 ++++ Efi2Xsd/mapDesTypes.py | 6 +- Efi2Xsd/mesAgregats.py | 68 ++++--- Efi2Xsd/mesAgregatsDefinition.py | 168 +++++++++++++++++ Efi2Xsd/readerEfiXsd.py | 300 +++++++++++++++++++++++++++++++ 5 files changed, 550 insertions(+), 29 deletions(-) create mode 100644 Efi2Xsd/balises.py create mode 100755 Efi2Xsd/mesAgregatsDefinition.py create mode 100755 Efi2Xsd/readerEfiXsd.py diff --git a/Efi2Xsd/balises.py b/Efi2Xsd/balises.py new file mode 100644 index 00000000..c0eee995 --- /dev/null +++ b/Efi2Xsd/balises.py @@ -0,0 +1,37 @@ +typeSimple = '\t\n\t\t\n\t\n' +eltDsSequence = '\t\t\t\n' + +debutTypeComplexe = '\t\n\t\t\n' +finTypeComplexe = '\t\t\n\t\n' + +debutTypeCata = '\t\n\t\t\n' +finTypeCata = '\t\t\n\t ' + +eltCata = '\n' + + +if __name__ == '__main__' : + nomElt='Simple' + nomDuType='T_Simple' + nomDuTypeBase='int' + nomDuComplexe='T_Complexe' + nomDuCode='monCode' + minOccurs=1 + maxOccurs=1 + + texteSimple=typeSimple.format(nomDuType, nomDuTypeBase) + texteElt=eltDsSequence.format(nomElt,nomDuCode,nomDuType,minOccurs,maxOccurs) + + minOccurs=0 + texteComplexe=debutTypeComplexe.format(nomDuComplexe) + texteComplexe+=texteElt + texteComplexe+=finTypeComplexe + texteEltComplexe=eltDsSequence.format(nomElt,nomDuCode,nomDuType,minOccurs,maxOccurs) + + texteCata=debutTypeCata.format(nomDuCode) + texteCata+=texteEltComplexe + texteCata+=finTypeCata + + eltRacine=eltCata.format(nomDuCode, 'T_'+nomDuCode) + print (texteSimple+texteComplexe+texteCata+eltRacine) + diff --git a/Efi2Xsd/mapDesTypes.py b/Efi2Xsd/mapDesTypes.py index e5547d4a..fcd797f8 100755 --- a/Efi2Xsd/mapDesTypes.py +++ b/Efi2Xsd/mapDesTypes.py @@ -88,7 +88,8 @@ dictPROCXMLEficas = inverseDico(dictPROCEficasXML) dictOPEREficasXML = dictPROCEficasXML dictOPERXMLEficas = dictPROCXMLEficas -dicoPourCast = { 'I' : int, 'R' : float, 'bool' : bool , } +dictPourCast = { 'I' : int, 'R' : float, 'bool' : bool , } +dictNomsDesTypes = { 'I' : 'int', 'R' : 'float', bool : 'bool' , 'TXM' : 'string', 'Fichier' : 'string' } listeParamDeTypeTypeAttendu = ( 'defaut', 'sug', 'val_min', 'val_max', 'into', 'intoSug') listeParamDeTypeStr = ('fr', 'docu', 'ang', 'nom' ) @@ -116,3 +117,6 @@ if __name__ == "__main__": print ('\n\n') print ('dictPROCXMLEficas') pp.pprint(dictPROCXMLEficas) + print ('\n\n') + print ('dictNomsDesTypes') + pp.pprint(dictNomsDesTypes ) diff --git a/Efi2Xsd/mesAgregats.py b/Efi2Xsd/mesAgregats.py index 19d55a1a..eb20219c 100755 --- a/Efi2Xsd/mesAgregats.py +++ b/Efi2Xsd/mesAgregats.py @@ -7,84 +7,96 @@ import types sys.path.insert(0,os.path.abspath(os.path.join(os.getcwd(),'..'))) -import Atmo.raw.atmo_test1 as modeleMetier class X_MCSIMP: # ------------- def buildObjPyxb(self) : + if not self.cata.modeleMetier : return #print ('X_MCSIMP buildObjPyxb', self.nom, self) self.monNomDeClasseModeleMetier='T_'+self.nom - self.maClasseModeleMetier=getattr(modeleMetier,self.monNomDeClasseModeleMetier) + self.maClasseModeleMetier=getattr(self.cata.modeleMetier,self.monNomDeClasseModeleMetier) if self.val != None : self.objPyxb=self.maClasseModeleMetier(self.val) - else : self.objPyxb=self.maClasseModeleMetier() + else : self.objPyxb=self.maClasseModeleMetier() #print ('fin X_MCSIMP', self.objPyxb, self.nom,self) - def setValeur(self,val): - print ('a faire PNPNPNPN') + def setValeurObjPyxb(self,newVal): + if not self.cata.modeleMetier : return + print ('setValeurObjPyxb') + if newVal != None : nvlObj=self.maClasseModeleMetier(newVal) + else : nvlObj=self.maClasseModeleMetier() + self.val=newVal + self.objPyxb=nvlObj + setattr(self.parent.objPyxb, self.nom, nvlObj) class X_MCCOMPO: # -------------- # def buildObjPyxb(self,mc_list) : + if not self.cata.modeleMetier : return print ('X_MCCOMPO buildObjPyxb', self.nom, self) self.monNomDeClasseModeleMetier='T_'+self.nom - self.maClasseModeleMetier=getattr(modeleMetier,self.monNomDeClasseModeleMetier) + self.maClasseModeleMetier=getattr(self.cata.modeleMetier,self.monNomDeClasseModeleMetier) listArg=[] for objAccas in mc_list : - listArg.append(objAccas.objPyxb) + from Accas.A_MCLIST import MCList + if isinstance(objAccas,MCList) : + for mcfact in objAccas : listArg.append(mcfact.objPyxb) + else : listArg.append(objAccas.objPyxb) + print (listArg) self.objPyxb=self.maClasseModeleMetier(*listArg) - print ('fin MCCOMPO', self.objPyxb, self.nom,self,self.objPyxb.content()) -class X_MCFACT: +class X_MCFACT : # -------------- # Pour un MCFACT : # le buildObjPyxb sera pris en charge par X_MCLIST # on ne fait rien def buildObjPyxb(self,mc_list): + #print ('X_MCFACT buildObjPyxb debut et fin', self.nom, self) pass class X_MCLIST: # -------------- + def buildObjPyxb(self,factList): + if not self.cata.modeleMetier : return #print ('X_MCLIST buildObjPyxb', self.nom, self) + self.monNomDeClasseModeleMetier='T_'+self.nom - self.maClasseModeleMetier=getattr(modeleMetier,self.monNomDeClasseModeleMetier) - listArg=[] + self.maClasseModeleMetier=getattr(self.cata.modeleMetier,self.monNomDeClasseModeleMetier) for objAccas in factList : - #print objAccas.nom + listArg=[] for objAccasFils in objAccas.mc_liste : - #print (objAccasFils) - #print (objAccasFils.nom) - #print (objAccasFils.objPyxb) listArg.append(objAccasFils.objPyxb) - # print (objAccasFils.objPyxb) - self.objPyxb=self.maClasseModeleMetier(*listArg) - #print (self.objPyxb.content()) - #print ('fin MCLIST', self.objPyxb, self.nom,self) + objAccas.objPyxb=self.maClasseModeleMetier(*listArg) + #print (objAccas , 'ds MCLIST a pour obj pyxb', objAccas.objPyxb) class X_JDC: # ---------- def __init__(self): - print ('--------- init du X_JDC') + #print ('X_JDC buildObjPyxb', self) + if not self.cata.modeleMetier : return self.monNomDeClasseModeleMetier=self.code - self.maClasseModeleMetier=getattr(modeleMetier,self.monNomDeClasseModeleMetier) + self.maClasseModeleMetier=getattr(self.cata.modeleMetier,self.monNomDeClasseModeleMetier) self.objPyxb=self.maClasseModeleMetier() + #print ('fin X_JDC buildObjPyxb', self.objPyxb, self) - def ajoutEtapeAPyxb(self,etape): + def enregistreEtapePyxb(self,etape): # OK seulement si sequence (choice ? ...) - print ('----------------------------------------------------------------------------------------------je suis la') - self.objPyxb.append(etape.objPyxb) - self.toxml() + print ('ds enregistreEtapePyxb', etape.nom) + if not self.cata.modeleMetier : return + self.objPyxb.append(etape.objPyxb) + #self.toXml() - def toxml(self): - print(self.objPyxb.toDOM().toprettyxml()) - print(self.objPyxb.toxml()) + def toXml(self): + if not self.cata.modeleMetier : return + print(self.objPyxb.toDOM().toprettyxml()) + print(self.objPyxb.toxml()) diff --git a/Efi2Xsd/mesAgregatsDefinition.py b/Efi2Xsd/mesAgregatsDefinition.py new file mode 100755 index 00000000..e05e7be4 --- /dev/null +++ b/Efi2Xsd/mesAgregatsDefinition.py @@ -0,0 +1,168 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +import sys,os +import types + +#import raw.efficas as efficas +sys.path.insert(0,os.path.abspath(os.path.join(os.getcwd(),'..'))) + +# 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 dictOPEREficasXML, dictOPERXMLEficas +from mapDesTypes import dictBLOCEficasXML, dictBLOCXMLEficas +from mapDesTypes import dictPourCast, dictNomsDesTypes +from mapDesTypes import listeParamDeTypeTypeAttendu, listeParamDeTypeStr, dictPourCast +from mapDesTypes import listeParamTjsSequence, listeParamSelonType + + +from balises import * + +# ----------------- +class X_definition: +# ----------------- + + def getCode(self): + if hasattr(self,'code') : return + obj=self + while ( not hasattr(obj,'code') ): obj=obj.pere + self.code = obj.code + + def genealogie(self): + texte=self.nom + obj=self + while ( hasattr(obj,'pere') ): + texte=obj.pere.nom+'_'+texte + obj=obj.pere + return 'T_'+texte + + def nomSimple(self): + return 'T_'+self.nom + #return self.genealogie() + + + +# ---------------------------------------- +class X_definitionComposee (X_definition): +# ---------------------------------------- + + + def dumpXsd(self): + #print ('------------------------------------------------') + #print ('dumpXsd de ' , self.nom) + + self.getCode() + self.nomDuTypeCree = self.nomSimple() + self.texteSimple = "" # on n ajoute pas de type simple + + self.texteComplexe = debutTypeComplexe.format(self.nomDuTypeCree) + texteComplexeVenantDesFils="" + for nom in self.ordre_mc: + mcFils = self.entites[nom] + mcFils.dumpXsd() + self.texteComplexe += mcFils.texteElt + self.texteSimple += mcFils.texteSimple + texteComplexeVenantDesFils += mcFils.texteComplexe + self.texteComplexe += finTypeComplexe + self.texteComplexe = texteComplexeVenantDesFils + self.texteComplexe + + self.traduitMinMax() + self.texteElt=eltDsSequence.format(self.nom,self.code,self.nomDuTypeCree,self.minOccurs,self.maxOccurs) + + def traduitMinMax(self): + # ____________________ + # valable pour bloc, proc et oper + self.minOccurs = 0 + self.maxOccurs = 1 + +# --------------------------------- +class X_FACT (X_definitionComposee): +#--------- ------------------------ + def traduitMinMax(self): + if self.max == '**' or self.max == float('inf') : self.maxOccurs="unbounded" + else : self.maxOccurs = self.max + self.minOccurs = self.min + if self.statut =='f' : self.minOccurs=0 + +# --------------------------------- +class X_OPER (X_definitionComposee): +# --------------------------------- + pass + +# ---------------------------------- +class X_PROC (X_definitionComposee): +#----------------------------------- + pass + +#----------------------------------- +class X_BLOC (X_definitionComposee): +#----------------------------------- + def dumpXsd(self): + X_definitionComposee.dumpXsd(self) + +#-------------------------------- +class X_SIMP (X_definition): +#-------------------------------- + def dumpXsd(self): + #print ('exploreObjet SIMP') + self.getCode() + + # --> homonymie on peut utiliser genealogie + #self.traduitMinMax() + #self.traduitValMinValMax() + self.nomDuTypeDeBase = self.traduitType() + self.nomDuTypeCree = self.nomSimple() + self.texteSimple = typeSimple.format(self.nomDuTypeCree, self.nomDuTypeDeBase) + self.texteComplexe = "" + + # on se sert des listes si maxOccurs est > 0 + if self.statut =='f' : minOccurs = 0 + else : minOccurs = 1 + self.texteElt = eltDsSequence.format(self.nom,self.code,self.nomDuTypeCree,minOccurs,1) + + + def traduitType(self): + # il faut traduire le min et le max + # il faut ajouter les regles + # il faut gerer les types tuple et fichier + return dictNomsDesTypes[self.type[0]] + + def traduitValMinValMax(self): + self.maxInclusive=self.val_max + self.minInclusive=self.val_min + if self.val_min == float('-inf') and val_max== float('inf') : return + print ('il faut affiner le type du SIMP ', self.nom) + if self.val_max == '**' or self.val_max == float('inf') : self.maxInclusive=None + else : self.maxInclusive = self.val_max + if self.val_min == '**' or self.val_max == float('-inf') : self.maxInclusive=None + else : self.minInclusive = self.val_min + + def traduitMinMax(self): + if self.min == 1 and self.max == 1 : return + print ('il faut creer une liste ' , self.nom) + + +#----------------- +class X_JDC_CATA : +#----------------- + + def dumpXsd(self): + self.texteSimple = "" + self.texteComplexe = "" + self.nomDuTypeCree='T_'+self.code + self.texteCata = debutTypeCata.format(self.nomDuTypeCree) + for commande in self.commandes : + commande.code=self.code + commande.dumpXsd() + self.texteSimple += commande.texteSimple + self.texteSimple += commande.texteComplexe + self.texteCata += commande.texteElt + self.texteCata += finTypeCata + self.texteElt=eltCata.format(self.code, self.nomDuTypeCree) + print (self.texteSimple) + print (self.texteComplexe) + print (self.texteCata) + print (self.texteElt) + diff --git a/Efi2Xsd/readerEfiXsd.py b/Efi2Xsd/readerEfiXsd.py new file mode 100755 index 00000000..82883038 --- /dev/null +++ b/Efi2Xsd/readerEfiXsd.py @@ -0,0 +1,300 @@ +#!/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 * + + +# 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 dictOPEREficasXML, dictOPERXMLEficas +from mapDesTypes import dictBLOCEficasXML, dictBLOCXMLEficas +from mapDesTypes import dictPourCast +from mapDesTypes import listeParamDeTypeTypeAttendu, listeParamDeTypeStr, dictPourCast +from mapDesTypes import listeParamTjsSequence, listeParamSelonType + + +# ------------------------------ +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,cata): + # -------------------------- + 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(cata) + if hasattr(obj,'getAccasEquivalent') : + nom,objetAccas=obj.getAccasEquivalent() + self.dictArgsEficas[nom]=objetAccas + +# ---------------------------------------------------- +class monSIMP (efficas.T_SIMP, objetDefinitionAccas): +# ---------------------------------------------------- + + def explore(self,cata): + # -------------------- + #print ("je passe dans explore pour SIMP ", self.nom) + self.dictATraiter= dictSIMPXMLEficas + self.argumentXMLToEficas() + + self.objAccas=A_SIMP.SIMP(**self.dictArgsEficas) + self.objAccas.nom=self.nomObj + + def argumentXMLToEficas(self): + # ---------------------------- + #print self.nom + objetDefinitionAccas.argumentXMLToEficas(self) + + if self.attendTuple() : + #nbDElts=type(listeDElt[0]) + print self.nomTypeAttendu + + + self.traiteLesSequences() + print (self.dictArgsEficas) + #self.convertitLesTypes() + + def attendListe(self): + # --------------- + if 'max' in self.dictArgsEficas : + if self.dictArgsEficas['max'] > 1 : return True + if self.dictArgsEficas['max'] == "**" : return True + return False + + def attendTuple(self): + # ----------------- + if self.dictArgsEficas['typ'] != 'tuple' : return False + return True + + def attendTXM(self): + # ---------------- + if self.dictArgsEficas['typ'] == 'TXM' : return True + return False + + + def traiteLesSequences(self): + # --------------------------- + listeDeListe=self.attendListe() + for param in listeParamTjsSequence : + if param in self.dictArgsEficas : + if listeDeListe == False: + listeDElt=self.dictArgsEficas[param][0].content() + listeRetour=self.convertitListeDsLeBonType(listeDElt) + self.dictArgsEficas[param]=listeRetour + else : + listeResultat=[] + # on transforme en liste pour traiter chaque elt de la liste + for i in range(len(self.dictArgsEficas[param])): + if self.dictArgsEficas[param][i].typesimple != None : + lesElts=self.dictArgsEficas[param][i].typesimple + else : + lesElts=self.dictArgsEficas[param][i].content() + if (not(isinstance(lesElts,list)) and not (isinstance(lesElts,tuple))): + lesElts=(lesElts,) + lesEltsTransformes=self.convertitListeDsLeBonType(lesElts) + lesEltsTransformes=self.convertitListeDsLeBonType(lesElts) + listeResultat.append(lesEltsTransformes) + self.dictArgsEficas[param]=listeResultat + #print ('fin de traiteLesSequences pour', self.nom, ' param :', param, 'listeResultat',self.dictArgsEficas[param]) + + + def convertitListeDsLeBonType(self,listeDElt): + # ------------------------------------------- + # Cas des Tuples non traites + typeAttendu = self.dictArgsEficas['typ'] + if typeAttendu in list(dictPourCast.keys()): + nouvelleListe=[] + castDsLeTypeAttendu=dictPourCast[typeAttendu] + for valeurACaster in listeDElt : + val=castDsLeTypeAttendu(valeurACaster) + nouvelleListe.append(val) + return nouvelleListe + elif self.attendTuple() : + nbDElts=type(listeDElt[0]).n + + else : return listeDElt + + + + def convertitLesTypes(self): + # ------------------------ + # Cas des Tuples non traites + # Cas des fonctions utilisateurs non traites + + typeAttendu = self.dictArgsEficas['typ'] + if typeAttendu in list(dictPourCast.keys()): + castDsLeTypeAttendu=dictPourCast[typeAttendu] + for param in listeParamDeTypeTypeAttendu : + if param in list(self.dictArgsEficas.keys()): + if param in listeParamEnListeSelonType or param in listeParamTjsEnListe : + print ('typeAttendu',typeAttendu) + print (self.dictArgsEficas[param]) + print (self.dictArgsEficas[param].content()) + print (self.dictArgsEficas[param].content()) + return + 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,cata): + # -------------------- + #print "je passe dans explore pour FACT ", self.nom + + self.dictATraiter= dictFACTXMLEficas + self.argumentXMLToEficas() + self.exploreArbre(cata) + 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(cata) + self.dictArgsEficas['op']=None + + self.objAccas=A_PROC.PROC(**self.dictArgsEficas) + setattr(cata, self.nomObj,self.objAccas) + cata.contexteXML[self.nomObj]=self.objAccas + +# --------------------------------------------------------- +class monOPER(efficas.T_OPER, objetComposeDefinitionAccas): +# --------------------------------------------------------- + def explore(self,cata): +# ------------------------ + print "je passe dans explore pour OPER", self.nom + self.cata=cata + self.dictATraiter= dictOPERXMLEficas + self.argumentXMLToEficas() + self.exploreArbre(cata) + + textCreationClasse='class '+str(self.typeCree)+'(ASSD): pass\n' + exec(textCreationClasse,globals()) + maClasseCreee=globals()[self.typeCree] + self.dictArgsEficas['sd_prod'] = maClasseCreee + cata.contexteXML[self.typeCree] = maClasseCreee + + self.dictArgsEficas['op'] = None + self.objAccas=A_OPER.OPER(**self.dictArgsEficas) + setattr(cata, self.nomObj,self.objAccas) + cata.contexteXML[self.nomObj] = self.objAccas + +# --------------------------------------------------------- +class monBLOC(efficas.T_BLOC, objetComposeDefinitionAccas): +# --------------------------------------------------------- + def explore(self,cata): +# ------------------------ + print ('je passe dans explore pour BLOC', self.nom) + self.cata=cata + self.dictATraiter= dictBLOCXMLEficas + self.argumentXMLToEficas() + self.exploreArbre(cata) + self.objAccas=A_BLOC.BLOC(**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_OPER._SetSupersedingClass(monOPER) +efficas.T_BLOC._SetSupersedingClass(monBLOC) +efficas.T_cata._SetSupersedingClass(monCata) + +if __name__ == "__main__": +# print dir(efficas) +# print dir(efficas.T_SIMP) + + #xml = open('cata_test1.xml').read() + xml = open('cata.xml').read() + SchemaMed = efficas.CreateFromDocument(xml) + SchemaMed.exploreCata() + #SchemaMed.dumpXSD() + -- 2.39.2