spacedatastandards.org 1.73.0__py3-none-any.whl

XTC/CommandContainer.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()
+
+# Command container definition
+class CommandContainer(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = CommandContainer()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsCommandContainer(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    @classmethod
+    def CommandContainerBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x24\x58\x54\x43", size_prefixed=size_prefixed)
+
+    # CommandContainer
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Container name
+    # CommandContainer
+    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
+
+    # Entry list
+    # CommandContainer
+    def ENTRY_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 CommandContainerEntry import CommandContainerEntry
+            obj = CommandContainerEntry()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # CommandContainer
+    def ENTRY_LISTLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # CommandContainer
+    def ENTRY_LISTIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        return o == 0
+
+    # Base container reference
+    # CommandContainer
+    def BASE_CONTAINER(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            x = self._tab.Indirect(o + self._tab.Pos)
+            from BaseContainer import BaseContainer
+            obj = BaseContainer()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+def CommandContainerStart(builder):
+    builder.StartObject(3)
+
+def Start(builder):
+    CommandContainerStart(builder)
+
+def CommandContainerAddNAME(builder, NAME):
+    builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(NAME), 0)
+
+def AddNAME(builder, NAME):
+    CommandContainerAddNAME(builder, NAME)
+
+def CommandContainerAddENTRY_LIST(builder, ENTRY_LIST):
+    builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(ENTRY_LIST), 0)
+
+def AddENTRY_LIST(builder, ENTRY_LIST):
+    CommandContainerAddENTRY_LIST(builder, ENTRY_LIST)
+
+def CommandContainerStartENTRY_LISTVector(builder, numElems):
+    return builder.StartVector(4, numElems, 4)
+
+def StartENTRY_LISTVector(builder, numElems):
+    return CommandContainerStartENTRY_LISTVector(builder, numElems)
+
+def CommandContainerAddBASE_CONTAINER(builder, BASE_CONTAINER):
+    builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(BASE_CONTAINER), 0)
+
+def AddBASE_CONTAINER(builder, BASE_CONTAINER):
+    CommandContainerAddBASE_CONTAINER(builder, BASE_CONTAINER)
+
+def CommandContainerEnd(builder):
+    return builder.EndObject()
+
+def End(builder):
+    return CommandContainerEnd(builder)
+
+import BaseContainer
+import CommandContainerEntry
+try:
+    from typing import List, Optional
+except:
+    pass
+
+class CommandContainerT(object):
+
+    # CommandContainerT
+    def __init__(self):
+        self.NAME = None  # type: str
+        self.ENTRY_LIST = None  # type: List[CommandContainerEntry.CommandContainerEntryT]
+        self.BASE_CONTAINER = None  # type: Optional[BaseContainer.BaseContainerT]
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        commandContainer = CommandContainer()
+        commandContainer.Init(buf, pos)
+        return cls.InitFromObj(commandContainer)
+
+    @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, commandContainer):
+        x = CommandContainerT()
+        x._UnPack(commandContainer)
+        return x
+
+    # CommandContainerT
+    def _UnPack(self, commandContainer):
+        if commandContainer is None:
+            return
+        self.NAME = commandContainer.NAME()
+        if not commandContainer.ENTRY_LISTIsNone():
+            self.ENTRY_LIST = []
+            for i in range(commandContainer.ENTRY_LISTLength()):
+                if commandContainer.ENTRY_LIST(i) is None:
+                    self.ENTRY_LIST.append(None)
+                else:
+                    commandContainerEntry_ = CommandContainerEntry.CommandContainerEntryT.InitFromObj(commandContainer.ENTRY_LIST(i))
+                    self.ENTRY_LIST.append(commandContainerEntry_)
+        if commandContainer.BASE_CONTAINER() is not None:
+            self.BASE_CONTAINER = BaseContainer.BaseContainerT.InitFromObj(commandContainer.BASE_CONTAINER())
+
+    # CommandContainerT
+    def Pack(self, builder):
+        if self.NAME is not None:
+            NAME = builder.CreateString(self.NAME)
+        if self.ENTRY_LIST is not None:
+            ENTRY_LISTlist = []
+            for i in range(len(self.ENTRY_LIST)):
+                ENTRY_LISTlist.append(self.ENTRY_LIST[i].Pack(builder))
+            CommandContainerStartENTRY_LISTVector(builder, len(self.ENTRY_LIST))
+            for i in reversed(range(len(self.ENTRY_LIST))):
+                builder.PrependUOffsetTRelative(ENTRY_LISTlist[i])
+            ENTRY_LIST = builder.EndVector()
+        if self.BASE_CONTAINER is not None:
+            BASE_CONTAINER = self.BASE_CONTAINER.Pack(builder)
+        CommandContainerStart(builder)
+        if self.NAME is not None:
+            CommandContainerAddNAME(builder, NAME)
+        if self.ENTRY_LIST is not None:
+            CommandContainerAddENTRY_LIST(builder, ENTRY_LIST)
+        if self.BASE_CONTAINER is not None:
+            CommandContainerAddBASE_CONTAINER(builder, BASE_CONTAINER)
+        commandContainer = CommandContainerEnd(builder)
+        return commandContainer

