spacedatastandards.org 1.73.0__py3-none-any.whl

XTC/EnumerationValue.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()
+
+# Enumeration value mapping
+class EnumerationValue(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = EnumerationValue()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsEnumerationValue(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    @classmethod
+    def EnumerationValueBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x24\x58\x54\x43", size_prefixed=size_prefixed)
+
+    # EnumerationValue
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Label/name for this value
+    # EnumerationValue
+    def LABEL(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
+
+    # Numeric value
+    # EnumerationValue
+    def VALUE(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int64Flags, o + self._tab.Pos)
+        return 0
+
+    # Maximum value (for ranges)
+    # EnumerationValue
+    def MAX_VALUE(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int64Flags, o + self._tab.Pos)
+        return 0
+
+    # Description of this enumeration value
+    # EnumerationValue
+    def DESCRIPTION(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+def EnumerationValueStart(builder):
+    builder.StartObject(4)
+
+def Start(builder):
+    EnumerationValueStart(builder)
+
+def EnumerationValueAddLABEL(builder, LABEL):
+    builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(LABEL), 0)
+
+def AddLABEL(builder, LABEL):
+    EnumerationValueAddLABEL(builder, LABEL)
+
+def EnumerationValueAddVALUE(builder, VALUE):
+    builder.PrependInt64Slot(1, VALUE, 0)
+
+def AddVALUE(builder, VALUE):
+    EnumerationValueAddVALUE(builder, VALUE)
+
+def EnumerationValueAddMAX_VALUE(builder, MAX_VALUE):
+    builder.PrependInt64Slot(2, MAX_VALUE, 0)
+
+def AddMAX_VALUE(builder, MAX_VALUE):
+    EnumerationValueAddMAX_VALUE(builder, MAX_VALUE)
+
+def EnumerationValueAddDESCRIPTION(builder, DESCRIPTION):
+    builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(DESCRIPTION), 0)
+
+def AddDESCRIPTION(builder, DESCRIPTION):
+    EnumerationValueAddDESCRIPTION(builder, DESCRIPTION)
+
+def EnumerationValueEnd(builder):
+    return builder.EndObject()
+
+def End(builder):
+    return EnumerationValueEnd(builder)
+
+
+class EnumerationValueT(object):
+
+    # EnumerationValueT
+    def __init__(self):
+        self.LABEL = None  # type: str
+        self.VALUE = 0  # type: int
+        self.MAX_VALUE = 0  # type: int
+        self.DESCRIPTION = None  # type: str
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        enumerationValue = EnumerationValue()
+        enumerationValue.Init(buf, pos)
+        return cls.InitFromObj(enumerationValue)
+
+    @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, enumerationValue):
+        x = EnumerationValueT()
+        x._UnPack(enumerationValue)
+        return x
+
+    # EnumerationValueT
+    def _UnPack(self, enumerationValue):
+        if enumerationValue is None:
+            return
+        self.LABEL = enumerationValue.LABEL()
+        self.VALUE = enumerationValue.VALUE()
+        self.MAX_VALUE = enumerationValue.MAX_VALUE()
+        self.DESCRIPTION = enumerationValue.DESCRIPTION()
+
+    # EnumerationValueT
+    def Pack(self, builder):
+        if self.LABEL is not None:
+            LABEL = builder.CreateString(self.LABEL)
+        if self.DESCRIPTION is not None:
+            DESCRIPTION = builder.CreateString(self.DESCRIPTION)
+        EnumerationValueStart(builder)
+        if self.LABEL is not None:
+            EnumerationValueAddLABEL(builder, LABEL)
+        EnumerationValueAddVALUE(builder, self.VALUE)
+        EnumerationValueAddMAX_VALUE(builder, self.MAX_VALUE)
+        if self.DESCRIPTION is not None:
+            EnumerationValueAddDESCRIPTION(builder, DESCRIPTION)
+        enumerationValue = EnumerationValueEnd(builder)
+        return enumerationValue

XTC/EpochType.py

@@ -0,0 +1,16 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: 
+
+# Epoch reference for absolute time
+class EpochType(object):
+    # TAI epoch (1958-01-01)
+    TAI = 0
+    # J2000 epoch (2000-01-01 12:00:00 TT)
+    J2000 = 1
+    # Unix epoch (1970-01-01)
+    UNIX = 2
+    # GPS epoch (1980-01-06)
+    GPS = 3
+    # Custom epoch specified in offset
+    CUSTOM = 4

XTC/ErrorDetectionType.py

@@ -0,0 +1,14 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: 
+
+# Error detection/correction algorithms
+class ErrorDetectionType(object):
+    # No error detection
+    NONE = 0
+    # Cyclic redundancy check
+    CRC = 1
+    # Checksum
+    CHECKSUM = 2
+    # Parity
+    PARITY = 3

XTC/FixedFrameStream.py

@@ -0,0 +1,153 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: 
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+# Fixed frame stream
+class FixedFrameStream(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = FixedFrameStream()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsFixedFrameStream(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    @classmethod
+    def FixedFrameStreamBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x24\x58\x54\x43", size_prefixed=size_prefixed)
+
+    # FixedFrameStream
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Stream name
+    # FixedFrameStream
+    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
+    # FixedFrameStream
+    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
+
+    # Frame size in bits
+    # FixedFrameStream
+    def FRAME_SIZE_IN_BITS(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
+        return 0
+
+    # Sync pattern (hex string)
+    # FixedFrameStream
+    def SYNC_PATTERN(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+def FixedFrameStreamStart(builder):
+    builder.StartObject(4)
+
+def Start(builder):
+    FixedFrameStreamStart(builder)
+
+def FixedFrameStreamAddNAME(builder, NAME):
+    builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(NAME), 0)
+
+def AddNAME(builder, NAME):
+    FixedFrameStreamAddNAME(builder, NAME)
+
+def FixedFrameStreamAddSHORT_DESCRIPTION(builder, SHORT_DESCRIPTION):
+    builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(SHORT_DESCRIPTION), 0)
+
+def AddSHORT_DESCRIPTION(builder, SHORT_DESCRIPTION):
+    FixedFrameStreamAddSHORT_DESCRIPTION(builder, SHORT_DESCRIPTION)
+
+def FixedFrameStreamAddFRAME_SIZE_IN_BITS(builder, FRAME_SIZE_IN_BITS):
+    builder.PrependUint32Slot(2, FRAME_SIZE_IN_BITS, 0)
+
+def AddFRAME_SIZE_IN_BITS(builder, FRAME_SIZE_IN_BITS):
+    FixedFrameStreamAddFRAME_SIZE_IN_BITS(builder, FRAME_SIZE_IN_BITS)
+
+def FixedFrameStreamAddSYNC_PATTERN(builder, SYNC_PATTERN):
+    builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(SYNC_PATTERN), 0)
+
+def AddSYNC_PATTERN(builder, SYNC_PATTERN):
+    FixedFrameStreamAddSYNC_PATTERN(builder, SYNC_PATTERN)
+
+def FixedFrameStreamEnd(builder):
+    return builder.EndObject()
+
+def End(builder):
+    return FixedFrameStreamEnd(builder)
+
+
+class FixedFrameStreamT(object):
+
+    # FixedFrameStreamT
+    def __init__(self):
+        self.NAME = None  # type: str
+        self.SHORT_DESCRIPTION = None  # type: str
+        self.FRAME_SIZE_IN_BITS = 0  # type: int
+        self.SYNC_PATTERN = None  # type: str
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        fixedFrameStream = FixedFrameStream()
+        fixedFrameStream.Init(buf, pos)
+        return cls.InitFromObj(fixedFrameStream)
+
+    @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, fixedFrameStream):
+        x = FixedFrameStreamT()
+        x._UnPack(fixedFrameStream)
+        return x
+
+    # FixedFrameStreamT
+    def _UnPack(self, fixedFrameStream):
+        if fixedFrameStream is None:
+            return
+        self.NAME = fixedFrameStream.NAME()
+        self.SHORT_DESCRIPTION = fixedFrameStream.SHORT_DESCRIPTION()
+        self.FRAME_SIZE_IN_BITS = fixedFrameStream.FRAME_SIZE_IN_BITS()
+        self.SYNC_PATTERN = fixedFrameStream.SYNC_PATTERN()
+
+    # FixedFrameStreamT
+    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.SYNC_PATTERN is not None:
+            SYNC_PATTERN = builder.CreateString(self.SYNC_PATTERN)
+        FixedFrameStreamStart(builder)
+        if self.NAME is not None:
+            FixedFrameStreamAddNAME(builder, NAME)
+        if self.SHORT_DESCRIPTION is not None:
+            FixedFrameStreamAddSHORT_DESCRIPTION(builder, SHORT_DESCRIPTION)
+        FixedFrameStreamAddFRAME_SIZE_IN_BITS(builder, self.FRAME_SIZE_IN_BITS)
+        if self.SYNC_PATTERN is not None:
+            FixedFrameStreamAddSYNC_PATTERN(builder, SYNC_PATTERN)
+        fixedFrameStream = FixedFrameStreamEnd(builder)
+        return fixedFrameStream

XTC/FixedValueEntry.py

@@ -0,0 +1,163 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: 
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+# Fixed value entry (static padding/header)
+class FixedValueEntry(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = FixedValueEntry()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsFixedValueEntry(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    @classmethod
+    def FixedValueEntryBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x24\x58\x54\x43", size_prefixed=size_prefixed)
+
+    # FixedValueEntry
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Binary value (hex string)
+    # FixedValueEntry
+    def BINARY_VALUE(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
+
+    # Size in bits
+    # FixedValueEntry
+    def 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
+
+    # Name/description
+    # FixedValueEntry
+    def NAME(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
+
+    # Location in container
+    # FixedValueEntry
+    def LOCATION(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            x = self._tab.Indirect(o + self._tab.Pos)
+            from LocationInContainer import LocationInContainer
+            obj = LocationInContainer()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+def FixedValueEntryStart(builder):
+    builder.StartObject(4)
+
+def Start(builder):
+    FixedValueEntryStart(builder)
+
+def FixedValueEntryAddBINARY_VALUE(builder, BINARY_VALUE):
+    builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(BINARY_VALUE), 0)
+
+def AddBINARY_VALUE(builder, BINARY_VALUE):
+    FixedValueEntryAddBINARY_VALUE(builder, BINARY_VALUE)
+
+def FixedValueEntryAddSIZE_IN_BITS(builder, SIZE_IN_BITS):
+    builder.PrependUint16Slot(1, SIZE_IN_BITS, 0)
+
+def AddSIZE_IN_BITS(builder, SIZE_IN_BITS):
+    FixedValueEntryAddSIZE_IN_BITS(builder, SIZE_IN_BITS)
+
+def FixedValueEntryAddNAME(builder, NAME):
+    builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(NAME), 0)
+
+def AddNAME(builder, NAME):
+    FixedValueEntryAddNAME(builder, NAME)
+
+def FixedValueEntryAddLOCATION(builder, LOCATION):
+    builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(LOCATION), 0)
+
+def AddLOCATION(builder, LOCATION):
+    FixedValueEntryAddLOCATION(builder, LOCATION)
+
+def FixedValueEntryEnd(builder):
+    return builder.EndObject()
+
+def End(builder):
+    return FixedValueEntryEnd(builder)
+
+import LocationInContainer
+try:
+    from typing import Optional
+except:
+    pass
+
+class FixedValueEntryT(object):
+
+    # FixedValueEntryT
+    def __init__(self):
+        self.BINARY_VALUE = None  # type: str
+        self.SIZE_IN_BITS = 0  # type: int
+        self.NAME = None  # type: str
+        self.LOCATION = None  # type: Optional[LocationInContainer.LocationInContainerT]
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        fixedValueEntry = FixedValueEntry()
+        fixedValueEntry.Init(buf, pos)
+        return cls.InitFromObj(fixedValueEntry)
+
+    @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, fixedValueEntry):
+        x = FixedValueEntryT()
+        x._UnPack(fixedValueEntry)
+        return x
+
+    # FixedValueEntryT
+    def _UnPack(self, fixedValueEntry):
+        if fixedValueEntry is None:
+            return
+        self.BINARY_VALUE = fixedValueEntry.BINARY_VALUE()
+        self.SIZE_IN_BITS = fixedValueEntry.SIZE_IN_BITS()
+        self.NAME = fixedValueEntry.NAME()
+        if fixedValueEntry.LOCATION() is not None:
+            self.LOCATION = LocationInContainer.LocationInContainerT.InitFromObj(fixedValueEntry.LOCATION())
+
+    # FixedValueEntryT
+    def Pack(self, builder):
+        if self.BINARY_VALUE is not None:
+            BINARY_VALUE = builder.CreateString(self.BINARY_VALUE)
+        if self.NAME is not None:
+            NAME = builder.CreateString(self.NAME)
+        if self.LOCATION is not None:
+            LOCATION = self.LOCATION.Pack(builder)
+        FixedValueEntryStart(builder)
+        if self.BINARY_VALUE is not None:
+            FixedValueEntryAddBINARY_VALUE(builder, BINARY_VALUE)
+        FixedValueEntryAddSIZE_IN_BITS(builder, self.SIZE_IN_BITS)
+        if self.NAME is not None:
+            FixedValueEntryAddNAME(builder, NAME)
+        if self.LOCATION is not None:
+            FixedValueEntryAddLOCATION(builder, LOCATION)
+        fixedValueEntry = FixedValueEntryEnd(builder)
+        return fixedValueEntry