From 8bdee51ca28b6797cc18cfcd4cb16708090b63c4 Mon Sep 17 00:00:00 2001 From: cmp0xff Date: Mon, 1 Dec 2025 17:49:27 +0100 Subject: [PATCH 1/6] fix: pandas-dev/pandas#63195 --- pandas-stubs/core/frame.pyi | 10 ++ pandas-stubs/core/series.pyi | 3 + tests/series/test_series.py | 210 ++++++++++++++++------ tests/test_frame.py | 330 +++++++++++++++++++++++++++-------- 4 files changed, 425 insertions(+), 128 deletions(-) diff --git a/pandas-stubs/core/frame.pyi b/pandas-stubs/core/frame.pyi index 344121c01..5686bbf04 100644 --- a/pandas-stubs/core/frame.pyi +++ b/pandas-stubs/core/frame.pyi @@ -1027,6 +1027,7 @@ class DataFrame(NDFrame, OpsMixin, _GetItemHack): axis: Axis | None = ..., limit: int = ..., inplace: Literal[True], + # TODO: pandas-dev/pandas#63195 return Self after Pandas 3.0 ) -> None: ... @overload def fillna( @@ -1045,6 +1046,7 @@ class DataFrame(NDFrame, OpsMixin, _GetItemHack): *, inplace: Literal[True], regex: ReplaceValue | Mapping[HashableT3, ReplaceValue] = ..., + # TODO: pandas-dev/pandas#63195 return Self after Pandas 3.0 ) -> None: ... @overload def replace( @@ -2046,6 +2048,7 @@ class DataFrame(NDFrame, OpsMixin, _GetItemHack): inplace: Literal[True], limit: int | None = ..., limit_area: Literal["inside", "outside"] | None = ..., + # TODO: pandas-dev/pandas#63195 return Self after Pandas 3.0 ) -> None: ... @overload def bfill( @@ -2105,6 +2108,7 @@ class DataFrame(NDFrame, OpsMixin, _GetItemHack): axis: Axis | None = ..., inplace: Literal[True], **kwargs: Any, + # TODO: pandas-dev/pandas#63195 return Self after Pandas 3.0 ) -> None: ... @overload def clip( @@ -2115,6 +2119,7 @@ class DataFrame(NDFrame, OpsMixin, _GetItemHack): axis: Axis = ..., inplace: Literal[True], **kwargs: Any, + # TODO: pandas-dev/pandas#63195 return Self after Pandas 3.0 ) -> None: ... @overload def clip( @@ -2125,6 +2130,7 @@ class DataFrame(NDFrame, OpsMixin, _GetItemHack): axis: Axis = ..., inplace: Literal[True], **kwargs: Any, + # TODO: pandas-dev/pandas#63195 return Self after Pandas 3.0 ) -> None: ... @final def copy(self, deep: _bool = True) -> Self: ... @@ -2209,6 +2215,7 @@ class DataFrame(NDFrame, OpsMixin, _GetItemHack): inplace: Literal[True], limit: int | None = ..., limit_area: Literal["inside", "outside"] | None = ..., + # TODO: pandas-dev/pandas#63195 return Self after Pandas 3.0 ) -> None: ... @overload def ffill( @@ -2270,6 +2277,7 @@ class DataFrame(NDFrame, OpsMixin, _GetItemHack): limit_area: Literal["inside", "outside"] | None = ..., inplace: Literal[True], **kwargs: Any, + # TODO: pandas-dev/pandas#63195 return Self after Pandas 3.0 ) -> None: ... @overload def interpolate( @@ -2327,6 +2335,7 @@ class DataFrame(NDFrame, OpsMixin, _GetItemHack): inplace: Literal[True], axis: Axis | None = ..., level: Level | None = None, + # TODO: pandas-dev/pandas#63195 return Self after Pandas 3.0 ) -> None: ... @overload def mask( @@ -2799,6 +2808,7 @@ class DataFrame(NDFrame, OpsMixin, _GetItemHack): inplace: Literal[True], axis: Axis | None = ..., level: Level | None = None, + # TODO: pandas-dev/pandas#63195 return Self after Pandas 3.0 ) -> None: ... @overload def where( diff --git a/pandas-stubs/core/series.pyi b/pandas-stubs/core/series.pyi index dfa25dc93..151b8e943 100644 --- a/pandas-stubs/core/series.pyi +++ b/pandas-stubs/core/series.pyi @@ -1280,6 +1280,7 @@ class Series(IndexOpsMixin[S1], ElementOpsMixin[S1], NDFrame): *, regex: ReplaceValue = ..., inplace: Literal[True], + # TODO: pandas-dev/pandas#63195 return Self after Pandas 3.0 ) -> None: ... @overload def replace( @@ -1543,6 +1544,7 @@ class Series(IndexOpsMixin[S1], ElementOpsMixin[S1], NDFrame): limit_direction: Literal["forward", "backward", "both"] | None = ..., limit_area: Literal["inside", "outside"] | None = ..., **kwargs: Any, + # TODO: pandas-dev/pandas#63195 return Self after Pandas 3.0 ) -> None: ... @overload def interpolate( @@ -1581,6 +1583,7 @@ class Series(IndexOpsMixin[S1], ElementOpsMixin[S1], NDFrame): axis: AxisIndex | None = 0, inplace: Literal[True], **kwargs: Any, + # TODO: pandas-dev/pandas#63195 return Self after Pandas 3.0 ) -> None: ... @overload def clip( diff --git a/tests/series/test_series.py b/tests/series/test_series.py index c34b01694..b958c69af 100644 --- a/tests/series/test_series.py +++ b/tests/series/test_series.py @@ -394,7 +394,11 @@ def test_types_fillna() -> None: pd.Series, float, ) - assert assert_type(s.fillna(0, inplace=True), None) is None + # TODO: pandas-dev/pandas#63195 return Self after Pandas 3.0 + if PD_LTE_23: + assert assert_type(s.fillna(0, inplace=True), None) is None + else: + check(assert_type(s.fillna(0, inplace=True), None), pd.Series, np.floating) check(assert_type(s.fillna(0), "pd.Series[float]"), pd.Series, float) check( assert_type(s.fillna(0, limit=1), "pd.Series[float]"), @@ -469,11 +473,7 @@ def test_types_shift() -> None: """Test shift operator on series with different arguments.""" s = pd.Series([1, 2, 3], index=pd.date_range("2020", periods=3)) check(assert_type(s.shift(), pd.Series), pd.Series, np.floating) - check( - assert_type(s.shift(axis=0, periods=1), pd.Series), - pd.Series, - np.floating, - ) + check(assert_type(s.shift(axis=0, periods=1), pd.Series), pd.Series, np.floating) check(assert_type(s.shift(-1, fill_value=0), pd.Series), pd.Series, np.integer) check(assert_type(s.shift(freq="1D"), pd.Series), pd.Series, np.integer) check(assert_type(s.shift(freq=BDay(1)), pd.Series), pd.Series, np.integer) @@ -646,17 +646,38 @@ def test_types_clip() -> None: pd.Series, np.integer, ) - check(assert_type(s.clip(lower=0, upper=5, inplace=True), None), type(None)) - check(assert_type(s.clip(lower=0, upper=None, inplace=True), None), type(None)) + # TODO: pandas-dev/pandas#63195 return Self after Pandas 3.0 + if PD_LTE_23: + check(assert_type(s.clip(lower=0, upper=5, inplace=True), None), type(None)) + check(assert_type(s.clip(lower=0, upper=None, inplace=True), None), type(None)) + else: + check( + assert_type(s.clip(lower=0, upper=5, inplace=True), None), + pd.Series, + np.integer, + ) + check( + assert_type(s.clip(lower=0, upper=None, inplace=True), None), + pd.Series, + np.integer, + ) check( assert_type(s.clip(lower=None, upper=None, inplace=True), "pd.Series[int]"), pd.Series, np.integer, ) - check( - assert_type(s.clip(lower=None, upper=5, inplace=True), None), - type(None), - ) + # TODO: pandas-dev/pandas#63195 return Self after Pandas 3.0 + if PD_LTE_23: + check( + assert_type(s.clip(lower=None, upper=5, inplace=True), None), + type(None), + ) + else: + check( + assert_type(s.clip(lower=None, upper=5, inplace=True), None), + pd.Series, + np.integer, + ) check( assert_type(s.clip(lower=lower, upper=upper), "pd.Series[int]"), pd.Series, @@ -672,15 +693,40 @@ def test_types_clip() -> None: pd.Series, np.integer, ) - check(assert_type(s.clip(lower=lower, upper=upper, inplace=True), None), type(None)) - check( - assert_type(s.clip(lower=lower, upper=upper, axis=0, inplace=True), None), - type(None), - ) - check( - assert_type(s.clip(lower=lower, upper=upper, axis="index", inplace=True), None), - type(None), - ) + # TODO: pandas-dev/pandas#63195 return Self after Pandas 3.0 + if PD_LTE_23: + check( + assert_type(s.clip(lower=lower, upper=upper, inplace=True), None), + type(None), + ) + check( + assert_type(s.clip(lower=lower, upper=upper, axis=0, inplace=True), None), + type(None), + ) + check( + assert_type( + s.clip(lower=lower, upper=upper, axis="index", inplace=True), None + ), + type(None), + ) + else: + check( + assert_type(s.clip(lower=lower, upper=upper, inplace=True), None), + pd.Series, + np.integer, + ) + check( + assert_type(s.clip(lower=lower, upper=upper, axis=0, inplace=True), None), + pd.Series, + np.integer, + ) + check( + assert_type( + s.clip(lower=lower, upper=upper, axis="index", inplace=True), None + ), + pd.Series, + np.integer, + ) # without lower check(assert_type(s.clip(upper=None), "pd.Series[int]"), pd.Series, np.integer) @@ -690,7 +736,11 @@ def test_types_clip() -> None: pd.Series, np.integer, ) - check(assert_type(s.clip(upper=5, inplace=True), None), type(None)) + # TODO: pandas-dev/pandas#63195 return Self after Pandas 3.0 + if PD_LTE_23: + check(assert_type(s.clip(upper=5, inplace=True), None), type(None)) + else: + check(assert_type(s.clip(upper=5, inplace=True), None), pd.Series, np.integer) check(assert_type(s.clip(upper=upper), "pd.Series[int]"), pd.Series, np.integer) check( assert_type(s.clip(upper=upper, axis=0), "pd.Series[int]"), @@ -702,11 +752,28 @@ def test_types_clip() -> None: pd.Series, np.integer, ) - check(assert_type(s.clip(upper=upper, inplace=True), None), type(None)) - check(assert_type(s.clip(upper=upper, axis=0, inplace=True), None), type(None)) - check( - assert_type(s.clip(upper=upper, axis="index", inplace=True), None), type(None) - ) + # TODO: pandas-dev/pandas#63195 return Self after Pandas 3.0 + if PD_LTE_23: + check(assert_type(s.clip(upper=upper, inplace=True), None), type(None)) + check(assert_type(s.clip(upper=upper, axis=0, inplace=True), None), type(None)) + check( + assert_type(s.clip(upper=upper, axis="index", inplace=True), None), + type(None), + ) + else: + check( + assert_type(s.clip(upper=upper, inplace=True), None), pd.Series, np.integer + ) + check( + assert_type(s.clip(upper=upper, axis=0, inplace=True), None), + pd.Series, + np.integer, + ) + check( + assert_type(s.clip(upper=upper, axis="index", inplace=True), None), + pd.Series, + np.integer, + ) # without upper check(assert_type(s.clip(lower=None), "pd.Series[int]"), pd.Series, np.integer) @@ -734,11 +801,28 @@ def test_types_clip() -> None: pd.Series, np.integer, ) - check(assert_type(s.clip(lower=lower, inplace=True), None), type(None)) - check(assert_type(s.clip(lower=lower, axis=0, inplace=True), None), type(None)) - check( - assert_type(s.clip(lower=lower, axis="index", inplace=True), None), type(None) - ) + # TODO: pandas-dev/pandas#63195 return Self after Pandas 3.0 + if PD_LTE_23: + check(assert_type(s.clip(lower=lower, inplace=True), None), type(None)) + check(assert_type(s.clip(lower=lower, axis=0, inplace=True), None), type(None)) + check( + assert_type(s.clip(lower=lower, axis="index", inplace=True), None), + type(None), + ) + else: + check( + assert_type(s.clip(lower=lower, inplace=True), None), pd.Series, np.integer + ) + check( + assert_type(s.clip(lower=lower, axis=0, inplace=True), None), + pd.Series, + np.integer, + ) + check( + assert_type(s.clip(lower=lower, axis="index", inplace=True), None), + pd.Series, + np.integer, + ) if TYPE_CHECKING_INVALID_USAGE: s.clip(lower=lower, axis=1) # type: ignore[call-overload] # pyright: ignore[reportArgumentType] @@ -1322,11 +1406,7 @@ def test_types_agg() -> None: def test_types_aggregate() -> None: s = pd.Series([1, 2, 3], index=["col1", "col2", "col3"]) check(assert_type(s.aggregate("min"), int), np.integer) - check( - assert_type(s.aggregate(["min", "max"]), pd.Series), - pd.Series, - np.integer, - ) + check(assert_type(s.aggregate(["min", "max"]), pd.Series), pd.Series, np.integer) check(assert_type(s.aggregate({"a": "min"}), pd.Series), pd.Series, np.integer) with pytest_warns_bounded( FutureWarning, @@ -1334,11 +1414,7 @@ def test_types_aggregate() -> None: upper="2.3.99", ): check(assert_type(s.aggregate(min), int), np.integer if PD_LTE_23 else int) - check( - assert_type(s.aggregate([min, max]), pd.Series), - pd.Series, - np.integer, - ) + check(assert_type(s.aggregate([min, max]), pd.Series), pd.Series, np.integer) check(assert_type(s.aggregate({0: min}), pd.Series), pd.Series, np.integer) @@ -1521,8 +1597,17 @@ def test_types_bfill() -> None: pd.Series, np.integer, ) - assert assert_type(s1.bfill(inplace=True), None) is None - assert assert_type(s1.bfill(inplace=True, limit_area="outside"), None) is None + # TODO: pandas-dev/pandas#63195 return Self after Pandas 3.0 + if PD_LTE_23: + assert assert_type(s1.bfill(inplace=True), None) is None + assert assert_type(s1.bfill(inplace=True, limit_area="outside"), None) is None + else: + check(assert_type(s1.bfill(inplace=True), None), pd.Series, np.integer) + check( + assert_type(s1.bfill(inplace=True, limit_area="outside"), None), + pd.Series, + np.integer, + ) def test_types_ewm() -> None: @@ -1571,8 +1656,17 @@ def test_types_ffill() -> None: pd.Series, np.integer, ) - assert assert_type(s1.ffill(inplace=True), None) is None - assert assert_type(s1.ffill(inplace=True, limit_area="outside"), None) is None + # TODO: pandas-dev/pandas#63195 return Self after Pandas 3.0 + if PD_LTE_23: + assert assert_type(s1.ffill(inplace=True), None) is None + assert assert_type(s1.ffill(inplace=True, limit_area="outside"), None) is None + else: + check(assert_type(s1.ffill(inplace=True), None), pd.Series, np.integer) + check( + assert_type(s1.ffill(inplace=True, limit_area="outside"), None), + pd.Series, + np.integer, + ) def test_types_as_type() -> None: @@ -1668,7 +1762,11 @@ def test_types_replace() -> None: pd.Series, np.integer, ) - assert assert_type(s.replace(1, 2, inplace=True), None) is None + # TODO: pandas-dev/pandas#63195 return Self after Pandas 3.0 + if PD_LTE_23: + assert assert_type(s.replace(1, 2, inplace=True), None) is None + else: + check(assert_type(s.replace(1, 2, inplace=True), None), pd.Series, np.integer) def test_series_replace() -> None: @@ -1955,11 +2053,7 @@ def test_resample() -> None: def test_squeeze() -> None: s1 = pd.Series([1, 2, 3]) - check( - assert_type(s1.squeeze(), "pd.Series[int] | Scalar"), - pd.Series, - np.integer, - ) + check(assert_type(s1.squeeze(), "pd.Series[int] | Scalar"), pd.Series, np.integer) s2 = pd.Series([1]) check(assert_type(s2.squeeze(), "pd.Series[int] | Scalar"), np.integer) @@ -3136,7 +3230,17 @@ def test_interpolate() -> None: pd.Series, np.integer, ) - check(assert_type(s.interpolate(method="linear", inplace=True), None), type(None)) + # TODO: pandas-dev/pandas#63195 return Self after Pandas 3.0 + if PD_LTE_23: + check( + assert_type(s.interpolate(method="linear", inplace=True), None), type(None) + ) + else: + check( + assert_type(s.interpolate(method="linear", inplace=True), None), + pd.Series, + np.integer, + ) def test_groupby_diff() -> None: diff --git a/tests/test_frame.py b/tests/test_frame.py index 8bcf9411e..0c4d7b2c7 100644 --- a/tests/test_frame.py +++ b/tests/test_frame.py @@ -558,7 +558,11 @@ def test_types_drop_duplicates() -> None: def test_types_fillna() -> None: df = pd.DataFrame(data={"col1": [np.nan, np.nan], "col2": [3, np.nan]}) check(assert_type(df.fillna(0), pd.DataFrame), pd.DataFrame) - check(assert_type(df.fillna(0, axis=1, inplace=True), None), type(None)) + # TODO: pandas-dev/pandas#63195 return Self after Pandas 3.0 + if PD_LTE_23: + check(assert_type(df.fillna(0, axis=1, inplace=True), None), type(None)) + else: + check(assert_type(df.fillna(0, axis=1, inplace=True), None), pd.DataFrame) def test_types_sort_index() -> None: @@ -870,14 +874,25 @@ def test_dataframe_clip() -> None: ), pd.DataFrame, ) - check( - assert_type(df.clip(lower=5, upper=None, axis=None, inplace=True), None), - type(None), - ) - check( - assert_type(df.clip(lower=None, upper=15, axis=None, inplace=True), None), - type(None), - ) + # TODO: pandas-dev/pandas#63195 return Self after Pandas 3.0 + if PD_LTE_23: + check( + assert_type(df.clip(lower=5, upper=None, axis=None, inplace=True), None), + type(None), + ) + check( + assert_type(df.clip(lower=None, upper=15, axis=None, inplace=True), None), + type(None), + ) + else: + check( + assert_type(df.clip(lower=5, upper=None, axis=None, inplace=True), None), + pd.DataFrame, + ) + check( + assert_type(df.clip(lower=None, upper=15, axis=None, inplace=True), None), + pd.DataFrame, + ) check( assert_type(df.clip(lower=None, upper=None, axis=0), pd.DataFrame), pd.DataFrame @@ -900,28 +915,65 @@ def test_dataframe_clip() -> None: ), pd.DataFrame, ) - check( - assert_type(df.clip(lower=5, upper=None, axis="index", inplace=True), None), - type(None), - ) - check( - assert_type(df.clip(lower=None, upper=15, axis="index", inplace=True), None), - type(None), - ) - check( - assert_type( - df.clip(lower=pd.Series([1, 2]), upper=None, axis="index", inplace=True), - None, - ), - type(None), - ) - check( - assert_type( - df.clip(lower=None, upper=pd.Series([1, 2]), axis="index", inplace=True), - None, - ), - type(None), - ) + # TODO: pandas-dev/pandas#63195 return Self after Pandas 3.0 + if PD_LTE_23: + check( + assert_type(df.clip(lower=5, upper=None, axis="index", inplace=True), None), + type(None), + ) + check( + assert_type( + df.clip(lower=None, upper=15, axis="index", inplace=True), None + ), + type(None), + ) + check( + assert_type( + df.clip( + lower=pd.Series([1, 2]), upper=None, axis="index", inplace=True + ), + None, + ), + type(None), + ) + check( + assert_type( + df.clip( + lower=None, upper=pd.Series([1, 2]), axis="index", inplace=True + ), + None, + ), + type(None), + ) + else: + check( + assert_type(df.clip(lower=5, upper=None, axis="index", inplace=True), None), + pd.DataFrame, + ) + check( + assert_type( + df.clip(lower=None, upper=15, axis="index", inplace=True), None + ), + pd.DataFrame, + ) + check( + assert_type( + df.clip( + lower=pd.Series([1, 2]), upper=None, axis="index", inplace=True + ), + None, + ), + pd.DataFrame, + ) + check( + assert_type( + df.clip( + lower=None, upper=pd.Series([1, 2]), axis="index", inplace=True + ), + None, + ), + pd.DataFrame, + ) check( assert_type(df.clip(lower=None, upper=None, axis="index"), pd.DataFrame), pd.DataFrame, @@ -952,14 +1004,25 @@ def test_dataframe_clip() -> None: ), pd.DataFrame, ) - check( - assert_type(df.clip(lower=5, upper=None, axis=0, inplace=True), None), - type(None), - ) - check( - assert_type(df.clip(lower=None, upper=15, axis=0, inplace=True), None), - type(None), - ) + # TODO: pandas-dev/pandas#63195 return Self after Pandas 3.0 + if PD_LTE_23: + check( + assert_type(df.clip(lower=5, upper=None, axis=0, inplace=True), None), + type(None), + ) + check( + assert_type(df.clip(lower=None, upper=15, axis=0, inplace=True), None), + type(None), + ) + else: + check( + assert_type(df.clip(lower=5, upper=None, axis=0, inplace=True), None), + pd.DataFrame, + ) + check( + assert_type(df.clip(lower=None, upper=15, axis=0, inplace=True), None), + pd.DataFrame, + ) # without lower check(assert_type(df.clip(upper=None, axis=None), pd.DataFrame), pd.DataFrame) @@ -968,7 +1031,13 @@ def test_dataframe_clip() -> None: assert_type(df.clip(upper=None, axis=None, inplace=True), pd.DataFrame), pd.DataFrame, ) - check(assert_type(df.clip(upper=15, axis=None, inplace=True), None), type(None)) + # TODO: pandas-dev/pandas#63195 return Self after Pandas 3.0 + if PD_LTE_23: + check(assert_type(df.clip(upper=15, axis=None, inplace=True), None), type(None)) + else: + check( + assert_type(df.clip(upper=15, axis=None, inplace=True), None), pd.DataFrame + ) check(assert_type(df.clip(upper=None, axis=0), pd.DataFrame), pd.DataFrame) check(assert_type(df.clip(upper=15, axis=0), pd.DataFrame), pd.DataFrame) @@ -980,11 +1049,28 @@ def test_dataframe_clip() -> None: assert_type(df.clip(upper=None, axis="index", inplace=True), pd.DataFrame), pd.DataFrame, ) - check(assert_type(df.clip(upper=15, axis="index", inplace=True), None), type(None)) - check( - assert_type(df.clip(upper=pd.Series([1, 2]), axis="index", inplace=True), None), - type(None), - ) + # TODO: pandas-dev/pandas#63195 return Self after Pandas 3.0 + if PD_LTE_23: + check( + assert_type(df.clip(upper=15, axis="index", inplace=True), None), type(None) + ) + check( + assert_type( + df.clip(upper=pd.Series([1, 2]), axis="index", inplace=True), None + ), + type(None), + ) + else: + check( + assert_type(df.clip(upper=15, axis="index", inplace=True), None), + pd.DataFrame, + ) + check( + assert_type( + df.clip(upper=pd.Series([1, 2]), axis="index", inplace=True), None + ), + pd.DataFrame, + ) check(assert_type(df.clip(upper=None, axis="index"), pd.DataFrame), pd.DataFrame) check(assert_type(df.clip(upper=15, axis="index"), pd.DataFrame), pd.DataFrame) check( @@ -995,7 +1081,14 @@ def test_dataframe_clip() -> None: assert_type(df.clip(upper=None, axis=0, inplace=True), pd.DataFrame), pd.DataFrame, ) - check(assert_type(df.clip(upper=15, axis=0, inplace=True), None), type(None)) + # TODO: pandas-dev/pandas#63195 return Self after Pandas 3.0 + if PD_LTE_23: + check(assert_type(df.clip(upper=15, axis=0, inplace=True), None), type(None)) + else: + check( + assert_type(df.clip(upper=15, axis=0, inplace=True), None), + pd.DataFrame, + ) # without upper check( @@ -1007,10 +1100,17 @@ def test_dataframe_clip() -> None: assert_type(df.clip(lower=None, axis=None, inplace=True), pd.DataFrame), pd.DataFrame, ) - check( - assert_type(df.clip(lower=5, axis=None, inplace=True), None), - type(None), - ) + # TODO: pandas-dev/pandas#63195 return Self after Pandas 3.0 + if PD_LTE_23: + check( + assert_type(df.clip(lower=5, axis=None, inplace=True), None), + type(None), + ) + else: + check( + assert_type(df.clip(lower=5, axis=None, inplace=True), None), + pd.DataFrame, + ) check( assert_type(df.clip(lower=None, axis=None, inplace=True), pd.DataFrame), pd.DataFrame, @@ -1026,14 +1126,32 @@ def test_dataframe_clip() -> None: assert_type(df.clip(lower=None, axis="index", inplace=True), pd.DataFrame), pd.DataFrame, ) - check( - assert_type(df.clip(lower=5, axis="index", inplace=True), None), - type(None), - ) - check( - assert_type(df.clip(lower=pd.Series([1, 2]), axis="index", inplace=True), None), - type(None), - ) + # TODO: pandas-dev/pandas#63195 return Self after Pandas 3.0 + if PD_LTE_23: + check( + assert_type(df.clip(lower=5, axis="index", inplace=True), None), + type(None), + ) + else: + check( + assert_type(df.clip(lower=5, axis="index", inplace=True), None), + pd.DataFrame, + ) + # TODO: pandas-dev/pandas#63195 return Self after Pandas 3.0 + if PD_LTE_23: + check( + assert_type( + df.clip(lower=pd.Series([1, 2]), axis="index", inplace=True), None + ), + type(None), + ) + else: + check( + assert_type( + df.clip(lower=pd.Series([1, 2]), axis="index", inplace=True), None + ), + pd.DataFrame, + ) check( assert_type(df.clip(lower=None, axis="index"), pd.DataFrame), pd.DataFrame, @@ -1050,7 +1168,14 @@ def test_dataframe_clip() -> None: assert_type(df.clip(lower=None, axis=0, inplace=True), pd.DataFrame), pd.DataFrame, ) - check(assert_type(df.clip(lower=5, axis=0, inplace=True), None), type(None)) + # TODO: pandas-dev/pandas#63195 return Self after Pandas 3.0 + if PD_LTE_23: + check(assert_type(df.clip(lower=5, axis=0, inplace=True), None), type(None)) + else: + check( + assert_type(df.clip(lower=5, axis=0, inplace=True), None), + pd.DataFrame, + ) def test_types_abs() -> None: @@ -2998,8 +3123,18 @@ def test_types_ffill() -> None: assert_type(df.ffill(inplace=False, limit_area="inside"), pd.DataFrame), pd.DataFrame, ) - check(assert_type(df.ffill(inplace=True), None), type(None)) - check(assert_type(df.ffill(inplace=True, limit_area="outside"), None), type(None)) + # TODO: pandas-dev/pandas#63195 return Self after Pandas 3.0 + if PD_LTE_23: + check(assert_type(df.ffill(inplace=True), None), type(None)) + check( + assert_type(df.ffill(inplace=True, limit_area="outside"), None), type(None) + ) + else: + check(assert_type(df.ffill(inplace=True), None), pd.DataFrame) + check( + assert_type(df.ffill(inplace=True, limit_area="outside"), None), + pd.DataFrame, + ) def test_types_bfill() -> None: @@ -3011,8 +3146,18 @@ def test_types_bfill() -> None: assert_type(df.bfill(inplace=False, limit_area="inside"), pd.DataFrame), pd.DataFrame, ) - check(assert_type(df.bfill(inplace=True), None), type(None)) - check(assert_type(df.bfill(inplace=True, limit_area="outside"), None), type(None)) + # TODO: pandas-dev/pandas#63195 return Self after Pandas 3.0 + if PD_LTE_23: + check(assert_type(df.bfill(inplace=True), None), type(None)) + check( + assert_type(df.bfill(inplace=True, limit_area="outside"), None), type(None) + ) + else: + check(assert_type(df.bfill(inplace=True), None), pd.DataFrame) + check( + assert_type(df.bfill(inplace=True, limit_area="outside"), None), + pd.DataFrame, + ) def test_types_replace() -> None: @@ -3020,7 +3165,11 @@ def test_types_replace() -> None: df = pd.DataFrame([[1, 2, 3]]) check(assert_type(df.replace(1, 2), pd.DataFrame), pd.DataFrame) check(assert_type(df.replace(1, 2, inplace=False), pd.DataFrame), pd.DataFrame) - check(assert_type(df.replace(1, 2, inplace=True), None), type(None)) + # TODO: pandas-dev/pandas#63195 return Self after Pandas 3.0 + if PD_LTE_23: + check(assert_type(df.replace(1, 2, inplace=True), None), type(None)) + else: + check(assert_type(df.replace(1, 2, inplace=True), None), pd.DataFrame) def test_dataframe_replace() -> None: @@ -3923,21 +4072,38 @@ def test_loc_slice() -> None: check(assert_type(df.loc[mask, mask_col], pd.DataFrame), pd.DataFrame) -def test_where() -> None: - df = pd.DataFrame({"a": [1, 2, 3], "b": [4, 5, 6]}) +def where_cond1(x: int) -> bool: + return x % 2 == 0 - def cond1(x: int) -> bool: - return x % 2 == 0 - check(assert_type(df.where(cond1), pd.DataFrame), pd.DataFrame) +def where_cond2(x: pd.DataFrame) -> pd.DataFrame: + return x > 1 + - def cond2(x: pd.DataFrame) -> pd.DataFrame: - return x > 1 +where_cond3 = pd.DataFrame({"a": [True, True, False], "b": [False, False, False]}) + + +@pytest.mark.parametrize("cond", [where_cond1, where_cond2, where_cond3]) +def test_where( + cond: Callable[[int], bool] | Callable[[pd.DataFrame], pd.DataFrame] | pd.DataFrame, +) -> None: + df = pd.DataFrame({"a": [1, 2, 3], "b": [4, 5, 6]}) - check(assert_type(df.where(cond2), pd.DataFrame), pd.DataFrame) + check(df.where(cond), pd.DataFrame) + # TODO: pandas-dev/pandas#63195 return Self after Pandas 3.0 + if PD_LTE_23: + check(df.where(cond, inplace=True), type(None)) + else: + check(df.where(cond, inplace=True), pd.DataFrame) - cond3 = pd.DataFrame({"a": [True, True, False], "b": [False, False, False]}) - check(assert_type(df.where(cond3), pd.DataFrame), pd.DataFrame) + if TYPE_CHECKING: + assert_type(df.where(where_cond1), pd.DataFrame) + assert_type(df.where(where_cond2), pd.DataFrame) + assert_type(df.where(where_cond3), pd.DataFrame) + # TODO: pandas-dev/pandas#63195 return Self after Pandas 3.0 + assert_type(df.where(where_cond1, inplace=True), None) + assert_type(df.where(where_cond2, inplace=True), None) + assert_type(df.where(where_cond3, inplace=True), None) def test_mask() -> None: @@ -3947,6 +4113,11 @@ def cond1(x: int) -> bool: return x % 2 == 0 check(assert_type(df.mask(cond1), pd.DataFrame), pd.DataFrame) + # TODO: pandas-dev/pandas#63195 return Self after Pandas 3.0 + if PD_LTE_23: + check(assert_type(df.mask(cond1, inplace=True), None), type(None)) + else: + check(assert_type(df.mask(cond1, inplace=True), None), pd.DataFrame) def test_setitem_loc() -> None: @@ -4483,7 +4654,16 @@ def test_interpolate() -> None: assert_type(df.interpolate(method="linear", inplace=False), pd.DataFrame), pd.DataFrame, ) - check(assert_type(df.interpolate(method="linear", inplace=True), None), type(None)) + # TODO: pandas-dev/pandas#63195 return Self after Pandas 3.0 + if PD_LTE_23: + check( + assert_type(df.interpolate(method="linear", inplace=True), None), type(None) + ) + else: + check( + assert_type(df.interpolate(method="linear", inplace=True), None), + pd.DataFrame, + ) def test_getitem_generator() -> None: From 1e95626538eacd0df1707e643ced2346a071d05e Mon Sep 17 00:00:00 2001 From: cmp0xff Date: Mon, 1 Dec 2025 18:37:45 +0100 Subject: [PATCH 2/6] one more case --- tests/series/test_series.py | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/tests/series/test_series.py b/tests/series/test_series.py index b958c69af..e7f859114 100644 --- a/tests/series/test_series.py +++ b/tests/series/test_series.py @@ -784,7 +784,11 @@ def test_types_clip() -> None: pd.Series, np.integer, ) - check(assert_type(s.clip(lower=0, inplace=True), None), type(None)) + # TODO: pandas-dev/pandas#63195 return Self after Pandas 3.0 + if PD_LTE_23: + check(assert_type(s.clip(lower=0, inplace=True), None), type(None)) + else: + check(assert_type(s.clip(lower=0, inplace=True), None), pd.Series, np.integer) check( assert_type(s.clip(lower=None, inplace=True), "pd.Series[int]"), pd.Series, From 8ed2913bdbf5baa99a9562a66e937a63bca6f3aa Mon Sep 17 00:00:00 2001 From: cmp0xff Date: Tue, 2 Dec 2025 10:40:01 +0100 Subject: [PATCH 3/6] fix: pandas-dev/pandas#62552 --- tests/indexes/arithmetic/timedeltaindex/test_floordiv.py | 8 +++++++- tests/series/arithmetic/timedelta/test_floordiv.py | 8 +++++++- 2 files changed, 14 insertions(+), 2 deletions(-) diff --git a/tests/indexes/arithmetic/timedeltaindex/test_floordiv.py b/tests/indexes/arithmetic/timedeltaindex/test_floordiv.py index fd0b570ee..9b395f0a8 100644 --- a/tests/indexes/arithmetic/timedeltaindex/test_floordiv.py +++ b/tests/indexes/arithmetic/timedeltaindex/test_floordiv.py @@ -14,6 +14,7 @@ ) from tests import ( + PD_LTE_23, TYPE_CHECKING_INVALID_USAGE, check, ) @@ -62,7 +63,12 @@ def test_floordiv_py_sequence(left: pd.TimedeltaIndex) -> None: if TYPE_CHECKING_INVALID_USAGE: _03 = left // c # type: ignore[operator] # pyright: ignore[reportOperatorIssue] _04 = left // s # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - check(assert_type(left // d, "pd.Index[int]"), pd.Index, int) + # TODO: pandas-dev/pandas#62552 switch to np.integer after Pandas 3.0 + check( + assert_type(left // d, "pd.Index[int]"), + pd.Index, + int if PD_LTE_23 else np.integer, + ) if TYPE_CHECKING_INVALID_USAGE: _10 = b // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] diff --git a/tests/series/arithmetic/timedelta/test_floordiv.py b/tests/series/arithmetic/timedelta/test_floordiv.py index dcea23361..d75203cde 100644 --- a/tests/series/arithmetic/timedelta/test_floordiv.py +++ b/tests/series/arithmetic/timedelta/test_floordiv.py @@ -14,6 +14,7 @@ ) from tests import ( + PD_LTE_23, TYPE_CHECKING_INVALID_USAGE, check, ) @@ -87,7 +88,12 @@ def test_floordiv_py_sequence(left: "pd.Series[pd.Timedelta]") -> None: if TYPE_CHECKING_INVALID_USAGE: _03 = left // c # type: ignore[operator] # pyright: ignore[reportOperatorIssue] _04 = left // s # type: ignore[operator] # pyright: ignore[reportOperatorIssue] - check(assert_type(left // d, "pd.Series[int]"), pd.Series, int) + # TODO: pandas-dev/pandas#62552 switch to np.integer after Pandas 3.0 + check( + assert_type(left // d, "pd.Series[int]"), + pd.Series, + int if PD_LTE_23 else np.integer, + ) if TYPE_CHECKING_INVALID_USAGE: _10 = b // left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] From 4c40fb7a9514aebd7763b824512b3e5313c321a5 Mon Sep 17 00:00:00 2001 From: cmp0xff Date: Tue, 2 Dec 2025 11:09:16 +0100 Subject: [PATCH 4/6] fix: __truediv__ --- pandas-stubs/core/base.pyi | 5 +++-- pandas-stubs/core/series.pyi | 4 ++-- tests/indexes/arithmetic/bool/test_truediv.py | 6 ++++-- tests/series/arithmetic/bool/test_truediv.py | 6 ++++-- 4 files changed, 13 insertions(+), 8 deletions(-) diff --git a/pandas-stubs/core/base.pyi b/pandas-stubs/core/base.pyi index ec9a22f39..13b0b311b 100644 --- a/pandas-stubs/core/base.pyi +++ b/pandas-stubs/core/base.pyi @@ -22,6 +22,7 @@ import numpy.typing as npt from pandas.core.arraylike import OpsMixin from pandas.core.arrays import ExtensionArray from pandas.core.arrays.categorical import Categorical +from pandas.core.arrays.floating import FloatingArray from pandas.core.arrays.integer import IntegerArray from pandas.core.arrays.timedeltas import TimedeltaArray from pandas.core.indexes.accessors import ArrayDescriptor @@ -192,7 +193,7 @@ ScalarArrayIndexJustFloat: TypeAlias = ( | np.floating | Sequence[Just[float] | np.floating] | np_ndarray_float - # | FloatingArray # TODO: after pandas-dev/pandas-stubs#1469 + | FloatingArray | Index[float] ) ScalarArrayIndexSeriesJustFloat: TypeAlias = ScalarArrayIndexJustFloat | Series[float] @@ -210,7 +211,7 @@ ScalarArrayIndexSeriesJustComplex: TypeAlias = ( ScalarArrayIndexIntNoBool: TypeAlias = ( Just[int] | np.integer - | Sequence[int | np.integer] + | Sequence[Just[int] | np.integer] | np_ndarray_anyint | IntegerArray | Index[int] diff --git a/pandas-stubs/core/series.pyi b/pandas-stubs/core/series.pyi index 151b8e943..569e5c2bc 100644 --- a/pandas-stubs/core/series.pyi +++ b/pandas-stubs/core/series.pyi @@ -3776,7 +3776,7 @@ class Series(IndexOpsMixin[S1], ElementOpsMixin[S1], NDFrame): @overload def truediv( self: Series[bool] | Series[int], - other: ScalarArrayIndexSeriesIntNoBool, + other: ScalarArrayIndexSeriesIntNoBool | Sequence[bool | np.bool], level: Level | None = None, fill_value: float | None = None, axis: AxisIndex = 0, @@ -3969,7 +3969,7 @@ class Series(IndexOpsMixin[S1], ElementOpsMixin[S1], NDFrame): @overload def rtruediv( self: Series[bool] | Series[int], - other: ScalarArrayIndexSeriesIntNoBool, + other: ScalarArrayIndexSeriesIntNoBool | Sequence[bool | np.bool], level: Level | None = None, fill_value: float | None = None, axis: AxisIndex = 0, diff --git a/tests/indexes/arithmetic/bool/test_truediv.py b/tests/indexes/arithmetic/bool/test_truediv.py index 00d2571fa..0d8c9bb29 100644 --- a/tests/indexes/arithmetic/bool/test_truediv.py +++ b/tests/indexes/arithmetic/bool/test_truediv.py @@ -43,12 +43,14 @@ def test_truediv_py_sequence(left: "pd.Index[bool]") -> None: """Test pd.Index[bool] / Python native sequences""" b, i, f, c = [True, False, True], [2, 3, 5], [1.0, 2.0, 3.0], [1j, 1j, 4j] - check(assert_type(left / b, "pd.Index[float]"), pd.Index, np.floating) + if TYPE_CHECKING_INVALID_USAGE: + _00 = left / b # type: ignore[operator] # pyright: ignore[reportOperatorIssue] check(assert_type(left / i, "pd.Index[float]"), pd.Index, np.floating) check(assert_type(left / f, "pd.Index[float]"), pd.Index, np.floating) check(assert_type(left / c, "pd.Index[complex]"), pd.Index, np.complexfloating) - check(assert_type(b / left, "pd.Index[float]"), pd.Index, np.floating) + if TYPE_CHECKING_INVALID_USAGE: + _10 = b / left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] check(assert_type(i / left, "pd.Index[float]"), pd.Index, np.floating) check(assert_type(f / left, "pd.Index[float]"), pd.Index, np.floating) check(assert_type(c / left, "pd.Index[complex]"), pd.Index, np.complexfloating) diff --git a/tests/series/arithmetic/bool/test_truediv.py b/tests/series/arithmetic/bool/test_truediv.py index d366f950d..de9a72b26 100644 --- a/tests/series/arithmetic/bool/test_truediv.py +++ b/tests/series/arithmetic/bool/test_truediv.py @@ -81,12 +81,14 @@ def test_truediv_py_sequence(left: "pd.Series[bool]") -> None: """Test pd.Series[bool] / Python native sequences""" b, i, f, c = [True, False, True], [2, 3, 5], [1.0, 2.0, 3.0], [1j, 1j, 4j] - check(assert_type(left / b, "pd.Series[float]"), pd.Series, np.floating) + if TYPE_CHECKING_INVALID_USAGE: + _00 = left / b # type: ignore[operator] # pyright: ignore[reportOperatorIssue] check(assert_type(left / i, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left / f, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left / c, "pd.Series[complex]"), pd.Series, np.complexfloating) - check(assert_type(b / left, "pd.Series[float]"), pd.Series, np.floating) + if TYPE_CHECKING_INVALID_USAGE: + _10 = b / left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] check(assert_type(i / left, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(f / left, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(c / left, "pd.Series[complex]"), pd.Series, np.complexfloating) From fb2fc30ec2b9926b0663823d77f2aed0fa7bfe2f Mon Sep 17 00:00:00 2001 From: cmp0xff Date: Tue, 2 Dec 2025 13:14:57 +0100 Subject: [PATCH 5/6] reduce redundancy --- pandas-stubs/core/base.pyi | 10 ---------- pandas-stubs/core/indexes/base.pyi | 6 +++--- pandas-stubs/core/series.pyi | 9 ++++----- 3 files changed, 7 insertions(+), 18 deletions(-) diff --git a/pandas-stubs/core/base.pyi b/pandas-stubs/core/base.pyi index 13b0b311b..e4b820d79 100644 --- a/pandas-stubs/core/base.pyi +++ b/pandas-stubs/core/base.pyi @@ -208,16 +208,6 @@ ScalarArrayIndexSeriesJustComplex: TypeAlias = ( ScalarArrayIndexJustComplex | Series[complex] ) -ScalarArrayIndexIntNoBool: TypeAlias = ( - Just[int] - | np.integer - | Sequence[Just[int] | np.integer] - | np_ndarray_anyint - | IntegerArray - | Index[int] -) -ScalarArrayIndexSeriesIntNoBool: TypeAlias = ScalarArrayIndexIntNoBool | Series[int] - NumpyRealScalar: TypeAlias = np.bool | np.integer | np.floating IndexReal: TypeAlias = Index[bool] | Index[int] | Index[float] ScalarArrayIndexReal: TypeAlias = ( diff --git a/pandas-stubs/core/indexes/base.pyi b/pandas-stubs/core/indexes/base.pyi index 09bb37a8a..62863bf7c 100644 --- a/pandas-stubs/core/indexes/base.pyi +++ b/pandas-stubs/core/indexes/base.pyi @@ -39,9 +39,9 @@ from pandas.core.base import ( IndexOpsMixin, IndexReal, ScalarArrayIndexComplex, - ScalarArrayIndexIntNoBool, ScalarArrayIndexJustComplex, ScalarArrayIndexJustFloat, + ScalarArrayIndexJustInt, ScalarArrayIndexReal, ScalarArrayIndexTimedelta, Supports_ProtoAdd, @@ -1012,7 +1012,7 @@ class Index(IndexOpsMixin[S1], ElementOpsMixin[S1]): ) -> Index[float]: ... @overload def __truediv__( - self: Index[bool] | Index[int], other: ScalarArrayIndexIntNoBool + self: Index[bool] | Index[int], other: ScalarArrayIndexJustInt ) -> Index[float]: ... @overload def __truediv__( @@ -1063,7 +1063,7 @@ class Index(IndexOpsMixin[S1], ElementOpsMixin[S1]): ) -> Index[float]: ... @overload def __rtruediv__( - self: Index[bool] | Index[int], other: ScalarArrayIndexIntNoBool + self: Index[bool] | Index[int], other: ScalarArrayIndexJustInt ) -> Index[float]: ... @overload def __rtruediv__( # type: ignore[misc] diff --git a/pandas-stubs/core/series.pyi b/pandas-stubs/core/series.pyi index 983785666..c732e3826 100644 --- a/pandas-stubs/core/series.pyi +++ b/pandas-stubs/core/series.pyi @@ -77,7 +77,6 @@ from pandas.core.base import ( IndexOpsMixin, NumListLike, ScalarArrayIndexSeriesComplex, - ScalarArrayIndexSeriesIntNoBool, ScalarArrayIndexSeriesJustComplex, ScalarArrayIndexSeriesJustFloat, ScalarArrayIndexSeriesJustInt, @@ -3684,7 +3683,7 @@ class Series(IndexOpsMixin[S1], ElementOpsMixin[S1], NDFrame): ) -> Series[float]: ... @overload def __truediv__( - self: Series[bool] | Series[int], other: ScalarArrayIndexSeriesIntNoBool + self: Series[bool] | Series[int], other: ScalarArrayIndexSeriesJustInt ) -> Series[float]: ... @overload def __truediv__( @@ -3776,7 +3775,7 @@ class Series(IndexOpsMixin[S1], ElementOpsMixin[S1], NDFrame): @overload def truediv( self: Series[bool] | Series[int], - other: ScalarArrayIndexSeriesIntNoBool | Sequence[bool | np.bool], + other: ScalarArrayIndexSeriesJustInt | Sequence[bool | np.bool], level: Level | None = None, fill_value: float | None = None, axis: AxisIndex = 0, @@ -3886,7 +3885,7 @@ class Series(IndexOpsMixin[S1], ElementOpsMixin[S1], NDFrame): ) -> Series[float]: ... @overload def __rtruediv__( - self: Series[bool] | Series[int], other: ScalarArrayIndexSeriesIntNoBool + self: Series[bool] | Series[int], other: ScalarArrayIndexSeriesJustInt ) -> Series[float]: ... @overload def __rtruediv__( # type: ignore[misc] @@ -3969,7 +3968,7 @@ class Series(IndexOpsMixin[S1], ElementOpsMixin[S1], NDFrame): @overload def rtruediv( self: Series[bool] | Series[int], - other: ScalarArrayIndexSeriesIntNoBool | Sequence[bool | np.bool], + other: ScalarArrayIndexSeriesJustInt | Sequence[bool | np.bool], level: Level | None = None, fill_value: float | None = None, axis: AxisIndex = 0, From a96c7dc214fd9542d48f71d5f7514f019ac9219f Mon Sep 17 00:00:00 2001 From: cmp0xff Date: Tue, 2 Dec 2025 13:35:50 +0100 Subject: [PATCH 6/6] python/mypy#20061 --- tests/indexes/arithmetic/bool/test_truediv.py | 6 ++++-- tests/series/arithmetic/bool/test_truediv.py | 6 ++++-- 2 files changed, 8 insertions(+), 4 deletions(-) diff --git a/tests/indexes/arithmetic/bool/test_truediv.py b/tests/indexes/arithmetic/bool/test_truediv.py index 0d8c9bb29..7bb82ecbd 100644 --- a/tests/indexes/arithmetic/bool/test_truediv.py +++ b/tests/indexes/arithmetic/bool/test_truediv.py @@ -44,13 +44,15 @@ def test_truediv_py_sequence(left: "pd.Index[bool]") -> None: b, i, f, c = [True, False, True], [2, 3, 5], [1.0, 2.0, 3.0], [1j, 1j, 4j] if TYPE_CHECKING_INVALID_USAGE: - _00 = left / b # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + # TODO: python/mypy#20061 + _00 = left / b # pyright: ignore[reportOperatorIssue] check(assert_type(left / i, "pd.Index[float]"), pd.Index, np.floating) check(assert_type(left / f, "pd.Index[float]"), pd.Index, np.floating) check(assert_type(left / c, "pd.Index[complex]"), pd.Index, np.complexfloating) if TYPE_CHECKING_INVALID_USAGE: - _10 = b / left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + # TODO: python/mypy#20061 + _10 = b / left # pyright: ignore[reportOperatorIssue] check(assert_type(i / left, "pd.Index[float]"), pd.Index, np.floating) check(assert_type(f / left, "pd.Index[float]"), pd.Index, np.floating) check(assert_type(c / left, "pd.Index[complex]"), pd.Index, np.complexfloating) diff --git a/tests/series/arithmetic/bool/test_truediv.py b/tests/series/arithmetic/bool/test_truediv.py index de9a72b26..900cf7e1d 100644 --- a/tests/series/arithmetic/bool/test_truediv.py +++ b/tests/series/arithmetic/bool/test_truediv.py @@ -82,13 +82,15 @@ def test_truediv_py_sequence(left: "pd.Series[bool]") -> None: b, i, f, c = [True, False, True], [2, 3, 5], [1.0, 2.0, 3.0], [1j, 1j, 4j] if TYPE_CHECKING_INVALID_USAGE: - _00 = left / b # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + # TODO: python/mypy#20061 + _00 = left / b # pyright: ignore[reportOperatorIssue] check(assert_type(left / i, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left / f, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(left / c, "pd.Series[complex]"), pd.Series, np.complexfloating) if TYPE_CHECKING_INVALID_USAGE: - _10 = b / left # type: ignore[operator] # pyright: ignore[reportOperatorIssue] + # TODO: python/mypy#20061 + _10 = b / left # pyright: ignore[reportOperatorIssue] check(assert_type(i / left, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(f / left, "pd.Series[float]"), pd.Series, np.floating) check(assert_type(c / left, "pd.Series[complex]"), pd.Series, np.complexfloating)