Source code for hbp_nrp_commons.generated.exp_conf_api_gen

# ./exp_conf_api_gen.py
# -*- coding: utf-8 -*-
# PyXB bindings for NM:e455c55bde4037492ee2ed5fe3b59ed8c44bb0d3
# Generated 2023-06-11 22:34:46.068383 by PyXB version 1.2.6 using Python 3.8.10.final.0
# Namespace http://schemas.humanbrainproject.eu/SP10/2014/ExDConfig

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:67384aea-0897-11ee-9e7d-0242ac110002')

# 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://schemas.humanbrainproject.eu/SP10/2014/ExDConfig', 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://schemas.humanbrainproject.eu/SP10/2014/ExDConfig}ThumbnailFile
class ThumbnailFile (pyxb.binding.datatypes.string):

    """This type denotes a path to an image file. The supported extensions are .png, .jpg, .jpeg and .gif. The file name must not contain whitespaces."""

    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'ThumbnailFile')
    _XSDLocation = pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 13, 2)
    _Documentation = 'This type denotes a path to an image file. The supported extensions are .png, .jpg, .jpeg and .gif. The file name must not contain whitespaces.'
ThumbnailFile._CF_pattern = pyxb.binding.facets.CF_pattern()
ThumbnailFile._CF_pattern.addPattern(pattern='[a-zA-Z0-9\\._\\-/]*\\.(png|gif|jp[e]?g)')
ThumbnailFile._InitializeFacetMap(ThumbnailFile._CF_pattern)
Namespace.addCategoryObject('typeBinding', 'ThumbnailFile', ThumbnailFile)
_module_typeBindings.ThumbnailFile = ThumbnailFile

# Atomic simple type: {http://schemas.humanbrainproject.eu/SP10/2014/ExDConfig}MaturityType
class MaturityType (pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration_mixin):

    """This type denotes a maturity of an experiment. It can either be development or production."""

    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'MaturityType')
    _XSDLocation = pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 22, 2)
    _Documentation = 'This type denotes a maturity of an experiment. It can either be development or production.'
MaturityType._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=MaturityType, enum_prefix=None)
MaturityType.development = MaturityType._CF_enumeration.addEnumeration(unicode_value='development', tag='development')
MaturityType.production = MaturityType._CF_enumeration.addEnumeration(unicode_value='production', tag='production')
MaturityType._InitializeFacetMap(MaturityType._CF_enumeration)
Namespace.addCategoryObject('typeBinding', 'MaturityType', MaturityType)
_module_typeBindings.MaturityType = MaturityType

# List simple type: {http://schemas.humanbrainproject.eu/SP10/2014/ExDConfig}Tags
# superclasses pyxb.binding.datatypes.anySimpleType
class Tags (pyxb.binding.basis.STD_list):

    """Simple type that is a list of pyxb.binding.datatypes.string."""

    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'Tags')
    _XSDLocation = pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 88, 2)
    _Documentation = None

    _ItemType = pyxb.binding.datatypes.string
Tags._InitializeFacetMap()
Namespace.addCategoryObject('typeBinding', 'Tags', Tags)
_module_typeBindings.Tags = Tags

# List simple type: {http://schemas.humanbrainproject.eu/SP10/2014/ExDConfig}RecordRosTopics
# superclasses pyxb.binding.datatypes.anySimpleType
class RecordRosTopics (pyxb.binding.basis.STD_list):

    """Simple type that is a list of pyxb.binding.datatypes.string."""

    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'RecordRosTopics')
    _XSDLocation = pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 93, 2)
    _Documentation = None

    _ItemType = pyxb.binding.datatypes.string
RecordRosTopics._InitializeFacetMap()
Namespace.addCategoryObject('typeBinding', 'RecordRosTopics', RecordRosTopics)
_module_typeBindings.RecordRosTopics = RecordRosTopics

# Atomic simple type: {http://schemas.humanbrainproject.eu/SP10/2014/ExDConfig}ConfTypeEnumeration
class ConfTypeEnumeration (pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration_mixin):

    """This enumeration lists the standard configuration types used in the NRP."""

    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'ConfTypeEnumeration')
    _XSDLocation = pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 105, 2)
    _Documentation = 'This enumeration lists the standard configuration types used in the NRP.'
ConfTypeEnumeration._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=ConfTypeEnumeration, enum_prefix=None)
ConfTypeEnumeration.n3d_settings = ConfTypeEnumeration._CF_enumeration.addEnumeration(unicode_value='3d-settings', tag='n3d_settings')
ConfTypeEnumeration._InitializeFacetMap(ConfTypeEnumeration._CF_enumeration)
Namespace.addCategoryObject('typeBinding', 'ConfTypeEnumeration', ConfTypeEnumeration)
_module_typeBindings.ConfTypeEnumeration = ConfTypeEnumeration

# Atomic simple type: {http://schemas.humanbrainproject.eu/SP10/2014/ExDConfig}PhysicsEngine
class PhysicsEngine (pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration_mixin):

    """This enumeration contains the physics engines supported by the NRP. This includes the standard physics engine ODE and OpenSim."""

    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'PhysicsEngine')
    _XSDLocation = pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 229, 2)
    _Documentation = 'This enumeration contains the physics engines supported by the NRP. This includes the standard physics engine ODE and OpenSim.'
PhysicsEngine._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=PhysicsEngine, enum_prefix=None)
PhysicsEngine.ode = PhysicsEngine._CF_enumeration.addEnumeration(unicode_value='ode', tag='ode')
PhysicsEngine.opensim = PhysicsEngine._CF_enumeration.addEnumeration(unicode_value='opensim', tag='opensim')
PhysicsEngine._InitializeFacetMap(PhysicsEngine._CF_enumeration)
Namespace.addCategoryObject('typeBinding', 'PhysicsEngine', PhysicsEngine)
_module_typeBindings.PhysicsEngine = PhysicsEngine

# Atomic simple type: {http://schemas.humanbrainproject.eu/SP10/2014/ExDConfig}TimeoutTime
class TimeoutTime (pyxb.binding.datatypes.string, pyxb.binding.basis.enumeration_mixin):

    """An atomic simple type."""

    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'TimeoutTime')
    _XSDLocation = pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 369, 2)
    _Documentation = None
TimeoutTime._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=TimeoutTime, enum_prefix=None)
TimeoutTime.simulation = TimeoutTime._CF_enumeration.addEnumeration(unicode_value='simulation', tag='simulation')
TimeoutTime.real = TimeoutTime._CF_enumeration.addEnumeration(unicode_value='real', tag='real')
TimeoutTime._InitializeFacetMap(TimeoutTime._CF_enumeration)
Namespace.addCategoryObject('typeBinding', 'TimeoutTime', TimeoutTime)
_module_typeBindings.TimeoutTime = TimeoutTime

# Union simple type: {http://schemas.humanbrainproject.eu/SP10/2014/ExDConfig}ConfType
# superclasses pyxb.binding.datatypes.anySimpleType
class ConfType (pyxb.binding.basis.STD_union):

    """This type denotes a configuration type which can be a standard configuration type or a custom type. The latter is just any string."""

    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'ConfType')
    _XSDLocation = pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 98, 2)
    _Documentation = 'This type denotes a configuration type which can be a standard configuration type or a custom type. The latter is just any string.'

    _MemberTypes = ( ConfTypeEnumeration, pyxb.binding.datatypes.string, )
ConfType._CF_pattern = pyxb.binding.facets.CF_pattern()
ConfType._CF_enumeration = pyxb.binding.facets.CF_enumeration(value_datatype=ConfType)
ConfType.n3d_settings = '3d-settings'             # originally ConfTypeEnumeration.n3d_settings
ConfType._InitializeFacetMap(ConfType._CF_pattern,
   ConfType._CF_enumeration)
Namespace.addCategoryObject('typeBinding', 'ConfType', ConfType)
_module_typeBindings.ConfType = ConfType

