spacedatastandards.org 1.73.0__py3-none-any.whl

REC/REC.py

@@ -0,0 +1,158 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: 
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+# Collection of Standard Records
+class REC(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = REC()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsREC(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    @classmethod
+    def RECBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x24\x52\x45\x43", size_prefixed=size_prefixed)
+
+    # REC
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Schema version identifier
+    # REC
+    def Version(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
+
+    # Array of heterogeneous records from any supported standard
+    # REC
+    def RECORDS(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 Record import Record
+            obj = Record()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # REC
+    def RECORDSLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # REC
+    def RECORDSIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        return o == 0
+
+def RECStart(builder):
+    builder.StartObject(2)
+
+def Start(builder):
+    RECStart(builder)
+
+def RECAddVersion(builder, version):
+    builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(version), 0)
+
+def AddVersion(builder, version):
+    RECAddVersion(builder, version)
+
+def RECAddRECORDS(builder, RECORDS):
+    builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(RECORDS), 0)
+
+def AddRECORDS(builder, RECORDS):
+    RECAddRECORDS(builder, RECORDS)
+
+def RECStartRECORDSVector(builder, numElems):
+    return builder.StartVector(4, numElems, 4)
+
+def StartRECORDSVector(builder, numElems):
+    return RECStartRECORDSVector(builder, numElems)
+
+def RECEnd(builder):
+    return builder.EndObject()
+
+def End(builder):
+    return RECEnd(builder)
+
+import Record
+try:
+    from typing import List
+except:
+    pass
+
+class RECT(object):
+
+    # RECT
+    def __init__(self):
+        self.version = None  # type: str
+        self.RECORDS = None  # type: List[Record.RecordT]
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        REC = REC()
+        REC.Init(buf, pos)
+        return cls.InitFromObj(REC)
+
+    @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, REC):
+        x = RECT()
+        x._UnPack(REC)
+        return x
+
+    # RECT
+    def _UnPack(self, REC):
+        if REC is None:
+            return
+        self.version = REC.Version()
+        if not REC.RECORDSIsNone():
+            self.RECORDS = []
+            for i in range(REC.RECORDSLength()):
+                if REC.RECORDS(i) is None:
+                    self.RECORDS.append(None)
+                else:
+                    record_ = Record.RecordT.InitFromObj(REC.RECORDS(i))
+                    self.RECORDS.append(record_)
+
+    # RECT
+    def Pack(self, builder):
+        if self.version is not None:
+            version = builder.CreateString(self.version)
+        if self.RECORDS is not None:
+            RECORDSlist = []
+            for i in range(len(self.RECORDS)):
+                RECORDSlist.append(self.RECORDS[i].Pack(builder))
+            RECStartRECORDSVector(builder, len(self.RECORDS))
+            for i in reversed(range(len(self.RECORDS))):
+                builder.PrependUOffsetTRelative(RECORDSlist[i])
+            RECORDS = builder.EndVector()
+        RECStart(builder)
+        if self.version is not None:
+            RECAddVersion(builder, version)
+        if self.RECORDS is not None:
+            RECAddRECORDS(builder, RECORDS)
+        REC = RECEnd(builder)
+        return REC

REC/REV.py

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

REC/RFB.py

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

REC/RFE.py

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

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

REC/RFMUnion.py

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

REC/RFO.py

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

REC/ROC.py

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

REC/RangefinderType.py

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

REC/RateBasisType.py

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

REC/RateInStream.py

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

REC/Record.py

@@ -0,0 +1,258 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: 
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+# Individual record wrapper for any standard type
+class Record(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = Record()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsRecord(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    @classmethod
+    def RecordBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x24\x52\x45\x43", size_prefixed=size_prefixed)
+
+    # Record
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Record
+    def ValueType(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
+        return 0
+
+    # The record data (union of all supported standards)
+    # Record
+    def Value(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            from flatbuffers.table import Table
+            obj = Table(bytearray(), 0)
+            self._tab.Union(obj, o)
+            return obj
+        return None
+
+    # Standard identifier (e.g., "OMM", "CDM", "CAT")
+    # Record
+    def Standard(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
+
+def RecordStart(builder):
+    builder.StartObject(3)
+
+def Start(builder):
+    RecordStart(builder)
+
+def RecordAddValueType(builder, valueType):
+    builder.PrependUint8Slot(0, valueType, 0)
+
+def AddValueType(builder, valueType):
+    RecordAddValueType(builder, valueType)
+
+def RecordAddValue(builder, value):
+    builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(value), 0)
+
+def AddValue(builder, value):
+    RecordAddValue(builder, value)
+
+def RecordAddStandard(builder, standard):
+    builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(standard), 0)
+
+def AddStandard(builder, standard):
+    RecordAddStandard(builder, standard)
+
+def RecordEnd(builder):
+    return builder.EndObject()
+
+def End(builder):
+    return RecordEnd(builder)
+
+import ACL
+import ACM
+import ACR
+import AEM
+import AOF
+import APM
+import ARM
+import AST
+import ATD
+import ATM
+import BAL
+import BEM
+import BMC
+import BOV
+import CAT
+import CDM
+import CFP
+import CHN
+import CLT
+import CMS
+import COM
+import CRD
+import CRM
+import CSM
+import CTR
+import DFH
+import DMG
+import DOA
+import EME
+import ENC
+import ENV
+import EOO
+import EOP
+import EPM
+import EWR
+import FCS
+import GDI
+import GEO
+import GNO
+import GRV
+import GVH
+import HEL
+import HYP
+import IDM
+import IRO
+import LCC
+import LDM
+import LKS
+import LND
+import LNE
+import MET
+import MFE
+import MNF
+import MNV
+import MPE
+import MSL
+import MST
+import MTI
+import NAV
+import OBD
+import OBT
+import OCM
+import OEM
+import OMM
+import OOD
+import OOE
+import OOI
+import OOL
+import OON
+import OPM
+import OSM
+import PCF
+import PHY
+import PLD
+import PLG
+import PLK
+import PNM
+import PRG
+import PUR
+import RAF
+import RCF
+import RDM
+import RDO
+import REV
+import RFB
+import RFE
+import RFM
+import RFO
+import ROC
+import RecordType
+import SAR
+import SCM
+import SDL
+import SEO
+import SEV
+import SIT
+import SKI
+import SNR
+import SOI
+import SON
+import SPP
+import SPW
+import STF
+import STR
+import STV
+import SWR
+import TCF
+import TDM
+import TIM
+import TKG
+import TME
+import TMF
+import TPN
+import TRK
+import TRN
+import VCM
+import WPN
+import WTH
+import XTC
+try:
+    from typing import Union
+except:
+    pass
+
+class RecordT(object):
+
+    # RecordT
+    def __init__(self):
+        self.valueType = 0  # type: int
+        self.value = None  # type: Union[None, ACL.ACLT, ACM.ACMT, ACR.ACRT, AEM.AEMT, AOF.AOFT, APM.APMT, ARM.ARMT, AST.ASTT, ATD.ATDT, ATM.ATMT, BAL.BALT, BEM.BEMT, BMC.BMCT, BOV.BOVT, CAT.CATT, CDM.CDMT, CFP.CFPT, CHN.CHNT, CLT.CLTT, CMS.CMST, COM.COMT, CRD.CRDT, CRM.CRMT, CSM.CSMT, CTR.CTRT, DFH.DFHT, DMG.DMGT, DOA.DOAT, EME.EMET, ENC.ENCT, ENV.ENVT, EOO.EOOT, EOP.EOPT, EPM.EPMT, EWR.EWRT, FCS.FCST, GDI.GDIT, GEO.GEOT, GNO.GNOT, GRV.GRVT, GVH.GVHT, HEL.HELT, HYP.HYPT, IDM.IDMT, IRO.IROT, LCC.LCCT, LDM.LDMT, LKS.LKST, LND.LNDT, LNE.LNET, MET.METT, MFE.MFET, MNF.MNFT, MNV.MNVT, MPE.MPET, MSL.MSLT, MST.MSTT, MTI.MTIT, NAV.NAVT, OBD.OBDT, OBT.OBTT, OCM.OCMT, OEM.OEMT, OMM.OMMT, OOD.OODT, OOE.OOET, OOI.OOIT, OOL.OOLT, OON.OONT, OPM.OPMT, OSM.OSMT, PCF.PCFT, PHY.PHYT, PLD.PLDT, PLG.PLGT, PLK.PLKT, PNM.PNMT, PRG.PRGT, PUR.PURT, RAF.RAFT, RCF.RCFT, RDM.RDMT, RDO.RDOT, REV.REVT, RFB.RFBT, RFE.RFET, RFM.RFMT, RFO.RFOT, ROC.ROCT, SAR.SART, SCM.SCMT, SDL.SDLT, SEO.SEOT, SEV.SEVT, SIT.SITT, SKI.SKIT, SNR.SNRT, SOI.SOIT, SON.SONT, SPP.SPPT, SPW.SPWT, STF.STFT, STR.STRT, STV.STVT, SWR.SWRT, TCF.TCFT, TDM.TDMT, TIM.TIMT, TKG.TKGT, TME.TMET, TMF.TMFT, TPN.TPNT, TRK.TRKT, TRN.TRNT, VCM.VCMT, WPN.WPNT, WTH.WTHT, XTC.XTCT]
+        self.standard = None  # type: str
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        record = Record()
+        record.Init(buf, pos)
+        return cls.InitFromObj(record)
+
+    @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, record):
+        x = RecordT()
+        x._UnPack(record)
+        return x
+
+    # RecordT
+    def _UnPack(self, record):
+        if record is None:
+            return
+        self.valueType = record.ValueType()
+        self.value = RecordType.RecordTypeCreator(self.valueType, record.Value())
+        self.standard = record.Standard()
+
+    # RecordT
+    def Pack(self, builder):
+        if self.value is not None:
+            value = self.value.Pack(builder)
+        if self.standard is not None:
+            standard = builder.CreateString(self.standard)
+        RecordStart(builder)
+        RecordAddValueType(builder, self.valueType)
+        if self.value is not None:
+            RecordAddValue(builder, value)
+        if self.standard is not None:
+            RecordAddStandard(builder, standard)
+        record = RecordEnd(builder)
+        return record