spacedatastandards.org 1.73.0__py3-none-any.whl

XTC/ServiceSet.py

@@ -0,0 +1,138 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: 
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+# Collection of services
+class ServiceSet(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = ServiceSet()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsServiceSet(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    @classmethod
+    def ServiceSetBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x24\x58\x54\x43", size_prefixed=size_prefixed)
+
+    # ServiceSet
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Services
+    # ServiceSet
+    def SERVICES(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            x = self._tab.Vector(o)
+            x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
+            x = self._tab.Indirect(x)
+            from Service import Service
+            obj = Service()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # ServiceSet
+    def SERVICESLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # ServiceSet
+    def SERVICESIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        return o == 0
+
+def ServiceSetStart(builder):
+    builder.StartObject(1)
+
+def Start(builder):
+    ServiceSetStart(builder)
+
+def ServiceSetAddSERVICES(builder, SERVICES):
+    builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(SERVICES), 0)
+
+def AddSERVICES(builder, SERVICES):
+    ServiceSetAddSERVICES(builder, SERVICES)
+
+def ServiceSetStartSERVICESVector(builder, numElems):
+    return builder.StartVector(4, numElems, 4)
+
+def StartSERVICESVector(builder, numElems):
+    return ServiceSetStartSERVICESVector(builder, numElems)
+
+def ServiceSetEnd(builder):
+    return builder.EndObject()
+
+def End(builder):
+    return ServiceSetEnd(builder)
+
+import Service
+try:
+    from typing import List
+except:
+    pass
+
+class ServiceSetT(object):
+
+    # ServiceSetT
+    def __init__(self):
+        self.SERVICES = None  # type: List[Service.ServiceT]
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        serviceSet = ServiceSet()
+        serviceSet.Init(buf, pos)
+        return cls.InitFromObj(serviceSet)
+
+    @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, serviceSet):
+        x = ServiceSetT()
+        x._UnPack(serviceSet)
+        return x
+
+    # ServiceSetT
+    def _UnPack(self, serviceSet):
+        if serviceSet is None:
+            return
+        if not serviceSet.SERVICESIsNone():
+            self.SERVICES = []
+            for i in range(serviceSet.SERVICESLength()):
+                if serviceSet.SERVICES(i) is None:
+                    self.SERVICES.append(None)
+                else:
+                    service_ = Service.ServiceT.InitFromObj(serviceSet.SERVICES(i))
+                    self.SERVICES.append(service_)
+
+    # ServiceSetT
+    def Pack(self, builder):
+        if self.SERVICES is not None:
+            SERVICESlist = []
+            for i in range(len(self.SERVICES)):
+                SERVICESlist.append(self.SERVICES[i].Pack(builder))
+            ServiceSetStartSERVICESVector(builder, len(self.SERVICES))
+            for i in reversed(range(len(self.SERVICES))):
+                builder.PrependUOffsetTRelative(SERVICESlist[i])
+            SERVICES = builder.EndVector()
+        ServiceSetStart(builder)
+        if self.SERVICES is not None:
+            ServiceSetAddSERVICES(builder, SERVICES)
+        serviceSet = ServiceSetEnd(builder)
+        return serviceSet

XTC/SplineCalibrator.py

@@ -0,0 +1,172 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: 
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+# Spline calibrator - piecewise linear interpolation
+class SplineCalibrator(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = SplineCalibrator()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsSplineCalibrator(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    @classmethod
+    def SplineCalibratorBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x24\x58\x54\x43", size_prefixed=size_prefixed)
+
+    # SplineCalibrator
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Spline points ordered by raw value
+    # SplineCalibrator
+    def POINTS(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            x = self._tab.Vector(o)
+            x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
+            x = self._tab.Indirect(x)
+            from SplinePoint import SplinePoint
+            obj = SplinePoint()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # SplineCalibrator
+    def POINTSLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # SplineCalibrator
+    def POINTSIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        return o == 0
+
+    # Extrapolate below minimum point
+    # SplineCalibrator
+    def EXTRAPOLATE_LOW(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 False
+
+    # Extrapolate above maximum point
+    # SplineCalibrator
+    def EXTRAPOLATE_HIGH(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+def SplineCalibratorStart(builder):
+    builder.StartObject(3)
+
+def Start(builder):
+    SplineCalibratorStart(builder)
+
+def SplineCalibratorAddPOINTS(builder, POINTS):
+    builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(POINTS), 0)
+
+def AddPOINTS(builder, POINTS):
+    SplineCalibratorAddPOINTS(builder, POINTS)
+
+def SplineCalibratorStartPOINTSVector(builder, numElems):
+    return builder.StartVector(4, numElems, 4)
+
+def StartPOINTSVector(builder, numElems):
+    return SplineCalibratorStartPOINTSVector(builder, numElems)
+
+def SplineCalibratorAddEXTRAPOLATE_LOW(builder, EXTRAPOLATE_LOW):
+    builder.PrependBoolSlot(1, EXTRAPOLATE_LOW, 0)
+
+def AddEXTRAPOLATE_LOW(builder, EXTRAPOLATE_LOW):
+    SplineCalibratorAddEXTRAPOLATE_LOW(builder, EXTRAPOLATE_LOW)
+
+def SplineCalibratorAddEXTRAPOLATE_HIGH(builder, EXTRAPOLATE_HIGH):
+    builder.PrependBoolSlot(2, EXTRAPOLATE_HIGH, 0)
+
+def AddEXTRAPOLATE_HIGH(builder, EXTRAPOLATE_HIGH):
+    SplineCalibratorAddEXTRAPOLATE_HIGH(builder, EXTRAPOLATE_HIGH)
+
+def SplineCalibratorEnd(builder):
+    return builder.EndObject()
+
+def End(builder):
+    return SplineCalibratorEnd(builder)
+
+import SplinePoint
+try:
+    from typing import List
+except:
+    pass
+
+class SplineCalibratorT(object):
+
+    # SplineCalibratorT
+    def __init__(self):
+        self.POINTS = None  # type: List[SplinePoint.SplinePointT]
+        self.EXTRAPOLATE_LOW = False  # type: bool
+        self.EXTRAPOLATE_HIGH = False  # type: bool
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        splineCalibrator = SplineCalibrator()
+        splineCalibrator.Init(buf, pos)
+        return cls.InitFromObj(splineCalibrator)
+
+    @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, splineCalibrator):
+        x = SplineCalibratorT()
+        x._UnPack(splineCalibrator)
+        return x
+
+    # SplineCalibratorT
+    def _UnPack(self, splineCalibrator):
+        if splineCalibrator is None:
+            return
+        if not splineCalibrator.POINTSIsNone():
+            self.POINTS = []
+            for i in range(splineCalibrator.POINTSLength()):
+                if splineCalibrator.POINTS(i) is None:
+                    self.POINTS.append(None)
+                else:
+                    splinePoint_ = SplinePoint.SplinePointT.InitFromObj(splineCalibrator.POINTS(i))
+                    self.POINTS.append(splinePoint_)
+        self.EXTRAPOLATE_LOW = splineCalibrator.EXTRAPOLATE_LOW()
+        self.EXTRAPOLATE_HIGH = splineCalibrator.EXTRAPOLATE_HIGH()
+
+    # SplineCalibratorT
+    def Pack(self, builder):
+        if self.POINTS is not None:
+            POINTSlist = []
+            for i in range(len(self.POINTS)):
+                POINTSlist.append(self.POINTS[i].Pack(builder))
+            SplineCalibratorStartPOINTSVector(builder, len(self.POINTS))
+            for i in reversed(range(len(self.POINTS))):
+                builder.PrependUOffsetTRelative(POINTSlist[i])
+            POINTS = builder.EndVector()
+        SplineCalibratorStart(builder)
+        if self.POINTS is not None:
+            SplineCalibratorAddPOINTS(builder, POINTS)
+        SplineCalibratorAddEXTRAPOLATE_LOW(builder, self.EXTRAPOLATE_LOW)
+        SplineCalibratorAddEXTRAPOLATE_HIGH(builder, self.EXTRAPOLATE_HIGH)
+        splineCalibrator = SplineCalibratorEnd(builder)
+        return splineCalibrator

XTC/SplinePoint.py

@@ -0,0 +1,110 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: 
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+# Spline point for spline calibration
+class SplinePoint(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = SplinePoint()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsSplinePoint(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    @classmethod
+    def SplinePointBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x24\x58\x54\x43", size_prefixed=size_prefixed)
+
+    # SplinePoint
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Raw value
+    # SplinePoint
+    def RAW(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return 0.0
+
+    # Calibrated/engineering value
+    # SplinePoint
+    def CALIBRATED(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
+
+def SplinePointStart(builder):
+    builder.StartObject(2)
+
+def Start(builder):
+    SplinePointStart(builder)
+
+def SplinePointAddRAW(builder, RAW):
+    builder.PrependFloat64Slot(0, RAW, 0.0)
+
+def AddRAW(builder, RAW):
+    SplinePointAddRAW(builder, RAW)
+
+def SplinePointAddCALIBRATED(builder, CALIBRATED):
+    builder.PrependFloat64Slot(1, CALIBRATED, 0.0)
+
+def AddCALIBRATED(builder, CALIBRATED):
+    SplinePointAddCALIBRATED(builder, CALIBRATED)
+
+def SplinePointEnd(builder):
+    return builder.EndObject()
+
+def End(builder):
+    return SplinePointEnd(builder)
+
+
+class SplinePointT(object):
+
+    # SplinePointT
+    def __init__(self):
+        self.RAW = 0.0  # type: float
+        self.CALIBRATED = 0.0  # type: float
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        splinePoint = SplinePoint()
+        splinePoint.Init(buf, pos)
+        return cls.InitFromObj(splinePoint)
+
+    @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, splinePoint):
+        x = SplinePointT()
+        x._UnPack(splinePoint)
+        return x
+
+    # SplinePointT
+    def _UnPack(self, splinePoint):
+        if splinePoint is None:
+            return
+        self.RAW = splinePoint.RAW()
+        self.CALIBRATED = splinePoint.CALIBRATED()
+
+    # SplinePointT
+    def Pack(self, builder):
+        SplinePointStart(builder)
+        SplinePointAddRAW(builder, self.RAW)
+        SplinePointAddCALIBRATED(builder, self.CALIBRATED)
+        splinePoint = SplinePointEnd(builder)
+        return splinePoint

XTC/StaticAlarmRanges.py

@@ -0,0 +1,206 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: 
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+# Static numeric alarm levels
+class StaticAlarmRanges(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = StaticAlarmRanges()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsStaticAlarmRanges(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    @classmethod
+    def StaticAlarmRangesBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x24\x58\x54\x43", size_prefixed=size_prefixed)
+
+    # StaticAlarmRanges
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Watch range
+    # StaticAlarmRanges
+    def WATCH_RANGE(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            x = self._tab.Indirect(o + self._tab.Pos)
+            from AlarmRange import AlarmRange
+            obj = AlarmRange()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # Warning range
+    # StaticAlarmRanges
+    def WARNING_RANGE(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            x = self._tab.Indirect(o + self._tab.Pos)
+            from AlarmRange import AlarmRange
+            obj = AlarmRange()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # Distress range
+    # StaticAlarmRanges
+    def DISTRESS_RANGE(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            x = self._tab.Indirect(o + self._tab.Pos)
+            from AlarmRange import AlarmRange
+            obj = AlarmRange()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # Critical range
+    # StaticAlarmRanges
+    def CRITICAL_RANGE(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            x = self._tab.Indirect(o + self._tab.Pos)
+            from AlarmRange import AlarmRange
+            obj = AlarmRange()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # Severe range
+    # StaticAlarmRanges
+    def SEVERE_RANGE(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            x = self._tab.Indirect(o + self._tab.Pos)
+            from AlarmRange import AlarmRange
+            obj = AlarmRange()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+def StaticAlarmRangesStart(builder):
+    builder.StartObject(5)
+
+def Start(builder):
+    StaticAlarmRangesStart(builder)
+
+def StaticAlarmRangesAddWATCH_RANGE(builder, WATCH_RANGE):
+    builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(WATCH_RANGE), 0)
+
+def AddWATCH_RANGE(builder, WATCH_RANGE):
+    StaticAlarmRangesAddWATCH_RANGE(builder, WATCH_RANGE)
+
+def StaticAlarmRangesAddWARNING_RANGE(builder, WARNING_RANGE):
+    builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(WARNING_RANGE), 0)
+
+def AddWARNING_RANGE(builder, WARNING_RANGE):
+    StaticAlarmRangesAddWARNING_RANGE(builder, WARNING_RANGE)
+
+def StaticAlarmRangesAddDISTRESS_RANGE(builder, DISTRESS_RANGE):
+    builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(DISTRESS_RANGE), 0)
+
+def AddDISTRESS_RANGE(builder, DISTRESS_RANGE):
+    StaticAlarmRangesAddDISTRESS_RANGE(builder, DISTRESS_RANGE)
+
+def StaticAlarmRangesAddCRITICAL_RANGE(builder, CRITICAL_RANGE):
+    builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(CRITICAL_RANGE), 0)
+
+def AddCRITICAL_RANGE(builder, CRITICAL_RANGE):
+    StaticAlarmRangesAddCRITICAL_RANGE(builder, CRITICAL_RANGE)
+
+def StaticAlarmRangesAddSEVERE_RANGE(builder, SEVERE_RANGE):
+    builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(SEVERE_RANGE), 0)
+
+def AddSEVERE_RANGE(builder, SEVERE_RANGE):
+    StaticAlarmRangesAddSEVERE_RANGE(builder, SEVERE_RANGE)
+
+def StaticAlarmRangesEnd(builder):
+    return builder.EndObject()
+
+def End(builder):
+    return StaticAlarmRangesEnd(builder)
+
+import AlarmRange
+try:
+    from typing import Optional
+except:
+    pass
+
+class StaticAlarmRangesT(object):
+
+    # StaticAlarmRangesT
+    def __init__(self):
+        self.WATCH_RANGE = None  # type: Optional[AlarmRange.AlarmRangeT]
+        self.WARNING_RANGE = None  # type: Optional[AlarmRange.AlarmRangeT]
+        self.DISTRESS_RANGE = None  # type: Optional[AlarmRange.AlarmRangeT]
+        self.CRITICAL_RANGE = None  # type: Optional[AlarmRange.AlarmRangeT]
+        self.SEVERE_RANGE = None  # type: Optional[AlarmRange.AlarmRangeT]
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        staticAlarmRanges = StaticAlarmRanges()
+        staticAlarmRanges.Init(buf, pos)
+        return cls.InitFromObj(staticAlarmRanges)
+
+    @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, staticAlarmRanges):
+        x = StaticAlarmRangesT()
+        x._UnPack(staticAlarmRanges)
+        return x
+
+    # StaticAlarmRangesT
+    def _UnPack(self, staticAlarmRanges):
+        if staticAlarmRanges is None:
+            return
+        if staticAlarmRanges.WATCH_RANGE() is not None:
+            self.WATCH_RANGE = AlarmRange.AlarmRangeT.InitFromObj(staticAlarmRanges.WATCH_RANGE())
+        if staticAlarmRanges.WARNING_RANGE() is not None:
+            self.WARNING_RANGE = AlarmRange.AlarmRangeT.InitFromObj(staticAlarmRanges.WARNING_RANGE())
+        if staticAlarmRanges.DISTRESS_RANGE() is not None:
+            self.DISTRESS_RANGE = AlarmRange.AlarmRangeT.InitFromObj(staticAlarmRanges.DISTRESS_RANGE())
+        if staticAlarmRanges.CRITICAL_RANGE() is not None:
+            self.CRITICAL_RANGE = AlarmRange.AlarmRangeT.InitFromObj(staticAlarmRanges.CRITICAL_RANGE())
+        if staticAlarmRanges.SEVERE_RANGE() is not None:
+            self.SEVERE_RANGE = AlarmRange.AlarmRangeT.InitFromObj(staticAlarmRanges.SEVERE_RANGE())
+
+    # StaticAlarmRangesT
+    def Pack(self, builder):
+        if self.WATCH_RANGE is not None:
+            WATCH_RANGE = self.WATCH_RANGE.Pack(builder)
+        if self.WARNING_RANGE is not None:
+            WARNING_RANGE = self.WARNING_RANGE.Pack(builder)
+        if self.DISTRESS_RANGE is not None:
+            DISTRESS_RANGE = self.DISTRESS_RANGE.Pack(builder)
+        if self.CRITICAL_RANGE is not None:
+            CRITICAL_RANGE = self.CRITICAL_RANGE.Pack(builder)
+        if self.SEVERE_RANGE is not None:
+            SEVERE_RANGE = self.SEVERE_RANGE.Pack(builder)
+        StaticAlarmRangesStart(builder)
+        if self.WATCH_RANGE is not None:
+            StaticAlarmRangesAddWATCH_RANGE(builder, WATCH_RANGE)
+        if self.WARNING_RANGE is not None:
+            StaticAlarmRangesAddWARNING_RANGE(builder, WARNING_RANGE)
+        if self.DISTRESS_RANGE is not None:
+            StaticAlarmRangesAddDISTRESS_RANGE(builder, DISTRESS_RANGE)
+        if self.CRITICAL_RANGE is not None:
+            StaticAlarmRangesAddCRITICAL_RANGE(builder, CRITICAL_RANGE)
+        if self.SEVERE_RANGE is not None:
+            StaticAlarmRangesAddSEVERE_RANGE(builder, SEVERE_RANGE)
+        staticAlarmRanges = StaticAlarmRangesEnd(builder)
+        return staticAlarmRanges