From 0d8e2623ae2ef6480ae05b9a3e1ef05f64c5101d Mon Sep 17 00:00:00 2001 From: Loic Diridollou Date: Wed, 27 Nov 2024 15:20:13 -0500 Subject: [PATCH 1/9] GH1055 Add pandas.api.typing to pandas-stubs --- pandas-stubs/api/typing/__init__.pyi | 34 +++++++++++++++ tests/test_api_typing.py | 63 ++++++++++++++++++++++++++++ 2 files changed, 97 insertions(+) create mode 100644 pandas-stubs/api/typing/__init__.pyi create mode 100644 tests/test_api_typing.py diff --git a/pandas-stubs/api/typing/__init__.pyi b/pandas-stubs/api/typing/__init__.pyi new file mode 100644 index 000000000..938283593 --- /dev/null +++ b/pandas-stubs/api/typing/__init__.pyi @@ -0,0 +1,34 @@ +""" +Public API classes that store intermediate results useful for type-hinting. +""" + +from pandas.core.groupby import ( + DataFrameGroupBy as DataFrameGroupBy, + SeriesGroupBy as SeriesGroupBy, +) +from pandas.core.indexes.frozen import FrozenList as FrozenList +from pandas.core.resample import ( + DatetimeIndexResamplerGroupby as DatetimeIndexResamplerGroupby, + PeriodIndexResamplerGroupby as PeriodIndexResamplerGroupby, + Resampler as Resampler, + TimedeltaIndexResamplerGroupby as TimedeltaIndexResamplerGroupby, + TimeGrouper as TimeGrouper, +) +from pandas.core.window import ( + Expanding as Expanding, + ExpandingGroupby as ExpandingGroupby, + ExponentialMovingWindow as ExponentialMovingWindow, + ExponentialMovingWindowGroupby as ExponentialMovingWindowGroupby, + Rolling as Rolling, + RollingGroupby as RollingGroupby, + Window as Window, +) + +from pandas._libs import NaTType as NaTType +from pandas._libs.missing import NAType as NAType + +from pandas.io.json._json import JsonReader as JsonReader + +# SASReader is not defined so commenting it out for now +# from pandas.io.sas.sasreader import SASReader as SASReader +from pandas.io.stata import StataReader as StataReader diff --git a/tests/test_api_typing.py b/tests/test_api_typing.py new file mode 100644 index 000000000..8004770c7 --- /dev/null +++ b/tests/test_api_typing.py @@ -0,0 +1,63 @@ +"""Test module for classes in pandas.api.typing.""" + +from typing import ( + TYPE_CHECKING, + Literal, + assert_type, +) + +import numpy as np +import pandas as pd +from pandas.api.typing import ( + DataFrameGroupBy, + DatetimeIndexResamplerGroupby, + FrozenList, + NAType, + SeriesGroupBy, +) + +from pandas._typing import Scalar + +from tests import check + +if TYPE_CHECKING: + from pandas.core.groupby.groupby import _ResamplerGroupBy # noqa: F401 + + +def test_dataframegroupby(): + df = pd.DataFrame({"a": [1, 2, 3]}) + check( + assert_type(df.groupby("a"), DataFrameGroupBy[Scalar, Literal[True]]), + DataFrameGroupBy, + ) + + +def test_seriesgroupby(): + sr: pd.Series[int] = pd.Series([1, 2, 3], index=pd.Index(["a", "b", "a"])) + check( + assert_type(sr.groupby("a"), SeriesGroupBy[int, Scalar]), + SeriesGroupBy, + ) + + +def test_frozenlist() -> None: + flst = FrozenList([1, 2, 3]) + check(assert_type(flst, FrozenList), FrozenList) + + +def tests_datetimeindexersamplergroupby() -> None: + idx = pd.date_range("1999-1-1", periods=365, freq="D") + df = pd.DataFrame( + np.random.standard_normal((365, 2)), index=idx, columns=["col1", "col2"] + ) + gb_df = df.groupby("col2") + check( + assert_type(gb_df.resample("ME"), "_ResamplerGroupBy[pd.DataFrame]"), + DatetimeIndexResamplerGroupby, + pd.DataFrame, + ) + + +def test_natype() -> None: + i64dt = pd.Int64Dtype() + check(assert_type(i64dt.na_value, NAType), NAType) From 3568b96a48634e77460b7dec1a0ee930182dcc62 Mon Sep 17 00:00:00 2001 From: Loic Diridollou Date: Wed, 27 Nov 2024 15:22:14 -0500 Subject: [PATCH 2/9] GH1055 Fix lint --- pandas-stubs/api/typing/__init__.pyi | 4 ---- 1 file changed, 4 deletions(-) diff --git a/pandas-stubs/api/typing/__init__.pyi b/pandas-stubs/api/typing/__init__.pyi index 938283593..550bdd123 100644 --- a/pandas-stubs/api/typing/__init__.pyi +++ b/pandas-stubs/api/typing/__init__.pyi @@ -1,7 +1,3 @@ -""" -Public API classes that store intermediate results useful for type-hinting. -""" - from pandas.core.groupby import ( DataFrameGroupBy as DataFrameGroupBy, SeriesGroupBy as SeriesGroupBy, From c3b2f33f61bf688e89802cbd90ed32fff566ae4d Mon Sep 17 00:00:00 2001 From: Loic Diridollou Date: Wed, 27 Nov 2024 15:23:40 -0500 Subject: [PATCH 3/9] GH1055 Fix assert_type --- tests/test_api_typing.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/test_api_typing.py b/tests/test_api_typing.py index 8004770c7..bfccc8946 100644 --- a/tests/test_api_typing.py +++ b/tests/test_api_typing.py @@ -3,7 +3,6 @@ from typing import ( TYPE_CHECKING, Literal, - assert_type, ) import numpy as np @@ -15,6 +14,7 @@ NAType, SeriesGroupBy, ) +from typing_extensions import assert_type from pandas._typing import Scalar From 487faf40d5e837d627b20b38011bed5e95d59e20 Mon Sep 17 00:00:00 2001 From: Loic Diridollou Date: Wed, 27 Nov 2024 15:51:05 -0500 Subject: [PATCH 4/9] GH1055 Fix tests --- pandas-stubs/api/typing/__init__.pyi | 1 - tests/test_api_typing.py | 18 +++++------------- 2 files changed, 5 insertions(+), 14 deletions(-) diff --git a/pandas-stubs/api/typing/__init__.pyi b/pandas-stubs/api/typing/__init__.pyi index 550bdd123..c81f444c0 100644 --- a/pandas-stubs/api/typing/__init__.pyi +++ b/pandas-stubs/api/typing/__init__.pyi @@ -2,7 +2,6 @@ from pandas.core.groupby import ( DataFrameGroupBy as DataFrameGroupBy, SeriesGroupBy as SeriesGroupBy, ) -from pandas.core.indexes.frozen import FrozenList as FrozenList from pandas.core.resample import ( DatetimeIndexResamplerGroupby as DatetimeIndexResamplerGroupby, PeriodIndexResamplerGroupby as PeriodIndexResamplerGroupby, diff --git a/tests/test_api_typing.py b/tests/test_api_typing.py index bfccc8946..7238288e7 100644 --- a/tests/test_api_typing.py +++ b/tests/test_api_typing.py @@ -1,22 +1,19 @@ """Test module for classes in pandas.api.typing.""" -from typing import ( - TYPE_CHECKING, - Literal, -) +from typing import Literal # noqa: F401 +from typing import TYPE_CHECKING import numpy as np import pandas as pd from pandas.api.typing import ( DataFrameGroupBy, DatetimeIndexResamplerGroupby, - FrozenList, NAType, SeriesGroupBy, ) from typing_extensions import assert_type -from pandas._typing import Scalar +from pandas._typing import Scalar # noqa: F401 from tests import check @@ -27,7 +24,7 @@ def test_dataframegroupby(): df = pd.DataFrame({"a": [1, 2, 3]}) check( - assert_type(df.groupby("a"), DataFrameGroupBy[Scalar, Literal[True]]), + assert_type(df.groupby("a"), "DataFrameGroupBy[Scalar, Literal[True]]"), DataFrameGroupBy, ) @@ -35,16 +32,11 @@ def test_dataframegroupby(): def test_seriesgroupby(): sr: pd.Series[int] = pd.Series([1, 2, 3], index=pd.Index(["a", "b", "a"])) check( - assert_type(sr.groupby("a"), SeriesGroupBy[int, Scalar]), + assert_type(sr.groupby(level=0), "SeriesGroupBy[int, Scalar]"), SeriesGroupBy, ) -def test_frozenlist() -> None: - flst = FrozenList([1, 2, 3]) - check(assert_type(flst, FrozenList), FrozenList) - - def tests_datetimeindexersamplergroupby() -> None: idx = pd.date_range("1999-1-1", periods=365, freq="D") df = pd.DataFrame( From 708cba1a58a228cc8ecfd3eafd88bd494b41d0e1 Mon Sep 17 00:00:00 2001 From: Loic Diridollou Date: Wed, 27 Nov 2024 22:21:38 -0500 Subject: [PATCH 5/9] Revert to generic --- tests/test_api_typing.py | 14 +++----------- 1 file changed, 3 insertions(+), 11 deletions(-) diff --git a/tests/test_api_typing.py b/tests/test_api_typing.py index 7238288e7..0a7299a04 100644 --- a/tests/test_api_typing.py +++ b/tests/test_api_typing.py @@ -1,8 +1,5 @@ """Test module for classes in pandas.api.typing.""" -from typing import Literal # noqa: F401 -from typing import TYPE_CHECKING - import numpy as np import pandas as pd from pandas.api.typing import ( @@ -13,18 +10,13 @@ ) from typing_extensions import assert_type -from pandas._typing import Scalar # noqa: F401 - from tests import check -if TYPE_CHECKING: - from pandas.core.groupby.groupby import _ResamplerGroupBy # noqa: F401 - def test_dataframegroupby(): df = pd.DataFrame({"a": [1, 2, 3]}) check( - assert_type(df.groupby("a"), "DataFrameGroupBy[Scalar, Literal[True]]"), + assert_type(df.groupby("a"), DataFrameGroupBy), DataFrameGroupBy, ) @@ -32,7 +24,7 @@ def test_dataframegroupby(): def test_seriesgroupby(): sr: pd.Series[int] = pd.Series([1, 2, 3], index=pd.Index(["a", "b", "a"])) check( - assert_type(sr.groupby(level=0), "SeriesGroupBy[int, Scalar]"), + assert_type(sr.groupby(level=0), SeriesGroupBy), SeriesGroupBy, ) @@ -44,7 +36,7 @@ def tests_datetimeindexersamplergroupby() -> None: ) gb_df = df.groupby("col2") check( - assert_type(gb_df.resample("ME"), "_ResamplerGroupBy[pd.DataFrame]"), + assert_type(gb_df.resample("ME"), DatetimeIndexResamplerGroupby), DatetimeIndexResamplerGroupby, pd.DataFrame, ) From 85742e42b4c668e520e8c45595c4e36866f4d440 Mon Sep 17 00:00:00 2001 From: Loic Diridollou Date: Thu, 28 Nov 2024 18:13:07 -0500 Subject: [PATCH 6/9] GH1055 Fix tests --- tests/test_api_typing.py | 136 +++++++++++++++++++++++++++++++++++---- 1 file changed, 123 insertions(+), 13 deletions(-) diff --git a/tests/test_api_typing.py b/tests/test_api_typing.py index 0a7299a04..22d93ca16 100644 --- a/tests/test_api_typing.py +++ b/tests/test_api_typing.py @@ -1,32 +1,55 @@ """Test module for classes in pandas.api.typing.""" +from pathlib import Path + import numpy as np import pandas as pd +from pandas._testing import ensure_clean from pandas.api.typing import ( DataFrameGroupBy, DatetimeIndexResamplerGroupby, + Expanding, + ExpandingGroupby, + ExponentialMovingWindow, + ExponentialMovingWindowGroupby, + JsonReader, + NaTType, NAType, + PeriodIndexResamplerGroupby, + Resampler, + Rolling, + RollingGroupby, SeriesGroupBy, + TimedeltaIndexResamplerGroupby, + TimeGrouper, + Window, ) +import pytest from typing_extensions import assert_type from tests import check +from pandas.io.json._json import read_json +from pandas.io.stata import StataReader + def test_dataframegroupby(): df = pd.DataFrame({"a": [1, 2, 3]}) - check( - assert_type(df.groupby("a"), DataFrameGroupBy), - DataFrameGroupBy, - ) + group = df.groupby("a") + + def f1(gb: DataFrameGroupBy): + check(gb, DataFrameGroupBy) + + f1(group) def test_seriesgroupby(): - sr: pd.Series[int] = pd.Series([1, 2, 3], index=pd.Index(["a", "b", "a"])) - check( - assert_type(sr.groupby(level=0), SeriesGroupBy), - SeriesGroupBy, - ) + sr = pd.Series([1, 2, 3], index=pd.Index(["a", "b", "a"])) + + def f1(gb: SeriesGroupBy): + check(gb, SeriesGroupBy) + + f1(sr.groupby(level=0)) def tests_datetimeindexersamplergroupby() -> None: @@ -35,13 +58,100 @@ def tests_datetimeindexersamplergroupby() -> None: np.random.standard_normal((365, 2)), index=idx, columns=["col1", "col2"] ) gb_df = df.groupby("col2") - check( - assert_type(gb_df.resample("ME"), DatetimeIndexResamplerGroupby), - DatetimeIndexResamplerGroupby, - pd.DataFrame, + check(gb_df.resample("ME"), DatetimeIndexResamplerGroupby) + + +def test_timedeltaindexresamplergroupby() -> None: + idx = pd.TimedeltaIndex(["0 days", "1 days", "2 days", "3 days", "4 days"]) + df = pd.DataFrame( + np.random.standard_normal((5, 2)), index=idx, columns=["col1", "col2"] ) + gb_df = df.groupby("col2") + check(gb_df.resample("1D"), TimedeltaIndexResamplerGroupby) def test_natype() -> None: i64dt = pd.Int64Dtype() check(assert_type(i64dt.na_value, NAType), NAType) + + +def test_nattype() -> None: + td = pd.Timedelta("1 day") + as_nat = pd.NaT + check(assert_type(td + as_nat, NaTType), NaTType) + + +def test_expanding() -> None: + df = pd.DataFrame({"B": [0, 1, 2, np.nan, 4]}) + check(df.expanding(), Expanding) + + +def test_expanding_groubpy() -> None: + df = pd.DataFrame({"B": [0, 1, 2, np.nan, 4]}) + check(df.groupby("B").expanding(), ExpandingGroupby) + + +def test_ewm() -> None: + df = pd.DataFrame({"B": [0, 1, 2, np.nan, 4]}) + check(df.ewm(2), ExponentialMovingWindow) + + +def test_ewm_groubpy() -> None: + df = pd.DataFrame({"B": [0, 1, 2, np.nan, 4]}) + check(df.groupby("B").ewm(2), ExponentialMovingWindowGroupby) + + +def test_json_reader() -> None: + df = pd.DataFrame({"B": [0, 1, 2, np.nan, 4]}) + + with ensure_clean() as path: + check(assert_type(df.to_json(path), None), type(None)) + json_reader = read_json(path, chunksize=1, lines=True) + check(json_reader, JsonReader) + json_reader.close() + + +@pytest.mark.skip("Resampling with a PeriodIndex is deprecated.") +def test_periodindexresamplergroupby() -> None: + idx = pd.period_range("2020-01-28 09:00", periods=4, freq="D") + df = pd.DataFrame(data=4 * [range(2)], index=idx, columns=["a", "b"]) + check( + df.groupby("a").resample("3min"), + PeriodIndexResamplerGroupby, + ) + + +def test_resampler() -> None: + s = pd.Series([1, 2, 3, 4, 5], index=pd.date_range("20130101", periods=5, freq="s")) + check(s.resample("3min"), Resampler) + + +def test_rolling() -> None: + df = pd.DataFrame({"B": [0, 1, 2, np.nan, 4]}) + check(df.rolling(2), Rolling) + + +def test_rolling_groupby() -> None: + df = pd.DataFrame({"B": [0, 1, 2, np.nan, 4]}) + check(df.groupby("B").rolling(2), RollingGroupby) + + +def test_timegrouper() -> None: + check(pd.Grouper(key="Publish date", freq="1W"), TimeGrouper) + + +def test_window() -> None: + ser = pd.Series([0, 1, 5, 2, 8]) + check(ser.rolling(2, win_type="gaussian"), Window) + + +def test_statereader(tmp_path: Path) -> None: + df = pd.DataFrame([[1, 2], [3, 4]], columns=["col_1", "col_2"]) + time_stamp = pd.Timestamp(2000, 2, 29, 14, 21) + variable_labels = {"col_1": "This is an example"} + path = tmp_path / "file" + df.to_stata( + path, time_stamp=time_stamp, variable_labels=variable_labels, version=None + ) + with StataReader(path) as reader: + check(reader, StataReader) From 227a095f1d8244b6aad9c053903aa506c77c5df4 Mon Sep 17 00:00:00 2001 From: Loic Diridollou Date: Thu, 28 Nov 2024 20:33:25 -0500 Subject: [PATCH 7/9] GH1055 new test format --- tests/test_api_typing.py | 105 +++++++++++++++++++++++++++++++-------- 1 file changed, 84 insertions(+), 21 deletions(-) diff --git a/tests/test_api_typing.py b/tests/test_api_typing.py index 22d93ca16..350132e1c 100644 --- a/tests/test_api_typing.py +++ b/tests/test_api_typing.py @@ -58,6 +58,13 @@ def tests_datetimeindexersamplergroupby() -> None: np.random.standard_normal((365, 2)), index=idx, columns=["col1", "col2"] ) gb_df = df.groupby("col2") + + # TODO the groupby here is too wide and returns _ResamplerGroupby alias + # def f1(gb: DatetimeIndexResamplerGroupby): + # check(gb, DatetimeIndexResamplerGroupby) + # + # f1(gb_df.resample("ME")) + check(gb_df.resample("ME"), DatetimeIndexResamplerGroupby) @@ -67,9 +74,30 @@ def test_timedeltaindexresamplergroupby() -> None: np.random.standard_normal((5, 2)), index=idx, columns=["col1", "col2"] ) gb_df = df.groupby("col2") + + # TODO the groupby here is too wide and returns _ResamplerGroupby alias + # def f1(gb: TimedeltaIndexResamplerGroupby): + # check(gb, TimedeltaIndexResamplerGroupby) + # + # f1(gb_df.resample("1D")) + check(gb_df.resample("1D"), TimedeltaIndexResamplerGroupby) +@pytest.mark.skip("Resampling with a PeriodIndex is deprecated.") +def test_periodindexresamplergroupby() -> None: + idx = pd.period_range("2020-01-28 09:00", periods=4, freq="D") + df = pd.DataFrame(data=4 * [range(2)], index=idx, columns=["a", "b"]) + + # TODO the groupby here is too wide and returns _ResamplerGroupby alias + # def f1(gb: PeriodIndexResamplerGroupby): + # check(gb, PeriodIndexResamplerGroupby) + # + # f1(df.groupby("a").resample("3min")) + + check(df.groupby("a").resample("3min"), PeriodIndexResamplerGroupby) + + def test_natype() -> None: i64dt = pd.Int64Dtype() check(assert_type(i64dt.na_value, NAType), NAType) @@ -78,71 +106,102 @@ def test_natype() -> None: def test_nattype() -> None: td = pd.Timedelta("1 day") as_nat = pd.NaT + check(assert_type(td + as_nat, NaTType), NaTType) def test_expanding() -> None: df = pd.DataFrame({"B": [0, 1, 2, np.nan, 4]}) - check(df.expanding(), Expanding) + + def f1(gb: Expanding): + check(gb, Expanding) + + f1(df.expanding()) def test_expanding_groubpy() -> None: df = pd.DataFrame({"B": [0, 1, 2, np.nan, 4]}) - check(df.groupby("B").expanding(), ExpandingGroupby) + + def f1(gb: ExpandingGroupby): + check(gb, ExpandingGroupby) + + f1(df.groupby("B").expanding()) def test_ewm() -> None: df = pd.DataFrame({"B": [0, 1, 2, np.nan, 4]}) - check(df.ewm(2), ExponentialMovingWindow) + + def f1(gb: ExponentialMovingWindow): + check(gb, ExponentialMovingWindow) + + f1(df.ewm(2)) def test_ewm_groubpy() -> None: df = pd.DataFrame({"B": [0, 1, 2, np.nan, 4]}) - check(df.groupby("B").ewm(2), ExponentialMovingWindowGroupby) + + def f1(gb: ExponentialMovingWindowGroupby): + check(gb, ExponentialMovingWindowGroupby) + + f1(df.groupby("B").ewm(2)) def test_json_reader() -> None: df = pd.DataFrame({"B": [0, 1, 2, np.nan, 4]}) + def f1(gb: JsonReader): + check(gb, JsonReader) + with ensure_clean() as path: check(assert_type(df.to_json(path), None), type(None)) json_reader = read_json(path, chunksize=1, lines=True) - check(json_reader, JsonReader) + f1(json_reader) json_reader.close() -@pytest.mark.skip("Resampling with a PeriodIndex is deprecated.") -def test_periodindexresamplergroupby() -> None: - idx = pd.period_range("2020-01-28 09:00", periods=4, freq="D") - df = pd.DataFrame(data=4 * [range(2)], index=idx, columns=["a", "b"]) - check( - df.groupby("a").resample("3min"), - PeriodIndexResamplerGroupby, - ) - - def test_resampler() -> None: s = pd.Series([1, 2, 3, 4, 5], index=pd.date_range("20130101", periods=5, freq="s")) - check(s.resample("3min"), Resampler) + + def f1(gb: Resampler): + check(gb, Resampler) + + f1(s.resample("3min")) def test_rolling() -> None: df = pd.DataFrame({"B": [0, 1, 2, np.nan, 4]}) - check(df.rolling(2), Rolling) + + def f1(gb: Rolling): + check(gb, Rolling) + + f1(df.rolling(2)) def test_rolling_groupby() -> None: df = pd.DataFrame({"B": [0, 1, 2, np.nan, 4]}) - check(df.groupby("B").rolling(2), RollingGroupby) + + def f1(gb: RollingGroupby): + check(gb, RollingGroupby) + + f1(df.groupby("B").rolling(2)) def test_timegrouper() -> None: - check(pd.Grouper(key="Publish date", freq="1W"), TimeGrouper) + grouper = pd.Grouper(key="Publish date", freq="1W") + + def f1(gb: TimeGrouper): + check(gb, TimeGrouper) + + f1(grouper) def test_window() -> None: ser = pd.Series([0, 1, 5, 2, 8]) - check(ser.rolling(2, win_type="gaussian"), Window) + + def f1(gb: Window): + check(gb, Window) + + f1(ser.rolling(2, win_type="gaussian")) def test_statereader(tmp_path: Path) -> None: @@ -153,5 +212,9 @@ def test_statereader(tmp_path: Path) -> None: df.to_stata( path, time_stamp=time_stamp, variable_labels=variable_labels, version=None ) + + def f1(gb: StataReader): + check(gb, StataReader) + with StataReader(path) as reader: - check(reader, StataReader) + f1(reader) From fcea20eba2c576133ac030eac7808f9d78f5edc1 Mon Sep 17 00:00:00 2001 From: Loic Diridollou Date: Fri, 29 Nov 2024 17:03:55 -0500 Subject: [PATCH 8/9] GH1055 PR Feedback --- tests/test_api_typing.py | 55 ++++++++++++++++++---------------------- 1 file changed, 25 insertions(+), 30 deletions(-) diff --git a/tests/test_api_typing.py b/tests/test_api_typing.py index 350132e1c..ea6b9d0bd 100644 --- a/tests/test_api_typing.py +++ b/tests/test_api_typing.py @@ -1,7 +1,5 @@ """Test module for classes in pandas.api.typing.""" -from pathlib import Path - import numpy as np import pandas as pd from pandas._testing import ensure_clean @@ -20,6 +18,7 @@ Rolling, RollingGroupby, SeriesGroupBy, + StataReader, TimedeltaIndexResamplerGroupby, TimeGrouper, Window, @@ -30,7 +29,12 @@ from tests import check from pandas.io.json._json import read_json -from pandas.io.stata import StataReader + +ResamplerGroupBy = ( + DatetimeIndexResamplerGroupby + | PeriodIndexResamplerGroupby + | TimedeltaIndexResamplerGroupby +) def test_dataframegroupby(): @@ -59,13 +63,10 @@ def tests_datetimeindexersamplergroupby() -> None: ) gb_df = df.groupby("col2") - # TODO the groupby here is too wide and returns _ResamplerGroupby alias - # def f1(gb: DatetimeIndexResamplerGroupby): - # check(gb, DatetimeIndexResamplerGroupby) - # - # f1(gb_df.resample("ME")) + def f1(gb: ResamplerGroupBy): + check(gb, DatetimeIndexResamplerGroupby) - check(gb_df.resample("ME"), DatetimeIndexResamplerGroupby) + f1(gb_df.resample("ME")) def test_timedeltaindexresamplergroupby() -> None: @@ -75,13 +76,10 @@ def test_timedeltaindexresamplergroupby() -> None: ) gb_df = df.groupby("col2") - # TODO the groupby here is too wide and returns _ResamplerGroupby alias - # def f1(gb: TimedeltaIndexResamplerGroupby): - # check(gb, TimedeltaIndexResamplerGroupby) - # - # f1(gb_df.resample("1D")) + def f1(gb: ResamplerGroupBy): + check(gb, TimedeltaIndexResamplerGroupby) - check(gb_df.resample("1D"), TimedeltaIndexResamplerGroupby) + f1(gb_df.resample("1D")) @pytest.mark.skip("Resampling with a PeriodIndex is deprecated.") @@ -89,13 +87,10 @@ def test_periodindexresamplergroupby() -> None: idx = pd.period_range("2020-01-28 09:00", periods=4, freq="D") df = pd.DataFrame(data=4 * [range(2)], index=idx, columns=["a", "b"]) - # TODO the groupby here is too wide and returns _ResamplerGroupby alias - # def f1(gb: PeriodIndexResamplerGroupby): - # check(gb, PeriodIndexResamplerGroupby) - # - # f1(df.groupby("a").resample("3min")) + def f1(gb: ResamplerGroupBy): + check(gb, PeriodIndexResamplerGroupby) - check(df.groupby("a").resample("3min"), PeriodIndexResamplerGroupby) + f1(df.groupby("a").resample("3min")) def test_natype() -> None: @@ -204,17 +199,17 @@ def f1(gb: Window): f1(ser.rolling(2, win_type="gaussian")) -def test_statereader(tmp_path: Path) -> None: +def test_statereader() -> None: df = pd.DataFrame([[1, 2], [3, 4]], columns=["col_1", "col_2"]) time_stamp = pd.Timestamp(2000, 2, 29, 14, 21) variable_labels = {"col_1": "This is an example"} - path = tmp_path / "file" - df.to_stata( - path, time_stamp=time_stamp, variable_labels=variable_labels, version=None - ) + with ensure_clean() as path: + df.to_stata( + path, time_stamp=time_stamp, variable_labels=variable_labels, version=None + ) - def f1(gb: StataReader): - check(gb, StataReader) + def f1(gb: StataReader): + check(gb, StataReader) - with StataReader(path) as reader: - f1(reader) + with StataReader(path) as reader: + f1(reader) From 2f72bafbc9a07b3be6e632fe6b4906765790a7e5 Mon Sep 17 00:00:00 2001 From: Loic Diridollou Date: Sat, 30 Nov 2024 14:40:48 -0500 Subject: [PATCH 9/9] GH1055 TypeAlias Feedback --- tests/test_api_typing.py | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/tests/test_api_typing.py b/tests/test_api_typing.py index ea6b9d0bd..8ccca9e58 100644 --- a/tests/test_api_typing.py +++ b/tests/test_api_typing.py @@ -24,13 +24,16 @@ Window, ) import pytest -from typing_extensions import assert_type +from typing_extensions import ( + TypeAlias, + assert_type, +) from tests import check from pandas.io.json._json import read_json -ResamplerGroupBy = ( +ResamplerGroupBy: TypeAlias = ( DatetimeIndexResamplerGroupby | PeriodIndexResamplerGroupby | TimedeltaIndexResamplerGroupby