mediapipe-nightly 0.10.21.post20250114__cp310-cp310-manylinux_2_28_x86_64.whl

mediapipe/tasks/metadata/object_detector_metadata_schema_py_generated.py

@@ -0,0 +1,674 @@
+import flatbuffers
+
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: tasks
+
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class FixedAnchor(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = FixedAnchor()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsFixedAnchor(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    @classmethod
+    def FixedAnchorBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x56\x30\x30\x31", size_prefixed=size_prefixed)
+
+    # FixedAnchor
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # FixedAnchor
+    def XCenter(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
+        return 0.0
+
+    # FixedAnchor
+    def YCenter(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
+        return 0.0
+
+    # FixedAnchor
+    def Width(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
+        return 0.0
+
+    # FixedAnchor
+    def Height(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
+        return 0.0
+
+def FixedAnchorStart(builder):
+    builder.StartObject(4)
+
+def FixedAnchorAddXCenter(builder, xCenter):
+    builder.PrependFloat32Slot(0, xCenter, 0.0)
+
+def FixedAnchorAddYCenter(builder, yCenter):
+    builder.PrependFloat32Slot(1, yCenter, 0.0)
+
+def FixedAnchorAddWidth(builder, width):
+    builder.PrependFloat32Slot(2, width, 0.0)
+
+def FixedAnchorAddHeight(builder, height):
+    builder.PrependFloat32Slot(3, height, 0.0)
+
+def FixedAnchorEnd(builder):
+    return builder.EndObject()
+
+
+
+class FixedAnchorT(object):
+
+    # FixedAnchorT
+    def __init__(self):
+        self.xCenter = 0.0  # type: float
+        self.yCenter = 0.0  # type: float
+        self.width = 0.0  # type: float
+        self.height = 0.0  # type: float
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        fixedAnchor = FixedAnchor()
+        fixedAnchor.Init(buf, pos)
+        return cls.InitFromObj(fixedAnchor)
+
+    @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, fixedAnchor):
+        x = FixedAnchorT()
+        x._UnPack(fixedAnchor)
+        return x
+
+    # FixedAnchorT
+    def _UnPack(self, fixedAnchor):
+        if fixedAnchor is None:
+            return
+        self.xCenter = fixedAnchor.XCenter()
+        self.yCenter = fixedAnchor.YCenter()
+        self.width = fixedAnchor.Width()
+        self.height = fixedAnchor.Height()
+
+    # FixedAnchorT
+    def Pack(self, builder):
+        FixedAnchorStart(builder)
+        FixedAnchorAddXCenter(builder, self.xCenter)
+        FixedAnchorAddYCenter(builder, self.yCenter)
+        FixedAnchorAddWidth(builder, self.width)
+        FixedAnchorAddHeight(builder, self.height)
+        fixedAnchor = FixedAnchorEnd(builder)
+        return fixedAnchor
+
+
+class FixedAnchorsSchema(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = FixedAnchorsSchema()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsFixedAnchorsSchema(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    @classmethod
+    def FixedAnchorsSchemaBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x56\x30\x30\x31", size_prefixed=size_prefixed)
+
+    # FixedAnchorsSchema
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # FixedAnchorsSchema
+    def Anchors(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)
+            obj = FixedAnchor()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # FixedAnchorsSchema
+    def AnchorsLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # FixedAnchorsSchema
+    def AnchorsIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        return o == 0
+
+def FixedAnchorsSchemaStart(builder):
+    builder.StartObject(1)
+
+def FixedAnchorsSchemaAddAnchors(builder, anchors):
+    builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(anchors), 0)
+
+def FixedAnchorsSchemaStartAnchorsVector(builder, numElems):
+    return builder.StartVector(4, numElems, 4)
+
+def FixedAnchorsSchemaEnd(builder):
+    return builder.EndObject()
+
+
+try:
+    from typing import List
+except:
+    pass
+
+class FixedAnchorsSchemaT(object):
+
+    # FixedAnchorsSchemaT
+    def __init__(self):
+        self.anchors = None  # type: List[FixedAnchorT]
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        fixedAnchorsSchema = FixedAnchorsSchema()
+        fixedAnchorsSchema.Init(buf, pos)
+        return cls.InitFromObj(fixedAnchorsSchema)
+
+    @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, fixedAnchorsSchema):
+        x = FixedAnchorsSchemaT()
+        x._UnPack(fixedAnchorsSchema)
+        return x
+
+    # FixedAnchorsSchemaT
+    def _UnPack(self, fixedAnchorsSchema):
+        if fixedAnchorsSchema is None:
+            return
+        if not fixedAnchorsSchema.AnchorsIsNone():
+            self.anchors = []
+            for i in range(fixedAnchorsSchema.AnchorsLength()):
+                if fixedAnchorsSchema.Anchors(i) is None:
+                    self.anchors.append(None)
+                else:
+                    fixedAnchor_ = FixedAnchorT.InitFromObj(fixedAnchorsSchema.Anchors(i))
+                    self.anchors.append(fixedAnchor_)
+
+    # FixedAnchorsSchemaT
+    def Pack(self, builder):
+        if self.anchors is not None:
+            anchorslist = []
+            for i in range(len(self.anchors)):
+                anchorslist.append(self.anchors[i].Pack(builder))
+            FixedAnchorsSchemaStartAnchorsVector(builder, len(self.anchors))
+            for i in reversed(range(len(self.anchors))):
+                builder.PrependUOffsetTRelative(anchorslist[i])
+            anchors = builder.EndVector()
+        FixedAnchorsSchemaStart(builder)
+        if self.anchors is not None:
+            FixedAnchorsSchemaAddAnchors(builder, anchors)
+        fixedAnchorsSchema = FixedAnchorsSchemaEnd(builder)
+        return fixedAnchorsSchema
+
+
+class SsdAnchorsOptions(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = SsdAnchorsOptions()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsSsdAnchorsOptions(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    @classmethod
+    def SsdAnchorsOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x56\x30\x30\x31", size_prefixed=size_prefixed)
+
+    # SsdAnchorsOptions
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # SsdAnchorsOptions
+    def FixedAnchorsSchema(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            x = self._tab.Indirect(o + self._tab.Pos)
+            obj = FixedAnchorsSchema()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+def SsdAnchorsOptionsStart(builder):
+    builder.StartObject(1)
+
+def SsdAnchorsOptionsAddFixedAnchorsSchema(builder, fixedAnchorsSchema):
+    builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(fixedAnchorsSchema), 0)
+
+def SsdAnchorsOptionsEnd(builder):
+    return builder.EndObject()
+
+
+try:
+    from typing import Optional
+except:
+    pass
+
+class SsdAnchorsOptionsT(object):
+
+    # SsdAnchorsOptionsT
+    def __init__(self):
+        self.fixedAnchorsSchema = None  # type: Optional[FixedAnchorsSchemaT]
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        ssdAnchorsOptions = SsdAnchorsOptions()
+        ssdAnchorsOptions.Init(buf, pos)
+        return cls.InitFromObj(ssdAnchorsOptions)
+
+    @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, ssdAnchorsOptions):
+        x = SsdAnchorsOptionsT()
+        x._UnPack(ssdAnchorsOptions)
+        return x
+
+    # SsdAnchorsOptionsT
+    def _UnPack(self, ssdAnchorsOptions):
+        if ssdAnchorsOptions is None:
+            return
+        if ssdAnchorsOptions.FixedAnchorsSchema() is not None:
+            self.fixedAnchorsSchema = FixedAnchorsSchemaT.InitFromObj(ssdAnchorsOptions.FixedAnchorsSchema())
+
+    # SsdAnchorsOptionsT
+    def Pack(self, builder):
+        if self.fixedAnchorsSchema is not None:
+            fixedAnchorsSchema = self.fixedAnchorsSchema.Pack(builder)
+        SsdAnchorsOptionsStart(builder)
+        if self.fixedAnchorsSchema is not None:
+            SsdAnchorsOptionsAddFixedAnchorsSchema(builder, fixedAnchorsSchema)
+        ssdAnchorsOptions = SsdAnchorsOptionsEnd(builder)
+        return ssdAnchorsOptions
+
+
+class TensorsDecodingOptions(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = TensorsDecodingOptions()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsTensorsDecodingOptions(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    @classmethod
+    def TensorsDecodingOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x56\x30\x30\x31", size_prefixed=size_prefixed)
+
+    # TensorsDecodingOptions
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # TensorsDecodingOptions
+    def NumClasses(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
+        return 0
+
+    # TensorsDecodingOptions
+    def NumBoxes(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
+        return 0
+
+    # TensorsDecodingOptions
+    def NumCoords(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
+        return 0
+
+    # TensorsDecodingOptions
+    def KeypointCoordOffset(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
+        return 0
+
+    # TensorsDecodingOptions
+    def NumKeypoints(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
+        return 0
+
+    # TensorsDecodingOptions
+    def NumValuesPerKeypoint(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
+        return 0
+
+    # TensorsDecodingOptions
+    def XScale(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
+        return 0.0
+
+    # TensorsDecodingOptions
+    def YScale(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
+        return 0.0
+
+    # TensorsDecodingOptions
+    def WScale(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
+        return 0.0
+
+    # TensorsDecodingOptions
+    def HScale(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
+        return 0.0
+
+    # TensorsDecodingOptions
+    def ApplyExponentialOnBoxSize(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+    # TensorsDecodingOptions
+    def SigmoidScore(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
+        if o != 0:
+            return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+        return False
+
+def TensorsDecodingOptionsStart(builder):
+    builder.StartObject(12)
+
+def TensorsDecodingOptionsAddNumClasses(builder, numClasses):
+    builder.PrependInt32Slot(0, numClasses, 0)
+
+def TensorsDecodingOptionsAddNumBoxes(builder, numBoxes):
+    builder.PrependInt32Slot(1, numBoxes, 0)
+
+def TensorsDecodingOptionsAddNumCoords(builder, numCoords):
+    builder.PrependInt32Slot(2, numCoords, 0)
+
+def TensorsDecodingOptionsAddKeypointCoordOffset(builder, keypointCoordOffset):
+    builder.PrependInt32Slot(3, keypointCoordOffset, 0)
+
+def TensorsDecodingOptionsAddNumKeypoints(builder, numKeypoints):
+    builder.PrependInt32Slot(4, numKeypoints, 0)
+
+def TensorsDecodingOptionsAddNumValuesPerKeypoint(builder, numValuesPerKeypoint):
+    builder.PrependInt32Slot(5, numValuesPerKeypoint, 0)
+
+def TensorsDecodingOptionsAddXScale(builder, xScale):
+    builder.PrependFloat32Slot(6, xScale, 0.0)
+
+def TensorsDecodingOptionsAddYScale(builder, yScale):
+    builder.PrependFloat32Slot(7, yScale, 0.0)
+
+def TensorsDecodingOptionsAddWScale(builder, wScale):
+    builder.PrependFloat32Slot(8, wScale, 0.0)
+
+def TensorsDecodingOptionsAddHScale(builder, hScale):
+    builder.PrependFloat32Slot(9, hScale, 0.0)
+
+def TensorsDecodingOptionsAddApplyExponentialOnBoxSize(builder, applyExponentialOnBoxSize):
+    builder.PrependBoolSlot(10, applyExponentialOnBoxSize, 0)
+
+def TensorsDecodingOptionsAddSigmoidScore(builder, sigmoidScore):
+    builder.PrependBoolSlot(11, sigmoidScore, 0)
+
+def TensorsDecodingOptionsEnd(builder):
+    return builder.EndObject()
+
+
+
+class TensorsDecodingOptionsT(object):
+
+    # TensorsDecodingOptionsT
+    def __init__(self):
+        self.numClasses = 0  # type: int
+        self.numBoxes = 0  # type: int
+        self.numCoords = 0  # type: int
+        self.keypointCoordOffset = 0  # type: int
+        self.numKeypoints = 0  # type: int
+        self.numValuesPerKeypoint = 0  # type: int
+        self.xScale = 0.0  # type: float
+        self.yScale = 0.0  # type: float
+        self.wScale = 0.0  # type: float
+        self.hScale = 0.0  # type: float
+        self.applyExponentialOnBoxSize = False  # type: bool
+        self.sigmoidScore = False  # type: bool
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        tensorsDecodingOptions = TensorsDecodingOptions()
+        tensorsDecodingOptions.Init(buf, pos)
+        return cls.InitFromObj(tensorsDecodingOptions)
+
+    @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, tensorsDecodingOptions):
+        x = TensorsDecodingOptionsT()
+        x._UnPack(tensorsDecodingOptions)
+        return x
+
+    # TensorsDecodingOptionsT
+    def _UnPack(self, tensorsDecodingOptions):
+        if tensorsDecodingOptions is None:
+            return
+        self.numClasses = tensorsDecodingOptions.NumClasses()
+        self.numBoxes = tensorsDecodingOptions.NumBoxes()
+        self.numCoords = tensorsDecodingOptions.NumCoords()
+        self.keypointCoordOffset = tensorsDecodingOptions.KeypointCoordOffset()
+        self.numKeypoints = tensorsDecodingOptions.NumKeypoints()
+        self.numValuesPerKeypoint = tensorsDecodingOptions.NumValuesPerKeypoint()
+        self.xScale = tensorsDecodingOptions.XScale()
+        self.yScale = tensorsDecodingOptions.YScale()
+        self.wScale = tensorsDecodingOptions.WScale()
+        self.hScale = tensorsDecodingOptions.HScale()
+        self.applyExponentialOnBoxSize = tensorsDecodingOptions.ApplyExponentialOnBoxSize()
+        self.sigmoidScore = tensorsDecodingOptions.SigmoidScore()
+
+    # TensorsDecodingOptionsT
+    def Pack(self, builder):
+        TensorsDecodingOptionsStart(builder)
+        TensorsDecodingOptionsAddNumClasses(builder, self.numClasses)
+        TensorsDecodingOptionsAddNumBoxes(builder, self.numBoxes)
+        TensorsDecodingOptionsAddNumCoords(builder, self.numCoords)
+        TensorsDecodingOptionsAddKeypointCoordOffset(builder, self.keypointCoordOffset)
+        TensorsDecodingOptionsAddNumKeypoints(builder, self.numKeypoints)
+        TensorsDecodingOptionsAddNumValuesPerKeypoint(builder, self.numValuesPerKeypoint)
+        TensorsDecodingOptionsAddXScale(builder, self.xScale)
+        TensorsDecodingOptionsAddYScale(builder, self.yScale)
+        TensorsDecodingOptionsAddWScale(builder, self.wScale)
+        TensorsDecodingOptionsAddHScale(builder, self.hScale)
+        TensorsDecodingOptionsAddApplyExponentialOnBoxSize(builder, self.applyExponentialOnBoxSize)
+        TensorsDecodingOptionsAddSigmoidScore(builder, self.sigmoidScore)
+        tensorsDecodingOptions = TensorsDecodingOptionsEnd(builder)
+        return tensorsDecodingOptions
+
+
+class ObjectDetectorOptions(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = ObjectDetectorOptions()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsObjectDetectorOptions(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    @classmethod
+    def ObjectDetectorOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x56\x30\x30\x31", size_prefixed=size_prefixed)
+
+    # ObjectDetectorOptions
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # ObjectDetectorOptions
+    def MinParserVersion(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
+
+    # ObjectDetectorOptions
+    def SsdAnchorsOptions(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            x = self._tab.Indirect(o + self._tab.Pos)
+            obj = SsdAnchorsOptions()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # ObjectDetectorOptions
+    def TensorsDecodingOptions(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            x = self._tab.Indirect(o + self._tab.Pos)
+            obj = TensorsDecodingOptions()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+def ObjectDetectorOptionsStart(builder):
+    builder.StartObject(3)
+
+def ObjectDetectorOptionsAddMinParserVersion(builder, minParserVersion):
+    builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(minParserVersion), 0)
+
+def ObjectDetectorOptionsAddSsdAnchorsOptions(builder, ssdAnchorsOptions):
+    builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(ssdAnchorsOptions), 0)
+
+def ObjectDetectorOptionsAddTensorsDecodingOptions(builder, tensorsDecodingOptions):
+    builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(tensorsDecodingOptions), 0)
+
+def ObjectDetectorOptionsEnd(builder):
+    return builder.EndObject()
+
+
+try:
+    from typing import Optional
+except:
+    pass
+
+class ObjectDetectorOptionsT(object):
+
+    # ObjectDetectorOptionsT
+    def __init__(self):
+        self.minParserVersion = None  # type: str
+        self.ssdAnchorsOptions = None  # type: Optional[SsdAnchorsOptionsT]
+        self.tensorsDecodingOptions = None  # type: Optional[TensorsDecodingOptionsT]
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        objectDetectorOptions = ObjectDetectorOptions()
+        objectDetectorOptions.Init(buf, pos)
+        return cls.InitFromObj(objectDetectorOptions)
+
+    @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, objectDetectorOptions):
+        x = ObjectDetectorOptionsT()
+        x._UnPack(objectDetectorOptions)
+        return x
+
+    # ObjectDetectorOptionsT
+    def _UnPack(self, objectDetectorOptions):
+        if objectDetectorOptions is None:
+            return
+        self.minParserVersion = objectDetectorOptions.MinParserVersion()
+        if objectDetectorOptions.SsdAnchorsOptions() is not None:
+            self.ssdAnchorsOptions = SsdAnchorsOptionsT.InitFromObj(objectDetectorOptions.SsdAnchorsOptions())
+        if objectDetectorOptions.TensorsDecodingOptions() is not None:
+            self.tensorsDecodingOptions = TensorsDecodingOptionsT.InitFromObj(objectDetectorOptions.TensorsDecodingOptions())
+
+    # ObjectDetectorOptionsT
+    def Pack(self, builder):
+        if self.minParserVersion is not None:
+            minParserVersion = builder.CreateString(self.minParserVersion)
+        if self.ssdAnchorsOptions is not None:
+            ssdAnchorsOptions = self.ssdAnchorsOptions.Pack(builder)
+        if self.tensorsDecodingOptions is not None:
+            tensorsDecodingOptions = self.tensorsDecodingOptions.Pack(builder)
+        ObjectDetectorOptionsStart(builder)
+        if self.minParserVersion is not None:
+            ObjectDetectorOptionsAddMinParserVersion(builder, minParserVersion)
+        if self.ssdAnchorsOptions is not None:
+            ObjectDetectorOptionsAddSsdAnchorsOptions(builder, ssdAnchorsOptions)
+        if self.tensorsDecodingOptions is not None:
+            ObjectDetectorOptionsAddTensorsDecodingOptions(builder, tensorsDecodingOptions)
+        objectDetectorOptions = ObjectDetectorOptionsEnd(builder)
+        return objectDetectorOptions
+
+