spacedatastandards.org 1.73.0__py3-none-any.whl

XTC/ArgumentRefEntry.py

@@ -0,0 +1,146 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: 
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+# Argument reference entry in command container
+class ArgumentRefEntry(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = ArgumentRefEntry()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsArgumentRefEntry(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    @classmethod
+    def ArgumentRefEntryBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x24\x58\x54\x43", size_prefixed=size_prefixed)
+
+    # ArgumentRefEntry
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Argument reference
+    # ArgumentRefEntry
+    def ARGUMENT_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
+    # ArgumentRefEntry
+    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
+
+    # Short description
+    # ArgumentRefEntry
+    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
+
+def ArgumentRefEntryStart(builder):
+    builder.StartObject(3)
+
+def Start(builder):
+    ArgumentRefEntryStart(builder)
+
+def ArgumentRefEntryAddARGUMENT_REF(builder, ARGUMENT_REF):
+    builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(ARGUMENT_REF), 0)
+
+def AddARGUMENT_REF(builder, ARGUMENT_REF):
+    ArgumentRefEntryAddARGUMENT_REF(builder, ARGUMENT_REF)
+
+def ArgumentRefEntryAddLOCATION(builder, LOCATION):
+    builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(LOCATION), 0)
+
+def AddLOCATION(builder, LOCATION):
+    ArgumentRefEntryAddLOCATION(builder, LOCATION)
+
+def ArgumentRefEntryAddSHORT_DESCRIPTION(builder, SHORT_DESCRIPTION):
+    builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(SHORT_DESCRIPTION), 0)
+
+def AddSHORT_DESCRIPTION(builder, SHORT_DESCRIPTION):
+    ArgumentRefEntryAddSHORT_DESCRIPTION(builder, SHORT_DESCRIPTION)
+
+def ArgumentRefEntryEnd(builder):
+    return builder.EndObject()
+
+def End(builder):
+    return ArgumentRefEntryEnd(builder)
+
+import LocationInContainer
+try:
+    from typing import Optional
+except:
+    pass
+
+class ArgumentRefEntryT(object):
+
+    # ArgumentRefEntryT
+    def __init__(self):
+        self.ARGUMENT_REF = None  # type: str
+        self.LOCATION = None  # type: Optional[LocationInContainer.LocationInContainerT]
+        self.SHORT_DESCRIPTION = None  # type: str
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        argumentRefEntry = ArgumentRefEntry()
+        argumentRefEntry.Init(buf, pos)
+        return cls.InitFromObj(argumentRefEntry)
+
+    @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, argumentRefEntry):
+        x = ArgumentRefEntryT()
+        x._UnPack(argumentRefEntry)
+        return x
+
+    # ArgumentRefEntryT
+    def _UnPack(self, argumentRefEntry):
+        if argumentRefEntry is None:
+            return
+        self.ARGUMENT_REF = argumentRefEntry.ARGUMENT_REF()
+        if argumentRefEntry.LOCATION() is not None:
+            self.LOCATION = LocationInContainer.LocationInContainerT.InitFromObj(argumentRefEntry.LOCATION())
+        self.SHORT_DESCRIPTION = argumentRefEntry.SHORT_DESCRIPTION()
+
+    # ArgumentRefEntryT
+    def Pack(self, builder):
+        if self.ARGUMENT_REF is not None:
+            ARGUMENT_REF = builder.CreateString(self.ARGUMENT_REF)
+        if self.LOCATION is not None:
+            LOCATION = self.LOCATION.Pack(builder)
+        if self.SHORT_DESCRIPTION is not None:
+            SHORT_DESCRIPTION = builder.CreateString(self.SHORT_DESCRIPTION)
+        ArgumentRefEntryStart(builder)
+        if self.ARGUMENT_REF is not None:
+            ArgumentRefEntryAddARGUMENT_REF(builder, ARGUMENT_REF)
+        if self.LOCATION is not None:
+            ArgumentRefEntryAddLOCATION(builder, LOCATION)
+        if self.SHORT_DESCRIPTION is not None:
+            ArgumentRefEntryAddSHORT_DESCRIPTION(builder, SHORT_DESCRIPTION)
+        argumentRefEntry = ArgumentRefEntryEnd(builder)
+        return argumentRefEntry