# Complex type {http://schemas.humanbrainproject.eu/SP10/2014/ExDConfig}RobotPose with content type EMPTY
class RobotPose (pyxb.binding.basis.complexTypeDefinition):
    """This type represents a robot pose. It consists of a position part (x, y and z coordinates in meters) and a rotation part (roll, pitch and yaw in radians). All fields are double precision values."""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'RobotPose')
    _XSDLocation = pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 33, 2)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Attribute robotId uses Python identifier robotId
    __robotId = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'robotId'), 'robotId', '__httpschemas_humanbrainproject_euSP102014ExDConfig_RobotPose_robotId', pyxb.binding.datatypes.string)
    __robotId._DeclarationLocation = pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 37, 4)
    __robotId._UseLocation = pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 37, 4)
    
    robotId = property(__robotId.value, __robotId.set, None, 'Robot id the pose refers to')

    
    # Attribute x uses Python identifier x
    __x = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'x'), 'x', '__httpschemas_humanbrainproject_euSP102014ExDConfig_RobotPose_x', pyxb.binding.datatypes.double, required=True)
    __x._DeclarationLocation = pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 42, 4)
    __x._UseLocation = pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 42, 4)
    
    x = property(__x.value, __x.set, None, 'The x coordinate of the robot position')

    
    # Attribute y uses Python identifier y
    __y = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'y'), 'y', '__httpschemas_humanbrainproject_euSP102014ExDConfig_RobotPose_y', pyxb.binding.datatypes.double, required=True)
    __y._DeclarationLocation = pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 47, 4)
    __y._UseLocation = pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 47, 4)
    
    y = property(__y.value, __y.set, None, 'The y coordinate of the robot position')

    
    # Attribute z uses Python identifier z
    __z = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'z'), 'z', '__httpschemas_humanbrainproject_euSP102014ExDConfig_RobotPose_z', pyxb.binding.datatypes.double, required=True)
    __z._DeclarationLocation = pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 52, 4)
    __z._UseLocation = pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 52, 4)
    
    z = property(__z.value, __z.set, None, 'The z coordinate of the robot position')

    
    # Attribute pitch uses Python identifier pitch
    __pitch = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'pitch'), 'pitch', '__httpschemas_humanbrainproject_euSP102014ExDConfig_RobotPose_pitch', pyxb.binding.datatypes.double)
    __pitch._DeclarationLocation = pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 58, 4)
    __pitch._UseLocation = pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 58, 4)
    
    pitch = property(__pitch.value, __pitch.set, None, None)

    
    # Attribute yaw uses Python identifier yaw
    __yaw = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'yaw'), 'yaw', '__httpschemas_humanbrainproject_euSP102014ExDConfig_RobotPose_yaw', pyxb.binding.datatypes.double)
    __yaw._DeclarationLocation = pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 59, 4)
    __yaw._UseLocation = pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 59, 4)
    
    yaw = property(__yaw.value, __yaw.set, None, None)

    
    # Attribute roll uses Python identifier roll
    __roll = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'roll'), 'roll', '__httpschemas_humanbrainproject_euSP102014ExDConfig_RobotPose_roll', pyxb.binding.datatypes.double)
    __roll._DeclarationLocation = pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 60, 4)
    __roll._UseLocation = pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 60, 4)
    
    roll = property(__roll.value, __roll.set, None, None)

    
    # Attribute ux uses Python identifier ux
    __ux = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'ux'), 'ux', '__httpschemas_humanbrainproject_euSP102014ExDConfig_RobotPose_ux', pyxb.binding.datatypes.double)
    __ux._DeclarationLocation = pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 63, 4)
    __ux._UseLocation = pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 63, 4)
    
    ux = property(__ux.value, __ux.set, None, None)

    
    # Attribute uy uses Python identifier uy
    __uy = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'uy'), 'uy', '__httpschemas_humanbrainproject_euSP102014ExDConfig_RobotPose_uy', pyxb.binding.datatypes.double)
    __uy._DeclarationLocation = pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 64, 4)
    __uy._UseLocation = pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 64, 4)
    
    uy = property(__uy.value, __uy.set, None, None)

    
    # Attribute uz uses Python identifier uz
    __uz = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'uz'), 'uz', '__httpschemas_humanbrainproject_euSP102014ExDConfig_RobotPose_uz', pyxb.binding.datatypes.double)
    __uz._DeclarationLocation = pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 65, 4)
    __uz._UseLocation = pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 65, 4)
    
    uz = property(__uz.value, __uz.set, None, None)

    
    # Attribute theta uses Python identifier theta
    __theta = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'theta'), 'theta', '__httpschemas_humanbrainproject_euSP102014ExDConfig_RobotPose_theta', pyxb.binding.datatypes.double)
    __theta._DeclarationLocation = pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 66, 4)
    __theta._UseLocation = pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 66, 4)
    
    theta = property(__theta.value, __theta.set, None, None)

    _ElementMap.update({
        
    })
    _AttributeMap.update({
        __robotId.name() : __robotId,
        __x.name() : __x,
        __y.name() : __y,
        __z.name() : __z,
        __pitch.name() : __pitch,
        __yaw.name() : __yaw,
        __roll.name() : __roll,
        __ux.name() : __ux,
        __uy.name() : __uy,
        __uz.name() : __uz,
        __theta.name() : __theta
    })
_module_typeBindings.RobotPose = RobotPose
Namespace.addCategoryObject('typeBinding', 'RobotPose', RobotPose)


# Complex type {http://schemas.humanbrainproject.eu/SP10/2014/ExDConfig}Position with content type EMPTY
class Position (pyxb.binding.basis.complexTypeDefinition):
    """This type denotes a position with x, y and z coordinates."""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'Position')
    _XSDLocation = pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 115, 2)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Attribute x uses Python identifier x
    __x = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'x'), 'x', '__httpschemas_humanbrainproject_euSP102014ExDConfig_Position_x', pyxb.binding.datatypes.double, required=True)
    __x._DeclarationLocation = pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 119, 4)
    __x._UseLocation = pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 119, 4)
    
    x = property(__x.value, __x.set, None, 'The x coordinate of the position')

    
    # Attribute y uses Python identifier y
    __y = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'y'), 'y', '__httpschemas_humanbrainproject_euSP102014ExDConfig_Position_y', pyxb.binding.datatypes.double, required=True)
    __y._DeclarationLocation = pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 124, 4)
    __y._UseLocation = pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 124, 4)
    
    y = property(__y.value, __y.set, None, 'The y coordinate of the position')

    
    # Attribute z uses Python identifier z
    __z = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'z'), 'z', '__httpschemas_humanbrainproject_euSP102014ExDConfig_Position_z', pyxb.binding.datatypes.double, required=True)
    __z._DeclarationLocation = pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 129, 4)
    __z._UseLocation = pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 129, 4)
    
    z = property(__z.value, __z.set, None, 'The z coordinate of the position')

    _ElementMap.update({
        
    })
    _AttributeMap.update({
        __x.name() : __x,
        __y.name() : __y,
        __z.name() : __z
    })
_module_typeBindings.Position = Position
Namespace.addCategoryObject('typeBinding', 'Position', Position)


