onnx-ir 0.1.5__py3-none-any.whl → 0.1.7__py3-none-any.whl

onnx_ir/__init__.py

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

onnx_ir/_convenience/__init__.py

@@ -58,44 +58,52 @@ def _infer_attribute_type(attr: SupportedAttrTypes) -> _enums.AttributeType:
         return _enums.AttributeType.STRING
     if isinstance(attr, _core.Attr):
         return attr.type
-    if isinstance(attr, Sequence) and all(isinstance(x, int) for x in attr):
-        return _enums.AttributeType.INTS
-    if isinstance(attr, Sequence) and all(isinstance(x, float) for x in attr):
-        return _enums.AttributeType.FLOATS
-    if isinstance(attr, Sequence) and all(isinstance(x, str) for x in attr):
-        return _enums.AttributeType.STRINGS
+    if isinstance(attr, (_core.Graph, onnx.GraphProto, _protocols.GraphProtocol)):
+        return _enums.AttributeType.GRAPH
     if isinstance(attr, (_core.TensorBase, onnx.TensorProto, _protocols.TensorProtocol)):
         # Be sure to check TensorProtocol last because isinstance checking on Protocols can be slower
         return _enums.AttributeType.TENSOR
-    if isinstance(attr, Sequence) and all(
-        isinstance(x, (_core.TensorBase, onnx.TensorProto, _protocols.TensorProtocol))
-        for x in attr
-    ):
-        return _enums.AttributeType.TENSORS
-    if isinstance(attr, (_core.Graph, onnx.GraphProto, _protocols.GraphProtocol)):
-        return _enums.AttributeType.GRAPH
-    if isinstance(attr, Sequence) and all(
-        isinstance(x, (_core.Graph, onnx.GraphProto, _protocols.GraphProtocol)) for x in attr
-    ):
-        return _enums.AttributeType.GRAPHS
     if isinstance(
         attr,
         (_core.TensorType, _core.SequenceType, _core.OptionalType, _protocols.TypeProtocol),
     ):
         return _enums.AttributeType.TYPE_PROTO
-    if isinstance(attr, Sequence) and all(
-        isinstance(
-            x,
-            (
-                _core.TensorType,
-                _core.SequenceType,
-                _core.OptionalType,
-                _protocols.TypeProtocol,
-            ),
-        )
-        for x in attr
-    ):
-        return _enums.AttributeType.TYPE_PROTOS
+    if isinstance(attr, Sequence):
+        if not attr:
+            logger.warning(
+                "Attribute type is ambiguous because it is an empty sequence. "
+                "Please create an Attr with an explicit type. Defaulted to INTS"
+            )
+            return _enums.AttributeType.INTS
+        if all(isinstance(x, int) for x in attr):
+            return _enums.AttributeType.INTS
+        if all(isinstance(x, float) for x in attr):
+            return _enums.AttributeType.FLOATS
+        if all(isinstance(x, str) for x in attr):
+            return _enums.AttributeType.STRINGS
+        if all(
+            isinstance(x, (_core.TensorBase, onnx.TensorProto, _protocols.TensorProtocol))
+            for x in attr
+        ):
+            return _enums.AttributeType.TENSORS
+        if all(
+            isinstance(x, (_core.Graph, onnx.GraphProto, _protocols.GraphProtocol))
+            for x in attr
+        ):
+            return _enums.AttributeType.GRAPHS
+        if all(
+            isinstance(
+                x,
+                (
+                    _core.TensorType,
+                    _core.SequenceType,
+                    _core.OptionalType,
+                    _protocols.TypeProtocol,
+                ),
+            )
+            for x in attr
+        ):
+            return _enums.AttributeType.TYPE_PROTOS
     raise TypeError(f"Unsupported attribute type: '{type(attr)}'")
 
 
@@ -218,7 +226,7 @@ def convert_attributes(
         ...     "type_protos": [ir.TensorType(ir.DataType.FLOAT), ir.TensorType(ir.DataType.FLOAT)],
         ... }
         >>> convert_attributes(attrs)
