diff --git a/pandas-stubs/core/series.pyi b/pandas-stubs/core/series.pyi index d206adcb..33148e39 100644 --- a/pandas-stubs/core/series.pyi +++ b/pandas-stubs/core/series.pyi @@ -1652,8 +1652,8 @@ class Series(IndexOpsMixin[S1], NDFrame): def __add__( self: Series[float], other: ( - _T_INT - | Sequence[_T_INT] + int + | Sequence[int] | np_ndarray_bool | np_ndarray_anyint | np_ndarray_float @@ -1690,6 +1690,14 @@ class Series(IndexOpsMixin[S1], NDFrame): axis: int = 0, ) -> Series: ... @overload + def add( + self, + other: Series[Never], + level: Level | None = None, + fill_value: float | None = None, + axis: int = 0, + ) -> Series: ... + @overload def add( self: Series[bool], other: _T_COMPLEX | Sequence[_T_COMPLEX] | Series[_T_COMPLEX], @@ -1767,8 +1775,8 @@ class Series(IndexOpsMixin[S1], NDFrame): def add( self: Series[float], other: ( - _T_INT - | Sequence[_T_INT] + int + | Sequence[int] | np_ndarray_bool | np_ndarray_anyint | np_ndarray_float @@ -1821,7 +1829,8 @@ class Series(IndexOpsMixin[S1], NDFrame): def __radd__(self: Series[Never], other: Scalar | _ListLike) -> Series: ... @overload def __radd__( - self: Series[bool], other: _T_COMPLEX | Sequence[_T_COMPLEX] + self: Series[bool], + other: _T_COMPLEX | Sequence[_T_COMPLEX] | Series[_T_COMPLEX], ) -> Series[_T_COMPLEX]: ... @overload def __radd__(self: Series[bool], other: np_ndarray_bool) -> Series[bool]: ... @@ -1830,50 +1839,52 @@ class Series(IndexOpsMixin[S1], NDFrame): @overload def __radd__(self: Series[bool], other: np_ndarray_float) -> Series[float]: ... @overload - def __radd__(self: Series[bool], other: np_ndarray_complex) -> Series[complex]: ... - @overload def __radd__( self: Series[int], - other: bool | Sequence[bool] | np_ndarray_bool | np_ndarray_anyint, + other: ( + bool | Sequence[bool] | np_ndarray_bool | np_ndarray_anyint | Series[bool] + ), ) -> Series[int]: ... @overload def __radd__( - self: Series[int], other: _T_COMPLEX | Sequence[_T_COMPLEX] + self: Series[int], other: _T_COMPLEX | Sequence[_T_COMPLEX] | Series[_T_COMPLEX] ) -> Series[_T_COMPLEX]: ... @overload def __radd__(self: Series[int], other: np_ndarray_float) -> Series[float]: ... @overload - def __radd__(self: Series[int], other: np_ndarray_complex) -> Series[complex]: ... - @overload def __radd__( self: Series[float], other: ( - _T_INT - | Sequence[_T_INT] + int + | Sequence[int] | np_ndarray_bool | np_ndarray_anyint | np_ndarray_float + | Series[_T_INT] ), ) -> Series[float]: ... @overload def __radd__( - self: Series[float], other: _T_COMPLEX | Sequence[_T_COMPLEX] + self: Series[float], + other: _T_COMPLEX | Sequence[_T_COMPLEX] | Series[_T_COMPLEX], ) -> Series[_T_COMPLEX]: ... @overload - def __radd__(self: Series[float], other: np_ndarray_complex) -> Series[complex]: ... - @overload def __radd__( self: Series[complex], other: ( - np_ndarray_bool + Sequence[_T_COMPLEX] + | np_ndarray_bool | np_ndarray_anyint | np_ndarray_float - | np_ndarray_complex - | Sequence[_T_COMPLEX] + | Series[_T_COMPLEX] ), ) -> Series[complex]: ... @overload - def __radd__(self, other: S1) -> Self: ... + def __radd__( + self: Series[_T_COMPLEX], other: np_ndarray_complex + ) -> Series[complex]: ... + @overload + def __radd__(self, other: S1 | Series[S1]) -> Self: ... @overload def radd( self: Series[Never], @@ -1899,14 +1910,6 @@ class Series(IndexOpsMixin[S1], NDFrame): axis: int = 0, ) -> Series[bool]: ... @overload - def radd( - self: Series[bool], - other: np_ndarray_anyint, - level: Level | None = None, - fill_value: float | None = None, - axis: int = 0, - ) -> Series[int]: ... - @overload def radd( self: Series[bool], other: np_ndarray_float, @@ -1917,11 +1920,11 @@ class Series(IndexOpsMixin[S1], NDFrame): @overload def radd( self: Series[bool], - other: np_ndarray_complex, + other: np_ndarray_anyint, level: Level | None = None, fill_value: float | None = None, axis: int = 0, - ) -> Series[complex]: ... + ) -> Series[int]: ... @overload def radd( self: Series[int], @@ -1949,19 +1952,11 @@ class Series(IndexOpsMixin[S1], NDFrame): axis: int = 0, ) -> Series[float]: ... @overload - def radd( - self: Series[int], - other: np_ndarray_complex, - level: Level | None = None, - fill_value: float | None = None, - axis: int = 0, - ) -> Series[complex]: ... - @overload def radd( self: Series[float], other: ( - _T_INT - | Sequence[_T_INT] + int + | Sequence[int] | np_ndarray_bool | np_ndarray_anyint | np_ndarray_float @@ -1980,14 +1975,6 @@ class Series(IndexOpsMixin[S1], NDFrame): axis: int = 0, ) -> Series[_T_COMPLEX]: ... @overload - def radd( - self: Series[float], - other: np_ndarray_complex, - level: Level | None = None, - fill_value: float | None = None, - axis: int = 0, - ) -> Series[complex]: ... - @overload def radd( self: Series[complex], other: ( @@ -1995,7 +1982,6 @@ class Series(IndexOpsMixin[S1], NDFrame): | np_ndarray_bool | np_ndarray_anyint | np_ndarray_float - | np_ndarray_complex | Series[_T_COMPLEX] ), level: Level | None = None, @@ -2003,6 +1989,14 @@ class Series(IndexOpsMixin[S1], NDFrame): axis: int = 0, ) -> Series[complex]: ... @overload + def radd( + self: Series[_T_COMPLEX], + other: np_ndarray_complex, + level: Level | None = None, + fill_value: float | None = None, + axis: int = 0, + ) -> Series[complex]: ... + @overload def radd( self, other: S1 | Series[S1], @@ -2097,27 +2091,56 @@ class Series(IndexOpsMixin[S1], NDFrame): def __sub__(self, other: num | _ListLike | Series) -> Series: ... @overload def __truediv__( - self: Series[Never], other: Scalar | _ListLike | Series + self: Series[Never], other: complex | _ListLike | Series ) -> Series: ... @overload def __truediv__(self, other: Series[Never]) -> Series: ... @overload + def __truediv__(self: Series[bool], other: bool | np_ndarray_bool) -> Never: ... + @overload + def __truediv__( # pyright: ignore[reportOverlappingOverload] + self: Series[bool], + other: ( + float + | Sequence[float] + | np_ndarray_anyint + | np_ndarray_float + | Series[int] + | Series[float] + ), + ) -> Series[float]: ... + @overload + def __truediv__( + self: Series[bool], other: complex | Sequence[complex] | Series[complex] + ) -> Series[complex]: ... + @overload def __truediv__( self: Series[int], - other: int | Sequence[int] | np_ndarray_anyint | np_ndarray_float | Series[int], + other: ( + int + | Sequence[int] + | np_ndarray_bool + | np_ndarray_anyint + | np_ndarray_float + | Series[_T_INT] + ), ) -> Series[float]: ... @overload def __truediv__( - self: Series[int], other: _T_COMPLEX | Sequence[_T_COMPLEX] | Series[_T_COMPLEX] + 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], + other: ( + int + | Sequence[int] + | np_ndarray_bool + | np_ndarray_anyint + | np_ndarray_float + | Series[_T_INT] + ), ) -> Series[float]: ... @overload def __truediv__( @@ -2125,27 +2148,27 @@ class Series(IndexOpsMixin[S1], NDFrame): 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_bool | np_ndarray_anyint | np_ndarray_float - | np_ndarray_complex | Series[_T_COMPLEX] ), ) -> Series[complex]: ... @overload + def __truediv__( + self: Series[_T_COMPLEX], other: np_ndarray_complex + ) -> Series[complex]: ... + @overload def __truediv__(self, other: Path) -> Series: ... @overload def truediv( self: Series[Never], - other: Scalar | _ListLike | Series, + other: complex | _ListLike | Series, level: Level | None = None, fill_value: float | None = None, axis: AxisIndex = 0, @@ -2160,39 +2183,53 @@ class Series(IndexOpsMixin[S1], NDFrame): ) -> Series: ... @overload def truediv( - self: Series[int], - other: int | Sequence[int] | np_ndarray_anyint | np_ndarray_float | Series[int], + self: Series[bool], + other: bool | np_ndarray_bool, level: Level | None = None, fill_value: float | None = None, axis: AxisIndex = 0, - ) -> Series[float]: ... + ) -> Never: ... @overload - def truediv( - self: Series[int], - other: _T_COMPLEX | Sequence[_T_COMPLEX] | Series[_T_COMPLEX], + def truediv( # pyright: ignore[reportOverlappingOverload] + self: Series[bool], + other: ( + float + | Sequence[float] + | np_ndarray_anyint + | np_ndarray_float + | Series[int] + | Series[float] + ), level: Level | None = None, fill_value: float | None = None, axis: AxisIndex = 0, - ) -> Series[_T_COMPLEX]: ... + ) -> Series[float]: ... @overload def truediv( - self: Series[int], - other: np_ndarray_complex, + self: Series[bool], + other: complex | Sequence[complex] | Series[complex], level: Level | None = None, fill_value: float | None = None, axis: AxisIndex = 0, ) -> Series[complex]: ... @overload def truediv( - self: Series[float], - other: int | Sequence[int] | np_ndarray_anyint | np_ndarray_float | Series[int], + self: Series[int], + other: ( + int + | Sequence[int] + | np_ndarray_bool + | np_ndarray_anyint + | np_ndarray_float + | Series[_T_INT] + ), level: Level | None = None, fill_value: float | None = None, axis: AxisIndex = 0, ) -> Series[float]: ... @overload def truediv( - self: Series[float], + self: Series[int], other: _T_COMPLEX | Sequence[_T_COMPLEX] | Series[_T_COMPLEX], level: Level | None = None, fill_value: float | None = None, @@ -2201,20 +2238,35 @@ class Series(IndexOpsMixin[S1], NDFrame): @overload def truediv( self: Series[float], - other: np_ndarray_complex, + other: ( + int + | Sequence[int] + | np_ndarray_bool + | np_ndarray_anyint + | np_ndarray_float + | Series[_T_INT] + ), level: Level | None = None, fill_value: float | None = None, axis: AxisIndex = 0, - ) -> Series[complex]: ... + ) -> Series[float]: ... + @overload + def truediv( + self: Series[float], + other: _T_COMPLEX | Sequence[_T_COMPLEX] | Series[_T_COMPLEX], + level: Level | None = None, + fill_value: float | None = None, + axis: AxisIndex = 0, + ) -> Series[_T_COMPLEX]: ... @overload def truediv( self: Series[complex], other: ( _T_COMPLEX | Sequence[_T_COMPLEX] + | np_ndarray_bool | np_ndarray_anyint | np_ndarray_float - | np_ndarray_complex | Series[_T_COMPLEX] ), level: Level | None = None, @@ -2222,6 +2274,14 @@ class Series(IndexOpsMixin[S1], NDFrame): axis: AxisIndex = 0, ) -> Series[complex]: ... @overload + def truediv( + self: Series[_T_COMPLEX], + other: np_ndarray_complex, + level: Level | None = None, + fill_value: float | None = None, + axis: AxisIndex = 0, + ) -> Series[complex]: ... + @overload def truediv( self, other: Path, @@ -2231,89 +2291,145 @@ class Series(IndexOpsMixin[S1], NDFrame): ) -> Series: ... div = truediv @overload - def __rtruediv__(self: Series[Never], other: Scalar | _ListLike) -> Series: ... + def __rtruediv__( + self: Series[Never], other: complex | _ListLike | Series + ) -> Series: ... + @overload + def __rtruediv__(self, other: Series[Never]) -> Series: ... + @overload + def __rtruediv__(self: Series[bool], other: bool | np_ndarray_bool) -> Never: ... + @overload + def __rtruediv__( # pyright: ignore[reportOverlappingOverload] + self: Series[bool], + other: ( + float + | Sequence[float] + | np_ndarray_anyint + | np_ndarray_float + | Series[int] + | Series[float] + ), + ) -> Series[float]: ... + @overload + def __rtruediv__( + self: Series[bool], other: complex | Sequence[complex] | Series[complex] + ) -> Series[complex]: ... @overload def __rtruediv__( self: Series[int], - other: int | Sequence[int] | np_ndarray_anyint | np_ndarray_float, + other: ( + int + | Sequence[int] + | np_ndarray_bool + | np_ndarray_anyint + | np_ndarray_float + | Series[_T_INT] + ), ) -> Series[float]: ... @overload def __rtruediv__( - self: Series[int], other: _T_COMPLEX | Sequence[_T_COMPLEX] + self: Series[int], other: _T_COMPLEX | Sequence[_T_COMPLEX] | Series[_T_COMPLEX] ) -> Series[_T_COMPLEX]: ... @overload - def __rtruediv__( - self: Series[int], other: np_ndarray_complex - ) -> Series[complex]: ... - @overload def __rtruediv__( self: Series[float], - other: int | Sequence[int] | np_ndarray_anyint | np_ndarray_float, + other: ( + int + | Sequence[int] + | np_ndarray_bool + | np_ndarray_anyint + | np_ndarray_float + | Series[_T_INT] + ), ) -> Series[float]: ... @overload def __rtruediv__( - self: Series[float], other: _T_COMPLEX | Sequence[_T_COMPLEX] + self: Series[float], + other: _T_COMPLEX | Sequence[_T_COMPLEX] | Series[_T_COMPLEX], ) -> Series[_T_COMPLEX]: ... @overload - def __rtruediv__( - self: Series[float], other: np_ndarray_complex - ) -> Series[complex]: ... - @overload def __rtruediv__( self: Series[complex], other: ( _T_COMPLEX | Sequence[_T_COMPLEX] + | np_ndarray_bool | np_ndarray_anyint | np_ndarray_float - | np_ndarray_complex + | Series[_T_COMPLEX] ), ) -> Series[complex]: ... @overload + def __rtruediv__( + self: Series[_T_COMPLEX], other: np_ndarray_complex + ) -> Series[complex]: ... + @overload def __rtruediv__(self, other: Path) -> Series: ... @overload def rtruediv( self: Series[Never], - other: Scalar | _ListLike | Series, + other: complex | _ListLike | Series, level: Level | None = None, fill_value: float | None = None, axis: AxisIndex = 0, ) -> Series: ... @overload def rtruediv( - self: Series[int], - other: int | Sequence[int] | np_ndarray_anyint | np_ndarray_float | Series[int], + self, + other: Series[Never], level: Level | None = None, fill_value: float | None = None, axis: AxisIndex = 0, - ) -> Series[float]: ... + ) -> Series: ... @overload def rtruediv( - self: Series[int], - other: _T_COMPLEX | Sequence[_T_COMPLEX] | Series[_T_COMPLEX], + self: Series[bool], + other: bool | np_ndarray_bool, level: Level | None = None, fill_value: float | None = None, axis: AxisIndex = 0, - ) -> Series[_T_COMPLEX]: ... + ) -> Never: ... + @overload + def rtruediv( # pyright: ignore[reportOverlappingOverload] + self: Series[bool], + other: ( + float + | Sequence[float] + | np_ndarray_anyint + | np_ndarray_float + | Series[int] + | Series[float] + ), + level: Level | None = None, + fill_value: float | None = None, + axis: AxisIndex = 0, + ) -> Series[float]: ... @overload def rtruediv( - self: Series[int], - other: np_ndarray_complex, + self: Series[bool], + other: complex | Sequence[complex] | Series[complex], level: Level | None = None, fill_value: float | None = None, axis: AxisIndex = 0, ) -> Series[complex]: ... @overload def rtruediv( - self: Series[float], - other: int | Sequence[int] | np_ndarray_anyint | np_ndarray_float | Series[int], + self: Series[int], + other: ( + int + | Sequence[int] + | np_ndarray_bool + | np_ndarray_anyint + | np_ndarray_float + | Series[_T_INT] + ), level: Level | None = None, fill_value: float | None = None, axis: AxisIndex = 0, ) -> Series[float]: ... @overload def rtruediv( - self: Series[float], + self: Series[int], other: _T_COMPLEX | Sequence[_T_COMPLEX] | Series[_T_COMPLEX], level: Level | None = None, fill_value: float | None = None, @@ -2322,20 +2438,35 @@ class Series(IndexOpsMixin[S1], NDFrame): @overload def rtruediv( self: Series[float], - other: np_ndarray_complex, + other: ( + int + | Sequence[int] + | np_ndarray_bool + | np_ndarray_anyint + | np_ndarray_float + | Series[_T_INT] + ), level: Level | None = None, fill_value: float | None = None, axis: AxisIndex = 0, - ) -> Series[complex]: ... + ) -> Series[float]: ... + @overload + def rtruediv( + self: Series[float], + other: _T_COMPLEX | Sequence[_T_COMPLEX] | Series[_T_COMPLEX], + level: Level | None = None, + fill_value: float | None = None, + axis: AxisIndex = 0, + ) -> Series[_T_COMPLEX]: ... @overload def rtruediv( self: Series[complex], other: ( _T_COMPLEX | Sequence[_T_COMPLEX] + | np_ndarray_bool | np_ndarray_anyint | np_ndarray_float - | np_ndarray_complex | Series[_T_COMPLEX] ), level: Level | None = None, @@ -2343,6 +2474,14 @@ class Series(IndexOpsMixin[S1], NDFrame): axis: AxisIndex = 0, ) -> Series[complex]: ... @overload + def rtruediv( + self: Series[_T_COMPLEX], + other: np_ndarray_complex, + level: Level | None = None, + fill_value: float | None = None, + axis: AxisIndex = 0, + ) -> Series[complex]: ... + @overload def rtruediv( self, other: Path, @@ -2994,7 +3133,7 @@ class PeriodSeries(Series[Period]): ) -> Never: ... class OffsetSeries(Series[BaseOffset]): - @overload + @overload # type: ignore[override] def __radd__(self, other: Period) -> PeriodSeries: ... @overload def __radd__( # pyright: ignore[reportIncompatibleMethodOverride] diff --git a/tests/series/arithmetic/bool/test_truediv.py b/tests/series/arithmetic/bool/test_truediv.py new file mode 100644 index 00000000..caf61d0e --- /dev/null +++ b/tests/series/arithmetic/bool/test_truediv.py @@ -0,0 +1,225 @@ +import numpy as np +from numpy import typing as npt # noqa: F401 +import pandas as pd +from typing_extensions import ( + Never, + assert_type, +) + +from tests import ( + TYPE_CHECKING_INVALID_USAGE, + check, +) + +left = pd.Series([True, False, True]) # left operand + + +def test_truediv_py_scalar() -> None: + """Test pd.Series[bool] / Python native scalars""" + b, i, f, c = True, 1, 1.0, 1j + + if TYPE_CHECKING_INVALID_USAGE: + assert_type(left / b, Never) + check(assert_type(left / i, "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(left / f, "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(left / c, "pd.Series[complex]"), pd.Series, np.complexfloating) + + if TYPE_CHECKING_INVALID_USAGE: + assert_type(b / left, Never) + check(assert_type(i / left, "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(f / left, "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(c / left, "pd.Series[complex]"), pd.Series, np.complexfloating) + + if TYPE_CHECKING_INVALID_USAGE: + assert_type(left.truediv(b), Never) + check(assert_type(left.truediv(i), "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(left.truediv(f), "pd.Series[float]"), pd.Series, np.floating) + check( + assert_type(left.truediv(c), "pd.Series[complex]"), + pd.Series, + np.complexfloating, + ) + + if TYPE_CHECKING_INVALID_USAGE: + assert_type(left.div(b), Never) + check(assert_type(left.div(i), "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(left.div(f), "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(left.div(c), "pd.Series[complex]"), pd.Series, np.complexfloating) + + if TYPE_CHECKING_INVALID_USAGE: + assert_type(left.rtruediv(b), Never) + check(assert_type(left.rtruediv(i), "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(left.rtruediv(f), "pd.Series[float]"), pd.Series, np.floating) + check( + assert_type(left.rtruediv(c), "pd.Series[complex]"), + pd.Series, + np.complexfloating, + ) + + if TYPE_CHECKING_INVALID_USAGE: + assert_type(left.rdiv(b), Never) + check(assert_type(left.rdiv(i), "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(left.rdiv(f), "pd.Series[float]"), pd.Series, np.floating) + check( + assert_type(left.rdiv(c), "pd.Series[complex]"), pd.Series, np.complexfloating + ) + + +def test_truediv_py_sequence() -> None: + """Test pd.Series[bool] / Python native sequence""" + b, i, f, c = [True, False, True], [2, 3, 5], [1.0, 2.0, 3.0], [1j, 1j, 4j] + + check(assert_type(left / b, "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(left / i, "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(left / f, "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(left / c, "pd.Series[complex]"), pd.Series, np.complexfloating) + + check(assert_type(b / left, "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(i / left, "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(f / left, "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(c / left, "pd.Series[complex]"), pd.Series, np.complexfloating) + + check(assert_type(left.truediv(b), "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(left.truediv(i), "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(left.truediv(f), "pd.Series[float]"), pd.Series, np.floating) + check( + assert_type(left.truediv(c), "pd.Series[complex]"), + pd.Series, + np.complexfloating, + ) + + check(assert_type(left.div(b), "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(left.div(i), "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(left.div(f), "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(left.div(c), "pd.Series[complex]"), pd.Series, np.complexfloating) + + check(assert_type(left.rtruediv(b), "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(left.rtruediv(i), "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(left.rtruediv(f), "pd.Series[float]"), pd.Series, np.floating) + check( + assert_type(left.rtruediv(c), "pd.Series[complex]"), + pd.Series, + np.complexfloating, + ) + + check(assert_type(left.rdiv(b), "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(left.rdiv(i), "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(left.rdiv(f), "pd.Series[float]"), pd.Series, np.floating) + check( + assert_type(left.rdiv(c), "pd.Series[complex]"), pd.Series, np.complexfloating + ) + + +def test_truediv_numpy_array() -> None: + """Test pd.Series[bool] / numpy array""" + b = np.array([True, False, True], np.bool_) + i = np.array([2, 3, 5], np.int64) + f = np.array([1.0, 2.0, 3.0], np.float64) + c = np.array([1.1j, 2.2j, 4.1j], np.complex128) + + if TYPE_CHECKING_INVALID_USAGE: + assert_type(left / b, Never) + check(assert_type(left / i, "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(left / f, "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(left / c, "pd.Series[complex]"), pd.Series, np.complexfloating) + + # `numpy` typing gives the corresponding `ndarray`s in the static type + # checking, where our `__rtruediv__` cannot override. At runtime, they return + # `Series`s with the correct element type. + if TYPE_CHECKING_INVALID_USAGE: + assert_type(b / left, "npt.NDArray[np.float64]") + check(assert_type(i / left, "npt.NDArray[np.float64]"), pd.Series, np.floating) + check(assert_type(f / left, "npt.NDArray[np.float64]"), pd.Series, np.floating) + check( + assert_type(c / left, "npt.NDArray[np.complex128]"), + pd.Series, + np.complexfloating, + ) + + if TYPE_CHECKING_INVALID_USAGE: + assert_type(left.truediv(b), Never) + check(assert_type(left.truediv(i), "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(left.truediv(f), "pd.Series[float]"), pd.Series, np.floating) + check( + assert_type(left.truediv(c), "pd.Series[complex]"), + pd.Series, + np.complexfloating, + ) + + if TYPE_CHECKING_INVALID_USAGE: + assert_type(left.div(b), Never) + check(assert_type(left.div(i), "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(left.div(f), "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(left.div(c), "pd.Series[complex]"), pd.Series, np.complexfloating) + + if TYPE_CHECKING_INVALID_USAGE: + assert_type(left.rtruediv(b), Never) + check(assert_type(left.rtruediv(i), "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(left.rtruediv(f), "pd.Series[float]"), pd.Series, np.floating) + check( + assert_type(left.rtruediv(c), "pd.Series[complex]"), + pd.Series, + np.complexfloating, + ) + + if TYPE_CHECKING_INVALID_USAGE: + assert_type(left.rdiv(b), Never) + check(assert_type(left.rdiv(i), "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(left.rdiv(f), "pd.Series[float]"), pd.Series, np.floating) + check( + assert_type(left.rdiv(c), "pd.Series[complex]"), pd.Series, np.complexfloating + ) + + +def test_truediv_pd_series() -> None: + """Test pd.Series[bool] / pandas series""" + b = pd.Series([True, False, True]) + i = pd.Series([2, 3, 5]) + f = pd.Series([1.0, 2.0, 3.0]) + c = pd.Series([1.1j, 2.2j, 4.1j]) + + if TYPE_CHECKING_INVALID_USAGE: + _ = left / b # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + check(assert_type(left / i, "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(left / f, "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(left / c, "pd.Series[complex]"), pd.Series, np.complexfloating) + + if TYPE_CHECKING_INVALID_USAGE: + _ = b / left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + check(assert_type(i / left, "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(f / left, "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(c / left, "pd.Series[complex]"), pd.Series, np.complexfloating) + + if TYPE_CHECKING_INVALID_USAGE: + left.truediv(b) # type: ignore[arg-type] # pyright: ignore[reportArgumentType,reportCallIssue] + check(assert_type(left.truediv(i), "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(left.truediv(f), "pd.Series[float]"), pd.Series, np.floating) + check( + assert_type(left.truediv(c), "pd.Series[complex]"), + pd.Series, + np.complexfloating, + ) + + if TYPE_CHECKING_INVALID_USAGE: + left.div(b) # type: ignore[arg-type] # pyright: ignore[reportArgumentType,reportCallIssue] + check(assert_type(left.div(i), "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(left.div(f), "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(left.div(c), "pd.Series[complex]"), pd.Series, np.complexfloating) + + if TYPE_CHECKING_INVALID_USAGE: + left.rtruediv(b) # type: ignore[arg-type] # pyright: ignore[reportArgumentType,reportCallIssue] + check(assert_type(left.rtruediv(i), "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(left.rtruediv(f), "pd.Series[float]"), pd.Series, np.floating) + check( + assert_type(left.rtruediv(c), "pd.Series[complex]"), + pd.Series, + np.complexfloating, + ) + + if TYPE_CHECKING_INVALID_USAGE: + left.rdiv(b) # type: ignore[arg-type] # pyright: ignore[reportArgumentType,reportCallIssue] + check(assert_type(left.rdiv(i), "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(left.rdiv(f), "pd.Series[float]"), pd.Series, np.floating) + check( + assert_type(left.rdiv(c), "pd.Series[complex]"), pd.Series, np.complexfloating + ) diff --git a/tests/series/arithmetic/complex/test_truediv.py b/tests/series/arithmetic/complex/test_truediv.py index 996541b8..ddf3529d 100644 --- a/tests/series/arithmetic/complex/test_truediv.py +++ b/tests/series/arithmetic/complex/test_truediv.py @@ -10,16 +10,23 @@ def test_truediv_py_scalar() -> None: """Test pd.Series[complex] / Python native scalars""" - i, f, c = 1, 1.0, 1j + b, i, f, c = True, 1, 1.0, 1j + check(assert_type(left / b, "pd.Series[complex]"), pd.Series, np.complexfloating) check(assert_type(left / i, "pd.Series[complex]"), pd.Series, np.complexfloating) check(assert_type(left / f, "pd.Series[complex]"), pd.Series, np.complexfloating) check(assert_type(left / c, "pd.Series[complex]"), pd.Series, np.complexfloating) + check(assert_type(b / left, "pd.Series[complex]"), pd.Series, np.complexfloating) check(assert_type(i / left, "pd.Series[complex]"), pd.Series, np.complexfloating) check(assert_type(f / left, "pd.Series[complex]"), pd.Series, np.complexfloating) check(assert_type(c / left, "pd.Series[complex]"), pd.Series, np.complexfloating) + check( + assert_type(left.truediv(b), "pd.Series[complex]"), + pd.Series, + np.complexfloating, + ) check( assert_type(left.truediv(i), "pd.Series[complex]"), pd.Series, @@ -36,10 +43,16 @@ def test_truediv_py_scalar() -> None: np.complexfloating, ) + check(assert_type(left.div(b), "pd.Series[complex]"), pd.Series, np.complexfloating) check(assert_type(left.div(i), "pd.Series[complex]"), pd.Series, np.complexfloating) check(assert_type(left.div(f), "pd.Series[complex]"), pd.Series, np.complexfloating) check(assert_type(left.div(c), "pd.Series[complex]"), pd.Series, np.complexfloating) + check( + assert_type(left.rtruediv(b), "pd.Series[complex]"), + pd.Series, + np.complexfloating, + ) check( assert_type(left.rtruediv(i), "pd.Series[complex]"), pd.Series, @@ -56,6 +69,9 @@ def test_truediv_py_scalar() -> None: np.complexfloating, ) + check( + assert_type(left.rdiv(b), "pd.Series[complex]"), pd.Series, np.complexfloating + ) check( assert_type(left.rdiv(i), "pd.Series[complex]"), pd.Series, np.complexfloating ) @@ -69,16 +85,23 @@ def test_truediv_py_scalar() -> None: def test_truediv_py_sequence() -> None: """Test pd.Series[complex] / Python native sequence""" - i, f, c = [2, 3, 5], [1.0, 2.0, 3.0], [1j, 1j, 4j] + b, i, f, c = [True, False, True], [2, 3, 5], [1.0, 2.0, 3.0], [1j, 1j, 4j] + check(assert_type(left / b, "pd.Series[complex]"), pd.Series, np.complexfloating) check(assert_type(left / i, "pd.Series[complex]"), pd.Series, np.complexfloating) check(assert_type(left / f, "pd.Series[complex]"), pd.Series, np.complexfloating) check(assert_type(left / c, "pd.Series[complex]"), pd.Series, np.complexfloating) + check(assert_type(b / left, "pd.Series[complex]"), pd.Series, np.complexfloating) check(assert_type(i / left, "pd.Series[complex]"), pd.Series, np.complexfloating) check(assert_type(f / left, "pd.Series[complex]"), pd.Series, np.complexfloating) check(assert_type(c / left, "pd.Series[complex]"), pd.Series, np.complexfloating) + check( + assert_type(left.truediv(b), "pd.Series[complex]"), + pd.Series, + np.complexfloating, + ) check( assert_type(left.truediv(i), "pd.Series[complex]"), pd.Series, @@ -95,10 +118,16 @@ def test_truediv_py_sequence() -> None: np.complexfloating, ) + check(assert_type(left.div(b), "pd.Series[complex]"), pd.Series, np.complexfloating) check(assert_type(left.div(i), "pd.Series[complex]"), pd.Series, np.complexfloating) check(assert_type(left.div(f), "pd.Series[complex]"), pd.Series, np.complexfloating) check(assert_type(left.div(c), "pd.Series[complex]"), pd.Series, np.complexfloating) + check( + assert_type(left.rtruediv(b), "pd.Series[complex]"), + pd.Series, + np.complexfloating, + ) check( assert_type(left.rtruediv(i), "pd.Series[complex]"), pd.Series, @@ -115,6 +144,9 @@ def test_truediv_py_sequence() -> None: np.complexfloating, ) + check( + assert_type(left.rdiv(b), "pd.Series[complex]"), pd.Series, np.complexfloating + ) check( assert_type(left.rdiv(i), "pd.Series[complex]"), pd.Series, np.complexfloating ) @@ -128,10 +160,12 @@ def test_truediv_py_sequence() -> None: def test_truediv_numpy_array() -> None: """Test pd.Series[complex] / numpy array""" + b = np.array([True, False, True], np.bool_) i = np.array([2, 3, 5], np.int64) f = np.array([1.0, 2.0, 3.0], np.float64) c = np.array([1.1j, 2.2j, 4.1j], np.complex128) + check(assert_type(left / b, "pd.Series[complex]"), pd.Series, np.complexfloating) check(assert_type(left / i, "pd.Series[complex]"), pd.Series, np.complexfloating) check(assert_type(left / f, "pd.Series[complex]"), pd.Series, np.complexfloating) check(assert_type(left / c, "pd.Series[complex]"), pd.Series, np.complexfloating) @@ -139,6 +173,9 @@ def test_truediv_numpy_array() -> None: # `numpy` typing gives the corresponding `ndarray`s in the static type # checking, where our `__rtruediv__` cannot override. At runtime, they return # `Series`s with the correct element type. + check( + assert_type(b / left, "npt.NDArray[np.float64]"), pd.Series, np.complexfloating + ) check( assert_type(i / left, "npt.NDArray[np.float64]"), pd.Series, np.complexfloating ) @@ -151,6 +188,11 @@ def test_truediv_numpy_array() -> None: np.complexfloating, ) + check( + assert_type(left.truediv(b), "pd.Series[complex]"), + pd.Series, + np.complexfloating, + ) check( assert_type(left.truediv(i), "pd.Series[complex]"), pd.Series, @@ -167,10 +209,16 @@ def test_truediv_numpy_array() -> None: np.complexfloating, ) + check(assert_type(left.div(b), "pd.Series[complex]"), pd.Series, np.complexfloating) check(assert_type(left.div(i), "pd.Series[complex]"), pd.Series, np.complexfloating) check(assert_type(left.div(f), "pd.Series[complex]"), pd.Series, np.complexfloating) check(assert_type(left.div(c), "pd.Series[complex]"), pd.Series, np.complexfloating) + check( + assert_type(left.rtruediv(b), "pd.Series[complex]"), + pd.Series, + np.complexfloating, + ) check( assert_type(left.rtruediv(i), "pd.Series[complex]"), pd.Series, @@ -187,6 +235,9 @@ def test_truediv_numpy_array() -> None: np.complexfloating, ) + check( + assert_type(left.rdiv(b), "pd.Series[complex]"), pd.Series, np.complexfloating + ) check( assert_type(left.rdiv(i), "pd.Series[complex]"), pd.Series, np.complexfloating ) @@ -200,18 +251,26 @@ def test_truediv_numpy_array() -> None: def test_truediv_pd_series() -> None: """Test pd.Series[complex] / pandas series""" + b = pd.Series([True, False, True]) i = pd.Series([2, 3, 5]) f = pd.Series([1.0, 2.0, 3.0]) c = pd.Series([1.1j, 2.2j, 4.1j]) + check(assert_type(left / b, "pd.Series[complex]"), pd.Series, np.complexfloating) check(assert_type(left / i, "pd.Series[complex]"), pd.Series, np.complexfloating) check(assert_type(left / f, "pd.Series[complex]"), pd.Series, np.complexfloating) check(assert_type(left / c, "pd.Series[complex]"), pd.Series, np.complexfloating) + check(assert_type(b / left, "pd.Series[complex]"), pd.Series, np.complexfloating) check(assert_type(i / left, "pd.Series[complex]"), pd.Series, np.complexfloating) check(assert_type(f / left, "pd.Series[complex]"), pd.Series, np.complexfloating) check(assert_type(c / left, "pd.Series[complex]"), pd.Series, np.complexfloating) + check( + assert_type(left.truediv(b), "pd.Series[complex]"), + pd.Series, + np.complexfloating, + ) check( assert_type(left.truediv(i), "pd.Series[complex]"), pd.Series, @@ -228,10 +287,16 @@ def test_truediv_pd_series() -> None: np.complexfloating, ) + check(assert_type(left.div(b), "pd.Series[complex]"), pd.Series, np.complexfloating) check(assert_type(left.div(i), "pd.Series[complex]"), pd.Series, np.complexfloating) check(assert_type(left.div(f), "pd.Series[complex]"), pd.Series, np.complexfloating) check(assert_type(left.div(c), "pd.Series[complex]"), pd.Series, np.complexfloating) + check( + assert_type(left.rtruediv(b), "pd.Series[complex]"), + pd.Series, + np.complexfloating, + ) check( assert_type(left.rtruediv(i), "pd.Series[complex]"), pd.Series, @@ -248,6 +313,9 @@ def test_truediv_pd_series() -> None: np.complexfloating, ) + check( + assert_type(left.rdiv(b), "pd.Series[complex]"), pd.Series, np.complexfloating + ) check( assert_type(left.rdiv(i), "pd.Series[complex]"), pd.Series, np.complexfloating ) diff --git a/tests/series/arithmetic/float/test_truediv.py b/tests/series/arithmetic/float/test_truediv.py index 2bb8c482..ae3f59f5 100644 --- a/tests/series/arithmetic/float/test_truediv.py +++ b/tests/series/arithmetic/float/test_truediv.py @@ -10,16 +10,19 @@ def test_truediv_py_scalar() -> None: """Test pd.Series[float] / Python native scalars""" - i, f, c = 1, 1.0, 1j + b, i, f, c = True, 1, 1.0, 1j + check(assert_type(left / b, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left / i, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left / f, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left / c, "pd.Series[complex]"), pd.Series, np.complexfloating) + check(assert_type(b / left, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(i / left, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(f / left, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(c / left, "pd.Series[complex]"), pd.Series, np.complexfloating) + check(assert_type(left.truediv(b), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.truediv(i), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.truediv(f), "pd.Series[float]"), pd.Series, np.floating) check( @@ -28,10 +31,12 @@ def test_truediv_py_scalar() -> None: np.complexfloating, ) + check(assert_type(left.div(b), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.div(i), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.div(f), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.div(c), "pd.Series[complex]"), pd.Series, np.complexfloating) + check(assert_type(left.rtruediv(b), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.rtruediv(i), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.rtruediv(f), "pd.Series[float]"), pd.Series, np.floating) check( @@ -40,6 +45,7 @@ def test_truediv_py_scalar() -> None: np.complexfloating, ) + check(assert_type(left.rdiv(b), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.rdiv(i), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.rdiv(f), "pd.Series[float]"), pd.Series, np.floating) check( @@ -49,16 +55,19 @@ def test_truediv_py_scalar() -> None: def test_truediv_py_sequence() -> None: """Test pd.Series[float] / Python native sequence""" - i, f, c = [2, 3, 5], [1.0, 2.0, 3.0], [1j, 1j, 4j] + b, i, f, c = [True, False, True], [2, 3, 5], [1.0, 2.0, 3.0], [1j, 1j, 4j] + check(assert_type(left / b, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left / i, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left / f, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left / c, "pd.Series[complex]"), pd.Series, np.complexfloating) + check(assert_type(b / left, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(i / left, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(f / left, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(c / left, "pd.Series[complex]"), pd.Series, np.complexfloating) + check(assert_type(left.truediv(b), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.truediv(i), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.truediv(f), "pd.Series[float]"), pd.Series, np.floating) check( @@ -67,10 +76,12 @@ def test_truediv_py_sequence() -> None: np.complexfloating, ) + check(assert_type(left.div(b), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.div(i), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.div(f), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.div(c), "pd.Series[complex]"), pd.Series, np.complexfloating) + check(assert_type(left.rtruediv(b), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.rtruediv(i), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.rtruediv(f), "pd.Series[float]"), pd.Series, np.floating) check( @@ -79,6 +90,7 @@ def test_truediv_py_sequence() -> None: np.complexfloating, ) + check(assert_type(left.rdiv(b), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.rdiv(i), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.rdiv(f), "pd.Series[float]"), pd.Series, np.floating) check( @@ -88,10 +100,12 @@ def test_truediv_py_sequence() -> None: def test_truediv_numpy_array() -> None: """Test pd.Series[float] / numpy array""" + b = np.array([True, False, True], np.bool_) i = np.array([2, 3, 5], np.int64) f = np.array([1.0, 2.0, 3.0], np.float64) c = np.array([1.1j, 2.2j, 4.1j], np.complex128) + check(assert_type(left / b, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left / i, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left / f, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left / c, "pd.Series[complex]"), pd.Series, np.complexfloating) @@ -99,6 +113,7 @@ def test_truediv_numpy_array() -> None: # `numpy` typing gives the corresponding `ndarray`s in the static type # checking, where our `__rtruediv__` cannot override. At runtime, they return # `Series`s with the correct element type. + check(assert_type(b / left, "npt.NDArray[np.float64]"), pd.Series, np.floating) check(assert_type(i / left, "npt.NDArray[np.float64]"), pd.Series, np.floating) check(assert_type(f / left, "npt.NDArray[np.float64]"), pd.Series, np.floating) check( @@ -107,6 +122,7 @@ def test_truediv_numpy_array() -> None: np.complexfloating, ) + check(assert_type(left.truediv(b), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.truediv(i), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.truediv(f), "pd.Series[float]"), pd.Series, np.floating) check( @@ -115,10 +131,12 @@ def test_truediv_numpy_array() -> None: np.complexfloating, ) + check(assert_type(left.div(b), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.div(i), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.div(f), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.div(c), "pd.Series[complex]"), pd.Series, np.complexfloating) + check(assert_type(left.rtruediv(b), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.rtruediv(i), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.rtruediv(f), "pd.Series[float]"), pd.Series, np.floating) check( @@ -127,6 +145,7 @@ def test_truediv_numpy_array() -> None: np.complexfloating, ) + check(assert_type(left.rdiv(b), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.rdiv(i), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.rdiv(f), "pd.Series[float]"), pd.Series, np.floating) check( @@ -136,18 +155,22 @@ def test_truediv_numpy_array() -> None: def test_truediv_pd_series() -> None: """Test pd.Series[float] / pandas series""" + b = pd.Series([True, False, True]) i = pd.Series([2, 3, 5]) f = pd.Series([1.0, 2.0, 3.0]) c = pd.Series([1.1j, 2.2j, 4.1j]) + check(assert_type(left / b, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left / i, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left / f, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left / c, "pd.Series[complex]"), pd.Series, np.complexfloating) + check(assert_type(b / left, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(i / left, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(f / left, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(c / left, "pd.Series[complex]"), pd.Series, np.complexfloating) + check(assert_type(left.truediv(b), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.truediv(i), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.truediv(f), "pd.Series[float]"), pd.Series, np.floating) check( @@ -156,10 +179,12 @@ def test_truediv_pd_series() -> None: np.complexfloating, ) + check(assert_type(left.div(b), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.div(i), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.div(f), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.div(c), "pd.Series[complex]"), pd.Series, np.complexfloating) + check(assert_type(left.rtruediv(b), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.rtruediv(i), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.rtruediv(f), "pd.Series[float]"), pd.Series, np.floating) check( @@ -168,6 +193,7 @@ def test_truediv_pd_series() -> None: np.complexfloating, ) + check(assert_type(left.rdiv(b), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.rdiv(i), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.rdiv(f), "pd.Series[float]"), pd.Series, np.floating) check( diff --git a/tests/series/arithmetic/int/test_truediv.py b/tests/series/arithmetic/int/test_truediv.py index 34e642e4..4f0785cc 100644 --- a/tests/series/arithmetic/int/test_truediv.py +++ b/tests/series/arithmetic/int/test_truediv.py @@ -10,16 +10,19 @@ def test_truediv_py_scalar() -> None: """Test pd.Series[int] / Python native scalars""" - i, f, c = 1, 1.0, 1j + b, i, f, c = True, 1, 1.0, 1j + check(assert_type(left / b, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left / i, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left / f, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left / c, "pd.Series[complex]"), pd.Series, np.complexfloating) + check(assert_type(b / left, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(i / left, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(f / left, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(c / left, "pd.Series[complex]"), pd.Series, np.complexfloating) + check(assert_type(left.truediv(b), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.truediv(i), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.truediv(f), "pd.Series[float]"), pd.Series, np.floating) check( @@ -28,10 +31,12 @@ def test_truediv_py_scalar() -> None: np.complexfloating, ) + check(assert_type(left.div(b), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.div(i), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.div(f), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.div(c), "pd.Series[complex]"), pd.Series, np.complexfloating) + check(assert_type(left.rtruediv(b), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.rtruediv(i), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.rtruediv(f), "pd.Series[float]"), pd.Series, np.floating) check( @@ -40,6 +45,7 @@ def test_truediv_py_scalar() -> None: np.complexfloating, ) + check(assert_type(left.rdiv(b), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.rdiv(i), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.rdiv(f), "pd.Series[float]"), pd.Series, np.floating) check( @@ -49,16 +55,19 @@ def test_truediv_py_scalar() -> None: def test_truediv_py_sequence() -> None: """Test pd.Series[int] / Python native sequence""" - i, f, c = [2, 3, 5], [1.0, 2.0, 3.0], [1j, 1j, 4j] + b, i, f, c = [True, False, True], [2, 3, 5], [1.0, 2.0, 3.0], [1j, 1j, 4j] + check(assert_type(left / b, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left / i, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left / f, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left / c, "pd.Series[complex]"), pd.Series, np.complexfloating) + check(assert_type(b / left, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(i / left, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(f / left, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(c / left, "pd.Series[complex]"), pd.Series, np.complexfloating) + check(assert_type(left.truediv(b), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.truediv(i), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.truediv(f), "pd.Series[float]"), pd.Series, np.floating) check( @@ -67,10 +76,12 @@ def test_truediv_py_sequence() -> None: np.complexfloating, ) + check(assert_type(left.div(b), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.div(i), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.div(f), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.div(c), "pd.Series[complex]"), pd.Series, np.complexfloating) + check(assert_type(left.rtruediv(b), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.rtruediv(i), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.rtruediv(f), "pd.Series[float]"), pd.Series, np.floating) check( @@ -79,6 +90,7 @@ def test_truediv_py_sequence() -> None: np.complexfloating, ) + check(assert_type(left.rdiv(b), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.rdiv(i), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.rdiv(f), "pd.Series[float]"), pd.Series, np.floating) check( @@ -88,10 +100,12 @@ def test_truediv_py_sequence() -> None: def test_truediv_numpy_array() -> None: """Test pd.Series[int] / numpy array""" + b = np.array([True, False, True], np.bool_) i = np.array([2, 3, 5], np.int64) f = np.array([1.0, 2.0, 3.0], np.float64) c = np.array([1.1j, 2.2j, 4.1j], np.complex128) + check(assert_type(left / b, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left / i, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left / f, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left / c, "pd.Series[complex]"), pd.Series, np.complexfloating) @@ -99,6 +113,7 @@ def test_truediv_numpy_array() -> None: # `numpy` typing gives the corresponding `ndarray`s in the static type # checking, where our `__rtruediv__` cannot override. At runtime, they return # `Series`s with the correct element type. + check(assert_type(b / left, "npt.NDArray[np.float64]"), pd.Series, np.floating) check(assert_type(i / left, "npt.NDArray[np.float64]"), pd.Series, np.floating) check(assert_type(f / left, "npt.NDArray[np.float64]"), pd.Series, np.floating) check( @@ -107,6 +122,7 @@ def test_truediv_numpy_array() -> None: np.complexfloating, ) + check(assert_type(left.truediv(b), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.truediv(i), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.truediv(f), "pd.Series[float]"), pd.Series, np.floating) check( @@ -115,10 +131,12 @@ def test_truediv_numpy_array() -> None: np.complexfloating, ) + check(assert_type(left.div(b), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.div(i), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.div(f), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.div(c), "pd.Series[complex]"), pd.Series, np.complexfloating) + check(assert_type(left.rtruediv(b), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.rtruediv(i), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.rtruediv(f), "pd.Series[float]"), pd.Series, np.floating) check( @@ -127,6 +145,7 @@ def test_truediv_numpy_array() -> None: np.complexfloating, ) + check(assert_type(left.rdiv(b), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.rdiv(i), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.rdiv(f), "pd.Series[float]"), pd.Series, np.floating) check( @@ -136,18 +155,22 @@ def test_truediv_numpy_array() -> None: def test_truediv_pd_series() -> None: """Test pd.Series[int] / pandas series""" + b = pd.Series([True, False, True]) i = pd.Series([2, 3, 5]) f = pd.Series([1.0, 2.0, 3.0]) c = pd.Series([1.1j, 2.2j, 4.1j]) + check(assert_type(left / b, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left / i, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left / f, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left / c, "pd.Series[complex]"), pd.Series, np.complexfloating) + check(assert_type(b / left, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(i / left, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(f / left, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(c / left, "pd.Series[complex]"), pd.Series, np.complexfloating) + check(assert_type(left.truediv(b), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.truediv(i), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.truediv(f), "pd.Series[float]"), pd.Series, np.floating) check( @@ -156,10 +179,12 @@ def test_truediv_pd_series() -> None: np.complexfloating, ) + check(assert_type(left.div(b), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.div(i), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.div(f), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.div(c), "pd.Series[complex]"), pd.Series, np.complexfloating) + check(assert_type(left.rtruediv(b), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.rtruediv(i), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.rtruediv(f), "pd.Series[float]"), pd.Series, np.floating) check( @@ -168,6 +193,7 @@ def test_truediv_pd_series() -> None: np.complexfloating, ) + check(assert_type(left.rdiv(b), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.rdiv(i), "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left.rdiv(f), "pd.Series[float]"), pd.Series, np.floating) check( diff --git a/tests/series/arithmetic/test_truediv.py b/tests/series/arithmetic/test_truediv.py index c5d5efaf..155a0c0e 100644 --- a/tests/series/arithmetic/test_truediv.py +++ b/tests/series/arithmetic/test_truediv.py @@ -15,28 +15,34 @@ def test_truediv_py_scalar() -> None: """Test pd.Series[Any] / Python native scalars""" - i, f, c = 1, 1.0, 1j + b, i, f, c = True, 1, 1.0, 1j + check(assert_type(left / b, pd.Series), pd.Series) check(assert_type(left / i, pd.Series), pd.Series) check(assert_type(left / f, pd.Series), pd.Series) check(assert_type(left / c, pd.Series), pd.Series) + check(assert_type(b / left, pd.Series), pd.Series) check(assert_type(i / left, pd.Series), pd.Series) check(assert_type(f / left, pd.Series), pd.Series) check(assert_type(c / left, pd.Series), pd.Series) + check(assert_type(left.truediv(b), pd.Series), pd.Series) check(assert_type(left.truediv(i), pd.Series), pd.Series) check(assert_type(left.truediv(f), pd.Series), pd.Series) check(assert_type(left.truediv(c), pd.Series), pd.Series) + check(assert_type(left.div(b), pd.Series), pd.Series) check(assert_type(left.div(i), pd.Series), pd.Series) check(assert_type(left.div(f), pd.Series), pd.Series) check(assert_type(left.div(c), pd.Series), pd.Series) + check(assert_type(left.rtruediv(b), pd.Series), pd.Series) check(assert_type(left.rtruediv(i), pd.Series), pd.Series) check(assert_type(left.rtruediv(f), pd.Series), pd.Series) check(assert_type(left.rtruediv(c), pd.Series), pd.Series) + check(assert_type(left.rdiv(b), pd.Series), pd.Series) check(assert_type(left.rdiv(i), pd.Series), pd.Series) check(assert_type(left.rdiv(f), pd.Series), pd.Series) check(assert_type(left.rdiv(c), pd.Series), pd.Series) @@ -44,28 +50,34 @@ def test_truediv_py_scalar() -> None: def test_truediv_py_sequence() -> None: """Test pd.Series[Any] / Python native sequence""" - i, f, c = [2, 3, 5], [1.0, 2.0, 3.0], [1j, 1j, 4j] + b, i, f, c = [True, False, True], [2, 3, 5], [1.0, 2.0, 3.0], [1j, 1j, 4j] + check(assert_type(left / b, pd.Series), pd.Series) check(assert_type(left / i, pd.Series), pd.Series) check(assert_type(left / f, pd.Series), pd.Series) check(assert_type(left / c, pd.Series), pd.Series) + check(assert_type(b / left, pd.Series), pd.Series) check(assert_type(i / left, pd.Series), pd.Series) check(assert_type(f / left, pd.Series), pd.Series) check(assert_type(c / left, pd.Series), pd.Series) + check(assert_type(left.truediv(b), pd.Series), pd.Series) check(assert_type(left.truediv(i), pd.Series), pd.Series) check(assert_type(left.truediv(f), pd.Series), pd.Series) check(assert_type(left.truediv(c), pd.Series), pd.Series) + check(assert_type(left.div(b), pd.Series), pd.Series) check(assert_type(left.div(i), pd.Series), pd.Series) check(assert_type(left.div(f), pd.Series), pd.Series) check(assert_type(left.div(c), pd.Series), pd.Series) + check(assert_type(left.rtruediv(b), pd.Series), pd.Series) check(assert_type(left.rtruediv(i), pd.Series), pd.Series) check(assert_type(left.rtruediv(f), pd.Series), pd.Series) check(assert_type(left.rtruediv(c), pd.Series), pd.Series) + check(assert_type(left.rdiv(b), pd.Series), pd.Series) check(assert_type(left.rdiv(i), pd.Series), pd.Series) check(assert_type(left.rdiv(f), pd.Series), pd.Series) check(assert_type(left.rdiv(c), pd.Series), pd.Series) @@ -73,10 +85,12 @@ def test_truediv_py_sequence() -> None: def test_truediv_numpy_array() -> None: """Test pd.Series[Any] / numpy array""" + b = np.array([True, False, True], np.bool_) i = np.array([2, 3, 5], np.int64) f = np.array([1.0, 2.0, 3.0], np.float64) c = np.array([1.1j, 2.2j, 4.1j], np.complex64) + check(assert_type(left / b, pd.Series), pd.Series) check(assert_type(left / i, pd.Series), pd.Series) check(assert_type(left / f, pd.Series), pd.Series) check(assert_type(left / c, pd.Series), pd.Series) @@ -85,6 +99,9 @@ def test_truediv_numpy_array() -> None: # checking, where our `__rtruediv__` cannot override. At runtime, they return # `Series`s. # `mypy` thinks the return types are `Any`, which is a bug. + check( + assert_type(b / left, "npt.NDArray[np.float64]"), pd.Series # type: ignore[assert-type] + ) check( assert_type(i / left, "npt.NDArray[np.float64]"), pd.Series # type: ignore[assert-type] ) @@ -95,18 +112,22 @@ def test_truediv_numpy_array() -> None: assert_type(c / left, "npt.NDArray[np.complex128]"), pd.Series # type: ignore[assert-type] ) + check(assert_type(left.truediv(b), pd.Series), pd.Series) check(assert_type(left.truediv(i), pd.Series), pd.Series) check(assert_type(left.truediv(f), pd.Series), pd.Series) check(assert_type(left.truediv(c), pd.Series), pd.Series) + check(assert_type(left.div(b), pd.Series), pd.Series) check(assert_type(left.div(i), pd.Series), pd.Series) check(assert_type(left.div(f), pd.Series), pd.Series) check(assert_type(left.div(c), pd.Series), pd.Series) + check(assert_type(left.rtruediv(b), pd.Series), pd.Series) check(assert_type(left.rtruediv(i), pd.Series), pd.Series) check(assert_type(left.rtruediv(f), pd.Series), pd.Series) check(assert_type(left.rtruediv(c), pd.Series), pd.Series) + check(assert_type(left.rdiv(b), pd.Series), pd.Series) check(assert_type(left.rdiv(i), pd.Series), pd.Series) check(assert_type(left.rdiv(f), pd.Series), pd.Series) check(assert_type(left.rdiv(c), pd.Series), pd.Series) @@ -114,30 +135,37 @@ def test_truediv_numpy_array() -> None: def test_truediv_pd_series() -> None: """Test pd.Series[Any] / pandas series""" + b = pd.Series([True, False, True]) i = pd.Series([2, 3, 5]) f = pd.Series([1.0, 2.0, 3.0]) c = pd.Series([1.1j, 2.2j, 4.1j]) + check(assert_type(left / b, pd.Series), pd.Series) check(assert_type(left / i, pd.Series), pd.Series) check(assert_type(left / f, pd.Series), pd.Series) check(assert_type(left / c, pd.Series), pd.Series) + check(assert_type(b / left, pd.Series), pd.Series) check(assert_type(i / left, pd.Series), pd.Series) check(assert_type(f / left, pd.Series), pd.Series) check(assert_type(c / left, pd.Series), pd.Series) + check(assert_type(left.truediv(b), pd.Series), pd.Series) check(assert_type(left.truediv(i), pd.Series), pd.Series) check(assert_type(left.truediv(f), pd.Series), pd.Series) check(assert_type(left.truediv(c), pd.Series), pd.Series) + check(assert_type(left.div(b), pd.Series), pd.Series) check(assert_type(left.div(i), pd.Series), pd.Series) check(assert_type(left.div(f), pd.Series), pd.Series) check(assert_type(left.div(c), pd.Series), pd.Series) + check(assert_type(left.rtruediv(b), pd.Series), pd.Series) check(assert_type(left.rtruediv(i), pd.Series), pd.Series) check(assert_type(left.rtruediv(f), pd.Series), pd.Series) check(assert_type(left.rtruediv(c), pd.Series), pd.Series) + check(assert_type(left.rdiv(b), pd.Series), pd.Series) check(assert_type(left.rdiv(i), pd.Series), pd.Series) check(assert_type(left.rdiv(f), pd.Series), pd.Series) check(assert_type(left.rdiv(c), pd.Series), pd.Series)