From d91bebbf1cc562a46fc7d18af9e541213ddb5a95 Mon Sep 17 00:00:00 2001 From: cmp0xff Date: Mon, 11 Aug 2025 15:28:20 +0200 Subject: [PATCH 01/10] feat(series): truediv for bools --- pandas-stubs/core/series.pyi | 140 ++++++++++---- tests/series/arithmetic/bool/test_truediv.py | 175 ++++++++++++++++++ .../series/arithmetic/complex/test_truediv.py | 72 ++++++- tests/series/arithmetic/float/test_truediv.py | 6 +- tests/series/arithmetic/int/test_truediv.py | 30 ++- tests/series/arithmetic/test_truediv.py | 32 +++- 6 files changed, 408 insertions(+), 47 deletions(-) create mode 100644 tests/series/arithmetic/bool/test_truediv.py diff --git a/pandas-stubs/core/series.pyi b/pandas-stubs/core/series.pyi index d206adcb6..735749d2e 100644 --- a/pandas-stubs/core/series.pyi +++ b/pandas-stubs/core/series.pyi @@ -2097,27 +2097,48 @@ class Series(IndexOpsMixin[S1], NDFrame): def __sub__(self, other: num | _ListLike | Series) -> Series: ... @overload def __truediv__( - self: Series[Never], other: Scalar | _ListLike | Series + self: Series[Never], other: complex | _ListLike | Series ) -> Series: ... @overload def __truediv__(self, other: Series[Never]) -> Series: ... @overload def __truediv__( - self: Series[int], + self: Series[bool], other: int | Sequence[int] | np_ndarray_anyint | np_ndarray_float | Series[int], ) -> Series[float]: ... @overload def __truediv__( - self: Series[int], other: _T_COMPLEX | Sequence[_T_COMPLEX] | Series[_T_COMPLEX] + self: Series[bool], + other: _T_COMPLEX | Sequence[_T_COMPLEX] | Series[_T_COMPLEX], ) -> Series[_T_COMPLEX]: ... @overload def __truediv__( - self: Series[int], other: np_ndarray_complex - ) -> Series[complex]: ... + self: Series[int], + other: ( + _T_INT + | Sequence[_T_INT] + | np_ndarray_bool + | np_ndarray_anyint + | np_ndarray_float + | Series[_T_INT] + ), + ) -> Series[float]: ... + @overload + def __truediv__( + self: Series[int], + other: _T_COMPLEX | Sequence[_T_COMPLEX] | Series[_T_COMPLEX], + ) -> Series[_T_COMPLEX]: ... @overload def __truediv__( self: Series[float], - other: int | Sequence[int] | np_ndarray_anyint | np_ndarray_float | Series[int], + other: ( + _T_INT + | Sequence[_T_INT] + | np_ndarray_bool + | np_ndarray_anyint + | np_ndarray_float + | Series[_T_INT] + ), ) -> Series[float]: ... @overload def __truediv__( @@ -2126,7 +2147,7 @@ class Series(IndexOpsMixin[S1], NDFrame): ) -> Series[_T_COMPLEX]: ... @overload def __truediv__( - self: Series[float], other: np_ndarray_complex + self: Series[_T_COMPLEX], other: np_ndarray_complex ) -> Series[complex]: ... @overload def __truediv__( @@ -2134,9 +2155,9 @@ class Series(IndexOpsMixin[S1], NDFrame): other: ( _T_COMPLEX | Sequence[_T_COMPLEX] + | np_ndarray_bool | np_ndarray_anyint | np_ndarray_float - | np_ndarray_complex | Series[_T_COMPLEX] ), ) -> Series[complex]: ... @@ -2145,7 +2166,7 @@ class Series(IndexOpsMixin[S1], NDFrame): @overload def truediv( self: Series[Never], - other: Scalar | _ListLike | Series, + other: complex | _ListLike | Series, level: Level | None = None, fill_value: float | None = None, axis: AxisIndex = 0, @@ -2160,7 +2181,7 @@ class Series(IndexOpsMixin[S1], NDFrame): ) -> Series: ... @overload def truediv( - self: Series[int], + self: Series[bool], other: int | Sequence[int] | np_ndarray_anyint | np_ndarray_float | Series[int], level: Level | None = None, fill_value: float | None = None, @@ -2168,7 +2189,7 @@ class Series(IndexOpsMixin[S1], NDFrame): ) -> Series[float]: ... @overload def truediv( - self: Series[int], + self: Series[bool], other: _T_COMPLEX | Sequence[_T_COMPLEX] | Series[_T_COMPLEX], level: Level | None = None, fill_value: float | None = None, @@ -2177,11 +2198,26 @@ class Series(IndexOpsMixin[S1], NDFrame): @overload def truediv( self: Series[int], - other: np_ndarray_complex, + other: ( + _T_INT + | Sequence[_T_INT] + | np_ndarray_bool + | np_ndarray_anyint + | np_ndarray_float + | Series[_T_INT] + ), level: Level | None = None, fill_value: float | None = None, axis: AxisIndex = 0, - ) -> Series[complex]: ... + ) -> Series[float]: ... + @overload + def truediv( + self: Series[int], + other: _T_COMPLEX | Sequence[_T_COMPLEX] | Series[_T_COMPLEX], + level: Level | None = None, + fill_value: float | None = None, + axis: AxisIndex = 0, + ) -> Series[_T_COMPLEX]: ... @overload def truediv( self: Series[float], @@ -2200,7 +2236,7 @@ class Series(IndexOpsMixin[S1], NDFrame): ) -> Series[_T_COMPLEX]: ... @overload def truediv( - self: Series[float], + self: Series[_T_COMPLEX], other: np_ndarray_complex, level: Level | None = None, fill_value: float | None = None, @@ -2212,9 +2248,9 @@ class Series(IndexOpsMixin[S1], NDFrame): other: ( _T_COMPLEX | Sequence[_T_COMPLEX] + | np_ndarray_bool | np_ndarray_anyint | np_ndarray_float - | np_ndarray_complex | Series[_T_COMPLEX] ), level: Level | None = None, @@ -2231,20 +2267,31 @@ class Series(IndexOpsMixin[S1], NDFrame): ) -> Series: ... div = truediv @overload - def __rtruediv__(self: Series[Never], other: Scalar | _ListLike) -> Series: ... + def __rtruediv__(self: Series[Never], other: complex | _ListLike) -> Series: ... @overload def __rtruediv__( - self: Series[int], - other: int | Sequence[int] | np_ndarray_anyint | np_ndarray_float, + self: Series[bool], + other: _T_INT | Sequence[_T_INT] | np_ndarray_anyint | np_ndarray_float, ) -> Series[float]: ... @overload def __rtruediv__( - self: Series[int], other: _T_COMPLEX | Sequence[_T_COMPLEX] + self: Series[bool], other: _T_COMPLEX | Sequence[_T_COMPLEX] ) -> Series[_T_COMPLEX]: ... @overload def __rtruediv__( - self: Series[int], other: np_ndarray_complex - ) -> Series[complex]: ... + self: Series[int], + other: ( + _T_INT + | Sequence[_T_INT] + | np_ndarray_bool + | np_ndarray_anyint + | np_ndarray_float + ), + ) -> Series[float]: ... + @overload + def __rtruediv__( + self: Series[int], other: _T_COMPLEX | Sequence[_T_COMPLEX] + ) -> Series[_T_COMPLEX]: ... @overload def __rtruediv__( self: Series[float], @@ -2255,33 +2302,33 @@ class Series(IndexOpsMixin[S1], NDFrame): self: Series[float], other: _T_COMPLEX | Sequence[_T_COMPLEX] ) -> Series[_T_COMPLEX]: ... @overload - def __rtruediv__( - self: Series[float], other: np_ndarray_complex - ) -> Series[complex]: ... - @overload def __rtruediv__( self: Series[complex], other: ( _T_COMPLEX | Sequence[_T_COMPLEX] + | np_ndarray_bool | np_ndarray_anyint | np_ndarray_float - | np_ndarray_complex ), ) -> Series[complex]: ... @overload + def __rtruediv__( + self: Series[_T_COMPLEX], other: np_ndarray_complex + ) -> Series[complex]: ... + @overload def __rtruediv__(self, other: Path) -> Series: ... @overload def rtruediv( self: Series[Never], - other: Scalar | _ListLike | Series, + other: complex | _ListLike | Series, level: Level | None = None, fill_value: float | None = None, axis: AxisIndex = 0, ) -> Series: ... @overload def rtruediv( - self: Series[int], + self: Series[bool], other: int | Sequence[int] | np_ndarray_anyint | np_ndarray_float | Series[int], level: Level | None = None, fill_value: float | None = None, @@ -2289,7 +2336,7 @@ class Series(IndexOpsMixin[S1], NDFrame): ) -> Series[float]: ... @overload def rtruediv( - self: Series[int], + self: Series[bool], other: _T_COMPLEX | Sequence[_T_COMPLEX] | Series[_T_COMPLEX], level: Level | None = None, fill_value: float | None = None, @@ -2298,44 +2345,51 @@ class Series(IndexOpsMixin[S1], NDFrame): @overload def rtruediv( self: Series[int], - other: np_ndarray_complex, + other: ( + _T_INT + | Sequence[_T_INT] + | np_ndarray_bool + | np_ndarray_anyint + | np_ndarray_float + | Series[_T_INT] + ), level: Level | None = None, fill_value: float | None = None, axis: AxisIndex = 0, - ) -> Series[complex]: ... + ) -> Series[float]: ... @overload def rtruediv( - self: Series[float], - other: int | Sequence[int] | np_ndarray_anyint | np_ndarray_float | Series[int], + self: Series[int], + other: _T_COMPLEX | Sequence[_T_COMPLEX] | Series[_T_COMPLEX], level: Level | None = None, fill_value: float | None = None, axis: AxisIndex = 0, - ) -> Series[float]: ... + ) -> Series[_T_COMPLEX]: ... @overload def rtruediv( self: Series[float], - other: _T_COMPLEX | Sequence[_T_COMPLEX] | Series[_T_COMPLEX], + other: int | Sequence[int] | np_ndarray_anyint | np_ndarray_float | Series[int], level: Level | None = None, fill_value: float | None = None, axis: AxisIndex = 0, - ) -> Series[_T_COMPLEX]: ... + ) -> Series[float]: ... @overload def rtruediv( self: Series[float], - other: np_ndarray_complex, + other: _T_COMPLEX | Sequence[_T_COMPLEX] | Series[_T_COMPLEX], level: Level | None = None, fill_value: float | None = None, axis: AxisIndex = 0, - ) -> Series[complex]: ... + ) -> Series[_T_COMPLEX]: ... @overload def rtruediv( self: Series[complex], other: ( _T_COMPLEX | Sequence[_T_COMPLEX] + | np_ndarray_bool | np_ndarray_anyint | np_ndarray_float - | np_ndarray_complex | Series[_T_COMPLEX] ), level: Level | None = None, @@ -2343,6 +2397,14 @@ class Series(IndexOpsMixin[S1], NDFrame): axis: AxisIndex = 0, ) -> Series[complex]: ... @overload + def rtruediv( + self: Series[_T_COMPLEX], + other: np_ndarray_complex, + level: Level | None = None, + fill_value: float | None = None, + axis: AxisIndex = 0, + ) -> Series[complex]: ... + @overload def rtruediv( self, other: Path, diff --git a/tests/series/arithmetic/bool/test_truediv.py b/tests/series/arithmetic/bool/test_truediv.py new file mode 100644 index 000000000..e4b8cd0d8 --- /dev/null +++ b/tests/series/arithmetic/bool/test_truediv.py @@ -0,0 +1,175 @@ +import numpy as np +from numpy import typing as npt # noqa: F401 +import pandas as pd +from typing_extensions import assert_type + +from tests import check + +left = pd.Series([True, False, True]) # left operand + + +def test_truediv_py_scalar() -> None: + """Test pd.Series[bool] / Python native scalars""" + i, f, c = 1, 1.0, 1j + + check(assert_type(left / i, "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(left / f, "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(left / c, "pd.Series[complex]"), pd.Series, np.complexfloating) + + check(assert_type(i / left, "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(f / left, "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(c / left, "pd.Series[complex]"), pd.Series, np.complexfloating) + + check(assert_type(left.truediv(i), "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(left.truediv(f), "pd.Series[float]"), pd.Series, np.floating) + check( + assert_type(left.truediv(c), "pd.Series[complex]"), + pd.Series, + np.complexfloating, + ) + + check(assert_type(left.div(i), "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(left.div(f), "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(left.div(c), "pd.Series[complex]"), pd.Series, np.complexfloating) + + check(assert_type(left.rtruediv(i), "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(left.rtruediv(f), "pd.Series[float]"), pd.Series, np.floating) + check( + assert_type(left.rtruediv(c), "pd.Series[complex]"), + pd.Series, + np.complexfloating, + ) + + check(assert_type(left.rdiv(i), "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(left.rdiv(f), "pd.Series[float]"), pd.Series, np.floating) + check( + assert_type(left.rdiv(c), "pd.Series[complex]"), pd.Series, np.complexfloating + ) + + +def test_truediv_py_sequence() -> None: + """Test pd.Series[bool] / Python native sequence""" + i, f, c = [2, 3, 5], [1.0, 2.0, 3.0], [1j, 1j, 4j] + + check(assert_type(left / i, "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(left / f, "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(left / c, "pd.Series[complex]"), pd.Series, np.complexfloating) + + check(assert_type(i / left, "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(f / left, "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(c / left, "pd.Series[complex]"), pd.Series, np.complexfloating) + + check(assert_type(left.truediv(i), "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(left.truediv(f), "pd.Series[float]"), pd.Series, np.floating) + check( + assert_type(left.truediv(c), "pd.Series[complex]"), + pd.Series, + np.complexfloating, + ) + + check(assert_type(left.div(i), "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(left.div(f), "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(left.div(c), "pd.Series[complex]"), pd.Series, np.complexfloating) + + check(assert_type(left.rtruediv(i), "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(left.rtruediv(f), "pd.Series[float]"), pd.Series, np.floating) + check( + assert_type(left.rtruediv(c), "pd.Series[complex]"), + pd.Series, + np.complexfloating, + ) + + check(assert_type(left.rdiv(i), "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(left.rdiv(f), "pd.Series[float]"), pd.Series, np.floating) + check( + assert_type(left.rdiv(c), "pd.Series[complex]"), pd.Series, np.complexfloating + ) + + +def test_truediv_numpy_array() -> None: + """Test pd.Series[bool] / numpy array""" + i = np.array([2, 3, 5], np.int64) + f = np.array([1.0, 2.0, 3.0], np.float64) + c = np.array([1.1j, 2.2j, 4.1j], np.complex128) + + check(assert_type(left / i, "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(left / f, "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(left / c, "pd.Series[complex]"), pd.Series, np.complexfloating) + + # `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. + 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) + check( + assert_type(c / left, "npt.NDArray[np.complex128]"), + pd.Series, + np.complexfloating, + ) + + check(assert_type(left.truediv(i), "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(left.truediv(f), "pd.Series[float]"), pd.Series, np.floating) + check( + assert_type(left.truediv(c), "pd.Series[complex]"), + pd.Series, + np.complexfloating, + ) + + check(assert_type(left.div(i), "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(left.div(f), "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(left.div(c), "pd.Series[complex]"), pd.Series, np.complexfloating) + + check(assert_type(left.rtruediv(i), "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(left.rtruediv(f), "pd.Series[float]"), pd.Series, np.floating) + check( + assert_type(left.rtruediv(c), "pd.Series[complex]"), + pd.Series, + np.complexfloating, + ) + + check(assert_type(left.rdiv(i), "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(left.rdiv(f), "pd.Series[float]"), pd.Series, np.floating) + check( + assert_type(left.rdiv(c), "pd.Series[complex]"), pd.Series, np.complexfloating + ) + + +def test_truediv_pd_series() -> None: + """Test pd.Series[bool] / pandas series""" + i = pd.Series([2, 3, 5]) + f = pd.Series([1.0, 2.0, 3.0]) + c = pd.Series([1.1j, 2.2j, 4.1j]) + + check(assert_type(left / i, "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(left / f, "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(left / c, "pd.Series[complex]"), pd.Series, np.complexfloating) + + check(assert_type(i / left, "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(f / left, "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(c / left, "pd.Series[complex]"), pd.Series, np.complexfloating) + + check(assert_type(left.truediv(i), "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(left.truediv(f), "pd.Series[float]"), pd.Series, np.floating) + check( + assert_type(left.truediv(c), "pd.Series[complex]"), + pd.Series, + np.complexfloating, + ) + + check(assert_type(left.div(i), "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(left.div(f), "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(left.div(c), "pd.Series[complex]"), pd.Series, np.complexfloating) + + check(assert_type(left.rtruediv(i), "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(left.rtruediv(f), "pd.Series[float]"), pd.Series, np.floating) + check( + assert_type(left.rtruediv(c), "pd.Series[complex]"), + pd.Series, + np.complexfloating, + ) + + check(assert_type(left.rdiv(i), "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(left.rdiv(f), "pd.Series[float]"), pd.Series, np.floating) + check( + assert_type(left.rdiv(c), "pd.Series[complex]"), pd.Series, np.complexfloating + ) diff --git a/tests/series/arithmetic/complex/test_truediv.py b/tests/series/arithmetic/complex/test_truediv.py index 996541b8d..ddf3529d4 100644 --- a/tests/series/arithmetic/complex/test_truediv.py +++ b/tests/series/arithmetic/complex/test_truediv.py @@ -10,16 +10,23 @@ def test_truediv_py_scalar() -> None: """Test pd.Series[complex] / Python native scalars""" - i, f, c = 1, 1.0, 1j + b, i, f, c = True, 1, 1.0, 1j + check(assert_type(left / b, "pd.Series[complex]"), pd.Series, np.complexfloating) check(assert_type(left / i, "pd.Series[complex]"), pd.Series, np.complexfloating) check(assert_type(left / f, "pd.Series[complex]"), pd.Series, np.complexfloating) check(assert_type(left / c, "pd.Series[complex]"), pd.Series, np.complexfloating) + check(assert_type(b / left, "pd.Series[complex]"), pd.Series, np.complexfloating) check(assert_type(i / left, "pd.Series[complex]"), pd.Series, np.complexfloating) check(assert_type(f / left, "pd.Series[complex]"), pd.Series, np.complexfloating) check(assert_type(c / left, "pd.Series[complex]"), pd.Series, np.complexfloating) + check( + assert_type(left.truediv(b), "pd.Series[complex]"), + pd.Series, + np.complexfloating, + ) check( assert_type(left.truediv(i), "pd.Series[complex]"), pd.Series, @@ -36,10 +43,16 @@ def test_truediv_py_scalar() -> None: np.complexfloating, ) + check(assert_type(left.div(b), "pd.Series[complex]"), pd.Series, np.complexfloating) check(assert_type(left.div(i), "pd.Series[complex]"), pd.Series, np.complexfloating) check(assert_type(left.div(f), "pd.Series[complex]"), pd.Series, np.complexfloating) check(assert_type(left.div(c), "pd.Series[complex]"), pd.Series, np.complexfloating) + check( + assert_type(left.rtruediv(b), "pd.Series[complex]"), + pd.Series, + np.complexfloating, + ) check( assert_type(left.rtruediv(i), "pd.Series[complex]"), pd.Series, @@ -56,6 +69,9 @@ def test_truediv_py_scalar() -> None: np.complexfloating, ) + check( + assert_type(left.rdiv(b), "pd.Series[complex]"), pd.Series, np.complexfloating + ) check( assert_type(left.rdiv(i), "pd.Series[complex]"), pd.Series, np.complexfloating ) @@ -69,16 +85,23 @@ def test_truediv_py_scalar() -> None: def test_truediv_py_sequence() -> None: """Test pd.Series[complex] / Python native sequence""" - i, f, c = [2, 3, 5], [1.0, 2.0, 3.0], [1j, 1j, 4j] + b, i, f, c = [True, False, True], [2, 3, 5], [1.0, 2.0, 3.0], [1j, 1j, 4j] + check(assert_type(left / b, "pd.Series[complex]"), pd.Series, np.complexfloating) check(assert_type(left / i, "pd.Series[complex]"), pd.Series, np.complexfloating) check(assert_type(left / f, "pd.Series[complex]"), pd.Series, np.complexfloating) check(assert_type(left / c, "pd.Series[complex]"), pd.Series, np.complexfloating) + check(assert_type(b / left, "pd.Series[complex]"), pd.Series, np.complexfloating) check(assert_type(i / left, "pd.Series[complex]"), pd.Series, np.complexfloating) check(assert_type(f / left, "pd.Series[complex]"), pd.Series, np.complexfloating) check(assert_type(c / left, "pd.Series[complex]"), pd.Series, np.complexfloating) + check( + assert_type(left.truediv(b), "pd.Series[complex]"), + pd.Series, + np.complexfloating, + ) check( assert_type(left.truediv(i), "pd.Series[complex]"), pd.Series, @@ -95,10 +118,16 @@ def test_truediv_py_sequence() -> None: np.complexfloating, ) + check(assert_type(left.div(b), "pd.Series[complex]"), pd.Series, np.complexfloating) check(assert_type(left.div(i), "pd.Series[complex]"), pd.Series, np.complexfloating) check(assert_type(left.div(f), "pd.Series[complex]"), pd.Series, np.complexfloating) check(assert_type(left.div(c), "pd.Series[complex]"), pd.Series, np.complexfloating) + check( + assert_type(left.rtruediv(b), "pd.Series[complex]"), + pd.Series, + np.complexfloating, + ) check( assert_type(left.rtruediv(i), "pd.Series[complex]"), pd.Series, @@ -115,6 +144,9 @@ def test_truediv_py_sequence() -> None: np.complexfloating, ) + check( + assert_type(left.rdiv(b), "pd.Series[complex]"), pd.Series, np.complexfloating + ) check( assert_type(left.rdiv(i), "pd.Series[complex]"), pd.Series, np.complexfloating ) @@ -128,10 +160,12 @@ def test_truediv_py_sequence() -> None: def test_truediv_numpy_array() -> None: """Test pd.Series[complex] / numpy array""" + b = np.array([True, False, True], np.bool_) i = np.array([2, 3, 5], np.int64) f = np.array([1.0, 2.0, 3.0], np.float64) c = np.array([1.1j, 2.2j, 4.1j], np.complex128) + check(assert_type(left / b, "pd.Series[complex]"), pd.Series, np.complexfloating) check(assert_type(left / i, "pd.Series[complex]"), pd.Series, np.complexfloating) check(assert_type(left / f, "pd.Series[complex]"), pd.Series, np.complexfloating) check(assert_type(left / c, "pd.Series[complex]"), pd.Series, np.complexfloating) @@ -139,6 +173,9 @@ 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. + check( + assert_type(b / left, "npt.NDArray[np.float64]"), pd.Series, np.complexfloating + ) check( assert_type(i / left, "npt.NDArray[np.float64]"), pd.Series, np.complexfloating ) @@ -151,6 +188,11 @@ def test_truediv_numpy_array() -> None: np.complexfloating, ) + check( + assert_type(left.truediv(b), "pd.Series[complex]"), + pd.Series, + np.complexfloating, + ) check( assert_type(left.truediv(i), "pd.Series[complex]"), pd.Series, @@ -167,10 +209,16 @@ def test_truediv_numpy_array() -> None: np.complexfloating, ) + check(assert_type(left.div(b), "pd.Series[complex]"), pd.Series, np.complexfloating) check(assert_type(left.div(i), "pd.Series[complex]"), pd.Series, np.complexfloating) check(assert_type(left.div(f), "pd.Series[complex]"), pd.Series, np.complexfloating) check(assert_type(left.div(c), "pd.Series[complex]"), pd.Series, np.complexfloating) + check( + assert_type(left.rtruediv(b), "pd.Series[complex]"), + pd.Series, + np.complexfloating, + ) check( assert_type(left.rtruediv(i), "pd.Series[complex]"), pd.Series, @@ -187,6 +235,9 @@ def test_truediv_numpy_array() -> None: np.complexfloating, ) + check( + assert_type(left.rdiv(b), "pd.Series[complex]"), pd.Series, np.complexfloating + ) check( assert_type(left.rdiv(i), "pd.Series[complex]"), pd.Series, np.complexfloating ) @@ -200,18 +251,26 @@ def test_truediv_numpy_array() -> None: def test_truediv_pd_series() -> None: """Test pd.Series[complex] / pandas series""" + b = pd.Series([True, False, True]) i = pd.Series([2, 3, 5]) f = pd.Series([1.0, 2.0, 3.0]) c = pd.Series([1.1j, 2.2j, 4.1j]) + check(assert_type(left / b, "pd.Series[complex]"), pd.Series, np.complexfloating) check(assert_type(left / i, "pd.Series[complex]"), pd.Series, np.complexfloating) check(assert_type(left / f, "pd.Series[complex]"), pd.Series, np.complexfloating) check(assert_type(left / c, "pd.Series[complex]"), pd.Series, np.complexfloating) + check(assert_type(b / left, "pd.Series[complex]"), pd.Series, np.complexfloating) check(assert_type(i / left, "pd.Series[complex]"), pd.Series, np.complexfloating) check(assert_type(f / left, "pd.Series[complex]"), pd.Series, np.complexfloating) check(assert_type(c / left, "pd.Series[complex]"), pd.Series, np.complexfloating) + check( + assert_type(left.truediv(b), "pd.Series[complex]"), + pd.Series, + np.complexfloating, + ) check( assert_type(left.truediv(i), "pd.Series[complex]"), pd.Series, @@ -228,10 +287,16 @@ def test_truediv_pd_series() -> None: np.complexfloating, ) + check(assert_type(left.div(b), "pd.Series[complex]"), pd.Series, np.complexfloating) check(assert_type(left.div(i), "pd.Series[complex]"), pd.Series, np.complexfloating) check(assert_type(left.div(f), "pd.Series[complex]"), pd.Series, np.complexfloating) check(assert_type(left.div(c), "pd.Series[complex]"), pd.Series, np.complexfloating) + check( + assert_type(left.rtruediv(b), "pd.Series[complex]"), + pd.Series, + np.complexfloating, + ) check( assert_type(left.rtruediv(i), "pd.Series[complex]"), pd.Series, @@ -248,6 +313,9 @@ def test_truediv_pd_series() -> None: np.complexfloating, ) + check( + assert_type(left.rdiv(b), "pd.Series[complex]"), pd.Series, np.complexfloating + ) check( assert_type(left.rdiv(i), "pd.Series[complex]"), pd.Series, np.complexfloating ) diff --git a/tests/series/arithmetic/float/test_truediv.py b/tests/series/arithmetic/float/test_truediv.py index 2bb8c4824..80d283c68 100644 --- a/tests/series/arithmetic/float/test_truediv.py +++ b/tests/series/arithmetic/float/test_truediv.py @@ -10,7 +10,7 @@ def test_truediv_py_scalar() -> None: """Test pd.Series[float] / Python native scalars""" - i, f, c = 1, 1.0, 1j + b, i, f, c = True, 1, 1.0, 1j check(assert_type(left / i, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left / f, "pd.Series[float]"), pd.Series, np.floating) @@ -49,7 +49,7 @@ def test_truediv_py_scalar() -> None: def test_truediv_py_sequence() -> None: """Test pd.Series[float] / Python native sequence""" - i, f, c = [2, 3, 5], [1.0, 2.0, 3.0], [1j, 1j, 4j] + b, i, f, c = [True, False, True], [2, 3, 5], [1.0, 2.0, 3.0], [1j, 1j, 4j] check(assert_type(left / i, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left / f, "pd.Series[float]"), pd.Series, np.floating) @@ -88,6 +88,7 @@ def test_truediv_py_sequence() -> None: def test_truediv_numpy_array() -> None: """Test pd.Series[float] / numpy array""" + b = np.array([True, False, True], np.bool_) i = np.array([2, 3, 5], np.int64) f = np.array([1.0, 2.0, 3.0], np.float64) c = np.array([1.1j, 2.2j, 4.1j], np.complex128) @@ -136,6 +137,7 @@ def test_truediv_numpy_array() -> None: def test_truediv_pd_series() -> None: """Test pd.Series[float] / pandas series""" + b = pd.Series([True, False, True]) i = pd.Series([2, 3, 5]) f = pd.Series([1.0, 2.0, 3.0]) c = pd.Series([1.1j, 2.2j, 4.1j]) diff --git a/tests/series/arithmetic/int/test_truediv.py b/tests/series/arithmetic/int/test_truediv.py index 34e642e40..4f0785cc9 100644 --- a/tests/series/arithmetic/int/test_truediv.py +++ b/tests/series/arithmetic/int/test_truediv.py @@ -10,16 +10,19 @@ def test_truediv_py_scalar() -> None: """Test pd.Series[int] / Python native scalars""" - i, f, c = 1, 1.0, 1j + b, i, f, c = True, 1, 1.0, 1j + check(assert_type(left / b, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left / i, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left / f, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left / c, "pd.Series[complex]"), pd.Series, np.complexfloating) + check(assert_type(b / left, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(i / left, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(f / left, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(c / left, "pd.Series[complex]"), pd.Series, np.complexfloating) + check(assert_type(left.truediv(b), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.truediv(i), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.truediv(f), "pd.Series[float]"), pd.Series, np.floating) check( @@ -28,10 +31,12 @@ def test_truediv_py_scalar() -> None: np.complexfloating, ) + check(assert_type(left.div(b), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.div(i), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.div(f), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.div(c), "pd.Series[complex]"), pd.Series, np.complexfloating) + check(assert_type(left.rtruediv(b), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.rtruediv(i), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.rtruediv(f), "pd.Series[float]"), pd.Series, np.floating) check( @@ -40,6 +45,7 @@ def test_truediv_py_scalar() -> None: np.complexfloating, ) + check(assert_type(left.rdiv(b), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.rdiv(i), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.rdiv(f), "pd.Series[float]"), pd.Series, np.floating) check( @@ -49,16 +55,19 @@ def test_truediv_py_scalar() -> None: def test_truediv_py_sequence() -> None: """Test pd.Series[int] / Python native sequence""" - i, f, c = [2, 3, 5], [1.0, 2.0, 3.0], [1j, 1j, 4j] + b, i, f, c = [True, False, True], [2, 3, 5], [1.0, 2.0, 3.0], [1j, 1j, 4j] + check(assert_type(left / b, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left / i, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left / f, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left / c, "pd.Series[complex]"), pd.Series, np.complexfloating) + check(assert_type(b / left, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(i / left, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(f / left, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(c / left, "pd.Series[complex]"), pd.Series, np.complexfloating) + check(assert_type(left.truediv(b), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.truediv(i), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.truediv(f), "pd.Series[float]"), pd.Series, np.floating) check( @@ -67,10 +76,12 @@ def test_truediv_py_sequence() -> None: np.complexfloating, ) + check(assert_type(left.div(b), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.div(i), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.div(f), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.div(c), "pd.Series[complex]"), pd.Series, np.complexfloating) + check(assert_type(left.rtruediv(b), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.rtruediv(i), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.rtruediv(f), "pd.Series[float]"), pd.Series, np.floating) check( @@ -79,6 +90,7 @@ def test_truediv_py_sequence() -> None: np.complexfloating, ) + check(assert_type(left.rdiv(b), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.rdiv(i), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.rdiv(f), "pd.Series[float]"), pd.Series, np.floating) check( @@ -88,10 +100,12 @@ def test_truediv_py_sequence() -> None: def test_truediv_numpy_array() -> None: """Test pd.Series[int] / numpy array""" + b = np.array([True, False, True], np.bool_) i = np.array([2, 3, 5], np.int64) f = np.array([1.0, 2.0, 3.0], np.float64) c = np.array([1.1j, 2.2j, 4.1j], np.complex128) + check(assert_type(left / b, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left / i, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left / f, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left / c, "pd.Series[complex]"), pd.Series, np.complexfloating) @@ -99,6 +113,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. + 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) check( @@ -107,6 +122,7 @@ def test_truediv_numpy_array() -> None: np.complexfloating, ) + check(assert_type(left.truediv(b), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.truediv(i), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.truediv(f), "pd.Series[float]"), pd.Series, np.floating) check( @@ -115,10 +131,12 @@ def test_truediv_numpy_array() -> None: np.complexfloating, ) + check(assert_type(left.div(b), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.div(i), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.div(f), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.div(c), "pd.Series[complex]"), pd.Series, np.complexfloating) + check(assert_type(left.rtruediv(b), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.rtruediv(i), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.rtruediv(f), "pd.Series[float]"), pd.Series, np.floating) check( @@ -127,6 +145,7 @@ def test_truediv_numpy_array() -> None: np.complexfloating, ) + check(assert_type(left.rdiv(b), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.rdiv(i), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.rdiv(f), "pd.Series[float]"), pd.Series, np.floating) check( @@ -136,18 +155,22 @@ def test_truediv_numpy_array() -> None: def test_truediv_pd_series() -> None: """Test pd.Series[int] / pandas series""" + b = pd.Series([True, False, True]) i = pd.Series([2, 3, 5]) f = pd.Series([1.0, 2.0, 3.0]) c = pd.Series([1.1j, 2.2j, 4.1j]) + check(assert_type(left / b, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left / i, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left / f, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left / c, "pd.Series[complex]"), pd.Series, np.complexfloating) + check(assert_type(b / left, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(i / left, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(f / left, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(c / left, "pd.Series[complex]"), pd.Series, np.complexfloating) + check(assert_type(left.truediv(b), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.truediv(i), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.truediv(f), "pd.Series[float]"), pd.Series, np.floating) check( @@ -156,10 +179,12 @@ def test_truediv_pd_series() -> None: np.complexfloating, ) + check(assert_type(left.div(b), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.div(i), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.div(f), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.div(c), "pd.Series[complex]"), pd.Series, np.complexfloating) + check(assert_type(left.rtruediv(b), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.rtruediv(i), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.rtruediv(f), "pd.Series[float]"), pd.Series, np.floating) check( @@ -168,6 +193,7 @@ def test_truediv_pd_series() -> None: np.complexfloating, ) + check(assert_type(left.rdiv(b), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.rdiv(i), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.rdiv(f), "pd.Series[float]"), pd.Series, np.floating) check( diff --git a/tests/series/arithmetic/test_truediv.py b/tests/series/arithmetic/test_truediv.py index c5d5efaf7..155a0c0e7 100644 --- a/tests/series/arithmetic/test_truediv.py +++ b/tests/series/arithmetic/test_truediv.py @@ -15,28 +15,34 @@ def test_truediv_py_scalar() -> None: """Test pd.Series[Any] / Python native scalars""" - i, f, c = 1, 1.0, 1j + b, i, f, c = True, 1, 1.0, 1j + check(assert_type(left / b, pd.Series), pd.Series) check(assert_type(left / i, pd.Series), pd.Series) check(assert_type(left / f, pd.Series), pd.Series) check(assert_type(left / c, pd.Series), pd.Series) + check(assert_type(b / left, pd.Series), pd.Series) check(assert_type(i / left, pd.Series), pd.Series) check(assert_type(f / left, pd.Series), pd.Series) check(assert_type(c / left, pd.Series), pd.Series) + check(assert_type(left.truediv(b), pd.Series), pd.Series) check(assert_type(left.truediv(i), pd.Series), pd.Series) check(assert_type(left.truediv(f), pd.Series), pd.Series) check(assert_type(left.truediv(c), pd.Series), pd.Series) + check(assert_type(left.div(b), pd.Series), pd.Series) check(assert_type(left.div(i), pd.Series), pd.Series) check(assert_type(left.div(f), pd.Series), pd.Series) check(assert_type(left.div(c), pd.Series), pd.Series) + check(assert_type(left.rtruediv(b), pd.Series), pd.Series) check(assert_type(left.rtruediv(i), pd.Series), pd.Series) check(assert_type(left.rtruediv(f), pd.Series), pd.Series) check(assert_type(left.rtruediv(c), pd.Series), pd.Series) + check(assert_type(left.rdiv(b), pd.Series), pd.Series) check(assert_type(left.rdiv(i), pd.Series), pd.Series) check(assert_type(left.rdiv(f), pd.Series), pd.Series) check(assert_type(left.rdiv(c), pd.Series), pd.Series) @@ -44,28 +50,34 @@ def test_truediv_py_scalar() -> None: def test_truediv_py_sequence() -> None: """Test pd.Series[Any] / Python native sequence""" - i, f, c = [2, 3, 5], [1.0, 2.0, 3.0], [1j, 1j, 4j] + b, i, f, c = [True, False, True], [2, 3, 5], [1.0, 2.0, 3.0], [1j, 1j, 4j] + check(assert_type(left / b, pd.Series), pd.Series) check(assert_type(left / i, pd.Series), pd.Series) check(assert_type(left / f, pd.Series), pd.Series) check(assert_type(left / c, pd.Series), pd.Series) + check(assert_type(b / left, pd.Series), pd.Series) check(assert_type(i / left, pd.Series), pd.Series) check(assert_type(f / left, pd.Series), pd.Series) check(assert_type(c / left, pd.Series), pd.Series) + check(assert_type(left.truediv(b), pd.Series), pd.Series) check(assert_type(left.truediv(i), pd.Series), pd.Series) check(assert_type(left.truediv(f), pd.Series), pd.Series) check(assert_type(left.truediv(c), pd.Series), pd.Series) + check(assert_type(left.div(b), pd.Series), pd.Series) check(assert_type(left.div(i), pd.Series), pd.Series) check(assert_type(left.div(f), pd.Series), pd.Series) check(assert_type(left.div(c), pd.Series), pd.Series) + check(assert_type(left.rtruediv(b), pd.Series), pd.Series) check(assert_type(left.rtruediv(i), pd.Series), pd.Series) check(assert_type(left.rtruediv(f), pd.Series), pd.Series) check(assert_type(left.rtruediv(c), pd.Series), pd.Series) + check(assert_type(left.rdiv(b), pd.Series), pd.Series) check(assert_type(left.rdiv(i), pd.Series), pd.Series) check(assert_type(left.rdiv(f), pd.Series), pd.Series) check(assert_type(left.rdiv(c), pd.Series), pd.Series) @@ -73,10 +85,12 @@ def test_truediv_py_sequence() -> None: def test_truediv_numpy_array() -> None: """Test pd.Series[Any] / numpy array""" + b = np.array([True, False, True], np.bool_) i = np.array([2, 3, 5], np.int64) f = np.array([1.0, 2.0, 3.0], np.float64) c = np.array([1.1j, 2.2j, 4.1j], np.complex64) + check(assert_type(left / b, pd.Series), pd.Series) check(assert_type(left / i, pd.Series), pd.Series) check(assert_type(left / f, pd.Series), pd.Series) check(assert_type(left / c, pd.Series), pd.Series) @@ -85,6 +99,9 @@ def test_truediv_numpy_array() -> None: # checking, where our `__rtruediv__` cannot override. At runtime, they return # `Series`s. # `mypy` thinks the return types are `Any`, which is a bug. + check( + assert_type(b / left, "npt.NDArray[np.float64]"), pd.Series # type: ignore[assert-type] + ) check( assert_type(i / left, "npt.NDArray[np.float64]"), pd.Series # type: ignore[assert-type] ) @@ -95,18 +112,22 @@ def test_truediv_numpy_array() -> None: assert_type(c / left, "npt.NDArray[np.complex128]"), pd.Series # type: ignore[assert-type] ) + check(assert_type(left.truediv(b), pd.Series), pd.Series) check(assert_type(left.truediv(i), pd.Series), pd.Series) check(assert_type(left.truediv(f), pd.Series), pd.Series) check(assert_type(left.truediv(c), pd.Series), pd.Series) + check(assert_type(left.div(b), pd.Series), pd.Series) check(assert_type(left.div(i), pd.Series), pd.Series) check(assert_type(left.div(f), pd.Series), pd.Series) check(assert_type(left.div(c), pd.Series), pd.Series) + check(assert_type(left.rtruediv(b), pd.Series), pd.Series) check(assert_type(left.rtruediv(i), pd.Series), pd.Series) check(assert_type(left.rtruediv(f), pd.Series), pd.Series) check(assert_type(left.rtruediv(c), pd.Series), pd.Series) + check(assert_type(left.rdiv(b), pd.Series), pd.Series) check(assert_type(left.rdiv(i), pd.Series), pd.Series) check(assert_type(left.rdiv(f), pd.Series), pd.Series) check(assert_type(left.rdiv(c), pd.Series), pd.Series) @@ -114,30 +135,37 @@ def test_truediv_numpy_array() -> None: def test_truediv_pd_series() -> None: """Test pd.Series[Any] / pandas series""" + b = pd.Series([True, False, True]) i = pd.Series([2, 3, 5]) f = pd.Series([1.0, 2.0, 3.0]) c = pd.Series([1.1j, 2.2j, 4.1j]) + check(assert_type(left / b, pd.Series), pd.Series) check(assert_type(left / i, pd.Series), pd.Series) check(assert_type(left / f, pd.Series), pd.Series) check(assert_type(left / c, pd.Series), pd.Series) + check(assert_type(b / left, pd.Series), pd.Series) check(assert_type(i / left, pd.Series), pd.Series) check(assert_type(f / left, pd.Series), pd.Series) check(assert_type(c / left, pd.Series), pd.Series) + check(assert_type(left.truediv(b), pd.Series), pd.Series) check(assert_type(left.truediv(i), pd.Series), pd.Series) check(assert_type(left.truediv(f), pd.Series), pd.Series) check(assert_type(left.truediv(c), pd.Series), pd.Series) + check(assert_type(left.div(b), pd.Series), pd.Series) check(assert_type(left.div(i), pd.Series), pd.Series) check(assert_type(left.div(f), pd.Series), pd.Series) check(assert_type(left.div(c), pd.Series), pd.Series) + check(assert_type(left.rtruediv(b), pd.Series), pd.Series) check(assert_type(left.rtruediv(i), pd.Series), pd.Series) check(assert_type(left.rtruediv(f), pd.Series), pd.Series) check(assert_type(left.rtruediv(c), pd.Series), pd.Series) + check(assert_type(left.rdiv(b), pd.Series), pd.Series) check(assert_type(left.rdiv(i), pd.Series), pd.Series) check(assert_type(left.rdiv(f), pd.Series), pd.Series) check(assert_type(left.rdiv(c), pd.Series), pd.Series) From effc25220e33589572763b4b6d702390d1cf54ae Mon Sep 17 00:00:00 2001 From: cmp0xff Date: Tue, 12 Aug 2025 10:25:26 +0200 Subject: [PATCH 02/10] fix(comment): with unwanted ignores https://github.com/pandas-dev/pandas-stubs/pull/1314#discussion_r2267377904 https://github.com/pandas-dev/pandas-stubs/pull/1314#discussion_r2267389070 https://github.com/pandas-dev/pandas-stubs/pull/1314#discussion_r2267390732 --- pandas-stubs/core/series.pyi | 57 ++++++++++++++------ tests/series/arithmetic/bool/test_truediv.py | 55 +++++++++++++++++-- tests/series/arithmetic/test_truediv.py | 2 +- tests/series/test_series.py | 2 +- 4 files changed, 96 insertions(+), 20 deletions(-) diff --git a/pandas-stubs/core/series.pyi b/pandas-stubs/core/series.pyi index 735749d2e..68a73f983 100644 --- a/pandas-stubs/core/series.pyi +++ b/pandas-stubs/core/series.pyi @@ -188,6 +188,7 @@ from pandas.core.dtypes.dtypes import CategoricalDtype from pandas.plotting import PlotAccessor +_T_NUM_NON_BOOL = TypeVar("_T_NUM_NON_BOOL", int, float, complex) _T_INT = TypeVar("_T_INT", bound=int) _T_COMPLEX = TypeVar("_T_COMPLEX", bound=complex) @@ -2100,17 +2101,22 @@ class Series(IndexOpsMixin[S1], NDFrame): self: Series[Never], other: complex | _ListLike | Series ) -> Series: ... @overload - def __truediv__(self, other: Series[Never]) -> Series: ... + def __truediv__(self, other: Series[Never]) -> Series: ... # type: ignore[overload-overlap] + @overload + def __truediv__( + self: Series[bool], + other: bool | np_ndarray_bool | Series[bool], + ) -> Never: ... @overload def __truediv__( self: Series[bool], other: int | Sequence[int] | np_ndarray_anyint | np_ndarray_float | Series[int], ) -> Series[float]: ... @overload - def __truediv__( + def __truediv__( # type: ignore[overload-overlap] self: Series[bool], - other: _T_COMPLEX | Sequence[_T_COMPLEX] | Series[_T_COMPLEX], - ) -> Series[_T_COMPLEX]: ... + other: _T_NUM_NON_BOOL | Sequence[_T_NUM_NON_BOOL] | Series[_T_NUM_NON_BOOL], + ) -> Series[_T_NUM_NON_BOOL]: ... @overload def __truediv__( self: Series[int], @@ -2172,7 +2178,7 @@ class Series(IndexOpsMixin[S1], NDFrame): axis: AxisIndex = 0, ) -> Series: ... @overload - def truediv( + def truediv( # type: ignore[overload-overlap] self, other: Series[Never], level: Level | None = None, @@ -2180,6 +2186,14 @@ class Series(IndexOpsMixin[S1], NDFrame): axis: AxisIndex = 0, ) -> Series: ... @overload + def truediv( + self: Series[bool], + other: bool | np_ndarray_bool | Series[bool], + level: Level | None = None, + fill_value: float | None = None, + axis: AxisIndex = 0, + ) -> Never: ... + @overload def truediv( self: Series[bool], other: int | Sequence[int] | np_ndarray_anyint | np_ndarray_float | Series[int], @@ -2188,13 +2202,13 @@ class Series(IndexOpsMixin[S1], NDFrame): axis: AxisIndex = 0, ) -> Series[float]: ... @overload - def truediv( + def truediv( # type: ignore[overload-overlap] self: Series[bool], - other: _T_COMPLEX | Sequence[_T_COMPLEX] | Series[_T_COMPLEX], + other: _T_NUM_NON_BOOL | Sequence[_T_NUM_NON_BOOL] | Series[_T_NUM_NON_BOOL], level: Level | None = None, fill_value: float | None = None, axis: AxisIndex = 0, - ) -> Series[_T_COMPLEX]: ... + ) -> Series[_T_NUM_NON_BOOL]: ... @overload def truediv( self: Series[int], @@ -2271,12 +2285,17 @@ class Series(IndexOpsMixin[S1], NDFrame): @overload def __rtruediv__( self: Series[bool], - other: _T_INT | Sequence[_T_INT] | np_ndarray_anyint | np_ndarray_float, - ) -> Series[float]: ... + other: bool | np_ndarray_bool, + ) -> Never: ... @overload def __rtruediv__( - self: Series[bool], other: _T_COMPLEX | Sequence[_T_COMPLEX] - ) -> Series[_T_COMPLEX]: ... + self: Series[bool], + other: int | Sequence[int] | np_ndarray_anyint | np_ndarray_float, + ) -> Series[float]: ... + @overload + def __rtruediv__( # type: ignore[overload-overlap] + self: Series[bool], other: _T_NUM_NON_BOOL | Sequence[_T_NUM_NON_BOOL] + ) -> Series[_T_NUM_NON_BOOL]: ... @overload def __rtruediv__( self: Series[int], @@ -2327,6 +2346,14 @@ class Series(IndexOpsMixin[S1], NDFrame): axis: AxisIndex = 0, ) -> Series: ... @overload + def rtruediv( + self: Series[bool], + other: bool | np_ndarray_bool | Series[bool], + level: Level | None = None, + fill_value: float | None = None, + axis: AxisIndex = 0, + ) -> Never: ... + @overload def rtruediv( self: Series[bool], other: int | Sequence[int] | np_ndarray_anyint | np_ndarray_float | Series[int], @@ -2335,13 +2362,13 @@ class Series(IndexOpsMixin[S1], NDFrame): axis: AxisIndex = 0, ) -> Series[float]: ... @overload - def rtruediv( + def rtruediv( # type: ignore[overload-overlap] self: Series[bool], - other: _T_COMPLEX | Sequence[_T_COMPLEX] | Series[_T_COMPLEX], + other: _T_NUM_NON_BOOL | Sequence[_T_NUM_NON_BOOL] | Series[_T_NUM_NON_BOOL], level: Level | None = None, fill_value: float | None = None, axis: AxisIndex = 0, - ) -> Series[_T_COMPLEX]: ... + ) -> Series[_T_NUM_NON_BOOL]: ... @overload def rtruediv( self: Series[int], diff --git a/tests/series/arithmetic/bool/test_truediv.py b/tests/series/arithmetic/bool/test_truediv.py index e4b8cd0d8..b00a42dd8 100644 --- a/tests/series/arithmetic/bool/test_truediv.py +++ b/tests/series/arithmetic/bool/test_truediv.py @@ -1,25 +1,36 @@ +from typing import Never + import numpy as np from numpy import typing as npt # noqa: F401 import pandas as pd from typing_extensions import assert_type -from tests import check +from tests import ( + TYPE_CHECKING_INVALID_USAGE, + check, +) left = pd.Series([True, False, True]) # left operand def test_truediv_py_scalar() -> None: """Test pd.Series[bool] / Python native scalars""" - i, f, c = 1, 1.0, 1j + b, i, f, c = True, 1, 1.0, 1j + if TYPE_CHECKING_INVALID_USAGE: + assert_type(left / b, Never) check(assert_type(left / i, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left / f, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left / c, "pd.Series[complex]"), pd.Series, np.complexfloating) + if TYPE_CHECKING_INVALID_USAGE: + assert_type(b / left, Never) check(assert_type(i / left, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(f / left, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(c / left, "pd.Series[complex]"), pd.Series, np.complexfloating) + if TYPE_CHECKING_INVALID_USAGE: + assert_type(left.truediv(b), Never) check(assert_type(left.truediv(i), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.truediv(f), "pd.Series[float]"), pd.Series, np.floating) check( @@ -28,10 +39,14 @@ def test_truediv_py_scalar() -> None: np.complexfloating, ) + if TYPE_CHECKING_INVALID_USAGE: + assert_type(left.div(b), Never) check(assert_type(left.div(i), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.div(f), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.div(c), "pd.Series[complex]"), pd.Series, np.complexfloating) + if TYPE_CHECKING_INVALID_USAGE: + assert_type(left.rtruediv(b), Never) check(assert_type(left.rtruediv(i), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.rtruediv(f), "pd.Series[float]"), pd.Series, np.floating) check( @@ -40,6 +55,8 @@ def test_truediv_py_scalar() -> None: np.complexfloating, ) + if TYPE_CHECKING_INVALID_USAGE: + assert_type(left.rdiv(b), Never) check(assert_type(left.rdiv(i), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.rdiv(f), "pd.Series[float]"), pd.Series, np.floating) check( @@ -49,16 +66,19 @@ def test_truediv_py_scalar() -> None: def test_truediv_py_sequence() -> None: """Test pd.Series[bool] / Python native sequence""" - i, f, c = [2, 3, 5], [1.0, 2.0, 3.0], [1j, 1j, 4j] + b, i, f, c = [True, False, True], [2, 3, 5], [1.0, 2.0, 3.0], [1j, 1j, 4j] + check(assert_type(left / b, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left / i, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left / f, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left / c, "pd.Series[complex]"), pd.Series, np.complexfloating) + check(assert_type(b / left, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(i / left, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(f / left, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(c / left, "pd.Series[complex]"), pd.Series, np.complexfloating) + check(assert_type(left.truediv(b), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.truediv(i), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.truediv(f), "pd.Series[float]"), pd.Series, np.floating) check( @@ -67,10 +87,12 @@ def test_truediv_py_sequence() -> None: np.complexfloating, ) + check(assert_type(left.div(b), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.div(i), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.div(f), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.div(c), "pd.Series[complex]"), pd.Series, np.complexfloating) + check(assert_type(left.rtruediv(b), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.rtruediv(i), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.rtruediv(f), "pd.Series[float]"), pd.Series, np.floating) check( @@ -79,6 +101,7 @@ def test_truediv_py_sequence() -> None: np.complexfloating, ) + check(assert_type(left.rdiv(b), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.rdiv(i), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.rdiv(f), "pd.Series[float]"), pd.Series, np.floating) check( @@ -88,10 +111,13 @@ def test_truediv_py_sequence() -> None: def test_truediv_numpy_array() -> None: """Test pd.Series[bool] / numpy array""" + b = np.array([True, False, True], np.bool_) i = np.array([2, 3, 5], np.int64) f = np.array([1.0, 2.0, 3.0], np.float64) c = np.array([1.1j, 2.2j, 4.1j], np.complex128) + if TYPE_CHECKING_INVALID_USAGE: + assert_type(left / b, Never) check(assert_type(left / i, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left / f, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left / c, "pd.Series[complex]"), pd.Series, np.complexfloating) @@ -99,6 +125,8 @@ 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. + 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) check(assert_type(f / left, "npt.NDArray[np.float64]"), pd.Series, np.floating) check( @@ -107,6 +135,8 @@ def test_truediv_numpy_array() -> None: np.complexfloating, ) + if TYPE_CHECKING_INVALID_USAGE: + assert_type(left.truediv(b), Never) check(assert_type(left.truediv(i), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.truediv(f), "pd.Series[float]"), pd.Series, np.floating) check( @@ -115,10 +145,14 @@ def test_truediv_numpy_array() -> None: np.complexfloating, ) + if TYPE_CHECKING_INVALID_USAGE: + assert_type(left.div(b), Never) check(assert_type(left.div(i), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.div(f), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.div(c), "pd.Series[complex]"), pd.Series, np.complexfloating) + if TYPE_CHECKING_INVALID_USAGE: + assert_type(left.rtruediv(b), Never) check(assert_type(left.rtruediv(i), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.rtruediv(f), "pd.Series[float]"), pd.Series, np.floating) check( @@ -127,6 +161,8 @@ def test_truediv_numpy_array() -> None: np.complexfloating, ) + if TYPE_CHECKING_INVALID_USAGE: + assert_type(left.rdiv(b), Never) check(assert_type(left.rdiv(i), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.rdiv(f), "pd.Series[float]"), pd.Series, np.floating) check( @@ -136,18 +172,25 @@ def test_truediv_numpy_array() -> None: def test_truediv_pd_series() -> None: """Test pd.Series[bool] / pandas series""" + b = pd.Series([True, False, True]) i = pd.Series([2, 3, 5]) f = pd.Series([1.0, 2.0, 3.0]) c = pd.Series([1.1j, 2.2j, 4.1j]) + if TYPE_CHECKING_INVALID_USAGE: + assert_type(left / b, Never) check(assert_type(left / i, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left / f, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left / c, "pd.Series[complex]"), pd.Series, np.complexfloating) + if TYPE_CHECKING_INVALID_USAGE: + assert_type(b / left, Never) check(assert_type(i / left, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(f / left, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(c / left, "pd.Series[complex]"), pd.Series, np.complexfloating) + if TYPE_CHECKING_INVALID_USAGE: + assert_type(left.truediv(b), Never) check(assert_type(left.truediv(i), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.truediv(f), "pd.Series[float]"), pd.Series, np.floating) check( @@ -156,10 +199,14 @@ def test_truediv_pd_series() -> None: np.complexfloating, ) + if TYPE_CHECKING_INVALID_USAGE: + assert_type(left.div(b), Never) check(assert_type(left.div(i), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.div(f), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.div(c), "pd.Series[complex]"), pd.Series, np.complexfloating) + if TYPE_CHECKING_INVALID_USAGE: + assert_type(left.rtruediv(b), Never) check(assert_type(left.rtruediv(i), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.rtruediv(f), "pd.Series[float]"), pd.Series, np.floating) check( @@ -168,6 +215,8 @@ def test_truediv_pd_series() -> None: np.complexfloating, ) + if TYPE_CHECKING_INVALID_USAGE: + assert_type(left.rdiv(b), Never) check(assert_type(left.rdiv(i), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.rdiv(f), "pd.Series[float]"), pd.Series, np.floating) check( diff --git a/tests/series/arithmetic/test_truediv.py b/tests/series/arithmetic/test_truediv.py index 155a0c0e7..f1e95633b 100644 --- a/tests/series/arithmetic/test_truediv.py +++ b/tests/series/arithmetic/test_truediv.py @@ -145,7 +145,7 @@ def test_truediv_pd_series() -> None: check(assert_type(left / f, pd.Series), pd.Series) check(assert_type(left / c, pd.Series), pd.Series) - check(assert_type(b / left, pd.Series), pd.Series) + check(assert_type(b / left, pd.Series), pd.Series) # type: ignore[assert-type] check(assert_type(i / left, pd.Series), pd.Series) check(assert_type(f / left, pd.Series), pd.Series) check(assert_type(c / left, pd.Series), pd.Series) diff --git a/tests/series/test_series.py b/tests/series/test_series.py index 4d1486dcc..7029ffd2b 100644 --- a/tests/series/test_series.py +++ b/tests/series/test_series.py @@ -1607,7 +1607,7 @@ def test_series_min_max_sub_axis() -> None: check(assert_type(sa, pd.Series), pd.Series) check(assert_type(ss, pd.Series), pd.Series) check(assert_type(sm, pd.Series), pd.Series) - check(assert_type(sd, pd.Series), pd.Series) + check(assert_type(sd, pd.Series), pd.Series) # type: ignore[assert-type] def test_series_index_isin() -> None: From c823f217db0a4508d43286141cbf0799e254a86f Mon Sep 17 00:00:00 2001 From: cmp0xff Date: Tue, 12 Aug 2025 10:29:32 +0200 Subject: [PATCH 03/10] fix(import): python 3.10 --- tests/series/arithmetic/bool/test_truediv.py | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/tests/series/arithmetic/bool/test_truediv.py b/tests/series/arithmetic/bool/test_truediv.py index b00a42dd8..9e9e266e0 100644 --- a/tests/series/arithmetic/bool/test_truediv.py +++ b/tests/series/arithmetic/bool/test_truediv.py @@ -1,9 +1,10 @@ -from typing import Never - import numpy as np from numpy import typing as npt # noqa: F401 import pandas as pd -from typing_extensions import assert_type +from typing_extensions import ( + Never, + assert_type, +) from tests import ( TYPE_CHECKING_INVALID_USAGE, From d57ec7a665731dda043cb4616ae310558f37899a Mon Sep 17 00:00:00 2001 From: cmp0xff Date: Tue, 12 Aug 2025 15:51:25 +0200 Subject: [PATCH 04/10] fix(comment): reduce ignores --- pandas-stubs/core/series.pyi | 30 ++++++++++---------- tests/series/arithmetic/bool/test_truediv.py | 4 +-- tests/series/arithmetic/test_truediv.py | 2 +- tests/series/test_series.py | 2 +- 4 files changed, 19 insertions(+), 19 deletions(-) diff --git a/pandas-stubs/core/series.pyi b/pandas-stubs/core/series.pyi index 68a73f983..da9cd28e6 100644 --- a/pandas-stubs/core/series.pyi +++ b/pandas-stubs/core/series.pyi @@ -2101,22 +2101,25 @@ class Series(IndexOpsMixin[S1], NDFrame): self: Series[Never], other: complex | _ListLike | Series ) -> Series: ... @overload - def __truediv__(self, other: Series[Never]) -> Series: ... # type: ignore[overload-overlap] + def __truediv__(self, other: Series[Never]) -> Series: ... @overload - def __truediv__( - self: Series[bool], - other: bool | np_ndarray_bool | Series[bool], - ) -> Never: ... + def __truediv__(self: Series[bool], other: bool | np_ndarray_bool) -> Never: ... @overload - def __truediv__( + def __truediv__( # pyright: ignore[reportOverlappingOverload] self: Series[bool], - other: int | Sequence[int] | np_ndarray_anyint | np_ndarray_float | Series[int], + other: ( + float + | Sequence[float] + | np_ndarray_anyint + | np_ndarray_float + | Series[int] + | Series[float] + ), ) -> Series[float]: ... @overload - def __truediv__( # type: ignore[overload-overlap] - self: Series[bool], - other: _T_NUM_NON_BOOL | Sequence[_T_NUM_NON_BOOL] | Series[_T_NUM_NON_BOOL], - ) -> Series[_T_NUM_NON_BOOL]: ... + def __truediv__( + self: Series[bool], other: complex | Sequence[complex] | Series[complex] + ) -> Series[complex]: ... @overload def __truediv__( self: Series[int], @@ -2283,10 +2286,7 @@ class Series(IndexOpsMixin[S1], NDFrame): @overload def __rtruediv__(self: Series[Never], other: complex | _ListLike) -> Series: ... @overload - def __rtruediv__( - self: Series[bool], - other: bool | np_ndarray_bool, - ) -> Never: ... + def __rtruediv__(self: Series[bool], other: bool | np_ndarray_bool) -> Never: ... @overload def __rtruediv__( self: Series[bool], diff --git a/tests/series/arithmetic/bool/test_truediv.py b/tests/series/arithmetic/bool/test_truediv.py index 9e9e266e0..b4c64bd4a 100644 --- a/tests/series/arithmetic/bool/test_truediv.py +++ b/tests/series/arithmetic/bool/test_truediv.py @@ -179,13 +179,13 @@ def test_truediv_pd_series() -> None: c = pd.Series([1.1j, 2.2j, 4.1j]) if TYPE_CHECKING_INVALID_USAGE: - assert_type(left / b, Never) + _ = left / b # type: ignore[operator] # pyright: ignore[reportOperatorIssue] check(assert_type(left / i, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left / f, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left / c, "pd.Series[complex]"), pd.Series, np.complexfloating) if TYPE_CHECKING_INVALID_USAGE: - assert_type(b / left, Never) + _ = b / left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] check(assert_type(i / left, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(f / left, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(c / left, "pd.Series[complex]"), pd.Series, np.complexfloating) diff --git a/tests/series/arithmetic/test_truediv.py b/tests/series/arithmetic/test_truediv.py index f1e95633b..155a0c0e7 100644 --- a/tests/series/arithmetic/test_truediv.py +++ b/tests/series/arithmetic/test_truediv.py @@ -145,7 +145,7 @@ def test_truediv_pd_series() -> None: check(assert_type(left / f, pd.Series), pd.Series) check(assert_type(left / c, pd.Series), pd.Series) - check(assert_type(b / left, pd.Series), pd.Series) # type: ignore[assert-type] + check(assert_type(b / left, pd.Series), pd.Series) check(assert_type(i / left, pd.Series), pd.Series) check(assert_type(f / left, pd.Series), pd.Series) check(assert_type(c / left, pd.Series), pd.Series) diff --git a/tests/series/test_series.py b/tests/series/test_series.py index 7029ffd2b..4d1486dcc 100644 --- a/tests/series/test_series.py +++ b/tests/series/test_series.py @@ -1607,7 +1607,7 @@ def test_series_min_max_sub_axis() -> None: check(assert_type(sa, pd.Series), pd.Series) check(assert_type(ss, pd.Series), pd.Series) check(assert_type(sm, pd.Series), pd.Series) - check(assert_type(sd, pd.Series), pd.Series) # type: ignore[assert-type] + check(assert_type(sd, pd.Series), pd.Series) def test_series_index_isin() -> None: From bce19790c2e571f7d3c08f5ccd88f37139e36bdf Mon Sep 17 00:00:00 2001 From: cmp0xff Date: Tue, 12 Aug 2025 17:22:54 +0200 Subject: [PATCH 05/10] fix: missing tests --- pandas-stubs/core/series.pyi | 18 ++++++++++++-- tests/series/arithmetic/float/test_truediv.py | 24 +++++++++++++++++++ 2 files changed, 40 insertions(+), 2 deletions(-) diff --git a/pandas-stubs/core/series.pyi b/pandas-stubs/core/series.pyi index da9cd28e6..a217190f7 100644 --- a/pandas-stubs/core/series.pyi +++ b/pandas-stubs/core/series.pyi @@ -2238,7 +2238,14 @@ class Series(IndexOpsMixin[S1], NDFrame): @overload def truediv( self: Series[float], - other: int | Sequence[int] | np_ndarray_anyint | np_ndarray_float | Series[int], + other: ( + int + | Sequence[int] + | np_ndarray_bool + | np_ndarray_anyint + | np_ndarray_float + | Series[_T_INT] + ), level: Level | None = None, fill_value: float | None = None, axis: AxisIndex = 0, @@ -2395,7 +2402,14 @@ class Series(IndexOpsMixin[S1], NDFrame): @overload def rtruediv( self: Series[float], - other: int | Sequence[int] | np_ndarray_anyint | np_ndarray_float | Series[int], + other: ( + int + | Sequence[int] + | np_ndarray_bool + | np_ndarray_anyint + | np_ndarray_float + | Series[_T_INT] + ), level: Level | None = None, fill_value: float | None = None, axis: AxisIndex = 0, diff --git a/tests/series/arithmetic/float/test_truediv.py b/tests/series/arithmetic/float/test_truediv.py index 80d283c68..ae3f59f50 100644 --- a/tests/series/arithmetic/float/test_truediv.py +++ b/tests/series/arithmetic/float/test_truediv.py @@ -12,14 +12,17 @@ def test_truediv_py_scalar() -> None: """Test pd.Series[float] / Python native scalars""" b, i, f, c = True, 1, 1.0, 1j + check(assert_type(left / b, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left / i, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left / f, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left / c, "pd.Series[complex]"), pd.Series, np.complexfloating) + check(assert_type(b / left, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(i / left, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(f / left, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(c / left, "pd.Series[complex]"), pd.Series, np.complexfloating) + check(assert_type(left.truediv(b), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.truediv(i), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.truediv(f), "pd.Series[float]"), pd.Series, np.floating) check( @@ -28,10 +31,12 @@ def test_truediv_py_scalar() -> None: np.complexfloating, ) + check(assert_type(left.div(b), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.div(i), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.div(f), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.div(c), "pd.Series[complex]"), pd.Series, np.complexfloating) + check(assert_type(left.rtruediv(b), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.rtruediv(i), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.rtruediv(f), "pd.Series[float]"), pd.Series, np.floating) check( @@ -40,6 +45,7 @@ def test_truediv_py_scalar() -> None: np.complexfloating, ) + check(assert_type(left.rdiv(b), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.rdiv(i), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.rdiv(f), "pd.Series[float]"), pd.Series, np.floating) check( @@ -51,14 +57,17 @@ def test_truediv_py_sequence() -> None: """Test pd.Series[float] / Python native sequence""" b, i, f, c = [True, False, True], [2, 3, 5], [1.0, 2.0, 3.0], [1j, 1j, 4j] + check(assert_type(left / b, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left / i, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left / f, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left / c, "pd.Series[complex]"), pd.Series, np.complexfloating) + check(assert_type(b / left, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(i / left, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(f / left, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(c / left, "pd.Series[complex]"), pd.Series, np.complexfloating) + check(assert_type(left.truediv(b), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.truediv(i), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.truediv(f), "pd.Series[float]"), pd.Series, np.floating) check( @@ -67,10 +76,12 @@ def test_truediv_py_sequence() -> None: np.complexfloating, ) + check(assert_type(left.div(b), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.div(i), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.div(f), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.div(c), "pd.Series[complex]"), pd.Series, np.complexfloating) + check(assert_type(left.rtruediv(b), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.rtruediv(i), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.rtruediv(f), "pd.Series[float]"), pd.Series, np.floating) check( @@ -79,6 +90,7 @@ def test_truediv_py_sequence() -> None: np.complexfloating, ) + check(assert_type(left.rdiv(b), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.rdiv(i), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.rdiv(f), "pd.Series[float]"), pd.Series, np.floating) check( @@ -93,6 +105,7 @@ def test_truediv_numpy_array() -> None: f = np.array([1.0, 2.0, 3.0], np.float64) c = np.array([1.1j, 2.2j, 4.1j], np.complex128) + check(assert_type(left / b, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left / i, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left / f, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left / c, "pd.Series[complex]"), pd.Series, np.complexfloating) @@ -100,6 +113,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. + 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) check( @@ -108,6 +122,7 @@ def test_truediv_numpy_array() -> None: np.complexfloating, ) + check(assert_type(left.truediv(b), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.truediv(i), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.truediv(f), "pd.Series[float]"), pd.Series, np.floating) check( @@ -116,10 +131,12 @@ def test_truediv_numpy_array() -> None: np.complexfloating, ) + check(assert_type(left.div(b), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.div(i), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.div(f), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.div(c), "pd.Series[complex]"), pd.Series, np.complexfloating) + check(assert_type(left.rtruediv(b), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.rtruediv(i), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.rtruediv(f), "pd.Series[float]"), pd.Series, np.floating) check( @@ -128,6 +145,7 @@ def test_truediv_numpy_array() -> None: np.complexfloating, ) + check(assert_type(left.rdiv(b), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.rdiv(i), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.rdiv(f), "pd.Series[float]"), pd.Series, np.floating) check( @@ -142,14 +160,17 @@ def test_truediv_pd_series() -> None: f = pd.Series([1.0, 2.0, 3.0]) c = pd.Series([1.1j, 2.2j, 4.1j]) + check(assert_type(left / b, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left / i, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left / f, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left / c, "pd.Series[complex]"), pd.Series, np.complexfloating) + check(assert_type(b / left, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(i / left, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(f / left, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(c / left, "pd.Series[complex]"), pd.Series, np.complexfloating) + check(assert_type(left.truediv(b), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.truediv(i), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.truediv(f), "pd.Series[float]"), pd.Series, np.floating) check( @@ -158,10 +179,12 @@ def test_truediv_pd_series() -> None: np.complexfloating, ) + check(assert_type(left.div(b), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.div(i), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.div(f), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.div(c), "pd.Series[complex]"), pd.Series, np.complexfloating) + check(assert_type(left.rtruediv(b), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.rtruediv(i), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.rtruediv(f), "pd.Series[float]"), pd.Series, np.floating) check( @@ -170,6 +193,7 @@ def test_truediv_pd_series() -> None: np.complexfloating, ) + check(assert_type(left.rdiv(b), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.rdiv(i), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.rdiv(f), "pd.Series[float]"), pd.Series, np.floating) check( From 424537503b732f88120ea8de87adb062a152808f Mon Sep 17 00:00:00 2001 From: cmp0xff Date: Tue, 12 Aug 2025 17:47:02 +0200 Subject: [PATCH 06/10] fix(comment): https://github.com/pandas-dev/pandas-stubs/pull/1314#discussion_r2270240568 --- pandas-stubs/core/series.pyi | 105 +++++++++++-------- tests/series/arithmetic/bool/test_truediv.py | 8 +- 2 files changed, 65 insertions(+), 48 deletions(-) diff --git a/pandas-stubs/core/series.pyi b/pandas-stubs/core/series.pyi index a217190f7..4eccc04e2 100644 --- a/pandas-stubs/core/series.pyi +++ b/pandas-stubs/core/series.pyi @@ -188,7 +188,6 @@ from pandas.core.dtypes.dtypes import CategoricalDtype from pandas.plotting import PlotAccessor -_T_NUM_NON_BOOL = TypeVar("_T_NUM_NON_BOOL", int, float, complex) _T_INT = TypeVar("_T_INT", bound=int) _T_COMPLEX = TypeVar("_T_COMPLEX", bound=complex) @@ -2124,8 +2123,8 @@ class Series(IndexOpsMixin[S1], NDFrame): def __truediv__( self: Series[int], other: ( - _T_INT - | Sequence[_T_INT] + int + | Sequence[int] | np_ndarray_bool | np_ndarray_anyint | np_ndarray_float @@ -2141,8 +2140,8 @@ class Series(IndexOpsMixin[S1], NDFrame): def __truediv__( self: Series[float], other: ( - _T_INT - | Sequence[_T_INT] + int + | Sequence[int] | np_ndarray_bool | np_ndarray_anyint | np_ndarray_float @@ -2155,10 +2154,6 @@ class Series(IndexOpsMixin[S1], NDFrame): other: _T_COMPLEX | Sequence[_T_COMPLEX] | Series[_T_COMPLEX], ) -> Series[_T_COMPLEX]: ... @overload - def __truediv__( - self: Series[_T_COMPLEX], other: np_ndarray_complex - ) -> Series[complex]: ... - @overload def __truediv__( self: Series[complex], other: ( @@ -2171,6 +2166,10 @@ class Series(IndexOpsMixin[S1], NDFrame): ), ) -> Series[complex]: ... @overload + def __truediv__( + self: Series[_T_COMPLEX], other: np_ndarray_complex + ) -> Series[complex]: ... + @overload def __truediv__(self, other: Path) -> Series: ... @overload def truediv( @@ -2181,7 +2180,7 @@ class Series(IndexOpsMixin[S1], NDFrame): axis: AxisIndex = 0, ) -> Series: ... @overload - def truediv( # type: ignore[overload-overlap] + def truediv( self, other: Series[Never], level: Level | None = None, @@ -2191,33 +2190,40 @@ class Series(IndexOpsMixin[S1], NDFrame): @overload def truediv( self: Series[bool], - other: bool | np_ndarray_bool | Series[bool], + other: bool | np_ndarray_bool, level: Level | None = None, fill_value: float | None = None, axis: AxisIndex = 0, ) -> Never: ... @overload - def truediv( + def truediv( # pyright: ignore[reportOverlappingOverload] self: Series[bool], - other: int | Sequence[int] | np_ndarray_anyint | np_ndarray_float | Series[int], + other: ( + float + | Sequence[float] + | np_ndarray_anyint + | np_ndarray_float + | Series[int] + | Series[float] + ), level: Level | None = None, fill_value: float | None = None, axis: AxisIndex = 0, ) -> Series[float]: ... @overload - def truediv( # type: ignore[overload-overlap] + def truediv( self: Series[bool], - other: _T_NUM_NON_BOOL | Sequence[_T_NUM_NON_BOOL] | Series[_T_NUM_NON_BOOL], + other: complex | Sequence[complex] | Series[complex], level: Level | None = None, fill_value: float | None = None, axis: AxisIndex = 0, - ) -> Series[_T_NUM_NON_BOOL]: ... + ) -> Series[complex]: ... @overload def truediv( self: Series[int], other: ( - _T_INT - | Sequence[_T_INT] + int + | Sequence[int] | np_ndarray_bool | np_ndarray_anyint | np_ndarray_float @@ -2259,14 +2265,6 @@ class Series(IndexOpsMixin[S1], NDFrame): axis: AxisIndex = 0, ) -> Series[_T_COMPLEX]: ... @overload - def truediv( - self: Series[_T_COMPLEX], - other: np_ndarray_complex, - level: Level | None = None, - fill_value: float | None = None, - axis: AxisIndex = 0, - ) -> Series[complex]: ... - @overload def truediv( self: Series[complex], other: ( @@ -2282,6 +2280,14 @@ class Series(IndexOpsMixin[S1], NDFrame): axis: AxisIndex = 0, ) -> Series[complex]: ... @overload + def truediv( + self: Series[_T_COMPLEX], + other: np_ndarray_complex, + level: Level | None = None, + fill_value: float | None = None, + axis: AxisIndex = 0, + ) -> Series[complex]: ... + @overload def truediv( self, other: Path, @@ -2295,23 +2301,19 @@ class Series(IndexOpsMixin[S1], NDFrame): @overload def __rtruediv__(self: Series[bool], other: bool | np_ndarray_bool) -> Never: ... @overload - def __rtruediv__( + def __rtruediv__( # pyright: ignore[reportOverlappingOverload] self: Series[bool], - other: int | Sequence[int] | np_ndarray_anyint | np_ndarray_float, + other: float | Sequence[float] | np_ndarray_anyint | np_ndarray_float, ) -> Series[float]: ... @overload - def __rtruediv__( # type: ignore[overload-overlap] - self: Series[bool], other: _T_NUM_NON_BOOL | Sequence[_T_NUM_NON_BOOL] - ) -> Series[_T_NUM_NON_BOOL]: ... + def __rtruediv__( + self: Series[bool], other: complex | Sequence[complex] + ) -> Series[complex]: ... @overload def __rtruediv__( self: Series[int], other: ( - _T_INT - | Sequence[_T_INT] - | np_ndarray_bool - | np_ndarray_anyint - | np_ndarray_float + int | Sequence[int] | np_ndarray_bool | np_ndarray_anyint | np_ndarray_float ), ) -> Series[float]: ... @overload @@ -2353,35 +2355,50 @@ class Series(IndexOpsMixin[S1], NDFrame): axis: AxisIndex = 0, ) -> Series: ... @overload + def rtruediv( + self, + other: Series[Never], + level: Level | None = None, + fill_value: float | None = None, + axis: AxisIndex = 0, + ) -> Series: ... + @overload def rtruediv( self: Series[bool], - other: bool | np_ndarray_bool | Series[bool], + other: bool | np_ndarray_bool, level: Level | None = None, fill_value: float | None = None, axis: AxisIndex = 0, ) -> Never: ... @overload - def rtruediv( + def rtruediv( # pyright: ignore[reportOverlappingOverload] self: Series[bool], - other: int | Sequence[int] | np_ndarray_anyint | np_ndarray_float | Series[int], + other: ( + float + | Sequence[float] + | np_ndarray_anyint + | np_ndarray_float + | Series[int] + | Series[float] + ), level: Level | None = None, fill_value: float | None = None, axis: AxisIndex = 0, ) -> Series[float]: ... @overload - def rtruediv( # type: ignore[overload-overlap] + def rtruediv( self: Series[bool], - other: _T_NUM_NON_BOOL | Sequence[_T_NUM_NON_BOOL] | Series[_T_NUM_NON_BOOL], + other: complex | Sequence[complex] | Series[complex], level: Level | None = None, fill_value: float | None = None, axis: AxisIndex = 0, - ) -> Series[_T_NUM_NON_BOOL]: ... + ) -> Series[complex]: ... @overload def rtruediv( self: Series[int], other: ( - _T_INT - | Sequence[_T_INT] + int + | Sequence[int] | np_ndarray_bool | np_ndarray_anyint | np_ndarray_float diff --git a/tests/series/arithmetic/bool/test_truediv.py b/tests/series/arithmetic/bool/test_truediv.py index b4c64bd4a..caf61d0e3 100644 --- a/tests/series/arithmetic/bool/test_truediv.py +++ b/tests/series/arithmetic/bool/test_truediv.py @@ -191,7 +191,7 @@ def test_truediv_pd_series() -> None: check(assert_type(c / left, "pd.Series[complex]"), pd.Series, np.complexfloating) if TYPE_CHECKING_INVALID_USAGE: - assert_type(left.truediv(b), Never) + left.truediv(b) # type: ignore[arg-type] # pyright: ignore[reportArgumentType,reportCallIssue] check(assert_type(left.truediv(i), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.truediv(f), "pd.Series[float]"), pd.Series, np.floating) check( @@ -201,13 +201,13 @@ def test_truediv_pd_series() -> None: ) if TYPE_CHECKING_INVALID_USAGE: - assert_type(left.div(b), Never) + left.div(b) # type: ignore[arg-type] # pyright: ignore[reportArgumentType,reportCallIssue] check(assert_type(left.div(i), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.div(f), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.div(c), "pd.Series[complex]"), pd.Series, np.complexfloating) if TYPE_CHECKING_INVALID_USAGE: - assert_type(left.rtruediv(b), Never) + left.rtruediv(b) # type: ignore[arg-type] # pyright: ignore[reportArgumentType,reportCallIssue] check(assert_type(left.rtruediv(i), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.rtruediv(f), "pd.Series[float]"), pd.Series, np.floating) check( @@ -217,7 +217,7 @@ def test_truediv_pd_series() -> None: ) if TYPE_CHECKING_INVALID_USAGE: - assert_type(left.rdiv(b), Never) + left.rdiv(b) # type: ignore[arg-type] # pyright: ignore[reportArgumentType,reportCallIssue] check(assert_type(left.rdiv(i), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.rdiv(f), "pd.Series[float]"), pd.Series, np.floating) check( From 5cc4ec514dd95945501b904d55363b836f232e6a Mon Sep 17 00:00:00 2001 From: cmp0xff Date: Tue, 12 Aug 2025 18:21:11 +0200 Subject: [PATCH 07/10] fix: reduce TypeVar usage 424537503b732f88120ea8de87adb062a152808f --- pandas-stubs/core/series.pyi | 18 +++++++----------- 1 file changed, 7 insertions(+), 11 deletions(-) diff --git a/pandas-stubs/core/series.pyi b/pandas-stubs/core/series.pyi index 4eccc04e2..a1f66c169 100644 --- a/pandas-stubs/core/series.pyi +++ b/pandas-stubs/core/series.pyi @@ -1652,8 +1652,8 @@ class Series(IndexOpsMixin[S1], NDFrame): def __add__( self: Series[float], other: ( - _T_INT - | Sequence[_T_INT] + int + | Sequence[int] | np_ndarray_bool | np_ndarray_anyint | np_ndarray_float @@ -1767,8 +1767,8 @@ class Series(IndexOpsMixin[S1], NDFrame): def add( self: Series[float], other: ( - _T_INT - | Sequence[_T_INT] + int + | Sequence[int] | np_ndarray_bool | np_ndarray_anyint | np_ndarray_float @@ -1848,11 +1848,7 @@ class Series(IndexOpsMixin[S1], NDFrame): def __radd__( self: Series[float], other: ( - _T_INT - | Sequence[_T_INT] - | np_ndarray_bool - | np_ndarray_anyint - | np_ndarray_float + int | Sequence[int] | np_ndarray_bool | np_ndarray_anyint | np_ndarray_float ), ) -> Series[float]: ... @overload @@ -1960,8 +1956,8 @@ class Series(IndexOpsMixin[S1], NDFrame): def radd( self: Series[float], other: ( - _T_INT - | Sequence[_T_INT] + int + | Sequence[int] | np_ndarray_bool | np_ndarray_anyint | np_ndarray_float From 6f39da6f3e133fe9f73a4d3c428bd3607136a904 Mon Sep 17 00:00:00 2001 From: cmp0xff Date: Tue, 12 Aug 2025 23:25:30 +0200 Subject: [PATCH 08/10] fix(comment): https://github.com/pandas-dev/pandas-stubs/pull/1314/files#r2270685700 --- pandas-stubs/core/series.pyi | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/pandas-stubs/core/series.pyi b/pandas-stubs/core/series.pyi index a1f66c169..33b7d5858 100644 --- a/pandas-stubs/core/series.pyi +++ b/pandas-stubs/core/series.pyi @@ -2319,7 +2319,9 @@ class Series(IndexOpsMixin[S1], NDFrame): @overload def __rtruediv__( self: Series[float], - other: int | Sequence[int] | np_ndarray_anyint | np_ndarray_float, + other: ( + int | Sequence[int] | np_ndarray_bool | np_ndarray_anyint | np_ndarray_float + ), ) -> Series[float]: ... @overload def __rtruediv__( From 1853a8d9f5a823d5cd554bd764bfe3ee5e284cd9 Mon Sep 17 00:00:00 2001 From: cmp0xff Date: Wed, 13 Aug 2025 11:51:37 +0200 Subject: [PATCH 09/10] fix(comment): make `__r__` and `r` identical --- pandas-stubs/core/series.pyi | 111 +++++++++++++++++++---------------- 1 file changed, 62 insertions(+), 49 deletions(-) diff --git a/pandas-stubs/core/series.pyi b/pandas-stubs/core/series.pyi index 33b7d5858..fc4e0c002 100644 --- a/pandas-stubs/core/series.pyi +++ b/pandas-stubs/core/series.pyi @@ -1821,7 +1821,8 @@ class Series(IndexOpsMixin[S1], NDFrame): def __radd__(self: Series[Never], other: Scalar | _ListLike) -> Series: ... @overload def __radd__( - self: Series[bool], other: _T_COMPLEX | Sequence[_T_COMPLEX] + self: Series[bool], + other: _T_COMPLEX | Sequence[_T_COMPLEX] | Series[_T_COMPLEX], ) -> Series[_T_COMPLEX]: ... @overload def __radd__(self: Series[bool], other: np_ndarray_bool) -> Series[bool]: ... @@ -1830,45 +1831,51 @@ class Series(IndexOpsMixin[S1], NDFrame): @overload def __radd__(self: Series[bool], other: np_ndarray_float) -> Series[float]: ... @overload - def __radd__(self: Series[bool], other: np_ndarray_complex) -> Series[complex]: ... - @overload def __radd__( self: Series[int], - other: bool | Sequence[bool] | np_ndarray_bool | np_ndarray_anyint, + other: ( + bool | Sequence[bool] | np_ndarray_bool | np_ndarray_anyint | Series[bool] + ), ) -> Series[int]: ... @overload def __radd__( - self: Series[int], other: _T_COMPLEX | Sequence[_T_COMPLEX] + self: Series[int], other: _T_COMPLEX | Sequence[_T_COMPLEX] | Series[_T_COMPLEX] ) -> Series[_T_COMPLEX]: ... @overload def __radd__(self: Series[int], other: np_ndarray_float) -> Series[float]: ... @overload - def __radd__(self: Series[int], other: np_ndarray_complex) -> Series[complex]: ... - @overload def __radd__( self: Series[float], other: ( - int | Sequence[int] | np_ndarray_bool | np_ndarray_anyint | np_ndarray_float + int + | Sequence[int] + | np_ndarray_bool + | np_ndarray_anyint + | np_ndarray_float + | Series[_T_INT] ), ) -> Series[float]: ... @overload def __radd__( - self: Series[float], other: _T_COMPLEX | Sequence[_T_COMPLEX] + self: Series[float], + other: _T_COMPLEX | Sequence[_T_COMPLEX] | Series[_T_COMPLEX], ) -> Series[_T_COMPLEX]: ... @overload - def __radd__(self: Series[float], other: np_ndarray_complex) -> Series[complex]: ... - @overload def __radd__( self: Series[complex], other: ( - np_ndarray_bool + Sequence[_T_COMPLEX] + | np_ndarray_bool | np_ndarray_anyint | np_ndarray_float - | np_ndarray_complex - | Sequence[_T_COMPLEX] + | Series[_T_COMPLEX] ), ) -> Series[complex]: ... @overload + def __radd__( + self: Series[_T_COMPLEX], other: np_ndarray_complex + ) -> Series[complex]: ... + @overload def __radd__(self, other: S1) -> Self: ... @overload def radd( @@ -1895,14 +1902,6 @@ class Series(IndexOpsMixin[S1], NDFrame): axis: int = 0, ) -> Series[bool]: ... @overload - def radd( - self: Series[bool], - other: np_ndarray_anyint, - level: Level | None = None, - fill_value: float | None = None, - axis: int = 0, - ) -> Series[int]: ... - @overload def radd( self: Series[bool], other: np_ndarray_float, @@ -1913,11 +1912,11 @@ class Series(IndexOpsMixin[S1], NDFrame): @overload def radd( self: Series[bool], - other: np_ndarray_complex, + other: np_ndarray_anyint, level: Level | None = None, fill_value: float | None = None, axis: int = 0, - ) -> Series[complex]: ... + ) -> Series[int]: ... @overload def radd( self: Series[int], @@ -1945,14 +1944,6 @@ class Series(IndexOpsMixin[S1], NDFrame): axis: int = 0, ) -> Series[float]: ... @overload - def radd( - self: Series[int], - other: np_ndarray_complex, - level: Level | None = None, - fill_value: float | None = None, - axis: int = 0, - ) -> Series[complex]: ... - @overload def radd( self: Series[float], other: ( @@ -1976,14 +1967,6 @@ class Series(IndexOpsMixin[S1], NDFrame): axis: int = 0, ) -> Series[_T_COMPLEX]: ... @overload - def radd( - self: Series[float], - other: np_ndarray_complex, - level: Level | None = None, - fill_value: float | None = None, - axis: int = 0, - ) -> Series[complex]: ... - @overload def radd( self: Series[complex], other: ( @@ -1991,7 +1974,6 @@ class Series(IndexOpsMixin[S1], NDFrame): | np_ndarray_bool | np_ndarray_anyint | np_ndarray_float - | np_ndarray_complex | Series[_T_COMPLEX] ), level: Level | None = None, @@ -1999,6 +1981,14 @@ class Series(IndexOpsMixin[S1], NDFrame): axis: int = 0, ) -> Series[complex]: ... @overload + def radd( + self: Series[_T_COMPLEX], + other: np_ndarray_complex, + level: Level | None = None, + fill_value: float | None = None, + axis: int = 0, + ) -> Series[complex]: ... + @overload def radd( self, other: S1 | Series[S1], @@ -2293,39 +2283,61 @@ class Series(IndexOpsMixin[S1], NDFrame): ) -> Series: ... div = truediv @overload - def __rtruediv__(self: Series[Never], other: complex | _ListLike) -> Series: ... + def __rtruediv__( + self: Series[Never], other: complex | _ListLike | Series + ) -> Series: ... + @overload + def __rtruediv__(self, other: Series[Never]) -> Series: ... @overload def __rtruediv__(self: Series[bool], other: bool | np_ndarray_bool) -> Never: ... @overload def __rtruediv__( # pyright: ignore[reportOverlappingOverload] self: Series[bool], - other: float | Sequence[float] | np_ndarray_anyint | np_ndarray_float, + other: ( + float + | Sequence[float] + | np_ndarray_anyint + | np_ndarray_float + | Series[int] + | Series[float] + ), ) -> Series[float]: ... @overload def __rtruediv__( - self: Series[bool], other: complex | Sequence[complex] + self: Series[bool], other: complex | Sequence[complex] | Series[complex] ) -> Series[complex]: ... @overload def __rtruediv__( self: Series[int], other: ( - int | Sequence[int] | np_ndarray_bool | np_ndarray_anyint | np_ndarray_float + int + | Sequence[int] + | np_ndarray_bool + | np_ndarray_anyint + | np_ndarray_float + | Series[_T_INT] ), ) -> Series[float]: ... @overload def __rtruediv__( - self: Series[int], other: _T_COMPLEX | Sequence[_T_COMPLEX] + self: Series[int], other: _T_COMPLEX | Sequence[_T_COMPLEX] | Series[_T_COMPLEX] ) -> Series[_T_COMPLEX]: ... @overload def __rtruediv__( self: Series[float], other: ( - int | Sequence[int] | np_ndarray_bool | np_ndarray_anyint | np_ndarray_float + int + | Sequence[int] + | np_ndarray_bool + | np_ndarray_anyint + | np_ndarray_float + | Series[_T_INT] ), ) -> Series[float]: ... @overload def __rtruediv__( - self: Series[float], other: _T_COMPLEX | Sequence[_T_COMPLEX] + self: Series[float], + other: _T_COMPLEX | Sequence[_T_COMPLEX] | Series[_T_COMPLEX], ) -> Series[_T_COMPLEX]: ... @overload def __rtruediv__( @@ -2336,6 +2348,7 @@ class Series(IndexOpsMixin[S1], NDFrame): | np_ndarray_bool | np_ndarray_anyint | np_ndarray_float + | Series[_T_COMPLEX] ), ) -> Series[complex]: ... @overload @@ -3112,7 +3125,7 @@ class PeriodSeries(Series[Period]): ) -> Never: ... class OffsetSeries(Series[BaseOffset]): - @overload + @overload # type: ignore[override] def __radd__(self, other: Period) -> PeriodSeries: ... @overload def __radd__( # pyright: ignore[reportIncompatibleMethodOverride] From 7d585d915a8988f7165f50f1fa0d2c4d9b095473 Mon Sep 17 00:00:00 2001 From: cmp0xff Date: Wed, 13 Aug 2025 21:54:52 +0200 Subject: [PATCH 10/10] fix(comment): https://github.com/pandas-dev/pandas-stubs/pull/1314#discussion_r2273989859 --- pandas-stubs/core/series.pyi | 10 +++++++++- 1 file changed, 9 insertions(+), 1 deletion(-) diff --git a/pandas-stubs/core/series.pyi b/pandas-stubs/core/series.pyi index fc4e0c002..33148e391 100644 --- a/pandas-stubs/core/series.pyi +++ b/pandas-stubs/core/series.pyi @@ -1690,6 +1690,14 @@ class Series(IndexOpsMixin[S1], NDFrame): axis: int = 0, ) -> Series: ... @overload + def add( + self, + other: Series[Never], + level: Level | None = None, + fill_value: float | None = None, + axis: int = 0, + ) -> Series: ... + @overload def add( self: Series[bool], other: _T_COMPLEX | Sequence[_T_COMPLEX] | Series[_T_COMPLEX], @@ -1876,7 +1884,7 @@ class Series(IndexOpsMixin[S1], NDFrame): self: Series[_T_COMPLEX], other: np_ndarray_complex ) -> Series[complex]: ... @overload - def __radd__(self, other: S1) -> Self: ... + def __radd__(self, other: S1 | Series[S1]) -> Self: ... @overload def radd( self: Series[Never],