onnx 1.18.0__cp310-cp310-win32.whl → 1.19.1rc1__cp310-cp310-win32.whl

onnx/test/symbolic_shape_test.py

@@ -56,9 +56,9 @@ class TestSymbolicShape(unittest.TestCase):
         for v in inputs + outputs + valueinfos:
             if v.name == name:
                 if v.type.HasField("tensor_type"):
-                    return v.type.tensor_type.shape  # type: ignore
+                    return v.type.tensor_type.shape
                 if v.type.HasField("sparse_tensor_type"):
-                    return v.type.sparse_tensor_type.shape  # type: ignore
+                    return v.type.sparse_tensor_type.shape
         return None
 
     def test_concat_enable_symbolic(self) -> None:

onnx/test/test_backend_reference.py

@@ -21,6 +21,7 @@ from onnx.backend.base import Device, DeviceType
 from onnx.reference import ReferenceEvaluator
 
 # The following just executes a backend based on ReferenceEvaluator through the backend test
+VERBOSE = int(os.environ.get("VERBOSE", "0"))
 
 
 class ReferenceEvaluatorBackendRep(onnx.backend.base.BackendRep):
@@ -61,11 +62,11 @@ class ReferenceEvaluatorBackend(onnx.backend.base.Backend):
     @classmethod
     def supports_device(cls, device: str) -> bool:
         d = Device(device)
-        return d.type == DeviceType.CPU  # type: ignore[no-any-return]
+        return d.type == DeviceType.CPU
 
     @classmethod
     def create_inference_session(cls, model):
