fix(pyright): microsoft/pyright#10924 ignore (#1370)

cmp0xff · web-flow · commit c38b6a3cbf02 · 2025-09-14T10:19:56.000-04:00
* fix: error comes from pyright

* chore: spelling
diff --git a/pandas-stubs/core/generic.pyi b/pandas-stubs/core/generic.pyi
@@ -430,6 +430,6 @@ class NDFrame(indexing.IndexingMixin):
         origin: TimeGrouperOrigin | TimestampConvertibleTypes = "start_day",
         offset: TimedeltaConvertibleTypes | None = None,
         group_keys: _bool = False,
-    ) -> DatetimeIndexResampler[Self]: ...
+    ) -> DatetimeIndexResampler[Self]: ...  # pyrefly: ignore[bad-specialization]
     @final
     def take(self, indices: TakeIndexer, axis: Axis = 0, **kwargs: Any) -> Self: ...
diff --git a/pandas-stubs/core/groupby/generic.pyi b/pandas-stubs/core/groupby/generic.pyi
@@ -229,7 +229,7 @@ class DFCallable3(Protocol[P]):  # ty: ignore[invalid-argument-type]
 class DataFrameGroupBy(GroupBy[DataFrame], Generic[ByT, _TT]):
     # error: Overload 3 for "apply" will never be used because its parameters overlap overload 1
     @overload  # type: ignore[override]