# Complex type {http://schemas.humanbrainproject.eu/SP10/2014/ExDConfig}CameraPose with content type ELEMENT_ONLY
class CameraPose (pyxb.binding.basis.complexTypeDefinition):
    """This type denotes a camera pose. Unlike the robot pose, a camera pose is specified using a position of the camera and a point to which the camera looks at. The camera is always rotated with the up vector z (0,0,1)."""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'CameraPose')
    _XSDLocation = pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 137, 2)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://schemas.humanbrainproject.eu/SP10/2014/ExDConfig}cameraPosition uses Python identifier cameraPosition
    __cameraPosition = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'cameraPosition'), 'cameraPosition', '__httpschemas_humanbrainproject_euSP102014ExDConfig_CameraPose_httpschemas_humanbrainproject_euSP102014ExDConfigcameraPosition', False, pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 142, 6), )

    
    cameraPosition = property(__cameraPosition.value, __cameraPosition.set, None, 'The position of the camera')

    
    # Element {http://schemas.humanbrainproject.eu/SP10/2014/ExDConfig}cameraLookAt uses Python identifier cameraLookAt
    __cameraLookAt = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'cameraLookAt'), 'cameraLookAt', '__httpschemas_humanbrainproject_euSP102014ExDConfig_CameraPose_httpschemas_humanbrainproject_euSP102014ExDConfigcameraLookAt', False, pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 147, 6), )

    
    cameraLookAt = property(__cameraLookAt.value, __cameraLookAt.set, None, 'The position to which the camera should look at')

    _ElementMap.update({
        __cameraPosition.name() : __cameraPosition,
        __cameraLookAt.name() : __cameraLookAt
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.CameraPose = CameraPose
Namespace.addCategoryObject('typeBinding', 'CameraPose', CameraPose)


# Complex type {http://schemas.humanbrainproject.eu/SP10/2014/ExDConfig}EnvironmentModel with content type ELEMENT_ONLY
class EnvironmentModel (pyxb.binding.basis.complexTypeDefinition):
    """This type defines the necessary configuration for an environment. It combines the specification of an environment model through the src attribute and a robot pose using the element robotPose."""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'EnvironmentModel')
    _XSDLocation = pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 156, 2)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://schemas.humanbrainproject.eu/SP10/2014/ExDConfig}robotPose uses Python identifier robotPose
    __robotPose = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'robotPose'), 'robotPose', '__httpschemas_humanbrainproject_euSP102014ExDConfig_EnvironmentModel_httpschemas_humanbrainproject_euSP102014ExDConfigrobotPose', True, pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 161, 6), )

    
    robotPose = property(__robotPose.value, __robotPose.set, None, 'The position of the robot')

    
    # Attribute src uses Python identifier src
    __src = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'src'), 'src', '__httpschemas_humanbrainproject_euSP102014ExDConfig_EnvironmentModel_src', pyxb.binding.datatypes.string, required=True)
    __src._DeclarationLocation = pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 167, 4)
    __src._UseLocation = pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 167, 4)
    
    src = property(__src.value, __src.set, None, 'A path to an SDF file that specifies the scene')

    
    # Attribute model uses Python identifier model
    __model = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'model'), 'model', '__httpschemas_humanbrainproject_euSP102014ExDConfig_EnvironmentModel_model', pyxb.binding.datatypes.string)
    __model._DeclarationLocation = pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 172, 4)
    __model._UseLocation = pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 172, 4)
    
    model = property(__model.value, __model.set, None, 'Specifies the path to the custom model')

    _ElementMap.update({
        __robotPose.name() : __robotPose
    })
    _AttributeMap.update({
        __src.name() : __src,
        __model.name() : __model
    })
_module_typeBindings.EnvironmentModel = EnvironmentModel
Namespace.addCategoryObject('typeBinding', 'EnvironmentModel', EnvironmentModel)


# Complex type {http://schemas.humanbrainproject.eu/SP10/2014/ExDConfig}VisualModel with content type ELEMENT_ONLY
class VisualModel (pyxb.binding.basis.complexTypeDefinition):
    """This type defines a visual model (for example for the robot) as used in the frontend."""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'VisualModel')
    _XSDLocation = pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 180, 2)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://schemas.humanbrainproject.eu/SP10/2014/ExDConfig}visualPose uses Python identifier visualPose
    __visualPose = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'visualPose'), 'visualPose', '__httpschemas_humanbrainproject_euSP102014ExDConfig_VisualModel_httpschemas_humanbrainproject_euSP102014ExDConfigvisualPose', False, pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 185, 6), )

    
    visualPose = property(__visualPose.value, __visualPose.set, None, None)

    
    # Attribute src uses Python identifier src
    __src = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'src'), 'src', '__httpschemas_humanbrainproject_euSP102014ExDConfig_VisualModel_src', pyxb.binding.datatypes.string, required=True)
    __src._DeclarationLocation = pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 187, 4)
    __src._UseLocation = pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 187, 4)
    
    src = property(__src.value, __src.set, None, None)

    
    # Attribute scale uses Python identifier scale
    __scale = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'scale'), 'scale', '__httpschemas_humanbrainproject_euSP102014ExDConfig_VisualModel_scale', pyxb.binding.datatypes.double)
    __scale._DeclarationLocation = pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 188, 4)
    __scale._UseLocation = pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 188, 4)
    
    scale = property(__scale.value, __scale.set, None, None)

    _ElementMap.update({
        __visualPose.name() : __visualPose
    })
    _AttributeMap.update({
        __src.name() : __src,
        __scale.name() : __scale
    })
_module_typeBindings.VisualModel = VisualModel
Namespace.addCategoryObject('typeBinding', 'VisualModel', VisualModel)


# Complex type {http://schemas.humanbrainproject.eu/SP10/2014/ExDConfig}SkinModel with content type EMPTY
class SkinModel (pyxb.binding.basis.complexTypeDefinition):
    """This type defines a skin model (for example for the robot) as used in the frontend."""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'SkinModel')
    _XSDLocation = pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 192, 2)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Attribute src uses Python identifier src
    __src = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'src'), 'src', '__httpschemas_humanbrainproject_euSP102014ExDConfig_SkinModel_src', pyxb.binding.datatypes.string, required=True)
    __src._DeclarationLocation = pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 196, 4)
    __src._UseLocation = pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 196, 4)
    
    src = property(__src.value, __src.set, None, None)

    _ElementMap.update({
        
    })
    _AttributeMap.update({
        __src.name() : __src
    })
_module_typeBindings.SkinModel = SkinModel
Namespace.addCategoryObject('typeBinding', 'SkinModel', SkinModel)


# Complex type {http://schemas.humanbrainproject.eu/SP10/2014/ExDConfig}BibiConf with content type EMPTY
class BibiConf (pyxb.binding.basis.complexTypeDefinition):
    """This type denotes the BIBI configuration used for this experiment. It is described using a reference to the BIBI model in the src attribute and an attribute processes to specify the number of processes that should be used to run the experiment. The default value for processes is 1."""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'BibiConf')
    _XSDLocation = pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 200, 2)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Attribute src uses Python identifier src
    __src = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'src'), 'src', '__httpschemas_humanbrainproject_euSP102014ExDConfig_BibiConf_src', pyxb.binding.datatypes.string, required=True)
    __src._DeclarationLocation = pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 204, 4)
    __src._UseLocation = pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 204, 4)
    
    src = property(__src.value, __src.set, None, 'The path to the BIBI configuration that specifies the model, the neural network and the connection between those.')

    
    # Attribute processes uses Python identifier processes
    __processes = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'processes'), 'processes', '__httpschemas_humanbrainproject_euSP102014ExDConfig_BibiConf_processes', pyxb.binding.datatypes.positiveInteger, unicode_default='1')
    __processes._DeclarationLocation = pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 209, 4)
    __processes._UseLocation = pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 209, 4)
    
    processes = property(__processes.value, __processes.set, None, 'The number of processes that should be used to run the neural network simulation. If this value is larger than 1, a dedicated simulation setup for distributed simulation of the neural network is used.')

    _ElementMap.update({
        
    })
    _AttributeMap.update({
        __src.name() : __src,
        __processes.name() : __processes
    })
_module_typeBindings.BibiConf = BibiConf
Namespace.addCategoryObject('typeBinding', 'BibiConf', BibiConf)


