From b5ebe12f760b837fa1d28c1335e66e95a12d8b54 Mon Sep 17 00:00:00 2001
From: Laurent Mutricy <laurent.mutricy@ekium.eu>
Date: Wed, 3 Apr 2024 18:56:13 +0200
Subject: [PATCH 01/12] Adding tests for #821

---
 tests/test_series.py | 46 ++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 46 insertions(+)

diff --git a/tests/test_series.py b/tests/test_series.py
index 8bbe0f8d7..24ef8d0bf 100644
--- a/tests/test_series.py
+++ b/tests/test_series.py
@@ -32,6 +32,7 @@
 from typing_extensions import (
     Self,
     TypeAlias,
+    assert_never,
     assert_type,
 )
 import xarray as xr
@@ -3069,3 +3070,48 @@ def first_arg_not_series(argument_1: int, ser: pd.Series) -> pd.Series:
             ),
             1,
         )
+
+
+def test_diff() -> None:
+    s = pd.Series([1, 1, 2, 3, 5, 8])
+    # int -> float
+    check(assert_type(s.diff(), "pd.Series[float]"), pd.Series, float)
+    # unint -> float
+    check(assert_type(s.astype(np.uint32).diff(), "pd.Series[float]"), pd.Series, float)
+    # float -> float
+    check(assert_type(s.astype(float).diff(), "pd.Series[float]"), pd.Series, float)
+    # timestamp -> timedelta
+    times = pd.Series([pd.Timestamp(0), pd.Timestamp(1)])
+    check(assert_type(times.diff(), "TimedeltaSeries"), pd.Series, pd.Timedelta)
+    # timedelta -> timedelta64
+    check(
+        assert_type(
+            pd.Series([pd.Timedelta(0), pd.Timedelta(1)]).diff(), "TimedeltaSeries"
+        ),
+        pd.Series,
+        pd.Timedelta,
+    )
+    # period -> object
+    check(
+        assert_type(
+            pd.Series(
+                [pd.Period("2012", freq="D"), pd.Period("2012-1-1", freq="D")]
+            ).diff(),
+            "pd.Series[object]",
+        ),
+        pd.Series,
+        object,
+    )
+    # bool -> object
+    check(
+        assert_type(
+            pd.Series([True, True, False, False, True]).diff(), "pd.Series[object]"
+        ),
+        pd.Series,
+        object,
+    )
+    # object -> object
+    check(assert_type(s.astype(object).diff(), "pd.Series[object]"), pd.Series, object)
+    # interval -> TypeError: IntervalArray has no 'diff' method. Convert to a suitable dtype prior to calling 'diff'.
+    if TYPE_CHECKING_INVALID_USAGE:
+        assert_never(pd.Series([pd.Interval(0, 2), pd.Interval(1, 4)]).diff())

From c3bcc1497b233ae423688d4d7ef84ea39aafb7a3 Mon Sep 17 00:00:00 2001
From: Laurent Mutricy <laurent.mutricy@ekium.eu>
Date: Sat, 6 Apr 2024 22:03:15 +0200
Subject: [PATCH 02/12] finish to add tests from  pd._types.S1 definition

---
 tests/test_series.py | 26 +++++++++++++++++++++++++-
 1 file changed, 25 insertions(+), 1 deletion(-)

diff --git a/tests/test_series.py b/tests/test_series.py
index 24ef8d0bf..bf559531e 100644
--- a/tests/test_series.py
+++ b/tests/test_series.py
@@ -3080,6 +3080,17 @@ def test_diff() -> None:
     check(assert_type(s.astype(np.uint32).diff(), "pd.Series[float]"), pd.Series, float)
     # float -> float
     check(assert_type(s.astype(float).diff(), "pd.Series[float]"), pd.Series, float)
+    # datetime.date -> timeDelta
+    check(
+        assert_type(
+            pd.Series(
+                [datetime.datetime.now().date(), datetime.datetime.now().date()]
+            ).diff(),
+            "TimedeltaSeries",
+        ),
+        pd.Series,
+        pd.Timedelta,
+    )
     # timestamp -> timedelta
     times = pd.Series([pd.Timestamp(0), pd.Timestamp(1)])
     check(assert_type(times.diff(), "TimedeltaSeries"), pd.Series, pd.Timedelta)
