diff --git a/pandas-stubs/core/series.pyi b/pandas-stubs/core/series.pyi index f0dc7e7fc..8de99a420 100644 --- a/pandas-stubs/core/series.pyi +++ b/pandas-stubs/core/series.pyi @@ -429,20 +429,6 @@ class Series(IndexOpsMixin[S1], NDFrame): ) -> Series: ... @property def hasnans(self) -> bool: ... - def div( - self, - other: num | _ListLike | Series[S1], - level: Level | None = ..., - fill_value: float | None = ..., - axis: AxisIndex = ..., - ) -> Series[float]: ... - def rdiv( - self, - other: Series[S1] | Scalar, - level: Level | None = ..., - fill_value: float | None = ..., - axis: AxisIndex = ..., - ) -> Series[S1]: ... @property def dtype(self) -> DtypeObj: ... @property @@ -1622,10 +1608,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 @@ -1663,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 @@ -1736,89 +1768,16 @@ class Series(IndexOpsMixin[S1], NDFrame): ) -> Series[complex]: ... @overload def __radd__(self, other: S1) -> Self: ... - # ignore needed for mypy as we want different results based on the arguments - @overload # type: ignore[override] - def __rand__( # pyright: ignore[reportOverlappingOverload] - self, other: bool | MaskType | list[int] - ) -> Series[bool]: ... - @overload - def __rand__(self, other: int | np_ndarray_anyint | Series[int]) -> Series[int]: ... - def __rdivmod__(self, other: num | _ListLike | Series[S1]) -> Series[S1]: ... # type: ignore[override] # pyright: ignore[reportIncompatibleMethodOverride] - def __rfloordiv__(self, other: num | _ListLike | Series[S1]) -> Series[S1]: ... - def __rmod__(self, other: num | _ListLike | Series[S1]) -> Series[S1]: ... - @overload - def __rmul__( - self, other: timedelta | Timedelta | TimedeltaSeries | np.timedelta64 - ) -> TimedeltaSeries: ... - @overload - def __rmul__(self, other: num | _ListLike | Series) -> Series: ... - def __rpow__(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 __ror__( # pyright: ignore[reportOverlappingOverload] - self, other: bool | MaskType | list[int] - ) -> Series[bool]: ... - @overload - def __ror__(self, other: int | np_ndarray_anyint | Series[int]) -> Series[int]: ... - def __rsub__(self, other: num | _ListLike | Series[S1]) -> Series: ... - 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] - def __rxor__( # pyright: ignore[reportOverlappingOverload] - self, other: bool | MaskType | list[int] - ) -> Series[bool]: ... - @overload - def __rxor__(self, other: int | np_ndarray_anyint | Series[int]) -> Series[int]: ... - @overload - def __sub__( - self: Series[Timestamp], - other: Timedelta | TimedeltaSeries | TimedeltaIndex | np.timedelta64, - ) -> TimestampSeries: ... - @overload - def __sub__( - self: Series[Timedelta], - other: Timedelta | TimedeltaSeries | TimedeltaIndex | np.timedelta64, - ) -> TimedeltaSeries: ... - @overload - def __sub__( - self, other: Timestamp | datetime | TimestampSeries - ) -> TimedeltaSeries: ... - @overload - def __sub__(self, other: num | _ListLike | Series) -> Series: ... - 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] - 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 radd( self: Series[Never], other: Scalar | _ListLike | Series, level: Level | None = ..., fill_value: float | None = ..., - axis: int = ..., + axis: AxisIndex = ..., ) -> Series: ... @overload - def add( + def radd( self: Series[int], other: _T_COMPLEX | Sequence[_T_COMPLEX] | Series[_T_COMPLEX], level: Level | None = ..., @@ -1826,7 +1785,7 @@ class Series(IndexOpsMixin[S1], NDFrame): axis: int = ..., ) -> Series[_T_COMPLEX]: ... @overload - def add( + def radd( self: Series[int], other: np_ndarray_anyint, level: Level | None = ..., @@ -1834,7 +1793,7 @@ class Series(IndexOpsMixin[S1], NDFrame): axis: int = ..., ) -> Series[int]: ... @overload - def add( + def radd( self: Series[int], other: np_ndarray_float, level: Level | None = ..., @@ -1842,7 +1801,7 @@ class Series(IndexOpsMixin[S1], NDFrame): axis: int = ..., ) -> Series[float]: ... @overload - def add( + def radd( self: Series[int], other: np_ndarray_complex, level: Level | None = ..., @@ -1850,7 +1809,7 @@ class Series(IndexOpsMixin[S1], NDFrame): axis: int = ..., ) -> Series[complex]: ... @overload - def add( + def radd( self: Series[float], other: int | Sequence[int] | np_ndarray_anyint | np_ndarray_float | Series[int], level: Level | None = ..., @@ -1858,7 +1817,7 @@ class Series(IndexOpsMixin[S1], NDFrame): axis: int = ..., ) -> Series[float]: ... @overload - def add( + def radd( self: Series[float], other: _T_COMPLEX | Sequence[_T_COMPLEX] | Series[_T_COMPLEX], level: Level | None = ..., @@ -1866,7 +1825,7 @@ class Series(IndexOpsMixin[S1], NDFrame): axis: int = ..., ) -> Series[_T_COMPLEX]: ... @overload - def add( + def radd( self: Series[float], other: np_ndarray_complex, level: Level | None = ..., @@ -1874,7 +1833,7 @@ class Series(IndexOpsMixin[S1], NDFrame): axis: int = ..., ) -> Series[complex]: ... @overload - def add( + def radd( self: Series[complex], other: ( Sequence[_T_COMPLEX] @@ -1888,45 +1847,408 @@ class Series(IndexOpsMixin[S1], NDFrame): axis: int = ..., ) -> Series[complex]: ... @overload - def add( + def radd( self, other: S1 | Series[S1], level: Level | None = ..., fill_value: float | None = ..., - axis: int = ..., - ) -> Self: ... - def all( - self, - axis: AxisIndex = ..., - bool_only: _bool | None = ..., - skipna: _bool = ..., - **kwargs: Any, - ) -> np.bool: ... - def any( - self, - *, axis: AxisIndex = ..., - bool_only: _bool | None = ..., - skipna: _bool = ..., - **kwargs: Any, - ) -> np.bool: ... - def cummax( - self, - axis: AxisIndex | None = ..., - skipna: _bool = ..., - *args: Any, - **kwargs: Any, - ) -> Series[S1]: ... - def cummin( - self, - axis: AxisIndex | None = ..., - skipna: _bool = ..., - *args: Any, - **kwargs: Any, - ) -> Series[S1]: ... - @overload - def cumprod( - self: Series[_str], + ) -> 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] + self, other: bool | MaskType | list[int] + ) -> Series[bool]: ... + @overload + def __rand__(self, other: int | np_ndarray_anyint | Series[int]) -> Series[int]: ... + def __rdivmod__(self, other: num | _ListLike | Series[S1]) -> Series[S1]: ... # type: ignore[override] # pyright: ignore[reportIncompatibleMethodOverride] + def __rfloordiv__(self, other: num | _ListLike | Series[S1]) -> Series[S1]: ... + def __rmod__(self, other: num | _ListLike | Series[S1]) -> Series[S1]: ... + @overload + def __rmul__( + self, other: timedelta | Timedelta | TimedeltaSeries | np.timedelta64 + ) -> TimedeltaSeries: ... + @overload + def __rmul__(self, other: num | _ListLike | Series) -> Series: ... + def __rpow__(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 __ror__( # pyright: ignore[reportOverlappingOverload] + self, other: bool | MaskType | list[int] + ) -> Series[bool]: ... + @overload + def __ror__(self, other: int | np_ndarray_anyint | Series[int]) -> Series[int]: ... + def __rsub__(self, other: num | _ListLike | Series[S1]) -> Series: ... + # ignore needed for mypy as we want different results based on the arguments + @overload # type: ignore[override] + def __rxor__( # pyright: ignore[reportOverlappingOverload] + self, other: bool | MaskType | list[int] + ) -> Series[bool]: ... + @overload + def __rxor__(self, other: int | np_ndarray_anyint | Series[int]) -> Series[int]: ... + @overload + def __sub__( + self: Series[Timestamp], + other: Timedelta | TimedeltaSeries | TimedeltaIndex | np.timedelta64, + ) -> TimestampSeries: ... + @overload + def __sub__( + self: Series[Timedelta], + other: Timedelta | TimedeltaSeries | TimedeltaIndex | np.timedelta64, + ) -> TimedeltaSeries: ... + @overload + def __sub__( + self, other: Timestamp | datetime | TimestampSeries + ) -> TimedeltaSeries: ... + @overload + def __sub__(self, other: num | _ListLike | Series) -> Series: ... + @overload + def __truediv__( + self: Series[Never], other: Scalar | _ListLike | Series + ) -> Series: ... + @overload + def __truediv__(self, 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: Path) -> Series: ... + @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: ... + div = truediv + @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: ... + @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: ... + 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 = ..., + bool_only: _bool | None = ..., + skipna: _bool = ..., + **kwargs: Any, + ) -> np.bool: ... + def any( + self, + *, + axis: AxisIndex = ..., + bool_only: _bool | None = ..., + skipna: _bool = ..., + **kwargs: Any, + ) -> np.bool: ... + def cummax( + self, + axis: AxisIndex | None = ..., + skipna: _bool = ..., + *args: Any, + **kwargs: Any, + ) -> Series[S1]: ... + def cummin( + self, + axis: AxisIndex | None = ..., + skipna: _bool = ..., + *args: Any, + **kwargs: Any, + ) -> Series[S1]: ... + @overload + def cumprod( + self: Series[_str], axis: AxisIndex = ..., skipna: _bool = ..., *args: Any, @@ -1947,13 +2269,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], @@ -2134,92 +2449,6 @@ 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, @@ -2297,13 +2526,6 @@ class Series(IndexOpsMixin[S1], NDFrame): fill_value: float | None = ..., axis: AxisIndex = ..., ) -> Series[S1]: ... - def rtruediv( - self, - other, - level: Level | None = ..., - fill_value: float | None = ..., - axis: AxisIndex = ..., - ) -> Series[S1]: ... def sem( self, axis: AxisIndex | None = ..., @@ -2379,13 +2601,6 @@ class Series(IndexOpsMixin[S1], NDFrame): **kwargs: Any, ) -> np.ndarray: ... def tolist(self) -> list[S1]: ... - def truediv( - self, - other, - level: Level | None = ..., - fill_value: float | None = ..., - axis: AxisIndex = ..., - ) -> Series[float]: ... def var( self, axis: AxisIndex | None = ..., diff --git a/tests/series/arithmetic/complex/test_add.py b/tests/series/arithmetic/complex/test_add.py index 2ab7d1afc..269204087 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 new file mode 100644 index 000000000..996541b8d --- /dev/null +++ b/tests/series/arithmetic/complex/test_truediv.py @@ -0,0 +1,259 @@ +import numpy as np +from numpy import typing as npt # noqa: F401 +import pandas as pd +from typing_extensions import assert_type + +from tests import check + +left = pd.Series([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.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.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.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.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.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.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.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.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.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.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: + """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.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 `__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.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.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.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.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.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: + """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.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.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.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.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.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 61b77742c..6864c596e 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 new file mode 100644 index 000000000..2bb8c4824 --- /dev/null +++ b/tests/series/arithmetic/float/test_truediv.py @@ -0,0 +1,175 @@ +import numpy as np +from numpy import typing as npt # noqa: F401 +import pandas as pd +from typing_extensions import assert_type + +from tests import check + +left = pd.Series([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.floating) + check(assert_type(left / f, "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(left / c, "pd.Series[complex]"), pd.Series, np.complexfloating) + + check(assert_type(i / left, "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(f / left, "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(c / left, "pd.Series[complex]"), pd.Series, np.complexfloating) + + check(assert_type(left.truediv(i), "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(left.truediv(f), "pd.Series[float]"), pd.Series, np.floating) + check( + assert_type(left.truediv(c), "pd.Series[complex]"), + pd.Series, + np.complexfloating, + ) + + check(assert_type(left.div(i), "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(left.div(f), "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(left.div(c), "pd.Series[complex]"), pd.Series, np.complexfloating) + + check(assert_type(left.rtruediv(i), "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(left.rtruediv(f), "pd.Series[float]"), pd.Series, np.floating) + check( + assert_type(left.rtruediv(c), "pd.Series[complex]"), + pd.Series, + np.complexfloating, + ) + + check(assert_type(left.rdiv(i), "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(left.rdiv(f), "pd.Series[float]"), pd.Series, np.floating) + check( + assert_type(left.rdiv(c), "pd.Series[complex]"), pd.Series, np.complexfloating + ) + + +def test_truediv_py_sequence() -> None: + """Test pd.Series[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.floating) + check(assert_type(left / f, "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(left / c, "pd.Series[complex]"), pd.Series, np.complexfloating) + + check(assert_type(i / left, "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(f / left, "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(c / left, "pd.Series[complex]"), pd.Series, np.complexfloating) + + check(assert_type(left.truediv(i), "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(left.truediv(f), "pd.Series[float]"), pd.Series, np.floating) + check( + assert_type(left.truediv(c), "pd.Series[complex]"), + pd.Series, + np.complexfloating, + ) + + check(assert_type(left.div(i), "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(left.div(f), "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(left.div(c), "pd.Series[complex]"), pd.Series, np.complexfloating) + + check(assert_type(left.rtruediv(i), "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(left.rtruediv(f), "pd.Series[float]"), pd.Series, np.floating) + check( + assert_type(left.rtruediv(c), "pd.Series[complex]"), + pd.Series, + np.complexfloating, + ) + + check(assert_type(left.rdiv(i), "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(left.rdiv(f), "pd.Series[float]"), pd.Series, np.floating) + check( + assert_type(left.rdiv(c), "pd.Series[complex]"), pd.Series, np.complexfloating + ) + + +def test_truediv_numpy_array() -> None: + """Test pd.Series[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.floating) + check(assert_type(left / f, "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(left / c, "pd.Series[complex]"), pd.Series, np.complexfloating) + + # `numpy` typing gives the corresponding `ndarray`s in the static type + # checking, where our `__rtruediv__` cannot override. At runtime, they return + # `Series`s with the correct element type. + check(assert_type(i / left, "npt.NDArray[np.float64]"), pd.Series, np.floating) + check(assert_type(f / left, "npt.NDArray[np.float64]"), pd.Series, np.floating) + check( + assert_type(c / left, "npt.NDArray[np.complex128]"), + pd.Series, + np.complexfloating, + ) + + check(assert_type(left.truediv(i), "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(left.truediv(f), "pd.Series[float]"), pd.Series, np.floating) + check( + assert_type(left.truediv(c), "pd.Series[complex]"), + pd.Series, + np.complexfloating, + ) + + check(assert_type(left.div(i), "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(left.div(f), "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(left.div(c), "pd.Series[complex]"), pd.Series, np.complexfloating) + + check(assert_type(left.rtruediv(i), "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(left.rtruediv(f), "pd.Series[float]"), pd.Series, np.floating) + check( + assert_type(left.rtruediv(c), "pd.Series[complex]"), + pd.Series, + np.complexfloating, + ) + + check(assert_type(left.rdiv(i), "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(left.rdiv(f), "pd.Series[float]"), pd.Series, np.floating) + check( + assert_type(left.rdiv(c), "pd.Series[complex]"), pd.Series, np.complexfloating + ) + + +def test_truediv_pd_series() -> None: + """Test pd.Series[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.floating) + check(assert_type(left / f, "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(left / c, "pd.Series[complex]"), pd.Series, np.complexfloating) + + check(assert_type(i / left, "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(f / left, "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(c / left, "pd.Series[complex]"), pd.Series, np.complexfloating) + + check(assert_type(left.truediv(i), "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(left.truediv(f), "pd.Series[float]"), pd.Series, np.floating) + check( + assert_type(left.truediv(c), "pd.Series[complex]"), + pd.Series, + np.complexfloating, + ) + + check(assert_type(left.div(i), "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(left.div(f), "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(left.div(c), "pd.Series[complex]"), pd.Series, np.complexfloating) + + check(assert_type(left.rtruediv(i), "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(left.rtruediv(f), "pd.Series[float]"), pd.Series, np.floating) + check( + assert_type(left.rtruediv(c), "pd.Series[complex]"), + pd.Series, + np.complexfloating, + ) + + check(assert_type(left.rdiv(i), "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(left.rdiv(f), "pd.Series[float]"), pd.Series, np.floating) + check( + assert_type(left.rdiv(c), "pd.Series[complex]"), pd.Series, np.complexfloating + ) diff --git a/tests/series/arithmetic/int/test_add.py b/tests/series/arithmetic/int/test_add.py index ad25aeb30..2117dcd90 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 new file mode 100644 index 000000000..34e642e40 --- /dev/null +++ b/tests/series/arithmetic/int/test_truediv.py @@ -0,0 +1,175 @@ +import numpy as np +from numpy import typing as npt # noqa: F401 +import pandas as pd +from typing_extensions import assert_type + +from tests import check + +left = pd.Series([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.floating) + check(assert_type(left / f, "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(left / c, "pd.Series[complex]"), pd.Series, np.complexfloating) + + check(assert_type(i / left, "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(f / left, "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(c / left, "pd.Series[complex]"), pd.Series, np.complexfloating) + + check(assert_type(left.truediv(i), "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(left.truediv(f), "pd.Series[float]"), pd.Series, np.floating) + check( + assert_type(left.truediv(c), "pd.Series[complex]"), + pd.Series, + np.complexfloating, + ) + + check(assert_type(left.div(i), "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(left.div(f), "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(left.div(c), "pd.Series[complex]"), pd.Series, np.complexfloating) + + check(assert_type(left.rtruediv(i), "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(left.rtruediv(f), "pd.Series[float]"), pd.Series, np.floating) + check( + assert_type(left.rtruediv(c), "pd.Series[complex]"), + pd.Series, + np.complexfloating, + ) + + check(assert_type(left.rdiv(i), "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(left.rdiv(f), "pd.Series[float]"), pd.Series, np.floating) + check( + assert_type(left.rdiv(c), "pd.Series[complex]"), pd.Series, np.complexfloating + ) + + +def test_truediv_py_sequence() -> None: + """Test pd.Series[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.floating) + check(assert_type(left / f, "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(left / c, "pd.Series[complex]"), pd.Series, np.complexfloating) + + check(assert_type(i / left, "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(f / left, "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(c / left, "pd.Series[complex]"), pd.Series, np.complexfloating) + + check(assert_type(left.truediv(i), "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(left.truediv(f), "pd.Series[float]"), pd.Series, np.floating) + check( + assert_type(left.truediv(c), "pd.Series[complex]"), + pd.Series, + np.complexfloating, + ) + + check(assert_type(left.div(i), "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(left.div(f), "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(left.div(c), "pd.Series[complex]"), pd.Series, np.complexfloating) + + check(assert_type(left.rtruediv(i), "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(left.rtruediv(f), "pd.Series[float]"), pd.Series, np.floating) + check( + assert_type(left.rtruediv(c), "pd.Series[complex]"), + pd.Series, + np.complexfloating, + ) + + check(assert_type(left.rdiv(i), "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(left.rdiv(f), "pd.Series[float]"), pd.Series, np.floating) + check( + assert_type(left.rdiv(c), "pd.Series[complex]"), pd.Series, np.complexfloating + ) + + +def test_truediv_numpy_array() -> None: + """Test pd.Series[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.floating) + check(assert_type(left / f, "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(left / c, "pd.Series[complex]"), pd.Series, np.complexfloating) + + # `numpy` typing gives the corresponding `ndarray`s in the static type + # checking, where our `__rtruediv__` cannot override. At runtime, they return + # `Series`s with the correct element type. + check(assert_type(i / left, "npt.NDArray[np.float64]"), pd.Series, np.floating) + check(assert_type(f / left, "npt.NDArray[np.float64]"), pd.Series, np.floating) + check( + assert_type(c / left, "npt.NDArray[np.complex128]"), + pd.Series, + np.complexfloating, + ) + + check(assert_type(left.truediv(i), "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(left.truediv(f), "pd.Series[float]"), pd.Series, np.floating) + check( + assert_type(left.truediv(c), "pd.Series[complex]"), + pd.Series, + np.complexfloating, + ) + + check(assert_type(left.div(i), "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(left.div(f), "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(left.div(c), "pd.Series[complex]"), pd.Series, np.complexfloating) + + check(assert_type(left.rtruediv(i), "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(left.rtruediv(f), "pd.Series[float]"), pd.Series, np.floating) + check( + assert_type(left.rtruediv(c), "pd.Series[complex]"), + pd.Series, + np.complexfloating, + ) + + check(assert_type(left.rdiv(i), "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(left.rdiv(f), "pd.Series[float]"), pd.Series, np.floating) + check( + assert_type(left.rdiv(c), "pd.Series[complex]"), pd.Series, np.complexfloating + ) + + +def test_truediv_pd_series() -> None: + """Test pd.Series[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.floating) + check(assert_type(left / f, "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(left / c, "pd.Series[complex]"), pd.Series, np.complexfloating) + + check(assert_type(i / left, "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(f / left, "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(c / left, "pd.Series[complex]"), pd.Series, np.complexfloating) + + check(assert_type(left.truediv(i), "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(left.truediv(f), "pd.Series[float]"), pd.Series, np.floating) + check( + assert_type(left.truediv(c), "pd.Series[complex]"), + pd.Series, + np.complexfloating, + ) + + check(assert_type(left.div(i), "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(left.div(f), "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(left.div(c), "pd.Series[complex]"), pd.Series, np.complexfloating) + + check(assert_type(left.rtruediv(i), "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(left.rtruediv(f), "pd.Series[float]"), pd.Series, np.floating) + check( + assert_type(left.rtruediv(c), "pd.Series[complex]"), + pd.Series, + np.complexfloating, + ) + + check(assert_type(left.rdiv(i), "pd.Series[float]"), pd.Series, np.floating) + check(assert_type(left.rdiv(f), "pd.Series[float]"), pd.Series, np.floating) + check( + assert_type(left.rdiv(c), "pd.Series[complex]"), pd.Series, np.complexfloating + ) diff --git a/tests/series/arithmetic/test_truediv.py b/tests/series/arithmetic/test_truediv.py new file mode 100644 index 000000000..39ec872bc --- /dev/null +++ b/tests/series/arithmetic/test_truediv.py @@ -0,0 +1,154 @@ +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 + +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 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(i / left, "npt.NDArray[np.float64]"), pd.Series # type: ignore[assert-type] + ) + check( + assert_type(f / left, "npt.NDArray[np.float64]"), pd.Series # type: ignore[assert-type] + ) + check( + assert_type(c / left, "npt.NDArray[np.complex128]"), pd.Series # type: ignore[assert-type] + ) + + 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) + + +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) diff --git a/tests/series/test_series.py b/tests/series/test_series.py index 49fd80962..297272d38 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 )