spacedatastandards.org 1.73.0__py3-none-any.whl

XTC/ContainerRefEntry.py

@@ -0,0 +1,178 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: 
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+# Container reference entry (nested container)
+class ContainerRefEntry(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = ContainerRefEntry()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsContainerRefEntry(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    @classmethod
+    def ContainerRefEntryBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x24\x58\x54\x43", size_prefixed=size_prefixed)
+
+    # ContainerRefEntry
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Container reference path
+    # ContainerRefEntry
+    def CONTAINER_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
+
+    # Location in container
+    # ContainerRefEntry
+    def LOCATION(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            x = self._tab.Indirect(o + self._tab.Pos)
+            from LocationInContainer import LocationInContainer
+            obj = LocationInContainer()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # Repeat specification
+    # ContainerRefEntry
+    def REPEAT(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            x = self._tab.Indirect(o + self._tab.Pos)
+            from RepeatEntry import RepeatEntry
+            obj = RepeatEntry()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # Include condition
+    # ContainerRefEntry
+    def INCLUDE_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 ContainerRefEntryStart(builder):
+    builder.StartObject(4)
+
+def Start(builder):
+    ContainerRefEntryStart(builder)
+
+def ContainerRefEntryAddCONTAINER_REF(builder, CONTAINER_REF):
+    builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(CONTAINER_REF), 0)
+
+def AddCONTAINER_REF(builder, CONTAINER_REF):
+    ContainerRefEntryAddCONTAINER_REF(builder, CONTAINER_REF)
+
+def ContainerRefEntryAddLOCATION(builder, LOCATION):
+    builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(LOCATION), 0)
+
+def AddLOCATION(builder, LOCATION):
+    ContainerRefEntryAddLOCATION(builder, LOCATION)
+
+def ContainerRefEntryAddREPEAT(builder, REPEAT):
+    builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(REPEAT), 0)
+
+def AddREPEAT(builder, REPEAT):
+    ContainerRefEntryAddREPEAT(builder, REPEAT)
+
+def ContainerRefEntryAddINCLUDE_CONDITION(builder, INCLUDE_CONDITION):
+    builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(INCLUDE_CONDITION), 0)
+
+def AddINCLUDE_CONDITION(builder, INCLUDE_CONDITION):
+    ContainerRefEntryAddINCLUDE_CONDITION(builder, INCLUDE_CONDITION)
+
+def ContainerRefEntryEnd(builder):
+    return builder.EndObject()
+
+def End(builder):
+    return ContainerRefEntryEnd(builder)
+
+import LocationInContainer
+import MatchCriteria
+import RepeatEntry
+try:
+    from typing import Optional
+except:
+    pass
+
+class ContainerRefEntryT(object):
+
+    # ContainerRefEntryT
+    def __init__(self):
+        self.CONTAINER_REF = None  # type: str
+        self.LOCATION = None  # type: Optional[LocationInContainer.LocationInContainerT]
+        self.REPEAT = None  # type: Optional[RepeatEntry.RepeatEntryT]
+        self.INCLUDE_CONDITION = None  # type: Optional[MatchCriteria.MatchCriteriaT]
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        containerRefEntry = ContainerRefEntry()
+        containerRefEntry.Init(buf, pos)
+        return cls.InitFromObj(containerRefEntry)
+
+    @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, containerRefEntry):
+        x = ContainerRefEntryT()
+        x._UnPack(containerRefEntry)
+        return x
+
+    # ContainerRefEntryT
+    def _UnPack(self, containerRefEntry):
+        if containerRefEntry is None:
+            return
+        self.CONTAINER_REF = containerRefEntry.CONTAINER_REF()
+        if containerRefEntry.LOCATION() is not None:
+            self.LOCATION = LocationInContainer.LocationInContainerT.InitFromObj(containerRefEntry.LOCATION())
+        if containerRefEntry.REPEAT() is not None:
+            self.REPEAT = RepeatEntry.RepeatEntryT.InitFromObj(containerRefEntry.REPEAT())
+        if containerRefEntry.INCLUDE_CONDITION() is not None:
+            self.INCLUDE_CONDITION = MatchCriteria.MatchCriteriaT.InitFromObj(containerRefEntry.INCLUDE_CONDITION())
+
+    # ContainerRefEntryT
+    def Pack(self, builder):
+        if self.CONTAINER_REF is not None:
+            CONTAINER_REF = builder.CreateString(self.CONTAINER_REF)
+        if self.LOCATION is not None:
+            LOCATION = self.LOCATION.Pack(builder)
+        if self.REPEAT is not None:
+            REPEAT = self.REPEAT.Pack(builder)
+        if self.INCLUDE_CONDITION is not None:
+            INCLUDE_CONDITION = self.INCLUDE_CONDITION.Pack(builder)
+        ContainerRefEntryStart(builder)
+        if self.CONTAINER_REF is not None:
+            ContainerRefEntryAddCONTAINER_REF(builder, CONTAINER_REF)
+        if self.LOCATION is not None:
+            ContainerRefEntryAddLOCATION(builder, LOCATION)
+        if self.REPEAT is not None:
+            ContainerRefEntryAddREPEAT(builder, REPEAT)
+        if self.INCLUDE_CONDITION is not None:
+            ContainerRefEntryAddINCLUDE_CONDITION(builder, INCLUDE_CONDITION)
+        containerRefEntry = ContainerRefEntryEnd(builder)
+        return containerRefEntry