-        return ReferenceEvaluator(model)
+        return ReferenceEvaluator(model, verbose=VERBOSE)
 
     @classmethod
     def prepare(
@@ -124,44 +125,6 @@ backend_test.exclude(
 # The following tests are about deprecated operators.
 backend_test.exclude("(test_scatter_with_axis|test_scatter_without)")
 
-# The following tests are using types not supported by numpy.
-# They could be if method to_array is extended to support custom
-# types the same as the reference implementation does
-# (see onnx.reference.op_run.to_array_extended).
-backend_test.exclude(
-    "(test_cast_FLOAT_to_FLOAT8"
-    "|test_cast_FLOAT16_to_FLOAT8"
-    "|test_castlike_FLOAT_to_FLOAT8"
-    "|test_castlike_FLOAT16_to_FLOAT8"
-    "|test_cast_FLOAT_to_UINT4"
-    "|test_cast_FLOAT16_to_UINT4"
-    "|test_cast_FLOAT_to_INT4"
-    "|test_cast_FLOAT16_to_INT4"
-    "|test_cast_no_saturate_FLOAT_to_FLOAT8"
-    "|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"
-    ")"
-)
-
-# The following tests are using types not supported by NumPy.
-# They could be if method to_array is extended to support custom
-# types the same as the reference implementation does
-# (see onnx.reference.op_run.to_array_extended).
-backend_test.exclude(
-    "(test_cast_FLOAT_to_BFLOAT16"
-    "|test_castlike_FLOAT_to_BFLOAT16"
-    "|test_castlike_FLOAT_to_BFLOAT16_expanded"
-    ")"
-)
-
 # The following tests are too slow with the reference implementation (Conv).
 backend_test.exclude(
     "(test_bvlc_alexnet"
@@ -196,19 +159,13 @@ backend_test.exclude("(test_eyelike_without_dtype)")
 # The following tests fail due to discrepancies (small but still higher than 1e-7).
 backend_test.exclude("test_adam_multiple")  # 1e-2
 
-# Currently google-re2/Pillow is not supported on Win32 and is required for the reference implementation of RegexFullMatch.
+# Currently Pillow is not supported on Win32 and is required for the reference implementation of RegexFullMatch.
 if sys.platform == "win32":
     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")
     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_")
@@ -218,22 +175,27 @@ if sys.platform == "darwin":
     backend_test.exclude("test_qlinearmatmul_3D_int8_float16_cpu")
     backend_test.exclude("test_qlinearmatmul_3D_int8_float32_cpu")
 
-# op_dft and op_stft requires numpy >= 1.21.5
-if version_utils.numpy_older_than("1.21.5"):
-    backend_test.exclude("test_stft")
-    backend_test.exclude("test_stft_with_window")
-    backend_test.exclude("test_stft_cpu")
-    backend_test.exclude("test_dft")
-    backend_test.exclude("test_dft_axis")
-    backend_test.exclude("test_dft_inverse")
-    backend_test.exclude("test_dft_opset19")
-    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")
 
+if version_utils.numpy_older_than("2.0"):
+    # assert_allclose does not support ml_dtypes types in numpy < 2.0
+    backend_test.exclude(r"test_cast.*(FLOAT8|BFLOAT16|FLOAT4|INT4)")
+    backend_test.exclude(r"test_quantizelinear_e4m3fn")
+    backend_test.exclude(r"test_quantizelinear_float4e2m1")
+
+# The documentation does not explicitly say that is_causal=1 and attn_mask is not None
+# is not allowed. The expansion (based on the function definition in ONNX)
+# assumes this case never happens and behaves likes is_causal=0 even if it is 1.
+# The reference implementation and the backend tests have a different behabiour in that case.
+backend_test.exclude(
+    "(test_attention_4d_with_past_and_present_qk_matmul_bias_4d_mask_causal_expanded"
+    "|test_attention_4d_with_past_and_present_qk_matmul_bias_3d_mask_causal_expanded"
+    "|test_attention_4d_attn_mask_4d_causal_expanded"
+    "|test_attention_4d_attn_mask_3d_causal_expanded)"
+)
+
 # 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

@@ -84,7 +84,7 @@ class DummyBackend(onnx.backend.base.Backend):
     @classmethod
     def supports_device(cls, device: str) -> bool:
         d = Device(device)
-        return d.type == DeviceType.CPU  # type: ignore[no-any-return]
+        return d.type == DeviceType.CPU
 
 
 test_coverage_safelist = {

onnx/test/test_external_data.py

@@ -78,14 +78,14 @@ class TestLoadExternalDataBase(unittest.TestCase):
             inputs=[],
             outputs=["values"],
             value=self.create_external_data_tensor(
-                self.attribute_value,  # type: ignore[arg-type]
+                self.attribute_value,
                 "attribute_value",
             ),
         )
 
         initializers = [
             self.create_external_data_tensor(
-                self.initializer_value,  # type: ignore[arg-type]
+                self.initializer_value,
                 "input_value",
                 location,
             )
@@ -299,8 +299,8 @@ class TestSaveAllTensorsAsExternalData(unittest.TestCase):
     def create_test_model_proto(self) -> ModelProto:
         tensors = self.create_data_tensors(
             [
-                (self.attribute_value, "attribute_value"),  # type: ignore[list-item]
-                (self.initializer_value, "input_value"),  # type: ignore[list-item]
+                (self.attribute_value, "attribute_value"),
+                (self.initializer_value, "input_value"),
             ]
         )
 

onnx/test/tools_test.py

@@ -75,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]  # type: ignore[index]
+        y1 = oinf1.run(None, {"X": x})[0]
         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]  # type: ignore[index]
+        y2 = oinf2.run(None, {"X": x})[0]
         assert_allclose(y1, y2)
 
     def test_replace_constant(self):
@@ -102,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]  # type: ignore[index]
+        y1 = oinf1.run(None, {"X": x})[0]
         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]  # type: ignore[index]
+        y2 = oinf2.run(None, {"X": x})[0]
         assert_allclose(y1, y2)
 
     def test_replace_range(self):
@@ -129,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]  # type: ignore[index]
+        y1 = oinf1.run(None, {"X": x})[0]
         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]  # type: ignore[index]
+        y2 = oinf2.run(None, {"X": x})[0]
         assert_allclose(y1.shape, y2.shape)
 
     def test_replace_constant_function(self):
@@ -172,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]  # type: ignore[index]
+        y1 = oinf1.run(None, {"X": x})[0]
         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]  # type: ignore[index]
