onnx 1.13.1__cp39-cp39-macosx_10_12_universal2.whl → 1.14.1__cp39-cp39-macosx_10_12_universal2.whl

onnx/reference/ops/op_slice.py

@@ -1,3 +1,5 @@
+# Copyright (c) ONNX Project Contributors
+
 # SPDX-License-Identifier: Apache-2.0
 # pylint: disable=R0912,R0913,W0221
 
@@ -5,9 +7,7 @@ from typing import Optional
 
 import numpy as np
 
-from onnx.defs import onnx_opset_version
-
-from ._op import OpRun
+from onnx.reference.ops._op import OpRun
 
 
 def _slice(
@@ -73,9 +73,3 @@ class Slice_1(SliceCommon):
 
     def _run(self, data, axes=None, ends=None, starts=None):  # type: ignore
         return SliceCommon._run(self, data, starts, ends, axes)
-
-
-if onnx_opset_version() >= 10:
-    Slice = Slice_10
-else:
-    Slice = Slice_1  # type: ignore

onnx/reference/ops/op_softmax.py

@@ -1,9 +1,11 @@
+# Copyright (c) ONNX Project Contributors
+
 # SPDX-License-Identifier: Apache-2.0
 # pylint: disable=W0221
 
 import numpy as np
 
-from ._op import OpRunUnaryNum
+from onnx.reference.ops._op import OpRunUnaryNum
 
 
 class Softmax(OpRunUnaryNum):
@@ -12,4 +14,4 @@ class Softmax(OpRunUnaryNum):
         tmp = X - X.max(axis=axis, keepdims=1)  # type: ignore
         Y = np.exp(tmp)
         Y /= Y.sum(axis=axis, keepdims=1)  # type: ignore
-        return (Y,)
+        return (Y.astype(X.dtype),)

onnx/reference/ops/op_softmax_cross_entropy_loss.py

@@ -1,3 +1,5 @@
+# Copyright (c) ONNX Project Contributors
+
 # SPDX-License-Identifier: Apache-2.0
 # pylint: disable=R0912,R0913,R0914,W0221
 
@@ -73,8 +75,9 @@ def softmaxcrossentropy(  # type: ignore
     elif reduction == "sum":
         loss = np.sum(loss)
 
+    loss = loss.astype(x.dtype)
     if get_log_prob is True:
-        return loss, log_prob
+        return loss, log_prob.astype(x.dtype)  # type: ignore[union-attr]
     return (loss,)
 
 

onnx/reference/ops/op_softplus.py

@@ -1,14 +1,16 @@
+# Copyright (c) ONNX Project Contributors
+
 # SPDX-License-Identifier: Apache-2.0
 # pylint: disable=W0221
 
 import numpy as np
 
-from ._op import OpRunUnaryNum
+from onnx.reference.ops._op import OpRunUnaryNum
 
 
 class Softplus(OpRunUnaryNum):
     def _run(self, X):  # type: ignore
-        tmp = np.exp(X)
+        tmp = np.exp(X).astype(X.dtype)
         tmp += 1
         np.log(tmp, out=tmp)
         return (tmp,)

onnx/reference/ops/op_softsign.py

@@ -1,9 +1,11 @@
+# Copyright (c) ONNX Project Contributors
+
 # SPDX-License-Identifier: Apache-2.0
 # pylint: disable=W0221
 
 import numpy as np
 
-from ._op import OpRunUnaryNum
+from onnx.reference.ops._op import OpRunUnaryNum
 
 
 class Softsign(OpRunUnaryNum):

onnx/reference/ops/op_space_to_depth.py

@@ -1,3 +1,5 @@
+# Copyright (c) ONNX Project Contributors
+
 # SPDX-License-Identifier: Apache-2.0
 # pylint: disable=W0221
 
@@ -27,5 +29,5 @@ class SpaceToDepth(OpRun):
             H // blocksize,
             W // blocksize,
         )
-        y = np.reshape(transposed, finalshape)
+        y = np.reshape(transposed, finalshape).astype(data.dtype)
         return (y,)

onnx/reference/ops/op_split.py

@@ -1,7 +1,8 @@
+# Copyright (c) ONNX Project Contributors
+
 # SPDX-License-Identifier: Apache-2.0
 # pylint: disable=W0221
 
-from onnx.defs import onnx_opset_version
 from onnx.reference.op_run import OpRun
 
 
@@ -41,13 +42,10 @@ class Split_11(Split_2):
 
 
 class Split_13(CommonSplit):
-    def _run(self, mat, split=None, axis=None, num_outputs=None):  # type: ignore
-        return self.common_run(mat, split, axis=axis, num_outputs=num_outputs)
+    def _run(self, mat, split=None, axis=None):  # type: ignore
+        return self.common_run(mat, split, axis=axis, num_outputs=None)
 
 
-if onnx_opset_version() >= 13:
-    Split = Split_13
-elif onnx_opset_version() >= 11:
-    Split = Split_11  # type: ignore
-else:
-    Split = Split_2  # type: ignore
+class Split_18(CommonSplit):
+    def _run(self, mat, split=None, axis=None, num_outputs=None):  # type: ignore
+        return self.common_run(mat, split, axis=axis, num_outputs=num_outputs)

onnx/reference/ops/op_split_to_sequence.py

@@ -1,20 +1,51 @@
+# Copyright (c) ONNX Project Contributors
+
 # SPDX-License-Identifier: Apache-2.0
 # pylint: disable=C0200,W0221
 
-from .op_split import CommonSplit
+from typing import List, Optional, Tuple
+
+import numpy as np
+
+from onnx.reference.op_run import OpRun
 
 
-class SplitToSequence(CommonSplit):
-    def _run(self, mat, split=None, axis=None, keepdims=None):  # type: ignore
+class SplitToSequence(OpRun):
+    def common_run(
+        self, mat: np.ndarray, split: Optional[np.ndarray], axis: int
+    ) -> List[np.ndarray]:
         if split is None:
-            num_outputs = mat.shape[axis]
+            split_length = [1 for _ in range(mat.shape[axis])]
+        elif len(split.shape) == 0:
+            # A scalar
+            dim = mat.shape[axis]
+            length = int(split)
+            n = dim // int(length)
+            split_length = [length] * n
+            left = dim - length * n
+            if left > 0:
+                split_length.append(left)
         else:
-            if len(split.shape) == 0:
-                num_outputs = split
-            else:
-                num_outputs = split.shape[0]
-        res = list(self.common_run(mat, split, axis=axis, num_outputs=num_outputs))
-        if keepdims == 0 and axis is not None:
+            split_length = list(split)
+
+        sli = [slice(0, s) for s in mat.shape]
+        res = []
+        pos = 0
+        for spl in split_length:
+            sli[axis] = slice(pos, pos + spl)  # type: ignore
+            pos += spl
+            res.append(mat[tuple(sli)])
+        return res
+
+    def _run(
+        self,
+        mat: np.ndarray,
+        split: Optional[np.ndarray] = None,
+        axis: int = 0,
+        keepdims: int = 1,
+    ) -> Tuple[np.ndarray]:
+        res = self.common_run(mat, split, axis=axis)
+        if split is None and not keepdims:
             for i in range(len(res)):
                 shape = list(res[i].shape)
                 del shape[axis]

onnx/reference/ops/op_sqrt.py

@@ -1,3 +1,5 @@
+# Copyright (c) ONNX Project Contributors
+
 # SPDX-License-Identifier: Apache-2.0
 # pylint: disable=W0221
 
@@ -5,11 +7,11 @@ from warnings import catch_warnings, simplefilter
 
 import numpy as np
 
-from ._op import OpRunUnaryNum
+from onnx.reference.ops._op import OpRunUnaryNum
 
 
 class Sqrt(OpRunUnaryNum):
     def _run(self, x):  # type: ignore
         with catch_warnings():
             simplefilter("ignore")
-            return (np.sqrt(x),)
+            return (np.sqrt(x).astype(x.dtype),)

onnx/reference/ops/op_squeeze.py

@@ -1,15 +1,14 @@
+# Copyright (c) ONNX Project Contributors
+
 # SPDX-License-Identifier: Apache-2.0
 # pylint: disable=E0203,W0221
 
 import numpy as np
 
-from onnx.defs import onnx_opset_version
 from onnx.reference.op_run import OpRun
 
-from ._op import OpRunUnaryNum
-
 
-class Squeeze_1(OpRunUnaryNum):
+class Squeeze_1(OpRun):
     def _run(self, data, axes=None):  # type: ignore
         if isinstance(axes, np.ndarray):
             axes = tuple(axes)
@@ -44,11 +43,3 @@ class Squeeze_13(OpRun):
         else:
             sq = np.squeeze(data)
         return (sq,)
-
-
-if onnx_opset_version() >= 13:
-    Squeeze = Squeeze_13
-elif onnx_opset_version() >= 11:
-    Squeeze = Squeeze_11  # type: ignore
-else:
-    Squeeze = Squeeze_1  # type: ignore

onnx/reference/ops/op_stft.py

@@ -1,13 +1,14 @@
+# Copyright (c) ONNX Project Contributors
+
 # SPDX-License-Identifier: Apache-2.0
 # pylint: disable=R0913,R0914,R0915,W0613,W0221
 
 import numpy as np
 
 from onnx.reference.op_run import OpRun
-
-from .op_concat_from_sequence import _concat_from_sequence
-from .op_dft import _cfft as _dft
-from .op_slice import _slice
+from onnx.reference.ops.op_concat_from_sequence import _concat_from_sequence
+from onnx.reference.ops.op_dft import _cfft as _dft
+from onnx.reference.ops.op_slice import _slice
 
 
 def _concat(*args, axis=0):  # type: ignore
@@ -62,7 +63,7 @@ def _stft(x, fft_length, hop_length, n_frames, window, onesided=False):  # type:
     shape_x = new_x.shape
     shape_x_short = shape_x[:-2]
     shape_x_short_one = tuple(1 for _ in shape_x_short)
-    window_shape = shape_x_short_one + (window_size, 1)
+    window_shape = (*shape_x_short_one, window_size, 1)
     weights = np.reshape(window, window_shape)
     weighted_new_x = new_x * weights
 
@@ -110,8 +111,8 @@ def _istft(x, fft_length, hop_length, window, onesided=False):  # type: ignore
         size = ytmp.shape[-1]
         n_right = expected_signal_len - (n_left + size)
 
-        left_shape = shape_begin + (n_left,)
-        right_shape = shape_begin + (n_right,)
+        left_shape = (*shape_begin, n_left)
+        right_shape = (*shape_begin, n_right)
         right = np.zeros(right_shape, dtype=x.dtype)
         left = np.zeros(left_shape, dtype=x.dtype)
 

onnx/reference/ops/op_string_normalizer.py

@@ -1,3 +1,5 @@
+# Copyright (c) ONNX Project Contributors
+
 # SPDX-License-Identifier: Apache-2.0
 # pylint: disable=R0912,R0913,W0221
 
@@ -87,8 +89,7 @@ class StringNormalizer(OpRun):
                 pylocale.setlocale(pylocale.LC_ALL, slocale)
             except pylocale.Error as e:
                 warnings.warn(
-                    f"Unknown local setting {slocale!r} (current: {pylocale.getlocale()!r}) - {e!r}.",
-                    stacklevel=2,
+                    f"Unknown local setting {slocale!r} (current: {pylocale.getlocale()!r}) - {e!r}."
                 )
         cout[:] = cin[:]
 
@@ -130,7 +131,7 @@ class StringNormalizer(OpRun):
         """
         Transforms accentuated unicode symbols into their simple counterpart.
         Source: `sklearn/feature_extraction/text.py
-        <https://github.com/scikit-learn/scikit-learn/blob/master/sklearn/
+        <https://github.com/scikit-learn/scikit-learn/blob/main/sklearn/
         feature_extraction/text.py#L115>`_.
 
         :param s: string

onnx/reference/ops/op_sub.py

@@ -1,9 +1,11 @@
+# Copyright (c) ONNX Project Contributors
+
 # SPDX-License-Identifier: Apache-2.0
 # pylint: disable=W0221
 
 import numpy as np
 
-from ._op import OpRunBinaryNumpy
+from onnx.reference.ops._op import OpRunBinaryNumpy
 
 
 class Sub(OpRunBinaryNumpy):

onnx/reference/ops/op_sum.py

@@ -1,3 +1,5 @@
+# Copyright (c) ONNX Project Contributors
+
 # SPDX-License-Identifier: Apache-2.0
 # pylint: disable=W0221
 
@@ -6,4 +8,4 @@ from onnx.reference.op_run import OpRun
 
 class Sum(OpRun):
     def _run(self, *args):  # type: ignore
-        return (sum(args),)
+        return (sum(args).astype(args[0].dtype),)

onnx/reference/ops/op_tan.py

@@ -1,9 +1,11 @@
+# Copyright (c) ONNX Project Contributors
+
 # SPDX-License-Identifier: Apache-2.0
 # pylint: disable=W0221
 
 import numpy as np
 
-from ._op import OpRunUnaryNum
+from onnx.reference.ops._op import OpRunUnaryNum
 
 
 class Tan(OpRunUnaryNum):

onnx/reference/ops/op_tanh.py

@@ -1,9 +1,11 @@
+# Copyright (c) ONNX Project Contributors
+
 # SPDX-License-Identifier: Apache-2.0
 # pylint: disable=W0221
 
 import numpy as np
 
-from ._op import OpRunUnaryNum
+from onnx.reference.ops._op import OpRunUnaryNum
 
 
 class Tanh(OpRunUnaryNum):

onnx/reference/ops/op_tfidf_vectorizer.py

@@ -1,3 +1,5 @@
+# Copyright (c) ONNX Project Contributors
+
 # SPDX-License-Identifier: Apache-2.0
 # pylint: disable=C0200,R0902,R0912,R0913,R0914,R0915,R1716,W0611,W0612,W0613,W0221
 
@@ -92,10 +94,10 @@ class NgramPart:
 
 
 class WeightingCriteria(IntEnum):
-    kNone = 0
-    kTF = 1
-    kIDF = 2
-    kTFIDF = 3
+    NONE = 0
+    TF = 1
+    IDF = 2
+    TFIDF = 3
 
 
 def populate_grams(
@@ -130,11 +132,11 @@ class TfIdfVectorizer(OpRun):
         mode = self.mode  # type: ignore
 
         if mode == "TF":
-            self.weighting_criteria_ = WeightingCriteria.kTF
+            self.weighting_criteria_ = WeightingCriteria.TF
         elif mode == "IDF":
-            self.weighting_criteria_ = WeightingCriteria.kIDF
+            self.weighting_criteria_ = WeightingCriteria.IDF
         elif mode == "TFIDF":
-            self.weighting_criteria_ = WeightingCriteria.kTFIDF
+            self.weighting_criteria_ = WeightingCriteria.TFIDF
 
         self.min_gram_length_ = self.min_gram_length  # type: ignore
         self.max_gram_length_ = self.max_gram_length  # type: ignore
@@ -204,12 +206,12 @@ class TfIdfVectorizer(OpRun):
         Y = np.empty((total_dims,), dtype=np.float32)
 
         w = self.weights_
-        if self.weighting_criteria_ == WeightingCriteria.kTF:
+        if self.weighting_criteria_ == WeightingCriteria.TF:
             i = 0
             for f in frequencies:
                 Y[i] = f
                 i += 1
-        elif self.weighting_criteria_ == WeightingCriteria.kIDF:
+        elif self.weighting_criteria_ == WeightingCriteria.IDF:
             if len(w) > 0:
                 p = 0
                 for _batch in range(B):
@@ -221,7 +223,7 @@ class TfIdfVectorizer(OpRun):
                 for f in frequencies:
                     Y[p] = 1 if f > 0 else 0
                     p += 1
-        elif self.weighting_criteria_ == WeightingCriteria.kTFIDF:
+        elif self.weighting_criteria_ == WeightingCriteria.TFIDF:
             if len(w) > 0:
                 p = 0
                 for _batch in range(B):
@@ -357,14 +359,14 @@ class TfIdfVectorizer(OpRun):
             # TfidfVectorizer returns a zero tensor of shape
             # {b_dim, output_size} when b_dim is the number of received observations
             # and output_size the is the maximum value in ngram_indexes attribute plus 1.
-            return self.output_result(B, frequencies)
+            return self.output_result(B, frequencies)  # type: ignore[arg-type]
 
         def fn(row_num):
             self.compute_impl(
                 X,
                 row_num,
                 C,
-                frequencies,
+                frequencies,  # type: ignore[arg-type]
                 max_gram_length=max_gram_length,
                 max_skip_count=max_skip_count,
                 min_gram_length=min_gram_length,
@@ -380,4 +382,4 @@ class TfIdfVectorizer(OpRun):
         for i in range(num_rows):
             fn(i)
 
-        return (self.output_result(B, frequencies),)
+        return (self.output_result(B, frequencies),)  # type: ignore[arg-type]

onnx/reference/ops/op_thresholded_relu.py

@@ -1,12 +1,14 @@
+# Copyright (c) ONNX Project Contributors
+
 # SPDX-License-Identifier: Apache-2.0
 # pylint: disable=W0221
 
 import numpy as np
 
-from ._op import OpRunUnaryNum
+from onnx.reference.ops._op import OpRunUnaryNum
 
 
 class ThresholdedRelu(OpRunUnaryNum):
     def _run(self, x, alpha=None):  # type: ignore
         alpha = alpha or self.alpha  # type: ignore
-        return (np.where(x > alpha, x, 0),)  # type: ignore
+        return (np.where(x > alpha, x, 0).astype(x.dtype),)  # type: ignore

onnx/reference/ops/op_tile.py

@@ -1,3 +1,5 @@
+# Copyright (c) ONNX Project Contributors
+
 # SPDX-License-Identifier: Apache-2.0
 # pylint: disable=W0221
 

onnx/reference/ops/op_topk.py

@@ -1,17 +1,18 @@
+# Copyright (c) ONNX Project Contributors
+
 # SPDX-License-Identifier: Apache-2.0
 # pylint: disable=R0913,W0221,W0622
 
 import numpy as np
 
-from onnx.defs import onnx_opset_version
 from onnx.reference.op_run import OpRun
 
 
 def topk_sorted_implementation(X, k, axis, largest):  # type: ignore
     """
     See function `_kneighbors_reduce_func
-    <https://github.com/scikit-learn/scikit-learn/tree/master/
-    sklearn/neighbors/base.py#L304>`_.
+    <https://github.com/scikit-learn/scikit-learn/blob/main/
+    sklearn/neighbors/_base.py#L304>`_.
     """
     if isinstance(k, np.ndarray):
         if k.size != 1:
@@ -59,9 +60,9 @@ class _CommonTopK(OpRun):
 
         .. warning::
             ONNX specifications may be imprecise in case of negative value
-            for axis. The implementation follows what :epkg:`onnxruntime`
+            for axis. The implementation follows what `onnxruntime`
             does in `top_k.cc
-            <https://github.com/Microsoft/onnxruntime/blob/master/onnxruntime/core/providers/cpu/math/top_k.cc#L63>`_.
+            <https://github.com/Microsoft/onnxruntime/blob/main/onnxruntime/core/providers/cpu/math/top_k.cc#L63>`_.
         """
         k = ink[0]
         axis = axis if axis >= 0 else (axis + len(data.shape))  # type: ignore
@@ -79,9 +80,9 @@ class TopK_1(_CommonTopK):
 
         .. warning::
             ONNX specifications may be imprecise in case of negative value
-            for axis. The implementation follows what :epkg:`onnxruntime`
+            for axis. The implementation follows what `onnxruntime`
             does in `top_k.cc
-            <https://github.com/Microsoft/onnxruntime/blob/master/onnxruntime/core/providers/cpu/math/top_k.cc#L63>`_.
+            <https://github.com/Microsoft/onnxruntime/blob/main/onnxruntime/core/providers/cpu/math/top_k.cc#L63>`_.
         """
         return _CommonTopK._common_run(self, data, [k], axis=axis)  # type: ignore
 
@@ -96,9 +97,9 @@ class TopK_10(_CommonTopK):
 
         .. warning::
             ONNX specifications may be imprecise in case of negative value
-            for axis. The implementation follows what :epkg:`onnxruntime`
+            for axis. The implementation follows what `onnxruntime`
             does in `top_k.cc
-            <https://github.com/Microsoft/onnxruntime/blob/master/onnxruntime/core/providers/cpu/math/top_k.cc#L63>`_.
+            <https://github.com/Microsoft/onnxruntime/blob/main/onnxruntime/core/providers/cpu/math/top_k.cc#L63>`_.
         """
         return _CommonTopK._common_run(self, data, ink, axis=axis)
 
@@ -113,18 +114,10 @@ class TopK_11(_CommonTopK):
 
         .. warning::
             ONNX specifications may be imprecise in case of negative value
-            for axis. The implementation follows what :epkg:`onnxruntime`
+            for axis. The implementation follows what `onnxruntime`
             does in `top_k.cc
-            <https://github.com/Microsoft/onnxruntime/blob/master/onnxruntime/core/providers/cpu/math/top_k.cc#L63>`_.
+            <https://github.com/Microsoft/onnxruntime/blob/main/onnxruntime/core/providers/cpu/math/top_k.cc#L63>`_.
         """
         if sorted not in (True, 1):
             raise RuntimeError("TopK does not implement anything for sorted=0.")
         return _CommonTopK._common_run(self, data, ink, axis=axis, largest=largest)
-
-
-if onnx_opset_version() >= 11:
-    TopK = TopK_11
-elif onnx_opset_version() >= 10:
-    TopK = TopK_10  # type: ignore
-else:
-    TopK = TopK_1  # type: ignore

onnx/reference/ops/op_transpose.py

@@ -1,3 +1,5 @@
+# Copyright (c) ONNX Project Contributors
+
 # SPDX-License-Identifier: Apache-2.0
 # pylint: disable=W0221
 

onnx/reference/ops/op_trilu.py

@@ -1,3 +1,5 @@
+# Copyright (c) ONNX Project Contributors
+
 # SPDX-License-Identifier: Apache-2.0
 # pylint: disable=W0221
 
@@ -11,4 +13,4 @@ class Trilu(OpRun):
         k = 0 if k is None else int(k)
         if upper:  # type: ignore
             return (np.triu(x, k),)
-        return (np.tril(x, k),)
+        return (np.tril(x, k).astype(x.dtype),)

onnx/reference/ops/op_unique.py

@@ -1,3 +1,5 @@
+# Copyright (c) ONNX Project Contributors
+
 # SPDX-License-Identifier: Apache-2.0
 # pylint: disable=W0221,W0622
 

onnx/reference/ops/op_unsqueeze.py

@@ -1,9 +1,10 @@
+# Copyright (c) ONNX Project Contributors
+
 # SPDX-License-Identifier: Apache-2.0
 # pylint: disable=E0203,W0221
 
 import numpy as np
 
-from onnx.defs import onnx_opset_version
 from onnx.reference.op_run import OpRun
 
 
@@ -51,11 +52,3 @@ class Unsqueeze_13(OpRun):
                 "axes cannot be None for operator Unsqueeze (Unsqueeze_13)."
             )
         return (sq,)
-
-
-if onnx_opset_version() >= 13:
-    Unsqueeze = Unsqueeze_13
-elif onnx_opset_version() >= 11:
-    Unsqueeze = Unsqueeze_11  # type: ignore
-else:
-    Unsqueeze = Unsqueeze_1  # type: ignore

onnx/reference/ops/op_upsample.py

@@ -1,3 +1,5 @@
+# Copyright (c) ONNX Project Contributors
+
 # SPDX-License-Identifier: Apache-2.0
 # pylint: disable=W0221,R0913
 
@@ -8,12 +10,11 @@ from onnx.reference.op_run import OpRun
 
 class Upsample(OpRun):
     def _run(self, x, scale, mode=None):  # type: ignore
-        if mode == "nearest":
-            if scale.astype(np.int64).tolist() == scale.tolist():
-                r = x
-                for axis, s in enumerate(scale):
-                    if s == 1:
-                        continue
-                    r = np.repeat(r, int(s), axis=axis)
-                return (r,)
+        if mode == "nearest" and scale.astype(np.int64).tolist() == scale.tolist():
+            r = x
+            for axis, s in enumerate(scale):
+                if s == 1:
+                    continue
+                r = np.repeat(r, int(s), axis=axis)
+            return (r,)
         raise RuntimeError(f"Not implemented for mode={mode!r} and scale={scale!r}.")

onnx/reference/ops/op_where.py

@@ -1,3 +1,5 @@
+# Copyright (c) ONNX Project Contributors
+
 # SPDX-License-Identifier: Apache-2.0
 # pylint: disable=W0221
 
@@ -8,7 +10,11 @@ from onnx.reference.op_run import OpRun
 
 class Where(OpRun):
     def _run(self, condition, x, y):  # type: ignore
-        if x.dtype != y.dtype and x.dtype not in (object,):
+        if (
+            x.dtype != y.dtype
+            and x.dtype not in (object,)
+            and not (x.dtype.type is np.str_ and y.dtype.type is np.str_)
+        ):
             raise RuntimeError(
                 f"x and y should share the same dtype {x.dtype} != {y.dtype}"
             )

onnx/reference/ops/op_xor.py

@@ -1,9 +1,11 @@
+# Copyright (c) ONNX Project Contributors
+
 # SPDX-License-Identifier: Apache-2.0
 # pylint: disable=W0221
 
 import numpy as np
 
-from ._op import OpRunBinary
+from onnx.reference.ops._op import OpRunBinary
 
 
 class Xor(OpRunBinary):