XTC/CommandContainerEntry.py

@@ -0,0 +1,158 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: 
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+# Command container entry
+class CommandContainerEntry(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = CommandContainerEntry()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsCommandContainerEntry(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    @classmethod
+    def CommandContainerEntryBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x24\x58\x54\x43", size_prefixed=size_prefixed)
+
+    # CommandContainerEntry
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Argument reference entry
+    # CommandContainerEntry
+    def ARGUMENT_REF_ENTRY(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            x = self._tab.Indirect(o + self._tab.Pos)
+            from ArgumentRefEntry import ArgumentRefEntry
+            obj = ArgumentRefEntry()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # Parameter reference entry
+    # CommandContainerEntry
+    def PARAMETER_REF_ENTRY(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            x = self._tab.Indirect(o + self._tab.Pos)
+            from ParameterRefEntry import ParameterRefEntry
+            obj = ParameterRefEntry()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # Fixed value entry
+    # CommandContainerEntry
+    def FIXED_VALUE_ENTRY(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            x = self._tab.Indirect(o + self._tab.Pos)
+            from FixedValueEntry import FixedValueEntry
+            obj = FixedValueEntry()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+def CommandContainerEntryStart(builder):
+    builder.StartObject(3)
+
+def Start(builder):
+    CommandContainerEntryStart(builder)
+
+def CommandContainerEntryAddARGUMENT_REF_ENTRY(builder, ARGUMENT_REF_ENTRY):
+    builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(ARGUMENT_REF_ENTRY), 0)
+
+def AddARGUMENT_REF_ENTRY(builder, ARGUMENT_REF_ENTRY):
+    CommandContainerEntryAddARGUMENT_REF_ENTRY(builder, ARGUMENT_REF_ENTRY)
+
+def CommandContainerEntryAddPARAMETER_REF_ENTRY(builder, PARAMETER_REF_ENTRY):
+    builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(PARAMETER_REF_ENTRY), 0)
+
+def AddPARAMETER_REF_ENTRY(builder, PARAMETER_REF_ENTRY):
+    CommandContainerEntryAddPARAMETER_REF_ENTRY(builder, PARAMETER_REF_ENTRY)
+
+def CommandContainerEntryAddFIXED_VALUE_ENTRY(builder, FIXED_VALUE_ENTRY):
+    builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(FIXED_VALUE_ENTRY), 0)
+
+def AddFIXED_VALUE_ENTRY(builder, FIXED_VALUE_ENTRY):
+    CommandContainerEntryAddFIXED_VALUE_ENTRY(builder, FIXED_VALUE_ENTRY)
+
+def CommandContainerEntryEnd(builder):
+    return builder.EndObject()
+
+def End(builder):
+    return CommandContainerEntryEnd(builder)
+
+import ArgumentRefEntry
+import FixedValueEntry
+import ParameterRefEntry
+try:
+    from typing import Optional
+except:
+    pass
+
+class CommandContainerEntryT(object):
+
+    # CommandContainerEntryT
+    def __init__(self):
+        self.ARGUMENT_REF_ENTRY = None  # type: Optional[ArgumentRefEntry.ArgumentRefEntryT]
+        self.PARAMETER_REF_ENTRY = None  # type: Optional[ParameterRefEntry.ParameterRefEntryT]
+        self.FIXED_VALUE_ENTRY = None  # type: Optional[FixedValueEntry.FixedValueEntryT]
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        commandContainerEntry = CommandContainerEntry()
+        commandContainerEntry.Init(buf, pos)
+        return cls.InitFromObj(commandContainerEntry)
+
+    @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, commandContainerEntry):
+        x = CommandContainerEntryT()
+        x._UnPack(commandContainerEntry)
+        return x
+
+    # CommandContainerEntryT
+    def _UnPack(self, commandContainerEntry):
+        if commandContainerEntry is None:
+            return
+        if commandContainerEntry.ARGUMENT_REF_ENTRY() is not None:
+            self.ARGUMENT_REF_ENTRY = ArgumentRefEntry.ArgumentRefEntryT.InitFromObj(commandContainerEntry.ARGUMENT_REF_ENTRY())
+        if commandContainerEntry.PARAMETER_REF_ENTRY() is not None:
+            self.PARAMETER_REF_ENTRY = ParameterRefEntry.ParameterRefEntryT.InitFromObj(commandContainerEntry.PARAMETER_REF_ENTRY())
+        if commandContainerEntry.FIXED_VALUE_ENTRY() is not None:
+            self.FIXED_VALUE_ENTRY = FixedValueEntry.FixedValueEntryT.InitFromObj(commandContainerEntry.FIXED_VALUE_ENTRY())
+
+    # CommandContainerEntryT
+    def Pack(self, builder):
+        if self.ARGUMENT_REF_ENTRY is not None:
+            ARGUMENT_REF_ENTRY = self.ARGUMENT_REF_ENTRY.Pack(builder)
+        if self.PARAMETER_REF_ENTRY is not None:
+            PARAMETER_REF_ENTRY = self.PARAMETER_REF_ENTRY.Pack(builder)
+        if self.FIXED_VALUE_ENTRY is not None:
+            FIXED_VALUE_ENTRY = self.FIXED_VALUE_ENTRY.Pack(builder)
+        CommandContainerEntryStart(builder)
+        if self.ARGUMENT_REF_ENTRY is not None:
+            CommandContainerEntryAddARGUMENT_REF_ENTRY(builder, ARGUMENT_REF_ENTRY)
+        if self.PARAMETER_REF_ENTRY is not None:
+            CommandContainerEntryAddPARAMETER_REF_ENTRY(builder, PARAMETER_REF_ENTRY)
+        if self.FIXED_VALUE_ENTRY is not None:
+            CommandContainerEntryAddFIXED_VALUE_ENTRY(builder, FIXED_VALUE_ENTRY)
+        commandContainerEntry = CommandContainerEntryEnd(builder)
+        return commandContainerEntry

XTC/CommandMetaData.py

@@ -0,0 +1,262 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: 
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+# Command metadata collection
+class CommandMetaData(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = CommandMetaData()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsCommandMetaData(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    @classmethod
+    def CommandMetaDataBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x24\x58\x54\x43", size_prefixed=size_prefixed)
+
+    # CommandMetaData
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Argument type definitions
+    # CommandMetaData
+    def ARGUMENT_TYPE_SET(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            x = self._tab.Indirect(o + self._tab.Pos)
+            from ArgumentTypeSet import ArgumentTypeSet
+            obj = ArgumentTypeSet()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # Parameter types used by commands
+    # CommandMetaData
+    def PARAMETER_TYPE_SET(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            x = self._tab.Indirect(o + self._tab.Pos)
+            from ParameterTypeSet import ParameterTypeSet
+            obj = ParameterTypeSet()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # Parameters used by commands
+    # CommandMetaData
+    def PARAMETER_SET(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            x = self._tab.Indirect(o + self._tab.Pos)
+            from ParameterSet import ParameterSet
+            obj = ParameterSet()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # MetaCommand definitions
+    # CommandMetaData
+    def META_COMMAND_SET(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            x = self._tab.Indirect(o + self._tab.Pos)
+            from MetaCommandSet import MetaCommandSet
+            obj = MetaCommandSet()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # Command container set
+    # CommandMetaData
+    def COMMAND_CONTAINER_SET(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            x = self._tab.Indirect(o + self._tab.Pos)
+            from ContainerSet import ContainerSet
+            obj = ContainerSet()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # Algorithm definitions
+    # CommandMetaData
+    def ALGORITHM_SET(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        if o != 0:
+            x = self._tab.Indirect(o + self._tab.Pos)
+            from AlgorithmSet import AlgorithmSet
+            obj = AlgorithmSet()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # Stream definitions
+    # CommandMetaData
+    def STREAM_SET(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
+        if o != 0:
+            x = self._tab.Indirect(o + self._tab.Pos)
+            from StreamSet import StreamSet
+            obj = StreamSet()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+def CommandMetaDataStart(builder):
+    builder.StartObject(7)
+
+def Start(builder):
+    CommandMetaDataStart(builder)
+
+def CommandMetaDataAddARGUMENT_TYPE_SET(builder, ARGUMENT_TYPE_SET):
+    builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(ARGUMENT_TYPE_SET), 0)
+
+def AddARGUMENT_TYPE_SET(builder, ARGUMENT_TYPE_SET):
+    CommandMetaDataAddARGUMENT_TYPE_SET(builder, ARGUMENT_TYPE_SET)
+
+def CommandMetaDataAddPARAMETER_TYPE_SET(builder, PARAMETER_TYPE_SET):
+    builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(PARAMETER_TYPE_SET), 0)
+
+def AddPARAMETER_TYPE_SET(builder, PARAMETER_TYPE_SET):
+    CommandMetaDataAddPARAMETER_TYPE_SET(builder, PARAMETER_TYPE_SET)
+
+def CommandMetaDataAddPARAMETER_SET(builder, PARAMETER_SET):
+    builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(PARAMETER_SET), 0)
+
+def AddPARAMETER_SET(builder, PARAMETER_SET):
+    CommandMetaDataAddPARAMETER_SET(builder, PARAMETER_SET)
+
+def CommandMetaDataAddMETA_COMMAND_SET(builder, META_COMMAND_SET):
+    builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(META_COMMAND_SET), 0)
+
+def AddMETA_COMMAND_SET(builder, META_COMMAND_SET):
+    CommandMetaDataAddMETA_COMMAND_SET(builder, META_COMMAND_SET)
+
+def CommandMetaDataAddCOMMAND_CONTAINER_SET(builder, COMMAND_CONTAINER_SET):
+    builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(COMMAND_CONTAINER_SET), 0)
+
+def AddCOMMAND_CONTAINER_SET(builder, COMMAND_CONTAINER_SET):
+    CommandMetaDataAddCOMMAND_CONTAINER_SET(builder, COMMAND_CONTAINER_SET)
+
+def CommandMetaDataAddALGORITHM_SET(builder, ALGORITHM_SET):
+    builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(ALGORITHM_SET), 0)
+
+def AddALGORITHM_SET(builder, ALGORITHM_SET):
+    CommandMetaDataAddALGORITHM_SET(builder, ALGORITHM_SET)
+
+def CommandMetaDataAddSTREAM_SET(builder, STREAM_SET):
+    builder.PrependUOffsetTRelativeSlot(6, flatbuffers.number_types.UOffsetTFlags.py_type(STREAM_SET), 0)
+
+def AddSTREAM_SET(builder, STREAM_SET):
+    CommandMetaDataAddSTREAM_SET(builder, STREAM_SET)
+
+def CommandMetaDataEnd(builder):
+    return builder.EndObject()
+
+def End(builder):
+    return CommandMetaDataEnd(builder)
+
+import AlgorithmSet
+import ArgumentTypeSet
+import ContainerSet
+import MetaCommandSet
+import ParameterSet
+import ParameterTypeSet
+import StreamSet
+try:
+    from typing import Optional
+except:
+    pass
+
+class CommandMetaDataT(object):
+
+    # CommandMetaDataT
+    def __init__(self):
+        self.ARGUMENT_TYPE_SET = None  # type: Optional[ArgumentTypeSet.ArgumentTypeSetT]
+        self.PARAMETER_TYPE_SET = None  # type: Optional[ParameterTypeSet.ParameterTypeSetT]
+        self.PARAMETER_SET = None  # type: Optional[ParameterSet.ParameterSetT]
+        self.META_COMMAND_SET = None  # type: Optional[MetaCommandSet.MetaCommandSetT]
+        self.COMMAND_CONTAINER_SET = None  # type: Optional[ContainerSet.ContainerSetT]
+        self.ALGORITHM_SET = None  # type: Optional[AlgorithmSet.AlgorithmSetT]
+        self.STREAM_SET = None  # type: Optional[StreamSet.StreamSetT]
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        commandMetaData = CommandMetaData()
+        commandMetaData.Init(buf, pos)
+        return cls.InitFromObj(commandMetaData)
+
+    @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, commandMetaData):
+        x = CommandMetaDataT()
+        x._UnPack(commandMetaData)
+        return x
+
+    # CommandMetaDataT
+    def _UnPack(self, commandMetaData):
+        if commandMetaData is None:
+            return
+        if commandMetaData.ARGUMENT_TYPE_SET() is not None:
+            self.ARGUMENT_TYPE_SET = ArgumentTypeSet.ArgumentTypeSetT.InitFromObj(commandMetaData.ARGUMENT_TYPE_SET())
+        if commandMetaData.PARAMETER_TYPE_SET() is not None:
+            self.PARAMETER_TYPE_SET = ParameterTypeSet.ParameterTypeSetT.InitFromObj(commandMetaData.PARAMETER_TYPE_SET())
+        if commandMetaData.PARAMETER_SET() is not None:
+            self.PARAMETER_SET = ParameterSet.ParameterSetT.InitFromObj(commandMetaData.PARAMETER_SET())
+        if commandMetaData.META_COMMAND_SET() is not None:
+            self.META_COMMAND_SET = MetaCommandSet.MetaCommandSetT.InitFromObj(commandMetaData.META_COMMAND_SET())
+        if commandMetaData.COMMAND_CONTAINER_SET() is not None:
+            self.COMMAND_CONTAINER_SET = ContainerSet.ContainerSetT.InitFromObj(commandMetaData.COMMAND_CONTAINER_SET())
+        if commandMetaData.ALGORITHM_SET() is not None:
+            self.ALGORITHM_SET = AlgorithmSet.AlgorithmSetT.InitFromObj(commandMetaData.ALGORITHM_SET())
+        if commandMetaData.STREAM_SET() is not None:
+            self.STREAM_SET = StreamSet.StreamSetT.InitFromObj(commandMetaData.STREAM_SET())
+
+    # CommandMetaDataT
+    def Pack(self, builder):
+        if self.ARGUMENT_TYPE_SET is not None:
+            ARGUMENT_TYPE_SET = self.ARGUMENT_TYPE_SET.Pack(builder)
+        if self.PARAMETER_TYPE_SET is not None:
+            PARAMETER_TYPE_SET = self.PARAMETER_TYPE_SET.Pack(builder)
+        if self.PARAMETER_SET is not None:
+            PARAMETER_SET = self.PARAMETER_SET.Pack(builder)
+        if self.META_COMMAND_SET is not None:
+            META_COMMAND_SET = self.META_COMMAND_SET.Pack(builder)
+        if self.COMMAND_CONTAINER_SET is not None:
+            COMMAND_CONTAINER_SET = self.COMMAND_CONTAINER_SET.Pack(builder)
+        if self.ALGORITHM_SET is not None:
+            ALGORITHM_SET = self.ALGORITHM_SET.Pack(builder)
+        if self.STREAM_SET is not None:
+            STREAM_SET = self.STREAM_SET.Pack(builder)
+        CommandMetaDataStart(builder)
+        if self.ARGUMENT_TYPE_SET is not None:
+            CommandMetaDataAddARGUMENT_TYPE_SET(builder, ARGUMENT_TYPE_SET)
+        if self.PARAMETER_TYPE_SET is not None:
+            CommandMetaDataAddPARAMETER_TYPE_SET(builder, PARAMETER_TYPE_SET)
+        if self.PARAMETER_SET is not None:
+            CommandMetaDataAddPARAMETER_SET(builder, PARAMETER_SET)
+        if self.META_COMMAND_SET is not None:
+            CommandMetaDataAddMETA_COMMAND_SET(builder, META_COMMAND_SET)
+        if self.COMMAND_CONTAINER_SET is not None:
+            CommandMetaDataAddCOMMAND_CONTAINER_SET(builder, COMMAND_CONTAINER_SET)
+        if self.ALGORITHM_SET is not None:
+            CommandMetaDataAddALGORITHM_SET(builder, ALGORITHM_SET)
+        if self.STREAM_SET is not None:
+            CommandMetaDataAddSTREAM_SET(builder, STREAM_SET)
+        commandMetaData = CommandMetaDataEnd(builder)
+        return commandMetaData