spacedatastandards.org 1.73.0__py3-none-any.whl

XTC/StringParameterType.py

@@ -0,0 +1,290 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: 
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+# String parameter type
+class StringParameterType(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = StringParameterType()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsStringParameterType(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    @classmethod
+    def StringParameterTypeBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x24\x58\x54\x43", size_prefixed=size_prefixed)
+
+    # StringParameterType
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Type name
+    # StringParameterType
+    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
+    # StringParameterType
+    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
+    # StringParameterType
+    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
+    # StringParameterType
+    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
+
+    # Default alarm
+    # StringParameterType
+    def DEFAULT_ALARM(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            x = self._tab.Indirect(o + self._tab.Pos)
+            from DefaultAlarm import DefaultAlarm
+            obj = DefaultAlarm()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # Context alarms
+    # StringParameterType
+    def CONTEXT_ALARMS(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        if o != 0:
+            x = self._tab.Vector(o)
+            x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
+            x = self._tab.Indirect(x)
+            from ContextAlarm import ContextAlarm
+            obj = ContextAlarm()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # StringParameterType
+    def CONTEXT_ALARMSLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # StringParameterType
+    def CONTEXT_ALARMSIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        return o == 0
+
+    # Initial/default value
+    # StringParameterType
+    def INITIAL_VALUE(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Restriction pattern (regex)
+    # StringParameterType
+    def RESTRICTION_PATTERN(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+def StringParameterTypeStart(builder):
+    builder.StartObject(8)
+
+def Start(builder):
+    StringParameterTypeStart(builder)
+
+def StringParameterTypeAddNAME(builder, NAME):
+    builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(NAME), 0)
+
+def AddNAME(builder, NAME):
+    StringParameterTypeAddNAME(builder, NAME)
+
+def StringParameterTypeAddSHORT_DESCRIPTION(builder, SHORT_DESCRIPTION):
+    builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(SHORT_DESCRIPTION), 0)
+
+def AddSHORT_DESCRIPTION(builder, SHORT_DESCRIPTION):
+    StringParameterTypeAddSHORT_DESCRIPTION(builder, SHORT_DESCRIPTION)
+
+def StringParameterTypeAddLONG_DESCRIPTION(builder, LONG_DESCRIPTION):
+    builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(LONG_DESCRIPTION), 0)
+
+def AddLONG_DESCRIPTION(builder, LONG_DESCRIPTION):
+    StringParameterTypeAddLONG_DESCRIPTION(builder, LONG_DESCRIPTION)
+
+def StringParameterTypeAddDATA_ENCODING(builder, DATA_ENCODING):
+    builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(DATA_ENCODING), 0)
+
+def AddDATA_ENCODING(builder, DATA_ENCODING):
+    StringParameterTypeAddDATA_ENCODING(builder, DATA_ENCODING)
+
+def StringParameterTypeAddDEFAULT_ALARM(builder, DEFAULT_ALARM):
+    builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(DEFAULT_ALARM), 0)
+
+def AddDEFAULT_ALARM(builder, DEFAULT_ALARM):
+    StringParameterTypeAddDEFAULT_ALARM(builder, DEFAULT_ALARM)
+
+def StringParameterTypeAddCONTEXT_ALARMS(builder, CONTEXT_ALARMS):
+    builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(CONTEXT_ALARMS), 0)
+
+def AddCONTEXT_ALARMS(builder, CONTEXT_ALARMS):
+    StringParameterTypeAddCONTEXT_ALARMS(builder, CONTEXT_ALARMS)
+
+def StringParameterTypeStartCONTEXT_ALARMSVector(builder, numElems):
+    return builder.StartVector(4, numElems, 4)
+
+def StartCONTEXT_ALARMSVector(builder, numElems):
+    return StringParameterTypeStartCONTEXT_ALARMSVector(builder, numElems)
+
+def StringParameterTypeAddINITIAL_VALUE(builder, INITIAL_VALUE):
+    builder.PrependUOffsetTRelativeSlot(6, flatbuffers.number_types.UOffsetTFlags.py_type(INITIAL_VALUE), 0)
+
+def AddINITIAL_VALUE(builder, INITIAL_VALUE):
+    StringParameterTypeAddINITIAL_VALUE(builder, INITIAL_VALUE)
+
+def StringParameterTypeAddRESTRICTION_PATTERN(builder, RESTRICTION_PATTERN):
+    builder.PrependUOffsetTRelativeSlot(7, flatbuffers.number_types.UOffsetTFlags.py_type(RESTRICTION_PATTERN), 0)
+
+def AddRESTRICTION_PATTERN(builder, RESTRICTION_PATTERN):
+    StringParameterTypeAddRESTRICTION_PATTERN(builder, RESTRICTION_PATTERN)
+
+def StringParameterTypeEnd(builder):
+    return builder.EndObject()
+
+def End(builder):
+    return StringParameterTypeEnd(builder)
+
+import ContextAlarm
+import DefaultAlarm
+import StringDataEncoding
+try:
+    from typing import List, Optional
+except:
+    pass
+
+class StringParameterTypeT(object):
+
+    # StringParameterTypeT
+    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.DEFAULT_ALARM = None  # type: Optional[DefaultAlarm.DefaultAlarmT]
+        self.CONTEXT_ALARMS = None  # type: List[ContextAlarm.ContextAlarmT]
+        self.INITIAL_VALUE = None  # type: str
+        self.RESTRICTION_PATTERN = None  # type: str
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        stringParameterType = StringParameterType()
+        stringParameterType.Init(buf, pos)
+        return cls.InitFromObj(stringParameterType)
+
+    @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, stringParameterType):
+        x = StringParameterTypeT()
+        x._UnPack(stringParameterType)
+        return x
+
+    # StringParameterTypeT
+    def _UnPack(self, stringParameterType):
+        if stringParameterType is None:
+            return
+        self.NAME = stringParameterType.NAME()
+        self.SHORT_DESCRIPTION = stringParameterType.SHORT_DESCRIPTION()
+        self.LONG_DESCRIPTION = stringParameterType.LONG_DESCRIPTION()
+        if stringParameterType.DATA_ENCODING() is not None:
+            self.DATA_ENCODING = StringDataEncoding.StringDataEncodingT.InitFromObj(stringParameterType.DATA_ENCODING())
+        if stringParameterType.DEFAULT_ALARM() is not None:
+            self.DEFAULT_ALARM = DefaultAlarm.DefaultAlarmT.InitFromObj(stringParameterType.DEFAULT_ALARM())
+        if not stringParameterType.CONTEXT_ALARMSIsNone():
+            self.CONTEXT_ALARMS = []
+            for i in range(stringParameterType.CONTEXT_ALARMSLength()):
+                if stringParameterType.CONTEXT_ALARMS(i) is None:
+                    self.CONTEXT_ALARMS.append(None)
+                else:
+                    contextAlarm_ = ContextAlarm.ContextAlarmT.InitFromObj(stringParameterType.CONTEXT_ALARMS(i))
+                    self.CONTEXT_ALARMS.append(contextAlarm_)
+        self.INITIAL_VALUE = stringParameterType.INITIAL_VALUE()
+        self.RESTRICTION_PATTERN = stringParameterType.RESTRICTION_PATTERN()
+
+    # StringParameterTypeT
+    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.DEFAULT_ALARM is not None:
+            DEFAULT_ALARM = self.DEFAULT_ALARM.Pack(builder)
+        if self.CONTEXT_ALARMS is not None:
+            CONTEXT_ALARMSlist = []
+            for i in range(len(self.CONTEXT_ALARMS)):
+                CONTEXT_ALARMSlist.append(self.CONTEXT_ALARMS[i].Pack(builder))
+            StringParameterTypeStartCONTEXT_ALARMSVector(builder, len(self.CONTEXT_ALARMS))
+            for i in reversed(range(len(self.CONTEXT_ALARMS))):
+                builder.PrependUOffsetTRelative(CONTEXT_ALARMSlist[i])
+            CONTEXT_ALARMS = builder.EndVector()
+        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)
+        StringParameterTypeStart(builder)
+        if self.NAME is not None:
+            StringParameterTypeAddNAME(builder, NAME)
+        if self.SHORT_DESCRIPTION is not None:
+            StringParameterTypeAddSHORT_DESCRIPTION(builder, SHORT_DESCRIPTION)
+        if self.LONG_DESCRIPTION is not None:
+            StringParameterTypeAddLONG_DESCRIPTION(builder, LONG_DESCRIPTION)
+        if self.DATA_ENCODING is not None:
+            StringParameterTypeAddDATA_ENCODING(builder, DATA_ENCODING)
+        if self.DEFAULT_ALARM is not None:
+            StringParameterTypeAddDEFAULT_ALARM(builder, DEFAULT_ALARM)
+        if self.CONTEXT_ALARMS is not None:
+            StringParameterTypeAddCONTEXT_ALARMS(builder, CONTEXT_ALARMS)
+        if self.INITIAL_VALUE is not None:
+            StringParameterTypeAddINITIAL_VALUE(builder, INITIAL_VALUE)
+        if self.RESTRICTION_PATTERN is not None:
+            StringParameterTypeAddRESTRICTION_PATTERN(builder, RESTRICTION_PATTERN)
+        stringParameterType = StringParameterTypeEnd(builder)
+        return stringParameterType

