spacedatastandards.org 1.73.0__py3-none-any.whl

XTC/Interlock.py

@@ -0,0 +1,133 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: 
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+# Interlock constraint
+class Interlock(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = Interlock()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsInterlock(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    @classmethod
+    def InterlockBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x24\x58\x54\x43", size_prefixed=size_prefixed)
+
+    # Interlock
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Parameter reference
+    # Interlock
+    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
+
+    # Required value
+    # Interlock
+    def VALUE(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
+
+    # Operator for comparison
+    # Interlock
+    def OPERATOR(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos)
+        return 0
+
+def InterlockStart(builder):
+    builder.StartObject(3)
+
+def Start(builder):
+    InterlockStart(builder)
+
+def InterlockAddPARAMETER_REF(builder, PARAMETER_REF):
+    builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(PARAMETER_REF), 0)
+
+def AddPARAMETER_REF(builder, PARAMETER_REF):
+    InterlockAddPARAMETER_REF(builder, PARAMETER_REF)
+
+def InterlockAddVALUE(builder, VALUE):
+    builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(VALUE), 0)
+
+def AddVALUE(builder, VALUE):
+    InterlockAddVALUE(builder, VALUE)
+
+def InterlockAddOPERATOR(builder, OPERATOR):
+    builder.PrependInt8Slot(2, OPERATOR, 0)
+
+def AddOPERATOR(builder, OPERATOR):
+    InterlockAddOPERATOR(builder, OPERATOR)
+
+def InterlockEnd(builder):
+    return builder.EndObject()
+
+def End(builder):
+    return InterlockEnd(builder)
+
+
+class InterlockT(object):
+
+    # InterlockT
+    def __init__(self):
+        self.PARAMETER_REF = None  # type: str
+        self.VALUE = None  # type: str
+        self.OPERATOR = 0  # type: int
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        interlock = Interlock()
+        interlock.Init(buf, pos)
+        return cls.InitFromObj(interlock)
+
+    @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, interlock):
+        x = InterlockT()
+        x._UnPack(interlock)
+        return x
+
+    # InterlockT
+    def _UnPack(self, interlock):
+        if interlock is None:
+            return
+        self.PARAMETER_REF = interlock.PARAMETER_REF()
+        self.VALUE = interlock.VALUE()
+        self.OPERATOR = interlock.OPERATOR()
+
+    # InterlockT
+    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)
+        InterlockStart(builder)
+        if self.PARAMETER_REF is not None:
+            InterlockAddPARAMETER_REF(builder, PARAMETER_REF)
+        if self.VALUE is not None:
+            InterlockAddVALUE(builder, VALUE)
+        InterlockAddOPERATOR(builder, self.OPERATOR)
+        interlock = InterlockEnd(builder)
+        return interlock

