onnx 1.17.0__cp312-cp312-win32.whl → 1.19.0__cp312-cp312-win32.whl

onnx/reference/ops/op_scatter_elements.py

@@ -8,7 +8,7 @@ import numpy as np
 from onnx.reference.op_run import OpRun
 
 
-def scatter_elements(data, indices, updates, axis=0, reduction=None):  # type: ignore
+def scatter_elements(data, indices, updates, axis=0, reduction=None):
     """Scatter elements.
 
     ::
@@ -109,6 +109,6 @@ def scatter_elements(data, indices, updates, axis=0, reduction=None):  # type: i
 
 
 class ScatterElements(OpRun):
-    def _run(self, data, indices, updates, axis=None, reduction=None):  # type: ignore
+    def _run(self, data, indices, updates, axis=None, reduction=None):
         res = scatter_elements(data, indices, updates, axis=axis, reduction=reduction)
         return (res,)

onnx/reference/ops/op_scatternd.py

@@ -8,7 +8,7 @@ import numpy as np
 from onnx.reference.op_run import OpRun
 
 
-def _scatter_nd_impl(data, indices, updates, reduction=None):  # type: ignore
+def _scatter_nd_impl(data, indices, updates, reduction=None):
     output = np.copy(data)
     for i in np.ndindex(indices.shape[:-1]):
         if reduction == "add":
@@ -25,6 +25,6 @@ def _scatter_nd_impl(data, indices, updates, reduction=None):  # type: ignore
 
 
 class ScatterND(OpRun):
-    def _run(self, data, indices, updates, reduction=None):  # type: ignore
+    def _run(self, data, indices, updates, reduction=None):
         y = _scatter_nd_impl(data, indices, updates, reduction=reduction)
         return (y,)

onnx/reference/ops/op_selu.py

@@ -9,7 +9,7 @@ from onnx.reference.op_run import OpRun
 
 
 class Selu(OpRun):
-    def _run(self, x, alpha=None, gamma=None):  # type: ignore
+    def _run(self, x, alpha=None, gamma=None):
         return (
             (np.where(x > 0, x, np.exp(x) * alpha - alpha) * gamma).astype(x.dtype),
         )

onnx/reference/ops/op_sequence_at.py

@@ -7,5 +7,5 @@ from onnx.reference.op_run import OpRun
 
 
 class SequenceAt(OpRun):
-    def _run(self, seq, index):  # type: ignore
+    def _run(self, seq, index):
         return (seq[index],)

onnx/reference/ops/op_sequence_construct.py

@@ -7,5 +7,5 @@ from onnx.reference.op_run import OpRun
 
 
 class SequenceConstruct(OpRun):
-    def _run(self, *data):  # type: ignore
+    def _run(self, *data):
         return (list(data),)

onnx/reference/ops/op_sequence_erase.py

@@ -7,7 +7,7 @@ from onnx.reference.op_run import OpRun
 
 
 class SequenceErase(OpRun):
-    def _run(self, S, ind=None):  # type: ignore
+    def _run(self, S, ind=None):
         if ind is None:
             ind = -1
         else:

onnx/reference/ops/op_sequence_insert.py

@@ -38,7 +38,7 @@ def sequence_insert_reference_implementation(
 
 
 class SequenceInsert(OpRun):
-    def _run(self, S, T, ind=None):  # type: ignore
+    def _run(self, S, T, ind=None):
         if ind is None:
             res = sequence_insert_reference_implementation(S, T)
         elif isinstance(ind, int):

onnx/reference/ops/op_sequence_length.py

@@ -9,7 +9,7 @@ from onnx.reference.op_run import OpRun
 
 
 class SequenceLength(OpRun):
-    def _run(self, input_sequence):  # type: ignore
+    def _run(self, input_sequence):
         if not isinstance(input_sequence, list):
             raise TypeError(
                 f"input_sequence must be a list not {type(input_sequence)}."

onnx/reference/ops/op_sequence_map.py

@@ -7,7 +7,7 @@ from onnx.reference.op_run import OpRun
 
 
 class SequenceMap(OpRun):
-    def _run(self, input_sequence, *additional_inputs, body=None, attributes=None):  # type: ignore
+    def _run(self, input_sequence, *additional_inputs, body=None, attributes=None):
         if len(additional_inputs) == 1 and isinstance(additional_inputs[0], list):
             res = None
             for obj1, obj2 in zip(input_sequence, additional_inputs[0]):
@@ -18,7 +18,7 @@ class SequenceMap(OpRun):
                 else:
                     for s, i in zip(res, r):
                         s.append(i)
-            return tuple(res)  # type: ignore
+            return tuple(res)
 
         feeds = dict(zip(body.input_names[1:], additional_inputs))
         res = None
@@ -30,4 +30,4 @@ class SequenceMap(OpRun):
             else:
                 for s, i in zip(res, r):
                     s.append(i)
-        return tuple(res)  # type: ignore
+        return tuple(res)

onnx/reference/ops/op_shape.py

@@ -9,7 +9,7 @@ from onnx.reference.op_run import OpRun
 
 
 class Shape_1(OpRun):
-    def _run(self, data):  # type: ignore
+    def _run(self, data):
         return (np.array(data.shape, dtype=np.int64),)
 
 
@@ -23,12 +23,12 @@ class Shape_15(Shape_1):
                 return (0, n + end)
             return (0, end)
         if end is None or np.isnan(end):
-            return (start, n)  # type: ignore
+            return (start, n)
         if end < 0:
-            return (start, n + end)  # type: ignore
-        return (start, end)  # type: ignore
+            return (start, n + end)
+        return (start, end)
 
-    def _run(self, data, end=None, start=None):  # type: ignore
+    def _run(self, data, end=None, start=None):
         ab = self._interval(len(data.shape), start=start, end=end)
         if ab is None:
             return (np.array(data.shape, dtype=np.int64),)

onnx/reference/ops/op_shrink.py

@@ -9,7 +9,7 @@ from onnx.reference.op_run import OpRun
 
 
 class Shrink(OpRun):
-    def _run(self, x, bias=None, lambd=None):  # type: ignore
+    def _run(self, x, bias=None, lambd=None):
         return (
             np.where(
                 x < -lambd,

onnx/reference/ops/op_sigmoid.py

@@ -8,18 +8,18 @@ import numpy as np
 from onnx.reference.ops._op import OpRunUnaryNum
 
 
-def sigmoid(x):  # type: ignore
+def sigmoid(x):
     if x > 0:
         return 1 / (1 + np.exp(-x))
     return np.exp(x) / (1 + np.exp(x))
 
 
 class Sigmoid(OpRunUnaryNum):
-    def __init__(self, onnx_node, run_params):  # type: ignore
+    def __init__(self, onnx_node, run_params):
         OpRunUnaryNum.__init__(self, onnx_node, run_params)
         self.vf = np.vectorize(sigmoid)
 
-    def _run(self, X):  # type: ignore
+    def _run(self, X):
         if len(X.shape) == 0:
             return (sigmoid(X).astype(X.dtype),)
         if X.size == 0:

onnx/reference/ops/op_sign.py

@@ -9,5 +9,5 @@ from onnx.reference.ops._op import OpRunUnaryNum
 
 
 class Sign(OpRunUnaryNum):
-    def _run(self, x):  # type: ignore
+    def _run(self, x):
         return (np.sign(x),)

onnx/reference/ops/op_sin.py

@@ -9,5 +9,5 @@ from onnx.reference.ops._op import OpRunUnaryNum
 
 
 class Sin(OpRunUnaryNum):
-    def _run(self, x):  # type: ignore
+    def _run(self, x):
         return (np.sin(x),)

onnx/reference/ops/op_sinh.py

@@ -9,5 +9,5 @@ from onnx.reference.ops._op import OpRunUnaryNum
 
 
 class Sinh(OpRunUnaryNum):
-    def _run(self, x):  # type: ignore
+    def _run(self, x):
         return (np.sinh(x),)

onnx/reference/ops/op_size.py

@@ -9,5 +9,5 @@ from onnx.reference.op_run import OpRun
 
 
 class Size(OpRun):
-    def _run(self, data):  # type: ignore
+    def _run(self, data):
         return (np.array(data.size, dtype=np.int64),)

onnx/reference/ops/op_slice.py

@@ -42,7 +42,7 @@ def _slice(
             for s, e, a, d in zip(starts, ends, axes, steps):
                 slices[a] = slice(s, e, d)
     try:
-        return data[tuple(slices)]  # type: ignore
+        return data[tuple(slices)]
     except TypeError as e:  # pragma: no cover
         raise TypeError(
             f"Unable to extract slice {slices!r} for shape {data.shape!r}."
@@ -50,18 +50,18 @@ def _slice(
 
 
 class SliceCommon(OpRun):
-    def _run(self, data, starts, ends, axes=None, steps=None):  # type: ignore
+    def _run(self, data, starts, ends, axes=None, steps=None):
         res = _slice(data, starts, ends, axes, steps)
         return (res,)
 
 
 class Slice_10(SliceCommon):
-    def __init__(self, onnx_node, run_params):  # type: ignore
+    def __init__(self, onnx_node, run_params):
         SliceCommon.__init__(self, onnx_node, run_params)
 
 
 class Slice_1(SliceCommon):
-    def __init__(self, onnx_node, run_params):  # type: ignore
+    def __init__(self, onnx_node, run_params):
         SliceCommon.__init__(self, onnx_node, run_params)
         for f in ["starts", "ends", "steps", "axes"]:
             if not hasattr(self, f):
@@ -69,5 +69,5 @@ class Slice_1(SliceCommon):
             if getattr(self, f) is not None and len(getattr(self, f)) == 0:
                 setattr(self, f, None)
 
-    def _run(self, data, axes=None, ends=None, starts=None):  # type: ignore
+    def _run(self, data, axes=None, ends=None, starts=None):
         return SliceCommon._run(self, data, starts, ends, axes)

onnx/reference/ops/op_softmax.py

@@ -9,9 +9,9 @@ from onnx.reference.ops._op import OpRunUnaryNum
 
 
 class Softmax(OpRunUnaryNum):
-    def _run(self, X, axis=None):  # type: ignore
-        axis = axis or self.axis  # type: ignore
-        tmp = X - X.max(axis=axis, keepdims=1)  # type: ignore
+    def _run(self, X, axis=None):
+        axis = axis or self.axis
+        tmp = X - X.max(axis=axis, keepdims=1)
         Y = np.exp(tmp)
-        Y /= Y.sum(axis=axis, keepdims=1)  # type: ignore
+        Y /= Y.sum(axis=axis, keepdims=1)
         return (Y.astype(X.dtype),)

onnx/reference/ops/op_softmax_cross_entropy_loss.py

@@ -8,7 +8,7 @@ import numpy as np
 from onnx.reference.op_run import OpRun
 
 
-def softmaxcrossentropy(  # type: ignore
+def softmaxcrossentropy(
     x, target, weight=None, reduction="mean", ignore_index=None, get_log_prob=None
 ):
     input_shape = x.shape
@@ -82,8 +82,8 @@ def softmaxcrossentropy(  # type: ignore
 
 
 class SoftmaxCrossEntropyLoss(OpRun):
-    def _run(self, x, target, weight=None, ignore_index=None, reduction=None):  # type: ignore
-        n_outputs = len(self.onnx_node.output)  # type: ignore
+    def _run(self, x, target, weight=None, ignore_index=None, reduction=None):
+        n_outputs = len(self.onnx_node.output)
         return softmaxcrossentropy(
             x,
             target,

onnx/reference/ops/op_softplus.py

@@ -9,8 +9,8 @@ from onnx.reference.ops._op import OpRunUnaryNum
 
 
 class Softplus(OpRunUnaryNum):
-    def _run(self, X):  # type: ignore
-        tmp = np.exp(X).astype(X.dtype)
+    def _run(self, X):
+        tmp = np.asarray(np.exp(X), dtype=X.dtype)
         tmp += 1
         np.log(tmp, out=tmp)
         return (tmp,)

onnx/reference/ops/op_softsign.py

@@ -9,7 +9,7 @@ from onnx.reference.ops._op import OpRunUnaryNum
 
 
 class Softsign(OpRunUnaryNum):
-    def _run(self, X):  # type: ignore
+    def _run(self, X):
         tmp = np.abs(X)
         tmp += 1
         np.divide(X, tmp, out=tmp)

onnx/reference/ops/op_space_to_depth.py

@@ -9,7 +9,7 @@ from onnx.reference.op_run import OpRun
 
 
 class SpaceToDepth(OpRun):
-    def _run(self, data, blocksize=None):  # type: ignore
+    def _run(self, data, blocksize=None):
         if len(data.shape) != 4:
             raise RuntimeError(f"Unexpected shape {data.shape!r}.")
         b, C, H, W = data.shape

onnx/reference/ops/op_split.py

@@ -7,11 +7,11 @@ from onnx.reference.op_run import OpRun
 
 
 class CommonSplit(OpRun):
-    def __init__(self, onnx_node, run_params):  # type: ignore
+    def __init__(self, onnx_node, run_params):
         OpRun.__init__(self, onnx_node, run_params)
         self.n_outputs = len(onnx_node.output)
 
-    def common_run(self, mat, split, axis, num_outputs):  # type: ignore
+    def common_run(self, mat, split, axis, num_outputs):
         n_outputs = num_outputs or self.n_outputs
         if split is None:
             if mat.shape[axis] % n_outputs == 0:
@@ -20,21 +20,21 @@ class CommonSplit(OpRun):
             else:
                 div = mat.shape[axis] // n_outputs + 1
                 split = [div] * n_outputs
-                split[-1] += mat.shape[axis] - sum(split)  # type: ignore
+                split[-1] += mat.shape[axis] - sum(split)
 
         sli = [slice(0, s) for s in mat.shape]
         res = []
         pos = 0
         for spl in split:
-            sli[axis] = slice(pos, pos + spl)  # type: ignore
+            sli[axis] = slice(pos, pos + spl)
             pos += spl
             res.append(mat[tuple(sli)])
         return tuple(res)
 
 
 class Split_2(CommonSplit):
-    def _run(self, mat, axis=None, split=None):  # type: ignore
-        return self.common_run(mat, split, axis=axis, num_outputs=None)  # type: ignore
+    def _run(self, mat, axis=None, split=None):
+        return self.common_run(mat, split, axis=axis, num_outputs=None)
 
 
 class Split_11(Split_2):
@@ -42,10 +42,10 @@ class Split_11(Split_2):
 
 
 class Split_13(CommonSplit):
-    def _run(self, mat, split=None, axis=None):  # type: ignore
+    def _run(self, mat, split=None, axis=None):
         return self.common_run(mat, split, axis=axis, num_outputs=None)
 
 
 class Split_18(CommonSplit):
-    def _run(self, mat, split=None, axis=None, num_outputs=None):  # type: ignore
+    def _run(self, mat, split=None, axis=None, num_outputs=None):
         return self.common_run(mat, split, axis=axis, num_outputs=num_outputs)

onnx/reference/ops/op_split_to_sequence.py

@@ -3,10 +3,13 @@
 # SPDX-License-Identifier: Apache-2.0
 from __future__ import annotations
 
-import numpy as np
+from typing import TYPE_CHECKING
 
 from onnx.reference.op_run import OpRun
 
+if TYPE_CHECKING:
+    import numpy as np
+
 
 class SplitToSequence(OpRun):
     def common_run(
@@ -30,7 +33,7 @@ class SplitToSequence(OpRun):
         res = []
         pos = 0
         for spl in split_length:
-            sli[axis] = slice(pos, pos + spl)  # type: ignore
+            sli[axis] = slice(pos, pos + spl)
             pos += spl
             res.append(mat[tuple(sli)])
         return res
@@ -44,8 +47,8 @@ class SplitToSequence(OpRun):
     ) -> 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)
+            for i, res_i in enumerate(res):
+                shape = list(res_i.shape)
                 del shape[axis]
-                res[i] = res[i].reshape(tuple(shape))
+                res[i] = res_i.reshape(tuple(shape))
         return (res,)

onnx/reference/ops/op_sqrt.py

@@ -11,7 +11,7 @@ from onnx.reference.ops._op import OpRunUnaryNum
 
 
 class Sqrt(OpRunUnaryNum):
-    def _run(self, x):  # type: ignore
+    def _run(self, x):
         with catch_warnings():
             simplefilter("ignore")
             return (np.sqrt(x).astype(x.dtype),)

onnx/reference/ops/op_squeeze.py

@@ -9,7 +9,7 @@ from onnx.reference.op_run import OpRun
 
 
 class Squeeze_1(OpRun):
-    def _run(self, data, axes=None):  # type: ignore
+    def _run(self, data, axes=None):
         if isinstance(axes, np.ndarray):
             axes = tuple(axes)
         elif axes in [[], ()]:
@@ -30,11 +30,11 @@ class Squeeze_11(Squeeze_1):
 
 
 class Squeeze_13(OpRun):
-    def __init__(self, onnx_node, run_params):  # type: ignore
+    def __init__(self, onnx_node, run_params):
         OpRun.__init__(self, onnx_node, run_params)
         self.axes = None
 
-    def _run(self, data, axes=None):  # type: ignore
+    def _run(self, data, axes=None):
         if axes is not None:
             if hasattr(axes, "__iter__"):
                 sq = np.squeeze(data, axis=tuple(axes))

onnx/reference/ops/op_stft.py

@@ -11,11 +11,11 @@ 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
+def _concat(*args, axis=0):
     return np.concatenate(args, axis=axis)
 
 
-def _unsqueeze(a, axis):  # type: ignore
+def _unsqueeze(a, axis):
     try:
         return np.expand_dims(a, axis=axis)
     except TypeError:
@@ -27,7 +27,7 @@ def _unsqueeze(a, axis):  # type: ignore
         return a
 
 
-def _stft(x, fft_length: int, hop_length, n_frames, window, onesided=False):  # type: ignore
+def _stft(x, fft_length: int, hop_length, n_frames, window, onesided=False):
     """Applies one dimensional FFT with window weights.
 
     torch defines the number of frames as:
@@ -43,7 +43,7 @@ def _stft(x, fft_length: int, hop_length, n_frames, window, onesided=False):  #
     for fs in range(n_frames):
         begin = fs * hop_length
         end = begin + window_size
-        sliced_x = _slice(x, np.array([begin]), np.array([end]), axis)  # type: ignore
+        sliced_x = _slice(x, np.array([begin]), np.array([end]), axis)
 
         # sliced_x may be smaller
         new_dim = sliced_x.shape[-2:-1]
@@ -74,7 +74,7 @@ def _stft(x, fft_length: int, hop_length, n_frames, window, onesided=False):  #
     return result
 
 
-def _istft(x, fft_length: int, hop_length, window, onesided=False):  # type: ignore
+def _istft(x, fft_length: int, hop_length, window, onesided=False):
     """Reverses of `stft`."""
     zero = [0]
     one = [1]
@@ -92,7 +92,7 @@ def _istft(x, fft_length: int, hop_length, window, onesided=False):  # type: ign
         end = fs + 1
         frame_x = np.squeeze(
             _slice(x, np.array([begin]), np.array([end]), axisf),
-            axis=axisf[0],  # type: ignore
+            axis=axisf[0],
         )
 
         # ifft
@@ -101,7 +101,7 @@ def _istft(x, fft_length: int, hop_length, window, onesided=False):  # type: ign
 
         # real part
         n_dims_1 = n_dims - 1
