spacedatastandards.org 1.73.0__py3-none-any.whl

XTC/ArrayDimension.py

@@ -0,0 +1,113 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: 
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+# Array dimension specification
+class ArrayDimension(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = ArrayDimension()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsArrayDimension(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    @classmethod
+    def ArrayDimensionBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x24\x58\x54\x43", size_prefixed=size_prefixed)
+
+    # ArrayDimension
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Fixed size of this dimension
+    # ArrayDimension
+    def SIZE(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
+        return 0
+
+    # Dynamic size from parameter reference
+    # ArrayDimension
+    def SIZE_PARAMETER_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
+
+def ArrayDimensionStart(builder):
+    builder.StartObject(2)
+
+def Start(builder):
+    ArrayDimensionStart(builder)
+
+def ArrayDimensionAddSIZE(builder, SIZE):
+    builder.PrependUint32Slot(0, SIZE, 0)
+
+def AddSIZE(builder, SIZE):
+    ArrayDimensionAddSIZE(builder, SIZE)
+
+def ArrayDimensionAddSIZE_PARAMETER_REF(builder, SIZE_PARAMETER_REF):
+    builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(SIZE_PARAMETER_REF), 0)
+
+def AddSIZE_PARAMETER_REF(builder, SIZE_PARAMETER_REF):
+    ArrayDimensionAddSIZE_PARAMETER_REF(builder, SIZE_PARAMETER_REF)
+
+def ArrayDimensionEnd(builder):
+    return builder.EndObject()
+
+def End(builder):
+    return ArrayDimensionEnd(builder)
+
+
+class ArrayDimensionT(object):
+
+    # ArrayDimensionT
+    def __init__(self):
+        self.SIZE = 0  # type: int
+        self.SIZE_PARAMETER_REF = None  # type: str
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        arrayDimension = ArrayDimension()
+        arrayDimension.Init(buf, pos)
+        return cls.InitFromObj(arrayDimension)
+
+    @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, arrayDimension):
+        x = ArrayDimensionT()
+        x._UnPack(arrayDimension)
+        return x
+
+    # ArrayDimensionT
+    def _UnPack(self, arrayDimension):
+        if arrayDimension is None:
+            return
+        self.SIZE = arrayDimension.SIZE()
+        self.SIZE_PARAMETER_REF = arrayDimension.SIZE_PARAMETER_REF()
+
+    # ArrayDimensionT
+    def Pack(self, builder):
+        if self.SIZE_PARAMETER_REF is not None:
+            SIZE_PARAMETER_REF = builder.CreateString(self.SIZE_PARAMETER_REF)
+        ArrayDimensionStart(builder)
+        ArrayDimensionAddSIZE(builder, self.SIZE)
+        if self.SIZE_PARAMETER_REF is not None:
+            ArrayDimensionAddSIZE_PARAMETER_REF(builder, SIZE_PARAMETER_REF)
+        arrayDimension = ArrayDimensionEnd(builder)
+        return arrayDimension

XTC/ArrayParameterRefEntry.py

@@ -0,0 +1,160 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: 
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+# Array parameter reference entry
+class ArrayParameterRefEntry(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = ArrayParameterRefEntry()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsArrayParameterRefEntry(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    @classmethod
+    def ArrayParameterRefEntryBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x24\x58\x54\x43", size_prefixed=size_prefixed)
+
+    # ArrayParameterRefEntry
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Parameter reference path
+    # ArrayParameterRefEntry
+    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
+
+    # Location in container
+    # ArrayParameterRefEntry
+    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
+
+    # First index to include
+    # ArrayParameterRefEntry
+    def FIRST_INDEX(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
+        return 0
+
+    # Last index to include
+    # ArrayParameterRefEntry
+    def LAST_INDEX(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
+        return 0
+
+def ArrayParameterRefEntryStart(builder):
+    builder.StartObject(4)
+
+def Start(builder):
+    ArrayParameterRefEntryStart(builder)
+
+def ArrayParameterRefEntryAddPARAMETER_REF(builder, PARAMETER_REF):
+    builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(PARAMETER_REF), 0)
+
+def AddPARAMETER_REF(builder, PARAMETER_REF):
+    ArrayParameterRefEntryAddPARAMETER_REF(builder, PARAMETER_REF)
+
+def ArrayParameterRefEntryAddLOCATION(builder, LOCATION):
+    builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(LOCATION), 0)
+
+def AddLOCATION(builder, LOCATION):
+    ArrayParameterRefEntryAddLOCATION(builder, LOCATION)
+
+def ArrayParameterRefEntryAddFIRST_INDEX(builder, FIRST_INDEX):
+    builder.PrependUint32Slot(2, FIRST_INDEX, 0)
+
+def AddFIRST_INDEX(builder, FIRST_INDEX):
+    ArrayParameterRefEntryAddFIRST_INDEX(builder, FIRST_INDEX)
+
+def ArrayParameterRefEntryAddLAST_INDEX(builder, LAST_INDEX):
+    builder.PrependUint32Slot(3, LAST_INDEX, 0)
+
+def AddLAST_INDEX(builder, LAST_INDEX):
+    ArrayParameterRefEntryAddLAST_INDEX(builder, LAST_INDEX)
+
+def ArrayParameterRefEntryEnd(builder):
+    return builder.EndObject()
+
+def End(builder):
+    return ArrayParameterRefEntryEnd(builder)
+
+import LocationInContainer
+try:
+    from typing import Optional
+except:
+    pass
+
+class ArrayParameterRefEntryT(object):
+
+    # ArrayParameterRefEntryT
+    def __init__(self):
+        self.PARAMETER_REF = None  # type: str
+        self.LOCATION = None  # type: Optional[LocationInContainer.LocationInContainerT]
+        self.FIRST_INDEX = 0  # type: int
+        self.LAST_INDEX = 0  # type: int
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        arrayParameterRefEntry = ArrayParameterRefEntry()
+        arrayParameterRefEntry.Init(buf, pos)
+        return cls.InitFromObj(arrayParameterRefEntry)
+
+    @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, arrayParameterRefEntry):
+        x = ArrayParameterRefEntryT()
+        x._UnPack(arrayParameterRefEntry)
+        return x
+
+    # ArrayParameterRefEntryT
+    def _UnPack(self, arrayParameterRefEntry):
+        if arrayParameterRefEntry is None:
+            return
+        self.PARAMETER_REF = arrayParameterRefEntry.PARAMETER_REF()
+        if arrayParameterRefEntry.LOCATION() is not None:
+            self.LOCATION = LocationInContainer.LocationInContainerT.InitFromObj(arrayParameterRefEntry.LOCATION())
+        self.FIRST_INDEX = arrayParameterRefEntry.FIRST_INDEX()
+        self.LAST_INDEX = arrayParameterRefEntry.LAST_INDEX()
+
+    # ArrayParameterRefEntryT
+    def Pack(self, builder):
+        if self.PARAMETER_REF is not None:
+            PARAMETER_REF = builder.CreateString(self.PARAMETER_REF)
+        if self.LOCATION is not None:
+            LOCATION = self.LOCATION.Pack(builder)
+        ArrayParameterRefEntryStart(builder)
+        if self.PARAMETER_REF is not None:
+            ArrayParameterRefEntryAddPARAMETER_REF(builder, PARAMETER_REF)
+        if self.LOCATION is not None:
+            ArrayParameterRefEntryAddLOCATION(builder, LOCATION)
+        ArrayParameterRefEntryAddFIRST_INDEX(builder, self.FIRST_INDEX)
+        ArrayParameterRefEntryAddLAST_INDEX(builder, self.LAST_INDEX)
+        arrayParameterRefEntry = ArrayParameterRefEntryEnd(builder)
+        return arrayParameterRefEntry

XTC/ArrayParameterType.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()
+
+# Array parameter type
+class ArrayParameterType(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = ArrayParameterType()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsArrayParameterType(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    @classmethod
+    def ArrayParameterTypeBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x24\x58\x54\x43", size_prefixed=size_prefixed)
+
+    # ArrayParameterType
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Type name
+    # ArrayParameterType
+    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
+    # ArrayParameterType
+    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
+
+    # Long description
+    # ArrayParameterType
+    def LONG_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
+
+    # Reference to the array element type
+    # ArrayParameterType
+    def ARRAY_TYPE_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
+
+    # Dimension list
+    # ArrayParameterType
+    def DIMENSIONS(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 ArrayDimension import ArrayDimension
+            obj = ArrayDimension()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # ArrayParameterType
+    def DIMENSIONSLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # ArrayParameterType
+    def DIMENSIONSIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        return o == 0
+
+def ArrayParameterTypeStart(builder):
+    builder.StartObject(5)
+
+def Start(builder):
+    ArrayParameterTypeStart(builder)
+
+def ArrayParameterTypeAddNAME(builder, NAME):
+    builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(NAME), 0)
+
+def AddNAME(builder, NAME):
+    ArrayParameterTypeAddNAME(builder, NAME)
+
+def ArrayParameterTypeAddSHORT_DESCRIPTION(builder, SHORT_DESCRIPTION):
+    builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(SHORT_DESCRIPTION), 0)
+
+def AddSHORT_DESCRIPTION(builder, SHORT_DESCRIPTION):
+    ArrayParameterTypeAddSHORT_DESCRIPTION(builder, SHORT_DESCRIPTION)
+
+def ArrayParameterTypeAddLONG_DESCRIPTION(builder, LONG_DESCRIPTION):
+    builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(LONG_DESCRIPTION), 0)
+
+def AddLONG_DESCRIPTION(builder, LONG_DESCRIPTION):
+    ArrayParameterTypeAddLONG_DESCRIPTION(builder, LONG_DESCRIPTION)
+
+def ArrayParameterTypeAddARRAY_TYPE_REF(builder, ARRAY_TYPE_REF):
+    builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(ARRAY_TYPE_REF), 0)
+
+def AddARRAY_TYPE_REF(builder, ARRAY_TYPE_REF):
+    ArrayParameterTypeAddARRAY_TYPE_REF(builder, ARRAY_TYPE_REF)
+
+def ArrayParameterTypeAddDIMENSIONS(builder, DIMENSIONS):
+    builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(DIMENSIONS), 0)
+
+def AddDIMENSIONS(builder, DIMENSIONS):
+    ArrayParameterTypeAddDIMENSIONS(builder, DIMENSIONS)
+
+def ArrayParameterTypeStartDIMENSIONSVector(builder, numElems):
+    return builder.StartVector(4, numElems, 4)
+
+def StartDIMENSIONSVector(builder, numElems):
+    return ArrayParameterTypeStartDIMENSIONSVector(builder, numElems)
+
+def ArrayParameterTypeEnd(builder):
+    return builder.EndObject()
+
+def End(builder):
+    return ArrayParameterTypeEnd(builder)
+
+import ArrayDimension
+try:
+    from typing import List
+except:
+    pass
+
+class ArrayParameterTypeT(object):
+
+    # ArrayParameterTypeT
+    def __init__(self):
+        self.NAME = None  # type: str
+        self.SHORT_DESCRIPTION = None  # type: str
+        self.LONG_DESCRIPTION = None  # type: str
+        self.ARRAY_TYPE_REF = None  # type: str
+        self.DIMENSIONS = None  # type: List[ArrayDimension.ArrayDimensionT]
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        arrayParameterType = ArrayParameterType()
+        arrayParameterType.Init(buf, pos)
+        return cls.InitFromObj(arrayParameterType)
+
+    @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, arrayParameterType):
+        x = ArrayParameterTypeT()
+        x._UnPack(arrayParameterType)
+        return x
+
+    # ArrayParameterTypeT
+    def _UnPack(self, arrayParameterType):
+        if arrayParameterType is None:
+            return
+        self.NAME = arrayParameterType.NAME()
+        self.SHORT_DESCRIPTION = arrayParameterType.SHORT_DESCRIPTION()
+        self.LONG_DESCRIPTION = arrayParameterType.LONG_DESCRIPTION()
+        self.ARRAY_TYPE_REF = arrayParameterType.ARRAY_TYPE_REF()
+        if not arrayParameterType.DIMENSIONSIsNone():
+            self.DIMENSIONS = []
+            for i in range(arrayParameterType.DIMENSIONSLength()):
+                if arrayParameterType.DIMENSIONS(i) is None:
+                    self.DIMENSIONS.append(None)
+                else:
+                    arrayDimension_ = ArrayDimension.ArrayDimensionT.InitFromObj(arrayParameterType.DIMENSIONS(i))
+                    self.DIMENSIONS.append(arrayDimension_)
+
+    # ArrayParameterTypeT
+    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.LONG_DESCRIPTION is not None:
+            LONG_DESCRIPTION = builder.CreateString(self.LONG_DESCRIPTION)
+        if self.ARRAY_TYPE_REF is not None:
+            ARRAY_TYPE_REF = builder.CreateString(self.ARRAY_TYPE_REF)
+        if self.DIMENSIONS is not None:
+            DIMENSIONSlist = []
+            for i in range(len(self.DIMENSIONS)):
+                DIMENSIONSlist.append(self.DIMENSIONS[i].Pack(builder))
+            ArrayParameterTypeStartDIMENSIONSVector(builder, len(self.DIMENSIONS))
+            for i in reversed(range(len(self.DIMENSIONS))):
+                builder.PrependUOffsetTRelative(DIMENSIONSlist[i])
+            DIMENSIONS = builder.EndVector()
+        ArrayParameterTypeStart(builder)
+        if self.NAME is not None:
+            ArrayParameterTypeAddNAME(builder, NAME)
+        if self.SHORT_DESCRIPTION is not None:
+            ArrayParameterTypeAddSHORT_DESCRIPTION(builder, SHORT_DESCRIPTION)
+        if self.LONG_DESCRIPTION is not None:
+            ArrayParameterTypeAddLONG_DESCRIPTION(builder, LONG_DESCRIPTION)
+        if self.ARRAY_TYPE_REF is not None:
+            ArrayParameterTypeAddARRAY_TYPE_REF(builder, ARRAY_TYPE_REF)
+        if self.DIMENSIONS is not None:
+            ArrayParameterTypeAddDIMENSIONS(builder, DIMENSIONS)
+        arrayParameterType = ArrayParameterTypeEnd(builder)
+        return arrayParameterType

