onnx 1.16.1__cp38-cp38-win_amd64.whl → 1.17.0__cp38-cp38-win_amd64.whl

onnx/test/version_converter_test.py

@@ -1,11 +1,11 @@
 # Copyright (c) ONNX Project Contributors
 
 # SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
 
 import contextlib
 import struct
 import unittest
-from typing import Optional, Tuple
 
 import numpy as np
 import parameterized
@@ -1439,6 +1439,25 @@ class TestVersionConverter(unittest.TestCase):
         assert converted_model.graph.node[0].op_type == "Split"
         assert converted_model.opset_import[0].version == 12
 
+    def test_split_with_optional_input(self) -> None:
+
+        nodes = [helper.make_node("Split", ["X"], ["Y1", "Y2"], axis=1)]
+        graph = helper.make_graph(
+            nodes,
+            "test_split_optional_input",
+            [helper.make_tensor_value_info("X", TensorProto.FLOAT, (6,))],
+            [
+                helper.make_tensor_value_info("Y1", TensorProto.FLOAT, (3,)),
+                helper.make_tensor_value_info("Y2", TensorProto.FLOAT, (3,)),
+            ],
+        )
+        converted_model = self._converted(graph, helper.make_operatorsetid("", 12), 18)
+
+        assert converted_model.graph.node[0].op_type == "Split"
+        assert converted_model.opset_import[0].version == 18
+
+        assert len(converted_model.graph.node[0].output) == 2
+
     # Test Split Adapter: 12 -> 13
     def test_split_12_13(self) -> None:
         nodes = [helper.make_node("Split", ["X"], ["Y1", "Y2"], split=[2, 3])]
