From: pascale.noyret Date: Thu, 8 Nov 2018 15:06:12 +0000 (+0100) Subject: pour test X-Git-Tag: avantMenage~69 X-Git-Url: http://git.salome-platform.org/gitweb/?a=commitdiff_plain;h=85eec38b91f2a6629900565d703e6b0e4fcf4c0b;p=tools%2Feficas.git pour test --- diff --git a/CataTestXSD/cata_TestXSD_genere.xsd b/CataTestXSD/cata_TestXSD_genere.xsd new file mode 100644 index 00000000..f6be7bb6 --- /dev/null +++ b/CataTestXSD/cata_TestXSD_genere.xsd @@ -0,0 +1,55 @@ + + + + > + + + > + + + + + + + + + + > + + + > + + + > + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/CataTestXSD/cata_test1.py b/CataTestXSD/cata_test1.py new file mode 100644 index 00000000..21178984 --- /dev/null +++ b/CataTestXSD/cata_test1.py @@ -0,0 +1,23 @@ +# coding: utf-8 + +from Accas import * + +JdC = JDC_CATA (code = 'testXSD', + execmodul = None, + ) +PROC1=PROC(nom='PROC1',op=None, + description = SIMP(statut='f', typ='TXM', defaut=''), + milieu = SIMP(statut='o', typ='TXM', defaut='File'), + FactNiveauHaut = FACT(statut='f', max="**", + source = SIMP(statut='o', typ='TXM', into=['File','Dico','Value'],defaut='File'), + b_source_valeur = BLOC(condition="source == 'Value'", + simpDuBloc = SIMP(statut = "o", typ = 'R'), + ), + FactNiveauDuBas= FACT( statut = 'o', max='**', + diameter = SIMP(statut='o', typ='R', val_min = 0), + thickness = SIMP(statut='o', typ='R', val_min = 0), + ), + + ), +); + diff --git a/CataTestXSD/prefs_TestXSD.py b/CataTestXSD/prefs_TestXSD.py index 1fc5d23e..c8e48d1c 100644 --- a/CataTestXSD/prefs_TestXSD.py +++ b/CataTestXSD/prefs_TestXSD.py @@ -35,8 +35,14 @@ encoding='iso-8859-1' docPath=repIni # -typeDeCata='XML' +#typeDeCata='XML' catalogues=( - ('TestXSD','TestXSD',os.path.join(repIni,'cata_test1.xml'),'dico','xml'), +# ('TestXSD','TestXSDPY',os.path.join(repIni,'cata_test1.xml'),'python','python'), +# ('TestXSD','TestXSD',os.path.join(repIni,'cata_test1.xml'),'python','xml'), + ('TestXSD','TestXSDPY',os.path.join(repIni,'cata_test1.py'),'python','python'), ) +withXSD=True +#dumpXSD=True +#afficheIhm=False + diff --git a/CataTestXSD/raw/__init__.py b/CataTestXSD/raw/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/CataTestXSD/raw/cata_genere.py b/CataTestXSD/raw/cata_genere.py new file mode 100644 index 00000000..c6c5d076 --- /dev/null +++ b/CataTestXSD/raw/cata_genere.py @@ -0,0 +1,472 @@ +# ./raw/cata_genere.py +# -*- coding: utf-8 -*- +# PyXB bindings for NM:933a854d4f58913558dd4662ff8be8d029ebb4db +# Generated 2018-11-08 16:02:25.664950 by PyXB version 1.2.6 using Python 2.7.9.final.0 +# Namespace http://chercheurs.edf.com/logiciels/testXSD + +from __future__ import unicode_literals +import pyxb +import pyxb.binding +import pyxb.binding.saxer +import io +import pyxb.utils.utility +import pyxb.utils.domutils +import sys +import pyxb.utils.six as _six +# Unique identifier for bindings created at the same time +_GenerationUID = pyxb.utils.utility.UniqueIdentifier('urn:uuid:4d842c7c-e367-11e8-85d3-308d996bd755') + +# Version of PyXB used to generate the bindings +_PyXBVersion = '1.2.6' +# Generated bindings are not compatible across PyXB versions +if pyxb.__version__ != _PyXBVersion: + raise pyxb.PyXBVersionError(_PyXBVersion) + +# A holder for module-level binding classes so we can access them from +# inside class definitions where property names may conflict. +_module_typeBindings = pyxb.utils.utility.Object() + +# Import bindings for namespaces imported into schema +import pyxb.binding.datatypes + +# NOTE: All namespace declarations are reserved within the binding +Namespace = pyxb.namespace.NamespaceForURI('http://chercheurs.edf.com/logiciels/testXSD', create_if_missing=True) +Namespace.configureCategories(['typeBinding', 'elementBinding']) + +def CreateFromDocument (xml_text, default_namespace=None, location_base=None): + """Parse the given XML and use the document element to create a + Python instance. + + @param xml_text An XML document. This should be data (Python 2 + str or Python 3 bytes), or a text (Python 2 unicode or Python 3 + str) in the L{pyxb._InputEncoding} encoding. + + @keyword default_namespace The L{pyxb.Namespace} instance to use as the + default namespace where there is no default namespace in scope. + If unspecified or C{None}, the namespace of the module containing + this function will be used. + + @keyword location_base: An object to be recorded as the base of all + L{pyxb.utils.utility.Location} instances associated with events and + objects handled by the parser. You might pass the URI from which + the document was obtained. + """ + + if pyxb.XMLStyle_saxer != pyxb._XMLStyle: + dom = pyxb.utils.domutils.StringToDOM(xml_text) + return CreateFromDOM(dom.documentElement, default_namespace=default_namespace) + if default_namespace is None: + default_namespace = Namespace.fallbackNamespace() + saxer = pyxb.binding.saxer.make_parser(fallback_namespace=default_namespace, location_base=location_base) + handler = saxer.getContentHandler() + xmld = xml_text + if isinstance(xmld, _six.text_type): + xmld = xmld.encode(pyxb._InputEncoding) + saxer.parse(io.BytesIO(xmld)) + instance = handler.rootObject() + return instance + +def CreateFromDOM (node, default_namespace=None): + """Create a Python instance from the given DOM node. + The node tag must correspond to an element declaration in this module. + + @deprecated: Forcing use of DOM interface is unnecessary; use L{CreateFromDocument}.""" + if default_namespace is None: + default_namespace = Namespace.fallbackNamespace() + return pyxb.binding.basis.element.AnyCreateFromDOM(node, default_namespace) + + +# Atomic simple type: {http://chercheurs.edf.com/logiciels/testXSD}T_description +class T_description (pyxb.binding.datatypes.string): + + """An atomic simple type.""" + + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'T_description') + _XSDLocation = pyxb.utils.utility.Location('/home/A96028/QT5GitEficasTravail/eficas/CataTestXSD/cata_TestXSD_genere.xsd', 3, 1) + _Documentation = None +T_description._InitializeFacetMap() +Namespace.addCategoryObject('typeBinding', 'T_description', T_description) +_module_typeBindings.T_description = T_description + +# Atomic simple type: {http://chercheurs.edf.com/logiciels/testXSD}T_milieu +class T_milieu (pyxb.binding.datatypes.string): + + """An atomic simple type.""" + + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'T_milieu') + _XSDLocation = pyxb.utils.utility.Location('/home/A96028/QT5GitEficasTravail/eficas/CataTestXSD/cata_TestXSD_genere.xsd', 6, 1) + _Documentation = None +T_milieu._InitializeFacetMap() +Namespace.addCategoryObject('typeBinding', 'T_milieu', T_milieu) +_module_typeBindings.T_milieu = T_milieu + +# Atomic simple type: {http://chercheurs.edf.com/logiciels/testXSD}T_source +class T_source (pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration_mixin): + + """An atomic simple type.""" + + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'T_source') + _XSDLocation = pyxb.utils.utility.Location('/home/A96028/QT5GitEficasTravail/eficas/CataTestXSD/cata_TestXSD_genere.xsd', 9, 1) + _Documentation = None +T_source._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=T_source, enum_prefix=None) +T_source.File = T_source._CF_enumeration.addEnumeration(unicode_value='File', tag='File') +T_source.Dico = T_source._CF_enumeration.addEnumeration(unicode_value='Dico', tag='Dico') +T_source.Value = T_source._CF_enumeration.addEnumeration(unicode_value='Value', tag='Value') +T_source._InitializeFacetMap(T_source._CF_enumeration) +Namespace.addCategoryObject('typeBinding', 'T_source', T_source) +_module_typeBindings.T_source = T_source + +# Atomic simple type: {http://chercheurs.edf.com/logiciels/testXSD}T_simpDuBloc +class T_simpDuBloc (pyxb.binding.datatypes.float): + + """An atomic simple type.""" + + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'T_simpDuBloc') + _XSDLocation = pyxb.utils.utility.Location('/home/A96028/QT5GitEficasTravail/eficas/CataTestXSD/cata_TestXSD_genere.xsd', 16, 1) + _Documentation = None +T_simpDuBloc._InitializeFacetMap() +Namespace.addCategoryObject('typeBinding', 'T_simpDuBloc', T_simpDuBloc) +_module_typeBindings.T_simpDuBloc = T_simpDuBloc + +# Atomic simple type: {http://chercheurs.edf.com/logiciels/testXSD}T_diameter +class T_diameter (pyxb.binding.datatypes.float): + + """An atomic simple type.""" + + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'T_diameter') + _XSDLocation = pyxb.utils.utility.Location('/home/A96028/QT5GitEficasTravail/eficas/CataTestXSD/cata_TestXSD_genere.xsd', 19, 1) + _Documentation = None +T_diameter._InitializeFacetMap() +Namespace.addCategoryObject('typeBinding', 'T_diameter', T_diameter) +_module_typeBindings.T_diameter = T_diameter + +# Atomic simple type: {http://chercheurs.edf.com/logiciels/testXSD}T_thickness +class T_thickness (pyxb.binding.datatypes.float): + + """An atomic simple type.""" + + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'T_thickness') + _XSDLocation = pyxb.utils.utility.Location('/home/A96028/QT5GitEficasTravail/eficas/CataTestXSD/cata_TestXSD_genere.xsd', 22, 1) + _Documentation = None +T_thickness._InitializeFacetMap() +Namespace.addCategoryObject('typeBinding', 'T_thickness', T_thickness) +_module_typeBindings.T_thickness = T_thickness + +# Complex type {http://chercheurs.edf.com/logiciels/testXSD}T_FactNiveauDuBas with content type ELEMENT_ONLY +class T_FactNiveauDuBas (pyxb.binding.basis.complexTypeDefinition): + """Complex type {http://chercheurs.edf.com/logiciels/testXSD}T_FactNiveauDuBas with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'T_FactNiveauDuBas') + _XSDLocation = pyxb.utils.utility.Location('/home/A96028/QT5GitEficasTravail/eficas/CataTestXSD/cata_TestXSD_genere.xsd', 30, 1) + _ElementMap = {} + _AttributeMap = {} + # Base type is pyxb.binding.datatypes.anyType + + # Element {http://chercheurs.edf.com/logiciels/testXSD}diameter uses Python identifier diameter + __diameter = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'diameter'), 'diameter', '__httpchercheurs_edf_comlogicielstestXSD_T_FactNiveauDuBas_httpchercheurs_edf_comlogicielstestXSDdiameter', False, pyxb.utils.utility.Location('/home/A96028/QT5GitEficasTravail/eficas/CataTestXSD/cata_TestXSD_genere.xsd', 32, 3), ) + + + diameter = property(__diameter.value, __diameter.set, None, None) + + + # Element {http://chercheurs.edf.com/logiciels/testXSD}thickness uses Python identifier thickness + __thickness = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'thickness'), 'thickness', '__httpchercheurs_edf_comlogicielstestXSD_T_FactNiveauDuBas_httpchercheurs_edf_comlogicielstestXSDthickness', False, pyxb.utils.utility.Location('/home/A96028/QT5GitEficasTravail/eficas/CataTestXSD/cata_TestXSD_genere.xsd', 33, 3), ) + + + thickness = property(__thickness.value, __thickness.set, None, None) + + _ElementMap.update({ + __diameter.name() : __diameter, + __thickness.name() : __thickness + }) + _AttributeMap.update({ + + }) +_module_typeBindings.T_FactNiveauDuBas = T_FactNiveauDuBas +Namespace.addCategoryObject('typeBinding', 'T_FactNiveauDuBas', T_FactNiveauDuBas) + + +# Complex type {http://chercheurs.edf.com/logiciels/testXSD}T_FactNiveauHaut with content type ELEMENT_ONLY +class T_FactNiveauHaut (pyxb.binding.basis.complexTypeDefinition): + """Complex type {http://chercheurs.edf.com/logiciels/testXSD}T_FactNiveauHaut with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'T_FactNiveauHaut') + _XSDLocation = pyxb.utils.utility.Location('/home/A96028/QT5GitEficasTravail/eficas/CataTestXSD/cata_TestXSD_genere.xsd', 36, 1) + _ElementMap = {} + _AttributeMap = {} + # Base type is pyxb.binding.datatypes.anyType + + # Element {http://chercheurs.edf.com/logiciels/testXSD}simpDuBloc uses Python identifier simpDuBloc + __simpDuBloc = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'simpDuBloc'), 'simpDuBloc', '__httpchercheurs_edf_comlogicielstestXSD_T_FactNiveauHaut_httpchercheurs_edf_comlogicielstestXSDsimpDuBloc', False, pyxb.utils.utility.Location('/home/A96028/QT5GitEficasTravail/eficas/CataTestXSD/cata_TestXSD_genere.xsd', 27, 3), ) + + + simpDuBloc = property(__simpDuBloc.value, __simpDuBloc.set, None, None) + + + # Element {http://chercheurs.edf.com/logiciels/testXSD}source uses Python identifier source + __source = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'source'), 'source', '__httpchercheurs_edf_comlogicielstestXSD_T_FactNiveauHaut_httpchercheurs_edf_comlogicielstestXSDsource', False, pyxb.utils.utility.Location('/home/A96028/QT5GitEficasTravail/eficas/CataTestXSD/cata_TestXSD_genere.xsd', 38, 3), ) + + + source = property(__source.value, __source.set, None, None) + + + # Element {http://chercheurs.edf.com/logiciels/testXSD}FactNiveauDuBas uses Python identifier FactNiveauDuBas + __FactNiveauDuBas = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'FactNiveauDuBas'), 'FactNiveauDuBas', '__httpchercheurs_edf_comlogicielstestXSD_T_FactNiveauHaut_httpchercheurs_edf_comlogicielstestXSDFactNiveauDuBas', False, pyxb.utils.utility.Location('/home/A96028/QT5GitEficasTravail/eficas/CataTestXSD/cata_TestXSD_genere.xsd', 40, 3), ) + + + FactNiveauDuBas = property(__FactNiveauDuBas.value, __FactNiveauDuBas.set, None, None) + + _ElementMap.update({ + __simpDuBloc.name() : __simpDuBloc, + __source.name() : __source, + __FactNiveauDuBas.name() : __FactNiveauDuBas + }) + _AttributeMap.update({ + + }) +_module_typeBindings.T_FactNiveauHaut = T_FactNiveauHaut +Namespace.addCategoryObject('typeBinding', 'T_FactNiveauHaut', T_FactNiveauHaut) + + +# Complex type {http://chercheurs.edf.com/logiciels/testXSD}T_PROC1 with content type ELEMENT_ONLY +class T_PROC1 (pyxb.binding.basis.complexTypeDefinition): + """Complex type {http://chercheurs.edf.com/logiciels/testXSD}T_PROC1 with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'T_PROC1') + _XSDLocation = pyxb.utils.utility.Location('/home/A96028/QT5GitEficasTravail/eficas/CataTestXSD/cata_TestXSD_genere.xsd', 43, 1) + _ElementMap = {} + _AttributeMap = {} + # Base type is pyxb.binding.datatypes.anyType + + # Element {http://chercheurs.edf.com/logiciels/testXSD}description uses Python identifier description + __description = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'description'), 'description', '__httpchercheurs_edf_comlogicielstestXSD_T_PROC1_httpchercheurs_edf_comlogicielstestXSDdescription', False, pyxb.utils.utility.Location('/home/A96028/QT5GitEficasTravail/eficas/CataTestXSD/cata_TestXSD_genere.xsd', 45, 3), ) + + + description = property(__description.value, __description.set, None, None) + + + # Element {http://chercheurs.edf.com/logiciels/testXSD}milieu uses Python identifier milieu + __milieu = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'milieu'), 'milieu', '__httpchercheurs_edf_comlogicielstestXSD_T_PROC1_httpchercheurs_edf_comlogicielstestXSDmilieu', False, pyxb.utils.utility.Location('/home/A96028/QT5GitEficasTravail/eficas/CataTestXSD/cata_TestXSD_genere.xsd', 46, 3), ) + + + milieu = property(__milieu.value, __milieu.set, None, None) + + + # Element {http://chercheurs.edf.com/logiciels/testXSD}FactNiveauHaut uses Python identifier FactNiveauHaut + __FactNiveauHaut = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'FactNiveauHaut'), 'FactNiveauHaut', '__httpchercheurs_edf_comlogicielstestXSD_T_PROC1_httpchercheurs_edf_comlogicielstestXSDFactNiveauHaut', False, pyxb.utils.utility.Location('/home/A96028/QT5GitEficasTravail/eficas/CataTestXSD/cata_TestXSD_genere.xsd', 47, 3), ) + + + FactNiveauHaut = property(__FactNiveauHaut.value, __FactNiveauHaut.set, None, None) + + _ElementMap.update({ + __description.name() : __description, + __milieu.name() : __milieu, + __FactNiveauHaut.name() : __FactNiveauHaut + }) + _AttributeMap.update({ + + }) +_module_typeBindings.T_PROC1 = T_PROC1 +Namespace.addCategoryObject('typeBinding', 'T_PROC1', T_PROC1) + + +# Complex type {http://chercheurs.edf.com/logiciels/testXSD}T_testXSD with content type ELEMENT_ONLY +class T_testXSD (pyxb.binding.basis.complexTypeDefinition): + """Complex type {http://chercheurs.edf.com/logiciels/testXSD}T_testXSD with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'T_testXSD') + _XSDLocation = pyxb.utils.utility.Location('/home/A96028/QT5GitEficasTravail/eficas/CataTestXSD/cata_TestXSD_genere.xsd', 50, 1) + _ElementMap = {} + _AttributeMap = {} + # Base type is pyxb.binding.datatypes.anyType + + # Element {http://chercheurs.edf.com/logiciels/testXSD}PROC1 uses Python identifier PROC1 + __PROC1 = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'PROC1'), 'PROC1', '__httpchercheurs_edf_comlogicielstestXSD_T_testXSD_httpchercheurs_edf_comlogicielstestXSDPROC1', True, pyxb.utils.utility.Location('/home/A96028/QT5GitEficasTravail/eficas/CataTestXSD/cata_TestXSD_genere.xsd', 52, 3), ) + + + PROC1 = property(__PROC1.value, __PROC1.set, None, None) + + _ElementMap.update({ + __PROC1.name() : __PROC1 + }) + _AttributeMap.update({ + + }) +_module_typeBindings.T_testXSD = T_testXSD +Namespace.addCategoryObject('typeBinding', 'T_testXSD', T_testXSD) + + +testXSD = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'testXSD'), T_testXSD, location=pyxb.utils.utility.Location('/home/A96028/QT5GitEficasTravail/eficas/CataTestXSD/cata_TestXSD_genere.xsd', 54, 17)) +Namespace.addCategoryObject('elementBinding', testXSD.name().localName(), testXSD) + + + +T_FactNiveauDuBas._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'diameter'), T_diameter, scope=T_FactNiveauDuBas, location=pyxb.utils.utility.Location('/home/A96028/QT5GitEficasTravail/eficas/CataTestXSD/cata_TestXSD_genere.xsd', 32, 3))) + +T_FactNiveauDuBas._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'thickness'), T_thickness, scope=T_FactNiveauDuBas, location=pyxb.utils.utility.Location('/home/A96028/QT5GitEficasTravail/eficas/CataTestXSD/cata_TestXSD_genere.xsd', 33, 3))) + +def _BuildAutomaton (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton + del _BuildAutomaton + import pyxb.utils.fac as fac + + counters = set() + states = [] + final_update = None + symbol = pyxb.binding.content.ElementUse(T_FactNiveauDuBas._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'diameter')), pyxb.utils.utility.Location('/home/A96028/QT5GitEficasTravail/eficas/CataTestXSD/cata_TestXSD_genere.xsd', 32, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = set() + symbol = pyxb.binding.content.ElementUse(T_FactNiveauDuBas._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'thickness')), pyxb.utils.utility.Location('/home/A96028/QT5GitEficasTravail/eficas/CataTestXSD/cata_TestXSD_genere.xsd', 33, 3)) + st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + transitions = [] + transitions.append(fac.Transition(st_1, [ + ])) + st_0._set_transitionSet(transitions) + transitions = [] + st_1._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +T_FactNiveauDuBas._Automaton = _BuildAutomaton() + + + + +T_FactNiveauHaut._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'simpDuBloc'), T_simpDuBloc, scope=T_FactNiveauHaut, location=pyxb.utils.utility.Location('/home/A96028/QT5GitEficasTravail/eficas/CataTestXSD/cata_TestXSD_genere.xsd', 27, 3))) + +T_FactNiveauHaut._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'source'), T_source, scope=T_FactNiveauHaut, location=pyxb.utils.utility.Location('/home/A96028/QT5GitEficasTravail/eficas/CataTestXSD/cata_TestXSD_genere.xsd', 38, 3))) + +T_FactNiveauHaut._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'FactNiveauDuBas'), T_FactNiveauDuBas, scope=T_FactNiveauHaut, location=pyxb.utils.utility.Location('/home/A96028/QT5GitEficasTravail/eficas/CataTestXSD/cata_TestXSD_genere.xsd', 40, 3))) + +def _BuildAutomaton_ (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_ + del _BuildAutomaton_ + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('/home/A96028/QT5GitEficasTravail/eficas/CataTestXSD/cata_TestXSD_genere.xsd', 39, 3)) + counters.add(cc_0) + cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('/home/A96028/QT5GitEficasTravail/eficas/CataTestXSD/cata_TestXSD_genere.xsd', 40, 3)) + counters.add(cc_1) + states = [] + final_update = set() + symbol = pyxb.binding.content.ElementUse(T_FactNiveauHaut._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'source')), pyxb.utils.utility.Location('/home/A96028/QT5GitEficasTravail/eficas/CataTestXSD/cata_TestXSD_genere.xsd', 38, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_0, False)) + symbol = pyxb.binding.content.ElementUse(T_FactNiveauHaut._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'simpDuBloc')), pyxb.utils.utility.Location('/home/A96028/QT5GitEficasTravail/eficas/CataTestXSD/cata_TestXSD_genere.xsd', 27, 3)) + st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_1, False)) + symbol = pyxb.binding.content.ElementUse(T_FactNiveauHaut._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'FactNiveauDuBas')), pyxb.utils.utility.Location('/home/A96028/QT5GitEficasTravail/eficas/CataTestXSD/cata_TestXSD_genere.xsd', 40, 3)) + st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + transitions = [] + transitions.append(fac.Transition(st_1, [ + ])) + transitions.append(fac.Transition(st_2, [ + ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, True) ])) + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_0, False) ])) + st_1._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_1, True) ])) + st_2._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +T_FactNiveauHaut._Automaton = _BuildAutomaton_() + + + + +T_PROC1._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'description'), T_description, scope=T_PROC1, location=pyxb.utils.utility.Location('/home/A96028/QT5GitEficasTravail/eficas/CataTestXSD/cata_TestXSD_genere.xsd', 45, 3))) + +T_PROC1._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'milieu'), T_milieu, scope=T_PROC1, location=pyxb.utils.utility.Location('/home/A96028/QT5GitEficasTravail/eficas/CataTestXSD/cata_TestXSD_genere.xsd', 46, 3))) + +T_PROC1._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'FactNiveauHaut'), T_FactNiveauHaut, scope=T_PROC1, location=pyxb.utils.utility.Location('/home/A96028/QT5GitEficasTravail/eficas/CataTestXSD/cata_TestXSD_genere.xsd', 47, 3))) + +def _BuildAutomaton_2 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_2 + del _BuildAutomaton_2 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('/home/A96028/QT5GitEficasTravail/eficas/CataTestXSD/cata_TestXSD_genere.xsd', 45, 3)) + counters.add(cc_0) + cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('/home/A96028/QT5GitEficasTravail/eficas/CataTestXSD/cata_TestXSD_genere.xsd', 47, 3)) + counters.add(cc_1) + states = [] + final_update = None + symbol = pyxb.binding.content.ElementUse(T_PROC1._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'description')), pyxb.utils.utility.Location('/home/A96028/QT5GitEficasTravail/eficas/CataTestXSD/cata_TestXSD_genere.xsd', 45, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = set() + symbol = pyxb.binding.content.ElementUse(T_PROC1._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'milieu')), pyxb.utils.utility.Location('/home/A96028/QT5GitEficasTravail/eficas/CataTestXSD/cata_TestXSD_genere.xsd', 46, 3)) + st_1 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_1, False)) + symbol = pyxb.binding.content.ElementUse(T_PROC1._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'FactNiveauHaut')), pyxb.utils.utility.Location('/home/A96028/QT5GitEficasTravail/eficas/CataTestXSD/cata_TestXSD_genere.xsd', 47, 3)) + st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + transitions = [] + transitions.append(fac.Transition(st_0, [ + fac.UpdateInstruction(cc_0, True) ])) + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, False) ])) + st_0._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + ])) + st_1._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_2, [ + fac.UpdateInstruction(cc_1, True) ])) + st_2._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +T_PROC1._Automaton = _BuildAutomaton_2() + + + + +T_testXSD._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'PROC1'), T_PROC1, scope=T_testXSD, location=pyxb.utils.utility.Location('/home/A96028/QT5GitEficasTravail/eficas/CataTestXSD/cata_TestXSD_genere.xsd', 52, 3))) + +def _BuildAutomaton_3 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_3 + del _BuildAutomaton_3 + import pyxb.utils.fac as fac + + counters = set() + cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('/home/A96028/QT5GitEficasTravail/eficas/CataTestXSD/cata_TestXSD_genere.xsd', 51, 2)) + counters.add(cc_0) + states = [] + final_update = set() + final_update.add(fac.UpdateInstruction(cc_0, False)) + symbol = pyxb.binding.content.ElementUse(T_testXSD._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'PROC1')), pyxb.utils.utility.Location('/home/A96028/QT5GitEficasTravail/eficas/CataTestXSD/cata_TestXSD_genere.xsd', 52, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + transitions = [] + transitions.append(fac.Transition(st_0, [ + fac.UpdateInstruction(cc_0, True) ])) + st_0._set_transitionSet(transitions) + return fac.Automaton(states, counters, True, containing_state=None) +T_testXSD._Automaton = _BuildAutomaton_3() + diff --git a/Extensions/nuplet.py b/Extensions/nuplet.py index 4d2a355c..465c6f01 100644 --- a/Extensions/nuplet.py +++ b/Extensions/nuplet.py @@ -75,11 +75,11 @@ class NUPL(N_ENTITE.ENTITE,I_ENTITE.ENTITE): self.cr.fatal(tr("L'attribut 'max' doit etre un entier : ")+str(self.max)) if self.min > self.max : self.cr.fatal(tr("Nombres d'occurrence min et max invalides :") +str(self.min)+","+str(self.max)) - if type(self.fr) != bytes : + if type(self.fr) != bytes and type(self.fr) != str : self.cr.fatal(tr("L'attribut 'fr' doit etre une chaine de caracteres")) if self.statut not in ['o','f','c','d']: self.cr.fatal(tr("L'attribut 'statut' doit valoir 'o','f','c' ou 'd'")) - if type(self.docu) != bytes : + if type(self.docu) != bytes and type(self.docu) != str : self.cr.fatal(tr("L'attribut 'docu' doit etre une chaine de caracteres")) self.verifCataRegles() diff --git a/Extensions/parametre.py b/Extensions/parametre.py index 38e0f2f6..5ab01bab 100644 --- a/Extensions/parametre.py +++ b/Extensions/parametre.py @@ -74,6 +74,7 @@ class PARAMETRE(N_OBJECT.OBJECT,I_OBJECT.OBJECT,Formula) : #self.val=valeur self.valeur = valeur self.val=repr(valeur) + self.fenetreIhm=None def interpreteValeur(self,val): """ @@ -99,7 +100,7 @@ class PARAMETRE(N_OBJECT.OBJECT,I_OBJECT.OBJECT,Formula) : return None return l_new_val - if type(val) == bytes: + if type(val) == bytes or type(val) == str: # on tente l'evaluation dans un contexte fourni par le parent s'il existe if self.parent: valeur=self.parent.evalInContext(val,self) @@ -284,7 +285,7 @@ class PARAMETRE(N_OBJECT.OBJECT,I_OBJECT.OBJECT,Formula) : """ Donne un echo de self sous la forme nom = valeur """ - if type(self.valeur) == bytes: + if type(self.valeur) == bytes or type(self.valeur) == str : if self.valeur.find('\n') == -1: # pas de retour chariot, on utilise repr return self.nom+' = '+ repr(self.valeur) diff --git a/InterfaceQT4/readercata.py b/InterfaceQT4/readercata.py index 9e1e693c..801ea86e 100644 --- a/InterfaceQT4/readercata.py +++ b/InterfaceQT4/readercata.py @@ -193,10 +193,11 @@ class ReaderCata (ReaderCataCommun): try : #import raw.Telemac2d as modeleMetier #import raw.cata_genere_fact as modeleMetier - import raw.cata_map_genere as modeleMetier + import raw.cata_genere as modeleMetier #import raw.cata_bloc as modeleMetier #print ('import raw.cata_lbm_genere as modeleMetier') except : + print ('______________ poum import cata_genere ') modeleMetier = None else : modeleMetier = None