spacedatastandards.org 1.73.0__py3-none-any.whl

XTC/CommandSignificance.py

@@ -0,0 +1,113 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: 
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+# Significance of command execution
+class CommandSignificance(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = CommandSignificance()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsCommandSignificance(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    @classmethod
+    def CommandSignificanceBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x24\x58\x54\x43", size_prefixed=size_prefixed)
+
+    # CommandSignificance
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Consequence level (1=lowest, higher=more severe)
+    # CommandSignificance
+    def CONSEQUENCE_LEVEL(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
+        return 0
+
+    # Reason for significance
+    # CommandSignificance
+    def REASON_FOR_WARNING(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+def CommandSignificanceStart(builder):
+    builder.StartObject(2)
+
+def Start(builder):
+    CommandSignificanceStart(builder)
+
+def CommandSignificanceAddCONSEQUENCE_LEVEL(builder, CONSEQUENCE_LEVEL):
+    builder.PrependUint8Slot(0, CONSEQUENCE_LEVEL, 0)
+
+def AddCONSEQUENCE_LEVEL(builder, CONSEQUENCE_LEVEL):
+    CommandSignificanceAddCONSEQUENCE_LEVEL(builder, CONSEQUENCE_LEVEL)
+
+def CommandSignificanceAddREASON_FOR_WARNING(builder, REASON_FOR_WARNING):
+    builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(REASON_FOR_WARNING), 0)
+
+def AddREASON_FOR_WARNING(builder, REASON_FOR_WARNING):
+    CommandSignificanceAddREASON_FOR_WARNING(builder, REASON_FOR_WARNING)
+
+def CommandSignificanceEnd(builder):
+    return builder.EndObject()
+
+def End(builder):
+    return CommandSignificanceEnd(builder)
+
+
+class CommandSignificanceT(object):
+
+    # CommandSignificanceT
+    def __init__(self):
+        self.CONSEQUENCE_LEVEL = 0  # type: int
+        self.REASON_FOR_WARNING = None  # type: str
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        commandSignificance = CommandSignificance()
+        commandSignificance.Init(buf, pos)
+        return cls.InitFromObj(commandSignificance)
+
+    @classmethod
+    def InitFromPackedBuf(cls, buf, pos=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos)
+        return cls.InitFromBuf(buf, pos+n)
+
+    @classmethod
+    def InitFromObj(cls, commandSignificance):
+        x = CommandSignificanceT()
+        x._UnPack(commandSignificance)
+        return x
+
+    # CommandSignificanceT
+    def _UnPack(self, commandSignificance):
+        if commandSignificance is None:
+            return
+        self.CONSEQUENCE_LEVEL = commandSignificance.CONSEQUENCE_LEVEL()
+        self.REASON_FOR_WARNING = commandSignificance.REASON_FOR_WARNING()
+
+    # CommandSignificanceT
+    def Pack(self, builder):
+        if self.REASON_FOR_WARNING is not None:
+            REASON_FOR_WARNING = builder.CreateString(self.REASON_FOR_WARNING)
+        CommandSignificanceStart(builder)
+        CommandSignificanceAddCONSEQUENCE_LEVEL(builder, self.CONSEQUENCE_LEVEL)
+        if self.REASON_FOR_WARNING is not None:
+            CommandSignificanceAddREASON_FOR_WARNING(builder, REASON_FOR_WARNING)
+        commandSignificance = CommandSignificanceEnd(builder)
+        return commandSignificance

XTC/CommandVerifier.py

@@ -0,0 +1,214 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: 
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+# Command verifier definition
+class CommandVerifier(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = CommandVerifier()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsCommandVerifier(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    @classmethod
+    def CommandVerifierBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x24\x58\x54\x43", size_prefixed=size_prefixed)
+
+    # CommandVerifier
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Verifier name
+    # CommandVerifier
+    def NAME(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Verifier type
+    # CommandVerifier
+    def VERIFIER_TYPE(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos)
+        return 0
+
+    # Verification condition
+    # CommandVerifier
+    def CONDITION(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            x = self._tab.Indirect(o + self._tab.Pos)
+            from MatchCriteria import MatchCriteria
+            obj = MatchCriteria()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # Container reference for verification
+    # CommandVerifier
+    def CONTAINER_REF(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Time window start (seconds)
+    # CommandVerifier
+    def TIME_WINDOW_START(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return 0.0
+
+    # Time window stop (seconds)
+    # CommandVerifier
+    def TIME_WINDOW_STOP(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return 0.0
+
+    # Time window reference type
+    # CommandVerifier
+    def TIME_WINDOW_REF(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos)
+        return 0
+
+def CommandVerifierStart(builder):
+    builder.StartObject(7)
+
+def Start(builder):
+    CommandVerifierStart(builder)
+
+def CommandVerifierAddNAME(builder, NAME):
+    builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(NAME), 0)
+
+def AddNAME(builder, NAME):
+    CommandVerifierAddNAME(builder, NAME)
+
+def CommandVerifierAddVERIFIER_TYPE(builder, VERIFIER_TYPE):
+    builder.PrependInt8Slot(1, VERIFIER_TYPE, 0)
+
+def AddVERIFIER_TYPE(builder, VERIFIER_TYPE):
+    CommandVerifierAddVERIFIER_TYPE(builder, VERIFIER_TYPE)
+
+def CommandVerifierAddCONDITION(builder, CONDITION):
+    builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(CONDITION), 0)
+
+def AddCONDITION(builder, CONDITION):
+    CommandVerifierAddCONDITION(builder, CONDITION)
+
+def CommandVerifierAddCONTAINER_REF(builder, CONTAINER_REF):
+    builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(CONTAINER_REF), 0)
+
+def AddCONTAINER_REF(builder, CONTAINER_REF):
+    CommandVerifierAddCONTAINER_REF(builder, CONTAINER_REF)
+
+def CommandVerifierAddTIME_WINDOW_START(builder, TIME_WINDOW_START):
+    builder.PrependFloat64Slot(4, TIME_WINDOW_START, 0.0)
+
+def AddTIME_WINDOW_START(builder, TIME_WINDOW_START):
+    CommandVerifierAddTIME_WINDOW_START(builder, TIME_WINDOW_START)
+
+def CommandVerifierAddTIME_WINDOW_STOP(builder, TIME_WINDOW_STOP):
+    builder.PrependFloat64Slot(5, TIME_WINDOW_STOP, 0.0)
+
+def AddTIME_WINDOW_STOP(builder, TIME_WINDOW_STOP):
+    CommandVerifierAddTIME_WINDOW_STOP(builder, TIME_WINDOW_STOP)
+
+def CommandVerifierAddTIME_WINDOW_REF(builder, TIME_WINDOW_REF):
+    builder.PrependInt8Slot(6, TIME_WINDOW_REF, 0)
+
+def AddTIME_WINDOW_REF(builder, TIME_WINDOW_REF):
+    CommandVerifierAddTIME_WINDOW_REF(builder, TIME_WINDOW_REF)
+
+def CommandVerifierEnd(builder):
+    return builder.EndObject()
+
+def End(builder):
+    return CommandVerifierEnd(builder)
+
+import MatchCriteria
+try:
+    from typing import Optional
+except:
+    pass
+
+class CommandVerifierT(object):
+
+    # CommandVerifierT
+    def __init__(self):
+        self.NAME = None  # type: str
+        self.VERIFIER_TYPE = 0  # type: int
+        self.CONDITION = None  # type: Optional[MatchCriteria.MatchCriteriaT]
+        self.CONTAINER_REF = None  # type: str
+        self.TIME_WINDOW_START = 0.0  # type: float
+        self.TIME_WINDOW_STOP = 0.0  # type: float
+        self.TIME_WINDOW_REF = 0  # type: int
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        commandVerifier = CommandVerifier()
+        commandVerifier.Init(buf, pos)
+        return cls.InitFromObj(commandVerifier)
+
+    @classmethod
+    def InitFromPackedBuf(cls, buf, pos=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos)
+        return cls.InitFromBuf(buf, pos+n)
+
+    @classmethod
+    def InitFromObj(cls, commandVerifier):
+        x = CommandVerifierT()
+        x._UnPack(commandVerifier)
+        return x
+
+    # CommandVerifierT
+    def _UnPack(self, commandVerifier):
+        if commandVerifier is None:
+            return
+        self.NAME = commandVerifier.NAME()
+        self.VERIFIER_TYPE = commandVerifier.VERIFIER_TYPE()
+        if commandVerifier.CONDITION() is not None:
+            self.CONDITION = MatchCriteria.MatchCriteriaT.InitFromObj(commandVerifier.CONDITION())
+        self.CONTAINER_REF = commandVerifier.CONTAINER_REF()
+        self.TIME_WINDOW_START = commandVerifier.TIME_WINDOW_START()
+        self.TIME_WINDOW_STOP = commandVerifier.TIME_WINDOW_STOP()
+        self.TIME_WINDOW_REF = commandVerifier.TIME_WINDOW_REF()
+
+    # CommandVerifierT
+    def Pack(self, builder):
+        if self.NAME is not None:
+            NAME = builder.CreateString(self.NAME)
+        if self.CONDITION is not None:
+            CONDITION = self.CONDITION.Pack(builder)
+        if self.CONTAINER_REF is not None:
+            CONTAINER_REF = builder.CreateString(self.CONTAINER_REF)
+        CommandVerifierStart(builder)
+        if self.NAME is not None:
+            CommandVerifierAddNAME(builder, NAME)
+        CommandVerifierAddVERIFIER_TYPE(builder, self.VERIFIER_TYPE)
+        if self.CONDITION is not None:
+            CommandVerifierAddCONDITION(builder, CONDITION)
+        if self.CONTAINER_REF is not None:
+            CommandVerifierAddCONTAINER_REF(builder, CONTAINER_REF)
+        CommandVerifierAddTIME_WINDOW_START(builder, self.TIME_WINDOW_START)
+        CommandVerifierAddTIME_WINDOW_STOP(builder, self.TIME_WINDOW_STOP)
+        CommandVerifierAddTIME_WINDOW_REF(builder, self.TIME_WINDOW_REF)
+        commandVerifier = CommandVerifierEnd(builder)
+        return commandVerifier

XTC/ComparisonOperator.py

@@ -0,0 +1,30 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: 
+
+# Comparison operators for match criteria and conditions
+class ComparisonOperator(object):
+    # Equal to
+    EQ = 0
+    # Not equal to
+    NE = 1
+    # Greater than
+    GT = 2
+    # Less than
+    LT = 3
+    # Greater than or equal to
+    GE = 4
+    # Less than or equal to
+    LE = 5
+    # String starts with
+    STARTS_WITH = 6
+    # String ends with
+    ENDS_WITH = 7
+    # String contains
+    CONTAINS = 8
+    # String does not start with
+    NOT_STARTS_WITH = 9
+    # String does not end with
+    NOT_ENDS_WITH = 10
+    # String does not contain
+    NOT_CONTAINS = 11

XTC/ContainerBinaryEncoding.py

@@ -0,0 +1,130 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: 
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+# Binary encoding specification for container
+class ContainerBinaryEncoding(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = ContainerBinaryEncoding()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsContainerBinaryEncoding(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    @classmethod
+    def ContainerBinaryEncodingBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x24\x58\x54\x43", size_prefixed=size_prefixed)
+
+    # ContainerBinaryEncoding
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Error detection type
+    # ContainerBinaryEncoding
+    def ERROR_DETECTION(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos)
+        return 0
+
+    # CRC polynomial (for CRC error detection)
+    # ContainerBinaryEncoding
+    def CRC_POLYNOMIAL(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Size in bits
+    # ContainerBinaryEncoding
+    def SIZE_IN_BITS(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
+        return 0
+
+def ContainerBinaryEncodingStart(builder):
+    builder.StartObject(3)
+
+def Start(builder):
+    ContainerBinaryEncodingStart(builder)
+
+def ContainerBinaryEncodingAddERROR_DETECTION(builder, ERROR_DETECTION):
+    builder.PrependInt8Slot(0, ERROR_DETECTION, 0)
+
+def AddERROR_DETECTION(builder, ERROR_DETECTION):
+    ContainerBinaryEncodingAddERROR_DETECTION(builder, ERROR_DETECTION)
+
+def ContainerBinaryEncodingAddCRC_POLYNOMIAL(builder, CRC_POLYNOMIAL):
+    builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(CRC_POLYNOMIAL), 0)
+
+def AddCRC_POLYNOMIAL(builder, CRC_POLYNOMIAL):
+    ContainerBinaryEncodingAddCRC_POLYNOMIAL(builder, CRC_POLYNOMIAL)
+
+def ContainerBinaryEncodingAddSIZE_IN_BITS(builder, SIZE_IN_BITS):
+    builder.PrependUint32Slot(2, SIZE_IN_BITS, 0)
+
+def AddSIZE_IN_BITS(builder, SIZE_IN_BITS):
+    ContainerBinaryEncodingAddSIZE_IN_BITS(builder, SIZE_IN_BITS)
+
+def ContainerBinaryEncodingEnd(builder):
+    return builder.EndObject()
+
+def End(builder):
+    return ContainerBinaryEncodingEnd(builder)
+
+
+class ContainerBinaryEncodingT(object):
+
+    # ContainerBinaryEncodingT
+    def __init__(self):
+        self.ERROR_DETECTION = 0  # type: int
+        self.CRC_POLYNOMIAL = None  # type: str
+        self.SIZE_IN_BITS = 0  # type: int
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        containerBinaryEncoding = ContainerBinaryEncoding()
+        containerBinaryEncoding.Init(buf, pos)
+        return cls.InitFromObj(containerBinaryEncoding)
+
+    @classmethod
+    def InitFromPackedBuf(cls, buf, pos=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos)
+        return cls.InitFromBuf(buf, pos+n)
+
+    @classmethod
+    def InitFromObj(cls, containerBinaryEncoding):
+        x = ContainerBinaryEncodingT()
+        x._UnPack(containerBinaryEncoding)
+        return x
+
+    # ContainerBinaryEncodingT
+    def _UnPack(self, containerBinaryEncoding):
+        if containerBinaryEncoding is None:
+            return
+        self.ERROR_DETECTION = containerBinaryEncoding.ERROR_DETECTION()
+        self.CRC_POLYNOMIAL = containerBinaryEncoding.CRC_POLYNOMIAL()
+        self.SIZE_IN_BITS = containerBinaryEncoding.SIZE_IN_BITS()
+
+    # ContainerBinaryEncodingT
+    def Pack(self, builder):
+        if self.CRC_POLYNOMIAL is not None:
+            CRC_POLYNOMIAL = builder.CreateString(self.CRC_POLYNOMIAL)
+        ContainerBinaryEncodingStart(builder)
+        ContainerBinaryEncodingAddERROR_DETECTION(builder, self.ERROR_DETECTION)
+        if self.CRC_POLYNOMIAL is not None:
+            ContainerBinaryEncodingAddCRC_POLYNOMIAL(builder, CRC_POLYNOMIAL)
+        ContainerBinaryEncodingAddSIZE_IN_BITS(builder, self.SIZE_IN_BITS)
+        containerBinaryEncoding = ContainerBinaryEncodingEnd(builder)
+        return containerBinaryEncoding

XTC/ContainerEntry.py

@@ -0,0 +1,184 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: 
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+# Container entry list item (union of entry types)
+class ContainerEntry(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = ContainerEntry()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsContainerEntry(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    @classmethod
+    def ContainerEntryBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x24\x58\x54\x43", size_prefixed=size_prefixed)
+
+    # ContainerEntry
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Parameter reference entry
+    # ContainerEntry
+    def PARAMETER_REF_ENTRY(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            x = self._tab.Indirect(o + self._tab.Pos)
+            from ParameterRefEntry import ParameterRefEntry
+            obj = ParameterRefEntry()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # Container reference entry
+    # ContainerEntry
+    def CONTAINER_REF_ENTRY(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            x = self._tab.Indirect(o + self._tab.Pos)
+            from ContainerRefEntry import ContainerRefEntry
+            obj = ContainerRefEntry()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # Fixed value entry
+    # ContainerEntry
+    def FIXED_VALUE_ENTRY(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            x = self._tab.Indirect(o + self._tab.Pos)
+            from FixedValueEntry import FixedValueEntry
+            obj = FixedValueEntry()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # Array parameter reference entry
+    # ContainerEntry
+    def ARRAY_PARAMETER_REF_ENTRY(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            x = self._tab.Indirect(o + self._tab.Pos)
+            from ArrayParameterRefEntry import ArrayParameterRefEntry
+            obj = ArrayParameterRefEntry()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+def ContainerEntryStart(builder):
+    builder.StartObject(4)
+
+def Start(builder):
+    ContainerEntryStart(builder)
+
+def ContainerEntryAddPARAMETER_REF_ENTRY(builder, PARAMETER_REF_ENTRY):
+    builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(PARAMETER_REF_ENTRY), 0)
+
+def AddPARAMETER_REF_ENTRY(builder, PARAMETER_REF_ENTRY):
+    ContainerEntryAddPARAMETER_REF_ENTRY(builder, PARAMETER_REF_ENTRY)
+
+def ContainerEntryAddCONTAINER_REF_ENTRY(builder, CONTAINER_REF_ENTRY):
+    builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(CONTAINER_REF_ENTRY), 0)
+
+def AddCONTAINER_REF_ENTRY(builder, CONTAINER_REF_ENTRY):
+    ContainerEntryAddCONTAINER_REF_ENTRY(builder, CONTAINER_REF_ENTRY)
+
+def ContainerEntryAddFIXED_VALUE_ENTRY(builder, FIXED_VALUE_ENTRY):
+    builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(FIXED_VALUE_ENTRY), 0)
+
+def AddFIXED_VALUE_ENTRY(builder, FIXED_VALUE_ENTRY):
+    ContainerEntryAddFIXED_VALUE_ENTRY(builder, FIXED_VALUE_ENTRY)
+
+def ContainerEntryAddARRAY_PARAMETER_REF_ENTRY(builder, ARRAY_PARAMETER_REF_ENTRY):
+    builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(ARRAY_PARAMETER_REF_ENTRY), 0)
+
+def AddARRAY_PARAMETER_REF_ENTRY(builder, ARRAY_PARAMETER_REF_ENTRY):
+    ContainerEntryAddARRAY_PARAMETER_REF_ENTRY(builder, ARRAY_PARAMETER_REF_ENTRY)
+
+def ContainerEntryEnd(builder):
+    return builder.EndObject()
+
+def End(builder):
+    return ContainerEntryEnd(builder)
+
+import ArrayParameterRefEntry
+import ContainerRefEntry
+import FixedValueEntry
+import ParameterRefEntry
+try:
+    from typing import Optional
+except:
+    pass
+
+class ContainerEntryT(object):
+
+    # ContainerEntryT
+    def __init__(self):
+        self.PARAMETER_REF_ENTRY = None  # type: Optional[ParameterRefEntry.ParameterRefEntryT]
+        self.CONTAINER_REF_ENTRY = None  # type: Optional[ContainerRefEntry.ContainerRefEntryT]
+        self.FIXED_VALUE_ENTRY = None  # type: Optional[FixedValueEntry.FixedValueEntryT]
+        self.ARRAY_PARAMETER_REF_ENTRY = None  # type: Optional[ArrayParameterRefEntry.ArrayParameterRefEntryT]
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        containerEntry = ContainerEntry()
+        containerEntry.Init(buf, pos)
+        return cls.InitFromObj(containerEntry)
+
+    @classmethod
+    def InitFromPackedBuf(cls, buf, pos=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos)
+        return cls.InitFromBuf(buf, pos+n)
+
+    @classmethod
+    def InitFromObj(cls, containerEntry):
+        x = ContainerEntryT()
+        x._UnPack(containerEntry)
+        return x
+
+    # ContainerEntryT
+    def _UnPack(self, containerEntry):
+        if containerEntry is None:
+            return
+        if containerEntry.PARAMETER_REF_ENTRY() is not None:
+            self.PARAMETER_REF_ENTRY = ParameterRefEntry.ParameterRefEntryT.InitFromObj(containerEntry.PARAMETER_REF_ENTRY())
+        if containerEntry.CONTAINER_REF_ENTRY() is not None:
+            self.CONTAINER_REF_ENTRY = ContainerRefEntry.ContainerRefEntryT.InitFromObj(containerEntry.CONTAINER_REF_ENTRY())
+        if containerEntry.FIXED_VALUE_ENTRY() is not None:
+            self.FIXED_VALUE_ENTRY = FixedValueEntry.FixedValueEntryT.InitFromObj(containerEntry.FIXED_VALUE_ENTRY())
+        if containerEntry.ARRAY_PARAMETER_REF_ENTRY() is not None:
+            self.ARRAY_PARAMETER_REF_ENTRY = ArrayParameterRefEntry.ArrayParameterRefEntryT.InitFromObj(containerEntry.ARRAY_PARAMETER_REF_ENTRY())
+
+    # ContainerEntryT
+    def Pack(self, builder):
+        if self.PARAMETER_REF_ENTRY is not None:
+            PARAMETER_REF_ENTRY = self.PARAMETER_REF_ENTRY.Pack(builder)
+        if self.CONTAINER_REF_ENTRY is not None:
+            CONTAINER_REF_ENTRY = self.CONTAINER_REF_ENTRY.Pack(builder)
+        if self.FIXED_VALUE_ENTRY is not None:
+            FIXED_VALUE_ENTRY = self.FIXED_VALUE_ENTRY.Pack(builder)
+        if self.ARRAY_PARAMETER_REF_ENTRY is not None:
+            ARRAY_PARAMETER_REF_ENTRY = self.ARRAY_PARAMETER_REF_ENTRY.Pack(builder)
+        ContainerEntryStart(builder)
+        if self.PARAMETER_REF_ENTRY is not None:
+            ContainerEntryAddPARAMETER_REF_ENTRY(builder, PARAMETER_REF_ENTRY)
+        if self.CONTAINER_REF_ENTRY is not None:
+            ContainerEntryAddCONTAINER_REF_ENTRY(builder, CONTAINER_REF_ENTRY)
+        if self.FIXED_VALUE_ENTRY is not None:
+            ContainerEntryAddFIXED_VALUE_ENTRY(builder, FIXED_VALUE_ENTRY)
+        if self.ARRAY_PARAMETER_REF_ENTRY is not None:
+            ContainerEntryAddARRAY_PARAMETER_REF_ENTRY(builder, ARRAY_PARAMETER_REF_ENTRY)
+        containerEntry = ContainerEntryEnd(builder)
+        return containerEntry