spacedatastandards.org 1.73.0__py3-none-any.whl

XTC/StreamSet.py

@@ -0,0 +1,254 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: 
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+# Collection of streams
+class StreamSet(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = StreamSet()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsStreamSet(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    @classmethod
+    def StreamSetBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x24\x58\x54\x43", size_prefixed=size_prefixed)
+
+    # StreamSet
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Fixed frame streams
+    # StreamSet
+    def FIXED_FRAME_STREAMS(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            x = self._tab.Vector(o)
+            x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
+            x = self._tab.Indirect(x)
+            from FixedFrameStream import FixedFrameStream
+            obj = FixedFrameStream()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # StreamSet
+    def FIXED_FRAME_STREAMSLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # StreamSet
+    def FIXED_FRAME_STREAMSIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        return o == 0
+
+    # Variable frame streams
+    # StreamSet
+    def VARIABLE_FRAME_STREAMS(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 VariableFrameStream import VariableFrameStream
+            obj = VariableFrameStream()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # StreamSet
+    def VARIABLE_FRAME_STREAMSLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # StreamSet
+    def VARIABLE_FRAME_STREAMSIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        return o == 0
+
+    # Custom streams
+    # StreamSet
+    def CUSTOM_STREAMS(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            x = self._tab.Vector(o)
+            x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
+            x = self._tab.Indirect(x)
+            from CustomStream import CustomStream
+            obj = CustomStream()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # StreamSet
+    def CUSTOM_STREAMSLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # StreamSet
+    def CUSTOM_STREAMSIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        return o == 0
+
+def StreamSetStart(builder):
+    builder.StartObject(3)
+
+def Start(builder):
+    StreamSetStart(builder)
+
+def StreamSetAddFIXED_FRAME_STREAMS(builder, FIXED_FRAME_STREAMS):
+    builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(FIXED_FRAME_STREAMS), 0)
+
+def AddFIXED_FRAME_STREAMS(builder, FIXED_FRAME_STREAMS):
+    StreamSetAddFIXED_FRAME_STREAMS(builder, FIXED_FRAME_STREAMS)
+
+def StreamSetStartFIXED_FRAME_STREAMSVector(builder, numElems):
+    return builder.StartVector(4, numElems, 4)
+
+def StartFIXED_FRAME_STREAMSVector(builder, numElems):
+    return StreamSetStartFIXED_FRAME_STREAMSVector(builder, numElems)
+
+def StreamSetAddVARIABLE_FRAME_STREAMS(builder, VARIABLE_FRAME_STREAMS):
+    builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(VARIABLE_FRAME_STREAMS), 0)
+
+def AddVARIABLE_FRAME_STREAMS(builder, VARIABLE_FRAME_STREAMS):
+    StreamSetAddVARIABLE_FRAME_STREAMS(builder, VARIABLE_FRAME_STREAMS)
+
+def StreamSetStartVARIABLE_FRAME_STREAMSVector(builder, numElems):
+    return builder.StartVector(4, numElems, 4)
+
+def StartVARIABLE_FRAME_STREAMSVector(builder, numElems):
+    return StreamSetStartVARIABLE_FRAME_STREAMSVector(builder, numElems)
+
+def StreamSetAddCUSTOM_STREAMS(builder, CUSTOM_STREAMS):
+    builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(CUSTOM_STREAMS), 0)
+
+def AddCUSTOM_STREAMS(builder, CUSTOM_STREAMS):
+    StreamSetAddCUSTOM_STREAMS(builder, CUSTOM_STREAMS)
+
+def StreamSetStartCUSTOM_STREAMSVector(builder, numElems):
+    return builder.StartVector(4, numElems, 4)
+
+def StartCUSTOM_STREAMSVector(builder, numElems):
+    return StreamSetStartCUSTOM_STREAMSVector(builder, numElems)
+
+def StreamSetEnd(builder):
+    return builder.EndObject()
+
+def End(builder):
+    return StreamSetEnd(builder)
+
+import CustomStream
+import FixedFrameStream
+import VariableFrameStream
+try:
+    from typing import List
+except:
+    pass
+
+class StreamSetT(object):
+
+    # StreamSetT
+    def __init__(self):
+        self.FIXED_FRAME_STREAMS = None  # type: List[FixedFrameStream.FixedFrameStreamT]
+        self.VARIABLE_FRAME_STREAMS = None  # type: List[VariableFrameStream.VariableFrameStreamT]
+        self.CUSTOM_STREAMS = None  # type: List[CustomStream.CustomStreamT]
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        streamSet = StreamSet()
+        streamSet.Init(buf, pos)
+        return cls.InitFromObj(streamSet)
+
+    @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, streamSet):
+        x = StreamSetT()
+        x._UnPack(streamSet)
+        return x
+
+    # StreamSetT
+    def _UnPack(self, streamSet):
+        if streamSet is None:
+            return
+        if not streamSet.FIXED_FRAME_STREAMSIsNone():
+            self.FIXED_FRAME_STREAMS = []
+            for i in range(streamSet.FIXED_FRAME_STREAMSLength()):
+                if streamSet.FIXED_FRAME_STREAMS(i) is None:
+                    self.FIXED_FRAME_STREAMS.append(None)
+                else:
+                    fixedFrameStream_ = FixedFrameStream.FixedFrameStreamT.InitFromObj(streamSet.FIXED_FRAME_STREAMS(i))
+                    self.FIXED_FRAME_STREAMS.append(fixedFrameStream_)
+        if not streamSet.VARIABLE_FRAME_STREAMSIsNone():
+            self.VARIABLE_FRAME_STREAMS = []
+            for i in range(streamSet.VARIABLE_FRAME_STREAMSLength()):
+                if streamSet.VARIABLE_FRAME_STREAMS(i) is None:
+                    self.VARIABLE_FRAME_STREAMS.append(None)
+                else:
+                    variableFrameStream_ = VariableFrameStream.VariableFrameStreamT.InitFromObj(streamSet.VARIABLE_FRAME_STREAMS(i))
+                    self.VARIABLE_FRAME_STREAMS.append(variableFrameStream_)
+        if not streamSet.CUSTOM_STREAMSIsNone():
+            self.CUSTOM_STREAMS = []
+            for i in range(streamSet.CUSTOM_STREAMSLength()):
+                if streamSet.CUSTOM_STREAMS(i) is None:
+                    self.CUSTOM_STREAMS.append(None)
+                else:
+                    customStream_ = CustomStream.CustomStreamT.InitFromObj(streamSet.CUSTOM_STREAMS(i))
+                    self.CUSTOM_STREAMS.append(customStream_)
+
+    # StreamSetT
+    def Pack(self, builder):
+        if self.FIXED_FRAME_STREAMS is not None:
+            FIXED_FRAME_STREAMSlist = []
+            for i in range(len(self.FIXED_FRAME_STREAMS)):
+                FIXED_FRAME_STREAMSlist.append(self.FIXED_FRAME_STREAMS[i].Pack(builder))
+            StreamSetStartFIXED_FRAME_STREAMSVector(builder, len(self.FIXED_FRAME_STREAMS))
+            for i in reversed(range(len(self.FIXED_FRAME_STREAMS))):
+                builder.PrependUOffsetTRelative(FIXED_FRAME_STREAMSlist[i])
+            FIXED_FRAME_STREAMS = builder.EndVector()
+        if self.VARIABLE_FRAME_STREAMS is not None:
+            VARIABLE_FRAME_STREAMSlist = []
+            for i in range(len(self.VARIABLE_FRAME_STREAMS)):
+                VARIABLE_FRAME_STREAMSlist.append(self.VARIABLE_FRAME_STREAMS[i].Pack(builder))
+            StreamSetStartVARIABLE_FRAME_STREAMSVector(builder, len(self.VARIABLE_FRAME_STREAMS))
+            for i in reversed(range(len(self.VARIABLE_FRAME_STREAMS))):
+                builder.PrependUOffsetTRelative(VARIABLE_FRAME_STREAMSlist[i])
+            VARIABLE_FRAME_STREAMS = builder.EndVector()
+        if self.CUSTOM_STREAMS is not None:
+            CUSTOM_STREAMSlist = []
+            for i in range(len(self.CUSTOM_STREAMS)):
+                CUSTOM_STREAMSlist.append(self.CUSTOM_STREAMS[i].Pack(builder))
+            StreamSetStartCUSTOM_STREAMSVector(builder, len(self.CUSTOM_STREAMS))
+            for i in reversed(range(len(self.CUSTOM_STREAMS))):
+                builder.PrependUOffsetTRelative(CUSTOM_STREAMSlist[i])
+            CUSTOM_STREAMS = builder.EndVector()
+        StreamSetStart(builder)
+        if self.FIXED_FRAME_STREAMS is not None:
+            StreamSetAddFIXED_FRAME_STREAMS(builder, FIXED_FRAME_STREAMS)
+        if self.VARIABLE_FRAME_STREAMS is not None:
+            StreamSetAddVARIABLE_FRAME_STREAMS(builder, VARIABLE_FRAME_STREAMS)
+        if self.CUSTOM_STREAMS is not None:
+            StreamSetAddCUSTOM_STREAMS(builder, CUSTOM_STREAMS)
+        streamSet = StreamSetEnd(builder)
+        return streamSet

XTC/StringArgumentType.py

@@ -0,0 +1,206 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: 
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+# String argument type
+class StringArgumentType(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = StringArgumentType()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsStringArgumentType(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    @classmethod
+    def StringArgumentTypeBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x24\x58\x54\x43", size_prefixed=size_prefixed)
+
+    # StringArgumentType
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Type name
+    # StringArgumentType
+    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
+    # StringArgumentType
+    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
+    # StringArgumentType
+    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
+    # StringArgumentType
+    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 StringDataEncoding import StringDataEncoding
+            obj = StringDataEncoding()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # Initial/default value
+    # StringArgumentType
+    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
+
+    # Restriction pattern (regex)
+    # StringArgumentType
+    def RESTRICTION_PATTERN(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+def StringArgumentTypeStart(builder):
+    builder.StartObject(6)
+
+def Start(builder):
+    StringArgumentTypeStart(builder)
+
+def StringArgumentTypeAddNAME(builder, NAME):
+    builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(NAME), 0)
+
+def AddNAME(builder, NAME):
+    StringArgumentTypeAddNAME(builder, NAME)
+
+def StringArgumentTypeAddSHORT_DESCRIPTION(builder, SHORT_DESCRIPTION):
+    builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(SHORT_DESCRIPTION), 0)
+
+def AddSHORT_DESCRIPTION(builder, SHORT_DESCRIPTION):
+    StringArgumentTypeAddSHORT_DESCRIPTION(builder, SHORT_DESCRIPTION)
+
+def StringArgumentTypeAddLONG_DESCRIPTION(builder, LONG_DESCRIPTION):
+    builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(LONG_DESCRIPTION), 0)
+
+def AddLONG_DESCRIPTION(builder, LONG_DESCRIPTION):
+    StringArgumentTypeAddLONG_DESCRIPTION(builder, LONG_DESCRIPTION)
+
+def StringArgumentTypeAddDATA_ENCODING(builder, DATA_ENCODING):
+    builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(DATA_ENCODING), 0)
+
+def AddDATA_ENCODING(builder, DATA_ENCODING):
+    StringArgumentTypeAddDATA_ENCODING(builder, DATA_ENCODING)
+
+def StringArgumentTypeAddINITIAL_VALUE(builder, INITIAL_VALUE):
+    builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(INITIAL_VALUE), 0)
+
+def AddINITIAL_VALUE(builder, INITIAL_VALUE):
+    StringArgumentTypeAddINITIAL_VALUE(builder, INITIAL_VALUE)
+
+def StringArgumentTypeAddRESTRICTION_PATTERN(builder, RESTRICTION_PATTERN):
+    builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(RESTRICTION_PATTERN), 0)
+
+def AddRESTRICTION_PATTERN(builder, RESTRICTION_PATTERN):
+    StringArgumentTypeAddRESTRICTION_PATTERN(builder, RESTRICTION_PATTERN)
+
+def StringArgumentTypeEnd(builder):
+    return builder.EndObject()
+
+def End(builder):
+    return StringArgumentTypeEnd(builder)
+
+import StringDataEncoding
+try:
+    from typing import Optional
+except:
+    pass
+
+class StringArgumentTypeT(object):
+
+    # StringArgumentTypeT
+    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[StringDataEncoding.StringDataEncodingT]
+        self.INITIAL_VALUE = None  # type: str
+        self.RESTRICTION_PATTERN = None  # type: str
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        stringArgumentType = StringArgumentType()
+        stringArgumentType.Init(buf, pos)
+        return cls.InitFromObj(stringArgumentType)
+
+    @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, stringArgumentType):
+        x = StringArgumentTypeT()
+        x._UnPack(stringArgumentType)
+        return x
+
+    # StringArgumentTypeT
+    def _UnPack(self, stringArgumentType):
+        if stringArgumentType is None:
+            return
+        self.NAME = stringArgumentType.NAME()
+        self.SHORT_DESCRIPTION = stringArgumentType.SHORT_DESCRIPTION()
+        self.LONG_DESCRIPTION = stringArgumentType.LONG_DESCRIPTION()
+        if stringArgumentType.DATA_ENCODING() is not None:
+            self.DATA_ENCODING = StringDataEncoding.StringDataEncodingT.InitFromObj(stringArgumentType.DATA_ENCODING())
+        self.INITIAL_VALUE = stringArgumentType.INITIAL_VALUE()
+        self.RESTRICTION_PATTERN = stringArgumentType.RESTRICTION_PATTERN()
+
+    # StringArgumentTypeT
+    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)
+        if self.RESTRICTION_PATTERN is not None:
+            RESTRICTION_PATTERN = builder.CreateString(self.RESTRICTION_PATTERN)
+        StringArgumentTypeStart(builder)
+        if self.NAME is not None:
+            StringArgumentTypeAddNAME(builder, NAME)
+        if self.SHORT_DESCRIPTION is not None:
+            StringArgumentTypeAddSHORT_DESCRIPTION(builder, SHORT_DESCRIPTION)
+        if self.LONG_DESCRIPTION is not None:
+            StringArgumentTypeAddLONG_DESCRIPTION(builder, LONG_DESCRIPTION)
+        if self.DATA_ENCODING is not None:
+            StringArgumentTypeAddDATA_ENCODING(builder, DATA_ENCODING)
+        if self.INITIAL_VALUE is not None:
+            StringArgumentTypeAddINITIAL_VALUE(builder, INITIAL_VALUE)
+        if self.RESTRICTION_PATTERN is not None:
+            StringArgumentTypeAddRESTRICTION_PATTERN(builder, RESTRICTION_PATTERN)
+        stringArgumentType = StringArgumentTypeEnd(builder)
+        return stringArgumentType