@@ -2057,12 +2076,12 @@ class TestVersionConverter(unittest.TestCase):
     def test_quantize_21_20(
         self,
         _: str,
-        x_shape: Tuple[int, ...],
-        scale_shape: Tuple[int, ...],
+        x_shape: tuple[int, ...],
+        scale_shape: tuple[int, ...],
         axis: int,
         block_size: int,
-        output_dtype: Optional[int],
-        zero_point_dtype: Optional[int],
+        output_dtype: int | None,
+        zero_point_dtype: int | None,
         compatible: bool,
     ) -> None:
         def test(
@@ -2116,8 +2135,8 @@ class TestVersionConverter(unittest.TestCase):
     def test_dequantize_21_20(
         self,
         _: str,
-        y_shape: Tuple[int, ...],
-        scale_shape: Tuple[int, ...],
+        y_shape: tuple[int, ...],
+        scale_shape: tuple[int, ...],
         axis: int,
         block_size: int,
         compatible: bool,

onnx/test/version_utils.py

@@ -1,6 +1,7 @@
 # Copyright (c) ONNX Project Contributors
 
 # SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
 
 from packaging.version import parse as version
 
@@ -10,3 +11,10 @@ def numpy_older_than(ver: str) -> bool:
     import numpy  # pylint: disable=import-outside-toplevel
 
     return version(numpy.__version__) < version(ver)
+
+
+def pillow_older_than(ver: str) -> bool:
+    """Returns True if the pillow version is older than the given version."""
+    import PIL  # pylint: disable=import-outside-toplevel
+
+    return version(PIL.__version__) < version(ver)

onnx/tools/net_drawer.py

@@ -3,7 +3,7 @@
 # SPDX-License-Identifier: Apache-2.0
 # A library and utility for drawing ONNX nets. Most of this implementation has
 # been borrowed from the caffe2 implementation
-# https://github.com/pytorch/pytorch/blob/master/caffe2/python/net_drawer.py
+# https://github.com/pytorch/pytorch/blob/v2.3.1/caffe2/python/net_drawer.py
 #
 # The script takes two required arguments:
 #   -input: a path to a serialized ModelProto .pb file.
@@ -13,11 +13,12 @@
 # with the graphviz `dot` utility, like so:
 #
 #   $ dot -Tsvg my_output.dot -o my_output.svg
+from __future__ import annotations
 
 import argparse
 import json
 from collections import defaultdict
-from typing import Any, Callable, Dict, Optional
+from typing import Any, Callable
 
 import pydot
 
@@ -70,16 +71,16 @@ def GetOpNodeProducer(  # noqa: N802
 
 def GetPydotGraph(  # noqa: N802
     graph: GraphProto,
-    name: Optional[str] = None,
+    name: str | None = None,
     rankdir: str = "LR",
-    node_producer: Optional[_NodeProducer] = None,
+    node_producer: _NodeProducer | None = None,
     embed_docstring: bool = False,
 ) -> pydot.Dot:
     if node_producer is None:
         node_producer = GetOpNodeProducer(embed_docstring=embed_docstring, **OP_STYLE)
     pydot_graph = pydot.Dot(name, rankdir=rankdir)
-    pydot_nodes: Dict[str, pydot.Node] = {}
-    pydot_node_counts: Dict[str, int] = defaultdict(int)
+    pydot_nodes: dict[str, pydot.Node] = {}
+    pydot_node_counts: dict[str, int] = defaultdict(int)
     for op_id, op in enumerate(graph.node):
         op_node = node_producer(op, op_id)
         pydot_graph.add_node(op_node)

onnx/tools/replace_constants.py

@@ -1,7 +1,7 @@
 # Copyright (c) ONNX Project Contributors
 
 # SPDX-License-Identifier: Apache-2.0
-from typing import List, Optional, Union
+from __future__ import annotations
 
 import numpy as np
 
@@ -30,7 +30,7 @@ from onnx.numpy_helper import from_array
 
 def _replace_constant(
     node: NodeProto, threshold: int, value_constant_of_shape: float
-) -> List[NodeProto]:
+) -> list[NodeProto]:
     """Replaces a Constant node with a large tensor (with more than threshold elements) by a sequence of nodes that produces a dummy constant of same shape as original tensor."""
     if node.op_type != "Constant":
         raise TypeError(f"Node type must be 'Constant' not {node.op_type!r}.")
@@ -69,8 +69,8 @@ def _replace_constant(
 
 
 def _replace_constant_of_shape_with_range(
-    onx: Union[GraphProto, FunctionProto]
-) -> Union[GraphProto, FunctionProto]:
+    onx: GraphProto | FunctionProto,
+) -> GraphProto | FunctionProto:
     """Replaces all *ConstantOfShape* by node *Range* to avoid constant tensors.
 
     The function is not recursive. The recursivity is done by
@@ -157,8 +157,8 @@ def _replace_constant_of_shape_with_range(
 
 
 def _replace_constant_of_shape_value(
-    onx: Union[GraphProto, FunctionProto], value_constant_of_shape: float
-) -> Union[GraphProto, FunctionProto]:
+    onx: GraphProto | FunctionProto, value_constant_of_shape: float
+) -> GraphProto | FunctionProto:
     """Replaces all fill value of all nodes *ConstantOfShape*."""
     if isinstance(onx, GraphProto):
         nodes = list(onx.node)
@@ -212,9 +212,9 @@ def _replace_constant_of_shape_value(
 
 
 def replace_initializer_by_constant_of_shape(  # noqa: PLR0911
-    onx: Union[FunctionProto, GraphProto, ModelProto],
+    onx: FunctionProto | GraphProto | ModelProto,
     threshold: int = 128,
-    ir_version: Optional[int] = None,
+    ir_version: int | None = None,
     use_range: bool = False,
     value_constant_of_shape: float = 0.5,
 ):
@@ -244,7 +244,7 @@ def replace_initializer_by_constant_of_shape(  # noqa: PLR0911
     """
     if isinstance(onx, FunctionProto):
         modified = False
-        new_nodes: List[NodeProto] = []
+        new_nodes: list[NodeProto] = []
         for node in onx.node:
             if node.op_type == "Constant":
                 cst_nodes = _replace_constant(node, threshold, value_constant_of_shape)
@@ -331,7 +331,7 @@ def replace_initializer_by_constant_of_shape(  # noqa: PLR0911
     removed = set()
     additional_inputs = []
 
-    new_inits: List[TensorProto] = []
+    new_inits: list[TensorProto] = []
     for init in onx.initializer:
         dims = tuple(init.dims)
         size = np.prod(dims)
@@ -357,7 +357,7 @@ def replace_initializer_by_constant_of_shape(  # noqa: PLR0911
                 make_tensor_value_info(new_name, TensorProto.INT64, [len(dims)])
             )
 
-    new_sparse_inits: List[SparseTensorProto] = []
+    new_sparse_inits: list[SparseTensorProto] = []
     for sp_init in onx.sparse_initializer:
         dims = tuple(sp_init.dims)
         size = np.prod(dims)

onnx/tools/update_model_dims.py

@@ -1,8 +1,9 @@
 # Copyright (c) ONNX Project Contributors
 
 # SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
 
-from typing import Any, Dict, List, Set
+from typing import Any
 
 import onnx.checker
 from onnx import ModelProto, ValueInfoProto
@@ -10,8 +11,8 @@ from onnx import ModelProto, ValueInfoProto
 
 def update_inputs_outputs_dims(
     model: ModelProto,
-    input_dims: Dict[str, List[Any]],
-    output_dims: Dict[str, List[Any]],
+    input_dims: dict[str, list[Any]],
+    output_dims: dict[str, list[Any]],
 ) -> ModelProto:
     """This function updates the dimension sizes of the model's inputs and outputs to the values
     provided in input_dims and output_dims. if the dim value provided is negative, a unique dim_param
@@ -43,10 +44,10 @@ def update_inputs_outputs_dims(
         updated_model = update_inputs_outputs_dims(model, input_dims, output_dims)
         onnx.save(updated_model, 'model.onnx')
     """
-    dim_param_set: Set[str] = set()
+    dim_param_set: set[str] = set()
 
     def init_dim_param_set(
-        dim_param_set: Set[str], value_infos: List[ValueInfoProto]
+        dim_param_set: set[str], value_infos: list[ValueInfoProto]
     ) -> None:
         for info in value_infos:
             shape = info.type.tensor_type.shape
@@ -77,7 +78,7 @@ def update_inputs_outputs_dims(
         elif isinstance(dim, str):
             dim_proto.dim_param = dim
         else:
-            raise ValueError(
+            raise ValueError(  # noqa: TRY004
                 f"Only int or str is accepted as dimension value, incorrect type: {type(dim)}"
             )
 

onnx/utils.py

@@ -4,6 +4,7 @@
 from __future__ import annotations
 
 import os
+import tarfile
 
 import onnx.checker
 import onnx.helper
@@ -29,12 +30,9 @@ class Extractor:
         io_names_to_keep = s_io_names_to_extract & original_io_names
         new_io_names_to_add = s_io_names_to_extract - original_io_names
 
-        new_io_tensors = []
-        for name in io_names_to_keep:
-            new_io_tensors.append(original_io_map[name])
-        for name in new_io_names_to_add:
-            # activation become input or output
-            new_io_tensors.append(self.vimap[name])
+        new_io_tensors = [original_io_map[name] for name in io_names_to_keep]
+        # activation become input or output
+        new_io_tensors.extend(self.vimap[name] for name in new_io_names_to_add)
 
         # adjust sequence
         new_io_tensors_map = self._build_name2obj_dict(new_io_tensors)
@@ -49,21 +47,39 @@ class Extractor:
     def _dfs_search_reachable_nodes(
         self,
         node_output_name: str,
-        graph_input_names: list[str],
-        reachable_nodes: list[NodeProto],
+        graph_input_names: set[str],
+        nodes: list[NodeProto],
+        reachable: set[int],
+        unreachable: set[int],
     ) -> None:
+        """Helper function to find nodes which are connected to an output
+
+        Arguments:
+            node_output_name (str): The name of the output
+            graph_input_names (set of string): The names of all inputs of the graph
+            nodes (list of nodes): The list of all nodes of the graph
+            reachable (set of int): The set of indexes to reachable nodes in `nodes`
+            unreachable (set of int): The set of indexes to unreachable nodes in `nodes`
+        """
+        # finish search at inputs
         if node_output_name in graph_input_names:
             return
-        for node in self.graph.node:
-            # check output_name first to reduce run time
-            if node_output_name not in node.output:
-                continue
-            if node in reachable_nodes:
-                continue
-            reachable_nodes.append(node)
-            for name in node.input:
+
+        # find nodes connected to this output
+        nodes_to_search = [
+            index for index in unreachable if node_output_name in nodes[index].output
+        ]
+
+        # add nodes connected to this output to sets
+        for node_index in nodes_to_search:
+            reachable.add(node_index)
+            unreachable.remove(node_index)
+
+        # recurse on inputs
+        for node_index in nodes_to_search:
+            for name in nodes[node_index].input:
                 self._dfs_search_reachable_nodes(
-                    name, graph_input_names, reachable_nodes
+                    name, graph_input_names, nodes, reachable, unreachable
                 )
 
     def _collect_reachable_nodes(
@@ -71,11 +87,16 @@ class Extractor:
         input_names: list[str],
         output_names: list[str],
     ) -> list[NodeProto]:
-        reachable_nodes = []  # type: ignore[var-annotated]
+        _input_names = set(input_names)
+        nodes = list(self.graph.node)
+        reachable: set[int] = set()
+        unreachable: set[int] = set(range(len(nodes)))
         for name in output_names:
-            self._dfs_search_reachable_nodes(name, input_names, reachable_nodes)
-        # needs to be topology sorted.
-        nodes = [n for n in self.graph.node if n in reachable_nodes]
+            self._dfs_search_reachable_nodes(
+                name, _input_names, nodes, reachable, unreachable
+            )
+        # needs to be topologically sorted
+        nodes = [nodes[node_index] for node_index in sorted(reachable)]
         return nodes
 
     def _collect_referred_local_functions(
@@ -212,3 +233,65 @@ def extract_model(
     onnx.save(extracted, output_path)
     if check_model:
         onnx.checker.check_model(output_path)
+
+
+def _tar_members_filter(
+    tar: tarfile.TarFile, base: str | os.PathLike
+) -> list[tarfile.TarInfo]:
+    """Check that the content of ``tar`` will be extracted safely
+
+    Args:
+        tar: The tarball file
+        base: The directory where the tarball will be extracted
+
+    Returns:
+        list of tarball members
+    """
+    result = []
+    for member in tar:
+        member_path = os.path.join(base, member.name)
+        abs_base = os.path.abspath(base)
+        abs_member = os.path.abspath(member_path)
+        if not abs_member.startswith(abs_base):
+            raise RuntimeError(
+                f"The tarball member {member_path} in downloading model contains "
+                f"directory traversal sequence which may contain harmful payload."
+            )
+        elif member.issym() or member.islnk():
+            raise RuntimeError(
+                f"The tarball member {member_path} in downloading model contains "
+                f"symbolic links which may contain harmful payload."
+            )
+        result.append(member)
+    return result
+
+
+def _extract_model_safe(
+    model_tar_path: str | os.PathLike, local_model_with_data_dir_path: str | os.PathLike
+) -> None:
+    """Safely extracts a tar file to a specified directory.
+
+    This function ensures that the extraction process mitigates against
+    directory traversal vulnerabilities by validating or sanitizing paths
+    within the tar file. It also provides compatibility for different versions
+    of the tarfile module by checking for the availability of certain attributes
+    or methods before invoking them.
+
+    Args:
+        model_tar_path: The path to the tar file to be extracted.
+        local_model_with_data_dir_path: The directory path where the tar file
+      contents will be extracted to.
+    """
+    with tarfile.open(model_tar_path) as model_with_data_zipped:
+        # Mitigate tarball directory traversal risks
+        if hasattr(tarfile, "data_filter"):
+            model_with_data_zipped.extractall(
+                path=local_model_with_data_dir_path, filter="data"
+            )
+        else:
+            model_with_data_zipped.extractall(
+                path=local_model_with_data_dir_path,
+                members=_tar_members_filter(
+                    model_with_data_zipped, local_model_with_data_dir_path
+                ),
+            )

onnx/version.py

@@ -1,5 +1,5 @@
 # This file is generated by setup.py. DO NOT EDIT!
 
 
-version = "1.16.1"
-git_version = "595228d99e3977ac27cb79d5963adda262af99ad"
+version = "1.17.0"
+git_version = "b8baa8446686496da4cc8fda09f2b6fe65c2a02c"

onnx/version_converter/adapters/split_17_18.h

@@ -22,7 +22,7 @@ class Split_17_18 : public Adapter {
 
   void adapt_split_17_18(std::shared_ptr<Graph>, Node* node) const {
     const auto num_outputs = node->outputs().size();
-    SetAttribute(knum_outputs, num_outputs);
+    node->i_(knum_outputs, num_outputs);
   }
 
   Node* adapt(std::shared_ptr<Graph> graph, Node* node) const override {

onnx/version_converter/convert.h

@@ -633,8 +633,6 @@ class DefaultVersionConverter : public BaseVersionConverter {
     registerAdapter(std::make_unique<CompatibleAdapter>("GroupNormalization", OpSetID(20), OpSetID(21)));
 
     /******** 21 -> 20 ********/
-    const std::vector<TensorProto_DataType> q_dq_20_unallowed_types = {
-        TensorProto_DataType_UINT16, TensorProto_DataType_INT16, TensorProto_DataType_UINT4, TensorProto_DataType_INT4};
     const std::vector<TensorProto_DataType> q_dqmm_20_unallowed_types = {
         TensorProto_DataType_BFLOAT16,
         TensorProto_DataType_FLOAT16,
@@ -671,6 +669,113 @@ class DefaultVersionConverter : public BaseVersionConverter {
     registerAdapter(std::make_unique<TypeRestriction>("Squeeze", OpSetID(21), OpSetID(20), ir10_types_not_in_ir4));
     registerAdapter(std::make_unique<TypeRestriction>("Transpose", OpSetID(21), OpSetID(20), ir10_types_not_in_ir9));
     registerAdapter(std::make_unique<TypeRestriction>("Unsqueeze", OpSetID(21), OpSetID(20), ir10_types_not_in_ir4));
+
+    /******** 21 -> 22 ********/
+    registerAdapter(std::make_unique<CompatibleAdapter>("EyeLike", OpSetID(21), OpSetID(22)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("RandomUniform", OpSetID(21), OpSetID(22)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("RandomNormal", OpSetID(21), OpSetID(22)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("RandomUniformLike", OpSetID(21), OpSetID(22)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("RandomNormalLike", OpSetID(21), OpSetID(22)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Multinomial", OpSetID(21), OpSetID(22)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Bernoulli", OpSetID(21), OpSetID(22)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("ThresholdedRelu", OpSetID(21), OpSetID(22)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Selu", OpSetID(21), OpSetID(22)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Elu", OpSetID(21), OpSetID(22)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Mish", OpSetID(21), OpSetID(22)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("HardSigmoid", OpSetID(21), OpSetID(22)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("HardSwish", OpSetID(21), OpSetID(22)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Softsign", OpSetID(21), OpSetID(22)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Softplus", OpSetID(21), OpSetID(22)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Sin", OpSetID(21), OpSetID(22)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Cos", OpSetID(21), OpSetID(22)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Tan", OpSetID(21), OpSetID(22)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Asin", OpSetID(21), OpSetID(22)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Acos", OpSetID(21), OpSetID(22)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Atan", OpSetID(21), OpSetID(22)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Sinh", OpSetID(21), OpSetID(22)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Cosh", OpSetID(21), OpSetID(22)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Asinh", OpSetID(21), OpSetID(22)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Acosh", OpSetID(21), OpSetID(22)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Atanh", OpSetID(21), OpSetID(22)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Round", OpSetID(21), OpSetID(22)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Det", OpSetID(21), OpSetID(22)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("NegativeLogLikelihoodLoss", OpSetID(21), OpSetID(22)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("AveragePool", OpSetID(21), OpSetID(22)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("MaxPool", OpSetID(21), OpSetID(22)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("MaxUnpool", OpSetID(21), OpSetID(22)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("LpPool", OpSetID(21), OpSetID(22)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("MaxRoiPool", OpSetID(21), OpSetID(22)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Conv", OpSetID(21), OpSetID(22)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("ConvTranspose", OpSetID(21), OpSetID(22)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("DeformConv", OpSetID(21), OpSetID(22)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("GlobalAveragePool", OpSetID(21), OpSetID(22)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("GlobalMaxPool", OpSetID(21), OpSetID(22)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("GlobalLpPool", OpSetID(21), OpSetID(22)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("InstanceNormalization", OpSetID(21), OpSetID(22)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("LpNormalization", OpSetID(21), OpSetID(22)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("Dropout", OpSetID(21), OpSetID(22)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("RoiAlign", OpSetID(21), OpSetID(22)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("RNN", OpSetID(21), OpSetID(22)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("GRU", OpSetID(21), OpSetID(22)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("LSTM", OpSetID(21), OpSetID(22)));
+    registerAdapter(std::make_unique<CompatibleAdapter>("GridSample", OpSetID(21), OpSetID(22)));
+
+    /******** 22 -> 21 ********/
+    const std::vector<TensorProto_DataType> bfloat16_not_allowed = {TensorProto_DataType_BFLOAT16};
+    registerAdapter(std::make_unique<TypeRestriction>("EyeLike", OpSetID(22), OpSetID(21), bfloat16_not_allowed));
+    registerAdapter(std::make_unique<TypeRestriction>("AveragePool", OpSetID(22), OpSetID(21), bfloat16_not_allowed));
+    registerAdapter(std::make_unique<TypeRestriction>("MaxPool", OpSetID(22), OpSetID(21), bfloat16_not_allowed));
+    registerAdapter(std::make_unique<TypeRestriction>("RandomUniform", OpSetID(22), OpSetID(21), bfloat16_not_allowed));
+    registerAdapter(std::make_unique<TypeRestriction>("RandomNormal", OpSetID(22), OpSetID(21), bfloat16_not_allowed));
+    registerAdapter(
+        std::make_unique<TypeRestriction>("RandomNormalLike", OpSetID(22), OpSetID(21), bfloat16_not_allowed));
+    registerAdapter(
+        std::make_unique<TypeRestriction>("RandomUniformLike", OpSetID(22), OpSetID(21), bfloat16_not_allowed));
+    registerAdapter(std::make_unique<TypeRestriction>("Multinomial", OpSetID(22), OpSetID(21), bfloat16_not_allowed));
+    registerAdapter(std::make_unique<TypeRestriction>("Bernoulli", OpSetID(22), OpSetID(21), bfloat16_not_allowed));
+    registerAdapter(
+        std::make_unique<TypeRestriction>("ThresholdedRelu", OpSetID(22), OpSetID(21), bfloat16_not_allowed));
+    registerAdapter(std::make_unique<TypeRestriction>("Selu", OpSetID(22), OpSetID(21), bfloat16_not_allowed));
+    registerAdapter(std::make_unique<TypeRestriction>("Elu", OpSetID(22), OpSetID(21), bfloat16_not_allowed));
+    registerAdapter(std::make_unique<TypeRestriction>("Mish", OpSetID(22), OpSetID(21), bfloat16_not_allowed));
+    registerAdapter(std::make_unique<TypeRestriction>("HardSigmoid", OpSetID(22), OpSetID(21), bfloat16_not_allowed));
+    registerAdapter(std::make_unique<TypeRestriction>("HardSwish", OpSetID(22), OpSetID(21), bfloat16_not_allowed));
+    registerAdapter(std::make_unique<TypeRestriction>("Softsign", OpSetID(22), OpSetID(21), bfloat16_not_allowed));
+    registerAdapter(std::make_unique<TypeRestriction>("Softplus", OpSetID(22), OpSetID(21), bfloat16_not_allowed));
+    registerAdapter(std::make_unique<TypeRestriction>("Sin", OpSetID(22), OpSetID(21), bfloat16_not_allowed));
+    registerAdapter(std::make_unique<TypeRestriction>("Cos", OpSetID(22), OpSetID(21), bfloat16_not_allowed));
+    registerAdapter(std::make_unique<TypeRestriction>("Tan", OpSetID(22), OpSetID(21), bfloat16_not_allowed));
+    registerAdapter(std::make_unique<TypeRestriction>("Asin", OpSetID(22), OpSetID(21), bfloat16_not_allowed));
+    registerAdapter(std::make_unique<TypeRestriction>("Acos", OpSetID(22), OpSetID(21), bfloat16_not_allowed));
+    registerAdapter(std::make_unique<TypeRestriction>("Atan", OpSetID(22), OpSetID(21), bfloat16_not_allowed));
+    registerAdapter(std::make_unique<TypeRestriction>("Sinh", OpSetID(22), OpSetID(21), bfloat16_not_allowed));
+    registerAdapter(std::make_unique<TypeRestriction>("Cosh", OpSetID(22), OpSetID(21), bfloat16_not_allowed));
+    registerAdapter(std::make_unique<TypeRestriction>("Asinh", OpSetID(22), OpSetID(21), bfloat16_not_allowed));
+    registerAdapter(std::make_unique<TypeRestriction>("Acosh", OpSetID(22), OpSetID(21), bfloat16_not_allowed));
+    registerAdapter(std::make_unique<TypeRestriction>("Atanh", OpSetID(22), OpSetID(21), bfloat16_not_allowed));
+    registerAdapter(std::make_unique<TypeRestriction>("Round", OpSetID(22), OpSetID(21), bfloat16_not_allowed));
+    registerAdapter(std::make_unique<TypeRestriction>("Det", OpSetID(22), OpSetID(21), bfloat16_not_allowed));
+    registerAdapter(
+        std::make_unique<TypeRestriction>("NegativeLogLikelihoodLoss", OpSetID(22), OpSetID(21), bfloat16_not_allowed));
+    registerAdapter(std::make_unique<TypeRestriction>("MaxUnpool", OpSetID(22), OpSetID(21), bfloat16_not_allowed));
+    registerAdapter(std::make_unique<TypeRestriction>("LpPool", OpSetID(22), OpSetID(21), bfloat16_not_allowed));
+    registerAdapter(std::make_unique<TypeRestriction>("MaxRoiPool", OpSetID(22), OpSetID(21), bfloat16_not_allowed));
+    registerAdapter(std::make_unique<TypeRestriction>("Conv", OpSetID(22), OpSetID(21), bfloat16_not_allowed));
+    registerAdapter(std::make_unique<TypeRestriction>("ConvTranspose", OpSetID(22), OpSetID(21), bfloat16_not_allowed));
+    registerAdapter(std::make_unique<TypeRestriction>("DeformConv", OpSetID(22), OpSetID(21), bfloat16_not_allowed));
+    registerAdapter(
+        std::make_unique<TypeRestriction>("GlobalAveragePool", OpSetID(22), OpSetID(21), bfloat16_not_allowed));
+    registerAdapter(std::make_unique<TypeRestriction>("GlobalLpPool", OpSetID(22), OpSetID(21), bfloat16_not_allowed));
+    registerAdapter(
+        std::make_unique<TypeRestriction>("InstanceNormalization", OpSetID(22), OpSetID(21), bfloat16_not_allowed));
+    registerAdapter(
+        std::make_unique<TypeRestriction>("LpNormalization", OpSetID(22), OpSetID(21), bfloat16_not_allowed));
+    registerAdapter(std::make_unique<TypeRestriction>("Dropout", OpSetID(22), OpSetID(21), bfloat16_not_allowed));
+    registerAdapter(std::make_unique<TypeRestriction>("RoiAlign", OpSetID(22), OpSetID(21), bfloat16_not_allowed));
+    registerAdapter(std::make_unique<TypeRestriction>("RNN", OpSetID(22), OpSetID(21), bfloat16_not_allowed));
+    registerAdapter(std::make_unique<TypeRestriction>("GRU", OpSetID(22), OpSetID(21), bfloat16_not_allowed));
+    registerAdapter(std::make_unique<TypeRestriction>("LSTM", OpSetID(22), OpSetID(21), bfloat16_not_allowed));
+    registerAdapter(std::make_unique<TypeRestriction>("GridSample", OpSetID(22), OpSetID(21), bfloat16_not_allowed));
   }
 
   ModelProto convert_version(const ModelProto& mp_in, const OpSetID& initial_version, const OpSetID& target_version)

onnx/version_converter.py

@@ -6,6 +6,7 @@
 This enables users to convert their models between different opsets within the
 default domain ("" or "ai.onnx").
 """
+from __future__ import annotations
 
 import onnx
 import onnx.onnx_cpp2py_export.version_converter as C  # noqa: N812
@@ -26,11 +27,11 @@ def convert_version(model: ModelProto, target_version: int) -> ModelProto:
         RuntimeError when some necessary conversion is not supported.
     """
     if not isinstance(model, ModelProto):
-        raise ValueError(
+        raise TypeError(
             f"VersionConverter only accepts ModelProto as model, incorrect type: {type(model)}"
         )
     if not isinstance(target_version, int):
-        raise ValueError(
+        raise TypeError(
             f"VersionConverter only accepts int as target_version, incorrect type: {type(target_version)}"
         )
     model_str = model.SerializeToString()

{onnx-1.16.1.dist-info → onnx-1.17.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: onnx
-Version: 1.16.1
+Version: 1.17.0
 Summary: Open Neural Network Exchange
 Author-email: ONNX Contributors <onnx-technical-discuss@lists.lfaidata.foundation>
 License: Apache License v2.0
@@ -18,23 +18,20 @@ Requires-Dist: Pillow ; extra == 'reference'
 
 <!--
 Copyright (c) ONNX Project Contributors
--->
 
-<!--- SPDX-License-Identifier: Apache-2.0 -->
+SPDX-License-Identifier: Apache-2.0
+-->
 
 <p align="center"><img width="40%" src="https://github.com/onnx/onnx/raw/main/docs/onnx-horizontal-color.png" /></p>
 
 [![PyPI - Version](https://img.shields.io/pypi/v/onnx.svg)](https://pypi.org/project/onnx)
-[![Build Status](https://dev.azure.com/onnx-pipelines/onnx/_apis/build/status/Windows-CI?branchName=main&label=Windows)](https://dev.azure.com/onnx-pipelines/onnx/_build/latest?definitionId=5&branchName=main)
-[![Build Status](https://dev.azure.com/onnx-pipelines/onnx/_apis/build/status/Linux-CI?branchName=main&label=Linux)](https://dev.azure.com/onnx-pipelines/onnx/_build/latest?definitionId=7&branchName=main)
-[![Build Status](https://dev.azure.com/onnx-pipelines/onnx/_apis/build/status/MacOS-CI?branchName=main&label=MacOS)](https://dev.azure.com/onnx-pipelines/onnx/_build/latest?definitionId=6&branchName=main)
+[![CI](https://github.com/onnx/onnx/actions/workflows/main.yml/badge.svg)](https://github.com/onnx/onnx/actions/workflows/main.yml)
 [![CII Best Practices](https://bestpractices.coreinfrastructure.org/projects/3313/badge)](https://bestpractices.coreinfrastructure.org/projects/3313)
 [![OpenSSF Scorecard](https://api.securityscorecards.dev/projects/github.com/onnx/onnx/badge)](https://api.securityscorecards.dev/projects/github.com/onnx/onnx)
 [![REUSE compliant](https://api.reuse.software/badge/github.com/onnx/onnx)](https://api.reuse.software/info/github.com/onnx/onnx)
 [![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)
 [![Black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
 
-
 [Open Neural Network Exchange (ONNX)](https://onnx.ai) is an open ecosystem that empowers AI developers
 to choose the right tools as their project evolves. ONNX provides an open source format for AI models, both deep learning and traditional ML. It defines an extensible computation graph model, as well as definitions of built-in operators and standard
 data types. Currently we focus on the capabilities needed for inferencing (scoring).
@@ -173,7 +170,7 @@ msbuild INSTALL.vcxproj /p:Configuration=Release
 Then it will be built as a static library and installed to <protobuf_install_dir>. Please add the bin directory(which contains protoc.exe) to your PATH.
 
 ```bat
-set PATH=<protobuf_install_dir>/bin;%PATH%
+set CMAKE_PREFIX_PATH=<protobuf_install_dir>;%CMAKE_PREFIX_PATH%
 ```
 
 Please note: if your protobuf_install_dir contains spaces, **do not** add quotation marks around it.
@@ -192,7 +189,7 @@ cd onnx
 git submodule update --init --recursive
 # prefer lite proto
 set CMAKE_ARGS=-DONNX_USE_LITE_PROTO=ON
-pip install -e .
+pip install -e . -v
 ```
 
 ### Linux
@@ -252,7 +249,7 @@ cd onnx
 git submodule update --init --recursive
 # Optional: prefer lite proto
 export CMAKE_ARGS=-DONNX_USE_LITE_PROTO=ON
-pip install -e .
+pip install -e . -v
 ```
 
 ### Mac
@@ -279,7 +276,7 @@ git clone --recursive https://github.com/onnx/onnx.git
 cd onnx
 # Optional: prefer lite proto
 set CMAKE_ARGS=-DONNX_USE_LITE_PROTO=ON
-pip install -e .
+pip install -e . -v
 ```
 
 ## Verify Installation