XTC/StringSizeType.py

@@ -0,0 +1,12 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: 
+
+# String size specification type
+class StringSizeType(object):
+    # Fixed length string
+    FIXED = 0
+    # Variable with leading count
+    LEADING_SIZE = 1
+    # Variable with termination character
+    TERMINATION_CHAR = 2

XTC/TelemetryMetaData.py

@@ -0,0 +1,210 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: 
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+# Telemetry metadata collection
+class TelemetryMetaData(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = TelemetryMetaData()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsTelemetryMetaData(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    @classmethod
+    def TelemetryMetaDataBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x24\x58\x54\x43", size_prefixed=size_prefixed)
+
+    # TelemetryMetaData
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Parameter type definitions
+    # TelemetryMetaData
+    def PARAMETER_TYPE_SET(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            x = self._tab.Indirect(o + self._tab.Pos)
+            from ParameterTypeSet import ParameterTypeSet
+            obj = ParameterTypeSet()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # Parameter definitions
+    # TelemetryMetaData
+    def PARAMETER_SET(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            x = self._tab.Indirect(o + self._tab.Pos)
+            from ParameterSet import ParameterSet
+            obj = ParameterSet()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # Container definitions
+    # TelemetryMetaData
+    def CONTAINER_SET(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            x = self._tab.Indirect(o + self._tab.Pos)
+            from ContainerSet import ContainerSet
+            obj = ContainerSet()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # Algorithm definitions
+    # TelemetryMetaData
+    def ALGORITHM_SET(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            x = self._tab.Indirect(o + self._tab.Pos)
+            from AlgorithmSet import AlgorithmSet
+            obj = AlgorithmSet()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # Stream definitions
+    # TelemetryMetaData
+    def STREAM_SET(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            x = self._tab.Indirect(o + self._tab.Pos)
+            from StreamSet import StreamSet
+            obj = StreamSet()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+def TelemetryMetaDataStart(builder):
+    builder.StartObject(5)
+
+def Start(builder):
+    TelemetryMetaDataStart(builder)
+
+def TelemetryMetaDataAddPARAMETER_TYPE_SET(builder, PARAMETER_TYPE_SET):
+    builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(PARAMETER_TYPE_SET), 0)
+
+def AddPARAMETER_TYPE_SET(builder, PARAMETER_TYPE_SET):
+    TelemetryMetaDataAddPARAMETER_TYPE_SET(builder, PARAMETER_TYPE_SET)
+
+def TelemetryMetaDataAddPARAMETER_SET(builder, PARAMETER_SET):
+    builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(PARAMETER_SET), 0)
+
+def AddPARAMETER_SET(builder, PARAMETER_SET):
+    TelemetryMetaDataAddPARAMETER_SET(builder, PARAMETER_SET)
+
+def TelemetryMetaDataAddCONTAINER_SET(builder, CONTAINER_SET):
+    builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(CONTAINER_SET), 0)
+
+def AddCONTAINER_SET(builder, CONTAINER_SET):
+    TelemetryMetaDataAddCONTAINER_SET(builder, CONTAINER_SET)
+
+def TelemetryMetaDataAddALGORITHM_SET(builder, ALGORITHM_SET):
+    builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(ALGORITHM_SET), 0)
+
+def AddALGORITHM_SET(builder, ALGORITHM_SET):
+    TelemetryMetaDataAddALGORITHM_SET(builder, ALGORITHM_SET)
+
+def TelemetryMetaDataAddSTREAM_SET(builder, STREAM_SET):
+    builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(STREAM_SET), 0)
+
+def AddSTREAM_SET(builder, STREAM_SET):
+    TelemetryMetaDataAddSTREAM_SET(builder, STREAM_SET)
+
+def TelemetryMetaDataEnd(builder):
+    return builder.EndObject()
+
+def End(builder):
+    return TelemetryMetaDataEnd(builder)
+
+import AlgorithmSet
+import ContainerSet
+import ParameterSet
+import ParameterTypeSet
+import StreamSet
+try:
+    from typing import Optional
+except:
+    pass
+
+class TelemetryMetaDataT(object):
+
+    # TelemetryMetaDataT
+    def __init__(self):
+        self.PARAMETER_TYPE_SET = None  # type: Optional[ParameterTypeSet.ParameterTypeSetT]
+        self.PARAMETER_SET = None  # type: Optional[ParameterSet.ParameterSetT]
+        self.CONTAINER_SET = None  # type: Optional[ContainerSet.ContainerSetT]
+        self.ALGORITHM_SET = None  # type: Optional[AlgorithmSet.AlgorithmSetT]
+        self.STREAM_SET = None  # type: Optional[StreamSet.StreamSetT]
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        telemetryMetaData = TelemetryMetaData()
+        telemetryMetaData.Init(buf, pos)
+        return cls.InitFromObj(telemetryMetaData)
+
+    @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, telemetryMetaData):
+        x = TelemetryMetaDataT()
+        x._UnPack(telemetryMetaData)
+        return x
+
+    # TelemetryMetaDataT
+    def _UnPack(self, telemetryMetaData):
+        if telemetryMetaData is None:
+            return
+        if telemetryMetaData.PARAMETER_TYPE_SET() is not None:
+            self.PARAMETER_TYPE_SET = ParameterTypeSet.ParameterTypeSetT.InitFromObj(telemetryMetaData.PARAMETER_TYPE_SET())
+        if telemetryMetaData.PARAMETER_SET() is not None:
+            self.PARAMETER_SET = ParameterSet.ParameterSetT.InitFromObj(telemetryMetaData.PARAMETER_SET())
+        if telemetryMetaData.CONTAINER_SET() is not None:
+            self.CONTAINER_SET = ContainerSet.ContainerSetT.InitFromObj(telemetryMetaData.CONTAINER_SET())
+        if telemetryMetaData.ALGORITHM_SET() is not None:
+            self.ALGORITHM_SET = AlgorithmSet.AlgorithmSetT.InitFromObj(telemetryMetaData.ALGORITHM_SET())
+        if telemetryMetaData.STREAM_SET() is not None:
+            self.STREAM_SET = StreamSet.StreamSetT.InitFromObj(telemetryMetaData.STREAM_SET())
+
+    # TelemetryMetaDataT
+    def Pack(self, builder):
+        if self.PARAMETER_TYPE_SET is not None:
+            PARAMETER_TYPE_SET = self.PARAMETER_TYPE_SET.Pack(builder)
+        if self.PARAMETER_SET is not None:
+            PARAMETER_SET = self.PARAMETER_SET.Pack(builder)
+        if self.CONTAINER_SET is not None:
+            CONTAINER_SET = self.CONTAINER_SET.Pack(builder)
+        if self.ALGORITHM_SET is not None:
+            ALGORITHM_SET = self.ALGORITHM_SET.Pack(builder)
+        if self.STREAM_SET is not None:
+            STREAM_SET = self.STREAM_SET.Pack(builder)
+        TelemetryMetaDataStart(builder)
+        if self.PARAMETER_TYPE_SET is not None:
+            TelemetryMetaDataAddPARAMETER_TYPE_SET(builder, PARAMETER_TYPE_SET)
+        if self.PARAMETER_SET is not None:
+            TelemetryMetaDataAddPARAMETER_SET(builder, PARAMETER_SET)
+        if self.CONTAINER_SET is not None:
+            TelemetryMetaDataAddCONTAINER_SET(builder, CONTAINER_SET)
+        if self.ALGORITHM_SET is not None:
+            TelemetryMetaDataAddALGORITHM_SET(builder, ALGORITHM_SET)
+        if self.STREAM_SET is not None:
+            TelemetryMetaDataAddSTREAM_SET(builder, STREAM_SET)
+        telemetryMetaData = TelemetryMetaDataEnd(builder)
+        return telemetryMetaData

XTC/TimeWindowRefType.py

@@ -0,0 +1,10 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: 
+
+# Time window reference for command verification
+class TimeWindowRefType(object):
+    # Relative to command release time
+    COMMAND_RELEASE = 0
+    # Relative to last verifier passed
+    TIME_LAST_VERIFIER_PASSED = 1

XTC/Unit.py

@@ -0,0 +1,150 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: 
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+# Unit specification
+class Unit(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = Unit()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsUnit(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    @classmethod
+    def UnitBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x24\x58\x54\x43", size_prefixed=size_prefixed)
+
+    # Unit
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Unit description (e.g., "meters per second")
+    # Unit
+    def DESCRIPTION(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
+
+    # Unit symbol (e.g., "m/s")
+    # Unit
+    def SYMBOL(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
+
+    # Power/exponent for this unit
+    # Unit
+    def POWER(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return 0.0
+
+    # Factor multiplier
+    # Unit
+    def FACTOR(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return 0.0
+
+def UnitStart(builder):
+    builder.StartObject(4)
+
+def Start(builder):
+    UnitStart(builder)
+
+def UnitAddDESCRIPTION(builder, DESCRIPTION):
+    builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(DESCRIPTION), 0)
+
+def AddDESCRIPTION(builder, DESCRIPTION):
+    UnitAddDESCRIPTION(builder, DESCRIPTION)
+
+def UnitAddSYMBOL(builder, SYMBOL):
+    builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(SYMBOL), 0)
+
+def AddSYMBOL(builder, SYMBOL):
+    UnitAddSYMBOL(builder, SYMBOL)
+
+def UnitAddPOWER(builder, POWER):
+    builder.PrependFloat64Slot(2, POWER, 0.0)
+
+def AddPOWER(builder, POWER):
+    UnitAddPOWER(builder, POWER)
+
+def UnitAddFACTOR(builder, FACTOR):
+    builder.PrependFloat64Slot(3, FACTOR, 0.0)
+
+def AddFACTOR(builder, FACTOR):
+    UnitAddFACTOR(builder, FACTOR)
+
+def UnitEnd(builder):
+    return builder.EndObject()
+
+def End(builder):
+    return UnitEnd(builder)
+
+
+class UnitT(object):
+
+    # UnitT
+    def __init__(self):
+        self.DESCRIPTION = None  # type: str
+        self.SYMBOL = None  # type: str
+        self.POWER = 0.0  # type: float
+        self.FACTOR = 0.0  # type: float
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        unit = Unit()
+        unit.Init(buf, pos)
+        return cls.InitFromObj(unit)
+
+    @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, unit):
+        x = UnitT()
+        x._UnPack(unit)
+        return x
+
+    # UnitT
+    def _UnPack(self, unit):
+        if unit is None:
+            return
+        self.DESCRIPTION = unit.DESCRIPTION()
+        self.SYMBOL = unit.SYMBOL()
+        self.POWER = unit.POWER()
+        self.FACTOR = unit.FACTOR()
+
+    # UnitT
+    def Pack(self, builder):
+        if self.DESCRIPTION is not None:
+            DESCRIPTION = builder.CreateString(self.DESCRIPTION)
+        if self.SYMBOL is not None:
+            SYMBOL = builder.CreateString(self.SYMBOL)
+        UnitStart(builder)
+        if self.DESCRIPTION is not None:
+            UnitAddDESCRIPTION(builder, DESCRIPTION)
+        if self.SYMBOL is not None:
+            UnitAddSYMBOL(builder, SYMBOL)
+        UnitAddPOWER(builder, self.POWER)
+        UnitAddFACTOR(builder, self.FACTOR)
+        unit = UnitEnd(builder)
+        return unit