From 82d9d6397769645237146709abe301f7de2a4c84 Mon Sep 17 00:00:00 2001 From: cmp0xff Date: Thu, 17 Jul 2025 22:13:55 +0200 Subject: [PATCH 1/9] feat(series): #1098 arithmetic truediv --- pandas-stubs/core/series.pyi | 403 +++++++++++++++++- .../series/arithmetic/complex/test_truediv.py | 146 +++++++ tests/series/arithmetic/float/test_truediv.py | 146 +++++++ tests/series/arithmetic/int/test_truediv.py | 146 +++++++ tests/series/arithmetic/test_truediv.py | 143 +++++++ tests/series/test_series.py | 4 +- 6 files changed, 979 insertions(+), 9 deletions(-) create mode 100644 tests/series/arithmetic/complex/test_truediv.py create mode 100644 tests/series/arithmetic/float/test_truediv.py create mode 100644 tests/series/arithmetic/int/test_truediv.py create mode 100644 tests/series/arithmetic/test_truediv.py diff --git a/pandas-stubs/core/series.pyi b/pandas-stubs/core/series.pyi index f0dc7e7f..eda903c0 100644 --- a/pandas-stubs/core/series.pyi +++ b/pandas-stubs/core/series.pyi @@ -429,20 +429,180 @@ class Series(IndexOpsMixin[S1], NDFrame): ) -> Series: ... @property def hasnans(self) -> bool: ... + @overload + def div( + self: Series[Never], + other: Scalar | _ListLike | Series, + level: Level | None = ..., + fill_value: float | None = ..., + axis: AxisIndex = ..., + ) -> Series: ... + @overload def div( self, - other: num | _ListLike | Series[S1], + other: Series[Never], + level: Level | None = ..., + fill_value: float | None = ..., + axis: AxisIndex = ..., + ) -> Series: ... + @overload + def div( + self: Series[int], + other: int | Sequence[int] | np_ndarray_anyint | np_ndarray_float | Series[int], + level: Level | None = ..., + fill_value: float | None = ..., + axis: AxisIndex = ..., + ) -> Series[float]: ... + @overload + def div( + self: Series[int], + other: _T_COMPLEX | Sequence[_T_COMPLEX] | Series[_T_COMPLEX], + level: Level | None = ..., + fill_value: float | None = ..., + axis: AxisIndex = ..., + ) -> Series[_T_COMPLEX]: ... + @overload + def div( + self: Series[int], + other: np_ndarray_complex, + level: Level | None = ..., + fill_value: float | None = ..., + axis: AxisIndex = ..., + ) -> Series[complex]: ... + @overload + def div( + self: Series[float], + other: int | Sequence[int] | np_ndarray_anyint | np_ndarray_float | Series[int], level: Level | None = ..., fill_value: float | None = ..., axis: AxisIndex = ..., ) -> Series[float]: ... + @overload + def div( + self: Series[float], + other: _T_COMPLEX | Sequence[_T_COMPLEX] | Series[_T_COMPLEX], + level: Level | None = ..., + fill_value: float | None = ..., + axis: AxisIndex = ..., + ) -> Series[_T_COMPLEX]: ... + @overload + def div( + self: Series[float], + other: np_ndarray_complex, + level: Level | None = ..., + fill_value: float | None = ..., + axis: AxisIndex = ..., + ) -> Series[complex]: ... + @overload + def div( + self: Series[complex], + other: ( + _T_COMPLEX + | Sequence[_T_COMPLEX] + | np_ndarray_anyint + | np_ndarray_float + | np_ndarray_complex + | Series[_T_COMPLEX] + ), + level: Level | None = ..., + fill_value: float | None = ..., + axis: AxisIndex = ..., + ) -> Series[complex]: ... + @overload + def div( + self, + other: Scalar | _ListLike | Series, + level: Level | None = ..., + fill_value: float | None = ..., + axis: AxisIndex = ..., + ) -> Series: ... + @overload + def rdiv( + self: Series[Never], + other: Scalar | _ListLike | Series, + level: Level | None = ..., + fill_value: float | None = ..., + axis: AxisIndex = ..., + ) -> Series: ... + @overload def rdiv( self, - other: Series[S1] | Scalar, + other: Series[Never], level: Level | None = ..., fill_value: float | None = ..., axis: AxisIndex = ..., - ) -> Series[S1]: ... + ) -> Series: ... + @overload + def rdiv( + self: Series[int], + other: int | Sequence[int] | np_ndarray_anyint | np_ndarray_float | Series[int], + level: Level | None = ..., + fill_value: float | None = ..., + axis: AxisIndex = ..., + ) -> Series[float]: ... + @overload + def rdiv( + self: Series[int], + other: _T_COMPLEX | Sequence[_T_COMPLEX] | Series[_T_COMPLEX], + level: Level | None = ..., + fill_value: float | None = ..., + axis: AxisIndex = ..., + ) -> Series[_T_COMPLEX]: ... + @overload + def rdiv( + self: Series[int], + other: np_ndarray_complex, + level: Level | None = ..., + fill_value: float | None = ..., + axis: AxisIndex = ..., + ) -> Series[complex]: ... + @overload + def rdiv( + self: Series[float], + other: int | Sequence[int] | np_ndarray_anyint | np_ndarray_float | Series[int], + level: Level | None = ..., + fill_value: float | None = ..., + axis: AxisIndex = ..., + ) -> Series[float]: ... + @overload + def rdiv( + self: Series[float], + other: _T_COMPLEX | Sequence[_T_COMPLEX] | Series[_T_COMPLEX], + level: Level | None = ..., + fill_value: float | None = ..., + axis: AxisIndex = ..., + ) -> Series[_T_COMPLEX]: ... + @overload + def rdiv( + self: Series[float], + other: np_ndarray_complex, + level: Level | None = ..., + fill_value: float | None = ..., + axis: AxisIndex = ..., + ) -> Series[complex]: ... + @overload + def rdiv( + self: Series[complex], + other: ( + _T_COMPLEX + | Sequence[_T_COMPLEX] + | np_ndarray_anyint + | np_ndarray_float + | np_ndarray_complex + | Series[_T_COMPLEX] + ), + level: Level | None = ..., + fill_value: float | None = ..., + axis: AxisIndex = ..., + ) -> Series[complex]: ... + @overload + def rdiv( + self, + other: Scalar | _ListLike | Series, + level: Level | None = ..., + fill_value: float | None = ..., + axis: AxisIndex = ..., + ) -> Series: ... @property def dtype(self) -> DtypeObj: ... @property @@ -1761,6 +1921,39 @@ class Series(IndexOpsMixin[S1], NDFrame): @overload def __ror__(self, other: int | np_ndarray_anyint | Series[int]) -> Series[int]: ... def __rsub__(self, other: num | _ListLike | Series[S1]) -> Series: ... + @overload + def __rtruediv__( + self: Series[Never], other: num | _ListLike | Series | Path + ) -> Series: ... + @overload + def __rtruediv__( + self: Series[int], other: int | Sequence[int] + ) -> Series[float]: ... + @overload + def __rtruediv__( + self: Series[int], other: _T_COMPLEX | Sequence[_T_COMPLEX] + ) -> Series[_T_COMPLEX]: ... + @overload + def __rtruediv__( + self: Series[float], + other: int | Sequence[int] | np_ndarray_anyint | np_ndarray_float, + ) -> Series[float]: ... + @overload + def __rtruediv__( + self: Series[complex], + other: ( + _T_COMPLEX + | Sequence[_T_COMPLEX] + | np_ndarray_anyint + | np_ndarray_float + | np_ndarray_complex + ), + ) -> Series[complex]: ... + @overload + def __rtruediv__( + self: Series[float], other: _T_COMPLEX | Sequence[_T_COMPLEX] + ) -> Series[_T_COMPLEX]: ... + @overload def __rtruediv__(self, other: num | _ListLike | Series[S1] | Path) -> Series: ... # ignore needed for mypy as we want different results based on the arguments @overload # type: ignore[override] @@ -1785,6 +1978,52 @@ class Series(IndexOpsMixin[S1], NDFrame): ) -> TimedeltaSeries: ... @overload def __sub__(self, other: num | _ListLike | Series) -> Series: ... + @overload + def __truediv__( + self: Series[Never], other: num | _ListLike | Series | Path + ) -> Series: ... + @overload + def __truediv__(self: Series, other: Series[Never]) -> Series: ... + @overload + def __truediv__( + self: Series[int], + 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] + ) -> Series[_T_COMPLEX]: ... + @overload + def __truediv__( + self: Series[int], other: np_ndarray_complex + ) -> Series[complex]: ... + @overload + def __truediv__( + self: Series[float], + other: int | Sequence[int] | np_ndarray_anyint | np_ndarray_float | Series[int], + ) -> Series[float]: ... + @overload + def __truediv__( + self: Series[float], + other: _T_COMPLEX | Sequence[_T_COMPLEX] | Series[_T_COMPLEX], + ) -> Series[_T_COMPLEX]: ... + @overload + def __truediv__( + self: Series[float], other: np_ndarray_complex + ) -> Series[complex]: ... + @overload + def __truediv__( + self: Series[complex], + other: ( + _T_COMPLEX + | Sequence[_T_COMPLEX] + | np_ndarray_anyint + | np_ndarray_float + | np_ndarray_complex + | Series[_T_COMPLEX] + ), + ) -> Series[complex]: ... + @overload def __truediv__(self, other: num | _ListLike | Series[S1] | Path) -> Series: ... # ignore needed for mypy as we want different results based on the arguments @overload # type: ignore[override] @@ -2297,13 +2536,85 @@ class Series(IndexOpsMixin[S1], NDFrame): fill_value: float | None = ..., axis: AxisIndex = ..., ) -> Series[S1]: ... + @overload + def rtruediv( + self: Series[Never], + other: Scalar | _ListLike | Series, + level: Level | None = ..., + fill_value: float | None = ..., + axis: AxisIndex = ..., + ) -> Series: ... + @overload + def rtruediv( + self: Series[int], + other: int | Sequence[int] | np_ndarray_anyint | np_ndarray_float | Series[int], + level: Level | None = ..., + fill_value: float | None = ..., + axis: AxisIndex = ..., + ) -> Series[float]: ... + @overload + def rtruediv( + self: Series[int], + other: _T_COMPLEX | Sequence[_T_COMPLEX] | Series[_T_COMPLEX], + level: Level | None = ..., + fill_value: float | None = ..., + axis: AxisIndex = ..., + ) -> Series[_T_COMPLEX]: ... + @overload + def rtruediv( + self: Series[int], + other: np_ndarray_complex, + level: Level | None = ..., + fill_value: float | None = ..., + axis: AxisIndex = ..., + ) -> Series[complex]: ... + @overload + def rtruediv( + self: Series[float], + other: int | Sequence[int] | np_ndarray_anyint | np_ndarray_float | Series[int], + level: Level | None = ..., + fill_value: float | None = ..., + axis: AxisIndex = ..., + ) -> Series[float]: ... + @overload + def rtruediv( + self: Series[float], + other: _T_COMPLEX | Sequence[_T_COMPLEX] | Series[_T_COMPLEX], + level: Level | None = ..., + fill_value: float | None = ..., + axis: AxisIndex = ..., + ) -> Series[_T_COMPLEX]: ... + @overload + def rtruediv( + self: Series[float], + other: np_ndarray_complex, + level: Level | None = ..., + fill_value: float | None = ..., + axis: AxisIndex = ..., + ) -> Series[complex]: ... + @overload + def rtruediv( + self: Series[complex], + other: ( + _T_COMPLEX + | Sequence[_T_COMPLEX] + | np_ndarray_anyint + | np_ndarray_float + | np_ndarray_complex + | Series[_T_COMPLEX] + ), + level: Level | None = ..., + fill_value: float | None = ..., + axis: AxisIndex = ..., + ) -> Series[complex]: ... + @overload def rtruediv( self, - other, + other: Scalar | _ListLike | Series, level: Level | None = ..., fill_value: float | None = ..., axis: AxisIndex = ..., - ) -> Series[S1]: ... + ) -> Series: ... def sem( self, axis: AxisIndex | None = ..., @@ -2379,13 +2690,93 @@ class Series(IndexOpsMixin[S1], NDFrame): **kwargs: Any, ) -> np.ndarray: ... def tolist(self) -> list[S1]: ... + @overload + def truediv( + self: Series[Never], + other: Scalar | _ListLike | Series, + level: Level | None = ..., + fill_value: float | None = ..., + axis: AxisIndex = ..., + ) -> Series: ... + @overload def truediv( self, - other, + other: Series[Never], + level: Level | None = ..., + fill_value: float | None = ..., + axis: AxisIndex = ..., + ) -> Series: ... + @overload + def truediv( + self: Series[int], + other: int | Sequence[int] | np_ndarray_anyint | np_ndarray_float | Series[int], level: Level | None = ..., fill_value: float | None = ..., axis: AxisIndex = ..., ) -> Series[float]: ... + @overload + def truediv( + self: Series[int], + other: _T_COMPLEX | Sequence[_T_COMPLEX] | Series[_T_COMPLEX], + level: Level | None = ..., + fill_value: float | None = ..., + axis: AxisIndex = ..., + ) -> Series[_T_COMPLEX]: ... + @overload + def truediv( + self: Series[int], + other: np_ndarray_complex, + level: Level | None = ..., + fill_value: float | None = ..., + axis: AxisIndex = ..., + ) -> Series[complex]: ... + @overload + def truediv( + self: Series[float], + other: int | Sequence[int] | np_ndarray_anyint | np_ndarray_float | Series[int], + level: Level | None = ..., + fill_value: float | None = ..., + axis: AxisIndex = ..., + ) -> Series[float]: ... + @overload + def truediv( + self: Series[float], + other: _T_COMPLEX | Sequence[_T_COMPLEX] | Series[_T_COMPLEX], + level: Level | None = ..., + fill_value: float | None = ..., + axis: AxisIndex = ..., + ) -> Series[_T_COMPLEX]: ... + @overload + def truediv( + self: Series[float], + other: np_ndarray_complex, + level: Level | None = ..., + fill_value: float | None = ..., + axis: AxisIndex = ..., + ) -> Series[complex]: ... + @overload + def truediv( + self: Series[complex], + other: ( + _T_COMPLEX + | Sequence[_T_COMPLEX] + | np_ndarray_anyint + | np_ndarray_float + | np_ndarray_complex + | Series[_T_COMPLEX] + ), + level: Level | None = ..., + fill_value: float | None = ..., + axis: AxisIndex = ..., + ) -> Series[complex]: ... + @overload + def truediv( + self, + other: Scalar | _ListLike | Series, + level: Level | None = ..., + fill_value: float | None = ..., + axis: AxisIndex = ..., + ) -> Series: ... def var( self, axis: AxisIndex | None = ..., diff --git a/tests/series/arithmetic/complex/test_truediv.py b/tests/series/arithmetic/complex/test_truediv.py new file mode 100644 index 00000000..d08c7caf --- /dev/null +++ b/tests/series/arithmetic/complex/test_truediv.py @@ -0,0 +1,146 @@ +import numpy as np +import pandas as pd +from typing_extensions import assert_type + +from tests import check + +left = pd.Series([1j, 2j, 3j]) # left operand + + +def test_truediv_py_scalar() -> None: + """Test pd.Series[complex] / Python native scalars""" + i, f, c = 1, 1.0, 1j + + check(assert_type(left / i, "pd.Series[complex]"), pd.Series, np.complex128) + check(assert_type(left / f, "pd.Series[complex]"), pd.Series, np.complex128) + check(assert_type(left / c, "pd.Series[complex]"), pd.Series, np.complex128) + + check(assert_type(i / left, "pd.Series[complex]"), pd.Series, np.complex128) + check(assert_type(f / left, "pd.Series[complex]"), pd.Series, np.complex128) + check(assert_type(c / left, "pd.Series[complex]"), pd.Series, np.complex128) + + check(assert_type(left.truediv(i), "pd.Series[complex]"), pd.Series, np.complex128) + check(assert_type(left.truediv(f), "pd.Series[complex]"), pd.Series, np.complex128) + check(assert_type(left.truediv(c), "pd.Series[complex]"), pd.Series, np.complex128) + + check(assert_type(left.div(i), "pd.Series[complex]"), pd.Series, np.complex128) + check(assert_type(left.div(f), "pd.Series[complex]"), pd.Series, np.complex128) + check(assert_type(left.div(c), "pd.Series[complex]"), pd.Series, np.complex128) + + check(assert_type(left.rtruediv(i), "pd.Series[complex]"), pd.Series, np.complex128) + check(assert_type(left.rtruediv(f), "pd.Series[complex]"), pd.Series, np.complex128) + check(assert_type(left.rtruediv(c), "pd.Series[complex]"), pd.Series, np.complex128) + + check(assert_type(left.rdiv(i), "pd.Series[complex]"), pd.Series, np.complex128) + check(assert_type(left.rdiv(f), "pd.Series[complex]"), pd.Series, np.complex128) + check(assert_type(left.rdiv(c), "pd.Series[complex]"), pd.Series, np.complex128) + + +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] + + check(assert_type(left / i, "pd.Series[complex]"), pd.Series, np.complex128) + check(assert_type(left / f, "pd.Series[complex]"), pd.Series, np.complex128) + check(assert_type(left / c, "pd.Series[complex]"), pd.Series, np.complex128) + + check(assert_type(i / left, "pd.Series[complex]"), pd.Series, np.complex128) + check(assert_type(f / left, "pd.Series[complex]"), pd.Series, np.complex128) + check(assert_type(c / left, "pd.Series[complex]"), pd.Series, np.complex128) + + check(assert_type(left.truediv(i), "pd.Series[complex]"), pd.Series, np.complex128) + check(assert_type(left.truediv(f), "pd.Series[complex]"), pd.Series, np.complex128) + check(assert_type(left.truediv(c), "pd.Series[complex]"), pd.Series, np.complex128) + + check(assert_type(left.div(i), "pd.Series[complex]"), pd.Series, np.complex128) + check(assert_type(left.div(f), "pd.Series[complex]"), pd.Series, np.complex128) + check(assert_type(left.div(c), "pd.Series[complex]"), pd.Series, np.complex128) + + check(assert_type(left.rtruediv(i), "pd.Series[complex]"), pd.Series, np.complex128) + check(assert_type(left.rtruediv(f), "pd.Series[complex]"), pd.Series, np.complex128) + check(assert_type(left.rtruediv(c), "pd.Series[complex]"), pd.Series, np.complex128) + + check(assert_type(left.rdiv(i), "pd.Series[complex]"), pd.Series, np.complex128) + check(assert_type(left.rdiv(f), "pd.Series[complex]"), pd.Series, np.complex128) + check(assert_type(left.rdiv(c), "pd.Series[complex]"), pd.Series, np.complex128) + + +def test_truediv_numpy_array() -> None: + """Test pd.Series[complex] / 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[complex]"), pd.Series, np.complex128) + check(assert_type(left / f, "pd.Series[complex]"), pd.Series, np.complex128) + check(assert_type(left / c, "pd.Series[complex]"), pd.Series, np.complex128) + + # numpy typing gives ndarray instead of `pd.Series[...]` in reality, which we cannot fix + check( + assert_type( # type: ignore[assert-type] + i / left, "pd.Series[complex]" # pyright: ignore[reportAssertTypeFailure] + ), + pd.Series, + np.complex128, + ) + check( + assert_type( # type: ignore[assert-type] + f / left, "pd.Series[complex]" # pyright: ignore[reportAssertTypeFailure] + ), + pd.Series, + np.complex128, + ) + check( + assert_type( # type: ignore[assert-type] + c / left, "pd.Series[complex]" # pyright: ignore[reportAssertTypeFailure] + ), + pd.Series, + np.complex128, + ) + + check(assert_type(left.truediv(i), "pd.Series[complex]"), pd.Series, np.complex128) + check(assert_type(left.truediv(f), "pd.Series[complex]"), pd.Series, np.complex128) + check(assert_type(left.truediv(c), "pd.Series[complex]"), pd.Series, np.complex128) + + check(assert_type(left.div(i), "pd.Series[complex]"), pd.Series, np.complex128) + check(assert_type(left.div(f), "pd.Series[complex]"), pd.Series, np.complex128) + check(assert_type(left.div(c), "pd.Series[complex]"), pd.Series, np.complex128) + + check(assert_type(left.rtruediv(i), "pd.Series[complex]"), pd.Series, np.complex128) + check(assert_type(left.rtruediv(f), "pd.Series[complex]"), pd.Series, np.complex128) + check(assert_type(left.rtruediv(c), "pd.Series[complex]"), pd.Series, np.complex128) + + check(assert_type(left.rdiv(i), "pd.Series[complex]"), pd.Series, np.complex128) + check(assert_type(left.rdiv(f), "pd.Series[complex]"), pd.Series, np.complex128) + check(assert_type(left.rdiv(c), "pd.Series[complex]"), pd.Series, np.complex128) + + +def test_truediv_pd_series() -> None: + """Test pd.Series[complex] / 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[complex]"), pd.Series, np.complex128) + check(assert_type(left / f, "pd.Series[complex]"), pd.Series, np.complex128) + check(assert_type(left / c, "pd.Series[complex]"), pd.Series, np.complex128) + + check(assert_type(i / left, "pd.Series[complex]"), pd.Series, np.complex128) + check(assert_type(f / left, "pd.Series[complex]"), pd.Series, np.complex128) + check(assert_type(c / left, "pd.Series[complex]"), pd.Series, np.complex128) + + check(assert_type(left.truediv(i), "pd.Series[complex]"), pd.Series, np.complex128) + check(assert_type(left.truediv(f), "pd.Series[complex]"), pd.Series, np.complex128) + check(assert_type(left.truediv(c), "pd.Series[complex]"), pd.Series, np.complex128) + + check(assert_type(left.div(i), "pd.Series[complex]"), pd.Series, np.complex128) + check(assert_type(left.div(f), "pd.Series[complex]"), pd.Series, np.complex128) + check(assert_type(left.div(c), "pd.Series[complex]"), pd.Series, np.complex128) + + check(assert_type(left.rtruediv(i), "pd.Series[complex]"), pd.Series, np.complex128) + check(assert_type(left.rtruediv(f), "pd.Series[complex]"), pd.Series, np.complex128) + check(assert_type(left.rtruediv(c), "pd.Series[complex]"), pd.Series, np.complex128) + + check(assert_type(left.rdiv(i), "pd.Series[complex]"), pd.Series, np.complex128) + check(assert_type(left.rdiv(f), "pd.Series[complex]"), pd.Series, np.complex128) + check(assert_type(left.rdiv(c), "pd.Series[complex]"), pd.Series, np.complex128) diff --git a/tests/series/arithmetic/float/test_truediv.py b/tests/series/arithmetic/float/test_truediv.py new file mode 100644 index 00000000..1e440b9f --- /dev/null +++ b/tests/series/arithmetic/float/test_truediv.py @@ -0,0 +1,146 @@ +import numpy as np +import pandas as pd +from typing_extensions import assert_type + +from tests import check + +left = pd.Series([1.0, 2.0, 3.0]) # left operand + + +def test_truediv_py_scalar() -> None: + """Test pd.Series[float] / Python native scalars""" + i, f, c = 1, 1.0, 1j + + check(assert_type(left / i, "pd.Series[float]"), pd.Series, np.float64) + check(assert_type(left / f, "pd.Series[float]"), pd.Series, np.float64) + check(assert_type(left / c, "pd.Series[complex]"), pd.Series, np.complex128) + + check(assert_type(i / left, "pd.Series[float]"), pd.Series, np.float64) + check(assert_type(f / left, "pd.Series[float]"), pd.Series, np.float64) + check(assert_type(c / left, "pd.Series[complex]"), pd.Series, np.complex128) + + check(assert_type(left.truediv(i), "pd.Series[float]"), pd.Series, np.float64) + check(assert_type(left.truediv(f), "pd.Series[float]"), pd.Series, np.float64) + check(assert_type(left.truediv(c), "pd.Series[complex]"), pd.Series, np.complex128) + + check(assert_type(left.div(i), "pd.Series[float]"), pd.Series, np.float64) + check(assert_type(left.div(f), "pd.Series[float]"), pd.Series, np.float64) + check(assert_type(left.div(c), "pd.Series[complex]"), pd.Series, np.complex128) + + check(assert_type(left.rtruediv(i), "pd.Series[float]"), pd.Series, np.float64) + check(assert_type(left.rtruediv(f), "pd.Series[float]"), pd.Series, np.float64) + check(assert_type(left.rtruediv(c), "pd.Series[complex]"), pd.Series, np.complex128) + + check(assert_type(left.rdiv(i), "pd.Series[float]"), pd.Series, np.float64) + check(assert_type(left.rdiv(f), "pd.Series[float]"), pd.Series, np.float64) + check(assert_type(left.rdiv(c), "pd.Series[complex]"), pd.Series, np.complex128) + + +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] + + check(assert_type(left / i, "pd.Series[float]"), pd.Series, np.float64) + check(assert_type(left / f, "pd.Series[float]"), pd.Series, np.float64) + check(assert_type(left / c, "pd.Series[complex]"), pd.Series, np.complex128) + + check(assert_type(i / left, "pd.Series[float]"), pd.Series, np.float64) + check(assert_type(f / left, "pd.Series[float]"), pd.Series, np.float64) + check(assert_type(c / left, "pd.Series[complex]"), pd.Series, np.complex128) + + check(assert_type(left.truediv(i), "pd.Series[float]"), pd.Series, np.float64) + check(assert_type(left.truediv(f), "pd.Series[float]"), pd.Series, np.float64) + check(assert_type(left.truediv(c), "pd.Series[complex]"), pd.Series, np.complex128) + + check(assert_type(left.div(i), "pd.Series[float]"), pd.Series, np.float64) + check(assert_type(left.div(f), "pd.Series[float]"), pd.Series, np.float64) + check(assert_type(left.div(c), "pd.Series[complex]"), pd.Series, np.complex128) + + check(assert_type(left.rtruediv(i), "pd.Series[float]"), pd.Series, np.float64) + check(assert_type(left.rtruediv(f), "pd.Series[float]"), pd.Series, np.float64) + check(assert_type(left.rtruediv(c), "pd.Series[complex]"), pd.Series, np.complex128) + + check(assert_type(left.rdiv(i), "pd.Series[float]"), pd.Series, np.float64) + check(assert_type(left.rdiv(f), "pd.Series[float]"), pd.Series, np.float64) + check(assert_type(left.rdiv(c), "pd.Series[complex]"), pd.Series, np.complex128) + + +def test_truediv_numpy_array() -> None: + """Test pd.Series[float] / 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.float64) + check(assert_type(left / f, "pd.Series[float]"), pd.Series, np.float64) + check(assert_type(left / c, "pd.Series[complex]"), pd.Series, np.complex128) + + # numpy typing gives ndarray instead of `pd.Series[...]` in reality, which we cannot fix + check( + assert_type( # type: ignore[assert-type] + i / left, "pd.Series[float]" # pyright: ignore[reportAssertTypeFailure] + ), + pd.Series, + np.float64, + ) + check( + assert_type( # type: ignore[assert-type] + f / left, "pd.Series[float]" # pyright: ignore[reportAssertTypeFailure] + ), + pd.Series, + np.float64, + ) + check( + assert_type( # type: ignore[assert-type] + c / left, "pd.Series[complex]" # pyright: ignore[reportAssertTypeFailure] + ), + pd.Series, + np.complex128, + ) + + check(assert_type(left.truediv(i), "pd.Series[float]"), pd.Series, np.float64) + check(assert_type(left.truediv(f), "pd.Series[float]"), pd.Series, np.float64) + check(assert_type(left.truediv(c), "pd.Series[complex]"), pd.Series, np.complex128) + + check(assert_type(left.div(i), "pd.Series[float]"), pd.Series, np.float64) + check(assert_type(left.div(f), "pd.Series[float]"), pd.Series, np.float64) + check(assert_type(left.div(c), "pd.Series[complex]"), pd.Series, np.complex128) + + check(assert_type(left.rtruediv(i), "pd.Series[float]"), pd.Series, np.float64) + check(assert_type(left.rtruediv(f), "pd.Series[float]"), pd.Series, np.float64) + check(assert_type(left.rtruediv(c), "pd.Series[complex]"), pd.Series, np.complex128) + + check(assert_type(left.rdiv(i), "pd.Series[float]"), pd.Series, np.float64) + check(assert_type(left.rdiv(f), "pd.Series[float]"), pd.Series, np.float64) + check(assert_type(left.rdiv(c), "pd.Series[complex]"), pd.Series, np.complex128) + + +def test_truediv_pd_series() -> None: + """Test pd.Series[float] / 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.float64) + check(assert_type(left / f, "pd.Series[float]"), pd.Series, np.float64) + check(assert_type(left / c, "pd.Series[complex]"), pd.Series, np.complex128) + + check(assert_type(i / left, "pd.Series[float]"), pd.Series, np.float64) + check(assert_type(f / left, "pd.Series[float]"), pd.Series, np.float64) + check(assert_type(c / left, "pd.Series[complex]"), pd.Series, np.complex128) + + check(assert_type(left.truediv(i), "pd.Series[float]"), pd.Series, np.float64) + check(assert_type(left.truediv(f), "pd.Series[float]"), pd.Series, np.float64) + check(assert_type(left.truediv(c), "pd.Series[complex]"), pd.Series, np.complex128) + + check(assert_type(left.div(i), "pd.Series[float]"), pd.Series, np.float64) + check(assert_type(left.div(f), "pd.Series[float]"), pd.Series, np.float64) + check(assert_type(left.div(c), "pd.Series[complex]"), pd.Series, np.complex128) + + check(assert_type(left.rtruediv(i), "pd.Series[float]"), pd.Series, np.float64) + check(assert_type(left.rtruediv(f), "pd.Series[float]"), pd.Series, np.float64) + check(assert_type(left.rtruediv(c), "pd.Series[complex]"), pd.Series, np.complex128) + + check(assert_type(left.rdiv(i), "pd.Series[float]"), pd.Series, np.float64) + check(assert_type(left.rdiv(f), "pd.Series[float]"), pd.Series, np.float64) + check(assert_type(left.rdiv(c), "pd.Series[complex]"), pd.Series, np.complex128) diff --git a/tests/series/arithmetic/int/test_truediv.py b/tests/series/arithmetic/int/test_truediv.py new file mode 100644 index 00000000..fee98380 --- /dev/null +++ b/tests/series/arithmetic/int/test_truediv.py @@ -0,0 +1,146 @@ +import numpy as np +import pandas as pd +from typing_extensions import assert_type + +from tests import check + +left = pd.Series([1, 2, 3]) # left operand + + +def test_truediv_py_scalar() -> None: + """Test pd.Series[int] / Python native scalars""" + i, f, c = 1, 1.0, 1j + + check(assert_type(left / i, "pd.Series[float]"), pd.Series, np.float64) + check(assert_type(left / f, "pd.Series[float]"), pd.Series, np.float64) + check(assert_type(left / c, "pd.Series[complex]"), pd.Series, np.complex128) + + check(assert_type(i / left, "pd.Series[float]"), pd.Series, np.float64) + check(assert_type(f / left, "pd.Series[float]"), pd.Series, np.float64) + check(assert_type(c / left, "pd.Series[complex]"), pd.Series, np.complex128) + + check(assert_type(left.truediv(i), "pd.Series[float]"), pd.Series, np.float64) + check(assert_type(left.truediv(f), "pd.Series[float]"), pd.Series, np.float64) + check(assert_type(left.truediv(c), "pd.Series[complex]"), pd.Series, np.complex128) + + check(assert_type(left.div(i), "pd.Series[float]"), pd.Series, np.float64) + check(assert_type(left.div(f), "pd.Series[float]"), pd.Series, np.float64) + check(assert_type(left.div(c), "pd.Series[complex]"), pd.Series, np.complex128) + + check(assert_type(left.rtruediv(i), "pd.Series[float]"), pd.Series, np.float64) + check(assert_type(left.rtruediv(f), "pd.Series[float]"), pd.Series, np.float64) + check(assert_type(left.rtruediv(c), "pd.Series[complex]"), pd.Series, np.complex128) + + check(assert_type(left.rdiv(i), "pd.Series[float]"), pd.Series, np.float64) + check(assert_type(left.rdiv(f), "pd.Series[float]"), pd.Series, np.float64) + check(assert_type(left.rdiv(c), "pd.Series[complex]"), pd.Series, np.complex128) + + +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] + + check(assert_type(left / i, "pd.Series[float]"), pd.Series, np.float64) + check(assert_type(left / f, "pd.Series[float]"), pd.Series, np.float64) + check(assert_type(left / c, "pd.Series[complex]"), pd.Series, np.complex128) + + check(assert_type(i / left, "pd.Series[float]"), pd.Series, np.float64) + check(assert_type(f / left, "pd.Series[float]"), pd.Series, np.float64) + check(assert_type(c / left, "pd.Series[complex]"), pd.Series, np.complex128) + + check(assert_type(left.truediv(i), "pd.Series[float]"), pd.Series, np.float64) + check(assert_type(left.truediv(f), "pd.Series[float]"), pd.Series, np.float64) + check(assert_type(left.truediv(c), "pd.Series[complex]"), pd.Series, np.complex128) + + check(assert_type(left.div(i), "pd.Series[float]"), pd.Series, np.float64) + check(assert_type(left.div(f), "pd.Series[float]"), pd.Series, np.float64) + check(assert_type(left.div(c), "pd.Series[complex]"), pd.Series, np.complex128) + + check(assert_type(left.rtruediv(i), "pd.Series[float]"), pd.Series, np.float64) + check(assert_type(left.rtruediv(f), "pd.Series[float]"), pd.Series, np.float64) + check(assert_type(left.rtruediv(c), "pd.Series[complex]"), pd.Series, np.complex128) + + check(assert_type(left.rdiv(i), "pd.Series[float]"), pd.Series, np.float64) + check(assert_type(left.rdiv(f), "pd.Series[float]"), pd.Series, np.float64) + check(assert_type(left.rdiv(c), "pd.Series[complex]"), pd.Series, np.complex128) + + +def test_truediv_numpy_array() -> None: + """Test pd.Series[int] / 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.float64) + check(assert_type(left / f, "pd.Series[float]"), pd.Series, np.float64) + check(assert_type(left / c, "pd.Series[complex]"), pd.Series, np.complex128) + + # numpy typing gives ndarray instead of `pd.Series[...]` in reality, which we cannot fix + check( + assert_type( # type: ignore[assert-type] + i / left, "pd.Series[float]" # pyright: ignore[reportAssertTypeFailure] + ), + pd.Series, + np.float64, + ) + check( + assert_type( # type: ignore[assert-type] + f / left, "pd.Series[float]" # pyright: ignore[reportAssertTypeFailure] + ), + pd.Series, + np.float64, + ) + check( + assert_type( # type: ignore[assert-type] + c / left, "pd.Series[complex]" # pyright: ignore[reportAssertTypeFailure] + ), + pd.Series, + np.complex128, + ) + + check(assert_type(left.truediv(i), "pd.Series[float]"), pd.Series, np.float64) + check(assert_type(left.truediv(f), "pd.Series[float]"), pd.Series, np.float64) + check(assert_type(left.truediv(c), "pd.Series[complex]"), pd.Series, np.complex128) + + check(assert_type(left.div(i), "pd.Series[float]"), pd.Series, np.float64) + check(assert_type(left.div(f), "pd.Series[float]"), pd.Series, np.float64) + check(assert_type(left.div(c), "pd.Series[complex]"), pd.Series, np.complex128) + + check(assert_type(left.rtruediv(i), "pd.Series[float]"), pd.Series, np.float64) + check(assert_type(left.rtruediv(f), "pd.Series[float]"), pd.Series, np.float64) + check(assert_type(left.rtruediv(c), "pd.Series[complex]"), pd.Series, np.complex128) + + check(assert_type(left.rdiv(i), "pd.Series[float]"), pd.Series, np.float64) + check(assert_type(left.rdiv(f), "pd.Series[float]"), pd.Series, np.float64) + check(assert_type(left.rdiv(c), "pd.Series[complex]"), pd.Series, np.complex128) + + +def test_truediv_pd_series() -> None: + """Test pd.Series[int] / 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.float64) + check(assert_type(left / f, "pd.Series[float]"), pd.Series, np.float64) + check(assert_type(left / c, "pd.Series[complex]"), pd.Series, np.complex128) + + check(assert_type(i / left, "pd.Series[float]"), pd.Series, np.float64) + check(assert_type(f / left, "pd.Series[float]"), pd.Series, np.float64) + check(assert_type(c / left, "pd.Series[complex]"), pd.Series, np.complex128) + + check(assert_type(left.truediv(i), "pd.Series[float]"), pd.Series, np.float64) + check(assert_type(left.truediv(f), "pd.Series[float]"), pd.Series, np.float64) + check(assert_type(left.truediv(c), "pd.Series[complex]"), pd.Series, np.complex128) + + check(assert_type(left.div(i), "pd.Series[float]"), pd.Series, np.float64) + check(assert_type(left.div(f), "pd.Series[float]"), pd.Series, np.float64) + check(assert_type(left.div(c), "pd.Series[complex]"), pd.Series, np.complex128) + + check(assert_type(left.rtruediv(i), "pd.Series[float]"), pd.Series, np.float64) + check(assert_type(left.rtruediv(f), "pd.Series[float]"), pd.Series, np.float64) + check(assert_type(left.rtruediv(c), "pd.Series[complex]"), pd.Series, np.complex128) + + check(assert_type(left.rdiv(i), "pd.Series[float]"), pd.Series, np.float64) + check(assert_type(left.rdiv(f), "pd.Series[float]"), pd.Series, np.float64) + check(assert_type(left.rdiv(c), "pd.Series[complex]"), pd.Series, np.complex128) diff --git a/tests/series/arithmetic/test_truediv.py b/tests/series/arithmetic/test_truediv.py new file mode 100644 index 00000000..7a806549 --- /dev/null +++ b/tests/series/arithmetic/test_truediv.py @@ -0,0 +1,143 @@ +import numpy as np +import pandas as pd +from typing_extensions import assert_type + +from tests import check + +left = pd.DataFrame({"a": [1, 2, 3]})["a"] # left operand + + +def test_truediv_py_scalar() -> None: + """Test pd.Series[Any] / Python native scalars""" + i, f, c = 1, 1.0, 1j + + 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(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(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(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(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(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) + + +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] + + 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(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(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(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(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(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) + + +def test_truediv_numpy_array() -> None: + """Test pd.Series[Any] / 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.complex64) + + 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) + + # numpy typing gives ndarray instead of `pd.Series[...]` in reality, which we cannot fix + check( + assert_type( # type: ignore[assert-type] + i / left, pd.Series # pyright: ignore[reportAssertTypeFailure] + ), + pd.Series, + ) + check( + assert_type( # type: ignore[assert-type] + f / left, pd.Series # pyright: ignore[reportAssertTypeFailure] + ), + pd.Series, + ) + check( + assert_type( # type: ignore[assert-type] + c / left, pd.Series # pyright: ignore[reportAssertTypeFailure] + ), + 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(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(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(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) + + +def test_truediv_pd_series() -> None: + """Test pd.Series[Any] / 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), pd.Series) + check(assert_type(left / f, pd.Series), pd.Series) + check(assert_type(left / c, 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(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(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(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(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) diff --git a/tests/series/test_series.py b/tests/series/test_series.py index 49fd8096..297272d3 100644 --- a/tests/series/test_series.py +++ b/tests/series/test_series.py @@ -823,9 +823,7 @@ def test_types_element_wise_arithmetic() -> None: # check(assert_type(s.mul(s2, fill_value=0), "pd.Series[int]"), pd.Series, np.integer) check(assert_type(s.mul(s2, fill_value=0), pd.Series), pd.Series, np.integer) - # TODO these two below should type pd.Series[float] - # check(assert_type(s / s2, "pd.Series[float]"), pd.Series, np.float64) - check(assert_type(s / s2, pd.Series), pd.Series, np.float64) + check(assert_type(s / s2, "pd.Series[float]"), pd.Series, np.float64) check( assert_type(s.div(s2, fill_value=0), "pd.Series[float]"), pd.Series, np.float64 ) From e57e8b490db54b7621d7e0c0e9c56d458133c9c2 Mon Sep 17 00:00:00 2001 From: cmp0xff Date: Tue, 29 Jul 2025 16:20:02 +0200 Subject: [PATCH 2/9] fix(typing): __truediv__ --- pandas-stubs/core/series.pyi | 18 +++--------------- 1 file changed, 3 insertions(+), 15 deletions(-) diff --git a/pandas-stubs/core/series.pyi b/pandas-stubs/core/series.pyi index eda903c0..fc923bfa 100644 --- a/pandas-stubs/core/series.pyi +++ b/pandas-stubs/core/series.pyi @@ -1782,10 +1782,7 @@ class Series(IndexOpsMixin[S1], NDFrame): # just failed to generate these so I couldn't match # them up. @overload - def __add__( - self: Series[Never], - other: Scalar | _ListLike | Series, - ) -> Series: ... + def __add__(self: Series[Never], other: Scalar | _ListLike | Series) -> Series: ... @overload def __add__(self, other: Series[Never]) -> Series: ... @overload @@ -1980,10 +1977,10 @@ class Series(IndexOpsMixin[S1], NDFrame): def __sub__(self, other: num | _ListLike | Series) -> Series: ... @overload def __truediv__( - self: Series[Never], other: num | _ListLike | Series | Path + self: Series[Never], other: Path | Scalar | _ListLike | Series ) -> Series: ... @overload - def __truediv__(self: Series, other: Series[Never]) -> Series: ... + def __truediv__(self, other: Series[Never]) -> Series: ... @overload def __truediv__( self: Series[int], @@ -2023,8 +2020,6 @@ class Series(IndexOpsMixin[S1], NDFrame): | Series[_T_COMPLEX] ), ) -> Series[complex]: ... - @overload - def __truediv__(self, other: num | _ListLike | Series[S1] | Path) -> Series: ... # ignore needed for mypy as we want different results based on the arguments @overload # type: ignore[override] def __xor__( # pyright: ignore[reportOverlappingOverload] @@ -2186,13 +2181,6 @@ class Series(IndexOpsMixin[S1], NDFrame): *args: Any, **kwargs: Any, ) -> Series[S1]: ... - def divide( - self, - other: num | _ListLike | Series[S1], - level: Level | None = ..., - fill_value: float | None = ..., - axis: AxisIndex = ..., - ) -> Series[float]: ... def divmod( self, other: num | _ListLike | Series[S1], From 58a668bbb6e72fae1708d01f9fbf8ff7d801d9e4 Mon Sep 17 00:00:00 2001 From: cmp0xff Date: Thu, 31 Jul 2025 09:24:34 +0200 Subject: [PATCH 3/9] fix(typing): truediv --- pandas-stubs/core/series.pyi | 10 +--------- 1 file changed, 1 insertion(+), 9 deletions(-) diff --git a/pandas-stubs/core/series.pyi b/pandas-stubs/core/series.pyi index fc923bfa..d3022105 100644 --- a/pandas-stubs/core/series.pyi +++ b/pandas-stubs/core/series.pyi @@ -2681,7 +2681,7 @@ class Series(IndexOpsMixin[S1], NDFrame): @overload def truediv( self: Series[Never], - other: Scalar | _ListLike | Series, + other: Path | Scalar | _ListLike | Series, level: Level | None = ..., fill_value: float | None = ..., axis: AxisIndex = ..., @@ -2757,14 +2757,6 @@ class Series(IndexOpsMixin[S1], NDFrame): fill_value: float | None = ..., axis: AxisIndex = ..., ) -> Series[complex]: ... - @overload - def truediv( - self, - other: Scalar | _ListLike | Series, - level: Level | None = ..., - fill_value: float | None = ..., - axis: AxisIndex = ..., - ) -> Series: ... def var( self, axis: AxisIndex | None = ..., From e6e47742c294e2a1557f2a82a6b303554892277d Mon Sep 17 00:00:00 2001 From: cmp0xff Date: Thu, 31 Jul 2025 09:40:00 +0200 Subject: [PATCH 4/9] fix(typing): __rtruediv__ and rtruediv --- pandas-stubs/core/series.pyi | 27 ++++++++++++++++++--------- 1 file changed, 18 insertions(+), 9 deletions(-) diff --git a/pandas-stubs/core/series.pyi b/pandas-stubs/core/series.pyi index d3022105..ed8bfd08 100644 --- a/pandas-stubs/core/series.pyi +++ b/pandas-stubs/core/series.pyi @@ -1920,22 +1920,35 @@ class Series(IndexOpsMixin[S1], NDFrame): def __rsub__(self, other: num | _ListLike | Series[S1]) -> Series: ... @overload def __rtruediv__( - self: Series[Never], other: num | _ListLike | Series | Path + self: Series[Never], other: Path | Scalar | _ListLike ) -> Series: ... @overload def __rtruediv__( - self: Series[int], other: int | Sequence[int] + self: Series[int], + other: int | Sequence[int] | 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[int], other: np_ndarray_complex + ) -> Series[complex]: ... + @overload def __rtruediv__( self: Series[float], other: int | Sequence[int] | np_ndarray_anyint | np_ndarray_float, ) -> Series[float]: ... @overload + def __rtruediv__( + 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: ( @@ -1947,11 +1960,7 @@ class Series(IndexOpsMixin[S1], NDFrame): ), ) -> Series[complex]: ... @overload - def __rtruediv__( - self: Series[float], other: _T_COMPLEX | Sequence[_T_COMPLEX] - ) -> Series[_T_COMPLEX]: ... - @overload - def __rtruediv__(self, other: num | _ListLike | Series[S1] | Path) -> Series: ... + def __rtruediv__(self, other: Path) -> Series: ... # ignore needed for mypy as we want different results based on the arguments @overload # type: ignore[override] def __rxor__( # pyright: ignore[reportOverlappingOverload] @@ -2527,7 +2536,7 @@ class Series(IndexOpsMixin[S1], NDFrame): @overload def rtruediv( self: Series[Never], - other: Scalar | _ListLike | Series, + other: Path | Scalar | _ListLike | Series, level: Level | None = ..., fill_value: float | None = ..., axis: AxisIndex = ..., @@ -2598,7 +2607,7 @@ class Series(IndexOpsMixin[S1], NDFrame): @overload def rtruediv( self, - other: Scalar | _ListLike | Series, + other: Path, level: Level | None = ..., fill_value: float | None = ..., axis: AxisIndex = ..., From d02638b7d8aa6609c76aa296a040e533fb85328e Mon Sep 17 00:00:00 2001 From: cmp0xff Date: Fri, 1 Aug 2025 16:17:58 +0200 Subject: [PATCH 5/9] fix(typing): div and rdiv --- pandas-stubs/core/series.pyi | 14 +++----------- 1 file changed, 3 insertions(+), 11 deletions(-) diff --git a/pandas-stubs/core/series.pyi b/pandas-stubs/core/series.pyi index ed8bfd08..fa26c5f6 100644 --- a/pandas-stubs/core/series.pyi +++ b/pandas-stubs/core/series.pyi @@ -432,7 +432,7 @@ class Series(IndexOpsMixin[S1], NDFrame): @overload def div( self: Series[Never], - other: Scalar | _ListLike | Series, + other: Path | Scalar | _ListLike | Series, level: Level | None = ..., fill_value: float | None = ..., axis: AxisIndex = ..., @@ -509,17 +509,9 @@ class Series(IndexOpsMixin[S1], NDFrame): axis: AxisIndex = ..., ) -> Series[complex]: ... @overload - def div( - self, - other: Scalar | _ListLike | Series, - level: Level | None = ..., - fill_value: float | None = ..., - axis: AxisIndex = ..., - ) -> Series: ... - @overload def rdiv( self: Series[Never], - other: Scalar | _ListLike | Series, + other: Path | Scalar | _ListLike | Series, level: Level | None = ..., fill_value: float | None = ..., axis: AxisIndex = ..., @@ -598,7 +590,7 @@ class Series(IndexOpsMixin[S1], NDFrame): @overload def rdiv( self, - other: Scalar | _ListLike | Series, + other: Path, level: Level | None = ..., fill_value: float | None = ..., axis: AxisIndex = ..., From c17f2eec503e8553efa0cfc364cf90f76beb779c Mon Sep 17 00:00:00 2001 From: cmp0xff Date: Fri, 1 Aug 2025 16:20:09 +0200 Subject: [PATCH 6/9] fix(comment): ordering https://github.com/pandas-dev/pandas-stubs/pull/1280#pullrequestreview-3053143453 --- pandas-stubs/core/series.pyi | 332 +++++++++++++++++------------------ 1 file changed, 166 insertions(+), 166 deletions(-) diff --git a/pandas-stubs/core/series.pyi b/pandas-stubs/core/series.pyi index fa26c5f6..7577dc59 100644 --- a/pandas-stubs/core/series.pyi +++ b/pandas-stubs/core/series.pyi @@ -429,172 +429,6 @@ class Series(IndexOpsMixin[S1], NDFrame): ) -> Series: ... @property def hasnans(self) -> bool: ... - @overload - def div( - self: Series[Never], - other: Path | Scalar | _ListLike | Series, - level: Level | None = ..., - fill_value: float | None = ..., - axis: AxisIndex = ..., - ) -> Series: ... - @overload - def div( - self, - other: Series[Never], - level: Level | None = ..., - fill_value: float | None = ..., - axis: AxisIndex = ..., - ) -> Series: ... - @overload - def div( - self: Series[int], - other: int | Sequence[int] | np_ndarray_anyint | np_ndarray_float | Series[int], - level: Level | None = ..., - fill_value: float | None = ..., - axis: AxisIndex = ..., - ) -> Series[float]: ... - @overload - def div( - self: Series[int], - other: _T_COMPLEX | Sequence[_T_COMPLEX] | Series[_T_COMPLEX], - level: Level | None = ..., - fill_value: float | None = ..., - axis: AxisIndex = ..., - ) -> Series[_T_COMPLEX]: ... - @overload - def div( - self: Series[int], - other: np_ndarray_complex, - level: Level | None = ..., - fill_value: float | None = ..., - axis: AxisIndex = ..., - ) -> Series[complex]: ... - @overload - def div( - self: Series[float], - other: int | Sequence[int] | np_ndarray_anyint | np_ndarray_float | Series[int], - level: Level | None = ..., - fill_value: float | None = ..., - axis: AxisIndex = ..., - ) -> Series[float]: ... - @overload - def div( - self: Series[float], - other: _T_COMPLEX | Sequence[_T_COMPLEX] | Series[_T_COMPLEX], - level: Level | None = ..., - fill_value: float | None = ..., - axis: AxisIndex = ..., - ) -> Series[_T_COMPLEX]: ... - @overload - def div( - self: Series[float], - other: np_ndarray_complex, - level: Level | None = ..., - fill_value: float | None = ..., - axis: AxisIndex = ..., - ) -> Series[complex]: ... - @overload - def div( - self: Series[complex], - other: ( - _T_COMPLEX - | Sequence[_T_COMPLEX] - | np_ndarray_anyint - | np_ndarray_float - | np_ndarray_complex - | Series[_T_COMPLEX] - ), - level: Level | None = ..., - fill_value: float | None = ..., - axis: AxisIndex = ..., - ) -> Series[complex]: ... - @overload - def rdiv( - self: Series[Never], - other: Path | Scalar | _ListLike | Series, - level: Level | None = ..., - fill_value: float | None = ..., - axis: AxisIndex = ..., - ) -> Series: ... - @overload - def rdiv( - self, - other: Series[Never], - level: Level | None = ..., - fill_value: float | None = ..., - axis: AxisIndex = ..., - ) -> Series: ... - @overload - def rdiv( - self: Series[int], - other: int | Sequence[int] | np_ndarray_anyint | np_ndarray_float | Series[int], - level: Level | None = ..., - fill_value: float | None = ..., - axis: AxisIndex = ..., - ) -> Series[float]: ... - @overload - def rdiv( - self: Series[int], - other: _T_COMPLEX | Sequence[_T_COMPLEX] | Series[_T_COMPLEX], - level: Level | None = ..., - fill_value: float | None = ..., - axis: AxisIndex = ..., - ) -> Series[_T_COMPLEX]: ... - @overload - def rdiv( - self: Series[int], - other: np_ndarray_complex, - level: Level | None = ..., - fill_value: float | None = ..., - axis: AxisIndex = ..., - ) -> Series[complex]: ... - @overload - def rdiv( - self: Series[float], - other: int | Sequence[int] | np_ndarray_anyint | np_ndarray_float | Series[int], - level: Level | None = ..., - fill_value: float | None = ..., - axis: AxisIndex = ..., - ) -> Series[float]: ... - @overload - def rdiv( - self: Series[float], - other: _T_COMPLEX | Sequence[_T_COMPLEX] | Series[_T_COMPLEX], - level: Level | None = ..., - fill_value: float | None = ..., - axis: AxisIndex = ..., - ) -> Series[_T_COMPLEX]: ... - @overload - def rdiv( - self: Series[float], - other: np_ndarray_complex, - level: Level | None = ..., - fill_value: float | None = ..., - axis: AxisIndex = ..., - ) -> Series[complex]: ... - @overload - def rdiv( - self: Series[complex], - other: ( - _T_COMPLEX - | Sequence[_T_COMPLEX] - | np_ndarray_anyint - | np_ndarray_float - | np_ndarray_complex - | Series[_T_COMPLEX] - ), - level: Level | None = ..., - fill_value: float | None = ..., - axis: AxisIndex = ..., - ) -> Series[complex]: ... - @overload - def rdiv( - self, - other: Path, - level: Level | None = ..., - fill_value: float | None = ..., - axis: AxisIndex = ..., - ) -> Series: ... @property def dtype(self) -> DtypeObj: ... @property @@ -2604,6 +2438,93 @@ class Series(IndexOpsMixin[S1], NDFrame): fill_value: float | None = ..., axis: AxisIndex = ..., ) -> Series: ... + @overload + def rdiv( + self: Series[Never], + other: Path | Scalar | _ListLike | Series, + level: Level | None = ..., + fill_value: float | None = ..., + axis: AxisIndex = ..., + ) -> Series: ... + @overload + def rdiv( + self, + other: Series[Never], + level: Level | None = ..., + fill_value: float | None = ..., + axis: AxisIndex = ..., + ) -> Series: ... + @overload + def rdiv( + self: Series[int], + other: int | Sequence[int] | np_ndarray_anyint | np_ndarray_float | Series[int], + level: Level | None = ..., + fill_value: float | None = ..., + axis: AxisIndex = ..., + ) -> Series[float]: ... + @overload + def rdiv( + self: Series[int], + other: _T_COMPLEX | Sequence[_T_COMPLEX] | Series[_T_COMPLEX], + level: Level | None = ..., + fill_value: float | None = ..., + axis: AxisIndex = ..., + ) -> Series[_T_COMPLEX]: ... + @overload + def rdiv( + self: Series[int], + other: np_ndarray_complex, + level: Level | None = ..., + fill_value: float | None = ..., + axis: AxisIndex = ..., + ) -> Series[complex]: ... + @overload + def rdiv( + self: Series[float], + other: int | Sequence[int] | np_ndarray_anyint | np_ndarray_float | Series[int], + level: Level | None = ..., + fill_value: float | None = ..., + axis: AxisIndex = ..., + ) -> Series[float]: ... + @overload + def rdiv( + self: Series[float], + other: _T_COMPLEX | Sequence[_T_COMPLEX] | Series[_T_COMPLEX], + level: Level | None = ..., + fill_value: float | None = ..., + axis: AxisIndex = ..., + ) -> Series[_T_COMPLEX]: ... + @overload + def rdiv( + self: Series[float], + other: np_ndarray_complex, + level: Level | None = ..., + fill_value: float | None = ..., + axis: AxisIndex = ..., + ) -> Series[complex]: ... + @overload + def rdiv( + self: Series[complex], + other: ( + _T_COMPLEX + | Sequence[_T_COMPLEX] + | np_ndarray_anyint + | np_ndarray_float + | np_ndarray_complex + | Series[_T_COMPLEX] + ), + level: Level | None = ..., + fill_value: float | None = ..., + axis: AxisIndex = ..., + ) -> Series[complex]: ... + @overload + def rdiv( + self, + other: Path, + level: Level | None = ..., + fill_value: float | None = ..., + axis: AxisIndex = ..., + ) -> Series: ... def sem( self, axis: AxisIndex | None = ..., @@ -2758,6 +2679,85 @@ class Series(IndexOpsMixin[S1], NDFrame): fill_value: float | None = ..., axis: AxisIndex = ..., ) -> Series[complex]: ... + @overload + def div( + self: Series[Never], + other: Path | Scalar | _ListLike | Series, + level: Level | None = ..., + fill_value: float | None = ..., + axis: AxisIndex = ..., + ) -> Series: ... + @overload + def div( + self, + other: Series[Never], + level: Level | None = ..., + fill_value: float | None = ..., + axis: AxisIndex = ..., + ) -> Series: ... + @overload + def div( + self: Series[int], + other: int | Sequence[int] | np_ndarray_anyint | np_ndarray_float | Series[int], + level: Level | None = ..., + fill_value: float | None = ..., + axis: AxisIndex = ..., + ) -> Series[float]: ... + @overload + def div( + self: Series[int], + other: _T_COMPLEX | Sequence[_T_COMPLEX] | Series[_T_COMPLEX], + level: Level | None = ..., + fill_value: float | None = ..., + axis: AxisIndex = ..., + ) -> Series[_T_COMPLEX]: ... + @overload + def div( + self: Series[int], + other: np_ndarray_complex, + level: Level | None = ..., + fill_value: float | None = ..., + axis: AxisIndex = ..., + ) -> Series[complex]: ... + @overload + def div( + self: Series[float], + other: int | Sequence[int] | np_ndarray_anyint | np_ndarray_float | Series[int], + level: Level | None = ..., + fill_value: float | None = ..., + axis: AxisIndex = ..., + ) -> Series[float]: ... + @overload + def div( + self: Series[float], + other: _T_COMPLEX | Sequence[_T_COMPLEX] | Series[_T_COMPLEX], + level: Level | None = ..., + fill_value: float | None = ..., + axis: AxisIndex = ..., + ) -> Series[_T_COMPLEX]: ... + @overload + def div( + self: Series[float], + other: np_ndarray_complex, + level: Level | None = ..., + fill_value: float | None = ..., + axis: AxisIndex = ..., + ) -> Series[complex]: ... + @overload + def div( + self: Series[complex], + other: ( + _T_COMPLEX + | Sequence[_T_COMPLEX] + | np_ndarray_anyint + | np_ndarray_float + | np_ndarray_complex + | Series[_T_COMPLEX] + ), + level: Level | None = ..., + fill_value: float | None = ..., + axis: AxisIndex = ..., + ) -> Series[complex]: ... def var( self, axis: AxisIndex | None = ..., From 465add678622b647cc668e36529592b5a3fcac08 Mon Sep 17 00:00:00 2001 From: cmp0xff Date: Fri, 1 Aug 2025 16:32:09 +0200 Subject: [PATCH 7/9] fix(comment): https://github.com/pandas-dev/pandas-stubs/pull/1302#discussion_r2247860692 --- tests/series/arithmetic/complex/test_add.py | 136 +++++---- .../series/arithmetic/complex/test_truediv.py | 279 ++++++++++++------ tests/series/arithmetic/float/test_add.py | 108 ++++--- tests/series/arithmetic/float/test_truediv.py | 199 +++++++------ tests/series/arithmetic/int/test_add.py | 104 ++++--- tests/series/arithmetic/int/test_truediv.py | 199 +++++++------ tests/series/arithmetic/test_truediv.py | 22 +- 7 files changed, 632 insertions(+), 415 deletions(-) diff --git a/tests/series/arithmetic/complex/test_add.py b/tests/series/arithmetic/complex/test_add.py index 2ab7d1af..26920408 100644 --- a/tests/series/arithmetic/complex/test_add.py +++ b/tests/series/arithmetic/complex/test_add.py @@ -12,42 +12,54 @@ def test_add_py_scalar() -> None: """Test pd.Series[complex] + Python native scalars""" i, f, c = 1, 1.0, 1j - check(assert_type(left + i, "pd.Series[complex]"), pd.Series, np.complex128) - check(assert_type(left + f, "pd.Series[complex]"), pd.Series, np.complex128) - check(assert_type(left + c, "pd.Series[complex]"), pd.Series, np.complex128) + 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(i + left, "pd.Series[complex]"), pd.Series, np.complex128) - check(assert_type(f + left, "pd.Series[complex]"), pd.Series, np.complex128) - check(assert_type(c + left, "pd.Series[complex]"), pd.Series, np.complex128) + 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.add(i), "pd.Series[complex]"), pd.Series, np.complex128) - check(assert_type(left.add(f), "pd.Series[complex]"), pd.Series, np.complex128) - check(assert_type(left.add(c), "pd.Series[complex]"), pd.Series, np.complex128) + check(assert_type(left.add(i), "pd.Series[complex]"), pd.Series, np.complexfloating) + check(assert_type(left.add(f), "pd.Series[complex]"), pd.Series, np.complexfloating) + check(assert_type(left.add(c), "pd.Series[complex]"), pd.Series, np.complexfloating) - check(assert_type(left.radd(i), "pd.Series[complex]"), pd.Series, np.complex128) - check(assert_type(left.radd(f), "pd.Series[complex]"), pd.Series, np.complex128) - check(assert_type(left.radd(c), "pd.Series[complex]"), pd.Series, np.complex128) + check( + assert_type(left.radd(i), "pd.Series[complex]"), pd.Series, np.complexfloating + ) + check( + assert_type(left.radd(f), "pd.Series[complex]"), pd.Series, np.complexfloating + ) + check( + assert_type(left.radd(c), "pd.Series[complex]"), pd.Series, np.complexfloating + ) def test_add_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] - check(assert_type(left + i, "pd.Series[complex]"), pd.Series, np.complex128) - check(assert_type(left + f, "pd.Series[complex]"), pd.Series, np.complex128) - check(assert_type(left + c, "pd.Series[complex]"), pd.Series, np.complex128) + 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(i + left, "pd.Series[complex]"), pd.Series, np.complex128) - check(assert_type(f + left, "pd.Series[complex]"), pd.Series, np.complex128) - check(assert_type(c + left, "pd.Series[complex]"), pd.Series, np.complex128) + 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.add(i), "pd.Series[complex]"), pd.Series, np.complex128) - check(assert_type(left.add(f), "pd.Series[complex]"), pd.Series, np.complex128) - check(assert_type(left.add(c), "pd.Series[complex]"), pd.Series, np.complex128) + check(assert_type(left.add(i), "pd.Series[complex]"), pd.Series, np.complexfloating) + check(assert_type(left.add(f), "pd.Series[complex]"), pd.Series, np.complexfloating) + check(assert_type(left.add(c), "pd.Series[complex]"), pd.Series, np.complexfloating) - check(assert_type(left.radd(i), "pd.Series[complex]"), pd.Series, np.complex128) - check(assert_type(left.radd(f), "pd.Series[complex]"), pd.Series, np.complex128) - check(assert_type(left.radd(c), "pd.Series[complex]"), pd.Series, np.complex128) + check( + assert_type(left.radd(i), "pd.Series[complex]"), pd.Series, np.complexfloating + ) + check( + assert_type(left.radd(f), "pd.Series[complex]"), pd.Series, np.complexfloating + ) + check( + assert_type(left.radd(c), "pd.Series[complex]"), pd.Series, np.complexfloating + ) def test_add_numpy_array() -> None: @@ -56,24 +68,36 @@ def test_add_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 + i, "pd.Series[complex]"), pd.Series, np.complex128) - check(assert_type(left + f, "pd.Series[complex]"), pd.Series, np.complex128) - check(assert_type(left + c, "pd.Series[complex]"), pd.Series, np.complex128) + 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) # `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. - check(assert_type(i + left, "npt.NDArray[np.int64]"), pd.Series, np.complex128) - check(assert_type(f + left, "npt.NDArray[np.float64]"), pd.Series, np.complex128) - check(assert_type(c + left, "npt.NDArray[np.complex128]"), pd.Series, np.complex128) - - check(assert_type(left.add(i), "pd.Series[complex]"), pd.Series, np.complex128) - check(assert_type(left.add(f), "pd.Series[complex]"), pd.Series, np.complex128) - check(assert_type(left.add(c), "pd.Series[complex]"), pd.Series, np.complex128) - - check(assert_type(left.radd(i), "pd.Series[complex]"), pd.Series, np.complex128) - check(assert_type(left.radd(f), "pd.Series[complex]"), pd.Series, np.complex128) - check(assert_type(left.radd(c), "pd.Series[complex]"), pd.Series, np.complex128) + check(assert_type(i + left, "npt.NDArray[np.int64]"), pd.Series, np.complexfloating) + check( + assert_type(f + left, "npt.NDArray[np.float64]"), pd.Series, np.complexfloating + ) + check( + assert_type(c + left, "npt.NDArray[np.complex128]"), + pd.Series, + np.complexfloating, + ) + + check(assert_type(left.add(i), "pd.Series[complex]"), pd.Series, np.complexfloating) + check(assert_type(left.add(f), "pd.Series[complex]"), pd.Series, np.complexfloating) + check(assert_type(left.add(c), "pd.Series[complex]"), pd.Series, np.complexfloating) + + check( + assert_type(left.radd(i), "pd.Series[complex]"), pd.Series, np.complexfloating + ) + check( + assert_type(left.radd(f), "pd.Series[complex]"), pd.Series, np.complexfloating + ) + check( + assert_type(left.radd(c), "pd.Series[complex]"), pd.Series, np.complexfloating + ) def test_add_pd_series() -> None: @@ -82,18 +106,24 @@ def test_add_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 + i, "pd.Series[complex]"), pd.Series, np.complex128) - check(assert_type(left + f, "pd.Series[complex]"), pd.Series, np.complex128) - check(assert_type(left + c, "pd.Series[complex]"), pd.Series, np.complex128) - - check(assert_type(i + left, "pd.Series[complex]"), pd.Series, np.complex128) - check(assert_type(f + left, "pd.Series[complex]"), pd.Series, np.complex128) - check(assert_type(c + left, "pd.Series[complex]"), pd.Series, np.complex128) - - check(assert_type(left.add(i), "pd.Series[complex]"), pd.Series, np.complex128) - check(assert_type(left.add(f), "pd.Series[complex]"), pd.Series, np.complex128) - check(assert_type(left.add(c), "pd.Series[complex]"), pd.Series, np.complex128) - - check(assert_type(left.radd(i), "pd.Series[complex]"), pd.Series, np.complex128) - check(assert_type(left.radd(f), "pd.Series[complex]"), pd.Series, np.complex128) - check(assert_type(left.radd(c), "pd.Series[complex]"), pd.Series, np.complex128) + 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(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.add(i), "pd.Series[complex]"), pd.Series, np.complexfloating) + check(assert_type(left.add(f), "pd.Series[complex]"), pd.Series, np.complexfloating) + check(assert_type(left.add(c), "pd.Series[complex]"), pd.Series, np.complexfloating) + + check( + assert_type(left.radd(i), "pd.Series[complex]"), pd.Series, np.complexfloating + ) + check( + assert_type(left.radd(f), "pd.Series[complex]"), pd.Series, np.complexfloating + ) + check( + assert_type(left.radd(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 d08c7caf..996541b8 100644 --- a/tests/series/arithmetic/complex/test_truediv.py +++ b/tests/series/arithmetic/complex/test_truediv.py @@ -1,4 +1,5 @@ import numpy as np +from numpy import typing as npt # noqa: F401 import pandas as pd from typing_extensions import assert_type @@ -11,58 +12,118 @@ def test_truediv_py_scalar() -> None: """Test pd.Series[complex] / Python native scalars""" i, f, c = 1, 1.0, 1j - check(assert_type(left / i, "pd.Series[complex]"), pd.Series, np.complex128) - check(assert_type(left / f, "pd.Series[complex]"), pd.Series, np.complex128) - check(assert_type(left / c, "pd.Series[complex]"), pd.Series, np.complex128) + 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(i / left, "pd.Series[complex]"), pd.Series, np.complex128) - check(assert_type(f / left, "pd.Series[complex]"), pd.Series, np.complex128) - check(assert_type(c / left, "pd.Series[complex]"), pd.Series, np.complex128) + 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(i), "pd.Series[complex]"), pd.Series, np.complex128) - check(assert_type(left.truediv(f), "pd.Series[complex]"), pd.Series, np.complex128) - check(assert_type(left.truediv(c), "pd.Series[complex]"), pd.Series, np.complex128) + check( + assert_type(left.truediv(i), "pd.Series[complex]"), + pd.Series, + np.complexfloating, + ) + check( + assert_type(left.truediv(f), "pd.Series[complex]"), + pd.Series, + np.complexfloating, + ) + check( + assert_type(left.truediv(c), "pd.Series[complex]"), + pd.Series, + np.complexfloating, + ) - check(assert_type(left.div(i), "pd.Series[complex]"), pd.Series, np.complex128) - check(assert_type(left.div(f), "pd.Series[complex]"), pd.Series, np.complex128) - check(assert_type(left.div(c), "pd.Series[complex]"), pd.Series, np.complex128) + 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(i), "pd.Series[complex]"), pd.Series, np.complex128) - check(assert_type(left.rtruediv(f), "pd.Series[complex]"), pd.Series, np.complex128) - check(assert_type(left.rtruediv(c), "pd.Series[complex]"), pd.Series, np.complex128) + check( + assert_type(left.rtruediv(i), "pd.Series[complex]"), + pd.Series, + np.complexfloating, + ) + check( + assert_type(left.rtruediv(f), "pd.Series[complex]"), + pd.Series, + np.complexfloating, + ) + check( + assert_type(left.rtruediv(c), "pd.Series[complex]"), + pd.Series, + np.complexfloating, + ) - check(assert_type(left.rdiv(i), "pd.Series[complex]"), pd.Series, np.complex128) - check(assert_type(left.rdiv(f), "pd.Series[complex]"), pd.Series, np.complex128) - check(assert_type(left.rdiv(c), "pd.Series[complex]"), pd.Series, np.complex128) + check( + assert_type(left.rdiv(i), "pd.Series[complex]"), pd.Series, np.complexfloating + ) + check( + assert_type(left.rdiv(f), "pd.Series[complex]"), pd.Series, np.complexfloating + ) + check( + assert_type(left.rdiv(c), "pd.Series[complex]"), pd.Series, np.complexfloating + ) 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] - check(assert_type(left / i, "pd.Series[complex]"), pd.Series, np.complex128) - check(assert_type(left / f, "pd.Series[complex]"), pd.Series, np.complex128) - check(assert_type(left / c, "pd.Series[complex]"), pd.Series, np.complex128) + 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(i / left, "pd.Series[complex]"), pd.Series, np.complex128) - check(assert_type(f / left, "pd.Series[complex]"), pd.Series, np.complex128) - check(assert_type(c / left, "pd.Series[complex]"), pd.Series, np.complex128) + 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(i), "pd.Series[complex]"), pd.Series, np.complex128) - check(assert_type(left.truediv(f), "pd.Series[complex]"), pd.Series, np.complex128) - check(assert_type(left.truediv(c), "pd.Series[complex]"), pd.Series, np.complex128) + check( + assert_type(left.truediv(i), "pd.Series[complex]"), + pd.Series, + np.complexfloating, + ) + check( + assert_type(left.truediv(f), "pd.Series[complex]"), + pd.Series, + np.complexfloating, + ) + check( + assert_type(left.truediv(c), "pd.Series[complex]"), + pd.Series, + np.complexfloating, + ) - check(assert_type(left.div(i), "pd.Series[complex]"), pd.Series, np.complex128) - check(assert_type(left.div(f), "pd.Series[complex]"), pd.Series, np.complex128) - check(assert_type(left.div(c), "pd.Series[complex]"), pd.Series, np.complex128) + 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(i), "pd.Series[complex]"), pd.Series, np.complex128) - check(assert_type(left.rtruediv(f), "pd.Series[complex]"), pd.Series, np.complex128) - check(assert_type(left.rtruediv(c), "pd.Series[complex]"), pd.Series, np.complex128) + check( + assert_type(left.rtruediv(i), "pd.Series[complex]"), + pd.Series, + np.complexfloating, + ) + check( + assert_type(left.rtruediv(f), "pd.Series[complex]"), + pd.Series, + np.complexfloating, + ) + check( + assert_type(left.rtruediv(c), "pd.Series[complex]"), + pd.Series, + np.complexfloating, + ) - check(assert_type(left.rdiv(i), "pd.Series[complex]"), pd.Series, np.complex128) - check(assert_type(left.rdiv(f), "pd.Series[complex]"), pd.Series, np.complex128) - check(assert_type(left.rdiv(c), "pd.Series[complex]"), pd.Series, np.complex128) + check( + assert_type(left.rdiv(i), "pd.Series[complex]"), pd.Series, np.complexfloating + ) + check( + assert_type(left.rdiv(f), "pd.Series[complex]"), pd.Series, np.complexfloating + ) + check( + assert_type(left.rdiv(c), "pd.Series[complex]"), pd.Series, np.complexfloating + ) def test_truediv_numpy_array() -> None: @@ -71,48 +132,70 @@ 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 / i, "pd.Series[complex]"), pd.Series, np.complex128) - check(assert_type(left / f, "pd.Series[complex]"), pd.Series, np.complex128) - check(assert_type(left / c, "pd.Series[complex]"), pd.Series, np.complex128) + 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) - # numpy typing gives ndarray instead of `pd.Series[...]` in reality, which we cannot fix + # `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( # type: ignore[assert-type] - i / left, "pd.Series[complex]" # pyright: ignore[reportAssertTypeFailure] - ), + assert_type(i / left, "npt.NDArray[np.float64]"), pd.Series, np.complexfloating + ) + check( + assert_type(f / left, "npt.NDArray[np.float64]"), pd.Series, np.complexfloating + ) + check( + assert_type(c / left, "npt.NDArray[np.complex128]"), pd.Series, - np.complex128, + np.complexfloating, ) + check( - assert_type( # type: ignore[assert-type] - f / left, "pd.Series[complex]" # pyright: ignore[reportAssertTypeFailure] - ), + assert_type(left.truediv(i), "pd.Series[complex]"), pd.Series, - np.complex128, + np.complexfloating, ) check( - assert_type( # type: ignore[assert-type] - c / left, "pd.Series[complex]" # pyright: ignore[reportAssertTypeFailure] - ), + assert_type(left.truediv(f), "pd.Series[complex]"), pd.Series, - np.complex128, + np.complexfloating, + ) + check( + assert_type(left.truediv(c), "pd.Series[complex]"), + pd.Series, + np.complexfloating, ) - check(assert_type(left.truediv(i), "pd.Series[complex]"), pd.Series, np.complex128) - check(assert_type(left.truediv(f), "pd.Series[complex]"), pd.Series, np.complex128) - check(assert_type(left.truediv(c), "pd.Series[complex]"), pd.Series, np.complex128) - - check(assert_type(left.div(i), "pd.Series[complex]"), pd.Series, np.complex128) - check(assert_type(left.div(f), "pd.Series[complex]"), pd.Series, np.complex128) - check(assert_type(left.div(c), "pd.Series[complex]"), pd.Series, np.complex128) + 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(i), "pd.Series[complex]"), pd.Series, np.complex128) - check(assert_type(left.rtruediv(f), "pd.Series[complex]"), pd.Series, np.complex128) - check(assert_type(left.rtruediv(c), "pd.Series[complex]"), pd.Series, np.complex128) + check( + assert_type(left.rtruediv(i), "pd.Series[complex]"), + pd.Series, + np.complexfloating, + ) + check( + assert_type(left.rtruediv(f), "pd.Series[complex]"), + pd.Series, + np.complexfloating, + ) + check( + assert_type(left.rtruediv(c), "pd.Series[complex]"), + pd.Series, + np.complexfloating, + ) - check(assert_type(left.rdiv(i), "pd.Series[complex]"), pd.Series, np.complex128) - check(assert_type(left.rdiv(f), "pd.Series[complex]"), pd.Series, np.complex128) - check(assert_type(left.rdiv(c), "pd.Series[complex]"), pd.Series, np.complex128) + check( + assert_type(left.rdiv(i), "pd.Series[complex]"), pd.Series, np.complexfloating + ) + check( + assert_type(left.rdiv(f), "pd.Series[complex]"), pd.Series, np.complexfloating + ) + check( + assert_type(left.rdiv(c), "pd.Series[complex]"), pd.Series, np.complexfloating + ) def test_truediv_pd_series() -> None: @@ -121,26 +204,56 @@ 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 / i, "pd.Series[complex]"), pd.Series, np.complex128) - check(assert_type(left / f, "pd.Series[complex]"), pd.Series, np.complex128) - check(assert_type(left / c, "pd.Series[complex]"), pd.Series, np.complex128) + 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(i / left, "pd.Series[complex]"), pd.Series, np.complex128) - check(assert_type(f / left, "pd.Series[complex]"), pd.Series, np.complex128) - check(assert_type(c / left, "pd.Series[complex]"), pd.Series, np.complex128) + 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(i), "pd.Series[complex]"), pd.Series, np.complex128) - check(assert_type(left.truediv(f), "pd.Series[complex]"), pd.Series, np.complex128) - check(assert_type(left.truediv(c), "pd.Series[complex]"), pd.Series, np.complex128) + check( + assert_type(left.truediv(i), "pd.Series[complex]"), + pd.Series, + np.complexfloating, + ) + check( + assert_type(left.truediv(f), "pd.Series[complex]"), + pd.Series, + np.complexfloating, + ) + check( + assert_type(left.truediv(c), "pd.Series[complex]"), + pd.Series, + np.complexfloating, + ) - check(assert_type(left.div(i), "pd.Series[complex]"), pd.Series, np.complex128) - check(assert_type(left.div(f), "pd.Series[complex]"), pd.Series, np.complex128) - check(assert_type(left.div(c), "pd.Series[complex]"), pd.Series, np.complex128) + 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(i), "pd.Series[complex]"), pd.Series, np.complex128) - check(assert_type(left.rtruediv(f), "pd.Series[complex]"), pd.Series, np.complex128) - check(assert_type(left.rtruediv(c), "pd.Series[complex]"), pd.Series, np.complex128) + check( + assert_type(left.rtruediv(i), "pd.Series[complex]"), + pd.Series, + np.complexfloating, + ) + check( + assert_type(left.rtruediv(f), "pd.Series[complex]"), + pd.Series, + np.complexfloating, + ) + check( + assert_type(left.rtruediv(c), "pd.Series[complex]"), + pd.Series, + np.complexfloating, + ) - check(assert_type(left.rdiv(i), "pd.Series[complex]"), pd.Series, np.complex128) - check(assert_type(left.rdiv(f), "pd.Series[complex]"), pd.Series, np.complex128) - check(assert_type(left.rdiv(c), "pd.Series[complex]"), pd.Series, np.complex128) + check( + assert_type(left.rdiv(i), "pd.Series[complex]"), pd.Series, np.complexfloating + ) + check( + assert_type(left.rdiv(f), "pd.Series[complex]"), pd.Series, np.complexfloating + ) + check( + assert_type(left.rdiv(c), "pd.Series[complex]"), pd.Series, np.complexfloating + ) diff --git a/tests/series/arithmetic/float/test_add.py b/tests/series/arithmetic/float/test_add.py index 61b77742..6864c596 100644 --- a/tests/series/arithmetic/float/test_add.py +++ b/tests/series/arithmetic/float/test_add.py @@ -12,42 +12,46 @@ def test_add_py_scalar() -> None: """Test pd.Series[float] + Python native scalars""" i, f, c = 1, 1.0, 1j - check(assert_type(left + i, "pd.Series[float]"), pd.Series, np.float64) - check(assert_type(left + f, "pd.Series[float]"), pd.Series, np.float64) - check(assert_type(left + c, "pd.Series[complex]"), pd.Series, 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) - check(assert_type(i + left, "pd.Series[float]"), pd.Series, np.float64) - check(assert_type(f + left, "pd.Series[float]"), pd.Series, np.float64) - check(assert_type(c + left, "pd.Series[complex]"), pd.Series, np.complex128) + 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.add(i), "pd.Series[float]"), pd.Series, np.float64) - check(assert_type(left.add(f), "pd.Series[float]"), pd.Series, np.float64) - check(assert_type(left.add(c), "pd.Series[complex]"), pd.Series, np.complex128) + check(assert_type(left.add(i), "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(left.add(f), "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(left.add(c), "pd.Series[complex]"), pd.Series, np.complexfloating) - check(assert_type(left.radd(i), "pd.Series[float]"), pd.Series, np.float64) - check(assert_type(left.radd(f), "pd.Series[float]"), pd.Series, np.float64) - check(assert_type(left.radd(c), "pd.Series[complex]"), pd.Series, np.complex128) + check(assert_type(left.radd(i), "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(left.radd(f), "pd.Series[float]"), pd.Series, np.floating) + check( + assert_type(left.radd(c), "pd.Series[complex]"), pd.Series, np.complexfloating + ) def test_add_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] - check(assert_type(left + i, "pd.Series[float]"), pd.Series, np.float64) - check(assert_type(left + f, "pd.Series[float]"), pd.Series, np.float64) - check(assert_type(left + c, "pd.Series[complex]"), pd.Series, 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) - check(assert_type(i + left, "pd.Series[float]"), pd.Series, np.float64) - check(assert_type(f + left, "pd.Series[float]"), pd.Series, np.float64) - check(assert_type(c + left, "pd.Series[complex]"), pd.Series, np.complex128) + 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.add(i), "pd.Series[float]"), pd.Series, np.float64) - check(assert_type(left.add(f), "pd.Series[float]"), pd.Series, np.float64) - check(assert_type(left.add(c), "pd.Series[complex]"), pd.Series, np.complex128) + check(assert_type(left.add(i), "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(left.add(f), "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(left.add(c), "pd.Series[complex]"), pd.Series, np.complexfloating) - check(assert_type(left.radd(i), "pd.Series[float]"), pd.Series, np.float64) - check(assert_type(left.radd(f), "pd.Series[float]"), pd.Series, np.float64) - check(assert_type(left.radd(c), "pd.Series[complex]"), pd.Series, np.complex128) + check(assert_type(left.radd(i), "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(left.radd(f), "pd.Series[float]"), pd.Series, np.floating) + check( + assert_type(left.radd(c), "pd.Series[complex]"), pd.Series, np.complexfloating + ) def test_add_numpy_array() -> None: @@ -56,24 +60,30 @@ def test_add_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 + i, "pd.Series[float]"), pd.Series, np.float64) - check(assert_type(left + f, "pd.Series[float]"), pd.Series, np.float64) - check(assert_type(left + c, "pd.Series[complex]"), pd.Series, 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 `__radd__` cannot override. At runtime, they return # `Series`s with the correct element type. - check(assert_type(i + left, "npt.NDArray[np.int64]"), pd.Series, np.float64) - check(assert_type(f + left, "npt.NDArray[np.float64]"), pd.Series, np.float64) - check(assert_type(c + left, "npt.NDArray[np.complex128]"), pd.Series, np.complex128) + 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) + check( + assert_type(c + left, "npt.NDArray[np.complex128]"), + pd.Series, + np.complexfloating, + ) - check(assert_type(left.add(i), "pd.Series[float]"), pd.Series, np.float64) - check(assert_type(left.add(f), "pd.Series[float]"), pd.Series, np.float64) - check(assert_type(left.add(c), "pd.Series[complex]"), pd.Series, np.complex128) + check(assert_type(left.add(i), "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(left.add(f), "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(left.add(c), "pd.Series[complex]"), pd.Series, np.complexfloating) - check(assert_type(left.radd(i), "pd.Series[float]"), pd.Series, np.float64) - check(assert_type(left.radd(f), "pd.Series[float]"), pd.Series, np.float64) - check(assert_type(left.radd(c), "pd.Series[complex]"), pd.Series, np.complex128) + check(assert_type(left.radd(i), "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(left.radd(f), "pd.Series[float]"), pd.Series, np.floating) + check( + assert_type(left.radd(c), "pd.Series[complex]"), pd.Series, np.complexfloating + ) def test_add_pd_series() -> None: @@ -82,18 +92,20 @@ def test_add_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 + i, "pd.Series[float]"), pd.Series, np.float64) - check(assert_type(left + f, "pd.Series[float]"), pd.Series, np.float64) - check(assert_type(left + c, "pd.Series[complex]"), pd.Series, 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) - check(assert_type(i + left, "pd.Series[float]"), pd.Series, np.float64) - check(assert_type(f + left, "pd.Series[float]"), pd.Series, np.float64) - check(assert_type(c + left, "pd.Series[complex]"), pd.Series, np.complex128) + 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.add(i), "pd.Series[float]"), pd.Series, np.float64) - check(assert_type(left.add(f), "pd.Series[float]"), pd.Series, np.float64) - check(assert_type(left.add(c), "pd.Series[complex]"), pd.Series, np.complex128) + check(assert_type(left.add(i), "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(left.add(f), "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(left.add(c), "pd.Series[complex]"), pd.Series, np.complexfloating) - check(assert_type(left.radd(i), "pd.Series[float]"), pd.Series, np.float64) - check(assert_type(left.radd(f), "pd.Series[float]"), pd.Series, np.float64) - check(assert_type(left.radd(c), "pd.Series[complex]"), pd.Series, np.complex128) + check(assert_type(left.radd(i), "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(left.radd(f), "pd.Series[float]"), pd.Series, np.floating) + check( + assert_type(left.radd(c), "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 1e440b9f..2bb8c482 100644 --- a/tests/series/arithmetic/float/test_truediv.py +++ b/tests/series/arithmetic/float/test_truediv.py @@ -1,4 +1,5 @@ import numpy as np +from numpy import typing as npt # noqa: F401 import pandas as pd from typing_extensions import assert_type @@ -11,58 +12,78 @@ def test_truediv_py_scalar() -> None: """Test pd.Series[float] / Python native scalars""" i, f, c = 1, 1.0, 1j - check(assert_type(left / i, "pd.Series[float]"), pd.Series, np.float64) - check(assert_type(left / f, "pd.Series[float]"), pd.Series, np.float64) - check(assert_type(left / c, "pd.Series[complex]"), pd.Series, 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) - check(assert_type(i / left, "pd.Series[float]"), pd.Series, np.float64) - check(assert_type(f / left, "pd.Series[float]"), pd.Series, np.float64) - check(assert_type(c / left, "pd.Series[complex]"), pd.Series, np.complex128) + 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.float64) - check(assert_type(left.truediv(f), "pd.Series[float]"), pd.Series, np.float64) - check(assert_type(left.truediv(c), "pd.Series[complex]"), pd.Series, np.complex128) + 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.float64) - check(assert_type(left.div(f), "pd.Series[float]"), pd.Series, np.float64) - check(assert_type(left.div(c), "pd.Series[complex]"), pd.Series, np.complex128) + 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.float64) - check(assert_type(left.rtruediv(f), "pd.Series[float]"), pd.Series, np.float64) - check(assert_type(left.rtruediv(c), "pd.Series[complex]"), pd.Series, np.complex128) + 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.float64) - check(assert_type(left.rdiv(f), "pd.Series[float]"), pd.Series, np.float64) - check(assert_type(left.rdiv(c), "pd.Series[complex]"), pd.Series, np.complex128) + 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[float] / 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.float64) - check(assert_type(left / f, "pd.Series[float]"), pd.Series, np.float64) - check(assert_type(left / c, "pd.Series[complex]"), pd.Series, 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) - check(assert_type(i / left, "pd.Series[float]"), pd.Series, np.float64) - check(assert_type(f / left, "pd.Series[float]"), pd.Series, np.float64) - check(assert_type(c / left, "pd.Series[complex]"), pd.Series, np.complex128) + 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.float64) - check(assert_type(left.truediv(f), "pd.Series[float]"), pd.Series, np.float64) - check(assert_type(left.truediv(c), "pd.Series[complex]"), pd.Series, np.complex128) + 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.float64) - check(assert_type(left.div(f), "pd.Series[float]"), pd.Series, np.float64) - check(assert_type(left.div(c), "pd.Series[complex]"), pd.Series, np.complex128) + 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.float64) - check(assert_type(left.rtruediv(f), "pd.Series[float]"), pd.Series, np.float64) - check(assert_type(left.rtruediv(c), "pd.Series[complex]"), pd.Series, np.complex128) + 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.float64) - check(assert_type(left.rdiv(f), "pd.Series[float]"), pd.Series, np.float64) - check(assert_type(left.rdiv(c), "pd.Series[complex]"), pd.Series, np.complex128) + 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: @@ -71,48 +92,46 @@ 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 / i, "pd.Series[float]"), pd.Series, np.float64) - check(assert_type(left / f, "pd.Series[float]"), pd.Series, np.float64) - check(assert_type(left / c, "pd.Series[complex]"), pd.Series, 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 ndarray instead of `pd.Series[...]` in reality, which we cannot fix + # `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( # type: ignore[assert-type] - i / left, "pd.Series[float]" # pyright: ignore[reportAssertTypeFailure] - ), + assert_type(c / left, "npt.NDArray[np.complex128]"), pd.Series, - np.float64, + 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( # type: ignore[assert-type] - f / left, "pd.Series[float]" # pyright: ignore[reportAssertTypeFailure] - ), + assert_type(left.truediv(c), "pd.Series[complex]"), pd.Series, - np.float64, + 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( # type: ignore[assert-type] - c / left, "pd.Series[complex]" # pyright: ignore[reportAssertTypeFailure] - ), + assert_type(left.rtruediv(c), "pd.Series[complex]"), pd.Series, - np.complex128, + np.complexfloating, ) - check(assert_type(left.truediv(i), "pd.Series[float]"), pd.Series, np.float64) - check(assert_type(left.truediv(f), "pd.Series[float]"), pd.Series, np.float64) - check(assert_type(left.truediv(c), "pd.Series[complex]"), pd.Series, np.complex128) - - check(assert_type(left.div(i), "pd.Series[float]"), pd.Series, np.float64) - check(assert_type(left.div(f), "pd.Series[float]"), pd.Series, np.float64) - check(assert_type(left.div(c), "pd.Series[complex]"), pd.Series, np.complex128) - - check(assert_type(left.rtruediv(i), "pd.Series[float]"), pd.Series, np.float64) - check(assert_type(left.rtruediv(f), "pd.Series[float]"), pd.Series, np.float64) - check(assert_type(left.rtruediv(c), "pd.Series[complex]"), pd.Series, np.complex128) - - check(assert_type(left.rdiv(i), "pd.Series[float]"), pd.Series, np.float64) - check(assert_type(left.rdiv(f), "pd.Series[float]"), pd.Series, np.float64) - check(assert_type(left.rdiv(c), "pd.Series[complex]"), pd.Series, np.complex128) + 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: @@ -121,26 +140,36 @@ 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 / i, "pd.Series[float]"), pd.Series, np.float64) - check(assert_type(left / f, "pd.Series[float]"), pd.Series, np.float64) - check(assert_type(left / c, "pd.Series[complex]"), pd.Series, 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) - check(assert_type(i / left, "pd.Series[float]"), pd.Series, np.float64) - check(assert_type(f / left, "pd.Series[float]"), pd.Series, np.float64) - check(assert_type(c / left, "pd.Series[complex]"), pd.Series, np.complex128) + 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.float64) - check(assert_type(left.truediv(f), "pd.Series[float]"), pd.Series, np.float64) - check(assert_type(left.truediv(c), "pd.Series[complex]"), pd.Series, np.complex128) + 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.float64) - check(assert_type(left.div(f), "pd.Series[float]"), pd.Series, np.float64) - check(assert_type(left.div(c), "pd.Series[complex]"), pd.Series, np.complex128) + 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.float64) - check(assert_type(left.rtruediv(f), "pd.Series[float]"), pd.Series, np.float64) - check(assert_type(left.rtruediv(c), "pd.Series[complex]"), pd.Series, np.complex128) + 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.float64) - check(assert_type(left.rdiv(f), "pd.Series[float]"), pd.Series, np.float64) - check(assert_type(left.rdiv(c), "pd.Series[complex]"), pd.Series, np.complex128) + 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/int/test_add.py b/tests/series/arithmetic/int/test_add.py index ad25aeb3..2117dcd9 100644 --- a/tests/series/arithmetic/int/test_add.py +++ b/tests/series/arithmetic/int/test_add.py @@ -12,42 +12,46 @@ def test_add_py_scalar() -> None: """Test pd.Series[int] + Python native scalars""" i, f, c = 1, 1.0, 1j - check(assert_type(left + i, "pd.Series[int]"), pd.Series, np.int64) - check(assert_type(left + f, "pd.Series[float]"), pd.Series, np.float64) - check(assert_type(left + c, "pd.Series[complex]"), pd.Series, np.complex128) + check(assert_type(left + i, "pd.Series[int]"), pd.Series, np.integer) + 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[int]"), pd.Series, np.int64) - check(assert_type(f + left, "pd.Series[float]"), pd.Series, np.float64) - check(assert_type(c + left, "pd.Series[complex]"), pd.Series, np.complex128) + check(assert_type(i + left, "pd.Series[int]"), pd.Series, np.integer) + 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.add(i), "pd.Series[int]"), pd.Series, np.int64) - check(assert_type(left.add(f), "pd.Series[float]"), pd.Series, np.float64) - check(assert_type(left.add(c), "pd.Series[complex]"), pd.Series, np.complex128) + check(assert_type(left.add(i), "pd.Series[int]"), pd.Series, np.integer) + check(assert_type(left.add(f), "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(left.add(c), "pd.Series[complex]"), pd.Series, np.complexfloating) - check(assert_type(left.radd(i), "pd.Series[int]"), pd.Series, np.int64) - check(assert_type(left.radd(f), "pd.Series[float]"), pd.Series, np.float64) - check(assert_type(left.radd(c), "pd.Series[complex]"), pd.Series, np.complex128) + check(assert_type(left.radd(i), "pd.Series[int]"), pd.Series, np.integer) + check(assert_type(left.radd(f), "pd.Series[float]"), pd.Series, np.floating) + check( + assert_type(left.radd(c), "pd.Series[complex]"), pd.Series, np.complexfloating + ) def test_add_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] - check(assert_type(left + i, "pd.Series[int]"), pd.Series, np.int64) - check(assert_type(left + f, "pd.Series[float]"), pd.Series, np.float64) - check(assert_type(left + c, "pd.Series[complex]"), pd.Series, np.complex128) + check(assert_type(left + i, "pd.Series[int]"), pd.Series, np.integer) + 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[int]"), pd.Series, np.int64) - check(assert_type(f + left, "pd.Series[float]"), pd.Series, np.float64) - check(assert_type(c + left, "pd.Series[complex]"), pd.Series, np.complex128) + check(assert_type(i + left, "pd.Series[int]"), pd.Series, np.integer) + 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.add(i), "pd.Series[int]"), pd.Series, np.int64) - check(assert_type(left.add(f), "pd.Series[float]"), pd.Series, np.float64) - check(assert_type(left.add(c), "pd.Series[complex]"), pd.Series, np.complex128) + check(assert_type(left.add(i), "pd.Series[int]"), pd.Series, np.integer) + check(assert_type(left.add(f), "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(left.add(c), "pd.Series[complex]"), pd.Series, np.complexfloating) - check(assert_type(left.radd(i), "pd.Series[int]"), pd.Series, np.int64) - check(assert_type(left.radd(f), "pd.Series[float]"), pd.Series, np.float64) - check(assert_type(left.radd(c), "pd.Series[complex]"), pd.Series, np.complex128) + check(assert_type(left.radd(i), "pd.Series[int]"), pd.Series, np.integer) + check(assert_type(left.radd(f), "pd.Series[float]"), pd.Series, np.floating) + check( + assert_type(left.radd(c), "pd.Series[complex]"), pd.Series, np.complexfloating + ) def test_add_numpy_array() -> None: @@ -56,28 +60,30 @@ def test_add_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 + i, "pd.Series[int]"), pd.Series, np.int64) - check(assert_type(left + f, "pd.Series[float]"), pd.Series, np.float64) - check(assert_type(left + c, "pd.Series[complex]"), pd.Series, np.complex128) + check(assert_type(left + i, "pd.Series[int]"), pd.Series, np.integer) + 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 `__radd__` cannot override. At runtime, they return # `Series`s with the correct element type. - check(assert_type(i + left, "npt.NDArray[np.int64]"), pd.Series, np.int64) - check(assert_type(f + left, "npt.NDArray[np.float64]"), pd.Series, np.float64) + 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) check( assert_type(c + left, "npt.NDArray[np.complex128]"), pd.Series, - np.complex128, + np.complexfloating, ) - check(assert_type(left.add(i), "pd.Series[int]"), pd.Series, np.int64) - check(assert_type(left.add(f), "pd.Series[float]"), pd.Series, np.float64) - check(assert_type(left.add(c), "pd.Series[complex]"), pd.Series, np.complex128) + check(assert_type(left.add(i), "pd.Series[int]"), pd.Series, np.integer) + check(assert_type(left.add(f), "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(left.add(c), "pd.Series[complex]"), pd.Series, np.complexfloating) - check(assert_type(left.radd(i), "pd.Series[int]"), pd.Series, np.int64) - check(assert_type(left.radd(f), "pd.Series[float]"), pd.Series, np.float64) - check(assert_type(left.radd(c), "pd.Series[complex]"), pd.Series, np.complex128) + check(assert_type(left.radd(i), "pd.Series[int]"), pd.Series, np.integer) + check(assert_type(left.radd(f), "pd.Series[float]"), pd.Series, np.floating) + check( + assert_type(left.radd(c), "pd.Series[complex]"), pd.Series, np.complexfloating + ) def test_add_pd_series() -> None: @@ -86,18 +92,20 @@ def test_add_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 + i, "pd.Series[int]"), pd.Series, np.int64) - check(assert_type(left + f, "pd.Series[float]"), pd.Series, np.float64) - check(assert_type(left + c, "pd.Series[complex]"), pd.Series, np.complex128) + check(assert_type(left + i, "pd.Series[int]"), pd.Series, np.integer) + 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[int]"), pd.Series, np.int64) - check(assert_type(f + left, "pd.Series[float]"), pd.Series, np.float64) - check(assert_type(c + left, "pd.Series[complex]"), pd.Series, np.complex128) + check(assert_type(i + left, "pd.Series[int]"), pd.Series, np.integer) + 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.add(i), "pd.Series[int]"), pd.Series, np.int64) - check(assert_type(left.add(f), "pd.Series[float]"), pd.Series, np.float64) - check(assert_type(left.add(c), "pd.Series[complex]"), pd.Series, np.complex128) + check(assert_type(left.add(i), "pd.Series[int]"), pd.Series, np.integer) + check(assert_type(left.add(f), "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(left.add(c), "pd.Series[complex]"), pd.Series, np.complexfloating) - check(assert_type(left.radd(i), "pd.Series[int]"), pd.Series, np.int64) - check(assert_type(left.radd(f), "pd.Series[float]"), pd.Series, np.float64) - check(assert_type(left.radd(c), "pd.Series[complex]"), pd.Series, np.complex128) + check(assert_type(left.radd(i), "pd.Series[int]"), pd.Series, np.integer) + check(assert_type(left.radd(f), "pd.Series[float]"), pd.Series, np.floating) + check( + assert_type(left.radd(c), "pd.Series[complex]"), pd.Series, np.complexfloating + ) diff --git a/tests/series/arithmetic/int/test_truediv.py b/tests/series/arithmetic/int/test_truediv.py index fee98380..34e642e4 100644 --- a/tests/series/arithmetic/int/test_truediv.py +++ b/tests/series/arithmetic/int/test_truediv.py @@ -1,4 +1,5 @@ import numpy as np +from numpy import typing as npt # noqa: F401 import pandas as pd from typing_extensions import assert_type @@ -11,58 +12,78 @@ def test_truediv_py_scalar() -> None: """Test pd.Series[int] / Python native scalars""" i, f, c = 1, 1.0, 1j - check(assert_type(left / i, "pd.Series[float]"), pd.Series, np.float64) - check(assert_type(left / f, "pd.Series[float]"), pd.Series, np.float64) - check(assert_type(left / c, "pd.Series[complex]"), pd.Series, 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) - check(assert_type(i / left, "pd.Series[float]"), pd.Series, np.float64) - check(assert_type(f / left, "pd.Series[float]"), pd.Series, np.float64) - check(assert_type(c / left, "pd.Series[complex]"), pd.Series, np.complex128) + 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.float64) - check(assert_type(left.truediv(f), "pd.Series[float]"), pd.Series, np.float64) - check(assert_type(left.truediv(c), "pd.Series[complex]"), pd.Series, np.complex128) + 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.float64) - check(assert_type(left.div(f), "pd.Series[float]"), pd.Series, np.float64) - check(assert_type(left.div(c), "pd.Series[complex]"), pd.Series, np.complex128) + 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.float64) - check(assert_type(left.rtruediv(f), "pd.Series[float]"), pd.Series, np.float64) - check(assert_type(left.rtruediv(c), "pd.Series[complex]"), pd.Series, np.complex128) + 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.float64) - check(assert_type(left.rdiv(f), "pd.Series[float]"), pd.Series, np.float64) - check(assert_type(left.rdiv(c), "pd.Series[complex]"), pd.Series, np.complex128) + 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[int] / 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.float64) - check(assert_type(left / f, "pd.Series[float]"), pd.Series, np.float64) - check(assert_type(left / c, "pd.Series[complex]"), pd.Series, 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) - check(assert_type(i / left, "pd.Series[float]"), pd.Series, np.float64) - check(assert_type(f / left, "pd.Series[float]"), pd.Series, np.float64) - check(assert_type(c / left, "pd.Series[complex]"), pd.Series, np.complex128) + 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.float64) - check(assert_type(left.truediv(f), "pd.Series[float]"), pd.Series, np.float64) - check(assert_type(left.truediv(c), "pd.Series[complex]"), pd.Series, np.complex128) + 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.float64) - check(assert_type(left.div(f), "pd.Series[float]"), pd.Series, np.float64) - check(assert_type(left.div(c), "pd.Series[complex]"), pd.Series, np.complex128) + 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.float64) - check(assert_type(left.rtruediv(f), "pd.Series[float]"), pd.Series, np.float64) - check(assert_type(left.rtruediv(c), "pd.Series[complex]"), pd.Series, np.complex128) + 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.float64) - check(assert_type(left.rdiv(f), "pd.Series[float]"), pd.Series, np.float64) - check(assert_type(left.rdiv(c), "pd.Series[complex]"), pd.Series, np.complex128) + 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: @@ -71,48 +92,46 @@ 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 / i, "pd.Series[float]"), pd.Series, np.float64) - check(assert_type(left / f, "pd.Series[float]"), pd.Series, np.float64) - check(assert_type(left / c, "pd.Series[complex]"), pd.Series, 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 ndarray instead of `pd.Series[...]` in reality, which we cannot fix + # `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( # type: ignore[assert-type] - i / left, "pd.Series[float]" # pyright: ignore[reportAssertTypeFailure] - ), + assert_type(c / left, "npt.NDArray[np.complex128]"), pd.Series, - np.float64, + 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( # type: ignore[assert-type] - f / left, "pd.Series[float]" # pyright: ignore[reportAssertTypeFailure] - ), + assert_type(left.truediv(c), "pd.Series[complex]"), pd.Series, - np.float64, + 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( # type: ignore[assert-type] - c / left, "pd.Series[complex]" # pyright: ignore[reportAssertTypeFailure] - ), + assert_type(left.rtruediv(c), "pd.Series[complex]"), pd.Series, - np.complex128, + np.complexfloating, ) - check(assert_type(left.truediv(i), "pd.Series[float]"), pd.Series, np.float64) - check(assert_type(left.truediv(f), "pd.Series[float]"), pd.Series, np.float64) - check(assert_type(left.truediv(c), "pd.Series[complex]"), pd.Series, np.complex128) - - check(assert_type(left.div(i), "pd.Series[float]"), pd.Series, np.float64) - check(assert_type(left.div(f), "pd.Series[float]"), pd.Series, np.float64) - check(assert_type(left.div(c), "pd.Series[complex]"), pd.Series, np.complex128) - - check(assert_type(left.rtruediv(i), "pd.Series[float]"), pd.Series, np.float64) - check(assert_type(left.rtruediv(f), "pd.Series[float]"), pd.Series, np.float64) - check(assert_type(left.rtruediv(c), "pd.Series[complex]"), pd.Series, np.complex128) - - check(assert_type(left.rdiv(i), "pd.Series[float]"), pd.Series, np.float64) - check(assert_type(left.rdiv(f), "pd.Series[float]"), pd.Series, np.float64) - check(assert_type(left.rdiv(c), "pd.Series[complex]"), pd.Series, np.complex128) + 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: @@ -121,26 +140,36 @@ 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 / i, "pd.Series[float]"), pd.Series, np.float64) - check(assert_type(left / f, "pd.Series[float]"), pd.Series, np.float64) - check(assert_type(left / c, "pd.Series[complex]"), pd.Series, 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) - check(assert_type(i / left, "pd.Series[float]"), pd.Series, np.float64) - check(assert_type(f / left, "pd.Series[float]"), pd.Series, np.float64) - check(assert_type(c / left, "pd.Series[complex]"), pd.Series, np.complex128) + 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.float64) - check(assert_type(left.truediv(f), "pd.Series[float]"), pd.Series, np.float64) - check(assert_type(left.truediv(c), "pd.Series[complex]"), pd.Series, np.complex128) + 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.float64) - check(assert_type(left.div(f), "pd.Series[float]"), pd.Series, np.float64) - check(assert_type(left.div(c), "pd.Series[complex]"), pd.Series, np.complex128) + 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.float64) - check(assert_type(left.rtruediv(f), "pd.Series[float]"), pd.Series, np.float64) - check(assert_type(left.rtruediv(c), "pd.Series[complex]"), pd.Series, np.complex128) + 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.float64) - check(assert_type(left.rdiv(f), "pd.Series[float]"), pd.Series, np.float64) - check(assert_type(left.rdiv(c), "pd.Series[complex]"), pd.Series, np.complex128) + 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/test_truediv.py b/tests/series/arithmetic/test_truediv.py index 7a806549..66920628 100644 --- a/tests/series/arithmetic/test_truediv.py +++ b/tests/series/arithmetic/test_truediv.py @@ -1,3 +1,5 @@ +from pathlib import Path + import numpy as np import pandas as pd from typing_extensions import assert_type @@ -75,24 +77,18 @@ def test_truediv_numpy_array() -> None: check(assert_type(left / f, pd.Series), pd.Series) check(assert_type(left / c, pd.Series), pd.Series) - # numpy typing gives ndarray instead of `pd.Series[...]` in reality, which we cannot fix + # `numpy` typing gives the corresponding `ndarray`s in the static type + # 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( # type: ignore[assert-type] - i / left, pd.Series # pyright: ignore[reportAssertTypeFailure] - ), - pd.Series, + assert_type(i / left, "npt.NDArray[np.float64]"), pd.Series # type: ignore[assert-type] ) check( - assert_type( # type: ignore[assert-type] - f / left, pd.Series # pyright: ignore[reportAssertTypeFailure] - ), - pd.Series, + assert_type(f / left, "npt.NDArray[np.float64]"), pd.Series # type: ignore[assert-type] ) check( - assert_type( # type: ignore[assert-type] - c / left, pd.Series # pyright: ignore[reportAssertTypeFailure] - ), - pd.Series, + assert_type(c / left, "npt.NDArray[np.complex128]"), pd.Series # type: ignore[assert-type] ) check(assert_type(left.truediv(i), pd.Series), pd.Series) From 6a281458fcdd9dc6aae66aacd8cdd3305c35fd18 Mon Sep 17 00:00:00 2001 From: cmp0xff Date: Fri, 1 Aug 2025 16:58:02 +0200 Subject: [PATCH 8/9] fix(typing): truediv path --- pandas-stubs/core/series.pyi | 32 ++++++++++++++++++------- tests/series/arithmetic/test_truediv.py | 15 ++++++++++++ 2 files changed, 39 insertions(+), 8 deletions(-) diff --git a/pandas-stubs/core/series.pyi b/pandas-stubs/core/series.pyi index 7577dc59..9705f34e 100644 --- a/pandas-stubs/core/series.pyi +++ b/pandas-stubs/core/series.pyi @@ -1745,9 +1745,7 @@ class Series(IndexOpsMixin[S1], NDFrame): def __ror__(self, other: int | np_ndarray_anyint | Series[int]) -> Series[int]: ... def __rsub__(self, other: num | _ListLike | Series[S1]) -> Series: ... @overload - def __rtruediv__( - self: Series[Never], other: Path | Scalar | _ListLike - ) -> Series: ... + def __rtruediv__(self: Series[Never], other: Scalar | _ListLike) -> Series: ... @overload def __rtruediv__( self: Series[int], @@ -1812,7 +1810,7 @@ class Series(IndexOpsMixin[S1], NDFrame): def __sub__(self, other: num | _ListLike | Series) -> Series: ... @overload def __truediv__( - self: Series[Never], other: Path | Scalar | _ListLike | Series + self: Series[Never], other: Scalar | _ListLike | Series ) -> Series: ... @overload def __truediv__(self, other: Series[Never]) -> Series: ... @@ -1855,6 +1853,8 @@ class Series(IndexOpsMixin[S1], NDFrame): | Series[_T_COMPLEX] ), ) -> Series[complex]: ... + @overload + def __truediv__(self, other: Path) -> Series: ... # ignore needed for mypy as we want different results based on the arguments @overload # type: ignore[override] def __xor__( # pyright: ignore[reportOverlappingOverload] @@ -2362,7 +2362,7 @@ class Series(IndexOpsMixin[S1], NDFrame): @overload def rtruediv( self: Series[Never], - other: Path | Scalar | _ListLike | Series, + other: Scalar | _ListLike | Series, level: Level | None = ..., fill_value: float | None = ..., axis: AxisIndex = ..., @@ -2441,7 +2441,7 @@ class Series(IndexOpsMixin[S1], NDFrame): @overload def rdiv( self: Series[Never], - other: Path | Scalar | _ListLike | Series, + other: Scalar | _ListLike | Series, level: Level | None = ..., fill_value: float | None = ..., axis: AxisIndex = ..., @@ -2603,7 +2603,7 @@ class Series(IndexOpsMixin[S1], NDFrame): @overload def truediv( self: Series[Never], - other: Path | Scalar | _ListLike | Series, + other: Scalar | _ListLike | Series, level: Level | None = ..., fill_value: float | None = ..., axis: AxisIndex = ..., @@ -2680,9 +2680,17 @@ class Series(IndexOpsMixin[S1], NDFrame): axis: AxisIndex = ..., ) -> Series[complex]: ... @overload + def truediv( + self, + other: Path, + level: Level | None = ..., + fill_value: float | None = ..., + axis: AxisIndex = ..., + ) -> Series: ... + @overload def div( self: Series[Never], - other: Path | Scalar | _ListLike | Series, + other: Scalar | _ListLike | Series, level: Level | None = ..., fill_value: float | None = ..., axis: AxisIndex = ..., @@ -2758,6 +2766,14 @@ class Series(IndexOpsMixin[S1], NDFrame): fill_value: float | None = ..., axis: AxisIndex = ..., ) -> Series[complex]: ... + @overload + def div( + self, + other: Path, + level: Level | None = ..., + fill_value: float | None = ..., + axis: AxisIndex = ..., + ) -> Series: ... def var( self, axis: AxisIndex | None = ..., diff --git a/tests/series/arithmetic/test_truediv.py b/tests/series/arithmetic/test_truediv.py index 66920628..39ec872b 100644 --- a/tests/series/arithmetic/test_truediv.py +++ b/tests/series/arithmetic/test_truediv.py @@ -1,6 +1,7 @@ from pathlib import Path import numpy as np +from numpy import typing as npt # noqa: F401 import pandas as pd from typing_extensions import assert_type @@ -137,3 +138,17 @@ def test_truediv_pd_series() -> None: 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) + + +def test_truediv_path() -> None: + """Test pd.Series / path object""" + left, p = pd.Series(["pat", "ath", "path"]), Path() + + check(assert_type(left / p, pd.Series), pd.Series, Path) + check(assert_type(p / left, pd.Series), pd.Series, Path) + + check(assert_type(left.truediv(p), pd.Series), pd.Series, Path) + check(assert_type(left.div(p), pd.Series), pd.Series, Path) + + check(assert_type(left.rtruediv(p), pd.Series), pd.Series, Path) + check(assert_type(left.rdiv(p), pd.Series), pd.Series, Path) From 9068f8bc2823c40a962406d9fca5b5d0f0bfe97f Mon Sep 17 00:00:00 2001 From: cmp0xff Date: Fri, 1 Aug 2025 17:42:45 +0200 Subject: [PATCH 9/9] fix(comment): ordering https://github.com/pandas-dev/pandas-stubs/pull/1280#pullrequestreview-3079643596 --- pandas-stubs/core/series.pyi | 1027 ++++++++++++++-------------------- 1 file changed, 427 insertions(+), 600 deletions(-) diff --git a/pandas-stubs/core/series.pyi b/pandas-stubs/core/series.pyi index 9705f34e..8de99a42 100644 --- a/pandas-stubs/core/series.pyi +++ b/pandas-stubs/core/series.pyi @@ -1646,44 +1646,93 @@ class Series(IndexOpsMixin[S1], NDFrame): ), ) -> Series[complex]: ... @overload - def __add__(self, other: S1 | Self) -> Self: ... - # ignore needed for mypy as we want different results based on the arguments - @overload # type: ignore[override] - def __and__( # pyright: ignore[reportOverlappingOverload] - self, other: bool | list[int] | MaskType - ) -> Series[bool]: ... + def __add__(self, other: S1 | Series[S1]) -> Self: ... @overload - def __and__(self, other: int | np_ndarray_anyint | Series[int]) -> Series[int]: ... - def __eq__(self, other: object) -> Series[_bool]: ... # type: ignore[override] # pyright: ignore[reportIncompatibleMethodOverride] - def __floordiv__(self, other: num | _ListLike | Series[S1]) -> Series[int]: ... - def __ge__( # type: ignore[override] - self, other: S1 | _ListLike | Series[S1] | datetime | timedelta | date - ) -> Series[_bool]: ... - def __gt__( # type: ignore[override] - self, other: S1 | _ListLike | Series[S1] | datetime | timedelta | date - ) -> Series[_bool]: ... - def __le__( # type: ignore[override] - self, other: S1 | _ListLike | Series[S1] | datetime | timedelta | date - ) -> Series[_bool]: ... - def __lt__( # type: ignore[override] - self, other: S1 | _ListLike | Series[S1] | datetime | timedelta | date - ) -> Series[_bool]: ... + def add( + self: Series[Never], + other: Scalar | _ListLike | Series, + level: Level | None = ..., + fill_value: float | None = ..., + axis: int = ..., + ) -> Series: ... @overload - def __mul__( - self, other: timedelta | Timedelta | TimedeltaSeries | np.timedelta64 - ) -> TimedeltaSeries: ... + def add( + self: Series[int], + other: _T_COMPLEX | Sequence[_T_COMPLEX] | Series[_T_COMPLEX], + level: Level | None = ..., + fill_value: float | None = ..., + axis: int = ..., + ) -> Series[_T_COMPLEX]: ... @overload - def __mul__(self, other: num | _ListLike | Series) -> Series: ... - def __mod__(self, other: num | _ListLike | Series[S1]) -> Series[S1]: ... - def __ne__(self, other: object) -> Series[_bool]: ... # type: ignore[override] # pyright: ignore[reportIncompatibleMethodOverride] - def __pow__(self, other: num | _ListLike | Series[S1]) -> Series[S1]: ... - # ignore needed for mypy as we want different results based on the arguments - @overload # type: ignore[override] - def __or__( # pyright: ignore[reportOverlappingOverload] - self, other: bool | list[int] | MaskType - ) -> Series[bool]: ... + def add( + self: Series[int], + other: np_ndarray_anyint, + level: Level | None = ..., + fill_value: float | None = ..., + axis: int = ..., + ) -> Series[int]: ... @overload - def __or__(self, other: int | np_ndarray_anyint | Series[int]) -> Series[int]: ... + def add( + self: Series[int], + other: np_ndarray_float, + level: Level | None = ..., + fill_value: float | None = ..., + axis: int = ..., + ) -> Series[float]: ... + @overload + def add( + self: Series[int], + other: np_ndarray_complex, + level: Level | None = ..., + fill_value: float | None = ..., + axis: int = ..., + ) -> Series[complex]: ... + @overload + def add( + self: Series[float], + other: int | Sequence[int] | np_ndarray_anyint | np_ndarray_float | Series[int], + level: Level | None = ..., + fill_value: float | None = ..., + axis: int = ..., + ) -> Series[float]: ... + @overload + def add( + self: Series[float], + other: _T_COMPLEX | Sequence[_T_COMPLEX] | Series[_T_COMPLEX], + level: Level | None = ..., + fill_value: float | None = ..., + axis: int = ..., + ) -> Series[_T_COMPLEX]: ... + @overload + def add( + self: Series[float], + other: np_ndarray_complex, + level: Level | None = ..., + fill_value: float | None = ..., + axis: int = ..., + ) -> Series[complex]: ... + @overload + def add( + self: Series[complex], + other: ( + Sequence[_T_COMPLEX] + | np_ndarray_anyint + | np_ndarray_float + | np_ndarray_complex + | Series[_T_COMPLEX] + ), + level: Level | None = ..., + fill_value: float | None = ..., + axis: int = ..., + ) -> Series[complex]: ... + @overload + def add( + self, + other: S1 | Series[S1], + level: Level | None = ..., + fill_value: float | None = ..., + axis: int = ..., + ) -> Self: ... @overload def __radd__(self: Series[Never], other: Scalar | _ListLike) -> Series: ... @overload @@ -1719,6 +1768,129 @@ class Series(IndexOpsMixin[S1], NDFrame): ) -> Series[complex]: ... @overload def __radd__(self, other: S1) -> Self: ... + @overload + def radd( + self: Series[Never], + other: Scalar | _ListLike | Series, + level: Level | None = ..., + fill_value: float | None = ..., + axis: AxisIndex = ..., + ) -> Series: ... + @overload + def radd( + self: Series[int], + other: _T_COMPLEX | Sequence[_T_COMPLEX] | Series[_T_COMPLEX], + level: Level | None = ..., + fill_value: float | None = ..., + axis: int = ..., + ) -> Series[_T_COMPLEX]: ... + @overload + def radd( + self: Series[int], + other: np_ndarray_anyint, + level: Level | None = ..., + fill_value: float | None = ..., + axis: int = ..., + ) -> Series[int]: ... + @overload + def radd( + self: Series[int], + other: np_ndarray_float, + level: Level | None = ..., + fill_value: float | None = ..., + axis: int = ..., + ) -> Series[float]: ... + @overload + def radd( + self: Series[int], + other: np_ndarray_complex, + level: Level | None = ..., + fill_value: float | None = ..., + axis: int = ..., + ) -> Series[complex]: ... + @overload + def radd( + self: Series[float], + other: int | Sequence[int] | np_ndarray_anyint | np_ndarray_float | Series[int], + level: Level | None = ..., + fill_value: float | None = ..., + axis: int = ..., + ) -> Series[float]: ... + @overload + def radd( + self: Series[float], + other: _T_COMPLEX | Sequence[_T_COMPLEX] | Series[_T_COMPLEX], + level: Level | None = ..., + fill_value: float | None = ..., + axis: int = ..., + ) -> Series[_T_COMPLEX]: ... + @overload + def radd( + self: Series[float], + other: np_ndarray_complex, + level: Level | None = ..., + fill_value: float | None = ..., + axis: int = ..., + ) -> Series[complex]: ... + @overload + def radd( + self: Series[complex], + other: ( + Sequence[_T_COMPLEX] + | np_ndarray_anyint + | np_ndarray_float + | np_ndarray_complex + | Series[_T_COMPLEX] + ), + level: Level | None = ..., + fill_value: float | None = ..., + axis: int = ..., + ) -> Series[complex]: ... + @overload + def radd( + self, + other: S1 | Series[S1], + level: Level | None = ..., + fill_value: float | None = ..., + axis: AxisIndex = ..., + ) -> Self: ... + # ignore needed for mypy as we want different results based on the arguments + @overload # type: ignore[override] + def __and__( # pyright: ignore[reportOverlappingOverload] + self, other: bool | list[int] | MaskType + ) -> Series[bool]: ... + @overload + def __and__(self, other: int | np_ndarray_anyint | Series[int]) -> Series[int]: ... + def __eq__(self, other: object) -> Series[_bool]: ... # type: ignore[override] # pyright: ignore[reportIncompatibleMethodOverride] + def __floordiv__(self, other: num | _ListLike | Series[S1]) -> Series[int]: ... + def __ge__( # type: ignore[override] + self, other: S1 | _ListLike | Series[S1] | datetime | timedelta | date + ) -> Series[_bool]: ... + def __gt__( # type: ignore[override] + self, other: S1 | _ListLike | Series[S1] | datetime | timedelta | date + ) -> Series[_bool]: ... + def __le__( # type: ignore[override] + self, other: S1 | _ListLike | Series[S1] | datetime | timedelta | date + ) -> Series[_bool]: ... + def __lt__( # type: ignore[override] + self, other: S1 | _ListLike | Series[S1] | datetime | timedelta | date + ) -> Series[_bool]: ... + @overload + def __mul__( + self, other: timedelta | Timedelta | TimedeltaSeries | np.timedelta64 + ) -> TimedeltaSeries: ... + @overload + def __mul__(self, other: num | _ListLike | Series) -> Series: ... + def __mod__(self, other: num | _ListLike | Series[S1]) -> Series[S1]: ... + def __ne__(self, other: object) -> Series[_bool]: ... # type: ignore[override] # pyright: ignore[reportIncompatibleMethodOverride] + def __pow__(self, other: num | _ListLike | Series[S1]) -> Series[S1]: ... + # ignore needed for mypy as we want different results based on the arguments + @overload # type: ignore[override] + def __or__( # pyright: ignore[reportOverlappingOverload] + self, other: bool | list[int] | MaskType + ) -> Series[bool]: ... + @overload + def __or__(self, other: int | np_ndarray_anyint | Series[int]) -> Series[int]: ... # ignore needed for mypy as we want different results based on the arguments @overload # type: ignore[override] def __rand__( # pyright: ignore[reportOverlappingOverload] @@ -1744,47 +1916,6 @@ class Series(IndexOpsMixin[S1], NDFrame): @overload def __ror__(self, other: int | np_ndarray_anyint | Series[int]) -> Series[int]: ... def __rsub__(self, other: num | _ListLike | Series[S1]) -> Series: ... - @overload - def __rtruediv__(self: Series[Never], other: Scalar | _ListLike) -> Series: ... - @overload - def __rtruediv__( - self: Series[int], - other: int | Sequence[int] | 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[int], other: np_ndarray_complex - ) -> Series[complex]: ... - @overload - def __rtruediv__( - self: Series[float], - other: int | Sequence[int] | np_ndarray_anyint | np_ndarray_float, - ) -> Series[float]: ... - @overload - def __rtruediv__( - 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_anyint - | np_ndarray_float - | np_ndarray_complex - ), - ) -> Series[complex]: ... - @overload - def __rtruediv__(self, other: Path) -> Series: ... # ignore needed for mypy as we want different results based on the arguments @overload # type: ignore[override] def __rxor__( # pyright: ignore[reportOverlappingOverload] @@ -1855,98 +1986,197 @@ class Series(IndexOpsMixin[S1], NDFrame): ) -> Series[complex]: ... @overload def __truediv__(self, other: Path) -> Series: ... - # ignore needed for mypy as we want different results based on the arguments - @overload # type: ignore[override] - def __xor__( # pyright: ignore[reportOverlappingOverload] - self, other: bool | MaskType | list[int] - ) -> Series[bool]: ... @overload - def __xor__(self, other: int | np_ndarray_anyint | Series[int]) -> Series[int]: ... - @final - def __invert__(self) -> Series[bool]: ... - # properties - # @property - # def array(self) -> _npndarray - @property - def at(self) -> _AtIndexer: ... - @property - def cat(self) -> CategoricalAccessor: ... - @property - def iat(self) -> _iAtIndexer: ... - @property - def iloc(self) -> _iLocIndexerSeries[S1]: ... - @property - def loc(self) -> _LocIndexerSeries[S1]: ... - # Methods - @overload - def add( + def truediv( self: Series[Never], other: Scalar | _ListLike | Series, level: Level | None = ..., fill_value: float | None = ..., - axis: int = ..., + axis: AxisIndex = ..., ) -> Series: ... @overload - def add( + def truediv( + self, + other: Series[Never], + level: Level | None = ..., + fill_value: float | None = ..., + axis: AxisIndex = ..., + ) -> Series: ... + @overload + def truediv( + self: Series[int], + other: int | Sequence[int] | np_ndarray_anyint | np_ndarray_float | Series[int], + level: Level | None = ..., + fill_value: float | None = ..., + axis: AxisIndex = ..., + ) -> Series[float]: ... + @overload + def truediv( self: Series[int], other: _T_COMPLEX | Sequence[_T_COMPLEX] | Series[_T_COMPLEX], level: Level | None = ..., fill_value: float | None = ..., - axis: int = ..., + axis: AxisIndex = ..., ) -> Series[_T_COMPLEX]: ... @overload - def add( + def truediv( self: Series[int], - other: np_ndarray_anyint, + other: np_ndarray_complex, level: Level | None = ..., fill_value: float | None = ..., - axis: int = ..., - ) -> Series[int]: ... + axis: AxisIndex = ..., + ) -> Series[complex]: ... @overload - def add( + def truediv( + self: Series[float], + other: int | Sequence[int] | np_ndarray_anyint | np_ndarray_float | Series[int], + level: Level | None = ..., + fill_value: float | None = ..., + axis: AxisIndex = ..., + ) -> Series[float]: ... + @overload + def truediv( + self: Series[float], + other: _T_COMPLEX | Sequence[_T_COMPLEX] | Series[_T_COMPLEX], + level: Level | None = ..., + fill_value: float | None = ..., + axis: AxisIndex = ..., + ) -> Series[_T_COMPLEX]: ... + @overload + def truediv( + self: Series[float], + other: np_ndarray_complex, + level: Level | None = ..., + fill_value: float | None = ..., + axis: AxisIndex = ..., + ) -> Series[complex]: ... + @overload + def truediv( + self: Series[complex], + other: ( + _T_COMPLEX + | Sequence[_T_COMPLEX] + | np_ndarray_anyint + | np_ndarray_float + | np_ndarray_complex + | Series[_T_COMPLEX] + ), + level: Level | None = ..., + fill_value: float | None = ..., + axis: AxisIndex = ..., + ) -> Series[complex]: ... + @overload + def truediv( + self, + other: Path, + level: Level | None = ..., + fill_value: float | None = ..., + axis: AxisIndex = ..., + ) -> Series: ... + div = truediv + @overload + def __rtruediv__(self: Series[Never], other: Scalar | _ListLike) -> Series: ... + @overload + def __rtruediv__( self: Series[int], - other: np_ndarray_float, + other: int | Sequence[int] | 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[int], other: np_ndarray_complex + ) -> Series[complex]: ... + @overload + def __rtruediv__( + self: Series[float], + other: int | Sequence[int] | np_ndarray_anyint | np_ndarray_float, + ) -> Series[float]: ... + @overload + def __rtruediv__( + 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_anyint + | np_ndarray_float + | np_ndarray_complex + ), + ) -> Series[complex]: ... + @overload + def __rtruediv__(self, other: Path) -> Series: ... + @overload + def rtruediv( + self: Series[Never], + other: Scalar | _ListLike | Series, level: Level | None = ..., fill_value: float | None = ..., - axis: int = ..., + axis: AxisIndex = ..., + ) -> Series: ... + @overload + def rtruediv( + self: Series[int], + other: int | Sequence[int] | np_ndarray_anyint | np_ndarray_float | Series[int], + level: Level | None = ..., + fill_value: float | None = ..., + axis: AxisIndex = ..., ) -> Series[float]: ... @overload - def add( + def rtruediv( + self: Series[int], + other: _T_COMPLEX | Sequence[_T_COMPLEX] | Series[_T_COMPLEX], + level: Level | None = ..., + fill_value: float | None = ..., + axis: AxisIndex = ..., + ) -> Series[_T_COMPLEX]: ... + @overload + def rtruediv( self: Series[int], other: np_ndarray_complex, level: Level | None = ..., fill_value: float | None = ..., - axis: int = ..., + axis: AxisIndex = ..., ) -> Series[complex]: ... @overload - def add( + def rtruediv( self: Series[float], other: int | Sequence[int] | np_ndarray_anyint | np_ndarray_float | Series[int], level: Level | None = ..., fill_value: float | None = ..., - axis: int = ..., + axis: AxisIndex = ..., ) -> Series[float]: ... @overload - def add( + def rtruediv( self: Series[float], other: _T_COMPLEX | Sequence[_T_COMPLEX] | Series[_T_COMPLEX], level: Level | None = ..., fill_value: float | None = ..., - axis: int = ..., + axis: AxisIndex = ..., ) -> Series[_T_COMPLEX]: ... @overload - def add( + def rtruediv( self: Series[float], other: np_ndarray_complex, level: Level | None = ..., fill_value: float | None = ..., - axis: int = ..., + axis: AxisIndex = ..., ) -> Series[complex]: ... @overload - def add( + def rtruediv( self: Series[complex], other: ( - Sequence[_T_COMPLEX] + _T_COMPLEX + | Sequence[_T_COMPLEX] | np_ndarray_anyint | np_ndarray_float | np_ndarray_complex @@ -1954,16 +2184,39 @@ class Series(IndexOpsMixin[S1], NDFrame): ), level: Level | None = ..., fill_value: float | None = ..., - axis: int = ..., + axis: AxisIndex = ..., ) -> Series[complex]: ... @overload - def add( + def rtruediv( self, - other: S1 | Series[S1], + other: Path, level: Level | None = ..., fill_value: float | None = ..., - axis: int = ..., - ) -> Self: ... + axis: AxisIndex = ..., + ) -> Series: ... + rdiv = rtruediv + # ignore needed for mypy as we want different results based on the arguments + @overload # type: ignore[override] + def __xor__( # pyright: ignore[reportOverlappingOverload] + self, other: bool | MaskType | list[int] + ) -> Series[bool]: ... + @overload + def __xor__(self, other: int | np_ndarray_anyint | Series[int]) -> Series[int]: ... + @final + def __invert__(self) -> Series[bool]: ... + # properties + # @property + # def array(self) -> _npndarray + @property + def at(self) -> _AtIndexer: ... + @property + def cat(self) -> CategoricalAccessor: ... + @property + def iat(self) -> _iAtIndexer: ... + @property + def iloc(self) -> _iLocIndexerSeries[S1]: ... + @property + def loc(self) -> _LocIndexerSeries[S1]: ... def all( self, axis: AxisIndex = ..., @@ -2196,335 +2449,83 @@ class Series(IndexOpsMixin[S1], NDFrame): min_count: int = ..., **kwargs: Any, ) -> Scalar: ... - @overload - def radd( - self: Series[Never], - other: Scalar | _ListLike | Series, - level: Level | None = ..., - fill_value: float | None = ..., - axis: AxisIndex = ..., - ) -> Series: ... - @overload - def radd( - self: Series[int], - other: _T_COMPLEX | Sequence[_T_COMPLEX] | Series[_T_COMPLEX], - level: Level | None = ..., - fill_value: float | None = ..., - axis: int = ..., - ) -> Series[_T_COMPLEX]: ... - @overload - def radd( - self: Series[int], - other: np_ndarray_anyint, - level: Level | None = ..., - fill_value: float | None = ..., - axis: int = ..., - ) -> Series[int]: ... - @overload - def radd( - self: Series[int], - other: np_ndarray_float, - level: Level | None = ..., - fill_value: float | None = ..., - axis: int = ..., - ) -> Series[float]: ... - @overload - def radd( - self: Series[int], - other: np_ndarray_complex, - level: Level | None = ..., - fill_value: float | None = ..., - axis: int = ..., - ) -> Series[complex]: ... - @overload - def radd( - self: Series[float], - other: int | Sequence[int] | np_ndarray_anyint | np_ndarray_float | Series[int], - level: Level | None = ..., - fill_value: float | None = ..., - axis: int = ..., - ) -> Series[float]: ... - @overload - def radd( - self: Series[float], - other: _T_COMPLEX | Sequence[_T_COMPLEX] | Series[_T_COMPLEX], - level: Level | None = ..., - fill_value: float | None = ..., - axis: int = ..., - ) -> Series[_T_COMPLEX]: ... - @overload - def radd( - self: Series[float], - other: np_ndarray_complex, - level: Level | None = ..., - fill_value: float | None = ..., - axis: int = ..., - ) -> Series[complex]: ... - @overload - def radd( - self: Series[complex], - other: ( - Sequence[_T_COMPLEX] - | np_ndarray_anyint - | np_ndarray_float - | np_ndarray_complex - | Series[_T_COMPLEX] - ), - level: Level | None = ..., - fill_value: float | None = ..., - axis: int = ..., - ) -> Series[complex]: ... - @overload - def radd( - self, - other: S1 | Series[S1], - level: Level | None = ..., - fill_value: float | None = ..., - axis: AxisIndex = ..., - ) -> Self: ... - def rdivmod( - self, - other: Series[S1] | Scalar, - level: Level | None = ..., - fill_value: float | None = ..., - axis: AxisIndex = ..., - ) -> Series[S1]: ... - def rfloordiv( - self, - other, - level: Level | None = ..., - fill_value: float | None = ..., - axis: AxisIndex = ..., - ) -> Series[S1]: ... - def rmod( - self, - other: Series[S1] | Scalar, - level: Level | None = ..., - fill_value: float | None = ..., - axis: AxisIndex = ..., - ) -> Series[S1]: ... - @overload - def rmul( - self, - other: timedelta | Timedelta | TimedeltaSeries | np.timedelta64, - level: Level | None = ..., - fill_value: float | None = ..., - axis: AxisIndex = ..., - ) -> TimedeltaSeries: ... - @overload - def rmul( - self, - other: num | _ListLike | Series, - level: Level | None = ..., - fill_value: float | None = ..., - axis: AxisIndex = ..., - ) -> Series: ... - @overload - def rolling( - self, - window: int | _str | timedelta | BaseOffset | BaseIndexer, - min_periods: int | None = ..., - center: _bool = ..., - on: _str | None = ..., - closed: IntervalClosedType | None = ..., - step: int | None = ..., - method: CalculationMethod = ..., - *, - win_type: _str, - ) -> Window[Series]: ... - @overload - def rolling( - self, - window: int | _str | timedelta | BaseOffset | BaseIndexer, - min_periods: int | None = ..., - center: _bool = ..., - on: _str | None = ..., - closed: IntervalClosedType | None = ..., - step: int | None = ..., - method: CalculationMethod = ..., - *, - win_type: None = ..., - ) -> Rolling[Series]: ... - def rpow( - self, - other: Series[S1] | Scalar, - level: Level | None = ..., - fill_value: float | None = ..., - axis: AxisIndex = ..., - ) -> Series[S1]: ... - def rsub( - self, - other: Series[S1] | Scalar, - level: Level | None = ..., - fill_value: float | None = ..., - axis: AxisIndex = ..., - ) -> Series[S1]: ... - @overload - def rtruediv( - self: Series[Never], - other: Scalar | _ListLike | Series, - level: Level | None = ..., - fill_value: float | None = ..., - axis: AxisIndex = ..., - ) -> Series: ... - @overload - def rtruediv( - self: Series[int], - other: int | Sequence[int] | np_ndarray_anyint | np_ndarray_float | Series[int], - level: Level | None = ..., - fill_value: float | None = ..., - axis: AxisIndex = ..., - ) -> Series[float]: ... - @overload - def rtruediv( - self: Series[int], - other: _T_COMPLEX | Sequence[_T_COMPLEX] | Series[_T_COMPLEX], - level: Level | None = ..., - fill_value: float | None = ..., - axis: AxisIndex = ..., - ) -> Series[_T_COMPLEX]: ... - @overload - def rtruediv( - self: Series[int], - other: np_ndarray_complex, - level: Level | None = ..., - fill_value: float | None = ..., - axis: AxisIndex = ..., - ) -> Series[complex]: ... - @overload - def rtruediv( - self: Series[float], - other: int | Sequence[int] | np_ndarray_anyint | np_ndarray_float | Series[int], - level: Level | None = ..., - fill_value: float | None = ..., - axis: AxisIndex = ..., - ) -> Series[float]: ... - @overload - def rtruediv( - self: Series[float], - other: _T_COMPLEX | Sequence[_T_COMPLEX] | Series[_T_COMPLEX], - level: Level | None = ..., - fill_value: float | None = ..., - axis: AxisIndex = ..., - ) -> Series[_T_COMPLEX]: ... - @overload - def rtruediv( - self: Series[float], - other: np_ndarray_complex, - level: Level | None = ..., - fill_value: float | None = ..., - axis: AxisIndex = ..., - ) -> Series[complex]: ... - @overload - def rtruediv( - self: Series[complex], - other: ( - _T_COMPLEX - | Sequence[_T_COMPLEX] - | np_ndarray_anyint - | np_ndarray_float - | np_ndarray_complex - | Series[_T_COMPLEX] - ), - level: Level | None = ..., - fill_value: float | None = ..., - axis: AxisIndex = ..., - ) -> Series[complex]: ... - @overload - def rtruediv( - self, - other: Path, - level: Level | None = ..., - fill_value: float | None = ..., - axis: AxisIndex = ..., - ) -> Series: ... - @overload - def rdiv( - self: Series[Never], - other: Scalar | _ListLike | Series, - level: Level | None = ..., - fill_value: float | None = ..., - axis: AxisIndex = ..., - ) -> Series: ... - @overload - def rdiv( + def rdivmod( self, - other: Series[Never], - level: Level | None = ..., - fill_value: float | None = ..., - axis: AxisIndex = ..., - ) -> Series: ... - @overload - def rdiv( - self: Series[int], - other: int | Sequence[int] | np_ndarray_anyint | np_ndarray_float | Series[int], + other: Series[S1] | Scalar, level: Level | None = ..., fill_value: float | None = ..., axis: AxisIndex = ..., - ) -> Series[float]: ... - @overload - def rdiv( - self: Series[int], - other: _T_COMPLEX | Sequence[_T_COMPLEX] | Series[_T_COMPLEX], + ) -> Series[S1]: ... + def rfloordiv( + self, + other, level: Level | None = ..., fill_value: float | None = ..., axis: AxisIndex = ..., - ) -> Series[_T_COMPLEX]: ... - @overload - def rdiv( - self: Series[int], - other: np_ndarray_complex, + ) -> Series[S1]: ... + def rmod( + self, + other: Series[S1] | Scalar, level: Level | None = ..., fill_value: float | None = ..., axis: AxisIndex = ..., - ) -> Series[complex]: ... + ) -> Series[S1]: ... @overload - def rdiv( - self: Series[float], - other: int | Sequence[int] | np_ndarray_anyint | np_ndarray_float | Series[int], + def rmul( + self, + other: timedelta | Timedelta | TimedeltaSeries | np.timedelta64, level: Level | None = ..., fill_value: float | None = ..., axis: AxisIndex = ..., - ) -> Series[float]: ... + ) -> TimedeltaSeries: ... @overload - def rdiv( - self: Series[float], - other: _T_COMPLEX | Sequence[_T_COMPLEX] | Series[_T_COMPLEX], + def rmul( + self, + other: num | _ListLike | Series, level: Level | None = ..., fill_value: float | None = ..., axis: AxisIndex = ..., - ) -> Series[_T_COMPLEX]: ... + ) -> Series: ... @overload - def rdiv( - self: Series[float], - other: np_ndarray_complex, - level: Level | None = ..., - fill_value: float | None = ..., - axis: AxisIndex = ..., - ) -> Series[complex]: ... + def rolling( + self, + window: int | _str | timedelta | BaseOffset | BaseIndexer, + min_periods: int | None = ..., + center: _bool = ..., + on: _str | None = ..., + closed: IntervalClosedType | None = ..., + step: int | None = ..., + method: CalculationMethod = ..., + *, + win_type: _str, + ) -> Window[Series]: ... @overload - def rdiv( - self: Series[complex], - other: ( - _T_COMPLEX - | Sequence[_T_COMPLEX] - | np_ndarray_anyint - | np_ndarray_float - | np_ndarray_complex - | Series[_T_COMPLEX] - ), + def rolling( + self, + window: int | _str | timedelta | BaseOffset | BaseIndexer, + min_periods: int | None = ..., + center: _bool = ..., + on: _str | None = ..., + closed: IntervalClosedType | None = ..., + step: int | None = ..., + method: CalculationMethod = ..., + *, + win_type: None = ..., + ) -> Rolling[Series]: ... + def rpow( + self, + other: Series[S1] | Scalar, level: Level | None = ..., fill_value: float | None = ..., axis: AxisIndex = ..., - ) -> Series[complex]: ... - @overload - def rdiv( + ) -> Series[S1]: ... + def rsub( self, - other: Path, + other: Series[S1] | Scalar, level: Level | None = ..., fill_value: float | None = ..., axis: AxisIndex = ..., - ) -> Series: ... + ) -> Series[S1]: ... def sem( self, axis: AxisIndex | None = ..., @@ -2600,180 +2601,6 @@ class Series(IndexOpsMixin[S1], NDFrame): **kwargs: Any, ) -> np.ndarray: ... def tolist(self) -> list[S1]: ... - @overload - def truediv( - self: Series[Never], - other: Scalar | _ListLike | Series, - level: Level | None = ..., - fill_value: float | None = ..., - axis: AxisIndex = ..., - ) -> Series: ... - @overload - def truediv( - self, - other: Series[Never], - level: Level | None = ..., - fill_value: float | None = ..., - axis: AxisIndex = ..., - ) -> Series: ... - @overload - def truediv( - self: Series[int], - other: int | Sequence[int] | np_ndarray_anyint | np_ndarray_float | Series[int], - level: Level | None = ..., - fill_value: float | None = ..., - axis: AxisIndex = ..., - ) -> Series[float]: ... - @overload - def truediv( - self: Series[int], - other: _T_COMPLEX | Sequence[_T_COMPLEX] | Series[_T_COMPLEX], - level: Level | None = ..., - fill_value: float | None = ..., - axis: AxisIndex = ..., - ) -> Series[_T_COMPLEX]: ... - @overload - def truediv( - self: Series[int], - other: np_ndarray_complex, - level: Level | None = ..., - fill_value: float | None = ..., - axis: AxisIndex = ..., - ) -> Series[complex]: ... - @overload - def truediv( - self: Series[float], - other: int | Sequence[int] | np_ndarray_anyint | np_ndarray_float | Series[int], - level: Level | None = ..., - fill_value: float | None = ..., - axis: AxisIndex = ..., - ) -> Series[float]: ... - @overload - def truediv( - self: Series[float], - other: _T_COMPLEX | Sequence[_T_COMPLEX] | Series[_T_COMPLEX], - level: Level | None = ..., - fill_value: float | None = ..., - axis: AxisIndex = ..., - ) -> Series[_T_COMPLEX]: ... - @overload - def truediv( - self: Series[float], - other: np_ndarray_complex, - level: Level | None = ..., - fill_value: float | None = ..., - axis: AxisIndex = ..., - ) -> Series[complex]: ... - @overload - def truediv( - self: Series[complex], - other: ( - _T_COMPLEX - | Sequence[_T_COMPLEX] - | np_ndarray_anyint - | np_ndarray_float - | np_ndarray_complex - | Series[_T_COMPLEX] - ), - level: Level | None = ..., - fill_value: float | None = ..., - axis: AxisIndex = ..., - ) -> Series[complex]: ... - @overload - def truediv( - self, - other: Path, - level: Level | None = ..., - fill_value: float | None = ..., - axis: AxisIndex = ..., - ) -> Series: ... - @overload - def div( - self: Series[Never], - other: Scalar | _ListLike | Series, - level: Level | None = ..., - fill_value: float | None = ..., - axis: AxisIndex = ..., - ) -> Series: ... - @overload - def div( - self, - other: Series[Never], - level: Level | None = ..., - fill_value: float | None = ..., - axis: AxisIndex = ..., - ) -> Series: ... - @overload - def div( - self: Series[int], - other: int | Sequence[int] | np_ndarray_anyint | np_ndarray_float | Series[int], - level: Level | None = ..., - fill_value: float | None = ..., - axis: AxisIndex = ..., - ) -> Series[float]: ... - @overload - def div( - self: Series[int], - other: _T_COMPLEX | Sequence[_T_COMPLEX] | Series[_T_COMPLEX], - level: Level | None = ..., - fill_value: float | None = ..., - axis: AxisIndex = ..., - ) -> Series[_T_COMPLEX]: ... - @overload - def div( - self: Series[int], - other: np_ndarray_complex, - level: Level | None = ..., - fill_value: float | None = ..., - axis: AxisIndex = ..., - ) -> Series[complex]: ... - @overload - def div( - self: Series[float], - other: int | Sequence[int] | np_ndarray_anyint | np_ndarray_float | Series[int], - level: Level | None = ..., - fill_value: float | None = ..., - axis: AxisIndex = ..., - ) -> Series[float]: ... - @overload - def div( - self: Series[float], - other: _T_COMPLEX | Sequence[_T_COMPLEX] | Series[_T_COMPLEX], - level: Level | None = ..., - fill_value: float | None = ..., - axis: AxisIndex = ..., - ) -> Series[_T_COMPLEX]: ... - @overload - def div( - self: Series[float], - other: np_ndarray_complex, - level: Level | None = ..., - fill_value: float | None = ..., - axis: AxisIndex = ..., - ) -> Series[complex]: ... - @overload - def div( - self: Series[complex], - other: ( - _T_COMPLEX - | Sequence[_T_COMPLEX] - | np_ndarray_anyint - | np_ndarray_float - | np_ndarray_complex - | Series[_T_COMPLEX] - ), - level: Level | None = ..., - fill_value: float | None = ..., - axis: AxisIndex = ..., - ) -> Series[complex]: ... - @overload - def div( - self, - other: Path, - level: Level | None = ..., - fill_value: float | None = ..., - axis: AxisIndex = ..., - ) -> Series: ... def var( self, axis: AxisIndex | None = ...,