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

onnx/test/symbolic_shape_test.py

@@ -1,9 +1,9 @@
 # Copyright (c) ONNX Project Contributors
 
 # SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
 
 import unittest
-from typing import List, Optional
 
 import onnx.shape_inference
 from onnx import ModelProto, TensorProto, TensorShapeProto, ValueInfoProto, helper
@@ -12,7 +12,7 @@ from onnx.helper import make_model, make_tensor_value_info
 
 class TestSymbolicShape(unittest.TestCase):
     def _assert_valueinfo_shape(
-        self, onnx_model: ModelProto, value_infos: List[ValueInfoProto]
+        self, onnx_model: ModelProto, value_infos: list[ValueInfoProto]
     ) -> None:
         """Assert onnx_model.value_info should be the same as expected value_infos
         Instead of exact symbol, use -1 to represent symbolic shape in expected value_infos
@@ -48,7 +48,7 @@ class TestSymbolicShape(unittest.TestCase):
 
     def _get_shape_from_name(
         self, onnx_model: ModelProto, name: str
-    ) -> Optional[TensorShapeProto]:
+    ) -> TensorShapeProto | None:
         """Get shape from tensor_type or sparse_tensor_type according to given name"""
         inputs = list(onnx_model.graph.input)
         outputs = list(onnx_model.graph.output)

onnx/test/test_backend_reference.py

@@ -1,6 +1,7 @@
 # Copyright (c) ONNX Project Contributors
 
 # SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
 
 import os
 import platform
@@ -26,7 +27,7 @@ class ReferenceEvaluatorBackendRep(onnx.backend.base.BackendRep):
     def __init__(self, session):
         self._session = session
 
-    def run(self, inputs, **kwargs):
+    def run(self, inputs, **kwargs):  # noqa: ARG002
         if isinstance(inputs, numpy.ndarray):
             inputs = [inputs]
         if isinstance(inputs, list):
@@ -54,7 +55,7 @@ class ReferenceEvaluatorBackendRep(onnx.backend.base.BackendRep):
 
 class ReferenceEvaluatorBackend(onnx.backend.base.Backend):
     @classmethod
-    def is_opset_supported(cls, model):
+    def is_opset_supported(cls, model):  # noqa: ARG003
         return True, ""
 
     @classmethod
@@ -89,7 +90,19 @@ class ReferenceEvaluatorBackend(onnx.backend.base.Backend):
         raise NotImplementedError("Unable to run the model node by node.")
 
 
-backend_test = onnx.backend.test.BackendTest(ReferenceEvaluatorBackend, __name__)
+dft_atol = 1e-3 if sys.platform != "linux" else 1e-6
+backend_test = onnx.backend.test.BackendTest(
+    ReferenceEvaluatorBackend,
+    __name__,
+    test_kwargs={
+        "test_dft": {"atol": dft_atol},
+        "test_dft_axis": {"atol": dft_atol},
+        "test_dft_axis_opset19": {"atol": dft_atol},
+        "test_dft_inverse": {"atol": dft_atol},
+        "test_dft_inverse_opset19": {"atol": dft_atol},
+        "test_dft_opset19": {"atol": dft_atol},
+    },
+)
 
 if os.getenv("APPVEYOR"):
     backend_test.exclude("(test_vgg19|test_zfnet)")
@@ -128,10 +141,13 @@ backend_test.exclude(
     "|test_cast_no_saturate_FLOAT16_to_FLOAT8"
     "|test_cast_BFLOAT16_to_FLOAT"
     "|test_castlike_BFLOAT16_to_FLOAT"
+    "|test_cast_FLOAT_to_FLOAT4"
+    "|test_cast_FLOAT16_to_FLOAT4"
     "|test_quantizelinear_e4m3"
     "|test_quantizelinear_e5m2"
     "|test_quantizelinear_uint4"
     "|test_quantizelinear_int4"
+    "|test_quantizelinear_float4e2m1"
     ")"
 )
 
@@ -187,6 +203,16 @@ if sys.platform == "win32":
     backend_test.exclude("test_regex_full_match_empty_cpu")
     backend_test.exclude("test_image_decoder_decode_")
 
+if sys.version_info >= (3, 13):
+    # TODO(https://github.com/google/re2/issues/516): Remove the skips
+    backend_test.exclude("test_regex_full_match_basic_cpu")
+    backend_test.exclude("test_regex_full_match_email_domain_cpu")
+    backend_test.exclude("test_regex_full_match_empty_cpu")
+
+if sys.version_info < (3, 10):
+    #  AttributeError: module 'numpy.typing' has no attribute 'NDArray'
+    backend_test.exclude("test_image_decoder_decode_")
+
 if sys.platform == "darwin":
     # FIXME: https://github.com/onnx/onnx/issues/5792
     backend_test.exclude("test_qlinearmatmul_3D_int8_float16_cpu")
@@ -204,6 +230,10 @@ if version_utils.numpy_older_than("1.21.5"):
     backend_test.exclude("test_dft_axis_opset19")
     backend_test.exclude("test_dft_inverse_opset19")
 
+if version_utils.pillow_older_than("10.0"):
+    backend_test.exclude("test_image_decoder_decode_webp_rgb")
+    backend_test.exclude("test_image_decoder_decode_jpeg2k_rgb")
+
 # import all test cases at global scope to make them visible to python.unittest
 globals().update(backend_test.test_cases)
 

onnx/test/test_backend_test.py

@@ -1,14 +1,13 @@
 # Copyright (c) ONNX Project Contributors
 
 # SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
 
 import itertools
 import os
 import platform
 import unittest
-from typing import Any, Optional, Sequence, Tuple
-
-import numpy
+from typing import TYPE_CHECKING, Any
 
 import onnx.backend.base
 import onnx.backend.test
@@ -18,6 +17,11 @@ from onnx import ModelProto, NodeProto, TensorProto
 from onnx.backend.base import Device, DeviceType
 from onnx.backend.test.runner import BackendIsNotSupposedToImplementIt
 
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+
+    import numpy
+
 # The following just executes the fake backend through the backend test
 # infrastructure. Since we don't have full reference implementation of all ops
 # in ONNX repo, it's impossible to produce the proper results. However, we can
@@ -34,7 +38,7 @@ class DummyBackend(onnx.backend.base.Backend):
     @classmethod
     def prepare(
         cls, model: ModelProto, device: str = "CPU", **kwargs: Any
-    ) -> Optional[onnx.backend.base.BackendRep]:
+    ) -> onnx.backend.base.BackendRep | None:
         super().prepare(model, device, **kwargs)
 
         onnx.checker.check_model(model)
@@ -69,9 +73,9 @@ class DummyBackend(onnx.backend.base.Backend):
         node: NodeProto,
         inputs: Any,
         device: str = "CPU",
-        outputs_info: Optional[Sequence[Tuple[numpy.dtype, Tuple[int, ...]]]] = None,
-        **kwargs: Any,
-    ) -> Optional[Tuple[Any, ...]]:
+        outputs_info: Sequence[tuple[numpy.dtype, tuple[int, ...]]] | None = None,
+        **kwargs: Any,  # noqa: ARG003
+    ) -> tuple[Any, ...] | None:
         super().run_node(node, inputs, device=device, outputs_info=outputs_info)
         raise BackendIsNotSupposedToImplementIt(
             "This is the dummy backend test that doesn't verify the results but does run the checker"
@@ -80,9 +84,7 @@ class DummyBackend(onnx.backend.base.Backend):
     @classmethod
     def supports_device(cls, device: str) -> bool:
         d = Device(device)
-        if d.type == DeviceType.CPU:
-            return True
-        return False
+        return d.type == DeviceType.CPU  # type: ignore[no-any-return]
 
 
 test_coverage_safelist = {

onnx/test/test_external_data.py

@@ -9,13 +9,21 @@ import pathlib
 import tempfile
 import unittest
 import uuid
-from typing import Any
+from typing import TYPE_CHECKING, Any
 
 import numpy as np
 import parameterized
 
 import onnx
-from onnx import ModelProto, TensorProto, checker, helper, shape_inference
+from onnx import (
+    ModelProto,
+    NodeProto,
+    TensorProto,
+    checker,
+    helper,
+    parser,
+    shape_inference,
+)
 from onnx.external_data_helper import (
     convert_model_from_external_data,
     convert_model_to_external_data,
@@ -25,6 +33,9 @@ from onnx.external_data_helper import (
 )
 from onnx.numpy_helper import from_array, to_array
 
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+
 
 class TestLoadExternalDataBase(unittest.TestCase):
     """Base class for testing external data related behaviors.
