rknncli 0.2.0__py3-none-any.whl

rknncli/schema/rknn/Node.py

@@ -0,0 +1,380 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: rknn
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class Node(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = Node()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsNode(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    @classmethod
+    def NodeBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x52\x4B\x4E\x4E", size_prefixed=size_prefixed)
+
+    # Node
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Node
+    def Var1(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
+
+    # Node
+    def Type(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
+
+    # Node
+    def Name(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
+
+    # Node
+    def Var2(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos)
+        return 0
+
+    # Node
+    def Inputs(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Int32Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4))
+        return 0
+
+    # Node
+    def InputsAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int32Flags, o)
+        return 0
+
+    # Node
+    def InputsLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # Node
+    def InputsIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        return o == 0
+
+    # Node
+    def Outputs(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Int32Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4))
+        return 0
+
+    # Node
+    def OutputsAsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int32Flags, o)
+        return 0
+
+    # Node
+    def OutputsLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # Node
+    def OutputsIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        return o == 0
+
+    # Node
+    def Var3(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 rknncli.schema.rknn.Type3 import Type3
+            obj = Type3()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # Node
+    def Var3Length(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # Node
+    def Var3IsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
+        return o == 0
+
+    # Node
+    def Var4(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos)
+        return 0
+
+    # Node
+    def Var5(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
+        return 0
+
+    # Node
+    def Var6(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
+        return 0
+
+def NodeStart(builder):
+    builder.StartObject(10)
+
+def Start(builder):
+    NodeStart(builder)
+
+def NodeAddVar1(builder, var1):
+    builder.PrependInt32Slot(0, var1, 0)
+
+def AddVar1(builder, var1):
+    NodeAddVar1(builder, var1)
+
+def NodeAddType(builder, type):
+    builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(type), 0)
+
+def AddType(builder, type):
+    NodeAddType(builder, type)
+
+def NodeAddName(builder, name):
+    builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0)
+
+def AddName(builder, name):
+    NodeAddName(builder, name)
+
+def NodeAddVar2(builder, var2):
+    builder.PrependInt8Slot(3, var2, 0)
+
+def AddVar2(builder, var2):
+    NodeAddVar2(builder, var2)
+
+def NodeAddInputs(builder, inputs):
+    builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(inputs), 0)
+
+def AddInputs(builder, inputs):
+    NodeAddInputs(builder, inputs)
+
+def NodeStartInputsVector(builder, numElems):
+    return builder.StartVector(4, numElems, 4)
+
+def StartInputsVector(builder, numElems):
+    return NodeStartInputsVector(builder, numElems)
+
+def NodeAddOutputs(builder, outputs):
+    builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(outputs), 0)
+
+def AddOutputs(builder, outputs):
+    NodeAddOutputs(builder, outputs)
+
+def NodeStartOutputsVector(builder, numElems):
+    return builder.StartVector(4, numElems, 4)
+
+def StartOutputsVector(builder, numElems):
+    return NodeStartOutputsVector(builder, numElems)
+
+def NodeAddVar3(builder, var3):
+    builder.PrependUOffsetTRelativeSlot(6, flatbuffers.number_types.UOffsetTFlags.py_type(var3), 0)
+
+def AddVar3(builder, var3):
+    NodeAddVar3(builder, var3)
+
+def NodeStartVar3Vector(builder, numElems):
+    return builder.StartVector(4, numElems, 4)
+
+def StartVar3Vector(builder, numElems):
+    return NodeStartVar3Vector(builder, numElems)
+
+def NodeAddVar4(builder, var4):
+    builder.PrependInt8Slot(7, var4, 0)
+
+def AddVar4(builder, var4):
+    NodeAddVar4(builder, var4)
+
+def NodeAddVar5(builder, var5):
+    builder.PrependInt32Slot(8, var5, 0)
+
+def AddVar5(builder, var5):
+    NodeAddVar5(builder, var5)
+
+def NodeAddVar6(builder, var6):
+    builder.PrependInt32Slot(9, var6, 0)
+
+def AddVar6(builder, var6):
+    NodeAddVar6(builder, var6)
+
+def NodeEnd(builder):
+    return builder.EndObject()
+
+def End(builder):
+    return NodeEnd(builder)
+
+import rknncli.schema.rknn.Type3
+try:
+    from typing import List
+except:
+    pass
+
+class NodeT(object):
+
+    # NodeT
+    def __init__(
+        self,
+        var1 = 0,
+        type = None,
+        name = None,
+        var2 = 0,
+        inputs = None,
+        outputs = None,
+        var3 = None,
+        var4 = 0,
+        var5 = 0,
+        var6 = 0,
+    ):
+        self.var1 = var1  # type: int
+        self.type = type  # type: Optional[str]
+        self.name = name  # type: Optional[str]
+        self.var2 = var2  # type: int
+        self.inputs = inputs  # type: Optional[List[int]]
+        self.outputs = outputs  # type: Optional[List[int]]
+        self.var3 = var3  # type: Optional[List[rknn.Type3.Type3T]]
+        self.var4 = var4  # type: int
+        self.var5 = var5  # type: int
+        self.var6 = var6  # type: int
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        node = Node()
+        node.Init(buf, pos)
+        return cls.InitFromObj(node)
+
+    @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, node):
+        x = NodeT()
+        x._UnPack(node)
+        return x
+
+    # NodeT
+    def _UnPack(self, node):
+        if node is None:
+            return
+        self.var1 = node.Var1()
+        self.type = node.Type()
+        self.name = node.Name()
+        self.var2 = node.Var2()
+        if not node.InputsIsNone():
+            if np is None:
+                self.inputs = []
+                for i in range(node.InputsLength()):
+                    self.inputs.append(node.Inputs(i))
+            else:
+                self.inputs = node.InputsAsNumpy()
+        if not node.OutputsIsNone():
+            if np is None:
+                self.outputs = []
+                for i in range(node.OutputsLength()):
+                    self.outputs.append(node.Outputs(i))
+            else:
+                self.outputs = node.OutputsAsNumpy()
+        if not node.Var3IsNone():
+            self.var3 = []
+            for i in range(node.Var3Length()):
+                if node.Var3(i) is None:
+                    self.var3.append(None)
+                else:
+                    type3_ = rknn.Type3.Type3T.InitFromObj(node.Var3(i))
+                    self.var3.append(type3_)
+        self.var4 = node.Var4()
+        self.var5 = node.Var5()
+        self.var6 = node.Var6()
+
+    # NodeT
+    def Pack(self, builder):
+        if self.type is not None:
+            type = builder.CreateString(self.type)
+        if self.name is not None:
+            name = builder.CreateString(self.name)
+        if self.inputs is not None:
+            if np is not None and type(self.inputs) is np.ndarray:
+                inputs = builder.CreateNumpyVector(self.inputs)
+            else:
+                NodeStartInputsVector(builder, len(self.inputs))
+                for i in reversed(range(len(self.inputs))):
+                    builder.PrependInt32(self.inputs[i])
+                inputs = builder.EndVector()
+        if self.outputs is not None:
+            if np is not None and type(self.outputs) is np.ndarray:
+                outputs = builder.CreateNumpyVector(self.outputs)
+            else:
+                NodeStartOutputsVector(builder, len(self.outputs))
+                for i in reversed(range(len(self.outputs))):
+                    builder.PrependInt32(self.outputs[i])
+                outputs = builder.EndVector()
+        if self.var3 is not None:
+            var3list = []
+            for i in range(len(self.var3)):
+                var3list.append(self.var3[i].Pack(builder))
+            NodeStartVar3Vector(builder, len(self.var3))
+            for i in reversed(range(len(self.var3))):
+                builder.PrependUOffsetTRelative(var3list[i])
+            var3 = builder.EndVector()
+        NodeStart(builder)
+        NodeAddVar1(builder, self.var1)
+        if self.type is not None:
+            NodeAddType(builder, type)
+        if self.name is not None:
+            NodeAddName(builder, name)
+        NodeAddVar2(builder, self.var2)
+        if self.inputs is not None:
+            NodeAddInputs(builder, inputs)
+        if self.outputs is not None:
+            NodeAddOutputs(builder, outputs)
+        if self.var3 is not None:
+            NodeAddVar3(builder, var3)
+        NodeAddVar4(builder, self.var4)
+        NodeAddVar5(builder, self.var5)
+        NodeAddVar6(builder, self.var6)
+        node = NodeEnd(builder)
+        return node