diff options
Diffstat (limited to 'python/tosa')
33 files changed, 1412 insertions, 578 deletions
diff --git a/python/tosa/ArithmeticRightShiftAttribute.py b/python/tosa/ArithmeticRightShiftAttribute.py index 226dc0e..f2aaeb5 100644 --- a/python/tosa/ArithmeticRightShiftAttribute.py +++ b/python/tosa/ArithmeticRightShiftAttribute.py @@ -10,13 +10,17 @@ class ArithmeticRightShiftAttribute(object): __slots__ = ['_tab'] @classmethod - def GetRootAsArithmeticRightShiftAttribute(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = ArithmeticRightShiftAttribute() x.Init(buf, n + offset) return x @classmethod + def GetRootAsArithmeticRightShiftAttribute(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def ArithmeticRightShiftAttributeBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x4F\x53\x41", size_prefixed=size_prefixed) @@ -31,6 +35,20 @@ class ArithmeticRightShiftAttribute(object): return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) return False -def ArithmeticRightShiftAttributeStart(builder): builder.StartObject(1) -def ArithmeticRightShiftAttributeAddRound(builder, round): builder.PrependBoolSlot(0, round, 0) -def ArithmeticRightShiftAttributeEnd(builder): return builder.EndObject() +def ArithmeticRightShiftAttributeStart(builder): + builder.StartObject(1) + +def Start(builder): + ArithmeticRightShiftAttributeStart(builder) + +def ArithmeticRightShiftAttributeAddRound(builder, round): + builder.PrependBoolSlot(0, round, 0) + +def AddRound(builder, round): + ArithmeticRightShiftAttributeAddRound(builder, round) + +def ArithmeticRightShiftAttributeEnd(builder): + return builder.EndObject() + +def End(builder): + return ArithmeticRightShiftAttributeEnd(builder) diff --git a/python/tosa/Attribute.py b/python/tosa/Attribute.py index 166de8e..6abdcfb 100644 --- a/python/tosa/Attribute.py +++ b/python/tosa/Attribute.py @@ -9,19 +9,18 @@ class Attribute(object): TransposeConvAttribute = 3 PadAttribute = 4 AxisAttribute = 5 - ReshapeAttribute = 6 - SliceAttribute = 7 - TileAttribute = 8 - ResizeAttribute = 9 - ClampAttribute = 10 - RescaleAttribute = 11 - MulAttribute = 12 - ArithmeticRightShiftAttribute = 13 - CondIfAttribute = 14 - WhileLoopAttribute = 15 - TransposeAttribute = 16 - TableAttribute = 17 - MatMulAttribute = 18 - FullyConnectedAttribute = 19 - NegateAttribute = 20 - + ResizeAttribute = 6 + ClampAttribute = 7 + RescaleAttribute = 8 + MulAttribute = 9 + ArithmeticRightShiftAttribute = 10 + CondIfAttribute = 11 + WhileLoopAttribute = 12 + TransposeAttribute = 13 + TableAttribute = 14 + MatMulAttribute = 15 + FullyConnectedAttribute = 16 + NegateAttribute = 17 + CustomAttribute = 18 + FFTAttribute = 19 + RFFTAttribute = 20 diff --git a/python/tosa/AxisAttribute.py b/python/tosa/AxisAttribute.py index 30876b7..7ce4a63 100644 --- a/python/tosa/AxisAttribute.py +++ b/python/tosa/AxisAttribute.py @@ -10,13 +10,17 @@ class AxisAttribute(object): __slots__ = ['_tab'] @classmethod - def GetRootAsAxisAttribute(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = AxisAttribute() x.Init(buf, n + offset) return x @classmethod + def GetRootAsAxisAttribute(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def AxisAttributeBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x4F\x53\x41", size_prefixed=size_prefixed) @@ -31,6 +35,20 @@ class AxisAttribute(object): return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) return 0 -def AxisAttributeStart(builder): builder.StartObject(1) -def AxisAttributeAddAxis(builder, axis): builder.PrependInt32Slot(0, axis, 0) -def AxisAttributeEnd(builder): return builder.EndObject() +def AxisAttributeStart(builder): + builder.StartObject(1) + +def Start(builder): + AxisAttributeStart(builder) + +def AxisAttributeAddAxis(builder, axis): + builder.PrependInt32Slot(0, axis, 0) + +def AddAxis(builder, axis): + AxisAttributeAddAxis(builder, axis) + +def AxisAttributeEnd(builder): + return builder.EndObject() + +def End(builder): + return AxisAttributeEnd(builder) diff --git a/python/tosa/ClampAttribute.py b/python/tosa/ClampAttribute.py index 066dd4f..40254ec 100644 --- a/python/tosa/ClampAttribute.py +++ b/python/tosa/ClampAttribute.py @@ -10,13 +10,17 @@ class ClampAttribute(object): __slots__ = ['_tab'] @classmethod - def GetRootAsClampAttribute(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = ClampAttribute() x.Init(buf, n + offset) return x @classmethod + def GetRootAsClampAttribute(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def ClampAttributeBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x4F\x53\x41", size_prefixed=size_prefixed) @@ -25,36 +29,91 @@ class ClampAttribute(object): self._tab = flatbuffers.table.Table(buf, pos) # ClampAttribute - def MinInt(self): + def MinVal(self, j): 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) + a = self._tab.Vector(o) + return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1)) return 0 # ClampAttribute - def MaxInt(self): + def MinValAsNumpy(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o) + return 0 + + # ClampAttribute + def MinValLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + + # ClampAttribute + def MinValIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + return o == 0 + + # ClampAttribute + def MaxVal(self, j): 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) + a = self._tab.Vector(o) + return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1)) return 0 # ClampAttribute - def MinFp(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + def MaxValAsNumpy(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 + return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o) + return 0 # ClampAttribute - def MaxFp(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) + def MaxValLength(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 - -def ClampAttributeStart(builder): builder.StartObject(4) -def ClampAttributeAddMinInt(builder, minInt): builder.PrependInt32Slot(0, minInt, 0) -def ClampAttributeAddMaxInt(builder, maxInt): builder.PrependInt32Slot(1, maxInt, 0) -def ClampAttributeAddMinFp(builder, minFp): builder.PrependFloat32Slot(2, minFp, 0.0) -def ClampAttributeAddMaxFp(builder, maxFp): builder.PrependFloat32Slot(3, maxFp, 0.0) -def ClampAttributeEnd(builder): return builder.EndObject() + return self._tab.VectorLen(o) + return 0 + + # ClampAttribute + def MaxValIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + return o == 0 + +def ClampAttributeStart(builder): + builder.StartObject(2) + +def Start(builder): + ClampAttributeStart(builder) + +def ClampAttributeAddMinVal(builder, minVal): + builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(minVal), 0) + +def AddMinVal(builder, minVal): + ClampAttributeAddMinVal(builder, minVal) + +def ClampAttributeStartMinValVector(builder, numElems): + return builder.StartVector(1, numElems, 1) + +def StartMinValVector(builder, numElems): + return ClampAttributeStartMinValVector(builder, numElems) + +def ClampAttributeAddMaxVal(builder, maxVal): + builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(maxVal), 0) + +def AddMaxVal(builder, maxVal): + ClampAttributeAddMaxVal(builder, maxVal) + +def ClampAttributeStartMaxValVector(builder, numElems): + return builder.StartVector(1, numElems, 1) + +def StartMaxValVector(builder, numElems): + return ClampAttributeStartMaxValVector(builder, numElems) + +def ClampAttributeEnd(builder): + return builder.EndObject() + +def End(builder): + return ClampAttributeEnd(builder) diff --git a/python/tosa/CondIfAttribute.py b/python/tosa/CondIfAttribute.py index 57e5cb7..8f2aa9b 100644 --- a/python/tosa/CondIfAttribute.py +++ b/python/tosa/CondIfAttribute.py @@ -10,13 +10,17 @@ class CondIfAttribute(object): __slots__ = ['_tab'] @classmethod - def GetRootAsCondIfAttribute(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = CondIfAttribute() x.Init(buf, n + offset) return x @classmethod + def GetRootAsCondIfAttribute(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def CondIfAttributeBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x4F\x53\x41", size_prefixed=size_prefixed) @@ -25,20 +29,39 @@ class CondIfAttribute(object): self._tab = flatbuffers.table.Table(buf, pos) # CondIfAttribute - def ThenBranch(self): + def ThenGraph(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 # CondIfAttribute - def ElseBranch(self): + def ElseGraph(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 CondIfAttributeStart(builder): builder.StartObject(2) -def CondIfAttributeAddThenBranch(builder, thenBranch): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(thenBranch), 0) -def CondIfAttributeAddElseBranch(builder, elseBranch): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(elseBranch), 0) -def CondIfAttributeEnd(builder): return builder.EndObject() +def CondIfAttributeStart(builder): + builder.StartObject(2) + +def Start(builder): + CondIfAttributeStart(builder) + +def CondIfAttributeAddThenGraph(builder, thenGraph): + builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(thenGraph), 0) + +def AddThenGraph(builder, thenGraph): + CondIfAttributeAddThenGraph(builder, thenGraph) + +def CondIfAttributeAddElseGraph(builder, elseGraph): + builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(elseGraph), 0) + +def AddElseGraph(builder, elseGraph): + CondIfAttributeAddElseGraph(builder, elseGraph) + +def CondIfAttributeEnd(builder): + return builder.EndObject() + +def End(builder): + return CondIfAttributeEnd(builder) diff --git a/python/tosa/ConvAttribute.py b/python/tosa/ConvAttribute.py index 8244ea5..1deca59 100644 --- a/python/tosa/ConvAttribute.py +++ b/python/tosa/ConvAttribute.py @@ -10,13 +10,17 @@ class ConvAttribute(object): __slots__ = ['_tab'] @classmethod - def GetRootAsConvAttribute(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = ConvAttribute() x.Init(buf, n + offset) return x @classmethod + def GetRootAsConvAttribute(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def ConvAttributeBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x4F\x53\x41", size_prefixed=size_prefixed) @@ -119,13 +123,88 @@ class ConvAttribute(object): return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) return 0 -def ConvAttributeStart(builder): builder.StartObject(5) -def ConvAttributeAddPad(builder, pad): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(pad), 0) -def ConvAttributeStartPadVector(builder, numElems): return builder.StartVector(4, numElems, 4) -def ConvAttributeAddStride(builder, stride): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(stride), 0) -def ConvAttributeStartStrideVector(builder, numElems): return builder.StartVector(4, numElems, 4) -def ConvAttributeAddDilation(builder, dilation): builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(dilation), 0) -def ConvAttributeStartDilationVector(builder, numElems): return builder.StartVector(4, numElems, 4) -def ConvAttributeAddInputZp(builder, inputZp): builder.PrependInt32Slot(3, inputZp, 0) -def ConvAttributeAddWeightZp(builder, weightZp): builder.PrependInt32Slot(4, weightZp, 0) -def ConvAttributeEnd(builder): return builder.EndObject() + # ConvAttribute + def LocalBound(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14)) + if o != 0: + return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) + return False + + # ConvAttribute + def AccType(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos) + return 0 + +def ConvAttributeStart(builder): + builder.StartObject(7) + +def Start(builder): + ConvAttributeStart(builder) + +def ConvAttributeAddPad(builder, pad): + builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(pad), 0) + +def AddPad(builder, pad): + ConvAttributeAddPad(builder, pad) + +def ConvAttributeStartPadVector(builder, numElems): + return builder.StartVector(4, numElems, 4) + +def StartPadVector(builder, numElems): + return ConvAttributeStartPadVector(builder, numElems) + +def ConvAttributeAddStride(builder, stride): + builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(stride), 0) + +def AddStride(builder, stride): + ConvAttributeAddStride(builder, stride) + +def ConvAttributeStartStrideVector(builder, numElems): + return builder.StartVector(4, numElems, 4) + +def StartStrideVector(builder, numElems): + return ConvAttributeStartStrideVector(builder, numElems) + +def ConvAttributeAddDilation(builder, dilation): + builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(dilation), 0) + +def AddDilation(builder, dilation): + ConvAttributeAddDilation(builder, dilation) + +def ConvAttributeStartDilationVector(builder, numElems): + return builder.StartVector(4, numElems, 4) + +def StartDilationVector(builder, numElems): + return ConvAttributeStartDilationVector(builder, numElems) + +def ConvAttributeAddInputZp(builder, inputZp): + builder.PrependInt32Slot(3, inputZp, 0) + +def AddInputZp(builder, inputZp): + ConvAttributeAddInputZp(builder, inputZp) + +def ConvAttributeAddWeightZp(builder, weightZp): + builder.PrependInt32Slot(4, weightZp, 0) + +def AddWeightZp(builder, weightZp): + ConvAttributeAddWeightZp(builder, weightZp) + +def ConvAttributeAddLocalBound(builder, localBound): + builder.PrependBoolSlot(5, localBound, 0) + +def AddLocalBound(builder, localBound): + ConvAttributeAddLocalBound(builder, localBound) + +def ConvAttributeAddAccType(builder, accType): + builder.PrependUint32Slot(6, accType, 0) + +def AddAccType(builder, accType): + ConvAttributeAddAccType(builder, accType) + +def ConvAttributeEnd(builder): + return builder.EndObject() + +def End(builder): + return ConvAttributeEnd(builder) diff --git a/python/tosa/CustomAttribute.py b/python/tosa/CustomAttribute.py new file mode 100644 index 0000000..4c1c477 --- /dev/null +++ b/python/tosa/CustomAttribute.py @@ -0,0 +1,106 @@ +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: tosa + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class CustomAttribute(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAs(cls, buf, offset=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = CustomAttribute() + x.Init(buf, n + offset) + return x + + @classmethod + def GetRootAsCustomAttribute(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod + def CustomAttributeBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x4F\x53\x41", size_prefixed=size_prefixed) + + # CustomAttribute + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # CustomAttribute + def OperatorName(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 + + # CustomAttribute + def DomainName(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 + + # CustomAttribute + def ImplementationAttrs(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + if o != 0: + a = self._tab.Vector(o) + return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1)) + return 0 + + # CustomAttribute + def ImplementationAttrsAsNumpy(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + if o != 0: + return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o) + return 0 + + # CustomAttribute + def ImplementationAttrsLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + + # CustomAttribute + def ImplementationAttrsIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + return o == 0 + +def CustomAttributeStart(builder): + builder.StartObject(3) + +def Start(builder): + CustomAttributeStart(builder) + +def CustomAttributeAddOperatorName(builder, operatorName): + builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(operatorName), 0) + +def AddOperatorName(builder, operatorName): + CustomAttributeAddOperatorName(builder, operatorName) + +def CustomAttributeAddDomainName(builder, domainName): + builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(domainName), 0) + +def AddDomainName(builder, domainName): + CustomAttributeAddDomainName(builder, domainName) + +def CustomAttributeAddImplementationAttrs(builder, implementationAttrs): + builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(implementationAttrs), 0) + +def AddImplementationAttrs(builder, implementationAttrs): + CustomAttributeAddImplementationAttrs(builder, implementationAttrs) + +def CustomAttributeStartImplementationAttrsVector(builder, numElems): + return builder.StartVector(1, numElems, 1) + +def StartImplementationAttrsVector(builder, numElems): + return CustomAttributeStartImplementationAttrsVector(builder, numElems) + +def CustomAttributeEnd(builder): + return builder.EndObject() + +def End(builder): + return CustomAttributeEnd(builder) diff --git a/python/tosa/DType.py b/python/tosa/DType.py index ad9048b..e585cb9 100644 --- a/python/tosa/DType.py +++ b/python/tosa/DType.py @@ -11,6 +11,10 @@ class DType(object): INT16 = 5 INT32 = 6 INT48 = 7 - FLOAT = 8 + FP32 = 8 UINT16 = 9 - + FP16 = 10 + BF16 = 11 + SHAPE = 12 + FP8E4M3 = 13 + FP8E5M2 = 14 diff --git a/python/tosa/FFTAttribute.py b/python/tosa/FFTAttribute.py new file mode 100644 index 0000000..d1624c2 --- /dev/null +++ b/python/tosa/FFTAttribute.py @@ -0,0 +1,67 @@ +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: tosa + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class FFTAttribute(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAs(cls, buf, offset=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = FFTAttribute() + x.Init(buf, n + offset) + return x + + @classmethod + def GetRootAsFFTAttribute(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod + def FFTAttributeBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x4F\x53\x41", size_prefixed=size_prefixed) + + # FFTAttribute + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # FFTAttribute + def Inverse(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) + return False + + # FFTAttribute + def LocalBound(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) + return False + +def FFTAttributeStart(builder): + builder.StartObject(2) + +def Start(builder): + FFTAttributeStart(builder) + +def FFTAttributeAddInverse(builder, inverse): + builder.PrependBoolSlot(0, inverse, 0) + +def AddInverse(builder, inverse): + FFTAttributeAddInverse(builder, inverse) + +def FFTAttributeAddLocalBound(builder, localBound): + builder.PrependBoolSlot(1, localBound, 0) + +def AddLocalBound(builder, localBound): + FFTAttributeAddLocalBound(builder, localBound) + +def FFTAttributeEnd(builder): + return builder.EndObject() + +def End(builder): + return FFTAttributeEnd(builder) diff --git a/python/tosa/FullyConnectedAttribute.py b/python/tosa/FullyConnectedAttribute.py index 62b480d..8854503 100644 --- a/python/tosa/FullyConnectedAttribute.py +++ b/python/tosa/FullyConnectedAttribute.py @@ -10,13 +10,17 @@ class FullyConnectedAttribute(object): __slots__ = ['_tab'] @classmethod - def GetRootAsFullyConnectedAttribute(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = FullyConnectedAttribute() x.Init(buf, n + offset) return x @classmethod + def GetRootAsFullyConnectedAttribute(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def FullyConnectedAttributeBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x4F\x53\x41", size_prefixed=size_prefixed) @@ -38,7 +42,26 @@ class FullyConnectedAttribute(object): return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) return 0 -def FullyConnectedAttributeStart(builder): builder.StartObject(2) -def FullyConnectedAttributeAddInputZp(builder, inputZp): builder.PrependInt32Slot(0, inputZp, 0) -def FullyConnectedAttributeAddWeightZp(builder, weightZp): builder.PrependInt32Slot(1, weightZp, 0) -def FullyConnectedAttributeEnd(builder): return builder.EndObject() +def FullyConnectedAttributeStart(builder): + builder.StartObject(2) + +def Start(builder): + FullyConnectedAttributeStart(builder) + +def FullyConnectedAttributeAddInputZp(builder, inputZp): + builder.PrependInt32Slot(0, inputZp, 0) + +def AddInputZp(builder, inputZp): + FullyConnectedAttributeAddInputZp(builder, inputZp) + +def FullyConnectedAttributeAddWeightZp(builder, weightZp): + builder.PrependInt32Slot(1, weightZp, 0) + +def AddWeightZp(builder, weightZp): + FullyConnectedAttributeAddWeightZp(builder, weightZp) + +def FullyConnectedAttributeEnd(builder): + return builder.EndObject() + +def End(builder): + return FullyConnectedAttributeEnd(builder) diff --git a/python/tosa/MatMulAttribute.py b/python/tosa/MatMulAttribute.py index 601f13f..325428a 100644 --- a/python/tosa/MatMulAttribute.py +++ b/python/tosa/MatMulAttribute.py @@ -10,13 +10,17 @@ class MatMulAttribute(object): __slots__ = ['_tab'] @classmethod - def GetRootAsMatMulAttribute(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = MatMulAttribute() x.Init(buf, n + offset) return x @classmethod + def GetRootAsMatMulAttribute(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def MatMulAttributeBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x4F\x53\x41", size_prefixed=size_prefixed) @@ -38,7 +42,26 @@ class MatMulAttribute(object): return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) return 0 -def MatMulAttributeStart(builder): builder.StartObject(2) -def MatMulAttributeAddAZp(builder, aZp): builder.PrependInt32Slot(0, aZp, 0) -def MatMulAttributeAddBZp(builder, bZp): builder.PrependInt32Slot(1, bZp, 0) -def MatMulAttributeEnd(builder): return builder.EndObject() +def MatMulAttributeStart(builder): + builder.StartObject(2) + +def Start(builder): + MatMulAttributeStart(builder) + +def MatMulAttributeAddAZp(builder, aZp): + builder.PrependInt32Slot(0, aZp, 0) + +def AddAZp(builder, aZp): + MatMulAttributeAddAZp(builder, aZp) + +def MatMulAttributeAddBZp(builder, bZp): + builder.PrependInt32Slot(1, bZp, 0) + +def AddBZp(builder, bZp): + MatMulAttributeAddBZp(builder, bZp) + +def MatMulAttributeEnd(builder): + return builder.EndObject() + +def End(builder): + return MatMulAttributeEnd(builder) diff --git a/python/tosa/MulAttribute.py b/python/tosa/MulAttribute.py index 79be4d3..236d3f5 100644 --- a/python/tosa/MulAttribute.py +++ b/python/tosa/MulAttribute.py @@ -10,13 +10,17 @@ class MulAttribute(object): __slots__ = ['_tab'] @classmethod - def GetRootAsMulAttribute(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = MulAttribute() x.Init(buf, n + offset) return x @classmethod + def GetRootAsMulAttribute(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def MulAttributeBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x4F\x53\x41", size_prefixed=size_prefixed) @@ -31,6 +35,20 @@ class MulAttribute(object): return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) return 0 -def MulAttributeStart(builder): builder.StartObject(1) -def MulAttributeAddShift(builder, shift): builder.PrependInt32Slot(0, shift, 0) -def MulAttributeEnd(builder): return builder.EndObject() +def MulAttributeStart(builder): + builder.StartObject(1) + +def Start(builder): + MulAttributeStart(builder) + +def MulAttributeAddShift(builder, shift): + builder.PrependInt32Slot(0, shift, 0) + +def AddShift(builder, shift): + MulAttributeAddShift(builder, shift) + +def MulAttributeEnd(builder): + return builder.EndObject() + +def End(builder): + return MulAttributeEnd(builder) diff --git a/python/tosa/NegateAttribute.py b/python/tosa/NegateAttribute.py index 24a57dc..eae46f5 100644 --- a/python/tosa/NegateAttribute.py +++ b/python/tosa/NegateAttribute.py @@ -10,13 +10,17 @@ class NegateAttribute(object): __slots__ = ['_tab'] @classmethod - def GetRootAsNegateAttribute(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = NegateAttribute() x.Init(buf, n + offset) return x @classmethod + def GetRootAsNegateAttribute(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def NegateAttributeBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x4F\x53\x41", size_prefixed=size_prefixed) @@ -38,7 +42,26 @@ class NegateAttribute(object): return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) return 0 -def NegateAttributeStart(builder): builder.StartObject(2) -def NegateAttributeAddInput1Zp(builder, input1Zp): builder.PrependInt32Slot(0, input1Zp, 0) -def NegateAttributeAddOutputZp(builder, outputZp): builder.PrependInt32Slot(1, outputZp, 0) -def NegateAttributeEnd(builder): return builder.EndObject() +def NegateAttributeStart(builder): + builder.StartObject(2) + +def Start(builder): + NegateAttributeStart(builder) + +def NegateAttributeAddInput1Zp(builder, input1Zp): + builder.PrependInt32Slot(0, input1Zp, 0) + +def AddInput1Zp(builder, input1Zp): + NegateAttributeAddInput1Zp(builder, input1Zp) + +def NegateAttributeAddOutputZp(builder, outputZp): + builder.PrependInt32Slot(1, outputZp, 0) + +def AddOutputZp(builder, outputZp): + NegateAttributeAddOutputZp(builder, outputZp) + +def NegateAttributeEnd(builder): + return builder.EndObject() + +def End(builder): + return NegateAttributeEnd(builder) diff --git a/python/tosa/Op.py b/python/tosa/Op.py index 181e457..35b2b80 100644 --- a/python/tosa/Op.py +++ b/python/tosa/Op.py @@ -72,4 +72,15 @@ class Op(object): CUSTOM = 66 COND_IF = 67 WHILE_LOOP = 68 - + FFT2D = 69 + RFFT2D = 70 + ERF = 71 + DIM = 72 + CONST_SHAPE = 73 + CONCAT_SHAPE = 74 + ADD_SHAPE = 75 + SUB_SHAPE = 76 + MUL_SHAPE = 77 + DIV_SHAPE = 78 + COS = 79 + SIN = 80 diff --git a/python/tosa/PadAttribute.py b/python/tosa/PadAttribute.py index 0875481..8adf9f7 100644 --- a/python/tosa/PadAttribute.py +++ b/python/tosa/PadAttribute.py @@ -10,13 +10,17 @@ class PadAttribute(object): __slots__ = ['_tab'] @classmethod - def GetRootAsPadAttribute(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = PadAttribute() x.Init(buf, n + offset) return x @classmethod + def GetRootAsPadAttribute(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def PadAttributeBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x4F\x53\x41", size_prefixed=size_prefixed) @@ -25,49 +29,52 @@ class PadAttribute(object): self._tab = flatbuffers.table.Table(buf, pos) # PadAttribute - def Padding(self, j): + def PadConst(self, j): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) 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 self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1)) return 0 # PadAttribute - def PaddingAsNumpy(self): + def PadConstAsNumpy(self): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) if o != 0: - return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int32Flags, o) + return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o) return 0 # PadAttribute - def PaddingLength(self): + def PadConstLength(self): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) if o != 0: return self._tab.VectorLen(o) return 0 # PadAttribute - def PaddingIsNone(self): + def PadConstIsNone(self): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) return o == 0 - # PadAttribute - def PadConstInt(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 +def PadAttributeStart(builder): + builder.StartObject(1) - # PadAttribute - def PadConstFp(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 - -def PadAttributeStart(builder): builder.StartObject(3) -def PadAttributeAddPadding(builder, padding): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(padding), 0) -def PadAttributeStartPaddingVector(builder, numElems): return builder.StartVector(4, numElems, 4) -def PadAttributeAddPadConstInt(builder, padConstInt): builder.PrependInt32Slot(1, padConstInt, 0) -def PadAttributeAddPadConstFp(builder, padConstFp): builder.PrependFloat32Slot(2, padConstFp, 0.0) -def PadAttributeEnd(builder): return builder.EndObject() +def Start(builder): + PadAttributeStart(builder) + +def PadAttributeAddPadConst(builder, padConst): + builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(padConst), 0) + +def AddPadConst(builder, padConst): + PadAttributeAddPadConst(builder, padConst) + +def PadAttributeStartPadConstVector(builder, numElems): + return builder.StartVector(1, numElems, 1) + +def StartPadConstVector(builder, numElems): + return PadAttributeStartPadConstVector(builder, numElems) + +def PadAttributeEnd(builder): + return builder.EndObject() + +def End(builder): + return PadAttributeEnd(builder) diff --git a/python/tosa/PoolAttribute.py b/python/tosa/PoolAttribute.py index 8b6903e..831d43b 100644 --- a/python/tosa/PoolAttribute.py +++ b/python/tosa/PoolAttribute.py @@ -10,13 +10,17 @@ class PoolAttribute(object): __slots__ = ['_tab'] @classmethod - def GetRootAsPoolAttribute(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = PoolAttribute() x.Init(buf, n + offset) return x @classmethod + def GetRootAsPoolAttribute(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def PoolAttributeBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x4F\x53\x41", size_prefixed=size_prefixed) @@ -119,13 +123,75 @@ class PoolAttribute(object): return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) return 0 -def PoolAttributeStart(builder): builder.StartObject(5) -def PoolAttributeAddPad(builder, pad): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(pad), 0) -def PoolAttributeStartPadVector(builder, numElems): return builder.StartVector(4, numElems, 4) -def PoolAttributeAddKernel(builder, kernel): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(kernel), 0) -def PoolAttributeStartKernelVector(builder, numElems): return builder.StartVector(4, numElems, 4) -def PoolAttributeAddStride(builder, stride): builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(stride), 0) -def PoolAttributeStartStrideVector(builder, numElems): return builder.StartVector(4, numElems, 4) -def PoolAttributeAddInputZp(builder, inputZp): builder.PrependInt32Slot(3, inputZp, 0) -def PoolAttributeAddOutputZp(builder, outputZp): builder.PrependInt32Slot(4, outputZp, 0) -def PoolAttributeEnd(builder): return builder.EndObject() + # PoolAttribute + def AccType(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos) + return 0 + +def PoolAttributeStart(builder): + builder.StartObject(6) + +def Start(builder): + PoolAttributeStart(builder) + +def PoolAttributeAddPad(builder, pad): + builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(pad), 0) + +def AddPad(builder, pad): + PoolAttributeAddPad(builder, pad) + +def PoolAttributeStartPadVector(builder, numElems): + return builder.StartVector(4, numElems, 4) + +def StartPadVector(builder, numElems): + return PoolAttributeStartPadVector(builder, numElems) + +def PoolAttributeAddKernel(builder, kernel): + builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(kernel), 0) + +def AddKernel(builder, kernel): + PoolAttributeAddKernel(builder, kernel) + +def PoolAttributeStartKernelVector(builder, numElems): + return builder.StartVector(4, numElems, 4) + +def StartKernelVector(builder, numElems): + return PoolAttributeStartKernelVector(builder, numElems) + +def PoolAttributeAddStride(builder, stride): + builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(stride), 0) + +def AddStride(builder, stride): + PoolAttributeAddStride(builder, stride) + +def PoolAttributeStartStrideVector(builder, numElems): + return builder.StartVector(4, numElems, 4) + +def StartStrideVector(builder, numElems): + return PoolAttributeStartStrideVector(builder, numElems) + +def PoolAttributeAddInputZp(builder, inputZp): + builder.PrependInt32Slot(3, inputZp, 0) + +def AddInputZp(builder, inputZp): + PoolAttributeAddInputZp(builder, inputZp) + +def PoolAttributeAddOutputZp(builder, outputZp): + builder.PrependInt32Slot(4, outputZp, 0) + +def AddOutputZp(builder, outputZp): + PoolAttributeAddOutputZp(builder, outputZp) + +def PoolAttributeAddAccType(builder, accType): + builder.PrependUint32Slot(5, accType, 0) + +def AddAccType(builder, accType): + PoolAttributeAddAccType(builder, accType) + +def PoolAttributeEnd(builder): + return builder.EndObject() + +def End(builder): + return PoolAttributeEnd(builder) diff --git a/python/tosa/RFFTAttribute.py b/python/tosa/RFFTAttribute.py new file mode 100644 index 0000000..7f76024 --- /dev/null +++ b/python/tosa/RFFTAttribute.py @@ -0,0 +1,54 @@ +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: tosa + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class RFFTAttribute(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAs(cls, buf, offset=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = RFFTAttribute() + x.Init(buf, n + offset) + return x + + @classmethod + def GetRootAsRFFTAttribute(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod + def RFFTAttributeBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x4F\x53\x41", size_prefixed=size_prefixed) + + # RFFTAttribute + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # RFFTAttribute + def LocalBound(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) + return False + +def RFFTAttributeStart(builder): + builder.StartObject(1) + +def Start(builder): + RFFTAttributeStart(builder) + +def RFFTAttributeAddLocalBound(builder, localBound): + builder.PrependBoolSlot(0, localBound, 0) + +def AddLocalBound(builder, localBound): + RFFTAttributeAddLocalBound(builder, localBound) + +def RFFTAttributeEnd(builder): + return builder.EndObject() + +def End(builder): + return RFFTAttributeEnd(builder) diff --git a/python/tosa/RescaleAttribute.py b/python/tosa/RescaleAttribute.py index 8ba68aa..12e7ced 100644 --- a/python/tosa/RescaleAttribute.py +++ b/python/tosa/RescaleAttribute.py @@ -10,13 +10,17 @@ class RescaleAttribute(object): __slots__ = ['_tab'] @classmethod - def GetRootAsRescaleAttribute(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = RescaleAttribute() x.Init(buf, n + offset) return x @classmethod + def GetRootAsRescaleAttribute(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def RescaleAttributeBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x4F\x53\x41", size_prefixed=size_prefixed) @@ -39,88 +43,90 @@ class RescaleAttribute(object): return 0 # RescaleAttribute - def Multiplier(self, j): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) - 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 - - # RescaleAttribute - def MultiplierAsNumpy(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) - if o != 0: - return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int32Flags, o) - return 0 - - # RescaleAttribute - def MultiplierLength(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) - if o != 0: - return self._tab.VectorLen(o) - return 0 - - # RescaleAttribute - def MultiplierIsNone(self): + def Scale32(self): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) - return o == 0 - - # RescaleAttribute - def Shift(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 - - # RescaleAttribute - def ShiftAsNumpy(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 + return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) + return False # RescaleAttribute - def ShiftLength(self): + def DoubleRound(self): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) if o != 0: - return self._tab.VectorLen(o) - return 0 - - # RescaleAttribute - def ShiftIsNone(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) - return o == 0 + return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) + return False # RescaleAttribute - def Scale32(self): + def PerChannel(self): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) if o != 0: return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) return False # RescaleAttribute - def DoubleRound(self): + def InputUnsigned(self): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14)) if o != 0: return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) return False # RescaleAttribute - def PerChannel(self): + def OutputUnsigned(self): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16)) if o != 0: return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) return False -def RescaleAttributeStart(builder): builder.StartObject(7) -def RescaleAttributeAddInputZp(builder, inputZp): builder.PrependInt32Slot(0, inputZp, 0) -def RescaleAttributeAddOutputZp(builder, outputZp): builder.PrependInt32Slot(1, outputZp, 0) -def RescaleAttributeAddMultiplier(builder, multiplier): builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(multiplier), 0) -def RescaleAttributeStartMultiplierVector(builder, numElems): return builder.StartVector(4, numElems, 4) -def RescaleAttributeAddShift(builder, shift): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(shift), 0) -def RescaleAttributeStartShiftVector(builder, numElems): return builder.StartVector(4, numElems, 4) -def RescaleAttributeAddScale32(builder, scale32): builder.PrependBoolSlot(4, scale32, 0) -def RescaleAttributeAddDoubleRound(builder, doubleRound): builder.PrependBoolSlot(5, doubleRound, 0) -def RescaleAttributeAddPerChannel(builder, perChannel): builder.PrependBoolSlot(6, perChannel, 0) -def RescaleAttributeEnd(builder): return builder.EndObject() +def RescaleAttributeStart(builder): + builder.StartObject(7) + +def Start(builder): + RescaleAttributeStart(builder) + +def RescaleAttributeAddInputZp(builder, inputZp): + builder.PrependInt32Slot(0, inputZp, 0) + +def AddInputZp(builder, inputZp): + RescaleAttributeAddInputZp(builder, inputZp) + +def RescaleAttributeAddOutputZp(builder, outputZp): + builder.PrependInt32Slot(1, outputZp, 0) + +def AddOutputZp(builder, outputZp): + RescaleAttributeAddOutputZp(builder, outputZp) + +def RescaleAttributeAddScale32(builder, scale32): + builder.PrependBoolSlot(2, scale32, 0) + +def AddScale32(builder, scale32): + RescaleAttributeAddScale32(builder, scale32) + +def RescaleAttributeAddDoubleRound(builder, doubleRound): + builder.PrependBoolSlot(3, doubleRound, 0) + +def AddDoubleRound(builder, doubleRound): + RescaleAttributeAddDoubleRound(builder, doubleRound) + +def RescaleAttributeAddPerChannel(builder, perChannel): + builder.PrependBoolSlot(4, perChannel, 0) + +def AddPerChannel(builder, perChannel): + RescaleAttributeAddPerChannel(builder, perChannel) + +def RescaleAttributeAddInputUnsigned(builder, inputUnsigned): + builder.PrependBoolSlot(5, inputUnsigned, 0) + +def AddInputUnsigned(builder, inputUnsigned): + RescaleAttributeAddInputUnsigned(builder, inputUnsigned) + +def RescaleAttributeAddOutputUnsigned(builder, outputUnsigned): + builder.PrependBoolSlot(6, outputUnsigned, 0) + +def AddOutputUnsigned(builder, outputUnsigned): + RescaleAttributeAddOutputUnsigned(builder, outputUnsigned) + +def RescaleAttributeEnd(builder): + return builder.EndObject() + +def End(builder): + return RescaleAttributeEnd(builder) diff --git a/python/tosa/ReshapeAttribute.py b/python/tosa/ReshapeAttribute.py deleted file mode 100644 index 73b1ee8..0000000 --- a/python/tosa/ReshapeAttribute.py +++ /dev/null @@ -1,57 +0,0 @@ -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tosa - -import flatbuffers -from flatbuffers.compat import import_numpy -np = import_numpy() - -class ReshapeAttribute(object): - __slots__ = ['_tab'] - - @classmethod - def GetRootAsReshapeAttribute(cls, buf, offset): - n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = ReshapeAttribute() - x.Init(buf, n + offset) - return x - - @classmethod - def ReshapeAttributeBufferHasIdentifier(cls, buf, offset, size_prefixed=False): - return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x4F\x53\x41", size_prefixed=size_prefixed) - - # ReshapeAttribute - def Init(self, buf, pos): - self._tab = flatbuffers.table.Table(buf, pos) - - # ReshapeAttribute - def NewShape(self, j): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) - 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 - - # ReshapeAttribute - def NewShapeAsNumpy(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) - if o != 0: - return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int32Flags, o) - return 0 - - # ReshapeAttribute - def NewShapeLength(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) - if o != 0: - return self._tab.VectorLen(o) - return 0 - - # ReshapeAttribute - def NewShapeIsNone(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) - return o == 0 - -def ReshapeAttributeStart(builder): builder.StartObject(1) -def ReshapeAttributeAddNewShape(builder, newShape): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(newShape), 0) -def ReshapeAttributeStartNewShapeVector(builder, numElems): return builder.StartVector(4, numElems, 4) -def ReshapeAttributeEnd(builder): return builder.EndObject() diff --git a/python/tosa/ResizeAttribute.py b/python/tosa/ResizeAttribute.py index 1ed2dc0..44f7d31 100644 --- a/python/tosa/ResizeAttribute.py +++ b/python/tosa/ResizeAttribute.py @@ -10,13 +10,17 @@ class ResizeAttribute(object): __slots__ = ['_tab'] @classmethod - def GetRootAsResizeAttribute(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = ResizeAttribute() x.Init(buf, n + offset) return x @classmethod + def GetRootAsResizeAttribute(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def ResizeAttributeBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x4F\x53\x41", size_prefixed=size_prefixed) @@ -25,165 +29,143 @@ class ResizeAttribute(object): self._tab = flatbuffers.table.Table(buf, pos) # ResizeAttribute - def OutputSize(self, j): + def Scale(self, j): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) 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 self._tab.Get(flatbuffers.number_types.Int16Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 2)) return 0 # ResizeAttribute - def OutputSizeAsNumpy(self): + def ScaleAsNumpy(self): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) if o != 0: - return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int32Flags, o) + return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int16Flags, o) return 0 # ResizeAttribute - def OutputSizeLength(self): + def ScaleLength(self): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) if o != 0: return self._tab.VectorLen(o) return 0 # ResizeAttribute - def OutputSizeIsNone(self): + def ScaleIsNone(self): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) return o == 0 # ResizeAttribute - def Stride(self, j): + def Offset(self, j): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) 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 self._tab.Get(flatbuffers.number_types.Int16Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 2)) return 0 # ResizeAttribute - def StrideAsNumpy(self): + def OffsetAsNumpy(self): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) if o != 0: - return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int32Flags, o) + return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int16Flags, o) return 0 # ResizeAttribute - def StrideLength(self): + def OffsetLength(self): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) if o != 0: return self._tab.VectorLen(o) return 0 # ResizeAttribute - def StrideIsNone(self): + def OffsetIsNone(self): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) return o == 0 # ResizeAttribute - def Offset(self, j): + def Border(self, j): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) 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 self._tab.Get(flatbuffers.number_types.Int16Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 2)) return 0 # ResizeAttribute - def OffsetAsNumpy(self): + def BorderAsNumpy(self): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) if o != 0: - return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int32Flags, o) + return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int16Flags, o) return 0 # ResizeAttribute - def OffsetLength(self): + def BorderLength(self): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) if o != 0: return self._tab.VectorLen(o) return 0 # ResizeAttribute - def OffsetIsNone(self): + def BorderIsNone(self): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) return o == 0 # ResizeAttribute - def Shift(self): + def Mode(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 self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos) return 0 - # ResizeAttribute - def StrideFp(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.Float32Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4)) - return 0 +def ResizeAttributeStart(builder): + builder.StartObject(4) - # ResizeAttribute - def StrideFpAsNumpy(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) - if o != 0: - return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Float32Flags, o) - return 0 +def Start(builder): + ResizeAttributeStart(builder) - # ResizeAttribute - def StrideFpLength(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) - if o != 0: - return self._tab.VectorLen(o) - return 0 +def ResizeAttributeAddScale(builder, scale): + builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(scale), 0) - # ResizeAttribute - def StrideFpIsNone(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) - return o == 0 +def AddScale(builder, scale): + ResizeAttributeAddScale(builder, scale) - # ResizeAttribute - def OffsetFp(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.Float32Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4)) - return 0 +def ResizeAttributeStartScaleVector(builder, numElems): + return builder.StartVector(2, numElems, 2) - # ResizeAttribute - def OffsetFpAsNumpy(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14)) - if o != 0: - return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Float32Flags, o) - return 0 +def StartScaleVector(builder, numElems): + return ResizeAttributeStartScaleVector(builder, numElems) - # ResizeAttribute - def OffsetFpLength(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14)) - if o != 0: - return self._tab.VectorLen(o) - return 0 +def ResizeAttributeAddOffset(builder, offset): + builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(offset), 0) - # ResizeAttribute - def OffsetFpIsNone(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14)) - return o == 0 +def AddOffset(builder, offset): + ResizeAttributeAddOffset(builder, offset) - # ResizeAttribute - def Mode(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16)) - if o != 0: - return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos) - return 0 +def ResizeAttributeStartOffsetVector(builder, numElems): + return builder.StartVector(2, numElems, 2) + +def StartOffsetVector(builder, numElems): + return ResizeAttributeStartOffsetVector(builder, numElems) + +def ResizeAttributeAddBorder(builder, border): + builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(border), 0) + +def AddBorder(builder, border): + ResizeAttributeAddBorder(builder, border) + +def ResizeAttributeStartBorderVector(builder, numElems): + return builder.StartVector(2, numElems, 2) + +def StartBorderVector(builder, numElems): + return ResizeAttributeStartBorderVector(builder, numElems) + +def ResizeAttributeAddMode(builder, mode): + builder.PrependUint32Slot(3, mode, 0) + +def AddMode(builder, mode): + ResizeAttributeAddMode(builder, mode) + +def ResizeAttributeEnd(builder): + return builder.EndObject() -def ResizeAttributeStart(builder): builder.StartObject(7) -def ResizeAttributeAddOutputSize(builder, outputSize): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(outputSize), 0) -def ResizeAttributeStartOutputSizeVector(builder, numElems): return builder.StartVector(4, numElems, 4) -def ResizeAttributeAddStride(builder, stride): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(stride), 0) -def ResizeAttributeStartStrideVector(builder, numElems): return builder.StartVector(4, numElems, 4) -def ResizeAttributeAddOffset(builder, offset): builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(offset), 0) -def ResizeAttributeStartOffsetVector(builder, numElems): return builder.StartVector(4, numElems, 4) -def ResizeAttributeAddShift(builder, shift): builder.PrependInt32Slot(3, shift, 0) -def ResizeAttributeAddStrideFp(builder, strideFp): builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(strideFp), 0) -def ResizeAttributeStartStrideFpVector(builder, numElems): return builder.StartVector(4, numElems, 4) -def ResizeAttributeAddOffsetFp(builder, offsetFp): builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(offsetFp), 0) -def ResizeAttributeStartOffsetFpVector(builder, numElems): return builder.StartVector(4, numElems, 4) -def ResizeAttributeAddMode(builder, mode): builder.PrependUint32Slot(6, mode, 0) -def ResizeAttributeEnd(builder): return builder.EndObject() +def End(builder): + return ResizeAttributeEnd(builder) diff --git a/python/tosa/ResizeMode.py b/python/tosa/ResizeMode.py index 65bcd5d..388ecda 100644 --- a/python/tosa/ResizeMode.py +++ b/python/tosa/ResizeMode.py @@ -6,4 +6,3 @@ class ResizeMode(object): UNKNOWN = 0 NEAREST = 1 BILINEAR = 2 - diff --git a/python/tosa/SliceAttribute.py b/python/tosa/SliceAttribute.py deleted file mode 100644 index d3f6073..0000000 --- a/python/tosa/SliceAttribute.py +++ /dev/null @@ -1,86 +0,0 @@ -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tosa - -import flatbuffers -from flatbuffers.compat import import_numpy -np = import_numpy() - -class SliceAttribute(object): - __slots__ = ['_tab'] - - @classmethod - def GetRootAsSliceAttribute(cls, buf, offset): - n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = SliceAttribute() - x.Init(buf, n + offset) - return x - - @classmethod - def SliceAttributeBufferHasIdentifier(cls, buf, offset, size_prefixed=False): - return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x4F\x53\x41", size_prefixed=size_prefixed) - - # SliceAttribute - def Init(self, buf, pos): - self._tab = flatbuffers.table.Table(buf, pos) - - # SliceAttribute - def Start(self, j): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) - 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 - - # SliceAttribute - def StartAsNumpy(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) - if o != 0: - return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int32Flags, o) - return 0 - - # SliceAttribute - def StartLength(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) - if o != 0: - return self._tab.VectorLen(o) - return 0 - - # SliceAttribute - def StartIsNone(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) - return o == 0 - - # SliceAttribute - def Size(self, j): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) - 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 - - # SliceAttribute - def SizeAsNumpy(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) - if o != 0: - return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int32Flags, o) - return 0 - - # SliceAttribute - def SizeLength(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) - if o != 0: - return self._tab.VectorLen(o) - return 0 - - # SliceAttribute - def SizeIsNone(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) - return o == 0 - -def SliceAttributeStart(builder): builder.StartObject(2) -def SliceAttributeAddStart(builder, start): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(start), 0) -def SliceAttributeStartStartVector(builder, numElems): return builder.StartVector(4, numElems, 4) -def SliceAttributeAddSize(builder, size): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(size), 0) -def SliceAttributeStartSizeVector(builder, numElems): return builder.StartVector(4, numElems, 4) -def SliceAttributeEnd(builder): return builder.EndObject() diff --git a/python/tosa/TableAttribute.py b/python/tosa/TableAttribute.py index 49a5c9a..04193fa 100644 --- a/python/tosa/TableAttribute.py +++ b/python/tosa/TableAttribute.py @@ -10,13 +10,17 @@ class TableAttribute(object): __slots__ = ['_tab'] @classmethod - def GetRootAsTableAttribute(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = TableAttribute() x.Init(buf, n + offset) return x @classmethod + def GetRootAsTableAttribute(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def TableAttributeBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x4F\x53\x41", size_prefixed=size_prefixed) @@ -51,7 +55,26 @@ class TableAttribute(object): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) return o == 0 -def TableAttributeStart(builder): builder.StartObject(1) -def TableAttributeAddTable(builder, table): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(table), 0) -def TableAttributeStartTableVector(builder, numElems): return builder.StartVector(2, numElems, 2) -def TableAttributeEnd(builder): return builder.EndObject() +def TableAttributeStart(builder): + builder.StartObject(1) + +def Start(builder): + TableAttributeStart(builder) + +def TableAttributeAddTable(builder, table): + builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(table), 0) + +def AddTable(builder, table): + TableAttributeAddTable(builder, table) + +def TableAttributeStartTableVector(builder, numElems): + return builder.StartVector(2, numElems, 2) + +def StartTableVector(builder, numElems): + return TableAttributeStartTableVector(builder, numElems) + +def TableAttributeEnd(builder): + return builder.EndObject() + +def End(builder): + return TableAttributeEnd(builder) diff --git a/python/tosa/TileAttribute.py b/python/tosa/TileAttribute.py deleted file mode 100644 index 03dd0fb..0000000 --- a/python/tosa/TileAttribute.py +++ /dev/null @@ -1,57 +0,0 @@ -# automatically generated by the FlatBuffers compiler, do not modify - -# namespace: tosa - -import flatbuffers -from flatbuffers.compat import import_numpy -np = import_numpy() - -class TileAttribute(object): - __slots__ = ['_tab'] - - @classmethod - def GetRootAsTileAttribute(cls, buf, offset): - n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) - x = TileAttribute() - x.Init(buf, n + offset) - return x - - @classmethod - def TileAttributeBufferHasIdentifier(cls, buf, offset, size_prefixed=False): - return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x4F\x53\x41", size_prefixed=size_prefixed) - - # TileAttribute - def Init(self, buf, pos): - self._tab = flatbuffers.table.Table(buf, pos) - - # TileAttribute - def Multiples(self, j): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) - 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 - - # TileAttribute - def MultiplesAsNumpy(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) - if o != 0: - return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int32Flags, o) - return 0 - - # TileAttribute - def MultiplesLength(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) - if o != 0: - return self._tab.VectorLen(o) - return 0 - - # TileAttribute - def MultiplesIsNone(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) - return o == 0 - -def TileAttributeStart(builder): builder.StartObject(1) -def TileAttributeAddMultiples(builder, multiples): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(multiples), 0) -def TileAttributeStartMultiplesVector(builder, numElems): return builder.StartVector(4, numElems, 4) -def TileAttributeEnd(builder): return builder.EndObject() diff --git a/python/tosa/TosaBasicBlock.py b/python/tosa/TosaBasicBlock.py index 1c93c63..30ad0ee 100644 --- a/python/tosa/TosaBasicBlock.py +++ b/python/tosa/TosaBasicBlock.py @@ -10,13 +10,17 @@ class TosaBasicBlock(object): __slots__ = ['_tab'] @classmethod - def GetRootAsTosaBasicBlock(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = TosaBasicBlock() x.Init(buf, n + offset) return x @classmethod + def GetRootAsTosaBasicBlock(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def TosaBasicBlockBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x4F\x53\x41", size_prefixed=size_prefixed) @@ -121,14 +125,68 @@ class TosaBasicBlock(object): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) return o == 0 -def TosaBasicBlockStart(builder): builder.StartObject(5) -def TosaBasicBlockAddName(builder, name): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0) -def TosaBasicBlockAddOperators(builder, operators): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(operators), 0) -def TosaBasicBlockStartOperatorsVector(builder, numElems): return builder.StartVector(4, numElems, 4) -def TosaBasicBlockAddTensors(builder, tensors): builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(tensors), 0) -def TosaBasicBlockStartTensorsVector(builder, numElems): return builder.StartVector(4, numElems, 4) -def TosaBasicBlockAddInputs(builder, inputs): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(inputs), 0) -def TosaBasicBlockStartInputsVector(builder, numElems): return builder.StartVector(4, numElems, 4) -def TosaBasicBlockAddOutputs(builder, outputs): builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(outputs), 0) -def TosaBasicBlockStartOutputsVector(builder, numElems): return builder.StartVector(4, numElems, 4) -def TosaBasicBlockEnd(builder): return builder.EndObject() +def TosaBasicBlockStart(builder): + builder.StartObject(5) + +def Start(builder): + TosaBasicBlockStart(builder) + +def TosaBasicBlockAddName(builder, name): + builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0) + +def AddName(builder, name): + TosaBasicBlockAddName(builder, name) + +def TosaBasicBlockAddOperators(builder, operators): + builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(operators), 0) + +def AddOperators(builder, operators): + TosaBasicBlockAddOperators(builder, operators) + +def TosaBasicBlockStartOperatorsVector(builder, numElems): + return builder.StartVector(4, numElems, 4) + +def StartOperatorsVector(builder, numElems): + return TosaBasicBlockStartOperatorsVector(builder, numElems) + +def TosaBasicBlockAddTensors(builder, tensors): + builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(tensors), 0) + +def AddTensors(builder, tensors): + TosaBasicBlockAddTensors(builder, tensors) + +def TosaBasicBlockStartTensorsVector(builder, numElems): + return builder.StartVector(4, numElems, 4) + +def StartTensorsVector(builder, numElems): + return TosaBasicBlockStartTensorsVector(builder, numElems) + +def TosaBasicBlockAddInputs(builder, inputs): + builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(inputs), 0) + +def AddInputs(builder, inputs): + TosaBasicBlockAddInputs(builder, inputs) + +def TosaBasicBlockStartInputsVector(builder, numElems): + return builder.StartVector(4, numElems, 4) + +def StartInputsVector(builder, numElems): + return TosaBasicBlockStartInputsVector(builder, numElems) + +def TosaBasicBlockAddOutputs(builder, outputs): + builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(outputs), 0) + +def AddOutputs(builder, outputs): + TosaBasicBlockAddOutputs(builder, outputs) + +def TosaBasicBlockStartOutputsVector(builder, numElems): + return builder.StartVector(4, numElems, 4) + +def StartOutputsVector(builder, numElems): + return TosaBasicBlockStartOutputsVector(builder, numElems) + +def TosaBasicBlockEnd(builder): + return builder.EndObject() + +def End(builder): + return TosaBasicBlockEnd(builder) diff --git a/python/tosa/TosaGraph.py b/python/tosa/TosaGraph.py index eceffdb..520372b 100644 --- a/python/tosa/TosaGraph.py +++ b/python/tosa/TosaGraph.py @@ -10,13 +10,17 @@ class TosaGraph(object): __slots__ = ['_tab'] @classmethod - def GetRootAsTosaGraph(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = TosaGraph() x.Init(buf, n + offset) return x @classmethod + def GetRootAsTosaGraph(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def TosaGraphBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x4F\x53\x41", size_prefixed=size_prefixed) @@ -36,32 +40,56 @@ class TosaGraph(object): return None # TosaGraph - def Blocks(self, j): + def Regions(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 tosa.TosaBasicBlock import TosaBasicBlock - obj = TosaBasicBlock() + from tosa.TosaRegion import TosaRegion + obj = TosaRegion() obj.Init(self._tab.Bytes, x) return obj return None # TosaGraph - def BlocksLength(self): + def RegionsLength(self): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) if o != 0: return self._tab.VectorLen(o) return 0 # TosaGraph - def BlocksIsNone(self): + def RegionsIsNone(self): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) return o == 0 -def TosaGraphStart(builder): builder.StartObject(2) -def TosaGraphAddVersion(builder, version): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(version), 0) -def TosaGraphAddBlocks(builder, blocks): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(blocks), 0) -def TosaGraphStartBlocksVector(builder, numElems): return builder.StartVector(4, numElems, 4) -def TosaGraphEnd(builder): return builder.EndObject() +def TosaGraphStart(builder): + builder.StartObject(2) + +def Start(builder): + TosaGraphStart(builder) + +def TosaGraphAddVersion(builder, version): + builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(version), 0) + +def AddVersion(builder, version): + TosaGraphAddVersion(builder, version) + +def TosaGraphAddRegions(builder, regions): + builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(regions), 0) + +def AddRegions(builder, regions): + TosaGraphAddRegions(builder, regions) + +def TosaGraphStartRegionsVector(builder, numElems): + return builder.StartVector(4, numElems, 4) + +def StartRegionsVector(builder, numElems): + return TosaGraphStartRegionsVector(builder, numElems) + +def TosaGraphEnd(builder): + return builder.EndObject() + +def End(builder): + return TosaGraphEnd(builder) diff --git a/python/tosa/TosaOperator.py b/python/tosa/TosaOperator.py index fd11f76..19f2d2c 100644 --- a/python/tosa/TosaOperator.py +++ b/python/tosa/TosaOperator.py @@ -10,13 +10,17 @@ class TosaOperator(object): __slots__ = ['_tab'] @classmethod - def GetRootAsTosaOperator(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = TosaOperator() x.Init(buf, n + offset) return x @classmethod + def GetRootAsTosaOperator(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def TosaOperatorBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x4F\x53\x41", size_prefixed=size_prefixed) @@ -88,12 +92,56 @@ class TosaOperator(object): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) return o == 0 -def TosaOperatorStart(builder): builder.StartObject(5) -def TosaOperatorAddOp(builder, op): builder.PrependUint32Slot(0, op, 0) -def TosaOperatorAddAttributeType(builder, attributeType): builder.PrependUint8Slot(1, attributeType, 0) -def TosaOperatorAddAttribute(builder, attribute): builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(attribute), 0) -def TosaOperatorAddInputs(builder, inputs): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(inputs), 0) -def TosaOperatorStartInputsVector(builder, numElems): return builder.StartVector(4, numElems, 4) -def TosaOperatorAddOutputs(builder, outputs): builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(outputs), 0) -def TosaOperatorStartOutputsVector(builder, numElems): return builder.StartVector(4, numElems, 4) -def TosaOperatorEnd(builder): return builder.EndObject() +def TosaOperatorStart(builder): + builder.StartObject(5) + +def Start(builder): + TosaOperatorStart(builder) + +def TosaOperatorAddOp(builder, op): + builder.PrependUint32Slot(0, op, 0) + +def AddOp(builder, op): + TosaOperatorAddOp(builder, op) + +def TosaOperatorAddAttributeType(builder, attributeType): + builder.PrependUint8Slot(1, attributeType, 0) + +def AddAttributeType(builder, attributeType): + TosaOperatorAddAttributeType(builder, attributeType) + +def TosaOperatorAddAttribute(builder, attribute): + builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(attribute), 0) + +def AddAttribute(builder, attribute): + TosaOperatorAddAttribute(builder, attribute) + +def TosaOperatorAddInputs(builder, inputs): + builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(inputs), 0) + +def AddInputs(builder, inputs): + TosaOperatorAddInputs(builder, inputs) + +def TosaOperatorStartInputsVector(builder, numElems): + return builder.StartVector(4, numElems, 4) + +def StartInputsVector(builder, numElems): + return TosaOperatorStartInputsVector(builder, numElems) + +def TosaOperatorAddOutputs(builder, outputs): + builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(outputs), 0) + +def AddOutputs(builder, outputs): + TosaOperatorAddOutputs(builder, outputs) + +def TosaOperatorStartOutputsVector(builder, numElems): + return builder.StartVector(4, numElems, 4) + +def StartOutputsVector(builder, numElems): + return TosaOperatorStartOutputsVector(builder, numElems) + +def TosaOperatorEnd(builder): + return builder.EndObject() + +def End(builder): + return TosaOperatorEnd(builder) diff --git a/python/tosa/TosaRegion.py b/python/tosa/TosaRegion.py new file mode 100644 index 0000000..80829da --- /dev/null +++ b/python/tosa/TosaRegion.py @@ -0,0 +1,91 @@ +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: tosa + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class TosaRegion(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAs(cls, buf, offset=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = TosaRegion() + x.Init(buf, n + offset) + return x + + @classmethod + def GetRootAsTosaRegion(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod + def TosaRegionBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x4F\x53\x41", size_prefixed=size_prefixed) + + # TosaRegion + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # TosaRegion + 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 + + # TosaRegion + def Blocks(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 tosa.TosaBasicBlock import TosaBasicBlock + obj = TosaBasicBlock() + obj.Init(self._tab.Bytes, x) + return obj + return None + + # TosaRegion + def BlocksLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + + # TosaRegion + def BlocksIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + return o == 0 + +def TosaRegionStart(builder): + builder.StartObject(2) + +def Start(builder): + TosaRegionStart(builder) + +def TosaRegionAddName(builder, name): + builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0) + +def AddName(builder, name): + TosaRegionAddName(builder, name) + +def TosaRegionAddBlocks(builder, blocks): + builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(blocks), 0) + +def AddBlocks(builder, blocks): + TosaRegionAddBlocks(builder, blocks) + +def TosaRegionStartBlocksVector(builder, numElems): + return builder.StartVector(4, numElems, 4) + +def StartBlocksVector(builder, numElems): + return TosaRegionStartBlocksVector(builder, numElems) + +def TosaRegionEnd(builder): + return builder.EndObject() + +def End(builder): + return TosaRegionEnd(builder) diff --git a/python/tosa/TosaTensor.py b/python/tosa/TosaTensor.py index a6f609d..1311aac 100644 --- a/python/tosa/TosaTensor.py +++ b/python/tosa/TosaTensor.py @@ -10,13 +10,17 @@ class TosaTensor(object): __slots__ = ['_tab'] @classmethod - def GetRootAsTosaTensor(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = TosaTensor() x.Init(buf, n + offset) return x @classmethod + def GetRootAsTosaTensor(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def TosaTensorBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x4F\x53\x41", size_prefixed=size_prefixed) @@ -92,11 +96,89 @@ class TosaTensor(object): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) return o == 0 -def TosaTensorStart(builder): builder.StartObject(4) -def TosaTensorAddName(builder, name): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0) -def TosaTensorAddShape(builder, shape): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(shape), 0) -def TosaTensorStartShapeVector(builder, numElems): return builder.StartVector(4, numElems, 4) -def TosaTensorAddType(builder, type): builder.PrependUint32Slot(2, type, 0) -def TosaTensorAddData(builder, data): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(data), 0) -def TosaTensorStartDataVector(builder, numElems): return builder.StartVector(1, numElems, 1) -def TosaTensorEnd(builder): return builder.EndObject() + # TosaTensor + def Variable(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) + if o != 0: + return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) + return False + + # TosaTensor + def IsUnranked(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14)) + if o != 0: + return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) + return False + + # TosaTensor + def VariableName(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16)) + if o != 0: + return self._tab.String(o + self._tab.Pos) + return None + +def TosaTensorStart(builder): + builder.StartObject(7) + +def Start(builder): + TosaTensorStart(builder) + +def TosaTensorAddName(builder, name): + builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0) + +def AddName(builder, name): + TosaTensorAddName(builder, name) + +def TosaTensorAddShape(builder, shape): + builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(shape), 0) + +def AddShape(builder, shape): + TosaTensorAddShape(builder, shape) + +def TosaTensorStartShapeVector(builder, numElems): + return builder.StartVector(4, numElems, 4) + +def StartShapeVector(builder, numElems): + return TosaTensorStartShapeVector(builder, numElems) + +def TosaTensorAddType(builder, type): + builder.PrependUint32Slot(2, type, 0) + +def AddType(builder, type): + TosaTensorAddType(builder, type) + +def TosaTensorAddData(builder, data): + builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(data), 0) + +def AddData(builder, data): + TosaTensorAddData(builder, data) + +def TosaTensorStartDataVector(builder, numElems): + return builder.StartVector(1, numElems, 1) + +def StartDataVector(builder, numElems): + return TosaTensorStartDataVector(builder, numElems) + +def TosaTensorAddVariable(builder, variable): + builder.PrependBoolSlot(4, variable, 0) + +def AddVariable(builder, variable): + TosaTensorAddVariable(builder, variable) + +def TosaTensorAddIsUnranked(builder, isUnranked): + builder.PrependBoolSlot(5, isUnranked, 0) + +def AddIsUnranked(builder, isUnranked): + TosaTensorAddIsUnranked(builder, isUnranked) + +def TosaTensorAddVariableName(builder, variableName): + builder.PrependUOffsetTRelativeSlot(6, flatbuffers.number_types.UOffsetTFlags.py_type(variableName), 0) + +def AddVariableName(builder, variableName): + TosaTensorAddVariableName(builder, variableName) + +def TosaTensorEnd(builder): + return builder.EndObject() + +def End(builder): + return TosaTensorEnd(builder) diff --git a/python/tosa/TransposeAttribute.py b/python/tosa/TransposeAttribute.py index 82e6b3a..5aa23e2 100644 --- a/python/tosa/TransposeAttribute.py +++ b/python/tosa/TransposeAttribute.py @@ -10,13 +10,17 @@ class TransposeAttribute(object): __slots__ = ['_tab'] @classmethod - def GetRootAsTransposeAttribute(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = TransposeAttribute() x.Init(buf, n + offset) return x @classmethod + def GetRootAsTransposeAttribute(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def TransposeAttributeBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x4F\x53\x41", size_prefixed=size_prefixed) @@ -51,7 +55,26 @@ class TransposeAttribute(object): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) return o == 0 -def TransposeAttributeStart(builder): builder.StartObject(1) -def TransposeAttributeAddPerms(builder, perms): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(perms), 0) -def TransposeAttributeStartPermsVector(builder, numElems): return builder.StartVector(4, numElems, 4) -def TransposeAttributeEnd(builder): return builder.EndObject() +def TransposeAttributeStart(builder): + builder.StartObject(1) + +def Start(builder): + TransposeAttributeStart(builder) + +def TransposeAttributeAddPerms(builder, perms): + builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(perms), 0) + +def AddPerms(builder, perms): + TransposeAttributeAddPerms(builder, perms) + +def TransposeAttributeStartPermsVector(builder, numElems): + return builder.StartVector(4, numElems, 4) + +def StartPermsVector(builder, numElems): + return TransposeAttributeStartPermsVector(builder, numElems) + +def TransposeAttributeEnd(builder): + return builder.EndObject() + +def End(builder): + return TransposeAttributeEnd(builder) diff --git a/python/tosa/TransposeConvAttribute.py b/python/tosa/TransposeConvAttribute.py index 8ca5ba7..2f7cdc7 100644 --- a/python/tosa/TransposeConvAttribute.py +++ b/python/tosa/TransposeConvAttribute.py @@ -10,13 +10,17 @@ class TransposeConvAttribute(object): __slots__ = ['_tab'] @classmethod - def GetRootAsTransposeConvAttribute(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = TransposeConvAttribute() x.Init(buf, n + offset) return x @classmethod + def GetRootAsTransposeConvAttribute(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def TransposeConvAttributeBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x4F\x53\x41", size_prefixed=size_prefixed) @@ -79,53 +83,89 @@ class TransposeConvAttribute(object): return o == 0 # TransposeConvAttribute - def OutputShape(self, j): + def InputZp(self): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) 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 self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) return 0 # TransposeConvAttribute - def OutputShapeAsNumpy(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + def WeightZp(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 self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) return 0 # TransposeConvAttribute - def OutputShapeLength(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + def LocalBound(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) if o != 0: - return self._tab.VectorLen(o) - return 0 - - # TransposeConvAttribute - def OutputShapeIsNone(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) - return o == 0 + return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) + return False # TransposeConvAttribute - def InputZp(self): - o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) + def AccType(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 self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos) return 0 - # TransposeConvAttribute - def WeightZp(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 +def TransposeConvAttributeStart(builder): + builder.StartObject(6) + +def Start(builder): + TransposeConvAttributeStart(builder) + +def TransposeConvAttributeAddOutPad(builder, outPad): + builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(outPad), 0) + +def AddOutPad(builder, outPad): + TransposeConvAttributeAddOutPad(builder, outPad) + +def TransposeConvAttributeStartOutPadVector(builder, numElems): + return builder.StartVector(4, numElems, 4) + +def StartOutPadVector(builder, numElems): + return TransposeConvAttributeStartOutPadVector(builder, numElems) + +def TransposeConvAttributeAddStride(builder, stride): + builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(stride), 0) + +def AddStride(builder, stride): + TransposeConvAttributeAddStride(builder, stride) + +def TransposeConvAttributeStartStrideVector(builder, numElems): + return builder.StartVector(4, numElems, 4) + +def StartStrideVector(builder, numElems): + return TransposeConvAttributeStartStrideVector(builder, numElems) + +def TransposeConvAttributeAddInputZp(builder, inputZp): + builder.PrependInt32Slot(2, inputZp, 0) + +def AddInputZp(builder, inputZp): + TransposeConvAttributeAddInputZp(builder, inputZp) + +def TransposeConvAttributeAddWeightZp(builder, weightZp): + builder.PrependInt32Slot(3, weightZp, 0) + +def AddWeightZp(builder, weightZp): + TransposeConvAttributeAddWeightZp(builder, weightZp) + +def TransposeConvAttributeAddLocalBound(builder, localBound): + builder.PrependBoolSlot(4, localBound, 0) + +def AddLocalBound(builder, localBound): + TransposeConvAttributeAddLocalBound(builder, localBound) + +def TransposeConvAttributeAddAccType(builder, accType): + builder.PrependUint32Slot(5, accType, 0) + +def AddAccType(builder, accType): + TransposeConvAttributeAddAccType(builder, accType) + +def TransposeConvAttributeEnd(builder): + return builder.EndObject() -def TransposeConvAttributeStart(builder): builder.StartObject(5) -def TransposeConvAttributeAddOutPad(builder, outPad): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(outPad), 0) -def TransposeConvAttributeStartOutPadVector(builder, numElems): return builder.StartVector(4, numElems, 4) -def TransposeConvAttributeAddStride(builder, stride): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(stride), 0) -def TransposeConvAttributeStartStrideVector(builder, numElems): return builder.StartVector(4, numElems, 4) -def TransposeConvAttributeAddOutputShape(builder, outputShape): builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(outputShape), 0) -def TransposeConvAttributeStartOutputShapeVector(builder, numElems): return builder.StartVector(4, numElems, 4) -def TransposeConvAttributeAddInputZp(builder, inputZp): builder.PrependInt32Slot(3, inputZp, 0) -def TransposeConvAttributeAddWeightZp(builder, weightZp): builder.PrependInt32Slot(4, weightZp, 0) -def TransposeConvAttributeEnd(builder): return builder.EndObject() +def End(builder): + return TransposeConvAttributeEnd(builder) diff --git a/python/tosa/Version.py b/python/tosa/Version.py index 06c3ba3..369f356 100644 --- a/python/tosa/Version.py +++ b/python/tosa/Version.py @@ -10,13 +10,17 @@ class Version(object): __slots__ = ['_tab'] @classmethod - def GetRootAsVersion(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = Version() x.Init(buf, n + offset) return x @classmethod + def GetRootAsVersion(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def VersionBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x4F\x53\x41", size_prefixed=size_prefixed) @@ -25,36 +29,65 @@ class Version(object): self._tab = flatbuffers.table.Table(buf, pos) # Version - def _major(self): + def _Major(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 + return -1 # Version - def _minor(self): + def _Minor(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 31 + return -1 # Version - def _patch(self): + def _Patch(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 + return -1 # Version - def _draft(self): + def _Draft(self): o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) if o != 0: return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) return True -def VersionStart(builder): builder.StartObject(4) -def VersionAdd_major(builder, Major): builder.PrependInt32Slot(0, Major, 0) -def VersionAdd_minor(builder, Minor): builder.PrependInt32Slot(1, Minor, 31) -def VersionAdd_patch(builder, Patch): builder.PrependInt32Slot(2, Patch, 0) -def VersionAdd_draft(builder, Draft): builder.PrependBoolSlot(3, Draft, 1) -def VersionEnd(builder): return builder.EndObject() +def VersionStart(builder): + builder.StartObject(4) + +def Start(builder): + VersionStart(builder) + +def VersionAdd_Major(builder, _Major): + builder.PrependInt32Slot(0, _Major, -1) + +def Add_Major(builder, _Major): + VersionAdd_Major(builder, _Major) + +def VersionAdd_Minor(builder, _Minor): + builder.PrependInt32Slot(1, _Minor, -1) + +def Add_Minor(builder, _Minor): + VersionAdd_Minor(builder, _Minor) + +def VersionAdd_Patch(builder, _Patch): + builder.PrependInt32Slot(2, _Patch, -1) + +def Add_Patch(builder, _Patch): + VersionAdd_Patch(builder, _Patch) + +def VersionAdd_Draft(builder, _Draft): + builder.PrependBoolSlot(3, _Draft, 1) + +def Add_Draft(builder, _Draft): + VersionAdd_Draft(builder, _Draft) + +def VersionEnd(builder): + return builder.EndObject() + +def End(builder): + return VersionEnd(builder) diff --git a/python/tosa/WhileLoopAttribute.py b/python/tosa/WhileLoopAttribute.py index 1e18bca..5148c26 100644 --- a/python/tosa/WhileLoopAttribute.py +++ b/python/tosa/WhileLoopAttribute.py @@ -10,13 +10,17 @@ class WhileLoopAttribute(object): __slots__ = ['_tab'] @classmethod - def GetRootAsWhileLoopAttribute(cls, buf, offset): + def GetRootAs(cls, buf, offset=0): n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) x = WhileLoopAttribute() x.Init(buf, n + offset) return x @classmethod + def GetRootAsWhileLoopAttribute(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + @classmethod def WhileLoopAttributeBufferHasIdentifier(cls, buf, offset, size_prefixed=False): return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x4F\x53\x41", size_prefixed=size_prefixed) @@ -25,20 +29,39 @@ class WhileLoopAttribute(object): self._tab = flatbuffers.table.Table(buf, pos) # WhileLoopAttribute - def CondBranch(self): + def CondGraph(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 # WhileLoopAttribute - def BodyBranch(self): + def BodyGraph(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 WhileLoopAttributeStart(builder): builder.StartObject(2) -def WhileLoopAttributeAddCondBranch(builder, condBranch): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(condBranch), 0) -def WhileLoopAttributeAddBodyBranch(builder, bodyBranch): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(bodyBranch), 0) -def WhileLoopAttributeEnd(builder): return builder.EndObject() +def WhileLoopAttributeStart(builder): + builder.StartObject(2) + +def Start(builder): + WhileLoopAttributeStart(builder) + +def WhileLoopAttributeAddCondGraph(builder, condGraph): + builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(condGraph), 0) + +def AddCondGraph(builder, condGraph): + WhileLoopAttributeAddCondGraph(builder, condGraph) + +def WhileLoopAttributeAddBodyGraph(builder, bodyGraph): + builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(bodyGraph), 0) + +def AddBodyGraph(builder, bodyGraph): + WhileLoopAttributeAddBodyGraph(builder, bodyGraph) + +def WhileLoopAttributeEnd(builder): + return builder.EndObject() + +def End(builder): + return WhileLoopAttributeEnd(builder) |