onnx 1.17.0__cp312-cp312-win_amd64.whl → 1.19.0__cp312-cp312-win_amd64.whl

onnx/onnx_operators_ml_pb2.py

@@ -1,11 +1,12 @@
 # -*- coding: utf-8 -*-
 # Generated by the protocol buffer compiler.  DO NOT EDIT!
 # source: onnx/onnx-operators-ml.proto
+# Protobuf Python Version: 4.25.1
 """Generated protocol buffer code."""
-from google.protobuf.internal import builder as _builder
 from google.protobuf import descriptor as _descriptor
 from google.protobuf import descriptor_pool as _descriptor_pool
 from google.protobuf import symbol_database as _symbol_database
+from google.protobuf.internal import builder as _builder
 # @@protoc_insertion_point(imports)
 
 _sym_db = _symbol_database.Default()
@@ -16,14 +17,14 @@ from onnx import onnx_ml_pb2 as onnx_dot_onnx__ml__pb2
 
 DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x1connx/onnx-operators-ml.proto\x12\x04onnx\x1a\x12onnx/onnx-ml.proto\"q\n\rOperatorProto\x12\x0f\n\x07op_type\x18\x01 \x01(\t\x12\x15\n\rsince_version\x18\x02 \x01(\x03\x12$\n\x06status\x18\x03 \x01(\x0e\x32\x14.onnx.OperatorStatus\x12\x12\n\ndoc_string\x18\n \x01(\t\"\xf9\x01\n\x10OperatorSetProto\x12\r\n\x05magic\x18\x01 \x01(\t\x12\x12\n\nir_version\x18\x02 \x01(\x03\x12\x1d\n\x15ir_version_prerelease\x18\x03 \x01(\t\x12\x19\n\x11ir_build_metadata\x18\x07 \x01(\t\x12\x0e\n\x06\x64omain\x18\x04 \x01(\t\x12\x15\n\ropset_version\x18\x05 \x01(\x03\x12\x12\n\ndoc_string\x18\x06 \x01(\t\x12%\n\x08operator\x18\x08 \x03(\x0b\x32\x13.onnx.OperatorProto\x12&\n\tfunctions\x18\t \x03(\x0b\x32\x13.onnx.FunctionProtoB\x02H\x03')
 
-_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, globals())
-_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'onnx.onnx_operators_ml_pb2', globals())
+_globals = globals()
+_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)
+_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'onnx.onnx_operators_ml_pb2', _globals)
 if _descriptor._USE_C_DESCRIPTORS == False:
-
-  DESCRIPTOR._options = None
-  DESCRIPTOR._serialized_options = b'H\003'
-  _OPERATORPROTO._serialized_start=58
-  _OPERATORPROTO._serialized_end=171
-  _OPERATORSETPROTO._serialized_start=174
-  _OPERATORSETPROTO._serialized_end=423
+  _globals['DESCRIPTOR']._options = None
+  _globals['DESCRIPTOR']._serialized_options = b'H\003'
+  _globals['_OPERATORPROTO']._serialized_start=58
+  _globals['_OPERATORPROTO']._serialized_end=171
+  _globals['_OPERATORSETPROTO']._serialized_start=174
+  _globals['_OPERATORSETPROTO']._serialized_end=423
 # @@protoc_insertion_point(module_scope)

onnx/onnx_operators_ml_pb2.pyi

@@ -1,67 +1,41 @@
-# @generated by protoc-gen-mypy.py.  Do not edit!
-# mypy: disable-error-code=override
-from google.protobuf.message import (  # type: ignore
-    Message,
-)
+from onnx import onnx_ml_pb2 as _onnx_ml_pb2
+from google.protobuf.internal import containers as _containers
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import message as _message
+from typing import ClassVar as _ClassVar, Iterable as _Iterable, Mapping as _Mapping, Optional as _Optional, Union as _Union
 
-from onnx.onnx_ml_pb2 import (
-    FunctionProto,
-    OperatorStatus,
-)
+DESCRIPTOR: _descriptor.FileDescriptor
 
