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

onnx/test/numpy_helper_test.py

@@ -1,29 +1,22 @@
 # Copyright (c) ONNX Project Contributors
 
 # SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
 
 import unittest
 from typing import Any
 
+import ml_dtypes
 import numpy as np
 import parameterized
 
 import onnx
+import onnx.reference
 from onnx import helper, numpy_helper
 
 
 def bfloat16_to_float32(ival: int) -> Any:
-    if ival == 0x7FC0:
-        return np.float32(np.nan)
-
-    expo = ival >> 7
-    prec = ival - (expo << 7)
-    sign = expo & 256
-    powe = expo & 255
-    fval = float(prec * 2 ** (-7) + 1) * 2.0 ** (powe - 127)
-    if sign:
-        fval = -fval
-    return np.float32(fval)
+    return np.int16(ival).view(ml_dtypes.bfloat16).astype(np.float32)
 
 
 def float8e4m3_to_float32(ival: int) -> Any:
@@ -596,6 +589,65 @@ class TestNumpyHelper(unittest.TestCase):
             # Differing value types should raise a TypeError
             numpy_helper.from_dict({0: np.array(1), 1: np.array(0.9)})
 
+    def _to_array_from_array(self, value: int, check_dtype: bool = True):
+        onnx_model = helper.make_model(
+            helper.make_graph(
+                [helper.make_node("Cast", ["X"], ["Y"], to=value)],
+                "test",
+                [helper.make_tensor_value_info("X", onnx.TensorProto.FLOAT, [4])],
+                [helper.make_tensor_value_info("Y", value, [4])],
+            )
+        )
+        ref = onnx.reference.ReferenceEvaluator(onnx_model)
+        start = ref.run(None, {"X": np.array([0, 1, -2, 3], dtype=np.float32)})
+        tp = numpy_helper.from_array(start[0], name="check")
+        self.assertEqual(tp.data_type, value)
+        back = numpy_helper.to_array(tp)
+        self.assertEqual(start[0].shape, back.shape)
+        if check_dtype:
+            self.assertEqual(start[0].dtype, back.dtype)
+        again = numpy_helper.from_array(back, name="check")
+        self.assertEqual(tp.data_type, again.data_type)
+        self.assertEqual(tp.name, again.name)
+        self.assertEqual(len(tp.raw_data), len(again.raw_data))
+        self.assertEqual(list(tp.raw_data), list(again.raw_data))
+        self.assertEqual(tp.raw_data, again.raw_data)
+        self.assertEqual(tuple(tp.dims), tuple(again.dims))
+        self.assertEqual(tp.SerializeToString(), again.SerializeToString())
+        self.assertEqual(tp.data_type, helper.np_dtype_to_tensor_dtype(back.dtype))
+
+    @parameterized.parameterized.expand(
+        [
+            ("FLOAT", onnx.TensorProto.FLOAT),
+            ("UINT8", onnx.TensorProto.UINT8),
+            ("INT8", onnx.TensorProto.INT8),
+            ("UINT16", onnx.TensorProto.UINT16),
+            ("INT16", onnx.TensorProto.INT16),
+            ("INT32", onnx.TensorProto.INT32),
+            ("INT64", onnx.TensorProto.INT64),
+            ("BOOL", onnx.TensorProto.BOOL),
+            ("FLOAT16", onnx.TensorProto.FLOAT16),
+            ("DOUBLE", onnx.TensorProto.DOUBLE),
+            ("UINT32", onnx.TensorProto.UINT32),
+            ("UINT64", onnx.TensorProto.UINT64),
+            ("COMPLEX64", onnx.TensorProto.COMPLEX64),
+            ("COMPLEX128", onnx.TensorProto.COMPLEX128),
+            ("BFLOAT16", onnx.TensorProto.BFLOAT16),
+            ("FLOAT8E4M3FN", onnx.TensorProto.FLOAT8E4M3FN),
+            ("FLOAT8E4M3FNUZ", onnx.TensorProto.FLOAT8E4M3FNUZ),
+            ("FLOAT8E5M2", onnx.TensorProto.FLOAT8E5M2),
+            ("FLOAT8E5M2FNUZ", onnx.TensorProto.FLOAT8E5M2FNUZ),
+            ("UINT4", onnx.TensorProto.UINT4),
+            ("INT4", onnx.TensorProto.INT4),
+            ("FLOAT4E2M1", onnx.TensorProto.FLOAT4E2M1),
+        ]
+    )
+    def test_to_array_from_array(self, _: str, data_type: onnx.TensorProto.DataType):
+        self._to_array_from_array(data_type)
+
+    def test_to_array_from_array_string(self):
+        self._to_array_from_array(onnx.TensorProto.STRING, False)
+
 
 if __name__ == "__main__":
-    unittest.main()
+    unittest.main(verbosity=2)

onnx/test/parser_test.py

