From: pascale.noyret Date: Wed, 18 Nov 2020 13:30:24 +0000 (+0100) Subject: Poc pou 5c X-Git-Tag: V210224_osthus~99 X-Git-Url: http://git.salome-platform.org/gitweb/?a=commitdiff_plain;h=31781c1d082c72002a36809550e13386fd41ea9d;p=tools%2Feficas.git Poc pou 5c --- diff --git a/Poc/cataPoc.py b/Poc/cataPoc.py new file mode 100644 index 00000000..ad05d26f --- /dev/null +++ b/Poc/cataPoc.py @@ -0,0 +1,70 @@ +# -*- coding: utf-8 -*- +# Copyright (C) 2008-2018 EDF R&D +# +# This file is part of SALOME ADAO module +# +# This library is free software; you can redistribute it and/or +# modify it under the terms of the GNU Lesser General Public +# License as published by the Free Software Foundation; either +# version 2.1 of the License. +# +# This library is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public +# License along with this library; if not, write to the Free Software +# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +# +# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com +import os, re +import Accas +from Accas import * +monFichier=os.path.abspath(__file__) + +JdC = JDC_CATA ( + code='Essai' + ) +VERSION_CATALOGUE='V_0' + +step_unit_input = ["inserted_steps", "extracted_steps", ] + + +RodsWorthSetting = PROC ( nom = 'RodsWorthSetting', + fr = "Définition des options d'un calcul de poids de grappe", + version = SIMP (statut='o', typ = 'TXM', defaut ="1.0.0"), + virtual_groups = FACT( max='**', statut='o', + group_name = SIMP(statut='o', typ='TXM'), + value_def = SIMP(statut='o', typ ='TXM',max='**' ), + ), + xenon_feedback = SIMP (statut='o', typ ='TXM', + into=["locked", "equilibrium", ]), + cb = SIMP (statut='o', typ ='TXM', + fr="Traitement de la CB pour les calculs d'efficacité", + into=["upstream_state", "critical", "critical_from_previous_state"]), + + states = SIMP(statut='o', typ = 'TXM', max='**', + fr="Choix des états d'entrée du calcul"), + calcul_type = SIMP (statut='o', typ ='TXM', + fr="Choix du type de calcul de poids de grappe à réaliser", + into = [ "differential_worth", "combination", "integral_worth", ]), + + BIntegral_O=BLOC ( condition = 'calcul_type == "integral_worth"', + Integral_O=SIMP(statut='o', typ= 'TXM', defaut = 'pas compris'), + ), + Integral = FACT( + #classe IntegralSituationsSetting + fr= "Définition de configurations intégrales de poids de grappes", + step_unit = SIMP (statut='o', typ='TXM' , into = step_unit_input, + fr="Unité retenue pour les insertions de grappes"), + config = FACT( max='**', statut='o', + key_config = SIMP(statut='o', typ='TXM'), + value_def = SIMP(statut='o', typ ='R', val_min=0, ), + fr="Definition des configurations de grappes", + ), + ), + +) + + diff --git a/Poc/cataPoc.xsd b/Poc/cataPoc.xsd new file mode 100644 index 00000000..e07e4c8e --- /dev/null +++ b/Poc/cataPoc.xsd @@ -0,0 +1,133 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + {'T_value_def': {'_value_def_config_Integral_RodsWorthSetting': 'T_value_def_1'}} + + + + + diff --git a/Poc/cataPoc_driver.py b/Poc/cataPoc_driver.py new file mode 100644 index 00000000..15061096 --- /dev/null +++ b/Poc/cataPoc_driver.py @@ -0,0 +1,2 @@ +# -*- coding: utf-8 -*- +from raw.cataPoc_driver import * diff --git a/Poc/generateXML.py b/Poc/generateXML.py new file mode 100755 index 00000000..d8fd33dd --- /dev/null +++ b/Poc/generateXML.py @@ -0,0 +1,36 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +# Copyright (C) 2007-2013 EDF R&D +# +# This library is free software; you can redistribute it and/or +# modify it under the terms of the GNU Lesser General Public +# License as published by the Free Software Foundation; either +# version 2.1 of the License. +# +# This library is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public +# License along with this library; if not, write to the Free Software +# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +# +# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com +# +""" + Ce module sert a lancer EFICAS configure pour Meteo +""" +# Modules Python +# Modules Eficas +import prefs +name='prefs_'+prefs.code +__import__(name) + +import sys +import os +sys.path.append(os.path.join(os.path.abspath(os.path.dirname(__file__)),'../..')) + +import prefs +from InterfaceQT4 import eficas_go +eficas_go.genereXML(code=prefs.code) diff --git a/Poc/generateXSD.py b/Poc/generateXSD.py new file mode 100755 index 00000000..ed550619 --- /dev/null +++ b/Poc/generateXSD.py @@ -0,0 +1,36 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +# Copyright (C) 2007-2013 EDF R&D +# +# This library is free software; you can redistribute it and/or +# modify it under the terms of the GNU Lesser General Public +# License as published by the Free Software Foundation; either +# version 2.1 of the License. +# +# This library is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public +# License along with this library; if not, write to the Free Software +# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +# +# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com +# +""" + Ce module sert a lancer EFICAS configure pour Meteo +""" +# Modules Python +# Modules Eficas +import prefs +name='prefs_'+prefs.code +__import__(name) + +import sys +import os +sys.path.append(os.path.join(os.path.abspath(os.path.dirname(__file__)),'../..')) + +import prefs +from InterfaceQT4 import eficas_go +eficas_go.genereXSD(code=prefs.code) diff --git a/Poc/metier.py b/Poc/metier.py new file mode 100644 index 00000000..fa4f1d73 --- /dev/null +++ b/Poc/metier.py @@ -0,0 +1,4 @@ + +def RodsWorthSetting(*args,**kwargs) : + print ('je suis dans RodsWorthSetting') + print ('je peux effectuer un traitement') diff --git a/Poc/pocEssai.comm b/Poc/pocEssai.comm new file mode 100644 index 00000000..8d51bf92 --- /dev/null +++ b/Poc/pocEssai.comm @@ -0,0 +1,14 @@ + +RodsWorthSetting(version='1.0.0', + virtual_groups=_F(group_name='monG1', + value_def=('1','2','3',),), + xenon_feedback='locked', + cb='upstream_state', + states=('s1','s2',), + calcul_type='integral_worth', + Integral_O='pas compris', + Integral=_F(step_unit='inserted_steps', + config=_F(key_config='k1', + value_def=1.0,),),); +#VERSION_CATALOGUE:V_0:FIN VERSION_CATALOGUE +#CHECKSUM:7b6880e43794d8314400196519227b02 -:FIN CHECKSUM \ No newline at end of file diff --git a/Poc/pocEssai.xml b/Poc/pocEssai.xml new file mode 100644 index 00000000..4952391b --- /dev/null +++ b/Poc/pocEssai.xml @@ -0,0 +1,22 @@ + + + + 1.0.0 + + monG1 + 1 2 3 + + locked + upstream_state + s1 s2 + integral_worth + pas compris + + inserted_steps + + k1 + 1.0 + + + + diff --git a/Poc/pocEssaiExecution.py b/Poc/pocEssaiExecution.py new file mode 100644 index 00000000..f6a47efe --- /dev/null +++ b/Poc/pocEssaiExecution.py @@ -0,0 +1,47 @@ +import os, sys +import prefs +name='prefs_'+prefs.code +__import__(name) +from Accas import * +from Noyau.N__F import _F + +print ('___________ Appel sans validation supplementaire ________________') +print ('\n l appel a ete cree par eficas et donc est valide') +from metier import * +RodsWorthSetting(version='1.0.0', + virtual_groups=_F(group_name='monG1', + value_def=('1','2','3',),), + xenon_feedback='locked', + cb='upstream_state', + states=('s1','s2',), + calcul_type='integral_worth', + Integral_O='pas compris', + Integral=_F(step_unit='inserted_steps', + config=_F(key_config='k1', + value_def=1.0,),),); + + + +print ('\n\n') +print ('___________ Appel avec validation supplementaire ________________') +print ('\n l appel a ete cree manuellement') +from InterfaceQT4.eficas_go import validateFonction +RodsWorthSetting=validateFonction(RodsWorthSetting) + +print ('fonction appel valide') +print ('____________________') +RodsWorthSetting(version='1.0.0', + virtual_groups=_F(group_name='monG1', + value_def=('1','2','3',),), + xenon_feedback='locked', + cb='upstream_state', + states=('s1','s2',), + calcul_type='integral_worth', + Integral_O='pas compris', + Integral=_F(step_unit='inserted_steps', + config=_F(key_config='k1', + value_def=1.0,),),); + +print ('fonction appel invalide') +print ('____________________') +RodsWorthSetting(monArgument='je ne passe pas les bons arguments') diff --git a/Poc/prefs.py b/Poc/prefs.py new file mode 100644 index 00000000..540898b5 --- /dev/null +++ b/Poc/prefs.py @@ -0,0 +1,22 @@ +# Copyright (C) 2007-2012 EDF R&D +# +# This library is free software; you can redistribute it and/or +# modify it under the terms of the GNU Lesser General Public +# License as published by the Free Software Foundation; either +# version 2.1 of the License. +# +# This library is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public +# License along with this library; if not, write to the Free Software +# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +# +# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com +# +code="Essai" +import sys, os +if os.path.dirname(os.path.abspath(__file__)) not in sys.path : + sys.path.insert(0,os.path.dirname(os.path.abspath(__file__))) diff --git a/Poc/prefs_Essai.py b/Poc/prefs_Essai.py new file mode 100644 index 00000000..8d1bc00f --- /dev/null +++ b/Poc/prefs_Essai.py @@ -0,0 +1,50 @@ +# -*- coding: utf-8 -*- +# maConfiguration MANAGEMENT OF EDF VERSION +# ====================================================================== +# COPYRIGHT (C) 1991 - 2002 EDF R&D WWW.CODE-ASTER.ORG +# THIS PROGRAM IS FREE SOFTWARE; YOU CAN REDISTRIBUTE IT AND/OR MODIFY +# IT UNDER THE TERMS OF THE GNU GENERAL PUBLIC LICENSE AS PUBLISHED BY +# THE FREE SOFTWARE FOUNDATION; EITHER VERSION 2 OF THE LICENSE, OR +# (AT YOUR OPTION) ANY LATER VERSION. +# +# THIS PROGRAM IS DISTRIBUTED IN THE HOPE THAT IT WILL BE USEFUL, BUT +# WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF +# MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. SEE THE GNU +# GENERAL PUBLIC LICENSE FOR MORE DETAILS. +# +# YOU SHOULD HAVE RECEIVED A COPY OF THE GNU GENERAL PUBLIC LICENSE +# ALONG WITH THIS PROGRAM; IF NOT, WRITE TO EDF R&D CODE_ASTER, +# 1 AVENUE DU GENERAL DE GAULLE, 92141 CLAMART CEDEX, FRANCE. +# +# +# ====================================================================== + +import os,sys +# repIni sert a localiser le fichier editeur.ini +# Obligatoire +repIni=os.path.dirname(os.path.abspath(__file__)) +INSTALLDIR=os.path.join(repIni,'..') +sys.path[:0]=[INSTALLDIR] + + +# lang indique la langue utilisee pour les chaines d'aide : fr ou ang +lang='fr' + +# Codage des strings qui accepte les accents (en remplacement de 'ascii') +encoding='iso-8859-1' + +# +#typeDeCata='XML' +catalogues=( + ('Essai','Poc',os.path.join(repIni,'cataPoc.py'),'python','python'), +) +#nombreDeBoutonParLigne=4 +simpleClic=True +#closeFrameRechercheCommande=True +boutonDsMenuBar=False +#closeArbre=True +afficheListesPliees=False +#withXSD=True +afficheCommandesPliees = False +#dumpXSD=True +#afficheIhm=False diff --git a/Poc/qtEficasEssai.py b/Poc/qtEficasEssai.py new file mode 100755 index 00000000..349334aa --- /dev/null +++ b/Poc/qtEficasEssai.py @@ -0,0 +1,36 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +# Copyright (C) 2007-2013 EDF R&D +# +# This library is free software; you can redistribute it and/or +# modify it under the terms of the GNU Lesser General Public +# License as published by the Free Software Foundation; either +# version 2.1 of the License. +# +# This library is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public +# License along with this library; if not, write to the Free Software +# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +# +# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com +# +""" + Ce module sert a lancer EFICAS configure pour MAP +""" +# Modules Python +# Modules Eficas +import prefs +name='prefs_'+prefs.code +__import__(name) + +import os, sys +sys.path.append(os.path.join(os.path.abspath(os.path.dirname(__file__)),'..')) + +import prefs +from InterfaceQT4 import eficas_go +print (prefs.code) +eficas_go.lanceEficas(code=prefs.code) diff --git a/Poc/raw/__init__.py b/Poc/raw/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/Poc/raw/cataPoc_driver.py b/Poc/raw/cataPoc_driver.py new file mode 100644 index 00000000..2af3ae87 --- /dev/null +++ b/Poc/raw/cataPoc_driver.py @@ -0,0 +1,789 @@ +# ./raw/cataPoc_driver.py +# -*- coding: utf-8 -*- +# PyXB bindings for NM:9c3bd166183fcfc95687f415bcc4a066eb33ac79 +# Generated 2020-11-18 10:41:40.865410 by PyXB version 1.2.5 using Python 3.4.2.final.0 +# Namespace http://chercheurs.edf.com/logiciels/Essai + +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:42cf5b5e-2982-11eb-b63e-cc3d82d871d8') + +# Version of PyXB used to generate the bindings +_PyXBVersion = '1.2.5' +# 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/Essai', 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/Essai}T_version +class T_version (pyxb.binding.datatypes.string): + + """An atomic simple type.""" + + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'T_version') + _XSDLocation = pyxb.utils.utility.Location('/home/A96028/QT5GitEficasTravail/eficas/Poc/cataPoc.xsd', 7, 1) + _Documentation = None +T_version._InitializeFacetMap() +Namespace.addCategoryObject('typeBinding', 'T_version', T_version) +_module_typeBindings.T_version = T_version + +# Atomic simple type: {http://chercheurs.edf.com/logiciels/Essai}T_group_name +class T_group_name (pyxb.binding.datatypes.string): + + """An atomic simple type.""" + + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'T_group_name') + _XSDLocation = pyxb.utils.utility.Location('/home/A96028/QT5GitEficasTravail/eficas/Poc/cataPoc.xsd', 11, 1) + _Documentation = None +T_group_name._InitializeFacetMap() +Namespace.addCategoryObject('typeBinding', 'T_group_name', T_group_name) +_module_typeBindings.T_group_name = T_group_name + +# Atomic simple type: [anonymous] +class STD_ANON (pyxb.binding.datatypes.string): + + """An atomic simple type.""" + + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('/home/A96028/QT5GitEficasTravail/eficas/Poc/cataPoc.xsd', 19, 5) + _Documentation = None +STD_ANON._InitializeFacetMap() +_module_typeBindings.STD_ANON = STD_ANON + +# Atomic simple type: {http://chercheurs.edf.com/logiciels/Essai}T_xenon_feedback +class T_xenon_feedback (pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration_mixin): + + """An atomic simple type.""" + + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'T_xenon_feedback') + _XSDLocation = pyxb.utils.utility.Location('/home/A96028/QT5GitEficasTravail/eficas/Poc/cataPoc.xsd', 27, 1) + _Documentation = None +T_xenon_feedback._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=T_xenon_feedback, enum_prefix=None) +T_xenon_feedback.locked = T_xenon_feedback._CF_enumeration.addEnumeration(unicode_value='locked', tag='locked') +T_xenon_feedback.equilibrium = T_xenon_feedback._CF_enumeration.addEnumeration(unicode_value='equilibrium', tag='equilibrium') +T_xenon_feedback._InitializeFacetMap(T_xenon_feedback._CF_enumeration) +Namespace.addCategoryObject('typeBinding', 'T_xenon_feedback', T_xenon_feedback) +_module_typeBindings.T_xenon_feedback = T_xenon_feedback + +# Atomic simple type: {http://chercheurs.edf.com/logiciels/Essai}T_cb +class T_cb (pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration_mixin): + + """An atomic simple type.""" + + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'T_cb') + _XSDLocation = pyxb.utils.utility.Location('/home/A96028/QT5GitEficasTravail/eficas/Poc/cataPoc.xsd', 33, 1) + _Documentation = None +T_cb._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=T_cb, enum_prefix=None) +T_cb.upstream_state = T_cb._CF_enumeration.addEnumeration(unicode_value='upstream_state', tag='upstream_state') +T_cb.critical = T_cb._CF_enumeration.addEnumeration(unicode_value='critical', tag='critical') +T_cb.critical_from_previous_state = T_cb._CF_enumeration.addEnumeration(unicode_value='critical_from_previous_state', tag='critical_from_previous_state') +T_cb._InitializeFacetMap(T_cb._CF_enumeration) +Namespace.addCategoryObject('typeBinding', 'T_cb', T_cb) +_module_typeBindings.T_cb = T_cb + +# Atomic simple type: [anonymous] +class STD_ANON_ (pyxb.binding.datatypes.string): + + """An atomic simple type.""" + + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('/home/A96028/QT5GitEficasTravail/eficas/Poc/cataPoc.xsd', 44, 5) + _Documentation = None +STD_ANON_._InitializeFacetMap() +_module_typeBindings.STD_ANON_ = STD_ANON_ + +# Atomic simple type: {http://chercheurs.edf.com/logiciels/Essai}T_calcul_type +class T_calcul_type (pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration_mixin): + + """An atomic simple type.""" + + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'T_calcul_type') + _XSDLocation = pyxb.utils.utility.Location('/home/A96028/QT5GitEficasTravail/eficas/Poc/cataPoc.xsd', 52, 1) + _Documentation = None +T_calcul_type._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=T_calcul_type, enum_prefix=None) +T_calcul_type.differential_worth = T_calcul_type._CF_enumeration.addEnumeration(unicode_value='differential_worth', tag='differential_worth') +T_calcul_type.combination = T_calcul_type._CF_enumeration.addEnumeration(unicode_value='combination', tag='combination') +T_calcul_type.integral_worth = T_calcul_type._CF_enumeration.addEnumeration(unicode_value='integral_worth', tag='integral_worth') +T_calcul_type._InitializeFacetMap(T_calcul_type._CF_enumeration) +Namespace.addCategoryObject('typeBinding', 'T_calcul_type', T_calcul_type) +_module_typeBindings.T_calcul_type = T_calcul_type + +# Atomic simple type: {http://chercheurs.edf.com/logiciels/Essai}T_Integral_O +class T_Integral_O (pyxb.binding.datatypes.string): + + """An atomic simple type.""" + + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'T_Integral_O') + _XSDLocation = pyxb.utils.utility.Location('/home/A96028/QT5GitEficasTravail/eficas/Poc/cataPoc.xsd', 59, 1) + _Documentation = None +T_Integral_O._InitializeFacetMap() +Namespace.addCategoryObject('typeBinding', 'T_Integral_O', T_Integral_O) +_module_typeBindings.T_Integral_O = T_Integral_O + +# Atomic simple type: {http://chercheurs.edf.com/logiciels/Essai}T_step_unit +class T_step_unit (pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration_mixin): + + """An atomic simple type.""" + + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'T_step_unit') + _XSDLocation = pyxb.utils.utility.Location('/home/A96028/QT5GitEficasTravail/eficas/Poc/cataPoc.xsd', 63, 1) + _Documentation = None +T_step_unit._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=T_step_unit, enum_prefix=None) +T_step_unit.inserted_steps = T_step_unit._CF_enumeration.addEnumeration(unicode_value='inserted_steps', tag='inserted_steps') +T_step_unit.extracted_steps = T_step_unit._CF_enumeration.addEnumeration(unicode_value='extracted_steps', tag='extracted_steps') +T_step_unit._InitializeFacetMap(T_step_unit._CF_enumeration) +Namespace.addCategoryObject('typeBinding', 'T_step_unit', T_step_unit) +_module_typeBindings.T_step_unit = T_step_unit + +# Atomic simple type: {http://chercheurs.edf.com/logiciels/Essai}T_key_config +class T_key_config (pyxb.binding.datatypes.string): + + """An atomic simple type.""" + + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'T_key_config') + _XSDLocation = pyxb.utils.utility.Location('/home/A96028/QT5GitEficasTravail/eficas/Poc/cataPoc.xsd', 69, 1) + _Documentation = None +T_key_config._InitializeFacetMap() +Namespace.addCategoryObject('typeBinding', 'T_key_config', T_key_config) +_module_typeBindings.T_key_config = T_key_config + +# Atomic simple type: {http://chercheurs.edf.com/logiciels/Essai}T_value_def_1 +class T_value_def_1 (pyxb.binding.datatypes.float): + + """An atomic simple type.""" + + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'T_value_def_1') + _XSDLocation = pyxb.utils.utility.Location('/home/A96028/QT5GitEficasTravail/eficas/Poc/cataPoc.xsd', 73, 1) + _Documentation = None +T_value_def_1._CF_minInclusive = pyxb.binding.facets.CF_minInclusive(value_datatype=T_value_def_1, value=pyxb.binding.datatypes.float(0.0)) +T_value_def_1._InitializeFacetMap(T_value_def_1._CF_minInclusive) +Namespace.addCategoryObject('typeBinding', 'T_value_def_1', T_value_def_1) +_module_typeBindings.T_value_def_1 = T_value_def_1 + +# Atomic simple type: {http://chercheurs.edf.com/logiciels/Essai}PNEFdico_Essai +class PNEFdico_Essai (pyxb.binding.datatypes.string): + + """{'T_value_def': {'_value_def_config_Integral_RodsWorthSetting': 'T_value_def_1'}} + """ + + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'PNEFdico_Essai') + _XSDLocation = pyxb.utils.utility.Location('/home/A96028/QT5GitEficasTravail/eficas/Poc/cataPoc.xsd', 126, 1) + _Documentation = "{'T_value_def': {'_value_def_config_Integral_RodsWorthSetting': 'T_value_def_1'}}\n\t\t" +PNEFdico_Essai._InitializeFacetMap() +Namespace.addCategoryObject('typeBinding', 'PNEFdico_Essai', PNEFdico_Essai) +_module_typeBindings.PNEFdico_Essai = PNEFdico_Essai + +# List simple type: [anonymous] +# superclasses pyxb.binding.datatypes.anySimpleType +class STD_ANON_2 (pyxb.binding.basis.STD_list): + + """Simple type that is a list of STD_ANON.""" + + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('/home/A96028/QT5GitEficasTravail/eficas/Poc/cataPoc.xsd', 17, 3) + _Documentation = None + + _ItemType = STD_ANON +STD_ANON_2._InitializeFacetMap() +_module_typeBindings.STD_ANON_2 = STD_ANON_2 + +# List simple type: [anonymous] +# superclasses pyxb.binding.datatypes.anySimpleType +class STD_ANON_3 (pyxb.binding.basis.STD_list): + + """Simple type that is a list of STD_ANON_.""" + + _ExpandedName = None + _XSDLocation = pyxb.utils.utility.Location('/home/A96028/QT5GitEficasTravail/eficas/Poc/cataPoc.xsd', 42, 3) + _Documentation = None + + _ItemType = STD_ANON_ +STD_ANON_3._InitializeFacetMap() +_module_typeBindings.STD_ANON_3 = STD_ANON_3 + +# List simple type: {http://chercheurs.edf.com/logiciels/Essai}T_value_def +# superclasses STD_ANON_2 +class T_value_def (pyxb.binding.basis.STD_list): + + """Simple type that is a list of STD_ANON.""" + + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'T_value_def') + _XSDLocation = pyxb.utils.utility.Location('/home/A96028/QT5GitEficasTravail/eficas/Poc/cataPoc.xsd', 15, 1) + _Documentation = None + + _ItemType = STD_ANON +T_value_def._InitializeFacetMap() +Namespace.addCategoryObject('typeBinding', 'T_value_def', T_value_def) +_module_typeBindings.T_value_def = T_value_def + +# List simple type: {http://chercheurs.edf.com/logiciels/Essai}T_states +# superclasses STD_ANON_3 +class T_states (pyxb.binding.basis.STD_list): + + """Simple type that is a list of STD_ANON_.""" + + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'T_states') + _XSDLocation = pyxb.utils.utility.Location('/home/A96028/QT5GitEficasTravail/eficas/Poc/cataPoc.xsd', 40, 1) + _Documentation = None + + _ItemType = STD_ANON_ +T_states._InitializeFacetMap() +Namespace.addCategoryObject('typeBinding', 'T_states', T_states) +_module_typeBindings.T_states = T_states + +# Complex type {http://chercheurs.edf.com/logiciels/Essai}T_virtual_groups with content type ELEMENT_ONLY +class T_virtual_groups (pyxb.binding.basis.complexTypeDefinition): + """Complex type {http://chercheurs.edf.com/logiciels/Essai}T_virtual_groups with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'T_virtual_groups') + _XSDLocation = pyxb.utils.utility.Location('/home/A96028/QT5GitEficasTravail/eficas/Poc/cataPoc.xsd', 78, 1) + _ElementMap = {} + _AttributeMap = {} + # Base type is pyxb.binding.datatypes.anyType + + # Element {http://chercheurs.edf.com/logiciels/Essai}group_name uses Python identifier group_name + __group_name = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'group_name'), 'group_name', '__httpchercheurs_edf_comlogicielsEssai_T_virtual_groups_httpchercheurs_edf_comlogicielsEssaigroup_name', False, pyxb.utils.utility.Location('/home/A96028/QT5GitEficasTravail/eficas/Poc/cataPoc.xsd', 80, 3), ) + + + group_name = property(__group_name.value, __group_name.set, None, None) + + + # Element {http://chercheurs.edf.com/logiciels/Essai}value_def uses Python identifier value_def + __value_def = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'value_def'), 'value_def', '__httpchercheurs_edf_comlogicielsEssai_T_virtual_groups_httpchercheurs_edf_comlogicielsEssaivalue_def', False, pyxb.utils.utility.Location('/home/A96028/QT5GitEficasTravail/eficas/Poc/cataPoc.xsd', 81, 3), ) + + + value_def = property(__value_def.value, __value_def.set, None, None) + + _ElementMap.update({ + __group_name.name() : __group_name, + __value_def.name() : __value_def + }) + _AttributeMap.update({ + + }) +_module_typeBindings.T_virtual_groups = T_virtual_groups +Namespace.addCategoryObject('typeBinding', 'T_virtual_groups', T_virtual_groups) + + +# Complex type {http://chercheurs.edf.com/logiciels/Essai}T_config with content type ELEMENT_ONLY +class T_config (pyxb.binding.basis.complexTypeDefinition): + """Complex type {http://chercheurs.edf.com/logiciels/Essai}T_config with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'T_config') + _XSDLocation = pyxb.utils.utility.Location('/home/A96028/QT5GitEficasTravail/eficas/Poc/cataPoc.xsd', 89, 1) + _ElementMap = {} + _AttributeMap = {} + # Base type is pyxb.binding.datatypes.anyType + + # Element {http://chercheurs.edf.com/logiciels/Essai}key_config uses Python identifier key_config + __key_config = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'key_config'), 'key_config', '__httpchercheurs_edf_comlogicielsEssai_T_config_httpchercheurs_edf_comlogicielsEssaikey_config', False, pyxb.utils.utility.Location('/home/A96028/QT5GitEficasTravail/eficas/Poc/cataPoc.xsd', 91, 3), ) + + + key_config = property(__key_config.value, __key_config.set, None, None) + + + # Element {http://chercheurs.edf.com/logiciels/Essai}value_def uses Python identifier value_def + __value_def = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'value_def'), 'value_def', '__httpchercheurs_edf_comlogicielsEssai_T_config_httpchercheurs_edf_comlogicielsEssaivalue_def', False, pyxb.utils.utility.Location('/home/A96028/QT5GitEficasTravail/eficas/Poc/cataPoc.xsd', 92, 3), ) + + + value_def = property(__value_def.value, __value_def.set, None, None) + + _ElementMap.update({ + __key_config.name() : __key_config, + __value_def.name() : __value_def + }) + _AttributeMap.update({ + + }) +_module_typeBindings.T_config = T_config +Namespace.addCategoryObject('typeBinding', 'T_config', T_config) + + +# Complex type {http://chercheurs.edf.com/logiciels/Essai}T_Integral with content type ELEMENT_ONLY +class T_Integral (pyxb.binding.basis.complexTypeDefinition): + """Complex type {http://chercheurs.edf.com/logiciels/Essai}T_Integral with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'T_Integral') + _XSDLocation = pyxb.utils.utility.Location('/home/A96028/QT5GitEficasTravail/eficas/Poc/cataPoc.xsd', 95, 1) + _ElementMap = {} + _AttributeMap = {} + # Base type is pyxb.binding.datatypes.anyType + + # Element {http://chercheurs.edf.com/logiciels/Essai}step_unit uses Python identifier step_unit + __step_unit = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'step_unit'), 'step_unit', '__httpchercheurs_edf_comlogicielsEssai_T_Integral_httpchercheurs_edf_comlogicielsEssaistep_unit', False, pyxb.utils.utility.Location('/home/A96028/QT5GitEficasTravail/eficas/Poc/cataPoc.xsd', 97, 3), ) + + + step_unit = property(__step_unit.value, __step_unit.set, None, None) + + + # Element {http://chercheurs.edf.com/logiciels/Essai}config uses Python identifier config + __config = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'config'), 'config', '__httpchercheurs_edf_comlogicielsEssai_T_Integral_httpchercheurs_edf_comlogicielsEssaiconfig', True, pyxb.utils.utility.Location('/home/A96028/QT5GitEficasTravail/eficas/Poc/cataPoc.xsd', 98, 3), ) + + + config = property(__config.value, __config.set, None, None) + + _ElementMap.update({ + __step_unit.name() : __step_unit, + __config.name() : __config + }) + _AttributeMap.update({ + + }) +_module_typeBindings.T_Integral = T_Integral +Namespace.addCategoryObject('typeBinding', 'T_Integral', T_Integral) + + +# Complex type {http://chercheurs.edf.com/logiciels/Essai}T_step_Essai with content type EMPTY +class T_step_Essai (pyxb.binding.basis.complexTypeDefinition): + """Complex type {http://chercheurs.edf.com/logiciels/Essai}T_step_Essai with content type EMPTY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY + _Abstract = True + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'T_step_Essai') + _XSDLocation = pyxb.utils.utility.Location('/home/A96028/QT5GitEficasTravail/eficas/Poc/cataPoc.xsd', 118, 1) + _ElementMap = {} + _AttributeMap = {} + # Base type is pyxb.binding.datatypes.anyType + _ElementMap.update({ + + }) + _AttributeMap.update({ + + }) +_module_typeBindings.T_step_Essai = T_step_Essai +Namespace.addCategoryObject('typeBinding', 'T_step_Essai', T_step_Essai) + + +# Complex type {http://chercheurs.edf.com/logiciels/Essai}T_Essai with content type ELEMENT_ONLY +class T_Essai (pyxb.binding.basis.complexTypeDefinition): + """Complex type {http://chercheurs.edf.com/logiciels/Essai}T_Essai with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'T_Essai') + _XSDLocation = pyxb.utils.utility.Location('/home/A96028/QT5GitEficasTravail/eficas/Poc/cataPoc.xsd', 121, 2) + _ElementMap = {} + _AttributeMap = {} + # Base type is pyxb.binding.datatypes.anyType + + # Element {http://chercheurs.edf.com/logiciels/Essai}step_Essai uses Python identifier step_Essai + __step_Essai = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'step_Essai'), 'step_Essai', '__httpchercheurs_edf_comlogicielsEssai_T_Essai_httpchercheurs_edf_comlogicielsEssaistep_Essai', True, pyxb.utils.utility.Location('/home/A96028/QT5GitEficasTravail/eficas/Poc/cataPoc.xsd', 119, 1), ) + + + step_Essai = property(__step_Essai.value, __step_Essai.set, None, None) + + _ElementMap.update({ + __step_Essai.name() : __step_Essai + }) + _AttributeMap.update({ + + }) +_module_typeBindings.T_Essai = T_Essai +Namespace.addCategoryObject('typeBinding', 'T_Essai', T_Essai) + + +# Complex type {http://chercheurs.edf.com/logiciels/Essai}T_RodsWorthSetting with content type ELEMENT_ONLY +class T_RodsWorthSetting (T_step_Essai): + """Complex type {http://chercheurs.edf.com/logiciels/Essai}T_RodsWorthSetting with content type ELEMENT_ONLY""" + _TypeDefinition = None + _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY + _Abstract = False + _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'T_RodsWorthSetting') + _XSDLocation = pyxb.utils.utility.Location('/home/A96028/QT5GitEficasTravail/eficas/Poc/cataPoc.xsd', 101, 1) + _ElementMap = T_step_Essai._ElementMap.copy() + _AttributeMap = T_step_Essai._AttributeMap.copy() + # Base type is T_step_Essai + + # Element {http://chercheurs.edf.com/logiciels/Essai}Integral_O uses Python identifier Integral_O + __Integral_O = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'Integral_O'), 'Integral_O', '__httpchercheurs_edf_comlogicielsEssai_T_RodsWorthSetting_httpchercheurs_edf_comlogicielsEssaiIntegral_O', False, pyxb.utils.utility.Location('/home/A96028/QT5GitEficasTravail/eficas/Poc/cataPoc.xsd', 86, 3), ) + + + Integral_O = property(__Integral_O.value, __Integral_O.set, None, None) + + + # Element {http://chercheurs.edf.com/logiciels/Essai}version uses Python identifier version + __version = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'version'), 'version', '__httpchercheurs_edf_comlogicielsEssai_T_RodsWorthSetting_httpchercheurs_edf_comlogicielsEssaiversion', False, pyxb.utils.utility.Location('/home/A96028/QT5GitEficasTravail/eficas/Poc/cataPoc.xsd', 105, 3), ) + + + version = property(__version.value, __version.set, None, None) + + + # Element {http://chercheurs.edf.com/logiciels/Essai}virtual_groups uses Python identifier virtual_groups + __virtual_groups = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'virtual_groups'), 'virtual_groups', '__httpchercheurs_edf_comlogicielsEssai_T_RodsWorthSetting_httpchercheurs_edf_comlogicielsEssaivirtual_groups', True, pyxb.utils.utility.Location('/home/A96028/QT5GitEficasTravail/eficas/Poc/cataPoc.xsd', 106, 3), ) + + + virtual_groups = property(__virtual_groups.value, __virtual_groups.set, None, None) + + + # Element {http://chercheurs.edf.com/logiciels/Essai}xenon_feedback uses Python identifier xenon_feedback + __xenon_feedback = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'xenon_feedback'), 'xenon_feedback', '__httpchercheurs_edf_comlogicielsEssai_T_RodsWorthSetting_httpchercheurs_edf_comlogicielsEssaixenon_feedback', False, pyxb.utils.utility.Location('/home/A96028/QT5GitEficasTravail/eficas/Poc/cataPoc.xsd', 107, 3), ) + + + xenon_feedback = property(__xenon_feedback.value, __xenon_feedback.set, None, None) + + + # Element {http://chercheurs.edf.com/logiciels/Essai}cb uses Python identifier cb + __cb = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'cb'), 'cb', '__httpchercheurs_edf_comlogicielsEssai_T_RodsWorthSetting_httpchercheurs_edf_comlogicielsEssaicb', False, pyxb.utils.utility.Location('/home/A96028/QT5GitEficasTravail/eficas/Poc/cataPoc.xsd', 108, 3), ) + + + cb = property(__cb.value, __cb.set, None, None) + + + # Element {http://chercheurs.edf.com/logiciels/Essai}states uses Python identifier states + __states = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'states'), 'states', '__httpchercheurs_edf_comlogicielsEssai_T_RodsWorthSetting_httpchercheurs_edf_comlogicielsEssaistates', False, pyxb.utils.utility.Location('/home/A96028/QT5GitEficasTravail/eficas/Poc/cataPoc.xsd', 109, 3), ) + + + states = property(__states.value, __states.set, None, None) + + + # Element {http://chercheurs.edf.com/logiciels/Essai}calcul_type uses Python identifier calcul_type + __calcul_type = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'calcul_type'), 'calcul_type', '__httpchercheurs_edf_comlogicielsEssai_T_RodsWorthSetting_httpchercheurs_edf_comlogicielsEssaicalcul_type', False, pyxb.utils.utility.Location('/home/A96028/QT5GitEficasTravail/eficas/Poc/cataPoc.xsd', 110, 3), ) + + + calcul_type = property(__calcul_type.value, __calcul_type.set, None, None) + + + # Element {http://chercheurs.edf.com/logiciels/Essai}Integral uses Python identifier Integral + __Integral = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'Integral'), 'Integral', '__httpchercheurs_edf_comlogicielsEssai_T_RodsWorthSetting_httpchercheurs_edf_comlogicielsEssaiIntegral', False, pyxb.utils.utility.Location('/home/A96028/QT5GitEficasTravail/eficas/Poc/cataPoc.xsd', 112, 3), ) + + + Integral = property(__Integral.value, __Integral.set, None, None) + + _ElementMap.update({ + __Integral_O.name() : __Integral_O, + __version.name() : __version, + __virtual_groups.name() : __virtual_groups, + __xenon_feedback.name() : __xenon_feedback, + __cb.name() : __cb, + __states.name() : __states, + __calcul_type.name() : __calcul_type, + __Integral.name() : __Integral + }) + _AttributeMap.update({ + + }) +_module_typeBindings.T_RodsWorthSetting = T_RodsWorthSetting +Namespace.addCategoryObject('typeBinding', 'T_RodsWorthSetting', T_RodsWorthSetting) + + +step_Essai = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'step_Essai'), T_step_Essai, location=pyxb.utils.utility.Location('/home/A96028/QT5GitEficasTravail/eficas/Poc/cataPoc.xsd', 119, 1)) +Namespace.addCategoryObject('elementBinding', step_Essai.name().localName(), step_Essai) + +Essai = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Essai'), T_Essai, location=pyxb.utils.utility.Location('/home/A96028/QT5GitEficasTravail/eficas/Poc/cataPoc.xsd', 120, 1)) +Namespace.addCategoryObject('elementBinding', Essai.name().localName(), Essai) + +RodsWorthSetting = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'RodsWorthSetting'), T_RodsWorthSetting, location=pyxb.utils.utility.Location('/home/A96028/QT5GitEficasTravail/eficas/Poc/cataPoc.xsd', 117, 1)) +Namespace.addCategoryObject('elementBinding', RodsWorthSetting.name().localName(), RodsWorthSetting) + + + +T_virtual_groups._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'group_name'), T_group_name, scope=T_virtual_groups, location=pyxb.utils.utility.Location('/home/A96028/QT5GitEficasTravail/eficas/Poc/cataPoc.xsd', 80, 3))) + +T_virtual_groups._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'value_def'), T_value_def, scope=T_virtual_groups, location=pyxb.utils.utility.Location('/home/A96028/QT5GitEficasTravail/eficas/Poc/cataPoc.xsd', 81, 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_virtual_groups._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'group_name')), pyxb.utils.utility.Location('/home/A96028/QT5GitEficasTravail/eficas/Poc/cataPoc.xsd', 80, 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_virtual_groups._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'value_def')), pyxb.utils.utility.Location('/home/A96028/QT5GitEficasTravail/eficas/Poc/cataPoc.xsd', 81, 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_virtual_groups._Automaton = _BuildAutomaton() + + + + +T_config._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'key_config'), T_key_config, scope=T_config, location=pyxb.utils.utility.Location('/home/A96028/QT5GitEficasTravail/eficas/Poc/cataPoc.xsd', 91, 3))) + +T_config._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'value_def'), T_value_def_1, scope=T_config, location=pyxb.utils.utility.Location('/home/A96028/QT5GitEficasTravail/eficas/Poc/cataPoc.xsd', 92, 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_config._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'key_config')), pyxb.utils.utility.Location('/home/A96028/QT5GitEficasTravail/eficas/Poc/cataPoc.xsd', 91, 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_config._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'value_def')), pyxb.utils.utility.Location('/home/A96028/QT5GitEficasTravail/eficas/Poc/cataPoc.xsd', 92, 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_config._Automaton = _BuildAutomaton_() + + + + +T_Integral._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'step_unit'), T_step_unit, scope=T_Integral, location=pyxb.utils.utility.Location('/home/A96028/QT5GitEficasTravail/eficas/Poc/cataPoc.xsd', 97, 3))) + +T_Integral._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'config'), T_config, scope=T_Integral, location=pyxb.utils.utility.Location('/home/A96028/QT5GitEficasTravail/eficas/Poc/cataPoc.xsd', 98, 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=None, metadata=pyxb.utils.utility.Location('/home/A96028/QT5GitEficasTravail/eficas/Poc/cataPoc.xsd', 98, 3)) + counters.add(cc_0) + states = [] + final_update = set() + symbol = pyxb.binding.content.ElementUse(T_Integral._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'step_unit')), pyxb.utils.utility.Location('/home/A96028/QT5GitEficasTravail/eficas/Poc/cataPoc.xsd', 97, 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_Integral._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'config')), pyxb.utils.utility.Location('/home/A96028/QT5GitEficasTravail/eficas/Poc/cataPoc.xsd', 98, 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 = [] + transitions.append(fac.Transition(st_1, [ + fac.UpdateInstruction(cc_0, True) ])) + st_1._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +T_Integral._Automaton = _BuildAutomaton_2() + + + + +T_Essai._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'step_Essai'), T_step_Essai, scope=T_Essai, location=pyxb.utils.utility.Location('/home/A96028/QT5GitEficasTravail/eficas/Poc/cataPoc.xsd', 119, 1))) + +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/Poc/cataPoc.xsd', 122, 4)) + counters.add(cc_0) + cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('/home/A96028/QT5GitEficasTravail/eficas/Poc/cataPoc.xsd', 123, 3)) + counters.add(cc_1) + states = [] + final_update = set() + final_update.add(fac.UpdateInstruction(cc_0, False)) + final_update.add(fac.UpdateInstruction(cc_1, False)) + symbol = pyxb.binding.content.ElementUse(T_Essai._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'step_Essai')), pyxb.utils.utility.Location('/home/A96028/QT5GitEficasTravail/eficas/Poc/cataPoc.xsd', 123, 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), + fac.UpdateInstruction(cc_1, False) ])) + transitions.append(fac.Transition(st_0, [ + fac.UpdateInstruction(cc_1, True) ])) + st_0._set_transitionSet(transitions) + return fac.Automaton(states, counters, True, containing_state=None) +T_Essai._Automaton = _BuildAutomaton_3() + + + + +T_RodsWorthSetting._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Integral_O'), T_Integral_O, scope=T_RodsWorthSetting, location=pyxb.utils.utility.Location('/home/A96028/QT5GitEficasTravail/eficas/Poc/cataPoc.xsd', 86, 3), unicode_default='pas compris')) + +T_RodsWorthSetting._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'version'), T_version, scope=T_RodsWorthSetting, location=pyxb.utils.utility.Location('/home/A96028/QT5GitEficasTravail/eficas/Poc/cataPoc.xsd', 105, 3), unicode_default='1.0.0')) + +T_RodsWorthSetting._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'virtual_groups'), T_virtual_groups, scope=T_RodsWorthSetting, location=pyxb.utils.utility.Location('/home/A96028/QT5GitEficasTravail/eficas/Poc/cataPoc.xsd', 106, 3))) + +T_RodsWorthSetting._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'xenon_feedback'), T_xenon_feedback, scope=T_RodsWorthSetting, location=pyxb.utils.utility.Location('/home/A96028/QT5GitEficasTravail/eficas/Poc/cataPoc.xsd', 107, 3))) + +T_RodsWorthSetting._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'cb'), T_cb, scope=T_RodsWorthSetting, location=pyxb.utils.utility.Location('/home/A96028/QT5GitEficasTravail/eficas/Poc/cataPoc.xsd', 108, 3))) + +T_RodsWorthSetting._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'states'), T_states, scope=T_RodsWorthSetting, location=pyxb.utils.utility.Location('/home/A96028/QT5GitEficasTravail/eficas/Poc/cataPoc.xsd', 109, 3))) + +T_RodsWorthSetting._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'calcul_type'), T_calcul_type, scope=T_RodsWorthSetting, location=pyxb.utils.utility.Location('/home/A96028/QT5GitEficasTravail/eficas/Poc/cataPoc.xsd', 110, 3))) + +T_RodsWorthSetting._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'Integral'), T_Integral, scope=T_RodsWorthSetting, location=pyxb.utils.utility.Location('/home/A96028/QT5GitEficasTravail/eficas/Poc/cataPoc.xsd', 112, 3))) + +def _BuildAutomaton_4 (): + # Remove this helper function from the namespace after it is invoked + global _BuildAutomaton_4 + del _BuildAutomaton_4 + 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/Poc/cataPoc.xsd', 106, 3)) + counters.add(cc_0) + cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('/home/A96028/QT5GitEficasTravail/eficas/Poc/cataPoc.xsd', 111, 3)) + counters.add(cc_1) + cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('/home/A96028/QT5GitEficasTravail/eficas/Poc/cataPoc.xsd', 112, 3)) + counters.add(cc_2) + states = [] + final_update = None + symbol = pyxb.binding.content.ElementUse(T_RodsWorthSetting._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'version')), pyxb.utils.utility.Location('/home/A96028/QT5GitEficasTravail/eficas/Poc/cataPoc.xsd', 105, 3)) + st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False) + states.append(st_0) + final_update = None + symbol = pyxb.binding.content.ElementUse(T_RodsWorthSetting._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'virtual_groups')), pyxb.utils.utility.Location('/home/A96028/QT5GitEficasTravail/eficas/Poc/cataPoc.xsd', 106, 3)) + st_1 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_1) + final_update = None + symbol = pyxb.binding.content.ElementUse(T_RodsWorthSetting._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'xenon_feedback')), pyxb.utils.utility.Location('/home/A96028/QT5GitEficasTravail/eficas/Poc/cataPoc.xsd', 107, 3)) + st_2 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_2) + final_update = None + symbol = pyxb.binding.content.ElementUse(T_RodsWorthSetting._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'cb')), pyxb.utils.utility.Location('/home/A96028/QT5GitEficasTravail/eficas/Poc/cataPoc.xsd', 108, 3)) + st_3 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_3) + final_update = None + symbol = pyxb.binding.content.ElementUse(T_RodsWorthSetting._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'states')), pyxb.utils.utility.Location('/home/A96028/QT5GitEficasTravail/eficas/Poc/cataPoc.xsd', 109, 3)) + st_4 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_4) + final_update = set() + symbol = pyxb.binding.content.ElementUse(T_RodsWorthSetting._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'calcul_type')), pyxb.utils.utility.Location('/home/A96028/QT5GitEficasTravail/eficas/Poc/cataPoc.xsd', 110, 3)) + st_5 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_5) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_1, False)) + symbol = pyxb.binding.content.ElementUse(T_RodsWorthSetting._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Integral_O')), pyxb.utils.utility.Location('/home/A96028/QT5GitEficasTravail/eficas/Poc/cataPoc.xsd', 86, 3)) + st_6 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_6) + final_update = set() + final_update.add(fac.UpdateInstruction(cc_2, False)) + symbol = pyxb.binding.content.ElementUse(T_RodsWorthSetting._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'Integral')), pyxb.utils.utility.Location('/home/A96028/QT5GitEficasTravail/eficas/Poc/cataPoc.xsd', 112, 3)) + st_7 = fac.State(symbol, is_initial=False, final_update=final_update, is_unordered_catenation=False) + states.append(st_7) + 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_3, [ + ])) + st_2._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_4, [ + ])) + st_3._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_5, [ + ])) + st_4._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_6, [ + ])) + transitions.append(fac.Transition(st_7, [ + ])) + st_5._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_6, [ + fac.UpdateInstruction(cc_1, True) ])) + transitions.append(fac.Transition(st_7, [ + fac.UpdateInstruction(cc_1, False) ])) + st_6._set_transitionSet(transitions) + transitions = [] + transitions.append(fac.Transition(st_7, [ + fac.UpdateInstruction(cc_2, True) ])) + st_7._set_transitionSet(transitions) + return fac.Automaton(states, counters, False, containing_state=None) +T_RodsWorthSetting._Automaton = _BuildAutomaton_4() + + +RodsWorthSetting._setSubstitutionGroup(step_Essai) diff --git a/Poc/readExemple.py b/Poc/readExemple.py new file mode 100644 index 00000000..c28e2147 --- /dev/null +++ b/Poc/readExemple.py @@ -0,0 +1,12 @@ +from cataPoc_driver import * + +pyxb.GlobalValidationConfig._setContentInfluencesGeneration(pyxb.GlobalValidationConfig.ALWAYS) +pyxb.GlobalValidationConfig._setInvalidElementInContent(pyxb.GlobalValidationConfig.RAISE_EXCEPTION) +pyxb.GlobalValidationConfig._setOrphanElementInContent(pyxb.GlobalValidationConfig.RAISE_EXCEPTION) + + +jdd = CreateFromDocument(open('toto.xml').read()) +#print (jdd.toDOM().toprettyxml()) +print ('voici la valeur de xenon_feedback', jdd.step_Essai[0].xenon_feedback, '\n') + +