XTC/LocationInContainer.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()
+
+# Location specification within a container
+class LocationInContainer(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = LocationInContainer()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsLocationInContainer(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    @classmethod
+    def LocationInContainerBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x24\x58\x54\x43", size_prefixed=size_prefixed)
+
+    # LocationInContainer
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Reference location type
+    # LocationInContainer
+    def REFERENCE_LOCATION(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 2
+
+    # Offset in bits from reference location
+    # LocationInContainer
+    def OFFSET_IN_BITS(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
+        return 0
+
+def LocationInContainerStart(builder):
+    builder.StartObject(2)
+
+def Start(builder):
+    LocationInContainerStart(builder)
+
+def LocationInContainerAddREFERENCE_LOCATION(builder, REFERENCE_LOCATION):
+    builder.PrependInt8Slot(0, REFERENCE_LOCATION, 2)
+
+def AddREFERENCE_LOCATION(builder, REFERENCE_LOCATION):
+    LocationInContainerAddREFERENCE_LOCATION(builder, REFERENCE_LOCATION)
+
+def LocationInContainerAddOFFSET_IN_BITS(builder, OFFSET_IN_BITS):
+    builder.PrependInt32Slot(1, OFFSET_IN_BITS, 0)
+
+def AddOFFSET_IN_BITS(builder, OFFSET_IN_BITS):
+    LocationInContainerAddOFFSET_IN_BITS(builder, OFFSET_IN_BITS)
+
+def LocationInContainerEnd(builder):
+    return builder.EndObject()
+
+def End(builder):
+    return LocationInContainerEnd(builder)
+
+
+class LocationInContainerT(object):
+
+    # LocationInContainerT
+    def __init__(self):
+        self.REFERENCE_LOCATION = 2  # type: int
+        self.OFFSET_IN_BITS = 0  # type: int
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        locationInContainer = LocationInContainer()
+        locationInContainer.Init(buf, pos)
+        return cls.InitFromObj(locationInContainer)
+
+    @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, locationInContainer):
+        x = LocationInContainerT()
+        x._UnPack(locationInContainer)
+        return x
+
+    # LocationInContainerT
+    def _UnPack(self, locationInContainer):
+        if locationInContainer is None:
+            return
+        self.REFERENCE_LOCATION = locationInContainer.REFERENCE_LOCATION()
+        self.OFFSET_IN_BITS = locationInContainer.OFFSET_IN_BITS()
+
+    # LocationInContainerT
+    def Pack(self, builder):
+        LocationInContainerStart(builder)
+        LocationInContainerAddREFERENCE_LOCATION(builder, self.REFERENCE_LOCATION)
+        LocationInContainerAddOFFSET_IN_BITS(builder, self.OFFSET_IN_BITS)
+        locationInContainer = LocationInContainerEnd(builder)
+        return locationInContainer

XTC/MatchCriteria.py

@@ -0,0 +1,209 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: 
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+# Match criteria for conditional logic
+class MatchCriteria(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = MatchCriteria()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsMatchCriteria(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    @classmethod
+    def MatchCriteriaBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x24\x58\x54\x43", size_prefixed=size_prefixed)
+
+    # MatchCriteria
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Single comparison
+    # MatchCriteria
+    def COMPARISON(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            x = self._tab.Indirect(o + self._tab.Pos)
+            from ParameterComparison import ParameterComparison
+            obj = ParameterComparison()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # List of comparisons (implicit AND)
+    # MatchCriteria
+    def COMPARISON_LIST(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 ParameterComparison import ParameterComparison
+            obj = ParameterComparison()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # MatchCriteria
+    def COMPARISON_LISTLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # MatchCriteria
+    def COMPARISON_LISTIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        return o == 0
+
+    # Boolean expression
+    # MatchCriteria
+    def BOOLEAN_EXPRESSION(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            x = self._tab.Indirect(o + self._tab.Pos)
+            from BooleanExpression import BooleanExpression
+            obj = BooleanExpression()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # Custom algorithm reference
+    # MatchCriteria
+    def CUSTOM_ALGORITHM(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
+
+def MatchCriteriaStart(builder):
+    builder.StartObject(4)
+
+def Start(builder):
+    MatchCriteriaStart(builder)
+
+def MatchCriteriaAddCOMPARISON(builder, COMPARISON):
+    builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(COMPARISON), 0)
+
+def AddCOMPARISON(builder, COMPARISON):
+    MatchCriteriaAddCOMPARISON(builder, COMPARISON)
+
+def MatchCriteriaAddCOMPARISON_LIST(builder, COMPARISON_LIST):
+    builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(COMPARISON_LIST), 0)
+
+def AddCOMPARISON_LIST(builder, COMPARISON_LIST):
+    MatchCriteriaAddCOMPARISON_LIST(builder, COMPARISON_LIST)
+
+def MatchCriteriaStartCOMPARISON_LISTVector(builder, numElems):
+    return builder.StartVector(4, numElems, 4)
+
+def StartCOMPARISON_LISTVector(builder, numElems):
+    return MatchCriteriaStartCOMPARISON_LISTVector(builder, numElems)
+
+def MatchCriteriaAddBOOLEAN_EXPRESSION(builder, BOOLEAN_EXPRESSION):
+    builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(BOOLEAN_EXPRESSION), 0)
+
+def AddBOOLEAN_EXPRESSION(builder, BOOLEAN_EXPRESSION):
+    MatchCriteriaAddBOOLEAN_EXPRESSION(builder, BOOLEAN_EXPRESSION)
+
+def MatchCriteriaAddCUSTOM_ALGORITHM(builder, CUSTOM_ALGORITHM):
+    builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(CUSTOM_ALGORITHM), 0)
+
+def AddCUSTOM_ALGORITHM(builder, CUSTOM_ALGORITHM):
+    MatchCriteriaAddCUSTOM_ALGORITHM(builder, CUSTOM_ALGORITHM)
+
+def MatchCriteriaEnd(builder):
+    return builder.EndObject()
+
+def End(builder):
+    return MatchCriteriaEnd(builder)
+
+import BooleanExpression
+import ParameterComparison
+try:
+    from typing import List, Optional
+except:
+    pass
+
+class MatchCriteriaT(object):
+
+    # MatchCriteriaT
+    def __init__(self):
+        self.COMPARISON = None  # type: Optional[ParameterComparison.ParameterComparisonT]
+        self.COMPARISON_LIST = None  # type: List[ParameterComparison.ParameterComparisonT]
+        self.BOOLEAN_EXPRESSION = None  # type: Optional[BooleanExpression.BooleanExpressionT]
+        self.CUSTOM_ALGORITHM = None  # type: str
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        matchCriteria = MatchCriteria()
+        matchCriteria.Init(buf, pos)
+        return cls.InitFromObj(matchCriteria)
+
+    @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, matchCriteria):
+        x = MatchCriteriaT()
+        x._UnPack(matchCriteria)
+        return x
+
+    # MatchCriteriaT
+    def _UnPack(self, matchCriteria):
+        if matchCriteria is None:
+            return
+        if matchCriteria.COMPARISON() is not None:
+            self.COMPARISON = ParameterComparison.ParameterComparisonT.InitFromObj(matchCriteria.COMPARISON())
+        if not matchCriteria.COMPARISON_LISTIsNone():
+            self.COMPARISON_LIST = []
+            for i in range(matchCriteria.COMPARISON_LISTLength()):
+                if matchCriteria.COMPARISON_LIST(i) is None:
+                    self.COMPARISON_LIST.append(None)
+                else:
+                    parameterComparison_ = ParameterComparison.ParameterComparisonT.InitFromObj(matchCriteria.COMPARISON_LIST(i))
+                    self.COMPARISON_LIST.append(parameterComparison_)
+        if matchCriteria.BOOLEAN_EXPRESSION() is not None:
+            self.BOOLEAN_EXPRESSION = BooleanExpression.BooleanExpressionT.InitFromObj(matchCriteria.BOOLEAN_EXPRESSION())
+        self.CUSTOM_ALGORITHM = matchCriteria.CUSTOM_ALGORITHM()
+
+    # MatchCriteriaT
+    def Pack(self, builder):
+        if self.COMPARISON is not None:
+            COMPARISON = self.COMPARISON.Pack(builder)
+        if self.COMPARISON_LIST is not None:
+            COMPARISON_LISTlist = []
+            for i in range(len(self.COMPARISON_LIST)):
+                COMPARISON_LISTlist.append(self.COMPARISON_LIST[i].Pack(builder))
+            MatchCriteriaStartCOMPARISON_LISTVector(builder, len(self.COMPARISON_LIST))
+            for i in reversed(range(len(self.COMPARISON_LIST))):
+                builder.PrependUOffsetTRelative(COMPARISON_LISTlist[i])
+            COMPARISON_LIST = builder.EndVector()
+        if self.BOOLEAN_EXPRESSION is not None:
+            BOOLEAN_EXPRESSION = self.BOOLEAN_EXPRESSION.Pack(builder)
+        if self.CUSTOM_ALGORITHM is not None:
+            CUSTOM_ALGORITHM = builder.CreateString(self.CUSTOM_ALGORITHM)
+        MatchCriteriaStart(builder)
+        if self.COMPARISON is not None:
+            MatchCriteriaAddCOMPARISON(builder, COMPARISON)
+        if self.COMPARISON_LIST is not None:
+            MatchCriteriaAddCOMPARISON_LIST(builder, COMPARISON_LIST)
+        if self.BOOLEAN_EXPRESSION is not None:
+            MatchCriteriaAddBOOLEAN_EXPRESSION(builder, BOOLEAN_EXPRESSION)
+        if self.CUSTOM_ALGORITHM is not None:
+            MatchCriteriaAddCUSTOM_ALGORITHM(builder, CUSTOM_ALGORITHM)
+        matchCriteria = MatchCriteriaEnd(builder)
+        return matchCriteria

XTC/MathAlgorithm.py

@@ -0,0 +1,218 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: 
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+# Math algorithm (inline calculation)
+class MathAlgorithm(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = MathAlgorithm()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsMathAlgorithm(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    @classmethod
+    def MathAlgorithmBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x24\x58\x54\x43", size_prefixed=size_prefixed)
+
+    # MathAlgorithm
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Algorithm name
+    # MathAlgorithm
+    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
+
+    # Short description
+    # MathAlgorithm
+    def SHORT_DESCRIPTION(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
+
+    # Math operation in RPN
+    # MathAlgorithm
+    def MATH_OPERATION(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
+
+    # Output parameter reference
+    # MathAlgorithm
+    def OUTPUT_PARAMETER_REF(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
+
+    # Trigger conditions
+    # MathAlgorithm
+    def TRIGGERS(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            x = self._tab.Vector(o)
+            x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
+            x = self._tab.Indirect(x)
+            from AlgorithmTrigger import AlgorithmTrigger
+            obj = AlgorithmTrigger()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # MathAlgorithm
+    def TRIGGERSLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # MathAlgorithm
+    def TRIGGERSIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        return o == 0
+
+def MathAlgorithmStart(builder):
+    builder.StartObject(5)
+
+def Start(builder):
+    MathAlgorithmStart(builder)
+
+def MathAlgorithmAddNAME(builder, NAME):
+    builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(NAME), 0)
+
+def AddNAME(builder, NAME):
+    MathAlgorithmAddNAME(builder, NAME)
+
+def MathAlgorithmAddSHORT_DESCRIPTION(builder, SHORT_DESCRIPTION):
+    builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(SHORT_DESCRIPTION), 0)
+
+def AddSHORT_DESCRIPTION(builder, SHORT_DESCRIPTION):
+    MathAlgorithmAddSHORT_DESCRIPTION(builder, SHORT_DESCRIPTION)
+
+def MathAlgorithmAddMATH_OPERATION(builder, MATH_OPERATION):
+    builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(MATH_OPERATION), 0)
+
+def AddMATH_OPERATION(builder, MATH_OPERATION):
+    MathAlgorithmAddMATH_OPERATION(builder, MATH_OPERATION)
+
+def MathAlgorithmAddOUTPUT_PARAMETER_REF(builder, OUTPUT_PARAMETER_REF):
+    builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(OUTPUT_PARAMETER_REF), 0)
+
+def AddOUTPUT_PARAMETER_REF(builder, OUTPUT_PARAMETER_REF):
+    MathAlgorithmAddOUTPUT_PARAMETER_REF(builder, OUTPUT_PARAMETER_REF)
+
+def MathAlgorithmAddTRIGGERS(builder, TRIGGERS):
+    builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(TRIGGERS), 0)
+
+def AddTRIGGERS(builder, TRIGGERS):
+    MathAlgorithmAddTRIGGERS(builder, TRIGGERS)
+
+def MathAlgorithmStartTRIGGERSVector(builder, numElems):
+    return builder.StartVector(4, numElems, 4)
+
+def StartTRIGGERSVector(builder, numElems):
+    return MathAlgorithmStartTRIGGERSVector(builder, numElems)
+
+def MathAlgorithmEnd(builder):
+    return builder.EndObject()
+
+def End(builder):
+    return MathAlgorithmEnd(builder)
+
+import AlgorithmTrigger
+try:
+    from typing import List
+except:
+    pass
+
+class MathAlgorithmT(object):
+
+    # MathAlgorithmT
+    def __init__(self):
+        self.NAME = None  # type: str
+        self.SHORT_DESCRIPTION = None  # type: str
+        self.MATH_OPERATION = None  # type: str
+        self.OUTPUT_PARAMETER_REF = None  # type: str
+        self.TRIGGERS = None  # type: List[AlgorithmTrigger.AlgorithmTriggerT]
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        mathAlgorithm = MathAlgorithm()
+        mathAlgorithm.Init(buf, pos)
+        return cls.InitFromObj(mathAlgorithm)
+
+    @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, mathAlgorithm):
+        x = MathAlgorithmT()
+        x._UnPack(mathAlgorithm)
+        return x
+
+    # MathAlgorithmT
+    def _UnPack(self, mathAlgorithm):
+        if mathAlgorithm is None:
+            return
+        self.NAME = mathAlgorithm.NAME()
+        self.SHORT_DESCRIPTION = mathAlgorithm.SHORT_DESCRIPTION()
+        self.MATH_OPERATION = mathAlgorithm.MATH_OPERATION()
+        self.OUTPUT_PARAMETER_REF = mathAlgorithm.OUTPUT_PARAMETER_REF()
+        if not mathAlgorithm.TRIGGERSIsNone():
+            self.TRIGGERS = []
+            for i in range(mathAlgorithm.TRIGGERSLength()):
+                if mathAlgorithm.TRIGGERS(i) is None:
+                    self.TRIGGERS.append(None)
+                else:
+                    algorithmTrigger_ = AlgorithmTrigger.AlgorithmTriggerT.InitFromObj(mathAlgorithm.TRIGGERS(i))
+                    self.TRIGGERS.append(algorithmTrigger_)
+
+    # MathAlgorithmT
+    def Pack(self, builder):
+        if self.NAME is not None:
+            NAME = builder.CreateString(self.NAME)
+        if self.SHORT_DESCRIPTION is not None:
+            SHORT_DESCRIPTION = builder.CreateString(self.SHORT_DESCRIPTION)
+        if self.MATH_OPERATION is not None:
+            MATH_OPERATION = builder.CreateString(self.MATH_OPERATION)
+        if self.OUTPUT_PARAMETER_REF is not None:
+            OUTPUT_PARAMETER_REF = builder.CreateString(self.OUTPUT_PARAMETER_REF)
+        if self.TRIGGERS is not None:
+            TRIGGERSlist = []
+            for i in range(len(self.TRIGGERS)):
+                TRIGGERSlist.append(self.TRIGGERS[i].Pack(builder))
+            MathAlgorithmStartTRIGGERSVector(builder, len(self.TRIGGERS))
+            for i in reversed(range(len(self.TRIGGERS))):
+                builder.PrependUOffsetTRelative(TRIGGERSlist[i])
+            TRIGGERS = builder.EndVector()
+        MathAlgorithmStart(builder)
+        if self.NAME is not None:
+            MathAlgorithmAddNAME(builder, NAME)
+        if self.SHORT_DESCRIPTION is not None:
+            MathAlgorithmAddSHORT_DESCRIPTION(builder, SHORT_DESCRIPTION)
+        if self.MATH_OPERATION is not None:
+            MathAlgorithmAddMATH_OPERATION(builder, MATH_OPERATION)
+        if self.OUTPUT_PARAMETER_REF is not None:
+            MathAlgorithmAddOUTPUT_PARAMETER_REF(builder, OUTPUT_PARAMETER_REF)
+        if self.TRIGGERS is not None:
+            MathAlgorithmAddTRIGGERS(builder, TRIGGERS)
+        mathAlgorithm = MathAlgorithmEnd(builder)
+        return mathAlgorithm