@@ -3112,6 +3123,19 @@ def test_diff() -> None:
     )
     # object -> object
     check(assert_type(s.astype(object).diff(), "pd.Series[object]"), pd.Series, object)
-    # interval -> TypeError: IntervalArray has no 'diff' method. Convert to a suitable dtype prior to calling 'diff'.
+    # Baseoffset (object) -> object
+    # from pandas.tseries.frequencies import to_offset
+    # pd.Series([to_offset("5min"), to_offset("1D1h")]).diff()
+    # complex -> complex
+    check(
+        assert_type(s.astype(complex).diff(), "pd.Series[complex]"), pd.Series, complex
+    )
     if TYPE_CHECKING_INVALID_USAGE:
+        # interval -> TypeError: IntervalArray has no 'diff' method. Convert to a suitable dtype prior to calling 'diff'.
         assert_never(pd.Series([pd.Interval(0, 2), pd.Interval(1, 4)]).diff())
+        # bytes -> numpy.core._exceptions._UFuncNoLoopError: ufunc 'subtract' did not contain a loop with signature matching types (dtype('S21'), dtype('S21')) -> None
+        assert_never(s.astype(bytes).diff())
+        # dtype -> TypeError: unsupported operand type(s) for -: 'type' and 'type'
+        assert_never(pd.Series([str, int, bool]).diff())
+        # datetime.time -> TypeError: unsupported operand type(s) for -: 'datetime.time' and 'datetime.time'
+        # pd.Series([datetime.datetime.now().time(), datetime.datetime.now().time()]).diff()

From 9e78fe5c459a9a7cbc9a44ad9c982c0fa936feb9 Mon Sep 17 00:00:00 2001
From: Laurent Mutricy <laurent.mutricy@ekium.eu>
Date: Sat, 6 Apr 2024 23:18:22 +0200
Subject: [PATCH 03/12] start fixing stubs

---
 pandas-stubs/core/series.pyi | 12 ++++++++----
 tests/test_series.py         |  2 +-
 2 files changed, 9 insertions(+), 5 deletions(-)

diff --git a/pandas-stubs/core/series.pyi b/pandas-stubs/core/series.pyi
index d38b54dae..2a7e3c817 100644
--- a/pandas-stubs/core/series.pyi
+++ b/pandas-stubs/core/series.pyi
@@ -234,10 +234,11 @@ class Series(IndexOpsMixin[S1], NDFrame):
         cls,
         data: (
             DatetimeIndex
-            | Sequence[np.datetime64 | datetime]
-            | dict[HashableT1, np.datetime64 | datetime]
+            | Sequence[np.datetime64 | datetime | date]
+            | dict[HashableT1, np.datetime64 | datetime | date]
             | np.datetime64
             | datetime
+            | date
         ),
         index: Axes | None = ...,
         *,
@@ -258,7 +259,7 @@ class Series(IndexOpsMixin[S1], NDFrame):
     @overload
     def __new__(  # type: ignore[overload-overlap]
         cls,
-        data: PeriodIndex,
+        data: PeriodIndex | Sequence[Period],
         index: Axes | None = ...,
         *,
         dtype: PeriodDtype = ...,
@@ -747,7 +748,7 @@ class Series(IndexOpsMixin[S1], NDFrame):
     def cov(
         self, other: Series[S1], min_periods: int | None = ..., ddof: int = ...
     ) -> float: ...
-    def diff(self, periods: int = ...) -> Series[S1]: ...
+    def diff(self, periods: int = ...) -> Series[float]: ...
     def autocorr(self, lag: int = ...) -> float: ...
     @overload
     def dot(self, other: Series[S1]) -> Scalar: ...
@@ -2072,6 +2073,7 @@ class TimestampSeries(Series[Timestamp]):
         numeric_only: _bool = ...,
         **kwargs,
     ) -> Timedelta: ...