-        sliced = _slice(ift, np.array(zero), np.array(one), [n_dims_1])  # type: ignore
+        sliced = _slice(ift, np.array(zero), np.array(one), [n_dims_1])
         ytmp = np.squeeze(sliced, axis=n_dims_1)
         ctmp = np.full(ytmp.shape, fill_value=1, dtype=x.dtype) * window
 
@@ -119,7 +119,7 @@ def _istft(x, fft_length: int, hop_length, window, onesided=False):  # type: ign
         yc = _concat(left, ctmp, right, axis=-1)
 
         # imaginary part
-        sliced = _slice(ift, np.array(one), np.array(two), [n_dims_1])  # type: ignore
+        sliced = _slice(ift, np.array(one), np.array(two), [n_dims_1])
         itmp = np.squeeze(sliced, axis=n_dims_1)
         yi = _concat(left, itmp, right, axis=-1)
 
@@ -134,9 +134,9 @@ def _istft(x, fft_length: int, hop_length, window, onesided=False):  # type: ign
     redc = _concat_from_sequence(seqc, axis=-1, new_axis=0)
 
     # unweight
-    resr = redr.sum(axis=-1, keepdims=0)  # type: ignore
-    resi = redi.sum(axis=-1, keepdims=0)  # type: ignore
-    resc = redc.sum(axis=-1, keepdims=0)  # type: ignore
+    resr = redr.sum(axis=-1, keepdims=0)
+    resi = redi.sum(axis=-1, keepdims=0)
+    resc = redc.sum(axis=-1, keepdims=0)
     rr = resr / resc
     ri = resi / resc
 
