ai-edge-litert-nightly 2.0.4.dev20251024__cp39-cp39-macosx_12_0_arm64.whl → 2.0.4.dev20251102__cp39-cp39-macosx_12_0_arm64.whl

ai_edge_litert/__init__.py

@@ -1 +1 @@
-__version__ = "2.0.4.dev20251024"
+__version__ = "2.0.4.dev20251102"

ai_edge_litert/schema_py_generated.py

@@ -2451,8 +2451,15 @@ class Tensor(object):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
         return o == 0
 
+    # Tensor
+    def ExternalBuffer(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
+        return 0
+
 def TensorStart(builder):
-    builder.StartObject(10)
+    builder.StartObject(11)
 
 def TensorAddShape(builder, shape):
     builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(shape), 0)
@@ -2493,6 +2500,9 @@ def TensorAddVariantTensors(builder, variantTensors):
 def TensorStartVariantTensorsVector(builder, numElems):
     return builder.StartVector(4, numElems, 4)
 
+def TensorAddExternalBuffer(builder, externalBuffer):
+    builder.PrependUint32Slot(10, externalBuffer, 0)
+
 def TensorEnd(builder):
     return builder.EndObject()
 
@@ -2517,6 +2527,7 @@ class TensorT(object):
         shapeSignature = None,
         hasRank = False,
         variantTensors = None,
+        externalBuffer = 0,
     ):
         self.shape = shape  # type: Optional[List[int]]
         self.type = type  # type: int
@@ -2528,6 +2539,7 @@ class TensorT(object):
         self.shapeSignature = shapeSignature  # type: Optional[List[int]]
         self.hasRank = hasRank  # type: bool
         self.variantTensors = variantTensors  # type: Optional[List[VariantSubTypeT]]
+        self.externalBuffer = externalBuffer  # type: int
 
     @classmethod
     def InitFromBuf(cls, buf, pos):
@@ -2581,6 +2593,7 @@ class TensorT(object):
                 else:
                     variantSubType_ = VariantSubTypeT.InitFromObj(tensor.VariantTensors(i))
                     self.variantTensors.append(variantSubType_)
+        self.externalBuffer = tensor.ExternalBuffer()
 
     # TensorT
     def Pack(self, builder):
@@ -2631,6 +2644,7 @@ class TensorT(object):
         TensorAddHasRank(builder, self.hasRank)
         if self.variantTensors is not None:
             TensorAddVariantTensors(builder, variantTensors)
+        TensorAddExternalBuffer(builder, self.externalBuffer)
         tensor = TensorEnd(builder)
         return tensor
 
@@ -18504,6 +18518,228 @@ class BufferT(object):
         return buffer
 
 