+        y2 = oinf2.run(None, {"X": x})[0]
         assert_allclose(y1, y2)
 
     def test_replace_range_function(self):
@@ -216,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]  # type: ignore[index]
+        y1 = oinf1.run(None, {"X": x})[0]
         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]  # type: ignore[index]
+        y2 = oinf2.run(None, {"X": x})[0]
         assert_allclose(y1.shape, y2.shape)
 
     def test_replace_constant_graph(self):
@@ -265,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]  # type: ignore[index]
+        y1 = oinf1.run(None, {"X": x})[0]
         repl = replace_initializer_by_constant_of_shape(onnx_model)
         self.assertIn("ConstantOfShape", str(repl))
         oinf2 = ReferenceEvaluator(repl)
-        y2 = oinf2.run(None, {"X": x})[0]  # type: ignore[index]
+        y2 = oinf2.run(None, {"X": x})[0]
         y1 = y1.copy()
         y1[:] = 0.5
         assert_allclose(y1, y2)
@@ -314,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]  # type: ignore[index]
+        y1 = oinf1.run(None, {"X": x})[0]
         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]  # type: ignore[index]
+        y2 = oinf2.run(None, {"X": x})[0]
         assert_allclose(y1.shape, y2.shape)
 
 

onnx/test/version_converter/automatic_conversion_test_base.py

@@ -93,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] = []
@@ -121,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_upgrade_test.py

@@ -1473,6 +1473,9 @@ class TestAutomaticUpgrade(automatic_conversion_test_base.TestAutomaticConversio
             attrs={"consumed_inputs": [0]},
         )
 
+    def test_Swish(self) -> None:
+        self._test_op_upgrade("Swish", 24, attrs={"alpha": 0.2})
+
     def test_Tanh(self) -> None:
         self._test_op_upgrade("Tanh", 1, attrs={"consumed_inputs": [0]})
 
@@ -1914,6 +1917,22 @@ class TestAutomaticUpgrade(automatic_conversion_test_base.TestAutomaticConversio
             [TensorProto.BOOL],
         )
 
+    def test_TensorScatter(self) -> None:
+        self._test_op_upgrade(
+            "TensorScatter",
+            24,
+            [
+                [2, 3, 4, 5],
+                [2, 3, 2, 5],
+                [
+                    2,
+                ],
+            ],
+            [[2, 3, 4, 5]],
+            [TensorProto.FLOAT, TensorProto.FLOAT, TensorProto.INT64],
+            [TensorProto.FLOAT],
+        )
+
     def test_ops_tested(self) -> None:
         # NOTE: This test is order dependent and needs to run last in this class
         all_schemas = onnx.defs.get_all_schemas()

onnx/test/version_converter_test.py

@@ -4,7 +4,9 @@
 from __future__ import annotations
 
 import contextlib
+import os
 import struct
+import tempfile
 import unittest
 
 import numpy as np
@@ -2184,6 +2186,79 @@ class TestVersionConverter(unittest.TestCase):
         with context_manager:
             test(y_shape, scale_shape, axis, block_size)
 