XTC/StringDataEncoding.py

@@ -0,0 +1,178 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: 
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+# String data encoding specification
+class StringDataEncoding(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = StringDataEncoding()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsStringDataEncoding(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    @classmethod
+    def StringDataEncodingBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x24\x58\x54\x43", size_prefixed=size_prefixed)
+
+    # StringDataEncoding
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Character encoding
+    # StringDataEncoding
+    def ENCODING(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 3
+
+    # Size type specification
+    # StringDataEncoding
+    def SIZE_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
+
+    # Fixed size in bits (when SIZE_TYPE=FIXED)
+    # StringDataEncoding
+    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.Uint16Flags, o + self._tab.Pos)
+        return 0
+
+    # Termination character (when SIZE_TYPE=TERMINATION_CHAR)
+    # StringDataEncoding
+    def TERMINATION_CHAR(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
+        return 0
+
+    # Maximum size in bits (for variable length)
+    # StringDataEncoding
+    def MAX_SIZE_IN_BITS(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint16Flags, o + self._tab.Pos)
+        return 0
+
+    # Leading size field bits (when SIZE_TYPE=LEADING_SIZE)
+    # StringDataEncoding
+    def LEADING_SIZE_BITS(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
+        return 0
+
+def StringDataEncodingStart(builder):
+    builder.StartObject(6)
+
+def Start(builder):
+    StringDataEncodingStart(builder)
+
+def StringDataEncodingAddENCODING(builder, ENCODING):
+    builder.PrependInt8Slot(0, ENCODING, 3)
+
+def AddENCODING(builder, ENCODING):
+    StringDataEncodingAddENCODING(builder, ENCODING)
+
+def StringDataEncodingAddSIZE_TYPE(builder, SIZE_TYPE):
+    builder.PrependInt8Slot(1, SIZE_TYPE, 0)
+
+def AddSIZE_TYPE(builder, SIZE_TYPE):
+    StringDataEncodingAddSIZE_TYPE(builder, SIZE_TYPE)
+
+def StringDataEncodingAddSIZE_IN_BITS(builder, SIZE_IN_BITS):
+    builder.PrependUint16Slot(2, SIZE_IN_BITS, 0)
+
+def AddSIZE_IN_BITS(builder, SIZE_IN_BITS):
+    StringDataEncodingAddSIZE_IN_BITS(builder, SIZE_IN_BITS)
+
+def StringDataEncodingAddTERMINATION_CHAR(builder, TERMINATION_CHAR):
+    builder.PrependUint8Slot(3, TERMINATION_CHAR, 0)
+
+def AddTERMINATION_CHAR(builder, TERMINATION_CHAR):
+    StringDataEncodingAddTERMINATION_CHAR(builder, TERMINATION_CHAR)
+
+def StringDataEncodingAddMAX_SIZE_IN_BITS(builder, MAX_SIZE_IN_BITS):
+    builder.PrependUint16Slot(4, MAX_SIZE_IN_BITS, 0)
+
+def AddMAX_SIZE_IN_BITS(builder, MAX_SIZE_IN_BITS):
+    StringDataEncodingAddMAX_SIZE_IN_BITS(builder, MAX_SIZE_IN_BITS)
+
+def StringDataEncodingAddLEADING_SIZE_BITS(builder, LEADING_SIZE_BITS):
+    builder.PrependUint8Slot(5, LEADING_SIZE_BITS, 0)
+
+def AddLEADING_SIZE_BITS(builder, LEADING_SIZE_BITS):
+    StringDataEncodingAddLEADING_SIZE_BITS(builder, LEADING_SIZE_BITS)
+
+def StringDataEncodingEnd(builder):
+    return builder.EndObject()
+
+def End(builder):
+    return StringDataEncodingEnd(builder)
+
+
+class StringDataEncodingT(object):
+
+    # StringDataEncodingT
+    def __init__(self):
+        self.ENCODING = 3  # type: int
+        self.SIZE_TYPE = 0  # type: int
+        self.SIZE_IN_BITS = 0  # type: int
+        self.TERMINATION_CHAR = 0  # type: int
+        self.MAX_SIZE_IN_BITS = 0  # type: int
+        self.LEADING_SIZE_BITS = 0  # type: int
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        stringDataEncoding = StringDataEncoding()
+        stringDataEncoding.Init(buf, pos)
+        return cls.InitFromObj(stringDataEncoding)
+
+    @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, stringDataEncoding):
+        x = StringDataEncodingT()
+        x._UnPack(stringDataEncoding)
+        return x
+
+    # StringDataEncodingT
+    def _UnPack(self, stringDataEncoding):
+        if stringDataEncoding is None:
+            return
+        self.ENCODING = stringDataEncoding.ENCODING()
+        self.SIZE_TYPE = stringDataEncoding.SIZE_TYPE()
+        self.SIZE_IN_BITS = stringDataEncoding.SIZE_IN_BITS()
+        self.TERMINATION_CHAR = stringDataEncoding.TERMINATION_CHAR()
+        self.MAX_SIZE_IN_BITS = stringDataEncoding.MAX_SIZE_IN_BITS()
+        self.LEADING_SIZE_BITS = stringDataEncoding.LEADING_SIZE_BITS()
+
+    # StringDataEncodingT
+    def Pack(self, builder):
+        StringDataEncodingStart(builder)
+        StringDataEncodingAddENCODING(builder, self.ENCODING)
+        StringDataEncodingAddSIZE_TYPE(builder, self.SIZE_TYPE)
+        StringDataEncodingAddSIZE_IN_BITS(builder, self.SIZE_IN_BITS)
+        StringDataEncodingAddTERMINATION_CHAR(builder, self.TERMINATION_CHAR)
+        StringDataEncodingAddMAX_SIZE_IN_BITS(builder, self.MAX_SIZE_IN_BITS)
+        StringDataEncodingAddLEADING_SIZE_BITS(builder, self.LEADING_SIZE_BITS)
+        stringDataEncoding = StringDataEncodingEnd(builder)
+        return stringDataEncoding

XTC/StringEncodingType.py

@@ -0,0 +1,20 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: 
+
+# String encoding character sets
+class StringEncodingType(object):
+    # US-ASCII (7-bit)
+    US_ASCII = 0
+    # ISO 8859-1 Latin-1
+    ISO_8859_1 = 1
+    # Windows-1252
+    WINDOWS_1252 = 2
+    # UTF-8
+    UTF_8 = 3
+    # UTF-16
+    UTF_16 = 4
+    # UTF-16 Big Endian
+    UTF_16BE = 5
+    # UTF-16 Little Endian
+    UTF_16LE = 6