diff --git a/pandas-stubs/_typing.pyi b/pandas-stubs/_typing.pyi index 0d9bc9627..8392880df 100644 --- a/pandas-stubs/_typing.pyi +++ b/pandas-stubs/_typing.pyi @@ -872,9 +872,6 @@ SeriesDType: TypeAlias = ( | datetime.timedelta # includes pd.Timedelta ) S1 = TypeVar("S1", bound=SeriesDType, default=Any) -S1_CO_NSDT = TypeVar( - "S1_CO_NSDT", bound=SeriesDTypeNoStrDateTime, default=Any, covariant=True -) S1_CT_NDT = TypeVar( "S1_CT_NDT", bound=SeriesDTypeNoDateTime, default=Any, contravariant=True ) @@ -882,6 +879,8 @@ S1_CO = TypeVar("S1_CO", bound=SeriesDType, default=Any, covariant=True) S1_CT = TypeVar("S1_CT", bound=SeriesDType, default=Any, contravariant=True) # Like S1, but without `default=Any`. S2 = TypeVar("S2", bound=SeriesDType) +S2_CT = TypeVar("S2_CT", bound=SeriesDType, contravariant=True) +S2_CO_NSDT = TypeVar("S2_CO_NSDT", bound=SeriesDTypeNoStrDateTime, covariant=True) S3 = TypeVar("S3", bound=SeriesDType) # Constraint, instead of bound diff --git a/pandas-stubs/core/indexes/base.pyi b/pandas-stubs/core/indexes/base.pyi index 7b94a5090..deb90f221 100644 --- a/pandas-stubs/core/indexes/base.pyi +++ b/pandas-stubs/core/indexes/base.pyi @@ -56,8 +56,9 @@ from pandas._typing import ( C2, S1, S1_CO, - S1_CO_NSDT, S1_CT, + S2_CO_NSDT, + S2_CT, T_COMPLEX, T_INT, AnyAll, @@ -753,30 +754,32 @@ class Index(IndexOpsMixin[S1]): @overload def __mul__(self, other: np_ndarray_dt) -> Never: ... @overload - def __mul__(self: Index[complex], other: np_ndarray_td) -> Never: ... + def __mul__(self: Index[bool] | Index[complex], other: np_ndarray_td) -> Never: ... # pandas-dev/pandas#62524: An index of Python native timedeltas can be # produced, instead of a TimedeltaIndex, hence the overload @overload def __mul__( # type: ignore[overload-overlap] - self: Index[bool] | Index[int] | Index[float], other: Sequence[timedelta] + self: Index[int] | Index[float], other: Sequence[timedelta] ) -> Index[Timedelta]: ... @overload def __mul__( - self: Index[bool] | Index[int] | Index[float], + self: Index[int] | Index[float], other: timedelta | Sequence[Timedelta] | np.timedelta64 | np_ndarray_td, ) -> TimedeltaIndex: ... @overload - def __mul__(self: Index[Timedelta], other: np_ndarray_complex) -> Never: ... + def __mul__( + self: Index[Timedelta], other: np_ndarray_bool | np_ndarray_complex + ) -> Never: ... @overload def __mul__( self: Index[Timedelta], other: ( - float - | Sequence[float] - | np_ndarray_bool + Just[int] + | Just[float] + | Sequence[Just[int]] + | Sequence[Just[float]] | np_ndarray_anyint | np_ndarray_float - | Index[bool] | Index[int] | Index[float] ), @@ -807,11 +810,11 @@ class Index(IndexOpsMixin[S1]): ) -> Index[complex]: ... @overload def __mul__( - self: Index[S1_CT], + self: Index[S2_CT], other: ( - SupportsRMul[S1_CT, S1_CO_NSDT] | Sequence[SupportsRMul[S1_CT, S1_CO_NSDT]] + SupportsRMul[S2_CT, S2_CO_NSDT] | Sequence[SupportsRMul[S2_CT, S2_CO_NSDT]] ), - ) -> Index[S1_CO_NSDT]: ... + ) -> Index[S2_CO_NSDT]: ... @overload def __mul__( self: Index[T_COMPLEX], other: np_ndarray_bool | Index[bool] @@ -843,30 +846,32 @@ class Index(IndexOpsMixin[S1]): @overload def __rmul__(self, other: np_ndarray_dt) -> Never: ... @overload - def __rmul__(self: Index[complex], other: np_ndarray_td) -> Never: ... + def __rmul__(self: Index[bool] | Index[complex], other: np_ndarray_td) -> Never: ... # pandas-dev/pandas#62524: An index of Python native timedeltas can be # produced, instead of a TimedeltaIndex, hence the overload @overload def __rmul__( # type: ignore[overload-overlap] - self: Index[bool] | Index[int] | Index[float], other: Sequence[timedelta] + self: Index[int] | Index[float], other: Sequence[timedelta] ) -> Index[Timedelta]: ... @overload def __rmul__( - self: Index[bool] | Index[int] | Index[float], + self: Index[int] | Index[float], other: timedelta | Sequence[Timedelta] | np.timedelta64 | np_ndarray_td, ) -> TimedeltaIndex: ... @overload - def __rmul__(self: Index[Timedelta], other: np_ndarray_complex) -> Never: ... + def __rmul__( + self: Index[Timedelta], other: np_ndarray_bool | np_ndarray_complex + ) -> Never: ... @overload def __rmul__( self: Index[Timedelta], other: ( - float - | Sequence[float] - | np_ndarray_bool + Just[int] + | Just[float] + | Sequence[Just[int]] + | Sequence[Just[float]] | np_ndarray_anyint | np_ndarray_float - | Index[bool] | Index[int] | Index[float] ), @@ -897,11 +902,11 @@ class Index(IndexOpsMixin[S1]): ) -> Index[complex]: ... @overload def __rmul__( - self: Index[S1_CT], + self: Index[S2_CT], other: ( - SupportsMul[S1_CT, S1_CO_NSDT] | Sequence[SupportsMul[S1_CT, S1_CO_NSDT]] + SupportsMul[S2_CT, S2_CO_NSDT] | Sequence[SupportsMul[S2_CT, S2_CO_NSDT]] ), - ) -> Index[S1_CO_NSDT]: ... + ) -> Index[S2_CO_NSDT]: ... @overload def __rmul__( self: Index[T_COMPLEX], other: np_ndarray_bool | Index[bool] diff --git a/pandas-stubs/core/indexes/timedeltas.pyi b/pandas-stubs/core/indexes/timedeltas.pyi index de2bee2bd..93b74f5a6 100644 --- a/pandas-stubs/core/indexes/timedeltas.pyi +++ b/pandas-stubs/core/indexes/timedeltas.pyi @@ -29,6 +29,7 @@ from pandas._libs import Timedelta from pandas._libs.tslibs import BaseOffset from pandas._typing import ( AxesData, + Just, TimedeltaConvertibleTypes, np_ndarray_anyint, np_ndarray_bool, @@ -86,33 +87,33 @@ class TimedeltaIndex( self, other: dt.datetime | np.datetime64 | np_ndarray_dt | DatetimeIndex ) -> DatetimeIndex: ... @overload # type: ignore[override] - def __mul__(self, other: np_ndarray_complex) -> Never: ... + def __mul__(self, other: np_ndarray_bool | np_ndarray_complex) -> Never: ... @overload def __mul__( self, other: ( - float - | Sequence[float] - | np_ndarray_bool + Just[int] + | Just[float] + | Sequence[Just[int]] + | Sequence[Just[float]] | np_ndarray_anyint | np_ndarray_float - | Index[bool] | Index[int] | Index[float] ), ) -> Self: ... @overload # type: ignore[override] - def __rmul__(self, other: np_ndarray_complex) -> Never: ... + def __rmul__(self, other: np_ndarray_bool | np_ndarray_complex) -> Never: ... @overload def __rmul__( self, other: ( - float - | Sequence[float] - | np_ndarray_bool + Just[int] + | Just[float] + | Sequence[Just[int]] + | Sequence[Just[float]] | np_ndarray_anyint | np_ndarray_float - | Index[bool] | Index[int] | Index[float] ), diff --git a/pandas-stubs/core/series.pyi b/pandas-stubs/core/series.pyi index 3bbf0c81a..815b949e1 100644 --- a/pandas-stubs/core/series.pyi +++ b/pandas-stubs/core/series.pyi @@ -114,10 +114,11 @@ from pandas._libs.tslibs.offsets import DateOffset from pandas._typing import ( S1, S1_CO, - S1_CO_NSDT, S1_CT, S1_CT_NDT, S2, + S2_CO_NSDT, + S2_CT, T_COMPLEX, T_INT, AggFuncTypeBase, @@ -2549,10 +2550,12 @@ class Series(IndexOpsMixin[S1], NDFrame): @overload def __mul__(self, other: np_ndarray_dt) -> Never: ... @overload - def __mul__(self: Series[complex], other: np_ndarray_td) -> Never: ... + def __mul__( + self: Series[bool] | Series[complex], other: np_ndarray_td + ) -> Never: ... @overload def __mul__( - self: Series[bool] | Series[int] | Series[float], + self: Series[int] | Series[float], other: ( timedelta | Sequence[timedelta] @@ -2565,20 +2568,21 @@ class Series(IndexOpsMixin[S1], NDFrame): @overload def __mul__(self: Series[Timestamp], other: np_ndarray) -> Never: ... @overload - def __mul__(self: Series[Timedelta], other: np_ndarray_complex) -> Never: ... + def __mul__( + self: Series[Timedelta], other: np_ndarray_bool | np_ndarray_complex + ) -> Never: ... @overload def __mul__( self: Series[Timedelta], other: ( - float - | Sequence[float] - | np_ndarray_bool + Just[int] + | Just[float] + | Sequence[Just[int]] + | Sequence[Just[float]] | np_ndarray_anyint | np_ndarray_float - | Index[bool] | Index[int] | Index[float] - | Series[bool] | Series[int] | Series[float] ), @@ -2615,11 +2619,11 @@ class Series(IndexOpsMixin[S1], NDFrame): ) -> Series[complex]: ... @overload def __mul__( - self: Series[S1_CT], + self: Series[S2_CT], other: ( - SupportsRMul[S1_CT, S1_CO_NSDT] | Sequence[SupportsRMul[S1_CT, S1_CO_NSDT]] + SupportsRMul[S2_CT, S2_CO_NSDT] | Sequence[SupportsRMul[S2_CT, S2_CO_NSDT]] ), - ) -> Series[S1_CO_NSDT]: ... + ) -> Series[S2_CO_NSDT]: ... @overload def __mul__( self: Series[T_COMPLEX], other: np_ndarray_bool | Index[bool] | Series[bool] @@ -2664,7 +2668,7 @@ class Series(IndexOpsMixin[S1], NDFrame): ) -> Series: ... @overload def mul( - self: Series[bool] | Series[int] | Series[float], + self: Series[int] | Series[float], other: ( timedelta | Sequence[timedelta] @@ -2681,15 +2685,14 @@ class Series(IndexOpsMixin[S1], NDFrame): def mul( self: Series[Timedelta], other: ( - float - | Sequence[float] - | np_ndarray_bool + Just[int] + | Just[float] + | Sequence[Just[int]] + | Sequence[Just[float]] | np_ndarray_anyint | np_ndarray_float - | Index[bool] | Index[int] | Index[float] - | Series[bool] | Series[int] | Series[float] ), @@ -2737,14 +2740,14 @@ class Series(IndexOpsMixin[S1], NDFrame): ) -> Series[complex]: ... @overload def mul( - self: Series[S1_CT], + self: Series[S2_CT], other: ( - SupportsRMul[S1_CT, S1_CO_NSDT] | Sequence[SupportsRMul[S1_CT, S1_CO_NSDT]] + SupportsRMul[S2_CT, S2_CO_NSDT] | Sequence[SupportsRMul[S2_CT, S2_CO_NSDT]] ), level: Level | None = None, fill_value: float | None = None, axis: int = 0, - ) -> Series[S1_CO_NSDT]: ... + ) -> Series[S2_CO_NSDT]: ... @overload def mul( self: Series[T_COMPLEX], @@ -2802,8 +2805,8 @@ class Series(IndexOpsMixin[S1], NDFrame): @overload def __rmul__(self, other: np_ndarray_dt) -> Never: ... @overload - def __rmul__( - self: Series[bool] | Series[int] | Series[float], + def __rmul__( # type: ignore[overload-overlap] + self: Series[int] | Series[float], other: ( timedelta | Sequence[timedelta] @@ -2816,22 +2819,25 @@ class Series(IndexOpsMixin[S1], NDFrame): @overload def __rmul__(self: Series[Timestamp], other: np_ndarray) -> Never: ... @overload - def __rmul__(self: Series[complex], other: np_ndarray_td) -> Never: ... + def __rmul__( + self: Series[bool] | Series[complex], other: np_ndarray_td + ) -> Never: ... @overload - def __rmul__(self: Series[Timedelta], other: np_ndarray_complex) -> Never: ... + def __rmul__( + self: Series[Timedelta], other: np_ndarray_bool | np_ndarray_complex + ) -> Never: ... @overload def __rmul__( self: Series[Timedelta], other: ( - float - | Sequence[float] - | np_ndarray_bool + Just[int] + | Just[float] + | Sequence[Just[int]] + | Sequence[Just[float]] | np_ndarray_anyint | np_ndarray_float - | Index[bool] | Index[int] | Index[float] - | Series[bool] | Series[int] | Series[float] ), @@ -2870,11 +2876,11 @@ class Series(IndexOpsMixin[S1], NDFrame): ) -> Series[complex]: ... @overload def __rmul__( - self: Series[S1_CT], + self: Series[S2_CT], other: ( - SupportsMul[S1_CT, S1_CO_NSDT] | Sequence[SupportsMul[S1_CT, S1_CO_NSDT]] + SupportsMul[S2_CT, S2_CO_NSDT] | Sequence[SupportsMul[S2_CT, S2_CO_NSDT]] ), - ) -> Series[S1_CO_NSDT]: ... + ) -> Series[S2_CO_NSDT]: ... @overload def __rmul__( self: Series[T_COMPLEX], other: np_ndarray_bool | Index[bool] | Series[bool] @@ -2919,7 +2925,7 @@ class Series(IndexOpsMixin[S1], NDFrame): ) -> Series: ... @overload def rmul( - self: Series[bool] | Series[int] | Series[float], + self: Series[int] | Series[float], other: ( timedelta | Sequence[timedelta] @@ -2936,15 +2942,14 @@ class Series(IndexOpsMixin[S1], NDFrame): def rmul( self: Series[Timedelta], other: ( - float - | Sequence[float] - | np_ndarray_bool + Just[int] + | Just[float] + | Sequence[Just[int]] + | Sequence[Just[float]] | np_ndarray_anyint | np_ndarray_float - | Index[bool] | Index[int] | Index[float] - | Series[bool] | Series[int] | Series[float] ), @@ -2992,14 +2997,14 @@ class Series(IndexOpsMixin[S1], NDFrame): ) -> Series[complex]: ... @overload def rmul( - self: Series[S1_CT], + self: Series[S2_CT], other: ( - SupportsMul[S1_CT, S1_CO_NSDT] | Sequence[SupportsMul[S1_CT, S1_CO_NSDT]] + SupportsMul[S2_CT, S2_CO_NSDT] | Sequence[SupportsMul[S2_CT, S2_CO_NSDT]] ), level: Level | None = None, fill_value: float | None = None, axis: int = 0, - ) -> Series[S1_CO_NSDT]: ... + ) -> Series[S2_CO_NSDT]: ... @overload def rmul( self: Series[T_COMPLEX], diff --git a/tests/indexes/arithmetic/bool/test_mul.py b/tests/indexes/arithmetic/bool/test_mul.py index a68a63ce2..ad4b929d8 100644 --- a/tests/indexes/arithmetic/bool/test_mul.py +++ b/tests/indexes/arithmetic/bool/test_mul.py @@ -14,7 +14,6 @@ ) from tests import ( - PD_LTE_23, TYPE_CHECKING_INVALID_USAGE, check, ) @@ -38,7 +37,7 @@ def test_mul_py_scalar(left: "pd.Index[bool]") -> None: check(assert_type(left * c, "pd.Index[complex]"), pd.Index, np.complexfloating) if TYPE_CHECKING_INVALID_USAGE: _04 = left * s # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - check(assert_type(left * d, pd.TimedeltaIndex), pd.TimedeltaIndex, pd.Timedelta) + _05 = left * d # type: ignore[type-var] # pyright: ignore[reportOperatorIssue] check(assert_type(b * left, "pd.Index[bool]"), pd.Index, np.bool_) check(assert_type(i * left, "pd.Index[int]"), pd.Index, np.integer) @@ -46,7 +45,7 @@ def test_mul_py_scalar(left: "pd.Index[bool]") -> None: check(assert_type(c * left, "pd.Index[complex]"), pd.Index, np.complexfloating) if TYPE_CHECKING_INVALID_USAGE: _14 = s * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - check(assert_type(d * left, pd.TimedeltaIndex), pd.TimedeltaIndex, pd.Timedelta) + _15 = d * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] def test_mul_py_sequence(left: "pd.Index[bool]") -> None: @@ -61,7 +60,7 @@ def test_mul_py_sequence(left: "pd.Index[bool]") -> None: check(assert_type(left * c, "pd.Index[complex]"), pd.Index, np.complexfloating) if TYPE_CHECKING_INVALID_USAGE: _04 = left * s # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - check(assert_type(left * d, "pd.Index[pd.Timedelta]"), pd.Index, timedelta) + _05 = left * d # type: ignore[operator] # pyright: ignore[reportOperatorIssue] check(assert_type(b * left, "pd.Index[bool]"), pd.Index, np.bool_) check(assert_type(i * left, "pd.Index[int]"), pd.Index, np.integer) @@ -69,7 +68,7 @@ def test_mul_py_sequence(left: "pd.Index[bool]") -> None: check(assert_type(c * left, "pd.Index[complex]"), pd.Index, np.complexfloating) if TYPE_CHECKING_INVALID_USAGE: _14 = s * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - check(assert_type(d * left, "pd.Index[pd.Timedelta]"), pd.Index, timedelta) + _15 = d * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] def test_mul_numpy_array(left: "pd.Index[bool]") -> None: @@ -87,10 +86,7 @@ def test_mul_numpy_array(left: "pd.Index[bool]") -> None: check(assert_type(left * c, "pd.Index[complex]"), pd.Index, np.complexfloating) if TYPE_CHECKING_INVALID_USAGE: assert_type(left * s, Never) - if PD_LTE_23: - # pandas-dev/pandas#62316: both timedelta * bool - # and np.timedelta64 * bool works, so pandas probably also should work - check(assert_type(left * d, pd.TimedeltaIndex), pd.TimedeltaIndex, pd.Timedelta) + assert_type(left * d, Never) # `numpy` typing gives the corresponding `ndarray`s in the static type # checking, where our `__rmul__` cannot override. At runtime, they return @@ -105,14 +101,7 @@ def test_mul_numpy_array(left: "pd.Index[bool]") -> None: ) if TYPE_CHECKING_INVALID_USAGE: assert_type(s * left, Any) - if PD_LTE_23: - # pandas-dev/pandas#62316: both timedelta * bool - # and np.timedelta64 * bool works, so pandas probably also should work - check( - assert_type(d * left, "npt.NDArray[np.timedelta64]"), - pd.TimedeltaIndex, - pd.Timedelta, - ) + assert_type(d * left, "npt.NDArray[np.timedelta64]") def test_mul_pd_index(left: "pd.Index[bool]") -> None: @@ -130,10 +119,7 @@ def test_mul_pd_index(left: "pd.Index[bool]") -> None: check(assert_type(left * c, "pd.Index[complex]"), pd.Index, np.complexfloating) if TYPE_CHECKING_INVALID_USAGE: _04 = left * s # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - if PD_LTE_23: - # pandas-dev/pandas#62316: both timedelta * bool - # and np.timedelta64 * bool works, so pandas probably also should work - check(assert_type(left * d, pd.TimedeltaIndex), pd.Index, timedelta) + _05 = left * d # type: ignore[operator] # pyright: ignore[reportOperatorIssue] check(assert_type(b * left, "pd.Index[bool]"), pd.Index, np.bool_) check(assert_type(i * left, "pd.Index[int]"), pd.Index, np.integer) @@ -141,7 +127,4 @@ def test_mul_pd_index(left: "pd.Index[bool]") -> None: check(assert_type(c * left, "pd.Index[complex]"), pd.Index, np.complexfloating) if TYPE_CHECKING_INVALID_USAGE: _14 = s * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - if PD_LTE_23: - # pandas-dev/pandas#62316: both timedelta * bool - # and np.timedelta64 * bool works, so pandas probably also should work - check(assert_type(d * left, pd.TimedeltaIndex), pd.Index, timedelta) + _15 = d * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] diff --git a/tests/indexes/arithmetic/timedelta/test_mul.py b/tests/indexes/arithmetic/timedelta/test_mul.py index 590dc57d6..29b7e889a 100644 --- a/tests/indexes/arithmetic/timedelta/test_mul.py +++ b/tests/indexes/arithmetic/timedelta/test_mul.py @@ -10,7 +10,6 @@ ) from tests import ( - PD_LTE_23, TYPE_CHECKING_INVALID_USAGE, check, ) @@ -29,40 +28,38 @@ def test_mul_py_scalar(left: "pd.Index[pd.Timedelta]") -> None: """Test pd.Index[pd.Timedelta] * Python native scalars""" b, i, f, c = True, 1, 1.0, 1j - # pandas-dev/pandas#62316 - if PD_LTE_23: - check(assert_type(left * b, "pd.Index[pd.Timedelta]"), pd.Index, timedelta) + if TYPE_CHECKING_INVALID_USAGE: + _00 = left * b # type: ignore[operator] # pyright: ignore[reportOperatorIssue] check(assert_type(left * i, "pd.Index[pd.Timedelta]"), pd.Index, timedelta) check(assert_type(left * f, "pd.Index[pd.Timedelta]"), pd.Index, timedelta) if TYPE_CHECKING_INVALID_USAGE: - _0 = left * c # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _03 = left * c # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - if PD_LTE_23: - check(assert_type(b * left, "pd.Index[pd.Timedelta]"), pd.Index, timedelta) + if TYPE_CHECKING_INVALID_USAGE: + _10 = b * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] check(assert_type(i * left, "pd.Index[pd.Timedelta]"), pd.Index, timedelta) check(assert_type(f * left, "pd.Index[pd.Timedelta]"), pd.Index, timedelta) if TYPE_CHECKING_INVALID_USAGE: - _1 = c * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _13 = c * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] def test_mul_py_sequence(left: "pd.Index[pd.Timedelta]") -> None: """Test pd.Index[pd.Timedelta] * Python native sequences""" b, i, f, c = [True], [2], [1.5], [1.7j] - # pandas-dev/pandas#62316 - if PD_LTE_23: - check(assert_type(left * b, "pd.Index[pd.Timedelta]"), pd.Index, timedelta) + if TYPE_CHECKING_INVALID_USAGE: + _00 = left * b # type: ignore[operator] # pyright: ignore[reportOperatorIssue] check(assert_type(left * i, "pd.Index[pd.Timedelta]"), pd.Index, timedelta) check(assert_type(left * f, "pd.Index[pd.Timedelta]"), pd.Index, timedelta) if TYPE_CHECKING_INVALID_USAGE: - _0 = left * c # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _03 = left * c # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - if PD_LTE_23: - check(assert_type(b * left, "pd.Index[pd.Timedelta]"), pd.Index, timedelta) + if TYPE_CHECKING_INVALID_USAGE: + _10 = b * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] check(assert_type(i * left, "pd.Index[pd.Timedelta]"), pd.Index, timedelta) check(assert_type(f * left, "pd.Index[pd.Timedelta]"), pd.Index, timedelta) if TYPE_CHECKING_INVALID_USAGE: - _1 = c * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _13 = c * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] def test_mul_numpy_array(left: "pd.Index[pd.Timedelta]") -> None: @@ -72,9 +69,8 @@ def test_mul_numpy_array(left: "pd.Index[pd.Timedelta]") -> None: f = np.array([1.5], np.float64) c = np.array([1.7j], np.complex128) - # pandas-dev/pandas#62316 - if PD_LTE_23: - check(assert_type(left * b, "pd.Index[pd.Timedelta]"), pd.Index, timedelta) + if TYPE_CHECKING_INVALID_USAGE: + assert_type(left * b, Never) check(assert_type(left * i, "pd.Index[pd.Timedelta]"), pd.Index, timedelta) check(assert_type(left * f, "pd.Index[pd.Timedelta]"), pd.Index, timedelta) if TYPE_CHECKING_INVALID_USAGE: @@ -83,8 +79,8 @@ def test_mul_numpy_array(left: "pd.Index[pd.Timedelta]") -> None: # `numpy` typing gives the corresponding `ndarray`s in the static type # checking, where our `__rmul__` cannot override. At runtime, they return # `Series` with the correct element type. - if PD_LTE_23: - check(assert_type(b * left, "npt.NDArray[np.bool_]"), pd.Index, timedelta) + if TYPE_CHECKING_INVALID_USAGE: + assert_type(b * left, "npt.NDArray[np.bool_]") check(assert_type(i * left, "npt.NDArray[np.int64]"), pd.Index, timedelta) check(assert_type(f * left, "npt.NDArray[np.float64]"), pd.Index, timedelta) if TYPE_CHECKING_INVALID_USAGE: @@ -99,17 +95,16 @@ def test_mul_pd_index(left: "pd.Index[pd.Timedelta]") -> None: f = pd.Index([1.5]) c = pd.Index([1.7j]) - # pandas-dev/pandas#62316 - if PD_LTE_23: - check(assert_type(left * b, "pd.Index[pd.Timedelta]"), pd.Index, timedelta) + if TYPE_CHECKING_INVALID_USAGE: + _00 = left * b # type: ignore[operator] # pyright: ignore[reportOperatorIssue] check(assert_type(left * i, "pd.Index[pd.Timedelta]"), pd.Index, timedelta) check(assert_type(left * f, "pd.Index[pd.Timedelta]"), pd.Index, timedelta) if TYPE_CHECKING_INVALID_USAGE: - _0 = left * c # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _03 = left * c # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - if PD_LTE_23: - check(assert_type(b * left, "pd.Index[pd.Timedelta]"), pd.Index, timedelta) + if TYPE_CHECKING_INVALID_USAGE: + _10 = b * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] check(assert_type(i * left, "pd.Index[pd.Timedelta]"), pd.Index, timedelta) check(assert_type(f * left, "pd.Index[pd.Timedelta]"), pd.Index, timedelta) if TYPE_CHECKING_INVALID_USAGE: - _1 = c * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _13 = c * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] diff --git a/tests/indexes/arithmetic/timedeltaindex/test_mul.py b/tests/indexes/arithmetic/timedeltaindex/test_mul.py index 3bc6577c3..dcd329343 100644 --- a/tests/indexes/arithmetic/timedeltaindex/test_mul.py +++ b/tests/indexes/arithmetic/timedeltaindex/test_mul.py @@ -8,7 +8,6 @@ ) from tests import ( - PD_LTE_23, TYPE_CHECKING_INVALID_USAGE, check, ) @@ -25,40 +24,38 @@ def test_mul_py_scalar(left: pd.TimedeltaIndex) -> None: """Test pd.TimedeltaIndex * Python native scalars""" b, i, f, c = True, 1, 1.0, 1j - # pandas-dev/pandas#62316 - if PD_LTE_23: - check(assert_type(left * b, pd.TimedeltaIndex), pd.TimedeltaIndex, pd.Timedelta) + if TYPE_CHECKING_INVALID_USAGE: + _00 = left * b # type: ignore[operator] # pyright: ignore[reportOperatorIssue] check(assert_type(left * i, pd.TimedeltaIndex), pd.TimedeltaIndex, pd.Timedelta) check(assert_type(left * f, pd.TimedeltaIndex), pd.TimedeltaIndex, pd.Timedelta) if TYPE_CHECKING_INVALID_USAGE: - _0 = left * c # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _03 = left * c # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - if PD_LTE_23: - check(assert_type(b * left, pd.TimedeltaIndex), pd.TimedeltaIndex, pd.Timedelta) + if TYPE_CHECKING_INVALID_USAGE: + _10 = b * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] check(assert_type(i * left, pd.TimedeltaIndex), pd.TimedeltaIndex, pd.Timedelta) check(assert_type(f * left, pd.TimedeltaIndex), pd.TimedeltaIndex, pd.Timedelta) if TYPE_CHECKING_INVALID_USAGE: - _1 = c * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _13 = c * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] def test_mul_py_sequence(left: pd.TimedeltaIndex) -> None: """Test pd.TimedeltaIndex * Python native sequences""" b, i, f, c = [True], [2], [1.5], [1.7j] - # pandas-dev/pandas#62316 - if PD_LTE_23: - check(assert_type(left * b, pd.TimedeltaIndex), pd.TimedeltaIndex, pd.Timedelta) + if TYPE_CHECKING_INVALID_USAGE: + _00 = left * b # type: ignore[operator] # pyright: ignore[reportOperatorIssue] check(assert_type(left * i, pd.TimedeltaIndex), pd.TimedeltaIndex, pd.Timedelta) check(assert_type(left * f, pd.TimedeltaIndex), pd.TimedeltaIndex, pd.Timedelta) if TYPE_CHECKING_INVALID_USAGE: - _0 = left * c # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _03 = left * c # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - if PD_LTE_23: - check(assert_type(b * left, pd.TimedeltaIndex), pd.TimedeltaIndex, pd.Timedelta) + if TYPE_CHECKING_INVALID_USAGE: + _10 = b * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] check(assert_type(i * left, pd.TimedeltaIndex), pd.TimedeltaIndex, pd.Timedelta) check(assert_type(f * left, pd.TimedeltaIndex), pd.TimedeltaIndex, pd.Timedelta) if TYPE_CHECKING_INVALID_USAGE: - _1 = c * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _13 = c * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] def test_mul_numpy_array(left: pd.TimedeltaIndex) -> None: @@ -68,9 +65,8 @@ def test_mul_numpy_array(left: pd.TimedeltaIndex) -> None: f = np.array([1.5], np.float64) c = np.array([1.7j], np.complex128) - # pandas-dev/pandas#62316 - if PD_LTE_23: - check(assert_type(left * b, pd.TimedeltaIndex), pd.TimedeltaIndex, pd.Timedelta) + if TYPE_CHECKING_INVALID_USAGE: + assert_type(left * b, Never) check(assert_type(left * i, pd.TimedeltaIndex), pd.TimedeltaIndex, pd.Timedelta) check(assert_type(left * f, pd.TimedeltaIndex), pd.TimedeltaIndex, pd.Timedelta) if TYPE_CHECKING_INVALID_USAGE: @@ -79,12 +75,9 @@ def test_mul_numpy_array(left: pd.TimedeltaIndex) -> None: # `numpy` typing gives the corresponding `ndarray`s in the static type # checking, where our `__rmul__` cannot override. At runtime, they return # `Series` with the correct element type. - if PD_LTE_23: - check( - assert_type(b * left, "npt.NDArray[np.bool_]"), - pd.TimedeltaIndex, - pd.Timedelta, - ) + if TYPE_CHECKING_INVALID_USAGE: + # We made it Never, but numpy takes over + assert_type(b * left, "npt.NDArray[np.bool_]") check( assert_type(i * left, "npt.NDArray[np.int64]"), pd.TimedeltaIndex, pd.Timedelta ) @@ -94,7 +87,6 @@ def test_mul_numpy_array(left: pd.TimedeltaIndex) -> None: pd.Timedelta, ) if TYPE_CHECKING_INVALID_USAGE: - # We made it Never, but numpy takes over assert_type(c * left, "npt.NDArray[np.complex128]") @@ -105,17 +97,16 @@ def test_mul_pd_index(left: pd.TimedeltaIndex) -> None: f = pd.Index([1.5]) c = pd.Index([1.7j]) - # pandas-dev/pandas#62316 - if PD_LTE_23: - check(assert_type(left * b, pd.TimedeltaIndex), pd.TimedeltaIndex, pd.Timedelta) + if TYPE_CHECKING_INVALID_USAGE: + _00 = left * b # type: ignore[operator] # pyright: ignore[reportOperatorIssue] check(assert_type(left * i, pd.TimedeltaIndex), pd.TimedeltaIndex, pd.Timedelta) check(assert_type(left * f, pd.TimedeltaIndex), pd.TimedeltaIndex, pd.Timedelta) if TYPE_CHECKING_INVALID_USAGE: - _0 = left * c # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _03 = left * c # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - if PD_LTE_23: - check(assert_type(b * left, pd.TimedeltaIndex), pd.TimedeltaIndex, pd.Timedelta) + if TYPE_CHECKING_INVALID_USAGE: + _10 = b * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] check(assert_type(i * left, pd.TimedeltaIndex), pd.TimedeltaIndex, pd.Timedelta) check(assert_type(f * left, pd.TimedeltaIndex), pd.TimedeltaIndex, pd.Timedelta) if TYPE_CHECKING_INVALID_USAGE: - _1 = c * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _13 = c * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] diff --git a/tests/series/arithmetic/bool/test_mul.py b/tests/series/arithmetic/bool/test_mul.py index d781e0d8d..ea98eb821 100644 --- a/tests/series/arithmetic/bool/test_mul.py +++ b/tests/series/arithmetic/bool/test_mul.py @@ -14,7 +14,6 @@ ) from tests import ( - PD_LTE_23, TYPE_CHECKING_INVALID_USAGE, check, ) @@ -38,7 +37,7 @@ def test_mul_py_scalar(left: "pd.Series[bool]") -> None: check(assert_type(left * c, "pd.Series[complex]"), pd.Series, np.complexfloating) if TYPE_CHECKING_INVALID_USAGE: _04 = left * s # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - check(assert_type(left * d, "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta) + _05 = left * d # type: ignore[type-var] # pyright: ignore[reportOperatorIssue] check(assert_type(b * left, "pd.Series[bool]"), pd.Series, np.bool_) check(assert_type(i * left, "pd.Series[int]"), pd.Series, np.integer) @@ -46,7 +45,7 @@ def test_mul_py_scalar(left: "pd.Series[bool]") -> None: check(assert_type(c * left, "pd.Series[complex]"), pd.Series, np.complexfloating) if TYPE_CHECKING_INVALID_USAGE: _14 = s * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - check(assert_type(d * left, "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta) + _15 = d * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] check(assert_type(left.mul(b), "pd.Series[bool]"), pd.Series, np.bool_) check(assert_type(left.mul(i), "pd.Series[int]"), pd.Series, np.integer) @@ -54,7 +53,7 @@ def test_mul_py_scalar(left: "pd.Series[bool]") -> None: check(assert_type(left.mul(c), "pd.Series[complex]"), pd.Series, np.complexfloating) if TYPE_CHECKING_INVALID_USAGE: left.mul(s) # type: ignore[call-overload] # pyright: ignore[reportArgumentType,reportCallIssue] - check(assert_type(left.mul(d), "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta) + left.mul(d) # type: ignore[type-var] # pyright: ignore[reportArgumentType,reportCallIssue] check(assert_type(left.rmul(b), "pd.Series[bool]"), pd.Series, np.bool_) check(assert_type(left.rmul(i), "pd.Series[int]"), pd.Series, np.integer) @@ -64,7 +63,7 @@ def test_mul_py_scalar(left: "pd.Series[bool]") -> None: ) if TYPE_CHECKING_INVALID_USAGE: left.rmul(s) # type: ignore[call-overload] # pyright: ignore[reportArgumentType,reportCallIssue] - check(assert_type(left.rmul(d), "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta) + left.rmul(d) # type: ignore[type-var] # pyright: ignore[reportArgumentType,reportCallIssue] def test_mul_py_sequence(left: "pd.Series[bool]") -> None: @@ -79,10 +78,7 @@ def test_mul_py_sequence(left: "pd.Series[bool]") -> None: check(assert_type(left * c, "pd.Series[complex]"), pd.Series, np.complexfloating) if TYPE_CHECKING_INVALID_USAGE: _04 = left * s # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - if PD_LTE_23: - # pandas-dev/pandas#62316: both timedelta * bool - # and np.timedelta64 * bool works, so pandas probably also should work - check(assert_type(left * d, "pd.Series[pd.Timedelta]"), pd.Series, timedelta) + _05 = left * d # type: ignore[operator] # pyright: ignore[reportOperatorIssue] check(assert_type(b * left, "pd.Series[bool]"), pd.Series, np.bool_) check(assert_type(i * left, "pd.Series[int]"), pd.Series, np.integer) @@ -90,10 +86,7 @@ def test_mul_py_sequence(left: "pd.Series[bool]") -> None: check(assert_type(c * left, "pd.Series[complex]"), pd.Series, np.complexfloating) if TYPE_CHECKING_INVALID_USAGE: _14 = s * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - if PD_LTE_23: - # pandas-dev/pandas#62316: both timedelta * bool - # and np.timedelta64 * bool works, so pandas probably also should work - check(assert_type(d * left, "pd.Series[pd.Timedelta]"), pd.Series, timedelta) + _15 = d * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] check(assert_type(left.mul(b), "pd.Series[bool]"), pd.Series, np.bool_) check(assert_type(left.mul(i), "pd.Series[int]"), pd.Series, np.integer) @@ -101,10 +94,7 @@ def test_mul_py_sequence(left: "pd.Series[bool]") -> None: check(assert_type(left.mul(c), "pd.Series[complex]"), pd.Series, np.complexfloating) if TYPE_CHECKING_INVALID_USAGE: left.mul(s) # type: ignore[arg-type] # pyright: ignore[reportArgumentType,reportCallIssue] - if PD_LTE_23: - # pandas-dev/pandas#62316: both timedelta * bool - # and np.timedelta64 * bool works, so pandas probably also should work - check(assert_type(left.mul(d), "pd.Series[pd.Timedelta]"), pd.Series, timedelta) + left.mul(d) # type: ignore[arg-type] # pyright: ignore[reportArgumentType,reportCallIssue] check(assert_type(left.rmul(b), "pd.Series[bool]"), pd.Series, np.bool_) check(assert_type(left.rmul(i), "pd.Series[int]"), pd.Series, np.integer) @@ -114,12 +104,7 @@ def test_mul_py_sequence(left: "pd.Series[bool]") -> None: ) if TYPE_CHECKING_INVALID_USAGE: left.rmul(s) # type: ignore[arg-type] # pyright: ignore[reportArgumentType,reportCallIssue] - if PD_LTE_23: - # pandas-dev/pandas#62316: both timedelta * bool - # and np.timedelta64 * bool works, so pandas probably also should work - check( - assert_type(left.rmul(d), "pd.Series[pd.Timedelta]"), pd.Series, timedelta - ) + left.rmul(d) # type: ignore[arg-type] # pyright: ignore[reportArgumentType,reportCallIssue] def test_mul_numpy_array(left: "pd.Series[bool]") -> None: @@ -137,10 +122,7 @@ def test_mul_numpy_array(left: "pd.Series[bool]") -> None: check(assert_type(left * c, "pd.Series[complex]"), pd.Series, np.complexfloating) if TYPE_CHECKING_INVALID_USAGE: assert_type(left * s, Never) - if PD_LTE_23: - # pandas-dev/pandas#62316: both timedelta * bool - # and np.timedelta64 * bool works, so pandas probably also should work - check(assert_type(left * d, "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta) + assert_type(left * d, Never) # `numpy` typing gives the corresponding `ndarray`s in the static type # checking, where our `__rmul__` cannot override. At runtime, they return @@ -155,14 +137,7 @@ def test_mul_numpy_array(left: "pd.Series[bool]") -> None: ) if TYPE_CHECKING_INVALID_USAGE: assert_type(s * left, Any) - if PD_LTE_23: - # pandas-dev/pandas#62316: both timedelta * bool - # and np.timedelta64 * bool works, so pandas probably also should work - check( - assert_type(d * left, "npt.NDArray[np.timedelta64]"), - pd.Series, - pd.Timedelta, - ) + assert_type(d * left, "npt.NDArray[np.timedelta64]") check(assert_type(left.mul(b), "pd.Series[bool]"), pd.Series, np.bool_) check(assert_type(left.mul(i), "pd.Series[int]"), pd.Series, np.integer) @@ -170,12 +145,7 @@ def test_mul_numpy_array(left: "pd.Series[bool]") -> None: check(assert_type(left.mul(c), "pd.Series[complex]"), pd.Series, np.complexfloating) if TYPE_CHECKING_INVALID_USAGE: left.mul(s) # type: ignore[arg-type] # pyright: ignore[reportArgumentType,reportCallIssue] - if PD_LTE_23: - # pandas-dev/pandas#62316: both timedelta * bool - # and np.timedelta64 * bool works, so pandas probably also should work - check( - assert_type(left.mul(d), "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta - ) + left.mul(d) # type: ignore[type-var] # pyright: ignore[reportArgumentType,reportCallIssue] check(assert_type(left.rmul(b), "pd.Series[bool]"), pd.Series, np.bool_) check(assert_type(left.rmul(i), "pd.Series[int]"), pd.Series, np.integer) @@ -185,14 +155,7 @@ def test_mul_numpy_array(left: "pd.Series[bool]") -> None: ) if TYPE_CHECKING_INVALID_USAGE: left.rmul(s) # type: ignore[arg-type] # pyright: ignore[reportArgumentType,reportCallIssue] - if PD_LTE_23: - # pandas-dev/pandas#62316: both timedelta * bool - # and np.timedelta64 * bool works, so pandas probably also should work - check( - assert_type(left.rmul(d), "pd.Series[pd.Timedelta]"), - pd.Series, - pd.Timedelta, - ) + left.rmul(d) # type: ignore[type-var] # pyright: ignore[reportArgumentType,reportCallIssue] def test_mul_pd_index(left: "pd.Series[bool]") -> None: @@ -210,10 +173,7 @@ def test_mul_pd_index(left: "pd.Series[bool]") -> None: check(assert_type(left * c, "pd.Series[complex]"), pd.Series, np.complexfloating) if TYPE_CHECKING_INVALID_USAGE: _04 = left * s # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - if PD_LTE_23: - # pandas-dev/pandas#62316: both timedelta * bool - # and np.timedelta64 * bool works, so pandas probably also should work - check(assert_type(left * d, "pd.Series[pd.Timedelta]"), pd.Series, timedelta) + _05 = left * d # type: ignore[operator] # pyright: ignore[reportOperatorIssue] check(assert_type(b * left, "pd.Series[bool]"), pd.Series, np.bool_) check(assert_type(i * left, "pd.Series[int]"), pd.Series, np.integer) @@ -221,10 +181,7 @@ def test_mul_pd_index(left: "pd.Series[bool]") -> None: check(assert_type(c * left, "pd.Series[complex]"), pd.Series, np.complexfloating) if TYPE_CHECKING_INVALID_USAGE: _14 = s * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - if PD_LTE_23: - # pandas-dev/pandas#62316: both timedelta * bool - # and np.timedelta64 * bool works, so pandas probably also should work - check(assert_type(d * left, "pd.Series[pd.Timedelta]"), pd.Series, timedelta) + _15 = d * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] check(assert_type(left.mul(b), "pd.Series[bool]"), pd.Series, np.bool_) check(assert_type(left.mul(i), "pd.Series[int]"), pd.Series, np.integer) @@ -232,10 +189,7 @@ def test_mul_pd_index(left: "pd.Series[bool]") -> None: check(assert_type(left.mul(c), "pd.Series[complex]"), pd.Series, np.complexfloating) if TYPE_CHECKING_INVALID_USAGE: left.mul(s) # type: ignore[arg-type] # pyright: ignore[reportArgumentType,reportCallIssue] - if PD_LTE_23: - # pandas-dev/pandas#62316: both timedelta * bool - # and np.timedelta64 * bool works, so pandas probably also should work - check(assert_type(left.mul(d), "pd.Series[pd.Timedelta]"), pd.Series, timedelta) + left.mul(d) # type: ignore[arg-type] # pyright: ignore[reportArgumentType,reportCallIssue] check(assert_type(left.rmul(b), "pd.Series[bool]"), pd.Series, np.bool_) check(assert_type(left.rmul(i), "pd.Series[int]"), pd.Series, np.integer) @@ -245,12 +199,7 @@ def test_mul_pd_index(left: "pd.Series[bool]") -> None: ) if TYPE_CHECKING_INVALID_USAGE: left.rmul(s) # type: ignore[arg-type] # pyright: ignore[reportArgumentType,reportCallIssue] - if PD_LTE_23: - # pandas-dev/pandas#62316: both timedelta * bool - # and np.timedelta64 * bool works, so pandas probably also should work - check( - assert_type(left.rmul(d), "pd.Series[pd.Timedelta]"), pd.Series, timedelta - ) + left.rmul(d) # type: ignore[arg-type] # pyright: ignore[reportArgumentType,reportCallIssue] def test_mul_pd_series(left: "pd.Series[bool]") -> None: @@ -268,10 +217,7 @@ def test_mul_pd_series(left: "pd.Series[bool]") -> None: check(assert_type(left * c, "pd.Series[complex]"), pd.Series, np.complexfloating) if TYPE_CHECKING_INVALID_USAGE: _04 = left * s # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - if PD_LTE_23: - # pandas-dev/pandas#62316: both timedelta * bool - # and np.timedelta64 * bool works, so pandas probably also should work - check(assert_type(left * d, "pd.Series[pd.Timedelta]"), pd.Series, timedelta) + _05 = left * d # type: ignore[operator] # pyright: ignore[reportOperatorIssue] check(assert_type(b * left, "pd.Series[bool]"), pd.Series, np.bool_) check(assert_type(i * left, "pd.Series[int]"), pd.Series, np.integer) @@ -279,10 +225,7 @@ def test_mul_pd_series(left: "pd.Series[bool]") -> None: check(assert_type(c * left, "pd.Series[complex]"), pd.Series, np.complexfloating) if TYPE_CHECKING_INVALID_USAGE: _14 = s * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - if PD_LTE_23: - # pandas-dev/pandas#62316: both timedelta * bool - # and np.timedelta64 * bool works, so pandas probably also should work - check(assert_type(d * left, "pd.Series[pd.Timedelta]"), pd.Series, timedelta) + _15 = d * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] check(assert_type(left.mul(b), "pd.Series[bool]"), pd.Series, np.bool_) check(assert_type(left.mul(i), "pd.Series[int]"), pd.Series, np.integer) @@ -290,10 +233,7 @@ def test_mul_pd_series(left: "pd.Series[bool]") -> None: check(assert_type(left.mul(c), "pd.Series[complex]"), pd.Series, np.complexfloating) if TYPE_CHECKING_INVALID_USAGE: left.mul(s) # type: ignore[arg-type] # pyright: ignore[reportArgumentType,reportCallIssue] - if PD_LTE_23: - # pandas-dev/pandas#62316: both timedelta * bool - # and np.timedelta64 * bool works, so pandas probably also should work - check(assert_type(left.mul(d), "pd.Series[pd.Timedelta]"), pd.Series, timedelta) + left.mul(d) # type: ignore[arg-type] # pyright: ignore[reportArgumentType,reportCallIssue] check(assert_type(left.rmul(b), "pd.Series[bool]"), pd.Series, np.bool_) check(assert_type(left.rmul(i), "pd.Series[int]"), pd.Series, np.integer) @@ -303,9 +243,4 @@ def test_mul_pd_series(left: "pd.Series[bool]") -> None: ) if TYPE_CHECKING_INVALID_USAGE: left.rmul(s) # type: ignore[arg-type] # pyright: ignore[reportArgumentType,reportCallIssue] - if PD_LTE_23: - # pandas-dev/pandas#62316: both timedelta * bool - # and np.timedelta64 * bool works, so pandas probably also should work - check( - assert_type(left.rmul(d), "pd.Series[pd.Timedelta]"), pd.Series, timedelta - ) + left.rmul(d) # type: ignore[arg-type] # pyright: ignore[reportArgumentType,reportCallIssue] diff --git a/tests/series/arithmetic/timedelta/test_mul.py b/tests/series/arithmetic/timedelta/test_mul.py index 5eaf68ffd..4d0b5fe26 100644 --- a/tests/series/arithmetic/timedelta/test_mul.py +++ b/tests/series/arithmetic/timedelta/test_mul.py @@ -8,7 +8,6 @@ ) from tests import ( - PD_LTE_23, TYPE_CHECKING_INVALID_USAGE, check, ) @@ -25,36 +24,29 @@ def test_mul_py_scalar(left: "pd.Series[pd.Timedelta]") -> None: """Test pd.Series[pd.Timedelta] * Python native scalars""" b, i, f, c = True, 1, 1.0, 1j - # pandas-dev/pandas#62316 - if PD_LTE_23: - check(assert_type(left * b, "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta) + if TYPE_CHECKING_INVALID_USAGE: + _00 = left * b # type: ignore[operator] # pyright: ignore[reportOperatorIssue] check(assert_type(left * i, "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta) check(assert_type(left * f, "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta) if TYPE_CHECKING_INVALID_USAGE: - _0 = left * c # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _03 = left * c # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - if PD_LTE_23: - check(assert_type(b * left, "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta) + if TYPE_CHECKING_INVALID_USAGE: + _10 = b * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] check(assert_type(i * left, "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta) check(assert_type(f * left, "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta) if TYPE_CHECKING_INVALID_USAGE: - _1 = c * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _13 = c * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - if PD_LTE_23: - check( - assert_type(left.mul(b), "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta - ) + if TYPE_CHECKING_INVALID_USAGE: + left.mul(b) # type: ignore[arg-type] # pyright: ignore[reportArgumentType,reportCallIssue] check(assert_type(left.mul(i), "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta) check(assert_type(left.mul(f), "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta) if TYPE_CHECKING_INVALID_USAGE: left.mul(c) # type: ignore[arg-type] # pyright: ignore[reportArgumentType,reportCallIssue] - if PD_LTE_23: - check( - assert_type(left.rmul(b), "pd.Series[pd.Timedelta]"), - pd.Series, - pd.Timedelta, - ) + if TYPE_CHECKING_INVALID_USAGE: + left.rmul(b) # type: ignore[arg-type] # pyright: ignore[reportArgumentType,reportCallIssue] check(assert_type(left.rmul(i), "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta) check(assert_type(left.rmul(f), "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta) if TYPE_CHECKING_INVALID_USAGE: @@ -65,36 +57,29 @@ def test_mul_py_sequence(left: "pd.Series[pd.Timedelta]") -> None: """Test pd.Series[pd.Timedelta] * Python native sequences""" b, i, f, c = [True], [2], [1.5], [1.7j] - # pandas-dev/pandas#62316 - if PD_LTE_23: - check(assert_type(left * b, "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta) + if TYPE_CHECKING_INVALID_USAGE: + _00 = left * b # type: ignore[operator] # pyright: ignore[reportOperatorIssue] check(assert_type(left * i, "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta) check(assert_type(left * f, "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta) if TYPE_CHECKING_INVALID_USAGE: - _0 = left * c # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _03 = left * c # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - if PD_LTE_23: - check(assert_type(b * left, "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta) + if TYPE_CHECKING_INVALID_USAGE: + _10 = b * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] check(assert_type(i * left, "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta) check(assert_type(f * left, "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta) if TYPE_CHECKING_INVALID_USAGE: - _1 = c * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _13 = c * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - if PD_LTE_23: - check( - assert_type(left.mul(b), "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta - ) + if TYPE_CHECKING_INVALID_USAGE: + left.mul(b) # type: ignore[arg-type] # pyright: ignore[reportArgumentType,reportCallIssue] check(assert_type(left.mul(i), "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta) check(assert_type(left.mul(f), "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta) if TYPE_CHECKING_INVALID_USAGE: left.mul(c) # type: ignore[arg-type] # pyright: ignore[reportArgumentType,reportCallIssue] - if PD_LTE_23: - check( - assert_type(left.rmul(b), "pd.Series[pd.Timedelta]"), - pd.Series, - pd.Timedelta, - ) + if TYPE_CHECKING_INVALID_USAGE: + left.rmul(b) # type: ignore[arg-type] # pyright: ignore[reportArgumentType,reportCallIssue] check(assert_type(left.rmul(i), "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta) check(assert_type(left.rmul(f), "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta) if TYPE_CHECKING_INVALID_USAGE: @@ -108,9 +93,8 @@ def test_mul_numpy_array(left: "pd.Series[pd.Timedelta]") -> None: f = np.array([1.5], np.float64) c = np.array([1.7j], np.complex128) - # pandas-dev/pandas#62316 - if PD_LTE_23: - check(assert_type(left * b, "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta) + if TYPE_CHECKING_INVALID_USAGE: + assert_type(left * b, Never) check(assert_type(left * i, "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta) check(assert_type(left * f, "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta) if TYPE_CHECKING_INVALID_USAGE: @@ -119,29 +103,23 @@ def test_mul_numpy_array(left: "pd.Series[pd.Timedelta]") -> None: # `numpy` typing gives the corresponding `ndarray`s in the static type # checking, where our `__rmul__` cannot override. At runtime, they return # `Series` with the correct element type. - if PD_LTE_23: - check(assert_type(b * left, "npt.NDArray[np.bool_]"), pd.Series, pd.Timedelta) + if TYPE_CHECKING_INVALID_USAGE: + assert_type(b * left, "npt.NDArray[np.bool_]") check(assert_type(i * left, "npt.NDArray[np.int64]"), pd.Series, pd.Timedelta) check(assert_type(f * left, "npt.NDArray[np.float64]"), pd.Series, pd.Timedelta) if TYPE_CHECKING_INVALID_USAGE: # We made it Never, but numpy takes over assert_type(c * left, "npt.NDArray[np.complex128]") - if PD_LTE_23: - check( - assert_type(left.mul(b), "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta - ) + if TYPE_CHECKING_INVALID_USAGE: + left.mul(b) # type: ignore[arg-type] # pyright: ignore[reportArgumentType,reportCallIssue] check(assert_type(left.mul(i), "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta) check(assert_type(left.mul(f), "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta) if TYPE_CHECKING_INVALID_USAGE: left.mul(c) # type: ignore[arg-type] # pyright: ignore[reportArgumentType,reportCallIssue] - if PD_LTE_23: - check( - assert_type(left.rmul(b), "pd.Series[pd.Timedelta]"), - pd.Series, - pd.Timedelta, - ) + if TYPE_CHECKING_INVALID_USAGE: + left.rmul(b) # type: ignore[arg-type] # pyright: ignore[reportArgumentType,reportCallIssue] check(assert_type(left.rmul(i), "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta) check(assert_type(left.rmul(f), "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta) if TYPE_CHECKING_INVALID_USAGE: @@ -155,36 +133,29 @@ def test_mul_pd_index(left: "pd.Series[pd.Timedelta]") -> None: f = pd.Index([1.5]) c = pd.Index([1.7j]) - # pandas-dev/pandas#62316 - if PD_LTE_23: - check(assert_type(left * b, "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta) + if TYPE_CHECKING_INVALID_USAGE: + _00 = left * b # type: ignore[operator] # pyright: ignore[reportOperatorIssue] check(assert_type(left * i, "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta) check(assert_type(left * f, "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta) if TYPE_CHECKING_INVALID_USAGE: - _0 = left * c # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _03 = left * c # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - if PD_LTE_23: - check(assert_type(b * left, "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta) + if TYPE_CHECKING_INVALID_USAGE: + _10 = b * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] check(assert_type(i * left, "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta) check(assert_type(f * left, "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta) if TYPE_CHECKING_INVALID_USAGE: - _1 = c * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _13 = c * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - if PD_LTE_23: - check( - assert_type(left.mul(b), "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta - ) + if TYPE_CHECKING_INVALID_USAGE: + left.mul(b) # type: ignore[arg-type] # pyright: ignore[reportArgumentType,reportCallIssue] check(assert_type(left.mul(i), "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta) check(assert_type(left.mul(f), "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta) if TYPE_CHECKING_INVALID_USAGE: left.mul(c) # type: ignore[arg-type] # pyright: ignore[reportArgumentType,reportCallIssue] - if PD_LTE_23: - check( - assert_type(left.rmul(b), "pd.Series[pd.Timedelta]"), - pd.Series, - pd.Timedelta, - ) + if TYPE_CHECKING_INVALID_USAGE: + left.rmul(b) # type: ignore[arg-type] # pyright: ignore[reportArgumentType,reportCallIssue] check(assert_type(left.rmul(i), "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta) check(assert_type(left.rmul(f), "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta) if TYPE_CHECKING_INVALID_USAGE: @@ -198,36 +169,29 @@ def test_mul_pd_series(left: "pd.Series[pd.Timedelta]") -> None: f = pd.Series([1.5]) c = pd.Series([1.7j]) - # pandas-dev/pandas#62316 - if PD_LTE_23: - check(assert_type(left * b, "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta) + if TYPE_CHECKING_INVALID_USAGE: + _00 = left * b # type: ignore[operator] # pyright: ignore[reportOperatorIssue] check(assert_type(left * i, "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta) check(assert_type(left * f, "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta) if TYPE_CHECKING_INVALID_USAGE: - _0 = left * c # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _03 = left * c # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - if PD_LTE_23: - check(assert_type(b * left, "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta) + if TYPE_CHECKING_INVALID_USAGE: + _10 = b * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] check(assert_type(i * left, "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta) check(assert_type(f * left, "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta) if TYPE_CHECKING_INVALID_USAGE: - _1 = c * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + _13 = c * left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - if PD_LTE_23: - check( - assert_type(left.mul(b), "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta - ) + if TYPE_CHECKING_INVALID_USAGE: + left.mul(b) # type: ignore[arg-type] # pyright: ignore[reportArgumentType,reportCallIssue] check(assert_type(left.mul(i), "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta) check(assert_type(left.mul(f), "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta) if TYPE_CHECKING_INVALID_USAGE: left.mul(c) # type: ignore[arg-type] # pyright: ignore[reportArgumentType,reportCallIssue] - if PD_LTE_23: - check( - assert_type(left.rmul(b), "pd.Series[pd.Timedelta]"), - pd.Series, - pd.Timedelta, - ) + if TYPE_CHECKING_INVALID_USAGE: + left.rmul(b) # type: ignore[arg-type] # pyright: ignore[reportArgumentType,reportCallIssue] check(assert_type(left.rmul(i), "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta) check(assert_type(left.rmul(f), "pd.Series[pd.Timedelta]"), pd.Series, pd.Timedelta) if TYPE_CHECKING_INVALID_USAGE: