203 lines
6.8 KiB
Python
203 lines
6.8 KiB
Python
from copy import deepcopy
|
|
from operator import methodcaller
|
|
from typing import Literal
|
|
|
|
import numpy as np
|
|
import pytest
|
|
|
|
import pandas as pd
|
|
from pandas import (
|
|
DataFrame,
|
|
MultiIndex,
|
|
Series,
|
|
date_range,
|
|
)
|
|
import pandas._testing as tm
|
|
|
|
|
|
class TestDataFrame:
|
|
@pytest.mark.parametrize("func", ["_set_axis_name", "rename_axis"])
|
|
def test_set_axis_name(self, func):
|
|
df = DataFrame([[1, 2], [3, 4]])
|
|
|
|
result = methodcaller(func, "foo")(df)
|
|
assert df.index.name is None
|
|
assert result.index.name == "foo"
|
|
|
|
result = methodcaller(func, "cols", axis=1)(df)
|
|
assert df.columns.name is None
|
|
assert result.columns.name == "cols"
|
|
|
|
@pytest.mark.parametrize("func", ["_set_axis_name", "rename_axis"])
|
|
def test_set_axis_name_mi(self, func):
|
|
df = DataFrame(
|
|
np.empty((3, 3)),
|
|
index=MultiIndex.from_tuples([("A", x) for x in list("aBc")]),
|
|
columns=MultiIndex.from_tuples([("C", x) for x in list("xyz")]),
|
|
)
|
|
|
|
level_names = ["L1", "L2"]
|
|
|
|
result = methodcaller(func, level_names)(df)
|
|
assert result.index.names == level_names
|
|
assert result.columns.names == [None, None]
|
|
|
|
result = methodcaller(func, level_names, axis=1)(df)
|
|
assert result.columns.names == ["L1", "L2"]
|
|
assert result.index.names == [None, None]
|
|
|
|
def test_nonzero_single_element(self):
|
|
df = DataFrame([[False, False]])
|
|
msg_err = "The truth value of a DataFrame is ambiguous"
|
|
with pytest.raises(ValueError, match=msg_err):
|
|
bool(df)
|
|
|
|
def test_metadata_propagation_indiv_groupby(self):
|
|
# groupby
|
|
df = DataFrame(
|
|
{
|
|
"A": ["foo", "bar", "foo", "bar", "foo", "bar", "foo", "foo"],
|
|
"B": ["one", "one", "two", "three", "two", "two", "one", "three"],
|
|
"C": np.random.default_rng(2).standard_normal(8),
|
|
"D": np.random.default_rng(2).standard_normal(8),
|
|
}
|
|
)
|
|
result = df.groupby("A").sum()
|
|
tm.assert_metadata_equivalent(df, result)
|
|
|
|
def test_metadata_propagation_indiv_resample(self):
|
|
# resample
|
|
df = DataFrame(
|
|
np.random.default_rng(2).standard_normal((1000, 2)),
|
|
index=date_range("20130101", periods=1000, freq="s"),
|
|
)
|
|
result = df.resample("1min")
|
|
tm.assert_metadata_equivalent(df, result)
|
|
|
|
def test_metadata_propagation_indiv(self, monkeypatch):
|
|
# merging with override
|
|
# GH 6923
|
|
|
|
def finalize(
|
|
self: DataFrame,
|
|
other: DataFrame,
|
|
method: Literal["merge", "concat"] | None = None,
|
|
**kwargs,
|
|
):
|
|
for name in self._metadata:
|
|
if method == "merge":
|
|
left, right = other.input_objs
|
|
value = getattr(left, name, "") + "|" + getattr(right, name, "")
|
|
object.__setattr__(self, name, value)
|
|
elif method == "concat":
|
|
value = "+".join(
|
|
[
|
|
getattr(o, name)
|
|
for o in other.input_objs
|
|
if getattr(o, name, None)
|
|
]
|
|
)
|
|
object.__setattr__(self, name, value)
|
|
else:
|
|
object.__setattr__(self, name, getattr(other, name, ""))
|
|
|
|
return self
|
|
|
|
with monkeypatch.context() as m:
|
|
m.setattr(DataFrame, "_metadata", ["filename"])
|
|
m.setattr(DataFrame, "__finalize__", finalize)
|
|
|
|
df1 = DataFrame(
|
|
np.random.default_rng(2).integers(0, 4, (3, 2)), columns=["a", "b"]
|
|
)
|
|
df2 = DataFrame(
|
|
np.random.default_rng(2).integers(0, 4, (3, 2)), columns=["c", "d"]
|
|
)
|
|
DataFrame._metadata = ["filename"]
|
|
df1.filename = "fname1.csv"
|
|
df2.filename = "fname2.csv"
|
|
|
|
result = df1.merge(df2, left_on=["a"], right_on=["c"], how="inner")
|
|
assert result.filename == "fname1.csv|fname2.csv"
|
|
|
|
# concat
|
|
# GH#6927
|
|
df1 = DataFrame(
|
|
np.random.default_rng(2).integers(0, 4, (3, 2)), columns=list("ab")
|
|
)
|
|
df1.filename = "foo"
|
|
|
|
result = pd.concat([df1, df1])
|
|
assert result.filename == "foo+foo"
|
|
|
|
def test_set_attribute(self):
|
|
# Test for consistent setattr behavior when an attribute and a column
|
|
# have the same name (Issue #8994)
|
|
df = DataFrame({"x": [1, 2, 3]})
|
|
|
|
df.y = 2
|
|
df["y"] = [2, 4, 6]
|
|
df.y = 5
|
|
|
|
assert df.y == 5
|
|
tm.assert_series_equal(df["y"], Series([2, 4, 6], name="y"))
|
|
|
|
def test_deepcopy_empty(self):
|
|
# This test covers empty frame copying with non-empty column sets
|
|
# as reported in issue GH15370
|
|
empty_frame = DataFrame(data=[], index=[], columns=["A"])
|
|
empty_frame_copy = deepcopy(empty_frame)
|
|
|
|
tm.assert_frame_equal(empty_frame_copy, empty_frame)
|
|
|
|
|
|
# formerly in Generic but only test DataFrame
|
|
class TestDataFrame2:
|
|
@pytest.mark.parametrize("value", [1, "True", [1, 2, 3], 5.0])
|
|
def test_validate_bool_args(self, value):
|
|
df = DataFrame({"a": [1, 2, 3], "b": [4, 5, 6]})
|
|
|
|
msg = 'For argument "inplace" expected type bool, received type'
|
|
with pytest.raises(ValueError, match=msg):
|
|
df.copy().rename_axis(mapper={"a": "x", "b": "y"}, axis=1, inplace=value)
|
|
|
|
with pytest.raises(ValueError, match=msg):
|
|
df.copy().drop("a", axis=1, inplace=value)
|
|
|
|
with pytest.raises(ValueError, match=msg):
|
|
df.copy().fillna(value=0, inplace=value)
|
|
|
|
with pytest.raises(ValueError, match=msg):
|
|
df.copy().replace(to_replace=1, value=7, inplace=value)
|
|
|
|
with pytest.raises(ValueError, match=msg):
|
|
df.copy().interpolate(inplace=value)
|
|
|
|
with pytest.raises(ValueError, match=msg):
|
|
df.copy()._where(cond=df.a > 2, inplace=value)
|
|
|
|
with pytest.raises(ValueError, match=msg):
|
|
df.copy().mask(cond=df.a > 2, inplace=value)
|
|
|
|
def test_unexpected_keyword(self):
|
|
# GH8597
|
|
df = DataFrame(
|
|
np.random.default_rng(2).standard_normal((5, 2)), columns=["jim", "joe"]
|
|
)
|
|
ca = pd.Categorical([0, 0, 2, 2, 3, np.nan])
|
|
ts = df["joe"].copy()
|
|
ts[2] = np.nan
|
|
|
|
msg = "unexpected keyword"
|
|
with pytest.raises(TypeError, match=msg):
|
|
df.drop("joe", axis=1, in_place=True)
|
|
|
|
with pytest.raises(TypeError, match=msg):
|
|
df.reindex([1, 0], inplace=True)
|
|
|
|
with pytest.raises(TypeError, match=msg):
|
|
ca.fillna(0, inplace=True)
|
|
|
|
with pytest.raises(TypeError, match=msg):
|
|
ts.fillna(0, in_place=True)
|