spacedatastandards.org 1.73.0__py3-none-any.whl

XTC/RepeatEntry.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()
+
+# Repeat entry specification
+class RepeatEntry(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = RepeatEntry()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsRepeatEntry(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    @classmethod
+    def RepeatEntryBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x24\x58\x54\x43", size_prefixed=size_prefixed)
+
+    # RepeatEntry
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Fixed repeat count
+    # RepeatEntry
+    def COUNT(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
+        return 0
+
+    # Dynamic count from parameter reference
+    # RepeatEntry
+    def COUNT_PARAMETER_REF(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
+
+    # Offset in bits between repetitions
+    # RepeatEntry
+    def OFFSET_IN_BITS(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
+        return 0
+
+def RepeatEntryStart(builder):
+    builder.StartObject(3)
+
+def Start(builder):
+    RepeatEntryStart(builder)
+
+def RepeatEntryAddCOUNT(builder, COUNT):
+    builder.PrependUint32Slot(0, COUNT, 0)
+
+def AddCOUNT(builder, COUNT):
+    RepeatEntryAddCOUNT(builder, COUNT)
+
+def RepeatEntryAddCOUNT_PARAMETER_REF(builder, COUNT_PARAMETER_REF):
+    builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(COUNT_PARAMETER_REF), 0)
+
+def AddCOUNT_PARAMETER_REF(builder, COUNT_PARAMETER_REF):
+    RepeatEntryAddCOUNT_PARAMETER_REF(builder, COUNT_PARAMETER_REF)
+
+def RepeatEntryAddOFFSET_IN_BITS(builder, OFFSET_IN_BITS):
+    builder.PrependInt32Slot(2, OFFSET_IN_BITS, 0)
+
+def AddOFFSET_IN_BITS(builder, OFFSET_IN_BITS):
+    RepeatEntryAddOFFSET_IN_BITS(builder, OFFSET_IN_BITS)
+
+def RepeatEntryEnd(builder):
+    return builder.EndObject()
+
+def End(builder):
+    return RepeatEntryEnd(builder)
+
+
+class RepeatEntryT(object):
+
+    # RepeatEntryT
+    def __init__(self):
+        self.COUNT = 0  # type: int
+        self.COUNT_PARAMETER_REF = None  # type: str
+        self.OFFSET_IN_BITS = 0  # type: int
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        repeatEntry = RepeatEntry()
+        repeatEntry.Init(buf, pos)
+        return cls.InitFromObj(repeatEntry)
+
+    @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, repeatEntry):
+        x = RepeatEntryT()
+        x._UnPack(repeatEntry)
+        return x
+
+    # RepeatEntryT
+    def _UnPack(self, repeatEntry):
+        if repeatEntry is None:
+            return
+        self.COUNT = repeatEntry.COUNT()
+        self.COUNT_PARAMETER_REF = repeatEntry.COUNT_PARAMETER_REF()
+        self.OFFSET_IN_BITS = repeatEntry.OFFSET_IN_BITS()
+
+    # RepeatEntryT
+    def Pack(self, builder):
+        if self.COUNT_PARAMETER_REF is not None:
+            COUNT_PARAMETER_REF = builder.CreateString(self.COUNT_PARAMETER_REF)
+        RepeatEntryStart(builder)
+        RepeatEntryAddCOUNT(builder, self.COUNT)
+        if self.COUNT_PARAMETER_REF is not None:
+            RepeatEntryAddCOUNT_PARAMETER_REF(builder, COUNT_PARAMETER_REF)
+        RepeatEntryAddOFFSET_IN_BITS(builder, self.OFFSET_IN_BITS)
+        repeatEntry = RepeatEntryEnd(builder)
+        return repeatEntry

XTC/SequenceContainer.py

@@ -0,0 +1,313 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: 
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+# Sequence container (packet definition)
+class SequenceContainer(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = SequenceContainer()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsSequenceContainer(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    @classmethod
+    def SequenceContainerBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x24\x58\x54\x43", size_prefixed=size_prefixed)
+
+    # SequenceContainer
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Container name
+    # SequenceContainer
+    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
+
+    # Short description
+    # SequenceContainer
+    def SHORT_DESCRIPTION(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
+
+    # Long description
+    # SequenceContainer
+    def LONG_DESCRIPTION(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Abstract container (used as base only)
+    # SequenceContainer
+    def ABSTRACT(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # Container entry list
+    # SequenceContainer
+    def ENTRY_LIST(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            x = self._tab.Vector(o)
+            x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
+            x = self._tab.Indirect(x)
+            from ContainerEntry import ContainerEntry
+            obj = ContainerEntry()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # SequenceContainer
+    def ENTRY_LISTLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # SequenceContainer
+    def ENTRY_LISTIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        return o == 0
+
+    # Base container (inheritance)
+    # SequenceContainer
+    def BASE_CONTAINER(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        if o != 0:
+            x = self._tab.Indirect(o + self._tab.Pos)
+            from BaseContainer import BaseContainer
+            obj = BaseContainer()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # Binary encoding
+    # SequenceContainer
+    def BINARY_ENCODING(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
+        if o != 0:
+            x = self._tab.Indirect(o + self._tab.Pos)
+            from ContainerBinaryEncoding import ContainerBinaryEncoding
+            obj = ContainerBinaryEncoding()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # Rate in stream
+    # SequenceContainer
+    def RATE_IN_STREAM(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
+        if o != 0:
+            x = self._tab.Indirect(o + self._tab.Pos)
+            from RateInStream import RateInStream
+            obj = RateInStream()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # Idle pattern (hex string for padding)
+    # SequenceContainer
+    def IDLE_PATTERN(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+def SequenceContainerStart(builder):
+    builder.StartObject(9)
+
+def Start(builder):
+    SequenceContainerStart(builder)
+
+def SequenceContainerAddNAME(builder, NAME):
+    builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(NAME), 0)
+
+def AddNAME(builder, NAME):
+    SequenceContainerAddNAME(builder, NAME)
+
+def SequenceContainerAddSHORT_DESCRIPTION(builder, SHORT_DESCRIPTION):
+    builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(SHORT_DESCRIPTION), 0)
+
+def AddSHORT_DESCRIPTION(builder, SHORT_DESCRIPTION):
+    SequenceContainerAddSHORT_DESCRIPTION(builder, SHORT_DESCRIPTION)
+
+def SequenceContainerAddLONG_DESCRIPTION(builder, LONG_DESCRIPTION):
+    builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(LONG_DESCRIPTION), 0)
+
+def AddLONG_DESCRIPTION(builder, LONG_DESCRIPTION):
+    SequenceContainerAddLONG_DESCRIPTION(builder, LONG_DESCRIPTION)
+
+def SequenceContainerAddABSTRACT(builder, ABSTRACT):
+    builder.PrependBoolSlot(3, ABSTRACT, 0)
+
+def AddABSTRACT(builder, ABSTRACT):
+    SequenceContainerAddABSTRACT(builder, ABSTRACT)
+
+def SequenceContainerAddENTRY_LIST(builder, ENTRY_LIST):
+    builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(ENTRY_LIST), 0)
+
+def AddENTRY_LIST(builder, ENTRY_LIST):
+    SequenceContainerAddENTRY_LIST(builder, ENTRY_LIST)
+
+def SequenceContainerStartENTRY_LISTVector(builder, numElems):
+    return builder.StartVector(4, numElems, 4)
+
+def StartENTRY_LISTVector(builder, numElems):
+    return SequenceContainerStartENTRY_LISTVector(builder, numElems)
+
+def SequenceContainerAddBASE_CONTAINER(builder, BASE_CONTAINER):
+    builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(BASE_CONTAINER), 0)
+
+def AddBASE_CONTAINER(builder, BASE_CONTAINER):
+    SequenceContainerAddBASE_CONTAINER(builder, BASE_CONTAINER)
+
+def SequenceContainerAddBINARY_ENCODING(builder, BINARY_ENCODING):
+    builder.PrependUOffsetTRelativeSlot(6, flatbuffers.number_types.UOffsetTFlags.py_type(BINARY_ENCODING), 0)
+
+def AddBINARY_ENCODING(builder, BINARY_ENCODING):
+    SequenceContainerAddBINARY_ENCODING(builder, BINARY_ENCODING)
+
+def SequenceContainerAddRATE_IN_STREAM(builder, RATE_IN_STREAM):
+    builder.PrependUOffsetTRelativeSlot(7, flatbuffers.number_types.UOffsetTFlags.py_type(RATE_IN_STREAM), 0)
+
+def AddRATE_IN_STREAM(builder, RATE_IN_STREAM):
+    SequenceContainerAddRATE_IN_STREAM(builder, RATE_IN_STREAM)
+
+def SequenceContainerAddIDLE_PATTERN(builder, IDLE_PATTERN):
+    builder.PrependUOffsetTRelativeSlot(8, flatbuffers.number_types.UOffsetTFlags.py_type(IDLE_PATTERN), 0)
+
+def AddIDLE_PATTERN(builder, IDLE_PATTERN):
+    SequenceContainerAddIDLE_PATTERN(builder, IDLE_PATTERN)
+
+def SequenceContainerEnd(builder):
+    return builder.EndObject()
+
+def End(builder):
+    return SequenceContainerEnd(builder)
+
+import BaseContainer
+import ContainerBinaryEncoding
+import ContainerEntry
+import RateInStream
+try:
+    from typing import List, Optional
+except:
+    pass
+
+class SequenceContainerT(object):
+
+    # SequenceContainerT
+    def __init__(self):
+        self.NAME = None  # type: str
+        self.SHORT_DESCRIPTION = None  # type: str
+        self.LONG_DESCRIPTION = None  # type: str
+        self.ABSTRACT = False  # type: bool
+        self.ENTRY_LIST = None  # type: List[ContainerEntry.ContainerEntryT]
+        self.BASE_CONTAINER = None  # type: Optional[BaseContainer.BaseContainerT]
+        self.BINARY_ENCODING = None  # type: Optional[ContainerBinaryEncoding.ContainerBinaryEncodingT]
+        self.RATE_IN_STREAM = None  # type: Optional[RateInStream.RateInStreamT]
+        self.IDLE_PATTERN = None  # type: str
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        sequenceContainer = SequenceContainer()
+        sequenceContainer.Init(buf, pos)
+        return cls.InitFromObj(sequenceContainer)
+
+    @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, sequenceContainer):
+        x = SequenceContainerT()
+        x._UnPack(sequenceContainer)
+        return x
+
+    # SequenceContainerT
+    def _UnPack(self, sequenceContainer):
+        if sequenceContainer is None:
+            return
+        self.NAME = sequenceContainer.NAME()
+        self.SHORT_DESCRIPTION = sequenceContainer.SHORT_DESCRIPTION()
+        self.LONG_DESCRIPTION = sequenceContainer.LONG_DESCRIPTION()
+        self.ABSTRACT = sequenceContainer.ABSTRACT()
+        if not sequenceContainer.ENTRY_LISTIsNone():
+            self.ENTRY_LIST = []
+            for i in range(sequenceContainer.ENTRY_LISTLength()):
+                if sequenceContainer.ENTRY_LIST(i) is None:
+                    self.ENTRY_LIST.append(None)
+                else:
+                    containerEntry_ = ContainerEntry.ContainerEntryT.InitFromObj(sequenceContainer.ENTRY_LIST(i))
+                    self.ENTRY_LIST.append(containerEntry_)
+        if sequenceContainer.BASE_CONTAINER() is not None:
+            self.BASE_CONTAINER = BaseContainer.BaseContainerT.InitFromObj(sequenceContainer.BASE_CONTAINER())
+        if sequenceContainer.BINARY_ENCODING() is not None:
+            self.BINARY_ENCODING = ContainerBinaryEncoding.ContainerBinaryEncodingT.InitFromObj(sequenceContainer.BINARY_ENCODING())
+        if sequenceContainer.RATE_IN_STREAM() is not None:
+            self.RATE_IN_STREAM = RateInStream.RateInStreamT.InitFromObj(sequenceContainer.RATE_IN_STREAM())
+        self.IDLE_PATTERN = sequenceContainer.IDLE_PATTERN()
+
+    # SequenceContainerT
+    def Pack(self, builder):
+        if self.NAME is not None:
+            NAME = builder.CreateString(self.NAME)
+        if self.SHORT_DESCRIPTION is not None:
+            SHORT_DESCRIPTION = builder.CreateString(self.SHORT_DESCRIPTION)
+        if self.LONG_DESCRIPTION is not None:
+            LONG_DESCRIPTION = builder.CreateString(self.LONG_DESCRIPTION)
+        if self.ENTRY_LIST is not None:
+            ENTRY_LISTlist = []
+            for i in range(len(self.ENTRY_LIST)):
+                ENTRY_LISTlist.append(self.ENTRY_LIST[i].Pack(builder))
+            SequenceContainerStartENTRY_LISTVector(builder, len(self.ENTRY_LIST))
+            for i in reversed(range(len(self.ENTRY_LIST))):
+                builder.PrependUOffsetTRelative(ENTRY_LISTlist[i])
+            ENTRY_LIST = builder.EndVector()
+        if self.BASE_CONTAINER is not None:
+            BASE_CONTAINER = self.BASE_CONTAINER.Pack(builder)
+        if self.BINARY_ENCODING is not None:
+            BINARY_ENCODING = self.BINARY_ENCODING.Pack(builder)
+        if self.RATE_IN_STREAM is not None:
+            RATE_IN_STREAM = self.RATE_IN_STREAM.Pack(builder)
+        if self.IDLE_PATTERN is not None:
+            IDLE_PATTERN = builder.CreateString(self.IDLE_PATTERN)
+        SequenceContainerStart(builder)
+        if self.NAME is not None:
+            SequenceContainerAddNAME(builder, NAME)
+        if self.SHORT_DESCRIPTION is not None:
+            SequenceContainerAddSHORT_DESCRIPTION(builder, SHORT_DESCRIPTION)
+        if self.LONG_DESCRIPTION is not None:
+            SequenceContainerAddLONG_DESCRIPTION(builder, LONG_DESCRIPTION)
+        SequenceContainerAddABSTRACT(builder, self.ABSTRACT)
+        if self.ENTRY_LIST is not None:
+            SequenceContainerAddENTRY_LIST(builder, ENTRY_LIST)
+        if self.BASE_CONTAINER is not None:
+            SequenceContainerAddBASE_CONTAINER(builder, BASE_CONTAINER)
+        if self.BINARY_ENCODING is not None:
+            SequenceContainerAddBINARY_ENCODING(builder, BINARY_ENCODING)
+        if self.RATE_IN_STREAM is not None:
+            SequenceContainerAddRATE_IN_STREAM(builder, RATE_IN_STREAM)
+        if self.IDLE_PATTERN is not None:
+            SequenceContainerAddIDLE_PATTERN(builder, IDLE_PATTERN)
+        sequenceContainer = SequenceContainerEnd(builder)
+        return sequenceContainer

XTC/Service.py

@@ -0,0 +1,236 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: 
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+# Service definition
+class Service(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = Service()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsService(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    @classmethod
+    def ServiceBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x24\x58\x54\x43", size_prefixed=size_prefixed)
+
+    # Service
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Service name
+    # Service
+    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
+
+    # Short description
+    # Service
+    def SHORT_DESCRIPTION(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
+
+    # Long description
+    # Service
+    def LONG_DESCRIPTION(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Container references provided by this service
+    # Service
+    def CONTAINER_REFS(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.String(a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4))
+        return ""
+
+    # Service
+    def CONTAINER_REFSLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # Service
+    def CONTAINER_REFSIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        return o == 0
+
+    # Command references accepted by this service
+    # Service
+    def COMMAND_REFS(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.String(a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4))
+        return ""
+
+    # Service
+    def COMMAND_REFSLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # Service
+    def COMMAND_REFSIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        return o == 0
+
+def ServiceStart(builder):
+    builder.StartObject(5)
+
+def Start(builder):
+    ServiceStart(builder)
+
+def ServiceAddNAME(builder, NAME):
+    builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(NAME), 0)
+
+def AddNAME(builder, NAME):
+    ServiceAddNAME(builder, NAME)
+
+def ServiceAddSHORT_DESCRIPTION(builder, SHORT_DESCRIPTION):
+    builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(SHORT_DESCRIPTION), 0)
+
+def AddSHORT_DESCRIPTION(builder, SHORT_DESCRIPTION):
+    ServiceAddSHORT_DESCRIPTION(builder, SHORT_DESCRIPTION)
+
+def ServiceAddLONG_DESCRIPTION(builder, LONG_DESCRIPTION):
+    builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(LONG_DESCRIPTION), 0)
+
+def AddLONG_DESCRIPTION(builder, LONG_DESCRIPTION):
+    ServiceAddLONG_DESCRIPTION(builder, LONG_DESCRIPTION)
+
+def ServiceAddCONTAINER_REFS(builder, CONTAINER_REFS):
+    builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(CONTAINER_REFS), 0)
+
+def AddCONTAINER_REFS(builder, CONTAINER_REFS):
+    ServiceAddCONTAINER_REFS(builder, CONTAINER_REFS)
+
+def ServiceStartCONTAINER_REFSVector(builder, numElems):
+    return builder.StartVector(4, numElems, 4)
+
+def StartCONTAINER_REFSVector(builder, numElems):
+    return ServiceStartCONTAINER_REFSVector(builder, numElems)
+
+def ServiceAddCOMMAND_REFS(builder, COMMAND_REFS):
+    builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(COMMAND_REFS), 0)
+
+def AddCOMMAND_REFS(builder, COMMAND_REFS):
+    ServiceAddCOMMAND_REFS(builder, COMMAND_REFS)
+
+def ServiceStartCOMMAND_REFSVector(builder, numElems):
+    return builder.StartVector(4, numElems, 4)
+
+def StartCOMMAND_REFSVector(builder, numElems):
+    return ServiceStartCOMMAND_REFSVector(builder, numElems)
+
+def ServiceEnd(builder):
+    return builder.EndObject()
+
+def End(builder):
+    return ServiceEnd(builder)
+
+try:
+    from typing import List
+except:
+    pass
+
+class ServiceT(object):
+
+    # ServiceT
+    def __init__(self):
+        self.NAME = None  # type: str
+        self.SHORT_DESCRIPTION = None  # type: str
+        self.LONG_DESCRIPTION = None  # type: str
+        self.CONTAINER_REFS = None  # type: List[str]
+        self.COMMAND_REFS = None  # type: List[str]
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        service = Service()
+        service.Init(buf, pos)
+        return cls.InitFromObj(service)
+
+    @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, service):
+        x = ServiceT()
+        x._UnPack(service)
+        return x
+
+    # ServiceT
+    def _UnPack(self, service):
+        if service is None:
+            return
+        self.NAME = service.NAME()
+        self.SHORT_DESCRIPTION = service.SHORT_DESCRIPTION()
+        self.LONG_DESCRIPTION = service.LONG_DESCRIPTION()
+        if not service.CONTAINER_REFSIsNone():
+            self.CONTAINER_REFS = []
+            for i in range(service.CONTAINER_REFSLength()):
+                self.CONTAINER_REFS.append(service.CONTAINER_REFS(i))
+        if not service.COMMAND_REFSIsNone():
+            self.COMMAND_REFS = []
+            for i in range(service.COMMAND_REFSLength()):
+                self.COMMAND_REFS.append(service.COMMAND_REFS(i))
+
+    # ServiceT
+    def Pack(self, builder):
+        if self.NAME is not None:
+            NAME = builder.CreateString(self.NAME)
+        if self.SHORT_DESCRIPTION is not None:
+            SHORT_DESCRIPTION = builder.CreateString(self.SHORT_DESCRIPTION)
+        if self.LONG_DESCRIPTION is not None:
+            LONG_DESCRIPTION = builder.CreateString(self.LONG_DESCRIPTION)
+        if self.CONTAINER_REFS is not None:
+            CONTAINER_REFSlist = []
+            for i in range(len(self.CONTAINER_REFS)):
+                CONTAINER_REFSlist.append(builder.CreateString(self.CONTAINER_REFS[i]))
+            ServiceStartCONTAINER_REFSVector(builder, len(self.CONTAINER_REFS))
+            for i in reversed(range(len(self.CONTAINER_REFS))):
+                builder.PrependUOffsetTRelative(CONTAINER_REFSlist[i])
+            CONTAINER_REFS = builder.EndVector()
+        if self.COMMAND_REFS is not None:
+            COMMAND_REFSlist = []
+            for i in range(len(self.COMMAND_REFS)):
+                COMMAND_REFSlist.append(builder.CreateString(self.COMMAND_REFS[i]))
+            ServiceStartCOMMAND_REFSVector(builder, len(self.COMMAND_REFS))
+            for i in reversed(range(len(self.COMMAND_REFS))):
+                builder.PrependUOffsetTRelative(COMMAND_REFSlist[i])
+            COMMAND_REFS = builder.EndVector()
+        ServiceStart(builder)
+        if self.NAME is not None:
+            ServiceAddNAME(builder, NAME)
+        if self.SHORT_DESCRIPTION is not None:
+            ServiceAddSHORT_DESCRIPTION(builder, SHORT_DESCRIPTION)
+        if self.LONG_DESCRIPTION is not None:
+            ServiceAddLONG_DESCRIPTION(builder, LONG_DESCRIPTION)
+        if self.CONTAINER_REFS is not None:
+            ServiceAddCONTAINER_REFS(builder, CONTAINER_REFS)
+        if self.COMMAND_REFS is not None:
+            ServiceAddCOMMAND_REFS(builder, COMMAND_REFS)
+        service = ServiceEnd(builder)
+        return service