ai-content-maker/.venv/Lib/site-packages/pandas/tests/generic/test_finalize.py

774 lines
26 KiB
Python

"""
An exhaustive list of pandas methods exercising NDFrame.__finalize__.
"""
import operator
import re
import numpy as np
import pytest
import pandas as pd
# TODO:
# * Binary methods (mul, div, etc.)
# * Binary outputs (align, etc.)
# * top-level methods (concat, merge, get_dummies, etc.)
# * window
# * cumulative reductions
not_implemented_mark = pytest.mark.xfail(reason="not implemented")
mi = pd.MultiIndex.from_product([["a", "b"], [0, 1]], names=["A", "B"])
frame_data = ({"A": [1]},)
frame_mi_data = ({"A": [1, 2, 3, 4]}, mi)
# Tuple of
# - Callable: Constructor (Series, DataFrame)
# - Tuple: Constructor args
# - Callable: pass the constructed value with attrs set to this.
_all_methods = [
(
pd.Series,
(np.array([0], dtype="float64")),
operator.methodcaller("view", "int64"),
),
(pd.Series, ([0],), operator.methodcaller("take", [])),
(pd.Series, ([0],), operator.methodcaller("__getitem__", [True])),
(pd.Series, ([0],), operator.methodcaller("repeat", 2)),
(pd.Series, ([0],), operator.methodcaller("reset_index")),
(pd.Series, ([0],), operator.methodcaller("reset_index", drop=True)),
(pd.Series, ([0],), operator.methodcaller("to_frame")),
(pd.Series, ([0, 0],), operator.methodcaller("drop_duplicates")),
(pd.Series, ([0, 0],), operator.methodcaller("duplicated")),
(pd.Series, ([0, 0],), operator.methodcaller("round")),
(pd.Series, ([0, 0],), operator.methodcaller("rename", lambda x: x + 1)),
(pd.Series, ([0, 0],), operator.methodcaller("rename", "name")),
(pd.Series, ([0, 0],), operator.methodcaller("set_axis", ["a", "b"])),
(pd.Series, ([0, 0],), operator.methodcaller("reindex", [1, 0])),
(pd.Series, ([0, 0],), operator.methodcaller("drop", [0])),
(pd.Series, (pd.array([0, pd.NA]),), operator.methodcaller("fillna", 0)),
(pd.Series, ([0, 0],), operator.methodcaller("replace", {0: 1})),
(pd.Series, ([0, 0],), operator.methodcaller("shift")),
(pd.Series, ([0, 0],), operator.methodcaller("isin", [0, 1])),
(pd.Series, ([0, 0],), operator.methodcaller("between", 0, 2)),
(pd.Series, ([0, 0],), operator.methodcaller("isna")),
(pd.Series, ([0, 0],), operator.methodcaller("isnull")),
(pd.Series, ([0, 0],), operator.methodcaller("notna")),
(pd.Series, ([0, 0],), operator.methodcaller("notnull")),
(pd.Series, ([1],), operator.methodcaller("add", pd.Series([1]))),
# TODO: mul, div, etc.
(
pd.Series,
([0], pd.period_range("2000", periods=1)),
operator.methodcaller("to_timestamp"),
),
(
pd.Series,
([0], pd.date_range("2000", periods=1)),
operator.methodcaller("to_period"),
),
pytest.param(
(
pd.DataFrame,
frame_data,
operator.methodcaller("dot", pd.DataFrame(index=["A"])),
),
marks=pytest.mark.xfail(reason="Implement binary finalize"),
),
(pd.DataFrame, frame_data, operator.methodcaller("transpose")),
(pd.DataFrame, frame_data, operator.methodcaller("__getitem__", "A")),
(pd.DataFrame, frame_data, operator.methodcaller("__getitem__", ["A"])),
(pd.DataFrame, frame_data, operator.methodcaller("__getitem__", np.array([True]))),
(pd.DataFrame, ({("A", "a"): [1]},), operator.methodcaller("__getitem__", ["A"])),
(pd.DataFrame, frame_data, operator.methodcaller("query", "A == 1")),
(pd.DataFrame, frame_data, operator.methodcaller("eval", "A + 1", engine="python")),
(pd.DataFrame, frame_data, operator.methodcaller("select_dtypes", include="int")),
(pd.DataFrame, frame_data, operator.methodcaller("assign", b=1)),
(pd.DataFrame, frame_data, operator.methodcaller("set_axis", ["A"])),
(pd.DataFrame, frame_data, operator.methodcaller("reindex", [0, 1])),
(pd.DataFrame, frame_data, operator.methodcaller("drop", columns=["A"])),
(pd.DataFrame, frame_data, operator.methodcaller("drop", index=[0])),
(pd.DataFrame, frame_data, operator.methodcaller("rename", columns={"A": "a"})),
(pd.DataFrame, frame_data, operator.methodcaller("rename", index=lambda x: x)),
(pd.DataFrame, frame_data, operator.methodcaller("fillna", "A")),
(pd.DataFrame, frame_data, operator.methodcaller("fillna", method="ffill")),
(pd.DataFrame, frame_data, operator.methodcaller("set_index", "A")),
(pd.DataFrame, frame_data, operator.methodcaller("reset_index")),
(pd.DataFrame, frame_data, operator.methodcaller("isna")),
(pd.DataFrame, frame_data, operator.methodcaller("isnull")),
(pd.DataFrame, frame_data, operator.methodcaller("notna")),
(pd.DataFrame, frame_data, operator.methodcaller("notnull")),
(pd.DataFrame, frame_data, operator.methodcaller("dropna")),
(pd.DataFrame, frame_data, operator.methodcaller("drop_duplicates")),
(pd.DataFrame, frame_data, operator.methodcaller("duplicated")),
(pd.DataFrame, frame_data, operator.methodcaller("sort_values", by="A")),
(pd.DataFrame, frame_data, operator.methodcaller("sort_index")),
(pd.DataFrame, frame_data, operator.methodcaller("nlargest", 1, "A")),
(pd.DataFrame, frame_data, operator.methodcaller("nsmallest", 1, "A")),
(pd.DataFrame, frame_mi_data, operator.methodcaller("swaplevel")),
pytest.param(
(
pd.DataFrame,
frame_data,
operator.methodcaller("add", pd.DataFrame(*frame_data)),
),
marks=not_implemented_mark,
),
# TODO: div, mul, etc.
pytest.param(
(
pd.DataFrame,
frame_data,
operator.methodcaller("combine", pd.DataFrame(*frame_data), operator.add),
),
marks=not_implemented_mark,
),
pytest.param(
(
pd.DataFrame,
frame_data,
operator.methodcaller("combine_first", pd.DataFrame(*frame_data)),
),
marks=not_implemented_mark,
),
pytest.param(
(
pd.DataFrame,
frame_data,
operator.methodcaller("update", pd.DataFrame(*frame_data)),
),
marks=not_implemented_mark,
),
(pd.DataFrame, frame_data, operator.methodcaller("pivot", columns="A")),
(
pd.DataFrame,
({"A": [1], "B": [1]},),
operator.methodcaller("pivot_table", columns="A"),
),
(
pd.DataFrame,
({"A": [1], "B": [1]},),
operator.methodcaller("pivot_table", columns="A", aggfunc=["mean", "sum"]),
),
(pd.DataFrame, frame_data, operator.methodcaller("stack")),
(pd.DataFrame, frame_data, operator.methodcaller("explode", "A")),
(pd.DataFrame, frame_mi_data, operator.methodcaller("unstack")),
(
pd.DataFrame,
({"A": ["a", "b", "c"], "B": [1, 3, 5], "C": [2, 4, 6]},),
operator.methodcaller("melt", id_vars=["A"], value_vars=["B"]),
),
pytest.param(
(pd.DataFrame, frame_data, operator.methodcaller("applymap", lambda x: x))
),
pytest.param(
(
pd.DataFrame,
frame_data,
operator.methodcaller("append", pd.DataFrame({"A": [1]})),
),
marks=pytest.mark.filterwarnings(
"ignore:.*append method is deprecated.*:FutureWarning"
),
),
pytest.param(
(
pd.DataFrame,
frame_data,
operator.methodcaller("append", pd.DataFrame({"B": [1]})),
),
marks=pytest.mark.filterwarnings(
"ignore:.*append method is deprecated.*:FutureWarning"
),
),
pytest.param(
(
pd.DataFrame,
frame_data,
operator.methodcaller("merge", pd.DataFrame({"A": [1]})),
),
marks=not_implemented_mark,
),
pytest.param(
(pd.DataFrame, frame_data, operator.methodcaller("round", 2)),
),
pytest.param(
(pd.DataFrame, frame_data, operator.methodcaller("corr")),
marks=not_implemented_mark,
),
pytest.param(
(pd.DataFrame, frame_data, operator.methodcaller("cov")),
marks=[
not_implemented_mark,
pytest.mark.filterwarnings("ignore::RuntimeWarning"),
],
),
pytest.param(
(
pd.DataFrame,
frame_data,
operator.methodcaller("corrwith", pd.DataFrame(*frame_data)),
),
marks=not_implemented_mark,
),
pytest.param(
(pd.DataFrame, frame_data, operator.methodcaller("count")),
),
pytest.param(
(pd.DataFrame, frame_mi_data, operator.methodcaller("count", level="A")),
marks=[
pytest.mark.filterwarnings("ignore:Using the level keyword:FutureWarning"),
],
),
pytest.param(
(pd.DataFrame, frame_data, operator.methodcaller("nunique")),
),
(pd.DataFrame, frame_data, operator.methodcaller("idxmin")),
(pd.DataFrame, frame_data, operator.methodcaller("idxmax")),
(pd.DataFrame, frame_data, operator.methodcaller("mode")),
pytest.param(
(pd.Series, [0], operator.methodcaller("mode")),
marks=not_implemented_mark,
),
pytest.param(
(
pd.DataFrame,
frame_data,
operator.methodcaller("quantile", numeric_only=True),
),
),
pytest.param(
(
pd.DataFrame,
frame_data,
operator.methodcaller("quantile", q=[0.25, 0.75], numeric_only=True),
),
),
pytest.param(
(
pd.DataFrame,
({"A": [pd.Timedelta(days=1), pd.Timedelta(days=2)]},),
operator.methodcaller("quantile", numeric_only=False),
),
),
pytest.param(
(
pd.DataFrame,
({"A": [np.datetime64("2022-01-01"), np.datetime64("2022-01-02")]},),
operator.methodcaller("quantile", numeric_only=True),
),
),
(
pd.DataFrame,
({"A": [1]}, [pd.Period("2000", "D")]),
operator.methodcaller("to_timestamp"),
),
(
pd.DataFrame,
({"A": [1]}, [pd.Timestamp("2000")]),
operator.methodcaller("to_period", freq="D"),
),
pytest.param(
(pd.DataFrame, frame_mi_data, operator.methodcaller("isin", [1])),
),
pytest.param(
(pd.DataFrame, frame_mi_data, operator.methodcaller("isin", pd.Series([1]))),
),
pytest.param(
(
pd.DataFrame,
frame_mi_data,
operator.methodcaller("isin", pd.DataFrame({"A": [1]})),
),
),
(pd.DataFrame, frame_data, operator.methodcaller("swapaxes", 0, 1)),
(pd.DataFrame, frame_mi_data, operator.methodcaller("droplevel", "A")),
(pd.DataFrame, frame_data, operator.methodcaller("pop", "A")),
pytest.param(
(pd.DataFrame, frame_data, operator.methodcaller("squeeze")),
marks=not_implemented_mark,
),
(pd.Series, ([1, 2],), operator.methodcaller("squeeze")),
(pd.Series, ([1, 2],), operator.methodcaller("rename_axis", index="a")),
(pd.DataFrame, frame_data, operator.methodcaller("rename_axis", columns="a")),
# Unary ops
(pd.DataFrame, frame_data, operator.neg),
(pd.Series, [1], operator.neg),
(pd.DataFrame, frame_data, operator.pos),
(pd.Series, [1], operator.pos),
(pd.DataFrame, frame_data, operator.inv),
(pd.Series, [1], operator.inv),
(pd.DataFrame, frame_data, abs),
(pd.Series, [1], abs),
pytest.param((pd.DataFrame, frame_data, round)),
(pd.Series, [1], round),
(pd.DataFrame, frame_data, operator.methodcaller("take", [0, 0])),
(pd.DataFrame, frame_mi_data, operator.methodcaller("xs", "a")),
(pd.Series, (1, mi), operator.methodcaller("xs", "a")),
(pd.DataFrame, frame_data, operator.methodcaller("get", "A")),
(
pd.DataFrame,
frame_data,
operator.methodcaller("reindex_like", pd.DataFrame({"A": [1, 2, 3]})),
),
(
pd.Series,
frame_data,
operator.methodcaller("reindex_like", pd.Series([0, 1, 2])),
),
(pd.DataFrame, frame_data, operator.methodcaller("add_prefix", "_")),
(pd.DataFrame, frame_data, operator.methodcaller("add_suffix", "_")),
(pd.Series, (1, ["a", "b"]), operator.methodcaller("add_prefix", "_")),
(pd.Series, (1, ["a", "b"]), operator.methodcaller("add_suffix", "_")),
(pd.Series, ([3, 2],), operator.methodcaller("sort_values")),
(pd.Series, ([1] * 10,), operator.methodcaller("head")),
(pd.DataFrame, ({"A": [1] * 10},), operator.methodcaller("head")),
(pd.Series, ([1] * 10,), operator.methodcaller("tail")),
(pd.DataFrame, ({"A": [1] * 10},), operator.methodcaller("tail")),
(pd.Series, ([1, 2],), operator.methodcaller("sample", n=2, replace=True)),
(pd.DataFrame, (frame_data,), operator.methodcaller("sample", n=2, replace=True)),
(pd.Series, ([1, 2],), operator.methodcaller("astype", float)),
(pd.DataFrame, frame_data, operator.methodcaller("astype", float)),
(pd.Series, ([1, 2],), operator.methodcaller("copy")),
(pd.DataFrame, frame_data, operator.methodcaller("copy")),
(pd.Series, ([1, 2], None, object), operator.methodcaller("infer_objects")),
(
pd.DataFrame,
({"A": np.array([1, 2], dtype=object)},),
operator.methodcaller("infer_objects"),
),
(pd.Series, ([1, 2],), operator.methodcaller("convert_dtypes")),
(pd.DataFrame, frame_data, operator.methodcaller("convert_dtypes")),
(pd.Series, ([1, None, 3],), operator.methodcaller("interpolate")),
(pd.DataFrame, ({"A": [1, None, 3]},), operator.methodcaller("interpolate")),
(pd.Series, ([1, 2],), operator.methodcaller("clip", lower=1)),
(pd.DataFrame, frame_data, operator.methodcaller("clip", lower=1)),
(
pd.Series,
(1, pd.date_range("2000", periods=4)),
operator.methodcaller("asfreq", "H"),
),
(
pd.DataFrame,
({"A": [1, 1, 1, 1]}, pd.date_range("2000", periods=4)),
operator.methodcaller("asfreq", "H"),
),
(
pd.Series,
(1, pd.date_range("2000", periods=4)),
operator.methodcaller("at_time", "12:00"),
),
(
pd.DataFrame,
({"A": [1, 1, 1, 1]}, pd.date_range("2000", periods=4)),
operator.methodcaller("at_time", "12:00"),
),
(
pd.Series,
(1, pd.date_range("2000", periods=4)),
operator.methodcaller("between_time", "12:00", "13:00"),
),
(
pd.DataFrame,
({"A": [1, 1, 1, 1]}, pd.date_range("2000", periods=4)),
operator.methodcaller("between_time", "12:00", "13:00"),
),
(
pd.Series,
(1, pd.date_range("2000", periods=4)),
operator.methodcaller("first", "3D"),
),
(
pd.DataFrame,
({"A": [1, 1, 1, 1]}, pd.date_range("2000", periods=4)),
operator.methodcaller("first", "3D"),
),
(
pd.Series,
(1, pd.date_range("2000", periods=4)),
operator.methodcaller("last", "3D"),
),
(
pd.DataFrame,
({"A": [1, 1, 1, 1]}, pd.date_range("2000", periods=4)),
operator.methodcaller("last", "3D"),
),
(pd.Series, ([1, 2],), operator.methodcaller("rank")),
(pd.DataFrame, frame_data, operator.methodcaller("rank")),
(pd.Series, ([1, 2],), operator.methodcaller("where", np.array([True, False]))),
(pd.DataFrame, frame_data, operator.methodcaller("where", np.array([[True]]))),
(pd.Series, ([1, 2],), operator.methodcaller("mask", np.array([True, False]))),
(pd.DataFrame, frame_data, operator.methodcaller("mask", np.array([[True]]))),
pytest.param(
(
pd.Series,
(1, pd.date_range("2000", periods=4)),
operator.methodcaller("tshift"),
),
marks=pytest.mark.filterwarnings("ignore::FutureWarning"),
),
pytest.param(
(
pd.DataFrame,
({"A": [1, 1, 1, 1]}, pd.date_range("2000", periods=4)),
operator.methodcaller("tshift"),
),
marks=pytest.mark.filterwarnings("ignore::FutureWarning"),
),
(pd.Series, ([1, 2],), operator.methodcaller("truncate", before=0)),
(pd.DataFrame, frame_data, operator.methodcaller("truncate", before=0)),
(
pd.Series,
(1, pd.date_range("2000", periods=4, tz="UTC")),
operator.methodcaller("tz_convert", "CET"),
),
(
pd.DataFrame,
({"A": [1, 1, 1, 1]}, pd.date_range("2000", periods=4, tz="UTC")),
operator.methodcaller("tz_convert", "CET"),
),
(
pd.Series,
(1, pd.date_range("2000", periods=4)),
operator.methodcaller("tz_localize", "CET"),
),
(
pd.DataFrame,
({"A": [1, 1, 1, 1]}, pd.date_range("2000", periods=4)),
operator.methodcaller("tz_localize", "CET"),
),
pytest.param(
(pd.Series, ([1, 2],), operator.methodcaller("describe")),
marks=not_implemented_mark,
),
pytest.param(
(pd.DataFrame, frame_data, operator.methodcaller("describe")),
marks=not_implemented_mark,
),
(pd.Series, ([1, 2],), operator.methodcaller("pct_change")),
(pd.DataFrame, frame_data, operator.methodcaller("pct_change")),
(pd.Series, ([1],), operator.methodcaller("transform", lambda x: x - x.min())),
pytest.param(
(
pd.DataFrame,
frame_mi_data,
operator.methodcaller("transform", lambda x: x - x.min()),
),
),
(pd.Series, ([1],), operator.methodcaller("apply", lambda x: x)),
pytest.param(
(pd.DataFrame, frame_mi_data, operator.methodcaller("apply", lambda x: x)),
),
# Cumulative reductions
(pd.Series, ([1],), operator.methodcaller("cumsum")),
(pd.DataFrame, frame_data, operator.methodcaller("cumsum")),
# Reductions
pytest.param(
(pd.DataFrame, frame_data, operator.methodcaller("any")),
marks=not_implemented_mark,
),
pytest.param(
(pd.DataFrame, frame_data, operator.methodcaller("sum")),
marks=not_implemented_mark,
),
pytest.param(
(pd.DataFrame, frame_data, operator.methodcaller("std")),
marks=not_implemented_mark,
),
pytest.param(
(pd.DataFrame, frame_data, operator.methodcaller("mean")),
marks=not_implemented_mark,
),
]
def idfn(x):
xpr = re.compile(r"'(.*)?'")
m = xpr.search(str(x))
if m:
return m.group(1)
else:
return str(x)
@pytest.fixture(params=_all_methods, ids=lambda x: idfn(x[-1]))
def ndframe_method(request):
"""
An NDFrame method returning an NDFrame.
"""
return request.param
def test_finalize_called(ndframe_method):
cls, init_args, method = ndframe_method
ndframe = cls(*init_args)
ndframe.attrs = {"a": 1}
result = method(ndframe)
assert result.attrs == {"a": 1}
@not_implemented_mark
def test_finalize_called_eval_numexpr():
pytest.importorskip("numexpr")
df = pd.DataFrame({"A": [1, 2]})
df.attrs["A"] = 1
result = df.eval("A + 1", engine="numexpr")
assert result.attrs == {"A": 1}
# ----------------------------------------------------------------------------
# Binary operations
@pytest.mark.parametrize("annotate", ["left", "right", "both"])
@pytest.mark.parametrize(
"args",
[
(1, pd.Series([1])),
(1, pd.DataFrame({"A": [1]})),
(pd.Series([1]), 1),
(pd.DataFrame({"A": [1]}), 1),
(pd.Series([1]), pd.Series([1])),
(pd.DataFrame({"A": [1]}), pd.DataFrame({"A": [1]})),
(pd.Series([1]), pd.DataFrame({"A": [1]})),
(pd.DataFrame({"A": [1]}), pd.Series([1])),
],
)
def test_binops(request, args, annotate, all_arithmetic_functions):
# This generates 326 tests... Is that needed?
left, right = args
if annotate == "both" and isinstance(left, int) or isinstance(right, int):
return
if isinstance(left, pd.DataFrame) or isinstance(right, pd.DataFrame):
request.node.add_marker(pytest.mark.xfail(reason="not implemented"))
if annotate in {"left", "both"} and not isinstance(left, int):
left.attrs = {"a": 1}
if annotate in {"left", "both"} and not isinstance(right, int):
right.attrs = {"a": 1}
result = all_arithmetic_functions(left, right)
assert result.attrs == {"a": 1}
# ----------------------------------------------------------------------------
# Accessors
@pytest.mark.parametrize(
"method",
[
operator.methodcaller("capitalize"),
operator.methodcaller("casefold"),
operator.methodcaller("cat", ["a"]),
operator.methodcaller("contains", "a"),
operator.methodcaller("count", "a"),
operator.methodcaller("encode", "utf-8"),
operator.methodcaller("endswith", "a"),
operator.methodcaller("extract", r"(\w)(\d)"),
operator.methodcaller("extract", r"(\w)(\d)", expand=False),
operator.methodcaller("find", "a"),
operator.methodcaller("findall", "a"),
operator.methodcaller("get", 0),
operator.methodcaller("index", "a"),
operator.methodcaller("len"),
operator.methodcaller("ljust", 4),
operator.methodcaller("lower"),
operator.methodcaller("lstrip"),
operator.methodcaller("match", r"\w"),
operator.methodcaller("normalize", "NFC"),
operator.methodcaller("pad", 4),
operator.methodcaller("partition", "a"),
operator.methodcaller("repeat", 2),
operator.methodcaller("replace", "a", "b"),
operator.methodcaller("rfind", "a"),
operator.methodcaller("rindex", "a"),
operator.methodcaller("rjust", 4),
operator.methodcaller("rpartition", "a"),
operator.methodcaller("rstrip"),
operator.methodcaller("slice", 4),
operator.methodcaller("slice_replace", 1, repl="a"),
operator.methodcaller("startswith", "a"),
operator.methodcaller("strip"),
operator.methodcaller("swapcase"),
operator.methodcaller("translate", {"a": "b"}),
operator.methodcaller("upper"),
operator.methodcaller("wrap", 4),
operator.methodcaller("zfill", 4),
operator.methodcaller("isalnum"),
operator.methodcaller("isalpha"),
operator.methodcaller("isdigit"),
operator.methodcaller("isspace"),
operator.methodcaller("islower"),
operator.methodcaller("isupper"),
operator.methodcaller("istitle"),
operator.methodcaller("isnumeric"),
operator.methodcaller("isdecimal"),
operator.methodcaller("get_dummies"),
],
ids=idfn,
)
def test_string_method(method):
s = pd.Series(["a1"])
s.attrs = {"a": 1}
result = method(s.str)
assert result.attrs == {"a": 1}
@pytest.mark.parametrize(
"method",
[
operator.methodcaller("to_period"),
operator.methodcaller("tz_localize", "CET"),
operator.methodcaller("normalize"),
operator.methodcaller("strftime", "%Y"),
operator.methodcaller("round", "H"),
operator.methodcaller("floor", "H"),
operator.methodcaller("ceil", "H"),
operator.methodcaller("month_name"),
operator.methodcaller("day_name"),
],
ids=idfn,
)
def test_datetime_method(method):
s = pd.Series(pd.date_range("2000", periods=4))
s.attrs = {"a": 1}
result = method(s.dt)
assert result.attrs == {"a": 1}
@pytest.mark.parametrize(
"attr",
[
"date",
"time",
"timetz",
"year",
"month",
"day",
"hour",
"minute",
"second",
"microsecond",
"nanosecond",
"dayofweek",
"day_of_week",
"dayofyear",
"day_of_year",
"quarter",
"is_month_start",
"is_month_end",
"is_quarter_start",
"is_quarter_end",
"is_year_start",
"is_year_end",
"is_leap_year",
"daysinmonth",
"days_in_month",
],
)
def test_datetime_property(attr):
s = pd.Series(pd.date_range("2000", periods=4))
s.attrs = {"a": 1}
result = getattr(s.dt, attr)
assert result.attrs == {"a": 1}
@pytest.mark.parametrize(
"attr", ["days", "seconds", "microseconds", "nanoseconds", "components"]
)
def test_timedelta_property(attr):
s = pd.Series(pd.timedelta_range("2000", periods=4))
s.attrs = {"a": 1}
result = getattr(s.dt, attr)
assert result.attrs == {"a": 1}
@pytest.mark.parametrize("method", [operator.methodcaller("total_seconds")])
def test_timedelta_methods(method):
s = pd.Series(pd.timedelta_range("2000", periods=4))
s.attrs = {"a": 1}
result = method(s.dt)
assert result.attrs == {"a": 1}
@pytest.mark.parametrize(
"method",
[
operator.methodcaller("add_categories", ["c"]),
operator.methodcaller("as_ordered"),
operator.methodcaller("as_unordered"),
lambda x: getattr(x, "codes"),
operator.methodcaller("remove_categories", "a"),
operator.methodcaller("remove_unused_categories"),
operator.methodcaller("rename_categories", {"a": "A", "b": "B"}),
operator.methodcaller("reorder_categories", ["b", "a"]),
operator.methodcaller("set_categories", ["A", "B"]),
],
)
@not_implemented_mark
def test_categorical_accessor(method):
s = pd.Series(["a", "b"], dtype="category")
s.attrs = {"a": 1}
result = method(s.cat)
assert result.attrs == {"a": 1}
# ----------------------------------------------------------------------------
# Groupby
@pytest.mark.parametrize(
"obj", [pd.Series([0, 0]), pd.DataFrame({"A": [0, 1], "B": [1, 2]})]
)
@pytest.mark.parametrize(
"method",
[
operator.methodcaller("sum"),
lambda x: x.apply(lambda y: y),
lambda x: x.agg("sum"),
lambda x: x.agg("mean"),
lambda x: x.agg("median"),
],
)
def test_groupby_finalize(obj, method):
obj.attrs = {"a": 1}
result = method(obj.groupby([0, 0], group_keys=False))
assert result.attrs == {"a": 1}
@pytest.mark.parametrize(
"obj", [pd.Series([0, 0]), pd.DataFrame({"A": [0, 1], "B": [1, 2]})]
)
@pytest.mark.parametrize(
"method",
[
lambda x: x.agg(["sum", "count"]),
lambda x: x.agg("std"),
lambda x: x.agg("var"),
lambda x: x.agg("sem"),
lambda x: x.agg("size"),
lambda x: x.agg("ohlc"),
lambda x: x.agg("describe"),
],
)
@not_implemented_mark
def test_groupby_finalize_not_implemented(obj, method):
obj.attrs = {"a": 1}
result = method(obj.groupby([0, 0]))
assert result.attrs == {"a": 1}
def test_finalize_frame_series_name():
# https://github.com/pandas-dev/pandas/pull/37186/files#r506978889
# ensure we don't copy the column `name` to the Series.
df = pd.DataFrame({"name": [1, 2]})
result = pd.Series([1, 2]).__finalize__(df)
assert result.name is None