onnx 1.18.0__cp313-cp313-macosx_12_0_universal2.whl → 1.19.1rc1__cp313-cp313-macosx_12_0_universal2.whl

onnx/reference/op_run.py

@@ -4,39 +4,14 @@
 from __future__ import annotations
 
 import abc
-from typing import TYPE_CHECKING, Any, ClassVar
+from typing import TYPE_CHECKING, Any
 
 import numpy as np
 
-from onnx import TensorProto
-from onnx._custom_element_types import (
-    bfloat16,
-    float4e2m1,
-    float8e4m3fn,
-    float8e4m3fnuz,
-    float8e5m2,
-    float8e5m2fnuz,
-    int4,
-    uint4,
-)
-from onnx.defs import get_all_schemas_with_history, get_schema, onnx_opset_version
-from onnx.helper import make_node, make_tensor_type_proto, np_dtype_to_tensor_dtype
-from onnx.numpy_helper import to_array
-from onnx.onnx_pb import AttributeProto, GraphProto, NodeProto, TypeProto
+import onnx
 
 if TYPE_CHECKING:
-    from collections.abc import Iterable
-
-
-def _split_class_name(name):  # type: ignore
-    if "_" in name:
-        prefix, vers = name.rsplit("_", maxsplit=1)
-        try:
-            v = int(vers)
-        except ValueError:
-            return name, None
-        return prefix, v
-    return name, None
+    from collections.abc import Sequence
 
 
 class RuntimeTypeError(RuntimeError):
@@ -69,22 +44,22 @@ class RefAttrName:
         return f"{self.__class__.__name__}({self.name!r})"
 
 
-def _build_schemas() -> dict[str, type]:
-    res: dict[str, type] = {}
-    for schema in get_all_schemas_with_history():
+def _build_schemas() -> dict[str, onnx.defs.OpSchema]:
+    res: dict[str, onnx.defs.OpSchema] = {}
+    for schema in onnx.defs.onnx.defs.get_all_schemas_with_history():
         # Multiple version can coexist. The last one is kept.
         if schema.name in res:
-            if schema.domain != res[schema.name].domain:  # type: ignore
+            if schema.domain != res[schema.name].domain:
                 raise NotImplementedError(
-                    f"This function assumes every operator has a unique name {schema.name!r} "  # type: ignore
-                    f"even accross multiple domains {schema.domain!r} and {res[schema.name].domain!r}."  # type: ignore
+                    f"This function assumes every operator has a unique name {schema.name!r} "
+                    f"even across multiple domains {schema.domain!r} and {res[schema.name].domain!r}."
                 )
-            if schema.since_version > res[schema.name].since_version:  # type: ignore
+            if schema.since_version > res[schema.name].since_version:
                 # We keep the most recent one.
-                res[schema.name] = schema  # type: ignore
+                res[schema.name] = schema
         else:
-            res[schema.name] = schema  # type: ignore
-        res[schema.name + "_" + str(schema.since_version)] = schema  # type: ignore
+            res[schema.name] = schema
+        res[schema.name + "_" + str(schema.since_version)] = schema
     return res
 
 
@@ -92,9 +67,11 @@ _schemas = _build_schemas()
 
 
 class OnnxType:
-    def __init__(self, type_proto: TypeProto):
-        if not isinstance(type_proto, TypeProto):
-            raise TypeError(f"type_proto {type(type_proto)} must be of type TypeProto.")
+    def __init__(self, type_proto: onnx.TypeProto):
+        if not isinstance(type_proto, onnx.TypeProto):
+            raise TypeError(
+                f"type_proto {type(type_proto)} must be of type onnx.TypeProto."
+            )
         self.type_proto = type_proto
 
     def __repr__(self) -> str:
@@ -118,21 +95,49 @@ class SparseTensor:
         return self.values.dtype
 
 