-    def apply(
+    def apply(  # pyrefly: ignore[bad-override]
         self,
         func: DFCallable1[P],
         /,
diff --git a/pandas-stubs/core/groupby/groupby.pyi b/pandas-stubs/core/groupby/groupby.pyi
@@ -255,7 +255,9 @@ class GroupBy(BaseGroupBy[NDFrameT]):
     def bfill(self, limit: int | None = ...) -> NDFrameT: ...
     @final
     @property
-    def nth(self) -> GroupByNthSelector[Self]: ...
+    def nth(
+        self,
+    ) -> GroupByNthSelector[Self]: ...  # pyrefly: ignore[bad-specialization]
     @final
     def quantile(
         self,
diff --git a/pandas-stubs/core/indexes/base.pyi b/pandas-stubs/core/indexes/base.pyi
@@ -279,7 +279,7 @@ class Index(IndexOpsMixin[S1]):
     @property
     def str(
         self,
-    ) -> StringMethods[
+    ) -> StringMethods[  # pyrefly: ignore[bad-specialization]
         Self,
         MultiIndex,
         np_1darray[np.bool],
diff --git a/pandas-stubs/core/series.pyi b/pandas-stubs/core/series.pyi
@@ -1198,7 +1198,7 @@ class Series(IndexOpsMixin[S1], NDFrame):
     @property
     def str(
         self,
-    ) -> StringMethods[
+    ) -> StringMethods[  # pyrefly: ignore[bad-specialization]
         Self,
         DataFrame,
         Series[bool],
diff --git a/pyproject.toml b/pyproject.toml
@@ -41,15 +41,15 @@ pandas = "2.3.2"
 pyarrow = ">=10.0.1"
 pytest = ">=7.1.2"
 pyright = ">=1.1.405"
-ty = "^0.0.1a9"
-pyrefly = "^0.21.0"
+ty = ">=0.0.1a20"
+pyrefly = ">=0.32.0"
 poethepoet = ">=0.16.5"
 loguru = ">=0.6.0"
 typing-extensions = ">=4.4.0"
 matplotlib = ">=3.10.1"
 pre-commit = ">=2.19.0"
-black = ">=23.3.0"
-isort = ">=5.12.0"
+black = ">=25.1.0"
+isort = ">=6.0.1"
 openpyxl = ">=3.0.10"
 tables = { version = ">=3.10.1", python = "<4" }
 lxml = ">=4.9.1"
diff --git a/tests/indexes/arithmetic/bool/test_add.py b/tests/indexes/arithmetic/bool/test_add.py
@@ -54,7 +54,7 @@ def test_add_numpy_array() -> None:
 
     # `numpy` typing gives the corresponding `ndarray`s in the static type
     # checking, where our `__radd__` cannot override. At runtime, they return
-    # `Index`s with the correct element type.
+    # `Index`es with the correct element type.
     check(assert_type(b + left, "npt.NDArray[np.bool_]"), pd.Index, np.bool_)
     check(assert_type(i + left, "npt.NDArray[np.int64]"), pd.Index, np.integer)
     check(assert_type(f + left, "npt.NDArray[np.float64]"), pd.Index, np.floating)
diff --git a/tests/indexes/arithmetic/bool/test_sub.py b/tests/indexes/arithmetic/bool/test_sub.py
@@ -63,7 +63,7 @@ def test_sub_numpy_array() -> None:
 
     # `numpy` typing gives the corresponding `ndarray`s in the static type
     # checking, where our `__rsub__` cannot override. At runtime, they return
-    # `Index`s with the correct element type.
+    # `Index`es with the correct element type.
     if TYPE_CHECKING_INVALID_USAGE:
         assert_type(b - left, Never)
     check(assert_type(i - left, "npt.NDArray[np.int64]"), pd.Index, np.integer)
diff --git a/tests/indexes/arithmetic/complex/test_add.py b/tests/indexes/arithmetic/complex/test_add.py
@@ -53,7 +53,7 @@ def test_add_numpy_array() -> None:
 
     # `numpy` typing gives the corresponding `ndarray`s in the static type
     # checking, where our `__radd__` cannot override. At runtime, they return
-    # `Index`s with the correct element type.
+    # `Index`es with the correct element type.
     check(assert_type(b + left, "npt.NDArray[np.bool_]"), pd.Index, np.complexfloating)
     check(assert_type(i + left, "npt.NDArray[np.int64]"), pd.Index, np.complexfloating)
     check(
diff --git a/tests/indexes/arithmetic/complex/test_sub.py b/tests/indexes/arithmetic/complex/test_sub.py
@@ -55,7 +55,7 @@ def test_sub_numpy_array() -> None:
 
     # `numpy` typing gives the corresponding `ndarray`s in the static type
     # checking, where our `__rsub__` cannot override. At runtime, they return
-    # `Index`s with the correct element type.
+    # `Index`es with the correct element type.
     check(assert_type(b - left, NoReturn), pd.Index, np.complexfloating)
     check(assert_type(i - left, "npt.NDArray[np.int64]"), pd.Index, np.complexfloating)
     check(
diff --git a/tests/indexes/arithmetic/float/test_add.py b/tests/indexes/arithmetic/float/test_add.py
@@ -53,7 +53,7 @@ def test_add_numpy_array() -> None:
 
     # `numpy` typing gives the corresponding `ndarray`s in the static type
     # checking, where our `__radd__` cannot override. At runtime, they return
-    # `Index`s with the correct element type.
+    # `Index`es with the correct element type.
     check(assert_type(b + left, "npt.NDArray[np.bool_]"), pd.Index, np.floating)
     check(assert_type(i + left, "npt.NDArray[np.int64]"), pd.Index, np.floating)
     check(assert_type(f + left, "npt.NDArray[np.float64]"), pd.Index, np.floating)
diff --git a/tests/indexes/arithmetic/float/test_sub.py b/tests/indexes/arithmetic/float/test_sub.py
@@ -55,7 +55,7 @@ def test_sub_numpy_array() -> None:
 
     # `numpy` typing gives the corresponding `ndarray`s in the static type
     # checking, where our `__rsub__` cannot override. At runtime, they return
-    # `Index`s with the correct element type.
+    # `Index`es with the correct element type.
     check(assert_type(b - left, NoReturn), pd.Index, np.floating)
     check(assert_type(i - left, "npt.NDArray[np.int64]"), pd.Index, np.floating)
     check(assert_type(f - left, "npt.NDArray[np.float64]"), pd.Index, np.floating)
diff --git a/tests/indexes/arithmetic/int/test_add.py b/tests/indexes/arithmetic/int/test_add.py
@@ -53,7 +53,7 @@ def test_add_numpy_array() -> None:
 
     # `numpy` typing gives the corresponding `ndarray`s in the static type
     # checking, where our `__radd__` cannot override. At runtime, they return
-    # `Index`s with the correct element type.
+    # `Index`es with the correct element type.
     check(assert_type(b + left, "npt.NDArray[np.bool_]"), pd.Index, np.integer)
     check(assert_type(i + left, "npt.NDArray[np.int64]"), pd.Index, np.integer)
     check(assert_type(f + left, "npt.NDArray[np.float64]"), pd.Index, np.floating)
diff --git a/tests/indexes/arithmetic/int/test_sub.py b/tests/indexes/arithmetic/int/test_sub.py
@@ -55,7 +55,7 @@ def test_sub_numpy_array() -> None:
 
     # `numpy` typing gives the corresponding `ndarray`s in the static type
     # checking, where our `__rsub__` cannot override. At runtime, they return
-    # `Index`s with the correct element type.
+    # `Index`es with the correct element type.
     check(assert_type(b - left, NoReturn), pd.Index, np.integer)
     check(assert_type(i - left, "npt.NDArray[np.int64]"), pd.Index, np.integer)
     check(assert_type(f - left, "npt.NDArray[np.float64]"), pd.Index, np.floating)
diff --git a/tests/indexes/arithmetic/str/test_add.py b/tests/indexes/arithmetic/str/test_add.py
@@ -59,13 +59,13 @@ def test_add_numpy_array() -> None:
 
     # `numpy` typing gives `npt.NDArray[np.int64]` in the static type
     # checking, where our `__radd__` cannot override. At runtime, they return
-    # `Index`s.
+    # `Index`es.
     if TYPE_CHECKING_INVALID_USAGE:
         assert_type(i + left, "npt.NDArray[np.int64]")
     if sys.version_info >= (3, 11):
         # `numpy` typing gives `npt.NDArray[np.int64]` in the static type
         # checking, where our `__radd__` cannot override. At runtime, they return
-        # `Index`s.
+        # `Index`es.
         check(assert_type(r0 + left, "npt.NDArray[np.str_]"), pd.Index, str)
     else:
         # Python 3.10 uses NumPy 2.2.6, and it has for r0 ndarray[tuple[int,...], dtype[str_]]
diff --git a/tests/indexes/arithmetic/test_add.py b/tests/indexes/arithmetic/test_add.py
@@ -1,5 +1,6 @@
+from typing import Any
+
 import numpy as np
-from numpy import typing as npt  # noqa: F401
 import pandas as pd
 from typing_extensions import (
     Never,
@@ -60,19 +61,23 @@ def test_add_i_numpy_array() -> None:
 
     # `numpy` typing gives the corresponding `ndarray`s in the static type
     # checking, where our `__radd__` cannot override. At runtime, they return
-    # `Index`s.
-    # `mypy` thinks the return types are `Any`, which is a bug.
+    # `Index`es.
+    # microsoft/pyright#10924
     check(
-        assert_type(b + left_i, "npt.NDArray[np.bool_]"), pd.Index  # type: ignore[assert-type]
+        assert_type(b + left_i, Any),  # pyright: ignore[reportAssertTypeFailure]
+        pd.Index,
     )
     check(
-        assert_type(i + left_i, "npt.NDArray[np.int64]"), pd.Index  # type: ignore[assert-type]
+        assert_type(i + left_i, Any),  # pyright: ignore[reportAssertTypeFailure]
+        pd.Index,
     )
     check(
-        assert_type(f + left_i, "npt.NDArray[np.float64]"), pd.Index  # type: ignore[assert-type]
+        assert_type(f + left_i, Any),  # pyright: ignore[reportAssertTypeFailure]
+        pd.Index,
     )
     check(
-        assert_type(c + left_i, "npt.NDArray[np.complex128]"), pd.Index  # type: ignore[assert-type]
+        assert_type(c + left_i, Any),  # pyright: ignore[reportAssertTypeFailure]
+        pd.Index,
     )
 
 
diff --git a/tests/indexes/arithmetic/test_sub.py b/tests/indexes/arithmetic/test_sub.py
@@ -1,7 +1,6 @@
-from typing import NoReturn
+from typing import Any
 
 import numpy as np
-from numpy import typing as npt  # noqa: F401
 import pandas as pd
 from typing_extensions import assert_type
 
@@ -58,17 +57,23 @@ def test_sub_i_numpy_array() -> None:
 
     # `numpy` typing gives the corresponding `ndarray`s in the static type
     # checking, where our `__rsub__` cannot override. At runtime, they return
-    # `Index`s.
-    # `mypy` thinks the return types are `Any`, which is a bug.
-    check(assert_type(b - left_i, NoReturn), pd.Index)  # type: ignore[assert-type]
+    # `Index`es.
+    # microsoft/pyright#10924
     check(
-        assert_type(i - left_i, "npt.NDArray[np.int64]"), pd.Index  # type: ignore[assert-type]
+        assert_type(b - left_i, Any),  # pyright: ignore[reportAssertTypeFailure]
+        pd.Index,
     )
     check(
-        assert_type(f - left_i, "npt.NDArray[np.float64]"), pd.Index  # type: ignore[assert-type]
+        assert_type(i - left_i, Any),  # pyright: ignore[reportAssertTypeFailure]
+        pd.Index,
     )
     check(
-        assert_type(c - left_i, "npt.NDArray[np.complex128]"), pd.Index  # type: ignore[assert-type]
+        assert_type(f - left_i, Any),  # pyright: ignore[reportAssertTypeFailure]
+        pd.Index,
+    )
+    check(
+        assert_type(c - left_i, Any),  # pyright: ignore[reportAssertTypeFailure]
+        pd.Index,
     )
 
 
diff --git a/tests/series/arithmetic/bool/test_add.py b/tests/series/arithmetic/bool/test_add.py
@@ -76,7 +76,7 @@ def test_add_numpy_array() -> None:
 
     # `numpy` typing gives the corresponding `ndarray`s in the static type
     # checking, where our `__radd__` cannot override. At runtime, they return
-    # `Series`s with the correct element type.
+    # `Series` with the correct element type.
     check(assert_type(b + left, "npt.NDArray[np.bool_]"), pd.Series, np.bool_)
     check(assert_type(i + left, "npt.NDArray[np.int64]"), pd.Series, np.integer)
     check(assert_type(f + left, "npt.NDArray[np.float64]"), pd.Series, np.floating)
diff --git a/tests/series/arithmetic/bool/test_mul.py b/tests/series/arithmetic/bool/test_mul.py
@@ -76,7 +76,7 @@ def test_mul_numpy_array() -> None:
 
     # `numpy` typing gives the corresponding `ndarray`s in the static type
     # checking, where our `__rmul__` cannot override. At runtime, they return
-    # `Series`s with the correct element type.
+    # `Series` with the correct element type.
     check(assert_type(b * left, "npt.NDArray[np.bool_]"), pd.Series, np.bool_)
     check(assert_type(i * left, "npt.NDArray[np.int64]"), pd.Series, np.integer)
     check(assert_type(f * left, "npt.NDArray[np.float64]"), pd.Series, np.floating)
diff --git a/tests/series/arithmetic/bool/test_sub.py b/tests/series/arithmetic/bool/test_sub.py
@@ -91,7 +91,7 @@ def test_sub_numpy_array() -> None:
 
     # `numpy` typing gives the corresponding `ndarray`s in the static type
     # checking, where our `__rsub__` cannot override. At runtime, they return
-    # `Series`s with the correct element type.
+    # `Series` with the correct element type.
     if TYPE_CHECKING_INVALID_USAGE:
         assert_type(b - left, Never)
     check(assert_type(i - left, "npt.NDArray[np.int64]"), pd.Series, np.integer)
diff --git a/tests/series/arithmetic/bool/test_truediv.py b/tests/series/arithmetic/bool/test_truediv.py
@@ -125,7 +125,7 @@ def test_truediv_numpy_array() -> None:
 
     # `numpy` typing gives the corresponding `ndarray`s in the static type
     # checking, where our `__rtruediv__` cannot override. At runtime, they return
-    # `Series`s with the correct element type.
+    # `Series` with the correct element type.
     if TYPE_CHECKING_INVALID_USAGE:
         assert_type(b / left, "npt.NDArray[np.float64]")
     check(assert_type(i / left, "npt.NDArray[np.float64]"), pd.Series, np.floating)
diff --git a/tests/series/arithmetic/complex/test_add.py b/tests/series/arithmetic/complex/test_add.py
@@ -88,7 +88,7 @@ def test_add_numpy_array() -> None:
 
     # `numpy` typing gives the corresponding `ndarray`s in the static type
     # checking, where our `__radd__` cannot override. At runtime, they return
-    # `Series`s with the correct element type.
+    # `Series` with the correct element type.
     check(assert_type(b + left, "npt.NDArray[np.bool_]"), pd.Series, np.complexfloating)
     check(assert_type(i + left, "npt.NDArray[np.int64]"), pd.Series, np.complexfloating)
     check(
diff --git a/tests/series/arithmetic/complex/test_mul.py b/tests/series/arithmetic/complex/test_mul.py
@@ -88,7 +88,7 @@ def test_mul_numpy_array() -> None:
 
     # `numpy` typing gives the corresponding `ndarray`s in the static type
     # checking, where our `__rmul__` cannot override. At runtime, they return
-    # `Series`s with the correct element type.
+    # `Series` with the correct element type.
     check(assert_type(b * left, "npt.NDArray[np.bool_]"), pd.Series, np.complexfloating)
     check(assert_type(i * left, "npt.NDArray[np.int64]"), pd.Series, np.complexfloating)
     check(
diff --git a/tests/series/arithmetic/complex/test_sub.py b/tests/series/arithmetic/complex/test_sub.py
@@ -90,7 +90,7 @@ def test_sub_numpy_array() -> None:
 
     # `numpy` typing gives the corresponding `ndarray`s in the static type
     # checking, where our `__rsub__` cannot override. At runtime, they return
-    # `Series`s with the correct element type.
+    # `Series` with the correct element type.
     check(assert_type(b - left, NoReturn), pd.Series, np.complexfloating)
     check(assert_type(i - left, "npt.NDArray[np.int64]"), pd.Series, np.complexfloating)
     check(
diff --git a/tests/series/arithmetic/complex/test_truediv.py b/tests/series/arithmetic/complex/test_truediv.py
@@ -172,7 +172,7 @@ def test_truediv_numpy_array() -> None:
 
     # `numpy` typing gives the corresponding `ndarray`s in the static type
     # checking, where our `__rtruediv__` cannot override. At runtime, they return
-    # `Series`s with the correct element type.
+    # `Series` with the correct element type.
     check(
         assert_type(b / left, "npt.NDArray[np.float64]"), pd.Series, np.complexfloating
     )
diff --git a/tests/series/arithmetic/float/test_add.py b/tests/series/arithmetic/float/test_add.py
@@ -76,7 +76,7 @@ def test_add_numpy_array() -> None:
 
     # `numpy` typing gives the corresponding `ndarray`s in the static type
     # checking, where our `__radd__` cannot override. At runtime, they return
-    # `Series`s with the correct element type.
+    # `Series` with the correct element type.
     check(assert_type(b + left, "npt.NDArray[np.bool_]"), pd.Series, np.floating)
     check(assert_type(i + left, "npt.NDArray[np.int64]"), pd.Series, np.floating)
     check(assert_type(f + left, "npt.NDArray[np.float64]"), pd.Series, np.floating)
diff --git a/tests/series/arithmetic/float/test_mul.py b/tests/series/arithmetic/float/test_mul.py
@@ -76,7 +76,7 @@ def test_mul_numpy_array() -> None:
 
     # `numpy` typing gives the corresponding `ndarray`s in the static type
     # checking, where our `__rmul__` cannot override. At runtime, they return
-    # `Series`s with the correct element type.
+    # `Series` with the correct element type.
     check(assert_type(b * left, "npt.NDArray[np.bool_]"), pd.Series, np.floating)
     check(assert_type(i * left, "npt.NDArray[np.int64]"), pd.Series, np.floating)
     check(assert_type(f * left, "npt.NDArray[np.float64]"), pd.Series, np.floating)
diff --git a/tests/series/arithmetic/float/test_sub.py b/tests/series/arithmetic/float/test_sub.py
@@ -78,7 +78,7 @@ def test_sub_numpy_array() -> None:
 
     # `numpy` typing gives the corresponding `ndarray`s in the static type
     # checking, where our `__rsub__` cannot override. At runtime, they return
-    # `Series`s with the correct element type.
+    # `Series` with the correct element type.
     check(assert_type(b - left, NoReturn), pd.Series, np.floating)
     check(assert_type(i - left, "npt.NDArray[np.int64]"), pd.Series, np.floating)
     check(assert_type(f - left, "npt.NDArray[np.float64]"), pd.Series, np.floating)
diff --git a/tests/series/arithmetic/float/test_truediv.py b/tests/series/arithmetic/float/test_truediv.py
@@ -112,7 +112,7 @@ def test_truediv_numpy_array() -> None:
 
     # `numpy` typing gives the corresponding `ndarray`s in the static type
     # checking, where our `__rtruediv__` cannot override. At runtime, they return
-    # `Series`s with the correct element type.
+    # `Series` with the correct element type.
     check(assert_type(b / left, "npt.NDArray[np.float64]"), pd.Series, np.floating)
     check(assert_type(i / left, "npt.NDArray[np.float64]"), pd.Series, np.floating)
     check(assert_type(f / left, "npt.NDArray[np.float64]"), pd.Series, np.floating)
diff --git a/tests/series/arithmetic/int/test_add.py b/tests/series/arithmetic/int/test_add.py
@@ -76,7 +76,7 @@ def test_add_numpy_array() -> None:
 
     # `numpy` typing gives the corresponding `ndarray`s in the static type
     # checking, where our `__radd__` cannot override. At runtime, they return
-    # `Series`s with the correct element type.
+    # `Series` with the correct element type.
     check(assert_type(b + left, "npt.NDArray[np.bool_]"), pd.Series, np.integer)
     check(assert_type(i + left, "npt.NDArray[np.int64]"), pd.Series, np.integer)
     check(assert_type(f + left, "npt.NDArray[np.float64]"), pd.Series, np.floating)
diff --git a/tests/series/arithmetic/int/test_mul.py b/tests/series/arithmetic/int/test_mul.py
@@ -76,7 +76,7 @@ def test_mul_numpy_array() -> None:
 
     # `numpy` typing gives the corresponding `ndarray`s in the static type
     # checking, where our `__rmul__` cannot override. At runtime, they return
-    # `Series`s with the correct element type.
+    # `Series` with the correct element type.
     check(assert_type(b * left, "npt.NDArray[np.bool_]"), pd.Series, np.integer)
     check(assert_type(i * left, "npt.NDArray[np.int64]"), pd.Series, np.integer)
     check(assert_type(f * left, "npt.NDArray[np.float64]"), pd.Series, np.floating)
diff --git a/tests/series/arithmetic/int/test_sub.py b/tests/series/arithmetic/int/test_sub.py
@@ -78,7 +78,7 @@ def test_sub_numpy_array() -> None:
 
     # `numpy` typing gives the corresponding `ndarray`s in the static type
     # checking, where our `__rsub__` cannot override. At runtime, they return
-    # `Series`s with the correct element type.
+    # `Series` with the correct element type.
     check(assert_type(b - left, NoReturn), pd.Series, np.integer)
     check(assert_type(i - left, "npt.NDArray[np.int64]"), pd.Series, np.integer)
     check(assert_type(f - left, "npt.NDArray[np.float64]"), pd.Series, np.floating)
diff --git a/tests/series/arithmetic/int/test_truediv.py b/tests/series/arithmetic/int/test_truediv.py
@@ -112,7 +112,7 @@ def test_truediv_numpy_array() -> None:
 
     # `numpy` typing gives the corresponding `ndarray`s in the static type
     # checking, where our `__rtruediv__` cannot override. At runtime, they return
-    # `Series`s with the correct element type.
+    # `Series` with the correct element type.
     check(assert_type(b / left, "npt.NDArray[np.float64]"), pd.Series, np.floating)
     check(assert_type(i / left, "npt.NDArray[np.float64]"), pd.Series, np.floating)
     check(assert_type(f / left, "npt.NDArray[np.float64]"), pd.Series, np.floating)
diff --git a/tests/series/arithmetic/str/test_add.py b/tests/series/arithmetic/str/test_add.py
@@ -77,13 +77,13 @@ def test_add_numpy_array() -> None:
 
     # `numpy` typing gives `npt.NDArray[np.int64]` in the static type
     # checking, where our `__radd__` cannot override. At runtime, they return
-    # `Series`s.
+    # `Series`.
     if TYPE_CHECKING_INVALID_USAGE:
         assert_type(i + left, "npt.NDArray[np.int64]")
     if sys.version_info >= (3, 11):
         # `numpy` typing gives `npt.NDArray[np.int64]` in the static type
         # checking, where our `__radd__` cannot override. At runtime, they return
-        # `Series`s.
+        # `Series`.
         check(assert_type(r0 + left, "npt.NDArray[np.str_]"), pd.Series, str)
     else:
         # Python 3.10 uses NumPy 2.2.6, and it has for r0 ndarray[tuple[int,...], dtype[str_]]
diff --git a/tests/series/arithmetic/test_add.py b/tests/series/arithmetic/test_add.py
diff --git a/tests/series/arithmetic/test_mul.py b/tests/series/arithmetic/test_mul.py
diff --git a/tests/series/arithmetic/test_sub.py b/tests/series/arithmetic/test_sub.py
diff --git a/tests/series/arithmetic/test_truediv.py b/tests/series/arithmetic/test_truediv.py