@@ -1,12 +1,14 @@
 # Copyright (c) ONNX Project Contributors
 
 # SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
 import unittest
 
 from parameterized import parameterized
 
 import onnx
-from onnx import GraphProto, OperatorSetIdProto, checker
+from onnx import GraphProto, OperatorSetIdProto, TensorProto, checker
 
 
 class TestBasicFunctions(unittest.TestCase):
@@ -218,6 +220,28 @@ class TestBasicFunctions(unittest.TestCase):
         self.assertEqual(node.domain, "SomeDomain")
         self.assertEqual(node.op_type, "SomeOp")
 
+    def test_missing_identifier(self):
+        node = onnx.parser.parse_node("= SomeOp ()")
+        self.assertEqual(list(node.input), [])
+        self.assertEqual(list(node.output), [])
+        node = onnx.parser.parse_node(", = SomeOp (,)")
+        self.assertEqual(list(node.input), [""])
+        self.assertEqual(list(node.output), [""])
+        node = onnx.parser.parse_node("x, = SomeOp (y,)")
+        self.assertEqual(list(node.input), ["y"])
+        self.assertEqual(list(node.output), ["x"])
+        node = onnx.parser.parse_node(",x = SomeOp (,y)")
+        self.assertEqual(list(node.input), ["", "y"])
+        self.assertEqual(list(node.output), ["", "x"])
+
+    def test_quoted_empty_identifier(self):
+        node = onnx.parser.parse_node('"" = SomeOp ("")')
+        self.assertEqual(list(node.input), [""])
+        self.assertEqual(list(node.output), [""])
+        node = onnx.parser.parse_node('"",x = SomeOp ("",y)')
+        self.assertEqual(list(node.input), ["", "y"])
+        self.assertEqual(list(node.output), ["", "x"])
+
     @parameterized.expand(
         [
             ("not_a_good_float", True),
@@ -266,6 +290,51 @@ class TestBasicFunctions(unittest.TestCase):
                 str(model.graph.node[0].attribute[0].f), str(float(test_literal))
             )
 
+    @parameterized.expand(
+        [
+            ("bfloat16", TensorProto.BFLOAT16),
+            ("bool", TensorProto.BOOL),
+            ("complex64", TensorProto.COMPLEX64),
+            ("complex128", TensorProto.COMPLEX128),
+            ("double", TensorProto.DOUBLE),
+            ("float16", TensorProto.FLOAT16),
+            ("float", TensorProto.FLOAT),
+            ("float8e4m3fn", TensorProto.FLOAT8E4M3FN),
+            ("float8e4m3fnuz", TensorProto.FLOAT8E4M3FNUZ),
+            ("float8e5m2", TensorProto.FLOAT8E5M2),
+            ("float8e5m2fnuz", TensorProto.FLOAT8E5M2FNUZ),
+            ("int4", TensorProto.INT4),
+            ("int8", TensorProto.INT8),
+            ("int16", TensorProto.INT16),
+            ("int32", TensorProto.INT32),
+            ("int64", TensorProto.INT64),
+            ("string", TensorProto.STRING),
+            ("uint4", TensorProto.UINT4),
+            ("uint8", TensorProto.UINT8),
+            ("uint16", TensorProto.UINT16),
+            ("uint32", TensorProto.UINT32),
+            ("uint64", TensorProto.UINT64),
+            ("float4e2m1", TensorProto.FLOAT4E2M1),
+        ]
+    )
+    def test_parse_graph_types(self, name, itype) -> None:
+        w = '{"0"}' if itype == TensorProto.STRING else "{0}"
+        text_graph = f"""
+           <
+             ir_version: 10,
+             opset_import: [ "" : 19]
+           >
+           agraph (float[N] X) => ({name}[N] C)
+           <
+             {name}[1] weight = {w}
+           >
+           {{
+              C = Cast<to={itype}>(X)
+           }}
+           """
+        graph = onnx.parser.parse_model(text_graph)
+        self.assertEqual(len(graph.graph.node), 1)
+
 
 if __name__ == "__main__":
-    unittest.main()
+    unittest.main(verbosity=2)

onnx/test/printer_test.py

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

onnx/test/reference_evaluator_ml_test.py

@@ -2,7 +2,7 @@
 
 # SPDX-License-Identifier: Apache-2.0
 # type: ignore
-
+from __future__ import annotations
 
 import itertools
 import unittest
@@ -52,10 +52,9 @@ def has_onnxruntime():
         import onnxruntime
 
         del onnxruntime
-
-        return True
     except ImportError:
         return False
+    return True
 
 
 def skip_if_no_onnxruntime(fn):

onnx/test/reference_evaluator_model_test.py

@@ -2,6 +2,8 @@
 
 # SPDX-License-Identifier: Apache-2.0
 # type: ignore
+from __future__ import annotations
+
 import unittest
 
 import numpy as np