# Complex type {http://schemas.humanbrainproject.eu/SP10/2014/ExDConfig}RosLaunch with content type EMPTY
class RosLaunch (pyxb.binding.basis.complexTypeDefinition):
    """This type denotes a Ros Launchfile configuration."""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'RosLaunch')
    _XSDLocation = pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 217, 2)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Attribute src uses Python identifier src
    __src = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'src'), 'src', '__httpschemas_humanbrainproject_euSP102014ExDConfig_RosLaunch_src', pyxb.binding.datatypes.string, required=True)
    __src._DeclarationLocation = pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 221, 4)
    __src._UseLocation = pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 221, 4)
    
    src = property(__src.value, __src.set, None, 'The path to a ROSLaunch file')

    _ElementMap.update({
        
    })
    _AttributeMap.update({
        __src.name() : __src
    })
_module_typeBindings.RosLaunch = RosLaunch
Namespace.addCategoryObject('typeBinding', 'RosLaunch', RosLaunch)


# Complex type {http://schemas.humanbrainproject.eu/SP10/2014/ExDConfig}ExD with content type ELEMENT_ONLY
class ExD_ (pyxb.binding.basis.complexTypeDefinition):
    """This type is the root type for an experiment configuration."""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'ExD')
    _XSDLocation = pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 240, 2)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://schemas.humanbrainproject.eu/SP10/2014/ExDConfig}name uses Python identifier name
    __name = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'name'), 'name', '__httpschemas_humanbrainproject_euSP102014ExDConfig_ExD__httpschemas_humanbrainproject_euSP102014ExDConfigname', False, pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 245, 6), )

    
    name = property(__name.value, __name.set, None, 'This element denotes the name of the experiment as it appears in the experiment list.')

    
    # Element {http://schemas.humanbrainproject.eu/SP10/2014/ExDConfig}thumbnail uses Python identifier thumbnail
    __thumbnail = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'thumbnail'), 'thumbnail', '__httpschemas_humanbrainproject_euSP102014ExDConfig_ExD__httpschemas_humanbrainproject_euSP102014ExDConfigthumbnail', False, pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 250, 6), )

    
    thumbnail = property(__thumbnail.value, __thumbnail.set, None, 'This element references a path to a thumbnail that is used to give the user a forecast to the experiment.')

    
    # Element {http://schemas.humanbrainproject.eu/SP10/2014/ExDConfig}description uses Python identifier description
    __description = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'description'), 'description', '__httpschemas_humanbrainproject_euSP102014ExDConfig_ExD__httpschemas_humanbrainproject_euSP102014ExDConfigdescription', False, pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 255, 6), )

    
    description = property(__description.value, __description.set, None, 'This description will appear in the experiment description and provide a short description explaining what the experiment is all about.')

    
    # Element {http://schemas.humanbrainproject.eu/SP10/2014/ExDConfig}tags uses Python identifier tags
    __tags = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'tags'), 'tags', '__httpschemas_humanbrainproject_euSP102014ExDConfig_ExD__httpschemas_humanbrainproject_euSP102014ExDConfigtags', False, pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 260, 6), )

    
    tags = property(__tags.value, __tags.set, None, 'List of space separated tags that describe the experiment.')

    
    # Element {http://schemas.humanbrainproject.eu/SP10/2014/ExDConfig}timeout uses Python identifier timeout
    __timeout = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'timeout'), 'timeout', '__httpschemas_humanbrainproject_euSP102014ExDConfig_ExD__httpschemas_humanbrainproject_euSP102014ExDConfigtimeout', False, pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 265, 6), )

    
    timeout = property(__timeout.value, __timeout.set, None, 'The timeout of an experiment is the time an experiment is allowed to run by default, specified in seconds. If that time has elapsed, the users are asked whether they want to extend the runtime of the simulation. On the servers, this will only be allowed if the timeout fits within the cluster allocation.')

    
    # Element {http://schemas.humanbrainproject.eu/SP10/2014/ExDConfig}configuration uses Python identifier configuration
    __configuration = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'configuration'), 'configuration', '__httpschemas_humanbrainproject_euSP102014ExDConfig_ExD__httpschemas_humanbrainproject_euSP102014ExDConfigconfiguration', True, pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 270, 6), )

    
    configuration = property(__configuration.value, __configuration.set, None, 'An experiment may have multiple configuration entries. Despite configuration entries can be specified in anywhere in the ExD element, they must appear together.')

    
    # Element {http://schemas.humanbrainproject.eu/SP10/2014/ExDConfig}maturity uses Python identifier maturity
    __maturity = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'maturity'), 'maturity', '__httpschemas_humanbrainproject_euSP102014ExDConfig_ExD__httpschemas_humanbrainproject_euSP102014ExDConfigmaturity', False, pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 275, 6), )

    
    maturity = property(__maturity.value, __maturity.set, None, 'The maturity of an experiment determines whether it is shown by default to the user or only browsable in dev mode.')

    
    # Element {http://schemas.humanbrainproject.eu/SP10/2014/ExDConfig}environmentModel uses Python identifier environmentModel
    __environmentModel = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'environmentModel'), 'environmentModel', '__httpschemas_humanbrainproject_euSP102014ExDConfig_ExD__httpschemas_humanbrainproject_euSP102014ExDConfigenvironmentModel', False, pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 280, 6), )

    
    environmentModel = property(__environmentModel.value, __environmentModel.set, None, 'The environment model of an experiment specifies the used world file for a simulation and the pose where the robot should be spawned.')

    
    # Element {http://schemas.humanbrainproject.eu/SP10/2014/ExDConfig}visualModel uses Python identifier visualModel
    __visualModel = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'visualModel'), 'visualModel', '__httpschemas_humanbrainproject_euSP102014ExDConfig_ExD__httpschemas_humanbrainproject_euSP102014ExDConfigvisualModel', False, pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 285, 6), )

    
    visualModel = property(__visualModel.value, __visualModel.set, None, 'With the visual model, an experiment can specify an alternatively used model for the frontend visualization. This is helpful in case the robot model used in gazebo is very detailed and thus hard to visualize on the client. On the server, there may be more resources available to simulate more complex models.')

    
    # Element {http://schemas.humanbrainproject.eu/SP10/2014/ExDConfig}skinModel uses Python identifier skinModel
    __skinModel = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'skinModel'), 'skinModel', '__httpschemas_humanbrainproject_euSP102014ExDConfig_ExD__httpschemas_humanbrainproject_euSP102014ExDConfigskinModel', False, pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 290, 6), )

    
    skinModel = property(__skinModel.value, __skinModel.set, None, 'With the skin model, an experiment can specify a skin model for the frontend visualization.')

    
    # Element {http://schemas.humanbrainproject.eu/SP10/2014/ExDConfig}bibiConf uses Python identifier bibiConf
    __bibiConf = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'bibiConf'), 'bibiConf', '__httpschemas_humanbrainproject_euSP102014ExDConfig_ExD__httpschemas_humanbrainproject_euSP102014ExDConfigbibiConf', False, pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 295, 6), )

    
    bibiConf = property(__bibiConf.value, __bibiConf.set, None, 'The bibiConf element of an experiment configuration specifies the ')

    
    # Element {http://schemas.humanbrainproject.eu/SP10/2014/ExDConfig}experimentControl uses Python identifier experimentControl
    __experimentControl = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'experimentControl'), 'experimentControl', '__httpschemas_humanbrainproject_euSP102014ExDConfig_ExD__httpschemas_humanbrainproject_euSP102014ExDConfigexperimentControl', False, pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 300, 6), )

    
    experimentControl = property(__experimentControl.value, __experimentControl.set, None, 'The experiment control lists all state machines that control the experiment.')

    
    # Element {http://schemas.humanbrainproject.eu/SP10/2014/ExDConfig}experimentEvaluation uses Python identifier experimentEvaluation
    __experimentEvaluation = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'experimentEvaluation'), 'experimentEvaluation', '__httpschemas_humanbrainproject_euSP102014ExDConfig_ExD__httpschemas_humanbrainproject_euSP102014ExDConfigexperimentEvaluation', False, pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 309, 6), )

    
    experimentEvaluation = property(__experimentEvaluation.value, __experimentEvaluation.set, None, 'The experiment evaluation element lists all state machines that evaluate the success of a simulated experiment.')

    
    # Element {http://schemas.humanbrainproject.eu/SP10/2014/ExDConfig}cameraPose uses Python identifier cameraPose
    __cameraPose = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'cameraPose'), 'cameraPose', '__httpschemas_humanbrainproject_euSP102014ExDConfig_ExD__httpschemas_humanbrainproject_euSP102014ExDConfigcameraPose', False, pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 318, 6), )

    
    cameraPose = property(__cameraPose.value, __cameraPose.set, None, 'The camera pose specifies the initial position of the camera when a simulation is started.')

    
    # Element {http://schemas.humanbrainproject.eu/SP10/2014/ExDConfig}rosLaunch uses Python identifier rosLaunch
    __rosLaunch = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'rosLaunch'), 'rosLaunch', '__httpschemas_humanbrainproject_euSP102014ExDConfig_ExD__httpschemas_humanbrainproject_euSP102014ExDConfigrosLaunch', False, pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 323, 6), )

    
    rosLaunch = property(__rosLaunch.value, __rosLaunch.set, None, 'The roslaunch element species the path to a ROSLaunch file that is executed when the experiment is simulated. If no file is specified, no ROSLaunch file is executed at the beginning of an experiment.')

    
    # Element {http://schemas.humanbrainproject.eu/SP10/2014/ExDConfig}rngSeed uses Python identifier rngSeed
    __rngSeed = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'rngSeed'), 'rngSeed', '__httpschemas_humanbrainproject_euSP102014ExDConfig_ExD__httpschemas_humanbrainproject_euSP102014ExDConfigrngSeed', False, pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 328, 6), )

    
    rngSeed = property(__rngSeed.value, __rngSeed.set, None, 'If specified, this element specifies the random number generator seed. If this field is left blank, a seed is generated and therefore, the simulation is not 100% deterministic. If a seed is specified here, this seed is used for the robot and neural simulation, making the simulation much more deterministic.')

    
    # Element {http://schemas.humanbrainproject.eu/SP10/2014/ExDConfig}physicsEngine uses Python identifier physicsEngine
    __physicsEngine = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'physicsEngine'), 'physicsEngine', '__httpschemas_humanbrainproject_euSP102014ExDConfig_ExD__httpschemas_humanbrainproject_euSP102014ExDConfigphysicsEngine', False, pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 333, 6), )

    
    physicsEngine = property(__physicsEngine.value, __physicsEngine.set, None, 'If specified, this element denotes the physics simulator that should be used. We currently support either ODE or OpenSim.')

    
    # Element {http://schemas.humanbrainproject.eu/SP10/2014/ExDConfig}gazeboLockstep uses Python identifier gazeboLockstep
    __gazeboLockstep = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'gazeboLockstep'), 'gazeboLockstep', '__httpschemas_humanbrainproject_euSP102014ExDConfig_ExD__httpschemas_humanbrainproject_euSP102014ExDConfiggazeboLockstep', False, pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 338, 6), )

    
    gazeboLockstep = property(__gazeboLockstep.value, __gazeboLockstep.set, None, 'If specified, this element denotes the activation status of gazebo\'s "Lockstep of physics and sensors" feature. see https://gazebosim.org/tutorials?tut=lockstep_physics_sensors')

    
    # Element {http://schemas.humanbrainproject.eu/SP10/2014/ExDConfig}gzbridgesettings uses Python identifier gzbridgesettings
    __gzbridgesettings = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'gzbridgesettings'), 'gzbridgesettings', '__httpschemas_humanbrainproject_euSP102014ExDConfig_ExD__httpschemas_humanbrainproject_euSP102014ExDConfiggzbridgesettings', False, pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 343, 6), )

    
    gzbridgesettings = property(__gzbridgesettings.value, __gzbridgesettings.set, None, 'Settings for the relay of the component relaying information from the simulation backend to the visualization client.')

    
    # Element {http://schemas.humanbrainproject.eu/SP10/2014/ExDConfig}cloneDate uses Python identifier cloneDate
    __cloneDate = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'cloneDate'), 'cloneDate', '__httpschemas_humanbrainproject_euSP102014ExDConfig_ExD__httpschemas_humanbrainproject_euSP102014ExDConfigcloneDate', False, pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 348, 5), )

    
    cloneDate = property(__cloneDate.value, __cloneDate.set, None, 'If specified, the date when the experiment was cloned')

    
    # Element {http://schemas.humanbrainproject.eu/SP10/2014/ExDConfig}recordRosTopics uses Python identifier recordRosTopics
    __recordRosTopics = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'recordRosTopics'), 'recordRosTopics', '__httpschemas_humanbrainproject_euSP102014ExDConfig_ExD__httpschemas_humanbrainproject_euSP102014ExDConfigrecordRosTopics', False, pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 353, 6), )

    
    recordRosTopics = property(__recordRosTopics.value, __recordRosTopics.set, None, 'List of space separated ROS topics that shall be recorded to a rosbag file in addition to the standard topics.')

    _ElementMap.update({
        __name.name() : __name,
        __thumbnail.name() : __thumbnail,
        __description.name() : __description,
        __tags.name() : __tags,
        __timeout.name() : __timeout,
        __configuration.name() : __configuration,
        __maturity.name() : __maturity,
        __environmentModel.name() : __environmentModel,
        __visualModel.name() : __visualModel,
        __skinModel.name() : __skinModel,
        __bibiConf.name() : __bibiConf,
        __experimentControl.name() : __experimentControl,
        __experimentEvaluation.name() : __experimentEvaluation,
        __cameraPose.name() : __cameraPose,
        __rosLaunch.name() : __rosLaunch,
        __rngSeed.name() : __rngSeed,
        __physicsEngine.name() : __physicsEngine,
        __gazeboLockstep.name() : __gazeboLockstep,
        __gzbridgesettings.name() : __gzbridgesettings,
        __cloneDate.name() : __cloneDate,
        __recordRosTopics.name() : __recordRosTopics
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.ExD_ = ExD_
Namespace.addCategoryObject('typeBinding', 'ExD', ExD_)


# Complex type {http://schemas.humanbrainproject.eu/SP10/2014/ExDConfig}ExperimentControl with content type ELEMENT_ONLY
class ExperimentControl (pyxb.binding.basis.complexTypeDefinition):
    """This type depicts a list of state machines"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'ExperimentControl')
    _XSDLocation = pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 376, 2)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://schemas.humanbrainproject.eu/SP10/2014/ExDConfig}stateMachine uses Python identifier stateMachine
    __stateMachine = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'stateMachine'), 'stateMachine', '__httpschemas_humanbrainproject_euSP102014ExDConfig_ExperimentControl_httpschemas_humanbrainproject_euSP102014ExDConfigstateMachine', True, pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 381, 6), )

    
    stateMachine = property(__stateMachine.value, __stateMachine.set, None, 'The actual state machines of this list of state machines')

    _ElementMap.update({
        __stateMachine.name() : __stateMachine
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.ExperimentControl = ExperimentControl
Namespace.addCategoryObject('typeBinding', 'ExperimentControl', ExperimentControl)


# Complex type {http://schemas.humanbrainproject.eu/SP10/2014/ExDConfig}GzBridgeSettings with content type ELEMENT_ONLY
class GzBridgeSettings (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://schemas.humanbrainproject.eu/SP10/2014/ExDConfig}GzBridgeSettings with content type ELEMENT_ONLY"""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_ELEMENT_ONLY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'GzBridgeSettings')
    _XSDLocation = pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 389, 4)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Element {http://schemas.humanbrainproject.eu/SP10/2014/ExDConfig}pose_update_delta_translation uses Python identifier pose_update_delta_translation
    __pose_update_delta_translation = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'pose_update_delta_translation'), 'pose_update_delta_translation', '__httpschemas_humanbrainproject_euSP102014ExDConfig_GzBridgeSettings_httpschemas_humanbrainproject_euSP102014ExDConfigpose_update_delta_translation', False, pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 391, 12), )

    
    pose_update_delta_translation = property(__pose_update_delta_translation.value, __pose_update_delta_translation.set, None, '\n                  The magnitude of translation delta by which a pose must change for it to be relayed to the frontend.\n                ')

    
    # Element {http://schemas.humanbrainproject.eu/SP10/2014/ExDConfig}pose_update_delta_rotation uses Python identifier pose_update_delta_rotation
    __pose_update_delta_rotation = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'pose_update_delta_rotation'), 'pose_update_delta_rotation', '__httpschemas_humanbrainproject_euSP102014ExDConfig_GzBridgeSettings_httpschemas_humanbrainproject_euSP102014ExDConfigpose_update_delta_rotation', False, pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 398, 12), )

    
    pose_update_delta_rotation = property(__pose_update_delta_rotation.value, __pose_update_delta_rotation.set, None, '\n                  The angle delta by which a pose must change for it to be relayed to the frontend.\n                ')

    
    # Element {http://schemas.humanbrainproject.eu/SP10/2014/ExDConfig}pose_update_early_threshold uses Python identifier pose_update_early_threshold
    __pose_update_early_threshold = pyxb.binding.content.ElementDeclaration(pyxb.namespace.ExpandedName(Namespace, 'pose_update_early_threshold'), 'pose_update_early_threshold', '__httpschemas_humanbrainproject_euSP102014ExDConfig_GzBridgeSettings_httpschemas_humanbrainproject_euSP102014ExDConfigpose_update_early_threshold', False, pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 405, 12), )

    
    pose_update_early_threshold = property(__pose_update_early_threshold.value, __pose_update_early_threshold.set, None, '\n                  Maximal period during which larger thresholds are used rather than those defined in gzbridgesettings.\n                ')

    _ElementMap.update({
        __pose_update_delta_translation.name() : __pose_update_delta_translation,
        __pose_update_delta_rotation.name() : __pose_update_delta_rotation,
        __pose_update_early_threshold.name() : __pose_update_early_threshold
    })
    _AttributeMap.update({
        
    })