-def to_sparse_tensor(att: AttributeProto) -> SparseTensor:
+def to_sparse_tensor(att: onnx.AttributeProto) -> SparseTensor:
     """Hosts a sparse tensor."""
     shape = tuple(d for d in att.dims)  # type: ignore[attr-defined]
-    return SparseTensor(to_array(att.values), to_array(att.indices), shape)  # type: ignore
-
-
-def to_array_extended(tensor: TensorProto) -> np.ndarray:
-    """Alias for :func:`to_array`."""
-    return to_array(tensor)
+    return SparseTensor(
+        onnx.numpy_helper.to_array(att.values),  # type: ignore[attr-defined]
+        onnx.numpy_helper.to_array(att.indices),  # type: ignore[attr-defined]
+        shape,
+    )
+
+
+def _attribute_conversion_function(attr_type: onnx.AttributeProto.AttributeType):
+    return {
+        onnx.AttributeProto.FLOAT: lambda att: np.float32(att.f),
+        onnx.AttributeProto.FLOATS: lambda att: [np.float32(f) for f in att.floats],
+        onnx.AttributeProto.GRAPH: lambda att: Graph(att.g),
+        onnx.AttributeProto.GRAPHS: lambda att: [Graph(g) for g in att.graphs],
+        onnx.AttributeProto.INT: lambda att: int(att.i),
+        onnx.AttributeProto.INTS: lambda att: [int(i) for i in att.ints],
+        onnx.AttributeProto.SPARSE_TENSOR: lambda att: to_sparse_tensor(
+            att.sparse_tensor
+        ),
+        onnx.AttributeProto.SPARSE_TENSORS: lambda att: [
+            to_sparse_tensor(t) for t in att.sparse_tensors
+        ],
+        onnx.AttributeProto.STRING: lambda att: att.s.decode("utf-8"),
+        onnx.AttributeProto.STRINGS: lambda att: [
+            s.decode("utf-8") for s in att.strings
+        ],
+        onnx.AttributeProto.TENSOR: lambda att: onnx.numpy_helper.to_array(att.t),
+        onnx.AttributeProto.TENSORS: lambda att: [
+            onnx.numpy_helper.to_array(t) for t in att.tensors
+        ],
+        onnx.AttributeProto.TYPE_PROTO: lambda att: OnnxType(att.tp),
+        onnx.AttributeProto.TYPE_PROTOS: lambda att: [
+            OnnxType(t) for t in att.type_protos
+        ],
+    }[attr_type]
 
 
 class Graph:
     __slots__ = ("g",)
 
-    def __init__(self, g: GraphProto) -> None:
+    def __init__(self, g: onnx.GraphProto) -> None:
         self.g = g
 
 
@@ -149,27 +154,8 @@ class OpRun(abc.ABC):
 
     op_domain = ""
 
-    _attribute_conversion_functions: ClassVar[dict[Any, Any]] = {
-        AttributeProto.FLOAT: lambda att: np.float32(att.f),
-        AttributeProto.FLOATS: lambda att: [np.float32(f) for f in att.floats],
-        AttributeProto.GRAPH: lambda att: Graph(att.g),
-        AttributeProto.GRAPHS: lambda att: [Graph(g) for g in att.graphs],
-        AttributeProto.INT: lambda att: int(att.i),
-        AttributeProto.INTS: lambda att: [int(i) for i in att.ints],
-        AttributeProto.SPARSE_TENSOR: lambda att: to_sparse_tensor(att.sparse_tensor),
-        AttributeProto.SPARSE_TENSORS: lambda att: [
-            to_sparse_tensor(t) for t in att.sparse_tensors
-        ],
-        AttributeProto.STRING: lambda att: att.s.decode("utf-8"),
-        AttributeProto.STRINGS: lambda att: [s.decode("utf-8") for s in att.strings],
-        AttributeProto.TENSOR: lambda att: to_array_extended(att.t),
-        AttributeProto.TENSORS: lambda att: [to_array_extended(t) for t in att.tensors],
-        AttributeProto.TYPE_PROTO: lambda att: OnnxType(att.tp),
-        AttributeProto.TYPE_PROTOS: lambda att: [OnnxType(t) for t in att.type_protos],
-    }
-
     def __init__(
-        self, onnx_node: NodeProto, run_params: dict[str, Any], schema: Any = None
+        self, onnx_node: onnx.NodeProto, run_params: dict[str, Any], schema: Any = None
     ):
         if not isinstance(run_params, dict):
             raise TypeError(f"run_params must be a dictionary not {type(run_params)}.")