XTC/ContainerSet.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 sequence containers
+class ContainerSet(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = ContainerSet()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsContainerSet(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    @classmethod
+    def ContainerSetBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x24\x58\x54\x43", size_prefixed=size_prefixed)
+
+    # ContainerSet
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Sequence containers
+    # ContainerSet
+    def CONTAINERS(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 SequenceContainer import SequenceContainer
+            obj = SequenceContainer()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # ContainerSet
+    def CONTAINERSLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # ContainerSet
+    def CONTAINERSIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        return o == 0
+
+def ContainerSetStart(builder):
+    builder.StartObject(1)
+
+def Start(builder):
+    ContainerSetStart(builder)
+
+def ContainerSetAddCONTAINERS(builder, CONTAINERS):
+    builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(CONTAINERS), 0)
+
+def AddCONTAINERS(builder, CONTAINERS):
+    ContainerSetAddCONTAINERS(builder, CONTAINERS)
+
+def ContainerSetStartCONTAINERSVector(builder, numElems):
+    return builder.StartVector(4, numElems, 4)
+
+def StartCONTAINERSVector(builder, numElems):
+    return ContainerSetStartCONTAINERSVector(builder, numElems)
+
+def ContainerSetEnd(builder):
+    return builder.EndObject()
+
+def End(builder):
+    return ContainerSetEnd(builder)
+
+import SequenceContainer
+try:
+    from typing import List
+except:
+    pass
+
+class ContainerSetT(object):
+
+    # ContainerSetT
+    def __init__(self):
+        self.CONTAINERS = None  # type: List[SequenceContainer.SequenceContainerT]
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        containerSet = ContainerSet()
+        containerSet.Init(buf, pos)
+        return cls.InitFromObj(containerSet)
+
+    @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, containerSet):
+        x = ContainerSetT()
+        x._UnPack(containerSet)
+        return x
+
+    # ContainerSetT
+    def _UnPack(self, containerSet):
+        if containerSet is None:
+            return
+        if not containerSet.CONTAINERSIsNone():
+            self.CONTAINERS = []
+            for i in range(containerSet.CONTAINERSLength()):
+                if containerSet.CONTAINERS(i) is None:
+                    self.CONTAINERS.append(None)
+                else:
+                    sequenceContainer_ = SequenceContainer.SequenceContainerT.InitFromObj(containerSet.CONTAINERS(i))
+                    self.CONTAINERS.append(sequenceContainer_)
+
+    # ContainerSetT
+    def Pack(self, builder):
+        if self.CONTAINERS is not None:
+            CONTAINERSlist = []
+            for i in range(len(self.CONTAINERS)):
+                CONTAINERSlist.append(self.CONTAINERS[i].Pack(builder))
+            ContainerSetStartCONTAINERSVector(builder, len(self.CONTAINERS))
+            for i in reversed(range(len(self.CONTAINERS))):
+                builder.PrependUOffsetTRelative(CONTAINERSlist[i])
+            CONTAINERS = builder.EndVector()
+        ContainerSetStart(builder)
+        if self.CONTAINERS is not None:
+            ContainerSetAddCONTAINERS(builder, CONTAINERS)
+        containerSet = ContainerSetEnd(builder)
+        return containerSet

XTC/ContextAlarm.py

@@ -0,0 +1,132 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: 
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+# Context-dependent alarm
+class ContextAlarm(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = ContextAlarm()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsContextAlarm(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    @classmethod
+    def ContextAlarmBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x24\x58\x54\x43", size_prefixed=size_prefixed)
+
+    # ContextAlarm
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Match criteria for this alarm context
+    # ContextAlarm
+    def MATCH_CRITERIA(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        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
+
+    # Alarm definition for this context
+    # ContextAlarm
+    def ALARM(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            x = self._tab.Indirect(o + self._tab.Pos)
+            from DefaultAlarm import DefaultAlarm
+            obj = DefaultAlarm()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+def ContextAlarmStart(builder):
+    builder.StartObject(2)
+
+def Start(builder):
+    ContextAlarmStart(builder)
+
+def ContextAlarmAddMATCH_CRITERIA(builder, MATCH_CRITERIA):
+    builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(MATCH_CRITERIA), 0)
+
+def AddMATCH_CRITERIA(builder, MATCH_CRITERIA):
+    ContextAlarmAddMATCH_CRITERIA(builder, MATCH_CRITERIA)
+
+def ContextAlarmAddALARM(builder, ALARM):
+    builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(ALARM), 0)
+
+def AddALARM(builder, ALARM):
+    ContextAlarmAddALARM(builder, ALARM)
+
+def ContextAlarmEnd(builder):
+    return builder.EndObject()
+
+def End(builder):
+    return ContextAlarmEnd(builder)
+
+import DefaultAlarm
+import MatchCriteria
+try:
+    from typing import Optional
+except:
+    pass
+
+class ContextAlarmT(object):
+
+    # ContextAlarmT
+    def __init__(self):
+        self.MATCH_CRITERIA = None  # type: Optional[MatchCriteria.MatchCriteriaT]
+        self.ALARM = None  # type: Optional[DefaultAlarm.DefaultAlarmT]
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        contextAlarm = ContextAlarm()
+        contextAlarm.Init(buf, pos)
+        return cls.InitFromObj(contextAlarm)
+
+    @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, contextAlarm):
+        x = ContextAlarmT()
+        x._UnPack(contextAlarm)
+        return x
+
+    # ContextAlarmT
+    def _UnPack(self, contextAlarm):
+        if contextAlarm is None:
+            return
+        if contextAlarm.MATCH_CRITERIA() is not None:
+            self.MATCH_CRITERIA = MatchCriteria.MatchCriteriaT.InitFromObj(contextAlarm.MATCH_CRITERIA())
+        if contextAlarm.ALARM() is not None:
+            self.ALARM = DefaultAlarm.DefaultAlarmT.InitFromObj(contextAlarm.ALARM())
+
+    # ContextAlarmT
+    def Pack(self, builder):
+        if self.MATCH_CRITERIA is not None:
+            MATCH_CRITERIA = self.MATCH_CRITERIA.Pack(builder)
+        if self.ALARM is not None:
+            ALARM = self.ALARM.Pack(builder)
+        ContextAlarmStart(builder)
+        if self.MATCH_CRITERIA is not None:
+            ContextAlarmAddMATCH_CRITERIA(builder, MATCH_CRITERIA)
+        if self.ALARM is not None:
+            ContextAlarmAddALARM(builder, ALARM)
+        contextAlarm = ContextAlarmEnd(builder)
+        return contextAlarm

XTC/ContextCalibrator.py

@@ -0,0 +1,184 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: 
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+# Context-dependent calibrator selection
+class ContextCalibrator(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = ContextCalibrator()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsContextCalibrator(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    @classmethod
+    def ContextCalibratorBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x24\x58\x54\x43", size_prefixed=size_prefixed)
+
+    # ContextCalibrator
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Match criteria for selecting this calibrator
+    # ContextCalibrator
+    def MATCH_CRITERIA(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        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
+
+    # Polynomial calibrator (if used)
+    # ContextCalibrator
+    def POLYNOMIAL(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            x = self._tab.Indirect(o + self._tab.Pos)
+            from PolynomialCalibrator import PolynomialCalibrator
+            obj = PolynomialCalibrator()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # Spline calibrator (if used)
+    # ContextCalibrator
+    def SPLINE(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            x = self._tab.Indirect(o + self._tab.Pos)
+            from SplineCalibrator import SplineCalibrator
+            obj = SplineCalibrator()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # Math operation calibrator (if used)
+    # ContextCalibrator
+    def MATH_OPERATION(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            x = self._tab.Indirect(o + self._tab.Pos)
+            from MathOperation import MathOperation
+            obj = MathOperation()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+def ContextCalibratorStart(builder):
+    builder.StartObject(4)
+
+def Start(builder):
+    ContextCalibratorStart(builder)
+
+def ContextCalibratorAddMATCH_CRITERIA(builder, MATCH_CRITERIA):
+    builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(MATCH_CRITERIA), 0)
+
+def AddMATCH_CRITERIA(builder, MATCH_CRITERIA):
+    ContextCalibratorAddMATCH_CRITERIA(builder, MATCH_CRITERIA)
+
+def ContextCalibratorAddPOLYNOMIAL(builder, POLYNOMIAL):
+    builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(POLYNOMIAL), 0)
+
+def AddPOLYNOMIAL(builder, POLYNOMIAL):
+    ContextCalibratorAddPOLYNOMIAL(builder, POLYNOMIAL)
+
+def ContextCalibratorAddSPLINE(builder, SPLINE):
+    builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(SPLINE), 0)
+
+def AddSPLINE(builder, SPLINE):
+    ContextCalibratorAddSPLINE(builder, SPLINE)
+
+def ContextCalibratorAddMATH_OPERATION(builder, MATH_OPERATION):
+    builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(MATH_OPERATION), 0)
+
+def AddMATH_OPERATION(builder, MATH_OPERATION):
+    ContextCalibratorAddMATH_OPERATION(builder, MATH_OPERATION)
+
+def ContextCalibratorEnd(builder):
+    return builder.EndObject()
+
+def End(builder):
+    return ContextCalibratorEnd(builder)
+
+import MatchCriteria
+import MathOperation
+import PolynomialCalibrator
+import SplineCalibrator
+try:
+    from typing import Optional
+except:
+    pass
+
+class ContextCalibratorT(object):
+
+    # ContextCalibratorT
+    def __init__(self):
+        self.MATCH_CRITERIA = None  # type: Optional[MatchCriteria.MatchCriteriaT]
+        self.POLYNOMIAL = None  # type: Optional[PolynomialCalibrator.PolynomialCalibratorT]
+        self.SPLINE = None  # type: Optional[SplineCalibrator.SplineCalibratorT]
+        self.MATH_OPERATION = None  # type: Optional[MathOperation.MathOperationT]
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        contextCalibrator = ContextCalibrator()
+        contextCalibrator.Init(buf, pos)
+        return cls.InitFromObj(contextCalibrator)
+
+    @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, contextCalibrator):
+        x = ContextCalibratorT()
+        x._UnPack(contextCalibrator)
+        return x
+
+    # ContextCalibratorT
+    def _UnPack(self, contextCalibrator):
+        if contextCalibrator is None:
+            return
+        if contextCalibrator.MATCH_CRITERIA() is not None:
+            self.MATCH_CRITERIA = MatchCriteria.MatchCriteriaT.InitFromObj(contextCalibrator.MATCH_CRITERIA())
+        if contextCalibrator.POLYNOMIAL() is not None:
+            self.POLYNOMIAL = PolynomialCalibrator.PolynomialCalibratorT.InitFromObj(contextCalibrator.POLYNOMIAL())
+        if contextCalibrator.SPLINE() is not None:
+            self.SPLINE = SplineCalibrator.SplineCalibratorT.InitFromObj(contextCalibrator.SPLINE())
+        if contextCalibrator.MATH_OPERATION() is not None:
+            self.MATH_OPERATION = MathOperation.MathOperationT.InitFromObj(contextCalibrator.MATH_OPERATION())
+
+    # ContextCalibratorT
+    def Pack(self, builder):
+        if self.MATCH_CRITERIA is not None:
+            MATCH_CRITERIA = self.MATCH_CRITERIA.Pack(builder)
+        if self.POLYNOMIAL is not None:
+            POLYNOMIAL = self.POLYNOMIAL.Pack(builder)
+        if self.SPLINE is not None:
+            SPLINE = self.SPLINE.Pack(builder)
+        if self.MATH_OPERATION is not None:
+            MATH_OPERATION = self.MATH_OPERATION.Pack(builder)
+        ContextCalibratorStart(builder)
+        if self.MATCH_CRITERIA is not None:
+            ContextCalibratorAddMATCH_CRITERIA(builder, MATCH_CRITERIA)
+        if self.POLYNOMIAL is not None:
+            ContextCalibratorAddPOLYNOMIAL(builder, POLYNOMIAL)
+        if self.SPLINE is not None:
+            ContextCalibratorAddSPLINE(builder, SPLINE)
+        if self.MATH_OPERATION is not None:
+            ContextCalibratorAddMATH_OPERATION(builder, MATH_OPERATION)
+        contextCalibrator = ContextCalibratorEnd(builder)
+        return contextCalibrator