XTC/ArgumentTypeSet.py

@@ -0,0 +1,486 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: 
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+# Collection of argument types
+class ArgumentTypeSet(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = ArgumentTypeSet()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsArgumentTypeSet(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    @classmethod
+    def ArgumentTypeSetBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x24\x58\x54\x43", size_prefixed=size_prefixed)
+
+    # ArgumentTypeSet
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Integer argument types
+    # ArgumentTypeSet
+    def INTEGER_TYPES(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 IntegerArgumentType import IntegerArgumentType
+            obj = IntegerArgumentType()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # ArgumentTypeSet
+    def INTEGER_TYPESLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # ArgumentTypeSet
+    def INTEGER_TYPESIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        return o == 0
+
+    # Float argument types
+    # ArgumentTypeSet
+    def FLOAT_TYPES(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 FloatArgumentType import FloatArgumentType
+            obj = FloatArgumentType()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # ArgumentTypeSet
+    def FLOAT_TYPESLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # ArgumentTypeSet
+    def FLOAT_TYPESIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        return o == 0
+
+    # String argument types
+    # ArgumentTypeSet
+    def STRING_TYPES(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            x = self._tab.Vector(o)
+            x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
+            x = self._tab.Indirect(x)
+            from StringArgumentType import StringArgumentType
+            obj = StringArgumentType()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # ArgumentTypeSet
+    def STRING_TYPESLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # ArgumentTypeSet
+    def STRING_TYPESIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        return o == 0
+
+    # Boolean argument types
+    # ArgumentTypeSet
+    def BOOLEAN_TYPES(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            x = self._tab.Vector(o)
+            x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
+            x = self._tab.Indirect(x)
+            from BooleanArgumentType import BooleanArgumentType
+            obj = BooleanArgumentType()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # ArgumentTypeSet
+    def BOOLEAN_TYPESLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # ArgumentTypeSet
+    def BOOLEAN_TYPESIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        return o == 0
+
+    # Enumerated argument types
+    # ArgumentTypeSet
+    def ENUMERATED_TYPES(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 EnumeratedArgumentType import EnumeratedArgumentType
+            obj = EnumeratedArgumentType()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # ArgumentTypeSet
+    def ENUMERATED_TYPESLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # ArgumentTypeSet
+    def ENUMERATED_TYPESIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        return o == 0
+
+    # Binary argument types
+    # ArgumentTypeSet
+    def BINARY_TYPES(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        if o != 0:
+            x = self._tab.Vector(o)
+            x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
+            x = self._tab.Indirect(x)
+            from BinaryArgumentType import BinaryArgumentType
+            obj = BinaryArgumentType()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # ArgumentTypeSet
+    def BINARY_TYPESLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # ArgumentTypeSet
+    def BINARY_TYPESIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        return o == 0
+
+    # Aggregate argument types
+    # ArgumentTypeSet
+    def AGGREGATE_TYPES(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
+        if o != 0:
+            x = self._tab.Vector(o)
+            x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
+            x = self._tab.Indirect(x)
+            from AggregateArgumentType import AggregateArgumentType
+            obj = AggregateArgumentType()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # ArgumentTypeSet
+    def AGGREGATE_TYPESLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # ArgumentTypeSet
+    def AGGREGATE_TYPESIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
+        return o == 0
+
+def ArgumentTypeSetStart(builder):
+    builder.StartObject(7)
+
+def Start(builder):
+    ArgumentTypeSetStart(builder)
+
+def ArgumentTypeSetAddINTEGER_TYPES(builder, INTEGER_TYPES):
+    builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(INTEGER_TYPES), 0)
+
+def AddINTEGER_TYPES(builder, INTEGER_TYPES):
+    ArgumentTypeSetAddINTEGER_TYPES(builder, INTEGER_TYPES)
+
+def ArgumentTypeSetStartINTEGER_TYPESVector(builder, numElems):
+    return builder.StartVector(4, numElems, 4)
+
+def StartINTEGER_TYPESVector(builder, numElems):
+    return ArgumentTypeSetStartINTEGER_TYPESVector(builder, numElems)
+
+def ArgumentTypeSetAddFLOAT_TYPES(builder, FLOAT_TYPES):
+    builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(FLOAT_TYPES), 0)
+
+def AddFLOAT_TYPES(builder, FLOAT_TYPES):
+    ArgumentTypeSetAddFLOAT_TYPES(builder, FLOAT_TYPES)
+
+def ArgumentTypeSetStartFLOAT_TYPESVector(builder, numElems):
+    return builder.StartVector(4, numElems, 4)
+
+def StartFLOAT_TYPESVector(builder, numElems):
+    return ArgumentTypeSetStartFLOAT_TYPESVector(builder, numElems)
+
+def ArgumentTypeSetAddSTRING_TYPES(builder, STRING_TYPES):
+    builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(STRING_TYPES), 0)
+
+def AddSTRING_TYPES(builder, STRING_TYPES):
+    ArgumentTypeSetAddSTRING_TYPES(builder, STRING_TYPES)
+
+def ArgumentTypeSetStartSTRING_TYPESVector(builder, numElems):
+    return builder.StartVector(4, numElems, 4)
+
+def StartSTRING_TYPESVector(builder, numElems):
+    return ArgumentTypeSetStartSTRING_TYPESVector(builder, numElems)
+
+def ArgumentTypeSetAddBOOLEAN_TYPES(builder, BOOLEAN_TYPES):
+    builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(BOOLEAN_TYPES), 0)
+
+def AddBOOLEAN_TYPES(builder, BOOLEAN_TYPES):
+    ArgumentTypeSetAddBOOLEAN_TYPES(builder, BOOLEAN_TYPES)
+
+def ArgumentTypeSetStartBOOLEAN_TYPESVector(builder, numElems):
+    return builder.StartVector(4, numElems, 4)
+
+def StartBOOLEAN_TYPESVector(builder, numElems):
+    return ArgumentTypeSetStartBOOLEAN_TYPESVector(builder, numElems)
+
+def ArgumentTypeSetAddENUMERATED_TYPES(builder, ENUMERATED_TYPES):
+    builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(ENUMERATED_TYPES), 0)
+
+def AddENUMERATED_TYPES(builder, ENUMERATED_TYPES):
+    ArgumentTypeSetAddENUMERATED_TYPES(builder, ENUMERATED_TYPES)
+
+def ArgumentTypeSetStartENUMERATED_TYPESVector(builder, numElems):
+    return builder.StartVector(4, numElems, 4)
+
+def StartENUMERATED_TYPESVector(builder, numElems):
+    return ArgumentTypeSetStartENUMERATED_TYPESVector(builder, numElems)
+
+def ArgumentTypeSetAddBINARY_TYPES(builder, BINARY_TYPES):
+    builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(BINARY_TYPES), 0)
+
+def AddBINARY_TYPES(builder, BINARY_TYPES):
+    ArgumentTypeSetAddBINARY_TYPES(builder, BINARY_TYPES)
+
+def ArgumentTypeSetStartBINARY_TYPESVector(builder, numElems):
+    return builder.StartVector(4, numElems, 4)
+
+def StartBINARY_TYPESVector(builder, numElems):
+    return ArgumentTypeSetStartBINARY_TYPESVector(builder, numElems)
+
+def ArgumentTypeSetAddAGGREGATE_TYPES(builder, AGGREGATE_TYPES):
+    builder.PrependUOffsetTRelativeSlot(6, flatbuffers.number_types.UOffsetTFlags.py_type(AGGREGATE_TYPES), 0)
+
+def AddAGGREGATE_TYPES(builder, AGGREGATE_TYPES):
+    ArgumentTypeSetAddAGGREGATE_TYPES(builder, AGGREGATE_TYPES)
+
+def ArgumentTypeSetStartAGGREGATE_TYPESVector(builder, numElems):
+    return builder.StartVector(4, numElems, 4)
+
+def StartAGGREGATE_TYPESVector(builder, numElems):
+    return ArgumentTypeSetStartAGGREGATE_TYPESVector(builder, numElems)
+
+def ArgumentTypeSetEnd(builder):
+    return builder.EndObject()
+
+def End(builder):
+    return ArgumentTypeSetEnd(builder)
+
+import AggregateArgumentType
+import BinaryArgumentType
+import BooleanArgumentType
+import EnumeratedArgumentType
+import FloatArgumentType
+import IntegerArgumentType
+import StringArgumentType
+try:
+    from typing import List
+except:
+    pass
+
+class ArgumentTypeSetT(object):
+
+    # ArgumentTypeSetT
+    def __init__(self):
+        self.INTEGER_TYPES = None  # type: List[IntegerArgumentType.IntegerArgumentTypeT]
+        self.FLOAT_TYPES = None  # type: List[FloatArgumentType.FloatArgumentTypeT]
+        self.STRING_TYPES = None  # type: List[StringArgumentType.StringArgumentTypeT]
+        self.BOOLEAN_TYPES = None  # type: List[BooleanArgumentType.BooleanArgumentTypeT]
+        self.ENUMERATED_TYPES = None  # type: List[EnumeratedArgumentType.EnumeratedArgumentTypeT]
+        self.BINARY_TYPES = None  # type: List[BinaryArgumentType.BinaryArgumentTypeT]
+        self.AGGREGATE_TYPES = None  # type: List[AggregateArgumentType.AggregateArgumentTypeT]
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        argumentTypeSet = ArgumentTypeSet()
+        argumentTypeSet.Init(buf, pos)
+        return cls.InitFromObj(argumentTypeSet)
+
+    @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, argumentTypeSet):
+        x = ArgumentTypeSetT()
+        x._UnPack(argumentTypeSet)
+        return x
+
+    # ArgumentTypeSetT
+    def _UnPack(self, argumentTypeSet):
+        if argumentTypeSet is None:
+            return
+        if not argumentTypeSet.INTEGER_TYPESIsNone():
+            self.INTEGER_TYPES = []
+            for i in range(argumentTypeSet.INTEGER_TYPESLength()):
+                if argumentTypeSet.INTEGER_TYPES(i) is None:
+                    self.INTEGER_TYPES.append(None)
+                else:
+                    integerArgumentType_ = IntegerArgumentType.IntegerArgumentTypeT.InitFromObj(argumentTypeSet.INTEGER_TYPES(i))
+                    self.INTEGER_TYPES.append(integerArgumentType_)
+        if not argumentTypeSet.FLOAT_TYPESIsNone():
+            self.FLOAT_TYPES = []
+            for i in range(argumentTypeSet.FLOAT_TYPESLength()):
+                if argumentTypeSet.FLOAT_TYPES(i) is None:
+                    self.FLOAT_TYPES.append(None)
+                else:
+                    floatArgumentType_ = FloatArgumentType.FloatArgumentTypeT.InitFromObj(argumentTypeSet.FLOAT_TYPES(i))
+                    self.FLOAT_TYPES.append(floatArgumentType_)
+        if not argumentTypeSet.STRING_TYPESIsNone():
+            self.STRING_TYPES = []
+            for i in range(argumentTypeSet.STRING_TYPESLength()):
+                if argumentTypeSet.STRING_TYPES(i) is None:
+                    self.STRING_TYPES.append(None)
+                else:
+                    stringArgumentType_ = StringArgumentType.StringArgumentTypeT.InitFromObj(argumentTypeSet.STRING_TYPES(i))
+                    self.STRING_TYPES.append(stringArgumentType_)
+        if not argumentTypeSet.BOOLEAN_TYPESIsNone():
+            self.BOOLEAN_TYPES = []
+            for i in range(argumentTypeSet.BOOLEAN_TYPESLength()):
+                if argumentTypeSet.BOOLEAN_TYPES(i) is None:
+                    self.BOOLEAN_TYPES.append(None)
+                else:
+                    booleanArgumentType_ = BooleanArgumentType.BooleanArgumentTypeT.InitFromObj(argumentTypeSet.BOOLEAN_TYPES(i))
+                    self.BOOLEAN_TYPES.append(booleanArgumentType_)
+        if not argumentTypeSet.ENUMERATED_TYPESIsNone():
+            self.ENUMERATED_TYPES = []
+            for i in range(argumentTypeSet.ENUMERATED_TYPESLength()):
+                if argumentTypeSet.ENUMERATED_TYPES(i) is None:
+                    self.ENUMERATED_TYPES.append(None)
+                else:
+                    enumeratedArgumentType_ = EnumeratedArgumentType.EnumeratedArgumentTypeT.InitFromObj(argumentTypeSet.ENUMERATED_TYPES(i))
+                    self.ENUMERATED_TYPES.append(enumeratedArgumentType_)
+        if not argumentTypeSet.BINARY_TYPESIsNone():
+            self.BINARY_TYPES = []
+            for i in range(argumentTypeSet.BINARY_TYPESLength()):
+                if argumentTypeSet.BINARY_TYPES(i) is None:
+                    self.BINARY_TYPES.append(None)
+                else:
+                    binaryArgumentType_ = BinaryArgumentType.BinaryArgumentTypeT.InitFromObj(argumentTypeSet.BINARY_TYPES(i))
+                    self.BINARY_TYPES.append(binaryArgumentType_)
+        if not argumentTypeSet.AGGREGATE_TYPESIsNone():
+            self.AGGREGATE_TYPES = []
+            for i in range(argumentTypeSet.AGGREGATE_TYPESLength()):
+                if argumentTypeSet.AGGREGATE_TYPES(i) is None:
+                    self.AGGREGATE_TYPES.append(None)
+                else:
+                    aggregateArgumentType_ = AggregateArgumentType.AggregateArgumentTypeT.InitFromObj(argumentTypeSet.AGGREGATE_TYPES(i))
+                    self.AGGREGATE_TYPES.append(aggregateArgumentType_)
+
+    # ArgumentTypeSetT
+    def Pack(self, builder):
+        if self.INTEGER_TYPES is not None:
+            INTEGER_TYPESlist = []
+            for i in range(len(self.INTEGER_TYPES)):
+                INTEGER_TYPESlist.append(self.INTEGER_TYPES[i].Pack(builder))
+            ArgumentTypeSetStartINTEGER_TYPESVector(builder, len(self.INTEGER_TYPES))
+            for i in reversed(range(len(self.INTEGER_TYPES))):
+                builder.PrependUOffsetTRelative(INTEGER_TYPESlist[i])
+            INTEGER_TYPES = builder.EndVector()
+        if self.FLOAT_TYPES is not None:
+            FLOAT_TYPESlist = []
+            for i in range(len(self.FLOAT_TYPES)):
+                FLOAT_TYPESlist.append(self.FLOAT_TYPES[i].Pack(builder))
+            ArgumentTypeSetStartFLOAT_TYPESVector(builder, len(self.FLOAT_TYPES))
+            for i in reversed(range(len(self.FLOAT_TYPES))):
+                builder.PrependUOffsetTRelative(FLOAT_TYPESlist[i])
+            FLOAT_TYPES = builder.EndVector()
+        if self.STRING_TYPES is not None:
+            STRING_TYPESlist = []
+            for i in range(len(self.STRING_TYPES)):
+                STRING_TYPESlist.append(self.STRING_TYPES[i].Pack(builder))
+            ArgumentTypeSetStartSTRING_TYPESVector(builder, len(self.STRING_TYPES))
+            for i in reversed(range(len(self.STRING_TYPES))):
+                builder.PrependUOffsetTRelative(STRING_TYPESlist[i])
+            STRING_TYPES = builder.EndVector()
+        if self.BOOLEAN_TYPES is not None:
+            BOOLEAN_TYPESlist = []
+            for i in range(len(self.BOOLEAN_TYPES)):
+                BOOLEAN_TYPESlist.append(self.BOOLEAN_TYPES[i].Pack(builder))
+            ArgumentTypeSetStartBOOLEAN_TYPESVector(builder, len(self.BOOLEAN_TYPES))
+            for i in reversed(range(len(self.BOOLEAN_TYPES))):
+                builder.PrependUOffsetTRelative(BOOLEAN_TYPESlist[i])
+            BOOLEAN_TYPES = builder.EndVector()
+        if self.ENUMERATED_TYPES is not None:
+            ENUMERATED_TYPESlist = []
+            for i in range(len(self.ENUMERATED_TYPES)):
+                ENUMERATED_TYPESlist.append(self.ENUMERATED_TYPES[i].Pack(builder))
+            ArgumentTypeSetStartENUMERATED_TYPESVector(builder, len(self.ENUMERATED_TYPES))
+            for i in reversed(range(len(self.ENUMERATED_TYPES))):
+                builder.PrependUOffsetTRelative(ENUMERATED_TYPESlist[i])
+            ENUMERATED_TYPES = builder.EndVector()
+        if self.BINARY_TYPES is not None:
+            BINARY_TYPESlist = []
+            for i in range(len(self.BINARY_TYPES)):
+                BINARY_TYPESlist.append(self.BINARY_TYPES[i].Pack(builder))
+            ArgumentTypeSetStartBINARY_TYPESVector(builder, len(self.BINARY_TYPES))
+            for i in reversed(range(len(self.BINARY_TYPES))):
+                builder.PrependUOffsetTRelative(BINARY_TYPESlist[i])
+            BINARY_TYPES = builder.EndVector()
+        if self.AGGREGATE_TYPES is not None:
+            AGGREGATE_TYPESlist = []
+            for i in range(len(self.AGGREGATE_TYPES)):
+                AGGREGATE_TYPESlist.append(self.AGGREGATE_TYPES[i].Pack(builder))
+            ArgumentTypeSetStartAGGREGATE_TYPESVector(builder, len(self.AGGREGATE_TYPES))
+            for i in reversed(range(len(self.AGGREGATE_TYPES))):
+                builder.PrependUOffsetTRelative(AGGREGATE_TYPESlist[i])
+            AGGREGATE_TYPES = builder.EndVector()
+        ArgumentTypeSetStart(builder)
+        if self.INTEGER_TYPES is not None:
+            ArgumentTypeSetAddINTEGER_TYPES(builder, INTEGER_TYPES)
+        if self.FLOAT_TYPES is not None:
+            ArgumentTypeSetAddFLOAT_TYPES(builder, FLOAT_TYPES)
+        if self.STRING_TYPES is not None:
+            ArgumentTypeSetAddSTRING_TYPES(builder, STRING_TYPES)
+        if self.BOOLEAN_TYPES is not None:
+            ArgumentTypeSetAddBOOLEAN_TYPES(builder, BOOLEAN_TYPES)
+        if self.ENUMERATED_TYPES is not None:
+            ArgumentTypeSetAddENUMERATED_TYPES(builder, ENUMERATED_TYPES)
+        if self.BINARY_TYPES is not None:
+            ArgumentTypeSetAddBINARY_TYPES(builder, BINARY_TYPES)
+        if self.AGGREGATE_TYPES is not None:
+            ArgumentTypeSetAddAGGREGATE_TYPES(builder, AGGREGATE_TYPES)
+        argumentTypeSet = ArgumentTypeSetEnd(builder)
+        return argumentTypeSet