onnxruntime_extensions 0.14.0__cp313-cp313-macosx_11_0_universal2.whl

onnxruntime_extensions/tools/pre_post_processing/utils.py

@@ -0,0 +1,139 @@
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License.
+
+import onnx
+
+from dataclasses import dataclass
+from typing import List, Union
+
+
+def create_named_value(name: str, data_type: int, shape: List[Union[str, int]]):
+    """
+    Helper to create a new model input.
+
+    Args:
+        name: Name for input. Must not already be in use in the model being updated.
+        data_type: onnx.TensorProto data type. e.g. onnx.TensorProto.FLOAT, onnx.TensorProto.UINT8
+        shape: Input shape. Use int for dimensions with known values and strings for symbolic dimensions.
+               e.g. ['batch_size', 256, 256] would be a rank 3 tensor with a symbolic first dimension named 'batch_size'
+
+
+    Returns:
+        An onnx.ValueInfoProto that can be used as a new model input.
+    """
+    tensor_type = onnx.helper.make_tensor_type_proto(
+        elem_type=data_type, shape=shape)
+    return onnx.helper.make_value_info(name, tensor_type)
+
+
+# Create an onnx checker context that includes the ort-ext domain so that custom ops don't cause failure
+def create_custom_op_checker_context(onnx_opset: int):
+    """
+    Create an ONNX checker context that includes the ort-extensions custom op domains so that custom ops don't
+    cause failure when running onnx.checker.check_graph.
+
+    Args:
+        onnx_opset: ONNX opset to use in the checker context.
+
+    Returns:
+        ONNX checker context.
+    """
+    context = onnx.checker.C.CheckerContext()
+    context.ir_version = onnx.checker.DEFAULT_CONTEXT.ir_version
+    context.opset_imports = {"": onnx_opset, "com.microsoft.extensions": 1}
+
+    return context
+
+
+# The ONNX graph parser has it's own map of names just to be special
+# https://github.com/onnx/onnx/blob/604af9cb28f63a6b9924237dcb91530649233db9/onnx/defs/parser.h#L72
+TENSOR_TYPE_TO_ONNX_TYPE = {
+    int(onnx.TensorProto.FLOAT): "float",
+    int(onnx.TensorProto.UINT8): "uint8",
+    int(onnx.TensorProto.INT8): "int8",
+    int(onnx.TensorProto.UINT16): "uint16",
+    int(onnx.TensorProto.INT16): "int16",
+    int(onnx.TensorProto.INT32): "int32",
+    int(onnx.TensorProto.INT64): "int64",
+    int(onnx.TensorProto.STRING): "string",
+    int(onnx.TensorProto.BOOL): "bool",
+    int(onnx.TensorProto.FLOAT16): "float16",
+    int(onnx.TensorProto.DOUBLE): "double",
+    int(onnx.TensorProto.UINT32): "uint32",
+    int(onnx.TensorProto.UINT64): "uint64",
+    int(onnx.TensorProto.COMPLEX64): "complex64",
+    int(onnx.TensorProto.COMPLEX128): "complex128",
+    int(onnx.TensorProto.BFLOAT16): "bfloat16",
+}
+
+
+@dataclass
+class IoMapEntry:
+    """Entry to map the output index from a producer step to the input index of a consumer step."""
+
+    # optional producer
+    #   Uses Step if provided.
+    #   If a str with a previous Step name is provided the PrePostProcessor will find the relevant Step
+    #   If neither are provided the producer is inferred to be the immediately previous Step in the pipeline
+    producer: Union["Step", str] = None
+    # output index from the producer step
+    producer_idx: int = 0
+    # input index of the consumer step
+    consumer_idx: int = 0
+
+
+@dataclass
+class IOEntryValuePreserver:
+    """
+    used to allow an output value to have multiple consumers, 
+    which is only possible when IoMapEntry is used to create those additional connections.
+
+    Generally, a connection consumes an output and an input, then the output is removed from the graph.
+    This class enabled one-to-many connections by making the other consumers share the same output.
+    
+    How this class works:
+        1. when the IoMapEntry is created, this class will be created simultaneously.
+        2. It records the producer and consumer steps, and the output index of the producer step.
+    when producer step is running, this IOEntryValuePreserver will be activated and start to preserve the output.
+        3. when graph merge happens, this class will check if the output is still in the graph, if not, 
+    it will add the output
+        4. when consumer step is running, this class will be deactivated and remove output from preserved_list.
+    """
+
+    producer: Union["Step", str] = None
+    consumer: Union["Step", str] = None
+    # output index from the producer step
+    producer_idx: int = 0
+    is_active: bool = False
+    output: str = None
+
+
+def sanitize_output_names(graph: onnx.GraphProto):
+    """
+    Convert any usage of invalid characters like '/' and ';' in value names to '_'
+    This is common in models exported from TensorFlow [Lite].
+
+    ONNX parse_graph does not allow for that in a value name, and technically it's a violation of the ONNX spec as per
+    https://github.com/onnx/onnx/blob/main/docs/IR.md#names-within-a-graph
+
+    We do this for the original graph outputs only. The invalid naming has not been seen in model inputs, and we can
+    leave the internals of the graph intact to minimize changes.
+
+    Args:
+        graph: Graph to check and update any invalid names
+    """
+
+    bad_output_names = [o.name for o in graph.output if "/" in o.name or ";" in o.name]
+    if not bad_output_names:
+        return graph
+
+    renames = {}
+    for n in bad_output_names:
+        renames[n] = n.replace("/", "_").replace(";", "_")
+
+    for o in graph.output:
+        if o.name in bad_output_names:
+            # Add Identity node to rename the output, and update the name in graph.output
+            rename = onnx.helper.make_node("Identity", [o.name], [renames[o.name]], f"Rename {o.name}")
+            graph.node.append(rename)
+            o.name = renames[o.name]