-        [Attr('int', INT, 1), Attr('float', FLOAT, 1.0), Attr('str', STRING, 'hello'), Attr('ints', INTS, [1, 2, 3]), Attr('floats', FLOATS, [1.0, 2.0, 3.0]), Attr('strings', STRINGS, ['hello', 'world']), Attr('tensor', TENSOR, Tensor<DOUBLE,[3]>(array([1., 2., 3.]), name=None)), Attr('tensor_proto', TENSOR, TensorProtoTensor<FLOAT,[3]>(array([1., 2., 3.], dtype=float32), name='proto')), Attr('graph', INTS, Graph(
+        [Attr('int', INT, 1), Attr('float', FLOAT, 1.0), Attr('str', STRING, 'hello'), Attr('ints', INTS, [1, 2, 3]), Attr('floats', FLOATS, [1.0, 2.0, 3.0]), Attr('strings', STRINGS, ['hello', 'world']), Attr('tensor', TENSOR, Tensor<DOUBLE,[3]>(array([1., 2., 3.]), name=None)), Attr('tensor_proto', TENSOR, TensorProtoTensor<FLOAT,[3]>(array([1., 2., 3.], dtype=float32), name='proto')), Attr('graph', GRAPH, Graph(
             name='graph0',
             inputs=(
         <BLANKLINE>
@@ -247,11 +255,20 @@ def convert_attributes(
             len()=0
         )]), Attr('type_proto', TYPE_PROTO, Tensor(FLOAT)), Attr('type_protos', TYPE_PROTOS, [Tensor(FLOAT), Tensor(FLOAT)])]
 
+    .. important::
+        An empty sequence should be created with an explicit type by initializing
+        an Attr object with an attribute type to avoid type ambiguity. For example::
+
+            ir.Attr("empty", [], type=ir.AttributeType.INTS)
+
     Args:
         attrs: A dictionary of {<attribute name>: <python objects>} to convert.
 
     Returns:
-        A list of _core.Attr objects.
+        A list of :class:`_core.Attr` objects.
+
+    Raises:
+        TypeError: If an attribute type is not supported.
     """
     attributes: list[_core.Attr] = []
     for name, attr in attrs.items():

onnx_ir/_core.py

@@ -2564,14 +2564,23 @@ class Graph(_protocols.GraphProtocol, Sequence[Node], _display.PrettyPrintable):
 
         .. versionadded:: 0.1.2
         """
-        seen_graphs: set[Graph] = set()
-        for node in onnx_ir.traversal.RecursiveGraphIterator(self):
-            graph = node.graph
+        # Use a dict to preserve order
+        seen_graphs: dict[Graph, None] = {}
+
+        # Need to use the enter_graph callback so that empty subgraphs are collected
+        def enter_subgraph(graph) -> None:
             if graph is self:
-                continue
-            if graph is not None and graph not in seen_graphs:
-                seen_graphs.add(graph)
-                yield graph
+                return
+            if not isinstance(graph, Graph):
+                raise TypeError(
+                    f"Expected a Graph, got {type(graph)}. The model may be invalid"
+                )
+            if graph not in seen_graphs:
+                seen_graphs[graph] = None
+
+        for _ in onnx_ir.traversal.RecursiveGraphIterator(self, enter_graph=enter_subgraph):
+            pass
+        yield from seen_graphs.keys()
 
     # Mutation methods
     def append(self, node: Node, /) -> None:
@@ -3180,6 +3189,21 @@ class Function(_protocols.FunctionProtocol, Sequence[Node], _display.PrettyPrint
     def attributes(self) -> _graph_containers.Attributes:
         return self._attributes
 
+    @property
+    def graph(self) -> Graph:
+        """The underlying Graph object that contains the nodes of this function.
+
+        Only use this graph for identity comparison::
+
+            if value.graph is function.graph:
+                # Do something with the value that belongs to this function
+
+        Otherwise use the Function object directly to access the nodes and other properties.
+
+        .. versionadded:: 0.1.7
+        """
+        return self._graph
+
     @typing.overload
     def __getitem__(self, index: int) -> Node: ...
     @typing.overload
@@ -3240,14 +3264,22 @@ class Function(_protocols.FunctionProtocol, Sequence[Node], _display.PrettyPrint
 
         .. versionadded:: 0.1.2
         """
-        seen_graphs: set[Graph] = set()
-        for node in onnx_ir.traversal.RecursiveGraphIterator(self):
-            graph = node.graph
-            if graph is self._graph:
-                continue
-            if graph is not None and graph not in seen_graphs:
-                seen_graphs.add(graph)
-                yield graph
+        seen_graphs: dict[Graph, None] = {}
+
+        # Need to use the enter_graph callback so that empty subgraphs are collected
+        def enter_subgraph(graph) -> None:
+            if graph is self:
+                return
+            if not isinstance(graph, Graph):
+                raise TypeError(
+                    f"Expected a Graph, got {type(graph)}. The model may be invalid"
+                )
+            if graph not in seen_graphs:
+                seen_graphs[graph] = None
+
+        for _ in onnx_ir.traversal.RecursiveGraphIterator(self, enter_graph=enter_subgraph):
+            pass
+        yield from seen_graphs.keys()
 
     # Mutation methods
     def append(self, node: Node, /) -> None:
@@ -3349,7 +3381,7 @@ class Attr(
 ):
     """Base class for ONNX attributes or references."""
 
-    __slots__ = ("_name", "_ref_attr_name", "_type", "_value", "doc_string")
+    __slots__ = ("_metadata", "_name", "_ref_attr_name", "_type", "_value", "doc_string")
 
     def __init__(
         self,
@@ -3365,6 +3397,7 @@ class Attr(
         self._value = value
         self._ref_attr_name = ref_attr_name
         self.doc_string = doc_string
+        self._metadata: _metadata.MetadataStore | None = None
 
     @property
     def name(self) -> str:
@@ -3386,6 +3419,17 @@ class Attr(
     def ref_attr_name(self) -> str | None:
         return self._ref_attr_name
 
+    @property
+    def meta(self) -> _metadata.MetadataStore:
+        """The metadata store for intermediate analysis.
+
+        Write to the :attr:`metadata_props` if you would like the metadata to be serialized
+        to the ONNX proto.
+        """
+        if self._metadata is None:
+            self._metadata = _metadata.MetadataStore()
+        return self._metadata
+
     def is_ref(self) -> bool:
         """Check if this attribute is a reference attribute."""
         return self.ref_attr_name is not None

onnx_ir/passes/common/__init__.py

@@ -6,11 +6,13 @@ __all__ = [
     "CheckerPass",
     "ClearMetadataAndDocStringPass",
     "CommonSubexpressionEliminationPass",
+    "DeduplicateHashedInitializersPass",
     "DeduplicateInitializersPass",
     "IdentityEliminationPass",
     "InlinePass",
     "LiftConstantsToInitializersPass",
     "LiftSubgraphInitializersToMainGraphPass",
+    "NameFixPass",
     "RemoveInitializersFromInputsPass",
     "RemoveUnusedFunctionsPass",
     "RemoveUnusedNodesPass",
@@ -35,9 +37,11 @@ from onnx_ir.passes.common.identity_elimination import (
     IdentityEliminationPass,
 )
 from onnx_ir.passes.common.initializer_deduplication import (
+    DeduplicateHashedInitializersPass,
     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/passes/common/constant_manipulation.py

@@ -148,6 +148,7 @@ class LiftSubgraphInitializersToMainGraphPass(ir.passes.InPlacePass):
             if graph is model.graph:
                 continue
             for name in tuple(graph.initializers):
+                assert name is not None
                 initializer = graph.initializers[name]
                 if initializer.is_graph_input():
                     # Skip the ones that are also graph inputs
@@ -156,17 +157,24 @@ class LiftSubgraphInitializersToMainGraphPass(ir.passes.InPlacePass):
                         initializer.name,
                     )
                     continue
+                if initializer.is_graph_output():
+                    logger.debug(
+                        "Initializer '%s' is used as output, so it can't be lifted",
+                        initializer.name,
+                    )
+                    continue
                 # Remove the initializer from the subgraph
                 graph.initializers.pop(name)
                 # To avoid name conflicts, we need to rename the initializer
                 # to a unique name in the main graph
-                if name in registered_initializer_names:
-                    name_count = registered_initializer_names[name]
-                    initializer.name = f"{name}_{name_count}"
-                    registered_initializer_names[name] = name_count + 1
-                else:
-                    assert initializer.name is not None
-                    registered_initializer_names[initializer.name] = 1
+                new_name = name
+                while new_name in model.graph.initializers:
+                    if name in registered_initializer_names:
+                        registered_initializer_names[name] += 1
+                    else:
+                        registered_initializer_names[name] = 1
+                    new_name = f"{name}_{registered_initializer_names[name]}"
+                initializer.name = new_name
                 model.graph.register_initializer(initializer)
                 count += 1
                 logger.debug(

onnx_ir/passes/common/identity_elimination.py

@@ -19,6 +19,7 @@ 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,

onnx_ir/passes/common/initializer_deduplication.py

@@ -4,24 +4,68 @@
 
 from __future__ import annotations
 
-__all__ = [
-    "DeduplicateInitializersPass",
-]
+__all__ = ["DeduplicateInitializersPass", "DeduplicateHashedInitializersPass"]
 
 
+import hashlib
+import logging
+
 import onnx_ir as ir
 
+logger = logging.getLogger(__name__)
+
+
+def _should_skip_initializer(initializer: ir.Value, size_limit: int) -> bool:
+    """Check if the initializer should be skipped for deduplication."""
+    if initializer.is_graph_input() or initializer.is_graph_output():
+        # Skip graph inputs and outputs
+        logger.warning(
+            "Skipped deduplication of initializer '%s' as it is a graph input or output",
+            initializer.name,
+        )
+        return True
+
+    const_val = initializer.const_value
+    if const_val is None:
+        # Skip if initializer has no constant value
+        logger.warning(
+            "Skipped deduplication of initializer '%s' as it has no constant value. The model may contain invalid initializers",
+            initializer.name,
+        )
+        return True
+
+    if const_val.size > size_limit:
+        # Skip if the initializer is larger than the size limit
+        logger.debug(
+            "Skipped initializer '%s' as it exceeds the size limit of %d elements",
+            initializer.name,
+            size_limit,
+        )
+        return True
+
+    if const_val.dtype == ir.DataType.STRING:
+        # Skip string initializers as they don't have a bytes representation
+        logger.warning(
+            "Skipped deduplication of string initializer '%s' (unsupported yet)",
+            initializer.name,
+        )
+        return True
+    return False
+
 
 class DeduplicateInitializersPass(ir.passes.InPlacePass):
-    """Remove duplicated initializer tensors from the graph.
+    """Remove duplicated initializer tensors from the main graph and all subgraphs.
 
     This pass detects initializers with identical shape, dtype, and content,
     and replaces all duplicate references with a canonical one.
 
-    To deduplicate initializers from subgraphs, use :class:`~onnx_ir.passes.common.LiftSubgraphInitializersToMainGraphPass`
+    Initializers are deduplicated within each graph. To deduplicate initializers
+    in the model globally (across graphs), use :class:`~onnx_ir.passes.common.LiftSubgraphInitializersToMainGraphPass`
     to lift the initializers to the main graph first before running pass.
 
     .. versionadded:: 0.1.3
+    .. versionchanged:: 0.1.7
+        This pass now deduplicates initializers in subgraphs as well.
     """
 
     def __init__(self, size_limit: int = 1024):
@@ -29,28 +73,95 @@ class DeduplicateInitializersPass(ir.passes.InPlacePass):
         self.size_limit = size_limit
 
     def call(self, model: ir.Model) -> ir.passes.PassResult:
-        graph = model.graph
-        initializers: dict[tuple[ir.DataType, tuple[int, ...], bytes], ir.Value] = {}
         modified = False
 
-        for initializer in tuple(graph.initializers.values()):
-            # TODO(justinchuby): Handle subgraphs as well. For now users can lift initializers
-            # out from the main graph before running this pass.
-            const_val = initializer.const_value
-            if const_val is None:
-                # Skip if initializer has no constant value
-                continue
-
-            if const_val.size > self.size_limit:
-                continue
-
-            key = (const_val.dtype, tuple(const_val.shape), const_val.tobytes())
-            if key in initializers:
-                modified = True
-                ir.convenience.replace_all_uses_with(initializer, initializers[key])  # type: ignore[index]
-                assert initializer.name is not None
-                graph.initializers.pop(initializer.name)
-            else:
-                initializers[key] = initializer  # type: ignore[index]
+        for graph in model.graphs():
+            initializers: dict[tuple[ir.DataType, tuple[int, ...], bytes], ir.Value] = {}
+            for initializer in tuple(graph.initializers.values()):
+                if _should_skip_initializer(initializer, self.size_limit):
+                    continue
+
+                const_val = initializer.const_value
+                assert const_val is not None
+
+                key = (const_val.dtype, tuple(const_val.shape), const_val.tobytes())
+                if key in initializers:
+                    modified = True
+                    initializer_to_keep = initializers[key]  # type: ignore[index]
+                    ir.convenience.replace_all_uses_with(initializer, initializer_to_keep)
+                    assert initializer.name is not None
+                    graph.initializers.pop(initializer.name)
+                    logger.info(
+                        "Replaced initializer '%s' with existing initializer '%s'",
+                        initializer.name,
+                        initializer_to_keep.name,
+                    )
+                else:
+                    initializers[key] = initializer  # type: ignore[index]
+
+        return ir.passes.PassResult(model=model, modified=modified)
+
+
+class DeduplicateHashedInitializersPass(ir.passes.InPlacePass):
+    """Remove duplicated initializer tensors (using a hashed method) from the graph.
+
+    This pass detects initializers with identical shape, dtype, and hashed content,
+    and replaces all duplicate references with a canonical one.
+
+    This pass should have a lower peak memory usage than :class:`DeduplicateInitializersPass`
+    as it does not store the full tensor data in memory, but instead uses a hash of the tensor data.
+
+    .. versionadded:: 0.1.7
+    """
+
+    def __init__(self, size_limit: int = 4 * 1024 * 1024 * 1024):
+        super().__init__()
+        # 4 GB default size limit for deduplication
+        self.size_limit = size_limit
+
+    def call(self, model: ir.Model) -> ir.passes.PassResult:
+        modified = False
+
+        for graph in model.graphs():
+            initializers: dict[tuple[ir.DataType, tuple[int, ...], str], ir.Value] = {}
+
+            for initializer in tuple(graph.initializers.values()):
+                if _should_skip_initializer(initializer, self.size_limit):
+                    continue
+
+                const_val = initializer.const_value
+                assert const_val is not None
+
+                # Hash tensor data to avoid storing large amounts of data in memory
+                hashed = hashlib.sha512()
+                tensor_data = const_val.numpy()
+                hashed.update(tensor_data)
+                tensor_digest = hashed.hexdigest()
+
+                tensor_dims = tuple(const_val.shape.numpy())
+
+                key = (const_val.dtype, tensor_dims, tensor_digest)
+
+                if key in initializers:
+                    if initializers[key].const_value.tobytes() != const_val.tobytes():
+                        logger.warning(
+                            "Initializer deduplication failed: "
+                            "hashes match but values differ with values %s and %s",
+                            initializers[key],
+                            initializer,
+                        )
+                        continue
+                    modified = True
+                    initializer_to_keep = initializers[key]  # type: ignore[index]
+                    ir.convenience.replace_all_uses_with(initializer, initializer_to_keep)
+                    assert initializer.name is not None
+                    graph.initializers.pop(initializer.name)
+                    logger.info(
+                        "Replaced initializer '%s' with existing initializer '%s'",
+                        initializer.name,
+                        initializer_to_keep.name,
+                    )
+                else:
+                    initializers[key] = initializer  # type: ignore[index]
 
         return ir.passes.PassResult(model=model, modified=modified)

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(name_generator=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/serde.py

@@ -682,8 +682,8 @@ def deserialize_graph(proto: onnx.GraphProto) -> _core.Graph:
     Returns:
         IR Graph.
 
-    .. versionadded:: 0.3
-        Support for *quantization_annotation* is added.
+    .. versionadded:: 0.1.3
+        Support for `quantization_annotation` is added.
     """
     return _deserialize_graph(proto, [])
 
@@ -760,6 +760,18 @@ def _deserialize_graph(
     # Build the value info dictionary to allow for quick lookup for this graph scope
     value_info = {info.name: info for info in proto.value_info}
 
+    # Declare values for all node outputs from this graph scope. This is necessary
+    # to handle the case where a node in a subgraph uses a value that is declared out
+    # of order in the outer graph. Declaring the values first allows us to find the
+    # values later when deserializing the nodes in subgraphs.
+    for node in proto.node:
+        _declare_node_outputs(
+            node,
+            values,
+            value_info=value_info,
+            quantization_annotations=quantization_annotations,
+        )
+
     # Deserialize nodes with all known values
     nodes = [
         _deserialize_node(node, scoped_values, value_info, quantization_annotations)
@@ -798,6 +810,55 @@ def _deserialize_graph(
     )
 
 
+def _declare_node_outputs(
+    proto: onnx.NodeProto,
+    current_value_scope: dict[str, _core.Value],
+    value_info: dict[str, onnx.ValueInfoProto],
+    quantization_annotations: dict[str, onnx.TensorAnnotation],
+) -> None:
+    """Declare outputs for a node in the current graph scope.
+
+    This is necessary to handle the case where a node in a subgraph uses a value that is declared
+    out of order in the outer graph. Declaring the values first allows us to find the values later
+    when deserializing the nodes in subgraphs.
+
+    Args:
+        proto: The ONNX NodeProto to declare outputs for.
+        current_value_scope: The current scope of values, mapping value names to their corresponding Value objects.
+        value_info: A dictionary mapping value names to their corresponding ValueInfoProto.
+        quantization_annotations: A dictionary mapping tensor names to their corresponding TensorAnnotation.
+
+    Raises:
+        ValueError: If an output name is redeclared in the current graph scope.
+    """
+    for output_name in proto.output:
+        if output_name == "":
+            continue
+        if output_name in current_value_scope:
+            raise ValueError(
+                f"Output '{output_name}' is redeclared in the current graph scope. "
+                f"Original declaration {current_value_scope[output_name]}. "
+                f"New declaration: by operator '{proto.op_type}' of node '{proto.name}'. "
+                "The model is invalid"
+            )
+
+        # Create the value and add it to the current scope.
+        value = _core.Value(name=output_name)
+        current_value_scope[output_name] = value
+        # Fill in shape/type information if they exist
+        if output_name in value_info:
+            deserialize_value_info_proto(value_info[output_name], value)
+        else:
+            logger.debug(
+                "ValueInfoProto not found for output '%s' in node '%s' of type '%s'",
+                output_name,
+                proto.name,
+                proto.op_type,
+            )
+        if output_name in quantization_annotations:
+            _deserialize_quantization_annotation(quantization_annotations[output_name], value)
+
+
 @_capture_errors(lambda proto: proto.name)
 def deserialize_function(proto: onnx.FunctionProto) -> _core.Function:
     """Deserialize an ONNX FunctionProto into an IR Function.
@@ -812,7 +873,14 @@ def deserialize_function(proto: onnx.FunctionProto) -> _core.Function:
     values: dict[str, _core.Value] = {v.name: v for v in inputs}  # type: ignore[misc]
     value_info = {info.name: info for info in getattr(proto, "value_info", [])}
 
-    # TODO(justinchuby): Handle unsorted nodes
+    for node in proto.node:
+        _declare_node_outputs(
+            node,
+            values,
+            value_info=value_info,
+            quantization_annotations={},
+        )
+
     nodes = [
         _deserialize_node(node, [values], value_info=value_info, quantization_annotations={})
         for node in proto.node
@@ -1137,8 +1205,15 @@ def deserialize_node(proto: onnx.NodeProto) -> _core.Node:
     Returns:
         An IR Node object representing the ONNX node.
     """
+    value_scope: dict[str, _core.Value] = {}
+    _declare_node_outputs(
+        proto,
+        value_scope,
+        value_info={},
+        quantization_annotations={},
+    )
     return _deserialize_node(
-        proto, scoped_values=[{}], value_info={}, quantization_annotations={}
+        proto, scoped_values=[value_scope], value_info={}, quantization_annotations={}
     )
 
 
@@ -1161,18 +1236,18 @@ def _deserialize_node(
         for values in reversed(scoped_values):
             if input_name not in values:
                 continue
+
             node_inputs.append(values[input_name])
             found = True
             del values  # Remove the reference so it is not used by mistake
             break
         if not found:
-            # If the input is not found, we know the graph may be unsorted and
-            # the input may be a supposed-to-be initializer or an output of a node that comes later.
-            # Here we create the value with the name and add it to the current scope.
-            # Nodes need to check the value pool for potentially initialized outputs
+            # If the input is not found, we know the graph is invalid because the value
+            # is not declared. We will still create a new input for the node so that
+            # it can be fixed later.
             logger.warning(
-                "Input '%s' of node '%s(%s::%s:%s)' not found in any scope. "
-                "The graph may be unsorted. Creating a new input (current depth: %s) .",
+                "Input '%s' of node '%s' (%s::%s:%s) cannot be found in any scope. "
+                "The model is invalid but we will still create a new input for the node (current depth: %s)",
                 input_name,
                 proto.name,
                 proto.domain,
@@ -1208,35 +1283,22 @@ def _deserialize_node(
             node_outputs.append(_core.Value(name=""))
             continue
 
-        # 1. When the graph is unsorted, we may be able to find the output already created
+        # The outputs should already be declared in the current scope by _declare_node_outputs.
+        #
+        # When the graph is unsorted, we may be able to find the output already created
         # as an input to some other nodes in the current scope.
         # Note that a value is always owned by the producing node. Even though a value
         # can be created when parsing inputs of other nodes, the new node created here
         # that produces the value will assume ownership. It is then impossible to transfer
         # the ownership to any other node.
-
+        #
         # The output can only be found in the current scope. It is impossible for
         # a node to produce an output that is not in its own scope.
         current_scope = scoped_values[-1]
-        if output_name in current_scope:
-            value = current_scope[output_name]
-        else:
-            # 2. Common scenario: the graph is sorted and this is the first time we see the output.
-            # Create the value and add it to the current scope.
-            value = _core.Value(name=output_name)
-            current_scope[output_name] = value
-        # Fill in shape/type information if they exist
-        if output_name in value_info:
-            deserialize_value_info_proto(value_info[output_name], value)
-        else:
-            logger.debug(
-                "ValueInfoProto not found for output '%s' in node '%s' of type '%s'",
-                output_name,
-                proto.name,
-                proto.op_type,
-            )
-        if output_name in quantization_annotations:
-            _deserialize_quantization_annotation(quantization_annotations[output_name], value)
+        assert output_name in current_scope, (
+            f"Output '{output_name}' not found in the current scope. This is unexpected"
+        )
+        value = current_scope[output_name]
         node_outputs.append(value)
     return _core.Node(
         proto.domain,
@@ -1469,8 +1531,6 @@ def serialize_graph_into(
         serialize_value_into(graph_proto.input.add(), input_)
         if input_.name not in from_.initializers:
             # Annotations for initializers will be added below to avoid double adding
-            # TODO(justinchuby): We should add a method is_initializer() on Value when
-            # the initializer list is tracked
             _maybe_add_quantization_annotation(graph_proto, input_)
     input_names = {input_.name for input_ in from_.inputs}
     # TODO(justinchuby): Support sparse_initializer
@@ -1818,7 +1878,7 @@ def serialize_value(value: _protocols.ValueProtocol, *, name: str = "") -> onnx.
     return value_info_proto
 
 
-@_capture_errors(lambda value_info_proto, from_: repr(from_))
+@_capture_errors(lambda value_info_proto, from_, name="": repr(from_))
 def serialize_value_into(
     value_info_proto: onnx.ValueInfoProto,
     from_: _protocols.ValueProtocol,

onnx_ir/tensor_adapters.py

@@ -68,7 +68,6 @@ def from_torch_dtype(dtype: torch.dtype) -> ir.DataType:
             torch.float8_e4m3fnuz: ir.DataType.FLOAT8E4M3FNUZ,
             torch.float8_e5m2: ir.DataType.FLOAT8E5M2,
             torch.float8_e5m2fnuz: ir.DataType.FLOAT8E5M2FNUZ,
-            torch.float8_e8m0fnu: ir.DataType.FLOAT8E8M0,
             torch.int16: ir.DataType.INT16,
             torch.int32: ir.DataType.INT32,
             torch.int64: ir.DataType.INT64,
@@ -78,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}'. "
@@ -105,7 +108,6 @@ def to_torch_dtype(dtype: ir.DataType) -> torch.dtype:
             ir.DataType.FLOAT8E4M3FNUZ: torch.float8_e4m3fnuz,
             ir.DataType.FLOAT8E5M2: torch.float8_e5m2,
             ir.DataType.FLOAT8E5M2FNUZ: torch.float8_e5m2fnuz,
-            ir.DataType.FLOAT8E8M0: torch.float8_e8m0fnu,
             ir.DataType.INT16: torch.int16,
             ir.DataType.INT32: torch.int32,
             ir.DataType.INT64: torch.int64,
@@ -115,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: "

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.5.dist-info → onnx_ir-0.1.7.dist-info}/METADATA

@@ -1,9 +1,9 @@
 Metadata-Version: 2.4
 Name: onnx-ir
-Version: 0.1.5
+Version: 0.1.7
 Summary: Efficient in-memory representation for ONNX
 Author-email: ONNX Contributors <onnx-technical-discuss@lists.lfaidata.foundation>
-License: Apache License v2.0
+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
@@ -13,7 +13,6 @@ 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
@@ -29,7 +28,6 @@ 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.5.dist-info → onnx_ir-0.1.7.dist-info}/RECORD

@@ -1,5 +1,5 @@
-onnx_ir/__init__.py,sha256=_995K-JXuL0upLulUJxCXziF1gMcehH3gzea2eukCyM,3424
-onnx_ir/_core.py,sha256=CtRwtDb__hK0MJLWsrNNu5n_xz6TlbJctDLw8UDQAZQ,137454
+onnx_ir/__init__.py,sha256=GkXeM2FSKjT0TUO8ezCJdT1yHZKdtQ6keZKx2a3BluI,3424
+onnx_ir/_core.py,sha256=XQRd43VQj72qBGLa_4x9NEjjfhM0rxJ7qT6sLKA_rGA,139032
 onnx_ir/_display.py,sha256=230bMN_hVy47Ug3HkA4o5Tf5Hr21AnBEoq5w0fxjyTs,1300
 onnx_ir/_enums.py,sha256=SxC-GGgPrmdz6UsMhx7xT9-6VmkZ6j1oVzDqNUHr3Rc,9659
 onnx_ir/_graph_comparison.py,sha256=8_D1gu547eCDotEUqxfIJhUGU_Ufhfji7sfsSraOj3g,727
@@ -16,30 +16,31 @@ onnx_ir/_version_utils.py,sha256=bZThuE7meVHFOY1DLsmss9WshVIp9iig7udGfDbVaK4,133
 onnx_ir/convenience.py,sha256=0B1epuXZCSmY4FbW2vaYfR-t5ubxBZ1UruiytHs-zFw,917
 onnx_ir/external_data.py,sha256=rXHtRU-9tjAt10Iervhr5lsI6Dtv-EhR7J4brxppImA,18079
 onnx_ir/py.typed,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-onnx_ir/serde.py,sha256=bFQg5XYlDTvZsT_gDO_mPYedkMj_HcUbBvQuxLlRKvc,75980
+onnx_ir/serde.py,sha256=Ld00k4L_TJ50T8FA0myV0C1hLr7EqwujZk6bBr_nGLQ,78174
 onnx_ir/tape.py,sha256=4FyfAHmVhQoMsfHMYnBwP2azi6UF6b6pj--ercObqZs,350
-onnx_ir/tensor_adapters.py,sha256=Pl2eLXa1VQh0nZy6NFMBr_9BRY_OPoKQX1oa4K7ecUo,6717
+onnx_ir/tensor_adapters.py,sha256=YffUeZDZi8thxm-4nF2cL6cNSJSVmLm4A3IbEzwY8QQ,7233
 onnx_ir/testing.py,sha256=WTrjf2joWizDWaYMJlV1KjZMQw7YmZ8NvuBTVn1uY6s,8803
-onnx_ir/traversal.py,sha256=Z69wzYBNljn1S7PhVTYgwMftrfsdEBLoa0JYteOhLL0,2863
-onnx_ir/_convenience/__init__.py,sha256=DQ-Bz1wTiZJEARCFxDqZvYexWviGmwvDzE_1hR-vp0Q,19182
+onnx_ir/traversal.py,sha256=Wy4XphwuapAvm94-5iaz6G8LjIoMFpY7qfPfXzYViEE,4488
+onnx_ir/_convenience/__init__.py,sha256=bXUxjZ_91idQJ33zWtByQ0J4VsWCUdvAy9iIflpLtW8,19754
 onnx_ir/_convenience/_constructors.py,sha256=5GhlYy_xCE2ng7l_4cNx06WQsNDyvS-0U1HgOpPKJEk,8347
 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=xIOw_zZIuOqD4Z_wZ4OvsqXfh2IZMoMlDp1xQ_MPQlc,9567
-onnx_ir/passes/common/__init__.py,sha256=LWkH39XATj1lQz82cVrxtle6YiZZ8RkT1fVZNthiTLI,1586
+onnx_ir/passes/common/__init__.py,sha256=NYBrXvkq_CbWRwcZptSsF4u_-1zfN_BClLhVQY0pwYc,1738
 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=wZ1zEPdCshYB_ifP9fCAVfzQkesE6uhCfzCuL2qO5fA,7948
-onnx_ir/passes/common/constant_manipulation.py,sha256=_fGDwn0Axl2Q8APfc2m_mLMH28T-Mc9kIlpzBXoe3q4,8779
-onnx_ir/passes/common/identity_elimination.py,sha256=FyqnJxFUq9Ga9XyUJ3myjzr36InYSW-oJgDTrUrBORY,3663
-onnx_ir/passes/common/initializer_deduplication.py,sha256=4CIVFYfdXUlmF2sAx560c_pTwYVXtX5hcSwWzUKm5uc,2061
+onnx_ir/passes/common/constant_manipulation.py,sha256=dFzzqbpRecJJrYf6edvR_sdr4F0gV-1wEtDXsQ7fStM,9101
+onnx_ir/passes/common/identity_elimination.py,sha256=wN8g8uPGn6IIQ6Jf1lo6nGTXvpWyiSQtT_CfmtvZpwA,3664
+onnx_ir/passes/common/initializer_deduplication.py,sha256=k6IZdXrjANbVhTQCQAPIePUjqF83NG3YGwEYThYJJ7o,6655
 onnx_ir/passes/common/inliner.py,sha256=wBoO6yXt6F1AObQjYZHMQ0wn3YH681N4HQQVyaMAYd4,13702
+onnx_ir/passes/common/naming.py,sha256=NNKc9IPrmzm3J0zGQILfooayVzfdXDYHY9DHex1hFgs,10927
 onnx_ir/passes/common/onnx_checker.py,sha256=_sPmJ2ff9pDB1g9q7082BL6fyubomRaj6svE0cCyDew,1691
 onnx_ir/passes/common/shape_inference.py,sha256=LVdvxjeKtcIEbPcb6mKisxoPJOOawzsm3tzk5j9xqeM,3992
 onnx_ir/passes/common/topological_sort.py,sha256=Vcu1YhBdfRX4LROr0NScjB1Pwz2DjBFD0Z_GxqaxPF8,999
 onnx_ir/passes/common/unused_removal.py,sha256=cBNqaqGnUVyCWxsD7hBzYk4qSglVPo3SmHAvkUo5-Oc,7613
-onnx_ir-0.1.5.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
-onnx_ir-0.1.5.dist-info/METADATA,sha256=SHH7BxuFCKIsWyRKQyOKbXRtZX8n0ryietlWDPPLBvA,4884
-onnx_ir-0.1.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-onnx_ir-0.1.5.dist-info/top_level.txt,sha256=W5tROO93YjO0XRxIdjMy4wocp-5st5GiI2ukvW7UhDo,8
-onnx_ir-0.1.5.dist-info/RECORD,,
+onnx_ir-0.1.7.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+onnx_ir-0.1.7.dist-info/METADATA,sha256=M4-BdpNXpv18P_tALf6KdUdXeCO2JrVxbxtzs4HCmJI,3462
+onnx_ir-0.1.7.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+onnx_ir-0.1.7.dist-info/top_level.txt,sha256=W5tROO93YjO0XRxIdjMy4wocp-5st5GiI2ukvW7UhDo,8
+onnx_ir-0.1.7.dist-info/RECORD,,