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

onnx/backend/test/report/coverage.py

@@ -1,12 +1,13 @@
 # Copyright (c) ONNX Project Contributors
 
 # SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
 
 import csv
 import datetime
 import os
 from collections import OrderedDict, defaultdict
-from typing import IO, Any, Dict, List, Optional, Set
+from typing import IO, Any
 
 from tabulate import tabulate
 
@@ -18,8 +19,8 @@ _all_schemas = defs.get_all_schemas()
 
 class AttrCoverage:
     def __init__(self) -> None:
-        self.name: Optional[str] = None
-        self.values: Set[str] = set()
+        self.name: str | None = None
+        self.values: set[str] = set()
 
     def add(self, attr: onnx.AttributeProto) -> None:
         assert self.name in {None, attr.name}
@@ -35,8 +36,8 @@ class AttrCoverage:
 
 class NodeCoverage:
     def __init__(self) -> None:
-        self.op_type: Optional[str] = None
-        self.attr_coverages: Dict[str, AttrCoverage] = defaultdict(AttrCoverage)
+        self.op_type: str | None = None
+        self.attr_coverages: dict[str, AttrCoverage] = defaultdict(AttrCoverage)
 
     def add(self, node: onnx.NodeProto) -> None:
         assert self.op_type in [None, node.op_type]
@@ -52,9 +53,9 @@ class NodeCoverage:
 
 class ModelCoverage:
     def __init__(self) -> None:
-        self.name: Optional[str] = None
-        self.graph: Optional[GraphProto] = None
-        self.node_coverages: Dict[str, NodeCoverage] = defaultdict(NodeCoverage)
+        self.name: str | None = None
+        self.graph: GraphProto | None = None
+        self.node_coverages: dict[str, NodeCoverage] = defaultdict(NodeCoverage)
 
     def add(self, model: onnx.ModelProto) -> None:
         assert self.name in [None, model.graph.name]
@@ -70,11 +71,11 @@ class ModelCoverage:
 
 class Coverage:
     def __init__(self) -> None:
-        self.buckets: Dict[str, Dict[str, NodeCoverage]] = {
+        self.buckets: dict[str, dict[str, NodeCoverage]] = {
             "loaded": defaultdict(NodeCoverage),
             "passed": defaultdict(NodeCoverage),
         }
-        self.models: Dict[str, Dict[str, ModelCoverage]] = {
+        self.models: dict[str, dict[str, ModelCoverage]] = {
             "loaded": defaultdict(ModelCoverage),
             "passed": defaultdict(ModelCoverage),
         }
@@ -105,8 +106,8 @@ class Coverage:
 
         rows = []
         passed = []
-        all_ops: List[str] = []
-        experimental: List[str] = []
+        all_ops: list[str] = []
+        experimental: list[str] = []
         for op_cov in self.buckets["passed"].values():
             covered_attrs = [
                 f"{attr_cov.name}: {len(attr_cov.values)}"
@@ -144,7 +145,7 @@ class Coverage:
     # backend with indications of whether the tests passed or failed for
     # each row.
     def report_csv(
-        self, all_ops: List[str], passed: List[Optional[str]], experimental: List[str]
+        self, all_ops: list[str], passed: list[str | None], experimental: list[str]
     ) -> None:
         for schema in _all_schemas:
             if schema.domain in {"", "ai.onnx"}:
@@ -158,9 +159,9 @@ class Coverage:
         models_path = os.path.join(
             str(os.environ.get("CSVDIR")), "models.csv"  # type: ignore
         )  # type: ignore
-        existing_nodes: OrderedDict[str, Dict[str, str]] = OrderedDict()
-        existing_models: OrderedDict[str, Dict[str, str]] = OrderedDict()
-        frameworks: List[str] = []
+        existing_nodes: OrderedDict[str, dict[str, str]] = OrderedDict()
+        existing_models: OrderedDict[str, dict[str, str]] = OrderedDict()
+        frameworks: list[str] = []
         if os.path.isfile(nodes_path):
             with open(nodes_path) as nodes_file:
                 reader = csv.DictReader(nodes_file)
@@ -201,7 +202,7 @@ class Coverage:
                     existing_nodes[node_name][str(backend)] = "Passed!"
                 else:
                     existing_nodes[node_name][str(backend)] = "Failed!"
-            summaries: Dict[Any, Any] = {}
+            summaries: dict[Any, Any] = {}
             if "Summary" in existing_nodes:
                 summaries = existing_nodes["Summary"]
                 del existing_nodes["Summary"]
@@ -246,9 +247,9 @@ class Coverage:
                 del existing_models["Summary"]
             if str(backend) in summaries:
                 del summaries[str(backend)]
-            summaries[
-                str(backend)
-            ] = f"{len(self.models['passed'])}/{num_models} model tests passed"
+            summaries[str(backend)] = (
+                f"{len(self.models['passed'])}/{num_models} model tests passed"
+            )
             summaries["Model"] = "Summary"
             for model in existing_models:  # type: ignore
                 existing_models[model]["Model"] = model

onnx/backend/test/runner/__init__.py

@@ -10,7 +10,6 @@ import os
 import re
 import shutil
 import sys
-import tarfile
 import tempfile
 import time
 import unittest
@@ -42,7 +41,7 @@ def retry_execute(times: int) -> Callable[[Callable[..., Any]], Callable[..., An
             for i in range(1, times + 1):
                 try:
                     return func(*args, **kwargs)
-                except Exception:
+                except Exception:  # noqa: PERF203
                     print(f"{i} times tried")
                     if i == times:
                         raise
@@ -197,7 +196,7 @@ class Runner:
         for i in range(len(outputs)):
             if isinstance(outputs[i], (list, tuple)):
                 if not isinstance(ref_outputs[i], (list, tuple)):
-                    raise AssertionError(
+                    raise AssertionError(  # noqa: TRY004
                         f"Unexpected type {type(outputs[i])} for outputs[{i}]. Expected "
                         f"type is {type(ref_outputs[i])} (known test={model_dir or '?'!r})."
                     )
@@ -225,10 +224,14 @@ class Runner:
     @classmethod
     @retry_execute(3)
     def download_model(
-        cls, model_test: TestCase, model_dir: str, models_dir: str
+        cls,
+        model_test: TestCase,
+        model_dir: str,
+        models_dir: str,
     ) -> None:
         # On Windows, NamedTemporaryFile can not be opened for a
         # second time
+        del model_dir
         download_file = tempfile.NamedTemporaryFile(delete=False)
         try:
             download_file.close()
@@ -238,8 +241,7 @@ class Runner:
             )
             urlretrieve(model_test.url, download_file.name)
             print("Done")
-            with tarfile.open(download_file.name) as t:
-                t.extractall(models_dir)
+            onnx.utils._extract_model_safe(download_file.name, models_dir)
         except Exception as e:
             print(f"Failed to prepare data for model {model_test.model_name}: {e}")
             raise
@@ -341,7 +343,7 @@ class Runner:
         # never loaded if the test skipped
         model_marker: list[ModelProto | NodeProto | None] = [None]
 
-        def run(test_self: Any, device: str, **kwargs) -> None:
+        def run(test_self: Any, device: str, **kwargs) -> None:  # noqa: ARG001
             if model_test.url is not None and model_test.url.startswith(
                 "onnx/backend/test/data/light/"
             ):
@@ -459,8 +461,8 @@ class Runner:
                     self.assert_similar_outputs(
                         ref_outputs,
                         outputs,
-                        rtol=model_test.rtol,
-                        atol=model_test.atol,
+                        rtol=kwargs.get("rtol", model_test.rtol),
+                        atol=kwargs.get("atol", model_test.atol),
                         model_dir=model_dir,
                     )
 
@@ -483,8 +485,8 @@ class Runner:
                 self.assert_similar_outputs(
                     ref_outputs,
                     outputs,
-                    rtol=model_test.rtol,
-                    atol=model_test.atol,
+                    rtol=kwargs.get("rtol", model_test.rtol),
+                    atol=kwargs.get("atol", model_test.atol),
                     model_dir=model_dir,
                 )
 

onnx/backend/test/runner/item.py

@@ -1,9 +1,10 @@
 # Copyright (c) ONNX Project Contributors
 #
 # SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
 
 import dataclasses
-from typing import Any, Callable, List, Optional, Union
+from typing import Any, Callable
 
 from onnx import ModelProto, NodeProto
 
@@ -14,4 +15,4 @@ from onnx import ModelProto, NodeProto
 @dataclasses.dataclass
 class TestItem:
     func: Callable[..., Any]
-    proto: List[Optional[Union[ModelProto, NodeProto]]]
+    proto: list[ModelProto | NodeProto | None]

onnx/backend/test/stat_coverage.py

@@ -3,9 +3,10 @@
 # Copyright (c) ONNX Project Contributors
 #
 # SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
 
 import os
-from typing import IO, Any, Dict, List, Sequence
+from typing import IO, Any, Sequence
 
 from onnx import AttributeProto, defs, load
 from onnx.backend.test.case import collect_snippets
@@ -98,7 +99,7 @@ def gen_node_test_coverage(
         f.write("Node tests have covered 0/0 (N/A) common operators. \n\n")
     if num_experimental:
         f.write(
-            "Node tests have covered {}/{} ({:.2f}%, {} generators excluded) "
+            "Node tests have covered {}/{} ({:.2f}%, {} generators excluded) "  # noqa: UP032
             "experimental operators.\n\n".format(
                 len(experimental_covered),
                 num_experimental,
@@ -155,8 +156,8 @@ def gen_model_test_coverage(
         schema_dict[schema.name] = schema
     # Load models from each model test using Runner.prepare_model_data
     # Need to grab associated nodes
-    attrs: Dict[str, Dict[str, List[Any]]] = {}
-    model_paths: List[Any] = []
+    attrs: dict[str, dict[str, list[Any]]] = {}
+    model_paths: list[Any] = []
     for rt in load_model_tests(kind="real"):
         if rt.url.startswith("onnx/backend/test/data/light/"):
             # testing local files
@@ -251,7 +252,7 @@ def gen_model_test_coverage(
 
 
 def gen_overall_test_coverage(
-    schemas: Sequence[defs.OpSchema], f: IO[Any], ml: bool
+    schemas: Sequence[defs.OpSchema], f: IO[Any], ml: bool  # noqa: ARG001
 ) -> None:
     f.write("# Overall Test Coverage\n")
     f.write("## To be filled.\n")

onnx/bin/checker.py

@@ -1,6 +1,7 @@
 # Copyright (c) ONNX Project Contributors
 #
 # SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
 
 import argparse
 

onnx/checker.cc

@@ -709,6 +709,12 @@ void check_graph(const GraphProto& graph, const CheckerContext& ctx, const Lexic
       lex_ctx.add(output);
     }
   }
+  for (const auto& value_info : graph.output()) {
+    if (!lex_ctx.this_graph_has(value_info.name())) {
+      fail_check("Graph output '", value_info.name(), "' is not an output of any node in graph.");
+    }
+  }
+
   print_warning_if_has_experimental(used_experimental_ops);
 }
 
@@ -904,7 +910,6 @@ void check_model(const ModelProto& model, CheckerContext& ctx) {
       }
     }
   }
-  std::unordered_map<std::string, int> versions;
   ctx.set_ir_version(static_cast<int>(model.ir_version()));
   std::unordered_map<std::string, int> opset_imports;
   for (const auto& opset_import : model.opset_import()) {

onnx/common/version.h

@@ -9,6 +9,6 @@
 namespace ONNX_NAMESPACE {
 
 // Represents the most recent release version. Updated with every release.
-constexpr const char* LAST_RELEASE_VERSION = "1.16.1";
+constexpr const char* LAST_RELEASE_VERSION = "1.17.0";
 
 } // namespace ONNX_NAMESPACE

onnx/compose.py

@@ -1,16 +1,24 @@
 # Copyright (c) ONNX Project Contributors
 #
 # SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
 
+from typing import MutableMapping
 
-from typing import Dict, List, MutableMapping, Optional, Set, Tuple
-
-from onnx import GraphProto, ModelProto, TensorProto, checker, helper, utils
+from onnx import (
+    AttributeProto,
+    GraphProto,
+    ModelProto,
+    TensorProto,
+    checker,
+    helper,
+    utils,
+)
 
 
 def check_overlapping_names(
-    g1: GraphProto, g2: GraphProto, io_map: Optional[List[Tuple[str, str]]] = None
-) -> List[Tuple[str, List[str]]]:
+    g1: GraphProto, g2: GraphProto, io_map: list[tuple[str, str]] | None = None
+) -> list[tuple[str, list[str]]]:
     """Checks whether there are name collisions between two graphs
 
     Returns a list of tuples where the first element represents the member containing overlapping names
@@ -25,20 +33,20 @@ def check_overlapping_names(
     if type(g2) is not GraphProto:
         raise ValueError("g2 argument is not an ONNX graph")
 
-    def _overlapping(c1: List[str], c2: List[str]) -> List[str]:
+    def _overlapping(c1: list[str], c2: list[str]) -> list[str]:
         return list(set(c1) & set(c2))
 
-    def _edge_names(graph: GraphProto, exclude: Optional[Set[str]] = None) -> List[str]:
+    def _edge_names(graph: GraphProto, exclude: set[str] | None = None) -> list[str]:
         if exclude is None:
             exclude = set()
         edges = []
         for n in graph.node:
             for i in n.input:
                 if i != "" and i not in exclude:
-                    edges.append(i)
+                    edges.append(i)  # noqa: PERF401
             for o in n.output:
                 if o != "" and o not in exclude:
-                    edges.append(o)
+                    edges.append(o)  # noqa: PERF401
         return edges
 
     result = []
@@ -80,13 +88,13 @@ def check_overlapping_names(
 def merge_graphs(
     g1: GraphProto,
     g2: GraphProto,
-    io_map: List[Tuple[str, str]],
-    inputs: Optional[List[str]] = None,
-    outputs: Optional[List[str]] = None,
-    prefix1: Optional[str] = None,
-    prefix2: Optional[str] = None,
-    name: Optional[str] = None,
-    doc_string: Optional[str] = None,
+    io_map: list[tuple[str, str]],
+    inputs: list[str] | None = None,
+    outputs: list[str] | None = None,
+    prefix1: str | None = None,
+    prefix2: str | None = None,
+    name: str | None = None,
+    doc_string: str | None = None,
 ) -> GraphProto:
     """Combines two ONNX graphs into a single one.
 
@@ -206,12 +214,20 @@ def merge_graphs(
     g.node.extend(g2.node)
     g2_nodes_end = len(g.node)
 
+    # Search inputs of the subgraph recursively
+    def connect_io(sub_graph: GraphProto, start: int, end: int) -> None:
+        for node_idx in range(start, end):
+            node = sub_graph.node[node_idx]
+            for attr in node.attribute:
+                if attr.type == AttributeProto.GRAPH:
+                    connect_io(attr.g, 0, len(attr.g.node))
+
+            for index, name_ in enumerate(node.input):
+                if name_ in reversed_io_map:
+                    node.input[index] = reversed_io_map[name_]
+
     # Connecting outputs of the first graph with the inputs of the second
-    for node_idx in range(g2_nodes_begin, g2_nodes_end):
-        node = g.node[node_idx]
-        for index, name_ in enumerate(node.input):
-            if name_ in reversed_io_map:
-                node.input[index] = reversed_io_map[name_]
+    connect_io(g, g2_nodes_begin, g2_nodes_end)
 
     if inputs:
         input_set = set(inputs)
@@ -267,17 +283,17 @@ def merge_graphs(
 def merge_models(
     m1: ModelProto,
     m2: ModelProto,
-    io_map: List[Tuple[str, str]],
-    inputs: Optional[List[str]] = None,
-    outputs: Optional[List[str]] = None,
-    prefix1: Optional[str] = None,
-    prefix2: Optional[str] = None,
-    name: Optional[str] = None,
-    doc_string: Optional[str] = None,
-    producer_name: Optional[str] = "onnx.compose.merge_models",
-    producer_version: Optional[str] = "1.0",
-    domain: Optional[str] = "",
-    model_version: Optional[int] = 1,
+    io_map: list[tuple[str, str]],
+    inputs: list[str] | None = None,
+    outputs: list[str] | None = None,
+    prefix1: str | None = None,
+    prefix2: str | None = None,
+    name: str | None = None,
+    doc_string: str | None = None,
+    producer_name: str | None = "onnx.compose.merge_models",
+    producer_version: str | None = "1.0",
+    domain: str | None = "",
+    model_version: int | None = 1,
 ) -> ModelProto:
     """Combines two ONNX models into a single one.
 
@@ -413,14 +429,14 @@ def merge_models(
 def add_prefix_graph(
     graph: GraphProto,
     prefix: str,
-    rename_nodes: Optional[bool] = True,
-    rename_edges: Optional[bool] = True,
-    rename_inputs: Optional[bool] = True,
-    rename_outputs: Optional[bool] = True,
-    rename_initializers: Optional[bool] = True,
-    rename_value_infos: Optional[bool] = True,
-    inplace: Optional[bool] = False,
-    name_map: Optional[Dict[str, str]] = None,
+    rename_nodes: bool | None = True,
+    rename_edges: bool | None = True,
+    rename_inputs: bool | None = True,
+    rename_outputs: bool | None = True,
+    rename_initializers: bool | None = True,
+    rename_value_infos: bool | None = True,
+    inplace: bool | None = False,
+    name_map: dict[str, str] | None = None,
 ) -> GraphProto:
     """Adds a prefix to names of elements in a graph: nodes, edges, inputs, outputs,
     initializers, sparse initializer, value infos.
@@ -530,14 +546,14 @@ def add_prefix_graph(
 def add_prefix(
     model: ModelProto,
     prefix: str,
-    rename_nodes: Optional[bool] = True,
-    rename_edges: Optional[bool] = True,
-    rename_inputs: Optional[bool] = True,
-    rename_outputs: Optional[bool] = True,
-    rename_initializers: Optional[bool] = True,
-    rename_value_infos: Optional[bool] = True,
-    rename_functions: Optional[bool] = True,
-    inplace: Optional[bool] = False,
+    rename_nodes: bool | None = True,
+    rename_edges: bool | None = True,
+    rename_inputs: bool | None = True,
+    rename_outputs: bool | None = True,
+    rename_initializers: bool | None = True,
+    rename_value_infos: bool | None = True,
+    rename_functions: bool | None = True,
+    inplace: bool | None = False,
 ) -> ModelProto:
     """Adds a prefix to names of elements in a graph: nodes, edges, inputs, outputs,
     initializers, sparse initializer, value infos, and local functions.
@@ -604,7 +620,7 @@ def add_prefix(
 def expand_out_dim_graph(
     graph: GraphProto,
     dim_idx: int,
-    inplace: Optional[bool] = False,
+    inplace: bool | None = False,
 ) -> GraphProto:
     """Inserts an extra dimension with extent 1 to each output in the graph.
 
@@ -684,7 +700,7 @@ def expand_out_dim_graph(
 def expand_out_dim(
     model: ModelProto,
     dim_idx: int,
-    inplace: Optional[bool] = False,
+    inplace: bool | None = False,
 ) -> ModelProto:
     """Inserts an extra dimension with extent 1 to each output in the graph.
 

onnx/cpp2py_export.cc

@@ -20,6 +20,10 @@
 #include "onnx/shape_inference/implementation.h"
 #include "onnx/version_converter/convert.h"
 
+#if (PYBIND11_VERSION_MAJOR != 2 || PYBIND11_VERSION_MINOR < 12)
+#pragma error "Pybind11 must be >= 2.12 to be compatible with numpy 2.0."
+#endif
+
 namespace ONNX_NAMESPACE {
 namespace py = pybind11;
 using namespace pybind11::literals;

onnx/defs/__init__.py

@@ -1,6 +1,7 @@
 # Copyright (c) ONNX Project Contributors
 #
 # SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
 
 __all__ = [
     "C",
@@ -19,7 +20,6 @@ __all__ = [
     "SchemaError",
 ]
 
-from typing import List
 
 import onnx.onnx_cpp2py_export.defs as C  # noqa: N812
 from onnx import AttributeProto, FunctionProto
@@ -116,7 +116,7 @@ def _op_schema_attribute_repr(self) -> str:
 OpSchema.Attribute.__repr__ = _op_schema_attribute_repr  # type: ignore
 
 
-def get_function_ops() -> List[OpSchema]:
+def get_function_ops() -> list[OpSchema]:
     """Return operators defined as functions."""
     schemas = C.get_all_schemas()
     return [schema for schema in schemas if schema.has_function or schema.has_context_dependent_function]  # type: ignore

onnx/defs/data_type_utils.cc

@@ -139,7 +139,6 @@ std::string DataTypeUtils::ToString(const TypeProto& type_proto, const std::stri
     }
 #ifdef ONNX_ML
     case TypeProto::ValueCase::kOpaqueType: {
-      static const std::string empty;
       std::string result;
       const auto& op_type = type_proto.opaque_type();
       result.append(left).append("opaque(");

onnx/defs/gen_doc.py

@@ -3,10 +3,11 @@
 # Copyright (c) ONNX Project Contributors
 
 # SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
 
 import os
 from collections import defaultdict
-from typing import Any, Dict, List, NamedTuple, Sequence, Set, Tuple
+from typing import Any, NamedTuple, Sequence
 
 import numpy as np
 
@@ -75,7 +76,7 @@ def display_version_link(name: str, version: int, changelog: str) -> str:
 
 
 def generate_formal_parameter_tags(formal_parameter: OpSchema.FormalParameter) -> str:
-    tags: List[str] = []
+    tags: list[str] = []
     if OpSchema.FormalParameterOption.Optional == formal_parameter.option:
         tags = ["optional"]
     elif OpSchema.FormalParameterOption.Variadic == formal_parameter.option:
@@ -256,7 +257,7 @@ def main(args: Args) -> None:
         )
 
         # domain -> version -> [schema]
-        dv_index: Dict[str, Dict[int, List[OpSchema]]] = defaultdict(
+        dv_index: dict[str, dict[int, list[OpSchema]]] = defaultdict(
             lambda: defaultdict(list)
         )
         for schema in defs.get_all_schemas_with_history():
@@ -300,7 +301,7 @@ def main(args: Args) -> None:
         )
 
         # domain -> support level -> name -> [schema]
-        index: Dict[str, Dict[int, Dict[str, List[OpSchema]]]] = defaultdict(
+        index: dict[str, dict[int, dict[str, list[OpSchema]]]] = defaultdict(
             lambda: defaultdict(lambda: defaultdict(list))
         )
         for schema in defs.get_all_schemas_with_history():
@@ -310,10 +311,10 @@ def main(args: Args) -> None:
 
         # Preprocess the Operator Schemas
         # [(domain, [(support_level, [(schema name, current schema, all versions schemas)])])]
-        operator_schemas: List[
-            Tuple[str, List[Tuple[int, List[Tuple[str, OpSchema, List[OpSchema]]]]]]
+        operator_schemas: list[
+            tuple[str, list[tuple[int, list[tuple[str, OpSchema, list[OpSchema]]]]]]
         ] = []
-        existing_ops: Set[str] = set()
+        existing_ops: set[str] = set()
         for domain, _supportmap in sorted(index.items()):
             if not should_render_domain(domain, args.output):
                 continue
@@ -357,7 +358,7 @@ def main(args: Args) -> None:
             if function_ops:
                 fout.write("|**Function**|**Since version**|**Function version**|\n")
                 for n, schema, versions, function_versions in function_ops:
-                    s = '|{}<a href="#{}">{}</a>|{}|{}|\n'.format(
+                    s = '|{}<a href="#{}">{}</a>|{}|{}|\n'.format(  # noqa: UP032
                         support_level_str(schema.support_level),
                         format_name_with_domain(domain, n),
                         format_name_with_domain(domain, n),

onnx/defs/gen_shape_inference_information.py

@@ -1,6 +1,7 @@
 # Copyright (c) ONNX Project Contributors
 #
 # SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
 
 from onnx import defs