+    def diff(self, periods: int = ...) -> TimedeltaSeries: ...  # type: ignore[override] # pyright: ignore[reportIncompatibleMethodOverride]
 
 class TimedeltaSeries(Series[Timedelta]):
     # ignores needed because of mypy
@@ -2168,11 +2170,13 @@ class TimedeltaSeries(Series[Timedelta]):
         numeric_only: _bool = ...,
         **kwargs,
     ) -> Timedelta: ...
+    def diff(self, periods: int = ...) -> TimedeltaSeries: ...  # type: ignore[override] # pyright: ignore[reportIncompatibleMethodOverride]
 
 class PeriodSeries(Series[Period]):
     @property
     def dt(self) -> PeriodProperties: ...  # type: ignore[override] # pyright: ignore[reportIncompatibleMethodOverride]
     def __sub__(self, other: PeriodSeries) -> OffsetSeries: ...  # type: ignore[override] # pyright: ignore[reportIncompatibleMethodOverride]
+    def diff(self, periods: int = ...) -> Series[type[object]]: ...  # type: ignore[override] # pyright: ignore[reportIncompatibleMethodOverride]
 
 class OffsetSeries(Series[BaseOffset]):
     @overload  # type: ignore[override]
diff --git a/tests/test_series.py b/tests/test_series.py
index bf559531e..0ed508388 100644
--- a/tests/test_series.py
+++ b/tests/test_series.py
@@ -3108,7 +3108,7 @@ def test_diff() -> None:
             pd.Series(
                 [pd.Period("2012", freq="D"), pd.Period("2012-1-1", freq="D")]
             ).diff(),
-            "pd.Series[object]",
+            "pd.Series[type[object]]",
         ),
         pd.Series,
         object,

From fde2f9171d6cba67de919f218e27bc088fd0550f Mon Sep 17 00:00:00 2001
From: Laurent Mutricy <laurent.mutricy@ekium.eu>
Date: Sat, 6 Apr 2024 23:23:29 +0200
Subject: [PATCH 04/12] date le lt ge gt fixing

---
 pandas-stubs/core/series.pyi | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/pandas-stubs/core/series.pyi b/pandas-stubs/core/series.pyi
