spacedatastandards.org 1.73.0__py3-none-any.whl

XTC/BaseMetaCommand.py

@@ -0,0 +1,158 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: 
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+# Base metacommand reference
+class BaseMetaCommand(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = BaseMetaCommand()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsBaseMetaCommand(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    @classmethod
+    def BaseMetaCommandBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x24\x58\x54\x43", size_prefixed=size_prefixed)
+
+    # BaseMetaCommand
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # MetaCommand reference
+    # BaseMetaCommand
+    def META_COMMAND_REF(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
+
+    # Argument assignments for inherited arguments
+    # BaseMetaCommand
+    def ARGUMENT_ASSIGNMENTS(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            x = self._tab.Vector(o)
+            x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
+            x = self._tab.Indirect(x)
+            from ArgumentAssignment import ArgumentAssignment
+            obj = ArgumentAssignment()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # BaseMetaCommand
+    def ARGUMENT_ASSIGNMENTSLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # BaseMetaCommand
+    def ARGUMENT_ASSIGNMENTSIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        return o == 0
+
+def BaseMetaCommandStart(builder):
+    builder.StartObject(2)
+
+def Start(builder):
+    BaseMetaCommandStart(builder)
+
+def BaseMetaCommandAddMETA_COMMAND_REF(builder, META_COMMAND_REF):
+    builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(META_COMMAND_REF), 0)
+
+def AddMETA_COMMAND_REF(builder, META_COMMAND_REF):
+    BaseMetaCommandAddMETA_COMMAND_REF(builder, META_COMMAND_REF)
+
+def BaseMetaCommandAddARGUMENT_ASSIGNMENTS(builder, ARGUMENT_ASSIGNMENTS):
+    builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(ARGUMENT_ASSIGNMENTS), 0)
+
+def AddARGUMENT_ASSIGNMENTS(builder, ARGUMENT_ASSIGNMENTS):
+    BaseMetaCommandAddARGUMENT_ASSIGNMENTS(builder, ARGUMENT_ASSIGNMENTS)
+
+def BaseMetaCommandStartARGUMENT_ASSIGNMENTSVector(builder, numElems):
+    return builder.StartVector(4, numElems, 4)
+
+def StartARGUMENT_ASSIGNMENTSVector(builder, numElems):
+    return BaseMetaCommandStartARGUMENT_ASSIGNMENTSVector(builder, numElems)
+
+def BaseMetaCommandEnd(builder):
+    return builder.EndObject()
+
+def End(builder):
+    return BaseMetaCommandEnd(builder)
+
+import ArgumentAssignment
+try:
+    from typing import List
+except:
+    pass
+
+class BaseMetaCommandT(object):
+
+    # BaseMetaCommandT
+    def __init__(self):
+        self.META_COMMAND_REF = None  # type: str
+        self.ARGUMENT_ASSIGNMENTS = None  # type: List[ArgumentAssignment.ArgumentAssignmentT]
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        baseMetaCommand = BaseMetaCommand()
+        baseMetaCommand.Init(buf, pos)
+        return cls.InitFromObj(baseMetaCommand)
+
+    @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, baseMetaCommand):
+        x = BaseMetaCommandT()
+        x._UnPack(baseMetaCommand)
+        return x
+
+    # BaseMetaCommandT
+    def _UnPack(self, baseMetaCommand):
+        if baseMetaCommand is None:
+            return
+        self.META_COMMAND_REF = baseMetaCommand.META_COMMAND_REF()
+        if not baseMetaCommand.ARGUMENT_ASSIGNMENTSIsNone():
+            self.ARGUMENT_ASSIGNMENTS = []
+            for i in range(baseMetaCommand.ARGUMENT_ASSIGNMENTSLength()):
+                if baseMetaCommand.ARGUMENT_ASSIGNMENTS(i) is None:
+                    self.ARGUMENT_ASSIGNMENTS.append(None)
+                else:
+                    argumentAssignment_ = ArgumentAssignment.ArgumentAssignmentT.InitFromObj(baseMetaCommand.ARGUMENT_ASSIGNMENTS(i))
+                    self.ARGUMENT_ASSIGNMENTS.append(argumentAssignment_)
+
+    # BaseMetaCommandT
+    def Pack(self, builder):
+        if self.META_COMMAND_REF is not None:
+            META_COMMAND_REF = builder.CreateString(self.META_COMMAND_REF)
+        if self.ARGUMENT_ASSIGNMENTS is not None:
+            ARGUMENT_ASSIGNMENTSlist = []
+            for i in range(len(self.ARGUMENT_ASSIGNMENTS)):
+                ARGUMENT_ASSIGNMENTSlist.append(self.ARGUMENT_ASSIGNMENTS[i].Pack(builder))
+            BaseMetaCommandStartARGUMENT_ASSIGNMENTSVector(builder, len(self.ARGUMENT_ASSIGNMENTS))
+            for i in reversed(range(len(self.ARGUMENT_ASSIGNMENTS))):
+                builder.PrependUOffsetTRelative(ARGUMENT_ASSIGNMENTSlist[i])
+            ARGUMENT_ASSIGNMENTS = builder.EndVector()
+        BaseMetaCommandStart(builder)
+        if self.META_COMMAND_REF is not None:
+            BaseMetaCommandAddMETA_COMMAND_REF(builder, META_COMMAND_REF)
+        if self.ARGUMENT_ASSIGNMENTS is not None:
+            BaseMetaCommandAddARGUMENT_ASSIGNMENTS(builder, ARGUMENT_ASSIGNMENTS)
+        baseMetaCommand = BaseMetaCommandEnd(builder)
+        return baseMetaCommand

XTC/BinaryArgumentType.py

@@ -0,0 +1,186 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: 
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+# Binary argument type
+class BinaryArgumentType(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = BinaryArgumentType()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsBinaryArgumentType(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    @classmethod
+    def BinaryArgumentTypeBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x24\x58\x54\x43", size_prefixed=size_prefixed)
+
+    # BinaryArgumentType
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Type name
+    # BinaryArgumentType
+    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
+    # BinaryArgumentType
+    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
+    # BinaryArgumentType
+    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
+
+    # Data encoding
+    # BinaryArgumentType
+    def DATA_ENCODING(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            x = self._tab.Indirect(o + self._tab.Pos)
+            from BinaryDataEncoding import BinaryDataEncoding
+            obj = BinaryDataEncoding()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # Initial/default value (hex string)
+    # BinaryArgumentType
+    def INITIAL_VALUE(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+def BinaryArgumentTypeStart(builder):
+    builder.StartObject(5)
+
+def Start(builder):
+    BinaryArgumentTypeStart(builder)
+
+def BinaryArgumentTypeAddNAME(builder, NAME):
+    builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(NAME), 0)
+
+def AddNAME(builder, NAME):
+    BinaryArgumentTypeAddNAME(builder, NAME)
+
+def BinaryArgumentTypeAddSHORT_DESCRIPTION(builder, SHORT_DESCRIPTION):
+    builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(SHORT_DESCRIPTION), 0)
+
+def AddSHORT_DESCRIPTION(builder, SHORT_DESCRIPTION):
+    BinaryArgumentTypeAddSHORT_DESCRIPTION(builder, SHORT_DESCRIPTION)
+
+def BinaryArgumentTypeAddLONG_DESCRIPTION(builder, LONG_DESCRIPTION):
+    builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(LONG_DESCRIPTION), 0)
+
+def AddLONG_DESCRIPTION(builder, LONG_DESCRIPTION):
+    BinaryArgumentTypeAddLONG_DESCRIPTION(builder, LONG_DESCRIPTION)
+
+def BinaryArgumentTypeAddDATA_ENCODING(builder, DATA_ENCODING):
+    builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(DATA_ENCODING), 0)
+
+def AddDATA_ENCODING(builder, DATA_ENCODING):
+    BinaryArgumentTypeAddDATA_ENCODING(builder, DATA_ENCODING)
+
+def BinaryArgumentTypeAddINITIAL_VALUE(builder, INITIAL_VALUE):
+    builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(INITIAL_VALUE), 0)
+
+def AddINITIAL_VALUE(builder, INITIAL_VALUE):
+    BinaryArgumentTypeAddINITIAL_VALUE(builder, INITIAL_VALUE)
+
+def BinaryArgumentTypeEnd(builder):
+    return builder.EndObject()
+
+def End(builder):
+    return BinaryArgumentTypeEnd(builder)
+
+import BinaryDataEncoding
+try:
+    from typing import Optional
+except:
+    pass
+
+class BinaryArgumentTypeT(object):
+
+    # BinaryArgumentTypeT
+    def __init__(self):
+        self.NAME = None  # type: str
+        self.SHORT_DESCRIPTION = None  # type: str
+        self.LONG_DESCRIPTION = None  # type: str
+        self.DATA_ENCODING = None  # type: Optional[BinaryDataEncoding.BinaryDataEncodingT]
+        self.INITIAL_VALUE = None  # type: str
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        binaryArgumentType = BinaryArgumentType()
+        binaryArgumentType.Init(buf, pos)
+        return cls.InitFromObj(binaryArgumentType)
+
+    @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, binaryArgumentType):
+        x = BinaryArgumentTypeT()
+        x._UnPack(binaryArgumentType)
+        return x
+
+    # BinaryArgumentTypeT
+    def _UnPack(self, binaryArgumentType):
+        if binaryArgumentType is None:
+            return
+        self.NAME = binaryArgumentType.NAME()
+        self.SHORT_DESCRIPTION = binaryArgumentType.SHORT_DESCRIPTION()
+        self.LONG_DESCRIPTION = binaryArgumentType.LONG_DESCRIPTION()
+        if binaryArgumentType.DATA_ENCODING() is not None:
+            self.DATA_ENCODING = BinaryDataEncoding.BinaryDataEncodingT.InitFromObj(binaryArgumentType.DATA_ENCODING())
+        self.INITIAL_VALUE = binaryArgumentType.INITIAL_VALUE()
+
+    # BinaryArgumentTypeT
+    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.DATA_ENCODING is not None:
+            DATA_ENCODING = self.DATA_ENCODING.Pack(builder)
+        if self.INITIAL_VALUE is not None:
+            INITIAL_VALUE = builder.CreateString(self.INITIAL_VALUE)
+        BinaryArgumentTypeStart(builder)
+        if self.NAME is not None:
+            BinaryArgumentTypeAddNAME(builder, NAME)
+        if self.SHORT_DESCRIPTION is not None:
+            BinaryArgumentTypeAddSHORT_DESCRIPTION(builder, SHORT_DESCRIPTION)
+        if self.LONG_DESCRIPTION is not None:
+            BinaryArgumentTypeAddLONG_DESCRIPTION(builder, LONG_DESCRIPTION)
+        if self.DATA_ENCODING is not None:
+            BinaryArgumentTypeAddDATA_ENCODING(builder, DATA_ENCODING)
+        if self.INITIAL_VALUE is not None:
+            BinaryArgumentTypeAddINITIAL_VALUE(builder, INITIAL_VALUE)
+        binaryArgumentType = BinaryArgumentTypeEnd(builder)
+        return binaryArgumentType

