]> SALOME platform Git repositories - modules/eficas.git/commitdiff
Salome HOME
sauvegarde du 26-04
authorpascale.noyret <pascale.noyret@edf.fr>
Thu, 26 Apr 2018 14:26:41 +0000 (16:26 +0200)
committerpascale.noyret <pascale.noyret@edf.fr>
Thu, 26 Apr 2018 14:26:41 +0000 (16:26 +0200)
Efi2Xsd/balises.py [new file with mode: 0644]
Efi2Xsd/mapDesTypes.py
Efi2Xsd/mesAgregats.py
Efi2Xsd/mesAgregatsDefinition.py [new file with mode: 0755]
Efi2Xsd/readerEfiXsd.py [new file with mode: 0755]

diff --git a/Efi2Xsd/balises.py b/Efi2Xsd/balises.py
new file mode 100644 (file)
index 0000000..c0eee99
--- /dev/null
@@ -0,0 +1,37 @@
+typeSimple    = '\t<simpleType name="{}">\n\t\t<restriction base="{}"/>\n\t</simpleType>\n'
+eltDsSequence = '\t\t\t<element name="{}" type="{}:{}" minOccurs="{}" maxOccurs="{}"/>\n'
+
+debutTypeComplexe = '\t<complexType name="{}">\n\t\t<sequence>\n'
+finTypeComplexe   = '\t\t</sequence>\n\t</complexType>\n'
+
+debutTypeCata = '\t<complexType name="{}">\n\t\t<choice minOccurs="0" maxOccurs="unbounded">\n'
+finTypeCata   = '\t\t</choice>\n\t</complexType> '
+
+eltCata = '<element name="JDD" type="{}:{}"/>\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)
+
index e5547d4a7ae5246e39cc9ccf9d5d0d47c448a36c..fcd797f841fef77f1551da22edea52bbb51e200e 100755 (executable)
@@ -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 )
index 19d55a1a0b771aedeef4a295726a5f3539f22086..eb20219c7c25d3accaaca501c84984e40d030ac1 100755 (executable)
@@ -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 (executable)
index 0000000..e05e7be
--- /dev/null
@@ -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 (executable)
index 0000000..8288303
--- /dev/null
@@ -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()
+