index 2a7e3c817..3ba832694 100644
--- a/pandas-stubs/core/series.pyi
+++ b/pandas-stubs/core/series.pyi
@@ -1509,16 +1509,16 @@ class Series(IndexOpsMixin[S1], NDFrame):
     def __eq__(self, other: object) -> Series[_bool]: ...  # type: ignore[override] # pyright: ignore[reportIncompatibleMethodOverride]
     def __floordiv__(self, other: num | _ListLike | Series[S1]) -> Series[int]: ...
     def __ge__(  # type: ignore[override] # pyright: ignore[reportIncompatibleMethodOverride]
-        self, other: S1 | _ListLike | Series[S1] | datetime | timedelta
+        self, other: S1 | _ListLike | Series[S1] | datetime | timedelta | date
     ) -> Series[_bool]: ...
     def __gt__(  # type: ignore[override] # pyright: ignore[reportIncompatibleMethodOverride]
-        self, other: S1 | _ListLike | Series[S1] | datetime | timedelta
+        self, other: S1 | _ListLike | Series[S1] | datetime | timedelta | date
     ) -> Series[_bool]: ...
     def __le__(  # type: ignore[override] # pyright: ignore[reportIncompatibleMethodOverride]
-        self, other: S1 | _ListLike | Series[S1] | datetime | timedelta
+        self, other: S1 | _ListLike | Series[S1] | datetime | timedelta | date
     ) -> Series[_bool]: ...
     def __lt__(  # type: ignore[override] # pyright: ignore[reportIncompatibleMethodOverride]
-        self, other: S1 | _ListLike | Series[S1] | datetime | timedelta
+        self, other: S1 | _ListLike | Series[S1] | datetime | timedelta | date
     ) -> Series[_bool]: ...
     @overload
     def __mul__(

From f46e4645b6c2d90086b6eb72a92f868f96e4e924 Mon Sep 17 00:00:00 2001
From: Laurent Mutricy <laurent.mutricy@ekium.eu>
Date: Tue, 9 Apr 2024 17:09:41 +0200
Subject: [PATCH 05/12] new diff overloads

---
 pandas-stubs/core/series.pyi |  6 ++++++
 tests/test_series.py         | 10 ++++++++--
 2 files changed, 14 insertions(+), 2 deletions(-)

diff --git a/pandas-stubs/core/series.pyi b/pandas-stubs/core/series.pyi
index 3ba832694..f4e36bc21 100644
--- a/pandas-stubs/core/series.pyi
+++ b/pandas-stubs/core/series.pyi
@@ -748,6 +748,11 @@ class Series(IndexOpsMixin[S1], NDFrame):
     def cov(
         self, other: Series[S1], min_periods: int | None = ..., ddof: int = ...
     ) -> float: ...
+    @overload
+    def diff(self: Series[_bool], periods: int = ...) -> Series[type[object]]: ...  # type: ignore[overload-overlap]
+    @overload
+    def diff(self: Series[complex], periods: int = ...) -> Series[complex]: ...  # type: ignore[overload-overlap]
+    @overload
     def diff(self, periods: int = ...) -> Series[float]: ...
     def autocorr(self, lag: int = ...) -> float: ...
     @overload
@@ -2189,3 +2194,4 @@ class OffsetSeries(Series[BaseOffset]):
 class IntervalSeries(Series[Interval[_OrderableT]], Generic[_OrderableT]):
     @property
     def array(self) -> IntervalArray: ...
+    def diff(self, periods: int = ...) -> Never: ...
diff --git a/tests/test_series.py b/tests/test_series.py
index 0ed508388..a0021a264 100644
--- a/tests/test_series.py
+++ b/tests/test_series.py
@@ -3116,16 +3116,22 @@ def test_diff() -> None:
     # bool -> object
     check(
         assert_type(
-            pd.Series([True, True, False, False, True]).diff(), "pd.Series[object]"
+            pd.Series([True, True, False, False, True]).diff(),
+            "pd.Series[type[object]]",
         ),
         pd.Series,
         object,
     )
     # object -> object
-    check(assert_type(s.astype(object).diff(), "pd.Series[object]"), pd.Series, object)
+    check(
+        assert_type(s.astype(object).diff(), "pd.Series[type[object]]"),
+        pd.Series,
+        object,
+    )
     # Baseoffset (object) -> object
     # from pandas.tseries.frequencies import to_offset
     # pd.Series([to_offset("5min"), to_offset("1D1h")]).diff()
+    # pd.Series([pd.DateOffset(days=1), pd.DateOffset(days=2)]).diff()
     # complex -> complex
     check(
         assert_type(s.astype(complex).diff(), "pd.Series[complex]"), pd.Series, complex

From 9aeb6b74d4ccfec359a3008ae782a86125116e4d Mon Sep 17 00:00:00 2001
From: Laurent Mutricy <laurent.mutricy@ekium.eu>
Date: Tue, 16 Apr 2024 17:21:18 +0200
Subject: [PATCH 06/12] adding a few Never

---
 pandas-stubs/core/series.pyi |  6 ++++++
 tests/test_series.py         | 19 +++++++++++++++++--
 2 files changed, 23 insertions(+), 2 deletions(-)

diff --git a/pandas-stubs/core/series.pyi b/pandas-stubs/core/series.pyi
index f4e36bc21..27acf2326 100644
--- a/pandas-stubs/core/series.pyi
+++ b/pandas-stubs/core/series.pyi
@@ -753,6 +753,12 @@ class Series(IndexOpsMixin[S1], NDFrame):
     @overload
     def diff(self: Series[complex], periods: int = ...) -> Series[complex]: ...  # type: ignore[overload-overlap]
     @overload
+    def diff(self: Series[bytes], periods: int = ...) -> Never: ...
+    @overload
+    def diff(self: Series[type], periods: int = ...) -> Never: ...
+    @overload
+    def diff(self: Series[str], periods: int = ...) -> Never: ...
+    @overload
     def diff(self, periods: int = ...) -> Series[float]: ...
     def autocorr(self, lag: int = ...) -> float: ...
     @overload
diff --git a/tests/test_series.py b/tests/test_series.py
index a0021a264..6d1742067 100644
--- a/tests/test_series.py
+++ b/tests/test_series.py
@@ -3139,9 +3139,24 @@ def test_diff() -> None:
     if TYPE_CHECKING_INVALID_USAGE:
         # interval -> TypeError: IntervalArray has no 'diff' method. Convert to a suitable dtype prior to calling 'diff'.
         assert_never(pd.Series([pd.Interval(0, 2), pd.Interval(1, 4)]).diff())
+        # datetime.time -> TypeError: unsupported operand type(s) for -: 'datetime.time' and 'datetime.time'
+        # pd.Series([datetime.datetime.now().time(), datetime.datetime.now().time()]).diff()
+
+
+def test_diff_never1() -> None:
+    s = pd.Series([1, 1, 2, 3, 5, 8])
+    if TYPE_CHECKING_INVALID_USAGE:
         # bytes -> numpy.core._exceptions._UFuncNoLoopError: ufunc 'subtract' did not contain a loop with signature matching types (dtype('S21'), dtype('S21')) -> None
         assert_never(s.astype(bytes).diff())
+
+
+def test_diff_never2() -> None:
+    if TYPE_CHECKING_INVALID_USAGE:
         # dtype -> TypeError: unsupported operand type(s) for -: 'type' and 'type'
         assert_never(pd.Series([str, int, bool]).diff())
-        # datetime.time -> TypeError: unsupported operand type(s) for -: 'datetime.time' and 'datetime.time'
-        # pd.Series([datetime.datetime.now().time(), datetime.datetime.now().time()]).diff()
+
+
+def test_diff_never3() -> None:
+    if TYPE_CHECKING_INVALID_USAGE:
+        # str -> TypeError: unsupported operand type(s) for -: 'str' and 'str'
+        assert_never(pd.Series(["a", "b"]).diff())

From bb66a37408882a74f6ebe6b219bad218537208bc Mon Sep 17 00:00:00 2001
From: Laurent Mutricy <laurent.mutricy@ekium.eu>
Date: Thu, 18 Apr 2024 16:16:13 +0200
Subject: [PATCH 07/12] fix: check function updated for series.diff

---
 tests/__init__.py    | 13 ++++++++++---
 tests/test_series.py | 32 +++++++++++++++++++++-----------
 2 files changed, 31 insertions(+), 14 deletions(-)

diff --git a/tests/__init__.py b/tests/__init__.py
index ab95a55b3..4448af3c5 100644
--- a/tests/__init__.py
+++ b/tests/__init__.py
@@ -10,6 +10,7 @@
 from typing import (
     TYPE_CHECKING,
     Final,
+    Literal,
 )
 
 import pandas as pd
@@ -24,16 +25,22 @@
 PD_LTE_22 = Version(pd.__version__) < Version("2.2.999")
 
 
-def check(actual: T, klass: type, dtype: type | None = None, attr: str = "left") -> T:
+def check(
+    actual: T,
+    klass: type,
+    dtype: type | None = None,
+    attr: str = "left",
+    index_to_check_for_type: Literal[0, -1] = 0,
+) -> T:
     if not isinstance(actual, klass):
         raise RuntimeError(f"Expected type '{klass}' but got '{type(actual)}'")
     if dtype is None:
         return actual  # type: ignore[return-value]
 
     if isinstance(actual, pd.Series):
-        value = actual.iloc[0]
+        value = actual.iloc[index_to_check_for_type]
     elif isinstance(actual, pd.Index):
-        value = actual[0]  # type: ignore[assignment]
+        value = actual[index_to_check_for_type]  # type: ignore[assignment]
     elif isinstance(actual, BaseGroupBy):
         value = actual.obj
     elif hasattr(actual, "__iter__"):
diff --git a/tests/test_series.py b/tests/test_series.py
index 6d1742067..fdbbd543f 100644
--- a/tests/test_series.py
+++ b/tests/test_series.py
@@ -3090,29 +3090,39 @@ def test_diff() -> None:
         ),
         pd.Series,
         pd.Timedelta,
+        index_to_check_for_type=-1,
     )
     # timestamp -> timedelta
     times = pd.Series([pd.Timestamp(0), pd.Timestamp(1)])