_module_typeBindings.GzBridgeSettings = GzBridgeSettings
Namespace.addCategoryObject('typeBinding', 'GzBridgeSettings', GzBridgeSettings)


# Complex type {http://schemas.humanbrainproject.eu/SP10/2014/ExDConfig}StateMachine with content type EMPTY
class StateMachine (pyxb.binding.basis.complexTypeDefinition):
    """This abstract type depicts a state machine. Currently, State Machines in SMACH are supported."""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
    _Abstract = True
    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'StateMachine')
    _XSDLocation = pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 415, 2)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Attribute id uses Python identifier id
    __id = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'id'), 'id', '__httpschemas_humanbrainproject_euSP102014ExDConfig_StateMachine_id', pyxb.binding.datatypes.string, required=True)
    __id._DeclarationLocation = pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 419, 4)
    __id._UseLocation = pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 419, 4)
    
    id = property(__id.value, __id.set, None, 'Any state machine must have an identifier. This identifier is used to communicate with the state machine and therefore must be an identifier.')

    _ElementMap.update({
        
    })
    _AttributeMap.update({
        __id.name() : __id
    })
_module_typeBindings.StateMachine = StateMachine
Namespace.addCategoryObject('typeBinding', 'StateMachine', StateMachine)


# Complex type {http://schemas.humanbrainproject.eu/SP10/2014/ExDConfig}Timeout with content type SIMPLE
class Timeout (pyxb.binding.basis.complexTypeDefinition):
    """Complex type {http://schemas.humanbrainproject.eu/SP10/2014/ExDConfig}Timeout with content type SIMPLE"""
    _TypeDefinition = pyxb.binding.datatypes.double
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_SIMPLE
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'Timeout')
    _XSDLocation = pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 361, 2)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.double
    
    # Attribute time uses Python identifier time
    __time = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'time'), 'time', '__httpschemas_humanbrainproject_euSP102014ExDConfig_Timeout_time', _module_typeBindings.TimeoutTime)
    __time._DeclarationLocation = pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 364, 12)
    __time._UseLocation = pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 364, 12)
    
    time = property(__time.value, __time.set, None, None)

    _ElementMap.update({
        
    })
    _AttributeMap.update({
        __time.name() : __time
    })
