spacedatastandards.org 1.73.0__py3-none-any.whl

OCM/StateVector.py

@@ -0,0 +1,248 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: 
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class StateVector(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = StateVector()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsStateVector(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    @classmethod
+    def StateVectorBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x24\x4F\x43\x4D", size_prefixed=size_prefixed)
+
+    # StateVector
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Epoch of the state vector.
+    # StateVector
+    def EPOCH(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
+
+    # X component of position in the specified reference frame.
+    # StateVector
+    def X(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return 0.0
+
+    # Y component of position.
+    # StateVector
+    def Y(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
+
+    # Z component of position.
+    # StateVector
+    def Z(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
+
+    # X component of velocity.
+    # StateVector
+    def X_DOT(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return 0.0
+
+    # Y component of velocity.
+    # StateVector
+    def Y_DOT(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return 0.0
+
+    # Z component of velocity.
+    # StateVector
+    def Z_DOT(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return 0.0
+
+    # X component of acceleration.
+    # StateVector
+    def X_DDOT(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return 0.0
+
+    # Y component of acceleration.
+    # StateVector
+    def Y_DDOT(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return 0.0
+
+    # Z component of acceleration.
+    # StateVector
+    def Z_DDOT(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return 0.0
+
+def StateVectorStart(builder):
+    builder.StartObject(10)
+
+def Start(builder):
+    StateVectorStart(builder)
+
+def StateVectorAddEPOCH(builder, EPOCH):
+    builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(EPOCH), 0)
+
+def AddEPOCH(builder, EPOCH):
+    StateVectorAddEPOCH(builder, EPOCH)
+
+def StateVectorAddX(builder, X):
+    builder.PrependFloat64Slot(1, X, 0.0)
+
+def AddX(builder, X):
+    StateVectorAddX(builder, X)
+
+def StateVectorAddY(builder, Y):
+    builder.PrependFloat64Slot(2, Y, 0.0)
+
+def AddY(builder, Y):
+    StateVectorAddY(builder, Y)
+
+def StateVectorAddZ(builder, Z):
+    builder.PrependFloat64Slot(3, Z, 0.0)
+
+def AddZ(builder, Z):
+    StateVectorAddZ(builder, Z)
+
+def StateVectorAddX_DOT(builder, X_DOT):
+    builder.PrependFloat64Slot(4, X_DOT, 0.0)
+
+def AddX_DOT(builder, X_DOT):
+    StateVectorAddX_DOT(builder, X_DOT)
+
+def StateVectorAddY_DOT(builder, Y_DOT):
+    builder.PrependFloat64Slot(5, Y_DOT, 0.0)
+
+def AddY_DOT(builder, Y_DOT):
+    StateVectorAddY_DOT(builder, Y_DOT)
+
+def StateVectorAddZ_DOT(builder, Z_DOT):
+    builder.PrependFloat64Slot(6, Z_DOT, 0.0)
+
+def AddZ_DOT(builder, Z_DOT):
+    StateVectorAddZ_DOT(builder, Z_DOT)
+
+def StateVectorAddX_DDOT(builder, X_DDOT):
+    builder.PrependFloat64Slot(7, X_DDOT, 0.0)
+
+def AddX_DDOT(builder, X_DDOT):
+    StateVectorAddX_DDOT(builder, X_DDOT)
+
+def StateVectorAddY_DDOT(builder, Y_DDOT):
+    builder.PrependFloat64Slot(8, Y_DDOT, 0.0)
+
+def AddY_DDOT(builder, Y_DDOT):
+    StateVectorAddY_DDOT(builder, Y_DDOT)
+
+def StateVectorAddZ_DDOT(builder, Z_DDOT):
+    builder.PrependFloat64Slot(9, Z_DDOT, 0.0)
+
+def AddZ_DDOT(builder, Z_DDOT):
+    StateVectorAddZ_DDOT(builder, Z_DDOT)
+
+def StateVectorEnd(builder):
+    return builder.EndObject()
+
+def End(builder):
+    return StateVectorEnd(builder)
+
+
+class StateVectorT(object):
+
+    # StateVectorT
+    def __init__(self):
+        self.EPOCH = None  # type: str
+        self.X = 0.0  # type: float
+        self.Y = 0.0  # type: float
+        self.Z = 0.0  # type: float
+        self.X_DOT = 0.0  # type: float
+        self.Y_DOT = 0.0  # type: float
+        self.Z_DOT = 0.0  # type: float
+        self.X_DDOT = 0.0  # type: float
+        self.Y_DDOT = 0.0  # type: float
+        self.Z_DDOT = 0.0  # type: float
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        stateVector = StateVector()
+        stateVector.Init(buf, pos)
+        return cls.InitFromObj(stateVector)
+
+    @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, stateVector):
+        x = StateVectorT()
+        x._UnPack(stateVector)
+        return x
+
+    # StateVectorT
+    def _UnPack(self, stateVector):
+        if stateVector is None:
+            return
+        self.EPOCH = stateVector.EPOCH()
+        self.X = stateVector.X()
+        self.Y = stateVector.Y()
+        self.Z = stateVector.Z()
+        self.X_DOT = stateVector.X_DOT()
+        self.Y_DOT = stateVector.Y_DOT()
+        self.Z_DOT = stateVector.Z_DOT()
+        self.X_DDOT = stateVector.X_DDOT()
+        self.Y_DDOT = stateVector.Y_DDOT()
+        self.Z_DDOT = stateVector.Z_DDOT()
+
+    # StateVectorT
+    def Pack(self, builder):
+        if self.EPOCH is not None:
+            EPOCH = builder.CreateString(self.EPOCH)
+        StateVectorStart(builder)
+        if self.EPOCH is not None:
+            StateVectorAddEPOCH(builder, EPOCH)
+        StateVectorAddX(builder, self.X)
+        StateVectorAddY(builder, self.Y)
+        StateVectorAddZ(builder, self.Z)
+        StateVectorAddX_DOT(builder, self.X_DOT)
+        StateVectorAddY_DOT(builder, self.Y_DOT)
+        StateVectorAddZ_DOT(builder, self.Z_DOT)
+        StateVectorAddX_DDOT(builder, self.X_DDOT)
+        StateVectorAddY_DDOT(builder, self.Y_DDOT)
+        StateVectorAddZ_DDOT(builder, self.Z_DDOT)
+        stateVector = StateVectorEnd(builder)
+        return stateVector

OCM/UserDefinedParameters.py

@@ -0,0 +1,115 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: 
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class UserDefinedParameters(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = UserDefinedParameters()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsUserDefinedParameters(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    @classmethod
+    def UserDefinedParametersBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x24\x4F\x43\x4D", size_prefixed=size_prefixed)
+
+    # UserDefinedParameters
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Name of the user-defined parameter.
+    # UserDefinedParameters
+    def PARAM_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
+
+    # Value of the user-defined parameter.
+    # UserDefinedParameters
+    def PARAM_VALUE(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
+
+def UserDefinedParametersStart(builder):
+    builder.StartObject(2)
+
+def Start(builder):
+    UserDefinedParametersStart(builder)
+
+def UserDefinedParametersAddPARAM_NAME(builder, PARAM_NAME):
+    builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(PARAM_NAME), 0)
+
+def AddPARAM_NAME(builder, PARAM_NAME):
+    UserDefinedParametersAddPARAM_NAME(builder, PARAM_NAME)
+
+def UserDefinedParametersAddPARAM_VALUE(builder, PARAM_VALUE):
+    builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(PARAM_VALUE), 0)
+
+def AddPARAM_VALUE(builder, PARAM_VALUE):
+    UserDefinedParametersAddPARAM_VALUE(builder, PARAM_VALUE)
+
+def UserDefinedParametersEnd(builder):
+    return builder.EndObject()
+
+def End(builder):
+    return UserDefinedParametersEnd(builder)
+
+
+class UserDefinedParametersT(object):
+
+    # UserDefinedParametersT
+    def __init__(self):
+        self.PARAM_NAME = None  # type: str
+        self.PARAM_VALUE = None  # type: str
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        userDefinedParameters = UserDefinedParameters()
+        userDefinedParameters.Init(buf, pos)
+        return cls.InitFromObj(userDefinedParameters)
+
+    @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, userDefinedParameters):
+        x = UserDefinedParametersT()
+        x._UnPack(userDefinedParameters)
+        return x
+
+    # UserDefinedParametersT
+    def _UnPack(self, userDefinedParameters):
+        if userDefinedParameters is None:
+            return
+        self.PARAM_NAME = userDefinedParameters.PARAM_NAME()
+        self.PARAM_VALUE = userDefinedParameters.PARAM_VALUE()
+
+    # UserDefinedParametersT
+    def Pack(self, builder):
+        if self.PARAM_NAME is not None:
+            PARAM_NAME = builder.CreateString(self.PARAM_NAME)
+        if self.PARAM_VALUE is not None:
+            PARAM_VALUE = builder.CreateString(self.PARAM_VALUE)
+        UserDefinedParametersStart(builder)
+        if self.PARAM_NAME is not None:
+            UserDefinedParametersAddPARAM_NAME(builder, PARAM_NAME)
+        if self.PARAM_VALUE is not None:
+            UserDefinedParametersAddPARAM_VALUE(builder, PARAM_VALUE)
+        userDefinedParameters = UserDefinedParametersEnd(builder)
+        return userDefinedParameters

OEM/Band.py

@@ -0,0 +1,5 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: 
+
+# NOTE Band.py does not declare any structs or enums

OEM/CAT.py

@@ -0,0 +1,5 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: 
+
+# NOTE CAT.py does not declare any structs or enums

OEM/CelestialFrame.py

@@ -0,0 +1,5 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: 
+
+# NOTE CelestialFrame.py does not declare any structs or enums

OEM/CelestialFrameWrapper.py

@@ -0,0 +1,5 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: 
+
+# NOTE CelestialFrameWrapper.py does not declare any structs or enums

OEM/CustomFrame.py

@@ -0,0 +1,5 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: 
+
+# NOTE CustomFrame.py does not declare any structs or enums

OEM/CustomFrameWrapper.py

@@ -0,0 +1,5 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: 
+
+# NOTE CustomFrameWrapper.py does not declare any structs or enums

OEM/DataMode.py

@@ -0,0 +1,5 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: 
+
+# NOTE DataMode.py does not declare any structs or enums

OEM/DeviceType.py

@@ -0,0 +1,5 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: 
+
+# NOTE DeviceType.py does not declare any structs or enums

OEM/FrequencyRange.py

@@ -0,0 +1,5 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: 
+
+# NOTE FrequencyRange.py does not declare any structs or enums

OEM/IDM.py

@@ -0,0 +1,5 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: 
+
+# NOTE IDM.py does not declare any structs or enums

OEM/LCC.py

@@ -0,0 +1,5 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: 
+
+# NOTE LCC.py does not declare any structs or enums

OEM/OEM.py

@@ -0,0 +1,216 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: 
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+# Orbit Ephemeris Message
+class OEM(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = OEM()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsOEM(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    @classmethod
+    def OEMBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x24\x4F\x45\x4D", size_prefixed=size_prefixed)
+
+    # OEM
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # OEM Header
+    # Classification marking of the data in IC/CAPCO Portion-marked format.
+    # OEM
+    def CLASSIFICATION(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
+
+    # OEM Version
+    # OEM
+    def CCSDS_OEM_VERS(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return 0.0
+
+    # Creation Date
+    # OEM
+    def CREATION_DATE(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
+
+    # Originator
+    # OEM
+    def ORIGINATOR(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
+
+    # Array of ephemeris data blocks
+    # OEM
+    def EPHEMERIS_DATA_BLOCK(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            x = self._tab.Vector(o)
+            x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
+            x = self._tab.Indirect(x)
+            from ephemerisDataBlock import ephemerisDataBlock
+            obj = ephemerisDataBlock()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # OEM
+    def EPHEMERIS_DATA_BLOCKLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # OEM
+    def EPHEMERIS_DATA_BLOCKIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        return o == 0
+
+def OEMStart(builder):
+    builder.StartObject(5)
+
+def Start(builder):
+    OEMStart(builder)
+
+def OEMAddCLASSIFICATION(builder, CLASSIFICATION):
+    builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(CLASSIFICATION), 0)
+
+def AddCLASSIFICATION(builder, CLASSIFICATION):
+    OEMAddCLASSIFICATION(builder, CLASSIFICATION)
+
+def OEMAddCCSDS_OEM_VERS(builder, CCSDS_OEM_VERS):
+    builder.PrependFloat64Slot(1, CCSDS_OEM_VERS, 0.0)
+
+def AddCCSDS_OEM_VERS(builder, CCSDS_OEM_VERS):
+    OEMAddCCSDS_OEM_VERS(builder, CCSDS_OEM_VERS)
+
+def OEMAddCREATION_DATE(builder, CREATION_DATE):
+    builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(CREATION_DATE), 0)
+
+def AddCREATION_DATE(builder, CREATION_DATE):
+    OEMAddCREATION_DATE(builder, CREATION_DATE)
+
+def OEMAddORIGINATOR(builder, ORIGINATOR):
+    builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(ORIGINATOR), 0)
+
+def AddORIGINATOR(builder, ORIGINATOR):
+    OEMAddORIGINATOR(builder, ORIGINATOR)
+
+def OEMAddEPHEMERIS_DATA_BLOCK(builder, EPHEMERIS_DATA_BLOCK):
+    builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(EPHEMERIS_DATA_BLOCK), 0)
+
+def AddEPHEMERIS_DATA_BLOCK(builder, EPHEMERIS_DATA_BLOCK):
+    OEMAddEPHEMERIS_DATA_BLOCK(builder, EPHEMERIS_DATA_BLOCK)
+
+def OEMStartEPHEMERIS_DATA_BLOCKVector(builder, numElems):
+    return builder.StartVector(4, numElems, 4)
+
+def StartEPHEMERIS_DATA_BLOCKVector(builder, numElems):
+    return OEMStartEPHEMERIS_DATA_BLOCKVector(builder, numElems)
+
+def OEMEnd(builder):
+    return builder.EndObject()
+
+def End(builder):
+    return OEMEnd(builder)
+
+import ephemerisDataBlock
+try:
+    from typing import List
+except:
+    pass
+
+class OEMT(object):
+
+    # OEMT
+    def __init__(self):
+        self.CLASSIFICATION = None  # type: str
+        self.CCSDS_OEM_VERS = 0.0  # type: float
+        self.CREATION_DATE = None  # type: str
+        self.ORIGINATOR = None  # type: str
+        self.EPHEMERIS_DATA_BLOCK = None  # type: List[ephemerisDataBlock.ephemerisDataBlockT]
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        OEM = OEM()
+        OEM.Init(buf, pos)
+        return cls.InitFromObj(OEM)
+
+    @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, OEM):
+        x = OEMT()
+        x._UnPack(OEM)
+        return x
+
+    # OEMT
+    def _UnPack(self, OEM):
+        if OEM is None:
+            return
+        self.CLASSIFICATION = OEM.CLASSIFICATION()
+        self.CCSDS_OEM_VERS = OEM.CCSDS_OEM_VERS()
+        self.CREATION_DATE = OEM.CREATION_DATE()
+        self.ORIGINATOR = OEM.ORIGINATOR()
+        if not OEM.EPHEMERIS_DATA_BLOCKIsNone():
+            self.EPHEMERIS_DATA_BLOCK = []
+            for i in range(OEM.EPHEMERIS_DATA_BLOCKLength()):
+                if OEM.EPHEMERIS_DATA_BLOCK(i) is None:
+                    self.EPHEMERIS_DATA_BLOCK.append(None)
+                else:
+                    ephemerisDataBlock_ = ephemerisDataBlock.ephemerisDataBlockT.InitFromObj(OEM.EPHEMERIS_DATA_BLOCK(i))
+                    self.EPHEMERIS_DATA_BLOCK.append(ephemerisDataBlock_)
+
+    # OEMT
+    def Pack(self, builder):
+        if self.CLASSIFICATION is not None:
+            CLASSIFICATION = builder.CreateString(self.CLASSIFICATION)
+        if self.CREATION_DATE is not None:
+            CREATION_DATE = builder.CreateString(self.CREATION_DATE)
+        if self.ORIGINATOR is not None:
+            ORIGINATOR = builder.CreateString(self.ORIGINATOR)
+        if self.EPHEMERIS_DATA_BLOCK is not None:
+            EPHEMERIS_DATA_BLOCKlist = []
+            for i in range(len(self.EPHEMERIS_DATA_BLOCK)):
+                EPHEMERIS_DATA_BLOCKlist.append(self.EPHEMERIS_DATA_BLOCK[i].Pack(builder))
+            OEMStartEPHEMERIS_DATA_BLOCKVector(builder, len(self.EPHEMERIS_DATA_BLOCK))
+            for i in reversed(range(len(self.EPHEMERIS_DATA_BLOCK))):
+                builder.PrependUOffsetTRelative(EPHEMERIS_DATA_BLOCKlist[i])
+            EPHEMERIS_DATA_BLOCK = builder.EndVector()
+        OEMStart(builder)
+        if self.CLASSIFICATION is not None:
+            OEMAddCLASSIFICATION(builder, CLASSIFICATION)
+        OEMAddCCSDS_OEM_VERS(builder, self.CCSDS_OEM_VERS)
+        if self.CREATION_DATE is not None:
+            OEMAddCREATION_DATE(builder, CREATION_DATE)
+        if self.ORIGINATOR is not None:
+            OEMAddORIGINATOR(builder, ORIGINATOR)
+        if self.EPHEMERIS_DATA_BLOCK is not None:
+            OEMAddEPHEMERIS_DATA_BLOCK(builder, EPHEMERIS_DATA_BLOCK)
+        OEM = OEMEnd(builder)
+        return OEM

OEM/OrbitFrame.py

@@ -0,0 +1,5 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: 
+
+# NOTE OrbitFrame.py does not declare any structs or enums

OEM/OrbitFrameWrapper.py

@@ -0,0 +1,5 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: 
+
+# NOTE OrbitFrameWrapper.py does not declare any structs or enums

OEM/PLD.py

@@ -0,0 +1,5 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: 
+
+# NOTE PLD.py does not declare any structs or enums

OEM/PolarizationType.py

@@ -0,0 +1,5 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: 
+
+# NOTE PolarizationType.py does not declare any structs or enums

OEM/RFM.py

@@ -0,0 +1,5 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: 
+
+# NOTE RFM.py does not declare any structs or enums