onnx 1.17.0__cp310-cp310-win_amd64.whl → 1.19.0__cp310-cp310-win_amd64.whl

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,13 +5,24 @@ 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(
     module_context: dict[str, Any],
-) -> dict[str, dict[int | None, OpRun]]:
-    reg_ops: dict[str, dict[int | None, OpRun]] = {}
+) -> dict[str, dict[int | None, type[OpRun]]]:
+    reg_ops: dict[str, dict[int | None, type[OpRun]]] = {}
     for class_name, class_type in module_context.items():
         if class_name.startswith("_") or class_name in {
             "Any",
@@ -31,6 +40,7 @@ def build_registered_operators_any_domain(
             continue
         if isinstance(class_type, type(build_registered_operators_any_domain)):
             continue
+        issub: bool = False
         try:
             issub = issubclass(class_type, OpRun)
         except TypeError as e:

onnx/reference/ops/_op.py

@@ -3,17 +3,15 @@
 # SPDX-License-Identifier: Apache-2.0
 from __future__ import annotations
 
-from typing import Any
+from typing import TYPE_CHECKING, Any
 
 import numpy as np
 
-from onnx.onnx_pb import NodeProto
-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:
+    from onnx.onnx_pb import NodeProto
+
 
 class OpRunUnary(OpRun):
     """Ancestor to all unary operators in this subfolder.
@@ -21,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:
@@ -35,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)
 
@@ -46,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.
@@ -69,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.
@@ -85,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:
@@ -94,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)
 
@@ -109,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:
@@ -132,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*.
     """
@@ -148,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)):

onnx/reference/ops/_op_common_pool.py

@@ -35,7 +35,7 @@ def _get_pad_shape(
             f"kernel_spatial_shape={kernel_spatial_shape!r}, "
             f"strides_spatial={strides_spatial!r}."
         )
-    return tuple(pad_shape)  # type: ignore
+    return tuple(pad_shape)
 
 
 def _get_output_shape_no_ceil(
@@ -58,7 +58,7 @@ def _get_output_shape_no_ceil(
                     / float(strides_spatial[i])
                 )
             )