_module_typeBindings.Timeout = Timeout
Namespace.addCategoryObject('typeBinding', 'Timeout', Timeout)


# Complex type {http://schemas.humanbrainproject.eu/SP10/2014/ExDConfig}SMACHStateMachine with content type EMPTY
class SMACHStateMachine (StateMachine):
    """This type depicts a SMACH state machine. It is specified using a path to the source code of the state machine."""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'SMACHStateMachine')
    _XSDLocation = pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 426, 2)
    _ElementMap = StateMachine._ElementMap.copy()
    _AttributeMap = StateMachine._AttributeMap.copy()
    # Base type is StateMachine
    
    # Attribute id inherited from {http://schemas.humanbrainproject.eu/SP10/2014/ExDConfig}StateMachine
    
    # Attribute src uses Python identifier src
    __src = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'src'), 'src', '__httpschemas_humanbrainproject_euSP102014ExDConfig_SMACHStateMachine_src', pyxb.binding.datatypes.string, required=True)
    __src._DeclarationLocation = pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 432, 8)
    __src._UseLocation = pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 432, 8)
    
    src = property(__src.value, __src.set, None, 'The path to an Python script that describes the state machine. This script has to have a variable with global scope that must have the name sm or stateMachine.')

    _ElementMap.update({
        
    })
    _AttributeMap.update({
        __src.name() : __src
    })
_module_typeBindings.SMACHStateMachine = SMACHStateMachine
Namespace.addCategoryObject('typeBinding', 'SMACHStateMachine', SMACHStateMachine)


# Complex type {http://schemas.humanbrainproject.eu/SP10/2014/ExDConfig}ConfFile with content type EMPTY
class ConfFile (pyxb.binding.basis.complexTypeDefinition):
    """This type denotes a configuration entry. Configuration entries are used for multiple purposes, therefore the type of the configuration entry is set explicitly in an attribute called type. The actual configuration is referenced as a file through the src attribute."""
    _TypeDefinition = None
    _ContentTypeTag = pyxb.binding.basis.complexTypeDefinition._CT_EMPTY
    _Abstract = False
    _ExpandedName = pyxb.namespace.ExpandedName(Namespace, 'ConfFile')
    _XSDLocation = pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 71, 2)
    _ElementMap = {}
    _AttributeMap = {}
    # Base type is pyxb.binding.datatypes.anyType
    
    # Attribute src uses Python identifier src
    __src = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'src'), 'src', '__httpschemas_humanbrainproject_euSP102014ExDConfig_ConfFile_src', pyxb.binding.datatypes.string, required=True)
    __src._DeclarationLocation = pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 75, 4)
    __src._UseLocation = pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 75, 4)
    
    src = property(__src.value, __src.set, None, 'The path to the file that acts as configuration. Files specified as configuration are automatically considered whe an experiment is deployed.')

    
    # Attribute type uses Python identifier type
    __type = pyxb.binding.content.AttributeUse(pyxb.namespace.ExpandedName(None, 'type'), 'type', '__httpschemas_humanbrainproject_euSP102014ExDConfig_ConfFile_type', _module_typeBindings.ConfType, required=True)
    __type._DeclarationLocation = pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 80, 4)
    __type._UseLocation = pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 80, 4)
    
    type = property(__type.value, __type.set, None, 'The type of the configuration entry describes what this entry is used for. The NRP allows both predefined and custom entries.')

    _ElementMap.update({
        
    })
    _AttributeMap.update({
        __src.name() : __src,
        __type.name() : __type
    })
