onnx-ir 0.0.1__py3-none-any.whl → 0.1.1__py3-none-any.whl

onnx_ir/tape.py

@@ -0,0 +1,15 @@
+# Copyright (c) ONNX Project Contributors
+# SPDX-License-Identifier: Apache-2.0
+"""Taping module to facilitate building IR graphs."""
+
+# NOTE: Be *selective* about what this module exports because it is part of the public API.
+
+from __future__ import annotations
+
+__all__ = [
+    "Tape",
+]
+
+from onnx_ir._tape import Tape
+
+Tape.__module__ = __name__

onnx_ir/tensor_adapters.py

@@ -0,0 +1,122 @@
+# Copyright (c) ONNX Project Contributors
+# SPDX-License-Identifier: Apache-2.0
+"""Compatible adapters implementing the TensorProtocol interface for various framework tensor types.
+
+This module provides public classes that implement the :class:`onnx_ir.TensorProtocol`
+interface for various tensor types from popular deep learning frameworks.
+
+You can use these classes to create tensors and use them in the IR graph like any other tensor.
+
+Example::
+    import torch
+    import onnx_ir as ir
+
+    # Create a PyTorch tensor
+    torch_tensor = torch.tensor([1, 2, 3])
+
+    # Wrap the PyTorch tensor in a TorchTensor object
+    ir_tensor = ir.tensor_adapters.TorchTensor(torch_tensor)
+
+    # Use the IR tensor in the graph
+    attr = ir.AttrTensor("x", ir_tensor)
+    print(attr)
+"""
+
+# pylint: disable=import-outside-toplevel
+
+# NOTE: DO NOT import any framework-specific modules here in the global namespace.
+
+from __future__ import annotations
+
+__all__ = [
+    "TorchTensor",
+]
+
+import ctypes
+from typing import TYPE_CHECKING, Any
+
+import numpy.typing as npt
+
+import onnx_ir as ir
+from onnx_ir import _core
+
+if TYPE_CHECKING:
+    import torch
+
+
+class TorchTensor(_core.Tensor):
+    def __init__(
+        self, tensor: torch.Tensor, name: str | None = None, doc_string: str | None = None
+    ):
+        # Pass the tensor as the raw data to ir.Tensor's constructor
+        import torch
+
+        _TORCH_DTYPE_TO_ONNX: dict[torch.dtype, ir.DataType] = {
+            torch.bfloat16: ir.DataType.BFLOAT16,
+            torch.bool: ir.DataType.BOOL,
+            torch.complex128: ir.DataType.COMPLEX128,
+            torch.complex64: ir.DataType.COMPLEX64,
+            torch.float16: ir.DataType.FLOAT16,
+            torch.float32: ir.DataType.FLOAT,
+            torch.float64: ir.DataType.DOUBLE,
+            torch.float8_e4m3fn: ir.DataType.FLOAT8E4M3FN,
+            torch.float8_e4m3fnuz: ir.DataType.FLOAT8E4M3FNUZ,
+            torch.float8_e5m2: ir.DataType.FLOAT8E5M2,
+            torch.float8_e5m2fnuz: ir.DataType.FLOAT8E5M2FNUZ,
+            torch.int16: ir.DataType.INT16,
+            torch.int32: ir.DataType.INT32,
+            torch.int64: ir.DataType.INT64,
+            torch.int8: ir.DataType.INT8,
+            torch.uint8: ir.DataType.UINT8,
+            torch.uint16: ir.DataType.UINT16,
+            torch.uint32: ir.DataType.UINT32,
+            torch.uint64: ir.DataType.UINT64,
+        }
+        super().__init__(
+            tensor, dtype=_TORCH_DTYPE_TO_ONNX[tensor.dtype], name=name, doc_string=doc_string
+        )
+
+    def numpy(self) -> npt.NDArray:
+        import torch
+
+        self.raw: torch.Tensor
+        if self.dtype == ir.DataType.BFLOAT16:
+            return self.raw.view(torch.uint16).numpy(force=True).view(self.dtype.numpy())
+        if self.dtype in {
+            ir.DataType.FLOAT8E4M3FN,
+            ir.DataType.FLOAT8E4M3FNUZ,
+            ir.DataType.FLOAT8E5M2,
+            ir.DataType.FLOAT8E5M2FNUZ,
+        }:
+            return self.raw.view(torch.uint8).numpy(force=True).view(self.dtype.numpy())
+
+        return self.raw.numpy(force=True)
+
+    def __array__(self, dtype: Any = None, copy: bool | None = None) -> npt.NDArray:
+        del copy  # Unused, but needed for the signature
+        if dtype is None:
+            return self.numpy()
+        return self.numpy().__array__(dtype)
+
+    def tobytes(self) -> bytes:
+        # Implement tobytes to support native PyTorch types so we can use types like bloat16
+        # Reading from memory directly is also more efficient because
+        # it avoids copying to a NumPy array
+        import torch._subclasses.fake_tensor
+
+        with torch._subclasses.fake_tensor.unset_fake_temporarily():  # pylint: disable=protected-access
+            # Disable any fake mode so calling detach() etc. will return a real tensor
+            tensor = self.raw.detach().cpu().contiguous()
+
+        if isinstance(tensor, torch._subclasses.fake_tensor.FakeTensor):  # pylint: disable=protected-access
+            raise TypeError(
+                f"Cannot take content out from the FakeTensor ('{self.name}'). Please replace the tensor "
+                "with a tensor backed by real data using ONNXProgram.apply_weights() "
+                "or save the model without initializers by setting include_initializers=False."
+            )
+
+        return bytes(
+            (ctypes.c_ubyte * tensor.element_size() * tensor.numel()).from_address(
+                tensor.data_ptr()
+            )
+        )