-    return tuple(out_shape)  # type: ignore
+    return tuple(out_shape)
 
 
 def _get_output_shape(
@@ -75,11 +75,11 @@ def _get_output_shape(
         )
     else:
         round_fct = np.ceil if ceil_mode else np.floor
-        out_shape = [0] * len(input_spatial_shape)  # type: ignore
+        out_shape = [0] * len(input_spatial_shape)
         if auto_pad in ("SAME_UPPER", "SAME_LOWER"):
             for i in range(len(input_spatial_shape)):
-                out_shape[i] = int(  # type: ignore
-                    round_fct(float(input_spatial_shape[i]) / float(strides_spatial[i]))  # type: ignore
+                out_shape[i] = int(
+                    round_fct(float(input_spatial_shape[i]) / float(strides_spatial[i]))
                 )
         elif auto_pad == "VALID":
             if pad_shape is None:
@@ -88,8 +88,8 @@ def _get_output_shape(
                     "'VALID' and ceil_mode is 1."
                 )
             for i in range(len(input_spatial_shape)):
-                out_shape[i] = int(  # type: ignore
-                    round_fct(  # type: ignore
+                out_shape[i] = int(
+                    round_fct(
                         float(
                             input_spatial_shape[i]
                             + pad_shape[i]
@@ -113,7 +113,7 @@ def _get_output_shape(
             f"kernel_spatial_shape={kernel_spatial_shape!r}, "
             f"strides_spatial={strides_spatial!r}, ceil_mode={ceil_mode!r}."
         )
-    return tuple(out_shape)  # type: ignore
+    return tuple(out_shape)
 
 
 def _pool(
@@ -138,16 +138,16 @@ def _pool(
             f"Pooling type {pooling_type!r} does not support. Should be AVG, MAX."
         )
     spatial_size = len(x_shape) - 2
-    y = np.zeros([x_shape[0], x_shape[1], *list(out_shape)])  # type: ignore
+    y = np.zeros([x_shape[0], x_shape[1], *list(out_shape)])
     if indices:
         z = np.full(y.shape, fill_value=-1, dtype=np.int64)
     round_fct = np.ceil if ceil_mode else np.floor
 
-    def loop_range():  # type: ignore
+    def loop_range():
         return [
             range(
                 int(
-                    round_fct(  # type: ignore
+                    round_fct(
                         float(x_shape[i + 2] + pad_shape[i] - kernel_shape[i])
                         / float(strides_shape[i])
                         + 1
@@ -157,7 +157,7 @@ def _pool(
             for i in range(spatial_size)
         ]
 
-    for shape in itertools.product(range(x_shape[0]), range(x_shape[1]), *loop_range()):  # type: ignore
+    for shape in itertools.product(range(x_shape[0]), range(x_shape[1]), *loop_range()):
         window = padded[shape[0], shape[1]]
         listi = [
             range(
@@ -189,17 +189,17 @@ def _pool(
                     window_vals_min[np.isnan(window_vals_min)] = no_nan.min()
                 arg = np.argmax(window_vals_min)
                 coordinates = _get_indices(arg, out_shape)
-                delta = shape[2:] - pads[:, 0]  # type: ignore
+                delta = shape[2:] - pads[:, 0]
                 coordinates += delta
                 new_arg = _get_index(coordinates, x_shape[2:])
                 z[shape] = new_arg
     if indices:
-        return y.astype(padded.dtype), z  # type: ignore
-    return y.astype(padded.dtype)  # type: ignore
+        return y.astype(padded.dtype), z
+    return y.astype(padded.dtype)
 
 
 class CommonPool(OpRun):
-    def _run(  # type: ignore
+    def _run(
         self,
         pooling_type,
         count_include_pad,
@@ -250,9 +250,9 @@ class CommonPool(OpRun):
                 kernel_shape,
                 strides,
                 pad_shape,
-                ceil_mode,  # type: ignore
+                ceil_mode,
             )
-            pad_shape = _get_pad_shape(  # type: ignore
+            pad_shape = _get_pad_shape(
                 auto_pad, x_shape, kernel_shape, strides, out_shape
             )
             if auto_pad == "SAME_LOWER":
@@ -278,7 +278,7 @@ class CommonPool(OpRun):
                 kernel_shape,
                 strides,
                 pad_shape,
-                ceil_mode,  # type: ignore
+                ceil_mode,
             )
 
         n_dims = len(pads) // 2
@@ -289,11 +289,11 @@ class CommonPool(OpRun):
             kernel_shape,
             strides,
             out_shape,
-            pad_shape,  # type: ignore
+            pad_shape,
             pooling_type,
             count_include_pad=count_include_pad,
             ceil_mode=ceil_mode,
-            indices=len(self.output) > 1,  # type: ignore
+            indices=len(self.output) > 1,
             pads=new_pads,
         )
         if isinstance(res, tuple):

onnx/reference/ops/_op_common_random.py

@@ -10,22 +10,22 @@ from onnx.reference.op_run import OpRun
 
 
 class _CommonRandom(OpRun):
-    def __init__(self, onnx_node, run_params):  # type: ignore
+    def __init__(self, onnx_node, run_params):
         OpRun.__init__(self, onnx_node, run_params)
-        if hasattr(self, "shape") and len(self.shape) == 0:  # type: ignore
+        if hasattr(self, "shape") and len(self.shape) == 0:
             raise ValueError(  # pragma: no cover
                 f"shape cannot be empty for operator {self.__class__.__name__}."
             )
 
     @staticmethod
-    def numpy_type(dtype):  # type: ignore
+    def numpy_type(dtype):
         return tensor_dtype_to_np_dtype(dtype)
 
     @staticmethod
-    def _dtype(*data, dtype=None, dtype_first=False):  # type: ignore
+    def _dtype(*data, dtype=None, dtype_first=False):
         numpy_type = _CommonRandom.numpy_type(dtype)
         if dtype_first and numpy_type is not None:
-            if dtype != 0:  # type: ignore
+            if dtype != 0:
                 return numpy_type
             if data:
                 return data[0].dtype
@@ -47,9 +47,9 @@ class _CommonRandom(OpRun):
         return res
 
     @staticmethod
-    def _get_state(seed):  # type: ignore
-        if seed is None or np.isnan(seed):  # type: ignore
+    def _get_state(seed):
+        if seed is None or np.isnan(seed):
             state = np.random.RandomState()
         else:
-            state = np.random.RandomState(seed=int(seed))  # type: ignore
+            state = np.random.RandomState(seed=int(seed))
         return state

onnx/reference/ops/_op_common_window.py

@@ -11,7 +11,7 @@ from onnx.reference.op_run import OpRun
 
 class _CommonWindow(OpRun):
     @staticmethod
-    def _begin(size, periodic, output_datatype):  # type: ignore
+    def _begin(size, periodic, output_datatype):
         dtype = tensor_dtype_to_np_dtype(output_datatype)
         if periodic == 1:
             N_1 = size