+    def test_external_data_version_conversion(self) -> None:
+        with tempfile.TemporaryDirectory() as temp_dir:
+            # Create a model with external data
+            shape = (2, 3)
+            random_data = np.random.rand(*shape).astype(np.float32)
+
+            initializer_tensor = onnx.helper.make_tensor(
+                name="initializer_tensor",
+                data_type=onnx.TensorProto.FLOAT,
+                dims=list(shape),
+                vals=random_data.tobytes(),
+                raw=True,
+            )
+            initializer_scalar = onnx.helper.make_tensor(
+                name="initializer_scalar",
+                data_type=onnx.TensorProto.FLOAT,
+                dims=[],
+                vals=[1.0],
+            )
+
+            add_node = onnx.helper.make_node(
+                "Add",
+                inputs=["initializer_tensor", "initializer_scalar"],
+                outputs=["sum_output"],
+            )
+
+            graph_def = onnx.helper.make_graph(
+                name="SimpleAddition",
+                nodes=[add_node],
+                inputs=[],
+                outputs=[
+                    onnx.helper.make_tensor_value_info(
+                        "sum_output", onnx.TensorProto.FLOAT, list(shape)
+                    )
+                ],
+                initializer=[initializer_tensor, initializer_scalar],
+            )
+
+            # Save model to file with external data
+            model_filename = os.path.join(temp_dir, "test_simple_add.onnx")
+            data_filename = "test_simple_add.onnx.data"  # Use relative path
+            opset_imports = [onnx.helper.make_opsetid("", 20)]
+            model_def = onnx.helper.make_model(graph_def, opset_imports=opset_imports)
+            model_def.ir_version = 10
+            onnx.save_model(
+                model_def,
+                model_filename,
+                save_as_external_data=True,
+                all_tensors_to_one_file=True,
+                location=data_filename,
+                size_threshold=0,
+                convert_attribute=False,
+            )
+
+            # Load the model and verify external data
+            converted_model = onnx.version_converter.convert_version(
+                onnx.load(model_filename, load_external_data=False), 21
+            )
+            self.assertEqual(len(converted_model.graph.initializer), 2)
+
+            # Verify the large tensor has external data
+            tensors = {init.name: init for init in converted_model.graph.initializer}
+            self.assertIn("initializer_tensor", tensors)
+            large_tensor = tensors["initializer_tensor"]
+            self.assertEqual(large_tensor.data_location, TensorProto.EXTERNAL)
+            self.assertEqual(len(large_tensor.external_data), 3)
+
+            # Convert external_data to dictionary for order-independent checking
+            external_data_dict = {ed.key: ed.value for ed in large_tensor.external_data}
+            self.assertEqual(external_data_dict["location"], data_filename)
+            self.assertEqual(external_data_dict["offset"], "0")
+            self.assertEqual(external_data_dict["length"], "24")
+
 
 if __name__ == "__main__":
     unittest.main()

onnx/test/version_utils.py

@@ -8,13 +8,13 @@ from packaging.version import parse as version
 
 def numpy_older_than(ver: str) -> bool:
     """Returns True if the numpy version is older than the given version."""
-    import numpy  # pylint: disable=import-outside-toplevel
+    import numpy  # noqa: PLC0415
 
     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
+    import PIL  # noqa: PLC0415
 
     return version(PIL.__version__) < version(ver)

onnx/utils.py

@@ -11,19 +11,31 @@ from typing import TYPE_CHECKING
 import onnx.checker
 import onnx.helper
 import onnx.shape_inference
-from onnx import FunctionProto, ModelProto, NodeProto, TensorProto, ValueInfoProto
 
 if TYPE_CHECKING:
-    from google.protobuf.internal.containers import RepeatedCompositeFieldContainer
+    from onnx.onnx_pb import (
+        FunctionProto,
+        ModelProto,
+        NodeProto,
+        TensorProto,
+        ValueInfoProto,
+    )
 
 
 class Extractor:
     def __init__(self, model: ModelProto) -> None:
         self.model = model
         self.graph = self.model.graph
-        self.wmap = self._build_name2obj_dict(self.graph.initializer)
-        self.vimap = self._build_name2obj_dict(self.graph.value_info)
-        self.outmap = self._build_output_dict(self.graph)
+        self.initializers: dict[str, TensorProto] = self._build_name2obj_dict(
+            self.graph.initializer
+        )
+        self.value_infos: dict[str, ValueInfoProto] = self._build_name2obj_dict(
+            self.graph.value_info
+        )
+        # Add input and output values (not included in the value_info for intermediate values)
+        self.value_infos.update(self._build_name2obj_dict(self.graph.input))
+        self.value_infos.update(self._build_name2obj_dict(self.graph.output))
+        self.outmap: dict[str, int] = self._build_output_dict(self.graph)
 
     @staticmethod
     def _build_name2obj_dict(objs) -> dict:
@@ -40,25 +52,16 @@ class Extractor:
                 output_to_index[output_name] = index
         return output_to_index
 
-    def _collect_new_io_core(
-        self,
-        original_io: RepeatedCompositeFieldContainer[ValueInfoProto],
-        io_names_to_extract: list[str],
-    ) -> list[ValueInfoProto]:
-        original_io_map = self._build_name2obj_dict(original_io)
-        new_io_tensors = []
-        for io_name_to_extract in io_names_to_extract:
-            if io_name_to_extract in original_io_map:
-                new_io_tensors.append(original_io_map[io_name_to_extract])
-            else:
-                new_io_tensors.append(self.vimap[io_name_to_extract])
-        return new_io_tensors  # same order as io_names_to_extract
-
-    def _collect_new_inputs(self, names: list[str]) -> list[ValueInfoProto]:
-        return self._collect_new_io_core(self.graph.input, names)
-
-    def _collect_new_outputs(self, names: list[str]) -> list[ValueInfoProto]:
-        return self._collect_new_io_core(self.graph.output, names)
+    def _collect_new_io(self, io_names_to_extract: list[str]) -> list[ValueInfoProto]:
+        # Validate that all names exist in self.value_infos
+        missing_names = [
+            name for name in io_names_to_extract if name not in self.value_infos
+        ]
+        if missing_names:
+            raise ValueError(
+                f"The following names were not found in value_infos: {', '.join(missing_names)}"
+            )
+        return [self.value_infos[name] for name in io_names_to_extract]
 
     def _dfs_search_reachable_nodes(
         self,
@@ -134,8 +137,12 @@ class Extractor:
         for node in nodes:
             all_tensors_names.update(node.input)
             all_tensors_names.update(node.output)
-        initializer = [self.wmap[t] for t in self.wmap if t in all_tensors_names]
-        value_info = [self.vimap[t] for t in self.vimap if t in all_tensors_names]
+        initializer = [
+            self.initializers[t] for t in self.initializers if t in all_tensors_names
+        ]
+        value_info = [
+            self.value_infos[t] for t in self.value_infos if t in all_tensors_names
+        ]
         len_sparse_initializer = len(self.graph.sparse_initializer)
         if len_sparse_initializer != 0:
             raise ValueError(
@@ -174,8 +181,8 @@ class Extractor:
         input_names: list[str],
         output_names: list[str],
     ) -> ModelProto:
-        inputs = self._collect_new_inputs(input_names)
-        outputs = self._collect_new_outputs(output_names)
+        inputs = self._collect_new_io(input_names)
+        outputs = self._collect_new_io(output_names)
         nodes = self._collect_reachable_nodes(input_names, output_names)
         initializer, value_info = self._collect_reachable_tensors(nodes)
         local_functions = self._collect_referred_local_functions(nodes)

onnx/version.py

@@ -1,5 +1,5 @@
 # This file is generated by setup.py. DO NOT EDIT!
 
 
-version = "1.18.0"
-git_version = "e709452ef2bbc1d113faf678c24e6d3467696e83"
+version = "1.19.1rc1"
+git_version = "e11938a232432630e1ff8904bb80091af6823021"

onnx/version_converter/BaseConverter.h

@@ -62,14 +62,14 @@ class BaseVersionConverter {
         if (adapter_ptr != target_map->second.end()) {
           return *(adapter_ptr->second);
         } else {
-          ONNX_ASSERTM(false, "No Adapter To Version %s for %s", target.c_str(), op_name.c_str());
+          ONNX_ASSERTM(false, "No Adapter To Version %s for %s", target.c_str(), op_name.c_str())
         }
       } else {
-        ONNX_ASSERTM(false, "No Adapter From Version %s for %s", initial.c_str(), op_name.c_str());
+        ONNX_ASSERTM(false, "No Adapter From Version %s for %s", initial.c_str(), op_name.c_str())
       }
     } else {
       // No adapters exist for the given op
-      ONNX_ASSERTM(false, "No Adapter For %s", op_name.c_str());
+      ONNX_ASSERTM(false, "No Adapter For %s", op_name.c_str())
     }
   }
 