onnx_ir/testing.py

@@ -0,0 +1,197 @@
+# Copyright (c) ONNX Project Contributors
+# SPDX-License-Identifier: Apache-2.0
+"""Utilities for testing."""
+
+from __future__ import annotations
+
+__all__ = [
+    "assert_onnx_proto_equal",
+]
+
+import difflib
+import math
+from collections.abc import Collection, Sequence
+from typing import Any
+
+import google.protobuf.message
+import onnx
+
+
+def _opset_import_key(opset_import: onnx.OperatorSetIdProto) -> tuple[str, int]:
+    return (opset_import.domain, opset_import.version)
+
+
+def _value_info_key(value_info: onnx.ValueInfoProto) -> str:
+    return value_info.name
+
+
+def _function_key(function: onnx.FunctionProto) -> tuple[str, str, str]:
+    return (function.domain, function.name, getattr(function, "overload", ""))
+
+
+def _find_duplicates(with_duplicates: Collection[Any]) -> list[Any]:
+    """Return a list of duplicated elements in a collection."""
+    seen = set()
+    duplicates = []
+    for x in with_duplicates:
+        if x in seen:
+            duplicates.append(x)
+        seen.add(x)
+    return duplicates
+
+
+def assert_onnx_proto_equal(
+    actual: google.protobuf.message.Message | Any,
+    expected: google.protobuf.message.Message | Any,
+    ignore_initializer_value_proto: bool = False,
+) -> None:
+    """Assert that two ONNX protos are equal.
+
+    Equality is defined as having the same fields with the same values. When
+    a field takes the default value, it is considered equal to the field
+    not being set.
+
+    Sequential fields with name `opset_import`, `value_info`, and `functions` are
+    compared disregarding the order of their elements.
+
+    Args:
+        actual: The first ONNX proto.
+        expected: The second ONNX proto.
+        ignore_initializer_value_proto: Ignore value protos for initializers if there
+            are extra ones in the actual proto.
+    """
+    assert type(actual) is type(expected), (
+        f"Type not equal: {type(actual)} != {type(expected)}"
+    )
+
+    a_fields = {field.name: value for field, value in actual.ListFields()}
+    b_fields = {field.name: value for field, value in expected.ListFields()}
+    all_fields = sorted(set(a_fields.keys()) | set(b_fields.keys()))
+    if isinstance(actual, onnx.GraphProto) and isinstance(expected, onnx.GraphProto):
+        actual_initializer_names = {i.name for i in actual.initializer}
+        expected_initializer_names = {i.name for i in expected.initializer}
+    else:
+        actual_initializer_names = set()
+        expected_initializer_names = set()
+
+    # Record and report all errors
+    errors = []
+    for field in all_fields:  # pylint: disable=too-many-nested-blocks
+        # Obtain the default value if the field is not set. This way we can compare the two fields.
+        a_value = getattr(actual, field)
+        b_value = getattr(expected, field)
+        if (
+            isinstance(a_value, Sequence)
+            and isinstance(b_value, Sequence)
+            and not isinstance(a_value, (str, bytes))
+            and not isinstance(b_value, (str, bytes))
+        ):
+            # Check length first
+            a_keys: list[Any] = []
+            b_keys: list[Any] = []
+            if field == "opset_import":
+                a_value = sorted(a_value, key=_opset_import_key)
+                b_value = sorted(b_value, key=_opset_import_key)
+                a_keys = [_opset_import_key(opset_import) for opset_import in a_value]
+                b_keys = [_opset_import_key(opset_import) for opset_import in b_value]
+            elif field == "value_info":
+                if (
+                    ignore_initializer_value_proto
+                    and isinstance(actual, onnx.GraphProto)
+                    and isinstance(expected, onnx.GraphProto)
+                ):
+                    # Filter out initializers from the value_info list
+                    a_value = [
+                        value_info
+                        for value_info in a_value
+                        if value_info.name not in actual_initializer_names
+                    ]
+                    b_value = [
+                        value_info
+                        for value_info in b_value
+                        if value_info.name not in expected_initializer_names
+                    ]
+                a_value = sorted(a_value, key=_value_info_key)
+                b_value = sorted(b_value, key=_value_info_key)
+                a_keys = [_value_info_key(value_info) for value_info in a_value]
+                b_keys = [_value_info_key(value_info) for value_info in b_value]
+            elif field == "functions":
+                a_value = sorted(a_value, key=_function_key)
+                b_value = sorted(b_value, key=_function_key)
+                a_keys = [_function_key(functions) for functions in a_value]
+                b_keys = [_function_key(functions) for functions in b_value]
+
+            if a_keys != b_keys:
+                keys_only_in_actual = set(a_keys) - set(b_keys)
+                keys_only_in_expected = set(b_keys) - set(a_keys)
+                error_message = (
+                    f"Field {field} not equal: keys_only_in_actual={keys_only_in_actual}, keys_only_in_expected={keys_only_in_expected}. "
+                    f"Field type: {type(a_value)}. "
+                    f"Duplicated a_keys: {_find_duplicates(a_keys)}, duplicated b_keys: {_find_duplicates(b_keys)}"
+                )
+                errors.append(error_message)
+            elif len(a_value) != len(b_value):
+                error_message = (
+                    f"Field {field} not equal: len(a)={len(a_value)}, len(b)={len(b_value)} "
+                    f"Field type: {type(a_value)}"
+                )
+                errors.append(error_message)
+            else:
+                # Check every element
+                for i in range(len(a_value)):  # pylint: disable=consider-using-enumerate
+                    actual_value_i = a_value[i]
+                    expected_value_i = b_value[i]
+                    if isinstance(
+                        actual_value_i, google.protobuf.message.Message
+                    ) and isinstance(expected_value_i, google.protobuf.message.Message):
+                        try:
+                            assert_onnx_proto_equal(
+                                actual_value_i,
+                                expected_value_i,
+                                ignore_initializer_value_proto=ignore_initializer_value_proto,
+                            )
+                        except AssertionError as e:
+                            error_message = f"Field {field} index {i} in sequence not equal. type(actual_value_i): {type(actual_value_i)}, type(expected_value_i): {type(expected_value_i)}, actual_value_i: {actual_value_i}, expected_value_i: {expected_value_i}"
+                            error_message = (
+                                str(e) + "\n\nCaused by the above error\n\n" + error_message
+                            )
+                            errors.append(error_message)
+                    elif actual_value_i != expected_value_i:
+                        if (
+                            isinstance(actual_value_i, float)
+                            and isinstance(expected_value_i, float)
+                            and math.isnan(actual_value_i)
+                            and math.isnan(expected_value_i)
+                        ):
+                            # Consider NaNs equal
+                            continue
+                        error_message = f"Field {field} index {i} in sequence not equal. type(actual_value_i): {type(actual_value_i)}, type(expected_value_i): {type(expected_value_i)}"
+                        for line in difflib.ndiff(
+                            str(actual_value_i).splitlines(),
+                            str(expected_value_i).splitlines(),
+                        ):
+                            error_message += "\n" + line
+                        errors.append(error_message)
+        elif isinstance(a_value, google.protobuf.message.Message) and isinstance(
+            b_value, google.protobuf.message.Message
+        ):
+            assert_onnx_proto_equal(
+                a_value, b_value, ignore_initializer_value_proto=ignore_initializer_value_proto
+            )
+        elif a_value != b_value:
+            if (
+                isinstance(a_value, float)
+                and isinstance(b_value, float)
+                and math.isnan(a_value)
+                and math.isnan(b_value)
+            ):
+                # Consider NaNs equal
+                continue
+            error_message = (
+                f"Field {field} not equal. field_actual: {a_value}, field_expected: {b_value}"
+            )
+            errors.append(error_message)
+    if errors:
+        raise AssertionError(
+            f"Protos not equal: {type(actual)} != {type(expected)}\n" + "\n".join(errors)
+        )

