onnx 1.16.2__cp311-cp311-win32.whl → 1.18.0__cp311-cp311-win32.whl

onnx/backend/test/loader/__init__.py

@@ -1,10 +1,10 @@
 # Copyright (c) ONNX Project Contributors
 
 # SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
 
 import json
 import os
-from typing import List, Optional
 
 from onnx.backend.test.case.test_case import TestCase
 
@@ -15,8 +15,8 @@ DATA_DIR = os.path.join(
 
 def load_model_tests(
     data_dir: str = DATA_DIR,
-    kind: Optional[str] = None,
-) -> List[TestCase]:
+    kind: str | None = None,
+) -> list[TestCase]:
     """Load model test cases from on-disk data files."""
     supported_kinds = os.listdir(data_dir)
     if kind not in supported_kinds:
@@ -35,14 +35,19 @@ def load_model_tests(
         if os.path.exists(os.path.join(case_dir, "model.onnx")):
             url = None
             model_name = test_name[len("test_")]
-            model_dir: Optional[str] = case_dir
+            model_dir: str | None = case_dir
+            if os.path.exists(os.path.join(case_dir, "data.json")):
+                with open(os.path.join(case_dir, "data.json")) as f:
+                    data = json.load(f)
+                    rtol = data.get("rtol", rtol)
+                    atol = data.get("atol", atol)
         else:
             with open(os.path.join(case_dir, "data.json")) as f:
                 data = json.load(f)
                 url = data["url"]
                 model_name = data["model_name"]
-                rtol = data.get("rtol", 1e-3)
-                atol = data.get("atol", 1e-7)
+                rtol = data.get("rtol", rtol)
+                atol = data.get("atol", atol)
                 model_dir = None
         testcases.append(
             TestCase(

onnx/backend/test/report/__init__.py

@@ -1,16 +1,21 @@
 # Copyright (c) ONNX Project Contributors
 
 # SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
 
-from typing import Any, Dict, Sequence
+from typing import TYPE_CHECKING, Any
 
-import _pytest
 import pytest
 
 from onnx.backend.test.report.coverage import Coverage
 
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+
+    import _pytest
+
 _coverage = Coverage()
-_marks: Dict[str, Sequence[Any]] = {}
+_marks: dict[str, Sequence[Any]] = {}
 
 
 def _add_mark(mark: Any, bucket: str) -> None:
@@ -35,9 +40,10 @@ def pytest_runtest_logreport(report: Any) -> None:
         _add_mark(mark, "passed")
 
 
-@pytest.hookimpl(trylast=True)  # type: ignore
+@pytest.hookimpl(trylast=True)
 def pytest_terminal_summary(
-    terminalreporter: _pytest.terminal.TerminalReporter, exitstatus: int
+    terminalreporter: _pytest.terminal.TerminalReporter,
+    exitstatus: int,  # noqa: ARG001
 ) -> None:
     for mark in _marks.values():
         _add_mark(mark, "loaded")

onnx/backend/test/report/base.py

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

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"}:
@@ -152,15 +153,11 @@ class Coverage:
                 if schema.support_level == defs.OpSchema.SupportType.EXPERIMENTAL:
                     experimental.append(schema.name)
         all_ops.sort()
-        nodes_path = os.path.join(
-            str(os.environ.get("CSVDIR")), "nodes.csv"  # type: ignore
-        )  # type: ignore
-        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] = []
+        nodes_path = os.path.join(str(os.environ.get("CSVDIR")), "nodes.csv")
+        models_path = os.path.join(str(os.environ.get("CSVDIR")), "models.csv")
+        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 +198,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"]
@@ -218,7 +215,7 @@ class Coverage:
             # Consider both buckets
             num_models = 0
             for bucket in self.models:
-                for model in self.models[bucket]:  # type: ignore
+                for model in self.models[bucket]:
                     # Both analyze and run the model on the backend
                     num_covered = 0
                     for node in self.models[bucket][model].node_coverages:
@@ -246,18 +243,18 @@ 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
+            for model in existing_models:
                 existing_models[model]["Model"] = model
                 model_writer.writerow(existing_models[model])
             model_writer.writerow(summaries)
         with open(
-            os.path.join(str(os.environ.get("CSVDIR")), "metadata.csv"),  # type: ignore
+            os.path.join(str(os.environ.get("CSVDIR")), "metadata.csv"),
             "w",
-        ) as metadata_file:  # type: ignore
+        ) as metadata_file:
             metadata_writer = csv.writer(metadata_file)
             metadata_writer.writerow(
                 ["Latest Update", datetime.datetime.now().isoformat().replace("T", " ")]

onnx/backend/test/runner/__init__.py

@@ -14,7 +14,8 @@ import tempfile
 import time
 import unittest
 from collections import defaultdict
-from typing import Any, Callable, Iterable, Pattern, Sequence
+from re import Pattern
+from typing import TYPE_CHECKING, Any, Callable
 from urllib.request import urlretrieve
 
 import numpy as np
@@ -22,11 +23,15 @@ import numpy as np
 import onnx
 import onnx.reference
 from onnx import ONNX_ML, ModelProto, NodeProto, TypeProto, ValueInfoProto, numpy_helper
-from onnx.backend.base import Backend
-from onnx.backend.test.case.test_case import TestCase
 from onnx.backend.test.loader import load_model_tests
 from onnx.backend.test.runner.item import TestItem
 
+if TYPE_CHECKING:
+    from collections.abc import Iterable, Sequence
+
+    from onnx.backend.base import Backend
+    from onnx.backend.test.case.test_case import TestCase
+
 
 class BackendIsNotSupposedToImplementIt(unittest.SkipTest):
     pass
@@ -41,7 +46,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
@@ -196,7 +201,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})."
                     )