@@ -191,20 +177,20 @@ class OpRun(abc.ABC):
             elif onnx_node.op_type in _schemas:
                 self._schema = _schemas[onnx_node.op_type]
             else:
-                self._schema = None  # type: ignore
+                self._schema = None
         else:
             self._schema = schema
         self.has_subgraph = False
         self._load_attributes()
 
-    def _log(self, pattern, *args):  # type: ignore
+    def _log(self, pattern, *args):
         self.run_params["log"](pattern, *args)
 
     def _extract_attribute_value(
-        self, att: AttributeProto, ref_att: AttributeProto | None = None
+        self, att: onnx.AttributeProto, ref_att: onnx.AttributeProto | None = None
     ) -> Any:
         """Converts an attribute value into a python value."""
-        if att.type == AttributeProto.GRAPH:
+        if att.type == onnx.AttributeProto.GRAPH:
             new_ops = self.run_params.get("new_ops", None)
             if "existing_functions" in self.run_params:
                 functions = list(self.run_params["existing_functions"].values())
@@ -221,14 +207,18 @@ class OpRun(abc.ABC):
                 new_ops=None if new_ops is None else list(new_ops.values()),
                 functions=functions,
             )
-        if att.type in OpRun._attribute_conversion_functions:
-            return OpRun._attribute_conversion_functions[att.type](att)  # type: ignore
+
+        conversion_function = _attribute_conversion_function(att.type)
+        if conversion_function is not None:
+            return conversion_function(att)
+
         if ref_att is None:
             raise AttributeError(
                 f"Unable to convert attribute {att.name!r} type {att.type!r} "
                 f"from node type {self.onnx_node.op_type!r}, "
                 f"domain {self.onnx_node.domain!r}\n{att}."
             )
