rknncli 0.2.0__py3-none-any.whl

rknncli/schema/rknn/Tensor.py

@@ -0,0 +1,697 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: rknn
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+np = import_numpy()
+
+class Tensor(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = Tensor()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsTensor(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    @classmethod
+    def TensorBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x52\x4B\x4E\x4E", size_prefixed=size_prefixed)
+
+    # Tensor
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # Tensor
+    def DataType(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos)
+        return 0
+
+    # Tensor
+    def Var02(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos)
+        return 0
+
+    # Tensor
+    def Kind(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos)
+        return 0
+
+    # Tensor
+    def Var04(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        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
+
+    # Tensor
+    def Var04AsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int32Flags, o)
+        return 0
+
+    # Tensor
+    def Var04Length(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # Tensor
+    def Var04IsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        return o == 0
+
+    # Tensor
+    def Shape(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
+
+    # Tensor
+    def ShapeAsNumpy(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
+
+    # Tensor
+    def ShapeLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # Tensor
+    def ShapeIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+        return o == 0
+
+    # Tensor
+    def Name(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Tensor
+    def Var06(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Int8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
+        return 0
+
+    # Tensor
+    def Var06AsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int8Flags, o)
+        return 0
+
+    # Tensor
+    def Var06Length(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # Tensor
+    def Var06IsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
+        return o == 0
+
+    # Tensor
+    def Var07(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
+        if o != 0:
+            return self._tab.String(o + self._tab.Pos)
+        return None
+
+    # Tensor
+    def Var08(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Int8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
+        return 0
+
+    # Tensor
+    def Var08AsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int8Flags, o)
+        return 0
+
+    # Tensor
+    def Var08Length(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # Tensor
+    def Var08IsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
+        return o == 0
+
+    # Tensor
+    def Var09(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Int8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
+        return 0
+
+    # Tensor
+    def Var09AsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int8Flags, o)
+        return 0
+
+    # Tensor
+    def Var09Length(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # Tensor
+    def Var09IsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
+        return o == 0
+
+    # Tensor
+    def Var10(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Int8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
+        return 0
+
+    # Tensor
+    def Var10AsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int8Flags, o)
+        return 0
+
+    # Tensor
+    def Var10Length(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # Tensor
+    def Var10IsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
+        return o == 0
+
+    # Tensor
+    def Var11(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
+        if o != 0:
+            a = self._tab.Vector(o)
+            return self._tab.Get(flatbuffers.number_types.Int8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
+        return 0
+
+    # Tensor
+    def Var11AsNumpy(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
+        if o != 0:
+            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int8Flags, o)
+        return 0
+
+    # Tensor
+    def Var11Length(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # Tensor
+    def Var11IsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
+        return o == 0
+
+    # Tensor
+    def Size(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(28))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
+        return 0
+
+    # Tensor
+    def Var13(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
+        return 0
+
+    # Tensor
+    def Var14(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(32))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
+        return 0
+
+    # Tensor
+    def Var15(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(34))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
+        return 0
+
+    # Tensor
+    def Var16(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(36))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
+        return 0
+
+    # Tensor
+    def Var17(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(38))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
+        return 0
+
+    # Tensor
+    def Index(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(40))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
+        return 0
+
+def TensorStart(builder):
+    builder.StartObject(19)
+
+def Start(builder):
+    TensorStart(builder)
+
+def TensorAddDataType(builder, dataType):
+    builder.PrependInt8Slot(0, dataType, 0)
+
+def AddDataType(builder, dataType):
+    TensorAddDataType(builder, dataType)
+
+def TensorAddVar02(builder, var02):
+    builder.PrependInt8Slot(1, var02, 0)
+
+def AddVar02(builder, var02):
+    TensorAddVar02(builder, var02)
+
+def TensorAddKind(builder, kind):
+    builder.PrependInt8Slot(2, kind, 0)
+
+def AddKind(builder, kind):
+    TensorAddKind(builder, kind)
+
+def TensorAddVar04(builder, var04):
+    builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(var04), 0)
+
+def AddVar04(builder, var04):
+    TensorAddVar04(builder, var04)
+
+def TensorStartVar04Vector(builder, numElems):
+    return builder.StartVector(4, numElems, 4)
+
+def StartVar04Vector(builder, numElems):
+    return TensorStartVar04Vector(builder, numElems)
+
+def TensorAddShape(builder, shape):
+    builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(shape), 0)
+
+def AddShape(builder, shape):
+    TensorAddShape(builder, shape)
+
+def TensorStartShapeVector(builder, numElems):
+    return builder.StartVector(4, numElems, 4)
+
+def StartShapeVector(builder, numElems):
+    return TensorStartShapeVector(builder, numElems)
+
+def TensorAddName(builder, name):
+    builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0)
+
+def AddName(builder, name):
+    TensorAddName(builder, name)
+
+def TensorAddVar06(builder, var06):
+    builder.PrependUOffsetTRelativeSlot(6, flatbuffers.number_types.UOffsetTFlags.py_type(var06), 0)
+
+def AddVar06(builder, var06):
+    TensorAddVar06(builder, var06)
+
+def TensorStartVar06Vector(builder, numElems):
+    return builder.StartVector(1, numElems, 1)
+
+def StartVar06Vector(builder, numElems):
+    return TensorStartVar06Vector(builder, numElems)
+
+def TensorAddVar07(builder, var07):
+    builder.PrependUOffsetTRelativeSlot(7, flatbuffers.number_types.UOffsetTFlags.py_type(var07), 0)
+
+def AddVar07(builder, var07):
+    TensorAddVar07(builder, var07)
+
+def TensorAddVar08(builder, var08):
+    builder.PrependUOffsetTRelativeSlot(8, flatbuffers.number_types.UOffsetTFlags.py_type(var08), 0)
+
+def AddVar08(builder, var08):
+    TensorAddVar08(builder, var08)
+
+def TensorStartVar08Vector(builder, numElems):
+    return builder.StartVector(1, numElems, 1)
+
+def StartVar08Vector(builder, numElems):
+    return TensorStartVar08Vector(builder, numElems)
+
+def TensorAddVar09(builder, var09):
+    builder.PrependUOffsetTRelativeSlot(9, flatbuffers.number_types.UOffsetTFlags.py_type(var09), 0)
+
+def AddVar09(builder, var09):
+    TensorAddVar09(builder, var09)
+
+def TensorStartVar09Vector(builder, numElems):
+    return builder.StartVector(1, numElems, 1)
+
+def StartVar09Vector(builder, numElems):
+    return TensorStartVar09Vector(builder, numElems)
+
+def TensorAddVar10(builder, var10):
+    builder.PrependUOffsetTRelativeSlot(10, flatbuffers.number_types.UOffsetTFlags.py_type(var10), 0)
+
+def AddVar10(builder, var10):
+    TensorAddVar10(builder, var10)
+
+def TensorStartVar10Vector(builder, numElems):
+    return builder.StartVector(1, numElems, 1)
+
+def StartVar10Vector(builder, numElems):
+    return TensorStartVar10Vector(builder, numElems)
+
+def TensorAddVar11(builder, var11):
+    builder.PrependUOffsetTRelativeSlot(11, flatbuffers.number_types.UOffsetTFlags.py_type(var11), 0)
+
+def AddVar11(builder, var11):
+    TensorAddVar11(builder, var11)
+
+def TensorStartVar11Vector(builder, numElems):
+    return builder.StartVector(1, numElems, 1)
+
+def StartVar11Vector(builder, numElems):
+    return TensorStartVar11Vector(builder, numElems)
+
+def TensorAddSize(builder, size):
+    builder.PrependInt32Slot(12, size, 0)
+
+def AddSize(builder, size):
+    TensorAddSize(builder, size)
+
+def TensorAddVar13(builder, var13):
+    builder.PrependInt32Slot(13, var13, 0)
+
+def AddVar13(builder, var13):
+    TensorAddVar13(builder, var13)
+
+def TensorAddVar14(builder, var14):
+    builder.PrependInt32Slot(14, var14, 0)
+
+def AddVar14(builder, var14):
+    TensorAddVar14(builder, var14)
+
+def TensorAddVar15(builder, var15):
+    builder.PrependInt32Slot(15, var15, 0)
+
+def AddVar15(builder, var15):
+    TensorAddVar15(builder, var15)
+
+def TensorAddVar16(builder, var16):
+    builder.PrependInt32Slot(16, var16, 0)
+
+def AddVar16(builder, var16):
+    TensorAddVar16(builder, var16)
+
+def TensorAddVar17(builder, var17):
+    builder.PrependInt32Slot(17, var17, 0)
+
+def AddVar17(builder, var17):
+    TensorAddVar17(builder, var17)
+
+def TensorAddIndex(builder, index):
+    builder.PrependInt32Slot(18, index, 0)
+
+def AddIndex(builder, index):
+    TensorAddIndex(builder, index)
+
+def TensorEnd(builder):
+    return builder.EndObject()
+
+def End(builder):
+    return TensorEnd(builder)
+
+try:
+    from typing import List
+except:
+    pass
+
+class TensorT(object):
+
+    # TensorT
+    def __init__(
+        self,
+        dataType = 0,
+        var02 = 0,
+        kind = 0,
+        var04 = None,
+        shape = None,
+        name = None,
+        var06 = None,
+        var07 = None,
+        var08 = None,
+        var09 = None,
+        var10 = None,
+        var11 = None,
+        size = 0,
+        var13 = 0,
+        var14 = 0,
+        var15 = 0,
+        var16 = 0,
+        var17 = 0,
+        index = 0,
+    ):
+        self.dataType = dataType  # type: int
+        self.var02 = var02  # type: int
+        self.kind = kind  # type: int
+        self.var04 = var04  # type: Optional[List[int]]
+        self.shape = shape  # type: Optional[List[int]]
+        self.name = name  # type: Optional[str]
+        self.var06 = var06  # type: Optional[List[int]]
+        self.var07 = var07  # type: Optional[str]
+        self.var08 = var08  # type: Optional[List[int]]
+        self.var09 = var09  # type: Optional[List[int]]
+        self.var10 = var10  # type: Optional[List[int]]
+        self.var11 = var11  # type: Optional[List[int]]
+        self.size = size  # type: int
+        self.var13 = var13  # type: int
+        self.var14 = var14  # type: int
+        self.var15 = var15  # type: int
+        self.var16 = var16  # type: int
+        self.var17 = var17  # type: int
+        self.index = index  # type: int
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        tensor = Tensor()
+        tensor.Init(buf, pos)
+        return cls.InitFromObj(tensor)
+
+    @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, tensor):
+        x = TensorT()
+        x._UnPack(tensor)
+        return x
+
+    # TensorT
+    def _UnPack(self, tensor):
+        if tensor is None:
+            return
+        self.dataType = tensor.DataType()
+        self.var02 = tensor.Var02()
+        self.kind = tensor.Kind()
+        if not tensor.Var04IsNone():
+            if np is None:
+                self.var04 = []
+                for i in range(tensor.Var04Length()):
+                    self.var04.append(tensor.Var04(i))
+            else:
+                self.var04 = tensor.Var04AsNumpy()
+        if not tensor.ShapeIsNone():
+            if np is None:
+                self.shape = []
+                for i in range(tensor.ShapeLength()):
+                    self.shape.append(tensor.Shape(i))
+            else:
+                self.shape = tensor.ShapeAsNumpy()
+        self.name = tensor.Name()
+        if not tensor.Var06IsNone():
+            if np is None:
+                self.var06 = []
+                for i in range(tensor.Var06Length()):
+                    self.var06.append(tensor.Var06(i))
+            else:
+                self.var06 = tensor.Var06AsNumpy()
+        self.var07 = tensor.Var07()
+        if not tensor.Var08IsNone():
+            if np is None:
+                self.var08 = []
+                for i in range(tensor.Var08Length()):
+                    self.var08.append(tensor.Var08(i))
+            else:
+                self.var08 = tensor.Var08AsNumpy()
+        if not tensor.Var09IsNone():
+            if np is None:
+                self.var09 = []
+                for i in range(tensor.Var09Length()):
+                    self.var09.append(tensor.Var09(i))
+            else:
+                self.var09 = tensor.Var09AsNumpy()
+        if not tensor.Var10IsNone():
+            if np is None:
+                self.var10 = []
+                for i in range(tensor.Var10Length()):
+                    self.var10.append(tensor.Var10(i))
+            else:
+                self.var10 = tensor.Var10AsNumpy()
+        if not tensor.Var11IsNone():
+            if np is None:
+                self.var11 = []
+                for i in range(tensor.Var11Length()):
+                    self.var11.append(tensor.Var11(i))
+            else:
+                self.var11 = tensor.Var11AsNumpy()
+        self.size = tensor.Size()
+        self.var13 = tensor.Var13()
+        self.var14 = tensor.Var14()
+        self.var15 = tensor.Var15()
+        self.var16 = tensor.Var16()
+        self.var17 = tensor.Var17()
+        self.index = tensor.Index()
+
+    # TensorT
+    def Pack(self, builder):
+        if self.var04 is not None:
+            if np is not None and type(self.var04) is np.ndarray:
+                var04 = builder.CreateNumpyVector(self.var04)
+            else:
+                TensorStartVar04Vector(builder, len(self.var04))
+                for i in reversed(range(len(self.var04))):
+                    builder.PrependInt32(self.var04[i])
+                var04 = builder.EndVector()
+        if self.shape is not None:
+            if np is not None and type(self.shape) is np.ndarray:
+                shape = builder.CreateNumpyVector(self.shape)
+            else:
+                TensorStartShapeVector(builder, len(self.shape))
+                for i in reversed(range(len(self.shape))):
+                    builder.PrependInt32(self.shape[i])
+                shape = builder.EndVector()
+        if self.name is not None:
+            name = builder.CreateString(self.name)
+        if self.var06 is not None:
+            if np is not None and type(self.var06) is np.ndarray:
+                var06 = builder.CreateNumpyVector(self.var06)
+            else:
+                TensorStartVar06Vector(builder, len(self.var06))
+                for i in reversed(range(len(self.var06))):
+                    builder.PrependByte(self.var06[i])
+                var06 = builder.EndVector()
+        if self.var07 is not None:
+            var07 = builder.CreateString(self.var07)
+        if self.var08 is not None:
+            if np is not None and type(self.var08) is np.ndarray:
+                var08 = builder.CreateNumpyVector(self.var08)
+            else:
+                TensorStartVar08Vector(builder, len(self.var08))
+                for i in reversed(range(len(self.var08))):
+                    builder.PrependByte(self.var08[i])
+                var08 = builder.EndVector()
+        if self.var09 is not None:
+            if np is not None and type(self.var09) is np.ndarray:
+                var09 = builder.CreateNumpyVector(self.var09)
+            else:
+                TensorStartVar09Vector(builder, len(self.var09))
+                for i in reversed(range(len(self.var09))):
+                    builder.PrependByte(self.var09[i])
+                var09 = builder.EndVector()
+        if self.var10 is not None:
+            if np is not None and type(self.var10) is np.ndarray:
+                var10 = builder.CreateNumpyVector(self.var10)
+            else:
+                TensorStartVar10Vector(builder, len(self.var10))
+                for i in reversed(range(len(self.var10))):
+                    builder.PrependByte(self.var10[i])
+                var10 = builder.EndVector()
+        if self.var11 is not None:
+            if np is not None and type(self.var11) is np.ndarray:
+                var11 = builder.CreateNumpyVector(self.var11)
+            else:
+                TensorStartVar11Vector(builder, len(self.var11))
+                for i in reversed(range(len(self.var11))):
+                    builder.PrependByte(self.var11[i])
+                var11 = builder.EndVector()
+        TensorStart(builder)
+        TensorAddDataType(builder, self.dataType)
+        TensorAddVar02(builder, self.var02)
+        TensorAddKind(builder, self.kind)
+        if self.var04 is not None:
+            TensorAddVar04(builder, var04)
+        if self.shape is not None:
+            TensorAddShape(builder, shape)
+        if self.name is not None:
+            TensorAddName(builder, name)
+        if self.var06 is not None:
+            TensorAddVar06(builder, var06)
+        if self.var07 is not None:
+            TensorAddVar07(builder, var07)
+        if self.var08 is not None:
+            TensorAddVar08(builder, var08)
+        if self.var09 is not None:
+            TensorAddVar09(builder, var09)
+        if self.var10 is not None:
+            TensorAddVar10(builder, var10)
+        if self.var11 is not None:
+            TensorAddVar11(builder, var11)
+        TensorAddSize(builder, self.size)
+        TensorAddVar13(builder, self.var13)
+        TensorAddVar14(builder, self.var14)
+        TensorAddVar15(builder, self.var15)
+        TensorAddVar16(builder, self.var16)
+        TensorAddVar17(builder, self.var17)
+        TensorAddIndex(builder, self.index)
+        tensor = TensorEnd(builder)
+        return tensor