@@ -214,7 +219,12 @@ class Runner:
                         raise AssertionError(f"{ref_outputs[i]} != {outputs[i]}")
                     continue
                 np.testing.assert_equal(outputs[i].dtype, ref_outputs[i].dtype)
-                if ref_outputs[i].dtype == object:  # type: ignore[attr-defined]
+                np.testing.assert_array_equal(
+                    outputs[i].shape,
+                    ref_outputs[i].shape,
+                    err_msg=f"Output {i} has incorrect shape",
+                )
+                if ref_outputs[i].dtype == object:
                     np.testing.assert_array_equal(outputs[i], ref_outputs[i])
                 else:
                     np.testing.assert_allclose(
@@ -224,25 +234,23 @@ class Runner:
     @classmethod
     @retry_execute(3)
     def download_model(
-        cls, model_test: TestCase, model_dir: str, models_dir: str
+        cls,
+        model_test: TestCase,
+        models_dir: str,
     ) -> None:
-        # On Windows, NamedTemporaryFile can not be opened for a
-        # second time
-        download_file = tempfile.NamedTemporaryFile(delete=False)
-        try:
-            download_file.close()
-            assert model_test.url
-            print(
-                f"Start downloading model {model_test.model_name} from {model_test.url}"
-            )
-            urlretrieve(model_test.url, download_file.name)
-            print("Done")
-            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
-        finally:
-            os.remove(download_file.name)
+        with tempfile.TemporaryDirectory() as tmpdir:
+            try:
+                assert model_test.url
+                print(
+                    f"Start downloading model {model_test.model_name} from {model_test.url}"
+                )
+                filename = os.path.join(tmpdir, "file")
+                urlretrieve(model_test.url, filename)
+                print("Done")
+                onnx.utils._extract_model_safe(filename, models_dir)
+            except Exception as e:
+                print(f"Failed to prepare data for model {model_test.model_name}: {e}")
+                raise
 
     @classmethod
     def prepare_model_data(cls, model_test: TestCase) -> str:
@@ -263,9 +271,7 @@ class Runner:
                     break
             os.makedirs(model_dir)
 
-            cls.download_model(
-                model_test=model_test, model_dir=model_dir, models_dir=models_dir
-            )
+            cls.download_model(model_test=model_test, models_dir=models_dir)
         return model_dir
 
     def _add_test(
@@ -288,7 +294,7 @@ class Runner:
                     f'Duplicated test name "{device_test_name}" in category "{category}"'
                 )
 
-            @unittest.skipIf(  # type: ignore
+            @unittest.skipIf(
                 not self.backend.supports_device(device),
                 f"Backend doesn't support device {device}",
             )
@@ -339,7 +345,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/"
             ):
@@ -457,8 +463,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,
                     )
 
@@ -481,8 +487,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,11 +1,13 @@
 # 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 TYPE_CHECKING, Any, Callable
 
-from onnx import ModelProto, NodeProto
+if TYPE_CHECKING:
+    from onnx import ModelProto, NodeProto
 
 # A container that hosts the test function and the associated
 # test item (ModelProto)
@@ -14,4 +16,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,15 +3,19 @@
 # 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, TYPE_CHECKING, Any
 
 from onnx import AttributeProto, defs, load
 from onnx.backend.test.case import collect_snippets
 from onnx.backend.test.loader import load_model_tests
 from onnx.backend.test.runner import Runner
 
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+
 
 def is_ml(schemas: Sequence[defs.OpSchema]) -> bool:
     return any(s.domain == "ai.onnx.ml" for s in schemas)
@@ -98,7 +102,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 +159,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 +255,7 @@ def gen_model_test_coverage(
 
 
 def gen_overall_test_coverage(
-    schemas: Sequence[defs.OpSchema], f: IO[Any], ml: bool
+    f: IO[Any],
 ) -> None:
     f.write("# Overall Test Coverage\n")
     f.write("## To be filled.\n")
@@ -275,7 +279,7 @@ def main() -> None:
         gen_outlines(f, False)
         gen_node_test_coverage(schemas, f, False)
         gen_model_test_coverage(schemas, f, False)
-        gen_overall_test_coverage(schemas, f, False)
+        gen_overall_test_coverage(f)
 
     if has_ml:
         fname = os.path.join(docs_dir, "TestCoverage-ml.md")
@@ -284,7 +288,7 @@ def main() -> None:
             gen_outlines(f, True)
             gen_node_test_coverage(schemas, f, True)
             gen_model_test_coverage(schemas, f, True)
-            gen_overall_test_coverage(schemas, f, True)
+            gen_overall_test_coverage(f)
 
 
 if __name__ == "__main__":

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