@@ -156,7 +156,7 @@ def _istft(x, fft_length: int, hop_length, window, onesided=False):  # type: ign
 
 
 class STFT(OpRun):
-    def _run(self, x, frame_step, window=None, frame_length=None, onesided=None):  # type: ignore
+    def _run(self, x, frame_step, window=None, frame_length=None, onesided=None):
         if frame_length is None:
             if window is None:
                 frame_length = x.shape[-2]

onnx/reference/ops/op_string_normalizer.py

@@ -19,7 +19,7 @@ class StringNormalizer(OpRun):
     usually happens after this steps.
     """
 
-    def _run(  # type: ignore
+    def _run(
         self,
         x,
         case_change_action=None,
@@ -74,7 +74,7 @@ class StringNormalizer(OpRun):
         return (res,)
 
     @staticmethod
-    def _run_column(  # type: ignore
+    def _run_column(
         cin,
         cout,
         slocale=None,
@@ -122,12 +122,12 @@ class StringNormalizer(OpRun):
         return cout
 
     @staticmethod
-    def _remove_stopwords(text, stops):  # type: ignore
+    def _remove_stopwords(text, stops):
         spl = text.split(" ")
         return " ".join(filter(lambda s: s not in stops, spl))
 
     @staticmethod
-    def strip_accents_unicode(s):  # type: ignore
+    def strip_accents_unicode(s):
         """Transforms accentuated unicode symbols into their simple counterpart.
         Source: `sklearn/feature_extraction/text.py
         <https://github.com/scikit-learn/scikit-learn/blob/main/sklearn/

onnx/reference/ops/op_string_split.py

@@ -14,8 +14,10 @@ def pad_empty_string(
     split_lists: list | np.ndarray, padding_requirement: list | int
 ) -> list:
     if isinstance(split_lists, list):
+        assert isinstance(padding_requirement, int)
         return split_lists + ["" for _ in range(padding_requirement)]
     if isinstance(split_lists, np.ndarray):
+        assert isinstance(padding_requirement, list)
         return list(map(pad_empty_string, split_lists, padding_requirement))
     raise TypeError(f"Invalid array type '{type(split_lists)}'")
 

onnx/reference/ops/op_sub.py

@@ -9,5 +9,5 @@ from onnx.reference.ops._op import OpRunBinaryNumpy
 
 
 class Sub(OpRunBinaryNumpy):
-    def __init__(self, onnx_node, run_params):  # type: ignore
+    def __init__(self, onnx_node, run_params):
         OpRunBinaryNumpy.__init__(self, np.subtract, onnx_node, run_params)

onnx/reference/ops/op_sum.py

@@ -7,5 +7,5 @@ from onnx.reference.op_run import OpRun
 
 
 class Sum(OpRun):
-    def _run(self, *args):  # type: ignore
+    def _run(self, *args):
         return (sum(args).astype(args[0].dtype),)

onnx/reference/ops/op_swish.py

@@ -0,0 +1,14 @@
+# Copyright (c) ONNX Project Contributors
+
+# SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
+
+import numpy as np
+
+from onnx.reference.ops._op import OpRunUnaryNum
+
+
+class Swish(OpRunUnaryNum):
+    def _run(self, x, alpha=None):
+        alpha = self.alpha if alpha is None else alpha
+        return (x * (1 / (1 + np.exp(-alpha * x))).astype(x.dtype),)

onnx/reference/ops/op_tan.py

@@ -9,5 +9,5 @@ from onnx.reference.ops._op import OpRunUnaryNum
 
 
 class Tan(OpRunUnaryNum):
-    def _run(self, x):  # type: ignore
+    def _run(self, x):
         return (np.tan(x),)

onnx/reference/ops/op_tanh.py

@@ -9,5 +9,5 @@ from onnx.reference.ops._op import OpRunUnaryNum
 
 
 class Tanh(OpRunUnaryNum):
-    def _run(self, x):  # type: ignore
+    def _run(self, x):
         return (np.tanh(x),)