_module_typeBindings.ConfFile = ConfFile
Namespace.addCategoryObject('typeBinding', 'ConfFile', ConfFile)


ExD = pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'ExD'), ExD_, documentation='The root element of a experiment configuration model must be an ExD object.', location=pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 441, 2))
Namespace.addCategoryObject('elementBinding', ExD.name().localName(), ExD)



CameraPose._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'cameraPosition'), Position, scope=CameraPose, documentation='The position of the camera', location=pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 142, 6)))

CameraPose._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'cameraLookAt'), Position, scope=CameraPose, documentation='The position to which the camera should look at', location=pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 147, 6)))

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(CameraPose._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'cameraPosition')), pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 142, 6))
    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(CameraPose._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'cameraLookAt')), pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 147, 6))
    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)
CameraPose._Automaton = _BuildAutomaton()




EnvironmentModel._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'robotPose'), RobotPose, scope=EnvironmentModel, documentation='The position of the robot', location=pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 161, 6)))

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=None, metadata=pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 161, 6))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(EnvironmentModel._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'robotPose')), pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 161, 6))
    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)
EnvironmentModel._Automaton = _BuildAutomaton_()




VisualModel._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'visualPose'), RobotPose, scope=VisualModel, location=pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 185, 6)))

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()
    states = []
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(VisualModel._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'visualPose')), pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 185, 6))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
VisualModel._Automaton = _BuildAutomaton_2()




ExD_._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'name'), pyxb.binding.datatypes.string, scope=ExD_, documentation='This element denotes the name of the experiment as it appears in the experiment list.', location=pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 245, 6)))

ExD_._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'thumbnail'), ThumbnailFile, scope=ExD_, documentation='This element references a path to a thumbnail that is used to give the user a forecast to the experiment.', location=pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 250, 6)))

ExD_._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'description'), pyxb.binding.datatypes.string, scope=ExD_, documentation='This description will appear in the experiment description and provide a short description explaining what the experiment is all about.', location=pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 255, 6)))

ExD_._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'tags'), Tags, scope=ExD_, documentation='List of space separated tags that describe the experiment.', location=pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 260, 6)))

ExD_._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'timeout'), Timeout, scope=ExD_, documentation='The timeout of an experiment is the time an experiment is allowed to run by default, specified in seconds. If that time has elapsed, the users are asked whether they want to extend the runtime of the simulation. On the servers, this will only be allowed if the timeout fits within the cluster allocation.', location=pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 265, 6)))

ExD_._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'configuration'), ConfFile, scope=ExD_, documentation='An experiment may have multiple configuration entries. Despite configuration entries can be specified in anywhere in the ExD element, they must appear together.', location=pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 270, 6)))

ExD_._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'maturity'), MaturityType, scope=ExD_, documentation='The maturity of an experiment determines whether it is shown by default to the user or only browsable in dev mode.', location=pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 275, 6)))

ExD_._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'environmentModel'), EnvironmentModel, scope=ExD_, documentation='The environment model of an experiment specifies the used world file for a simulation and the pose where the robot should be spawned.', location=pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 280, 6)))

ExD_._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'visualModel'), VisualModel, scope=ExD_, documentation='With the visual model, an experiment can specify an alternatively used model for the frontend visualization. This is helpful in case the robot model used in gazebo is very detailed and thus hard to visualize on the client. On the server, there may be more resources available to simulate more complex models.', location=pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 285, 6)))

ExD_._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'skinModel'), SkinModel, scope=ExD_, documentation='With the skin model, an experiment can specify a skin model for the frontend visualization.', location=pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 290, 6)))

ExD_._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'bibiConf'), BibiConf, scope=ExD_, documentation='The bibiConf element of an experiment configuration specifies the ', location=pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 295, 6)))

ExD_._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'experimentControl'), ExperimentControl, scope=ExD_, documentation='The experiment control lists all state machines that control the experiment.', location=pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 300, 6)))

ExD_._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'experimentEvaluation'), ExperimentControl, scope=ExD_, documentation='The experiment evaluation element lists all state machines that evaluate the success of a simulated experiment.', location=pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 309, 6)))

ExD_._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'cameraPose'), CameraPose, scope=ExD_, documentation='The camera pose specifies the initial position of the camera when a simulation is started.', location=pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 318, 6)))

ExD_._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'rosLaunch'), RosLaunch, scope=ExD_, documentation='The roslaunch element species the path to a ROSLaunch file that is executed when the experiment is simulated. If no file is specified, no ROSLaunch file is executed at the beginning of an experiment.', location=pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 323, 6)))

ExD_._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'rngSeed'), pyxb.binding.datatypes.positiveInteger, scope=ExD_, documentation='If specified, this element specifies the random number generator seed. If this field is left blank, a seed is generated and therefore, the simulation is not 100% deterministic. If a seed is specified here, this seed is used for the robot and neural simulation, making the simulation much more deterministic.', location=pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 328, 6)))

ExD_._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'physicsEngine'), PhysicsEngine, scope=ExD_, documentation='If specified, this element denotes the physics simulator that should be used. We currently support either ODE or OpenSim.', location=pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 333, 6)))

ExD_._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'gazeboLockstep'), pyxb.binding.datatypes.boolean, scope=ExD_, documentation='If specified, this element denotes the activation status of gazebo\'s "Lockstep of physics and sensors" feature. see https://gazebosim.org/tutorials?tut=lockstep_physics_sensors', location=pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 338, 6)))

ExD_._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'gzbridgesettings'), GzBridgeSettings, scope=ExD_, documentation='Settings for the relay of the component relaying information from the simulation backend to the visualization client.', location=pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 343, 6)))

ExD_._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'cloneDate'), pyxb.binding.datatypes.dateTime, scope=ExD_, documentation='If specified, the date when the experiment was cloned', location=pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 348, 5)))

ExD_._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'recordRosTopics'), RecordRosTopics, scope=ExD_, documentation='List of space separated ROS topics that shall be recorded to a rosbag file in addition to the standard topics.', location=pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 353, 6)))

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()
    states = []
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(ExD_._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'name')), pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 245, 6))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=st_0)

def _BuildAutomaton_5 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_5
    del _BuildAutomaton_5
    import pyxb.utils.fac as fac

    counters = set()
    states = []
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(ExD_._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'thumbnail')), pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 250, 6))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=st_0)

def _BuildAutomaton_6 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_6
    del _BuildAutomaton_6
    import pyxb.utils.fac as fac

    counters = set()
    states = []
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(ExD_._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'description')), pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 255, 6))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=st_0)

def _BuildAutomaton_7 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_7
    del _BuildAutomaton_7
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 260, 6))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(ExD_._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'tags')), pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 260, 6))
    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=st_0)

def _BuildAutomaton_8 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_8
    del _BuildAutomaton_8
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 265, 6))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(ExD_._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'timeout')), pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 265, 6))
    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=st_0)

def _BuildAutomaton_9 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_9
    del _BuildAutomaton_9
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 270, 6))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(ExD_._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'configuration')), pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 270, 6))
    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=st_0)

def _BuildAutomaton_10 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_10
    del _BuildAutomaton_10
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 275, 6))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(ExD_._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'maturity')), pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 275, 6))
    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=st_0)

def _BuildAutomaton_11 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_11
    del _BuildAutomaton_11
    import pyxb.utils.fac as fac

    counters = set()
    states = []
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(ExD_._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'environmentModel')), pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 280, 6))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=st_0)

def _BuildAutomaton_12 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_12
    del _BuildAutomaton_12
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 285, 6))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(ExD_._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'visualModel')), pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 285, 6))
    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=st_0)

def _BuildAutomaton_13 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_13
    del _BuildAutomaton_13
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 290, 6))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(ExD_._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'skinModel')), pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 290, 6))
    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=st_0)