-    check(assert_type(times.diff(), "TimedeltaSeries"), pd.Series, pd.Timedelta)
-    # timedelta -> timedelta64
     check(
-        assert_type(
-            pd.Series([pd.Timedelta(0), pd.Timedelta(1)]).diff(), "TimedeltaSeries"
-        ),
+        assert_type(times.diff(), "TimedeltaSeries"),
         pd.Series,
         pd.Timedelta,
+        index_to_check_for_type=-1,
     )
-    # period -> object
+    # timedelta -> timedelta64
     check(
         assert_type(
-            pd.Series(
-                [pd.Period("2012", freq="D"), pd.Period("2012-1-1", freq="D")]
-            ).diff(),
-            "pd.Series[type[object]]",
+            pd.Series([pd.Timedelta(0), pd.Timedelta(1)]).diff(), "TimedeltaSeries"
         ),
         pd.Series,
-        object,
+        pd.Timedelta,
+        index_to_check_for_type=-1,
     )
+    # period -> object
+    with pytest_warns_bounded(
+        RuntimeWarning, "overflow encountered in scalar multiply"
+    ):
+        check(
+            assert_type(
+                pd.Series(
+                    [pd.Period("2012-1-1", freq="D"), pd.Period("2012-1-2", freq="D")]
+                ).diff(),
+                "pd.Series[type[object]]",
+            ),
+            pd.Series,
+            object,
+        )
     # bool -> object
     check(
         assert_type(

From c73b3b1c2e257cb386b4233901f3d3407da946cc Mon Sep 17 00:00:00 2001
From: Laurent Mutricy <laurent.mutricy@ekium.eu>
Date: Fri, 19 Apr 2024 10:33:34 +0200
Subject: [PATCH 08/12] clean comments and update period test

---
 tests/test_series.py | 33 ++++++++++++++-------------------
 1 file changed, 14 insertions(+), 19 deletions(-)

diff --git a/tests/test_series.py b/tests/test_series.py
index fdbbd543f..f0d28ec88 100644
--- a/tests/test_series.py
+++ b/tests/test_series.py
@@ -3110,19 +3110,16 @@ def test_diff() -> None:
         index_to_check_for_type=-1,
     )
     # period -> object
-    with pytest_warns_bounded(
-        RuntimeWarning, "overflow encountered in scalar multiply"
-    ):
-        check(
-            assert_type(
-                pd.Series(
-                    [pd.Period("2012-1-1", freq="D"), pd.Period("2012-1-2", freq="D")]
-                ).diff(),
-                "pd.Series[type[object]]",
-            ),
-            pd.Series,
-            object,
-        )
+    check(
+        assert_type(
+            pd.Series(
+                pd.period_range(start="2017-01-01", end="2017-02-01", freq="D")
+            ).diff(),
+            "pd.Series[type[object]]",
+        ),
+        pd.Series,
+        object,
+    )
     # bool -> object
     check(
         assert_type(
@@ -3138,10 +3135,6 @@ def test_diff() -> None:
         pd.Series,
         object,
     )
-    # Baseoffset (object) -> object
-    # from pandas.tseries.frequencies import to_offset
-    # pd.Series([to_offset("5min"), to_offset("1D1h")]).diff()
-    # pd.Series([pd.DateOffset(days=1), pd.DateOffset(days=2)]).diff()
     # complex -> complex
     check(
         assert_type(s.astype(complex).diff(), "pd.Series[complex]"), pd.Series, complex
@@ -3149,8 +3142,10 @@ def test_diff() -> None:
     if TYPE_CHECKING_INVALID_USAGE:
         # interval -> TypeError: IntervalArray has no 'diff' method. Convert to a suitable dtype prior to calling 'diff'.
         assert_never(pd.Series([pd.Interval(0, 2), pd.Interval(1, 4)]).diff())
-        # datetime.time -> TypeError: unsupported operand type(s) for -: 'datetime.time' and 'datetime.time'
-        # pd.Series([datetime.datetime.now().time(), datetime.datetime.now().time()]).diff()
+
+    # note managed by stubs:
+    # datetime.time -> Never (TypeError: unsupported operand type(s) for -: 'datetime.time' and 'datetime.time')
+    # Baseoffset (object) -> object
 
 
 def test_diff_never1() -> None:

From b4090878b727a07869d5e5ea155225b7894ec9d7 Mon Sep 17 00:00:00 2001
From: Laurent Mutricy <laurent.mutricy@ekium.eu>
Date: Mon, 22 Apr 2024 10:01:38 +0200
Subject: [PATCH 09/12] cover windows specific RuntimeWarning

---
 tests/test_series.py | 36 ++++++++++++++++++++++++++----------
 1 file changed, 26 insertions(+), 10 deletions(-)

diff --git a/tests/test_series.py b/tests/test_series.py
index 50567996e..f2ef5b10c 100644
--- a/tests/test_series.py
+++ b/tests/test_series.py
@@ -46,6 +46,7 @@
 from tests import (
     PD_LTE_22,
     TYPE_CHECKING_INVALID_USAGE,
+    WINDOWS,
     check,
     pytest_warns_bounded,
 )
@@ -3132,16 +3133,31 @@ def test_diff() -> None:
         index_to_check_for_type=-1,
     )
     # period -> object
-    check(
-        assert_type(
-            pd.Series(
-                pd.period_range(start="2017-01-01", end="2017-02-01", freq="D")
-            ).diff(),
-            "pd.Series[type[object]]",
-        ),
-        pd.Series,
-        object,
-    )
+    if WINDOWS:
+        with pytest_warns_bounded(
+            RuntimeWarning, "overflow encountered in scalar multiply"
+        ):
+            check(
+                assert_type(
+                    pd.Series(
+                        pd.period_range(start="2017-01-01", end="2017-02-01", freq="D")
+                    ).diff(),
+                    "pd.Series[type[object]]",
+                ),
+                pd.Series,
+                object,
+            )
+    else:
+        check(
+            assert_type(
+                pd.Series(
+                    pd.period_range(start="2017-01-01", end="2017-02-01", freq="D")
+                ).diff(),
+                "pd.Series[type[object]]",
+            ),
+            pd.Series,
+            object,
+        )
     # bool -> object
     check(
         assert_type(

From c9bb09f9c305abd763ebbc0264cdd0ec52e02b1d Mon Sep 17 00:00:00 2001
From: Laurent Mutricy <laurent.mutricy@ekium.eu>
Date: Thu, 25 Apr 2024 22:36:48 +0200
Subject: [PATCH 10/12] PeriodSeries.diff is OffsetSeries

---
 pandas-stubs/core/series.pyi |  2 +-
 tests/test_series.py         | 13 +++++++++----
 2 files changed, 10 insertions(+), 5 deletions(-)

diff --git a/pandas-stubs/core/series.pyi b/pandas-stubs/core/series.pyi
index 5da6eb414..1d48feba3 100644
--- a/pandas-stubs/core/series.pyi
+++ b/pandas-stubs/core/series.pyi
@@ -2190,7 +2190,7 @@ class PeriodSeries(Series[Period]):
     @property
     def dt(self) -> PeriodProperties: ...  # type: ignore[override] # pyright: ignore[reportIncompatibleMethodOverride]
     def __sub__(self, other: PeriodSeries) -> OffsetSeries: ...  # type: ignore[override] # pyright: ignore[reportIncompatibleMethodOverride]
-    def diff(self, periods: int = ...) -> Series[type[object]]: ...  # type: ignore[override] # pyright: ignore[reportIncompatibleMethodOverride]
+    def diff(self, periods: int = ...) -> OffsetSeries: ...  # type: ignore[override] # pyright: ignore[reportIncompatibleMethodOverride]
 
 class OffsetSeries(Series[BaseOffset]):
     @overload  # type: ignore[override]
diff --git a/tests/test_series.py b/tests/test_series.py
index f2ef5b10c..4073378ac 100644
--- a/tests/test_series.py
+++ b/tests/test_series.py
@@ -38,6 +38,7 @@
 import xarray as xr
 
 from pandas._libs.missing import NAType
+from pandas._libs.tslibs import BaseOffset
 from pandas._typing import (
     DtypeObj,
     Scalar,
@@ -54,12 +55,14 @@
 
 if TYPE_CHECKING:
     from pandas.core.series import (
+        OffsetSeries,
         TimedeltaSeries,
         TimestampSeries,
     )
 else:
     TimedeltaSeries: TypeAlias = pd.Series
     TimestampSeries: TypeAlias = pd.Series
+    OffsetSeries: TypeAlias = pd.Series
 
 if TYPE_CHECKING:
     from pandas._typing import (
@@ -3142,10 +3145,11 @@ def test_diff() -> None:
                     pd.Series(
                         pd.period_range(start="2017-01-01", end="2017-02-01", freq="D")
                     ).diff(),
-                    "pd.Series[type[object]]",
+                    "OffsetSeries",
                 ),
                 pd.Series,
-                object,
+                BaseOffset,
+                index_to_check_for_type=-1,
             )
     else:
         check(
@@ -3153,10 +3157,11 @@ def test_diff() -> None:
                 pd.Series(
                     pd.period_range(start="2017-01-01", end="2017-02-01", freq="D")
                 ).diff(),
-                "pd.Series[type[object]]",
+                "OffsetSeries",
             ),
             pd.Series,
-            object,
+            BaseOffset,
+            index_to_check_for_type=-1,
         )
     # bool -> object
     check(

From 67a9392ad7dfa33ee2066f7db6e82e20a03d9dd7 Mon Sep 17 00:00:00 2001
From: Laurent Mutricy <laurent.mutricy@ekium.eu>
Date: Thu, 25 Apr 2024 22:38:03 +0200
Subject: [PATCH 11/12] remove comments

---
 tests/test_series.py | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/tests/test_series.py b/tests/test_series.py
index 4073378ac..203f81700 100644
--- a/tests/test_series.py
+++ b/tests/test_series.py
@@ -3186,10 +3186,6 @@ def test_diff() -> None:
         # interval -> TypeError: IntervalArray has no 'diff' method. Convert to a suitable dtype prior to calling 'diff'.
         assert_never(pd.Series([pd.Interval(0, 2), pd.Interval(1, 4)]).diff())
 
-    # note managed by stubs:
-    # datetime.time -> Never (TypeError: unsupported operand type(s) for -: 'datetime.time' and 'datetime.time')
-    # Baseoffset (object) -> object
-
 
 def test_diff_never1() -> None:
     s = pd.Series([1, 1, 2, 3, 5, 8])

From 309d4b9555fb09b8cf12e51f52c6610135729f53 Mon Sep 17 00:00:00 2001
From: Laurent Mutricy <laurent.mutricy@ekium.eu>
Date: Fri, 26 Apr 2024 16:46:27 +0200
Subject: [PATCH 12/12] try tables 3.9.2 to fix macos github test

---
 pyproject.toml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pyproject.toml b/pyproject.toml
index f21594481..62c63b039 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -49,7 +49,7 @@ black = ">=23.3.0"
 isort = ">=5.12.0"
 openpyxl = ">=3.0.10"
 # for tables, MacOS gives random CI failures on 3.9.2
-tables = { version = "==3.9.1",  python = "<4"}  # 3.8.0 depends on blosc2 which caps python to <4
+tables = { version = "==3.9.2",  python = "<4"}  # 3.8.0 depends on blosc2 which caps python to <4
 lxml = ">=4.9.1"
 pyreadstat = ">=1.2.0"
 xlrd = ">=2.0.1"