+class ExternalBufferGroup(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = ExternalBufferGroup()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsExternalBufferGroup(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    @classmethod
+    def ExternalBufferGroupBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
+
+    # ExternalBufferGroup
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # ExternalBufferGroup
+    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
+
+def ExternalBufferGroupStart(builder):
+    builder.StartObject(1)
+
+def ExternalBufferGroupAddName(builder, name):
+    builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0)
+
+def ExternalBufferGroupEnd(builder):
+    return builder.EndObject()
+
+
+
+class ExternalBufferGroupT(object):
+
+    # ExternalBufferGroupT
+    def __init__(
+        self,
+        name = None,
+    ):
+        self.name = name  # type: Optional[str]
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        externalBufferGroup = ExternalBufferGroup()
+        externalBufferGroup.Init(buf, pos)
+        return cls.InitFromObj(externalBufferGroup)
+
+    @classmethod
+    def InitFromPackedBuf(cls, buf, pos=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos)
+        return cls.InitFromBuf(buf, pos+n)
+
+    @classmethod
+    def InitFromObj(cls, externalBufferGroup):
+        x = ExternalBufferGroupT()
+        x._UnPack(externalBufferGroup)
+        return x
+
+    # ExternalBufferGroupT
+    def _UnPack(self, externalBufferGroup):
+        if externalBufferGroup is None:
+            return
+        self.name = externalBufferGroup.Name()
+
+    # ExternalBufferGroupT
+    def Pack(self, builder):
+        if self.name is not None:
+            name = builder.CreateString(self.name)
+        ExternalBufferGroupStart(builder)
+        if self.name is not None:
+            ExternalBufferGroupAddName(builder, name)
+        externalBufferGroup = ExternalBufferGroupEnd(builder)
+        return externalBufferGroup
+
+
+class ExternalBuffer(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def GetRootAs(cls, buf, offset=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+        x = ExternalBuffer()
+        x.Init(buf, n + offset)
+        return x
+
+    @classmethod
+    def GetRootAsExternalBuffer(cls, buf, offset=0):
+        """This method is deprecated. Please switch to GetRootAs."""
+        return cls.GetRootAs(buf, offset)
+    @classmethod
+    def ExternalBufferBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
+        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x54\x46\x4C\x33", size_prefixed=size_prefixed)
+
+    # ExternalBuffer
+    def Init(self, buf, pos):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # ExternalBuffer
+    def Id(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
+
+    # ExternalBuffer
+    def Group(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
+
+    # ExternalBuffer
+    def Offset(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+    # ExternalBuffer
+    def Length(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
+        return 0
+
+    # ExternalBuffer
+    def Packing(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 ExternalBufferStart(builder):
+    builder.StartObject(5)
+
+def ExternalBufferAddId(builder, id):
+    builder.PrependUint32Slot(0, id, 0)
+
+def ExternalBufferAddGroup(builder, group):
+    builder.PrependUint32Slot(1, group, 0)
+
+def ExternalBufferAddOffset(builder, offset):
+    builder.PrependUint64Slot(2, offset, 0)
+
+def ExternalBufferAddLength(builder, length):
+    builder.PrependUint64Slot(3, length, 0)
+
+def ExternalBufferAddPacking(builder, packing):
+    builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(packing), 0)
+
+def ExternalBufferEnd(builder):
+    return builder.EndObject()
+
+
+
+class ExternalBufferT(object):
+
+    # ExternalBufferT
+    def __init__(
+        self,
+        id = 0,
+        group = 0,
+        offset = 0,
+        length = 0,
+        packing = None,
+    ):
+        self.id = id  # type: int
+        self.group = group  # type: int
+        self.offset = offset  # type: int
+        self.length = length  # type: int
+        self.packing = packing  # type: Optional[str]
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        externalBuffer = ExternalBuffer()
+        externalBuffer.Init(buf, pos)
+        return cls.InitFromObj(externalBuffer)
+
+    @classmethod
+    def InitFromPackedBuf(cls, buf, pos=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos)
+        return cls.InitFromBuf(buf, pos+n)
+
+    @classmethod
+    def InitFromObj(cls, externalBuffer):
+        x = ExternalBufferT()
+        x._UnPack(externalBuffer)
+        return x
+
+    # ExternalBufferT
+    def _UnPack(self, externalBuffer):
+        if externalBuffer is None:
+            return
+        self.id = externalBuffer.Id()
+        self.group = externalBuffer.Group()
+        self.offset = externalBuffer.Offset()
+        self.length = externalBuffer.Length()
+        self.packing = externalBuffer.Packing()
+
+    # ExternalBufferT
+    def Pack(self, builder):
+        if self.packing is not None:
+            packing = builder.CreateString(self.packing)
+        ExternalBufferStart(builder)
+        ExternalBufferAddId(builder, self.id)
+        ExternalBufferAddGroup(builder, self.group)
+        ExternalBufferAddOffset(builder, self.offset)
+        ExternalBufferAddLength(builder, self.length)
+        if self.packing is not None:
+            ExternalBufferAddPacking(builder, packing)
+        externalBuffer = ExternalBufferEnd(builder)
+        return externalBuffer
+
+
 class Metadata(object):
     __slots__ = ['_tab']
 
@@ -19082,8 +19318,56 @@ class Model(object):
         o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
         return o == 0
 
+    # Model
+    def ExternalBufferGroups(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
+        if o != 0:
+            x = self._tab.Vector(o)
+            x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
+            x = self._tab.Indirect(x)
+            obj = ExternalBufferGroup()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # Model
+    def ExternalBufferGroupsLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # Model
+    def ExternalBufferGroupsIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
+        return o == 0
+
+    # Model
+    def ExternalBuffers(self, j):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
+        if o != 0:
+            x = self._tab.Vector(o)
+            x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
+            x = self._tab.Indirect(x)
+            obj = ExternalBuffer()
+            obj.Init(self._tab.Bytes, x)
+            return obj
+        return None
+
+    # Model
+    def ExternalBuffersLength(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
+        if o != 0:
+            return self._tab.VectorLen(o)
+        return 0
+
+    # Model
+    def ExternalBuffersIsNone(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
+        return o == 0
+
 def ModelStart(builder):
-    builder.StartObject(8)
+    builder.StartObject(10)
 
 def ModelAddVersion(builder, version):
     builder.PrependUint32Slot(0, version, 0)
@@ -19127,6 +19411,18 @@ def ModelAddSignatureDefs(builder, signatureDefs):
 def ModelStartSignatureDefsVector(builder, numElems):
     return builder.StartVector(4, numElems, 4)
 
+def ModelAddExternalBufferGroups(builder, externalBufferGroups):
+    builder.PrependUOffsetTRelativeSlot(8, flatbuffers.number_types.UOffsetTFlags.py_type(externalBufferGroups), 0)
+
+def ModelStartExternalBufferGroupsVector(builder, numElems):
+    return builder.StartVector(4, numElems, 4)
+
+def ModelAddExternalBuffers(builder, externalBuffers):
+    builder.PrependUOffsetTRelativeSlot(9, flatbuffers.number_types.UOffsetTFlags.py_type(externalBuffers), 0)
+
+def ModelStartExternalBuffersVector(builder, numElems):
+    return builder.StartVector(4, numElems, 4)
+
 def ModelEnd(builder):
     return builder.EndObject()
 
@@ -19149,6 +19445,8 @@ class ModelT(object):
         metadataBuffer = None,
         metadata = None,
         signatureDefs = None,
+        externalBufferGroups = None,
+        externalBuffers = None,
     ):
         self.version = version  # type: int
         self.operatorCodes = operatorCodes  # type: Optional[List[OperatorCodeT]]
@@ -19158,6 +19456,8 @@ class ModelT(object):
         self.metadataBuffer = metadataBuffer  # type: Optional[List[int]]
         self.metadata = metadata  # type: Optional[List[MetadataT]]
         self.signatureDefs = signatureDefs  # type: Optional[List[SignatureDefT]]
+        self.externalBufferGroups = externalBufferGroups  # type: Optional[List[ExternalBufferGroupT]]
+        self.externalBuffers = externalBuffers  # type: Optional[List[ExternalBufferT]]
 
     @classmethod
     def InitFromBuf(cls, buf, pos):
@@ -19229,6 +19529,22 @@ class ModelT(object):
                 else:
                     signatureDef_ = SignatureDefT.InitFromObj(model.SignatureDefs(i))
                     self.signatureDefs.append(signatureDef_)
+        if not model.ExternalBufferGroupsIsNone():
+            self.externalBufferGroups = []
+            for i in range(model.ExternalBufferGroupsLength()):
+                if model.ExternalBufferGroups(i) is None:
+                    self.externalBufferGroups.append(None)
+                else:
+                    externalBufferGroup_ = ExternalBufferGroupT.InitFromObj(model.ExternalBufferGroups(i))
+                    self.externalBufferGroups.append(externalBufferGroup_)
+        if not model.ExternalBuffersIsNone():
+            self.externalBuffers = []
+            for i in range(model.ExternalBuffersLength()):
+                if model.ExternalBuffers(i) is None:
+                    self.externalBuffers.append(None)
+                else:
+                    externalBuffer_ = ExternalBufferT.InitFromObj(model.ExternalBuffers(i))
+                    self.externalBuffers.append(externalBuffer_)
 
     # ModelT
     def Pack(self, builder):
@@ -19282,6 +19598,22 @@ class ModelT(object):
             for i in reversed(range(len(self.signatureDefs))):
                 builder.PrependUOffsetTRelative(signatureDefslist[i])
             signatureDefs = builder.EndVector()
+        if self.externalBufferGroups is not None:
+            externalBufferGroupslist = []
+            for i in range(len(self.externalBufferGroups)):
+                externalBufferGroupslist.append(self.externalBufferGroups[i].Pack(builder))
+            ModelStartExternalBufferGroupsVector(builder, len(self.externalBufferGroups))
+            for i in reversed(range(len(self.externalBufferGroups))):
+                builder.PrependUOffsetTRelative(externalBufferGroupslist[i])
+            externalBufferGroups = builder.EndVector()
+        if self.externalBuffers is not None:
+            externalBufferslist = []
+            for i in range(len(self.externalBuffers)):
+                externalBufferslist.append(self.externalBuffers[i].Pack(builder))
+            ModelStartExternalBuffersVector(builder, len(self.externalBuffers))
+            for i in reversed(range(len(self.externalBuffers))):
+                builder.PrependUOffsetTRelative(externalBufferslist[i])
+            externalBuffers = builder.EndVector()
         ModelStart(builder)
         ModelAddVersion(builder, self.version)
         if self.operatorCodes is not None:
@@ -19298,6 +19630,10 @@ class ModelT(object):
             ModelAddMetadata(builder, metadata)
         if self.signatureDefs is not None:
             ModelAddSignatureDefs(builder, signatureDefs)
+        if self.externalBufferGroups is not None:
+            ModelAddExternalBufferGroups(builder, externalBufferGroups)
+        if self.externalBuffers is not None:
+            ModelAddExternalBuffers(builder, externalBuffers)
         model = ModelEnd(builder)
         return model
 

{ai_edge_litert_nightly-2.0.4.dev20251024.dist-info → ai_edge_litert_nightly-2.0.4.dev20251102.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ai-edge-litert-nightly
-Version: 2.0.4.dev20251024
+Version: 2.0.4.dev20251102
 Summary: LiteRT is for mobile and embedded devices.
 Home-page: https://www.tensorflow.org/lite/
 Author: Google AI Edge Authors

{ai_edge_litert_nightly-2.0.4.dev20251024.dist-info → ai_edge_litert_nightly-2.0.4.dev20251102.dist-info}/RECORD

@@ -1,4 +1,4 @@
-ai_edge_litert/__init__.py,sha256=PUvlfcwcxVUbPQ2KazxSr5j80KRGuydVAyAG0TUt6YU,34
+ai_edge_litert/__init__.py,sha256=gH2YFlM35Ol-OP0iFZSszAtl5SJvwsi9xJ81QY0wqKU,34
 ai_edge_litert/_pywrap_analyzer_wrapper.so,sha256=b208vF3tQRJUayfGJCiNN-h0JFAQHCkWx3mnQKGKSNY,50056
 ai_edge_litert/_pywrap_litert_compiled_model_wrapper.so,sha256=R48bfhjg5-oSz8DUqDfvpztzk071ZF-snPbKHzEZMow,50104
 ai_edge_litert/_pywrap_litert_tensor_buffer_wrapper.so,sha256=EZqmZDelToDS8vRG86Hekg2hG1pIrSMdcPtgiL6VIBg,50104
@@ -23,14 +23,14 @@ ai_edge_litert/model_runtime_info_pb2.py,sha256=iNaM8G9qxWm3LpFTacl0KP19CJxA3_N8
 ai_edge_litert/plugin_pb2.py,sha256=dDsvFbuWV2yq4ghU6XnHMW6ZrbxYG2l8DAArIoqL8PY,3514
 ai_edge_litert/profiling_info_pb2.py,sha256=RxZo_P9siirO7ktyZImOxVKMZ7g-ienzuP7rSsF61YM,3579
 ai_edge_litert/pywrap_genai_ops.so,sha256=jmpe56cqSgt1rFR-4mVysQmCvSfRGzg3o1Ml6_Wt-os,50024
-ai_edge_litert/schema_py_generated.py,sha256=RQXmAj9klHEkN6k6_tqUGfiD0A5nCxnT6CTMyHu_2FA,664163
+ai_edge_litert/schema_py_generated.py,sha256=9j4-NNxuJxeohqhYAVMgKKD9mMJsKaki1xNeguM9I6Y,676250
 ai_edge_litert/source_context_pb2.py,sha256=m_GMQpv9LUK-7oKg1Vv64fTL6Bd3ZThH-fVVLtPxdqI,1775
 ai_edge_litert/struct_pb2.py,sha256=DJ6P0fZe53upcah9J1jDo6BSClobouW9dHdCTItZO1A,2955
 ai_edge_litert/tensor_buffer.py,sha256=3Xy7kd_aR499QrfO0YITvr_z-aU1eONga41KiDBUeew,5356
 ai_edge_litert/timestamp_pb2.py,sha256=K7Gs_qOn2XAMZTNUUrJ1XcGf4OmYhdt858I_zDtZYzg,1793
 ai_edge_litert/type_pb2.py,sha256=x8rTulmlk9FxtRJal7BnUsaPbn2TcLlu8D7AVoVPjMA,5065
 ai_edge_litert/wrappers_pb2.py,sha256=4hQAZRGeaE5DyY6YQ7VfrqozPa_d_LCOBEYjxfQNlKs,2955
-ai_edge_litert_nightly-2.0.4.dev20251024.dist-info/METADATA,sha256=kNmmwx-PnMG2uDZ8Pm1Dzvsq4KOnwz2UA6-7qWsQx4U,1935
-ai_edge_litert_nightly-2.0.4.dev20251024.dist-info/WHEEL,sha256=aucntbTc6bEPmSzCHROrNYAuYGC7v9_aTX954jHchmw,107
-ai_edge_litert_nightly-2.0.4.dev20251024.dist-info/top_level.txt,sha256=WcDZgG99n0a0xDS_ipL8ZWy956g1v5fVyR3FH96VDT0,15
-ai_edge_litert_nightly-2.0.4.dev20251024.dist-info/RECORD,,
+ai_edge_litert_nightly-2.0.4.dev20251102.dist-info/METADATA,sha256=Za3I2i6mIWpEVEI7az43QlPfpLKTU-xHZqTvzVfPPYk,1935
+ai_edge_litert_nightly-2.0.4.dev20251102.dist-info/WHEEL,sha256=aucntbTc6bEPmSzCHROrNYAuYGC7v9_aTX954jHchmw,107
+ai_edge_litert_nightly-2.0.4.dev20251102.dist-info/top_level.txt,sha256=WcDZgG99n0a0xDS_ipL8ZWy956g1v5fVyR3FH96VDT0,15
+ai_edge_litert_nightly-2.0.4.dev20251102.dist-info/RECORD,,