spacedatastandards.org 1.73.0__py3-none-any.whl

XTC/Parameter.py

@@ -0,0 +1,226 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: 
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+# Parameter definition
+class Parameter(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = Parameter()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsParameter(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    @classmethod
+    def ParameterBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x24\x58\x54\x43", size_prefixed=size_prefixed)
+
+    # Parameter
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Parameter name
+    # Parameter
+    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
+
+    # Reference to parameter type
+    # Parameter
+    def PARAMETER_TYPE_REF(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
+
+    # Short description
+    # Parameter
+    def SHORT_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
+
+    # Long description
+    # Parameter
+    def LONG_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
+
+    # Parameter properties
+    # Parameter
+    def PROPERTIES(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            x = self._tab.Indirect(o + self._tab.Pos)
+            from ParameterProperties import ParameterProperties
+            obj = ParameterProperties()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # Physical address mapping
+    # Parameter
+    def PHYSICAL_ADDRESS(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
+
+    # Initial/default value
+    # Parameter
+    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
+
+def ParameterStart(builder):
+    builder.StartObject(7)
+
+def Start(builder):
+    ParameterStart(builder)
+
+def ParameterAddNAME(builder, NAME):
+    builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(NAME), 0)
+
+def AddNAME(builder, NAME):
+    ParameterAddNAME(builder, NAME)
+
+def ParameterAddPARAMETER_TYPE_REF(builder, PARAMETER_TYPE_REF):
+    builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(PARAMETER_TYPE_REF), 0)
+
+def AddPARAMETER_TYPE_REF(builder, PARAMETER_TYPE_REF):
+    ParameterAddPARAMETER_TYPE_REF(builder, PARAMETER_TYPE_REF)
+
+def ParameterAddSHORT_DESCRIPTION(builder, SHORT_DESCRIPTION):
+    builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(SHORT_DESCRIPTION), 0)
+
+def AddSHORT_DESCRIPTION(builder, SHORT_DESCRIPTION):
+    ParameterAddSHORT_DESCRIPTION(builder, SHORT_DESCRIPTION)
+
+def ParameterAddLONG_DESCRIPTION(builder, LONG_DESCRIPTION):
+    builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(LONG_DESCRIPTION), 0)
+
+def AddLONG_DESCRIPTION(builder, LONG_DESCRIPTION):
+    ParameterAddLONG_DESCRIPTION(builder, LONG_DESCRIPTION)
+
+def ParameterAddPROPERTIES(builder, PROPERTIES):
+    builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(PROPERTIES), 0)
+
+def AddPROPERTIES(builder, PROPERTIES):
+    ParameterAddPROPERTIES(builder, PROPERTIES)
+
+def ParameterAddPHYSICAL_ADDRESS(builder, PHYSICAL_ADDRESS):
+    builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(PHYSICAL_ADDRESS), 0)
+
+def AddPHYSICAL_ADDRESS(builder, PHYSICAL_ADDRESS):
+    ParameterAddPHYSICAL_ADDRESS(builder, PHYSICAL_ADDRESS)
+
+def ParameterAddINITIAL_VALUE(builder, INITIAL_VALUE):
+    builder.PrependUOffsetTRelativeSlot(6, flatbuffers.number_types.UOffsetTFlags.py_type(INITIAL_VALUE), 0)
+
+def AddINITIAL_VALUE(builder, INITIAL_VALUE):
+    ParameterAddINITIAL_VALUE(builder, INITIAL_VALUE)
+
+def ParameterEnd(builder):
+    return builder.EndObject()
+
+def End(builder):
+    return ParameterEnd(builder)
+
+import ParameterProperties
+try:
+    from typing import Optional
+except:
+    pass
+
+class ParameterT(object):
+
+    # ParameterT
+    def __init__(self):
+        self.NAME = None  # type: str
+        self.PARAMETER_TYPE_REF = None  # type: str
+        self.SHORT_DESCRIPTION = None  # type: str
+        self.LONG_DESCRIPTION = None  # type: str
+        self.PROPERTIES = None  # type: Optional[ParameterProperties.ParameterPropertiesT]
+        self.PHYSICAL_ADDRESS = None  # type: str
+        self.INITIAL_VALUE = None  # type: str
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        parameter = Parameter()
+        parameter.Init(buf, pos)
+        return cls.InitFromObj(parameter)
+
+    @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, parameter):
+        x = ParameterT()
+        x._UnPack(parameter)
+        return x
+
+    # ParameterT
+    def _UnPack(self, parameter):
+        if parameter is None:
+            return
+        self.NAME = parameter.NAME()
+        self.PARAMETER_TYPE_REF = parameter.PARAMETER_TYPE_REF()
+        self.SHORT_DESCRIPTION = parameter.SHORT_DESCRIPTION()
+        self.LONG_DESCRIPTION = parameter.LONG_DESCRIPTION()
+        if parameter.PROPERTIES() is not None:
+            self.PROPERTIES = ParameterProperties.ParameterPropertiesT.InitFromObj(parameter.PROPERTIES())
+        self.PHYSICAL_ADDRESS = parameter.PHYSICAL_ADDRESS()
+        self.INITIAL_VALUE = parameter.INITIAL_VALUE()
+
+    # ParameterT
+    def Pack(self, builder):
+        if self.NAME is not None:
+            NAME = builder.CreateString(self.NAME)
+        if self.PARAMETER_TYPE_REF is not None:
+            PARAMETER_TYPE_REF = builder.CreateString(self.PARAMETER_TYPE_REF)
+        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.PROPERTIES is not None:
+            PROPERTIES = self.PROPERTIES.Pack(builder)
+        if self.PHYSICAL_ADDRESS is not None:
+            PHYSICAL_ADDRESS = builder.CreateString(self.PHYSICAL_ADDRESS)
+        if self.INITIAL_VALUE is not None:
+            INITIAL_VALUE = builder.CreateString(self.INITIAL_VALUE)
+        ParameterStart(builder)
+        if self.NAME is not None:
+            ParameterAddNAME(builder, NAME)
+        if self.PARAMETER_TYPE_REF is not None:
+            ParameterAddPARAMETER_TYPE_REF(builder, PARAMETER_TYPE_REF)
+        if self.SHORT_DESCRIPTION is not None:
+            ParameterAddSHORT_DESCRIPTION(builder, SHORT_DESCRIPTION)
+        if self.LONG_DESCRIPTION is not None:
+            ParameterAddLONG_DESCRIPTION(builder, LONG_DESCRIPTION)
+        if self.PROPERTIES is not None:
+            ParameterAddPROPERTIES(builder, PROPERTIES)
+        if self.PHYSICAL_ADDRESS is not None:
+            ParameterAddPHYSICAL_ADDRESS(builder, PHYSICAL_ADDRESS)
+        if self.INITIAL_VALUE is not None:
+            ParameterAddINITIAL_VALUE(builder, INITIAL_VALUE)
+        parameter = ParameterEnd(builder)
+        return parameter

