spacedatastandards.org 1.73.0__py3-none-any.whl

XTC/AlgorithmSet.py

@@ -0,0 +1,196 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: 
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+# Collection of algorithms
+class AlgorithmSet(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = AlgorithmSet()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsAlgorithmSet(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    @classmethod
+    def AlgorithmSetBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x24\x58\x54\x43", size_prefixed=size_prefixed)
+
+    # AlgorithmSet
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Custom algorithms
+    # AlgorithmSet
+    def CUSTOM_ALGORITHMS(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 CustomAlgorithm import CustomAlgorithm
+            obj = CustomAlgorithm()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # AlgorithmSet
+    def CUSTOM_ALGORITHMSLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # AlgorithmSet
+    def CUSTOM_ALGORITHMSIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        return o == 0
+
+    # Math algorithms
+    # AlgorithmSet
+    def MATH_ALGORITHMS(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 MathAlgorithm import MathAlgorithm
+            obj = MathAlgorithm()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # AlgorithmSet
+    def MATH_ALGORITHMSLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # AlgorithmSet
+    def MATH_ALGORITHMSIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        return o == 0
+
+def AlgorithmSetStart(builder):
+    builder.StartObject(2)
+
+def Start(builder):
+    AlgorithmSetStart(builder)
+
+def AlgorithmSetAddCUSTOM_ALGORITHMS(builder, CUSTOM_ALGORITHMS):
+    builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(CUSTOM_ALGORITHMS), 0)
+
+def AddCUSTOM_ALGORITHMS(builder, CUSTOM_ALGORITHMS):
+    AlgorithmSetAddCUSTOM_ALGORITHMS(builder, CUSTOM_ALGORITHMS)
+
+def AlgorithmSetStartCUSTOM_ALGORITHMSVector(builder, numElems):
+    return builder.StartVector(4, numElems, 4)
+
+def StartCUSTOM_ALGORITHMSVector(builder, numElems):
+    return AlgorithmSetStartCUSTOM_ALGORITHMSVector(builder, numElems)
+
+def AlgorithmSetAddMATH_ALGORITHMS(builder, MATH_ALGORITHMS):
+    builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(MATH_ALGORITHMS), 0)
+
+def AddMATH_ALGORITHMS(builder, MATH_ALGORITHMS):
+    AlgorithmSetAddMATH_ALGORITHMS(builder, MATH_ALGORITHMS)
+
+def AlgorithmSetStartMATH_ALGORITHMSVector(builder, numElems):
+    return builder.StartVector(4, numElems, 4)
+
+def StartMATH_ALGORITHMSVector(builder, numElems):
+    return AlgorithmSetStartMATH_ALGORITHMSVector(builder, numElems)
+
+def AlgorithmSetEnd(builder):
+    return builder.EndObject()
+
+def End(builder):
+    return AlgorithmSetEnd(builder)
+
+import CustomAlgorithm
+import MathAlgorithm
+try:
+    from typing import List
+except:
+    pass
+
+class AlgorithmSetT(object):
+
+    # AlgorithmSetT
+    def __init__(self):
+        self.CUSTOM_ALGORITHMS = None  # type: List[CustomAlgorithm.CustomAlgorithmT]
+        self.MATH_ALGORITHMS = None  # type: List[MathAlgorithm.MathAlgorithmT]
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        algorithmSet = AlgorithmSet()
+        algorithmSet.Init(buf, pos)
+        return cls.InitFromObj(algorithmSet)
+
+    @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, algorithmSet):
+        x = AlgorithmSetT()
+        x._UnPack(algorithmSet)
+        return x
+
+    # AlgorithmSetT
+    def _UnPack(self, algorithmSet):
+        if algorithmSet is None:
+            return
+        if not algorithmSet.CUSTOM_ALGORITHMSIsNone():
+            self.CUSTOM_ALGORITHMS = []
+            for i in range(algorithmSet.CUSTOM_ALGORITHMSLength()):
+                if algorithmSet.CUSTOM_ALGORITHMS(i) is None:
+                    self.CUSTOM_ALGORITHMS.append(None)
+                else:
+                    customAlgorithm_ = CustomAlgorithm.CustomAlgorithmT.InitFromObj(algorithmSet.CUSTOM_ALGORITHMS(i))
+                    self.CUSTOM_ALGORITHMS.append(customAlgorithm_)
+        if not algorithmSet.MATH_ALGORITHMSIsNone():
+            self.MATH_ALGORITHMS = []
+            for i in range(algorithmSet.MATH_ALGORITHMSLength()):
+                if algorithmSet.MATH_ALGORITHMS(i) is None:
+                    self.MATH_ALGORITHMS.append(None)
+                else:
+                    mathAlgorithm_ = MathAlgorithm.MathAlgorithmT.InitFromObj(algorithmSet.MATH_ALGORITHMS(i))
+                    self.MATH_ALGORITHMS.append(mathAlgorithm_)
+
+    # AlgorithmSetT
+    def Pack(self, builder):
+        if self.CUSTOM_ALGORITHMS is not None:
+            CUSTOM_ALGORITHMSlist = []
+            for i in range(len(self.CUSTOM_ALGORITHMS)):
+                CUSTOM_ALGORITHMSlist.append(self.CUSTOM_ALGORITHMS[i].Pack(builder))
+            AlgorithmSetStartCUSTOM_ALGORITHMSVector(builder, len(self.CUSTOM_ALGORITHMS))
+            for i in reversed(range(len(self.CUSTOM_ALGORITHMS))):
+                builder.PrependUOffsetTRelative(CUSTOM_ALGORITHMSlist[i])
+            CUSTOM_ALGORITHMS = builder.EndVector()
+        if self.MATH_ALGORITHMS is not None:
+            MATH_ALGORITHMSlist = []
+            for i in range(len(self.MATH_ALGORITHMS)):
+                MATH_ALGORITHMSlist.append(self.MATH_ALGORITHMS[i].Pack(builder))
+            AlgorithmSetStartMATH_ALGORITHMSVector(builder, len(self.MATH_ALGORITHMS))
+            for i in reversed(range(len(self.MATH_ALGORITHMS))):
+                builder.PrependUOffsetTRelative(MATH_ALGORITHMSlist[i])
+            MATH_ALGORITHMS = builder.EndVector()
+        AlgorithmSetStart(builder)
+        if self.CUSTOM_ALGORITHMS is not None:
+            AlgorithmSetAddCUSTOM_ALGORITHMS(builder, CUSTOM_ALGORITHMS)
+        if self.MATH_ALGORITHMS is not None:
+            AlgorithmSetAddMATH_ALGORITHMS(builder, MATH_ALGORITHMS)
+        algorithmSet = AlgorithmSetEnd(builder)
+        return algorithmSet

XTC/AlgorithmTrigger.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()
+
+# Trigger condition for algorithm execution
+class AlgorithmTrigger(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = AlgorithmTrigger()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsAlgorithmTrigger(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    @classmethod
+    def AlgorithmTriggerBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x24\x58\x54\x43", size_prefixed=size_prefixed)
+
+    # AlgorithmTrigger
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Trigger on parameter update
+    # AlgorithmTrigger
+    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
+
+    # Trigger on container reception
+    # AlgorithmTrigger
+    def CONTAINER_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
+
+    # Trigger rate (per second)
+    # AlgorithmTrigger
+    def RATE(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return 0.0
+
+def AlgorithmTriggerStart(builder):
+    builder.StartObject(3)
+
+def Start(builder):
+    AlgorithmTriggerStart(builder)
+
+def AlgorithmTriggerAddPARAMETER_REF(builder, PARAMETER_REF):
+    builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(PARAMETER_REF), 0)
+
+def AddPARAMETER_REF(builder, PARAMETER_REF):
+    AlgorithmTriggerAddPARAMETER_REF(builder, PARAMETER_REF)
+
+def AlgorithmTriggerAddCONTAINER_REF(builder, CONTAINER_REF):
+    builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(CONTAINER_REF), 0)
+
+def AddCONTAINER_REF(builder, CONTAINER_REF):
+    AlgorithmTriggerAddCONTAINER_REF(builder, CONTAINER_REF)
+
+def AlgorithmTriggerAddRATE(builder, RATE):
+    builder.PrependFloat64Slot(2, RATE, 0.0)
+
+def AddRATE(builder, RATE):
+    AlgorithmTriggerAddRATE(builder, RATE)
+
+def AlgorithmTriggerEnd(builder):
+    return builder.EndObject()
+
+def End(builder):
+    return AlgorithmTriggerEnd(builder)
+
+
+class AlgorithmTriggerT(object):
+
+    # AlgorithmTriggerT
+    def __init__(self):
+        self.PARAMETER_REF = None  # type: str
+        self.CONTAINER_REF = None  # type: str
+        self.RATE = 0.0  # type: float
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        algorithmTrigger = AlgorithmTrigger()
+        algorithmTrigger.Init(buf, pos)
+        return cls.InitFromObj(algorithmTrigger)
+
+    @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, algorithmTrigger):
+        x = AlgorithmTriggerT()
+        x._UnPack(algorithmTrigger)
+        return x
+
+    # AlgorithmTriggerT
+    def _UnPack(self, algorithmTrigger):
+        if algorithmTrigger is None:
+            return
+        self.PARAMETER_REF = algorithmTrigger.PARAMETER_REF()
+        self.CONTAINER_REF = algorithmTrigger.CONTAINER_REF()
+        self.RATE = algorithmTrigger.RATE()
+
+    # AlgorithmTriggerT
+    def Pack(self, builder):
+        if self.PARAMETER_REF is not None:
+            PARAMETER_REF = builder.CreateString(self.PARAMETER_REF)
+        if self.CONTAINER_REF is not None:
+            CONTAINER_REF = builder.CreateString(self.CONTAINER_REF)
+        AlgorithmTriggerStart(builder)
+        if self.PARAMETER_REF is not None:
+            AlgorithmTriggerAddPARAMETER_REF(builder, PARAMETER_REF)
+        if self.CONTAINER_REF is not None:
+            AlgorithmTriggerAddCONTAINER_REF(builder, CONTAINER_REF)
+        AlgorithmTriggerAddRATE(builder, self.RATE)
+        algorithmTrigger = AlgorithmTriggerEnd(builder)
+        return algorithmTrigger

XTC/Argument.py

@@ -0,0 +1,176 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: 
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+# Command argument definition
+class Argument(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = Argument()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsArgument(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    @classmethod
+    def ArgumentBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x24\x58\x54\x43", size_prefixed=size_prefixed)
+
+    # Argument
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Argument name
+    # Argument
+    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 argument type
+    # Argument
+    def ARGUMENT_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
+    # Argument
+    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
+    # Argument
+    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
+
+    # Initial/default value
+    # Argument
+    def INITIAL_VALUE(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+def ArgumentStart(builder):
+    builder.StartObject(5)
+
+def Start(builder):
+    ArgumentStart(builder)
+
+def ArgumentAddNAME(builder, NAME):
+    builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(NAME), 0)
+
+def AddNAME(builder, NAME):
+    ArgumentAddNAME(builder, NAME)
+
+def ArgumentAddARGUMENT_TYPE_REF(builder, ARGUMENT_TYPE_REF):
+    builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(ARGUMENT_TYPE_REF), 0)
+
+def AddARGUMENT_TYPE_REF(builder, ARGUMENT_TYPE_REF):
+    ArgumentAddARGUMENT_TYPE_REF(builder, ARGUMENT_TYPE_REF)
+
+def ArgumentAddSHORT_DESCRIPTION(builder, SHORT_DESCRIPTION):
+    builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(SHORT_DESCRIPTION), 0)
+
+def AddSHORT_DESCRIPTION(builder, SHORT_DESCRIPTION):
+    ArgumentAddSHORT_DESCRIPTION(builder, SHORT_DESCRIPTION)
+
+def ArgumentAddLONG_DESCRIPTION(builder, LONG_DESCRIPTION):
+    builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(LONG_DESCRIPTION), 0)
+
+def AddLONG_DESCRIPTION(builder, LONG_DESCRIPTION):
+    ArgumentAddLONG_DESCRIPTION(builder, LONG_DESCRIPTION)
+
+def ArgumentAddINITIAL_VALUE(builder, INITIAL_VALUE):
+    builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(INITIAL_VALUE), 0)
+
+def AddINITIAL_VALUE(builder, INITIAL_VALUE):
+    ArgumentAddINITIAL_VALUE(builder, INITIAL_VALUE)
+
+def ArgumentEnd(builder):
+    return builder.EndObject()
+
+def End(builder):
+    return ArgumentEnd(builder)
+
+
+class ArgumentT(object):
+
+    # ArgumentT
+    def __init__(self):
+        self.NAME = None  # type: str
+        self.ARGUMENT_TYPE_REF = None  # type: str
+        self.SHORT_DESCRIPTION = None  # type: str
+        self.LONG_DESCRIPTION = None  # type: str
+        self.INITIAL_VALUE = None  # type: str
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        argument = Argument()
+        argument.Init(buf, pos)
+        return cls.InitFromObj(argument)
+
+    @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, argument):
+        x = ArgumentT()
+        x._UnPack(argument)
+        return x
+
+    # ArgumentT
+    def _UnPack(self, argument):
+        if argument is None:
+            return
+        self.NAME = argument.NAME()
+        self.ARGUMENT_TYPE_REF = argument.ARGUMENT_TYPE_REF()
+        self.SHORT_DESCRIPTION = argument.SHORT_DESCRIPTION()
+        self.LONG_DESCRIPTION = argument.LONG_DESCRIPTION()
+        self.INITIAL_VALUE = argument.INITIAL_VALUE()
+
+    # ArgumentT
+    def Pack(self, builder):
+        if self.NAME is not None:
+            NAME = builder.CreateString(self.NAME)
+        if self.ARGUMENT_TYPE_REF is not None:
+            ARGUMENT_TYPE_REF = builder.CreateString(self.ARGUMENT_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.INITIAL_VALUE is not None:
+            INITIAL_VALUE = builder.CreateString(self.INITIAL_VALUE)
+        ArgumentStart(builder)
+        if self.NAME is not None:
+            ArgumentAddNAME(builder, NAME)
+        if self.ARGUMENT_TYPE_REF is not None:
+            ArgumentAddARGUMENT_TYPE_REF(builder, ARGUMENT_TYPE_REF)
+        if self.SHORT_DESCRIPTION is not None:
+            ArgumentAddSHORT_DESCRIPTION(builder, SHORT_DESCRIPTION)
+        if self.LONG_DESCRIPTION is not None:
+            ArgumentAddLONG_DESCRIPTION(builder, LONG_DESCRIPTION)
+        if self.INITIAL_VALUE is not None:
+            ArgumentAddINITIAL_VALUE(builder, INITIAL_VALUE)
+        argument = ArgumentEnd(builder)
+        return argument

XTC/ArgumentAssignment.py

@@ -0,0 +1,116 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: 
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+# Argument assignment (value binding)
+class ArgumentAssignment(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = ArgumentAssignment()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsArgumentAssignment(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    @classmethod
+    def ArgumentAssignmentBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x24\x58\x54\x43", size_prefixed=size_prefixed)
+
+    # ArgumentAssignment
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Argument name
+    # ArgumentAssignment
+    def ARGUMENT_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
+
+    # Assigned value
+    # ArgumentAssignment
+    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
+
+def ArgumentAssignmentStart(builder):
+    builder.StartObject(2)
+
+def Start(builder):
+    ArgumentAssignmentStart(builder)
+
+def ArgumentAssignmentAddARGUMENT_NAME(builder, ARGUMENT_NAME):
+    builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(ARGUMENT_NAME), 0)
+
+def AddARGUMENT_NAME(builder, ARGUMENT_NAME):
+    ArgumentAssignmentAddARGUMENT_NAME(builder, ARGUMENT_NAME)
+
+def ArgumentAssignmentAddVALUE(builder, VALUE):
+    builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(VALUE), 0)
+
+def AddVALUE(builder, VALUE):
+    ArgumentAssignmentAddVALUE(builder, VALUE)
+
+def ArgumentAssignmentEnd(builder):
+    return builder.EndObject()
+
+def End(builder):
+    return ArgumentAssignmentEnd(builder)
+
+
+class ArgumentAssignmentT(object):
+
+    # ArgumentAssignmentT
+    def __init__(self):
+        self.ARGUMENT_NAME = None  # type: str
+        self.VALUE = None  # type: str
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        argumentAssignment = ArgumentAssignment()
+        argumentAssignment.Init(buf, pos)
+        return cls.InitFromObj(argumentAssignment)
+
+    @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, argumentAssignment):
+        x = ArgumentAssignmentT()
+        x._UnPack(argumentAssignment)
+        return x
+
+    # ArgumentAssignmentT
+    def _UnPack(self, argumentAssignment):
+        if argumentAssignment is None:
+            return
+        self.ARGUMENT_NAME = argumentAssignment.ARGUMENT_NAME()
+        self.VALUE = argumentAssignment.VALUE()
+
+    # ArgumentAssignmentT
+    def Pack(self, builder):
+        if self.ARGUMENT_NAME is not None:
+            ARGUMENT_NAME = builder.CreateString(self.ARGUMENT_NAME)
+        if self.VALUE is not None:
+            VALUE = builder.CreateString(self.VALUE)
+        ArgumentAssignmentStart(builder)
+        if self.ARGUMENT_NAME is not None:
+            ArgumentAssignmentAddARGUMENT_NAME(builder, ARGUMENT_NAME)
+        if self.VALUE is not None:
+            ArgumentAssignmentAddVALUE(builder, VALUE)
+        argumentAssignment = ArgumentAssignmentEnd(builder)
+        return argumentAssignment