onnx-ir 0.1.4__tar.gz → 0.1.6__tar.gz

{onnx_ir-0.1.4/src/onnx_ir.egg-info → onnx_ir-0.1.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: onnx-ir
-Version: 0.1.4
+Version: 0.1.6
 Summary: Efficient in-memory representation for ONNX
 Author-email: ONNX Contributors <onnx-technical-discuss@lists.lfaidata.foundation>
 License: Apache License v2.0
@@ -29,7 +29,7 @@ Dynamic: license-file
 [![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)
+[![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.
 

{onnx_ir-0.1.4 → onnx_ir-0.1.6}/README.md

@@ -4,7 +4,7 @@
 [![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)
+[![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.
 

{onnx_ir-0.1.4 → onnx_ir-0.1.6}/src/onnx_ir/__init__.py

@@ -167,4 +167,4 @@ def __set_module() -> None:
 
 
 __set_module()
-__version__ = "0.1.4"
+__version__ = "0.1.6"

{onnx_ir-0.1.4 → onnx_ir-0.1.6}/src/onnx_ir/_core.py

@@ -78,6 +78,7 @@ _NON_NUMPY_NATIVE_TYPES = frozenset(
         _enums.DataType.FLOAT8E4M3FNUZ,
         _enums.DataType.FLOAT8E5M2,
         _enums.DataType.FLOAT8E5M2FNUZ,
+        _enums.DataType.FLOAT8E8M0,
         _enums.DataType.INT4,
         _enums.DataType.UINT4,
         _enums.DataType.FLOAT4E2M1,
@@ -261,6 +262,7 @@ def _check_numpy_representation_type(array: np.ndarray, dtype: _enums.DataType)
             ml_dtypes.float8_e4m3fn,
             ml_dtypes.float8_e5m2fnuz,
             ml_dtypes.float8_e5m2,
+            ml_dtypes.float8_e8m0fnu,
         ):
             raise TypeError(
                 f"The numpy array dtype must be uint8 or ml_dtypes.float8* (not {array.dtype}) for IR data type {dtype}."
@@ -319,6 +321,8 @@ def _maybe_view_np_array_with_ml_dtypes(
         return array.view(ml_dtypes.float8_e5m2)
     if dtype == _enums.DataType.FLOAT8E5M2FNUZ:
         return array.view(ml_dtypes.float8_e5m2fnuz)
+    if dtype == _enums.DataType.FLOAT8E8M0:
+        return array.view(ml_dtypes.float8_e8m0fnu)
     if dtype == _enums.DataType.INT4:
         return array.view(ml_dtypes.int4)
     if dtype == _enums.DataType.UINT4:

{onnx_ir-0.1.4 → onnx_ir-0.1.6}/src/onnx_ir/_enums.py

@@ -65,6 +65,7 @@ class DataType(enum.IntEnum):
     UINT4 = 21
     INT4 = 22
     FLOAT4E2M1 = 23
+    FLOAT8E8M0 = 24
 
     @classmethod
     def from_numpy(cls, dtype: np.dtype) -> DataType:
@@ -81,6 +82,7 @@ class DataType(enum.IntEnum):
 
         # Special cases for handling custom dtypes defined in ONNX (as of onnx 1.18)
         # Ref: https://github.com/onnx/onnx/blob/2d42b6a60a52e925e57c422593e88cc51890f58a/onnx/_custom_element_types.py
+        # TODO(#137): Remove this when ONNX 1.19 is the minimum requirement
         if hasattr(dtype, "names"):
             if dtype.names == ("bfloat16",):
                 return DataType.BFLOAT16
@@ -167,6 +169,7 @@ class DataType(enum.IntEnum):
             DataType.FLOAT8E5M2,
             DataType.FLOAT8E5M2FNUZ,
             DataType.FLOAT4E2M1,
+            DataType.FLOAT8E8M0,
         }
 
     def is_integer(self) -> bool:
@@ -209,6 +212,7 @@ class DataType(enum.IntEnum):
             DataType.FLOAT8E5M2FNUZ,
             DataType.INT4,
             DataType.FLOAT4E2M1,
+            DataType.FLOAT8E8M0,
         }
 
     def __repr__(self) -> str:
@@ -241,6 +245,7 @@ _BITWIDTH_MAP = {
     DataType.UINT4: 4,
     DataType.INT4: 4,
     DataType.FLOAT4E2M1: 4,
+    DataType.FLOAT8E8M0: 8,
 }
 
 
@@ -266,6 +271,7 @@ _NP_TYPE_TO_DATA_TYPE = {
     np.dtype(ml_dtypes.float8_e4m3fnuz): DataType.FLOAT8E4M3FNUZ,
     np.dtype(ml_dtypes.float8_e5m2): DataType.FLOAT8E5M2,
     np.dtype(ml_dtypes.float8_e5m2fnuz): DataType.FLOAT8E5M2FNUZ,
+    np.dtype(ml_dtypes.float8_e8m0fnu): DataType.FLOAT8E8M0,
     np.dtype(ml_dtypes.int4): DataType.INT4,
     np.dtype(ml_dtypes.uint4): DataType.UINT4,
 }
@@ -290,6 +296,7 @@ _DATA_TYPE_TO_SHORT_NAME = {
     DataType.FLOAT8E5M2: "f8e5m2",
     DataType.FLOAT8E4M3FNUZ: "f8e4m3fnuz",
     DataType.FLOAT8E5M2FNUZ: "f8e5m2fnuz",
+    DataType.FLOAT8E8M0: "f8e8m0",
     DataType.FLOAT4E2M1: "f4e2m1",
     DataType.COMPLEX64: "c64",
     DataType.COMPLEX128: "c128",

{onnx_ir-0.1.4 → onnx_ir-0.1.6}/src/onnx_ir/passes/common/__init__.py

@@ -7,9 +7,11 @@ __all__ = [
     "ClearMetadataAndDocStringPass",
     "CommonSubexpressionEliminationPass",
     "DeduplicateInitializersPass",
+    "IdentityEliminationPass",
     "InlinePass",
     "LiftConstantsToInitializersPass",
     "LiftSubgraphInitializersToMainGraphPass",
+    "NameFixPass",
     "RemoveInitializersFromInputsPass",
     "RemoveUnusedFunctionsPass",
     "RemoveUnusedNodesPass",
@@ -30,10 +32,14 @@ from onnx_ir.passes.common.constant_manipulation import (
     LiftSubgraphInitializersToMainGraphPass,
     RemoveInitializersFromInputsPass,
 )
+from onnx_ir.passes.common.identity_elimination import (
+    IdentityEliminationPass,
+)
 from onnx_ir.passes.common.initializer_deduplication import (
     DeduplicateInitializersPass,
 )
 from onnx_ir.passes.common.inliner import InlinePass
+from onnx_ir.passes.common.naming import NameFixPass
 from onnx_ir.passes.common.onnx_checker import CheckerPass
 from onnx_ir.passes.common.shape_inference import ShapeInferencePass
 from onnx_ir.passes.common.topological_sort import TopologicalSortPass

onnx_ir-0.1.6/src/onnx_ir/passes/common/identity_elimination.py

@@ -0,0 +1,97 @@
+# Copyright (c) ONNX Project Contributors
+# SPDX-License-Identifier: Apache-2.0
+"""Identity elimination pass for removing redundant Identity nodes."""
+
+from __future__ import annotations
+
+__all__ = [
+    "IdentityEliminationPass",
+]
+
+import logging
+
+import onnx_ir as ir
+
+logger = logging.getLogger(__name__)
+
+
+class IdentityEliminationPass(ir.passes.InPlacePass):
+    """Pass for eliminating redundant Identity nodes.
+
+    This pass removes Identity nodes according to the following rules:
+    1. For any node of the form `y = Identity(x)`, where `y` is not an output
+       of any graph, replace all uses of `y` with a use of `x`, and remove the node.
+    2. If `y` is an output of a graph, and `x` is not an input of any graph,
+       we can still do the elimination, but the value `x` should be renamed to be `y`.
+    3. If `y` is a graph-output and `x` is a graph-input, we cannot eliminate
+       the node. It should be retained.
+    """
+
+    def call(self, model: ir.Model) -> ir.passes.PassResult:
+        """Main entry point for the identity elimination pass."""
+        modified = False
+
+        # Use RecursiveGraphIterator to process all nodes in the model graph and subgraphs
+        for node in ir.traversal.RecursiveGraphIterator(model.graph):
+            if self._try_eliminate_identity_node(node):
+                modified = True
+
+        # Process nodes in functions
+        for function in model.functions.values():
+            for node in ir.traversal.RecursiveGraphIterator(function):
+                if self._try_eliminate_identity_node(node):
+                    modified = True
+
+        if modified:
+            logger.info("Identity elimination pass modified the model")
+
+        return ir.passes.PassResult(model, modified=modified)
+
+    def _try_eliminate_identity_node(self, node: ir.Node) -> bool:
+        """Try to eliminate a single identity node. Returns True if modified."""
+        if node.op_type != "Identity" or node.domain != "":
+            return False
+
+        if len(node.inputs) != 1 or len(node.outputs) != 1:
+            # Invalid Identity node, skip
+            return False
+
+        input_value = node.inputs[0]
+        output_value = node.outputs[0]
+
+        if input_value is None:
+            # Cannot eliminate if input is None
+            return False
+
+        # Get the graph that contains this node
+        graph_like = node.graph
+        assert graph_like is not None, "Node must be in a graph"
+
+        output_is_graph_output = output_value.is_graph_output()
+        input_is_graph_input = input_value.is_graph_input()
+
+        # Case 3: Both output is graph output and input is graph input - keep the node
+        if output_is_graph_output and input_is_graph_input:
+            return False
+
+        # Case 1 & 2 (merged): Eliminate the identity node
+        # Replace all uses of output with input
+        ir.convenience.replace_all_uses_with(output_value, input_value)
+
+        # If output is a graph output, we need to rename input and update graph outputs
+        if output_is_graph_output:
+            # Store the original output name
+            original_output_name = output_value.name
+
+            # Update the input value to have the output's name
+            input_value.name = original_output_name
+
+            # Update graph outputs to point to the input value
+            for idx, graph_output in enumerate(graph_like.outputs):
+                if graph_output is output_value:
+                    graph_like.outputs[idx] = input_value
+
+        # Remove the identity node
+        graph_like.remove(node, safe=True)
+        logger.debug("Eliminated identity node: %s", node)
+        return True

onnx_ir-0.1.6/src/onnx_ir/passes/common/naming.py

@@ -0,0 +1,286 @@
+# Copyright (c) ONNX Project Contributors
+# SPDX-License-Identifier: Apache-2.0
+"""Name fix pass for ensuring unique names for all values and nodes."""
+
+from __future__ import annotations
+
+__all__ = [
+    "NameFixPass",
+    "NameGenerator",
+    "SimpleNameGenerator",
+]
+
+import collections
+import logging
+from typing import Protocol
+
+import onnx_ir as ir
+
+logger = logging.getLogger(__name__)
+
+
+class NameGenerator(Protocol):
+    def generate_node_name(self, node: ir.Node) -> str:
+        """Generate a preferred name for a node."""
+        ...
+
+    def generate_value_name(self, value: ir.Value) -> str:
+        """Generate a preferred name for a value."""
+        ...
+
+
+class SimpleNameGenerator(NameGenerator):
+    """Base class for name generation functions."""
+
+    def generate_node_name(self, node: ir.Node) -> str:
+        """Generate a preferred name for a node."""
+        return node.name or "node"
+
+    def generate_value_name(self, value: ir.Value) -> str:
+        """Generate a preferred name for a value."""
+        return value.name or "v"
+
+
+class NameFixPass(ir.passes.InPlacePass):
+    """Pass for fixing names to ensure all values and nodes have unique names.
+
+    This pass ensures that:
+    1. Graph inputs and outputs have unique names (take precedence)
+    2. All intermediate values have unique names (assign names to unnamed values)
+    3. All values in subgraphs have unique names within their graph and parent graphs
+    4. All nodes have unique names within their graph
+
+    The pass maintains global uniqueness across the entire model.
+
+    You can customize the name generation functions for nodes and values by passing
+    a subclass of :class:`NameGenerator`.
+
+    For example, you can use a custom naming scheme like this::
+
+        class CustomNameGenerator:
+            def custom_node_name(node: ir.Node) -> str:
+                return f"custom_node_{node.op_type}"
+
+            def custom_value_name(value: ir.Value) -> str:
+                return f"custom_value_{value.type}"
+
+        name_fix_pass = NameFixPass(nameGenerator=CustomNameGenerator())
+
+    .. versionadded:: 0.1.6
+    """
+
+    def __init__(
+        self,
+        name_generator: NameGenerator | None = None,
+    ) -> None:
+        """Initialize the NameFixPass with custom name generation functions.
+
+        Args:
+            name_generator (NameGenerator, optional): An instance of a subclass of
+                :class:`NameGenerator` to customize name generation for nodes and values.
+                If not provided, defaults to a basic implementation that uses
+                the node's or value's existing name or a generic name like "node" or "v".
+        """
+        super().__init__()
+        self._name_generator = name_generator or SimpleNameGenerator()
+
+    def call(self, model: ir.Model) -> ir.passes.PassResult:
+        # Process the main graph
+        modified = self._fix_graph_names(model.graph)
+
+        # Process functions
+        for function in model.functions.values():
+            modified = self._fix_graph_names(function) or modified
+
+        return ir.passes.PassResult(model, modified=modified)
+
+    def _fix_graph_names(self, graph_like: ir.Graph | ir.Function) -> bool:
+        """Fix names in a graph and return whether modifications were made."""
+        modified = False
+
+        # Set to track which values have been assigned names
+        seen_values: set[ir.Value] = set()
+
+        # The first set is a dummy placeholder so that there is always a [-1] scope for access
+        # (even though we don't write to it)
+        scoped_used_value_names: list[set[str]] = [set()]
+        scoped_used_node_names: list[set[str]] = [set()]
+
+        # Counters for generating unique names (using list to pass by reference)
+        value_counter = collections.Counter()
+        node_counter = collections.Counter()
+
+        def enter_graph(graph_like) -> None:
+            """Callback for entering a subgraph."""
+            # Initialize new scopes with all names from the parent scope
+            scoped_used_value_names.append(set(scoped_used_value_names[-1]))
+            scoped_used_node_names.append(set())
+
+            nonlocal modified
+
+            # Step 1: Fix graph input names first (they have precedence)
+            for input_value in graph_like.inputs:
+                if self._process_value(
+                    input_value, scoped_used_value_names[-1], seen_values, value_counter
+                ):
+                    modified = True
+
+            # Step 2: Fix graph output names (they have precedence)
+            for output_value in graph_like.outputs:
+                if self._process_value(
+                    output_value, scoped_used_value_names[-1], seen_values, value_counter
+                ):
+                    modified = True
+
+            if isinstance(graph_like, ir.Graph):
+                # For graphs, also fix initializers
+                for initializer in graph_like.initializers.values():
+                    if self._process_value(
+                        initializer, scoped_used_value_names[-1], seen_values, value_counter
+                    ):
+                        modified = True
+
+        def exit_graph(_) -> None:
+            """Callback for exiting a subgraph."""
+            # Pop the current scope
+            scoped_used_value_names.pop()
+            scoped_used_node_names.pop()
+
+        # Step 3: Process all nodes and their values
+        for node in ir.traversal.RecursiveGraphIterator(
+            graph_like, enter_graph=enter_graph, exit_graph=exit_graph
+        ):
+            # Fix node name
+            if not node.name:
+                if self._assign_node_name(node, scoped_used_node_names[-1], node_counter):
+                    modified = True
+            else:
+                if self._fix_duplicate_node_name(
+                    node, scoped_used_node_names[-1], node_counter
+                ):
+                    modified = True
+
+            # Fix input value names (only if not already processed)
+            for input_value in node.inputs:
+                if input_value is not None:
+                    if self._process_value(
+                        input_value, scoped_used_value_names[-1], seen_values, value_counter
+                    ):
+                        modified = True
+
+            # Fix output value names (only if not already processed)
+            for output_value in node.outputs:
+                if self._process_value(
+                    output_value, scoped_used_value_names[-1], seen_values, value_counter
+                ):
+                    modified = True
+
+        return modified
+
+    def _process_value(
+        self,
+        value: ir.Value,
+        used_value_names: set[str],
+        seen_values: set[ir.Value],
+        value_counter: collections.Counter,
+    ) -> bool:
+        """Process a value only if it hasn't been processed before."""
+        if value in seen_values:
+            return False
+
+        modified = False
+
+        if not value.name:
+            modified = self._assign_value_name(value, used_value_names, value_counter)
+        else:
+            old_name = value.name
+            modified = self._fix_duplicate_value_name(value, used_value_names, value_counter)
+            if modified:
+                assert value.graph is not None
+                if value.is_initializer():
+                    value.graph.initializers.pop(old_name)
+                    # Add the initializer back with the new name
+                    value.graph.initializers.add(value)
+
+        # Record the final name for this value
+        assert value.name is not None
+        seen_values.add(value)
+        return modified
+
+    def _assign_value_name(
+        self, value: ir.Value, used_names: set[str], counter: collections.Counter
+    ) -> bool:
+        """Assign a name to an unnamed value. Returns True if modified."""
+        assert not value.name, (
+            "value should not have a name already if function is called correctly"
+        )
+
+        preferred_name = self._name_generator.generate_value_name(value)
+        value.name = _find_and_record_next_unique_name(preferred_name, used_names, counter)
+        logger.debug("Assigned name %s to unnamed value", value.name)
+        return True
+
+    def _assign_node_name(
+        self, node: ir.Node, used_names: set[str], counter: collections.Counter
+    ) -> bool:
+        """Assign a name to an unnamed node. Returns True if modified."""
+        assert not node.name, (
+            "node should not have a name already if function is called correctly"
+        )
+
+        preferred_name = self._name_generator.generate_node_name(node)
+        node.name = _find_and_record_next_unique_name(preferred_name, used_names, counter)
+        logger.debug("Assigned name %s to unnamed node", node.name)
+        return True
+
+    def _fix_duplicate_value_name(
+        self, value: ir.Value, used_names: set[str], counter: collections.Counter
+    ) -> bool:
+        """Fix a value's name if it conflicts with existing names. Returns True if modified."""
+        original_name = value.name
+
+        assert original_name, (
+            "value should have a name already if function is called correctly"
+        )
+
+        if original_name not in used_names:
+            # Name is unique, just record it
+            used_names.add(original_name)
+            return False
+
+        # If name is already used, make it unique
+        base_name = self._name_generator.generate_value_name(value)
+        value.name = _find_and_record_next_unique_name(base_name, used_names, counter)
+        logger.debug("Renamed value from %s to %s for uniqueness", original_name, value.name)
+        return True
+
+    def _fix_duplicate_node_name(
+        self, node: ir.Node, used_names: set[str], counter: collections.Counter
+    ) -> bool:
+        """Fix a node's name if it conflicts with existing names. Returns True if modified."""
+        original_name = node.name
+
+        assert original_name, "node should have a name already if function is called correctly"
+
+        if original_name not in used_names:
+            # Name is unique, just record it
+            used_names.add(original_name)
+            return False
+
+        # If name is already used, make it unique
+        base_name = self._name_generator.generate_node_name(node)
+        node.name = _find_and_record_next_unique_name(base_name, used_names, counter)
+        logger.debug("Renamed node from %s to %s for uniqueness", original_name, node.name)
+        return True
+
+
+def _find_and_record_next_unique_name(
+    preferred_name: str, used_names: set[str], counter: collections.Counter
+) -> str:
+    """Generate a unique name based on the preferred name and current counter."""
+    new_name = preferred_name
+    while new_name in used_names:
+        counter[preferred_name] += 1
+        new_name = f"{preferred_name}_{counter[preferred_name]}"
+    used_names.add(new_name)
+    return new_name

{onnx_ir-0.1.4 → onnx_ir-0.1.6}/src/onnx_ir/serde.py

@@ -405,6 +405,7 @@ class TensorProtoTensor(_core.TensorBase):  # pylint: disable=too-many-ancestors
                 _enums.DataType.FLOAT8E4M3FNUZ,
                 _enums.DataType.FLOAT8E5M2,
                 _enums.DataType.FLOAT8E5M2FNUZ,
+                _enums.DataType.FLOAT8E8M0,
                 _enums.DataType.INT16,
                 _enums.DataType.INT32,
                 _enums.DataType.INT4,
@@ -505,6 +506,7 @@ class TensorProtoTensor(_core.TensorBase):  # pylint: disable=too-many-ancestors
                 _enums.DataType.FLOAT8E4M3FNUZ,
                 _enums.DataType.FLOAT8E5M2,
                 _enums.DataType.FLOAT8E5M2FNUZ,
+                _enums.DataType.FLOAT8E8M0,
                 _enums.DataType.INT4,
                 _enums.DataType.UINT4,
                 _enums.DataType.FLOAT4E2M1,

{onnx_ir-0.1.4 → onnx_ir-0.1.6}/src/onnx_ir/tensor_adapters.py

@@ -77,6 +77,10 @@ def from_torch_dtype(dtype: torch.dtype) -> ir.DataType:
             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 dtype not in _TORCH_DTYPE_TO_ONNX:
         raise TypeError(
             f"Unsupported PyTorch dtype '{dtype}'. "
@@ -113,7 +117,17 @@ def to_torch_dtype(dtype: ir.DataType) -> torch.dtype:
             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 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: "
@@ -142,6 +156,7 @@ class TorchTensor(_core.Tensor):
             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())
 

{onnx_ir-0.1.4 → onnx_ir-0.1.6}/src/onnx_ir/traversal.py

@@ -25,19 +25,33 @@ class RecursiveGraphIterator(Iterator[_core.Node], Reversible[_core.Node]):
         *,
         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)
@@ -50,34 +64,55 @@ class RecursiveGraphIterator(Iterator[_core.Node], Reversible[_core.Node]):
         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.4 → onnx_ir-0.1.6/src/onnx_ir.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: onnx-ir
-Version: 0.1.4
+Version: 0.1.6
 Summary: Efficient in-memory representation for ONNX
 Author-email: ONNX Contributors <onnx-technical-discuss@lists.lfaidata.foundation>
 License: Apache License v2.0
@@ -29,7 +29,7 @@ Dynamic: license-file
 [![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)
+[![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.
 

{onnx_ir-0.1.4 → onnx_ir-0.1.6}/src/onnx_ir.egg-info/SOURCES.txt

@@ -40,8 +40,10 @@ src/onnx_ir/passes/common/_c_api_utils.py
 src/onnx_ir/passes/common/clear_metadata_and_docstring.py
 src/onnx_ir/passes/common/common_subexpression_elimination.py
 src/onnx_ir/passes/common/constant_manipulation.py
+src/onnx_ir/passes/common/identity_elimination.py
 src/onnx_ir/passes/common/initializer_deduplication.py
 src/onnx_ir/passes/common/inliner.py
+src/onnx_ir/passes/common/naming.py
 src/onnx_ir/passes/common/onnx_checker.py
 src/onnx_ir/passes/common/shape_inference.py
 src/onnx_ir/passes/common/topological_sort.py