-from typing import (
-    Iterable,
-    Optional as OptionalType,
-)
+class OperatorProto(_message.Message):
+    __slots__ = ("op_type", "since_version", "status", "doc_string")
+    OP_TYPE_FIELD_NUMBER: _ClassVar[int]
+    SINCE_VERSION_FIELD_NUMBER: _ClassVar[int]
+    STATUS_FIELD_NUMBER: _ClassVar[int]
+    DOC_STRING_FIELD_NUMBER: _ClassVar[int]
+    op_type: str
+    since_version: int
+    status: _onnx_ml_pb2.OperatorStatus
+    doc_string: str
+    def __init__(self, op_type: _Optional[str] = ..., since_version: _Optional[int] = ..., status: _Optional[_Union[_onnx_ml_pb2.OperatorStatus, str]] = ..., doc_string: _Optional[str] = ...) -> None: ...
 
-from google.protobuf.internal.containers import (  # type: ignore
-    RepeatedCompositeFieldContainer,
-)
-
-class OperatorProto(Message):
-    op_type = ... # type: str
-    since_version = ... # type: int
-    status = ... # type: OperatorStatus
-    doc_string = ... # type: str
-    
-    def __init__(self,
-        op_type : OptionalType[str] = None,
-        since_version : OptionalType[int] = None,
-        status : OptionalType[OperatorStatus] = None,
-        doc_string : OptionalType[str] = None,
-        ) -> None: ...
-    @classmethod
-    def FromString(cls, s: bytes) -> OperatorProto: ...
-    def MergeFrom(self, other_msg: Message) -> None: ...
-    def CopyFrom(self, other_msg: Message) -> None: ...
-
-class OperatorSetProto(Message):
-    magic = ... # type: str
-    ir_version = ... # type: int
-    ir_version_prerelease = ... # type: str
-    ir_build_metadata = ... # type: str
-    domain = ... # type: str
-    opset_version = ... # type: int
-    doc_string = ... # type: str
-    
-    @property
-    def operator(self) -> RepeatedCompositeFieldContainer[OperatorProto]: ...
-    
-    @property
-    def functions(self) -> RepeatedCompositeFieldContainer[FunctionProto]: ...
-    
-    def __init__(self,
-        magic : OptionalType[str] = None,
-        ir_version : OptionalType[int] = None,
-        ir_version_prerelease : OptionalType[str] = None,
-        ir_build_metadata : OptionalType[str] = None,
-        domain : OptionalType[str] = None,
-        opset_version : OptionalType[int] = None,
-        doc_string : OptionalType[str] = None,
-        operator : OptionalType[Iterable[OperatorProto]] = None,
-        functions : OptionalType[Iterable[FunctionProto]] = None,
-        ) -> None: ...
-    @classmethod
-    def FromString(cls, s: bytes) -> OperatorSetProto: ...
-    def MergeFrom(self, other_msg: Message) -> None: ...
-    def CopyFrom(self, other_msg: Message) -> None: ...
+class OperatorSetProto(_message.Message):
+    __slots__ = ("magic", "ir_version", "ir_version_prerelease", "ir_build_metadata", "domain", "opset_version", "doc_string", "operator", "functions")
+    MAGIC_FIELD_NUMBER: _ClassVar[int]
+    IR_VERSION_FIELD_NUMBER: _ClassVar[int]
+    IR_VERSION_PRERELEASE_FIELD_NUMBER: _ClassVar[int]
+    IR_BUILD_METADATA_FIELD_NUMBER: _ClassVar[int]
+    DOMAIN_FIELD_NUMBER: _ClassVar[int]
+    OPSET_VERSION_FIELD_NUMBER: _ClassVar[int]
+    DOC_STRING_FIELD_NUMBER: _ClassVar[int]
+    OPERATOR_FIELD_NUMBER: _ClassVar[int]
+    FUNCTIONS_FIELD_NUMBER: _ClassVar[int]
+    magic: str
+    ir_version: int
+    ir_version_prerelease: str
+    ir_build_metadata: str
+    domain: str
+    opset_version: int
+    doc_string: str
+    operator: _containers.RepeatedCompositeFieldContainer[OperatorProto]
+    functions: _containers.RepeatedCompositeFieldContainer[_onnx_ml_pb2.FunctionProto]
+    def __init__(self, magic: _Optional[str] = ..., ir_version: _Optional[int] = ..., ir_version_prerelease: _Optional[str] = ..., ir_build_metadata: _Optional[str] = ..., domain: _Optional[str] = ..., opset_version: _Optional[int] = ..., doc_string: _Optional[str] = ..., operator: _Optional[_Iterable[_Union[OperatorProto, _Mapping]]] = ..., functions: _Optional[_Iterable[_Union[_onnx_ml_pb2.FunctionProto, _Mapping]]] = ...) -> None: ...

