onnx-ir 0.1.15__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,210 @@
+# 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__ = [
+    "from_torch_dtype",
+    "to_torch_dtype",
+    "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
+
+
+_TORCH_DTYPE_TO_ONNX: dict[torch.dtype, ir.DataType] | None = None
+_ONNX_DTYPE_TO_TORCH: dict[ir.DataType, torch.dtype] | None = None
+
+
+def from_torch_dtype(dtype: torch.dtype) -> ir.DataType:
+    """Convert a PyTorch dtype to an ONNX IR DataType."""
+    global _TORCH_DTYPE_TO_ONNX
+    if _TORCH_DTYPE_TO_ONNX is None:
+        import torch
+
+        _TORCH_DTYPE_TO_ONNX = {
+            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,
+        }
+        if hasattr(torch, "float8_e8m0fnu"):
+            # torch.float8_e8m0fnu is available in PyTorch 2.7+
+            _TORCH_DTYPE_TO_ONNX[torch.float8_e8m0fnu] = ir.DataType.FLOAT8E8M0
+        if hasattr(torch, "int2"):
+            _TORCH_DTYPE_TO_ONNX[torch.int2] = ir.DataType.INT2
+        if hasattr(torch, "uint2"):
+            _TORCH_DTYPE_TO_ONNX[torch.uint2] = ir.DataType.UINT2
+
+    if dtype not in _TORCH_DTYPE_TO_ONNX:
+        raise TypeError(
+            f"Unsupported PyTorch dtype '{dtype}'. "
+            "Please use a supported dtype from the list: "
+            f"{list(_TORCH_DTYPE_TO_ONNX.keys())}"
+        )
+    return _TORCH_DTYPE_TO_ONNX[dtype]
+
+
+def to_torch_dtype(dtype: ir.DataType) -> torch.dtype:
+    """Convert an ONNX IR DataType to a PyTorch dtype."""
+    global _ONNX_DTYPE_TO_TORCH
+    if _ONNX_DTYPE_TO_TORCH is None:
+        import torch
+
+        _ONNX_DTYPE_TO_TORCH = {
+            ir.DataType.BFLOAT16: torch.bfloat16,
+            ir.DataType.BOOL: torch.bool,
+            ir.DataType.COMPLEX128: torch.complex128,
+            ir.DataType.COMPLEX64: torch.complex64,
+            ir.DataType.FLOAT16: torch.float16,
+            ir.DataType.FLOAT: torch.float32,
+            ir.DataType.DOUBLE: torch.float64,
+            ir.DataType.FLOAT8E4M3FN: torch.float8_e4m3fn,
+            ir.DataType.FLOAT8E4M3FNUZ: torch.float8_e4m3fnuz,
+            ir.DataType.FLOAT8E5M2: torch.float8_e5m2,
+            ir.DataType.FLOAT8E5M2FNUZ: torch.float8_e5m2fnuz,
+            ir.DataType.INT16: torch.int16,
+            ir.DataType.INT32: torch.int32,
+            ir.DataType.INT64: torch.int64,
+            ir.DataType.INT8: torch.int8,
+            ir.DataType.UINT8: torch.uint8,
+            ir.DataType.UINT16: torch.uint16,
+            ir.DataType.UINT32: torch.uint32,
+            ir.DataType.UINT64: torch.uint64,
+        }
+
+        if hasattr(torch, "float8_e8m0fnu"):
+            # torch.float8_e8m0fnu is available in PyTorch 2.7+
+            _ONNX_DTYPE_TO_TORCH[ir.DataType.FLOAT8E8M0] = torch.float8_e8m0fnu
+        if hasattr(torch, "int2"):
+            _ONNX_DTYPE_TO_TORCH[ir.DataType.INT2] = torch.int2
+        if hasattr(torch, "uint2"):
+            _ONNX_DTYPE_TO_TORCH[ir.DataType.UINT2] = torch.uint2
+
+    if dtype not in _ONNX_DTYPE_TO_TORCH:
+        if dtype == ir.DataType.FLOAT8E8M0:
+            raise ValueError(
+                "The requested DataType 'FLOAT8E8M0' is only supported in PyTorch 2.7+. "
+                "Please upgrade your PyTorch version to use this dtype."
+            )
+        raise TypeError(
+            f"Unsupported conversion from ONNX dtype '{dtype}' to torch. "
+            "Please use a supported dtype from the list: "
+            f"{list(_ONNX_DTYPE_TO_TORCH.keys())}"
+        )
+    return _ONNX_DTYPE_TO_TORCH[dtype]
+
+
+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
+        super().__init__(
+            tensor, dtype=from_torch_dtype(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,
+            ir.DataType.FLOAT8E8M0,
+        }:
+            return self.raw.view(torch.uint8).numpy(force=True).view(self.dtype.numpy())
+        if self.dtype in {ir.DataType.INT2, ir.DataType.UINT2}:
+            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 _get_cbytes(self):
+        """Get a ctypes byte array pointing to the tensor data."""
+        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 the tensor to ensure it is not garbage collected while the ctypes array is in use
+        return tensor, (ctypes.c_ubyte * tensor.element_size() * tensor.numel()).from_address(
+            tensor.data_ptr()
+        )
+
+    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
+        _, data = self._get_cbytes()
+        return bytes(data)
+
+    def tofile(self, file) -> None:
+        _, data = self._get_cbytes()
+        return file.write(data)

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

@@ -0,0 +1,118 @@
+# Copyright (c) ONNX Project Contributors
+# SPDX-License-Identifier: Apache-2.0
+"""Utilities for traversing the IR graph."""
+
+from __future__ import annotations
+
+__all__ = [
+    "RecursiveGraphIterator",
+]
+
+from collections.abc import Iterator, Reversible
+from typing import Callable, Union
+
+from typing_extensions import Self
+
+from onnx_ir import _core, _enums
+
+GraphLike = Union[_core.Graph, _core.Function, _core.GraphView]
+
+
+class RecursiveGraphIterator(Iterator[_core.Node], Reversible[_core.Node]):
+    def __init__(
+        self,
+        graph_like: GraphLike,
+        *,
+        recursive: Callable[[_core.Node], bool] | None = None,
+        reverse: bool = False,
+        enter_graph: Callable[[GraphLike], None] | None = None,
+        exit_graph: Callable[[GraphLike], None] | None = None,
+    ):
+        """Iterate over the nodes in the graph, recursively visiting subgraphs.
+
+        This iterator allows for traversing the nodes of a graph and its subgraphs
+        in a depth-first manner. It supports optional callbacks for entering and exiting
+        subgraphs, as well as a callback `recursive` to determine whether to visit subgraphs
+        contained within nodes.
+
+        .. versionadded:: 0.1.6
+            Added the `enter_graph` and `exit_graph` callbacks.
+
+        Args:
+            graph_like: The graph to traverse.
+            recursive: A callback that determines whether to recursively visit the subgraphs
+                contained in a node. If not provided, all nodes in subgraphs are visited.
+            reverse: Whether to iterate in reverse order.
+            enter_graph: An optional callback that is called when entering a subgraph.
+            exit_graph: An optional callback that is called when exiting a subgraph.
+        """
+        self._graph = graph_like
+        self._recursive = recursive
+        self._reverse = reverse
+        self._iterator = self._recursive_node_iter(graph_like)
+        self._enter_graph = enter_graph
+        self._exit_graph = exit_graph
+
+    def __iter__(self) -> Self:
+        self._iterator = self._recursive_node_iter(self._graph)
+        return self
+
+    def __next__(self) -> _core.Node:
+        return next(self._iterator)
+
+    def _recursive_node_iter(
+        self, graph: _core.Graph | _core.Function | _core.GraphView
+    ) -> Iterator[_core.Node]:
+        iterable = reversed(graph) if self._reverse else graph
+
+        if self._enter_graph is not None:
+            self._enter_graph(graph)
+
+        for node in iterable:  # type: ignore[union-attr]
+            yield node
+            if self._recursive is not None and not self._recursive(node):
+                continue
+            yield from self._iterate_subgraphs(node)
+
+        if self._exit_graph is not None:
+            self._exit_graph(graph)
+
+    def _iterate_subgraphs(self, node: _core.Node):
+        for attr in node.attributes.values():
+            if not isinstance(attr, _core.Attr):
+                continue
+            if attr.type == _enums.AttributeType.GRAPH:
+                if self._enter_graph is not None:
+                    self._enter_graph(attr.value)
+                yield from RecursiveGraphIterator(
+                    attr.value,
+                    recursive=self._recursive,
+                    reverse=self._reverse,
+                    enter_graph=self._enter_graph,
+                    exit_graph=self._exit_graph,
+                )
+                if self._exit_graph is not None:
+                    self._exit_graph(attr.value)
+            elif attr.type == _enums.AttributeType.GRAPHS:
+                graphs = reversed(attr.value) if self._reverse else attr.value
+                for graph in graphs:
+                    if self._enter_graph is not None:
+                        self._enter_graph(graph)
+                    yield from RecursiveGraphIterator(
+                        graph,
+                        recursive=self._recursive,
+                        reverse=self._reverse,
+                        enter_graph=self._enter_graph,
+                        exit_graph=self._exit_graph,
+                    )
+                    if self._exit_graph is not None:
+                        self._exit_graph(graph)
+
+    def __reversed__(self) -> Iterator[_core.Node]:
+        return RecursiveGraphIterator(
+            self._graph,
+            recursive=self._recursive,
+            reverse=not self._reverse,
+            enter_graph=self._enter_graph,
+            exit_graph=self._exit_graph,
+        )

onnx_ir-0.1.15.dist-info/METADATA

@@ -0,0 +1,68 @@
+Metadata-Version: 2.4
+Name: onnx-ir
+Version: 0.1.15
+Summary: Efficient in-memory representation for ONNX
+Author-email: ONNX Contributors <onnx-technical-discuss@lists.lfaidata.foundation>
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://onnx.ai/ir-py
+Project-URL: Issues, https://github.com/onnx/ir-py/issues
+Project-URL: Repository, https://github.com/onnx/ir-py
+Classifier: Development Status :: 4 - Beta
+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>=0.5.0
+Dynamic: license-file
+
+# <img src="docs/_static/logo-light.png" alt="ONNX IR" width="250"/>
+
+[![PyPI - Version](https://img.shields.io/pypi/v/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)
+[![PyPI Downloads](https://static.pepy.tech/badge/onnx-ir/month)](https://pepy.tech/projects/onnx-ir)
+
+An in-memory IR that supports the full ONNX spec, designed for graph construction, analysis and transformation.
+
+## Getting Started
+
+[onnx-ir documentation](https://onnx.ai/ir-py/)
+
+### Installation
+
+Via pip:
+
+```
+pip install onnx-ir
+```
+
+Or from source:
+
+```
+pip install git+https://github.com/onnx/ir-py.git
+```
+
+## 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.
+
+## Concept Diagram
+
+![Concept Diagram](docs/resource/onnx-ir-entities.svg)
+
+## 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.15.dist-info/RECORD

@@ -0,0 +1,53 @@
+onnx_ir/__init__.py,sha256=KRCf_XITzIbeZi5MvpUkjEA6QtMbEzFgw145-WbhRAM,3588
+onnx_ir/_cloner.py,sha256=b1tUeg3K3yfAk7LE2IIAR0TlKU-mZw3vE9hpfumGKXg,9718
+onnx_ir/_core.py,sha256=a19zUiqEFhc355RroJiiyw4u2J8vclkfb3mn7DjcL6g,164263
+onnx_ir/_display.py,sha256=eVnikQJ2xAi5JjM6JPaHlYCMSOyna5-2FYgZWvsusNI,1420
+onnx_ir/_enums.py,sha256=Pv7jaLzSjIX95MjCRUjo1_SHbOkUVEkm-rubacrEU7E,14372
+onnx_ir/_graph_comparison.py,sha256=8_D1gu547eCDotEUqxfIJhUGU_Ufhfji7sfsSraOj3g,727
+onnx_ir/_graph_containers.py,sha256=PRKrshRZ5rzWCgRs1TefzJq9n8wyo7OqeKy3XxMhyys,14265
+onnx_ir/_io.py,sha256=dA2_mJCxvBBS_0cK6YW_vuuaCuxXnsZdqKNmYx2q_gM,5205
+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=PHJtdhATDNwnfocIpvQUNM2dPn1sxfGbU1JPhFDvoIA,21667
+onnx_ir/_tape.py,sha256=kVTejszu7ljRm3qACbgVNJL4YXMSpiq1Vu49VBRggYU,8148
+onnx_ir/_type_casting.py,sha256=GgGcAV6f2mzwHFcHCI9Xd-TBYwxAhcKt3U5PCP9VXOU,3195
+onnx_ir/_version_utils.py,sha256=bZThuE7meVHFOY1DLsmss9WshVIp9iig7udGfDbVaK4,1333
+onnx_ir/convenience.py,sha256=ZK-m9LNcDWRvBl9ebHfL5C1bpmTu9z61MGYJ4brbews,984
+onnx_ir/external_data.py,sha256=uIrcz1iqrUADx1MJFhw4zh-QHgF31rC4kz5i_4AfG94,19013
+onnx_ir/py.typed,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+onnx_ir/serde.py,sha256=PVefkYfyNjgF2z8rRE1SfO8645aAHUHDDKiIRheTTVk,81423
+onnx_ir/tape.py,sha256=4FyfAHmVhQoMsfHMYnBwP2azi6UF6b6pj--ercObqZs,350
+onnx_ir/tensor_adapters.py,sha256=KPZba59Jd17lKsypptUpu-Q8SzhoxDy4eOMKJBDtZUc,8123
+onnx_ir/testing.py,sha256=WTrjf2joWizDWaYMJlV1KjZMQw7YmZ8NvuBTVn1uY6s,8803
+onnx_ir/traversal.py,sha256=Wy4XphwuapAvm94-5iaz6G8LjIoMFpY7qfPfXzYViEE,4488
+onnx_ir/_convenience/__init__.py,sha256=h6U_F20fM6YjBsWfdj00tvWnzhmKlIuJ5jORQww-RR0,21268
+onnx_ir/_convenience/_constructors.py,sha256=HqCGtNPMzFFEerC7I5VEyMdBuIdOJDucn9UEdwuymcg,11519
+onnx_ir/_convenience/_extractor.py,sha256=QsaSqnhFT1nSwLMKEXI7iPJN5sI_S7rwazuYwoqP0P8,7452
+onnx_ir/_safetensors/__init__.py,sha256=f6d0xtgTIK9v9JKPuovQ4eR14kowFbHJT-ItGJu2FyU,18808
+onnx_ir/_thirdparty/asciichartpy.py,sha256=afQ0fsqko2uYRPAR4TZBrQxvCb4eN8lxZ2yDFbVQq_s,10533
+onnx_ir/analysis/__init__.py,sha256=Wk21u0f9rYCFTh-WBIbCUXRPZtK_Y_BGh7nmjOygTJk,503
+onnx_ir/analysis/_implicit_usage.py,sha256=03nEZieao_xAhlfR5Y6qlYd61cfumV8MoteLX34MOfM,2575
+onnx_ir/passes/__init__.py,sha256=IHMsZowNOmu18OyMt-fc-2tCGMZBAJq_BRLKW3sauaw,804
+onnx_ir/passes/_pass_infra.py,sha256=6x8ku-LbKKjZ4v_SXy2PkSvC5zT-rDE-KqOr1iD_cU0,11399
+onnx_ir/passes/common/__init__.py,sha256=c2Jswbg-bgMav-abEhdAS2YAmqJXQKtwB2MFawbT_IQ,1919
+onnx_ir/passes/common/_c_api_utils.py,sha256=g6riA6xNGVWaO5YjVHZ0krrfslWHmRlryRkwB8X56cg,2907
+onnx_ir/passes/common/clear_metadata_and_docstring.py,sha256=YwouLfsNFSaTuGd7uMOGjdvVwG9yHQTkSphUgDlM0ME,2365
+onnx_ir/passes/common/common_subexpression_elimination.py,sha256=p5hZjWyswn8qm91M6BqlqMUBu78ohxaw72Ky12zrPZ0,7949
+onnx_ir/passes/common/constant_manipulation.py,sha256=qKC--Mr8IzrXPmr6xKJKOVO54M9wh8Ruho423LQ1mfU,9375
+onnx_ir/passes/common/default_attributes.py,sha256=LI-cZagYoW5n32ywz8LpMQv2gcDiRUnpQ2V5kBzwPfc,3470
+onnx_ir/passes/common/identity_elimination.py,sha256=90HYaq4QYUilHMyRoN_qhwWt0bQpqm5Z69KNU_7z_As,4376
+onnx_ir/passes/common/initializer_deduplication.py,sha256=2OK6h6cLp2VmfT5VUxsknsRXr1fgbY2w5npn0hV1cdE,7221
+onnx_ir/passes/common/inliner.py,sha256=z7Yq1yGr_KmsrpPGkJCqjh-mXBgcXE_0YrH04XPNqNM,9373
+onnx_ir/passes/common/naming.py,sha256=0SgYItShUIFlZLmaMw0aYfGMEthd1PaQMMrqFYNK26s,10769
+onnx_ir/passes/common/onnx_checker.py,sha256=_sPmJ2ff9pDB1g9q7082BL6fyubomRaj6svE0cCyDew,1691
+onnx_ir/passes/common/output_fix.py,sha256=B5jQjJhtvPR5SSAcNLAg9IaNu_sXRdshRWl7ds_R-44,5304
+onnx_ir/passes/common/shape_inference.py,sha256=LVdvxjeKtcIEbPcb6mKisxoPJOOawzsm3tzk5j9xqeM,3992
+onnx_ir/passes/common/topological_sort.py,sha256=LqZ2ELD7RoXRGSrvo5kgbgQMdatjt9hHGBek9XIEfy4,1151
+onnx_ir/passes/common/unused_removal.py,sha256=BarXGpukPF4qlWdm_K7KfK9gQD9p5cFG5XNeo1wl5W8,8208
+onnx_ir-0.1.15.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+onnx_ir-0.1.15.dist-info/METADATA,sha256=6w6ljZycHmEH1sM5T-uLKGZNMSN0e98eW4jXGaqXwak,3238
+onnx_ir-0.1.15.dist-info/WHEEL,sha256=qELbo2s1Yzl39ZmrAibXA2jjPLUYfnVhUNTlyF1rq0Y,92
+onnx_ir-0.1.15.dist-info/top_level.txt,sha256=W5tROO93YjO0XRxIdjMy4wocp-5st5GiI2ukvW7UhDo,8
+onnx_ir-0.1.15.dist-info/RECORD,,

onnx_ir-0.1.15.dist-info/WHEEL

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