onnxruntime_extensions/util.py

@@ -0,0 +1,186 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+
+"""
+util.py: Miscellaneous utility functions
+"""
+
+import onnx
+import pathlib
+import inspect
+
+import numpy as np
+
+
+# some util function for testing and tools
+def get_test_data_file(*sub_dirs):
+    case_file = inspect.currentframe().f_back.f_code.co_filename
+    test_dir = pathlib.Path(case_file).parent
+    return str(test_dir.joinpath(*sub_dirs).resolve())
+
+
+def read_file(path, mode='r'):
+    with open(str(path), mode) as file_content:
+        return file_content.read()
+
+
+def mel_filterbank(
+        n_fft: int, n_mels: int = 80, sr=16000, min_mel=0, max_mel=45.245640471924965, dtype=np.float32):
+    """
+    Compute a Mel-filterbank. The filters are stored in the rows, the columns,
+    and it is Slaney normalized mel-scale filterbank.
+    """
+    fbank = np.zeros((n_mels, n_fft // 2 + 1), dtype=dtype)
+
+    # the centers of the frequency bins for the DFT
+    freq_bins = np.fft.rfftfreq(n=n_fft, d=1.0 / sr)
+
+    mel = np.linspace(min_mel, max_mel, n_mels + 2)
+    # Fill in the linear scale
+    f_min = 0.0
+    f_sp = 200.0 / 3
+    freqs = f_min + f_sp * mel
+
+    # And now the nonlinear scale
+    min_log_hz = 1000.0  # beginning of log region (Hz)
+    min_log_mel = (min_log_hz - f_min) / f_sp  # same (Mels)
+    logstep = np.log(6.4) / 27.0  # step size for log region
+
+    log_t = mel >= min_log_mel
+    freqs[log_t] = min_log_hz * np.exp(logstep * (mel[log_t] - min_log_mel))
+    mel_bins = freqs
+
+    mel_spacing = np.diff(mel_bins)
+
+    ramps = mel_bins.reshape(-1, 1) - freq_bins.reshape(1, -1)
+    for i in range(n_mels):
+        left = -ramps[i] / mel_spacing[i]
+        right = ramps[i + 2] / mel_spacing[i + 1]
+
+        # intersect them with each other and zero
+        fbank[i] = np.maximum(0, np.minimum(left, right))
+
+    energy_norm = 2.0 / (mel_bins[2: n_mels + 2] - mel_bins[:n_mels])
+    fbank *= energy_norm[:, np.newaxis]
+    return fbank
+
+
+def remove_unused_constants(subgraph):
+    nodes = [_n for _n in subgraph.node]
+
+    # Find the names of all input tensors for all nodes in the subgraph
+    input_tensors = set()
+    for node in nodes:
+        for input_name in node.input:
+            input_tensors.add(input_name)
+
+    # Remove Constant nodes whose output is not used by any other nodes
+    nodes_to_remove = []
+    for node in nodes:
+        if node.op_type == 'Constant':
+            output_name = node.output[0]
+            if output_name not in input_tensors:
+                nodes_to_remove.append(node)
+
+    for node in nodes_to_remove:
+        subgraph.node.remove(node)
+
+    # Recursively process subgraphs within this subgraph
+    for node in nodes:
+        for attr in node.attribute:
+            if attr.type == onnx.AttributeProto.GRAPH:
+                remove_unused_constants(attr.g)
+            elif attr.type == onnx.AttributeProto.GRAPHS:
+                for subgraph in attr.graphs:
+                    remove_unused_constants(subgraph)
+
+
+def remove_unused_initializers(subgraph, top_level_initializers=None):
+    if top_level_initializers is None:
+        top_level_initializers = []
+        remove_unused_constants(subgraph)
+    initializers = [_i for _i in subgraph.initializer]
+    nodes = subgraph.node
+
+    # Find the names of all input tensors for all nodes in the subgraph
+    input_tensors = set()
+    for node in nodes:
+        for input_name in node.input:
+            input_tensors.add(input_name)
+
+    # Combine top-level and current subgraph initializers
+    all_initializers = initializers + top_level_initializers
+
+    # Filter the initializers by checking if their names are in the list of used input tensors
+    used_initializers = [
+        init for init in all_initializers if init.name in input_tensors]
+
+    # Update the subgraph's initializers
+    del subgraph.initializer[:]
+    subgraph.initializer.extend(
+        [init for init in used_initializers if init in initializers])
+
+    # Recursively process subgraphs within this subgraph
+    for node in nodes:
+        for attr in node.attribute:
+            if attr.type == onnx.AttributeProto.GRAPH:
+                remove_unused_initializers(attr.g, top_level_initializers)
+            elif attr.type == onnx.AttributeProto.GRAPHS:
+                for subgraph in attr.graphs:
+                    remove_unused_initializers(
+                        subgraph, top_level_initializers)
+
+
+def quick_merge(*models, connection_indices=None):
+    """
+    This function merges multiple ONNX models into a single model, without performing any ONNX format checks.
+
+    Parameters:
+    *models (onnx.ModelProto): Varargs parameter representing the ONNX models to be merged.
+    connection_indices (List[List[int]], optional): A nested list specifying which outputs in one model should connect 
+                                                    to which inputs in the next model, based on their indices. 
+                                                    If not provided, it's assumed that the sequence of outputs in 
+                                                    one model exactly matches the sequence of inputs in the next model.
+
+    Returns:
+    merged_model (onnx.ModelProto): The merged ONNX model.
+
+    Raises:
+    ValueError: If there is any conflict in tensor names, either in initializers or in nodes, including subgraphs.
+                If there is any conflict in opset versions for the same domain.
+    """
+
+    merged_graph = models[0].graph
+
+    # Dictionary to store unique opsets
+    opset_imports = {
+        opset.domain if opset.domain else "ai.onnx": opset for opset in models[0].opset_import}
+
+    # Iterate over all other models and merge
+    for model_idx, model in enumerate(models[1:], start=1):
+        if connection_indices is None:
+            io_map = [(out.name, in_.name) for out, in_ in zip(
+                models[model_idx - 1].graph.output, model.graph.input)]
+        else:
+            io_map = [(models[model_idx - 1].graph.output[out_idx].name, model.graph.input[in_idx].name)
+                      for out_idx, in_idx in connection_indices[model_idx - 1]]
+
+        merged_graph = onnx.compose.merge_graphs(merged_graph, model.graph, io_map)
+
+        for opset in model.opset_import:
+            if not opset.domain:
+                opset.domain = "ai.onnx"
+            if opset.domain in opset_imports and opset_imports[opset.domain].version != opset.version:
+                raise ValueError(f"Conflict in opset versions for domain '{opset.domain}': " +
+                                 f"model {model_idx} has version {opset.version}, while previous model has version " +
+                                 f"{opset_imports[opset.domain].version}.")
+            else:
+                opset_imports[opset.domain] = opset
+
+    default_opset = opset_imports.pop("ai.onnx", None)
+    merged_model = onnx.helper.make_model_gen_version(merged_graph,
+                                                      opset_imports=[
+                                                          default_opset],
+                                                      producer_name='ONNX Model Merger')
+    merged_model.opset_import.extend(opset_imports.values())
+    return merged_model

onnxruntime_extensions-0.14.0.dist-info/LICENSE

@@ -0,0 +1,21 @@
+    MIT License
+
+    Copyright (c) Microsoft Corporation.
+
+    Permission is hereby granted, free of charge, to any person obtaining a copy
+    of this software and associated documentation files (the "Software"), to deal
+    in the Software without restriction, including without limitation the rights
+    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+    copies of the Software, and to permit persons to whom the Software is
+    furnished to do so, subject to the following conditions:
+
+    The above copyright notice and this permission notice shall be included in all
+    copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+    SOFTWARE

onnxruntime_extensions-0.14.0.dist-info/METADATA

@@ -0,0 +1,102 @@
+Metadata-Version: 2.2
+Name: onnxruntime_extensions
+Version: 0.14.0
+Summary: ONNXRuntime Extensions
+Home-page: https://github.com/microsoft/onnxruntime-extensions
+Author: Microsoft Corporation
+Author-email: onnxruntime@microsoft.com
+License: MIT License
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: C++
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: License :: OSI Approved :: MIT License
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: summary
+
+# ONNXRuntime-Extensions
+
+[![Build Status](https://dev.azure.com/onnxruntime/onnxruntime/_apis/build/status%2Fonnxruntime-extensions.CI?branchName=main)](https://dev.azure.com/onnxruntime/onnxruntime/_build/latest?definitionId=213&branchName=main)
+
+## What's ONNXRuntime-Extensions
+
+Introduction: ONNXRuntime-Extensions is a C/C++ library that extends the capability of the ONNX models and inference with ONNX Runtime, via ONNX Runtime Custom Operator ABIs. It includes a set of [ONNX Runtime Custom Operator](https://onnxruntime.ai/docs/reference/operators/add-custom-op.html) to support the common pre- and post-processing operators for vision, text, and nlp models. And it supports multiple languages and platforms, like Python on Windows/Linux/macOS, some mobile platforms like Android and iOS, and Web-Assembly etc. The basic workflow is to enhance a ONNX model firstly and then do the model inference with ONNX Runtime and ONNXRuntime-Extensions package.
+
+
+## Quickstart
+The library can be utilized as either a C/C++ library or other advance language packages like Python, Java, C#, etc. To build it as a shared library, you can use the `build.bat` or `build.sh` scripts located in the root folder. The CMake build definition is available in the `CMakeLists.txt` file and can be modified by appending options to `build.bat` or `build.sh`, such as `build.bat -DOCOS_BUILD_SHARED_LIB=OFF`. For more details, please refer to the [C API documentation](./docs/c_api.md).
+
+### **Python installation**
+```bash
+pip install onnxruntime-extensions
+````
+The nightly build is also available for the latest features, please refer to [nightly build](./docs/development.md#nightly-build)
+
+
+## Usage
+
+## 1. Generation of Pre-/Post-Processing ONNX Model
+The `onnxruntime-extensions` Python package provides a convenient way to generate the ONNX processing graph. This can be achieved by converting the Huggingface transformer data processing classes into the desired format. For more detailed information, please refer to the API below:
+
+```python
+help(onnxruntime_extensions.gen_processing_models)
+```
+### NOTE:
+The generation of model processing requires the **ONNX** package to be installed. The data processing models generated in this manner can be merged with other models using the [onnx.compose](https://onnx.ai/onnx/api/compose.html) if needed.
+
+## 2. Using Extensions for ONNX Runtime inference
+
+### Python
+There are individual packages for the following languages, please install it for the build.
+```python
+import onnxruntime as _ort
+from onnxruntime_extensions import get_library_path as _lib_path
+
+so = _ort.SessionOptions()
+so.register_custom_ops_library(_lib_path())
+
+# Run the ONNXRuntime Session, as ONNXRuntime docs suggested.
+# sess = _ort.InferenceSession(model, so)
+# sess.run (...)
+```
+### C++
+
+```c++
+  // The line loads the customop library into ONNXRuntime engine to load the ONNX model with the custom op
+  Ort::ThrowOnError(Ort::GetApi().RegisterCustomOpsLibrary((OrtSessionOptions*)session_options, custom_op_library_filename, &handle));
+
+  // The regular ONNXRuntime invoking to run the model.
+  Ort::Session session(env, model_uri, session_options);
+  RunSession(session, inputs, outputs);
+```
+### Java
+```java
+var env = OrtEnvironment.getEnvironment();
+var sess_opt = new OrtSession.SessionOptions();
+
+/* Register the custom ops from onnxruntime-extensions */
+sess_opt.registerCustomOpLibrary(OrtxPackage.getLibraryPath());
+```
+
+### C#
+```C#
+SessionOptions options = new SessionOptions()
+options.RegisterOrtExtensions()
+session = new InferenceSession(model, options)
+```
+
+
+#

onnxruntime_extensions-0.14.0.dist-info/RECORD

@@ -0,0 +1,43 @@
+onnxruntime_extensions/_cuops.py,sha256=BoyBYGsCmWqHy1jdCFXKqz2bI9InZjtfFiSSGgBdM9M,16098
+onnxruntime_extensions/cmd.py,sha256=Zz94QMFfSBVK7uh8t1tJ7Tje6H8Ed6QZTbbzDPLEDxw,2362
+onnxruntime_extensions/_extensions_pydll.cpython-313-darwin.so,sha256=5W_8StexPbrmLxZpBv9PrkaAjVzexhyP-51sHyNtKDk,7541184
+onnxruntime_extensions/_torch_cvt.py,sha256=Bg6fPEYeOspOYIgNVB4e1tiIvP__1BijE6EZa5zkQM8,9954
+onnxruntime_extensions/_version.py,sha256=gV0jajIhsEFulXzRHnb5qyjzK26g1T5Ges3p8hpC8Lc,74
+onnxruntime_extensions/util.py,sha256=yXmlyHdUm8DK0HV-GQulgDIR0Jvvbb1kdjqvbVKj-SU,7208
+onnxruntime_extensions/cvt.py,sha256=GJrkcqx91GTi_b_hIsMXxAA9Uh1t5zPuOIo0elG5CSw,13104
+onnxruntime_extensions/pp_api.py,sha256=ldUstCJST0LhmZMdZKDPo44e8wXfELP9fXa5EUHqI4A,3074
+onnxruntime_extensions/__init__.py,sha256=4eAhroTJ8B9AqY8RTq3iPMsqznuMP_U-e8hGx8Vu55o,2305
+onnxruntime_extensions/_hf_cvt.py,sha256=3WnAAEC1kxoF_OnA3x4pNurTDdPwV80ArAaqgC3JLjs,15614
+onnxruntime_extensions/_ortapi2.py,sha256=ebLMfrsI474Q6k4e6IxIi8N1z3i-lwXOGLHqZoMXuyE,9677
+onnxruntime_extensions/_ocos.py,sha256=6RPGMhs-GXU9n-jvCYr9wLwPLBReaI7wk7CXBhvQTNY,4060
+onnxruntime_extensions/_extensions_pydll.pyi,sha256=G_NAgjZlPEfIjOCOz_TevFq-RhmpuEoRh8qtzb-Wj5k,1025
+onnxruntime_extensions/tools/add_HuggingFace_CLIPImageProcessor_to_model.py,sha256=XvVjgmf6eB8dCBxc2kxSOajlVuN5ZNIBSIGCNUIQq6g,6615
+onnxruntime_extensions/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+onnxruntime_extensions/tools/add_pre_post_processing_to_model.py,sha256=IwDpJpX5iTIKKIgSLzk23sJGXSCstwUQ43c_7ClV1cU,23766
+onnxruntime_extensions/tools/pre_post_processing/__init__.py,sha256=nRTIZoZpm991ayyeG4SGe5_Y4oWElLvrSeMnsnQhYBI,121
+onnxruntime_extensions/tools/pre_post_processing/step.py,sha256=z72A62TjNVd2yn-KbPplLK-YEiJY1cztXWaOs62TAX8,9167
+onnxruntime_extensions/tools/pre_post_processing/utils.py,sha256=BRj9MI3PMtWWxGCPC0_1sKDKtHRuSOUC34zecUblzm8,5559
+onnxruntime_extensions/tools/pre_post_processing/pre_post_processor.py,sha256=d7UbC57F3VmQye1cMAuU-J6iz4JG_KgvLIfq9bV1XtY,19240
+onnxruntime_extensions/tools/pre_post_processing/steps/vision.py,sha256=7OtLKZVou7K7VaiQJrdB6v-3_iuSKBuCZnAHQFTNz5c,52026
+onnxruntime_extensions/tools/pre_post_processing/steps/__init__.py,sha256=UvcT_ZiFP3n3IuYymoZsbe-V_czym0i4EDvBsTO7Tdw,159
+onnxruntime_extensions/tools/pre_post_processing/steps/nlp.py,sha256=4kSTSyFkSng09SDvBHiYlY4aD1jl-ehuPC6TBpTTQ_Q,14829
+onnxruntime_extensions/tools/pre_post_processing/steps/general.py,sha256=uk5Pv5qELQXqODHM8ysQHFI52iV1bijvMOIUsZ5qqZo,13415
+onnxruntime_extensions/onnxprocess/_onnx_ops.py,sha256=46qVtkO52vZcoihsqOJ-MtXSTdAcONty3uzmU3ZVNv4,71748
+onnxruntime_extensions/onnxprocess/torch_wrapper.py,sha256=Zc1y7TFIGE5n4NMNNciEvQQPy-G8dU91ZED2Q20gtls,828
+onnxruntime_extensions/onnxprocess/__init__.py,sha256=QDb5TwaNWcA3wrNG36gBjI9MAWsLcG-ogbpTjV4R3mc,522
+onnxruntime_extensions/onnxprocess/_session.py,sha256=QVjQPQeucJgyE3S2eD-w0A14BL1bGSrJ7vNlcNzNX8Q,14803
+onnxruntime_extensions/onnxprocess/_tensor.py,sha256=BMIsZ0Q5TrKk6yyGCxhO7o-MOuxxz1ZujSqwfisRGQI,24782
+onnxruntime_extensions/onnxprocess/_builder.py,sha256=anpzKLdkEZyFEopmAQ0PE7qUa_u1t2Sidupb6Dr6w9E,1791
+onnxruntime_extensions/pnp/_base.py,sha256=Ho6QS_Nd-XHHmP9rKGWdY8fRdC2A42eBcmbL8PFJ9q4,3804
+onnxruntime_extensions/pnp/_onnx_ops.py,sha256=Yp7nzw01RNTgRBacUaDxRJYmoYC85EVd1CQqVlHjxgs,72854
+onnxruntime_extensions/pnp/_nlp.py,sha256=uZ4ULl4nY4JhrJkJm9PqCmZowlNISK4ve0AQLlEqKS4,7272
+onnxruntime_extensions/pnp/_imagenet.py,sha256=GwYFUMnbszmfMiWoW19BtytiZEMUAkFwJqj-AhTBju8,2387
+onnxruntime_extensions/pnp/__init__.py,sha256=jLK2YniktlZsERKfW85SmVx9kEWpEnbpO3_6w-c1Kb8,482
+onnxruntime_extensions/pnp/_unifier.py,sha256=YqWzUl2QgMipfUGTDd1hXC80W7SjbS2nLSJ4c_-J-HQ,1604
+onnxruntime_extensions/pnp/_torchext.py,sha256=KFW58a9ZCBlwISO-USQzLAtrS7XdaoXuVGOQErLhT8E,11617
+onnxruntime_extensions/pnp/_utils.py,sha256=U1m-4uxCY2slsdu1scprk2FGpLaoMjz0W6NgKudhutQ,12759
+onnxruntime_extensions-0.14.0.dist-info/RECORD,,
+onnxruntime_extensions-0.14.0.dist-info/LICENSE,sha256=ws_MuBL-SCEBqPBFl9_FqZkaaydIJmxHrJG2parhU4M,1141
+onnxruntime_extensions-0.14.0.dist-info/WHEEL,sha256=mXclPsvKCrLSi5M_t9A9nHNWopNLnNNMFFGj--YXJQo,141
+onnxruntime_extensions-0.14.0.dist-info/top_level.txt,sha256=XyAgQDKyXsf6_0MJb58kRdHwigpTn7A7kl9diBEjs8M,23
+onnxruntime_extensions-0.14.0.dist-info/METADATA,sha256=7WunQ6CdHmE_nN3tQsw74WY24zrMemtn4rdvAZuIZ4U,4555

onnxruntime_extensions-0.14.0.dist-info/WHEEL

@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: setuptools (75.8.2)
+Root-Is-Purelib: false
+Tag: cp313-cp313-macosx_11_0_universal2
+Generator: delocate 0.13.0
+

onnxruntime_extensions-0.14.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+onnxruntime_extensions