onnx_ir/traversal.py

@@ -1,5 +1,5 @@
-# Copyright (c) Microsoft Corporation.
-# Licensed under the MIT License.
+# Copyright (c) ONNX Project Contributors
+# SPDX-License-Identifier: Apache-2.0
 """Utilities for traversing the IR graph."""
 
 from __future__ import annotations
@@ -8,7 +8,8 @@ __all__ = [
     "RecursiveGraphIterator",
 ]
 
-from typing import Callable, Iterator, Reversible, Union
+from collections.abc import Iterator, Reversible
+from typing import Callable, Union
 
 from typing_extensions import Self
 

onnx_ir-0.1.1.dist-info/METADATA

@@ -0,0 +1,53 @@
+Metadata-Version: 2.4
+Name: onnx-ir
+Version: 0.1.1
+Summary: Efficient in-memory representation for ONNX
+Author-email: ONNX Contributors <onnx-technical-discuss@lists.lfaidata.foundation>
+License: Apache License v2.0
+Project-URL: Homepage, https://onnx.ai/onnx-ir
+Project-URL: Issues, https://github.com/onnx/onnx-ir/issues
+Project-URL: Repository, https://github.com/onnx/onnx-ir
+Classifier: Development Status :: 4 - Beta
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: License :: OSI Approved :: Apache Software License
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: onnx>=1.16
+Requires-Dist: typing_extensions>=4.10
+Requires-Dist: ml_dtypes
+Dynamic: license-file
+
+# ONNX IR
+
+[![PyPI - Version](https://img.shields.io/pypi/v/onnx-ir.svg)](https://pypi.org/project/onnx-ir)
+[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/onnx-ir.svg)](https://pypi.org/project/onnx-ir)
+[![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
+[![codecov](https://codecov.io/gh/onnx/ir-py/graph/badge.svg?token=SPQ3G9T78Z)](https://codecov.io/gh/onnx/ir-py)
+[![DeepWiki](https://img.shields.io/badge/DeepWiki-onnx%2Fir--py-blue.svg?logo=data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACwAAAAyCAYAAAAnWDnqAAAAAXNSR0IArs4c6QAAA05JREFUaEPtmUtyEzEQhtWTQyQLHNak2AB7ZnyXZMEjXMGeK/AIi+QuHrMnbChYY7MIh8g01fJoopFb0uhhEqqcbWTp06/uv1saEDv4O3n3dV60RfP947Mm9/SQc0ICFQgzfc4CYZoTPAswgSJCCUJUnAAoRHOAUOcATwbmVLWdGoH//PB8mnKqScAhsD0kYP3j/Yt5LPQe2KvcXmGvRHcDnpxfL2zOYJ1mFwrryWTz0advv1Ut4CJgf5uhDuDj5eUcAUoahrdY/56ebRWeraTjMt/00Sh3UDtjgHtQNHwcRGOC98BJEAEymycmYcWwOprTgcB6VZ5JK5TAJ+fXGLBm3FDAmn6oPPjR4rKCAoJCal2eAiQp2x0vxTPB3ALO2CRkwmDy5WohzBDwSEFKRwPbknEggCPB/imwrycgxX2NzoMCHhPkDwqYMr9tRcP5qNrMZHkVnOjRMWwLCcr8ohBVb1OMjxLwGCvjTikrsBOiA6fNyCrm8V1rP93iVPpwaE+gO0SsWmPiXB+jikdf6SizrT5qKasx5j8ABbHpFTx+vFXp9EnYQmLx02h1QTTrl6eDqxLnGjporxl3NL3agEvXdT0WmEost648sQOYAeJS9Q7bfUVoMGnjo4AZdUMQku50McDcMWcBPvr0SzbTAFDfvJqwLzgxwATnCgnp4wDl6Aa+Ax283gghmj+vj7feE2KBBRMW3FzOpLOADl0Isb5587h/U4gGvkt5v60Z1VLG8BhYjbzRwyQZemwAd6cCR5/XFWLYZRIMpX39AR0tjaGGiGzLVyhse5C9RKC6ai42ppWPKiBagOvaYk8lO7DajerabOZP46Lby5wKjw1HCRx7p9sVMOWGzb/vA1hwiWc6jm3MvQDTogQkiqIhJV0nBQBTU+3okKCFDy9WwferkHjtxib7t3xIUQtHxnIwtx4mpg26/HfwVNVDb4oI9RHmx5WGelRVlrtiw43zboCLaxv46AZeB3IlTkwouebTr1y2NjSpHz68WNFjHvupy3q8TFn3Hos2IAk4Ju5dCo8B3wP7VPr/FGaKiG+T+v+TQqIrOqMTL1VdWV1DdmcbO8KXBz6esmYWYKPwDL5b5FA1a0hwapHiom0r/cKaoqr+27/XcrS5UwSMbQAAAABJRU5ErkJggg==)](https://deepwiki.com/onnx/ir-py)
+
+An in-memory IR that supports the full ONNX spec, designed for graph construction, analysis and transformation.
+
+## Features ✨
+
+- Full ONNX spec support: all valid models representable by ONNX protobuf, and a subset of invalid models (so you can load and fix them).
+- Low memory footprint: mmap'ed external tensors; unified interface for ONNX TensorProto, Numpy arrays and PyTorch Tensors etc. No tensor size limitation. Zero copies.
+- Straightforward access patterns: Access value information and traverse the graph topology at ease.
+- Robust mutation: Create as many iterators as you like on the graph while mutating it.
+- Speed: Performant graph manipulation, serialization/deserialization to Protobuf.
+- Pythonic and familiar APIs: Classes define Pythonic apis and still map to ONNX protobuf concepts in an intuitive way.
+- No protobuf dependency: The IR does not require protobuf once the model is converted to the IR representation, decoupling from the serialization format.
+
+## Code Organization 🗺️
+
+- [`_protocols.py`](src/onnx_ir/_protocols.py): Interfaces defined for all entities in the IR.
+- [`_core.py`](src/onnx_ir/_core.py): Implementation of the core entities in the IR, including `Model`, `Graph`, `Node`, `Value`, and others.
+- [`_enums.py`](src/onnx_ir/_enums.py): Definition of the type enums that correspond to the `DataType` and `AttributeType` in `onnx.proto`.
+- [`_name_authority.py`](src/onnx_ir/_name_authority.py): The authority for giving names to entities in the graph, used internally.
+- [`_linked_list.py`](src/onnx_ir/_linked_list.py): The data structure as the node container in the graph that supports robust iteration and mutation. Internal.
+- [`_metadata.py`](src/onnx_ir/_metadata.py): Metadata store for all entities in the IR.

onnx_ir-0.1.1.dist-info/RECORD

@@ -0,0 +1,42 @@
+onnx_ir/__init__.py,sha256=0fD02tkU7-bC9BfPS68TP2500619oJ8NZyGx3CdGmVk,3352
+onnx_ir/_core.py,sha256=7nufz-9r8J3d6R4BzmRKq0DwmWosOZp3ICNr9MfMG0E,128316
+onnx_ir/_display.py,sha256=230bMN_hVy47Ug3HkA4o5Tf5Hr21AnBEoq5w0fxjyTs,1300
+onnx_ir/_enums.py,sha256=zMvRvYyxOg0Rf3DCQ5Sn1TyZ5znj4NuGO-OAOKZCiDM,7880
+onnx_ir/_graph_comparison.py,sha256=8_D1gu547eCDotEUqxfIJhUGU_Ufhfji7sfsSraOj3g,727
+onnx_ir/_graph_containers.py,sha256=hK3R3OrQTMXF8_z9Kx1DBtJriq_NQx8MUAFy7GpTZ2U,14154
+onnx_ir/_io.py,sha256=XmVqvM2lyX7QtXGr0KcV4bboRGTOPJ8BP4YtQ-jh4dg,3886
+onnx_ir/_linked_list.py,sha256=PXVcbHLMXHLZ6DxZnElnJLWfhBPvYcXUxM8Y3K4J7lM,10592
+onnx_ir/_metadata.py,sha256=lzmCaYy4kAJrPW-PSGKF4a78LisxF0hiofySNQ3Mwhg,1544
+onnx_ir/_name_authority.py,sha256=PnoV9TRgMLussZNufWavJXosDWx5avPfldVjMWEEz18,3036
+onnx_ir/_polyfill.py,sha256=LzAGBKQbVDlURC0tgQgaxgkYU4rESgCYnqVs-u-Vsx8,887
+onnx_ir/_protocols.py,sha256=M29sIOAvtdlis3QtBvCQPH4pnvSwhJCQNCvs3IrN9FY,21276
+onnx_ir/_tape.py,sha256=nEGY6VZVKuB8FDyXeYr0MTq8j7E4HKOE2yN8qpz4ia0,7007
+onnx_ir/_type_casting.py,sha256=evx6P4A0lI_V68SfKLqTN8pH7Q8GZb0So5wvf1eKCNw,3315
+onnx_ir/_version_utils.py,sha256=A51xvGq4I81vV4VuvDx7zc4Xe0XPSp0CTjsh_M7yX4A,2669
+onnx_ir/convenience.py,sha256=48mqMeva9Sb39P_9IUOud8V1Zc79wZUNcQEuMv-fT-Y,871
+onnx_ir/external_data.py,sha256=Aul9O5j7zNCayFP77sMHUU-FrUnwK9BL7mXm8wJmgHY,16511
+onnx_ir/serde.py,sha256=xtMaSdOW_JfSkvM_cdYzVx1By6Z-R9NVsVEZNECIvL8,70131
+onnx_ir/tape.py,sha256=4FyfAHmVhQoMsfHMYnBwP2azi6UF6b6pj--ercObqZs,350
+onnx_ir/tensor_adapters.py,sha256=J2z0gxkxwZqBrob1pYT53lgz1XQ1r7kCxhoSZa5NHaQ,4469
+onnx_ir/testing.py,sha256=WTrjf2joWizDWaYMJlV1KjZMQw7YmZ8NvuBTVn1uY6s,8803
+onnx_ir/traversal.py,sha256=Z69wzYBNljn1S7PhVTYgwMftrfsdEBLoa0JYteOhLL0,2863
+onnx_ir/_convenience/__init__.py,sha256=szllgzSyKafBsmrTFRazkxURjUYVjIEzwQRA593uSo4,14389
+onnx_ir/_convenience/_constructors.py,sha256=nA0tytizoFhQeN6gpxVx3khJQXq-tRtIh0UBM0CdTOg,8174
+onnx_ir/_thirdparty/asciichartpy.py,sha256=afQ0fsqko2uYRPAR4TZBrQxvCb4eN8lxZ2yDFbVQq_s,10533
+onnx_ir/passes/__init__.py,sha256=M_Tcl_-qGSNPluFIvOoeDyh0qAwNayaYyXDS5UJUJPQ,764
+onnx_ir/passes/_pass_infra.py,sha256=HEzxDbXjIUPVubv4pxsPTFXiCDPoiM_tPEoEH1mHO70,9560
+onnx_ir/passes/common/__init__.py,sha256=aHjx2y7L7LJChixmKsSUCdiaTP1u-zSmcmEISduqeG4,1335
+onnx_ir/passes/common/_c_api_utils.py,sha256=cr0vOhnZ-0lOcZV_mOS3Gn-cUK73CPzjAjfbYA-PJuQ,2891
+onnx_ir/passes/common/clear_metadata_and_docstring.py,sha256=YwouLfsNFSaTuGd7uMOGjdvVwG9yHQTkSphUgDlM0ME,2365
+onnx_ir/passes/common/common_subexpression_elimination.py,sha256=WMsTAI-12A3iVqptmWw0tiBmGwVKsls5VNxZEbjvp2A,6527
+onnx_ir/passes/common/constant_manipulation.py,sha256=_fGDwn0Axl2Q8APfc2m_mLMH28T-Mc9kIlpzBXoe3q4,8779
+onnx_ir/passes/common/inliner.py,sha256=wBoO6yXt6F1AObQjYZHMQ0wn3YH681N4HQQVyaMAYd4,13702
+onnx_ir/passes/common/onnx_checker.py,sha256=4RdWgleYHs36pRRiUCbojkBrw80b1LX88xmj5NLclMg,1675
+onnx_ir/passes/common/shape_inference.py,sha256=J5VWsLbx9dPwV1JTuaRBObliiVHEb978AxHq_9dOGII,3976
+onnx_ir/passes/common/topological_sort.py,sha256=Vcu1YhBdfRX4LROr0NScjB1Pwz2DjBFD0Z_GxqaxPF8,999
+onnx_ir/passes/common/unused_removal.py,sha256=n1Vr8kSv3HGZyxFin_Kyx79GasfmhlQRVdJ0hGeZnv0,7597
+onnx_ir-0.1.1.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+onnx_ir-0.1.1.dist-info/METADATA,sha256=W3i284mv7QuWNNkjRy7x_zHEsMwgUpXvmoux6VE0vZQ,4586
+onnx_ir-0.1.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+onnx_ir-0.1.1.dist-info/top_level.txt,sha256=W5tROO93YjO0XRxIdjMy4wocp-5st5GiI2ukvW7UhDo,8
+onnx_ir-0.1.1.dist-info/RECORD,,

{onnx_ir-0.0.1.dist-info → onnx_ir-0.1.1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.8.0)
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

onnx_ir-0.1.1.dist-info/licenses/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.