diff --git a/.gitattributes b/.gitattributes index 43a34c076e592d4b4ac185d3584f03ecff1e2bb3..f5039f86821f1ac6ebae61871e4f1b9bf940e7b4 100644 --- a/.gitattributes +++ b/.gitattributes @@ -99,3 +99,5 @@ lib/python3.10/site-packages/av/video/format.cpython-310-x86_64-linux-gnu.so fil lib/python3.10/site-packages/av/sidedata/motionvectors.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text lib/python3.10/site-packages/av/audio/layout.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text lib/python3.10/site-packages/av/audio/plane.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text +lib/python3.10/site-packages/av/audio/stream.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text +lib/python3.10/site-packages/av/audio/codeccontext.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text diff --git a/lib/python3.10/site-packages/av/audio/codeccontext.cpython-310-x86_64-linux-gnu.so b/lib/python3.10/site-packages/av/audio/codeccontext.cpython-310-x86_64-linux-gnu.so new file mode 100644 index 0000000000000000000000000000000000000000..3508ecad9b167b165e27eb43c8f26684f2f942cb --- /dev/null +++ b/lib/python3.10/site-packages/av/audio/codeccontext.cpython-310-x86_64-linux-gnu.so @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:56e98e1b9aaa98cdcf6c85d76da63690770ce022816e0a3ce7d9740e874611a3 +size 453801 diff --git a/lib/python3.10/site-packages/av/audio/stream.cpython-310-x86_64-linux-gnu.so b/lib/python3.10/site-packages/av/audio/stream.cpython-310-x86_64-linux-gnu.so new file mode 100644 index 0000000000000000000000000000000000000000..e9927e1d42ee0f9b08e07a00cefabd47073f185e --- /dev/null +++ b/lib/python3.10/site-packages/av/audio/stream.cpython-310-x86_64-linux-gnu.so @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:eafde59e9c342c16da1eb2258d6a4d45b28731a489b566a8ce715f28db706b0b +size 453873 diff --git a/lib/python3.10/site-packages/tf2onnx/tflite/AddNOptions.py b/lib/python3.10/site-packages/tf2onnx/tflite/AddNOptions.py new file mode 100644 index 0000000000000000000000000000000000000000..cdfac950cb8e197e36cbfe1429d5fc94f00453a4 --- /dev/null +++ b/lib/python3.10/site-packages/tf2onnx/tflite/AddNOptions.py @@ -0,0 +1,30 @@ +# SPDX-License-Identifier: Apache-2.0 + +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: tflite + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class AddNOptions(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAsAddNOptions(cls, buf, offset): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = AddNOptions() + x.Init(buf, n + offset) + return x + + @classmethod + def AddNOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) + + # AddNOptions + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + +def AddNOptionsStart(builder): builder.StartObject(0) +def AddNOptionsEnd(builder): return builder.EndObject() diff --git a/lib/python3.10/site-packages/tf2onnx/tflite/AddOptions.py b/lib/python3.10/site-packages/tf2onnx/tflite/AddOptions.py new file mode 100644 index 0000000000000000000000000000000000000000..7a756766fefa3d5542392a0860dcadd433bf8419 --- /dev/null +++ b/lib/python3.10/site-packages/tf2onnx/tflite/AddOptions.py @@ -0,0 +1,46 @@ +# SPDX-License-Identifier: Apache-2.0 + +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: tflite + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class AddOptions(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAsAddOptions(cls, buf, offset): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = AddOptions() + x.Init(buf, n + offset) + return x + + @classmethod + def AddOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) + + # AddOptions + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # AddOptions + def FusedActivationFunction(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos) + return 0 + + # AddOptions + def PotScaleInt16(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 True + +def AddOptionsStart(builder): builder.StartObject(2) +def AddOptionsAddFusedActivationFunction(builder, fusedActivationFunction): builder.PrependInt8Slot(0, fusedActivationFunction, 0) +def AddOptionsAddPotScaleInt16(builder, potScaleInt16): builder.PrependBoolSlot(1, potScaleInt16, 1) +def AddOptionsEnd(builder): return builder.EndObject() diff --git a/lib/python3.10/site-packages/tf2onnx/tflite/ArgMaxOptions.py b/lib/python3.10/site-packages/tf2onnx/tflite/ArgMaxOptions.py new file mode 100644 index 0000000000000000000000000000000000000000..83b2217c1da5fe5151f1a9c3e32827ace50a9c02 --- /dev/null +++ b/lib/python3.10/site-packages/tf2onnx/tflite/ArgMaxOptions.py @@ -0,0 +1,38 @@ +# SPDX-License-Identifier: Apache-2.0 + +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: tflite + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class ArgMaxOptions(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAsArgMaxOptions(cls, buf, offset): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = ArgMaxOptions() + x.Init(buf, n + offset) + return x + + @classmethod + def ArgMaxOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) + + # ArgMaxOptions + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # ArgMaxOptions + def OutputType(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos) + return 0 + +def ArgMaxOptionsStart(builder): builder.StartObject(1) +def ArgMaxOptionsAddOutputType(builder, outputType): builder.PrependInt8Slot(0, outputType, 0) +def ArgMaxOptionsEnd(builder): return builder.EndObject() diff --git a/lib/python3.10/site-packages/tf2onnx/tflite/BatchMatMulOptions.py b/lib/python3.10/site-packages/tf2onnx/tflite/BatchMatMulOptions.py new file mode 100644 index 0000000000000000000000000000000000000000..f9eb75007c50325ae0de5e296861321251157991 --- /dev/null +++ b/lib/python3.10/site-packages/tf2onnx/tflite/BatchMatMulOptions.py @@ -0,0 +1,54 @@ +# SPDX-License-Identifier: Apache-2.0 + +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: tflite + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class BatchMatMulOptions(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAsBatchMatMulOptions(cls, buf, offset): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = BatchMatMulOptions() + x.Init(buf, n + offset) + return x + + @classmethod + def BatchMatMulOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) + + # BatchMatMulOptions + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # BatchMatMulOptions + def AdjX(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 + + # BatchMatMulOptions + def AdjY(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 + + # BatchMatMulOptions + def AsymmetricQuantizeInputs(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + if o != 0: + return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) + return False + +def BatchMatMulOptionsStart(builder): builder.StartObject(3) +def BatchMatMulOptionsAddAdjX(builder, adjX): builder.PrependBoolSlot(0, adjX, 0) +def BatchMatMulOptionsAddAdjY(builder, adjY): builder.PrependBoolSlot(1, adjY, 0) +def BatchMatMulOptionsAddAsymmetricQuantizeInputs(builder, asymmetricQuantizeInputs): builder.PrependBoolSlot(2, asymmetricQuantizeInputs, 0) +def BatchMatMulOptionsEnd(builder): return builder.EndObject() diff --git a/lib/python3.10/site-packages/tf2onnx/tflite/BatchToSpaceNDOptions.py b/lib/python3.10/site-packages/tf2onnx/tflite/BatchToSpaceNDOptions.py new file mode 100644 index 0000000000000000000000000000000000000000..4d6f82613e307fd5c0d1f634fbf23b3d05e5839f --- /dev/null +++ b/lib/python3.10/site-packages/tf2onnx/tflite/BatchToSpaceNDOptions.py @@ -0,0 +1,30 @@ +# SPDX-License-Identifier: Apache-2.0 + +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: tflite + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class BatchToSpaceNDOptions(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAsBatchToSpaceNDOptions(cls, buf, offset): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = BatchToSpaceNDOptions() + x.Init(buf, n + offset) + return x + + @classmethod + def BatchToSpaceNDOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) + + # BatchToSpaceNDOptions + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + +def BatchToSpaceNDOptionsStart(builder): builder.StartObject(0) +def BatchToSpaceNDOptionsEnd(builder): return builder.EndObject() diff --git a/lib/python3.10/site-packages/tf2onnx/tflite/BidirectionalSequenceLSTMOptions.py b/lib/python3.10/site-packages/tf2onnx/tflite/BidirectionalSequenceLSTMOptions.py new file mode 100644 index 0000000000000000000000000000000000000000..f168deb48309ac4c1e1d198ae9808c42f4b5662e --- /dev/null +++ b/lib/python3.10/site-packages/tf2onnx/tflite/BidirectionalSequenceLSTMOptions.py @@ -0,0 +1,78 @@ +# SPDX-License-Identifier: Apache-2.0 + +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: tflite + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class BidirectionalSequenceLSTMOptions(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAsBidirectionalSequenceLSTMOptions(cls, buf, offset): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = BidirectionalSequenceLSTMOptions() + x.Init(buf, n + offset) + return x + + @classmethod + def BidirectionalSequenceLSTMOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) + + # BidirectionalSequenceLSTMOptions + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # BidirectionalSequenceLSTMOptions + def FusedActivationFunction(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos) + return 0 + + # BidirectionalSequenceLSTMOptions + def CellClip(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 + + # BidirectionalSequenceLSTMOptions + def ProjClip(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 + + # BidirectionalSequenceLSTMOptions + def MergeOutputs(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 False + + # BidirectionalSequenceLSTMOptions + def TimeMajor(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 True + + # BidirectionalSequenceLSTMOptions + def AsymmetricQuantizeInputs(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 + +def BidirectionalSequenceLSTMOptionsStart(builder): builder.StartObject(6) +def BidirectionalSequenceLSTMOptionsAddFusedActivationFunction(builder, fusedActivationFunction): builder.PrependInt8Slot(0, fusedActivationFunction, 0) +def BidirectionalSequenceLSTMOptionsAddCellClip(builder, cellClip): builder.PrependFloat32Slot(1, cellClip, 0.0) +def BidirectionalSequenceLSTMOptionsAddProjClip(builder, projClip): builder.PrependFloat32Slot(2, projClip, 0.0) +def BidirectionalSequenceLSTMOptionsAddMergeOutputs(builder, mergeOutputs): builder.PrependBoolSlot(3, mergeOutputs, 0) +def BidirectionalSequenceLSTMOptionsAddTimeMajor(builder, timeMajor): builder.PrependBoolSlot(4, timeMajor, 1) +def BidirectionalSequenceLSTMOptionsAddAsymmetricQuantizeInputs(builder, asymmetricQuantizeInputs): builder.PrependBoolSlot(5, asymmetricQuantizeInputs, 0) +def BidirectionalSequenceLSTMOptionsEnd(builder): return builder.EndObject() diff --git a/lib/python3.10/site-packages/tf2onnx/tflite/BidirectionalSequenceRNNOptions.py b/lib/python3.10/site-packages/tf2onnx/tflite/BidirectionalSequenceRNNOptions.py new file mode 100644 index 0000000000000000000000000000000000000000..e1da0805b70ac72f5a29616c02b09867d4ea6f3d --- /dev/null +++ b/lib/python3.10/site-packages/tf2onnx/tflite/BidirectionalSequenceRNNOptions.py @@ -0,0 +1,62 @@ +# SPDX-License-Identifier: Apache-2.0 + +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: tflite + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class BidirectionalSequenceRNNOptions(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAsBidirectionalSequenceRNNOptions(cls, buf, offset): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = BidirectionalSequenceRNNOptions() + x.Init(buf, n + offset) + return x + + @classmethod + def BidirectionalSequenceRNNOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) + + # BidirectionalSequenceRNNOptions + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # BidirectionalSequenceRNNOptions + def TimeMajor(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 + + # BidirectionalSequenceRNNOptions + def FusedActivationFunction(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos) + return 0 + + # BidirectionalSequenceRNNOptions + def MergeOutputs(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + if o != 0: + return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) + return False + + # BidirectionalSequenceRNNOptions + def AsymmetricQuantizeInputs(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 False + +def BidirectionalSequenceRNNOptionsStart(builder): builder.StartObject(4) +def BidirectionalSequenceRNNOptionsAddTimeMajor(builder, timeMajor): builder.PrependBoolSlot(0, timeMajor, 0) +def BidirectionalSequenceRNNOptionsAddFusedActivationFunction(builder, fusedActivationFunction): builder.PrependInt8Slot(1, fusedActivationFunction, 0) +def BidirectionalSequenceRNNOptionsAddMergeOutputs(builder, mergeOutputs): builder.PrependBoolSlot(2, mergeOutputs, 0) +def BidirectionalSequenceRNNOptionsAddAsymmetricQuantizeInputs(builder, asymmetricQuantizeInputs): builder.PrependBoolSlot(3, asymmetricQuantizeInputs, 0) +def BidirectionalSequenceRNNOptionsEnd(builder): return builder.EndObject() diff --git a/lib/python3.10/site-packages/tf2onnx/tflite/Buffer.py b/lib/python3.10/site-packages/tf2onnx/tflite/Buffer.py new file mode 100644 index 0000000000000000000000000000000000000000..180e81d2f0e072ae0605924238fd7c5b1177cc95 --- /dev/null +++ b/lib/python3.10/site-packages/tf2onnx/tflite/Buffer.py @@ -0,0 +1,59 @@ +# SPDX-License-Identifier: Apache-2.0 + +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: tflite + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class Buffer(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAsBuffer(cls, buf, offset): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = Buffer() + x.Init(buf, n + offset) + return x + + @classmethod + def BufferBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) + + # Buffer + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # Buffer + def Data(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.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1)) + return 0 + + # Buffer + def DataAsNumpy(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 + + # Buffer + def DataLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + + # Buffer + def DataIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + return o == 0 + +def BufferStart(builder): builder.StartObject(1) +def BufferAddData(builder, data): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(data), 0) +def BufferStartDataVector(builder, numElems): return builder.StartVector(1, numElems, 1) +def BufferEnd(builder): return builder.EndObject() diff --git a/lib/python3.10/site-packages/tf2onnx/tflite/CallOnceOptions.py b/lib/python3.10/site-packages/tf2onnx/tflite/CallOnceOptions.py new file mode 100644 index 0000000000000000000000000000000000000000..730c9c3161d41f2f9a678c7967c8ce40eb6847e9 --- /dev/null +++ b/lib/python3.10/site-packages/tf2onnx/tflite/CallOnceOptions.py @@ -0,0 +1,38 @@ +# SPDX-License-Identifier: Apache-2.0 + +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: tflite + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class CallOnceOptions(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAsCallOnceOptions(cls, buf, offset): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = CallOnceOptions() + x.Init(buf, n + offset) + return x + + @classmethod + def CallOnceOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) + + # CallOnceOptions + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # CallOnceOptions + def InitSubgraphIndex(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 + +def CallOnceOptionsStart(builder): builder.StartObject(1) +def CallOnceOptionsAddInitSubgraphIndex(builder, initSubgraphIndex): builder.PrependInt32Slot(0, initSubgraphIndex, 0) +def CallOnceOptionsEnd(builder): return builder.EndObject() diff --git a/lib/python3.10/site-packages/tf2onnx/tflite/ConcatenationOptions.py b/lib/python3.10/site-packages/tf2onnx/tflite/ConcatenationOptions.py new file mode 100644 index 0000000000000000000000000000000000000000..6bc21e099503e3cbca89937a585e7723639aef2c --- /dev/null +++ b/lib/python3.10/site-packages/tf2onnx/tflite/ConcatenationOptions.py @@ -0,0 +1,46 @@ +# SPDX-License-Identifier: Apache-2.0 + +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: tflite + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class ConcatenationOptions(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAsConcatenationOptions(cls, buf, offset): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = ConcatenationOptions() + x.Init(buf, n + offset) + return x + + @classmethod + def ConcatenationOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) + + # ConcatenationOptions + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # ConcatenationOptions + def Axis(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 + + # ConcatenationOptions + def FusedActivationFunction(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos) + return 0 + +def ConcatenationOptionsStart(builder): builder.StartObject(2) +def ConcatenationOptionsAddAxis(builder, axis): builder.PrependInt32Slot(0, axis, 0) +def ConcatenationOptionsAddFusedActivationFunction(builder, fusedActivationFunction): builder.PrependInt8Slot(1, fusedActivationFunction, 0) +def ConcatenationOptionsEnd(builder): return builder.EndObject() diff --git a/lib/python3.10/site-packages/tf2onnx/tflite/CumsumOptions.py b/lib/python3.10/site-packages/tf2onnx/tflite/CumsumOptions.py new file mode 100644 index 0000000000000000000000000000000000000000..0bcfd228a1d0f8aecaa8469d8a2841a86e481a52 --- /dev/null +++ b/lib/python3.10/site-packages/tf2onnx/tflite/CumsumOptions.py @@ -0,0 +1,46 @@ +# SPDX-License-Identifier: Apache-2.0 + +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: tflite + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class CumsumOptions(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAsCumsumOptions(cls, buf, offset): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = CumsumOptions() + x.Init(buf, n + offset) + return x + + @classmethod + def CumsumOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) + + # CumsumOptions + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # CumsumOptions + def Exclusive(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 + + # CumsumOptions + def Reverse(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 CumsumOptionsStart(builder): builder.StartObject(2) +def CumsumOptionsAddExclusive(builder, exclusive): builder.PrependBoolSlot(0, exclusive, 0) +def CumsumOptionsAddReverse(builder, reverse): builder.PrependBoolSlot(1, reverse, 0) +def CumsumOptionsEnd(builder): return builder.EndObject() diff --git a/lib/python3.10/site-packages/tf2onnx/tflite/CustomOptionsFormat.py b/lib/python3.10/site-packages/tf2onnx/tflite/CustomOptionsFormat.py new file mode 100644 index 0000000000000000000000000000000000000000..33228701acc5e36831b065bf95b18d29294c576b --- /dev/null +++ b/lib/python3.10/site-packages/tf2onnx/tflite/CustomOptionsFormat.py @@ -0,0 +1,9 @@ +# SPDX-License-Identifier: Apache-2.0 + +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: tflite + +class CustomOptionsFormat(object): + FLEXBUFFERS = 0 + diff --git a/lib/python3.10/site-packages/tf2onnx/tflite/CustomQuantization.py b/lib/python3.10/site-packages/tf2onnx/tflite/CustomQuantization.py new file mode 100644 index 0000000000000000000000000000000000000000..3110f6f84d8ecded66b4eb3caaeafa626cf18936 --- /dev/null +++ b/lib/python3.10/site-packages/tf2onnx/tflite/CustomQuantization.py @@ -0,0 +1,59 @@ +# SPDX-License-Identifier: Apache-2.0 + +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: tflite + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class CustomQuantization(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAsCustomQuantization(cls, buf, offset): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = CustomQuantization() + x.Init(buf, n + offset) + return x + + @classmethod + def CustomQuantizationBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) + + # CustomQuantization + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # CustomQuantization + def Custom(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.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1)) + return 0 + + # CustomQuantization + def CustomAsNumpy(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 + + # CustomQuantization + def CustomLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + + # CustomQuantization + def CustomIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + return o == 0 + +def CustomQuantizationStart(builder): builder.StartObject(1) +def CustomQuantizationAddCustom(builder, custom): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(custom), 0) +def CustomQuantizationStartCustomVector(builder, numElems): return builder.StartVector(1, numElems, 1) +def CustomQuantizationEnd(builder): return builder.EndObject() diff --git a/lib/python3.10/site-packages/tf2onnx/tflite/DequantizeOptions.py b/lib/python3.10/site-packages/tf2onnx/tflite/DequantizeOptions.py new file mode 100644 index 0000000000000000000000000000000000000000..b03541719f4d3afd1265c6446afe2e4e31934f07 --- /dev/null +++ b/lib/python3.10/site-packages/tf2onnx/tflite/DequantizeOptions.py @@ -0,0 +1,30 @@ +# SPDX-License-Identifier: Apache-2.0 + +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: tflite + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class DequantizeOptions(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAsDequantizeOptions(cls, buf, offset): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = DequantizeOptions() + x.Init(buf, n + offset) + return x + + @classmethod + def DequantizeOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) + + # DequantizeOptions + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + +def DequantizeOptionsStart(builder): builder.StartObject(0) +def DequantizeOptionsEnd(builder): return builder.EndObject() diff --git a/lib/python3.10/site-packages/tf2onnx/tflite/DivOptions.py b/lib/python3.10/site-packages/tf2onnx/tflite/DivOptions.py new file mode 100644 index 0000000000000000000000000000000000000000..e8626c54557ae4877a5eb03218e24febdbdfd2cd --- /dev/null +++ b/lib/python3.10/site-packages/tf2onnx/tflite/DivOptions.py @@ -0,0 +1,38 @@ +# SPDX-License-Identifier: Apache-2.0 + +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: tflite + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class DivOptions(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAsDivOptions(cls, buf, offset): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = DivOptions() + x.Init(buf, n + offset) + return x + + @classmethod + def DivOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) + + # DivOptions + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # DivOptions + def FusedActivationFunction(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos) + return 0 + +def DivOptionsStart(builder): builder.StartObject(1) +def DivOptionsAddFusedActivationFunction(builder, fusedActivationFunction): builder.PrependInt8Slot(0, fusedActivationFunction, 0) +def DivOptionsEnd(builder): return builder.EndObject() diff --git a/lib/python3.10/site-packages/tf2onnx/tflite/EmbeddingLookupSparseOptions.py b/lib/python3.10/site-packages/tf2onnx/tflite/EmbeddingLookupSparseOptions.py new file mode 100644 index 0000000000000000000000000000000000000000..b4b6f56d4c3204dd3b34f7c13c48f309fe61ed42 --- /dev/null +++ b/lib/python3.10/site-packages/tf2onnx/tflite/EmbeddingLookupSparseOptions.py @@ -0,0 +1,38 @@ +# SPDX-License-Identifier: Apache-2.0 + +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: tflite + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class EmbeddingLookupSparseOptions(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAsEmbeddingLookupSparseOptions(cls, buf, offset): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = EmbeddingLookupSparseOptions() + x.Init(buf, n + offset) + return x + + @classmethod + def EmbeddingLookupSparseOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) + + # EmbeddingLookupSparseOptions + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # EmbeddingLookupSparseOptions + def Combiner(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos) + return 0 + +def EmbeddingLookupSparseOptionsStart(builder): builder.StartObject(1) +def EmbeddingLookupSparseOptionsAddCombiner(builder, combiner): builder.PrependInt8Slot(0, combiner, 0) +def EmbeddingLookupSparseOptionsEnd(builder): return builder.EndObject() diff --git a/lib/python3.10/site-packages/tf2onnx/tflite/EqualOptions.py b/lib/python3.10/site-packages/tf2onnx/tflite/EqualOptions.py new file mode 100644 index 0000000000000000000000000000000000000000..28d045d31667055d6dd96aa23bea96dba862781a --- /dev/null +++ b/lib/python3.10/site-packages/tf2onnx/tflite/EqualOptions.py @@ -0,0 +1,30 @@ +# SPDX-License-Identifier: Apache-2.0 + +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: tflite + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class EqualOptions(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAsEqualOptions(cls, buf, offset): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = EqualOptions() + x.Init(buf, n + offset) + return x + + @classmethod + def EqualOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) + + # EqualOptions + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + +def EqualOptionsStart(builder): builder.StartObject(0) +def EqualOptionsEnd(builder): return builder.EndObject() diff --git a/lib/python3.10/site-packages/tf2onnx/tflite/ExpandDimsOptions.py b/lib/python3.10/site-packages/tf2onnx/tflite/ExpandDimsOptions.py new file mode 100644 index 0000000000000000000000000000000000000000..bc14de0b741ffa03bf8e0c13f6df5cf4cb274368 --- /dev/null +++ b/lib/python3.10/site-packages/tf2onnx/tflite/ExpandDimsOptions.py @@ -0,0 +1,30 @@ +# SPDX-License-Identifier: Apache-2.0 + +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: tflite + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class ExpandDimsOptions(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAsExpandDimsOptions(cls, buf, offset): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = ExpandDimsOptions() + x.Init(buf, n + offset) + return x + + @classmethod + def ExpandDimsOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) + + # ExpandDimsOptions + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + +def ExpandDimsOptionsStart(builder): builder.StartObject(0) +def ExpandDimsOptionsEnd(builder): return builder.EndObject() diff --git a/lib/python3.10/site-packages/tf2onnx/tflite/FloorDivOptions.py b/lib/python3.10/site-packages/tf2onnx/tflite/FloorDivOptions.py new file mode 100644 index 0000000000000000000000000000000000000000..43565a1e50330b7937bee07afdcdd555ed8089cd --- /dev/null +++ b/lib/python3.10/site-packages/tf2onnx/tflite/FloorDivOptions.py @@ -0,0 +1,30 @@ +# SPDX-License-Identifier: Apache-2.0 + +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: tflite + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class FloorDivOptions(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAsFloorDivOptions(cls, buf, offset): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = FloorDivOptions() + x.Init(buf, n + offset) + return x + + @classmethod + def FloorDivOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) + + # FloorDivOptions + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + +def FloorDivOptionsStart(builder): builder.StartObject(0) +def FloorDivOptionsEnd(builder): return builder.EndObject() diff --git a/lib/python3.10/site-packages/tf2onnx/tflite/FloorModOptions.py b/lib/python3.10/site-packages/tf2onnx/tflite/FloorModOptions.py new file mode 100644 index 0000000000000000000000000000000000000000..9c431a486f6e44228aaba942576d18bf174abfa7 --- /dev/null +++ b/lib/python3.10/site-packages/tf2onnx/tflite/FloorModOptions.py @@ -0,0 +1,30 @@ +# SPDX-License-Identifier: Apache-2.0 + +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: tflite + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class FloorModOptions(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAsFloorModOptions(cls, buf, offset): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = FloorModOptions() + x.Init(buf, n + offset) + return x + + @classmethod + def FloorModOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) + + # FloorModOptions + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + +def FloorModOptionsStart(builder): builder.StartObject(0) +def FloorModOptionsEnd(builder): return builder.EndObject() diff --git a/lib/python3.10/site-packages/tf2onnx/tflite/FullyConnectedOptions.py b/lib/python3.10/site-packages/tf2onnx/tflite/FullyConnectedOptions.py new file mode 100644 index 0000000000000000000000000000000000000000..4fe3e91e1aa863e861cc2cda01bbe5ef094c1dfe --- /dev/null +++ b/lib/python3.10/site-packages/tf2onnx/tflite/FullyConnectedOptions.py @@ -0,0 +1,62 @@ +# SPDX-License-Identifier: Apache-2.0 + +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: tflite + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class FullyConnectedOptions(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAsFullyConnectedOptions(cls, buf, offset): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = FullyConnectedOptions() + x.Init(buf, n + offset) + return x + + @classmethod + def FullyConnectedOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) + + # FullyConnectedOptions + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # FullyConnectedOptions + def FusedActivationFunction(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos) + return 0 + + # FullyConnectedOptions + def WeightsFormat(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos) + return 0 + + # FullyConnectedOptions + def KeepNumDims(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + if o != 0: + return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) + return False + + # FullyConnectedOptions + def AsymmetricQuantizeInputs(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 False + +def FullyConnectedOptionsStart(builder): builder.StartObject(4) +def FullyConnectedOptionsAddFusedActivationFunction(builder, fusedActivationFunction): builder.PrependInt8Slot(0, fusedActivationFunction, 0) +def FullyConnectedOptionsAddWeightsFormat(builder, weightsFormat): builder.PrependInt8Slot(1, weightsFormat, 0) +def FullyConnectedOptionsAddKeepNumDims(builder, keepNumDims): builder.PrependBoolSlot(2, keepNumDims, 0) +def FullyConnectedOptionsAddAsymmetricQuantizeInputs(builder, asymmetricQuantizeInputs): builder.PrependBoolSlot(3, asymmetricQuantizeInputs, 0) +def FullyConnectedOptionsEnd(builder): return builder.EndObject() diff --git a/lib/python3.10/site-packages/tf2onnx/tflite/GatherNdOptions.py b/lib/python3.10/site-packages/tf2onnx/tflite/GatherNdOptions.py new file mode 100644 index 0000000000000000000000000000000000000000..71c6bf66d289be04b638607e104f33c3f0aa3b4d --- /dev/null +++ b/lib/python3.10/site-packages/tf2onnx/tflite/GatherNdOptions.py @@ -0,0 +1,30 @@ +# SPDX-License-Identifier: Apache-2.0 + +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: tflite + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class GatherNdOptions(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAsGatherNdOptions(cls, buf, offset): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = GatherNdOptions() + x.Init(buf, n + offset) + return x + + @classmethod + def GatherNdOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) + + # GatherNdOptions + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + +def GatherNdOptionsStart(builder): builder.StartObject(0) +def GatherNdOptionsEnd(builder): return builder.EndObject() diff --git a/lib/python3.10/site-packages/tf2onnx/tflite/GreaterEqualOptions.py b/lib/python3.10/site-packages/tf2onnx/tflite/GreaterEqualOptions.py new file mode 100644 index 0000000000000000000000000000000000000000..b0940f89e31631f8e06d133e7333cec5ff254226 --- /dev/null +++ b/lib/python3.10/site-packages/tf2onnx/tflite/GreaterEqualOptions.py @@ -0,0 +1,30 @@ +# SPDX-License-Identifier: Apache-2.0 + +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: tflite + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class GreaterEqualOptions(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAsGreaterEqualOptions(cls, buf, offset): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = GreaterEqualOptions() + x.Init(buf, n + offset) + return x + + @classmethod + def GreaterEqualOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) + + # GreaterEqualOptions + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + +def GreaterEqualOptionsStart(builder): builder.StartObject(0) +def GreaterEqualOptionsEnd(builder): return builder.EndObject() diff --git a/lib/python3.10/site-packages/tf2onnx/tflite/IfOptions.py b/lib/python3.10/site-packages/tf2onnx/tflite/IfOptions.py new file mode 100644 index 0000000000000000000000000000000000000000..81339f6b32ba63ca3030aefde4f36fa179abf1e6 --- /dev/null +++ b/lib/python3.10/site-packages/tf2onnx/tflite/IfOptions.py @@ -0,0 +1,46 @@ +# SPDX-License-Identifier: Apache-2.0 + +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: tflite + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class IfOptions(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAsIfOptions(cls, buf, offset): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = IfOptions() + x.Init(buf, n + offset) + return x + + @classmethod + def IfOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) + + # IfOptions + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # IfOptions + def ThenSubgraphIndex(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 + + # IfOptions + def ElseSubgraphIndex(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 IfOptionsStart(builder): builder.StartObject(2) +def IfOptionsAddThenSubgraphIndex(builder, thenSubgraphIndex): builder.PrependInt32Slot(0, thenSubgraphIndex, 0) +def IfOptionsAddElseSubgraphIndex(builder, elseSubgraphIndex): builder.PrependInt32Slot(1, elseSubgraphIndex, 0) +def IfOptionsEnd(builder): return builder.EndObject() diff --git a/lib/python3.10/site-packages/tf2onnx/tflite/L2NormOptions.py b/lib/python3.10/site-packages/tf2onnx/tflite/L2NormOptions.py new file mode 100644 index 0000000000000000000000000000000000000000..e2e39d9b47792b65ba87fc1b1e862cdb7c51b84c --- /dev/null +++ b/lib/python3.10/site-packages/tf2onnx/tflite/L2NormOptions.py @@ -0,0 +1,38 @@ +# SPDX-License-Identifier: Apache-2.0 + +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: tflite + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class L2NormOptions(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAsL2NormOptions(cls, buf, offset): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = L2NormOptions() + x.Init(buf, n + offset) + return x + + @classmethod + def L2NormOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) + + # L2NormOptions + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # L2NormOptions + def FusedActivationFunction(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos) + return 0 + +def L2NormOptionsStart(builder): builder.StartObject(1) +def L2NormOptionsAddFusedActivationFunction(builder, fusedActivationFunction): builder.PrependInt8Slot(0, fusedActivationFunction, 0) +def L2NormOptionsEnd(builder): return builder.EndObject() diff --git a/lib/python3.10/site-packages/tf2onnx/tflite/LSHProjectionOptions.py b/lib/python3.10/site-packages/tf2onnx/tflite/LSHProjectionOptions.py new file mode 100644 index 0000000000000000000000000000000000000000..edfd9d7796c0614451291109e58322afe8891768 --- /dev/null +++ b/lib/python3.10/site-packages/tf2onnx/tflite/LSHProjectionOptions.py @@ -0,0 +1,38 @@ +# SPDX-License-Identifier: Apache-2.0 + +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: tflite + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class LSHProjectionOptions(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAsLSHProjectionOptions(cls, buf, offset): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = LSHProjectionOptions() + x.Init(buf, n + offset) + return x + + @classmethod + def LSHProjectionOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) + + # LSHProjectionOptions + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # LSHProjectionOptions + def Type(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos) + return 0 + +def LSHProjectionOptionsStart(builder): builder.StartObject(1) +def LSHProjectionOptionsAddType(builder, type): builder.PrependInt8Slot(0, type, 0) +def LSHProjectionOptionsEnd(builder): return builder.EndObject() diff --git a/lib/python3.10/site-packages/tf2onnx/tflite/LSHProjectionType.py b/lib/python3.10/site-packages/tf2onnx/tflite/LSHProjectionType.py new file mode 100644 index 0000000000000000000000000000000000000000..77153c773ff8d38dbe88e4e7e7b64a6b37489a93 --- /dev/null +++ b/lib/python3.10/site-packages/tf2onnx/tflite/LSHProjectionType.py @@ -0,0 +1,11 @@ +# SPDX-License-Identifier: Apache-2.0 + +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: tflite + +class LSHProjectionType(object): + UNKNOWN = 0 + SPARSE = 1 + DENSE = 2 + diff --git a/lib/python3.10/site-packages/tf2onnx/tflite/LSTMKernelType.py b/lib/python3.10/site-packages/tf2onnx/tflite/LSTMKernelType.py new file mode 100644 index 0000000000000000000000000000000000000000..2a3697ed29d4f9912d8e783ac1378d2837ab101e --- /dev/null +++ b/lib/python3.10/site-packages/tf2onnx/tflite/LSTMKernelType.py @@ -0,0 +1,10 @@ +# SPDX-License-Identifier: Apache-2.0 + +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: tflite + +class LSTMKernelType(object): + FULL = 0 + BASIC = 1 + diff --git a/lib/python3.10/site-packages/tf2onnx/tflite/LSTMOptions.py b/lib/python3.10/site-packages/tf2onnx/tflite/LSTMOptions.py new file mode 100644 index 0000000000000000000000000000000000000000..4de2d0859af42fe1ab2d605d87949596c4618c06 --- /dev/null +++ b/lib/python3.10/site-packages/tf2onnx/tflite/LSTMOptions.py @@ -0,0 +1,70 @@ +# SPDX-License-Identifier: Apache-2.0 + +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: tflite + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class LSTMOptions(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAsLSTMOptions(cls, buf, offset): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = LSTMOptions() + x.Init(buf, n + offset) + return x + + @classmethod + def LSTMOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) + + # LSTMOptions + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # LSTMOptions + def FusedActivationFunction(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos) + return 0 + + # LSTMOptions + def CellClip(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 + + # LSTMOptions + def ProjClip(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 + + # LSTMOptions + def KernelType(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos) + return 0 + + # LSTMOptions + def AsymmetricQuantizeInputs(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 + +def LSTMOptionsStart(builder): builder.StartObject(5) +def LSTMOptionsAddFusedActivationFunction(builder, fusedActivationFunction): builder.PrependInt8Slot(0, fusedActivationFunction, 0) +def LSTMOptionsAddCellClip(builder, cellClip): builder.PrependFloat32Slot(1, cellClip, 0.0) +def LSTMOptionsAddProjClip(builder, projClip): builder.PrependFloat32Slot(2, projClip, 0.0) +def LSTMOptionsAddKernelType(builder, kernelType): builder.PrependInt8Slot(3, kernelType, 0) +def LSTMOptionsAddAsymmetricQuantizeInputs(builder, asymmetricQuantizeInputs): builder.PrependBoolSlot(4, asymmetricQuantizeInputs, 0) +def LSTMOptionsEnd(builder): return builder.EndObject() diff --git a/lib/python3.10/site-packages/tf2onnx/tflite/LeakyReluOptions.py b/lib/python3.10/site-packages/tf2onnx/tflite/LeakyReluOptions.py new file mode 100644 index 0000000000000000000000000000000000000000..7702dfa78e34c9ed58800555ea36e56f37ba9348 --- /dev/null +++ b/lib/python3.10/site-packages/tf2onnx/tflite/LeakyReluOptions.py @@ -0,0 +1,38 @@ +# SPDX-License-Identifier: Apache-2.0 + +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: tflite + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class LeakyReluOptions(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAsLeakyReluOptions(cls, buf, offset): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = LeakyReluOptions() + x.Init(buf, n + offset) + return x + + @classmethod + def LeakyReluOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) + + # LeakyReluOptions + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # LeakyReluOptions + def Alpha(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos) + return 0.0 + +def LeakyReluOptionsStart(builder): builder.StartObject(1) +def LeakyReluOptionsAddAlpha(builder, alpha): builder.PrependFloat32Slot(0, alpha, 0.0) +def LeakyReluOptionsEnd(builder): return builder.EndObject() diff --git a/lib/python3.10/site-packages/tf2onnx/tflite/LessOptions.py b/lib/python3.10/site-packages/tf2onnx/tflite/LessOptions.py new file mode 100644 index 0000000000000000000000000000000000000000..397caa54e93b0525c4fb890ae28d4a2a6dcd873e --- /dev/null +++ b/lib/python3.10/site-packages/tf2onnx/tflite/LessOptions.py @@ -0,0 +1,30 @@ +# SPDX-License-Identifier: Apache-2.0 + +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: tflite + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class LessOptions(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAsLessOptions(cls, buf, offset): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = LessOptions() + x.Init(buf, n + offset) + return x + + @classmethod + def LessOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) + + # LessOptions + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + +def LessOptionsStart(builder): builder.StartObject(0) +def LessOptionsEnd(builder): return builder.EndObject() diff --git a/lib/python3.10/site-packages/tf2onnx/tflite/LogSoftmaxOptions.py b/lib/python3.10/site-packages/tf2onnx/tflite/LogSoftmaxOptions.py new file mode 100644 index 0000000000000000000000000000000000000000..e1ed14d975f870e2b3c7be29f248bd6d0481ca76 --- /dev/null +++ b/lib/python3.10/site-packages/tf2onnx/tflite/LogSoftmaxOptions.py @@ -0,0 +1,30 @@ +# SPDX-License-Identifier: Apache-2.0 + +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: tflite + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class LogSoftmaxOptions(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAsLogSoftmaxOptions(cls, buf, offset): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = LogSoftmaxOptions() + x.Init(buf, n + offset) + return x + + @classmethod + def LogSoftmaxOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) + + # LogSoftmaxOptions + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + +def LogSoftmaxOptionsStart(builder): builder.StartObject(0) +def LogSoftmaxOptionsEnd(builder): return builder.EndObject() diff --git a/lib/python3.10/site-packages/tf2onnx/tflite/LogicalAndOptions.py b/lib/python3.10/site-packages/tf2onnx/tflite/LogicalAndOptions.py new file mode 100644 index 0000000000000000000000000000000000000000..2968b337ddc01409799f628d84b70e5f23aa10a4 --- /dev/null +++ b/lib/python3.10/site-packages/tf2onnx/tflite/LogicalAndOptions.py @@ -0,0 +1,30 @@ +# SPDX-License-Identifier: Apache-2.0 + +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: tflite + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class LogicalAndOptions(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAsLogicalAndOptions(cls, buf, offset): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = LogicalAndOptions() + x.Init(buf, n + offset) + return x + + @classmethod + def LogicalAndOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) + + # LogicalAndOptions + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + +def LogicalAndOptionsStart(builder): builder.StartObject(0) +def LogicalAndOptionsEnd(builder): return builder.EndObject() diff --git a/lib/python3.10/site-packages/tf2onnx/tflite/LogicalOrOptions.py b/lib/python3.10/site-packages/tf2onnx/tflite/LogicalOrOptions.py new file mode 100644 index 0000000000000000000000000000000000000000..87cc478f7e16972f0913b37c6eeb8c101775b8cd --- /dev/null +++ b/lib/python3.10/site-packages/tf2onnx/tflite/LogicalOrOptions.py @@ -0,0 +1,30 @@ +# SPDX-License-Identifier: Apache-2.0 + +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: tflite + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class LogicalOrOptions(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAsLogicalOrOptions(cls, buf, offset): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = LogicalOrOptions() + x.Init(buf, n + offset) + return x + + @classmethod + def LogicalOrOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) + + # LogicalOrOptions + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + +def LogicalOrOptionsStart(builder): builder.StartObject(0) +def LogicalOrOptionsEnd(builder): return builder.EndObject() diff --git a/lib/python3.10/site-packages/tf2onnx/tflite/MatrixDiagOptions.py b/lib/python3.10/site-packages/tf2onnx/tflite/MatrixDiagOptions.py new file mode 100644 index 0000000000000000000000000000000000000000..d41297a6a4efc9b4ee8acf803b94af661bf043fb --- /dev/null +++ b/lib/python3.10/site-packages/tf2onnx/tflite/MatrixDiagOptions.py @@ -0,0 +1,30 @@ +# SPDX-License-Identifier: Apache-2.0 + +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: tflite + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class MatrixDiagOptions(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAsMatrixDiagOptions(cls, buf, offset): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = MatrixDiagOptions() + x.Init(buf, n + offset) + return x + + @classmethod + def MatrixDiagOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) + + # MatrixDiagOptions + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + +def MatrixDiagOptionsStart(builder): builder.StartObject(0) +def MatrixDiagOptionsEnd(builder): return builder.EndObject() diff --git a/lib/python3.10/site-packages/tf2onnx/tflite/MatrixSetDiagOptions.py b/lib/python3.10/site-packages/tf2onnx/tflite/MatrixSetDiagOptions.py new file mode 100644 index 0000000000000000000000000000000000000000..ff187663f4f139c6a8ad626fbf9993b3fee698d8 --- /dev/null +++ b/lib/python3.10/site-packages/tf2onnx/tflite/MatrixSetDiagOptions.py @@ -0,0 +1,30 @@ +# SPDX-License-Identifier: Apache-2.0 + +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: tflite + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class MatrixSetDiagOptions(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAsMatrixSetDiagOptions(cls, buf, offset): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = MatrixSetDiagOptions() + x.Init(buf, n + offset) + return x + + @classmethod + def MatrixSetDiagOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) + + # MatrixSetDiagOptions + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + +def MatrixSetDiagOptionsStart(builder): builder.StartObject(0) +def MatrixSetDiagOptionsEnd(builder): return builder.EndObject() diff --git a/lib/python3.10/site-packages/tf2onnx/tflite/Metadata.py b/lib/python3.10/site-packages/tf2onnx/tflite/Metadata.py new file mode 100644 index 0000000000000000000000000000000000000000..99837e85c2b45d14a31137de7afd531c212712ce --- /dev/null +++ b/lib/python3.10/site-packages/tf2onnx/tflite/Metadata.py @@ -0,0 +1,46 @@ +# SPDX-License-Identifier: Apache-2.0 + +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: tflite + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class Metadata(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAsMetadata(cls, buf, offset): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = Metadata() + x.Init(buf, n + offset) + return x + + @classmethod + def MetadataBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) + + # Metadata + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # Metadata + 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 + + # Metadata + def Buffer(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos) + return 0 + +def MetadataStart(builder): builder.StartObject(2) +def MetadataAddName(builder, name): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0) +def MetadataAddBuffer(builder, buffer): builder.PrependUint32Slot(1, buffer, 0) +def MetadataEnd(builder): return builder.EndObject() diff --git a/lib/python3.10/site-packages/tf2onnx/tflite/MulOptions.py b/lib/python3.10/site-packages/tf2onnx/tflite/MulOptions.py new file mode 100644 index 0000000000000000000000000000000000000000..11b49ae8166b3fde0a10937dd1c873cb4b1728b7 --- /dev/null +++ b/lib/python3.10/site-packages/tf2onnx/tflite/MulOptions.py @@ -0,0 +1,38 @@ +# SPDX-License-Identifier: Apache-2.0 + +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: tflite + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class MulOptions(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAsMulOptions(cls, buf, offset): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = MulOptions() + x.Init(buf, n + offset) + return x + + @classmethod + def MulOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) + + # MulOptions + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # MulOptions + def FusedActivationFunction(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos) + return 0 + +def MulOptionsStart(builder): builder.StartObject(1) +def MulOptionsAddFusedActivationFunction(builder, fusedActivationFunction): builder.PrependInt8Slot(0, fusedActivationFunction, 0) +def MulOptionsEnd(builder): return builder.EndObject() diff --git a/lib/python3.10/site-packages/tf2onnx/tflite/NegOptions.py b/lib/python3.10/site-packages/tf2onnx/tflite/NegOptions.py new file mode 100644 index 0000000000000000000000000000000000000000..06758dc144d3dd13445958391f9001ec35abe4ac --- /dev/null +++ b/lib/python3.10/site-packages/tf2onnx/tflite/NegOptions.py @@ -0,0 +1,30 @@ +# SPDX-License-Identifier: Apache-2.0 + +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: tflite + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class NegOptions(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAsNegOptions(cls, buf, offset): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = NegOptions() + x.Init(buf, n + offset) + return x + + @classmethod + def NegOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) + + # NegOptions + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + +def NegOptionsStart(builder): builder.StartObject(0) +def NegOptionsEnd(builder): return builder.EndObject() diff --git a/lib/python3.10/site-packages/tf2onnx/tflite/NonMaxSuppressionV4Options.py b/lib/python3.10/site-packages/tf2onnx/tflite/NonMaxSuppressionV4Options.py new file mode 100644 index 0000000000000000000000000000000000000000..72a2ab53e61f2a51c5e0bcf4a76a6a4fc3f65589 --- /dev/null +++ b/lib/python3.10/site-packages/tf2onnx/tflite/NonMaxSuppressionV4Options.py @@ -0,0 +1,30 @@ +# SPDX-License-Identifier: Apache-2.0 + +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: tflite + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class NonMaxSuppressionV4Options(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAsNonMaxSuppressionV4Options(cls, buf, offset): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = NonMaxSuppressionV4Options() + x.Init(buf, n + offset) + return x + + @classmethod + def NonMaxSuppressionV4OptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) + + # NonMaxSuppressionV4Options + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + +def NonMaxSuppressionV4OptionsStart(builder): builder.StartObject(0) +def NonMaxSuppressionV4OptionsEnd(builder): return builder.EndObject() diff --git a/lib/python3.10/site-packages/tf2onnx/tflite/OneHotOptions.py b/lib/python3.10/site-packages/tf2onnx/tflite/OneHotOptions.py new file mode 100644 index 0000000000000000000000000000000000000000..ac345a1666d3d3a5903bd84878307ddc67702892 --- /dev/null +++ b/lib/python3.10/site-packages/tf2onnx/tflite/OneHotOptions.py @@ -0,0 +1,38 @@ +# SPDX-License-Identifier: Apache-2.0 + +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: tflite + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class OneHotOptions(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAsOneHotOptions(cls, buf, offset): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = OneHotOptions() + x.Init(buf, n + offset) + return x + + @classmethod + def OneHotOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) + + # OneHotOptions + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # OneHotOptions + def Axis(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 + +def OneHotOptionsStart(builder): builder.StartObject(1) +def OneHotOptionsAddAxis(builder, axis): builder.PrependInt32Slot(0, axis, 0) +def OneHotOptionsEnd(builder): return builder.EndObject() diff --git a/lib/python3.10/site-packages/tf2onnx/tflite/Operator.py b/lib/python3.10/site-packages/tf2onnx/tflite/Operator.py new file mode 100644 index 0000000000000000000000000000000000000000..e23254a57d55d40b22c1fbfabde56c3a063eb5d2 --- /dev/null +++ b/lib/python3.10/site-packages/tf2onnx/tflite/Operator.py @@ -0,0 +1,210 @@ +# SPDX-License-Identifier: Apache-2.0 + +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: tflite + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class Operator(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAsOperator(cls, buf, offset): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = Operator() + x.Init(buf, n + offset) + return x + + @classmethod + def OperatorBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) + + # Operator + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # Operator + def OpcodeIndex(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos) + return 0 + + # Operator + def Inputs(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 + + # Operator + def InputsAsNumpy(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 + + # Operator + def InputsLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + + # Operator + def InputsIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + return o == 0 + + # Operator + def Outputs(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 + + # Operator + def OutputsAsNumpy(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 + + # Operator + def OutputsLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + + # Operator + def OutputsIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + return o == 0 + + # Operator + def BuiltinOptionsType(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos) + return 0 + + # Operator + def BuiltinOptions(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) + if o != 0: + from flatbuffers.table import Table + obj = Table(bytearray(), 0) + self._tab.Union(obj, o) + return obj + return None + + # Operator + def CustomOptions(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.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1)) + return 0 + + # Operator + def CustomOptionsAsNumpy(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14)) + if o != 0: + return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o) + return 0 + + # Operator + def CustomOptionsLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + + # Operator + def CustomOptionsIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14)) + return o == 0 + + # Operator + def CustomOptionsFormat(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos) + return 0 + + # Operator + def MutatingVariableInputs(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18)) + if o != 0: + a = self._tab.Vector(o) + return self._tab.Get(flatbuffers.number_types.BoolFlags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1)) + return 0 + + # Operator + def MutatingVariableInputsAsNumpy(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18)) + if o != 0: + return self._tab.GetVectorAsNumpy(flatbuffers.number_types.BoolFlags, o) + return 0 + + # Operator + def MutatingVariableInputsLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + + # Operator + def MutatingVariableInputsIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18)) + return o == 0 + + # Operator + def Intermediates(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20)) + if o != 0: + a = self._tab.Vector(o) + return self._tab.Get(flatbuffers.number_types.Int32Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4)) + return 0 + + # Operator + def IntermediatesAsNumpy(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20)) + if o != 0: + return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int32Flags, o) + return 0 + + # Operator + def IntermediatesLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + + # Operator + def IntermediatesIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20)) + return o == 0 + +def OperatorStart(builder): builder.StartObject(9) +def OperatorAddOpcodeIndex(builder, opcodeIndex): builder.PrependUint32Slot(0, opcodeIndex, 0) +def OperatorAddInputs(builder, inputs): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(inputs), 0) +def OperatorStartInputsVector(builder, numElems): return builder.StartVector(4, numElems, 4) +def OperatorAddOutputs(builder, outputs): builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(outputs), 0) +def OperatorStartOutputsVector(builder, numElems): return builder.StartVector(4, numElems, 4) +def OperatorAddBuiltinOptionsType(builder, builtinOptionsType): builder.PrependUint8Slot(3, builtinOptionsType, 0) +def OperatorAddBuiltinOptions(builder, builtinOptions): builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(builtinOptions), 0) +def OperatorAddCustomOptions(builder, customOptions): builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(customOptions), 0) +def OperatorStartCustomOptionsVector(builder, numElems): return builder.StartVector(1, numElems, 1) +def OperatorAddCustomOptionsFormat(builder, customOptionsFormat): builder.PrependInt8Slot(6, customOptionsFormat, 0) +def OperatorAddMutatingVariableInputs(builder, mutatingVariableInputs): builder.PrependUOffsetTRelativeSlot(7, flatbuffers.number_types.UOffsetTFlags.py_type(mutatingVariableInputs), 0) +def OperatorStartMutatingVariableInputsVector(builder, numElems): return builder.StartVector(1, numElems, 1) +def OperatorAddIntermediates(builder, intermediates): builder.PrependUOffsetTRelativeSlot(8, flatbuffers.number_types.UOffsetTFlags.py_type(intermediates), 0) +def OperatorStartIntermediatesVector(builder, numElems): return builder.StartVector(4, numElems, 4) +def OperatorEnd(builder): return builder.EndObject() diff --git a/lib/python3.10/site-packages/tf2onnx/tflite/PackOptions.py b/lib/python3.10/site-packages/tf2onnx/tflite/PackOptions.py new file mode 100644 index 0000000000000000000000000000000000000000..5e8f8b39b0262957a9da4473958cd9fc3e3c8d45 --- /dev/null +++ b/lib/python3.10/site-packages/tf2onnx/tflite/PackOptions.py @@ -0,0 +1,46 @@ +# SPDX-License-Identifier: Apache-2.0 + +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: tflite + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class PackOptions(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAsPackOptions(cls, buf, offset): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = PackOptions() + x.Init(buf, n + offset) + return x + + @classmethod + def PackOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) + + # PackOptions + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # PackOptions + def ValuesCount(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 + + # PackOptions + def Axis(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 PackOptionsStart(builder): builder.StartObject(2) +def PackOptionsAddValuesCount(builder, valuesCount): builder.PrependInt32Slot(0, valuesCount, 0) +def PackOptionsAddAxis(builder, axis): builder.PrependInt32Slot(1, axis, 0) +def PackOptionsEnd(builder): return builder.EndObject() diff --git a/lib/python3.10/site-packages/tf2onnx/tflite/PadOptions.py b/lib/python3.10/site-packages/tf2onnx/tflite/PadOptions.py new file mode 100644 index 0000000000000000000000000000000000000000..f32627914729b3e59f05e1239c0c2febfac96c0b --- /dev/null +++ b/lib/python3.10/site-packages/tf2onnx/tflite/PadOptions.py @@ -0,0 +1,30 @@ +# SPDX-License-Identifier: Apache-2.0 + +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: tflite + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class PadOptions(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAsPadOptions(cls, buf, offset): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = PadOptions() + x.Init(buf, n + offset) + return x + + @classmethod + def PadOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) + + # PadOptions + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + +def PadOptionsStart(builder): builder.StartObject(0) +def PadOptionsEnd(builder): return builder.EndObject() diff --git a/lib/python3.10/site-packages/tf2onnx/tflite/PadV2Options.py b/lib/python3.10/site-packages/tf2onnx/tflite/PadV2Options.py new file mode 100644 index 0000000000000000000000000000000000000000..c628c65cff1d1d2f95997eded3b268a13e5a5bfe --- /dev/null +++ b/lib/python3.10/site-packages/tf2onnx/tflite/PadV2Options.py @@ -0,0 +1,30 @@ +# SPDX-License-Identifier: Apache-2.0 + +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: tflite + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class PadV2Options(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAsPadV2Options(cls, buf, offset): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = PadV2Options() + x.Init(buf, n + offset) + return x + + @classmethod + def PadV2OptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) + + # PadV2Options + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + +def PadV2OptionsStart(builder): builder.StartObject(0) +def PadV2OptionsEnd(builder): return builder.EndObject() diff --git a/lib/python3.10/site-packages/tf2onnx/tflite/RNNOptions.py b/lib/python3.10/site-packages/tf2onnx/tflite/RNNOptions.py new file mode 100644 index 0000000000000000000000000000000000000000..8bb10fde0388474b2ccaedabfdcc914c9b4e5aef --- /dev/null +++ b/lib/python3.10/site-packages/tf2onnx/tflite/RNNOptions.py @@ -0,0 +1,46 @@ +# SPDX-License-Identifier: Apache-2.0 + +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: tflite + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class RNNOptions(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAsRNNOptions(cls, buf, offset): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = RNNOptions() + x.Init(buf, n + offset) + return x + + @classmethod + def RNNOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) + + # RNNOptions + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # RNNOptions + def FusedActivationFunction(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos) + return 0 + + # RNNOptions + def AsymmetricQuantizeInputs(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 RNNOptionsStart(builder): builder.StartObject(2) +def RNNOptionsAddFusedActivationFunction(builder, fusedActivationFunction): builder.PrependInt8Slot(0, fusedActivationFunction, 0) +def RNNOptionsAddAsymmetricQuantizeInputs(builder, asymmetricQuantizeInputs): builder.PrependBoolSlot(1, asymmetricQuantizeInputs, 0) +def RNNOptionsEnd(builder): return builder.EndObject() diff --git a/lib/python3.10/site-packages/tf2onnx/tflite/RangeOptions.py b/lib/python3.10/site-packages/tf2onnx/tflite/RangeOptions.py new file mode 100644 index 0000000000000000000000000000000000000000..098553650cd3388797cb8317d26e840a203495f4 --- /dev/null +++ b/lib/python3.10/site-packages/tf2onnx/tflite/RangeOptions.py @@ -0,0 +1,30 @@ +# SPDX-License-Identifier: Apache-2.0 + +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: tflite + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class RangeOptions(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAsRangeOptions(cls, buf, offset): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = RangeOptions() + x.Init(buf, n + offset) + return x + + @classmethod + def RangeOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) + + # RangeOptions + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + +def RangeOptionsStart(builder): builder.StartObject(0) +def RangeOptionsEnd(builder): return builder.EndObject() diff --git a/lib/python3.10/site-packages/tf2onnx/tflite/RankOptions.py b/lib/python3.10/site-packages/tf2onnx/tflite/RankOptions.py new file mode 100644 index 0000000000000000000000000000000000000000..a51bc760d93653ccc2dfadef363b7bf1b6a0a4c3 --- /dev/null +++ b/lib/python3.10/site-packages/tf2onnx/tflite/RankOptions.py @@ -0,0 +1,30 @@ +# SPDX-License-Identifier: Apache-2.0 + +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: tflite + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class RankOptions(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAsRankOptions(cls, buf, offset): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = RankOptions() + x.Init(buf, n + offset) + return x + + @classmethod + def RankOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) + + # RankOptions + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + +def RankOptionsStart(builder): builder.StartObject(0) +def RankOptionsEnd(builder): return builder.EndObject() diff --git a/lib/python3.10/site-packages/tf2onnx/tflite/ReducerOptions.py b/lib/python3.10/site-packages/tf2onnx/tflite/ReducerOptions.py new file mode 100644 index 0000000000000000000000000000000000000000..d2ad0848db940ce3bf7efc04618e3f18a20a4eb0 --- /dev/null +++ b/lib/python3.10/site-packages/tf2onnx/tflite/ReducerOptions.py @@ -0,0 +1,38 @@ +# SPDX-License-Identifier: Apache-2.0 + +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: tflite + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class ReducerOptions(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAsReducerOptions(cls, buf, offset): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = ReducerOptions() + x.Init(buf, n + offset) + return x + + @classmethod + def ReducerOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) + + # ReducerOptions + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # ReducerOptions + def KeepDims(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 ReducerOptionsStart(builder): builder.StartObject(1) +def ReducerOptionsAddKeepDims(builder, keepDims): builder.PrependBoolSlot(0, keepDims, 0) +def ReducerOptionsEnd(builder): return builder.EndObject() diff --git a/lib/python3.10/site-packages/tf2onnx/tflite/ResizeBilinearOptions.py b/lib/python3.10/site-packages/tf2onnx/tflite/ResizeBilinearOptions.py new file mode 100644 index 0000000000000000000000000000000000000000..d1a410c7e8ad90ad9953ee8a7c11436848c0ea0e --- /dev/null +++ b/lib/python3.10/site-packages/tf2onnx/tflite/ResizeBilinearOptions.py @@ -0,0 +1,46 @@ +# SPDX-License-Identifier: Apache-2.0 + +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: tflite + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class ResizeBilinearOptions(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAsResizeBilinearOptions(cls, buf, offset): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = ResizeBilinearOptions() + x.Init(buf, n + offset) + return x + + @classmethod + def ResizeBilinearOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) + + # ResizeBilinearOptions + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # ResizeBilinearOptions + def AlignCorners(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + if o != 0: + return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) + return False + + # ResizeBilinearOptions + def HalfPixelCenters(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 False + +def ResizeBilinearOptionsStart(builder): builder.StartObject(4) +def ResizeBilinearOptionsAddAlignCorners(builder, alignCorners): builder.PrependBoolSlot(2, alignCorners, 0) +def ResizeBilinearOptionsAddHalfPixelCenters(builder, halfPixelCenters): builder.PrependBoolSlot(3, halfPixelCenters, 0) +def ResizeBilinearOptionsEnd(builder): return builder.EndObject() diff --git a/lib/python3.10/site-packages/tf2onnx/tflite/ReverseV2Options.py b/lib/python3.10/site-packages/tf2onnx/tflite/ReverseV2Options.py new file mode 100644 index 0000000000000000000000000000000000000000..bd3b5e96b202fb100fed5fdd3ebce38c608ed855 --- /dev/null +++ b/lib/python3.10/site-packages/tf2onnx/tflite/ReverseV2Options.py @@ -0,0 +1,30 @@ +# SPDX-License-Identifier: Apache-2.0 + +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: tflite + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class ReverseV2Options(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAsReverseV2Options(cls, buf, offset): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = ReverseV2Options() + x.Init(buf, n + offset) + return x + + @classmethod + def ReverseV2OptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) + + # ReverseV2Options + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + +def ReverseV2OptionsStart(builder): builder.StartObject(0) +def ReverseV2OptionsEnd(builder): return builder.EndObject() diff --git a/lib/python3.10/site-packages/tf2onnx/tflite/Rfft2dOptions.py b/lib/python3.10/site-packages/tf2onnx/tflite/Rfft2dOptions.py new file mode 100644 index 0000000000000000000000000000000000000000..d4f07fda2490c8a9cf08d0a3786edfe7bd756aee --- /dev/null +++ b/lib/python3.10/site-packages/tf2onnx/tflite/Rfft2dOptions.py @@ -0,0 +1,30 @@ +# SPDX-License-Identifier: Apache-2.0 + +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: tflite + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class Rfft2dOptions(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAsRfft2dOptions(cls, buf, offset): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = Rfft2dOptions() + x.Init(buf, n + offset) + return x + + @classmethod + def Rfft2dOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) + + # Rfft2dOptions + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + +def Rfft2dOptionsStart(builder): builder.StartObject(0) +def Rfft2dOptionsEnd(builder): return builder.EndObject() diff --git a/lib/python3.10/site-packages/tf2onnx/tflite/SVDFOptions.py b/lib/python3.10/site-packages/tf2onnx/tflite/SVDFOptions.py new file mode 100644 index 0000000000000000000000000000000000000000..c5a8b616ef019ff99390e4a20563f9a3bdcd1d0d --- /dev/null +++ b/lib/python3.10/site-packages/tf2onnx/tflite/SVDFOptions.py @@ -0,0 +1,54 @@ +# SPDX-License-Identifier: Apache-2.0 + +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: tflite + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class SVDFOptions(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAsSVDFOptions(cls, buf, offset): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = SVDFOptions() + x.Init(buf, n + offset) + return x + + @classmethod + def SVDFOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) + + # SVDFOptions + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # SVDFOptions + def Rank(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 + + # SVDFOptions + def FusedActivationFunction(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos) + return 0 + + # SVDFOptions + def AsymmetricQuantizeInputs(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + if o != 0: + return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) + return False + +def SVDFOptionsStart(builder): builder.StartObject(3) +def SVDFOptionsAddRank(builder, rank): builder.PrependInt32Slot(0, rank, 0) +def SVDFOptionsAddFusedActivationFunction(builder, fusedActivationFunction): builder.PrependInt8Slot(1, fusedActivationFunction, 0) +def SVDFOptionsAddAsymmetricQuantizeInputs(builder, asymmetricQuantizeInputs): builder.PrependBoolSlot(2, asymmetricQuantizeInputs, 0) +def SVDFOptionsEnd(builder): return builder.EndObject() diff --git a/lib/python3.10/site-packages/tf2onnx/tflite/SelectOptions.py b/lib/python3.10/site-packages/tf2onnx/tflite/SelectOptions.py new file mode 100644 index 0000000000000000000000000000000000000000..a5a2b94b6b58369854d6f7196cc944920504d1c5 --- /dev/null +++ b/lib/python3.10/site-packages/tf2onnx/tflite/SelectOptions.py @@ -0,0 +1,30 @@ +# SPDX-License-Identifier: Apache-2.0 + +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: tflite + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class SelectOptions(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAsSelectOptions(cls, buf, offset): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = SelectOptions() + x.Init(buf, n + offset) + return x + + @classmethod + def SelectOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) + + # SelectOptions + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + +def SelectOptionsStart(builder): builder.StartObject(0) +def SelectOptionsEnd(builder): return builder.EndObject() diff --git a/lib/python3.10/site-packages/tf2onnx/tflite/ShapeOptions.py b/lib/python3.10/site-packages/tf2onnx/tflite/ShapeOptions.py new file mode 100644 index 0000000000000000000000000000000000000000..391469ed6888150110617485c3e690abb84e45c0 --- /dev/null +++ b/lib/python3.10/site-packages/tf2onnx/tflite/ShapeOptions.py @@ -0,0 +1,38 @@ +# SPDX-License-Identifier: Apache-2.0 + +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: tflite + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class ShapeOptions(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAsShapeOptions(cls, buf, offset): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = ShapeOptions() + x.Init(buf, n + offset) + return x + + @classmethod + def ShapeOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) + + # ShapeOptions + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # ShapeOptions + def OutType(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos) + return 0 + +def ShapeOptionsStart(builder): builder.StartObject(1) +def ShapeOptionsAddOutType(builder, outType): builder.PrependInt8Slot(0, outType, 0) +def ShapeOptionsEnd(builder): return builder.EndObject() diff --git a/lib/python3.10/site-packages/tf2onnx/tflite/SignatureDef.py b/lib/python3.10/site-packages/tf2onnx/tflite/SignatureDef.py new file mode 100644 index 0000000000000000000000000000000000000000..a7b117420181c7297afce9b4120d6c4686e00974 --- /dev/null +++ b/lib/python3.10/site-packages/tf2onnx/tflite/SignatureDef.py @@ -0,0 +1,100 @@ +# SPDX-License-Identifier: Apache-2.0 + +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: tflite + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class SignatureDef(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAsSignatureDef(cls, buf, offset): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = SignatureDef() + x.Init(buf, n + offset) + return x + + @classmethod + def SignatureDefBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) + + # SignatureDef + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # SignatureDef + def Inputs(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + x = self._tab.Vector(o) + x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4 + x = self._tab.Indirect(x) + from tf2onnx.tflite.TensorMap import TensorMap + obj = TensorMap() + obj.Init(self._tab.Bytes, x) + return obj + return None + + # SignatureDef + def InputsLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + + # SignatureDef + def InputsIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + return o == 0 + + # SignatureDef + def Outputs(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 tf2onnx.tflite.TensorMap import TensorMap + obj = TensorMap() + obj.Init(self._tab.Bytes, x) + return obj + return None + + # SignatureDef + def OutputsLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + + # SignatureDef + def OutputsIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + return o == 0 + + # SignatureDef + def MethodName(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + if o != 0: + return self._tab.String(o + self._tab.Pos) + return None + + # SignatureDef + def Key(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) + if o != 0: + return self._tab.String(o + self._tab.Pos) + return None + +def SignatureDefStart(builder): builder.StartObject(4) +def SignatureDefAddInputs(builder, inputs): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(inputs), 0) +def SignatureDefStartInputsVector(builder, numElems): return builder.StartVector(4, numElems, 4) +def SignatureDefAddOutputs(builder, outputs): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(outputs), 0) +def SignatureDefStartOutputsVector(builder, numElems): return builder.StartVector(4, numElems, 4) +def SignatureDefAddMethodName(builder, methodName): builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(methodName), 0) +def SignatureDefAddKey(builder, key): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(key), 0) +def SignatureDefEnd(builder): return builder.EndObject() diff --git a/lib/python3.10/site-packages/tf2onnx/tflite/SkipGramOptions.py b/lib/python3.10/site-packages/tf2onnx/tflite/SkipGramOptions.py new file mode 100644 index 0000000000000000000000000000000000000000..9ae727a83fa136bb4755c7ebffe5364b9b2ca180 --- /dev/null +++ b/lib/python3.10/site-packages/tf2onnx/tflite/SkipGramOptions.py @@ -0,0 +1,54 @@ +# SPDX-License-Identifier: Apache-2.0 + +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: tflite + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class SkipGramOptions(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAsSkipGramOptions(cls, buf, offset): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = SkipGramOptions() + x.Init(buf, n + offset) + return x + + @classmethod + def SkipGramOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) + + # SkipGramOptions + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # SkipGramOptions + def NgramSize(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 + + # SkipGramOptions + def MaxSkipSize(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 + + # SkipGramOptions + def IncludeAllNgrams(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + if o != 0: + return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) + return False + +def SkipGramOptionsStart(builder): builder.StartObject(3) +def SkipGramOptionsAddNgramSize(builder, ngramSize): builder.PrependInt32Slot(0, ngramSize, 0) +def SkipGramOptionsAddMaxSkipSize(builder, maxSkipSize): builder.PrependInt32Slot(1, maxSkipSize, 0) +def SkipGramOptionsAddIncludeAllNgrams(builder, includeAllNgrams): builder.PrependBoolSlot(2, includeAllNgrams, 0) +def SkipGramOptionsEnd(builder): return builder.EndObject() diff --git a/lib/python3.10/site-packages/tf2onnx/tflite/SliceOptions.py b/lib/python3.10/site-packages/tf2onnx/tflite/SliceOptions.py new file mode 100644 index 0000000000000000000000000000000000000000..68dd57db13197f48d544380d46c02d94c942f5fd --- /dev/null +++ b/lib/python3.10/site-packages/tf2onnx/tflite/SliceOptions.py @@ -0,0 +1,30 @@ +# SPDX-License-Identifier: Apache-2.0 + +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: tflite + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class SliceOptions(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAsSliceOptions(cls, buf, offset): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = SliceOptions() + x.Init(buf, n + offset) + return x + + @classmethod + def SliceOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) + + # SliceOptions + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + +def SliceOptionsStart(builder): builder.StartObject(0) +def SliceOptionsEnd(builder): return builder.EndObject() diff --git a/lib/python3.10/site-packages/tf2onnx/tflite/SoftmaxOptions.py b/lib/python3.10/site-packages/tf2onnx/tflite/SoftmaxOptions.py new file mode 100644 index 0000000000000000000000000000000000000000..4830fb4c2ae6ba7e825a55821bfccb385956e9f2 --- /dev/null +++ b/lib/python3.10/site-packages/tf2onnx/tflite/SoftmaxOptions.py @@ -0,0 +1,38 @@ +# SPDX-License-Identifier: Apache-2.0 + +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: tflite + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class SoftmaxOptions(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAsSoftmaxOptions(cls, buf, offset): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = SoftmaxOptions() + x.Init(buf, n + offset) + return x + + @classmethod + def SoftmaxOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) + + # SoftmaxOptions + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # SoftmaxOptions + def Beta(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos) + return 0.0 + +def SoftmaxOptionsStart(builder): builder.StartObject(1) +def SoftmaxOptionsAddBeta(builder, beta): builder.PrependFloat32Slot(0, beta, 0.0) +def SoftmaxOptionsEnd(builder): return builder.EndObject() diff --git a/lib/python3.10/site-packages/tf2onnx/tflite/SpaceToBatchNDOptions.py b/lib/python3.10/site-packages/tf2onnx/tflite/SpaceToBatchNDOptions.py new file mode 100644 index 0000000000000000000000000000000000000000..dd5e11c87ddaa28f0647ae7fb0e7cf754e6c432d --- /dev/null +++ b/lib/python3.10/site-packages/tf2onnx/tflite/SpaceToBatchNDOptions.py @@ -0,0 +1,30 @@ +# SPDX-License-Identifier: Apache-2.0 + +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: tflite + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class SpaceToBatchNDOptions(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAsSpaceToBatchNDOptions(cls, buf, offset): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = SpaceToBatchNDOptions() + x.Init(buf, n + offset) + return x + + @classmethod + def SpaceToBatchNDOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) + + # SpaceToBatchNDOptions + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + +def SpaceToBatchNDOptionsStart(builder): builder.StartObject(0) +def SpaceToBatchNDOptionsEnd(builder): return builder.EndObject() diff --git a/lib/python3.10/site-packages/tf2onnx/tflite/SpaceToDepthOptions.py b/lib/python3.10/site-packages/tf2onnx/tflite/SpaceToDepthOptions.py new file mode 100644 index 0000000000000000000000000000000000000000..c47f627042305f1da8c66280f63666de47e4bb80 --- /dev/null +++ b/lib/python3.10/site-packages/tf2onnx/tflite/SpaceToDepthOptions.py @@ -0,0 +1,38 @@ +# SPDX-License-Identifier: Apache-2.0 + +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: tflite + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class SpaceToDepthOptions(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAsSpaceToDepthOptions(cls, buf, offset): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = SpaceToDepthOptions() + x.Init(buf, n + offset) + return x + + @classmethod + def SpaceToDepthOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) + + # SpaceToDepthOptions + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # SpaceToDepthOptions + def BlockSize(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 + +def SpaceToDepthOptionsStart(builder): builder.StartObject(1) +def SpaceToDepthOptionsAddBlockSize(builder, blockSize): builder.PrependInt32Slot(0, blockSize, 0) +def SpaceToDepthOptionsEnd(builder): return builder.EndObject() diff --git a/lib/python3.10/site-packages/tf2onnx/tflite/SquareOptions.py b/lib/python3.10/site-packages/tf2onnx/tflite/SquareOptions.py new file mode 100644 index 0000000000000000000000000000000000000000..fd6fa4cac74a0a71505c5aad698b6d6491f6bf92 --- /dev/null +++ b/lib/python3.10/site-packages/tf2onnx/tflite/SquareOptions.py @@ -0,0 +1,30 @@ +# SPDX-License-Identifier: Apache-2.0 + +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: tflite + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class SquareOptions(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAsSquareOptions(cls, buf, offset): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = SquareOptions() + x.Init(buf, n + offset) + return x + + @classmethod + def SquareOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) + + # SquareOptions + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + +def SquareOptionsStart(builder): builder.StartObject(0) +def SquareOptionsEnd(builder): return builder.EndObject() diff --git a/lib/python3.10/site-packages/tf2onnx/tflite/SqueezeOptions.py b/lib/python3.10/site-packages/tf2onnx/tflite/SqueezeOptions.py new file mode 100644 index 0000000000000000000000000000000000000000..2068d58ec3a63ea4c64041a9da949192e96e4886 --- /dev/null +++ b/lib/python3.10/site-packages/tf2onnx/tflite/SqueezeOptions.py @@ -0,0 +1,59 @@ +# SPDX-License-Identifier: Apache-2.0 + +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: tflite + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class SqueezeOptions(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAsSqueezeOptions(cls, buf, offset): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = SqueezeOptions() + x.Init(buf, n + offset) + return x + + @classmethod + def SqueezeOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) + + # SqueezeOptions + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # SqueezeOptions + def SqueezeDims(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 + + # SqueezeOptions + def SqueezeDimsAsNumpy(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 + + # SqueezeOptions + def SqueezeDimsLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + + # SqueezeOptions + def SqueezeDimsIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + return o == 0 + +def SqueezeOptionsStart(builder): builder.StartObject(1) +def SqueezeOptionsAddSqueezeDims(builder, squeezeDims): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(squeezeDims), 0) +def SqueezeOptionsStartSqueezeDimsVector(builder, numElems): return builder.StartVector(4, numElems, 4) +def SqueezeOptionsEnd(builder): return builder.EndObject() diff --git a/lib/python3.10/site-packages/tf2onnx/tflite/SubGraph.py b/lib/python3.10/site-packages/tf2onnx/tflite/SubGraph.py new file mode 100644 index 0000000000000000000000000000000000000000..bf4e2c607454f7a29e3dcafec60797130ab4929d --- /dev/null +++ b/lib/python3.10/site-packages/tf2onnx/tflite/SubGraph.py @@ -0,0 +1,150 @@ +# SPDX-License-Identifier: Apache-2.0 + +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: tflite + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class SubGraph(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAsSubGraph(cls, buf, offset): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = SubGraph() + x.Init(buf, n + offset) + return x + + @classmethod + def SubGraphBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) + + # SubGraph + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # SubGraph + def Tensors(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + x = self._tab.Vector(o) + x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4 + x = self._tab.Indirect(x) + from tf2onnx.tflite.Tensor import Tensor + obj = Tensor() + obj.Init(self._tab.Bytes, x) + return obj + return None + + # SubGraph + def TensorsLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + + # SubGraph + def TensorsIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + return o == 0 + + # SubGraph + def Inputs(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 + + # SubGraph + def InputsAsNumpy(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 + + # SubGraph + def InputsLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + + # SubGraph + def InputsIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + return o == 0 + + # SubGraph + def Outputs(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 + + # SubGraph + def OutputsAsNumpy(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 + + # SubGraph + def OutputsLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + + # SubGraph + def OutputsIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + return o == 0 + + # SubGraph + def Operators(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) + if o != 0: + x = self._tab.Vector(o) + x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4 + x = self._tab.Indirect(x) + from tf2onnx.tflite.Operator import Operator + obj = Operator() + obj.Init(self._tab.Bytes, x) + return obj + return None + + # SubGraph + def OperatorsLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + + # SubGraph + def OperatorsIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) + return o == 0 + + # SubGraph + def Name(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) + if o != 0: + return self._tab.String(o + self._tab.Pos) + return None + +def SubGraphStart(builder): builder.StartObject(5) +def SubGraphAddTensors(builder, tensors): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(tensors), 0) +def SubGraphStartTensorsVector(builder, numElems): return builder.StartVector(4, numElems, 4) +def SubGraphAddInputs(builder, inputs): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(inputs), 0) +def SubGraphStartInputsVector(builder, numElems): return builder.StartVector(4, numElems, 4) +def SubGraphAddOutputs(builder, outputs): builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(outputs), 0) +def SubGraphStartOutputsVector(builder, numElems): return builder.StartVector(4, numElems, 4) +def SubGraphAddOperators(builder, operators): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(operators), 0) +def SubGraphStartOperatorsVector(builder, numElems): return builder.StartVector(4, numElems, 4) +def SubGraphAddName(builder, name): builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0) +def SubGraphEnd(builder): return builder.EndObject() diff --git a/lib/python3.10/site-packages/tf2onnx/tflite/Tensor.py b/lib/python3.10/site-packages/tf2onnx/tflite/Tensor.py new file mode 100644 index 0000000000000000000000000000000000000000..1f662375e746d8d9a9476cd915a5212f94da9d7d --- /dev/null +++ b/lib/python3.10/site-packages/tf2onnx/tflite/Tensor.py @@ -0,0 +1,144 @@ +# SPDX-License-Identifier: Apache-2.0 + +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: tflite + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class Tensor(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAsTensor(cls, buf, offset): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = Tensor() + x.Init(buf, n + offset) + return x + + @classmethod + def TensorBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) + + # Tensor + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # Tensor + def Shape(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 + + # Tensor + def ShapeAsNumpy(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 + + # Tensor + def ShapeLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + + # Tensor + def ShapeIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + return o == 0 + + # Tensor + def Type(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos) + return 0 + + # Tensor + def Buffer(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos) + return 0 + + # Tensor + def Name(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) + if o != 0: + return self._tab.String(o + self._tab.Pos) + return None + + # Tensor + def Quantization(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) + if o != 0: + x = self._tab.Indirect(o + self._tab.Pos) + from tf2onnx.tflite.QuantizationParameters import QuantizationParameters + obj = QuantizationParameters() + obj.Init(self._tab.Bytes, x) + return obj + return None + + # Tensor + def IsVariable(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 + + # Tensor + def Sparsity(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16)) + if o != 0: + x = self._tab.Indirect(o + self._tab.Pos) + from tf2onnx.tflite.SparsityParameters import SparsityParameters + obj = SparsityParameters() + obj.Init(self._tab.Bytes, x) + return obj + return None + + # Tensor + def ShapeSignature(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18)) + if o != 0: + a = self._tab.Vector(o) + return self._tab.Get(flatbuffers.number_types.Int32Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4)) + return 0 + + # Tensor + def ShapeSignatureAsNumpy(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18)) + if o != 0: + return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int32Flags, o) + return 0 + + # Tensor + def ShapeSignatureLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + + # Tensor + def ShapeSignatureIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18)) + return o == 0 + +def TensorStart(builder): builder.StartObject(8) +def TensorAddShape(builder, shape): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(shape), 0) +def TensorStartShapeVector(builder, numElems): return builder.StartVector(4, numElems, 4) +def TensorAddType(builder, type): builder.PrependInt8Slot(1, type, 0) +def TensorAddBuffer(builder, buffer): builder.PrependUint32Slot(2, buffer, 0) +def TensorAddName(builder, name): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0) +def TensorAddQuantization(builder, quantization): builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(quantization), 0) +def TensorAddIsVariable(builder, isVariable): builder.PrependBoolSlot(5, isVariable, 0) +def TensorAddSparsity(builder, sparsity): builder.PrependUOffsetTRelativeSlot(6, flatbuffers.number_types.UOffsetTFlags.py_type(sparsity), 0) +def TensorAddShapeSignature(builder, shapeSignature): builder.PrependUOffsetTRelativeSlot(7, flatbuffers.number_types.UOffsetTFlags.py_type(shapeSignature), 0) +def TensorStartShapeSignatureVector(builder, numElems): return builder.StartVector(4, numElems, 4) +def TensorEnd(builder): return builder.EndObject() diff --git a/lib/python3.10/site-packages/tf2onnx/tflite/TensorMap.py b/lib/python3.10/site-packages/tf2onnx/tflite/TensorMap.py new file mode 100644 index 0000000000000000000000000000000000000000..0129044c7dafc3e259b5e1ea6dba74f3385ad763 --- /dev/null +++ b/lib/python3.10/site-packages/tf2onnx/tflite/TensorMap.py @@ -0,0 +1,46 @@ +# SPDX-License-Identifier: Apache-2.0 + +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: tflite + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class TensorMap(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAsTensorMap(cls, buf, offset): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = TensorMap() + x.Init(buf, n + offset) + return x + + @classmethod + def TensorMapBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) + + # TensorMap + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # TensorMap + 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 + + # TensorMap + def TensorIndex(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos) + return 0 + +def TensorMapStart(builder): builder.StartObject(2) +def TensorMapAddName(builder, name): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0) +def TensorMapAddTensorIndex(builder, tensorIndex): builder.PrependUint32Slot(1, tensorIndex, 0) +def TensorMapEnd(builder): return builder.EndObject() diff --git a/lib/python3.10/site-packages/tf2onnx/tflite/TileOptions.py b/lib/python3.10/site-packages/tf2onnx/tflite/TileOptions.py new file mode 100644 index 0000000000000000000000000000000000000000..39c4db076ba88a3b6de2ffd260e5575c6e5c3fbf --- /dev/null +++ b/lib/python3.10/site-packages/tf2onnx/tflite/TileOptions.py @@ -0,0 +1,30 @@ +# SPDX-License-Identifier: Apache-2.0 + +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: tflite + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class TileOptions(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAsTileOptions(cls, buf, offset): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = TileOptions() + x.Init(buf, n + offset) + return x + + @classmethod + def TileOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) + + # TileOptions + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + +def TileOptionsStart(builder): builder.StartObject(0) +def TileOptionsEnd(builder): return builder.EndObject() diff --git a/lib/python3.10/site-packages/tf2onnx/tflite/Uint16Vector.py b/lib/python3.10/site-packages/tf2onnx/tflite/Uint16Vector.py new file mode 100644 index 0000000000000000000000000000000000000000..d616ca976400ba7fc3fc87cb3a8f7cebad815b6a --- /dev/null +++ b/lib/python3.10/site-packages/tf2onnx/tflite/Uint16Vector.py @@ -0,0 +1,59 @@ +# SPDX-License-Identifier: Apache-2.0 + +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: tflite + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class Uint16Vector(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAsUint16Vector(cls, buf, offset): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = Uint16Vector() + x.Init(buf, n + offset) + return x + + @classmethod + def Uint16VectorBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) + + # Uint16Vector + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # Uint16Vector + def Values(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.Uint16Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 2)) + return 0 + + # Uint16Vector + def ValuesAsNumpy(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint16Flags, o) + return 0 + + # Uint16Vector + def ValuesLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + + # Uint16Vector + def ValuesIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + return o == 0 + +def Uint16VectorStart(builder): builder.StartObject(1) +def Uint16VectorAddValues(builder, values): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(values), 0) +def Uint16VectorStartValuesVector(builder, numElems): return builder.StartVector(2, numElems, 2) +def Uint16VectorEnd(builder): return builder.EndObject() diff --git a/lib/python3.10/site-packages/tf2onnx/tflite/Uint8Vector.py b/lib/python3.10/site-packages/tf2onnx/tflite/Uint8Vector.py new file mode 100644 index 0000000000000000000000000000000000000000..aa5d8ff24046bbb052623c3f8c4ddd11fc761687 --- /dev/null +++ b/lib/python3.10/site-packages/tf2onnx/tflite/Uint8Vector.py @@ -0,0 +1,59 @@ +# SPDX-License-Identifier: Apache-2.0 + +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: tflite + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class Uint8Vector(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAsUint8Vector(cls, buf, offset): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = Uint8Vector() + x.Init(buf, n + offset) + return x + + @classmethod + def Uint8VectorBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) + + # Uint8Vector + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # Uint8Vector + def Values(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.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1)) + return 0 + + # Uint8Vector + def ValuesAsNumpy(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 + + # Uint8Vector + def ValuesLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + + # Uint8Vector + def ValuesIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + return o == 0 + +def Uint8VectorStart(builder): builder.StartObject(1) +def Uint8VectorAddValues(builder, values): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(values), 0) +def Uint8VectorStartValuesVector(builder, numElems): return builder.StartVector(1, numElems, 1) +def Uint8VectorEnd(builder): return builder.EndObject() diff --git a/lib/python3.10/site-packages/tf2onnx/tflite/UnidirectionalSequenceLSTMOptions.py b/lib/python3.10/site-packages/tf2onnx/tflite/UnidirectionalSequenceLSTMOptions.py new file mode 100644 index 0000000000000000000000000000000000000000..c34051bef68d3cb0673001f34b3fad46de9ab0d8 --- /dev/null +++ b/lib/python3.10/site-packages/tf2onnx/tflite/UnidirectionalSequenceLSTMOptions.py @@ -0,0 +1,70 @@ +# SPDX-License-Identifier: Apache-2.0 + +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: tflite + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class UnidirectionalSequenceLSTMOptions(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAsUnidirectionalSequenceLSTMOptions(cls, buf, offset): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = UnidirectionalSequenceLSTMOptions() + x.Init(buf, n + offset) + return x + + @classmethod + def UnidirectionalSequenceLSTMOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) + + # UnidirectionalSequenceLSTMOptions + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # UnidirectionalSequenceLSTMOptions + def FusedActivationFunction(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos) + return 0 + + # UnidirectionalSequenceLSTMOptions + def CellClip(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 + + # UnidirectionalSequenceLSTMOptions + def ProjClip(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 + + # UnidirectionalSequenceLSTMOptions + def TimeMajor(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 False + + # UnidirectionalSequenceLSTMOptions + def AsymmetricQuantizeInputs(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 + +def UnidirectionalSequenceLSTMOptionsStart(builder): builder.StartObject(5) +def UnidirectionalSequenceLSTMOptionsAddFusedActivationFunction(builder, fusedActivationFunction): builder.PrependInt8Slot(0, fusedActivationFunction, 0) +def UnidirectionalSequenceLSTMOptionsAddCellClip(builder, cellClip): builder.PrependFloat32Slot(1, cellClip, 0.0) +def UnidirectionalSequenceLSTMOptionsAddProjClip(builder, projClip): builder.PrependFloat32Slot(2, projClip, 0.0) +def UnidirectionalSequenceLSTMOptionsAddTimeMajor(builder, timeMajor): builder.PrependBoolSlot(3, timeMajor, 0) +def UnidirectionalSequenceLSTMOptionsAddAsymmetricQuantizeInputs(builder, asymmetricQuantizeInputs): builder.PrependBoolSlot(4, asymmetricQuantizeInputs, 0) +def UnidirectionalSequenceLSTMOptionsEnd(builder): return builder.EndObject() diff --git a/lib/python3.10/site-packages/tf2onnx/tflite/UniqueOptions.py b/lib/python3.10/site-packages/tf2onnx/tflite/UniqueOptions.py new file mode 100644 index 0000000000000000000000000000000000000000..d0b3068d2620cfc52abed1ccfe8fd3360ad0b540 --- /dev/null +++ b/lib/python3.10/site-packages/tf2onnx/tflite/UniqueOptions.py @@ -0,0 +1,38 @@ +# SPDX-License-Identifier: Apache-2.0 + +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: tflite + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class UniqueOptions(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAsUniqueOptions(cls, buf, offset): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = UniqueOptions() + x.Init(buf, n + offset) + return x + + @classmethod + def UniqueOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) + + # UniqueOptions + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # UniqueOptions + def IdxOutType(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos) + return 2 + +def UniqueOptionsStart(builder): builder.StartObject(1) +def UniqueOptionsAddIdxOutType(builder, idxOutType): builder.PrependInt8Slot(0, idxOutType, 2) +def UniqueOptionsEnd(builder): return builder.EndObject() diff --git a/lib/python3.10/site-packages/tf2onnx/tflite/UnpackOptions.py b/lib/python3.10/site-packages/tf2onnx/tflite/UnpackOptions.py new file mode 100644 index 0000000000000000000000000000000000000000..d0cbcbedf21025a5269edcc6f67aca1a233396fe --- /dev/null +++ b/lib/python3.10/site-packages/tf2onnx/tflite/UnpackOptions.py @@ -0,0 +1,46 @@ +# SPDX-License-Identifier: Apache-2.0 + +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: tflite + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class UnpackOptions(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAsUnpackOptions(cls, buf, offset): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = UnpackOptions() + x.Init(buf, n + offset) + return x + + @classmethod + def UnpackOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) + + # UnpackOptions + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # UnpackOptions + def Num(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 + + # UnpackOptions + def Axis(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 UnpackOptionsStart(builder): builder.StartObject(2) +def UnpackOptionsAddNum(builder, num): builder.PrependInt32Slot(0, num, 0) +def UnpackOptionsAddAxis(builder, axis): builder.PrependInt32Slot(1, axis, 0) +def UnpackOptionsEnd(builder): return builder.EndObject() diff --git a/lib/python3.10/site-packages/tf2onnx/tflite/WhereOptions.py b/lib/python3.10/site-packages/tf2onnx/tflite/WhereOptions.py new file mode 100644 index 0000000000000000000000000000000000000000..c802199e7e328c483480b133fc8e4df784b8e5d0 --- /dev/null +++ b/lib/python3.10/site-packages/tf2onnx/tflite/WhereOptions.py @@ -0,0 +1,30 @@ +# SPDX-License-Identifier: Apache-2.0 + +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: tflite + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class WhereOptions(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAsWhereOptions(cls, buf, offset): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = WhereOptions() + x.Init(buf, n + offset) + return x + + @classmethod + def WhereOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) + + # WhereOptions + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + +def WhereOptionsStart(builder): builder.StartObject(0) +def WhereOptionsEnd(builder): return builder.EndObject() diff --git a/lib/python3.10/site-packages/tf2onnx/tflite/ZerosLikeOptions.py b/lib/python3.10/site-packages/tf2onnx/tflite/ZerosLikeOptions.py new file mode 100644 index 0000000000000000000000000000000000000000..f0e90956c5948fa01c1dc41faab67549dd6ca997 --- /dev/null +++ b/lib/python3.10/site-packages/tf2onnx/tflite/ZerosLikeOptions.py @@ -0,0 +1,30 @@ +# SPDX-License-Identifier: Apache-2.0 + +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: tflite + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class ZerosLikeOptions(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAsZerosLikeOptions(cls, buf, offset): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = ZerosLikeOptions() + x.Init(buf, n + offset) + return x + + @classmethod + def ZerosLikeOptionsBufferHasIdentifier(cls, buf, offset, size_prefixed=False): + return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed) + + # ZerosLikeOptions + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + +def ZerosLikeOptionsStart(builder): builder.StartObject(0) +def ZerosLikeOptionsEnd(builder): return builder.EndObject() diff --git a/lib/python3.10/site-packages/tf2onnx/tflite/__init__.py b/lib/python3.10/site-packages/tf2onnx/tflite/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..db4392428f55e53f286a7409175786e591036454 --- /dev/null +++ b/lib/python3.10/site-packages/tf2onnx/tflite/__init__.py @@ -0,0 +1,2 @@ +# SPDX-License-Identifier: Apache-2.0 +