onnx/py.typed

@@ -1 +0,0 @@
-# Marker file for PEP-561 (inline types)

onnx/py_utils.h

@@ -15,7 +15,7 @@ template <typename Proto>
 bool ParseProtoFromPyBytes(Proto* proto, const py::bytes& bytes) {
   // Get the buffer from Python bytes object
   char* buffer = nullptr;
-  Py_ssize_t length;
+  Py_ssize_t length = 0;
   PyBytes_AsStringAndSize(bytes.ptr(), &buffer, &length);
 
   return ParseProtoFromBytes(proto, buffer, length);

onnx/reference/op_run.py

@@ -4,35 +4,14 @@
 from __future__ import annotations
 
 import abc
-from typing import Any, ClassVar, Iterable
+from typing import TYPE_CHECKING, Any
 
 import numpy as np
 
-from onnx import TensorProto
-from onnx._custom_element_types import (
-    bfloat16,
-    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
-
-
-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
+import onnx
+
+if TYPE_CHECKING:
+    from collections.abc import Sequence
 
 
 class RuntimeTypeError(RuntimeError):
@@ -65,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
 
 
@@ -88,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:
@@ -114,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
 
 
@@ -145,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)}.")
@@ -187,29 +177,29 @@ 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())
             else:
                 functions = None
             evaluator_cls = self.run_params.get("evaluator_cls", None)
-            assert (
-                evaluator_cls is not None
-            ), f"evaluator_cls must be specified to evaluate att={att}"
+            assert evaluator_cls is not None, (
+                f"evaluator_cls must be specified to evaluate att={att}"
+            )
             return evaluator_cls(
                 att.g,
                 opsets=self.run_params["opsets"],
@@ -217,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}, "
@@ -248,19 +242,21 @@ 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}",
-                    lambda context, value=value, attributes=None: OpRun._evaluate_subgraph(
+                    lambda context,
+                    value=value,
+                    attributes=None: OpRun._evaluate_subgraph(
                         context, value, attributes
                     ),
                 )
 
         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(
@@ -273,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)
@@ -281,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:
@@ -305,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
@@ -343,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.
@@ -387,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.
 
@@ -481,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
@@ -495,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:
@@ -525,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
@@ -568,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
@@ -580,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:
@@ -603,12 +599,7 @@ class OpRun(abc.ABC):
 class OpRunExpand(OpRun):
     """Class any operator to avoid must inherit from."""
 
-    def __init__(
-        self,
-        onnx_node: NodeProto,  # noqa: ARG002
-        run_params: dict[str, Any],  # noqa: ARG002
-        impl: Any = None,  # noqa: ARG002
-    ):
+    def __init__(self, *args, **kwargs):  # noqa: ARG002
         raise RuntimeError(
             f"The reference implementation must not use this node ({type(self)})."
         )
@@ -624,11 +615,11 @@ 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,
-    ):
+    ) -> None:
         if impl is None:
             raise RuntimeError(
                 f"impl cannot be None for node type {onnx_node.op_type!r} "
@@ -643,14 +634,14 @@ 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)} "
-                f"and the expected number of inputs {len(impl.inputs)} "
+                f"and the expected number of inputs {len(impl.input_names)} "
                 f"for node {self.op_type!r} from domain {self.domain!r}."
             )
         feeds = dict(zip(impl.input_names, inputs))
@@ -669,45 +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]
-                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)