def _BuildAutomaton_14 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_14
    del _BuildAutomaton_14
    import pyxb.utils.fac as fac

    counters = set()
    states = []
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(ExD_._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'bibiConf')), pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 295, 6))
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=False)
    states.append(st_0)
    transitions = []
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=st_0)

def _BuildAutomaton_15 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_15
    del _BuildAutomaton_15
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 300, 6))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(ExD_._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'experimentControl')), pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 300, 6))
    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=st_0)

def _BuildAutomaton_16 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_16
    del _BuildAutomaton_16
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 309, 6))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(ExD_._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'experimentEvaluation')), pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 309, 6))
    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=st_0)

def _BuildAutomaton_17 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_17
    del _BuildAutomaton_17
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 318, 6))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(ExD_._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'cameraPose')), pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 318, 6))
    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=st_0)

def _BuildAutomaton_18 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_18
    del _BuildAutomaton_18
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 323, 6))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(ExD_._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'rosLaunch')), pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 323, 6))
    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=st_0)

def _BuildAutomaton_19 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_19
    del _BuildAutomaton_19
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 328, 6))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(ExD_._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'rngSeed')), pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 328, 6))
    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=st_0)

def _BuildAutomaton_20 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_20
    del _BuildAutomaton_20
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 333, 6))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(ExD_._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'physicsEngine')), pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 333, 6))
    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=st_0)

def _BuildAutomaton_21 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_21
    del _BuildAutomaton_21
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 338, 6))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(ExD_._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'gazeboLockstep')), pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 338, 6))
    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=st_0)

def _BuildAutomaton_22 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_22
    del _BuildAutomaton_22
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 343, 6))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(ExD_._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'gzbridgesettings')), pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 343, 6))
    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=st_0)

def _BuildAutomaton_23 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_23
    del _BuildAutomaton_23
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 348, 5))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(ExD_._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'cloneDate')), pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 348, 5))
    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=st_0)

def _BuildAutomaton_24 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_24
    del _BuildAutomaton_24
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 353, 6))
    counters.add(cc_0)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(ExD_._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'recordRosTopics')), pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 353, 6))
    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=st_0)

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=1, metadata=pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 260, 6))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 265, 6))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=None, metadata=pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 270, 6))
    counters.add(cc_2)
    cc_3 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 275, 6))
    counters.add(cc_3)
    cc_4 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 285, 6))
    counters.add(cc_4)
    cc_5 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 290, 6))
    counters.add(cc_5)
    cc_6 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 300, 6))
    counters.add(cc_6)
    cc_7 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 309, 6))
    counters.add(cc_7)
    cc_8 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 318, 6))
    counters.add(cc_8)
    cc_9 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 323, 6))
    counters.add(cc_9)
    cc_10 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 328, 6))
    counters.add(cc_10)
    cc_11 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 333, 6))
    counters.add(cc_11)
    cc_12 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 338, 6))
    counters.add(cc_12)
    cc_13 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 343, 6))
    counters.add(cc_13)
    cc_14 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 348, 5))
    counters.add(cc_14)
    cc_15 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 353, 6))
    counters.add(cc_15)
    states = []
    sub_automata = []
    sub_automata.append(_BuildAutomaton_4())
    sub_automata.append(_BuildAutomaton_5())
    sub_automata.append(_BuildAutomaton_6())
    sub_automata.append(_BuildAutomaton_7())
    sub_automata.append(_BuildAutomaton_8())
    sub_automata.append(_BuildAutomaton_9())
    sub_automata.append(_BuildAutomaton_10())
    sub_automata.append(_BuildAutomaton_11())
    sub_automata.append(_BuildAutomaton_12())
    sub_automata.append(_BuildAutomaton_13())
    sub_automata.append(_BuildAutomaton_14())
    sub_automata.append(_BuildAutomaton_15())
    sub_automata.append(_BuildAutomaton_16())
    sub_automata.append(_BuildAutomaton_17())
    sub_automata.append(_BuildAutomaton_18())
    sub_automata.append(_BuildAutomaton_19())
    sub_automata.append(_BuildAutomaton_20())
    sub_automata.append(_BuildAutomaton_21())
    sub_automata.append(_BuildAutomaton_22())
    sub_automata.append(_BuildAutomaton_23())
    sub_automata.append(_BuildAutomaton_24())
    final_update = set()
    symbol = pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 244, 4)
    st_0 = fac.State(symbol, is_initial=True, final_update=final_update, is_unordered_catenation=True)
    st_0._set_subAutomata(*sub_automata)
    states.append(st_0)
    transitions = []
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
ExD_._Automaton = _BuildAutomaton_3()




ExperimentControl._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'stateMachine'), StateMachine, scope=ExperimentControl, documentation='The actual state machines of this list of state machines', location=pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 381, 6)))

def _BuildAutomaton_25 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_25
    del _BuildAutomaton_25
    import pyxb.utils.fac as fac

    counters = set()
    states = []
    final_update = set()
    symbol = pyxb.binding.content.ElementUse(ExperimentControl._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'stateMachine')), pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 381, 6))
    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, [
         ]))
    st_0._set_transitionSet(transitions)
    return fac.Automaton(states, counters, False, containing_state=None)
ExperimentControl._Automaton = _BuildAutomaton_25()




GzBridgeSettings._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'pose_update_delta_translation'), pyxb.binding.datatypes.float, scope=GzBridgeSettings, documentation='\n                  The magnitude of translation delta by which a pose must change for it to be relayed to the frontend.\n                ', location=pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 391, 12)))

GzBridgeSettings._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'pose_update_delta_rotation'), pyxb.binding.datatypes.float, scope=GzBridgeSettings, documentation='\n                  The angle delta by which a pose must change for it to be relayed to the frontend.\n                ', location=pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 398, 12)))

GzBridgeSettings._AddElement(pyxb.binding.basis.element(pyxb.namespace.ExpandedName(Namespace, 'pose_update_early_threshold'), pyxb.binding.datatypes.float, scope=GzBridgeSettings, documentation='\n                  Maximal period during which larger thresholds are used rather than those defined in gzbridgesettings.\n                ', location=pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 405, 12)))

def _BuildAutomaton_26 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_26
    del _BuildAutomaton_26
    import pyxb.utils.fac as fac

    counters = set()
    cc_0 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 391, 12))
    counters.add(cc_0)
    cc_1 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 398, 12))
    counters.add(cc_1)
    cc_2 = fac.CounterCondition(min=0, max=1, metadata=pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 405, 12))
    counters.add(cc_2)
    states = []
    final_update = set()
    final_update.add(fac.UpdateInstruction(cc_0, False))
    symbol = pyxb.binding.content.ElementUse(GzBridgeSettings._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'pose_update_delta_translation')), pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 391, 12))
    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_1, False))
    symbol = pyxb.binding.content.ElementUse(GzBridgeSettings._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'pose_update_delta_rotation')), pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 398, 12))
    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_2, False))
    symbol = pyxb.binding.content.ElementUse(GzBridgeSettings._UseForTag(pyxb.namespace.ExpandedName(Namespace, 'pose_update_early_threshold')), pyxb.utils.utility.Location('/home/ubuntu/workspace/Deploy_docs/ExDBackend/ExDConfFile.xsd', 405, 12))
    st_2 = fac.State(symbol, is_initial=True, 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) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_0, False) ]))
    st_0._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_1, [
        fac.UpdateInstruction(cc_1, True) ]))
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_1, False) ]))
    st_1._set_transitionSet(transitions)
    transitions = []
    transitions.append(fac.Transition(st_2, [
        fac.UpdateInstruction(cc_2, True) ]))
    st_2._set_transitionSet(transitions)
    return fac.Automaton(states, counters, True, containing_state=None)
GzBridgeSettings._Automaton = _BuildAutomaton_26()