XTC/BaseContainer.py

@@ -0,0 +1,126 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: 
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+# Base container reference with restriction
+class BaseContainer(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = BaseContainer()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsBaseContainer(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    @classmethod
+    def BaseContainerBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x24\x58\x54\x43", size_prefixed=size_prefixed)
+
+    # BaseContainer
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Container reference path
+    # BaseContainer
+    def CONTAINER_REF(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Restriction criteria
+    # BaseContainer
+    def RESTRICTION_CRITERIA(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            x = self._tab.Indirect(o + self._tab.Pos)
+            from MatchCriteria import MatchCriteria
+            obj = MatchCriteria()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+def BaseContainerStart(builder):
+    builder.StartObject(2)
+
+def Start(builder):
+    BaseContainerStart(builder)
+
+def BaseContainerAddCONTAINER_REF(builder, CONTAINER_REF):
+    builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(CONTAINER_REF), 0)
+
+def AddCONTAINER_REF(builder, CONTAINER_REF):
+    BaseContainerAddCONTAINER_REF(builder, CONTAINER_REF)
+
+def BaseContainerAddRESTRICTION_CRITERIA(builder, RESTRICTION_CRITERIA):
+    builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(RESTRICTION_CRITERIA), 0)
+
+def AddRESTRICTION_CRITERIA(builder, RESTRICTION_CRITERIA):
+    BaseContainerAddRESTRICTION_CRITERIA(builder, RESTRICTION_CRITERIA)
+
+def BaseContainerEnd(builder):
+    return builder.EndObject()
+
+def End(builder):
+    return BaseContainerEnd(builder)
+
+import MatchCriteria
+try:
+    from typing import Optional
+except:
+    pass
+
+class BaseContainerT(object):
+
+    # BaseContainerT
+    def __init__(self):
+        self.CONTAINER_REF = None  # type: str
+        self.RESTRICTION_CRITERIA = None  # type: Optional[MatchCriteria.MatchCriteriaT]
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        baseContainer = BaseContainer()
+        baseContainer.Init(buf, pos)
+        return cls.InitFromObj(baseContainer)
+
+    @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, baseContainer):
+        x = BaseContainerT()
+        x._UnPack(baseContainer)
+        return x
+
+    # BaseContainerT
+    def _UnPack(self, baseContainer):
+        if baseContainer is None:
+            return
+        self.CONTAINER_REF = baseContainer.CONTAINER_REF()
+        if baseContainer.RESTRICTION_CRITERIA() is not None:
+            self.RESTRICTION_CRITERIA = MatchCriteria.MatchCriteriaT.InitFromObj(baseContainer.RESTRICTION_CRITERIA())
+
+    # BaseContainerT
+    def Pack(self, builder):
+        if self.CONTAINER_REF is not None:
+            CONTAINER_REF = builder.CreateString(self.CONTAINER_REF)
+        if self.RESTRICTION_CRITERIA is not None:
+            RESTRICTION_CRITERIA = self.RESTRICTION_CRITERIA.Pack(builder)
+        BaseContainerStart(builder)
+        if self.CONTAINER_REF is not None:
+            BaseContainerAddCONTAINER_REF(builder, CONTAINER_REF)
+        if self.RESTRICTION_CRITERIA is not None:
+            BaseContainerAddRESTRICTION_CRITERIA(builder, RESTRICTION_CRITERIA)
+        baseContainer = BaseContainerEnd(builder)
+        return baseContainer