onnx/version_converter/adapters/Attention_24_23.h

@@ -0,0 +1,42 @@
+// Copyright (c) ONNX Project Contributors
+
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+// Adapter for Attention in default domain from version 24 to 23
+
+#pragma once
+
+#include "onnx/version_converter/adapters/adapter.h"
+
+namespace ONNX_NAMESPACE {
+namespace version_conversion {
+
+class Attention_24_23 final : public Adapter {
+ public:
+  explicit Attention_24_23() : Adapter("Attention", OpSetID(24), OpSetID(23)) {}
+
+  void adapt_attention_24_23(const std::shared_ptr<Graph>&, Node* node) const {
+    const ArrayRef<Value*>& inputs = node->inputs();
+
+    // Check if nonpad_kv_seqlen input is present (input index 6)
+    if (inputs.size() > 6) {
+      ONNX_ASSERTM(
+          false,
+          "%s being converted from %d to %d has nonpad_kv_seqlen input, "
+          "which is not supported in opset 23. This conversion cannot be performed.",
+          name().c_str(),
+          initial_version().version(),
+          target_version().version());
+    }
+  }
+
+  Node* adapt(std::shared_ptr<Graph> graph, Node* node) const override {
+    adapt_attention_24_23(graph, node);
+    return node;
+  }
+};
+
+} // namespace version_conversion
+} // namespace ONNX_NAMESPACE

onnx/version_converter/adapters/axes_input_to_attribute.h

@@ -38,7 +38,7 @@ class AxesInputToAttribute : public Adapter {
         std::string raw_data = node_ptr->t(kvalue).raw();
         ONNX_ASSERTM(
             !raw_data.empty() && raw_data.size() % 8 == 0,
-            "Raw Data must be non-empty and size must be a multiple of 8");
+            "Raw Data must be non-empty and size must be a multiple of 8")
         int64_t* raw = reinterpret_cast<int64_t*>(raw_data.data());
         node->is_(kaxes, std::vector<int64_t>(raw, raw + node_ptr->t(kvalue).size_from_dim(0)));
       } else {
@@ -62,7 +62,7 @@ class AxesInputToAttribute : public Adapter {
         }
       }
     }
-    ONNX_ASSERTM(node->hasAttribute(kaxes), "No initializer or constant input to node found");
+    ONNX_ASSERTM(node->hasAttribute(kaxes), "No initializer or constant input to node found")
     return node;
   }
 };

onnx/version_converter/adapters/axis_input_to_attribute.h

@@ -44,7 +44,7 @@ class AxisInputToAttribute : public Adapter {
       return EnsureAndReturnNode(node);
     }
 
-    ONNX_ASSERTM(false, "Axis input must be a constant or initializer for promotion to attribute.");
+    ONNX_ASSERTM(false, "Axis input must be a constant or initializer for promotion to attribute.")
   }
 
  private:
@@ -61,7 +61,7 @@ class AxisInputToAttribute : public Adapter {
     if (int64s.empty()) {
       std::string raw_data = axis_node->t(kvalue).raw();
       ONNX_ASSERTM(
-          !raw_data.empty() && raw_data.size() % 8 == 0, "Raw Data must be non-empty and size must be a multiple of 8");
+          !raw_data.empty() && raw_data.size() % 8 == 0, "Raw Data must be non-empty and size must be a multiple of 8")
       const int64_t* raw = reinterpret_cast<const int64_t*>(raw_data.c_str());
       node->i_(kaxis, raw[0]);
     } else {
@@ -88,7 +88,7 @@ class AxisInputToAttribute : public Adapter {
   }
 
   inline Node* EnsureAndReturnNode(Node* node) const {
-    ONNX_ASSERTM(node->hasAttribute(kaxis), "Axis attribute not created. This may be a bug.");
+    ONNX_ASSERTM(node->hasAttribute(kaxis), "Axis attribute not created. This may be a bug.")
     return node;
   }
 };