diff --git a/pandas-stubs/_typing.pyi b/pandas-stubs/_typing.pyi index 9258054e3..0f1e5bf28 100644 --- a/pandas-stubs/_typing.pyi +++ b/pandas-stubs/_typing.pyi @@ -581,7 +581,7 @@ SequenceIndexer: TypeAlias = slice | list[int] | np.ndarray PositionalIndexer: TypeAlias = ScalarIndexer | SequenceIndexer TakeIndexer: TypeAlias = Sequence[int] | Sequence[np.integer] | npt.NDArray[np.integer] -IgnoreRaiseCoerce: TypeAlias = Literal["ignore", "raise", "coerce"] +RaiseCoerce: TypeAlias = Literal["raise", "coerce"] # Shared by functions such as drop and astype IgnoreRaise: TypeAlias = Literal["ignore", "raise"] diff --git a/pandas-stubs/core/tools/datetimes.pyi b/pandas-stubs/core/tools/datetimes.pyi index 25400a617..94189b61d 100644 --- a/pandas-stubs/core/tools/datetimes.pyi +++ b/pandas-stubs/core/tools/datetimes.pyi @@ -26,7 +26,7 @@ from pandas._typing import ( AnyArrayLike, DictConvertible, IgnoreRaise, - IgnoreRaiseCoerce, + RaiseCoerce, TimestampConvertibleTypes, npt, ) @@ -68,7 +68,7 @@ def to_datetime( @overload def to_datetime( arg: Series | DictConvertible, - errors: IgnoreRaiseCoerce = ..., + errors: RaiseCoerce = ..., dayfirst: bool = ..., yearfirst: bool = ..., utc: bool = ..., @@ -91,7 +91,7 @@ def to_datetime( | Index | ExtensionArray ), - errors: IgnoreRaiseCoerce = ..., + errors: RaiseCoerce = ..., dayfirst: bool = ..., yearfirst: bool = ..., utc: bool = ..., diff --git a/pandas-stubs/core/tools/numeric.pyi b/pandas-stubs/core/tools/numeric.pyi index 5bfde0413..b38c3ba06 100644 --- a/pandas-stubs/core/tools/numeric.pyi +++ b/pandas-stubs/core/tools/numeric.pyi @@ -10,7 +10,7 @@ from typing_extensions import TypeAlias from pandas._libs.lib import NoDefault from pandas._typing import ( DtypeBackend, - IgnoreRaiseCoerce, + RaiseCoerce, Scalar, npt, ) @@ -27,14 +27,14 @@ def to_numeric( @overload def to_numeric( arg: list | tuple | np.ndarray, - errors: IgnoreRaiseCoerce = ..., + errors: RaiseCoerce = ..., downcast: _Downcast = ..., dtype_backend: DtypeBackend | NoDefault = ..., ) -> npt.NDArray: ... @overload def to_numeric( arg: pd.Series, - errors: IgnoreRaiseCoerce = ..., + errors: RaiseCoerce = ..., downcast: _Downcast = ..., dtype_backend: DtypeBackend | NoDefault = ..., ) -> pd.Series: ... diff --git a/pandas-stubs/core/tools/timedeltas.pyi b/pandas-stubs/core/tools/timedeltas.pyi index 2841ebb79..aa2c34ac9 100644 --- a/pandas-stubs/core/tools/timedeltas.pyi +++ b/pandas-stubs/core/tools/timedeltas.pyi @@ -13,20 +13,20 @@ from pandas._libs.tslibs import Timedelta from pandas._libs.tslibs.timedeltas import TimeDeltaUnitChoices from pandas._typing import ( ArrayLike, - IgnoreRaiseCoerce, + RaiseCoerce, ) @overload def to_timedelta( arg: str | float | timedelta, unit: TimeDeltaUnitChoices | None = ..., - errors: IgnoreRaiseCoerce = ..., + errors: RaiseCoerce = ..., ) -> Timedelta: ... @overload def to_timedelta( arg: Series, unit: TimeDeltaUnitChoices | None = ..., - errors: IgnoreRaiseCoerce = ..., + errors: RaiseCoerce = ..., ) -> TimedeltaSeries: ... @overload def to_timedelta( @@ -39,5 +39,5 @@ def to_timedelta( | Index ), unit: TimeDeltaUnitChoices | None = ..., - errors: IgnoreRaiseCoerce = ..., + errors: RaiseCoerce = ..., ) -> TimedeltaIndex: ... diff --git a/pandas-stubs/io/formats/style.pyi b/pandas-stubs/io/formats/style.pyi index 5ed6742d2..240a161ff 100644 --- a/pandas-stubs/io/formats/style.pyi +++ b/pandas-stubs/io/formats/style.pyi @@ -218,16 +218,6 @@ class Styler(StylerRenderer): level: Level | list[Level] | None = ..., **kwargs: Any, ) -> Styler: ... - def applymap_index( - self, - func: Callable[[Scalar], str], - axis: Axis = ..., - level: Level | list[Level] | None = ..., - **kwargs: Any, - ) -> Styler: ... - def applymap( - self, func: Callable[[Scalar], str], subset: Subset | None = ..., **kwargs: Any - ) -> Styler: ... def set_table_attributes(self, attributes: str) -> Styler: ... def export(self) -> StyleExportDict: ... def use(self, styles: StyleExportDict) -> Styler: ... diff --git a/tests/__init__.py b/tests/__init__.py index 520f02b11..ab95a55b3 100644 --- a/tests/__init__.py +++ b/tests/__init__.py @@ -21,7 +21,7 @@ TYPE_CHECKING_INVALID_USAGE: Final = TYPE_CHECKING WINDOWS = os.name == "nt" or "cygwin" in platform.system().lower() -PD_LTE_21 = Version(pd.__version__) < Version("2.1.999") +PD_LTE_22 = Version(pd.__version__) < Version("2.2.999") def check(actual: T, klass: type, dtype: type | None = None, attr: str = "left") -> T: diff --git a/tests/test_errors.py b/tests/test_errors.py index 98568cc63..1da52167f 100644 --- a/tests/test_errors.py +++ b/tests/test_errors.py @@ -3,7 +3,10 @@ from pandas import errors import pytest -from tests import WINDOWS +from tests import ( + PD_LTE_22, + WINDOWS, +) def test_abstract_method_error() -> None: @@ -105,13 +108,15 @@ def test_specification_error() -> None: def test_setting_with_copy_error() -> None: - with pytest.raises(errors.SettingWithCopyError): - raise errors.SettingWithCopyError() + if PD_LTE_22: + with pytest.raises(errors.SettingWithCopyError): + raise errors.SettingWithCopyError() def test_setting_with_copy_warning() -> None: - with pytest.warns(errors.SettingWithCopyWarning): - warnings.warn("", errors.SettingWithCopyWarning) + if PD_LTE_22: + with pytest.warns(errors.SettingWithCopyWarning): + warnings.warn("", errors.SettingWithCopyWarning) def test_numexpr_clobbering_error() -> None: diff --git a/tests/test_frame.py b/tests/test_frame.py index 96ee6d527..93c72656a 100644 --- a/tests/test_frame.py +++ b/tests/test_frame.py @@ -45,6 +45,7 @@ from pandas._typing import Scalar from tests import ( + PD_LTE_22, TYPE_CHECKING_INVALID_USAGE, check, pytest_warns_bounded, @@ -2257,7 +2258,11 @@ def test_groupby_result() -> None: index, value = next(iterator) assert_type((index, value), tuple[tuple, pd.DataFrame]) - check(assert_type(index, tuple), tuple, np.integer) + if PD_LTE_22: + check(assert_type(index, tuple), tuple, np.integer) + else: + check(assert_type(index, tuple), tuple, int) + check(assert_type(value, pd.DataFrame), pd.DataFrame) iterator2 = df.groupby("a").__iter__() @@ -2365,7 +2370,7 @@ def test_groupby_result_for_ambiguous_indexes() -> None: with pytest_warns_bounded( FutureWarning, "The default of observed=False is deprecated", - lower="2.0.99", + upper="2.2.99", ): categorical_index = pd.CategoricalIndex(df.a) iterator2 = df.groupby(categorical_index).__iter__() diff --git a/tests/test_groupby.py b/tests/test_groupby.py index 88e01ed06..9e356a4cf 100644 --- a/tests/test_groupby.py +++ b/tests/test_groupby.py @@ -34,7 +34,7 @@ from typing_extensions import assert_type from tests import ( - PD_LTE_21, + PD_LTE_22, TYPE_CHECKING_INVALID_USAGE, check, pytest_warns_bounded, @@ -51,13 +51,11 @@ GB_DF = DF.groupby("col3") GB_S = cast("SeriesGroupBy[float, int]", GB_DF.col1) -M = "M" if PD_LTE_21 else "ME" - def test_frame_groupby_resample() -> None: # basic check( - assert_type(GB_DF.resample(M), "_ResamplerGroupBy[DataFrame]"), + assert_type(GB_DF.resample("ME"), "_ResamplerGroupBy[DataFrame]"), DatetimeIndexResamplerGroupby, DataFrame, ) @@ -75,50 +73,54 @@ def test_frame_groupby_resample() -> None: ) # props - check(assert_type(GB_DF.resample(M).obj, DataFrame), DataFrame) - check(assert_type(GB_DF.resample(M).ax, Index), DatetimeIndex) + check(assert_type(GB_DF.resample("ME").obj, DataFrame), DataFrame) + check(assert_type(GB_DF.resample("ME").ax, Index), DatetimeIndex) # agg funcs with pytest_warns_bounded( DeprecationWarning, "DataFrameGroupBy.(apply|resample) operated on the grouping columns", ): - check(assert_type(GB_DF.resample(M).sum(), DataFrame), DataFrame) - check(assert_type(GB_DF.resample(M).prod(), DataFrame), DataFrame) - check(assert_type(GB_DF.resample(M).min(), DataFrame), DataFrame) - check(assert_type(GB_DF.resample(M).max(), DataFrame), DataFrame) - check(assert_type(GB_DF.resample(M).first(), DataFrame), DataFrame) - check(assert_type(GB_DF.resample(M).last(), DataFrame), DataFrame) - check(assert_type(GB_DF.resample(M).mean(), DataFrame), DataFrame) - check(assert_type(GB_DF.resample(M).sum(), DataFrame), DataFrame) - check(assert_type(GB_DF.resample(M).median(), DataFrame), DataFrame) - check(assert_type(GB_DF.resample(M).ohlc(), DataFrame), DataFrame) - check(assert_type(GB_DF.resample(M).nunique(), DataFrame), DataFrame) + check(assert_type(GB_DF.resample("ME").sum(), DataFrame), DataFrame) + check(assert_type(GB_DF.resample("ME").prod(), DataFrame), DataFrame) + check(assert_type(GB_DF.resample("ME").min(), DataFrame), DataFrame) + check(assert_type(GB_DF.resample("ME").max(), DataFrame), DataFrame) + check(assert_type(GB_DF.resample("ME").first(), DataFrame), DataFrame) + check(assert_type(GB_DF.resample("ME").last(), DataFrame), DataFrame) + check(assert_type(GB_DF.resample("ME").mean(), DataFrame), DataFrame) + check(assert_type(GB_DF.resample("ME").sum(), DataFrame), DataFrame) + check(assert_type(GB_DF.resample("ME").median(), DataFrame), DataFrame) + check(assert_type(GB_DF.resample("ME").ohlc(), DataFrame), DataFrame) + check(assert_type(GB_DF.resample("ME").nunique(), DataFrame), DataFrame) # quantile - check(assert_type(GB_DF.resample(M).quantile(0.5), DataFrame), DataFrame) - check(assert_type(GB_DF.resample(M).quantile([0.5, 0.7]), DataFrame), DataFrame) + check(assert_type(GB_DF.resample("ME").quantile(0.5), DataFrame), DataFrame) + check( + assert_type(GB_DF.resample("ME").quantile([0.5, 0.7]), DataFrame), DataFrame + ) check( - assert_type(GB_DF.resample(M).quantile(np.array([0.5, 0.7])), DataFrame), + assert_type(GB_DF.resample("ME").quantile(np.array([0.5, 0.7])), DataFrame), DataFrame, ) # std / var - check(assert_type(GB_DF.resample(M).std(), DataFrame), DataFrame) - check(assert_type(GB_DF.resample(M).var(2), DataFrame), DataFrame) + check(assert_type(GB_DF.resample("ME").std(), DataFrame), DataFrame) + check(assert_type(GB_DF.resample("ME").var(2), DataFrame), DataFrame) # size / count - check(assert_type(GB_DF.resample(M).size(), "Series[int]"), Series, np.integer) - check(assert_type(GB_DF.resample(M).count(), DataFrame), DataFrame) + check( + assert_type(GB_DF.resample("ME").size(), "Series[int]"), Series, np.integer + ) + check(assert_type(GB_DF.resample("ME").count(), DataFrame), DataFrame) # filling - check(assert_type(GB_DF.resample(M).ffill(), DataFrame), DataFrame) - check(assert_type(GB_DF.resample(M).nearest(), DataFrame), DataFrame) - check(assert_type(GB_DF.resample(M).bfill(), DataFrame), DataFrame) + check(assert_type(GB_DF.resample("ME").ffill(), DataFrame), DataFrame) + check(assert_type(GB_DF.resample("ME").nearest(), DataFrame), DataFrame) + check(assert_type(GB_DF.resample("ME").bfill(), DataFrame), DataFrame) # fillna (deprecated) if TYPE_CHECKING_INVALID_USAGE: - GB_DF.resample(M).fillna("ffill") # type: ignore[operator] # pyright: ignore + GB_DF.resample("ME").fillna("ffill") # type: ignore[operator] # pyright: ignore # aggregate / apply with pytest_warns_bounded( @@ -131,28 +133,33 @@ def test_frame_groupby_resample() -> None: lower="2.0.99", ): check( - assert_type(GB_DF.resample(M).aggregate(np.sum), DataFrame), DataFrame + assert_type(GB_DF.resample("ME").aggregate(np.sum), DataFrame), + DataFrame, ) - check(assert_type(GB_DF.resample(M).agg(np.sum), DataFrame), DataFrame) - check(assert_type(GB_DF.resample(M).apply(np.sum), DataFrame), DataFrame) + check(assert_type(GB_DF.resample("ME").agg(np.sum), DataFrame), DataFrame) + check(assert_type(GB_DF.resample("ME").apply(np.sum), DataFrame), DataFrame) check( - assert_type(GB_DF.resample(M).aggregate([np.sum, np.mean]), DataFrame), + assert_type( + GB_DF.resample("ME").aggregate([np.sum, np.mean]), DataFrame + ), DataFrame, ) check( - assert_type(GB_DF.resample(M).aggregate(["sum", np.mean]), DataFrame), + assert_type( + GB_DF.resample("ME").aggregate(["sum", np.mean]), DataFrame + ), DataFrame, ) check( assert_type( - GB_DF.resample(M).aggregate({"col1": "sum", "col2": np.mean}), + GB_DF.resample("ME").aggregate({"col1": "sum", "col2": np.mean}), DataFrame, ), DataFrame, ) check( assert_type( - GB_DF.resample(M).aggregate( + GB_DF.resample("ME").aggregate( {"col1": ["sum", np.mean], "col2": np.mean} ), DataFrame, @@ -167,7 +174,7 @@ def f(val: DataFrame) -> Series: DeprecationWarning, "DataFrameGroupBy.(apply|resample) operated on the grouping columns", ): - check(assert_type(GB_DF.resample(M).aggregate(f), DataFrame), DataFrame) + check(assert_type(GB_DF.resample("ME").aggregate(f), DataFrame), DataFrame) # aggregate combinations def df2frame(val: DataFrame) -> DataFrame: @@ -188,62 +195,65 @@ def df2scalar(val: DataFrame) -> float: r"The provided callable is currently using ", lower="2.0.99", ): - check(GB_DF.resample(M).aggregate(np.sum), DataFrame) - check(GB_DF.resample(M).aggregate([np.mean]), DataFrame) - check(GB_DF.resample(M).aggregate(["sum", np.mean]), DataFrame) - check(GB_DF.resample(M).aggregate({"col1": np.sum}), DataFrame) + check(GB_DF.resample("ME").aggregate(np.sum), DataFrame) + check(GB_DF.resample("ME").aggregate([np.mean]), DataFrame) + check(GB_DF.resample("ME").aggregate(["sum", np.mean]), DataFrame) + check(GB_DF.resample("ME").aggregate({"col1": np.sum}), DataFrame) check( - GB_DF.resample(M).aggregate({"col1": np.sum, "col2": np.mean}), + GB_DF.resample("ME").aggregate({"col1": np.sum, "col2": np.mean}), DataFrame, ) check( - GB_DF.resample(M).aggregate( + GB_DF.resample("ME").aggregate( {"col1": [np.sum], "col2": ["sum", np.mean]} ), DataFrame, ) check( - GB_DF.resample(M).aggregate({"col1": np.sum, "col2": ["sum", np.mean]}), + GB_DF.resample("ME").aggregate( + {"col1": np.sum, "col2": ["sum", np.mean]} + ), DataFrame, ) check( - GB_DF.resample(M).aggregate({"col1": "sum", "col2": [np.mean]}), + GB_DF.resample("ME").aggregate({"col1": "sum", "col2": [np.mean]}), DataFrame, ) - check(GB_DF.resample(M).aggregate("sum"), DataFrame) - check(GB_DF.resample(M).aggregate(df2frame), DataFrame) - check(GB_DF.resample(M).aggregate(df2series), DataFrame) - check(GB_DF.resample(M).aggregate(df2scalar), DataFrame) + check(GB_DF.resample("ME").aggregate("sum"), DataFrame) + check(GB_DF.resample("ME").aggregate(df2frame), DataFrame) + check(GB_DF.resample("ME").aggregate(df2series), DataFrame) + check(GB_DF.resample("ME").aggregate(df2scalar), DataFrame) # asfreq - check(assert_type(GB_DF.resample(M).asfreq(-1.0), DataFrame), DataFrame) + check(assert_type(GB_DF.resample("ME").asfreq(-1.0), DataFrame), DataFrame) # getattr check( - assert_type(GB_DF.resample(M).col1, "_ResamplerGroupBy[DataFrame]"), + assert_type(GB_DF.resample("ME").col1, "_ResamplerGroupBy[DataFrame]"), DatetimeIndexResamplerGroupby, ) # getitem check( - assert_type(GB_DF.resample(M)["col1"], "_ResamplerGroupBy[DataFrame]"), + assert_type(GB_DF.resample("ME")["col1"], "_ResamplerGroupBy[DataFrame]"), DatetimeIndexResamplerGroupby, ) check( assert_type( - GB_DF.resample(M)[["col1", "col2"]], "_ResamplerGroupBy[DataFrame]" + GB_DF.resample("ME")[["col1", "col2"]], "_ResamplerGroupBy[DataFrame]" ), DatetimeIndexResamplerGroupby, ) # interpolate - check(assert_type(GB_DF.resample(M).interpolate(), DataFrame), DataFrame) + check(assert_type(GB_DF.resample("ME").interpolate(), DataFrame), DataFrame) check( - assert_type(GB_DF.resample(M).interpolate(method="linear"), DataFrame), + assert_type(GB_DF.resample("ME").interpolate(method="linear"), DataFrame), DataFrame, ) check( - assert_type(GB_DF.resample(M).interpolate(inplace=True), None), type(None) + assert_type(GB_DF.resample("ME").interpolate(inplace=True), None), + type(None), ) # pipe @@ -251,80 +261,84 @@ def g(val: Resampler[DataFrame]) -> DataFrame: assert isinstance(val, Resampler) return val.mean() - check(assert_type(GB_DF.resample(M).pipe(g), DataFrame), DataFrame) + check(assert_type(GB_DF.resample("ME").pipe(g), DataFrame), DataFrame) def h(val: Resampler[DataFrame]) -> Series: assert isinstance(val, Resampler) return val.mean().mean() - check(assert_type(GB_DF.resample(M).pipe(h), Series), Series) + check(assert_type(GB_DF.resample("ME").pipe(h), Series), Series) def i(val: Resampler[DataFrame]) -> float: assert isinstance(val, Resampler) return float(val.mean().mean().mean()) - check(assert_type(GB_DF.resample(M).pipe(i), float), float) + check(assert_type(GB_DF.resample("ME").pipe(i), float), float) # transform def j(val: Series) -> Series: return -1 * val - check(assert_type(GB_DF.resample(M).transform(j), DataFrame), DataFrame) + check(assert_type(GB_DF.resample("ME").transform(j), DataFrame), DataFrame) def test_series_groupby_resample() -> None: # basic check( - assert_type(GB_S.resample(M), "_ResamplerGroupBy[Series[float]]"), + assert_type(GB_S.resample("ME"), "_ResamplerGroupBy[Series[float]]"), DatetimeIndexResamplerGroupby, Series, ) # props - check(assert_type(GB_S.resample(M).obj, "Series[float]"), Series, float) - check(assert_type(GB_S.resample(M).ax, Index), DatetimeIndex) + check(assert_type(GB_S.resample("ME").obj, "Series[float]"), Series, float) + check(assert_type(GB_S.resample("ME").ax, Index), DatetimeIndex) # agg funcs - check(assert_type(GB_S.resample(M).sum(), "Series[float]"), Series, float) - check(assert_type(GB_S.resample(M).prod(), "Series[float]"), Series, float) - check(assert_type(GB_S.resample(M).min(), "Series[float]"), Series, float) - check(assert_type(GB_S.resample(M).max(), "Series[float]"), Series, float) - check(assert_type(GB_S.resample(M).first(), "Series[float]"), Series, float) - check(assert_type(GB_S.resample(M).last(), "Series[float]"), Series, float) - check(assert_type(GB_S.resample(M).mean(), "Series[float]"), Series, float) - check(assert_type(GB_S.resample(M).sum(), "Series[float]"), Series, float) - check(assert_type(GB_S.resample(M).median(), "Series[float]"), Series, float) - check(assert_type(GB_S.resample(M).ohlc(), DataFrame), DataFrame) - check(assert_type(GB_S.resample(M).nunique(), "Series[int]"), Series, np.integer) + check(assert_type(GB_S.resample("ME").sum(), "Series[float]"), Series, float) + check(assert_type(GB_S.resample("ME").prod(), "Series[float]"), Series, float) + check(assert_type(GB_S.resample("ME").min(), "Series[float]"), Series, float) + check(assert_type(GB_S.resample("ME").max(), "Series[float]"), Series, float) + check(assert_type(GB_S.resample("ME").first(), "Series[float]"), Series, float) + check(assert_type(GB_S.resample("ME").last(), "Series[float]"), Series, float) + check(assert_type(GB_S.resample("ME").mean(), "Series[float]"), Series, float) + check(assert_type(GB_S.resample("ME").sum(), "Series[float]"), Series, float) + check(assert_type(GB_S.resample("ME").median(), "Series[float]"), Series, float) + check(assert_type(GB_S.resample("ME").ohlc(), DataFrame), DataFrame) + check(assert_type(GB_S.resample("ME").nunique(), "Series[int]"), Series, np.integer) # quantile - check(assert_type(GB_S.resample(M).quantile(0.5), "Series[float]"), Series, float) check( - assert_type(GB_S.resample(M).quantile([0.5, 0.7]), "Series[float]"), + assert_type(GB_S.resample("ME").quantile(0.5), "Series[float]"), Series, float + ) + check( + assert_type(GB_S.resample("ME").quantile([0.5, 0.7]), "Series[float]"), Series, float, ) check( - assert_type(GB_S.resample(M).quantile(np.array([0.5, 0.7])), "Series[float]"), + assert_type( + GB_S.resample("ME").quantile(np.array([0.5, 0.7])), "Series[float]" + ), Series, ) # std / var - check(assert_type(GB_S.resample(M).std(), "Series[float]"), Series, float) - check(assert_type(GB_S.resample(M).var(2), "Series[float]"), Series, float) + check(assert_type(GB_S.resample("ME").std(), "Series[float]"), Series, float) + check(assert_type(GB_S.resample("ME").var(2), "Series[float]"), Series, float) # size / count - check(assert_type(GB_S.resample(M).size(), "Series[int]"), Series, np.integer) - check(assert_type(GB_S.resample(M).count(), "Series[int]"), Series, np.integer) + check(assert_type(GB_S.resample("ME").size(), "Series[int]"), Series, np.integer) + check(assert_type(GB_S.resample("ME").count(), "Series[int]"), Series, np.integer) # filling - check(assert_type(GB_S.resample(M).ffill(), "Series[float]"), Series, float) - check(assert_type(GB_S.resample(M).nearest(), "Series[float]"), Series, float) - check(assert_type(GB_S.resample(M).bfill(), "Series[float]"), Series, float) + check(assert_type(GB_S.resample("ME").ffill(), "Series[float]"), Series, float) + check(assert_type(GB_S.resample("ME").nearest(), "Series[float]"), Series, float) + check(assert_type(GB_S.resample("ME").bfill(), "Series[float]"), Series, float) # fillna (deprecated) if TYPE_CHECKING_INVALID_USAGE: - GB_S.resample(M).fillna("ffill") # type: ignore[operator] # pyright: ignore + GB_S.resample("ME").fillna("ffill") # type: ignore[operator] # pyright: ignore # aggregate with pytest_warns_bounded( @@ -333,31 +347,36 @@ def test_series_groupby_resample() -> None: lower="2.0.99", ): check( - assert_type(GB_S.resample(M).aggregate(np.sum), Union[DataFrame, Series]), + assert_type( + GB_S.resample("ME").aggregate(np.sum), Union[DataFrame, Series] + ), Series, ) check( - assert_type(GB_S.resample(M).agg(np.sum), Union[DataFrame, Series]), Series + assert_type(GB_S.resample("ME").agg(np.sum), Union[DataFrame, Series]), + Series, ) check( - assert_type(GB_S.resample(M).apply(np.sum), Union[DataFrame, Series]), + assert_type(GB_S.resample("ME").apply(np.sum), Union[DataFrame, Series]), Series, ) check( assert_type( - GB_S.resample(M).aggregate([np.sum, np.mean]), Union[DataFrame, Series] + GB_S.resample("ME").aggregate([np.sum, np.mean]), + Union[DataFrame, Series], ), DataFrame, ) check( assert_type( - GB_S.resample(M).aggregate(["sum", np.mean]), Union[DataFrame, Series] + GB_S.resample("ME").aggregate(["sum", np.mean]), + Union[DataFrame, Series], ), DataFrame, ) check( assert_type( - GB_S.resample(M).aggregate({"col1": "sum", "col2": np.mean}), + GB_S.resample("ME").aggregate({"col1": "sum", "col2": np.mean}), Union[DataFrame, Series], ), DataFrame, @@ -366,27 +385,31 @@ def test_series_groupby_resample() -> None: def f(val: Series) -> float: return val.mean() - check(assert_type(GB_S.resample(M).aggregate(f), Union[DataFrame, Series]), Series) + check( + assert_type(GB_S.resample("ME").aggregate(f), Union[DataFrame, Series]), Series + ) # asfreq - check(assert_type(GB_S.resample(M).asfreq(-1.0), "Series[float]"), Series, float) + check(assert_type(GB_S.resample("ME").asfreq(-1.0), "Series[float]"), Series, float) # interpolate - check(assert_type(GB_S.resample(M).interpolate(), "Series[float]"), Series, float) - check(assert_type(GB_S.resample(M).interpolate(inplace=True), None), type(None)) + check( + assert_type(GB_S.resample("ME").interpolate(), "Series[float]"), Series, float + ) + check(assert_type(GB_S.resample("ME").interpolate(inplace=True), None), type(None)) # pipe def g(val: Resampler[Series]) -> float: assert isinstance(val, Resampler) return float(val.mean().mean()) - check(assert_type(GB_S.resample(M).pipe(g), float), float) + check(assert_type(GB_S.resample("ME").pipe(g), float), float) # transform def h(val: Series) -> Series: return -1 * val - check(assert_type(GB_S.resample(M).transform(h), Series), Series) + check(assert_type(GB_S.resample("ME").transform(h), Series), Series) # aggregate combinations def s2series(val: Series) -> Series: @@ -400,14 +423,16 @@ def s2scalar(val: Series) -> float: r"The provided callable is currently using ", lower="2.0.99", ): - check(GB_S.resample(M).aggregate(np.sum), Series) - check(GB_S.resample(M).aggregate([np.mean]), DataFrame) - check(GB_S.resample(M).aggregate(["sum", np.mean]), DataFrame) - check(GB_S.resample(M).aggregate({"sum": np.sum}), DataFrame) - check(GB_S.resample(M).aggregate({"sum": np.sum, "mean": np.mean}), DataFrame) - check(GB_S.resample(M).aggregate("sum"), Series) - check(GB_S.resample(M).aggregate(s2series), Series) - check(GB_S.resample(M).aggregate(s2scalar), Series) + check(GB_S.resample("ME").aggregate(np.sum), Series) + check(GB_S.resample("ME").aggregate([np.mean]), DataFrame) + check(GB_S.resample("ME").aggregate(["sum", np.mean]), DataFrame) + check(GB_S.resample("ME").aggregate({"sum": np.sum}), DataFrame) + check( + GB_S.resample("ME").aggregate({"sum": np.sum, "mean": np.mean}), DataFrame + ) + check(GB_S.resample("ME").aggregate("sum"), Series) + check(GB_S.resample("ME").aggregate(s2series), Series) + check(GB_S.resample("ME").aggregate(s2scalar), Series) def test_frame_groupby_rolling() -> None: @@ -422,7 +447,8 @@ def test_frame_groupby_rolling() -> None: check(assert_type(GB_DF.rolling(1).obj, DataFrame), DataFrame) check(assert_type(GB_DF.rolling(1).on, Union[str, Index, None]), type(None)) check(assert_type(GB_DF.rolling(1).method, Literal["single", "table"]), str) - check(assert_type(GB_DF.rolling(1).axis, int), int) + if PD_LTE_22: + check(assert_type(GB_DF.rolling(1).axis, int), int) # agg funcs check(assert_type(GB_DF.rolling(1).sum(), DataFrame), DataFrame) @@ -616,7 +642,8 @@ def test_frame_groupby_expanding() -> None: check(assert_type(GB_DF.expanding(1).obj, DataFrame), DataFrame) check(assert_type(GB_DF.expanding(1).on, Union[str, Index, None]), type(None)) check(assert_type(GB_DF.expanding(1).method, Literal["single", "table"]), str) - check(assert_type(GB_DF.expanding(1).axis, int), int) + if PD_LTE_22: + check(assert_type(GB_DF.expanding(1).axis, int), int) # agg funcs check(assert_type(GB_DF.expanding(1).sum(), DataFrame), DataFrame) @@ -814,7 +841,8 @@ def test_frame_groupby_ewm() -> None: check(assert_type(GB_DF.ewm(1).obj, DataFrame), DataFrame) check(assert_type(GB_DF.ewm(1).on, Union[str, Index, None]), type(None)) check(assert_type(GB_DF.ewm(1).method, Literal["single", "table"]), str) - check(assert_type(GB_DF.ewm(1).axis, int), int) + if PD_LTE_22: + check(assert_type(GB_DF.ewm(1).axis, int), int) # agg funcs check(assert_type(GB_DF.ewm(1).sum(), DataFrame), DataFrame) diff --git a/tests/test_io.py b/tests/test_io.py index e4f309a11..f2bcb21da 100644 --- a/tests/test_io.py +++ b/tests/test_io.py @@ -49,6 +49,7 @@ from typing_extensions import assert_type from tests import ( + PD_LTE_22, TYPE_CHECKING_INVALID_USAGE, WINDOWS, check, @@ -427,10 +428,15 @@ def test_hdf_series(): def test_spss(): + if PD_LTE_22: + warning_class = FutureWarning + message = "ChainedAssignmentError: behaviour will change" + else: + warning_class = pd.errors.ChainedAssignmentError # type: ignore[attr-defined] # pyright: ignore[reportAttributeAccessIssue] + message = "A value is trying to be set on a copy of a DataFrame" + path = Path(CWD, "data", "labelled-num.sav") - with pytest_warns_bounded( - FutureWarning, "ChainedAssignmentError: behaviour will change", lower="2.1.99" - ): + with pytest_warns_bounded(warning_class, message): check( assert_type(read_spss(path, convert_categoricals=True), DataFrame), DataFrame, diff --git a/tests/test_pandas.py b/tests/test_pandas.py index c3760aa0c..ba154a8fb 100644 --- a/tests/test_pandas.py +++ b/tests/test_pandas.py @@ -605,15 +605,6 @@ def test_to_numeric_array_like() -> None: ), np.ndarray, ) - with pytest_warns_bounded( - FutureWarning, "errors='ignore' is deprecated", lower="2.1.99" - ): - check( - assert_type( - pd.to_numeric([1.0, 2.0, "blerg"], errors="ignore"), npt.NDArray - ), - np.ndarray, - ) check( assert_type( pd.to_numeric((1.0, 2.0, 3.0)), @@ -642,15 +633,6 @@ def test_to_numeric_array_series() -> None: ), pd.Series, ) - with pytest_warns_bounded( - FutureWarning, "errors='ignore' is deprecated", lower="2.1.99" - ): - check( - assert_type( - pd.to_numeric(pd.Series([1, 2, "blerg"]), errors="ignore"), pd.Series - ), - pd.Series, - ) check( assert_type(pd.to_numeric(pd.Series([1, 2, 3]), downcast="signed"), pd.Series), pd.Series, diff --git a/tests/test_resampler.py b/tests/test_resampler.py index 75742725c..be7108b8d 100644 --- a/tests/test_resampler.py +++ b/tests/test_resampler.py @@ -21,7 +21,6 @@ from typing_extensions import assert_type from tests import ( - PD_LTE_21, TYPE_CHECKING_INVALID_USAGE, check, pytest_warns_bounded, @@ -35,68 +34,61 @@ _AggRetType = Union[DataFrame, Series] -if PD_LTE_21: - MonthFreq = "M" -else: - MonthFreq = "ME" - def test_props() -> None: - check(assert_type(DF.resample(MonthFreq).obj, DataFrame), DataFrame) - check(assert_type(DF.resample(MonthFreq).ax, Index), DatetimeIndex) + check(assert_type(DF.resample("ME").obj, DataFrame), DataFrame) + check(assert_type(DF.resample("ME").ax, Index), DatetimeIndex) def test_iter() -> None: - assert_type(iter(DF.resample(MonthFreq)), Iterator[tuple[Hashable, DataFrame]]) - for v in DF.resample(MonthFreq): + assert_type(iter(DF.resample("ME")), Iterator[tuple[Hashable, DataFrame]]) + for v in DF.resample("ME"): check(assert_type(v, tuple[Hashable, DataFrame]), tuple) def test_agg_funcs() -> None: - check(assert_type(DF.resample(MonthFreq).sum(), DataFrame), DataFrame) - check(assert_type(DF.resample(MonthFreq).prod(), DataFrame), DataFrame) - check(assert_type(DF.resample(MonthFreq).min(), DataFrame), DataFrame) - check(assert_type(DF.resample(MonthFreq).max(), DataFrame), DataFrame) - check(assert_type(DF.resample(MonthFreq).first(), DataFrame), DataFrame) - check(assert_type(DF.resample(MonthFreq).last(), DataFrame), DataFrame) - check(assert_type(DF.resample(MonthFreq).mean(), DataFrame), DataFrame) - check(assert_type(DF.resample(MonthFreq).sum(), DataFrame), DataFrame) - check(assert_type(DF.resample(MonthFreq).median(), DataFrame), DataFrame) - check(assert_type(DF.resample(MonthFreq).ohlc(), DataFrame), DataFrame) - check(assert_type(DF.resample(MonthFreq).nunique(), DataFrame), DataFrame) + check(assert_type(DF.resample("ME").sum(), DataFrame), DataFrame) + check(assert_type(DF.resample("ME").prod(), DataFrame), DataFrame) + check(assert_type(DF.resample("ME").min(), DataFrame), DataFrame) + check(assert_type(DF.resample("ME").max(), DataFrame), DataFrame) + check(assert_type(DF.resample("ME").first(), DataFrame), DataFrame) + check(assert_type(DF.resample("ME").last(), DataFrame), DataFrame) + check(assert_type(DF.resample("ME").mean(), DataFrame), DataFrame) + check(assert_type(DF.resample("ME").sum(), DataFrame), DataFrame) + check(assert_type(DF.resample("ME").median(), DataFrame), DataFrame) + check(assert_type(DF.resample("ME").ohlc(), DataFrame), DataFrame) + check(assert_type(DF.resample("ME").nunique(), DataFrame), DataFrame) def test_quantile() -> None: - check(assert_type(DF.resample(MonthFreq).quantile(0.5), DataFrame), DataFrame) - check( - assert_type(DF.resample(MonthFreq).quantile([0.5, 0.7]), DataFrame), DataFrame - ) + check(assert_type(DF.resample("ME").quantile(0.5), DataFrame), DataFrame) + check(assert_type(DF.resample("ME").quantile([0.5, 0.7]), DataFrame), DataFrame) check( - assert_type(DF.resample(MonthFreq).quantile(np.array([0.5, 0.7])), DataFrame), + assert_type(DF.resample("ME").quantile(np.array([0.5, 0.7])), DataFrame), DataFrame, ) def test_std_var() -> None: - check(assert_type(DF.resample(MonthFreq).std(), DataFrame), DataFrame) - check(assert_type(DF.resample(MonthFreq).var(2), DataFrame), DataFrame) + check(assert_type(DF.resample("ME").std(), DataFrame), DataFrame) + check(assert_type(DF.resample("ME").var(2), DataFrame), DataFrame) def test_size_count() -> None: - check(assert_type(DF.resample(MonthFreq).size(), "Series[int]"), Series, np.integer) - check(assert_type(DF.resample(MonthFreq).count(), DataFrame), DataFrame) + check(assert_type(DF.resample("ME").size(), "Series[int]"), Series, np.integer) + check(assert_type(DF.resample("ME").count(), DataFrame), DataFrame) def test_filling() -> None: - check(assert_type(DF.resample(MonthFreq).ffill(), DataFrame), DataFrame) - check(assert_type(DF.resample(MonthFreq).nearest(), DataFrame), DataFrame) - check(assert_type(DF.resample(MonthFreq).bfill(), DataFrame), DataFrame) + check(assert_type(DF.resample("ME").ffill(), DataFrame), DataFrame) + check(assert_type(DF.resample("ME").nearest(), DataFrame), DataFrame) + check(assert_type(DF.resample("ME").bfill(), DataFrame), DataFrame) def test_fillna() -> None: # deprecated (and removed from stub) if TYPE_CHECKING_INVALID_USAGE: - DF.resample(MonthFreq).fillna("pad") # type: ignore[operator] # pyright: ignore + DF.resample("ME").fillna("pad") # type: ignore[operator] # pyright: ignore def test_aggregate() -> None: @@ -105,29 +97,27 @@ def test_aggregate() -> None: r"The provided callable is currently using ", lower="2.0.99", ): + check(assert_type(DF.resample("ME").aggregate(np.sum), DataFrame), DataFrame) + check(assert_type(DF.resample("ME").agg(np.sum), DataFrame), DataFrame) + check(assert_type(DF.resample("ME").apply(np.sum), DataFrame), DataFrame) check( - assert_type(DF.resample(MonthFreq).aggregate(np.sum), DataFrame), DataFrame - ) - check(assert_type(DF.resample(MonthFreq).agg(np.sum), DataFrame), DataFrame) - check(assert_type(DF.resample(MonthFreq).apply(np.sum), DataFrame), DataFrame) - check( - assert_type(DF.resample(MonthFreq).aggregate([np.sum, np.mean]), DataFrame), + assert_type(DF.resample("ME").aggregate([np.sum, np.mean]), DataFrame), DataFrame, ) check( - assert_type(DF.resample(MonthFreq).aggregate(["sum", np.mean]), DataFrame), + assert_type(DF.resample("ME").aggregate(["sum", np.mean]), DataFrame), DataFrame, ) check( assert_type( - DF.resample(MonthFreq).aggregate({"col1": "sum", "col2": np.mean}), + DF.resample("ME").aggregate({"col1": "sum", "col2": np.mean}), DataFrame, ), DataFrame, ) check( assert_type( - DF.resample(MonthFreq).aggregate( + DF.resample("ME").aggregate( {"col1": ["sum", np.mean], "col2": np.mean} ), DataFrame, @@ -138,29 +128,27 @@ def test_aggregate() -> None: def f(val: DataFrame) -> Series: return val.mean() - check(assert_type(DF.resample(MonthFreq).aggregate(f), DataFrame), DataFrame) + check(assert_type(DF.resample("ME").aggregate(f), DataFrame), DataFrame) def test_asfreq() -> None: - check(assert_type(DF.resample(MonthFreq).asfreq(-1.0), DataFrame), DataFrame) + check(assert_type(DF.resample("ME").asfreq(-1.0), DataFrame), DataFrame) def test_getattr() -> None: - check(assert_type(DF.resample(MonthFreq).col1, SeriesGroupBy), SeriesGroupBy) + check(assert_type(DF.resample("ME").col1, SeriesGroupBy), SeriesGroupBy) def test_interpolate() -> None: - check(assert_type(DF.resample(MonthFreq).interpolate(), DataFrame), DataFrame) + check(assert_type(DF.resample("ME").interpolate(), DataFrame), DataFrame) check( - assert_type(DF.resample(MonthFreq).interpolate(method="time"), DataFrame), + assert_type(DF.resample("ME").interpolate(method="time"), DataFrame), DataFrame, ) def test_interpolate_inplace() -> None: - check( - assert_type(DF.resample(MonthFreq).interpolate(inplace=True), None), type(None) - ) + check(assert_type(DF.resample("ME").interpolate(inplace=True), None), type(None)) def test_pipe() -> None: @@ -168,25 +156,25 @@ def f(val: "DatetimeIndexResampler[DataFrame]") -> DataFrame: assert isinstance(val, DatetimeIndexResampler) return DataFrame(val) - check(assert_type(DF.resample(MonthFreq).pipe(f), DataFrame), DataFrame) + check(assert_type(DF.resample("ME").pipe(f), DataFrame), DataFrame) def g(val: "DatetimeIndexResampler[DataFrame]") -> DataFrame: assert isinstance(val, DatetimeIndexResampler) return val.mean() - check(assert_type(DF.resample(MonthFreq).pipe(g), DataFrame), DataFrame) + check(assert_type(DF.resample("ME").pipe(g), DataFrame), DataFrame) def h(val: "DatetimeIndexResampler[DataFrame]") -> Series: assert isinstance(val, DatetimeIndexResampler) return val.mean().mean() - check(assert_type(DF.resample(MonthFreq).pipe(h), Series), Series) + check(assert_type(DF.resample("ME").pipe(h), Series), Series) def i(val: "DatetimeIndexResampler[DataFrame]") -> float: assert isinstance(val, DatetimeIndexResampler) return float(val.mean().mean().mean()) - check(assert_type(DF.resample(MonthFreq).pipe(i), float), float) + check(assert_type(DF.resample("ME").pipe(i), float), float) def j( res: "DatetimeIndexResampler[DataFrame]", @@ -201,56 +189,54 @@ def j( return res.obj check( - assert_type( - DF.resample(MonthFreq).pipe(j, 1, [1.0], arg2="hi", kw=(1,)), DataFrame - ), + assert_type(DF.resample("ME").pipe(j, 1, [1.0], arg2="hi", kw=(1,)), DataFrame), DataFrame, ) if TYPE_CHECKING_INVALID_USAGE: - DF.resample(MonthFreq).pipe( + DF.resample("ME").pipe( j, "a", # type: ignore[arg-type] # pyright: ignore[reportArgumentType,reportCallIssue] [1.0, 2.0], arg2="hi", kw=(1,), ) - DF.resample(MonthFreq).pipe( + DF.resample("ME").pipe( j, 1, [1.0, "b"], # type: ignore[list-item] # pyright: ignore[reportArgumentType,reportCallIssue] arg2="hi", kw=(1,), ) - DF.resample(MonthFreq).pipe( + DF.resample("ME").pipe( j, 1, [1.0], arg2=11, # type: ignore[arg-type] # pyright: ignore[reportArgumentType,reportCallIssue] kw=(1,), ) - DF.resample(MonthFreq).pipe( + DF.resample("ME").pipe( j, 1, [1.0], arg2="hi", kw=(1, 2), # type: ignore[arg-type] # pyright: ignore[reportArgumentType,reportCallIssue] ) - DF.resample(MonthFreq).pipe( # type: ignore[call-arg] + DF.resample("ME").pipe( # type: ignore[call-arg] j, 1, [1.0], arg3="hi", # pyright: ignore[reportCallIssue] kw=(1,), ) - DF.resample(MonthFreq).pipe( # type: ignore[misc] + DF.resample("ME").pipe( # type: ignore[misc] j, 1, [1.0], 11, # type: ignore[arg-type] (1,), # pyright: ignore[reportCallIssue] ) - DF.resample(MonthFreq).pipe( # type: ignore[call-arg] + DF.resample("ME").pipe( # type: ignore[call-arg] j, pos=1, # pyright: ignore[reportCallIssue] arg1=[1.0], @@ -262,10 +248,10 @@ def k(x: int, t: "DatetimeIndexResampler[DataFrame]") -> DataFrame: assert isinstance(x, int) return t.obj - check(assert_type(DF.resample(MonthFreq).pipe((k, "t"), 1), DataFrame), DataFrame) + check(assert_type(DF.resample("ME").pipe((k, "t"), 1), DataFrame), DataFrame) if TYPE_CHECKING_INVALID_USAGE: - DF.resample(MonthFreq).pipe( # pyright: ignore[reportCallIssue] + DF.resample("ME").pipe( # pyright: ignore[reportCallIssue] (k, 1), # type: ignore[arg-type] # pyright: ignore[reportArgumentType] 1, ) @@ -275,64 +261,62 @@ def test_transform() -> None: def f(val: Series) -> Series: return -1 * val - check(assert_type(DF.resample(MonthFreq).transform(f), DataFrame), DataFrame) + check(assert_type(DF.resample("ME").transform(f), DataFrame), DataFrame) def test_props_series() -> None: - check(assert_type(S.resample(MonthFreq).obj, Series), Series) - check(assert_type(S.resample(MonthFreq).ax, Index), DatetimeIndex) + check(assert_type(S.resample("ME").obj, Series), Series) + check(assert_type(S.resample("ME").ax, Index), DatetimeIndex) def test_iter_series() -> None: - for v in S.resample(MonthFreq): + for v in S.resample("ME"): check(assert_type(v, tuple[Hashable, Series]), tuple) def test_agg_funcs_series() -> None: - check(assert_type(S.resample(MonthFreq).sum(), Series), Series) - check(assert_type(S.resample(MonthFreq).prod(), Series), Series) - check(assert_type(S.resample(MonthFreq).min(), Series), Series) - check(assert_type(S.resample(MonthFreq).max(), Series), Series) - check(assert_type(S.resample(MonthFreq).first(), Series), Series) - check(assert_type(S.resample(MonthFreq).last(), Series), Series) - check(assert_type(S.resample(MonthFreq).mean(), Series), Series) - check(assert_type(S.resample(MonthFreq).sum(), Series), Series) - check(assert_type(S.resample(MonthFreq).median(), Series), Series) - check(assert_type(S.resample(MonthFreq).ohlc(), DataFrame), DataFrame) - check( - assert_type(S.resample(MonthFreq).nunique(), "Series[int]"), Series, np.integer - ) + check(assert_type(S.resample("ME").sum(), Series), Series) + check(assert_type(S.resample("ME").prod(), Series), Series) + check(assert_type(S.resample("ME").min(), Series), Series) + check(assert_type(S.resample("ME").max(), Series), Series) + check(assert_type(S.resample("ME").first(), Series), Series) + check(assert_type(S.resample("ME").last(), Series), Series) + check(assert_type(S.resample("ME").mean(), Series), Series) + check(assert_type(S.resample("ME").sum(), Series), Series) + check(assert_type(S.resample("ME").median(), Series), Series) + check(assert_type(S.resample("ME").ohlc(), DataFrame), DataFrame) + check(assert_type(S.resample("ME").nunique(), "Series[int]"), Series, np.integer) def test_quantile_series() -> None: - check(assert_type(S.resample(MonthFreq).quantile(0.5), Series), Series) - check(assert_type(S.resample(MonthFreq).quantile([0.5, 0.7]), Series), Series) + check(assert_type(S.resample("ME").quantile(0.5), Series), Series) + check(assert_type(S.resample("ME").quantile([0.5, 0.7]), Series), Series) check( - assert_type(S.resample(MonthFreq).quantile(np.array([0.5, 0.7])), Series), + assert_type(S.resample("ME").quantile(np.array([0.5, 0.7])), Series), Series, ) def test_std_var_series() -> None: - check(assert_type(S.resample(MonthFreq).std(), Series), Series) - check(assert_type(S.resample(MonthFreq).var(2), Series), Series) + check(assert_type(S.resample("ME").std(), Series), Series) + check(assert_type(S.resample("ME").var(2), Series), Series) def test_size_count_series() -> None: - check(assert_type(S.resample(MonthFreq).size(), "Series[int]"), Series, np.integer) - check(assert_type(S.resample(MonthFreq).count(), "Series[int]"), Series, np.integer) + check(assert_type(S.resample("ME").size(), "Series[int]"), Series, np.integer) + check(assert_type(S.resample("ME").count(), "Series[int]"), Series, np.integer) def test_filling_series() -> None: - check(assert_type(S.resample(MonthFreq).ffill(), Series), Series) - check(assert_type(S.resample(MonthFreq).nearest(), Series), Series) - check(assert_type(S.resample(MonthFreq).bfill(), Series), Series) + check(assert_type(S.resample("ME").ffill(), Series), Series) + check(assert_type(S.resample("ME").nearest(), Series), Series) + check(assert_type(S.resample("ME").bfill(), Series), Series) def test_fillna_series() -> None: # deprecated (and removed from stub) if TYPE_CHECKING_INVALID_USAGE: - S.resample(MonthFreq).fillna("pad") # type: ignore[operator] # pyright: ignore + S.resample("ME").fillna("pad") # type: ignore[operator] # pyright: ignore def test_aggregate_series() -> None: @@ -341,22 +325,20 @@ def test_aggregate_series() -> None: r"The provided callable is currently using ", lower="2.0.99", ): - check(assert_type(S.resample(MonthFreq).aggregate(np.sum), _AggRetType), Series) - check(assert_type(S.resample(MonthFreq).agg(np.sum), _AggRetType), Series) - check(assert_type(S.resample(MonthFreq).apply(np.sum), _AggRetType), Series) + check(assert_type(S.resample("ME").aggregate(np.sum), _AggRetType), Series) + check(assert_type(S.resample("ME").agg(np.sum), _AggRetType), Series) + check(assert_type(S.resample("ME").apply(np.sum), _AggRetType), Series) check( - assert_type( - S.resample(MonthFreq).aggregate([np.sum, np.mean]), _AggRetType - ), + assert_type(S.resample("ME").aggregate([np.sum, np.mean]), _AggRetType), DataFrame, ) check( - assert_type(S.resample(MonthFreq).aggregate(["sum", np.mean]), _AggRetType), + assert_type(S.resample("ME").aggregate(["sum", np.mean]), _AggRetType), DataFrame, ) check( assert_type( - S.resample(MonthFreq).aggregate({"col1": "sum", "col2": np.mean}), + S.resample("ME").aggregate({"col1": "sum", "col2": np.mean}), _AggRetType, ), DataFrame, @@ -365,22 +347,20 @@ def test_aggregate_series() -> None: def f(val: Series) -> float: return val.mean() - check(assert_type(S.resample(MonthFreq).aggregate(f), _AggRetType), Series) + check(assert_type(S.resample("ME").aggregate(f), _AggRetType), Series) def test_asfreq_series() -> None: - check(assert_type(S.resample(MonthFreq).asfreq(-1.0), Series), Series) + check(assert_type(S.resample("ME").asfreq(-1.0), Series), Series) def test_interpolate_series() -> None: - check(assert_type(S.resample(MonthFreq).interpolate(), Series), Series) - check(assert_type(S.resample(MonthFreq).interpolate(method="time"), Series), Series) + check(assert_type(S.resample("ME").interpolate(), Series), Series) + check(assert_type(S.resample("ME").interpolate(method="time"), Series), Series) def test_interpolate_inplace_series() -> None: - check( - assert_type(S.resample(MonthFreq).interpolate(inplace=True), None), type(None) - ) + check(assert_type(S.resample("ME").interpolate(inplace=True), None), type(None)) def test_pipe_series() -> None: @@ -388,26 +368,26 @@ def f(val: "DatetimeIndexResampler[Series]") -> Series: assert isinstance(val, DatetimeIndexResampler) return Series(val) - check(assert_type(S.resample(MonthFreq).pipe(f), Series), Series) + check(assert_type(S.resample("ME").pipe(f), Series), Series) def g(val: "DatetimeIndexResampler[Series]") -> float: assert isinstance(val, DatetimeIndexResampler) return float(val.mean().mean()) - check(assert_type(S.resample(MonthFreq).pipe(g), float), float) + check(assert_type(S.resample("ME").pipe(g), float), float) def h(val: "DatetimeIndexResampler[Series]") -> DataFrame: assert isinstance(val, DatetimeIndexResampler) return DataFrame({0: val, 1: val}) - check(assert_type(S.resample(MonthFreq).pipe(h), DataFrame), DataFrame) + check(assert_type(S.resample("ME").pipe(h), DataFrame), DataFrame) def test_transform_series() -> None: def f(val: Series) -> Series: return -1 * val - check(assert_type(S.resample(MonthFreq).transform(f), Series), Series) + check(assert_type(S.resample("ME").transform(f), Series), Series) def test_aggregate_series_combinations() -> None: @@ -422,16 +402,14 @@ def s2scalar(val: Series) -> float: r"The provided callable is currently using ", lower="2.0.99", ): - check(S.resample(MonthFreq).aggregate(np.sum), Series) - check(S.resample(MonthFreq).aggregate([np.mean]), DataFrame) - check(S.resample(MonthFreq).aggregate(["sum", np.mean]), DataFrame) - check(S.resample(MonthFreq).aggregate({"sum": np.sum}), DataFrame) - check( - S.resample(MonthFreq).aggregate({"sum": np.sum, "mean": np.mean}), DataFrame - ) - check(S.resample(MonthFreq).aggregate("sum"), Series) - check(S.resample(MonthFreq).aggregate(s2series), Series) - check(S.resample(MonthFreq).aggregate(s2scalar), Series) + check(S.resample("ME").aggregate(np.sum), Series) + check(S.resample("ME").aggregate([np.mean]), DataFrame) + check(S.resample("ME").aggregate(["sum", np.mean]), DataFrame) + check(S.resample("ME").aggregate({"sum": np.sum}), DataFrame) + check(S.resample("ME").aggregate({"sum": np.sum, "mean": np.mean}), DataFrame) + check(S.resample("ME").aggregate("sum"), Series) + check(S.resample("ME").aggregate(s2series), Series) + check(S.resample("ME").aggregate(s2scalar), Series) def test_aggregate_frame_combinations() -> None: @@ -449,40 +427,36 @@ def df2scalar(val: DataFrame) -> float: r"The provided callable is currently using ", lower="2.0.99", ): - check(DF.resample(MonthFreq).aggregate(np.sum), DataFrame) - check(DF.resample(MonthFreq).aggregate([np.mean]), DataFrame) - check(DF.resample(MonthFreq).aggregate(["sum", np.mean]), DataFrame) - check(DF.resample(MonthFreq).aggregate({"col1": np.sum}), DataFrame) + check(DF.resample("ME").aggregate(np.sum), DataFrame) + check(DF.resample("ME").aggregate([np.mean]), DataFrame) + check(DF.resample("ME").aggregate(["sum", np.mean]), DataFrame) + check(DF.resample("ME").aggregate({"col1": np.sum}), DataFrame) check( - DF.resample(MonthFreq).aggregate({"col1": np.sum, "col2": np.mean}), + DF.resample("ME").aggregate({"col1": np.sum, "col2": np.mean}), DataFrame, ) check( - DF.resample(MonthFreq).aggregate( - {"col1": [np.sum], "col2": ["sum", np.mean]} - ), + DF.resample("ME").aggregate({"col1": [np.sum], "col2": ["sum", np.mean]}), DataFrame, ) check( - DF.resample(MonthFreq).aggregate( - {"col1": np.sum, "col2": ["sum", np.mean]} - ), + DF.resample("ME").aggregate({"col1": np.sum, "col2": ["sum", np.mean]}), DataFrame, ) check( - DF.resample(MonthFreq).aggregate({"col1": "sum", "col2": [np.mean]}), + DF.resample("ME").aggregate({"col1": "sum", "col2": [np.mean]}), DataFrame, ) - check(DF.resample(MonthFreq).aggregate("sum"), DataFrame) - check(DF.resample(MonthFreq).aggregate(df2frame), DataFrame) - check(DF.resample(MonthFreq).aggregate(df2series), DataFrame) - check(DF.resample(MonthFreq).aggregate(df2scalar), DataFrame) + check(DF.resample("ME").aggregate("sum"), DataFrame) + check(DF.resample("ME").aggregate(df2frame), DataFrame) + check(DF.resample("ME").aggregate(df2series), DataFrame) + check(DF.resample("ME").aggregate(df2scalar), DataFrame) def test_getitem() -> None: - check(assert_type(DF.resample(MonthFreq)["col1"], SeriesGroupBy), SeriesGroupBy) + check(assert_type(DF.resample("ME")["col1"], SeriesGroupBy), SeriesGroupBy) check( - assert_type(DF.resample(MonthFreq)[["col1", "col2"]], DataFrameGroupBy), + assert_type(DF.resample("ME")[["col1", "col2"]], DataFrameGroupBy), DataFrameGroupBy, ) diff --git a/tests/test_series.py b/tests/test_series.py index e12dba47e..c67092fbf 100644 --- a/tests/test_series.py +++ b/tests/test_series.py @@ -43,6 +43,7 @@ ) from tests import ( + PD_LTE_22, TYPE_CHECKING_INVALID_USAGE, check, pytest_warns_bounded, @@ -651,7 +652,11 @@ def test_groupby_result() -> None: index, value = next(iterator) assert_type((index, value), tuple[tuple, "pd.Series[int]"]) - check(assert_type(index, tuple), tuple, np.integer) + if PD_LTE_22: + check(assert_type(index, tuple), tuple, np.integer) + else: + check(assert_type(index, tuple), tuple, int) + check(assert_type(value, "pd.Series[int]"), pd.Series, np.integer) iterator2 = s.groupby("a").__iter__() @@ -776,7 +781,7 @@ def test_groupby_result_for_ambiguous_indexes() -> None: with pytest_warns_bounded( FutureWarning, "The default of observed=False is deprecated", - lower="2.0.99", + upper="2.2.99", ): categorical_index = pd.CategoricalIndex(s.index) iterator2 = s.groupby(categorical_index).__iter__() diff --git a/tests/test_styler.py b/tests/test_styler.py index 67c80d0c6..188710787 100644 --- a/tests/test_styler.py +++ b/tests/test_styler.py @@ -19,10 +19,7 @@ import pytest from typing_extensions import assert_type -from tests import ( - check, - pytest_warns_bounded, -) +from tests import check from pandas.io.formats.style import Styler @@ -66,30 +63,6 @@ def f1(s: Series) -> Series[str]: check(assert_type(DF.style.apply_index(f1), Styler), Styler) -def test_applymap() -> None: - def g(o: object) -> str: - return str(o) - - with pytest_warns_bounded( - FutureWarning, - "Styler.applymap has been deprecated. Use Styler.map instead", - lower="2.0.99", - ): - check(assert_type(DF.style.applymap(g), Styler), Styler) - - -def test_applymap_index() -> None: - def g(o: object) -> str: - return str(o) - - with pytest_warns_bounded( - FutureWarning, - "Styler.applymap_index has been deprecated. Use Styler.map_index instead", - lower="2.0.99", - ): - check(assert_type(DF.style.applymap_index(g), Styler), Styler) - - def test_background_gradient() -> None: check(assert_type(DF.style.background_gradient(), Styler), Styler) diff --git a/tests/test_timefuncs.py b/tests/test_timefuncs.py index 36dd6d548..dd66aa540 100644 --- a/tests/test_timefuncs.py +++ b/tests/test_timefuncs.py @@ -292,13 +292,6 @@ def test_comparisons_datetimeindex() -> None: def test_to_datetime_nat() -> None: # GH 88 - with pytest_warns_bounded( - FutureWarning, "errors='ignore' is deprecated", lower="2.1.99" - ): - check( - assert_type(pd.to_datetime("2021-03-01", errors="ignore"), pd.Timestamp), - pd.Timestamp, - ) check( assert_type(pd.to_datetime("2021-03-01", errors="raise"), pd.Timestamp), pd.Timestamp, @@ -811,13 +804,6 @@ def test_to_timedelta_scalar() -> None: assert_type(pd.to_timedelta(10, "ms", errors="raise"), pd.Timedelta), pd.Timedelta, ) - with pytest_warns_bounded( - FutureWarning, "errors='ignore' is deprecated", lower="2.1.99" - ): - check( - assert_type(pd.to_timedelta("10ms", errors="ignore"), pd.Timedelta), - pd.Timedelta, - ) check( assert_type( pd.to_timedelta(dt.timedelta(milliseconds=10), errors="coerce"),