@@ -67,13 +78,16 @@ class TestLoadExternalDataBase(unittest.TestCase):
             inputs=[],
             outputs=["values"],
             value=self.create_external_data_tensor(
-                self.attribute_value, "attribute_value"  # type: ignore[arg-type]
+                self.attribute_value,  # type: ignore[arg-type]
+                "attribute_value",
             ),
         )
 
         initializers = [
             self.create_external_data_tensor(
-                self.initializer_value, "input_value", location  # type: ignore[arg-type]
+                self.initializer_value,  # type: ignore[arg-type]
+                "input_value",
+                location,
             )
         ]
         inputs = [
@@ -794,5 +808,86 @@ class TestExternalDataToArrayWithPath(TestExternalDataToArray):
         return pathlib.Path(self._model_file_path)
 
 
+class TestFunctionsAndSubGraphs(unittest.TestCase):
+    def setUp(self) -> None:
+        self._temp_dir_obj = tempfile.TemporaryDirectory()
+        temp_dir = self._temp_dir_obj.name
+        self._model_file_path: str = os.path.join(temp_dir, "model.onnx")
+        array = np.arange(4096).astype(np.float32)
+        self._tensor = from_array(array, "tensor")
+
+    def tearDown(self) -> None:
+        self._temp_dir_obj.cleanup()
+
+    def _check_is_internal(self, tensor: TensorProto) -> None:
+        self.assertEqual(tensor.data_location, TensorProto.DEFAULT)
+
+    def _check_is_external(self, tensor: TensorProto) -> None:
+        self.assertEqual(tensor.data_location, TensorProto.EXTERNAL)
+
+    def _check(self, model: ModelProto, nodes: Sequence[NodeProto]) -> None:
+        """Check that the tensors in the model are externalized.
+
+        The tensors in the specified sequence of Constant nodes are set to self._tensor,
+        an internal tensor. The model is then converted to external data format.
+        The tensors are then checked to ensure that they are externalized.
+
+        Arguments:
+            model: The model to check.
+            nodes: A sequence of Constant nodes.
+
+        """
+        for node in nodes:
+            self.assertEqual(node.op_type, "Constant")
+            tensor = node.attribute[0].t
+            tensor.CopyFrom(self._tensor)
+            self._check_is_internal(tensor)
+
+        convert_model_to_external_data(model, size_threshold=0, convert_attribute=True)
+
+        for node in nodes:
+            tensor = node.attribute[0].t
+            self._check_is_external(tensor)
+
+    def test_function(self) -> None:
+        model_text = """
+           <ir_version: 7,  opset_import: ["": 15, "local": 1]>
+           agraph (float[N] X) => (float[N] Y)
+            {
+              Y = local.add(X)
+            }
+
+            <opset_import: ["" : 15],  domain: "local">
+            add (float[N] X) => (float[N] Y) {
+              C = Constant <value = float[1] {1.0}> ()
+              Y = Add (X, C)
+           }
+        """
+        model = parser.parse_model(model_text)
+        self._check(model, [model.functions[0].node[0]])
+
+    def test_subgraph(self) -> None:
+        model_text = """
+           <ir_version: 7,  opset_import: ["": 15, "local": 1]>
+           agraph (bool flag, float[N] X) => (float[N] Y)
+            {
+              Y = if (flag) <
+                then_branch = g1 () => (float[N] Y_then) {
+                    B = Constant <value = float[1] {0.0}> ()
+                    Y_then = Add (X, C)
+                },
+                else_branch = g2 () => (float[N] Y_else) {
+                    C = Constant <value = float[1] {1.0}> ()
+                    Y_else = Add (X, C)
+                }
+              >
+            }
+        """
+        model = parser.parse_model(model_text)
+        if_node = model.graph.node[0]
+        constant_nodes = [attr.g.node[0] for attr in if_node.attribute]
+        self._check(model, constant_nodes)
+
+
 if __name__ == "__main__":
     unittest.main()

onnx/test/tools_test.py

@@ -1,6 +1,7 @@
 # Copyright (c) ONNX Project Contributors
 
 # SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
 
 import unittest
 
@@ -74,14 +75,14 @@ class TestToolsFunctions(unittest.TestCase):
 
         x = np.array([1, 2, 4, 5, 5, 4]).astype(np.float32).reshape((3, 2))
         oinf1 = ReferenceEvaluator(model_def)
-        y1 = oinf1.run(None, {"X": x})[0]
+        y1 = oinf1.run(None, {"X": x})[0]  # type: ignore[index]
         repl = replace_initializer_by_constant_of_shape(model_def)
         node_types = {n.op_type for n in repl.graph.node}
         self.assertIn("ConstantOfShape", node_types)
         oinf2 = ReferenceEvaluator(repl)
         y1[:, :] = 3.5
         y1[0, :] = 0.5
-        y2 = oinf2.run(None, {"X": x})[0]
+        y2 = oinf2.run(None, {"X": x})[0]  # type: ignore[index]
         assert_allclose(y1, y2)
 
     def test_replace_constant(self):
@@ -101,14 +102,14 @@ class TestToolsFunctions(unittest.TestCase):
 
         x = np.array([1, 2, 4, 5, 5, 4]).astype(np.float32).reshape((3, 2))
         oinf1 = ReferenceEvaluator(model_def)
-        y1 = oinf1.run(None, {"X": x})[0]
+        y1 = oinf1.run(None, {"X": x})[0]  # type: ignore[index]
         repl = replace_initializer_by_constant_of_shape(model_def)
         node_types = {n.op_type for n in repl.graph.node}
         self.assertIn("ConstantOfShape", node_types)
         oinf2 = ReferenceEvaluator(repl)
         y1[:, :] = 3.5
         y1[0, :] = 0.5
-        y2 = oinf2.run(None, {"X": x})[0]
+        y2 = oinf2.run(None, {"X": x})[0]  # type: ignore[index]
         assert_allclose(y1, y2)
 
     def test_replace_range(self):
@@ -128,13 +129,13 @@ class TestToolsFunctions(unittest.TestCase):
 
         x = np.array([1, 2, 4, 5, 5, 4]).astype(np.float32).reshape((3, 2))
         oinf1 = ReferenceEvaluator(model_def)
-        y1 = oinf1.run(None, {"X": x})[0]
+        y1 = oinf1.run(None, {"X": x})[0]  # type: ignore[index]
         repl = replace_initializer_by_constant_of_shape(model_def, use_range=True)
         node_types = {n.op_type for n in repl.graph.node}
         self.assertIn("Range", node_types)
         self.assertNotIn("ConstantOfShape", node_types)
         oinf2 = ReferenceEvaluator(repl)
-        y2 = oinf2.run(None, {"X": x})[0]
+        y2 = oinf2.run(None, {"X": x})[0]  # type: ignore[index]
         assert_allclose(y1.shape, y2.shape)
 
     def test_replace_constant_function(self):
@@ -171,14 +172,14 @@ class TestToolsFunctions(unittest.TestCase):
 
         x = np.array([1, 2, 4, 5, 5, 4]).astype(np.float32).reshape((3, 2))
         oinf1 = ReferenceEvaluator(model_def)
-        y1 = oinf1.run(None, {"X": x})[0]
+        y1 = oinf1.run(None, {"X": x})[0]  # type: ignore[index]
         repl = replace_initializer_by_constant_of_shape(model_def)
         node_types = {n.op_type for n in repl.functions[0].node}
         self.assertIn("ConstantOfShape", node_types)
         oinf2 = ReferenceEvaluator(repl)
         y1[:, :] = 3.5
         y1[0, :] = 0.5
-        y2 = oinf2.run(None, {"X": x})[0]
+        y2 = oinf2.run(None, {"X": x})[0]  # type: ignore[index]
         assert_allclose(y1, y2)
 
     def test_replace_range_function(self):
@@ -215,13 +216,13 @@ class TestToolsFunctions(unittest.TestCase):
 
         x = np.array([1, 2, 4, 5, 5, 4]).astype(np.float32).reshape((3, 2))
         oinf1 = ReferenceEvaluator(model_def)
-        y1 = oinf1.run(None, {"X": x})[0]
+        y1 = oinf1.run(None, {"X": x})[0]  # type: ignore[index]
         repl = replace_initializer_by_constant_of_shape(model_def, use_range=True)
         node_types = {n.op_type for n in repl.functions[0].node}
         self.assertIn("Range", node_types)
         self.assertNotIn("ConstantOfShape", node_types)
         oinf2 = ReferenceEvaluator(repl)
-        y2 = oinf2.run(None, {"X": x})[0]
+        y2 = oinf2.run(None, {"X": x})[0]  # type: ignore[index]
         assert_allclose(y1.shape, y2.shape)
 
     def test_replace_constant_graph(self):
@@ -264,11 +265,11 @@ class TestToolsFunctions(unittest.TestCase):
 
         x = np.ones((3, 2), dtype=np.float32)
         oinf1 = ReferenceEvaluator(onnx_model)
-        y1 = oinf1.run(None, {"X": x})[0]
+        y1 = oinf1.run(None, {"X": x})[0]  # type: ignore[index]
         repl = replace_initializer_by_constant_of_shape(onnx_model)
         self.assertIn("ConstantOfShape", str(repl))
         oinf2 = ReferenceEvaluator(repl)
-        y2 = oinf2.run(None, {"X": x})[0]
+        y2 = oinf2.run(None, {"X": x})[0]  # type: ignore[index]
         y1 = y1.copy()
         y1[:] = 0.5
         assert_allclose(y1, y2)
@@ -313,12 +314,12 @@ class TestToolsFunctions(unittest.TestCase):
 
         x = np.ones((3, 2), dtype=np.float32)
         oinf1 = ReferenceEvaluator(onnx_model)
-        y1 = oinf1.run(None, {"X": x})[0]
+        y1 = oinf1.run(None, {"X": x})[0]  # type: ignore[index]
         repl = replace_initializer_by_constant_of_shape(onnx_model, use_range=True)
         self.assertNotIn("ConstantOfShape", str(repl))
         self.assertIn("Range", str(repl))
         oinf2 = ReferenceEvaluator(repl)
-        y2 = oinf2.run(None, {"X": x})[0]
+        y2 = oinf2.run(None, {"X": x})[0]  # type: ignore[index]
         assert_allclose(y1.shape, y2.shape)
 
 

onnx/test/training_tool_test.py

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

onnx/test/utils_test.py

@@ -1,6 +1,7 @@
 # Copyright (c) ONNX Project Contributors
 
 # SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
 
 import os
 import shutil
@@ -13,7 +14,7 @@ from onnx import TensorProto, helper
 
 class TestUtilityFunctions(unittest.TestCase):
     def test_extract_model(self) -> None:
-        def create_tensor(name):  # type: ignore
+        def create_tensor(name):
             return helper.make_tensor_value_info(name, TensorProto.FLOAT, [1, 2])
 
         A0 = create_tensor("A0")

onnx/test/version_converter/automatic_conversion_test_base.py

@@ -5,11 +5,14 @@ from __future__ import annotations
 
 import string
 import unittest
-from typing import Any, List, Sequence, cast
+from typing import TYPE_CHECKING, Any, cast
 
 import onnx
 from onnx import TensorProto, ValueInfoProto, helper, shape_inference, version_converter
 
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+
 LATEST_OPSET = onnx.defs.onnx_opset_version()
 
 
@@ -90,7 +93,7 @@ class TestAutomaticConversion(unittest.TestCase):
         # turn empty strings into [0] to ease type analysis, even though those entries
         # will be ignored
         input_shapes_cast = cast(
-            List[List[int]],
+            list[list[int]],
             [[0] if isinstance(shape, str) else shape for shape in input_shapes],
         )
         inputs: list[ValueInfoProto] = []
@@ -118,7 +121,7 @@ class TestAutomaticConversion(unittest.TestCase):
             0 if id not in optional_outputs else 1 for id in range(n_outputs)
         ]
         output_shapes_cast = cast(
-            List[List[int]],
+            list[list[int]],
             [[0] if isinstance(shape, str) else shape for shape in output_shapes],
         )
         outputs: list[ValueInfoProto] = []

onnx/test/version_converter/automatic_downgrade_test.py

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