spacedatastandards.org 1.73.0__py3-none-any.whl

PHY/PHY.py

@@ -0,0 +1,342 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: 
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+# Physics and Rigid Body Dynamics
+class PHY(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = PHY()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsPHY(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    @classmethod
+    def PHYBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x24\x50\x48\x59", size_prefixed=size_prefixed)
+
+    # PHY
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # PHY
+    def COMMAND(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
+
+    # PHY
+    def SIMULATION_STEP(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
+
+    # PHY
+    def RIGID_BODY(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
+
+    # PHY
+    def INTEGRATION_CONFIG(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
+
+    # PHY
+    def COLLISION_QUERY_A(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
+
+    # PHY
+    def COLLISION_QUERY_B(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
+
+    # PHY
+    def TRANSFORM_A(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
+
+    # PHY
+    def TRANSFORM_B(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
+
+    # PHY
+    def POSITION_A(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # PHY
+    def POSITION_B(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # PHY
+    def FLUID(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # PHY
+    def AERO_QUERY(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # PHY
+    def DRAG_MODEL(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(28))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # PHY
+    def THERMAL_STATE(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+def PHYStart(builder):
+    builder.StartObject(14)
+
+def Start(builder):
+    PHYStart(builder)
+
+def PHYAddCOMMAND(builder, COMMAND):
+    builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(COMMAND), 0)
+
+def AddCOMMAND(builder, COMMAND):
+    PHYAddCOMMAND(builder, COMMAND)
+
+def PHYAddSIMULATION_STEP(builder, SIMULATION_STEP):
+    builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(SIMULATION_STEP), 0)
+
+def AddSIMULATION_STEP(builder, SIMULATION_STEP):
+    PHYAddSIMULATION_STEP(builder, SIMULATION_STEP)
+
+def PHYAddRIGID_BODY(builder, RIGID_BODY):
+    builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(RIGID_BODY), 0)
+
+def AddRIGID_BODY(builder, RIGID_BODY):
+    PHYAddRIGID_BODY(builder, RIGID_BODY)
+
+def PHYAddINTEGRATION_CONFIG(builder, INTEGRATION_CONFIG):
+    builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(INTEGRATION_CONFIG), 0)
+
+def AddINTEGRATION_CONFIG(builder, INTEGRATION_CONFIG):
+    PHYAddINTEGRATION_CONFIG(builder, INTEGRATION_CONFIG)
+
+def PHYAddCOLLISION_QUERY_A(builder, COLLISION_QUERY_A):
+    builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(COLLISION_QUERY_A), 0)
+
+def AddCOLLISION_QUERY_A(builder, COLLISION_QUERY_A):
+    PHYAddCOLLISION_QUERY_A(builder, COLLISION_QUERY_A)
+
+def PHYAddCOLLISION_QUERY_B(builder, COLLISION_QUERY_B):
+    builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(COLLISION_QUERY_B), 0)
+
+def AddCOLLISION_QUERY_B(builder, COLLISION_QUERY_B):
+    PHYAddCOLLISION_QUERY_B(builder, COLLISION_QUERY_B)
+
+def PHYAddTRANSFORM_A(builder, TRANSFORM_A):
+    builder.PrependUOffsetTRelativeSlot(6, flatbuffers.number_types.UOffsetTFlags.py_type(TRANSFORM_A), 0)
+
+def AddTRANSFORM_A(builder, TRANSFORM_A):
+    PHYAddTRANSFORM_A(builder, TRANSFORM_A)
+
+def PHYAddTRANSFORM_B(builder, TRANSFORM_B):
+    builder.PrependUOffsetTRelativeSlot(7, flatbuffers.number_types.UOffsetTFlags.py_type(TRANSFORM_B), 0)
+
+def AddTRANSFORM_B(builder, TRANSFORM_B):
+    PHYAddTRANSFORM_B(builder, TRANSFORM_B)
+
+def PHYAddPOSITION_A(builder, POSITION_A):
+    builder.PrependUOffsetTRelativeSlot(8, flatbuffers.number_types.UOffsetTFlags.py_type(POSITION_A), 0)
+
+def AddPOSITION_A(builder, POSITION_A):
+    PHYAddPOSITION_A(builder, POSITION_A)
+
+def PHYAddPOSITION_B(builder, POSITION_B):
+    builder.PrependUOffsetTRelativeSlot(9, flatbuffers.number_types.UOffsetTFlags.py_type(POSITION_B), 0)
+
+def AddPOSITION_B(builder, POSITION_B):
+    PHYAddPOSITION_B(builder, POSITION_B)
+
+def PHYAddFLUID(builder, FLUID):
+    builder.PrependUOffsetTRelativeSlot(10, flatbuffers.number_types.UOffsetTFlags.py_type(FLUID), 0)
+
+def AddFLUID(builder, FLUID):
+    PHYAddFLUID(builder, FLUID)
+
+def PHYAddAERO_QUERY(builder, AERO_QUERY):
+    builder.PrependUOffsetTRelativeSlot(11, flatbuffers.number_types.UOffsetTFlags.py_type(AERO_QUERY), 0)
+
+def AddAERO_QUERY(builder, AERO_QUERY):
+    PHYAddAERO_QUERY(builder, AERO_QUERY)
+
+def PHYAddDRAG_MODEL(builder, DRAG_MODEL):
+    builder.PrependUOffsetTRelativeSlot(12, flatbuffers.number_types.UOffsetTFlags.py_type(DRAG_MODEL), 0)
+
+def AddDRAG_MODEL(builder, DRAG_MODEL):
+    PHYAddDRAG_MODEL(builder, DRAG_MODEL)
+
+def PHYAddTHERMAL_STATE(builder, THERMAL_STATE):
+    builder.PrependUOffsetTRelativeSlot(13, flatbuffers.number_types.UOffsetTFlags.py_type(THERMAL_STATE), 0)
+
+def AddTHERMAL_STATE(builder, THERMAL_STATE):
+    PHYAddTHERMAL_STATE(builder, THERMAL_STATE)
+
+def PHYEnd(builder):
+    return builder.EndObject()
+
+def End(builder):
+    return PHYEnd(builder)
+
+
+class PHYT(object):
+
+    # PHYT
+    def __init__(self):
+        self.COMMAND = None  # type: str
+        self.SIMULATION_STEP = None  # type: str
+        self.RIGID_BODY = None  # type: str
+        self.INTEGRATION_CONFIG = None  # type: str
+        self.COLLISION_QUERY_A = None  # type: str
+        self.COLLISION_QUERY_B = None  # type: str
+        self.TRANSFORM_A = None  # type: str
+        self.TRANSFORM_B = None  # type: str
+        self.POSITION_A = None  # type: str
+        self.POSITION_B = None  # type: str
+        self.FLUID = None  # type: str
+        self.AERO_QUERY = None  # type: str
+        self.DRAG_MODEL = None  # type: str
+        self.THERMAL_STATE = None  # type: str
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        PHY = PHY()
+        PHY.Init(buf, pos)
+        return cls.InitFromObj(PHY)
+
+    @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, PHY):
+        x = PHYT()
+        x._UnPack(PHY)
+        return x
+
+    # PHYT
+    def _UnPack(self, PHY):
+        if PHY is None:
+            return
+        self.COMMAND = PHY.COMMAND()
+        self.SIMULATION_STEP = PHY.SIMULATION_STEP()
+        self.RIGID_BODY = PHY.RIGID_BODY()
+        self.INTEGRATION_CONFIG = PHY.INTEGRATION_CONFIG()
+        self.COLLISION_QUERY_A = PHY.COLLISION_QUERY_A()
+        self.COLLISION_QUERY_B = PHY.COLLISION_QUERY_B()
+        self.TRANSFORM_A = PHY.TRANSFORM_A()
+        self.TRANSFORM_B = PHY.TRANSFORM_B()
+        self.POSITION_A = PHY.POSITION_A()
+        self.POSITION_B = PHY.POSITION_B()
+        self.FLUID = PHY.FLUID()
+        self.AERO_QUERY = PHY.AERO_QUERY()
+        self.DRAG_MODEL = PHY.DRAG_MODEL()
+        self.THERMAL_STATE = PHY.THERMAL_STATE()
+
+    # PHYT
+    def Pack(self, builder):
+        if self.COMMAND is not None:
+            COMMAND = builder.CreateString(self.COMMAND)
+        if self.SIMULATION_STEP is not None:
+            SIMULATION_STEP = builder.CreateString(self.SIMULATION_STEP)
+        if self.RIGID_BODY is not None:
+            RIGID_BODY = builder.CreateString(self.RIGID_BODY)
+        if self.INTEGRATION_CONFIG is not None:
+            INTEGRATION_CONFIG = builder.CreateString(self.INTEGRATION_CONFIG)
+        if self.COLLISION_QUERY_A is not None:
+            COLLISION_QUERY_A = builder.CreateString(self.COLLISION_QUERY_A)
+        if self.COLLISION_QUERY_B is not None:
+            COLLISION_QUERY_B = builder.CreateString(self.COLLISION_QUERY_B)
+        if self.TRANSFORM_A is not None:
+            TRANSFORM_A = builder.CreateString(self.TRANSFORM_A)
+        if self.TRANSFORM_B is not None:
+            TRANSFORM_B = builder.CreateString(self.TRANSFORM_B)
+        if self.POSITION_A is not None:
+            POSITION_A = builder.CreateString(self.POSITION_A)
+        if self.POSITION_B is not None:
+            POSITION_B = builder.CreateString(self.POSITION_B)
+        if self.FLUID is not None:
+            FLUID = builder.CreateString(self.FLUID)
+        if self.AERO_QUERY is not None:
+            AERO_QUERY = builder.CreateString(self.AERO_QUERY)
+        if self.DRAG_MODEL is not None:
+            DRAG_MODEL = builder.CreateString(self.DRAG_MODEL)
+        if self.THERMAL_STATE is not None:
+            THERMAL_STATE = builder.CreateString(self.THERMAL_STATE)
+        PHYStart(builder)
+        if self.COMMAND is not None:
+            PHYAddCOMMAND(builder, COMMAND)
+        if self.SIMULATION_STEP is not None:
+            PHYAddSIMULATION_STEP(builder, SIMULATION_STEP)
+        if self.RIGID_BODY is not None:
+            PHYAddRIGID_BODY(builder, RIGID_BODY)
+        if self.INTEGRATION_CONFIG is not None:
+            PHYAddINTEGRATION_CONFIG(builder, INTEGRATION_CONFIG)
+        if self.COLLISION_QUERY_A is not None:
+            PHYAddCOLLISION_QUERY_A(builder, COLLISION_QUERY_A)
+        if self.COLLISION_QUERY_B is not None:
+            PHYAddCOLLISION_QUERY_B(builder, COLLISION_QUERY_B)
+        if self.TRANSFORM_A is not None:
+            PHYAddTRANSFORM_A(builder, TRANSFORM_A)
+        if self.TRANSFORM_B is not None:
+            PHYAddTRANSFORM_B(builder, TRANSFORM_B)
+        if self.POSITION_A is not None:
+            PHYAddPOSITION_A(builder, POSITION_A)
+        if self.POSITION_B is not None:
+            PHYAddPOSITION_B(builder, POSITION_B)
+        if self.FLUID is not None:
+            PHYAddFLUID(builder, FLUID)
+        if self.AERO_QUERY is not None:
+            PHYAddAERO_QUERY(builder, AERO_QUERY)
+        if self.DRAG_MODEL is not None:
+            PHYAddDRAG_MODEL(builder, DRAG_MODEL)
+        if self.THERMAL_STATE is not None:
+            PHYAddTHERMAL_STATE(builder, THERMAL_STATE)
+        PHY = PHYEnd(builder)
+        return PHY

PLD/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

PLD/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

PLD/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

PLD/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

PLD/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

PLD/PLD.py

@@ -0,0 +1,245 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: 
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+# Payload Information
+class PLD(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = PLD()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsPLD(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    @classmethod
+    def PLDBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x24\x50\x4C\x44", size_prefixed=size_prefixed)
+
+    # PLD
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # PLD
+    def PAYLOAD_DURATION(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
+
+    # PLD
+    def MASS_AT_LAUNCH(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
+        return 0.0
+
+    # PLD
+    def DIMENSIONS(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
+
+    # PLD
+    def SOLAR_ARRAY_AREA(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
+        return 0.0
+
+    # PLD
+    def SOLAR_ARRAY_DIMENSIONS(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
+
+    # PLD
+    def NOMINAL_OPERATIONAL_LIFETIME(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
+
+    # PLD
+    def INSTRUMENTS(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
+        if o != 0:
+            x = self._tab.Vector(o)
+            x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
+            x = self._tab.Indirect(x)
+            from IDM import IDM
+            obj = IDM()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # PLD
+    def INSTRUMENTSLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # PLD
+    def INSTRUMENTSIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
+        return o == 0
+
+def PLDStart(builder):
+    builder.StartObject(7)
+
+def Start(builder):
+    PLDStart(builder)
+
+def PLDAddPAYLOAD_DURATION(builder, PAYLOAD_DURATION):
+    builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(PAYLOAD_DURATION), 0)
+
+def AddPAYLOAD_DURATION(builder, PAYLOAD_DURATION):
+    PLDAddPAYLOAD_DURATION(builder, PAYLOAD_DURATION)
+
+def PLDAddMASS_AT_LAUNCH(builder, MASS_AT_LAUNCH):
+    builder.PrependFloat32Slot(1, MASS_AT_LAUNCH, 0.0)
+
+def AddMASS_AT_LAUNCH(builder, MASS_AT_LAUNCH):
+    PLDAddMASS_AT_LAUNCH(builder, MASS_AT_LAUNCH)
+
+def PLDAddDIMENSIONS(builder, DIMENSIONS):
+    builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(DIMENSIONS), 0)
+
+def AddDIMENSIONS(builder, DIMENSIONS):
+    PLDAddDIMENSIONS(builder, DIMENSIONS)
+
+def PLDAddSOLAR_ARRAY_AREA(builder, SOLAR_ARRAY_AREA):
+    builder.PrependFloat32Slot(3, SOLAR_ARRAY_AREA, 0.0)
+
+def AddSOLAR_ARRAY_AREA(builder, SOLAR_ARRAY_AREA):
+    PLDAddSOLAR_ARRAY_AREA(builder, SOLAR_ARRAY_AREA)
+
+def PLDAddSOLAR_ARRAY_DIMENSIONS(builder, SOLAR_ARRAY_DIMENSIONS):
+    builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(SOLAR_ARRAY_DIMENSIONS), 0)
+
+def AddSOLAR_ARRAY_DIMENSIONS(builder, SOLAR_ARRAY_DIMENSIONS):
+    PLDAddSOLAR_ARRAY_DIMENSIONS(builder, SOLAR_ARRAY_DIMENSIONS)
+
+def PLDAddNOMINAL_OPERATIONAL_LIFETIME(builder, NOMINAL_OPERATIONAL_LIFETIME):
+    builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(NOMINAL_OPERATIONAL_LIFETIME), 0)
+
+def AddNOMINAL_OPERATIONAL_LIFETIME(builder, NOMINAL_OPERATIONAL_LIFETIME):
+    PLDAddNOMINAL_OPERATIONAL_LIFETIME(builder, NOMINAL_OPERATIONAL_LIFETIME)
+
+def PLDAddINSTRUMENTS(builder, INSTRUMENTS):
+    builder.PrependUOffsetTRelativeSlot(6, flatbuffers.number_types.UOffsetTFlags.py_type(INSTRUMENTS), 0)
+
+def AddINSTRUMENTS(builder, INSTRUMENTS):
+    PLDAddINSTRUMENTS(builder, INSTRUMENTS)
+
+def PLDStartINSTRUMENTSVector(builder, numElems):
+    return builder.StartVector(4, numElems, 4)
+
+def StartINSTRUMENTSVector(builder, numElems):
+    return PLDStartINSTRUMENTSVector(builder, numElems)
+
+def PLDEnd(builder):
+    return builder.EndObject()
+
+def End(builder):
+    return PLDEnd(builder)
+
+import IDM
+try:
+    from typing import List
+except:
+    pass
+
+class PLDT(object):
+
+    # PLDT
+    def __init__(self):
+        self.PAYLOAD_DURATION = None  # type: str
+        self.MASS_AT_LAUNCH = 0.0  # type: float
+        self.DIMENSIONS = None  # type: str
+        self.SOLAR_ARRAY_AREA = 0.0  # type: float
+        self.SOLAR_ARRAY_DIMENSIONS = None  # type: str
+        self.NOMINAL_OPERATIONAL_LIFETIME = None  # type: str
+        self.INSTRUMENTS = None  # type: List[IDM.IDMT]
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        PLD = PLD()
+        PLD.Init(buf, pos)
+        return cls.InitFromObj(PLD)
+
+    @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, PLD):
+        x = PLDT()
+        x._UnPack(PLD)
+        return x
+
+    # PLDT
+    def _UnPack(self, PLD):
+        if PLD is None:
+            return
+        self.PAYLOAD_DURATION = PLD.PAYLOAD_DURATION()
+        self.MASS_AT_LAUNCH = PLD.MASS_AT_LAUNCH()
+        self.DIMENSIONS = PLD.DIMENSIONS()
+        self.SOLAR_ARRAY_AREA = PLD.SOLAR_ARRAY_AREA()
+        self.SOLAR_ARRAY_DIMENSIONS = PLD.SOLAR_ARRAY_DIMENSIONS()
+        self.NOMINAL_OPERATIONAL_LIFETIME = PLD.NOMINAL_OPERATIONAL_LIFETIME()
+        if not PLD.INSTRUMENTSIsNone():
+            self.INSTRUMENTS = []
+            for i in range(PLD.INSTRUMENTSLength()):
+                if PLD.INSTRUMENTS(i) is None:
+                    self.INSTRUMENTS.append(None)
+                else:
+                    iDM_ = IDM.IDMT.InitFromObj(PLD.INSTRUMENTS(i))
+                    self.INSTRUMENTS.append(iDM_)
+
+    # PLDT
+    def Pack(self, builder):
+        if self.PAYLOAD_DURATION is not None:
+            PAYLOAD_DURATION = builder.CreateString(self.PAYLOAD_DURATION)
+        if self.DIMENSIONS is not None:
+            DIMENSIONS = builder.CreateString(self.DIMENSIONS)
+        if self.SOLAR_ARRAY_DIMENSIONS is not None:
+            SOLAR_ARRAY_DIMENSIONS = builder.CreateString(self.SOLAR_ARRAY_DIMENSIONS)
+        if self.NOMINAL_OPERATIONAL_LIFETIME is not None:
+            NOMINAL_OPERATIONAL_LIFETIME = builder.CreateString(self.NOMINAL_OPERATIONAL_LIFETIME)
+        if self.INSTRUMENTS is not None:
+            INSTRUMENTSlist = []
+            for i in range(len(self.INSTRUMENTS)):
+                INSTRUMENTSlist.append(self.INSTRUMENTS[i].Pack(builder))
+            PLDStartINSTRUMENTSVector(builder, len(self.INSTRUMENTS))
+            for i in reversed(range(len(self.INSTRUMENTS))):
+                builder.PrependUOffsetTRelative(INSTRUMENTSlist[i])
+            INSTRUMENTS = builder.EndVector()
+        PLDStart(builder)
+        if self.PAYLOAD_DURATION is not None:
+            PLDAddPAYLOAD_DURATION(builder, PAYLOAD_DURATION)
+        PLDAddMASS_AT_LAUNCH(builder, self.MASS_AT_LAUNCH)
+        if self.DIMENSIONS is not None:
+            PLDAddDIMENSIONS(builder, DIMENSIONS)
+        PLDAddSOLAR_ARRAY_AREA(builder, self.SOLAR_ARRAY_AREA)
+        if self.SOLAR_ARRAY_DIMENSIONS is not None:
+            PLDAddSOLAR_ARRAY_DIMENSIONS(builder, SOLAR_ARRAY_DIMENSIONS)
+        if self.NOMINAL_OPERATIONAL_LIFETIME is not None:
+            PLDAddNOMINAL_OPERATIONAL_LIFETIME(builder, NOMINAL_OPERATIONAL_LIFETIME)
+        if self.INSTRUMENTS is not None:
+            PLDAddINSTRUMENTS(builder, INSTRUMENTS)
+        PLD = PLDEnd(builder)
+        return PLD

PLD/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

PLD/SimplePolarization.py

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

PLD/StokesParameters.py

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