XTC/BinaryDataEncoding.py

@@ -0,0 +1,127 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: 
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+# Binary data encoding specification
+class BinaryDataEncoding(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = BinaryDataEncoding()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsBinaryDataEncoding(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    @classmethod
+    def BinaryDataEncodingBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x24\x58\x54\x43", size_prefixed=size_prefixed)
+
+    # BinaryDataEncoding
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Fixed size in bits
+    # BinaryDataEncoding
+    def SIZE_IN_BITS(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint16Flags, o + self._tab.Pos)
+        return 0
+
+    # Maximum size in bits (for variable length)
+    # BinaryDataEncoding
+    def MAX_SIZE_IN_BITS(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint16Flags, o + self._tab.Pos)
+        return 0
+
+    # Leading size field bits (for variable length)
+    # BinaryDataEncoding
+    def LEADING_SIZE_BITS(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
+        return 0
+
+def BinaryDataEncodingStart(builder):
+    builder.StartObject(3)
+
+def Start(builder):
+    BinaryDataEncodingStart(builder)
+
+def BinaryDataEncodingAddSIZE_IN_BITS(builder, SIZE_IN_BITS):
+    builder.PrependUint16Slot(0, SIZE_IN_BITS, 0)
+
+def AddSIZE_IN_BITS(builder, SIZE_IN_BITS):
+    BinaryDataEncodingAddSIZE_IN_BITS(builder, SIZE_IN_BITS)
+
+def BinaryDataEncodingAddMAX_SIZE_IN_BITS(builder, MAX_SIZE_IN_BITS):
+    builder.PrependUint16Slot(1, MAX_SIZE_IN_BITS, 0)
+
+def AddMAX_SIZE_IN_BITS(builder, MAX_SIZE_IN_BITS):
+    BinaryDataEncodingAddMAX_SIZE_IN_BITS(builder, MAX_SIZE_IN_BITS)
+
+def BinaryDataEncodingAddLEADING_SIZE_BITS(builder, LEADING_SIZE_BITS):
+    builder.PrependUint8Slot(2, LEADING_SIZE_BITS, 0)
+
+def AddLEADING_SIZE_BITS(builder, LEADING_SIZE_BITS):
+    BinaryDataEncodingAddLEADING_SIZE_BITS(builder, LEADING_SIZE_BITS)
+
+def BinaryDataEncodingEnd(builder):
+    return builder.EndObject()
+
+def End(builder):
+    return BinaryDataEncodingEnd(builder)
+
+
+class BinaryDataEncodingT(object):
+
+    # BinaryDataEncodingT
+    def __init__(self):
+        self.SIZE_IN_BITS = 0  # type: int
+        self.MAX_SIZE_IN_BITS = 0  # type: int
+        self.LEADING_SIZE_BITS = 0  # type: int
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        binaryDataEncoding = BinaryDataEncoding()
+        binaryDataEncoding.Init(buf, pos)
+        return cls.InitFromObj(binaryDataEncoding)
+
+    @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, binaryDataEncoding):
+        x = BinaryDataEncodingT()
+        x._UnPack(binaryDataEncoding)
+        return x
+
+    # BinaryDataEncodingT
+    def _UnPack(self, binaryDataEncoding):
+        if binaryDataEncoding is None:
+            return
+        self.SIZE_IN_BITS = binaryDataEncoding.SIZE_IN_BITS()
+        self.MAX_SIZE_IN_BITS = binaryDataEncoding.MAX_SIZE_IN_BITS()
+        self.LEADING_SIZE_BITS = binaryDataEncoding.LEADING_SIZE_BITS()
+
+    # BinaryDataEncodingT
+    def Pack(self, builder):
+        BinaryDataEncodingStart(builder)
+        BinaryDataEncodingAddSIZE_IN_BITS(builder, self.SIZE_IN_BITS)
+        BinaryDataEncodingAddMAX_SIZE_IN_BITS(builder, self.MAX_SIZE_IN_BITS)
+        BinaryDataEncodingAddLEADING_SIZE_BITS(builder, self.LEADING_SIZE_BITS)
+        binaryDataEncoding = BinaryDataEncodingEnd(builder)
+        return binaryDataEncoding

XTC/BinaryParameterType.py

@@ -0,0 +1,186 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: 
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+# Binary parameter type
+class BinaryParameterType(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = BinaryParameterType()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsBinaryParameterType(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    @classmethod
+    def BinaryParameterTypeBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x24\x58\x54\x43", size_prefixed=size_prefixed)
+
+    # BinaryParameterType
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Type name
+    # BinaryParameterType
+    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
+    # BinaryParameterType
+    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
+    # BinaryParameterType
+    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
+
+    # Data encoding
+    # BinaryParameterType
+    def DATA_ENCODING(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            x = self._tab.Indirect(o + self._tab.Pos)
+            from BinaryDataEncoding import BinaryDataEncoding
+            obj = BinaryDataEncoding()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # Initial/default value (hex string)
+    # BinaryParameterType
+    def INITIAL_VALUE(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+def BinaryParameterTypeStart(builder):
+    builder.StartObject(5)
+
+def Start(builder):
+    BinaryParameterTypeStart(builder)
+
+def BinaryParameterTypeAddNAME(builder, NAME):
+    builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(NAME), 0)
+
+def AddNAME(builder, NAME):
+    BinaryParameterTypeAddNAME(builder, NAME)
+
+def BinaryParameterTypeAddSHORT_DESCRIPTION(builder, SHORT_DESCRIPTION):
+    builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(SHORT_DESCRIPTION), 0)
+
+def AddSHORT_DESCRIPTION(builder, SHORT_DESCRIPTION):
+    BinaryParameterTypeAddSHORT_DESCRIPTION(builder, SHORT_DESCRIPTION)
+
+def BinaryParameterTypeAddLONG_DESCRIPTION(builder, LONG_DESCRIPTION):
+    builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(LONG_DESCRIPTION), 0)
+
+def AddLONG_DESCRIPTION(builder, LONG_DESCRIPTION):
+    BinaryParameterTypeAddLONG_DESCRIPTION(builder, LONG_DESCRIPTION)
+
+def BinaryParameterTypeAddDATA_ENCODING(builder, DATA_ENCODING):
+    builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(DATA_ENCODING), 0)
+
+def AddDATA_ENCODING(builder, DATA_ENCODING):
+    BinaryParameterTypeAddDATA_ENCODING(builder, DATA_ENCODING)
+
+def BinaryParameterTypeAddINITIAL_VALUE(builder, INITIAL_VALUE):
+    builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(INITIAL_VALUE), 0)
+
+def AddINITIAL_VALUE(builder, INITIAL_VALUE):
+    BinaryParameterTypeAddINITIAL_VALUE(builder, INITIAL_VALUE)
+
+def BinaryParameterTypeEnd(builder):
+    return builder.EndObject()
+
+def End(builder):
+    return BinaryParameterTypeEnd(builder)
+
+import BinaryDataEncoding
+try:
+    from typing import Optional
+except:
+    pass
+
+class BinaryParameterTypeT(object):
+
+    # BinaryParameterTypeT
+    def __init__(self):
+        self.NAME = None  # type: str
+        self.SHORT_DESCRIPTION = None  # type: str
+        self.LONG_DESCRIPTION = None  # type: str
+        self.DATA_ENCODING = None  # type: Optional[BinaryDataEncoding.BinaryDataEncodingT]
+        self.INITIAL_VALUE = None  # type: str
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        binaryParameterType = BinaryParameterType()
+        binaryParameterType.Init(buf, pos)
+        return cls.InitFromObj(binaryParameterType)
+
+    @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, binaryParameterType):
+        x = BinaryParameterTypeT()
+        x._UnPack(binaryParameterType)
+        return x
+
+    # BinaryParameterTypeT
+    def _UnPack(self, binaryParameterType):
+        if binaryParameterType is None:
+            return
+        self.NAME = binaryParameterType.NAME()
+        self.SHORT_DESCRIPTION = binaryParameterType.SHORT_DESCRIPTION()
+        self.LONG_DESCRIPTION = binaryParameterType.LONG_DESCRIPTION()
+        if binaryParameterType.DATA_ENCODING() is not None:
+            self.DATA_ENCODING = BinaryDataEncoding.BinaryDataEncodingT.InitFromObj(binaryParameterType.DATA_ENCODING())
+        self.INITIAL_VALUE = binaryParameterType.INITIAL_VALUE()
+
+    # BinaryParameterTypeT
+    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.DATA_ENCODING is not None:
+            DATA_ENCODING = self.DATA_ENCODING.Pack(builder)
+        if self.INITIAL_VALUE is not None:
+            INITIAL_VALUE = builder.CreateString(self.INITIAL_VALUE)
+        BinaryParameterTypeStart(builder)
+        if self.NAME is not None:
+            BinaryParameterTypeAddNAME(builder, NAME)
+        if self.SHORT_DESCRIPTION is not None:
+            BinaryParameterTypeAddSHORT_DESCRIPTION(builder, SHORT_DESCRIPTION)
+        if self.LONG_DESCRIPTION is not None:
+            BinaryParameterTypeAddLONG_DESCRIPTION(builder, LONG_DESCRIPTION)
+        if self.DATA_ENCODING is not None:
+            BinaryParameterTypeAddDATA_ENCODING(builder, DATA_ENCODING)
+        if self.INITIAL_VALUE is not None:
+            BinaryParameterTypeAddINITIAL_VALUE(builder, INITIAL_VALUE)
+        binaryParameterType = BinaryParameterTypeEnd(builder)
+        return binaryParameterType