+
         raise AttributeError(
             f"Unable to convert default value for {ref_att.name!r} type {att.type!r} "
             f"from node type {self.onnx_node.op_type!r}, "
@@ -252,9 +242,9 @@ class OpRun(abc.ABC):
                 value = self._extract_attribute_value(att)
             setattr(self, name, value)
             added_attributes.append(name)
-            if att.type == AttributeProto.GRAPH:
+            if att.type == onnx.AttributeProto.GRAPH:
                 self.has_subgraph = True
-                self.has_linked_attribute |= value.has_linked_attribute  # type: ignore
+                self.has_linked_attribute |= value.has_linked_attribute  # type: ignore[attr-defined]
                 setattr(
                     self,
                     f"_run_{att.name}",
@@ -266,7 +256,7 @@ class OpRun(abc.ABC):
                 )
 
         if self._schema and self.onnx_node.op_type not in {"Constant"}:
-            for k, v in self._schema.attributes.items():  # type: ignore
+            for k, v in self._schema.attributes.items():
                 if not hasattr(self, k):
                     if getattr(v, "required", True):
                         raise RuntimeError(
@@ -279,7 +269,7 @@ class OpRun(abc.ABC):
                             and v.default_value.t.data_type == 0
                         ):
                             # default value is undefined, it depends on the inputs
-                            value = None  # type: ignore
+                            value = None  # type: ignore[assignment]
                         else:
                             value = self._extract_attribute_value(v.default_value, v)
                         setattr(self, k, value)
@@ -287,19 +277,19 @@ class OpRun(abc.ABC):
         self.attributes_names_ = set(added_attributes)
 
     @staticmethod
-    def implicit_inputs(graph: GraphProto) -> list[str]:
-        """Returns all varibles not registered as inputs and not produced by
+    def implicit_inputs(graph: onnx.GraphProto) -> list[str]:
+        """Returns all variables not registered as inputs and not produced by
         an node inside the graph. This inputs are part of the context
         existing in the graph calling this one.
         """
-        if not isinstance(graph, GraphProto):
+        if not isinstance(graph, onnx.GraphProto):
             raise TypeError(f"Unexpected type {type(graph)!r}.")
         local = set()
         known = set()
         for init in graph.initializer:
             known.add(init.name)
         for sparse_init in graph.sparse_initializer:
-            known.add(sparse_init.name)  # type: ignore
+            known.add(sparse_init.name)  # type: ignore[attr-defined]
         for inp in graph.input:
             known.add(inp.name)
         for node in graph.node:
@@ -311,24 +301,24 @@ class OpRun(abc.ABC):
         return list(local)
 
     @property
-    def input(self) -> Iterable[str]:
+    def input(self) -> Sequence[str]:
         """Returns node attribute `input`."""
-        return self.onnx_node.input  # type: ignore
+        return self.onnx_node.input  # type: ignore[no-any-return]
 
     @property
-    def output(self) -> Iterable[str]:
+    def output(self) -> Sequence[str]:
         """Returns node attribute `output`."""
-        return self.onnx_node.output  # type: ignore
+        return self.onnx_node.output  # type: ignore[no-any-return]
 
     @property
     def op_type(self) -> str:
         """Returns node attribute `op_type`."""
-        return self.onnx_node.op_type  # type: ignore
+        return self.onnx_node.op_type
 
     @property
     def domain(self) -> str:
         """Returns node attribute `domain`."""
-        return self.onnx_node.domain  # type: ignore
+        return self.onnx_node.domain
 
     def need_context(self) -> bool:
         """Tells the runtime if this node needs the context
@@ -349,12 +339,12 @@ class OpRun(abc.ABC):
         return "\n".join(atts)
 
     @abc.abstractmethod
-    def _run(self, *args, **kwargs):  # type: ignore
+    def _run(self, *args, **kwargs):
         """Should be overwritten.
 
         Args:
             *args: operator inputs
-            **kwargs: optional inputs and overriden attributes, an
+            **kwargs: optional inputs and overridden attributes, an
                 attribute may be overridden if it belongs to a function,
                 in this case, the same instance of OpRun can be called
                 with different values of the same attribute.
@@ -393,12 +383,12 @@ class OpRun(abc.ABC):
             dtypes = [type(t) for t in res]
             raise TypeError(
                 f"One of the results returned by method '_run' of class {self.__class__.__name__!r} "
-                f"has an unexpected type, this is no ONNX correponding type (Map, List, Tensor, SparseTensor). "
+                f"has an unexpected type, this is no ONNX corresponding type (Map, List, Tensor, SparseTensor). "
                 f"All returned types: {dtypes!r}."
             )
         return res
 
-    def run(self, *args, linked_attributes=None, context=None):  # type: ignore
+    def run(self, *args, linked_attributes=None, context=None):
         """Calls method ``_run``, catches exceptions,
         displays a longer error message.
 
@@ -487,12 +477,12 @@ class OpRun(abc.ABC):
     def infer_name(cls):
         name = cls.__name__
         if "_" not in name:
-            return name, onnx_opset_version()
+            return name, onnx.defs.onnx_opset_version()
         name, vers = name.rsplit("_", 1)
         try:
             i_vers = int(vers)
         except ValueError:
-            return cls.__name__, onnx_opset_version()
+            return cls.__name__, onnx.defs.onnx_opset_version()
         return name, i_vers
 
     @classmethod
@@ -501,7 +491,7 @@ class OpRun(abc.ABC):
         n_inputs: int | None = None,
         n_outputs: int | None = None,
         **kwargs: Any,
-    ) -> NodeProto:  # type: ignore
+    ) -> onnx.NodeProto:
         """Creates an ONNX node for this class based on the given information.
 
         Args:
@@ -531,16 +521,16 @@ class OpRun(abc.ABC):
         schema = None
         if n_inputs is None:
             if schema is None:
-                schema = get_schema(op_type, opset, domain)
+                schema = onnx.defs.get_schema(op_type, opset, domain)
             n_inputs = schema.min_input
         if n_outputs is None:
             if schema is None:
-                schema = get_schema(op_type, opset, domain)
+                schema = onnx.defs.get_schema(op_type, opset, domain)
             n_outputs = schema.min_output
 
         names_in = [f"x{i}" for i in range(n_inputs)]
         names_out = [f"y{i}" for i in range(n_outputs)]
-        node = make_node(op_type, names_in, names_out, **kwargs)
+        node = onnx.helper.make_node(op_type, names_in, names_out, **kwargs)
         return node
 
     @classmethod
@@ -574,7 +564,7 @@ class OpRun(abc.ABC):
             "verbose": verbose,
             "log": log_function,
             "new_ops": None,
-            "opsets": {"": onnx_opset_version()},
+            "opsets": {"": onnx.defs.onnx_opset_version()},
         }
         cl = cls(node, run_params)
         return cl
@@ -586,7 +576,7 @@ class OpRun(abc.ABC):
         n_outputs: int | None = None,
         verbose: int = 0,
         **kwargs: Any,
-    ) -> Any:  # type: ignore
+    ) -> Any:
         """Evaluates this operator.
 
         Args:
@@ -625,7 +615,7 @@ class OpFunction(OpRun):
 
     def __init__(
         self,
-        onnx_node: NodeProto,
+        onnx_node: onnx.NodeProto,
         run_params: dict[str, Any] | None,
         impl: Any = None,
         attributes: dict[str, Any] | None = None,
@@ -644,10 +634,10 @@ class OpFunction(OpRun):
             for name in getattr(self.impl_, "attributes_", attributes)  # type: ignore[union-attr]
         }
 
-    def _run(self, *inputs, **kwargs):  # type: ignore
+    def _run(self, *inputs, **kwargs):
         return self._run_impl(self.impl_, *inputs, **kwargs)
 
-    def _run_impl(self, impl, *inputs, **kwargs):  # type: ignore
+    def _run_impl(self, impl, *inputs, **kwargs):
         if len(impl.input_names) != len(inputs):
             raise RuntimeError(
                 f"Mismatch lengths between the number of inputs {len(inputs)} "
@@ -670,47 +660,29 @@ class OpFunction(OpRun):
 class OpFunctionContextDependant(OpFunction):
     """The function can be instantiated but only at execution time.
     An instance of OpFunction is created everytime to node is executed.
-    This is needed when the schema of an operator defines a context dependant function.
+    This is needed when the schema of an operator defines a context dependent function.
     """
 
     def __init__(
         self,
-        onnx_node: NodeProto,
+        onnx_node: onnx.NodeProto,
         run_params: dict[str, Any] | None,
         parent: Any = None,
     ):
         OpFunction.__init__(self, onnx_node, run_params, impl=self, attributes={})
         self.parent = parent
         version = parent.opsets[onnx_node.domain]
-        self.schema_ = get_schema(onnx_node.op_type, version, onnx_node.domain)
+        self.schema_ = onnx.defs.get_schema(
+            onnx_node.op_type, version, onnx_node.domain
+        )
 
     def _run(self, *inputs, **kwargs):
         # Input types are known. They are used to properly
         # created the body for this operator.
         types = []
         for t in inputs:
-            try:
-                ttype = np_dtype_to_tensor_dtype(t.dtype)
-            except KeyError:
-                if t.dtype == float8e4m3fn:
-                    ttype = TensorProto.FLOAT8E4M3FN  # type: ignore[attr-defined]
-                elif t.dtype == float8e4m3fnuz:
-                    ttype = TensorProto.FLOAT8E4M3FNUZ  # type: ignore[attr-defined]
-                elif t.dtype == float8e5m2:
-                    ttype = TensorProto.FLOAT8E5M2  # type: ignore[attr-defined]
-                elif t.dtype == float8e5m2fnuz:
-                    ttype = TensorProto.FLOAT8E5M2FNUZ  # type: ignore[attr-defined]
-                elif t.dtype == bfloat16:
-                    ttype = TensorProto.BLOFAT16  # type: ignore[attr-defined]
-                elif t.dtype == uint4:
-                    ttype = TensorProto.UINT4  # type: ignore[attr-defined]
-                elif t.dtype == int4:
-                    ttype = TensorProto.INT4  # type: ignore[attr-defined]
-                elif t.dtype == float4e2m1:
-                    ttype = TensorProto.FLOAT4E2M1  # type: ignore[attr-defined]
-                else:
-                    raise
-            types.append(make_tensor_type_proto(ttype, t.shape))
+            dtype = onnx.helper.np_dtype_to_tensor_dtype(t.dtype)
+            types.append(onnx.helper.make_tensor_type_proto(dtype, t.shape))
         cl = self.parent._load_impl(self.onnx_node, types)
         inst = cl(self.onnx_node, self.run_params)
         return self._run_impl(inst.impl_, *inputs, **kwargs)

onnx/reference/ops/__init__.py

@@ -1,8 +1,8 @@
-# Copyright (c) ONNX Project Contributors
-
 # Copyright (c) ONNX Project Contributors
 #
 # SPDX-License-Identifier: Apache-2.0
 from __future__ import annotations
 
+__all__ = ["load_op"]
+
 from onnx.reference.ops._op_list import load_op

onnx/reference/ops/_helpers.py

@@ -1,5 +1,3 @@
-# Copyright (c) ONNX Project Contributors
-
 # Copyright (c) ONNX Project Contributors
 #
 # SPDX-License-Identifier: Apache-2.0
@@ -7,7 +5,18 @@ from __future__ import annotations
 
 from typing import Any
 
-from onnx.reference.op_run import OpRun, _split_class_name
+from onnx.reference.op_run import OpRun
+
+
+def _split_class_name(name):
+    if "_" in name:
+        prefix, vers = name.rsplit("_", maxsplit=1)
+        try:
+            v = int(vers)
+        except ValueError:
+            return name, None
+        return prefix, v
+    return name, None
 
 
 def build_registered_operators_any_domain(

onnx/reference/ops/_op.py

@@ -7,10 +7,6 @@ from typing import TYPE_CHECKING, Any
 
 import numpy as np
 
-from onnx.reference.custom_element_types import (
-    convert_from_ml_dtypes,
-    convert_to_ml_dtypes,
-)
 from onnx.reference.op_run import OpRun, RuntimeTypeError
 
 if TYPE_CHECKING:
@@ -23,13 +19,12 @@ class OpRunUnary(OpRun):
     Checks that input and output types are the same.
     """
 
-    def run(self, x):  # type: ignore
+    def run(self, x):
         """Calls method ``_run``, catches exceptions, displays a longer error message.
 
         Supports only unary operators.
         """
         self._log("-- begin %s.run(1 input)", self.__class__.__name__)
-        x = convert_to_ml_dtypes(x)
         try:
             res = self._run(x)
         except TypeError as e:
@@ -37,7 +32,6 @@ class OpRunUnary(OpRun):
                 f"Issues with types {', '.join(str(type(_)) for _ in [x])} "
                 f"(unary operator {self.__class__.__name__!r})."
             ) from e
-        res = (convert_from_ml_dtypes(res[0]),)
         self._log("-- done %s.run -> %d outputs", self.__class__.__name__, len(res))
         return self._check_and_fix_outputs(res)
 
@@ -48,7 +42,7 @@ class OpRunUnaryNum(OpRunUnary):
     Checks that input and output types are the same.
     """
 
-    def run(self, x):  # type: ignore
+    def run(self, x):
         """Calls method ``OpRunUnary.run``.
 
         Catches exceptions, displays a longer error message.
@@ -71,7 +65,7 @@ class OpRunBinary(OpRun):
     Checks that input and output types are the same.
     """
 
-    def run(self, x, y):  # type: ignore
+    def run(self, x, y):
         """Calls method ``_run``, catches exceptions, displays a longer error message.
 
         Supports only binary operators.
@@ -87,8 +81,6 @@ class OpRunBinary(OpRun):
                 f"(operator '{self.__class__.__name__!r}', "
                 f"shapes {x.shape}, {y.shape})."
             )
-        x = convert_to_ml_dtypes(x)
-        y = convert_to_ml_dtypes(y)
         try:
             res = self._run(x, y)
         except (TypeError, ValueError) as e:
@@ -96,7 +88,6 @@ class OpRunBinary(OpRun):
                 f"Issues with types {', '.join(str(type(_)) for _ in [x, y])} "
                 f"(binary operator {self.__class__.__name__!r})."
             ) from e
-        res = (convert_from_ml_dtypes(res[0]),)
         self._log("-- done %s.run -> %d outputs", self.__class__.__name__, len(res))
         return self._check_and_fix_outputs(res)
 
@@ -111,7 +102,7 @@ class OpRunBinaryNum(OpRunBinary):
     Checks that input oud output types are the same.
     """
 
-    def run(self, x, y):  # type: ignore
+    def run(self, x, y):
         """Calls method ``OpRunBinary.run``, catches exceptions, displays a longer error message."""
         res = OpRunBinary.run(self, x, y)
         if res[0].dtype != x.dtype:
@@ -134,15 +125,12 @@ class OpRunBinaryNumpy(OpRunBinaryNum):
         OpRunBinaryNum.__init__(self, onnx_node, run_params)
         self.numpy_fct = numpy_fct
 
-    def _run(self, a, b):  # type: ignore
-        a = convert_to_ml_dtypes(a)
-        b = convert_to_ml_dtypes(b)
+    def _run(self, a, b):
         res = (self.numpy_fct(a, b),)
-        res = (convert_from_ml_dtypes(res[0]),)
         return self._check_and_fix_outputs(res)
 
 
-class OpRunReduceNumpy(OpRun):  # type: ignore
+class OpRunReduceNumpy(OpRun):
     """Implements the reduce logic.
     It must have a parameter *axes*.
     """
@@ -150,8 +138,8 @@ class OpRunReduceNumpy(OpRun):  # type: ignore
     def __init__(self, onnx_node: NodeProto, run_params: dict[str, Any]):
         OpRun.__init__(self, onnx_node, run_params)
         if hasattr(self, "axes"):
-            if isinstance(self.axes, np.ndarray):  # type: ignore
-                if len(self.axes.shape) == 0 or self.axes.shape[0] == 0:  # type: ignore
+            if isinstance(self.axes, np.ndarray):
+                if len(self.axes.shape) == 0 or self.axes.shape[0] == 0:
                     self.axes = None
                 else:
                     self.axes = tuple(self.axes)

onnx/reference/ops/_op_common_indices.py

@@ -6,7 +6,7 @@ from __future__ import annotations
 import numpy as np
 
 
-def _get_indices(i, shape):  # type: ignore
+def _get_indices(i, shape):
     res = np.empty((len(shape),), dtype=np.int64)
     k = len(shape) - 1
     while k > 0:
@@ -19,7 +19,7 @@ def _get_indices(i, shape):  # type: ignore
     return res
 
 
-def _is_out(ind, shape):  # type: ignore
+def _is_out(ind, shape):
     for i, s in zip(ind, shape):
         if i < 0:
             return True
@@ -28,7 +28,7 @@ def _is_out(ind, shape):  # type: ignore
     return False
 
 
-def _get_index(indices, shape):  # type: ignore
+def _get_index(indices, shape):
     ind = 0
     mul = 1
     for pos, sh in zip(reversed(indices), reversed(shape)):