XTC/ParameterComparison.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()
+
+# Parameter comparison for match criteria
+class ParameterComparison(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = ParameterComparison()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsParameterComparison(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    @classmethod
+    def ParameterComparisonBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x24\x58\x54\x43", size_prefixed=size_prefixed)
+
+    # ParameterComparison
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Parameter reference path
+    # ParameterComparison
+    def PARAMETER_REF(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
+
+    # Comparison operator
+    # ParameterComparison
+    def OPERATOR(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos)
+        return 0
+
+    # Value to compare against
+    # ParameterComparison
+    def VALUE(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
+
+    # Use calibrated value (true) or raw value (false)
+    # ParameterComparison
+    def USE_CALIBRATED_VALUE(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return True
+
+def ParameterComparisonStart(builder):
+    builder.StartObject(4)
+
+def Start(builder):
+    ParameterComparisonStart(builder)
+
+def ParameterComparisonAddPARAMETER_REF(builder, PARAMETER_REF):
+    builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(PARAMETER_REF), 0)
+
+def AddPARAMETER_REF(builder, PARAMETER_REF):
+    ParameterComparisonAddPARAMETER_REF(builder, PARAMETER_REF)
+
+def ParameterComparisonAddOPERATOR(builder, OPERATOR):
+    builder.PrependInt8Slot(1, OPERATOR, 0)
+
+def AddOPERATOR(builder, OPERATOR):
+    ParameterComparisonAddOPERATOR(builder, OPERATOR)
+
+def ParameterComparisonAddVALUE(builder, VALUE):
+    builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(VALUE), 0)
+
+def AddVALUE(builder, VALUE):
+    ParameterComparisonAddVALUE(builder, VALUE)
+
+def ParameterComparisonAddUSE_CALIBRATED_VALUE(builder, USE_CALIBRATED_VALUE):
+    builder.PrependBoolSlot(3, USE_CALIBRATED_VALUE, 1)
+
+def AddUSE_CALIBRATED_VALUE(builder, USE_CALIBRATED_VALUE):
+    ParameterComparisonAddUSE_CALIBRATED_VALUE(builder, USE_CALIBRATED_VALUE)
+
+def ParameterComparisonEnd(builder):
+    return builder.EndObject()
+
+def End(builder):
+    return ParameterComparisonEnd(builder)
+
+
+class ParameterComparisonT(object):
+
+    # ParameterComparisonT
+    def __init__(self):
+        self.PARAMETER_REF = None  # type: str
+        self.OPERATOR = 0  # type: int
+        self.VALUE = None  # type: str
+        self.USE_CALIBRATED_VALUE = True  # type: bool
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        parameterComparison = ParameterComparison()
+        parameterComparison.Init(buf, pos)
+        return cls.InitFromObj(parameterComparison)
+
+    @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, parameterComparison):
+        x = ParameterComparisonT()
+        x._UnPack(parameterComparison)
+        return x
+
+    # ParameterComparisonT
+    def _UnPack(self, parameterComparison):
+        if parameterComparison is None:
+            return
+        self.PARAMETER_REF = parameterComparison.PARAMETER_REF()
+        self.OPERATOR = parameterComparison.OPERATOR()
+        self.VALUE = parameterComparison.VALUE()
+        self.USE_CALIBRATED_VALUE = parameterComparison.USE_CALIBRATED_VALUE()
+
+    # ParameterComparisonT
+    def Pack(self, builder):
+        if self.PARAMETER_REF is not None:
+            PARAMETER_REF = builder.CreateString(self.PARAMETER_REF)
+        if self.VALUE is not None:
+            VALUE = builder.CreateString(self.VALUE)
+        ParameterComparisonStart(builder)
+        if self.PARAMETER_REF is not None:
+            ParameterComparisonAddPARAMETER_REF(builder, PARAMETER_REF)
+        ParameterComparisonAddOPERATOR(builder, self.OPERATOR)
+        if self.VALUE is not None:
+            ParameterComparisonAddVALUE(builder, VALUE)
+        ParameterComparisonAddUSE_CALIBRATED_VALUE(builder, self.USE_CALIBRATED_VALUE)
+        parameterComparison = ParameterComparisonEnd(builder)
+        return parameterComparison

XTC/ParameterProperties.py

@@ -0,0 +1,160 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: 
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+# Parameter properties
+class ParameterProperties(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = ParameterProperties()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsParameterProperties(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    @classmethod
+    def ParameterPropertiesBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x24\x58\x54\x43", size_prefixed=size_prefixed)
+
+    # ParameterProperties
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Data source type
+    # ParameterProperties
+    def DATA_SOURCE(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos)
+        return 0
+
+    # Read-only parameter
+    # ParameterProperties
+    def READ_ONLY(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return True
+
+    # System/subsystem name
+    # ParameterProperties
+    def SYSTEM_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
+
+    # Validity condition
+    # ParameterProperties
+    def VALIDITY_CONDITION(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            x = self._tab.Indirect(o + self._tab.Pos)
+            from MatchCriteria import MatchCriteria
+            obj = MatchCriteria()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+def ParameterPropertiesStart(builder):
+    builder.StartObject(4)
+
+def Start(builder):
+    ParameterPropertiesStart(builder)
+
+def ParameterPropertiesAddDATA_SOURCE(builder, DATA_SOURCE):
+    builder.PrependInt8Slot(0, DATA_SOURCE, 0)
+
+def AddDATA_SOURCE(builder, DATA_SOURCE):
+    ParameterPropertiesAddDATA_SOURCE(builder, DATA_SOURCE)
+
+def ParameterPropertiesAddREAD_ONLY(builder, READ_ONLY):
+    builder.PrependBoolSlot(1, READ_ONLY, 1)
+
+def AddREAD_ONLY(builder, READ_ONLY):
+    ParameterPropertiesAddREAD_ONLY(builder, READ_ONLY)
+
+def ParameterPropertiesAddSYSTEM_NAME(builder, SYSTEM_NAME):
+    builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(SYSTEM_NAME), 0)
+
+def AddSYSTEM_NAME(builder, SYSTEM_NAME):
+    ParameterPropertiesAddSYSTEM_NAME(builder, SYSTEM_NAME)
+
+def ParameterPropertiesAddVALIDITY_CONDITION(builder, VALIDITY_CONDITION):
+    builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(VALIDITY_CONDITION), 0)
+
+def AddVALIDITY_CONDITION(builder, VALIDITY_CONDITION):
+    ParameterPropertiesAddVALIDITY_CONDITION(builder, VALIDITY_CONDITION)
+
+def ParameterPropertiesEnd(builder):
+    return builder.EndObject()
+
+def End(builder):
+    return ParameterPropertiesEnd(builder)
+
+import MatchCriteria
+try:
+    from typing import Optional
+except:
+    pass
+
+class ParameterPropertiesT(object):
+
+    # ParameterPropertiesT
+    def __init__(self):
+        self.DATA_SOURCE = 0  # type: int
+        self.READ_ONLY = True  # type: bool
+        self.SYSTEM_NAME = None  # type: str
+        self.VALIDITY_CONDITION = None  # type: Optional[MatchCriteria.MatchCriteriaT]
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        parameterProperties = ParameterProperties()
+        parameterProperties.Init(buf, pos)
+        return cls.InitFromObj(parameterProperties)
+
+    @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, parameterProperties):
+        x = ParameterPropertiesT()
+        x._UnPack(parameterProperties)
+        return x
+
+    # ParameterPropertiesT
+    def _UnPack(self, parameterProperties):
+        if parameterProperties is None:
+            return
+        self.DATA_SOURCE = parameterProperties.DATA_SOURCE()
+        self.READ_ONLY = parameterProperties.READ_ONLY()
+        self.SYSTEM_NAME = parameterProperties.SYSTEM_NAME()
+        if parameterProperties.VALIDITY_CONDITION() is not None:
+            self.VALIDITY_CONDITION = MatchCriteria.MatchCriteriaT.InitFromObj(parameterProperties.VALIDITY_CONDITION())
+
+    # ParameterPropertiesT
+    def Pack(self, builder):
+        if self.SYSTEM_NAME is not None:
+            SYSTEM_NAME = builder.CreateString(self.SYSTEM_NAME)
+        if self.VALIDITY_CONDITION is not None:
+            VALIDITY_CONDITION = self.VALIDITY_CONDITION.Pack(builder)
+        ParameterPropertiesStart(builder)
+        ParameterPropertiesAddDATA_SOURCE(builder, self.DATA_SOURCE)
+        ParameterPropertiesAddREAD_ONLY(builder, self.READ_ONLY)
+        if self.SYSTEM_NAME is not None:
+            ParameterPropertiesAddSYSTEM_NAME(builder, SYSTEM_NAME)
+        if self.VALIDITY_CONDITION is not None:
+            ParameterPropertiesAddVALIDITY_CONDITION(builder, VALIDITY_CONDITION)
+        parameterProperties = ParameterPropertiesEnd(builder)
+        return parameterProperties