virtuelle Umgebungen teil20 und teil20a
This commit is contained in:
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
@@ -0,0 +1,180 @@
|
||||
from datetime import datetime
|
||||
import warnings
|
||||
|
||||
import numpy as np
|
||||
import pytest
|
||||
|
||||
from pandas import (
|
||||
DataFrame,
|
||||
Series,
|
||||
)
|
||||
from pandas.core.indexes.datetimes import date_range
|
||||
from pandas.core.indexes.period import period_range
|
||||
|
||||
# The various methods we support
|
||||
downsample_methods = [
|
||||
"min",
|
||||
"max",
|
||||
"first",
|
||||
"last",
|
||||
"sum",
|
||||
"mean",
|
||||
"sem",
|
||||
"median",
|
||||
"prod",
|
||||
"var",
|
||||
"std",
|
||||
"ohlc",
|
||||
"quantile",
|
||||
]
|
||||
upsample_methods = ["count", "size"]
|
||||
series_methods = ["nunique"]
|
||||
resample_methods = downsample_methods + upsample_methods + series_methods
|
||||
|
||||
|
||||
@pytest.fixture(params=downsample_methods)
|
||||
def downsample_method(request):
|
||||
"""Fixture for parametrization of Grouper downsample methods."""
|
||||
return request.param
|
||||
|
||||
|
||||
@pytest.fixture(params=resample_methods)
|
||||
def resample_method(request):
|
||||
"""Fixture for parametrization of Grouper resample methods."""
|
||||
return request.param
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def simple_date_range_series():
|
||||
"""
|
||||
Series with date range index and random data for test purposes.
|
||||
"""
|
||||
|
||||
def _simple_date_range_series(start, end, freq="D"):
|
||||
rng = date_range(start, end, freq=freq)
|
||||
return Series(np.random.default_rng(2).standard_normal(len(rng)), index=rng)
|
||||
|
||||
return _simple_date_range_series
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def simple_period_range_series():
|
||||
"""
|
||||
Series with period range index and random data for test purposes.
|
||||
"""
|
||||
|
||||
def _simple_period_range_series(start, end, freq="D"):
|
||||
with warnings.catch_warnings():
|
||||
# suppress Period[B] deprecation warning
|
||||
msg = "|".join(["Period with BDay freq", r"PeriodDtype\[B\] is deprecated"])
|
||||
warnings.filterwarnings(
|
||||
"ignore",
|
||||
msg,
|
||||
category=FutureWarning,
|
||||
)
|
||||
rng = period_range(start, end, freq=freq)
|
||||
return Series(np.random.default_rng(2).standard_normal(len(rng)), index=rng)
|
||||
|
||||
return _simple_period_range_series
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def _index_start():
|
||||
"""Fixture for parametrization of index, series and frame."""
|
||||
return datetime(2005, 1, 1)
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def _index_end():
|
||||
"""Fixture for parametrization of index, series and frame."""
|
||||
return datetime(2005, 1, 10)
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def _index_freq():
|
||||
"""Fixture for parametrization of index, series and frame."""
|
||||
return "D"
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def _index_name():
|
||||
"""Fixture for parametrization of index, series and frame."""
|
||||
return None
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def index(_index_factory, _index_start, _index_end, _index_freq, _index_name):
|
||||
"""
|
||||
Fixture for parametrization of date_range, period_range and
|
||||
timedelta_range indexes
|
||||
"""
|
||||
return _index_factory(_index_start, _index_end, freq=_index_freq, name=_index_name)
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def _static_values(index):
|
||||
"""
|
||||
Fixture for parametrization of values used in parametrization of
|
||||
Series and DataFrames with date_range, period_range and
|
||||
timedelta_range indexes
|
||||
"""
|
||||
return np.arange(len(index))
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def _series_name():
|
||||
"""
|
||||
Fixture for parametrization of Series name for Series used with
|
||||
date_range, period_range and timedelta_range indexes
|
||||
"""
|
||||
return None
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def series(index, _series_name, _static_values):
|
||||
"""
|
||||
Fixture for parametrization of Series with date_range, period_range and
|
||||
timedelta_range indexes
|
||||
"""
|
||||
return Series(_static_values, index=index, name=_series_name)
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def empty_series_dti(series):
|
||||
"""
|
||||
Fixture for parametrization of empty Series with date_range,
|
||||
period_range and timedelta_range indexes
|
||||
"""
|
||||
return series[:0]
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def frame(index, _series_name, _static_values):
|
||||
"""
|
||||
Fixture for parametrization of DataFrame with date_range, period_range
|
||||
and timedelta_range indexes
|
||||
"""
|
||||
# _series_name is intentionally unused
|
||||
return DataFrame({"value": _static_values}, index=index)
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def empty_frame_dti(series):
|
||||
"""
|
||||
Fixture for parametrization of empty DataFrame with date_range,
|
||||
period_range and timedelta_range indexes
|
||||
"""
|
||||
index = series.index[:0]
|
||||
return DataFrame(index=index)
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def series_and_frame(frame_or_series, series, frame):
|
||||
"""
|
||||
Fixture for parametrization of Series and DataFrame with date_range,
|
||||
period_range and timedelta_range indexes
|
||||
"""
|
||||
if frame_or_series == Series:
|
||||
return series
|
||||
if frame_or_series == DataFrame:
|
||||
return frame
|
@@ -0,0 +1,341 @@
|
||||
from datetime import datetime
|
||||
|
||||
import numpy as np
|
||||
import pytest
|
||||
|
||||
from pandas import (
|
||||
DataFrame,
|
||||
MultiIndex,
|
||||
NaT,
|
||||
PeriodIndex,
|
||||
Series,
|
||||
TimedeltaIndex,
|
||||
)
|
||||
import pandas._testing as tm
|
||||
from pandas.core.groupby.groupby import DataError
|
||||
from pandas.core.groupby.grouper import Grouper
|
||||
from pandas.core.indexes.datetimes import date_range
|
||||
from pandas.core.indexes.period import period_range
|
||||
from pandas.core.indexes.timedeltas import timedelta_range
|
||||
from pandas.core.resample import _asfreq_compat
|
||||
|
||||
# a fixture value can be overridden by the test parameter value. Note that the
|
||||
# value of the fixture can be overridden this way even if the test doesn't use
|
||||
# it directly (doesn't mention it in the function prototype).
|
||||
# see https://docs.pytest.org/en/latest/fixture.html#override-a-fixture-with-direct-test-parametrization # noqa: E501
|
||||
# in this module we override the fixture values defined in conftest.py
|
||||
# tuples of '_index_factory,_series_name,_index_start,_index_end'
|
||||
DATE_RANGE = (date_range, "dti", datetime(2005, 1, 1), datetime(2005, 1, 10))
|
||||
PERIOD_RANGE = (period_range, "pi", datetime(2005, 1, 1), datetime(2005, 1, 10))
|
||||
TIMEDELTA_RANGE = (timedelta_range, "tdi", "1 day", "10 day")
|
||||
|
||||
all_ts = pytest.mark.parametrize(
|
||||
"_index_factory,_series_name,_index_start,_index_end",
|
||||
[DATE_RANGE, PERIOD_RANGE, TIMEDELTA_RANGE],
|
||||
)
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def create_index(_index_factory):
|
||||
def _create_index(*args, **kwargs):
|
||||
"""return the _index_factory created using the args, kwargs"""
|
||||
return _index_factory(*args, **kwargs)
|
||||
|
||||
return _create_index
|
||||
|
||||
|
||||
@pytest.mark.parametrize("freq", ["2D", "1H"])
|
||||
@pytest.mark.parametrize(
|
||||
"_index_factory,_series_name,_index_start,_index_end", [DATE_RANGE, TIMEDELTA_RANGE]
|
||||
)
|
||||
def test_asfreq(series_and_frame, freq, create_index):
|
||||
obj = series_and_frame
|
||||
|
||||
result = obj.resample(freq).asfreq()
|
||||
new_index = create_index(obj.index[0], obj.index[-1], freq=freq)
|
||||
expected = obj.reindex(new_index)
|
||||
tm.assert_almost_equal(result, expected)
|
||||
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
"_index_factory,_series_name,_index_start,_index_end", [DATE_RANGE, TIMEDELTA_RANGE]
|
||||
)
|
||||
def test_asfreq_fill_value(series, create_index):
|
||||
# test for fill value during resampling, issue 3715
|
||||
|
||||
ser = series
|
||||
|
||||
result = ser.resample("1H").asfreq()
|
||||
new_index = create_index(ser.index[0], ser.index[-1], freq="1H")
|
||||
expected = ser.reindex(new_index)
|
||||
tm.assert_series_equal(result, expected)
|
||||
|
||||
# Explicit cast to float to avoid implicit cast when setting None
|
||||
frame = ser.astype("float").to_frame("value")
|
||||
frame.iloc[1] = None
|
||||
result = frame.resample("1H").asfreq(fill_value=4.0)
|
||||
new_index = create_index(frame.index[0], frame.index[-1], freq="1H")
|
||||
expected = frame.reindex(new_index, fill_value=4.0)
|
||||
tm.assert_frame_equal(result, expected)
|
||||
|
||||
|
||||
@all_ts
|
||||
def test_resample_interpolate(frame):
|
||||
# GH#12925
|
||||
df = frame
|
||||
result = df.resample("1T").asfreq().interpolate()
|
||||
expected = df.resample("1T").interpolate()
|
||||
tm.assert_frame_equal(result, expected)
|
||||
|
||||
|
||||
def test_raises_on_non_datetimelike_index():
|
||||
# this is a non datetimelike index
|
||||
xp = DataFrame()
|
||||
msg = (
|
||||
"Only valid with DatetimeIndex, TimedeltaIndex or PeriodIndex, "
|
||||
"but got an instance of 'RangeIndex'"
|
||||
)
|
||||
with pytest.raises(TypeError, match=msg):
|
||||
xp.resample("A")
|
||||
|
||||
|
||||
@all_ts
|
||||
@pytest.mark.parametrize("freq", ["M", "D", "H"])
|
||||
def test_resample_empty_series(freq, empty_series_dti, resample_method):
|
||||
# GH12771 & GH12868
|
||||
|
||||
ser = empty_series_dti
|
||||
if freq == "M" and isinstance(ser.index, TimedeltaIndex):
|
||||
msg = (
|
||||
"Resampling on a TimedeltaIndex requires fixed-duration `freq`, "
|
||||
"e.g. '24H' or '3D', not <MonthEnd>"
|
||||
)
|
||||
with pytest.raises(ValueError, match=msg):
|
||||
ser.resample(freq)
|
||||
return
|
||||
|
||||
rs = ser.resample(freq)
|
||||
result = getattr(rs, resample_method)()
|
||||
|
||||
if resample_method == "ohlc":
|
||||
expected = DataFrame(
|
||||
[], index=ser.index[:0].copy(), columns=["open", "high", "low", "close"]
|
||||
)
|
||||
expected.index = _asfreq_compat(ser.index, freq)
|
||||
tm.assert_frame_equal(result, expected, check_dtype=False)
|
||||
else:
|
||||
expected = ser.copy()
|
||||
expected.index = _asfreq_compat(ser.index, freq)
|
||||
tm.assert_series_equal(result, expected, check_dtype=False)
|
||||
|
||||
tm.assert_index_equal(result.index, expected.index)
|
||||
assert result.index.freq == expected.index.freq
|
||||
|
||||
|
||||
@all_ts
|
||||
@pytest.mark.parametrize(
|
||||
"freq",
|
||||
[
|
||||
pytest.param("M", marks=pytest.mark.xfail(reason="Don't know why this fails")),
|
||||
"D",
|
||||
"H",
|
||||
],
|
||||
)
|
||||
def test_resample_nat_index_series(freq, series, resample_method):
|
||||
# GH39227
|
||||
|
||||
ser = series.copy()
|
||||
ser.index = PeriodIndex([NaT] * len(ser), freq=freq)
|
||||
rs = ser.resample(freq)
|
||||
result = getattr(rs, resample_method)()
|
||||
|
||||
if resample_method == "ohlc":
|
||||
expected = DataFrame(
|
||||
[], index=ser.index[:0].copy(), columns=["open", "high", "low", "close"]
|
||||
)
|
||||
tm.assert_frame_equal(result, expected, check_dtype=False)
|
||||
else:
|
||||
expected = ser[:0].copy()
|
||||
tm.assert_series_equal(result, expected, check_dtype=False)
|
||||
tm.assert_index_equal(result.index, expected.index)
|
||||
assert result.index.freq == expected.index.freq
|
||||
|
||||
|
||||
@all_ts
|
||||
@pytest.mark.parametrize("freq", ["M", "D", "H"])
|
||||
@pytest.mark.parametrize("resample_method", ["count", "size"])
|
||||
def test_resample_count_empty_series(freq, empty_series_dti, resample_method):
|
||||
# GH28427
|
||||
ser = empty_series_dti
|
||||
if freq == "M" and isinstance(ser.index, TimedeltaIndex):
|
||||
msg = (
|
||||
"Resampling on a TimedeltaIndex requires fixed-duration `freq`, "
|
||||
"e.g. '24H' or '3D', not <MonthEnd>"
|
||||
)
|
||||
with pytest.raises(ValueError, match=msg):
|
||||
ser.resample(freq)
|
||||
return
|
||||
|
||||
rs = ser.resample(freq)
|
||||
|
||||
result = getattr(rs, resample_method)()
|
||||
|
||||
index = _asfreq_compat(ser.index, freq)
|
||||
|
||||
expected = Series([], dtype="int64", index=index, name=ser.name)
|
||||
|
||||
tm.assert_series_equal(result, expected)
|
||||
|
||||
|
||||
@all_ts
|
||||
@pytest.mark.parametrize("freq", ["M", "D", "H"])
|
||||
def test_resample_empty_dataframe(empty_frame_dti, freq, resample_method):
|
||||
# GH13212
|
||||
df = empty_frame_dti
|
||||
# count retains dimensions too
|
||||
if freq == "M" and isinstance(df.index, TimedeltaIndex):
|
||||
msg = (
|
||||
"Resampling on a TimedeltaIndex requires fixed-duration `freq`, "
|
||||
"e.g. '24H' or '3D', not <MonthEnd>"
|
||||
)
|
||||
with pytest.raises(ValueError, match=msg):
|
||||
df.resample(freq, group_keys=False)
|
||||
return
|
||||
|
||||
rs = df.resample(freq, group_keys=False)
|
||||
result = getattr(rs, resample_method)()
|
||||
if resample_method == "ohlc":
|
||||
# TODO: no tests with len(df.columns) > 0
|
||||
mi = MultiIndex.from_product([df.columns, ["open", "high", "low", "close"]])
|
||||
expected = DataFrame(
|
||||
[], index=df.index[:0].copy(), columns=mi, dtype=np.float64
|
||||
)
|
||||
expected.index = _asfreq_compat(df.index, freq)
|
||||
|
||||
elif resample_method != "size":
|
||||
expected = df.copy()
|
||||
else:
|
||||
# GH14962
|
||||
expected = Series([], dtype=np.int64)
|
||||
|
||||
expected.index = _asfreq_compat(df.index, freq)
|
||||
|
||||
tm.assert_index_equal(result.index, expected.index)
|
||||
assert result.index.freq == expected.index.freq
|
||||
tm.assert_almost_equal(result, expected)
|
||||
|
||||
# test size for GH13212 (currently stays as df)
|
||||
|
||||
|
||||
@all_ts
|
||||
@pytest.mark.parametrize("freq", ["M", "D", "H"])
|
||||
def test_resample_count_empty_dataframe(freq, empty_frame_dti):
|
||||
# GH28427
|
||||
|
||||
empty_frame_dti["a"] = []
|
||||
|
||||
if freq == "M" and isinstance(empty_frame_dti.index, TimedeltaIndex):
|
||||
msg = (
|
||||
"Resampling on a TimedeltaIndex requires fixed-duration `freq`, "
|
||||
"e.g. '24H' or '3D', not <MonthEnd>"
|
||||
)
|
||||
with pytest.raises(ValueError, match=msg):
|
||||
empty_frame_dti.resample(freq)
|
||||
return
|
||||
|
||||
result = empty_frame_dti.resample(freq).count()
|
||||
|
||||
index = _asfreq_compat(empty_frame_dti.index, freq)
|
||||
|
||||
expected = DataFrame({"a": []}, dtype="int64", index=index)
|
||||
|
||||
tm.assert_frame_equal(result, expected)
|
||||
|
||||
|
||||
@all_ts
|
||||
@pytest.mark.parametrize("freq", ["M", "D", "H"])
|
||||
def test_resample_size_empty_dataframe(freq, empty_frame_dti):
|
||||
# GH28427
|
||||
|
||||
empty_frame_dti["a"] = []
|
||||
|
||||
if freq == "M" and isinstance(empty_frame_dti.index, TimedeltaIndex):
|
||||
msg = (
|
||||
"Resampling on a TimedeltaIndex requires fixed-duration `freq`, "
|
||||
"e.g. '24H' or '3D', not <MonthEnd>"
|
||||
)
|
||||
with pytest.raises(ValueError, match=msg):
|
||||
empty_frame_dti.resample(freq)
|
||||
return
|
||||
|
||||
result = empty_frame_dti.resample(freq).size()
|
||||
|
||||
index = _asfreq_compat(empty_frame_dti.index, freq)
|
||||
|
||||
expected = Series([], dtype="int64", index=index)
|
||||
|
||||
tm.assert_series_equal(result, expected)
|
||||
|
||||
|
||||
@pytest.mark.filterwarnings(r"ignore:PeriodDtype\[B\] is deprecated:FutureWarning")
|
||||
@pytest.mark.parametrize("index", tm.all_timeseries_index_generator(0))
|
||||
@pytest.mark.parametrize("dtype", [float, int, object, "datetime64[ns]"])
|
||||
def test_resample_empty_dtypes(index, dtype, resample_method):
|
||||
# Empty series were sometimes causing a segfault (for the functions
|
||||
# with Cython bounds-checking disabled) or an IndexError. We just run
|
||||
# them to ensure they no longer do. (GH #10228)
|
||||
if isinstance(index, PeriodIndex):
|
||||
# GH#53511
|
||||
index = PeriodIndex([], freq="B", name=index.name)
|
||||
empty_series_dti = Series([], index, dtype)
|
||||
rs = empty_series_dti.resample("d", group_keys=False)
|
||||
try:
|
||||
getattr(rs, resample_method)()
|
||||
except DataError:
|
||||
# Ignore these since some combinations are invalid
|
||||
# (ex: doing mean with dtype of np.object_)
|
||||
pass
|
||||
|
||||
|
||||
@all_ts
|
||||
@pytest.mark.parametrize("freq", ["M", "D", "H"])
|
||||
def test_apply_to_empty_series(empty_series_dti, freq):
|
||||
# GH 14313
|
||||
ser = empty_series_dti
|
||||
|
||||
if freq == "M" and isinstance(empty_series_dti.index, TimedeltaIndex):
|
||||
msg = (
|
||||
"Resampling on a TimedeltaIndex requires fixed-duration `freq`, "
|
||||
"e.g. '24H' or '3D', not <MonthEnd>"
|
||||
)
|
||||
with pytest.raises(ValueError, match=msg):
|
||||
empty_series_dti.resample(freq)
|
||||
return
|
||||
|
||||
result = ser.resample(freq, group_keys=False).apply(lambda x: 1)
|
||||
expected = ser.resample(freq).apply("sum")
|
||||
|
||||
tm.assert_series_equal(result, expected, check_dtype=False)
|
||||
|
||||
|
||||
@all_ts
|
||||
def test_resampler_is_iterable(series):
|
||||
# GH 15314
|
||||
freq = "H"
|
||||
tg = Grouper(freq=freq, convention="start")
|
||||
grouped = series.groupby(tg)
|
||||
resampled = series.resample(freq)
|
||||
for (rk, rv), (gk, gv) in zip(resampled, grouped):
|
||||
assert rk == gk
|
||||
tm.assert_series_equal(rv, gv)
|
||||
|
||||
|
||||
@all_ts
|
||||
def test_resample_quantile(series):
|
||||
# GH 15023
|
||||
ser = series
|
||||
q = 0.75
|
||||
freq = "H"
|
||||
result = ser.resample(freq).quantile(q)
|
||||
expected = ser.resample(freq).agg(lambda x: x.quantile(q)).rename(ser.name)
|
||||
tm.assert_series_equal(result, expected)
|
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,895 @@
|
||||
from datetime import datetime
|
||||
|
||||
import dateutil
|
||||
import numpy as np
|
||||
import pytest
|
||||
import pytz
|
||||
|
||||
from pandas._libs.tslibs.ccalendar import (
|
||||
DAYS,
|
||||
MONTHS,
|
||||
)
|
||||
from pandas._libs.tslibs.period import IncompatibleFrequency
|
||||
from pandas.errors import InvalidIndexError
|
||||
|
||||
import pandas as pd
|
||||
from pandas import (
|
||||
DataFrame,
|
||||
Series,
|
||||
Timestamp,
|
||||
)
|
||||
import pandas._testing as tm
|
||||
from pandas.core.indexes.datetimes import date_range
|
||||
from pandas.core.indexes.period import (
|
||||
Period,
|
||||
PeriodIndex,
|
||||
period_range,
|
||||
)
|
||||
from pandas.core.resample import _get_period_range_edges
|
||||
|
||||
from pandas.tseries import offsets
|
||||
|
||||
|
||||
@pytest.fixture()
|
||||
def _index_factory():
|
||||
return period_range
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def _series_name():
|
||||
return "pi"
|
||||
|
||||
|
||||
class TestPeriodIndex:
|
||||
@pytest.mark.parametrize("freq", ["2D", "1H", "2H"])
|
||||
@pytest.mark.parametrize("kind", ["period", None, "timestamp"])
|
||||
def test_asfreq(self, series_and_frame, freq, kind):
|
||||
# GH 12884, 15944
|
||||
# make sure .asfreq() returns PeriodIndex (except kind='timestamp')
|
||||
|
||||
obj = series_and_frame
|
||||
if kind == "timestamp":
|
||||
expected = obj.to_timestamp().resample(freq).asfreq()
|
||||
else:
|
||||
start = obj.index[0].to_timestamp(how="start")
|
||||
end = (obj.index[-1] + obj.index.freq).to_timestamp(how="start")
|
||||
new_index = date_range(start=start, end=end, freq=freq, inclusive="left")
|
||||
expected = obj.to_timestamp().reindex(new_index).to_period(freq)
|
||||
result = obj.resample(freq, kind=kind).asfreq()
|
||||
tm.assert_almost_equal(result, expected)
|
||||
|
||||
def test_asfreq_fill_value(self, series):
|
||||
# test for fill value during resampling, issue 3715
|
||||
|
||||
s = series
|
||||
new_index = date_range(
|
||||
s.index[0].to_timestamp(how="start"),
|
||||
(s.index[-1]).to_timestamp(how="start"),
|
||||
freq="1H",
|
||||
)
|
||||
expected = s.to_timestamp().reindex(new_index, fill_value=4.0)
|
||||
result = s.resample("1H", kind="timestamp").asfreq(fill_value=4.0)
|
||||
tm.assert_series_equal(result, expected)
|
||||
|
||||
frame = s.to_frame("value")
|
||||
new_index = date_range(
|
||||
frame.index[0].to_timestamp(how="start"),
|
||||
(frame.index[-1]).to_timestamp(how="start"),
|
||||
freq="1H",
|
||||
)
|
||||
expected = frame.to_timestamp().reindex(new_index, fill_value=3.0)
|
||||
result = frame.resample("1H", kind="timestamp").asfreq(fill_value=3.0)
|
||||
tm.assert_frame_equal(result, expected)
|
||||
|
||||
@pytest.mark.parametrize("freq", ["H", "12H", "2D", "W"])
|
||||
@pytest.mark.parametrize("kind", [None, "period", "timestamp"])
|
||||
@pytest.mark.parametrize("kwargs", [{"on": "date"}, {"level": "d"}])
|
||||
def test_selection(self, index, freq, kind, kwargs):
|
||||
# This is a bug, these should be implemented
|
||||
# GH 14008
|
||||
rng = np.arange(len(index), dtype=np.int64)
|
||||
df = DataFrame(
|
||||
{"date": index, "a": rng},
|
||||
index=pd.MultiIndex.from_arrays([rng, index], names=["v", "d"]),
|
||||
)
|
||||
msg = (
|
||||
"Resampling from level= or on= selection with a PeriodIndex is "
|
||||
r"not currently supported, use \.set_index\(\.\.\.\) to "
|
||||
"explicitly set index"
|
||||
)
|
||||
with pytest.raises(NotImplementedError, match=msg):
|
||||
df.resample(freq, kind=kind, **kwargs)
|
||||
|
||||
@pytest.mark.parametrize("month", MONTHS)
|
||||
@pytest.mark.parametrize("meth", ["ffill", "bfill"])
|
||||
@pytest.mark.parametrize("conv", ["start", "end"])
|
||||
@pytest.mark.parametrize("targ", ["D", "B", "M"])
|
||||
def test_annual_upsample_cases(
|
||||
self, targ, conv, meth, month, simple_period_range_series
|
||||
):
|
||||
ts = simple_period_range_series("1/1/1990", "12/31/1991", freq=f"A-{month}")
|
||||
warn = FutureWarning if targ == "B" else None
|
||||
msg = r"PeriodDtype\[B\] is deprecated"
|
||||
with tm.assert_produces_warning(warn, match=msg):
|
||||
result = getattr(ts.resample(targ, convention=conv), meth)()
|
||||
expected = result.to_timestamp(targ, how=conv)
|
||||
expected = expected.asfreq(targ, meth).to_period()
|
||||
tm.assert_series_equal(result, expected)
|
||||
|
||||
def test_basic_downsample(self, simple_period_range_series):
|
||||
ts = simple_period_range_series("1/1/1990", "6/30/1995", freq="M")
|
||||
result = ts.resample("a-dec").mean()
|
||||
|
||||
expected = ts.groupby(ts.index.year).mean()
|
||||
expected.index = period_range("1/1/1990", "6/30/1995", freq="a-dec")
|
||||
tm.assert_series_equal(result, expected)
|
||||
|
||||
# this is ok
|
||||
tm.assert_series_equal(ts.resample("a-dec").mean(), result)
|
||||
tm.assert_series_equal(ts.resample("a").mean(), result)
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
"rule,expected_error_msg",
|
||||
[
|
||||
("a-dec", "<YearEnd: month=12>"),
|
||||
("q-mar", "<QuarterEnd: startingMonth=3>"),
|
||||
("M", "<MonthEnd>"),
|
||||
("w-thu", "<Week: weekday=3>"),
|
||||
],
|
||||
)
|
||||
def test_not_subperiod(self, simple_period_range_series, rule, expected_error_msg):
|
||||
# These are incompatible period rules for resampling
|
||||
ts = simple_period_range_series("1/1/1990", "6/30/1995", freq="w-wed")
|
||||
msg = (
|
||||
"Frequency <Week: weekday=2> cannot be resampled to "
|
||||
f"{expected_error_msg}, as they are not sub or super periods"
|
||||
)
|
||||
with pytest.raises(IncompatibleFrequency, match=msg):
|
||||
ts.resample(rule).mean()
|
||||
|
||||
@pytest.mark.parametrize("freq", ["D", "2D"])
|
||||
def test_basic_upsample(self, freq, simple_period_range_series):
|
||||
ts = simple_period_range_series("1/1/1990", "6/30/1995", freq="M")
|
||||
result = ts.resample("a-dec").mean()
|
||||
|
||||
resampled = result.resample(freq, convention="end").ffill()
|
||||
expected = result.to_timestamp(freq, how="end")
|
||||
expected = expected.asfreq(freq, "ffill").to_period(freq)
|
||||
tm.assert_series_equal(resampled, expected)
|
||||
|
||||
def test_upsample_with_limit(self):
|
||||
rng = period_range("1/1/2000", periods=5, freq="A")
|
||||
ts = Series(np.random.default_rng(2).standard_normal(len(rng)), rng)
|
||||
|
||||
result = ts.resample("M", convention="end").ffill(limit=2)
|
||||
expected = ts.asfreq("M").reindex(result.index, method="ffill", limit=2)
|
||||
tm.assert_series_equal(result, expected)
|
||||
|
||||
def test_annual_upsample(self, simple_period_range_series):
|
||||
ts = simple_period_range_series("1/1/1990", "12/31/1995", freq="A-DEC")
|
||||
df = DataFrame({"a": ts})
|
||||
rdf = df.resample("D").ffill()
|
||||
exp = df["a"].resample("D").ffill()
|
||||
tm.assert_series_equal(rdf["a"], exp)
|
||||
|
||||
rng = period_range("2000", "2003", freq="A-DEC")
|
||||
ts = Series([1, 2, 3, 4], index=rng)
|
||||
|
||||
result = ts.resample("M").ffill()
|
||||
ex_index = period_range("2000-01", "2003-12", freq="M")
|
||||
|
||||
expected = ts.asfreq("M", how="start").reindex(ex_index, method="ffill")
|
||||
tm.assert_series_equal(result, expected)
|
||||
|
||||
@pytest.mark.parametrize("month", MONTHS)
|
||||
@pytest.mark.parametrize("target", ["D", "B", "M"])
|
||||
@pytest.mark.parametrize("convention", ["start", "end"])
|
||||
def test_quarterly_upsample(
|
||||
self, month, target, convention, simple_period_range_series
|
||||
):
|
||||
freq = f"Q-{month}"
|
||||
ts = simple_period_range_series("1/1/1990", "12/31/1995", freq=freq)
|
||||
warn = FutureWarning if target == "B" else None
|
||||
msg = r"PeriodDtype\[B\] is deprecated"
|
||||
with tm.assert_produces_warning(warn, match=msg):
|
||||
result = ts.resample(target, convention=convention).ffill()
|
||||
expected = result.to_timestamp(target, how=convention)
|
||||
expected = expected.asfreq(target, "ffill").to_period()
|
||||
tm.assert_series_equal(result, expected)
|
||||
|
||||
@pytest.mark.parametrize("target", ["D", "B"])
|
||||
@pytest.mark.parametrize("convention", ["start", "end"])
|
||||
def test_monthly_upsample(self, target, convention, simple_period_range_series):
|
||||
ts = simple_period_range_series("1/1/1990", "12/31/1995", freq="M")
|
||||
|
||||
warn = None if target == "D" else FutureWarning
|
||||
msg = r"PeriodDtype\[B\] is deprecated"
|
||||
with tm.assert_produces_warning(warn, match=msg):
|
||||
result = ts.resample(target, convention=convention).ffill()
|
||||
expected = result.to_timestamp(target, how=convention)
|
||||
expected = expected.asfreq(target, "ffill").to_period()
|
||||
tm.assert_series_equal(result, expected)
|
||||
|
||||
def test_resample_basic(self):
|
||||
# GH3609
|
||||
s = Series(
|
||||
range(100),
|
||||
index=date_range("20130101", freq="s", periods=100, name="idx"),
|
||||
dtype="float",
|
||||
)
|
||||
s[10:30] = np.nan
|
||||
index = PeriodIndex(
|
||||
[Period("2013-01-01 00:00", "T"), Period("2013-01-01 00:01", "T")],
|
||||
name="idx",
|
||||
)
|
||||
expected = Series([34.5, 79.5], index=index)
|
||||
result = s.to_period().resample("T", kind="period").mean()
|
||||
tm.assert_series_equal(result, expected)
|
||||
result2 = s.resample("T", kind="period").mean()
|
||||
tm.assert_series_equal(result2, expected)
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
"freq,expected_vals", [("M", [31, 29, 31, 9]), ("2M", [31 + 29, 31 + 9])]
|
||||
)
|
||||
def test_resample_count(self, freq, expected_vals):
|
||||
# GH12774
|
||||
series = Series(1, index=period_range(start="2000", periods=100))
|
||||
result = series.resample(freq).count()
|
||||
expected_index = period_range(
|
||||
start="2000", freq=freq, periods=len(expected_vals)
|
||||
)
|
||||
expected = Series(expected_vals, index=expected_index)
|
||||
tm.assert_series_equal(result, expected)
|
||||
|
||||
def test_resample_same_freq(self, resample_method):
|
||||
# GH12770
|
||||
series = Series(range(3), index=period_range(start="2000", periods=3, freq="M"))
|
||||
expected = series
|
||||
|
||||
result = getattr(series.resample("M"), resample_method)()
|
||||
tm.assert_series_equal(result, expected)
|
||||
|
||||
def test_resample_incompat_freq(self):
|
||||
msg = (
|
||||
"Frequency <MonthEnd> cannot be resampled to <Week: weekday=6>, "
|
||||
"as they are not sub or super periods"
|
||||
)
|
||||
with pytest.raises(IncompatibleFrequency, match=msg):
|
||||
Series(
|
||||
range(3), index=period_range(start="2000", periods=3, freq="M")
|
||||
).resample("W").mean()
|
||||
|
||||
def test_with_local_timezone_pytz(self):
|
||||
# see gh-5430
|
||||
local_timezone = pytz.timezone("America/Los_Angeles")
|
||||
|
||||
start = datetime(year=2013, month=11, day=1, hour=0, minute=0, tzinfo=pytz.utc)
|
||||
# 1 day later
|
||||
end = datetime(year=2013, month=11, day=2, hour=0, minute=0, tzinfo=pytz.utc)
|
||||
|
||||
index = date_range(start, end, freq="H")
|
||||
|
||||
series = Series(1, index=index)
|
||||
series = series.tz_convert(local_timezone)
|
||||
result = series.resample("D", kind="period").mean()
|
||||
|
||||
# Create the expected series
|
||||
# Index is moved back a day with the timezone conversion from UTC to
|
||||
# Pacific
|
||||
expected_index = period_range(start=start, end=end, freq="D") - offsets.Day()
|
||||
expected = Series(1.0, index=expected_index)
|
||||
tm.assert_series_equal(result, expected)
|
||||
|
||||
def test_resample_with_pytz(self):
|
||||
# GH 13238
|
||||
s = Series(
|
||||
2, index=date_range("2017-01-01", periods=48, freq="H", tz="US/Eastern")
|
||||
)
|
||||
result = s.resample("D").mean()
|
||||
expected = Series(
|
||||
2.0,
|
||||
index=pd.DatetimeIndex(
|
||||
["2017-01-01", "2017-01-02"], tz="US/Eastern", freq="D"
|
||||
),
|
||||
)
|
||||
tm.assert_series_equal(result, expected)
|
||||
# Especially assert that the timezone is LMT for pytz
|
||||
assert result.index.tz == pytz.timezone("US/Eastern")
|
||||
|
||||
def test_with_local_timezone_dateutil(self):
|
||||
# see gh-5430
|
||||
local_timezone = "dateutil/America/Los_Angeles"
|
||||
|
||||
start = datetime(
|
||||
year=2013, month=11, day=1, hour=0, minute=0, tzinfo=dateutil.tz.tzutc()
|
||||
)
|
||||
# 1 day later
|
||||
end = datetime(
|
||||
year=2013, month=11, day=2, hour=0, minute=0, tzinfo=dateutil.tz.tzutc()
|
||||
)
|
||||
|
||||
index = date_range(start, end, freq="H", name="idx")
|
||||
|
||||
series = Series(1, index=index)
|
||||
series = series.tz_convert(local_timezone)
|
||||
result = series.resample("D", kind="period").mean()
|
||||
|
||||
# Create the expected series
|
||||
# Index is moved back a day with the timezone conversion from UTC to
|
||||
# Pacific
|
||||
expected_index = (
|
||||
period_range(start=start, end=end, freq="D", name="idx") - offsets.Day()
|
||||
)
|
||||
expected = Series(1.0, index=expected_index)
|
||||
tm.assert_series_equal(result, expected)
|
||||
|
||||
def test_resample_nonexistent_time_bin_edge(self):
|
||||
# GH 19375
|
||||
index = date_range("2017-03-12", "2017-03-12 1:45:00", freq="15T")
|
||||
s = Series(np.zeros(len(index)), index=index)
|
||||
expected = s.tz_localize("US/Pacific")
|
||||
expected.index = pd.DatetimeIndex(expected.index, freq="900S")
|
||||
result = expected.resample("900S").mean()
|
||||
tm.assert_series_equal(result, expected)
|
||||
|
||||
# GH 23742
|
||||
index = date_range(start="2017-10-10", end="2017-10-20", freq="1H")
|
||||
index = index.tz_localize("UTC").tz_convert("America/Sao_Paulo")
|
||||
df = DataFrame(data=list(range(len(index))), index=index)
|
||||
result = df.groupby(pd.Grouper(freq="1D")).count()
|
||||
expected = date_range(
|
||||
start="2017-10-09",
|
||||
end="2017-10-20",
|
||||
freq="D",
|
||||
tz="America/Sao_Paulo",
|
||||
nonexistent="shift_forward",
|
||||
inclusive="left",
|
||||
)
|
||||
tm.assert_index_equal(result.index, expected)
|
||||
|
||||
def test_resample_ambiguous_time_bin_edge(self):
|
||||
# GH 10117
|
||||
idx = date_range(
|
||||
"2014-10-25 22:00:00", "2014-10-26 00:30:00", freq="30T", tz="Europe/London"
|
||||
)
|
||||
expected = Series(np.zeros(len(idx)), index=idx)
|
||||
result = expected.resample("30T").mean()
|
||||
tm.assert_series_equal(result, expected)
|
||||
|
||||
def test_fill_method_and_how_upsample(self):
|
||||
# GH2073
|
||||
s = Series(
|
||||
np.arange(9, dtype="int64"),
|
||||
index=date_range("2010-01-01", periods=9, freq="Q"),
|
||||
)
|
||||
last = s.resample("M").ffill()
|
||||
both = s.resample("M").ffill().resample("M").last().astype("int64")
|
||||
tm.assert_series_equal(last, both)
|
||||
|
||||
@pytest.mark.parametrize("day", DAYS)
|
||||
@pytest.mark.parametrize("target", ["D", "B"])
|
||||
@pytest.mark.parametrize("convention", ["start", "end"])
|
||||
def test_weekly_upsample(self, day, target, convention, simple_period_range_series):
|
||||
freq = f"W-{day}"
|
||||
ts = simple_period_range_series("1/1/1990", "12/31/1995", freq=freq)
|
||||
|
||||
warn = None if target == "D" else FutureWarning
|
||||
msg = r"PeriodDtype\[B\] is deprecated"
|
||||
with tm.assert_produces_warning(warn, match=msg):
|
||||
result = ts.resample(target, convention=convention).ffill()
|
||||
expected = result.to_timestamp(target, how=convention)
|
||||
expected = expected.asfreq(target, "ffill").to_period()
|
||||
tm.assert_series_equal(result, expected)
|
||||
|
||||
def test_resample_to_timestamps(self, simple_period_range_series):
|
||||
ts = simple_period_range_series("1/1/1990", "12/31/1995", freq="M")
|
||||
|
||||
result = ts.resample("A-DEC", kind="timestamp").mean()
|
||||
expected = ts.to_timestamp(how="start").resample("A-DEC").mean()
|
||||
tm.assert_series_equal(result, expected)
|
||||
|
||||
@pytest.mark.parametrize("month", MONTHS)
|
||||
def test_resample_to_quarterly(self, simple_period_range_series, month):
|
||||
ts = simple_period_range_series("1990", "1992", freq=f"A-{month}")
|
||||
quar_ts = ts.resample(f"Q-{month}").ffill()
|
||||
|
||||
stamps = ts.to_timestamp("D", how="start")
|
||||
qdates = period_range(
|
||||
ts.index[0].asfreq("D", "start"),
|
||||
ts.index[-1].asfreq("D", "end"),
|
||||
freq=f"Q-{month}",
|
||||
)
|
||||
|
||||
expected = stamps.reindex(qdates.to_timestamp("D", "s"), method="ffill")
|
||||
expected.index = qdates
|
||||
|
||||
tm.assert_series_equal(quar_ts, expected)
|
||||
|
||||
@pytest.mark.parametrize("how", ["start", "end"])
|
||||
def test_resample_to_quarterly_start_end(self, simple_period_range_series, how):
|
||||
# conforms, but different month
|
||||
ts = simple_period_range_series("1990", "1992", freq="A-JUN")
|
||||
result = ts.resample("Q-MAR", convention=how).ffill()
|
||||
expected = ts.asfreq("Q-MAR", how=how)
|
||||
expected = expected.reindex(result.index, method="ffill")
|
||||
|
||||
# .to_timestamp('D')
|
||||
# expected = expected.resample('Q-MAR').ffill()
|
||||
|
||||
tm.assert_series_equal(result, expected)
|
||||
|
||||
def test_resample_fill_missing(self):
|
||||
rng = PeriodIndex([2000, 2005, 2007, 2009], freq="A")
|
||||
|
||||
s = Series(np.random.default_rng(2).standard_normal(4), index=rng)
|
||||
|
||||
stamps = s.to_timestamp()
|
||||
filled = s.resample("A").ffill()
|
||||
expected = stamps.resample("A").ffill().to_period("A")
|
||||
tm.assert_series_equal(filled, expected)
|
||||
|
||||
def test_cant_fill_missing_dups(self):
|
||||
rng = PeriodIndex([2000, 2005, 2005, 2007, 2007], freq="A")
|
||||
s = Series(np.random.default_rng(2).standard_normal(5), index=rng)
|
||||
msg = "Reindexing only valid with uniquely valued Index objects"
|
||||
with pytest.raises(InvalidIndexError, match=msg):
|
||||
s.resample("A").ffill()
|
||||
|
||||
@pytest.mark.parametrize("freq", ["5min"])
|
||||
@pytest.mark.parametrize("kind", ["period", None, "timestamp"])
|
||||
def test_resample_5minute(self, freq, kind):
|
||||
rng = period_range("1/1/2000", "1/5/2000", freq="T")
|
||||
ts = Series(np.random.default_rng(2).standard_normal(len(rng)), index=rng)
|
||||
expected = ts.to_timestamp().resample(freq).mean()
|
||||
if kind != "timestamp":
|
||||
expected = expected.to_period(freq)
|
||||
result = ts.resample(freq, kind=kind).mean()
|
||||
tm.assert_series_equal(result, expected)
|
||||
|
||||
def test_upsample_daily_business_daily(self, simple_period_range_series):
|
||||
ts = simple_period_range_series("1/1/2000", "2/1/2000", freq="B")
|
||||
|
||||
result = ts.resample("D").asfreq()
|
||||
expected = ts.asfreq("D").reindex(period_range("1/3/2000", "2/1/2000"))
|
||||
tm.assert_series_equal(result, expected)
|
||||
|
||||
ts = simple_period_range_series("1/1/2000", "2/1/2000")
|
||||
result = ts.resample("H", convention="s").asfreq()
|
||||
exp_rng = period_range("1/1/2000", "2/1/2000 23:00", freq="H")
|
||||
expected = ts.asfreq("H", how="s").reindex(exp_rng)
|
||||
tm.assert_series_equal(result, expected)
|
||||
|
||||
def test_resample_irregular_sparse(self):
|
||||
dr = date_range(start="1/1/2012", freq="5min", periods=1000)
|
||||
s = Series(np.array(100), index=dr)
|
||||
# subset the data.
|
||||
subset = s[:"2012-01-04 06:55"]
|
||||
|
||||
result = subset.resample("10min").apply(len)
|
||||
expected = s.resample("10min").apply(len).loc[result.index]
|
||||
tm.assert_series_equal(result, expected)
|
||||
|
||||
def test_resample_weekly_all_na(self):
|
||||
rng = date_range("1/1/2000", periods=10, freq="W-WED")
|
||||
ts = Series(np.random.default_rng(2).standard_normal(len(rng)), index=rng)
|
||||
|
||||
result = ts.resample("W-THU").asfreq()
|
||||
|
||||
assert result.isna().all()
|
||||
|
||||
result = ts.resample("W-THU").asfreq().ffill()[:-1]
|
||||
expected = ts.asfreq("W-THU").ffill()
|
||||
tm.assert_series_equal(result, expected)
|
||||
|
||||
def test_resample_tz_localized(self):
|
||||
dr = date_range(start="2012-4-13", end="2012-5-1")
|
||||
ts = Series(range(len(dr)), index=dr)
|
||||
|
||||
ts_utc = ts.tz_localize("UTC")
|
||||
ts_local = ts_utc.tz_convert("America/Los_Angeles")
|
||||
|
||||
result = ts_local.resample("W").mean()
|
||||
|
||||
ts_local_naive = ts_local.copy()
|
||||
ts_local_naive.index = [
|
||||
x.replace(tzinfo=None) for x in ts_local_naive.index.to_pydatetime()
|
||||
]
|
||||
|
||||
exp = ts_local_naive.resample("W").mean().tz_localize("America/Los_Angeles")
|
||||
exp.index = pd.DatetimeIndex(exp.index, freq="W")
|
||||
|
||||
tm.assert_series_equal(result, exp)
|
||||
|
||||
# it works
|
||||
result = ts_local.resample("D").mean()
|
||||
|
||||
# #2245
|
||||
idx = date_range(
|
||||
"2001-09-20 15:59", "2001-09-20 16:00", freq="T", tz="Australia/Sydney"
|
||||
)
|
||||
s = Series([1, 2], index=idx)
|
||||
|
||||
result = s.resample("D", closed="right", label="right").mean()
|
||||
ex_index = date_range("2001-09-21", periods=1, freq="D", tz="Australia/Sydney")
|
||||
expected = Series([1.5], index=ex_index)
|
||||
|
||||
tm.assert_series_equal(result, expected)
|
||||
|
||||
# for good measure
|
||||
result = s.resample("D", kind="period").mean()
|
||||
ex_index = period_range("2001-09-20", periods=1, freq="D")
|
||||
expected = Series([1.5], index=ex_index)
|
||||
tm.assert_series_equal(result, expected)
|
||||
|
||||
# GH 6397
|
||||
# comparing an offset that doesn't propagate tz's
|
||||
rng = date_range("1/1/2011", periods=20000, freq="H")
|
||||
rng = rng.tz_localize("EST")
|
||||
ts = DataFrame(index=rng)
|
||||
ts["first"] = np.random.default_rng(2).standard_normal(len(rng))
|
||||
ts["second"] = np.cumsum(np.random.default_rng(2).standard_normal(len(rng)))
|
||||
expected = DataFrame(
|
||||
{
|
||||
"first": ts.resample("A").sum()["first"],
|
||||
"second": ts.resample("A").mean()["second"],
|
||||
},
|
||||
columns=["first", "second"],
|
||||
)
|
||||
result = (
|
||||
ts.resample("A")
|
||||
.agg({"first": "sum", "second": "mean"})
|
||||
.reindex(columns=["first", "second"])
|
||||
)
|
||||
tm.assert_frame_equal(result, expected)
|
||||
|
||||
def test_closed_left_corner(self):
|
||||
# #1465
|
||||
s = Series(
|
||||
np.random.default_rng(2).standard_normal(21),
|
||||
index=date_range(start="1/1/2012 9:30", freq="1min", periods=21),
|
||||
)
|
||||
s.iloc[0] = np.nan
|
||||
|
||||
result = s.resample("10min", closed="left", label="right").mean()
|
||||
exp = s[1:].resample("10min", closed="left", label="right").mean()
|
||||
tm.assert_series_equal(result, exp)
|
||||
|
||||
result = s.resample("10min", closed="left", label="left").mean()
|
||||
exp = s[1:].resample("10min", closed="left", label="left").mean()
|
||||
|
||||
ex_index = date_range(start="1/1/2012 9:30", freq="10min", periods=3)
|
||||
|
||||
tm.assert_index_equal(result.index, ex_index)
|
||||
tm.assert_series_equal(result, exp)
|
||||
|
||||
def test_quarterly_resampling(self):
|
||||
rng = period_range("2000Q1", periods=10, freq="Q-DEC")
|
||||
ts = Series(np.arange(10), index=rng)
|
||||
|
||||
result = ts.resample("A").mean()
|
||||
exp = ts.to_timestamp().resample("A").mean().to_period()
|
||||
tm.assert_series_equal(result, exp)
|
||||
|
||||
def test_resample_weekly_bug_1726(self):
|
||||
# 8/6/12 is a Monday
|
||||
ind = date_range(start="8/6/2012", end="8/26/2012", freq="D")
|
||||
n = len(ind)
|
||||
data = [[x] * 5 for x in range(n)]
|
||||
df = DataFrame(data, columns=["open", "high", "low", "close", "vol"], index=ind)
|
||||
|
||||
# it works!
|
||||
df.resample("W-MON", closed="left", label="left").first()
|
||||
|
||||
def test_resample_with_dst_time_change(self):
|
||||
# GH 15549
|
||||
index = (
|
||||
pd.DatetimeIndex([1457537600000000000, 1458059600000000000])
|
||||
.tz_localize("UTC")
|
||||
.tz_convert("America/Chicago")
|
||||
)
|
||||
df = DataFrame([1, 2], index=index)
|
||||
result = df.resample("12h", closed="right", label="right").last().ffill()
|
||||
|
||||
expected_index_values = [
|
||||
"2016-03-09 12:00:00-06:00",
|
||||
"2016-03-10 00:00:00-06:00",
|
||||
"2016-03-10 12:00:00-06:00",
|
||||
"2016-03-11 00:00:00-06:00",
|
||||
"2016-03-11 12:00:00-06:00",
|
||||
"2016-03-12 00:00:00-06:00",
|
||||
"2016-03-12 12:00:00-06:00",
|
||||
"2016-03-13 00:00:00-06:00",
|
||||
"2016-03-13 13:00:00-05:00",
|
||||
"2016-03-14 01:00:00-05:00",
|
||||
"2016-03-14 13:00:00-05:00",
|
||||
"2016-03-15 01:00:00-05:00",
|
||||
"2016-03-15 13:00:00-05:00",
|
||||
]
|
||||
index = pd.to_datetime(expected_index_values, utc=True).tz_convert(
|
||||
"America/Chicago"
|
||||
)
|
||||
index = pd.DatetimeIndex(index, freq="12h")
|
||||
expected = DataFrame(
|
||||
[1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 2.0],
|
||||
index=index,
|
||||
)
|
||||
tm.assert_frame_equal(result, expected)
|
||||
|
||||
def test_resample_bms_2752(self):
|
||||
# GH2753
|
||||
timeseries = Series(
|
||||
index=pd.bdate_range("20000101", "20000201"), dtype=np.float64
|
||||
)
|
||||
res1 = timeseries.resample("BMS").mean()
|
||||
res2 = timeseries.resample("BMS").mean().resample("B").mean()
|
||||
assert res1.index[0] == Timestamp("20000103")
|
||||
assert res1.index[0] == res2.index[0]
|
||||
|
||||
@pytest.mark.xfail(reason="Commented out for more than 3 years. Should this work?")
|
||||
def test_monthly_convention_span(self):
|
||||
rng = period_range("2000-01", periods=3, freq="M")
|
||||
ts = Series(np.arange(3), index=rng)
|
||||
|
||||
# hacky way to get same thing
|
||||
exp_index = period_range("2000-01-01", "2000-03-31", freq="D")
|
||||
expected = ts.asfreq("D", how="end").reindex(exp_index)
|
||||
expected = expected.fillna(method="bfill")
|
||||
|
||||
result = ts.resample("D").mean()
|
||||
|
||||
tm.assert_series_equal(result, expected)
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
"from_freq, to_freq", [("D", "M"), ("Q", "A"), ("M", "Q"), ("D", "W")]
|
||||
)
|
||||
def test_default_right_closed_label(self, from_freq, to_freq):
|
||||
idx = date_range(start="8/15/2012", periods=100, freq=from_freq)
|
||||
df = DataFrame(np.random.default_rng(2).standard_normal((len(idx), 2)), idx)
|
||||
|
||||
resampled = df.resample(to_freq).mean()
|
||||
tm.assert_frame_equal(
|
||||
resampled, df.resample(to_freq, closed="right", label="right").mean()
|
||||
)
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
"from_freq, to_freq",
|
||||
[("D", "MS"), ("Q", "AS"), ("M", "QS"), ("H", "D"), ("T", "H")],
|
||||
)
|
||||
def test_default_left_closed_label(self, from_freq, to_freq):
|
||||
idx = date_range(start="8/15/2012", periods=100, freq=from_freq)
|
||||
df = DataFrame(np.random.default_rng(2).standard_normal((len(idx), 2)), idx)
|
||||
|
||||
resampled = df.resample(to_freq).mean()
|
||||
tm.assert_frame_equal(
|
||||
resampled, df.resample(to_freq, closed="left", label="left").mean()
|
||||
)
|
||||
|
||||
def test_all_values_single_bin(self):
|
||||
# 2070
|
||||
index = period_range(start="2012-01-01", end="2012-12-31", freq="M")
|
||||
s = Series(np.random.default_rng(2).standard_normal(len(index)), index=index)
|
||||
|
||||
result = s.resample("A").mean()
|
||||
tm.assert_almost_equal(result.iloc[0], s.mean())
|
||||
|
||||
def test_evenly_divisible_with_no_extra_bins(self):
|
||||
# 4076
|
||||
# when the frequency is evenly divisible, sometimes extra bins
|
||||
|
||||
df = DataFrame(
|
||||
np.random.default_rng(2).standard_normal((9, 3)),
|
||||
index=date_range("2000-1-1", periods=9),
|
||||
)
|
||||
result = df.resample("5D").mean()
|
||||
expected = pd.concat([df.iloc[0:5].mean(), df.iloc[5:].mean()], axis=1).T
|
||||
expected.index = pd.DatetimeIndex(
|
||||
[Timestamp("2000-1-1"), Timestamp("2000-1-6")], freq="5D"
|
||||
)
|
||||
tm.assert_frame_equal(result, expected)
|
||||
|
||||
index = date_range(start="2001-5-4", periods=28)
|
||||
df = DataFrame(
|
||||
[
|
||||
{
|
||||
"REST_KEY": 1,
|
||||
"DLY_TRN_QT": 80,
|
||||
"DLY_SLS_AMT": 90,
|
||||
"COOP_DLY_TRN_QT": 30,
|
||||
"COOP_DLY_SLS_AMT": 20,
|
||||
}
|
||||
]
|
||||
* 28
|
||||
+ [
|
||||
{
|
||||
"REST_KEY": 2,
|
||||
"DLY_TRN_QT": 70,
|
||||
"DLY_SLS_AMT": 10,
|
||||
"COOP_DLY_TRN_QT": 50,
|
||||
"COOP_DLY_SLS_AMT": 20,
|
||||
}
|
||||
]
|
||||
* 28,
|
||||
index=index.append(index),
|
||||
).sort_index()
|
||||
|
||||
index = date_range("2001-5-4", periods=4, freq="7D")
|
||||
expected = DataFrame(
|
||||
[
|
||||
{
|
||||
"REST_KEY": 14,
|
||||
"DLY_TRN_QT": 14,
|
||||
"DLY_SLS_AMT": 14,
|
||||
"COOP_DLY_TRN_QT": 14,
|
||||
"COOP_DLY_SLS_AMT": 14,
|
||||
}
|
||||
]
|
||||
* 4,
|
||||
index=index,
|
||||
)
|
||||
result = df.resample("7D").count()
|
||||
tm.assert_frame_equal(result, expected)
|
||||
|
||||
expected = DataFrame(
|
||||
[
|
||||
{
|
||||
"REST_KEY": 21,
|
||||
"DLY_TRN_QT": 1050,
|
||||
"DLY_SLS_AMT": 700,
|
||||
"COOP_DLY_TRN_QT": 560,
|
||||
"COOP_DLY_SLS_AMT": 280,
|
||||
}
|
||||
]
|
||||
* 4,
|
||||
index=index,
|
||||
)
|
||||
result = df.resample("7D").sum()
|
||||
tm.assert_frame_equal(result, expected)
|
||||
|
||||
@pytest.mark.parametrize("freq, period_mult", [("H", 24), ("12H", 2)])
|
||||
@pytest.mark.parametrize("kind", [None, "period"])
|
||||
def test_upsampling_ohlc(self, freq, period_mult, kind):
|
||||
# GH 13083
|
||||
pi = period_range(start="2000", freq="D", periods=10)
|
||||
s = Series(range(len(pi)), index=pi)
|
||||
expected = s.to_timestamp().resample(freq).ohlc().to_period(freq)
|
||||
|
||||
# timestamp-based resampling doesn't include all sub-periods
|
||||
# of the last original period, so extend accordingly:
|
||||
new_index = period_range(start="2000", freq=freq, periods=period_mult * len(pi))
|
||||
expected = expected.reindex(new_index)
|
||||
result = s.resample(freq, kind=kind).ohlc()
|
||||
tm.assert_frame_equal(result, expected)
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
"periods, values",
|
||||
[
|
||||
(
|
||||
[
|
||||
pd.NaT,
|
||||
"1970-01-01 00:00:00",
|
||||
pd.NaT,
|
||||
"1970-01-01 00:00:02",
|
||||
"1970-01-01 00:00:03",
|
||||
],
|
||||
[2, 3, 5, 7, 11],
|
||||
),
|
||||
(
|
||||
[
|
||||
pd.NaT,
|
||||
pd.NaT,
|
||||
"1970-01-01 00:00:00",
|
||||
pd.NaT,
|
||||
pd.NaT,
|
||||
pd.NaT,
|
||||
"1970-01-01 00:00:02",
|
||||
"1970-01-01 00:00:03",
|
||||
pd.NaT,
|
||||
pd.NaT,
|
||||
],
|
||||
[1, 2, 3, 5, 6, 8, 7, 11, 12, 13],
|
||||
),
|
||||
],
|
||||
)
|
||||
@pytest.mark.parametrize(
|
||||
"freq, expected_values",
|
||||
[
|
||||
("1s", [3, np.nan, 7, 11]),
|
||||
("2s", [3, (7 + 11) / 2]),
|
||||
("3s", [(3 + 7) / 2, 11]),
|
||||
],
|
||||
)
|
||||
def test_resample_with_nat(self, periods, values, freq, expected_values):
|
||||
# GH 13224
|
||||
index = PeriodIndex(periods, freq="S")
|
||||
frame = DataFrame(values, index=index)
|
||||
|
||||
expected_index = period_range(
|
||||
"1970-01-01 00:00:00", periods=len(expected_values), freq=freq
|
||||
)
|
||||
expected = DataFrame(expected_values, index=expected_index)
|
||||
result = frame.resample(freq).mean()
|
||||
tm.assert_frame_equal(result, expected)
|
||||
|
||||
def test_resample_with_only_nat(self):
|
||||
# GH 13224
|
||||
pi = PeriodIndex([pd.NaT] * 3, freq="S")
|
||||
frame = DataFrame([2, 3, 5], index=pi, columns=["a"])
|
||||
expected_index = PeriodIndex(data=[], freq=pi.freq)
|
||||
expected = DataFrame(index=expected_index, columns=["a"], dtype="float64")
|
||||
result = frame.resample("1s").mean()
|
||||
tm.assert_frame_equal(result, expected)
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
"start,end,start_freq,end_freq,offset",
|
||||
[
|
||||
("19910905", "19910909 03:00", "H", "24H", "10H"),
|
||||
("19910905", "19910909 12:00", "H", "24H", "10H"),
|
||||
("19910905", "19910909 23:00", "H", "24H", "10H"),
|
||||
("19910905 10:00", "19910909", "H", "24H", "10H"),
|
||||
("19910905 10:00", "19910909 10:00", "H", "24H", "10H"),
|
||||
("19910905", "19910909 10:00", "H", "24H", "10H"),
|
||||
("19910905 12:00", "19910909", "H", "24H", "10H"),
|
||||
("19910905 12:00", "19910909 03:00", "H", "24H", "10H"),
|
||||
("19910905 12:00", "19910909 12:00", "H", "24H", "10H"),
|
||||
("19910905 12:00", "19910909 12:00", "H", "24H", "34H"),
|
||||
("19910905 12:00", "19910909 12:00", "H", "17H", "10H"),
|
||||
("19910905 12:00", "19910909 12:00", "H", "17H", "3H"),
|
||||
("19910905 12:00", "19910909 1:00", "H", "M", "3H"),
|
||||
("19910905", "19910913 06:00", "2H", "24H", "10H"),
|
||||
("19910905", "19910905 01:39", "Min", "5Min", "3Min"),
|
||||
("19910905", "19910905 03:18", "2Min", "5Min", "3Min"),
|
||||
],
|
||||
)
|
||||
def test_resample_with_offset(self, start, end, start_freq, end_freq, offset):
|
||||
# GH 23882 & 31809
|
||||
pi = period_range(start, end, freq=start_freq)
|
||||
ser = Series(np.arange(len(pi)), index=pi)
|
||||
result = ser.resample(end_freq, offset=offset).mean()
|
||||
result = result.to_timestamp(end_freq)
|
||||
|
||||
expected = ser.to_timestamp().resample(end_freq, offset=offset).mean()
|
||||
if end_freq == "M":
|
||||
# TODO: is non-tick the relevant characteristic? (GH 33815)
|
||||
expected.index = expected.index._with_freq(None)
|
||||
tm.assert_series_equal(result, expected)
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
"first,last,freq,exp_first,exp_last",
|
||||
[
|
||||
("19910905", "19920406", "D", "19910905", "19920406"),
|
||||
("19910905 00:00", "19920406 06:00", "D", "19910905", "19920406"),
|
||||
(
|
||||
"19910905 06:00",
|
||||
"19920406 06:00",
|
||||
"H",
|
||||
"19910905 06:00",
|
||||
"19920406 06:00",
|
||||
),
|
||||
("19910906", "19920406", "M", "1991-09", "1992-04"),
|
||||
("19910831", "19920430", "M", "1991-08", "1992-04"),
|
||||
("1991-08", "1992-04", "M", "1991-08", "1992-04"),
|
||||
],
|
||||
)
|
||||
def test_get_period_range_edges(self, first, last, freq, exp_first, exp_last):
|
||||
first = Period(first)
|
||||
last = Period(last)
|
||||
|
||||
exp_first = Period(exp_first, freq=freq)
|
||||
exp_last = Period(exp_last, freq=freq)
|
||||
|
||||
freq = pd.tseries.frequencies.to_offset(freq)
|
||||
result = _get_period_range_edges(first, last, freq)
|
||||
expected = (exp_first, exp_last)
|
||||
assert result == expected
|
||||
|
||||
def test_sum_min_count(self):
|
||||
# GH 19974
|
||||
index = date_range(start="2018", freq="M", periods=6)
|
||||
data = np.ones(6)
|
||||
data[3:6] = np.nan
|
||||
s = Series(data, index).to_period()
|
||||
result = s.resample("Q").sum(min_count=1)
|
||||
expected = Series(
|
||||
[3.0, np.nan], index=PeriodIndex(["2018Q1", "2018Q2"], freq="Q-DEC")
|
||||
)
|
||||
tm.assert_series_equal(result, expected)
|
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,698 @@
|
||||
from textwrap import dedent
|
||||
|
||||
import numpy as np
|
||||
import pytest
|
||||
|
||||
from pandas.compat import is_platform_windows
|
||||
from pandas.util._test_decorators import async_mark
|
||||
|
||||
import pandas as pd
|
||||
from pandas import (
|
||||
DataFrame,
|
||||
Index,
|
||||
Series,
|
||||
TimedeltaIndex,
|
||||
Timestamp,
|
||||
)
|
||||
import pandas._testing as tm
|
||||
from pandas.core.indexes.datetimes import date_range
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def test_frame():
|
||||
return DataFrame(
|
||||
{"A": [1] * 20 + [2] * 12 + [3] * 8, "B": np.arange(40)},
|
||||
index=date_range("1/1/2000", freq="s", periods=40),
|
||||
)
|
||||
|
||||
|
||||
@async_mark()
|
||||
async def test_tab_complete_ipython6_warning(ip):
|
||||
from IPython.core.completer import provisionalcompleter
|
||||
|
||||
code = dedent(
|
||||
"""\
|
||||
import pandas._testing as tm
|
||||
s = tm.makeTimeSeries()
|
||||
rs = s.resample("D")
|
||||
"""
|
||||
)
|
||||
await ip.run_code(code)
|
||||
|
||||
# GH 31324 newer jedi version raises Deprecation warning;
|
||||
# appears resolved 2021-02-02
|
||||
with tm.assert_produces_warning(None, raise_on_extra_warnings=False):
|
||||
with provisionalcompleter("ignore"):
|
||||
list(ip.Completer.completions("rs.", 1))
|
||||
|
||||
|
||||
def test_deferred_with_groupby():
|
||||
# GH 12486
|
||||
# support deferred resample ops with groupby
|
||||
data = [
|
||||
["2010-01-01", "A", 2],
|
||||
["2010-01-02", "A", 3],
|
||||
["2010-01-05", "A", 8],
|
||||
["2010-01-10", "A", 7],
|
||||
["2010-01-13", "A", 3],
|
||||
["2010-01-01", "B", 5],
|
||||
["2010-01-03", "B", 2],
|
||||
["2010-01-04", "B", 1],
|
||||
["2010-01-11", "B", 7],
|
||||
["2010-01-14", "B", 3],
|
||||
]
|
||||
|
||||
df = DataFrame(data, columns=["date", "id", "score"])
|
||||
df.date = pd.to_datetime(df.date)
|
||||
|
||||
def f_0(x):
|
||||
return x.set_index("date").resample("D").asfreq()
|
||||
|
||||
expected = df.groupby("id").apply(f_0)
|
||||
result = df.set_index("date").groupby("id").resample("D").asfreq()
|
||||
tm.assert_frame_equal(result, expected)
|
||||
|
||||
df = DataFrame(
|
||||
{
|
||||
"date": date_range(start="2016-01-01", periods=4, freq="W"),
|
||||
"group": [1, 1, 2, 2],
|
||||
"val": [5, 6, 7, 8],
|
||||
}
|
||||
).set_index("date")
|
||||
|
||||
def f_1(x):
|
||||
return x.resample("1D").ffill()
|
||||
|
||||
expected = df.groupby("group").apply(f_1)
|
||||
result = df.groupby("group").resample("1D").ffill()
|
||||
tm.assert_frame_equal(result, expected)
|
||||
|
||||
|
||||
def test_getitem(test_frame):
|
||||
g = test_frame.groupby("A")
|
||||
|
||||
expected = g.B.apply(lambda x: x.resample("2s").mean())
|
||||
|
||||
result = g.resample("2s").B.mean()
|
||||
tm.assert_series_equal(result, expected)
|
||||
|
||||
result = g.B.resample("2s").mean()
|
||||
tm.assert_series_equal(result, expected)
|
||||
|
||||
result = g.resample("2s").mean().B
|
||||
tm.assert_series_equal(result, expected)
|
||||
|
||||
|
||||
def test_getitem_multiple():
|
||||
# GH 13174
|
||||
# multiple calls after selection causing an issue with aliasing
|
||||
data = [{"id": 1, "buyer": "A"}, {"id": 2, "buyer": "B"}]
|
||||
df = DataFrame(data, index=date_range("2016-01-01", periods=2))
|
||||
r = df.groupby("id").resample("1D")
|
||||
result = r["buyer"].count()
|
||||
expected = Series(
|
||||
[1, 1],
|
||||
index=pd.MultiIndex.from_tuples(
|
||||
[(1, Timestamp("2016-01-01")), (2, Timestamp("2016-01-02"))],
|
||||
names=["id", None],
|
||||
),
|
||||
name="buyer",
|
||||
)
|
||||
tm.assert_series_equal(result, expected)
|
||||
|
||||
result = r["buyer"].count()
|
||||
tm.assert_series_equal(result, expected)
|
||||
|
||||
|
||||
def test_groupby_resample_on_api_with_getitem():
|
||||
# GH 17813
|
||||
df = DataFrame(
|
||||
{"id": list("aabbb"), "date": date_range("1-1-2016", periods=5), "data": 1}
|
||||
)
|
||||
exp = df.set_index("date").groupby("id").resample("2D")["data"].sum()
|
||||
result = df.groupby("id").resample("2D", on="date")["data"].sum()
|
||||
tm.assert_series_equal(result, exp)
|
||||
|
||||
|
||||
def test_groupby_with_origin():
|
||||
# GH 31809
|
||||
|
||||
freq = "1399min" # prime number that is smaller than 24h
|
||||
start, end = "1/1/2000 00:00:00", "1/31/2000 00:00"
|
||||
middle = "1/15/2000 00:00:00"
|
||||
|
||||
# test origin on 1970-01-01 00:00:00
|
||||
rng = date_range("1970-01-01 00:00:00", end, freq="1231min") # prime number
|
||||
ts = Series(np.random.default_rng(2).standard_normal(len(rng)), index=rng)
|
||||
middle_ts = rng[len(rng) // 2]
|
||||
ts2 = ts[middle_ts:end]
|
||||
|
||||
origin = Timestamp(0)
|
||||
adjusted_grouper = pd.Grouper(freq=freq, origin=origin)
|
||||
adjusted_count_ts = ts.groupby(adjusted_grouper).agg("count")
|
||||
adjusted_count_ts = adjusted_count_ts[middle_ts:end]
|
||||
adjusted_count_ts2 = ts2.groupby(adjusted_grouper).agg("count")
|
||||
tm.assert_series_equal(adjusted_count_ts, adjusted_count_ts2[middle_ts:end])
|
||||
|
||||
rng = date_range(start, end, freq="1231min") # prime number
|
||||
ts = Series(np.random.default_rng(2).standard_normal(len(rng)), index=rng)
|
||||
ts2 = ts[middle:end]
|
||||
|
||||
# proves that grouper without a fixed origin does not work
|
||||
# when dealing with unusual frequencies
|
||||
simple_grouper = pd.Grouper(freq=freq)
|
||||
count_ts = ts.groupby(simple_grouper).agg("count")
|
||||
count_ts = count_ts[middle:end]
|
||||
count_ts2 = ts2.groupby(simple_grouper).agg("count")
|
||||
with pytest.raises(AssertionError, match="Index are different"):
|
||||
tm.assert_index_equal(count_ts.index, count_ts2.index)
|
||||
|
||||
# test origin on 2049-10-18 20:00:00
|
||||
|
||||
rng = date_range(start, "2049-10-18 20:00:00", freq="1231min") # prime number
|
||||
ts = Series(np.random.default_rng(2).standard_normal(len(rng)), index=rng)
|
||||
middle_ts = rng[len(rng) // 2]
|
||||
ts2 = ts[middle_ts:end]
|
||||
origin_future = Timestamp(0) + pd.Timedelta("1399min") * 30_000
|
||||
adjusted_grouper2 = pd.Grouper(freq=freq, origin=origin_future)
|
||||
adjusted2_count_ts = ts.groupby(adjusted_grouper2).agg("count")
|
||||
adjusted2_count_ts = adjusted2_count_ts[middle_ts:end]
|
||||
adjusted2_count_ts2 = ts2.groupby(adjusted_grouper2).agg("count")
|
||||
tm.assert_series_equal(adjusted2_count_ts, adjusted2_count_ts2)
|
||||
|
||||
|
||||
def test_nearest():
|
||||
# GH 17496
|
||||
# Resample nearest
|
||||
index = date_range("1/1/2000", periods=3, freq="T")
|
||||
result = Series(range(3), index=index).resample("20s").nearest()
|
||||
|
||||
expected = Series(
|
||||
[0, 0, 1, 1, 1, 2, 2],
|
||||
index=pd.DatetimeIndex(
|
||||
[
|
||||
"2000-01-01 00:00:00",
|
||||
"2000-01-01 00:00:20",
|
||||
"2000-01-01 00:00:40",
|
||||
"2000-01-01 00:01:00",
|
||||
"2000-01-01 00:01:20",
|
||||
"2000-01-01 00:01:40",
|
||||
"2000-01-01 00:02:00",
|
||||
],
|
||||
dtype="datetime64[ns]",
|
||||
freq="20S",
|
||||
),
|
||||
)
|
||||
tm.assert_series_equal(result, expected)
|
||||
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
"f",
|
||||
[
|
||||
"first",
|
||||
"last",
|
||||
"median",
|
||||
"sem",
|
||||
"sum",
|
||||
"mean",
|
||||
"min",
|
||||
"max",
|
||||
"size",
|
||||
"count",
|
||||
"nearest",
|
||||
"bfill",
|
||||
"ffill",
|
||||
"asfreq",
|
||||
"ohlc",
|
||||
],
|
||||
)
|
||||
def test_methods(f, test_frame):
|
||||
g = test_frame.groupby("A")
|
||||
r = g.resample("2s")
|
||||
|
||||
result = getattr(r, f)()
|
||||
expected = g.apply(lambda x: getattr(x.resample("2s"), f)())
|
||||
tm.assert_equal(result, expected)
|
||||
|
||||
|
||||
def test_methods_nunique(test_frame):
|
||||
# series only
|
||||
g = test_frame.groupby("A")
|
||||
r = g.resample("2s")
|
||||
result = r.B.nunique()
|
||||
expected = g.B.apply(lambda x: x.resample("2s").nunique())
|
||||
tm.assert_series_equal(result, expected)
|
||||
|
||||
|
||||
@pytest.mark.parametrize("f", ["std", "var"])
|
||||
def test_methods_std_var(f, test_frame):
|
||||
g = test_frame.groupby("A")
|
||||
r = g.resample("2s")
|
||||
result = getattr(r, f)(ddof=1)
|
||||
expected = g.apply(lambda x: getattr(x.resample("2s"), f)(ddof=1))
|
||||
tm.assert_frame_equal(result, expected)
|
||||
|
||||
|
||||
def test_apply(test_frame):
|
||||
g = test_frame.groupby("A")
|
||||
r = g.resample("2s")
|
||||
|
||||
# reduction
|
||||
expected = g.resample("2s").sum()
|
||||
|
||||
def f_0(x):
|
||||
return x.resample("2s").sum()
|
||||
|
||||
result = r.apply(f_0)
|
||||
tm.assert_frame_equal(result, expected)
|
||||
|
||||
def f_1(x):
|
||||
return x.resample("2s").apply(lambda y: y.sum())
|
||||
|
||||
result = g.apply(f_1)
|
||||
# y.sum() results in int64 instead of int32 on 32-bit architectures
|
||||
expected = expected.astype("int64")
|
||||
tm.assert_frame_equal(result, expected)
|
||||
|
||||
|
||||
def test_apply_with_mutated_index():
|
||||
# GH 15169
|
||||
index = date_range("1-1-2015", "12-31-15", freq="D")
|
||||
df = DataFrame(
|
||||
data={"col1": np.random.default_rng(2).random(len(index))}, index=index
|
||||
)
|
||||
|
||||
def f(x):
|
||||
s = Series([1, 2], index=["a", "b"])
|
||||
return s
|
||||
|
||||
expected = df.groupby(pd.Grouper(freq="M")).apply(f)
|
||||
|
||||
result = df.resample("M").apply(f)
|
||||
tm.assert_frame_equal(result, expected)
|
||||
|
||||
# A case for series
|
||||
expected = df["col1"].groupby(pd.Grouper(freq="M"), group_keys=False).apply(f)
|
||||
result = df["col1"].resample("M").apply(f)
|
||||
tm.assert_series_equal(result, expected)
|
||||
|
||||
|
||||
def test_apply_columns_multilevel():
|
||||
# GH 16231
|
||||
cols = pd.MultiIndex.from_tuples([("A", "a", "", "one"), ("B", "b", "i", "two")])
|
||||
ind = date_range(start="2017-01-01", freq="15Min", periods=8)
|
||||
df = DataFrame(np.array([0] * 16).reshape(8, 2), index=ind, columns=cols)
|
||||
agg_dict = {col: (np.sum if col[3] == "one" else np.mean) for col in df.columns}
|
||||
result = df.resample("H").apply(lambda x: agg_dict[x.name](x))
|
||||
expected = DataFrame(
|
||||
2 * [[0, 0.0]],
|
||||
index=date_range(start="2017-01-01", freq="1H", periods=2),
|
||||
columns=pd.MultiIndex.from_tuples(
|
||||
[("A", "a", "", "one"), ("B", "b", "i", "two")]
|
||||
),
|
||||
)
|
||||
tm.assert_frame_equal(result, expected)
|
||||
|
||||
|
||||
def test_apply_non_naive_index():
|
||||
def weighted_quantile(series, weights, q):
|
||||
series = series.sort_values()
|
||||
cumsum = weights.reindex(series.index).fillna(0).cumsum()
|
||||
cutoff = cumsum.iloc[-1] * q
|
||||
return series[cumsum >= cutoff].iloc[0]
|
||||
|
||||
times = date_range("2017-6-23 18:00", periods=8, freq="15T", tz="UTC")
|
||||
data = Series([1.0, 1, 1, 1, 1, 2, 2, 0], index=times)
|
||||
weights = Series([160.0, 91, 65, 43, 24, 10, 1, 0], index=times)
|
||||
|
||||
result = data.resample("D").apply(weighted_quantile, weights=weights, q=0.5)
|
||||
ind = date_range(
|
||||
"2017-06-23 00:00:00+00:00", "2017-06-23 00:00:00+00:00", freq="D", tz="UTC"
|
||||
)
|
||||
expected = Series([1.0], index=ind)
|
||||
tm.assert_series_equal(result, expected)
|
||||
|
||||
|
||||
def test_resample_groupby_with_label():
|
||||
# GH 13235
|
||||
index = date_range("2000-01-01", freq="2D", periods=5)
|
||||
df = DataFrame(index=index, data={"col0": [0, 0, 1, 1, 2], "col1": [1, 1, 1, 1, 1]})
|
||||
result = df.groupby("col0").resample("1W", label="left").sum()
|
||||
|
||||
mi = [
|
||||
np.array([0, 0, 1, 2], dtype=np.int64),
|
||||
pd.to_datetime(
|
||||
np.array(["1999-12-26", "2000-01-02", "2000-01-02", "2000-01-02"])
|
||||
),
|
||||
]
|
||||
mindex = pd.MultiIndex.from_arrays(mi, names=["col0", None])
|
||||
expected = DataFrame(
|
||||
data={"col0": [0, 0, 2, 2], "col1": [1, 1, 2, 1]}, index=mindex
|
||||
)
|
||||
|
||||
tm.assert_frame_equal(result, expected)
|
||||
|
||||
|
||||
def test_consistency_with_window(test_frame):
|
||||
# consistent return values with window
|
||||
df = test_frame
|
||||
expected = Index([1, 2, 3], name="A")
|
||||
result = df.groupby("A").resample("2s").mean()
|
||||
assert result.index.nlevels == 2
|
||||
tm.assert_index_equal(result.index.levels[0], expected)
|
||||
|
||||
result = df.groupby("A").rolling(20).mean()
|
||||
assert result.index.nlevels == 2
|
||||
tm.assert_index_equal(result.index.levels[0], expected)
|
||||
|
||||
|
||||
def test_median_duplicate_columns():
|
||||
# GH 14233
|
||||
|
||||
df = DataFrame(
|
||||
np.random.default_rng(2).standard_normal((20, 3)),
|
||||
columns=list("aaa"),
|
||||
index=date_range("2012-01-01", periods=20, freq="s"),
|
||||
)
|
||||
df2 = df.copy()
|
||||
df2.columns = ["a", "b", "c"]
|
||||
expected = df2.resample("5s").median()
|
||||
result = df.resample("5s").median()
|
||||
expected.columns = result.columns
|
||||
tm.assert_frame_equal(result, expected)
|
||||
|
||||
|
||||
def test_apply_to_one_column_of_df():
|
||||
# GH: 36951
|
||||
df = DataFrame(
|
||||
{"col": range(10), "col1": range(10, 20)},
|
||||
index=date_range("2012-01-01", periods=10, freq="20min"),
|
||||
)
|
||||
|
||||
# access "col" via getattr -> make sure we handle AttributeError
|
||||
result = df.resample("H").apply(lambda group: group.col.sum())
|
||||
expected = Series(
|
||||
[3, 12, 21, 9], index=date_range("2012-01-01", periods=4, freq="H")
|
||||
)
|
||||
tm.assert_series_equal(result, expected)
|
||||
|
||||
# access "col" via _getitem__ -> make sure we handle KeyErrpr
|
||||
result = df.resample("H").apply(lambda group: group["col"].sum())
|
||||
tm.assert_series_equal(result, expected)
|
||||
|
||||
|
||||
def test_resample_groupby_agg():
|
||||
# GH: 33548
|
||||
df = DataFrame(
|
||||
{
|
||||
"cat": [
|
||||
"cat_1",
|
||||
"cat_1",
|
||||
"cat_2",
|
||||
"cat_1",
|
||||
"cat_2",
|
||||
"cat_1",
|
||||
"cat_2",
|
||||
"cat_1",
|
||||
],
|
||||
"num": [5, 20, 22, 3, 4, 30, 10, 50],
|
||||
"date": [
|
||||
"2019-2-1",
|
||||
"2018-02-03",
|
||||
"2020-3-11",
|
||||
"2019-2-2",
|
||||
"2019-2-2",
|
||||
"2018-12-4",
|
||||
"2020-3-11",
|
||||
"2020-12-12",
|
||||
],
|
||||
}
|
||||
)
|
||||
df["date"] = pd.to_datetime(df["date"])
|
||||
|
||||
resampled = df.groupby("cat").resample("Y", on="date")
|
||||
expected = resampled[["num"]].sum()
|
||||
result = resampled.agg({"num": "sum"})
|
||||
|
||||
tm.assert_frame_equal(result, expected)
|
||||
|
||||
|
||||
def test_resample_groupby_agg_listlike():
|
||||
# GH 42905
|
||||
ts = Timestamp("2021-02-28 00:00:00")
|
||||
df = DataFrame({"class": ["beta"], "value": [69]}, index=Index([ts], name="date"))
|
||||
resampled = df.groupby("class").resample("M")["value"]
|
||||
result = resampled.agg(["sum", "size"])
|
||||
expected = DataFrame(
|
||||
[[69, 1]],
|
||||
index=pd.MultiIndex.from_tuples([("beta", ts)], names=["class", "date"]),
|
||||
columns=["sum", "size"],
|
||||
)
|
||||
tm.assert_frame_equal(result, expected)
|
||||
|
||||
|
||||
@pytest.mark.parametrize("keys", [["a"], ["a", "b"]])
|
||||
def test_empty(keys):
|
||||
# GH 26411
|
||||
df = DataFrame([], columns=["a", "b"], index=TimedeltaIndex([]))
|
||||
result = df.groupby(keys).resample(rule=pd.to_timedelta("00:00:01")).mean()
|
||||
expected = (
|
||||
DataFrame(columns=["a", "b"])
|
||||
.set_index(keys, drop=False)
|
||||
.set_index(TimedeltaIndex([]), append=True)
|
||||
)
|
||||
if len(keys) == 1:
|
||||
expected.index.name = keys[0]
|
||||
|
||||
tm.assert_frame_equal(result, expected)
|
||||
|
||||
|
||||
@pytest.mark.parametrize("consolidate", [True, False])
|
||||
def test_resample_groupby_agg_object_dtype_all_nan(consolidate):
|
||||
# https://github.com/pandas-dev/pandas/issues/39329
|
||||
|
||||
dates = date_range("2020-01-01", periods=15, freq="D")
|
||||
df1 = DataFrame({"key": "A", "date": dates, "col1": range(15), "col_object": "val"})
|
||||
df2 = DataFrame({"key": "B", "date": dates, "col1": range(15)})
|
||||
df = pd.concat([df1, df2], ignore_index=True)
|
||||
if consolidate:
|
||||
df = df._consolidate()
|
||||
|
||||
result = df.groupby(["key"]).resample("W", on="date").min()
|
||||
idx = pd.MultiIndex.from_arrays(
|
||||
[
|
||||
["A"] * 3 + ["B"] * 3,
|
||||
pd.to_datetime(["2020-01-05", "2020-01-12", "2020-01-19"] * 2),
|
||||
],
|
||||
names=["key", "date"],
|
||||
)
|
||||
expected = DataFrame(
|
||||
{
|
||||
"key": ["A"] * 3 + ["B"] * 3,
|
||||
"col1": [0, 5, 12] * 2,
|
||||
"col_object": ["val"] * 3 + [np.nan] * 3,
|
||||
},
|
||||
index=idx,
|
||||
)
|
||||
tm.assert_frame_equal(result, expected)
|
||||
|
||||
|
||||
def test_groupby_resample_with_list_of_keys():
|
||||
# GH 47362
|
||||
df = DataFrame(
|
||||
data={
|
||||
"date": date_range(start="2016-01-01", periods=8),
|
||||
"group": [0, 0, 0, 0, 1, 1, 1, 1],
|
||||
"val": [1, 7, 5, 2, 3, 10, 5, 1],
|
||||
}
|
||||
)
|
||||
result = df.groupby("group").resample("2D", on="date")[["val"]].mean()
|
||||
expected = DataFrame(
|
||||
data={
|
||||
"val": [4.0, 3.5, 6.5, 3.0],
|
||||
},
|
||||
index=Index(
|
||||
data=[
|
||||
(0, Timestamp("2016-01-01")),
|
||||
(0, Timestamp("2016-01-03")),
|
||||
(1, Timestamp("2016-01-05")),
|
||||
(1, Timestamp("2016-01-07")),
|
||||
],
|
||||
name=("group", "date"),
|
||||
),
|
||||
)
|
||||
tm.assert_frame_equal(result, expected)
|
||||
|
||||
|
||||
@pytest.mark.parametrize("keys", [["a"], ["a", "b"]])
|
||||
def test_resample_no_index(keys):
|
||||
# GH 47705
|
||||
df = DataFrame([], columns=["a", "b", "date"])
|
||||
df["date"] = pd.to_datetime(df["date"])
|
||||
df = df.set_index("date")
|
||||
result = df.groupby(keys).resample(rule=pd.to_timedelta("00:00:01")).mean()
|
||||
expected = DataFrame(columns=["a", "b", "date"]).set_index(keys, drop=False)
|
||||
expected["date"] = pd.to_datetime(expected["date"])
|
||||
expected = expected.set_index("date", append=True, drop=True)
|
||||
if len(keys) == 1:
|
||||
expected.index.name = keys[0]
|
||||
|
||||
tm.assert_frame_equal(result, expected)
|
||||
|
||||
|
||||
def test_resample_no_columns():
|
||||
# GH#52484
|
||||
df = DataFrame(
|
||||
index=Index(
|
||||
pd.to_datetime(
|
||||
["2018-01-01 00:00:00", "2018-01-01 12:00:00", "2018-01-02 00:00:00"]
|
||||
),
|
||||
name="date",
|
||||
)
|
||||
)
|
||||
result = df.groupby([0, 0, 1]).resample(rule=pd.to_timedelta("06:00:00")).mean()
|
||||
index = pd.to_datetime(
|
||||
[
|
||||
"2018-01-01 00:00:00",
|
||||
"2018-01-01 06:00:00",
|
||||
"2018-01-01 12:00:00",
|
||||
"2018-01-02 00:00:00",
|
||||
]
|
||||
)
|
||||
expected = DataFrame(
|
||||
index=pd.MultiIndex(
|
||||
levels=[np.array([0, 1], dtype=np.intp), index],
|
||||
codes=[[0, 0, 0, 1], [0, 1, 2, 3]],
|
||||
names=[None, "date"],
|
||||
)
|
||||
)
|
||||
|
||||
# GH#52710 - Index comes out as 32-bit on 64-bit Windows
|
||||
tm.assert_frame_equal(result, expected, check_index_type=not is_platform_windows())
|
||||
|
||||
|
||||
def test_groupby_resample_size_all_index_same():
|
||||
# GH 46826
|
||||
df = DataFrame(
|
||||
{"A": [1] * 3 + [2] * 3 + [1] * 3 + [2] * 3, "B": np.arange(12)},
|
||||
index=date_range("31/12/2000 18:00", freq="H", periods=12),
|
||||
)
|
||||
result = df.groupby("A").resample("D").size()
|
||||
expected = Series(
|
||||
3,
|
||||
index=pd.MultiIndex.from_tuples(
|
||||
[
|
||||
(1, Timestamp("2000-12-31")),
|
||||
(1, Timestamp("2001-01-01")),
|
||||
(2, Timestamp("2000-12-31")),
|
||||
(2, Timestamp("2001-01-01")),
|
||||
],
|
||||
names=["A", None],
|
||||
),
|
||||
)
|
||||
tm.assert_series_equal(result, expected)
|
||||
|
||||
|
||||
def test_groupby_resample_on_index_with_list_of_keys():
|
||||
# GH 50840
|
||||
df = DataFrame(
|
||||
data={
|
||||
"group": [0, 0, 0, 0, 1, 1, 1, 1],
|
||||
"val": [3, 1, 4, 1, 5, 9, 2, 6],
|
||||
},
|
||||
index=Series(
|
||||
date_range(start="2016-01-01", periods=8),
|
||||
name="date",
|
||||
),
|
||||
)
|
||||
result = df.groupby("group").resample("2D")[["val"]].mean()
|
||||
expected = DataFrame(
|
||||
data={
|
||||
"val": [2.0, 2.5, 7.0, 4.0],
|
||||
},
|
||||
index=Index(
|
||||
data=[
|
||||
(0, Timestamp("2016-01-01")),
|
||||
(0, Timestamp("2016-01-03")),
|
||||
(1, Timestamp("2016-01-05")),
|
||||
(1, Timestamp("2016-01-07")),
|
||||
],
|
||||
name=("group", "date"),
|
||||
),
|
||||
)
|
||||
tm.assert_frame_equal(result, expected)
|
||||
|
||||
|
||||
def test_groupby_resample_on_index_with_list_of_keys_multi_columns():
|
||||
# GH 50876
|
||||
df = DataFrame(
|
||||
data={
|
||||
"group": [0, 0, 0, 0, 1, 1, 1, 1],
|
||||
"first_val": [3, 1, 4, 1, 5, 9, 2, 6],
|
||||
"second_val": [2, 7, 1, 8, 2, 8, 1, 8],
|
||||
"third_val": [1, 4, 1, 4, 2, 1, 3, 5],
|
||||
},
|
||||
index=Series(
|
||||
date_range(start="2016-01-01", periods=8),
|
||||
name="date",
|
||||
),
|
||||
)
|
||||
result = df.groupby("group").resample("2D")[["first_val", "second_val"]].mean()
|
||||
expected = DataFrame(
|
||||
data={
|
||||
"first_val": [2.0, 2.5, 7.0, 4.0],
|
||||
"second_val": [4.5, 4.5, 5.0, 4.5],
|
||||
},
|
||||
index=Index(
|
||||
data=[
|
||||
(0, Timestamp("2016-01-01")),
|
||||
(0, Timestamp("2016-01-03")),
|
||||
(1, Timestamp("2016-01-05")),
|
||||
(1, Timestamp("2016-01-07")),
|
||||
],
|
||||
name=("group", "date"),
|
||||
),
|
||||
)
|
||||
tm.assert_frame_equal(result, expected)
|
||||
|
||||
|
||||
def test_groupby_resample_on_index_with_list_of_keys_missing_column():
|
||||
# GH 50876
|
||||
df = DataFrame(
|
||||
data={
|
||||
"group": [0, 0, 0, 0, 1, 1, 1, 1],
|
||||
"val": [3, 1, 4, 1, 5, 9, 2, 6],
|
||||
},
|
||||
index=Series(
|
||||
date_range(start="2016-01-01", periods=8),
|
||||
name="date",
|
||||
),
|
||||
)
|
||||
with pytest.raises(KeyError, match="Columns not found"):
|
||||
df.groupby("group").resample("2D")[["val_not_in_dataframe"]].mean()
|
||||
|
||||
|
||||
@pytest.mark.parametrize("kind", ["datetime", "period"])
|
||||
def test_groupby_resample_kind(kind):
|
||||
# GH 24103
|
||||
df = DataFrame(
|
||||
{
|
||||
"datetime": pd.to_datetime(
|
||||
["20181101 1100", "20181101 1200", "20181102 1300", "20181102 1400"]
|
||||
),
|
||||
"group": ["A", "B", "A", "B"],
|
||||
"value": [1, 2, 3, 4],
|
||||
}
|
||||
)
|
||||
df = df.set_index("datetime")
|
||||
result = df.groupby("group")["value"].resample("D", kind=kind).last()
|
||||
|
||||
dt_level = pd.DatetimeIndex(["2018-11-01", "2018-11-02"])
|
||||
if kind == "period":
|
||||
dt_level = dt_level.to_period(freq="D")
|
||||
expected_index = pd.MultiIndex.from_product(
|
||||
[["A", "B"], dt_level],
|
||||
names=["group", "datetime"],
|
||||
)
|
||||
expected = Series([1, 3, 2, 4], index=expected_index, name="value")
|
||||
tm.assert_series_equal(result, expected)
|
@@ -0,0 +1,379 @@
|
||||
from datetime import datetime
|
||||
from operator import methodcaller
|
||||
|
||||
import numpy as np
|
||||
import pytest
|
||||
|
||||
import pandas as pd
|
||||
from pandas import (
|
||||
DataFrame,
|
||||
Series,
|
||||
Timestamp,
|
||||
)
|
||||
import pandas._testing as tm
|
||||
from pandas.core.groupby.grouper import Grouper
|
||||
from pandas.core.indexes.datetimes import date_range
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def test_series():
|
||||
return Series(
|
||||
np.random.default_rng(2).standard_normal(1000),
|
||||
index=date_range("1/1/2000", periods=1000),
|
||||
)
|
||||
|
||||
|
||||
def test_apply(test_series):
|
||||
grouper = Grouper(freq="A", label="right", closed="right")
|
||||
|
||||
grouped = test_series.groupby(grouper)
|
||||
|
||||
def f(x):
|
||||
return x.sort_values()[-3:]
|
||||
|
||||
applied = grouped.apply(f)
|
||||
expected = test_series.groupby(lambda x: x.year).apply(f)
|
||||
|
||||
applied.index = applied.index.droplevel(0)
|
||||
expected.index = expected.index.droplevel(0)
|
||||
tm.assert_series_equal(applied, expected)
|
||||
|
||||
|
||||
def test_count(test_series):
|
||||
test_series[::3] = np.nan
|
||||
|
||||
expected = test_series.groupby(lambda x: x.year).count()
|
||||
|
||||
grouper = Grouper(freq="A", label="right", closed="right")
|
||||
result = test_series.groupby(grouper).count()
|
||||
expected.index = result.index
|
||||
tm.assert_series_equal(result, expected)
|
||||
|
||||
result = test_series.resample("A").count()
|
||||
expected.index = result.index
|
||||
tm.assert_series_equal(result, expected)
|
||||
|
||||
|
||||
def test_numpy_reduction(test_series):
|
||||
result = test_series.resample("A", closed="right").prod()
|
||||
|
||||
msg = "using SeriesGroupBy.prod"
|
||||
with tm.assert_produces_warning(FutureWarning, match=msg):
|
||||
expected = test_series.groupby(lambda x: x.year).agg(np.prod)
|
||||
expected.index = result.index
|
||||
|
||||
tm.assert_series_equal(result, expected)
|
||||
|
||||
|
||||
def test_apply_iteration():
|
||||
# #2300
|
||||
N = 1000
|
||||
ind = date_range(start="2000-01-01", freq="D", periods=N)
|
||||
df = DataFrame({"open": 1, "close": 2}, index=ind)
|
||||
tg = Grouper(freq="M")
|
||||
|
||||
grouper, _ = tg._get_grouper(df)
|
||||
|
||||
# Errors
|
||||
grouped = df.groupby(grouper, group_keys=False)
|
||||
|
||||
def f(df):
|
||||
return df["close"] / df["open"]
|
||||
|
||||
# it works!
|
||||
result = grouped.apply(f)
|
||||
tm.assert_index_equal(result.index, df.index)
|
||||
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
"func",
|
||||
[
|
||||
tm.makeIntIndex,
|
||||
tm.makeStringIndex,
|
||||
tm.makeFloatIndex,
|
||||
(lambda m: tm.makeCustomIndex(m, 2)),
|
||||
],
|
||||
)
|
||||
def test_fails_on_no_datetime_index(func):
|
||||
n = 2
|
||||
index = func(n)
|
||||
name = type(index).__name__
|
||||
df = DataFrame({"a": np.random.default_rng(2).standard_normal(n)}, index=index)
|
||||
|
||||
msg = (
|
||||
"Only valid with DatetimeIndex, TimedeltaIndex "
|
||||
f"or PeriodIndex, but got an instance of '{name}'"
|
||||
)
|
||||
with pytest.raises(TypeError, match=msg):
|
||||
df.groupby(Grouper(freq="D"))
|
||||
|
||||
|
||||
def test_aaa_group_order():
|
||||
# GH 12840
|
||||
# check TimeGrouper perform stable sorts
|
||||
n = 20
|
||||
data = np.random.default_rng(2).standard_normal((n, 4))
|
||||
df = DataFrame(data, columns=["A", "B", "C", "D"])
|
||||
df["key"] = [
|
||||
datetime(2013, 1, 1),
|
||||
datetime(2013, 1, 2),
|
||||
datetime(2013, 1, 3),
|
||||
datetime(2013, 1, 4),
|
||||
datetime(2013, 1, 5),
|
||||
] * 4
|
||||
grouped = df.groupby(Grouper(key="key", freq="D"))
|
||||
|
||||
tm.assert_frame_equal(grouped.get_group(datetime(2013, 1, 1)), df[::5])
|
||||
tm.assert_frame_equal(grouped.get_group(datetime(2013, 1, 2)), df[1::5])
|
||||
tm.assert_frame_equal(grouped.get_group(datetime(2013, 1, 3)), df[2::5])
|
||||
tm.assert_frame_equal(grouped.get_group(datetime(2013, 1, 4)), df[3::5])
|
||||
tm.assert_frame_equal(grouped.get_group(datetime(2013, 1, 5)), df[4::5])
|
||||
|
||||
|
||||
def test_aggregate_normal(resample_method):
|
||||
"""Check TimeGrouper's aggregation is identical as normal groupby."""
|
||||
|
||||
data = np.random.default_rng(2).standard_normal((20, 4))
|
||||
normal_df = DataFrame(data, columns=["A", "B", "C", "D"])
|
||||
normal_df["key"] = [1, 2, 3, 4, 5] * 4
|
||||
|
||||
dt_df = DataFrame(data, columns=["A", "B", "C", "D"])
|
||||
dt_df["key"] = [
|
||||
datetime(2013, 1, 1),
|
||||
datetime(2013, 1, 2),
|
||||
datetime(2013, 1, 3),
|
||||
datetime(2013, 1, 4),
|
||||
datetime(2013, 1, 5),
|
||||
] * 4
|
||||
|
||||
normal_grouped = normal_df.groupby("key")
|
||||
dt_grouped = dt_df.groupby(Grouper(key="key", freq="D"))
|
||||
|
||||
expected = getattr(normal_grouped, resample_method)()
|
||||
dt_result = getattr(dt_grouped, resample_method)()
|
||||
expected.index = date_range(start="2013-01-01", freq="D", periods=5, name="key")
|
||||
tm.assert_equal(expected, dt_result)
|
||||
|
||||
|
||||
@pytest.mark.xfail(reason="if TimeGrouper is used included, 'nth' doesn't work yet")
|
||||
def test_aggregate_nth():
|
||||
"""Check TimeGrouper's aggregation is identical as normal groupby."""
|
||||
|
||||
data = np.random.default_rng(2).standard_normal((20, 4))
|
||||
normal_df = DataFrame(data, columns=["A", "B", "C", "D"])
|
||||
normal_df["key"] = [1, 2, 3, 4, 5] * 4
|
||||
|
||||
dt_df = DataFrame(data, columns=["A", "B", "C", "D"])
|
||||
dt_df["key"] = [
|
||||
datetime(2013, 1, 1),
|
||||
datetime(2013, 1, 2),
|
||||
datetime(2013, 1, 3),
|
||||
datetime(2013, 1, 4),
|
||||
datetime(2013, 1, 5),
|
||||
] * 4
|
||||
|
||||
normal_grouped = normal_df.groupby("key")
|
||||
dt_grouped = dt_df.groupby(Grouper(key="key", freq="D"))
|
||||
|
||||
expected = normal_grouped.nth(3)
|
||||
expected.index = date_range(start="2013-01-01", freq="D", periods=5, name="key")
|
||||
dt_result = dt_grouped.nth(3)
|
||||
tm.assert_frame_equal(expected, dt_result)
|
||||
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
"method, method_args, unit",
|
||||
[
|
||||
("sum", {}, 0),
|
||||
("sum", {"min_count": 0}, 0),
|
||||
("sum", {"min_count": 1}, np.nan),
|
||||
("prod", {}, 1),
|
||||
("prod", {"min_count": 0}, 1),
|
||||
("prod", {"min_count": 1}, np.nan),
|
||||
],
|
||||
)
|
||||
def test_resample_entirely_nat_window(method, method_args, unit):
|
||||
s = Series([0] * 2 + [np.nan] * 2, index=date_range("2017", periods=4))
|
||||
result = methodcaller(method, **method_args)(s.resample("2d"))
|
||||
expected = Series(
|
||||
[0.0, unit], index=pd.DatetimeIndex(["2017-01-01", "2017-01-03"], freq="2D")
|
||||
)
|
||||
tm.assert_series_equal(result, expected)
|
||||
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
"func, fill_value",
|
||||
[("min", np.nan), ("max", np.nan), ("sum", 0), ("prod", 1), ("count", 0)],
|
||||
)
|
||||
def test_aggregate_with_nat(func, fill_value):
|
||||
# check TimeGrouper's aggregation is identical as normal groupby
|
||||
# if NaT is included, 'var', 'std', 'mean', 'first','last'
|
||||
# and 'nth' doesn't work yet
|
||||
|
||||
n = 20
|
||||
data = np.random.default_rng(2).standard_normal((n, 4)).astype("int64")
|
||||
normal_df = DataFrame(data, columns=["A", "B", "C", "D"])
|
||||
normal_df["key"] = [1, 2, np.nan, 4, 5] * 4
|
||||
|
||||
dt_df = DataFrame(data, columns=["A", "B", "C", "D"])
|
||||
dt_df["key"] = [
|
||||
datetime(2013, 1, 1),
|
||||
datetime(2013, 1, 2),
|
||||
pd.NaT,
|
||||
datetime(2013, 1, 4),
|
||||
datetime(2013, 1, 5),
|
||||
] * 4
|
||||
|
||||
normal_grouped = normal_df.groupby("key")
|
||||
dt_grouped = dt_df.groupby(Grouper(key="key", freq="D"))
|
||||
|
||||
normal_result = getattr(normal_grouped, func)()
|
||||
dt_result = getattr(dt_grouped, func)()
|
||||
|
||||
pad = DataFrame([[fill_value] * 4], index=[3], columns=["A", "B", "C", "D"])
|
||||
expected = pd.concat([normal_result, pad])
|
||||
expected = expected.sort_index()
|
||||
dti = date_range(start="2013-01-01", freq="D", periods=5, name="key")
|
||||
expected.index = dti._with_freq(None) # TODO: is this desired?
|
||||
tm.assert_frame_equal(expected, dt_result)
|
||||
assert dt_result.index.name == "key"
|
||||
|
||||
|
||||
def test_aggregate_with_nat_size():
|
||||
# GH 9925
|
||||
n = 20
|
||||
data = np.random.default_rng(2).standard_normal((n, 4)).astype("int64")
|
||||
normal_df = DataFrame(data, columns=["A", "B", "C", "D"])
|
||||
normal_df["key"] = [1, 2, np.nan, 4, 5] * 4
|
||||
|
||||
dt_df = DataFrame(data, columns=["A", "B", "C", "D"])
|
||||
dt_df["key"] = [
|
||||
datetime(2013, 1, 1),
|
||||
datetime(2013, 1, 2),
|
||||
pd.NaT,
|
||||
datetime(2013, 1, 4),
|
||||
datetime(2013, 1, 5),
|
||||
] * 4
|
||||
|
||||
normal_grouped = normal_df.groupby("key")
|
||||
dt_grouped = dt_df.groupby(Grouper(key="key", freq="D"))
|
||||
|
||||
normal_result = normal_grouped.size()
|
||||
dt_result = dt_grouped.size()
|
||||
|
||||
pad = Series([0], index=[3])
|
||||
expected = pd.concat([normal_result, pad])
|
||||
expected = expected.sort_index()
|
||||
expected.index = date_range(
|
||||
start="2013-01-01", freq="D", periods=5, name="key"
|
||||
)._with_freq(None)
|
||||
tm.assert_series_equal(expected, dt_result)
|
||||
assert dt_result.index.name == "key"
|
||||
|
||||
|
||||
def test_repr():
|
||||
# GH18203
|
||||
result = repr(Grouper(key="A", freq="H"))
|
||||
expected = (
|
||||
"TimeGrouper(key='A', freq=<Hour>, axis=0, sort=True, dropna=True, "
|
||||
"closed='left', label='left', how='mean', "
|
||||
"convention='e', origin='start_day')"
|
||||
)
|
||||
assert result == expected
|
||||
|
||||
result = repr(Grouper(key="A", freq="H", origin="2000-01-01"))
|
||||
expected = (
|
||||
"TimeGrouper(key='A', freq=<Hour>, axis=0, sort=True, dropna=True, "
|
||||
"closed='left', label='left', how='mean', "
|
||||
"convention='e', origin=Timestamp('2000-01-01 00:00:00'))"
|
||||
)
|
||||
assert result == expected
|
||||
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
"method, method_args, expected_values",
|
||||
[
|
||||
("sum", {}, [1, 0, 1]),
|
||||
("sum", {"min_count": 0}, [1, 0, 1]),
|
||||
("sum", {"min_count": 1}, [1, np.nan, 1]),
|
||||
("sum", {"min_count": 2}, [np.nan, np.nan, np.nan]),
|
||||
("prod", {}, [1, 1, 1]),
|
||||
("prod", {"min_count": 0}, [1, 1, 1]),
|
||||
("prod", {"min_count": 1}, [1, np.nan, 1]),
|
||||
("prod", {"min_count": 2}, [np.nan, np.nan, np.nan]),
|
||||
],
|
||||
)
|
||||
def test_upsample_sum(method, method_args, expected_values):
|
||||
s = Series(1, index=date_range("2017", periods=2, freq="H"))
|
||||
resampled = s.resample("30T")
|
||||
index = pd.DatetimeIndex(
|
||||
["2017-01-01T00:00:00", "2017-01-01T00:30:00", "2017-01-01T01:00:00"],
|
||||
freq="30T",
|
||||
)
|
||||
result = methodcaller(method, **method_args)(resampled)
|
||||
expected = Series(expected_values, index=index)
|
||||
tm.assert_series_equal(result, expected)
|
||||
|
||||
|
||||
def test_groupby_resample_interpolate():
|
||||
# GH 35325
|
||||
d = {"price": [10, 11, 9], "volume": [50, 60, 50]}
|
||||
|
||||
df = DataFrame(d)
|
||||
|
||||
df["week_starting"] = date_range("01/01/2018", periods=3, freq="W")
|
||||
|
||||
result = (
|
||||
df.set_index("week_starting")
|
||||
.groupby("volume")
|
||||
.resample("1D")
|
||||
.interpolate(method="linear")
|
||||
)
|
||||
|
||||
expected_ind = pd.MultiIndex.from_tuples(
|
||||
[
|
||||
(50, Timestamp("2018-01-07")),
|
||||
(50, Timestamp("2018-01-08")),
|
||||
(50, Timestamp("2018-01-09")),
|
||||
(50, Timestamp("2018-01-10")),
|
||||
(50, Timestamp("2018-01-11")),
|
||||
(50, Timestamp("2018-01-12")),
|
||||
(50, Timestamp("2018-01-13")),
|
||||
(50, Timestamp("2018-01-14")),
|
||||
(50, Timestamp("2018-01-15")),
|
||||
(50, Timestamp("2018-01-16")),
|
||||
(50, Timestamp("2018-01-17")),
|
||||
(50, Timestamp("2018-01-18")),
|
||||
(50, Timestamp("2018-01-19")),
|
||||
(50, Timestamp("2018-01-20")),
|
||||
(50, Timestamp("2018-01-21")),
|
||||
(60, Timestamp("2018-01-14")),
|
||||
],
|
||||
names=["volume", "week_starting"],
|
||||
)
|
||||
|
||||
expected = DataFrame(
|
||||
data={
|
||||
"price": [
|
||||
10.0,
|
||||
9.928571428571429,
|
||||
9.857142857142858,
|
||||
9.785714285714286,
|
||||
9.714285714285714,
|
||||
9.642857142857142,
|
||||
9.571428571428571,
|
||||
9.5,
|
||||
9.428571428571429,
|
||||
9.357142857142858,
|
||||
9.285714285714286,
|
||||
9.214285714285714,
|
||||
9.142857142857142,
|
||||
9.071428571428571,
|
||||
9.0,
|
||||
11.0,
|
||||
],
|
||||
"volume": [50.0] * 15 + [60],
|
||||
},
|
||||
index=expected_ind,
|
||||
)
|
||||
tm.assert_frame_equal(result, expected)
|
@@ -0,0 +1,206 @@
|
||||
from datetime import timedelta
|
||||
|
||||
import numpy as np
|
||||
import pytest
|
||||
|
||||
import pandas as pd
|
||||
from pandas import (
|
||||
DataFrame,
|
||||
Series,
|
||||
)
|
||||
import pandas._testing as tm
|
||||
from pandas.core.indexes.timedeltas import timedelta_range
|
||||
|
||||
|
||||
def test_asfreq_bug():
|
||||
df = DataFrame(data=[1, 3], index=[timedelta(), timedelta(minutes=3)])
|
||||
result = df.resample("1T").asfreq()
|
||||
expected = DataFrame(
|
||||
data=[1, np.nan, np.nan, 3],
|
||||
index=timedelta_range("0 day", periods=4, freq="1T"),
|
||||
)
|
||||
tm.assert_frame_equal(result, expected)
|
||||
|
||||
|
||||
def test_resample_with_nat():
|
||||
# GH 13223
|
||||
index = pd.to_timedelta(["0s", pd.NaT, "2s"])
|
||||
result = DataFrame({"value": [2, 3, 5]}, index).resample("1s").mean()
|
||||
expected = DataFrame(
|
||||
{"value": [2.5, np.nan, 5.0]},
|
||||
index=timedelta_range("0 day", periods=3, freq="1S"),
|
||||
)
|
||||
tm.assert_frame_equal(result, expected)
|
||||
|
||||
|
||||
def test_resample_as_freq_with_subperiod():
|
||||
# GH 13022
|
||||
index = timedelta_range("00:00:00", "00:10:00", freq="5T")
|
||||
df = DataFrame(data={"value": [1, 5, 10]}, index=index)
|
||||
result = df.resample("2T").asfreq()
|
||||
expected_data = {"value": [1, np.nan, np.nan, np.nan, np.nan, 10]}
|
||||
expected = DataFrame(
|
||||
data=expected_data, index=timedelta_range("00:00:00", "00:10:00", freq="2T")
|
||||
)
|
||||
tm.assert_frame_equal(result, expected)
|
||||
|
||||
|
||||
def test_resample_with_timedeltas():
|
||||
expected = DataFrame({"A": np.arange(1480)})
|
||||
expected = expected.groupby(expected.index // 30).sum()
|
||||
expected.index = timedelta_range("0 days", freq="30min", periods=50)
|
||||
|
||||
df = DataFrame(
|
||||
{"A": np.arange(1480)}, index=pd.to_timedelta(np.arange(1480), unit="min")
|
||||
)
|
||||
result = df.resample("30min").sum()
|
||||
|
||||
tm.assert_frame_equal(result, expected)
|
||||
|
||||
s = df["A"]
|
||||
result = s.resample("30min").sum()
|
||||
tm.assert_series_equal(result, expected["A"])
|
||||
|
||||
|
||||
def test_resample_single_period_timedelta():
|
||||
s = Series(list(range(5)), index=timedelta_range("1 day", freq="s", periods=5))
|
||||
result = s.resample("2s").sum()
|
||||
expected = Series([1, 5, 4], index=timedelta_range("1 day", freq="2s", periods=3))
|
||||
tm.assert_series_equal(result, expected)
|
||||
|
||||
|
||||
def test_resample_timedelta_idempotency():
|
||||
# GH 12072
|
||||
index = timedelta_range("0", periods=9, freq="10L")
|
||||
series = Series(range(9), index=index)
|
||||
result = series.resample("10L").mean()
|
||||
expected = series.astype(float)
|
||||
tm.assert_series_equal(result, expected)
|
||||
|
||||
|
||||
def test_resample_offset_with_timedeltaindex():
|
||||
# GH 10530 & 31809
|
||||
rng = timedelta_range(start="0s", periods=25, freq="s")
|
||||
ts = Series(np.random.default_rng(2).standard_normal(len(rng)), index=rng)
|
||||
|
||||
with_base = ts.resample("2s", offset="5s").mean()
|
||||
without_base = ts.resample("2s").mean()
|
||||
|
||||
exp_without_base = timedelta_range(start="0s", end="25s", freq="2s")
|
||||
exp_with_base = timedelta_range(start="5s", end="29s", freq="2s")
|
||||
|
||||
tm.assert_index_equal(without_base.index, exp_without_base)
|
||||
tm.assert_index_equal(with_base.index, exp_with_base)
|
||||
|
||||
|
||||
def test_resample_categorical_data_with_timedeltaindex():
|
||||
# GH #12169
|
||||
df = DataFrame({"Group_obj": "A"}, index=pd.to_timedelta(list(range(20)), unit="s"))
|
||||
df["Group"] = df["Group_obj"].astype("category")
|
||||
result = df.resample("10s").agg(lambda x: (x.value_counts().index[0]))
|
||||
expected = DataFrame(
|
||||
{"Group_obj": ["A", "A"], "Group": ["A", "A"]},
|
||||
index=pd.TimedeltaIndex([0, 10], unit="s", freq="10s"),
|
||||
)
|
||||
expected = expected.reindex(["Group_obj", "Group"], axis=1)
|
||||
expected["Group"] = expected["Group_obj"]
|
||||
tm.assert_frame_equal(result, expected)
|
||||
|
||||
|
||||
def test_resample_timedelta_values():
|
||||
# GH 13119
|
||||
# check that timedelta dtype is preserved when NaT values are
|
||||
# introduced by the resampling
|
||||
|
||||
times = timedelta_range("1 day", "6 day", freq="4D")
|
||||
df = DataFrame({"time": times}, index=times)
|
||||
|
||||
times2 = timedelta_range("1 day", "6 day", freq="2D")
|
||||
exp = Series(times2, index=times2, name="time")
|
||||
exp.iloc[1] = pd.NaT
|
||||
|
||||
res = df.resample("2D").first()["time"]
|
||||
tm.assert_series_equal(res, exp)
|
||||
res = df["time"].resample("2D").first()
|
||||
tm.assert_series_equal(res, exp)
|
||||
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
"start, end, freq, resample_freq",
|
||||
[
|
||||
("8H", "21h59min50s", "10S", "3H"), # GH 30353 example
|
||||
("3H", "22H", "1H", "5H"),
|
||||
("527D", "5006D", "3D", "10D"),
|
||||
("1D", "10D", "1D", "2D"), # GH 13022 example
|
||||
# tests that worked before GH 33498:
|
||||
("8H", "21h59min50s", "10S", "2H"),
|
||||
("0H", "21h59min50s", "10S", "3H"),
|
||||
("10D", "85D", "D", "2D"),
|
||||
],
|
||||
)
|
||||
def test_resample_timedelta_edge_case(start, end, freq, resample_freq):
|
||||
# GH 33498
|
||||
# check that the timedelta bins does not contains an extra bin
|
||||
idx = timedelta_range(start=start, end=end, freq=freq)
|
||||
s = Series(np.arange(len(idx)), index=idx)
|
||||
result = s.resample(resample_freq).min()
|
||||
expected_index = timedelta_range(freq=resample_freq, start=start, end=end)
|
||||
tm.assert_index_equal(result.index, expected_index)
|
||||
assert result.index.freq == expected_index.freq
|
||||
assert not np.isnan(result.iloc[-1])
|
||||
|
||||
|
||||
@pytest.mark.parametrize("duplicates", [True, False])
|
||||
def test_resample_with_timedelta_yields_no_empty_groups(duplicates):
|
||||
# GH 10603
|
||||
df = DataFrame(
|
||||
np.random.default_rng(2).normal(size=(10000, 4)),
|
||||
index=timedelta_range(start="0s", periods=10000, freq="3906250n"),
|
||||
)
|
||||
if duplicates:
|
||||
# case with non-unique columns
|
||||
df.columns = ["A", "B", "A", "C"]
|
||||
|
||||
result = df.loc["1s":, :].resample("3s").apply(lambda x: len(x))
|
||||
|
||||
expected = DataFrame(
|
||||
[[768] * 4] * 12 + [[528] * 4],
|
||||
index=timedelta_range(start="1s", periods=13, freq="3s"),
|
||||
)
|
||||
expected.columns = df.columns
|
||||
tm.assert_frame_equal(result, expected)
|
||||
|
||||
|
||||
@pytest.mark.parametrize("unit", ["s", "ms", "us", "ns"])
|
||||
def test_resample_quantile_timedelta(unit):
|
||||
# GH: 29485
|
||||
dtype = np.dtype(f"m8[{unit}]")
|
||||
df = DataFrame(
|
||||
{"value": pd.to_timedelta(np.arange(4), unit="s").astype(dtype)},
|
||||
index=pd.date_range("20200101", periods=4, tz="UTC"),
|
||||
)
|
||||
result = df.resample("2D").quantile(0.99)
|
||||
expected = DataFrame(
|
||||
{
|
||||
"value": [
|
||||
pd.Timedelta("0 days 00:00:00.990000"),
|
||||
pd.Timedelta("0 days 00:00:02.990000"),
|
||||
]
|
||||
},
|
||||
index=pd.date_range("20200101", periods=2, tz="UTC", freq="2D"),
|
||||
).astype(dtype)
|
||||
tm.assert_frame_equal(result, expected)
|
||||
|
||||
|
||||
def test_resample_closed_right():
|
||||
# GH#45414
|
||||
idx = pd.Index([pd.Timedelta(seconds=120 + i * 30) for i in range(10)])
|
||||
ser = Series(range(10), index=idx)
|
||||
result = ser.resample("T", closed="right", label="right").sum()
|
||||
expected = Series(
|
||||
[0, 3, 7, 11, 15, 9],
|
||||
index=pd.TimedeltaIndex(
|
||||
[pd.Timedelta(seconds=120 + i * 60) for i in range(6)], freq="T"
|
||||
),
|
||||
)
|
||||
tm.assert_series_equal(result, expected)
|
Reference in New Issue
Block a user