pruned venvs
This commit is contained in:
d3m1g0d
BIN
Binary file not shown.
BIN
Binary file not shown.
BIN
Binary file not shown.
BIN
Binary file not shown.
BIN
Binary file not shown.
BIN
Binary file not shown.
BIN
Binary file not shown.
BIN
Binary file not shown.
BIN
Binary file not shown.
BIN
Binary file not shown.
BIN
Binary file not shown.
BIN
Binary file not shown.
BIN
Binary file not shown.
BIN
Binary file not shown.
-885
@@ -1,885 +0,0 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
from datetime import timedelta
|
||||
import operator
|
||||
|
||||
import pytest
|
||||
import numpy as np
|
||||
|
||||
import pandas as pd
|
||||
import pandas.util.testing as tm
|
||||
from pandas import (Timedelta,
|
||||
period_range, Period, PeriodIndex,
|
||||
_np_version_under1p10)
|
||||
import pandas.core.indexes.period as period
|
||||
from pandas.core import ops
|
||||
from pandas.errors import PerformanceWarning
|
||||
|
||||
|
||||
_common_mismatch = [pd.offsets.YearBegin(2),
|
||||
pd.offsets.MonthBegin(1),
|
||||
pd.offsets.Minute()]
|
||||
|
||||
|
||||
@pytest.fixture(params=[timedelta(minutes=30),
|
||||
np.timedelta64(30, 's'),
|
||||
Timedelta(seconds=30)] + _common_mismatch)
|
||||
def not_hourly(request):
|
||||
"""
|
||||
Several timedelta-like and DateOffset instances that are _not_
|
||||
compatible with Hourly frequencies.
|
||||
"""
|
||||
return request.param
|
||||
|
||||
|
||||
@pytest.fixture(params=[np.timedelta64(4, 'h'),
|
||||
timedelta(hours=23),
|
||||
Timedelta('23:00:00')] + _common_mismatch)
|
||||
def not_daily(request):
|
||||
"""
|
||||
Several timedelta-like and DateOffset instances that are _not_
|
||||
compatible with Daily frequencies.
|
||||
"""
|
||||
return request.param
|
||||
|
||||
|
||||
@pytest.fixture(params=[np.timedelta64(365, 'D'),
|
||||
timedelta(365),
|
||||
Timedelta(days=365)] + _common_mismatch)
|
||||
def mismatched(request):
|
||||
"""
|
||||
Several timedelta-like and DateOffset instances that are _not_
|
||||
compatible with Monthly or Annual frequencies.
|
||||
"""
|
||||
return request.param
|
||||
|
||||
|
||||
@pytest.fixture(params=[pd.offsets.Day(3),
|
||||
timedelta(days=3),
|
||||
np.timedelta64(3, 'D'),
|
||||
pd.offsets.Hour(72),
|
||||
timedelta(minutes=60 * 24 * 3),
|
||||
np.timedelta64(72, 'h'),
|
||||
Timedelta('72:00:00')])
|
||||
def three_days(request):
|
||||
"""
|
||||
Several timedelta-like and DateOffset objects that each represent
|
||||
a 3-day timedelta
|
||||
"""
|
||||
return request.param
|
||||
|
||||
|
||||
@pytest.fixture(params=[pd.offsets.Hour(2),
|
||||
timedelta(hours=2),
|
||||
np.timedelta64(2, 'h'),
|
||||
pd.offsets.Minute(120),
|
||||
timedelta(minutes=120),
|
||||
np.timedelta64(120, 'm')])
|
||||
def two_hours(request):
|
||||
"""
|
||||
Several timedelta-like and DateOffset objects that each represent
|
||||
a 2-hour timedelta
|
||||
"""
|
||||
return request.param
|
||||
|
||||
|
||||
class TestPeriodIndexComparisons(object):
|
||||
def test_pi_cmp_period(self):
|
||||
idx = period_range('2007-01', periods=20, freq='M')
|
||||
|
||||
result = idx < idx[10]
|
||||
exp = idx.values < idx.values[10]
|
||||
tm.assert_numpy_array_equal(result, exp)
|
||||
|
||||
@pytest.mark.parametrize('freq', ['M', '2M', '3M'])
|
||||
def test_pi_cmp_pi(self, freq):
|
||||
base = PeriodIndex(['2011-01', '2011-02', '2011-03', '2011-04'],
|
||||
freq=freq)
|
||||
per = Period('2011-02', freq=freq)
|
||||
|
||||
exp = np.array([False, True, False, False])
|
||||
tm.assert_numpy_array_equal(base == per, exp)
|
||||
tm.assert_numpy_array_equal(per == base, exp)
|
||||
|
||||
exp = np.array([True, False, True, True])
|
||||
tm.assert_numpy_array_equal(base != per, exp)
|
||||
tm.assert_numpy_array_equal(per != base, exp)
|
||||
|
||||
exp = np.array([False, False, True, True])
|
||||
tm.assert_numpy_array_equal(base > per, exp)
|
||||
tm.assert_numpy_array_equal(per < base, exp)
|
||||
|
||||
exp = np.array([True, False, False, False])
|
||||
tm.assert_numpy_array_equal(base < per, exp)
|
||||
tm.assert_numpy_array_equal(per > base, exp)
|
||||
|
||||
exp = np.array([False, True, True, True])
|
||||
tm.assert_numpy_array_equal(base >= per, exp)
|
||||
tm.assert_numpy_array_equal(per <= base, exp)
|
||||
|
||||
exp = np.array([True, True, False, False])
|
||||
tm.assert_numpy_array_equal(base <= per, exp)
|
||||
tm.assert_numpy_array_equal(per >= base, exp)
|
||||
|
||||
idx = PeriodIndex(['2011-02', '2011-01', '2011-03', '2011-05'],
|
||||
freq=freq)
|
||||
|
||||
exp = np.array([False, False, True, False])
|
||||
tm.assert_numpy_array_equal(base == idx, exp)
|
||||
|
||||
exp = np.array([True, True, False, True])
|
||||
tm.assert_numpy_array_equal(base != idx, exp)
|
||||
|
||||
exp = np.array([False, True, False, False])
|
||||
tm.assert_numpy_array_equal(base > idx, exp)
|
||||
|
||||
exp = np.array([True, False, False, True])
|
||||
tm.assert_numpy_array_equal(base < idx, exp)
|
||||
|
||||
exp = np.array([False, True, True, False])
|
||||
tm.assert_numpy_array_equal(base >= idx, exp)
|
||||
|
||||
exp = np.array([True, False, True, True])
|
||||
tm.assert_numpy_array_equal(base <= idx, exp)
|
||||
|
||||
@pytest.mark.parametrize('freq', ['M', '2M', '3M'])
|
||||
def test_pi_cmp_pi_mismatched_freq_raises(self, freq):
|
||||
# different base freq
|
||||
base = PeriodIndex(['2011-01', '2011-02', '2011-03', '2011-04'],
|
||||
freq=freq)
|
||||
|
||||
msg = "Input has different freq=A-DEC from PeriodIndex"
|
||||
with tm.assert_raises_regex(period.IncompatibleFrequency, msg):
|
||||
base <= Period('2011', freq='A')
|
||||
|
||||
with tm.assert_raises_regex(period.IncompatibleFrequency, msg):
|
||||
Period('2011', freq='A') >= base
|
||||
|
||||
idx = PeriodIndex(['2011', '2012', '2013', '2014'], freq='A')
|
||||
with tm.assert_raises_regex(period.IncompatibleFrequency, msg):
|
||||
base <= idx
|
||||
|
||||
# Different frequency
|
||||
msg = "Input has different freq=4M from PeriodIndex"
|
||||
with tm.assert_raises_regex(period.IncompatibleFrequency, msg):
|
||||
base <= Period('2011', freq='4M')
|
||||
|
||||
with tm.assert_raises_regex(period.IncompatibleFrequency, msg):
|
||||
Period('2011', freq='4M') >= base
|
||||
|
||||
idx = PeriodIndex(['2011', '2012', '2013', '2014'], freq='4M')
|
||||
with tm.assert_raises_regex(period.IncompatibleFrequency, msg):
|
||||
base <= idx
|
||||
|
||||
@pytest.mark.parametrize('freq', ['M', '2M', '3M'])
|
||||
def test_pi_cmp_nat(self, freq):
|
||||
idx1 = PeriodIndex(['2011-01', '2011-02', 'NaT', '2011-05'], freq=freq)
|
||||
|
||||
result = idx1 > Period('2011-02', freq=freq)
|
||||
exp = np.array([False, False, False, True])
|
||||
tm.assert_numpy_array_equal(result, exp)
|
||||
result = Period('2011-02', freq=freq) < idx1
|
||||
tm.assert_numpy_array_equal(result, exp)
|
||||
|
||||
result = idx1 == Period('NaT', freq=freq)
|
||||
exp = np.array([False, False, False, False])
|
||||
tm.assert_numpy_array_equal(result, exp)
|
||||
result = Period('NaT', freq=freq) == idx1
|
||||
tm.assert_numpy_array_equal(result, exp)
|
||||
|
||||
result = idx1 != Period('NaT', freq=freq)
|
||||
exp = np.array([True, True, True, True])
|
||||
tm.assert_numpy_array_equal(result, exp)
|
||||
result = Period('NaT', freq=freq) != idx1
|
||||
tm.assert_numpy_array_equal(result, exp)
|
||||
|
||||
idx2 = PeriodIndex(['2011-02', '2011-01', '2011-04', 'NaT'], freq=freq)
|
||||
result = idx1 < idx2
|
||||
exp = np.array([True, False, False, False])
|
||||
tm.assert_numpy_array_equal(result, exp)
|
||||
|
||||
result = idx1 == idx2
|
||||
exp = np.array([False, False, False, False])
|
||||
tm.assert_numpy_array_equal(result, exp)
|
||||
|
||||
result = idx1 != idx2
|
||||
exp = np.array([True, True, True, True])
|
||||
tm.assert_numpy_array_equal(result, exp)
|
||||
|
||||
result = idx1 == idx1
|
||||
exp = np.array([True, True, False, True])
|
||||
tm.assert_numpy_array_equal(result, exp)
|
||||
|
||||
result = idx1 != idx1
|
||||
exp = np.array([False, False, True, False])
|
||||
tm.assert_numpy_array_equal(result, exp)
|
||||
|
||||
@pytest.mark.parametrize('freq', ['M', '2M', '3M'])
|
||||
def test_pi_cmp_nat_mismatched_freq_raises(self, freq):
|
||||
idx1 = PeriodIndex(['2011-01', '2011-02', 'NaT', '2011-05'], freq=freq)
|
||||
|
||||
diff = PeriodIndex(['2011-02', '2011-01', '2011-04', 'NaT'], freq='4M')
|
||||
msg = "Input has different freq=4M from PeriodIndex"
|
||||
with tm.assert_raises_regex(period.IncompatibleFrequency, msg):
|
||||
idx1 > diff
|
||||
|
||||
with tm.assert_raises_regex(period.IncompatibleFrequency, msg):
|
||||
idx1 == diff
|
||||
|
||||
# TODO: De-duplicate with test_pi_cmp_nat
|
||||
@pytest.mark.parametrize('dtype', [object, None])
|
||||
def test_comp_nat(self, dtype):
|
||||
left = pd.PeriodIndex([pd.Period('2011-01-01'), pd.NaT,
|
||||
pd.Period('2011-01-03')])
|
||||
right = pd.PeriodIndex([pd.NaT, pd.NaT, pd.Period('2011-01-03')])
|
||||
|
||||
if dtype is not None:
|
||||
left = left.astype(dtype)
|
||||
right = right.astype(dtype)
|
||||
|
||||
result = left == right
|
||||
expected = np.array([False, False, True])
|
||||
tm.assert_numpy_array_equal(result, expected)
|
||||
|
||||
result = left != right
|
||||
expected = np.array([True, True, False])
|
||||
tm.assert_numpy_array_equal(result, expected)
|
||||
|
||||
expected = np.array([False, False, False])
|
||||
tm.assert_numpy_array_equal(left == pd.NaT, expected)
|
||||
tm.assert_numpy_array_equal(pd.NaT == right, expected)
|
||||
|
||||
expected = np.array([True, True, True])
|
||||
tm.assert_numpy_array_equal(left != pd.NaT, expected)
|
||||
tm.assert_numpy_array_equal(pd.NaT != left, expected)
|
||||
|
||||
expected = np.array([False, False, False])
|
||||
tm.assert_numpy_array_equal(left < pd.NaT, expected)
|
||||
tm.assert_numpy_array_equal(pd.NaT > left, expected)
|
||||
|
||||
|
||||
class TestPeriodIndexArithmetic(object):
|
||||
|
||||
# -------------------------------------------------------------
|
||||
# Invalid Operations
|
||||
|
||||
@pytest.mark.parametrize('other', [3.14, np.array([2.0, 3.0])])
|
||||
@pytest.mark.parametrize('op', [operator.add, ops.radd,
|
||||
operator.sub, ops.rsub])
|
||||
def test_pi_add_sub_float(self, op, other):
|
||||
dti = pd.DatetimeIndex(['2011-01-01', '2011-01-02'], freq='D')
|
||||
pi = dti.to_period('D')
|
||||
with pytest.raises(TypeError):
|
||||
op(pi, other)
|
||||
|
||||
# -----------------------------------------------------------------
|
||||
# __add__/__sub__ with ndarray[datetime64] and ndarray[timedelta64]
|
||||
|
||||
def test_pi_add_sub_dt64_array_raises(self):
|
||||
rng = pd.period_range('1/1/2000', freq='D', periods=3)
|
||||
dti = pd.date_range('2016-01-01', periods=3)
|
||||
dtarr = dti.values
|
||||
|
||||
with pytest.raises(TypeError):
|
||||
rng + dtarr
|
||||
with pytest.raises(TypeError):
|
||||
dtarr + rng
|
||||
|
||||
with pytest.raises(TypeError):
|
||||
rng - dtarr
|
||||
with pytest.raises(TypeError):
|
||||
dtarr - rng
|
||||
|
||||
def test_pi_add_sub_td64_array_non_tick_raises(self):
|
||||
rng = pd.period_range('1/1/2000', freq='Q', periods=3)
|
||||
dti = pd.date_range('2016-01-01', periods=3)
|
||||
tdi = dti - dti.shift(1)
|
||||
tdarr = tdi.values
|
||||
|
||||
with pytest.raises(period.IncompatibleFrequency):
|
||||
rng + tdarr
|
||||
with pytest.raises(period.IncompatibleFrequency):
|
||||
tdarr + rng
|
||||
|
||||
with pytest.raises(period.IncompatibleFrequency):
|
||||
rng - tdarr
|
||||
with pytest.raises(period.IncompatibleFrequency):
|
||||
tdarr - rng
|
||||
|
||||
@pytest.mark.xfail(reason='op with TimedeltaIndex raises, with ndarray OK')
|
||||
def test_pi_add_sub_td64_array_tick(self):
|
||||
rng = pd.period_range('1/1/2000', freq='Q', periods=3)
|
||||
dti = pd.date_range('2016-01-01', periods=3)
|
||||
tdi = dti - dti.shift(1)
|
||||
tdarr = tdi.values
|
||||
|
||||
expected = rng + tdi
|
||||
result = rng + tdarr
|
||||
tm.assert_index_equal(result, expected)
|
||||
result = tdarr + rng
|
||||
tm.assert_index_equal(result, expected)
|
||||
|
||||
expected = rng - tdi
|
||||
result = rng - tdarr
|
||||
tm.assert_index_equal(result, expected)
|
||||
|
||||
with pytest.raises(TypeError):
|
||||
tdarr - rng
|
||||
|
||||
# -----------------------------------------------------------------
|
||||
# operations with array/Index of DateOffset objects
|
||||
|
||||
@pytest.mark.parametrize('box', [np.array, pd.Index])
|
||||
def test_pi_add_offset_array(self, box):
|
||||
# GH#18849
|
||||
pi = pd.PeriodIndex([pd.Period('2015Q1'), pd.Period('2016Q2')])
|
||||
offs = box([pd.offsets.QuarterEnd(n=1, startingMonth=12),
|
||||
pd.offsets.QuarterEnd(n=-2, startingMonth=12)])
|
||||
expected = pd.PeriodIndex([pd.Period('2015Q2'), pd.Period('2015Q4')])
|
||||
|
||||
with tm.assert_produces_warning(PerformanceWarning):
|
||||
res = pi + offs
|
||||
tm.assert_index_equal(res, expected)
|
||||
|
||||
with tm.assert_produces_warning(PerformanceWarning):
|
||||
res2 = offs + pi
|
||||
tm.assert_index_equal(res2, expected)
|
||||
|
||||
unanchored = np.array([pd.offsets.Hour(n=1),
|
||||
pd.offsets.Minute(n=-2)])
|
||||
# addition/subtraction ops with incompatible offsets should issue
|
||||
# a PerformanceWarning and _then_ raise a TypeError.
|
||||
with pytest.raises(period.IncompatibleFrequency):
|
||||
with tm.assert_produces_warning(PerformanceWarning):
|
||||
pi + unanchored
|
||||
with pytest.raises(period.IncompatibleFrequency):
|
||||
with tm.assert_produces_warning(PerformanceWarning):
|
||||
unanchored + pi
|
||||
|
||||
@pytest.mark.parametrize('box', [np.array, pd.Index])
|
||||
def test_pi_sub_offset_array(self, box):
|
||||
# GH#18824
|
||||
pi = pd.PeriodIndex([pd.Period('2015Q1'), pd.Period('2016Q2')])
|
||||
other = box([pd.offsets.QuarterEnd(n=1, startingMonth=12),
|
||||
pd.offsets.QuarterEnd(n=-2, startingMonth=12)])
|
||||
|
||||
expected = PeriodIndex([pi[n] - other[n] for n in range(len(pi))])
|
||||
|
||||
with tm.assert_produces_warning(PerformanceWarning):
|
||||
res = pi - other
|
||||
tm.assert_index_equal(res, expected)
|
||||
|
||||
anchored = box([pd.offsets.MonthEnd(), pd.offsets.Day(n=2)])
|
||||
|
||||
# addition/subtraction ops with anchored offsets should issue
|
||||
# a PerformanceWarning and _then_ raise a TypeError.
|
||||
with pytest.raises(period.IncompatibleFrequency):
|
||||
with tm.assert_produces_warning(PerformanceWarning):
|
||||
pi - anchored
|
||||
with pytest.raises(period.IncompatibleFrequency):
|
||||
with tm.assert_produces_warning(PerformanceWarning):
|
||||
anchored - pi
|
||||
|
||||
def test_pi_add_iadd_pi_raises(self):
|
||||
rng = pd.period_range('1/1/2000', freq='D', periods=5)
|
||||
other = pd.period_range('1/6/2000', freq='D', periods=5)
|
||||
|
||||
# previously performed setop union, now raises TypeError (GH14164)
|
||||
with pytest.raises(TypeError):
|
||||
rng + other
|
||||
|
||||
with pytest.raises(TypeError):
|
||||
rng += other
|
||||
|
||||
def test_pi_add_iadd_int(self, one):
|
||||
# Variants of `one` for #19012
|
||||
rng = pd.period_range('2000-01-01 09:00', freq='H', periods=10)
|
||||
result = rng + one
|
||||
expected = pd.period_range('2000-01-01 10:00', freq='H', periods=10)
|
||||
tm.assert_index_equal(result, expected)
|
||||
rng += one
|
||||
tm.assert_index_equal(rng, expected)
|
||||
|
||||
def test_pi_sub_isub_int(self, one):
|
||||
"""
|
||||
PeriodIndex.__sub__ and __isub__ with several representations of
|
||||
the integer 1, e.g. int, long, np.int64, np.uint8, ...
|
||||
"""
|
||||
rng = pd.period_range('2000-01-01 09:00', freq='H', periods=10)
|
||||
result = rng - one
|
||||
expected = pd.period_range('2000-01-01 08:00', freq='H', periods=10)
|
||||
tm.assert_index_equal(result, expected)
|
||||
rng -= one
|
||||
tm.assert_index_equal(rng, expected)
|
||||
|
||||
@pytest.mark.parametrize('five', [5, np.array(5, dtype=np.int64)])
|
||||
def test_pi_sub_intlike(self, five):
|
||||
rng = period_range('2007-01', periods=50)
|
||||
|
||||
result = rng - five
|
||||
exp = rng + (-five)
|
||||
tm.assert_index_equal(result, exp)
|
||||
|
||||
def test_pi_sub_isub_pi_raises(self):
|
||||
# previously performed setop, now raises TypeError (GH14164)
|
||||
# TODO needs to wait on #13077 for decision on result type
|
||||
rng = pd.period_range('1/1/2000', freq='D', periods=5)
|
||||
other = pd.period_range('1/6/2000', freq='D', periods=5)
|
||||
|
||||
with pytest.raises(TypeError):
|
||||
rng - other
|
||||
|
||||
with pytest.raises(TypeError):
|
||||
rng -= other
|
||||
|
||||
def test_pi_sub_isub_offset(self):
|
||||
# offset
|
||||
# DateOffset
|
||||
rng = pd.period_range('2014', '2024', freq='A')
|
||||
result = rng - pd.offsets.YearEnd(5)
|
||||
expected = pd.period_range('2009', '2019', freq='A')
|
||||
tm.assert_index_equal(result, expected)
|
||||
rng -= pd.offsets.YearEnd(5)
|
||||
tm.assert_index_equal(rng, expected)
|
||||
|
||||
rng = pd.period_range('2014-01', '2016-12', freq='M')
|
||||
result = rng - pd.offsets.MonthEnd(5)
|
||||
expected = pd.period_range('2013-08', '2016-07', freq='M')
|
||||
tm.assert_index_equal(result, expected)
|
||||
|
||||
rng -= pd.offsets.MonthEnd(5)
|
||||
tm.assert_index_equal(rng, expected)
|
||||
|
||||
# ---------------------------------------------------------------
|
||||
# Timedelta-like (timedelta, timedelta64, Timedelta, Tick)
|
||||
# TODO: Some of these are misnomers because of non-Tick DateOffsets
|
||||
|
||||
def test_pi_add_iadd_timedeltalike_daily(self, three_days):
|
||||
# Tick
|
||||
other = three_days
|
||||
rng = pd.period_range('2014-05-01', '2014-05-15', freq='D')
|
||||
expected = pd.period_range('2014-05-04', '2014-05-18', freq='D')
|
||||
|
||||
result = rng + other
|
||||
tm.assert_index_equal(result, expected)
|
||||
|
||||
rng += other
|
||||
tm.assert_index_equal(rng, expected)
|
||||
|
||||
def test_pi_sub_isub_timedeltalike_daily(self, three_days):
|
||||
# Tick-like 3 Days
|
||||
other = three_days
|
||||
rng = pd.period_range('2014-05-01', '2014-05-15', freq='D')
|
||||
expected = pd.period_range('2014-04-28', '2014-05-12', freq='D')
|
||||
|
||||
result = rng - other
|
||||
tm.assert_index_equal(result, expected)
|
||||
|
||||
rng -= other
|
||||
tm.assert_index_equal(rng, expected)
|
||||
|
||||
def test_pi_add_iadd_timedeltalike_freq_mismatch_daily(self, not_daily):
|
||||
other = not_daily
|
||||
rng = pd.period_range('2014-05-01', '2014-05-15', freq='D')
|
||||
msg = 'Input has different freq(=.+)? from PeriodIndex\\(freq=D\\)'
|
||||
with tm.assert_raises_regex(period.IncompatibleFrequency, msg):
|
||||
rng + other
|
||||
with tm.assert_raises_regex(period.IncompatibleFrequency, msg):
|
||||
rng += other
|
||||
|
||||
def test_pi_sub_timedeltalike_freq_mismatch_daily(self, not_daily):
|
||||
other = not_daily
|
||||
rng = pd.period_range('2014-05-01', '2014-05-15', freq='D')
|
||||
msg = 'Input has different freq(=.+)? from PeriodIndex\\(freq=D\\)'
|
||||
with tm.assert_raises_regex(period.IncompatibleFrequency, msg):
|
||||
rng - other
|
||||
|
||||
def test_pi_add_iadd_timedeltalike_hourly(self, two_hours):
|
||||
other = two_hours
|
||||
rng = pd.period_range('2014-01-01 10:00', '2014-01-05 10:00', freq='H')
|
||||
expected = pd.period_range('2014-01-01 12:00', '2014-01-05 12:00',
|
||||
freq='H')
|
||||
|
||||
result = rng + other
|
||||
tm.assert_index_equal(result, expected)
|
||||
|
||||
rng += other
|
||||
tm.assert_index_equal(rng, expected)
|
||||
|
||||
def test_pi_add_timedeltalike_mismatched_freq_hourly(self, not_hourly):
|
||||
other = not_hourly
|
||||
rng = pd.period_range('2014-01-01 10:00', '2014-01-05 10:00', freq='H')
|
||||
msg = 'Input has different freq(=.+)? from PeriodIndex\\(freq=H\\)'
|
||||
|
||||
with tm.assert_raises_regex(period.IncompatibleFrequency, msg):
|
||||
rng + other
|
||||
|
||||
with tm.assert_raises_regex(period.IncompatibleFrequency, msg):
|
||||
rng += other
|
||||
|
||||
def test_pi_sub_isub_timedeltalike_hourly(self, two_hours):
|
||||
other = two_hours
|
||||
rng = pd.period_range('2014-01-01 10:00', '2014-01-05 10:00', freq='H')
|
||||
expected = pd.period_range('2014-01-01 08:00', '2014-01-05 08:00',
|
||||
freq='H')
|
||||
|
||||
result = rng - other
|
||||
tm.assert_index_equal(result, expected)
|
||||
|
||||
rng -= other
|
||||
tm.assert_index_equal(rng, expected)
|
||||
|
||||
def test_add_iadd_timedeltalike_annual(self):
|
||||
# offset
|
||||
# DateOffset
|
||||
rng = pd.period_range('2014', '2024', freq='A')
|
||||
result = rng + pd.offsets.YearEnd(5)
|
||||
expected = pd.period_range('2019', '2029', freq='A')
|
||||
tm.assert_index_equal(result, expected)
|
||||
rng += pd.offsets.YearEnd(5)
|
||||
tm.assert_index_equal(rng, expected)
|
||||
|
||||
def test_pi_add_iadd_timedeltalike_freq_mismatch_annual(self, mismatched):
|
||||
other = mismatched
|
||||
rng = pd.period_range('2014', '2024', freq='A')
|
||||
msg = ('Input has different freq(=.+)? '
|
||||
'from PeriodIndex\\(freq=A-DEC\\)')
|
||||
with tm.assert_raises_regex(period.IncompatibleFrequency, msg):
|
||||
rng + other
|
||||
with tm.assert_raises_regex(period.IncompatibleFrequency, msg):
|
||||
rng += other
|
||||
|
||||
def test_pi_sub_isub_timedeltalike_freq_mismatch_annual(self, mismatched):
|
||||
other = mismatched
|
||||
rng = pd.period_range('2014', '2024', freq='A')
|
||||
msg = ('Input has different freq(=.+)? '
|
||||
'from PeriodIndex\\(freq=A-DEC\\)')
|
||||
with tm.assert_raises_regex(period.IncompatibleFrequency, msg):
|
||||
rng - other
|
||||
with tm.assert_raises_regex(period.IncompatibleFrequency, msg):
|
||||
rng -= other
|
||||
|
||||
def test_pi_add_iadd_timedeltalike_M(self):
|
||||
rng = pd.period_range('2014-01', '2016-12', freq='M')
|
||||
expected = pd.period_range('2014-06', '2017-05', freq='M')
|
||||
|
||||
result = rng + pd.offsets.MonthEnd(5)
|
||||
tm.assert_index_equal(result, expected)
|
||||
|
||||
rng += pd.offsets.MonthEnd(5)
|
||||
tm.assert_index_equal(rng, expected)
|
||||
|
||||
def test_pi_add_iadd_timedeltalike_freq_mismatch_monthly(self, mismatched):
|
||||
other = mismatched
|
||||
rng = pd.period_range('2014-01', '2016-12', freq='M')
|
||||
msg = 'Input has different freq(=.+)? from PeriodIndex\\(freq=M\\)'
|
||||
with tm.assert_raises_regex(period.IncompatibleFrequency, msg):
|
||||
rng + other
|
||||
with tm.assert_raises_regex(period.IncompatibleFrequency, msg):
|
||||
rng += other
|
||||
|
||||
def test_pi_sub_isub_timedeltalike_freq_mismatch_monthly(self, mismatched):
|
||||
other = mismatched
|
||||
rng = pd.period_range('2014-01', '2016-12', freq='M')
|
||||
msg = 'Input has different freq(=.+)? from PeriodIndex\\(freq=M\\)'
|
||||
with tm.assert_raises_regex(period.IncompatibleFrequency, msg):
|
||||
rng - other
|
||||
with tm.assert_raises_regex(period.IncompatibleFrequency, msg):
|
||||
rng -= other
|
||||
|
||||
# ---------------------------------------------------------------
|
||||
# PeriodIndex.shift is used by __add__ and __sub__
|
||||
|
||||
def test_pi_shift_ndarray(self):
|
||||
idx = PeriodIndex(['2011-01', '2011-02', 'NaT', '2011-04'],
|
||||
freq='M', name='idx')
|
||||
result = idx.shift(np.array([1, 2, 3, 4]))
|
||||
expected = PeriodIndex(['2011-02', '2011-04', 'NaT', '2011-08'],
|
||||
freq='M', name='idx')
|
||||
tm.assert_index_equal(result, expected)
|
||||
|
||||
result = idx.shift(np.array([1, -2, 3, -4]))
|
||||
expected = PeriodIndex(['2011-02', '2010-12', 'NaT', '2010-12'],
|
||||
freq='M', name='idx')
|
||||
tm.assert_index_equal(result, expected)
|
||||
|
||||
def test_shift(self):
|
||||
pi1 = PeriodIndex(freq='A', start='1/1/2001', end='12/1/2009')
|
||||
pi2 = PeriodIndex(freq='A', start='1/1/2002', end='12/1/2010')
|
||||
|
||||
tm.assert_index_equal(pi1.shift(0), pi1)
|
||||
|
||||
assert len(pi1) == len(pi2)
|
||||
tm.assert_index_equal(pi1.shift(1), pi2)
|
||||
|
||||
pi1 = PeriodIndex(freq='A', start='1/1/2001', end='12/1/2009')
|
||||
pi2 = PeriodIndex(freq='A', start='1/1/2000', end='12/1/2008')
|
||||
assert len(pi1) == len(pi2)
|
||||
tm.assert_index_equal(pi1.shift(-1), pi2)
|
||||
|
||||
pi1 = PeriodIndex(freq='M', start='1/1/2001', end='12/1/2009')
|
||||
pi2 = PeriodIndex(freq='M', start='2/1/2001', end='1/1/2010')
|
||||
assert len(pi1) == len(pi2)
|
||||
tm.assert_index_equal(pi1.shift(1), pi2)
|
||||
|
||||
pi1 = PeriodIndex(freq='M', start='1/1/2001', end='12/1/2009')
|
||||
pi2 = PeriodIndex(freq='M', start='12/1/2000', end='11/1/2009')
|
||||
assert len(pi1) == len(pi2)
|
||||
tm.assert_index_equal(pi1.shift(-1), pi2)
|
||||
|
||||
pi1 = PeriodIndex(freq='D', start='1/1/2001', end='12/1/2009')
|
||||
pi2 = PeriodIndex(freq='D', start='1/2/2001', end='12/2/2009')
|
||||
assert len(pi1) == len(pi2)
|
||||
tm.assert_index_equal(pi1.shift(1), pi2)
|
||||
|
||||
pi1 = PeriodIndex(freq='D', start='1/1/2001', end='12/1/2009')
|
||||
pi2 = PeriodIndex(freq='D', start='12/31/2000', end='11/30/2009')
|
||||
assert len(pi1) == len(pi2)
|
||||
tm.assert_index_equal(pi1.shift(-1), pi2)
|
||||
|
||||
def test_shift_corner_cases(self):
|
||||
# GH#9903
|
||||
idx = pd.PeriodIndex([], name='xxx', freq='H')
|
||||
|
||||
with pytest.raises(TypeError):
|
||||
# period shift doesn't accept freq
|
||||
idx.shift(1, freq='H')
|
||||
|
||||
tm.assert_index_equal(idx.shift(0), idx)
|
||||
tm.assert_index_equal(idx.shift(3), idx)
|
||||
|
||||
idx = pd.PeriodIndex(['2011-01-01 10:00', '2011-01-01 11:00'
|
||||
'2011-01-01 12:00'], name='xxx', freq='H')
|
||||
tm.assert_index_equal(idx.shift(0), idx)
|
||||
exp = pd.PeriodIndex(['2011-01-01 13:00', '2011-01-01 14:00'
|
||||
'2011-01-01 15:00'], name='xxx', freq='H')
|
||||
tm.assert_index_equal(idx.shift(3), exp)
|
||||
exp = pd.PeriodIndex(['2011-01-01 07:00', '2011-01-01 08:00'
|
||||
'2011-01-01 09:00'], name='xxx', freq='H')
|
||||
tm.assert_index_equal(idx.shift(-3), exp)
|
||||
|
||||
def test_shift_nat(self):
|
||||
idx = PeriodIndex(['2011-01', '2011-02', 'NaT', '2011-04'],
|
||||
freq='M', name='idx')
|
||||
result = idx.shift(1)
|
||||
expected = PeriodIndex(['2011-02', '2011-03', 'NaT', '2011-05'],
|
||||
freq='M', name='idx')
|
||||
tm.assert_index_equal(result, expected)
|
||||
assert result.name == expected.name
|
||||
|
||||
def test_shift_gh8083(self):
|
||||
# test shift for PeriodIndex
|
||||
# GH#8083
|
||||
drange = pd.period_range('20130101', periods=5, freq='D')
|
||||
result = drange.shift(1)
|
||||
expected = PeriodIndex(['2013-01-02', '2013-01-03', '2013-01-04',
|
||||
'2013-01-05', '2013-01-06'], freq='D')
|
||||
tm.assert_index_equal(result, expected)
|
||||
|
||||
|
||||
class TestPeriodIndexSeriesMethods(object):
|
||||
""" Test PeriodIndex and Period Series Ops consistency """
|
||||
|
||||
def _check(self, values, func, expected):
|
||||
idx = pd.PeriodIndex(values)
|
||||
result = func(idx)
|
||||
if isinstance(expected, pd.Index):
|
||||
tm.assert_index_equal(result, expected)
|
||||
else:
|
||||
# comp op results in bool
|
||||
tm.assert_numpy_array_equal(result, expected)
|
||||
|
||||
ser = pd.Series(values)
|
||||
result = func(ser)
|
||||
|
||||
exp = pd.Series(expected, name=values.name)
|
||||
tm.assert_series_equal(result, exp)
|
||||
|
||||
def test_pi_ops(self):
|
||||
idx = PeriodIndex(['2011-01', '2011-02', '2011-03', '2011-04'],
|
||||
freq='M', name='idx')
|
||||
|
||||
expected = PeriodIndex(['2011-03', '2011-04', '2011-05', '2011-06'],
|
||||
freq='M', name='idx')
|
||||
self._check(idx, lambda x: x + 2, expected)
|
||||
self._check(idx, lambda x: 2 + x, expected)
|
||||
|
||||
self._check(idx + 2, lambda x: x - 2, idx)
|
||||
result = idx - Period('2011-01', freq='M')
|
||||
exp = pd.Index([0, 1, 2, 3], name='idx')
|
||||
tm.assert_index_equal(result, exp)
|
||||
|
||||
result = Period('2011-01', freq='M') - idx
|
||||
exp = pd.Index([0, -1, -2, -3], name='idx')
|
||||
tm.assert_index_equal(result, exp)
|
||||
|
||||
@pytest.mark.parametrize('ng', ["str", 1.5])
|
||||
def test_pi_ops_errors(self, ng):
|
||||
idx = PeriodIndex(['2011-01', '2011-02', '2011-03', '2011-04'],
|
||||
freq='M', name='idx')
|
||||
ser = pd.Series(idx)
|
||||
|
||||
msg = r"unsupported operand type\(s\)"
|
||||
|
||||
for obj in [idx, ser]:
|
||||
with tm.assert_raises_regex(TypeError, msg):
|
||||
obj + ng
|
||||
|
||||
with pytest.raises(TypeError):
|
||||
# error message differs between PY2 and 3
|
||||
ng + obj
|
||||
|
||||
with tm.assert_raises_regex(TypeError, msg):
|
||||
obj - ng
|
||||
|
||||
with pytest.raises(TypeError):
|
||||
np.add(obj, ng)
|
||||
|
||||
if _np_version_under1p10:
|
||||
assert np.add(ng, obj) is NotImplemented
|
||||
else:
|
||||
with pytest.raises(TypeError):
|
||||
np.add(ng, obj)
|
||||
|
||||
with pytest.raises(TypeError):
|
||||
np.subtract(obj, ng)
|
||||
|
||||
if _np_version_under1p10:
|
||||
assert np.subtract(ng, obj) is NotImplemented
|
||||
else:
|
||||
with pytest.raises(TypeError):
|
||||
np.subtract(ng, obj)
|
||||
|
||||
def test_pi_ops_nat(self):
|
||||
idx = PeriodIndex(['2011-01', '2011-02', 'NaT', '2011-04'],
|
||||
freq='M', name='idx')
|
||||
expected = PeriodIndex(['2011-03', '2011-04', 'NaT', '2011-06'],
|
||||
freq='M', name='idx')
|
||||
self._check(idx, lambda x: x + 2, expected)
|
||||
self._check(idx, lambda x: 2 + x, expected)
|
||||
self._check(idx, lambda x: np.add(x, 2), expected)
|
||||
|
||||
self._check(idx + 2, lambda x: x - 2, idx)
|
||||
self._check(idx + 2, lambda x: np.subtract(x, 2), idx)
|
||||
|
||||
# freq with mult
|
||||
idx = PeriodIndex(['2011-01', '2011-02', 'NaT', '2011-04'],
|
||||
freq='2M', name='idx')
|
||||
expected = PeriodIndex(['2011-07', '2011-08', 'NaT', '2011-10'],
|
||||
freq='2M', name='idx')
|
||||
self._check(idx, lambda x: x + 3, expected)
|
||||
self._check(idx, lambda x: 3 + x, expected)
|
||||
self._check(idx, lambda x: np.add(x, 3), expected)
|
||||
|
||||
self._check(idx + 3, lambda x: x - 3, idx)
|
||||
self._check(idx + 3, lambda x: np.subtract(x, 3), idx)
|
||||
|
||||
def test_pi_ops_array_int(self):
|
||||
idx = PeriodIndex(['2011-01', '2011-02', 'NaT', '2011-04'],
|
||||
freq='M', name='idx')
|
||||
f = lambda x: x + np.array([1, 2, 3, 4])
|
||||
exp = PeriodIndex(['2011-02', '2011-04', 'NaT', '2011-08'],
|
||||
freq='M', name='idx')
|
||||
self._check(idx, f, exp)
|
||||
|
||||
f = lambda x: np.add(x, np.array([4, -1, 1, 2]))
|
||||
exp = PeriodIndex(['2011-05', '2011-01', 'NaT', '2011-06'],
|
||||
freq='M', name='idx')
|
||||
self._check(idx, f, exp)
|
||||
|
||||
f = lambda x: x - np.array([1, 2, 3, 4])
|
||||
exp = PeriodIndex(['2010-12', '2010-12', 'NaT', '2010-12'],
|
||||
freq='M', name='idx')
|
||||
self._check(idx, f, exp)
|
||||
|
||||
f = lambda x: np.subtract(x, np.array([3, 2, 3, -2]))
|
||||
exp = PeriodIndex(['2010-10', '2010-12', 'NaT', '2011-06'],
|
||||
freq='M', name='idx')
|
||||
self._check(idx, f, exp)
|
||||
|
||||
def test_pi_ops_offset(self):
|
||||
idx = PeriodIndex(['2011-01-01', '2011-02-01', '2011-03-01',
|
||||
'2011-04-01'], freq='D', name='idx')
|
||||
f = lambda x: x + pd.offsets.Day()
|
||||
exp = PeriodIndex(['2011-01-02', '2011-02-02', '2011-03-02',
|
||||
'2011-04-02'], freq='D', name='idx')
|
||||
self._check(idx, f, exp)
|
||||
|
||||
f = lambda x: x + pd.offsets.Day(2)
|
||||
exp = PeriodIndex(['2011-01-03', '2011-02-03', '2011-03-03',
|
||||
'2011-04-03'], freq='D', name='idx')
|
||||
self._check(idx, f, exp)
|
||||
|
||||
f = lambda x: x - pd.offsets.Day(2)
|
||||
exp = PeriodIndex(['2010-12-30', '2011-01-30', '2011-02-27',
|
||||
'2011-03-30'], freq='D', name='idx')
|
||||
self._check(idx, f, exp)
|
||||
|
||||
def test_pi_offset_errors(self):
|
||||
idx = PeriodIndex(['2011-01-01', '2011-02-01', '2011-03-01',
|
||||
'2011-04-01'], freq='D', name='idx')
|
||||
ser = pd.Series(idx)
|
||||
|
||||
# Series op is applied per Period instance, thus error is raised
|
||||
# from Period
|
||||
msg_idx = r"Input has different freq from PeriodIndex\(freq=D\)"
|
||||
msg_s = r"Input cannot be converted to Period\(freq=D\)"
|
||||
for obj, msg in [(idx, msg_idx), (ser, msg_s)]:
|
||||
with tm.assert_raises_regex(period.IncompatibleFrequency, msg):
|
||||
obj + pd.offsets.Hour(2)
|
||||
|
||||
with tm.assert_raises_regex(period.IncompatibleFrequency, msg):
|
||||
pd.offsets.Hour(2) + obj
|
||||
|
||||
with tm.assert_raises_regex(period.IncompatibleFrequency, msg):
|
||||
obj - pd.offsets.Hour(2)
|
||||
|
||||
def test_pi_sub_period(self):
|
||||
# GH 13071
|
||||
idx = PeriodIndex(['2011-01', '2011-02', '2011-03', '2011-04'],
|
||||
freq='M', name='idx')
|
||||
|
||||
result = idx - pd.Period('2012-01', freq='M')
|
||||
exp = pd.Index([-12, -11, -10, -9], name='idx')
|
||||
tm.assert_index_equal(result, exp)
|
||||
|
||||
result = np.subtract(idx, pd.Period('2012-01', freq='M'))
|
||||
tm.assert_index_equal(result, exp)
|
||||
|
||||
result = pd.Period('2012-01', freq='M') - idx
|
||||
exp = pd.Index([12, 11, 10, 9], name='idx')
|
||||
tm.assert_index_equal(result, exp)
|
||||
|
||||
result = np.subtract(pd.Period('2012-01', freq='M'), idx)
|
||||
if _np_version_under1p10:
|
||||
assert result is NotImplemented
|
||||
else:
|
||||
tm.assert_index_equal(result, exp)
|
||||
|
||||
exp = pd.TimedeltaIndex([np.nan, np.nan, np.nan, np.nan], name='idx')
|
||||
tm.assert_index_equal(idx - pd.Period('NaT', freq='M'), exp)
|
||||
tm.assert_index_equal(pd.Period('NaT', freq='M') - idx, exp)
|
||||
|
||||
def test_pi_sub_pdnat(self):
|
||||
# GH 13071
|
||||
idx = PeriodIndex(['2011-01', '2011-02', 'NaT', '2011-04'],
|
||||
freq='M', name='idx')
|
||||
exp = pd.TimedeltaIndex([pd.NaT] * 4, name='idx')
|
||||
tm.assert_index_equal(pd.NaT - idx, exp)
|
||||
tm.assert_index_equal(idx - pd.NaT, exp)
|
||||
|
||||
def test_pi_sub_period_nat(self):
|
||||
# GH 13071
|
||||
idx = PeriodIndex(['2011-01', 'NaT', '2011-03', '2011-04'],
|
||||
freq='M', name='idx')
|
||||
|
||||
result = idx - pd.Period('2012-01', freq='M')
|
||||
exp = pd.Index([-12, np.nan, -10, -9], name='idx')
|
||||
tm.assert_index_equal(result, exp)
|
||||
|
||||
result = pd.Period('2012-01', freq='M') - idx
|
||||
exp = pd.Index([12, np.nan, 10, 9], name='idx')
|
||||
tm.assert_index_equal(result, exp)
|
||||
|
||||
exp = pd.TimedeltaIndex([np.nan, np.nan, np.nan, np.nan], name='idx')
|
||||
tm.assert_index_equal(idx - pd.Period('NaT', freq='M'), exp)
|
||||
tm.assert_index_equal(pd.Period('NaT', freq='M') - idx, exp)
|
||||
@@ -1,152 +0,0 @@
|
||||
import pytest
|
||||
|
||||
import numpy as np
|
||||
import pandas as pd
|
||||
from pandas.util import testing as tm
|
||||
from pandas import PeriodIndex, Series, DataFrame
|
||||
|
||||
|
||||
class TestPeriodIndex(object):
|
||||
|
||||
def test_asfreq(self):
|
||||
pi1 = PeriodIndex(freq='A', start='1/1/2001', end='1/1/2001')
|
||||
pi2 = PeriodIndex(freq='Q', start='1/1/2001', end='1/1/2001')
|
||||
pi3 = PeriodIndex(freq='M', start='1/1/2001', end='1/1/2001')
|
||||
pi4 = PeriodIndex(freq='D', start='1/1/2001', end='1/1/2001')
|
||||
pi5 = PeriodIndex(freq='H', start='1/1/2001', end='1/1/2001 00:00')
|
||||
pi6 = PeriodIndex(freq='Min', start='1/1/2001', end='1/1/2001 00:00')
|
||||
pi7 = PeriodIndex(freq='S', start='1/1/2001', end='1/1/2001 00:00:00')
|
||||
|
||||
assert pi1.asfreq('Q', 'S') == pi2
|
||||
assert pi1.asfreq('Q', 's') == pi2
|
||||
assert pi1.asfreq('M', 'start') == pi3
|
||||
assert pi1.asfreq('D', 'StarT') == pi4
|
||||
assert pi1.asfreq('H', 'beGIN') == pi5
|
||||
assert pi1.asfreq('Min', 'S') == pi6
|
||||
assert pi1.asfreq('S', 'S') == pi7
|
||||
|
||||
assert pi2.asfreq('A', 'S') == pi1
|
||||
assert pi2.asfreq('M', 'S') == pi3
|
||||
assert pi2.asfreq('D', 'S') == pi4
|
||||
assert pi2.asfreq('H', 'S') == pi5
|
||||
assert pi2.asfreq('Min', 'S') == pi6
|
||||
assert pi2.asfreq('S', 'S') == pi7
|
||||
|
||||
assert pi3.asfreq('A', 'S') == pi1
|
||||
assert pi3.asfreq('Q', 'S') == pi2
|
||||
assert pi3.asfreq('D', 'S') == pi4
|
||||
assert pi3.asfreq('H', 'S') == pi5
|
||||
assert pi3.asfreq('Min', 'S') == pi6
|
||||
assert pi3.asfreq('S', 'S') == pi7
|
||||
|
||||
assert pi4.asfreq('A', 'S') == pi1
|
||||
assert pi4.asfreq('Q', 'S') == pi2
|
||||
assert pi4.asfreq('M', 'S') == pi3
|
||||
assert pi4.asfreq('H', 'S') == pi5
|
||||
assert pi4.asfreq('Min', 'S') == pi6
|
||||
assert pi4.asfreq('S', 'S') == pi7
|
||||
|
||||
assert pi5.asfreq('A', 'S') == pi1
|
||||
assert pi5.asfreq('Q', 'S') == pi2
|
||||
assert pi5.asfreq('M', 'S') == pi3
|
||||
assert pi5.asfreq('D', 'S') == pi4
|
||||
assert pi5.asfreq('Min', 'S') == pi6
|
||||
assert pi5.asfreq('S', 'S') == pi7
|
||||
|
||||
assert pi6.asfreq('A', 'S') == pi1
|
||||
assert pi6.asfreq('Q', 'S') == pi2
|
||||
assert pi6.asfreq('M', 'S') == pi3
|
||||
assert pi6.asfreq('D', 'S') == pi4
|
||||
assert pi6.asfreq('H', 'S') == pi5
|
||||
assert pi6.asfreq('S', 'S') == pi7
|
||||
|
||||
assert pi7.asfreq('A', 'S') == pi1
|
||||
assert pi7.asfreq('Q', 'S') == pi2
|
||||
assert pi7.asfreq('M', 'S') == pi3
|
||||
assert pi7.asfreq('D', 'S') == pi4
|
||||
assert pi7.asfreq('H', 'S') == pi5
|
||||
assert pi7.asfreq('Min', 'S') == pi6
|
||||
|
||||
pytest.raises(ValueError, pi7.asfreq, 'T', 'foo')
|
||||
result1 = pi1.asfreq('3M')
|
||||
result2 = pi1.asfreq('M')
|
||||
expected = PeriodIndex(freq='M', start='2001-12', end='2001-12')
|
||||
tm.assert_numpy_array_equal(result1.asi8, expected.asi8)
|
||||
assert result1.freqstr == '3M'
|
||||
tm.assert_numpy_array_equal(result2.asi8, expected.asi8)
|
||||
assert result2.freqstr == 'M'
|
||||
|
||||
def test_asfreq_nat(self):
|
||||
idx = PeriodIndex(['2011-01', '2011-02', 'NaT', '2011-04'], freq='M')
|
||||
result = idx.asfreq(freq='Q')
|
||||
expected = PeriodIndex(['2011Q1', '2011Q1', 'NaT', '2011Q2'], freq='Q')
|
||||
tm.assert_index_equal(result, expected)
|
||||
|
||||
@pytest.mark.parametrize('freq', ['D', '3D'])
|
||||
def test_asfreq_mult_pi(self, freq):
|
||||
pi = PeriodIndex(['2001-01', '2001-02', 'NaT', '2001-03'], freq='2M')
|
||||
|
||||
result = pi.asfreq(freq)
|
||||
exp = PeriodIndex(['2001-02-28', '2001-03-31', 'NaT',
|
||||
'2001-04-30'], freq=freq)
|
||||
tm.assert_index_equal(result, exp)
|
||||
assert result.freq == exp.freq
|
||||
|
||||
result = pi.asfreq(freq, how='S')
|
||||
exp = PeriodIndex(['2001-01-01', '2001-02-01', 'NaT',
|
||||
'2001-03-01'], freq=freq)
|
||||
tm.assert_index_equal(result, exp)
|
||||
assert result.freq == exp.freq
|
||||
|
||||
def test_asfreq_combined_pi(self):
|
||||
pi = pd.PeriodIndex(['2001-01-01 00:00', '2001-01-02 02:00', 'NaT'],
|
||||
freq='H')
|
||||
exp = PeriodIndex(['2001-01-01 00:00', '2001-01-02 02:00', 'NaT'],
|
||||
freq='25H')
|
||||
for freq, how in zip(['1D1H', '1H1D'], ['S', 'E']):
|
||||
result = pi.asfreq(freq, how=how)
|
||||
tm.assert_index_equal(result, exp)
|
||||
assert result.freq == exp.freq
|
||||
|
||||
for freq in ['1D1H', '1H1D']:
|
||||
pi = pd.PeriodIndex(['2001-01-01 00:00', '2001-01-02 02:00',
|
||||
'NaT'], freq=freq)
|
||||
result = pi.asfreq('H')
|
||||
exp = PeriodIndex(['2001-01-02 00:00', '2001-01-03 02:00', 'NaT'],
|
||||
freq='H')
|
||||
tm.assert_index_equal(result, exp)
|
||||
assert result.freq == exp.freq
|
||||
|
||||
pi = pd.PeriodIndex(['2001-01-01 00:00', '2001-01-02 02:00',
|
||||
'NaT'], freq=freq)
|
||||
result = pi.asfreq('H', how='S')
|
||||
exp = PeriodIndex(['2001-01-01 00:00', '2001-01-02 02:00', 'NaT'],
|
||||
freq='H')
|
||||
tm.assert_index_equal(result, exp)
|
||||
assert result.freq == exp.freq
|
||||
|
||||
def test_asfreq_ts(self):
|
||||
index = PeriodIndex(freq='A', start='1/1/2001', end='12/31/2010')
|
||||
ts = Series(np.random.randn(len(index)), index=index)
|
||||
df = DataFrame(np.random.randn(len(index), 3), index=index)
|
||||
|
||||
result = ts.asfreq('D', how='end')
|
||||
df_result = df.asfreq('D', how='end')
|
||||
exp_index = index.asfreq('D', how='end')
|
||||
assert len(result) == len(ts)
|
||||
tm.assert_index_equal(result.index, exp_index)
|
||||
tm.assert_index_equal(df_result.index, exp_index)
|
||||
|
||||
result = ts.asfreq('D', how='start')
|
||||
assert len(result) == len(ts)
|
||||
tm.assert_index_equal(result.index, index.asfreq('D', how='start'))
|
||||
|
||||
def test_astype_asfreq(self):
|
||||
pi1 = PeriodIndex(['2011-01-01', '2011-02-01', '2011-03-01'], freq='D')
|
||||
exp = PeriodIndex(['2011-01', '2011-02', '2011-03'], freq='M')
|
||||
tm.assert_index_equal(pi1.asfreq('M'), exp)
|
||||
tm.assert_index_equal(pi1.astype('period[M]'), exp)
|
||||
|
||||
exp = PeriodIndex(['2011-01', '2011-02', '2011-03'], freq='3M')
|
||||
tm.assert_index_equal(pi1.asfreq('3M'), exp)
|
||||
tm.assert_index_equal(pi1.astype('period[3M]'), exp)
|
||||
@@ -1,99 +0,0 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
import numpy as np
|
||||
import pytest
|
||||
|
||||
import pandas as pd
|
||||
import pandas.util.testing as tm
|
||||
from pandas import NaT, Period, PeriodIndex, Int64Index, Index, period_range
|
||||
|
||||
|
||||
class TestPeriodIndexAsType(object):
|
||||
@pytest.mark.parametrize('dtype', [
|
||||
float, 'timedelta64', 'timedelta64[ns]'])
|
||||
def test_astype_raises(self, dtype):
|
||||
# GH#13149, GH#13209
|
||||
idx = PeriodIndex(['2016-05-16', 'NaT', NaT, np.NaN], freq='D')
|
||||
msg = 'Cannot cast PeriodIndex to dtype'
|
||||
with tm.assert_raises_regex(TypeError, msg):
|
||||
idx.astype(dtype)
|
||||
|
||||
def test_astype_conversion(self):
|
||||
# GH#13149, GH#13209
|
||||
idx = PeriodIndex(['2016-05-16', 'NaT', NaT, np.NaN], freq='D')
|
||||
|
||||
result = idx.astype(object)
|
||||
expected = Index([Period('2016-05-16', freq='D')] +
|
||||
[Period(NaT, freq='D')] * 3, dtype='object')
|
||||
tm.assert_index_equal(result, expected)
|
||||
|
||||
result = idx.astype(int)
|
||||
expected = Int64Index([16937] + [-9223372036854775808] * 3,
|
||||
dtype=np.int64)
|
||||
tm.assert_index_equal(result, expected)
|
||||
|
||||
result = idx.astype(str)
|
||||
expected = Index(str(x) for x in idx)
|
||||
tm.assert_index_equal(result, expected)
|
||||
|
||||
idx = period_range('1990', '2009', freq='A')
|
||||
result = idx.astype('i8')
|
||||
tm.assert_index_equal(result, Index(idx.asi8))
|
||||
tm.assert_numpy_array_equal(result.values, idx.asi8)
|
||||
|
||||
def test_astype_object(self):
|
||||
idx = pd.PeriodIndex([], freq='M')
|
||||
|
||||
exp = np.array([], dtype=object)
|
||||
tm.assert_numpy_array_equal(idx.astype(object).values, exp)
|
||||
tm.assert_numpy_array_equal(idx._mpl_repr(), exp)
|
||||
|
||||
idx = pd.PeriodIndex(['2011-01', pd.NaT], freq='M')
|
||||
|
||||
exp = np.array([pd.Period('2011-01', freq='M'), pd.NaT], dtype=object)
|
||||
tm.assert_numpy_array_equal(idx.astype(object).values, exp)
|
||||
tm.assert_numpy_array_equal(idx._mpl_repr(), exp)
|
||||
|
||||
exp = np.array([pd.Period('2011-01-01', freq='D'), pd.NaT],
|
||||
dtype=object)
|
||||
idx = pd.PeriodIndex(['2011-01-01', pd.NaT], freq='D')
|
||||
tm.assert_numpy_array_equal(idx.astype(object).values, exp)
|
||||
tm.assert_numpy_array_equal(idx._mpl_repr(), exp)
|
||||
|
||||
# TODO: de-duplicate this version (from test_ops) with the one above
|
||||
# (from test_period)
|
||||
def test_astype_object2(self):
|
||||
idx = pd.period_range(start='2013-01-01', periods=4, freq='M',
|
||||
name='idx')
|
||||
expected_list = [pd.Period('2013-01-31', freq='M'),
|
||||
pd.Period('2013-02-28', freq='M'),
|
||||
pd.Period('2013-03-31', freq='M'),
|
||||
pd.Period('2013-04-30', freq='M')]
|
||||
expected = pd.Index(expected_list, dtype=object, name='idx')
|
||||
result = idx.astype(object)
|
||||
assert isinstance(result, Index)
|
||||
assert result.dtype == object
|
||||
tm.assert_index_equal(result, expected)
|
||||
assert result.name == expected.name
|
||||
assert idx.tolist() == expected_list
|
||||
|
||||
idx = PeriodIndex(['2013-01-01', '2013-01-02', 'NaT',
|
||||
'2013-01-04'], freq='D', name='idx')
|
||||
expected_list = [pd.Period('2013-01-01', freq='D'),
|
||||
pd.Period('2013-01-02', freq='D'),
|
||||
pd.Period('NaT', freq='D'),
|
||||
pd.Period('2013-01-04', freq='D')]
|
||||
expected = pd.Index(expected_list, dtype=object, name='idx')
|
||||
result = idx.astype(object)
|
||||
assert isinstance(result, Index)
|
||||
assert result.dtype == object
|
||||
tm.assert_index_equal(result, expected)
|
||||
for i in [0, 1, 3]:
|
||||
assert result[i] == expected[i]
|
||||
assert result[2] is pd.NaT
|
||||
assert result.name == expected.name
|
||||
|
||||
result_list = idx.tolist()
|
||||
for i in [0, 1, 3]:
|
||||
assert result_list[i] == expected_list[i]
|
||||
assert result_list[2] is pd.NaT
|
||||
-489
@@ -1,489 +0,0 @@
|
||||
import pytest
|
||||
|
||||
import numpy as np
|
||||
import pandas as pd
|
||||
import pandas.util.testing as tm
|
||||
import pandas.core.indexes.period as period
|
||||
from pandas.compat import lrange, PY3, text_type, lmap
|
||||
from pandas import (Period, PeriodIndex, period_range, offsets, date_range,
|
||||
Series, Index)
|
||||
|
||||
|
||||
class TestPeriodIndex(object):
|
||||
|
||||
def setup_method(self, method):
|
||||
pass
|
||||
|
||||
def test_construction_base_constructor(self):
|
||||
# GH 13664
|
||||
arr = [pd.Period('2011-01', freq='M'), pd.NaT,
|
||||
pd.Period('2011-03', freq='M')]
|
||||
tm.assert_index_equal(pd.Index(arr), pd.PeriodIndex(arr))
|
||||
tm.assert_index_equal(pd.Index(np.array(arr)),
|
||||
pd.PeriodIndex(np.array(arr)))
|
||||
|
||||
arr = [np.nan, pd.NaT, pd.Period('2011-03', freq='M')]
|
||||
tm.assert_index_equal(pd.Index(arr), pd.PeriodIndex(arr))
|
||||
tm.assert_index_equal(pd.Index(np.array(arr)),
|
||||
pd.PeriodIndex(np.array(arr)))
|
||||
|
||||
arr = [pd.Period('2011-01', freq='M'), pd.NaT,
|
||||
pd.Period('2011-03', freq='D')]
|
||||
tm.assert_index_equal(pd.Index(arr), pd.Index(arr, dtype=object))
|
||||
|
||||
tm.assert_index_equal(pd.Index(np.array(arr)),
|
||||
pd.Index(np.array(arr), dtype=object))
|
||||
|
||||
def test_constructor_use_start_freq(self):
|
||||
# GH #1118
|
||||
p = Period('4/2/2012', freq='B')
|
||||
index = PeriodIndex(start=p, periods=10)
|
||||
expected = PeriodIndex(start='4/2/2012', periods=10, freq='B')
|
||||
tm.assert_index_equal(index, expected)
|
||||
|
||||
def test_constructor_field_arrays(self):
|
||||
# GH #1264
|
||||
|
||||
years = np.arange(1990, 2010).repeat(4)[2:-2]
|
||||
quarters = np.tile(np.arange(1, 5), 20)[2:-2]
|
||||
|
||||
index = PeriodIndex(year=years, quarter=quarters, freq='Q-DEC')
|
||||
expected = period_range('1990Q3', '2009Q2', freq='Q-DEC')
|
||||
tm.assert_index_equal(index, expected)
|
||||
|
||||
index2 = PeriodIndex(year=years, quarter=quarters, freq='2Q-DEC')
|
||||
tm.assert_numpy_array_equal(index.asi8, index2.asi8)
|
||||
|
||||
index = PeriodIndex(year=years, quarter=quarters)
|
||||
tm.assert_index_equal(index, expected)
|
||||
|
||||
years = [2007, 2007, 2007]
|
||||
months = [1, 2]
|
||||
pytest.raises(ValueError, PeriodIndex, year=years, month=months,
|
||||
freq='M')
|
||||
pytest.raises(ValueError, PeriodIndex, year=years, month=months,
|
||||
freq='2M')
|
||||
pytest.raises(ValueError, PeriodIndex, year=years, month=months,
|
||||
freq='M', start=Period('2007-01', freq='M'))
|
||||
|
||||
years = [2007, 2007, 2007]
|
||||
months = [1, 2, 3]
|
||||
idx = PeriodIndex(year=years, month=months, freq='M')
|
||||
exp = period_range('2007-01', periods=3, freq='M')
|
||||
tm.assert_index_equal(idx, exp)
|
||||
|
||||
def test_constructor_U(self):
|
||||
# U was used as undefined period
|
||||
pytest.raises(ValueError, period_range, '2007-1-1', periods=500,
|
||||
freq='X')
|
||||
|
||||
def test_constructor_nano(self):
|
||||
idx = period_range(start=Period(ordinal=1, freq='N'),
|
||||
end=Period(ordinal=4, freq='N'), freq='N')
|
||||
exp = PeriodIndex([Period(ordinal=1, freq='N'),
|
||||
Period(ordinal=2, freq='N'),
|
||||
Period(ordinal=3, freq='N'),
|
||||
Period(ordinal=4, freq='N')], freq='N')
|
||||
tm.assert_index_equal(idx, exp)
|
||||
|
||||
def test_constructor_arrays_negative_year(self):
|
||||
years = np.arange(1960, 2000, dtype=np.int64).repeat(4)
|
||||
quarters = np.tile(np.array([1, 2, 3, 4], dtype=np.int64), 40)
|
||||
|
||||
pindex = PeriodIndex(year=years, quarter=quarters)
|
||||
|
||||
tm.assert_index_equal(pindex.year, pd.Index(years))
|
||||
tm.assert_index_equal(pindex.quarter, pd.Index(quarters))
|
||||
|
||||
def test_constructor_invalid_quarters(self):
|
||||
pytest.raises(ValueError, PeriodIndex, year=lrange(2000, 2004),
|
||||
quarter=lrange(4), freq='Q-DEC')
|
||||
|
||||
def test_constructor_corner(self):
|
||||
pytest.raises(ValueError, PeriodIndex, periods=10, freq='A')
|
||||
|
||||
start = Period('2007', freq='A-JUN')
|
||||
end = Period('2010', freq='A-DEC')
|
||||
pytest.raises(ValueError, PeriodIndex, start=start, end=end)
|
||||
pytest.raises(ValueError, PeriodIndex, start=start)
|
||||
pytest.raises(ValueError, PeriodIndex, end=end)
|
||||
|
||||
result = period_range('2007-01', periods=10.5, freq='M')
|
||||
exp = period_range('2007-01', periods=10, freq='M')
|
||||
tm.assert_index_equal(result, exp)
|
||||
|
||||
def test_constructor_fromarraylike(self):
|
||||
idx = period_range('2007-01', periods=20, freq='M')
|
||||
|
||||
# values is an array of Period, thus can retrieve freq
|
||||
tm.assert_index_equal(PeriodIndex(idx.values), idx)
|
||||
tm.assert_index_equal(PeriodIndex(list(idx.values)), idx)
|
||||
|
||||
pytest.raises(ValueError, PeriodIndex, idx._ndarray_values)
|
||||
pytest.raises(ValueError, PeriodIndex, list(idx._ndarray_values))
|
||||
pytest.raises(TypeError, PeriodIndex,
|
||||
data=Period('2007', freq='A'))
|
||||
|
||||
result = PeriodIndex(iter(idx))
|
||||
tm.assert_index_equal(result, idx)
|
||||
|
||||
result = PeriodIndex(idx)
|
||||
tm.assert_index_equal(result, idx)
|
||||
|
||||
result = PeriodIndex(idx, freq='M')
|
||||
tm.assert_index_equal(result, idx)
|
||||
|
||||
result = PeriodIndex(idx, freq=offsets.MonthEnd())
|
||||
tm.assert_index_equal(result, idx)
|
||||
assert result.freq == 'M'
|
||||
|
||||
result = PeriodIndex(idx, freq='2M')
|
||||
tm.assert_index_equal(result, idx.asfreq('2M'))
|
||||
assert result.freq == '2M'
|
||||
|
||||
result = PeriodIndex(idx, freq=offsets.MonthEnd(2))
|
||||
tm.assert_index_equal(result, idx.asfreq('2M'))
|
||||
assert result.freq == '2M'
|
||||
|
||||
result = PeriodIndex(idx, freq='D')
|
||||
exp = idx.asfreq('D', 'e')
|
||||
tm.assert_index_equal(result, exp)
|
||||
|
||||
def test_constructor_datetime64arr(self):
|
||||
vals = np.arange(100000, 100000 + 10000, 100, dtype=np.int64)
|
||||
vals = vals.view(np.dtype('M8[us]'))
|
||||
|
||||
pytest.raises(ValueError, PeriodIndex, vals, freq='D')
|
||||
|
||||
def test_constructor_dtype(self):
|
||||
# passing a dtype with a tz should localize
|
||||
idx = PeriodIndex(['2013-01', '2013-03'], dtype='period[M]')
|
||||
exp = PeriodIndex(['2013-01', '2013-03'], freq='M')
|
||||
tm.assert_index_equal(idx, exp)
|
||||
assert idx.dtype == 'period[M]'
|
||||
|
||||
idx = PeriodIndex(['2013-01-05', '2013-03-05'], dtype='period[3D]')
|
||||
exp = PeriodIndex(['2013-01-05', '2013-03-05'], freq='3D')
|
||||
tm.assert_index_equal(idx, exp)
|
||||
assert idx.dtype == 'period[3D]'
|
||||
|
||||
# if we already have a freq and its not the same, then asfreq
|
||||
# (not changed)
|
||||
idx = PeriodIndex(['2013-01-01', '2013-01-02'], freq='D')
|
||||
|
||||
res = PeriodIndex(idx, dtype='period[M]')
|
||||
exp = PeriodIndex(['2013-01', '2013-01'], freq='M')
|
||||
tm.assert_index_equal(res, exp)
|
||||
assert res.dtype == 'period[M]'
|
||||
|
||||
res = PeriodIndex(idx, freq='M')
|
||||
tm.assert_index_equal(res, exp)
|
||||
assert res.dtype == 'period[M]'
|
||||
|
||||
msg = 'specified freq and dtype are different'
|
||||
with tm.assert_raises_regex(period.IncompatibleFrequency, msg):
|
||||
PeriodIndex(['2011-01'], freq='M', dtype='period[D]')
|
||||
|
||||
def test_constructor_empty(self):
|
||||
idx = pd.PeriodIndex([], freq='M')
|
||||
assert isinstance(idx, PeriodIndex)
|
||||
assert len(idx) == 0
|
||||
assert idx.freq == 'M'
|
||||
|
||||
with tm.assert_raises_regex(ValueError, 'freq not specified'):
|
||||
pd.PeriodIndex([])
|
||||
|
||||
def test_constructor_pi_nat(self):
|
||||
idx = PeriodIndex([Period('2011-01', freq='M'), pd.NaT,
|
||||
Period('2011-01', freq='M')])
|
||||
exp = PeriodIndex(['2011-01', 'NaT', '2011-01'], freq='M')
|
||||
tm.assert_index_equal(idx, exp)
|
||||
|
||||
idx = PeriodIndex(np.array([Period('2011-01', freq='M'), pd.NaT,
|
||||
Period('2011-01', freq='M')]))
|
||||
tm.assert_index_equal(idx, exp)
|
||||
|
||||
idx = PeriodIndex([pd.NaT, pd.NaT, Period('2011-01', freq='M'),
|
||||
Period('2011-01', freq='M')])
|
||||
exp = PeriodIndex(['NaT', 'NaT', '2011-01', '2011-01'], freq='M')
|
||||
tm.assert_index_equal(idx, exp)
|
||||
|
||||
idx = PeriodIndex(np.array([pd.NaT, pd.NaT,
|
||||
Period('2011-01', freq='M'),
|
||||
Period('2011-01', freq='M')]))
|
||||
tm.assert_index_equal(idx, exp)
|
||||
|
||||
idx = PeriodIndex([pd.NaT, pd.NaT, '2011-01', '2011-01'], freq='M')
|
||||
tm.assert_index_equal(idx, exp)
|
||||
|
||||
with tm.assert_raises_regex(ValueError, 'freq not specified'):
|
||||
PeriodIndex([pd.NaT, pd.NaT])
|
||||
|
||||
with tm.assert_raises_regex(ValueError, 'freq not specified'):
|
||||
PeriodIndex(np.array([pd.NaT, pd.NaT]))
|
||||
|
||||
with tm.assert_raises_regex(ValueError, 'freq not specified'):
|
||||
PeriodIndex(['NaT', 'NaT'])
|
||||
|
||||
with tm.assert_raises_regex(ValueError, 'freq not specified'):
|
||||
PeriodIndex(np.array(['NaT', 'NaT']))
|
||||
|
||||
def test_constructor_incompat_freq(self):
|
||||
msg = "Input has different freq=D from PeriodIndex\\(freq=M\\)"
|
||||
|
||||
with tm.assert_raises_regex(period.IncompatibleFrequency, msg):
|
||||
PeriodIndex([Period('2011-01', freq='M'), pd.NaT,
|
||||
Period('2011-01', freq='D')])
|
||||
|
||||
with tm.assert_raises_regex(period.IncompatibleFrequency, msg):
|
||||
PeriodIndex(np.array([Period('2011-01', freq='M'), pd.NaT,
|
||||
Period('2011-01', freq='D')]))
|
||||
|
||||
# first element is pd.NaT
|
||||
with tm.assert_raises_regex(period.IncompatibleFrequency, msg):
|
||||
PeriodIndex([pd.NaT, Period('2011-01', freq='M'),
|
||||
Period('2011-01', freq='D')])
|
||||
|
||||
with tm.assert_raises_regex(period.IncompatibleFrequency, msg):
|
||||
PeriodIndex(np.array([pd.NaT, Period('2011-01', freq='M'),
|
||||
Period('2011-01', freq='D')]))
|
||||
|
||||
def test_constructor_mixed(self):
|
||||
idx = PeriodIndex(['2011-01', pd.NaT, Period('2011-01', freq='M')])
|
||||
exp = PeriodIndex(['2011-01', 'NaT', '2011-01'], freq='M')
|
||||
tm.assert_index_equal(idx, exp)
|
||||
|
||||
idx = PeriodIndex(['NaT', pd.NaT, Period('2011-01', freq='M')])
|
||||
exp = PeriodIndex(['NaT', 'NaT', '2011-01'], freq='M')
|
||||
tm.assert_index_equal(idx, exp)
|
||||
|
||||
idx = PeriodIndex([Period('2011-01-01', freq='D'), pd.NaT,
|
||||
'2012-01-01'])
|
||||
exp = PeriodIndex(['2011-01-01', 'NaT', '2012-01-01'], freq='D')
|
||||
tm.assert_index_equal(idx, exp)
|
||||
|
||||
def test_constructor_simple_new(self):
|
||||
idx = period_range('2007-01', name='p', periods=2, freq='M')
|
||||
result = idx._simple_new(idx, 'p', freq=idx.freq)
|
||||
tm.assert_index_equal(result, idx)
|
||||
|
||||
result = idx._simple_new(idx.astype('i8'), 'p', freq=idx.freq)
|
||||
tm.assert_index_equal(result, idx)
|
||||
|
||||
result = idx._simple_new([pd.Period('2007-01', freq='M'),
|
||||
pd.Period('2007-02', freq='M')],
|
||||
'p', freq=idx.freq)
|
||||
tm.assert_index_equal(result, idx)
|
||||
|
||||
result = idx._simple_new(np.array([pd.Period('2007-01', freq='M'),
|
||||
pd.Period('2007-02', freq='M')]),
|
||||
'p', freq=idx.freq)
|
||||
tm.assert_index_equal(result, idx)
|
||||
|
||||
def test_constructor_simple_new_empty(self):
|
||||
# GH13079
|
||||
idx = PeriodIndex([], freq='M', name='p')
|
||||
result = idx._simple_new(idx, name='p', freq='M')
|
||||
tm.assert_index_equal(result, idx)
|
||||
|
||||
@pytest.mark.parametrize('floats', [[1.1, 2.1], np.array([1.1, 2.1])])
|
||||
def test_constructor_floats(self, floats):
|
||||
# GH#13079
|
||||
with pytest.raises(TypeError):
|
||||
pd.PeriodIndex._simple_new(floats, freq='M')
|
||||
|
||||
with pytest.raises(TypeError):
|
||||
pd.PeriodIndex(floats, freq='M')
|
||||
|
||||
def test_constructor_nat(self):
|
||||
pytest.raises(ValueError, period_range, start='NaT',
|
||||
end='2011-01-01', freq='M')
|
||||
pytest.raises(ValueError, period_range, start='2011-01-01',
|
||||
end='NaT', freq='M')
|
||||
|
||||
def test_constructor_year_and_quarter(self):
|
||||
year = pd.Series([2001, 2002, 2003])
|
||||
quarter = year - 2000
|
||||
idx = PeriodIndex(year=year, quarter=quarter)
|
||||
strs = ['%dQ%d' % t for t in zip(quarter, year)]
|
||||
lops = list(map(Period, strs))
|
||||
p = PeriodIndex(lops)
|
||||
tm.assert_index_equal(p, idx)
|
||||
|
||||
def test_constructor_freq_mult(self):
|
||||
# GH #7811
|
||||
for func in [PeriodIndex, period_range]:
|
||||
# must be the same, but for sure...
|
||||
pidx = func(start='2014-01', freq='2M', periods=4)
|
||||
expected = PeriodIndex(['2014-01', '2014-03',
|
||||
'2014-05', '2014-07'], freq='2M')
|
||||
tm.assert_index_equal(pidx, expected)
|
||||
|
||||
pidx = func(start='2014-01-02', end='2014-01-15', freq='3D')
|
||||
expected = PeriodIndex(['2014-01-02', '2014-01-05',
|
||||
'2014-01-08', '2014-01-11',
|
||||
'2014-01-14'], freq='3D')
|
||||
tm.assert_index_equal(pidx, expected)
|
||||
|
||||
pidx = func(end='2014-01-01 17:00', freq='4H', periods=3)
|
||||
expected = PeriodIndex(['2014-01-01 09:00', '2014-01-01 13:00',
|
||||
'2014-01-01 17:00'], freq='4H')
|
||||
tm.assert_index_equal(pidx, expected)
|
||||
|
||||
msg = ('Frequency must be positive, because it'
|
||||
' represents span: -1M')
|
||||
with tm.assert_raises_regex(ValueError, msg):
|
||||
PeriodIndex(['2011-01'], freq='-1M')
|
||||
|
||||
msg = ('Frequency must be positive, because it' ' represents span: 0M')
|
||||
with tm.assert_raises_regex(ValueError, msg):
|
||||
PeriodIndex(['2011-01'], freq='0M')
|
||||
|
||||
msg = ('Frequency must be positive, because it' ' represents span: 0M')
|
||||
with tm.assert_raises_regex(ValueError, msg):
|
||||
period_range('2011-01', periods=3, freq='0M')
|
||||
|
||||
@pytest.mark.parametrize('freq', ['A', 'M', 'D', 'T', 'S'])
|
||||
@pytest.mark.parametrize('mult', [1, 2, 3, 4, 5])
|
||||
def test_constructor_freq_mult_dti_compat(self, mult, freq):
|
||||
freqstr = str(mult) + freq
|
||||
pidx = PeriodIndex(start='2014-04-01', freq=freqstr, periods=10)
|
||||
expected = date_range(start='2014-04-01', freq=freqstr,
|
||||
periods=10).to_period(freqstr)
|
||||
tm.assert_index_equal(pidx, expected)
|
||||
|
||||
def test_constructor_freq_combined(self):
|
||||
for freq in ['1D1H', '1H1D']:
|
||||
pidx = PeriodIndex(['2016-01-01', '2016-01-02'], freq=freq)
|
||||
expected = PeriodIndex(['2016-01-01 00:00', '2016-01-02 00:00'],
|
||||
freq='25H')
|
||||
for freq, func in zip(['1D1H', '1H1D'], [PeriodIndex, period_range]):
|
||||
pidx = func(start='2016-01-01', periods=2, freq=freq)
|
||||
expected = PeriodIndex(['2016-01-01 00:00', '2016-01-02 01:00'],
|
||||
freq='25H')
|
||||
tm.assert_index_equal(pidx, expected)
|
||||
|
||||
def test_constructor(self):
|
||||
pi = PeriodIndex(freq='A', start='1/1/2001', end='12/1/2009')
|
||||
assert len(pi) == 9
|
||||
|
||||
pi = PeriodIndex(freq='Q', start='1/1/2001', end='12/1/2009')
|
||||
assert len(pi) == 4 * 9
|
||||
|
||||
pi = PeriodIndex(freq='M', start='1/1/2001', end='12/1/2009')
|
||||
assert len(pi) == 12 * 9
|
||||
|
||||
pi = PeriodIndex(freq='D', start='1/1/2001', end='12/31/2009')
|
||||
assert len(pi) == 365 * 9 + 2
|
||||
|
||||
pi = PeriodIndex(freq='B', start='1/1/2001', end='12/31/2009')
|
||||
assert len(pi) == 261 * 9
|
||||
|
||||
pi = PeriodIndex(freq='H', start='1/1/2001', end='12/31/2001 23:00')
|
||||
assert len(pi) == 365 * 24
|
||||
|
||||
pi = PeriodIndex(freq='Min', start='1/1/2001', end='1/1/2001 23:59')
|
||||
assert len(pi) == 24 * 60
|
||||
|
||||
pi = PeriodIndex(freq='S', start='1/1/2001', end='1/1/2001 23:59:59')
|
||||
assert len(pi) == 24 * 60 * 60
|
||||
|
||||
start = Period('02-Apr-2005', 'B')
|
||||
i1 = PeriodIndex(start=start, periods=20)
|
||||
assert len(i1) == 20
|
||||
assert i1.freq == start.freq
|
||||
assert i1[0] == start
|
||||
|
||||
end_intv = Period('2006-12-31', 'W')
|
||||
i1 = PeriodIndex(end=end_intv, periods=10)
|
||||
assert len(i1) == 10
|
||||
assert i1.freq == end_intv.freq
|
||||
assert i1[-1] == end_intv
|
||||
|
||||
end_intv = Period('2006-12-31', '1w')
|
||||
i2 = PeriodIndex(end=end_intv, periods=10)
|
||||
assert len(i1) == len(i2)
|
||||
assert (i1 == i2).all()
|
||||
assert i1.freq == i2.freq
|
||||
|
||||
end_intv = Period('2006-12-31', ('w', 1))
|
||||
i2 = PeriodIndex(end=end_intv, periods=10)
|
||||
assert len(i1) == len(i2)
|
||||
assert (i1 == i2).all()
|
||||
assert i1.freq == i2.freq
|
||||
|
||||
end_intv = Period('2005-05-01', 'B')
|
||||
i1 = PeriodIndex(start=start, end=end_intv)
|
||||
|
||||
# infer freq from first element
|
||||
i2 = PeriodIndex([end_intv, Period('2005-05-05', 'B')])
|
||||
assert len(i2) == 2
|
||||
assert i2[0] == end_intv
|
||||
|
||||
i2 = PeriodIndex(np.array([end_intv, Period('2005-05-05', 'B')]))
|
||||
assert len(i2) == 2
|
||||
assert i2[0] == end_intv
|
||||
|
||||
# Mixed freq should fail
|
||||
vals = [end_intv, Period('2006-12-31', 'w')]
|
||||
pytest.raises(ValueError, PeriodIndex, vals)
|
||||
vals = np.array(vals)
|
||||
pytest.raises(ValueError, PeriodIndex, vals)
|
||||
|
||||
def test_constructor_error(self):
|
||||
start = Period('02-Apr-2005', 'B')
|
||||
end_intv = Period('2006-12-31', ('w', 1))
|
||||
|
||||
msg = 'start and end must have same freq'
|
||||
with tm.assert_raises_regex(ValueError, msg):
|
||||
PeriodIndex(start=start, end=end_intv)
|
||||
|
||||
msg = ('Of the three parameters: start, end, and periods, '
|
||||
'exactly two must be specified')
|
||||
with tm.assert_raises_regex(ValueError, msg):
|
||||
PeriodIndex(start=start)
|
||||
|
||||
@pytest.mark.parametrize('freq', ['M', 'Q', 'A', 'D', 'B',
|
||||
'T', 'S', 'L', 'U', 'N', 'H'])
|
||||
def test_recreate_from_data(self, freq):
|
||||
org = PeriodIndex(start='2001/04/01', freq=freq, periods=1)
|
||||
idx = PeriodIndex(org.values, freq=freq)
|
||||
tm.assert_index_equal(idx, org)
|
||||
|
||||
def test_map_with_string_constructor(self):
|
||||
raw = [2005, 2007, 2009]
|
||||
index = PeriodIndex(raw, freq='A')
|
||||
types = str,
|
||||
|
||||
if PY3:
|
||||
# unicode
|
||||
types += text_type,
|
||||
|
||||
for t in types:
|
||||
expected = Index(lmap(t, raw))
|
||||
res = index.map(t)
|
||||
|
||||
# should return an Index
|
||||
assert isinstance(res, Index)
|
||||
|
||||
# preserve element types
|
||||
assert all(isinstance(resi, t) for resi in res)
|
||||
|
||||
# lastly, values should compare equal
|
||||
tm.assert_index_equal(res, expected)
|
||||
|
||||
|
||||
class TestSeriesPeriod(object):
|
||||
|
||||
def setup_method(self, method):
|
||||
self.series = Series(period_range('2000-01-01', periods=10, freq='D'))
|
||||
|
||||
def test_constructor_cant_cast_period(self):
|
||||
with pytest.raises(TypeError):
|
||||
Series(period_range('2000-01-01', periods=10, freq='D'),
|
||||
dtype=float)
|
||||
|
||||
def test_constructor_cast_object(self):
|
||||
s = Series(period_range('1/1/2000', periods=10), dtype=object)
|
||||
exp = Series(period_range('1/1/2000', periods=10))
|
||||
tm.assert_series_equal(s, exp)
|
||||
@@ -1,209 +0,0 @@
|
||||
from pandas import PeriodIndex
|
||||
|
||||
import numpy as np
|
||||
import pytest
|
||||
|
||||
import pandas.util.testing as tm
|
||||
import pandas as pd
|
||||
|
||||
|
||||
def test_to_native_types():
|
||||
index = PeriodIndex(['2017-01-01', '2017-01-02',
|
||||
'2017-01-03'], freq='D')
|
||||
|
||||
# First, with no arguments.
|
||||
expected = np.array(['2017-01-01', '2017-01-02',
|
||||
'2017-01-03'], dtype='=U10')
|
||||
|
||||
result = index.to_native_types()
|
||||
tm.assert_numpy_array_equal(result, expected)
|
||||
|
||||
# No NaN values, so na_rep has no effect
|
||||
result = index.to_native_types(na_rep='pandas')
|
||||
tm.assert_numpy_array_equal(result, expected)
|
||||
|
||||
# Make sure slicing works
|
||||
expected = np.array(['2017-01-01', '2017-01-03'], dtype='=U10')
|
||||
|
||||
result = index.to_native_types([0, 2])
|
||||
tm.assert_numpy_array_equal(result, expected)
|
||||
|
||||
# Make sure date formatting works
|
||||
expected = np.array(['01-2017-01', '01-2017-02',
|
||||
'01-2017-03'], dtype='=U10')
|
||||
|
||||
result = index.to_native_types(date_format='%m-%Y-%d')
|
||||
tm.assert_numpy_array_equal(result, expected)
|
||||
|
||||
# NULL object handling should work
|
||||
index = PeriodIndex(['2017-01-01', pd.NaT, '2017-01-03'], freq='D')
|
||||
expected = np.array(['2017-01-01', 'NaT', '2017-01-03'], dtype=object)
|
||||
|
||||
result = index.to_native_types()
|
||||
tm.assert_numpy_array_equal(result, expected)
|
||||
|
||||
expected = np.array(['2017-01-01', 'pandas',
|
||||
'2017-01-03'], dtype=object)
|
||||
|
||||
result = index.to_native_types(na_rep='pandas')
|
||||
tm.assert_numpy_array_equal(result, expected)
|
||||
|
||||
|
||||
class TestPeriodIndexRendering(object):
|
||||
@pytest.mark.parametrize('method', ['__repr__', '__unicode__', '__str__'])
|
||||
def test_representation(self, method):
|
||||
# GH#7601
|
||||
idx1 = PeriodIndex([], freq='D')
|
||||
idx2 = PeriodIndex(['2011-01-01'], freq='D')
|
||||
idx3 = PeriodIndex(['2011-01-01', '2011-01-02'], freq='D')
|
||||
idx4 = PeriodIndex(['2011-01-01', '2011-01-02', '2011-01-03'],
|
||||
freq='D')
|
||||
idx5 = PeriodIndex(['2011', '2012', '2013'], freq='A')
|
||||
idx6 = PeriodIndex(['2011-01-01 09:00', '2012-02-01 10:00', 'NaT'],
|
||||
freq='H')
|
||||
idx7 = pd.period_range('2013Q1', periods=1, freq="Q")
|
||||
idx8 = pd.period_range('2013Q1', periods=2, freq="Q")
|
||||
idx9 = pd.period_range('2013Q1', periods=3, freq="Q")
|
||||
idx10 = PeriodIndex(['2011-01-01', '2011-02-01'], freq='3D')
|
||||
|
||||
exp1 = """PeriodIndex([], dtype='period[D]', freq='D')"""
|
||||
|
||||
exp2 = """PeriodIndex(['2011-01-01'], dtype='period[D]', freq='D')"""
|
||||
|
||||
exp3 = ("PeriodIndex(['2011-01-01', '2011-01-02'], dtype='period[D]', "
|
||||
"freq='D')")
|
||||
|
||||
exp4 = ("PeriodIndex(['2011-01-01', '2011-01-02', '2011-01-03'], "
|
||||
"dtype='period[D]', freq='D')")
|
||||
|
||||
exp5 = ("PeriodIndex(['2011', '2012', '2013'], dtype='period[A-DEC]', "
|
||||
"freq='A-DEC')")
|
||||
|
||||
exp6 = ("PeriodIndex(['2011-01-01 09:00', '2012-02-01 10:00', 'NaT'], "
|
||||
"dtype='period[H]', freq='H')")
|
||||
|
||||
exp7 = ("PeriodIndex(['2013Q1'], dtype='period[Q-DEC]', "
|
||||
"freq='Q-DEC')")
|
||||
|
||||
exp8 = ("PeriodIndex(['2013Q1', '2013Q2'], dtype='period[Q-DEC]', "
|
||||
"freq='Q-DEC')")
|
||||
|
||||
exp9 = ("PeriodIndex(['2013Q1', '2013Q2', '2013Q3'], "
|
||||
"dtype='period[Q-DEC]', freq='Q-DEC')")
|
||||
|
||||
exp10 = ("PeriodIndex(['2011-01-01', '2011-02-01'], "
|
||||
"dtype='period[3D]', freq='3D')")
|
||||
|
||||
for idx, expected in zip([idx1, idx2, idx3, idx4, idx5,
|
||||
idx6, idx7, idx8, idx9, idx10],
|
||||
[exp1, exp2, exp3, exp4, exp5,
|
||||
exp6, exp7, exp8, exp9, exp10]):
|
||||
result = getattr(idx, method)()
|
||||
assert result == expected
|
||||
|
||||
def test_representation_to_series(self):
|
||||
# GH#10971
|
||||
idx1 = PeriodIndex([], freq='D')
|
||||
idx2 = PeriodIndex(['2011-01-01'], freq='D')
|
||||
idx3 = PeriodIndex(['2011-01-01', '2011-01-02'], freq='D')
|
||||
idx4 = PeriodIndex(['2011-01-01', '2011-01-02', '2011-01-03'],
|
||||
freq='D')
|
||||
idx5 = PeriodIndex(['2011', '2012', '2013'], freq='A')
|
||||
idx6 = PeriodIndex(['2011-01-01 09:00', '2012-02-01 10:00', 'NaT'],
|
||||
freq='H')
|
||||
|
||||
idx7 = pd.period_range('2013Q1', periods=1, freq="Q")
|
||||
idx8 = pd.period_range('2013Q1', periods=2, freq="Q")
|
||||
idx9 = pd.period_range('2013Q1', periods=3, freq="Q")
|
||||
|
||||
exp1 = """Series([], dtype: object)"""
|
||||
|
||||
exp2 = """0 2011-01-01
|
||||
dtype: object"""
|
||||
|
||||
exp3 = """0 2011-01-01
|
||||
1 2011-01-02
|
||||
dtype: object"""
|
||||
|
||||
exp4 = """0 2011-01-01
|
||||
1 2011-01-02
|
||||
2 2011-01-03
|
||||
dtype: object"""
|
||||
|
||||
exp5 = """0 2011
|
||||
1 2012
|
||||
2 2013
|
||||
dtype: object"""
|
||||
|
||||
exp6 = """0 2011-01-01 09:00
|
||||
1 2012-02-01 10:00
|
||||
2 NaT
|
||||
dtype: object"""
|
||||
|
||||
exp7 = """0 2013Q1
|
||||
dtype: object"""
|
||||
|
||||
exp8 = """0 2013Q1
|
||||
1 2013Q2
|
||||
dtype: object"""
|
||||
|
||||
exp9 = """0 2013Q1
|
||||
1 2013Q2
|
||||
2 2013Q3
|
||||
dtype: object"""
|
||||
|
||||
for idx, expected in zip([idx1, idx2, idx3, idx4, idx5,
|
||||
idx6, idx7, idx8, idx9],
|
||||
[exp1, exp2, exp3, exp4, exp5,
|
||||
exp6, exp7, exp8, exp9]):
|
||||
result = repr(pd.Series(idx))
|
||||
assert result == expected
|
||||
|
||||
def test_summary(self):
|
||||
# GH#9116
|
||||
idx1 = PeriodIndex([], freq='D')
|
||||
idx2 = PeriodIndex(['2011-01-01'], freq='D')
|
||||
idx3 = PeriodIndex(['2011-01-01', '2011-01-02'], freq='D')
|
||||
idx4 = PeriodIndex(['2011-01-01', '2011-01-02', '2011-01-03'],
|
||||
freq='D')
|
||||
idx5 = PeriodIndex(['2011', '2012', '2013'], freq='A')
|
||||
idx6 = PeriodIndex(['2011-01-01 09:00', '2012-02-01 10:00', 'NaT'],
|
||||
freq='H')
|
||||
|
||||
idx7 = pd.period_range('2013Q1', periods=1, freq="Q")
|
||||
idx8 = pd.period_range('2013Q1', periods=2, freq="Q")
|
||||
idx9 = pd.period_range('2013Q1', periods=3, freq="Q")
|
||||
|
||||
exp1 = """PeriodIndex: 0 entries
|
||||
Freq: D"""
|
||||
|
||||
exp2 = """PeriodIndex: 1 entries, 2011-01-01 to 2011-01-01
|
||||
Freq: D"""
|
||||
|
||||
exp3 = """PeriodIndex: 2 entries, 2011-01-01 to 2011-01-02
|
||||
Freq: D"""
|
||||
|
||||
exp4 = """PeriodIndex: 3 entries, 2011-01-01 to 2011-01-03
|
||||
Freq: D"""
|
||||
|
||||
exp5 = """PeriodIndex: 3 entries, 2011 to 2013
|
||||
Freq: A-DEC"""
|
||||
|
||||
exp6 = """PeriodIndex: 3 entries, 2011-01-01 09:00 to NaT
|
||||
Freq: H"""
|
||||
|
||||
exp7 = """PeriodIndex: 1 entries, 2013Q1 to 2013Q1
|
||||
Freq: Q-DEC"""
|
||||
|
||||
exp8 = """PeriodIndex: 2 entries, 2013Q1 to 2013Q2
|
||||
Freq: Q-DEC"""
|
||||
|
||||
exp9 = """PeriodIndex: 3 entries, 2013Q1 to 2013Q3
|
||||
Freq: Q-DEC"""
|
||||
|
||||
for idx, expected in zip([idx1, idx2, idx3, idx4, idx5,
|
||||
idx6, idx7, idx8, idx9],
|
||||
[exp1, exp2, exp3, exp4, exp5,
|
||||
exp6, exp7, exp8, exp9]):
|
||||
result = idx._summary()
|
||||
assert result == expected
|
||||
-635
@@ -1,635 +0,0 @@
|
||||
from datetime import datetime, timedelta
|
||||
|
||||
import pytest
|
||||
|
||||
import numpy as np
|
||||
import pandas as pd
|
||||
from pandas.util import testing as tm
|
||||
from pandas.compat import lrange
|
||||
from pandas._libs import tslibs
|
||||
from pandas import (PeriodIndex, Series, DatetimeIndex,
|
||||
period_range, Period, notna)
|
||||
from pandas._libs.tslibs import period as libperiod
|
||||
|
||||
|
||||
class TestGetItem(object):
|
||||
|
||||
def test_getitem(self):
|
||||
idx1 = pd.period_range('2011-01-01', '2011-01-31', freq='D',
|
||||
name='idx')
|
||||
|
||||
for idx in [idx1]:
|
||||
result = idx[0]
|
||||
assert result == pd.Period('2011-01-01', freq='D')
|
||||
|
||||
result = idx[-1]
|
||||
assert result == pd.Period('2011-01-31', freq='D')
|
||||
|
||||
result = idx[0:5]
|
||||
expected = pd.period_range('2011-01-01', '2011-01-05', freq='D',
|
||||
name='idx')
|
||||
tm.assert_index_equal(result, expected)
|
||||
assert result.freq == expected.freq
|
||||
assert result.freq == 'D'
|
||||
|
||||
result = idx[0:10:2]
|
||||
expected = pd.PeriodIndex(['2011-01-01', '2011-01-03',
|
||||
'2011-01-05',
|
||||
'2011-01-07', '2011-01-09'],
|
||||
freq='D', name='idx')
|
||||
tm.assert_index_equal(result, expected)
|
||||
assert result.freq == expected.freq
|
||||
assert result.freq == 'D'
|
||||
|
||||
result = idx[-20:-5:3]
|
||||
expected = pd.PeriodIndex(['2011-01-12', '2011-01-15',
|
||||
'2011-01-18',
|
||||
'2011-01-21', '2011-01-24'],
|
||||
freq='D', name='idx')
|
||||
tm.assert_index_equal(result, expected)
|
||||
assert result.freq == expected.freq
|
||||
assert result.freq == 'D'
|
||||
|
||||
result = idx[4::-1]
|
||||
expected = PeriodIndex(['2011-01-05', '2011-01-04', '2011-01-03',
|
||||
'2011-01-02', '2011-01-01'],
|
||||
freq='D', name='idx')
|
||||
tm.assert_index_equal(result, expected)
|
||||
assert result.freq == expected.freq
|
||||
assert result.freq == 'D'
|
||||
|
||||
def test_getitem_index(self):
|
||||
idx = period_range('2007-01', periods=10, freq='M', name='x')
|
||||
|
||||
result = idx[[1, 3, 5]]
|
||||
exp = pd.PeriodIndex(['2007-02', '2007-04', '2007-06'],
|
||||
freq='M', name='x')
|
||||
tm.assert_index_equal(result, exp)
|
||||
|
||||
result = idx[[True, True, False, False, False,
|
||||
True, True, False, False, False]]
|
||||
exp = pd.PeriodIndex(['2007-01', '2007-02', '2007-06', '2007-07'],
|
||||
freq='M', name='x')
|
||||
tm.assert_index_equal(result, exp)
|
||||
|
||||
def test_getitem_partial(self):
|
||||
rng = period_range('2007-01', periods=50, freq='M')
|
||||
ts = Series(np.random.randn(len(rng)), rng)
|
||||
|
||||
pytest.raises(KeyError, ts.__getitem__, '2006')
|
||||
|
||||
result = ts['2008']
|
||||
assert (result.index.year == 2008).all()
|
||||
|
||||
result = ts['2008':'2009']
|
||||
assert len(result) == 24
|
||||
|
||||
result = ts['2008-1':'2009-12']
|
||||
assert len(result) == 24
|
||||
|
||||
result = ts['2008Q1':'2009Q4']
|
||||
assert len(result) == 24
|
||||
|
||||
result = ts[:'2009']
|
||||
assert len(result) == 36
|
||||
|
||||
result = ts['2009':]
|
||||
assert len(result) == 50 - 24
|
||||
|
||||
exp = result
|
||||
result = ts[24:]
|
||||
tm.assert_series_equal(exp, result)
|
||||
|
||||
ts = ts[10:].append(ts[10:])
|
||||
tm.assert_raises_regex(KeyError,
|
||||
"left slice bound for non-unique "
|
||||
"label: '2008'",
|
||||
ts.__getitem__, slice('2008', '2009'))
|
||||
|
||||
def test_getitem_datetime(self):
|
||||
rng = period_range(start='2012-01-01', periods=10, freq='W-MON')
|
||||
ts = Series(lrange(len(rng)), index=rng)
|
||||
|
||||
dt1 = datetime(2011, 10, 2)
|
||||
dt4 = datetime(2012, 4, 20)
|
||||
|
||||
rs = ts[dt1:dt4]
|
||||
tm.assert_series_equal(rs, ts)
|
||||
|
||||
def test_getitem_nat(self):
|
||||
idx = pd.PeriodIndex(['2011-01', 'NaT', '2011-02'], freq='M')
|
||||
assert idx[0] == pd.Period('2011-01', freq='M')
|
||||
assert idx[1] is pd.NaT
|
||||
|
||||
s = pd.Series([0, 1, 2], index=idx)
|
||||
assert s[pd.NaT] == 1
|
||||
|
||||
s = pd.Series(idx, index=idx)
|
||||
assert (s[pd.Period('2011-01', freq='M')] ==
|
||||
pd.Period('2011-01', freq='M'))
|
||||
assert s[pd.NaT] is pd.NaT
|
||||
|
||||
def test_getitem_list_periods(self):
|
||||
# GH 7710
|
||||
rng = period_range(start='2012-01-01', periods=10, freq='D')
|
||||
ts = Series(lrange(len(rng)), index=rng)
|
||||
exp = ts.iloc[[1]]
|
||||
tm.assert_series_equal(ts[[Period('2012-01-02', freq='D')]], exp)
|
||||
|
||||
def test_getitem_seconds(self):
|
||||
# GH 6716
|
||||
didx = DatetimeIndex(start='2013/01/01 09:00:00', freq='S',
|
||||
periods=4000)
|
||||
pidx = PeriodIndex(start='2013/01/01 09:00:00', freq='S', periods=4000)
|
||||
|
||||
for idx in [didx, pidx]:
|
||||
# getitem against index should raise ValueError
|
||||
values = ['2014', '2013/02', '2013/01/02', '2013/02/01 9H',
|
||||
'2013/02/01 09:00']
|
||||
for v in values:
|
||||
# GH7116
|
||||
# these show deprecations as we are trying
|
||||
# to slice with non-integer indexers
|
||||
# with pytest.raises(IndexError):
|
||||
# idx[v]
|
||||
continue
|
||||
|
||||
s = Series(np.random.rand(len(idx)), index=idx)
|
||||
tm.assert_series_equal(s['2013/01/01 10:00'], s[3600:3660])
|
||||
tm.assert_series_equal(s['2013/01/01 9H'], s[:3600])
|
||||
for d in ['2013/01/01', '2013/01', '2013']:
|
||||
tm.assert_series_equal(s[d], s)
|
||||
|
||||
def test_getitem_day(self):
|
||||
# GH 6716
|
||||
# Confirm DatetimeIndex and PeriodIndex works identically
|
||||
didx = DatetimeIndex(start='2013/01/01', freq='D', periods=400)
|
||||
pidx = PeriodIndex(start='2013/01/01', freq='D', periods=400)
|
||||
|
||||
for idx in [didx, pidx]:
|
||||
# getitem against index should raise ValueError
|
||||
values = ['2014', '2013/02', '2013/01/02', '2013/02/01 9H',
|
||||
'2013/02/01 09:00']
|
||||
for v in values:
|
||||
|
||||
# GH7116
|
||||
# these show deprecations as we are trying
|
||||
# to slice with non-integer indexers
|
||||
# with pytest.raises(IndexError):
|
||||
# idx[v]
|
||||
continue
|
||||
|
||||
s = Series(np.random.rand(len(idx)), index=idx)
|
||||
tm.assert_series_equal(s['2013/01'], s[0:31])
|
||||
tm.assert_series_equal(s['2013/02'], s[31:59])
|
||||
tm.assert_series_equal(s['2014'], s[365:])
|
||||
|
||||
invalid = ['2013/02/01 9H', '2013/02/01 09:00']
|
||||
for v in invalid:
|
||||
with pytest.raises(KeyError):
|
||||
s[v]
|
||||
|
||||
|
||||
class TestWhere(object):
|
||||
@pytest.mark.parametrize('klass', [list, tuple, np.array, Series])
|
||||
def test_where(self, klass):
|
||||
i = period_range('20130101', periods=5, freq='D')
|
||||
cond = [True] * len(i)
|
||||
expected = i
|
||||
result = i.where(klass(cond))
|
||||
tm.assert_index_equal(result, expected)
|
||||
|
||||
cond = [False] + [True] * (len(i) - 1)
|
||||
expected = PeriodIndex([pd.NaT] + i[1:].tolist(), freq='D')
|
||||
result = i.where(klass(cond))
|
||||
tm.assert_index_equal(result, expected)
|
||||
|
||||
def test_where_other(self):
|
||||
i = period_range('20130101', periods=5, freq='D')
|
||||
for arr in [np.nan, pd.NaT]:
|
||||
result = i.where(notna(i), other=np.nan)
|
||||
expected = i
|
||||
tm.assert_index_equal(result, expected)
|
||||
|
||||
i2 = i.copy()
|
||||
i2 = pd.PeriodIndex([pd.NaT, pd.NaT] + i[2:].tolist(),
|
||||
freq='D')
|
||||
result = i.where(notna(i2), i2)
|
||||
tm.assert_index_equal(result, i2)
|
||||
|
||||
i2 = i.copy()
|
||||
i2 = pd.PeriodIndex([pd.NaT, pd.NaT] + i[2:].tolist(),
|
||||
freq='D')
|
||||
result = i.where(notna(i2), i2.values)
|
||||
tm.assert_index_equal(result, i2)
|
||||
|
||||
|
||||
class TestTake(object):
|
||||
def test_take(self):
|
||||
# GH#10295
|
||||
idx1 = pd.period_range('2011-01-01', '2011-01-31', freq='D',
|
||||
name='idx')
|
||||
|
||||
for idx in [idx1]:
|
||||
result = idx.take([0])
|
||||
assert result == pd.Period('2011-01-01', freq='D')
|
||||
|
||||
result = idx.take([5])
|
||||
assert result == pd.Period('2011-01-06', freq='D')
|
||||
|
||||
result = idx.take([0, 1, 2])
|
||||
expected = pd.period_range('2011-01-01', '2011-01-03', freq='D',
|
||||
name='idx')
|
||||
tm.assert_index_equal(result, expected)
|
||||
assert result.freq == 'D'
|
||||
assert result.freq == expected.freq
|
||||
|
||||
result = idx.take([0, 2, 4])
|
||||
expected = pd.PeriodIndex(['2011-01-01', '2011-01-03',
|
||||
'2011-01-05'], freq='D', name='idx')
|
||||
tm.assert_index_equal(result, expected)
|
||||
assert result.freq == expected.freq
|
||||
assert result.freq == 'D'
|
||||
|
||||
result = idx.take([7, 4, 1])
|
||||
expected = pd.PeriodIndex(['2011-01-08', '2011-01-05',
|
||||
'2011-01-02'],
|
||||
freq='D', name='idx')
|
||||
tm.assert_index_equal(result, expected)
|
||||
assert result.freq == expected.freq
|
||||
assert result.freq == 'D'
|
||||
|
||||
result = idx.take([3, 2, 5])
|
||||
expected = PeriodIndex(['2011-01-04', '2011-01-03', '2011-01-06'],
|
||||
freq='D', name='idx')
|
||||
tm.assert_index_equal(result, expected)
|
||||
assert result.freq == expected.freq
|
||||
assert result.freq == 'D'
|
||||
|
||||
result = idx.take([-3, 2, 5])
|
||||
expected = PeriodIndex(['2011-01-29', '2011-01-03', '2011-01-06'],
|
||||
freq='D', name='idx')
|
||||
tm.assert_index_equal(result, expected)
|
||||
assert result.freq == expected.freq
|
||||
assert result.freq == 'D'
|
||||
|
||||
def test_take_misc(self):
|
||||
index = PeriodIndex(start='1/1/10', end='12/31/12', freq='D',
|
||||
name='idx')
|
||||
expected = PeriodIndex([datetime(2010, 1, 6), datetime(2010, 1, 7),
|
||||
datetime(2010, 1, 9), datetime(2010, 1, 13)],
|
||||
freq='D', name='idx')
|
||||
|
||||
taken1 = index.take([5, 6, 8, 12])
|
||||
taken2 = index[[5, 6, 8, 12]]
|
||||
|
||||
for taken in [taken1, taken2]:
|
||||
tm.assert_index_equal(taken, expected)
|
||||
assert isinstance(taken, PeriodIndex)
|
||||
assert taken.freq == index.freq
|
||||
assert taken.name == expected.name
|
||||
|
||||
def test_take_fill_value(self):
|
||||
# GH#12631
|
||||
idx = pd.PeriodIndex(['2011-01-01', '2011-02-01', '2011-03-01'],
|
||||
name='xxx', freq='D')
|
||||
result = idx.take(np.array([1, 0, -1]))
|
||||
expected = pd.PeriodIndex(['2011-02-01', '2011-01-01', '2011-03-01'],
|
||||
name='xxx', freq='D')
|
||||
tm.assert_index_equal(result, expected)
|
||||
|
||||
# fill_value
|
||||
result = idx.take(np.array([1, 0, -1]), fill_value=True)
|
||||
expected = pd.PeriodIndex(['2011-02-01', '2011-01-01', 'NaT'],
|
||||
name='xxx', freq='D')
|
||||
tm.assert_index_equal(result, expected)
|
||||
|
||||
# allow_fill=False
|
||||
result = idx.take(np.array([1, 0, -1]), allow_fill=False,
|
||||
fill_value=True)
|
||||
expected = pd.PeriodIndex(['2011-02-01', '2011-01-01', '2011-03-01'],
|
||||
name='xxx', freq='D')
|
||||
tm.assert_index_equal(result, expected)
|
||||
|
||||
msg = ('When allow_fill=True and fill_value is not None, '
|
||||
'all indices must be >= -1')
|
||||
with tm.assert_raises_regex(ValueError, msg):
|
||||
idx.take(np.array([1, 0, -2]), fill_value=True)
|
||||
with tm.assert_raises_regex(ValueError, msg):
|
||||
idx.take(np.array([1, 0, -5]), fill_value=True)
|
||||
|
||||
with pytest.raises(IndexError):
|
||||
idx.take(np.array([1, -5]))
|
||||
|
||||
|
||||
class TestIndexing(object):
|
||||
|
||||
def test_get_loc_msg(self):
|
||||
idx = period_range('2000-1-1', freq='A', periods=10)
|
||||
bad_period = Period('2012', 'A')
|
||||
pytest.raises(KeyError, idx.get_loc, bad_period)
|
||||
|
||||
try:
|
||||
idx.get_loc(bad_period)
|
||||
except KeyError as inst:
|
||||
assert inst.args[0] == bad_period
|
||||
|
||||
def test_get_loc_nat(self):
|
||||
didx = DatetimeIndex(['2011-01-01', 'NaT', '2011-01-03'])
|
||||
pidx = PeriodIndex(['2011-01-01', 'NaT', '2011-01-03'], freq='M')
|
||||
|
||||
# check DatetimeIndex compat
|
||||
for idx in [didx, pidx]:
|
||||
assert idx.get_loc(pd.NaT) == 1
|
||||
assert idx.get_loc(None) == 1
|
||||
assert idx.get_loc(float('nan')) == 1
|
||||
assert idx.get_loc(np.nan) == 1
|
||||
|
||||
def test_get_loc(self):
|
||||
# GH 17717
|
||||
p0 = pd.Period('2017-09-01')
|
||||
p1 = pd.Period('2017-09-02')
|
||||
p2 = pd.Period('2017-09-03')
|
||||
|
||||
# get the location of p1/p2 from
|
||||
# monotonic increasing PeriodIndex with non-duplicate
|
||||
idx0 = pd.PeriodIndex([p0, p1, p2])
|
||||
expected_idx1_p1 = 1
|
||||
expected_idx1_p2 = 2
|
||||
|
||||
assert idx0.get_loc(p1) == expected_idx1_p1
|
||||
assert idx0.get_loc(str(p1)) == expected_idx1_p1
|
||||
assert idx0.get_loc(p2) == expected_idx1_p2
|
||||
assert idx0.get_loc(str(p2)) == expected_idx1_p2
|
||||
|
||||
pytest.raises(tslibs.parsing.DateParseError, idx0.get_loc, 'foo')
|
||||
pytest.raises(KeyError, idx0.get_loc, 1.1)
|
||||
pytest.raises(TypeError, idx0.get_loc, idx0)
|
||||
|
||||
# get the location of p1/p2 from
|
||||
# monotonic increasing PeriodIndex with duplicate
|
||||
idx1 = pd.PeriodIndex([p1, p1, p2])
|
||||
expected_idx1_p1 = slice(0, 2)
|
||||
expected_idx1_p2 = 2
|
||||
|
||||
assert idx1.get_loc(p1) == expected_idx1_p1
|
||||
assert idx1.get_loc(str(p1)) == expected_idx1_p1
|
||||
assert idx1.get_loc(p2) == expected_idx1_p2
|
||||
assert idx1.get_loc(str(p2)) == expected_idx1_p2
|
||||
|
||||
pytest.raises(tslibs.parsing.DateParseError, idx1.get_loc, 'foo')
|
||||
pytest.raises(KeyError, idx1.get_loc, 1.1)
|
||||
pytest.raises(TypeError, idx1.get_loc, idx1)
|
||||
|
||||
# get the location of p1/p2 from
|
||||
# non-monotonic increasing/decreasing PeriodIndex with duplicate
|
||||
idx2 = pd.PeriodIndex([p2, p1, p2])
|
||||
expected_idx2_p1 = 1
|
||||
expected_idx2_p2 = np.array([True, False, True])
|
||||
|
||||
assert idx2.get_loc(p1) == expected_idx2_p1
|
||||
assert idx2.get_loc(str(p1)) == expected_idx2_p1
|
||||
tm.assert_numpy_array_equal(idx2.get_loc(p2), expected_idx2_p2)
|
||||
tm.assert_numpy_array_equal(idx2.get_loc(str(p2)), expected_idx2_p2)
|
||||
|
||||
def test_is_monotonic_increasing(self):
|
||||
# GH 17717
|
||||
p0 = pd.Period('2017-09-01')
|
||||
p1 = pd.Period('2017-09-02')
|
||||
p2 = pd.Period('2017-09-03')
|
||||
|
||||
idx_inc0 = pd.PeriodIndex([p0, p1, p2])
|
||||
idx_inc1 = pd.PeriodIndex([p0, p1, p1])
|
||||
idx_dec0 = pd.PeriodIndex([p2, p1, p0])
|
||||
idx_dec1 = pd.PeriodIndex([p2, p1, p1])
|
||||
idx = pd.PeriodIndex([p1, p2, p0])
|
||||
|
||||
assert idx_inc0.is_monotonic_increasing
|
||||
assert idx_inc1.is_monotonic_increasing
|
||||
assert not idx_dec0.is_monotonic_increasing
|
||||
assert not idx_dec1.is_monotonic_increasing
|
||||
assert not idx.is_monotonic_increasing
|
||||
|
||||
def test_is_monotonic_decreasing(self):
|
||||
# GH 17717
|
||||
p0 = pd.Period('2017-09-01')
|
||||
p1 = pd.Period('2017-09-02')
|
||||
p2 = pd.Period('2017-09-03')
|
||||
|
||||
idx_inc0 = pd.PeriodIndex([p0, p1, p2])
|
||||
idx_inc1 = pd.PeriodIndex([p0, p1, p1])
|
||||
idx_dec0 = pd.PeriodIndex([p2, p1, p0])
|
||||
idx_dec1 = pd.PeriodIndex([p2, p1, p1])
|
||||
idx = pd.PeriodIndex([p1, p2, p0])
|
||||
|
||||
assert not idx_inc0.is_monotonic_decreasing
|
||||
assert not idx_inc1.is_monotonic_decreasing
|
||||
assert idx_dec0.is_monotonic_decreasing
|
||||
assert idx_dec1.is_monotonic_decreasing
|
||||
assert not idx.is_monotonic_decreasing
|
||||
|
||||
def test_is_unique(self):
|
||||
# GH 17717
|
||||
p0 = pd.Period('2017-09-01')
|
||||
p1 = pd.Period('2017-09-02')
|
||||
p2 = pd.Period('2017-09-03')
|
||||
|
||||
idx0 = pd.PeriodIndex([p0, p1, p2])
|
||||
assert idx0.is_unique
|
||||
|
||||
idx1 = pd.PeriodIndex([p1, p1, p2])
|
||||
assert not idx1.is_unique
|
||||
|
||||
def test_contains(self):
|
||||
# GH 17717
|
||||
p0 = pd.Period('2017-09-01')
|
||||
p1 = pd.Period('2017-09-02')
|
||||
p2 = pd.Period('2017-09-03')
|
||||
p3 = pd.Period('2017-09-04')
|
||||
|
||||
ps0 = [p0, p1, p2]
|
||||
idx0 = pd.PeriodIndex(ps0)
|
||||
|
||||
for p in ps0:
|
||||
assert idx0.contains(p)
|
||||
assert p in idx0
|
||||
|
||||
assert idx0.contains(str(p))
|
||||
assert str(p) in idx0
|
||||
|
||||
assert idx0.contains('2017-09-01 00:00:01')
|
||||
assert '2017-09-01 00:00:01' in idx0
|
||||
|
||||
assert idx0.contains('2017-09')
|
||||
assert '2017-09' in idx0
|
||||
|
||||
assert not idx0.contains(p3)
|
||||
assert p3 not in idx0
|
||||
|
||||
def test_get_value(self):
|
||||
# GH 17717
|
||||
p0 = pd.Period('2017-09-01')
|
||||
p1 = pd.Period('2017-09-02')
|
||||
p2 = pd.Period('2017-09-03')
|
||||
|
||||
idx0 = pd.PeriodIndex([p0, p1, p2])
|
||||
input0 = np.array([1, 2, 3])
|
||||
expected0 = 2
|
||||
|
||||
result0 = idx0.get_value(input0, p1)
|
||||
assert result0 == expected0
|
||||
|
||||
idx1 = pd.PeriodIndex([p1, p1, p2])
|
||||
input1 = np.array([1, 2, 3])
|
||||
expected1 = np.array([1, 2])
|
||||
|
||||
result1 = idx1.get_value(input1, p1)
|
||||
tm.assert_numpy_array_equal(result1, expected1)
|
||||
|
||||
idx2 = pd.PeriodIndex([p1, p2, p1])
|
||||
input2 = np.array([1, 2, 3])
|
||||
expected2 = np.array([1, 3])
|
||||
|
||||
result2 = idx2.get_value(input2, p1)
|
||||
tm.assert_numpy_array_equal(result2, expected2)
|
||||
|
||||
def test_get_indexer(self):
|
||||
# GH 17717
|
||||
p1 = pd.Period('2017-09-01')
|
||||
p2 = pd.Period('2017-09-04')
|
||||
p3 = pd.Period('2017-09-07')
|
||||
|
||||
tp0 = pd.Period('2017-08-31')
|
||||
tp1 = pd.Period('2017-09-02')
|
||||
tp2 = pd.Period('2017-09-05')
|
||||
tp3 = pd.Period('2017-09-09')
|
||||
|
||||
idx = pd.PeriodIndex([p1, p2, p3])
|
||||
|
||||
tm.assert_numpy_array_equal(idx.get_indexer(idx),
|
||||
np.array([0, 1, 2], dtype=np.intp))
|
||||
|
||||
target = pd.PeriodIndex([tp0, tp1, tp2, tp3])
|
||||
tm.assert_numpy_array_equal(idx.get_indexer(target, 'pad'),
|
||||
np.array([-1, 0, 1, 2], dtype=np.intp))
|
||||
tm.assert_numpy_array_equal(idx.get_indexer(target, 'backfill'),
|
||||
np.array([0, 1, 2, -1], dtype=np.intp))
|
||||
tm.assert_numpy_array_equal(idx.get_indexer(target, 'nearest'),
|
||||
np.array([0, 0, 1, 2], dtype=np.intp))
|
||||
|
||||
res = idx.get_indexer(target, 'nearest',
|
||||
tolerance=pd.Timedelta('1 day'))
|
||||
tm.assert_numpy_array_equal(res,
|
||||
np.array([0, 0, 1, -1], dtype=np.intp))
|
||||
|
||||
def test_get_indexer_non_unique(self):
|
||||
# GH 17717
|
||||
p1 = pd.Period('2017-09-02')
|
||||
p2 = pd.Period('2017-09-03')
|
||||
p3 = pd.Period('2017-09-04')
|
||||
p4 = pd.Period('2017-09-05')
|
||||
|
||||
idx1 = pd.PeriodIndex([p1, p2, p1])
|
||||
idx2 = pd.PeriodIndex([p2, p1, p3, p4])
|
||||
|
||||
result = idx1.get_indexer_non_unique(idx2)
|
||||
expected_indexer = np.array([1, 0, 2, -1, -1], dtype=np.intp)
|
||||
expected_missing = np.array([2, 3], dtype=np.int64)
|
||||
|
||||
tm.assert_numpy_array_equal(result[0], expected_indexer)
|
||||
tm.assert_numpy_array_equal(result[1], expected_missing)
|
||||
|
||||
# TODO: This method came from test_period; de-dup with version above
|
||||
def test_get_loc2(self):
|
||||
idx = pd.period_range('2000-01-01', periods=3)
|
||||
|
||||
for method in [None, 'pad', 'backfill', 'nearest']:
|
||||
assert idx.get_loc(idx[1], method) == 1
|
||||
assert idx.get_loc(idx[1].asfreq('H', how='start'), method) == 1
|
||||
assert idx.get_loc(idx[1].to_timestamp(), method) == 1
|
||||
assert idx.get_loc(idx[1].to_timestamp()
|
||||
.to_pydatetime(), method) == 1
|
||||
assert idx.get_loc(str(idx[1]), method) == 1
|
||||
|
||||
idx = pd.period_range('2000-01-01', periods=5)[::2]
|
||||
assert idx.get_loc('2000-01-02T12', method='nearest',
|
||||
tolerance='1 day') == 1
|
||||
assert idx.get_loc('2000-01-02T12', method='nearest',
|
||||
tolerance=pd.Timedelta('1D')) == 1
|
||||
assert idx.get_loc('2000-01-02T12', method='nearest',
|
||||
tolerance=np.timedelta64(1, 'D')) == 1
|
||||
assert idx.get_loc('2000-01-02T12', method='nearest',
|
||||
tolerance=timedelta(1)) == 1
|
||||
with tm.assert_raises_regex(ValueError,
|
||||
'unit abbreviation w/o a number'):
|
||||
idx.get_loc('2000-01-10', method='nearest', tolerance='foo')
|
||||
|
||||
msg = 'Input has different freq from PeriodIndex\\(freq=D\\)'
|
||||
with tm.assert_raises_regex(ValueError, msg):
|
||||
idx.get_loc('2000-01-10', method='nearest', tolerance='1 hour')
|
||||
with pytest.raises(KeyError):
|
||||
idx.get_loc('2000-01-10', method='nearest', tolerance='1 day')
|
||||
with pytest.raises(
|
||||
ValueError,
|
||||
match='list-like tolerance size must match target index size'):
|
||||
idx.get_loc('2000-01-10', method='nearest',
|
||||
tolerance=[pd.Timedelta('1 day').to_timedelta64(),
|
||||
pd.Timedelta('1 day').to_timedelta64()])
|
||||
|
||||
# TODO: This method came from test_period; de-dup with version above
|
||||
def test_get_indexer2(self):
|
||||
idx = pd.period_range('2000-01-01', periods=3).asfreq('H', how='start')
|
||||
tm.assert_numpy_array_equal(idx.get_indexer(idx),
|
||||
np.array([0, 1, 2], dtype=np.intp))
|
||||
|
||||
target = pd.PeriodIndex(['1999-12-31T23', '2000-01-01T12',
|
||||
'2000-01-02T01'], freq='H')
|
||||
tm.assert_numpy_array_equal(idx.get_indexer(target, 'pad'),
|
||||
np.array([-1, 0, 1], dtype=np.intp))
|
||||
tm.assert_numpy_array_equal(idx.get_indexer(target, 'backfill'),
|
||||
np.array([0, 1, 2], dtype=np.intp))
|
||||
tm.assert_numpy_array_equal(idx.get_indexer(target, 'nearest'),
|
||||
np.array([0, 1, 1], dtype=np.intp))
|
||||
tm.assert_numpy_array_equal(idx.get_indexer(target, 'nearest',
|
||||
tolerance='1 hour'),
|
||||
np.array([0, -1, 1], dtype=np.intp))
|
||||
|
||||
msg = 'Input has different freq from PeriodIndex\\(freq=H\\)'
|
||||
with tm.assert_raises_regex(ValueError, msg):
|
||||
idx.get_indexer(target, 'nearest', tolerance='1 minute')
|
||||
|
||||
tm.assert_numpy_array_equal(idx.get_indexer(target, 'nearest',
|
||||
tolerance='1 day'),
|
||||
np.array([0, 1, 1], dtype=np.intp))
|
||||
tol_raw = [pd.Timedelta('1 hour'),
|
||||
pd.Timedelta('1 hour'),
|
||||
np.timedelta64(1, 'D'), ]
|
||||
tm.assert_numpy_array_equal(
|
||||
idx.get_indexer(target, 'nearest',
|
||||
tolerance=[np.timedelta64(x) for x in tol_raw]),
|
||||
np.array([0, -1, 1], dtype=np.intp))
|
||||
tol_bad = [pd.Timedelta('2 hour').to_timedelta64(),
|
||||
pd.Timedelta('1 hour').to_timedelta64(),
|
||||
np.timedelta64(1, 'M'), ]
|
||||
with pytest.raises(
|
||||
libperiod.IncompatibleFrequency,
|
||||
match='Input has different freq from'):
|
||||
idx.get_indexer(target, 'nearest', tolerance=tol_bad)
|
||||
|
||||
def test_indexing(self):
|
||||
# GH 4390, iat incorrectly indexing
|
||||
index = period_range('1/1/2001', periods=10)
|
||||
s = Series(np.random.randn(10), index=index)
|
||||
expected = s[index[0]]
|
||||
result = s.iat[0]
|
||||
assert expected == result
|
||||
|
||||
def test_period_index_indexer(self):
|
||||
# GH4125
|
||||
idx = pd.period_range('2002-01', '2003-12', freq='M')
|
||||
df = pd.DataFrame(pd.np.random.randn(24, 10), index=idx)
|
||||
tm.assert_frame_equal(df, df.loc[idx])
|
||||
tm.assert_frame_equal(df, df.loc[list(idx)])
|
||||
tm.assert_frame_equal(df, df.loc[list(idx)])
|
||||
tm.assert_frame_equal(df.iloc[0:5], df.loc[idx[0:5]])
|
||||
tm.assert_frame_equal(df, df.loc[list(idx)])
|
||||
@@ -1,505 +0,0 @@
|
||||
|
||||
import numpy as np
|
||||
import pytest
|
||||
|
||||
import pandas as pd
|
||||
import pandas._libs.tslib as tslib
|
||||
import pandas.util.testing as tm
|
||||
from pandas import (DatetimeIndex, PeriodIndex, Series, Period,
|
||||
_np_version_under1p10, Index)
|
||||
|
||||
from pandas.tests.test_base import Ops
|
||||
|
||||
|
||||
class TestPeriodIndexOps(Ops):
|
||||
|
||||
def setup_method(self, method):
|
||||
super(TestPeriodIndexOps, self).setup_method(method)
|
||||
mask = lambda x: (isinstance(x, DatetimeIndex) or
|
||||
isinstance(x, PeriodIndex))
|
||||
self.is_valid_objs = [o for o in self.objs if mask(o)]
|
||||
self.not_valid_objs = [o for o in self.objs if not mask(o)]
|
||||
|
||||
def test_ops_properties(self):
|
||||
f = lambda x: isinstance(x, PeriodIndex)
|
||||
self.check_ops_properties(PeriodIndex._field_ops, f)
|
||||
self.check_ops_properties(PeriodIndex._object_ops, f)
|
||||
self.check_ops_properties(PeriodIndex._bool_ops, f)
|
||||
|
||||
def test_minmax(self):
|
||||
|
||||
# monotonic
|
||||
idx1 = pd.PeriodIndex([pd.NaT, '2011-01-01', '2011-01-02',
|
||||
'2011-01-03'], freq='D')
|
||||
assert idx1.is_monotonic
|
||||
|
||||
# non-monotonic
|
||||
idx2 = pd.PeriodIndex(['2011-01-01', pd.NaT, '2011-01-03',
|
||||
'2011-01-02', pd.NaT], freq='D')
|
||||
assert not idx2.is_monotonic
|
||||
|
||||
for idx in [idx1, idx2]:
|
||||
assert idx.min() == pd.Period('2011-01-01', freq='D')
|
||||
assert idx.max() == pd.Period('2011-01-03', freq='D')
|
||||
assert idx1.argmin() == 1
|
||||
assert idx2.argmin() == 0
|
||||
assert idx1.argmax() == 3
|
||||
assert idx2.argmax() == 2
|
||||
|
||||
for op in ['min', 'max']:
|
||||
# Return NaT
|
||||
obj = PeriodIndex([], freq='M')
|
||||
result = getattr(obj, op)()
|
||||
assert result is tslib.NaT
|
||||
|
||||
obj = PeriodIndex([pd.NaT], freq='M')
|
||||
result = getattr(obj, op)()
|
||||
assert result is tslib.NaT
|
||||
|
||||
obj = PeriodIndex([pd.NaT, pd.NaT, pd.NaT], freq='M')
|
||||
result = getattr(obj, op)()
|
||||
assert result is tslib.NaT
|
||||
|
||||
def test_numpy_minmax(self):
|
||||
pr = pd.period_range(start='2016-01-15', end='2016-01-20')
|
||||
|
||||
assert np.min(pr) == Period('2016-01-15', freq='D')
|
||||
assert np.max(pr) == Period('2016-01-20', freq='D')
|
||||
|
||||
errmsg = "the 'out' parameter is not supported"
|
||||
tm.assert_raises_regex(ValueError, errmsg, np.min, pr, out=0)
|
||||
tm.assert_raises_regex(ValueError, errmsg, np.max, pr, out=0)
|
||||
|
||||
assert np.argmin(pr) == 0
|
||||
assert np.argmax(pr) == 5
|
||||
|
||||
if not _np_version_under1p10:
|
||||
errmsg = "the 'out' parameter is not supported"
|
||||
tm.assert_raises_regex(
|
||||
ValueError, errmsg, np.argmin, pr, out=0)
|
||||
tm.assert_raises_regex(
|
||||
ValueError, errmsg, np.argmax, pr, out=0)
|
||||
|
||||
def test_resolution(self):
|
||||
for freq, expected in zip(['A', 'Q', 'M', 'D', 'H',
|
||||
'T', 'S', 'L', 'U'],
|
||||
['day', 'day', 'day', 'day',
|
||||
'hour', 'minute', 'second',
|
||||
'millisecond', 'microsecond']):
|
||||
|
||||
idx = pd.period_range(start='2013-04-01', periods=30, freq=freq)
|
||||
assert idx.resolution == expected
|
||||
|
||||
def test_value_counts_unique(self):
|
||||
# GH 7735
|
||||
idx = pd.period_range('2011-01-01 09:00', freq='H', periods=10)
|
||||
# create repeated values, 'n'th element is repeated by n+1 times
|
||||
idx = PeriodIndex(np.repeat(idx.values, range(1, len(idx) + 1)),
|
||||
freq='H')
|
||||
|
||||
exp_idx = PeriodIndex(['2011-01-01 18:00', '2011-01-01 17:00',
|
||||
'2011-01-01 16:00', '2011-01-01 15:00',
|
||||
'2011-01-01 14:00', '2011-01-01 13:00',
|
||||
'2011-01-01 12:00', '2011-01-01 11:00',
|
||||
'2011-01-01 10:00',
|
||||
'2011-01-01 09:00'], freq='H')
|
||||
expected = Series(range(10, 0, -1), index=exp_idx, dtype='int64')
|
||||
|
||||
for obj in [idx, Series(idx)]:
|
||||
tm.assert_series_equal(obj.value_counts(), expected)
|
||||
|
||||
expected = pd.period_range('2011-01-01 09:00', freq='H',
|
||||
periods=10)
|
||||
tm.assert_index_equal(idx.unique(), expected)
|
||||
|
||||
idx = PeriodIndex(['2013-01-01 09:00', '2013-01-01 09:00',
|
||||
'2013-01-01 09:00', '2013-01-01 08:00',
|
||||
'2013-01-01 08:00', pd.NaT], freq='H')
|
||||
|
||||
exp_idx = PeriodIndex(['2013-01-01 09:00', '2013-01-01 08:00'],
|
||||
freq='H')
|
||||
expected = Series([3, 2], index=exp_idx)
|
||||
|
||||
for obj in [idx, Series(idx)]:
|
||||
tm.assert_series_equal(obj.value_counts(), expected)
|
||||
|
||||
exp_idx = PeriodIndex(['2013-01-01 09:00', '2013-01-01 08:00',
|
||||
pd.NaT], freq='H')
|
||||
expected = Series([3, 2, 1], index=exp_idx)
|
||||
|
||||
for obj in [idx, Series(idx)]:
|
||||
tm.assert_series_equal(obj.value_counts(dropna=False), expected)
|
||||
|
||||
tm.assert_index_equal(idx.unique(), exp_idx)
|
||||
|
||||
def test_drop_duplicates_metadata(self):
|
||||
# GH 10115
|
||||
idx = pd.period_range('2011-01-01', '2011-01-31', freq='D', name='idx')
|
||||
result = idx.drop_duplicates()
|
||||
tm.assert_index_equal(idx, result)
|
||||
assert idx.freq == result.freq
|
||||
|
||||
idx_dup = idx.append(idx) # freq will not be reset
|
||||
result = idx_dup.drop_duplicates()
|
||||
tm.assert_index_equal(idx, result)
|
||||
assert idx.freq == result.freq
|
||||
|
||||
def test_drop_duplicates(self):
|
||||
# to check Index/Series compat
|
||||
base = pd.period_range('2011-01-01', '2011-01-31', freq='D',
|
||||
name='idx')
|
||||
idx = base.append(base[:5])
|
||||
|
||||
res = idx.drop_duplicates()
|
||||
tm.assert_index_equal(res, base)
|
||||
res = Series(idx).drop_duplicates()
|
||||
tm.assert_series_equal(res, Series(base))
|
||||
|
||||
res = idx.drop_duplicates(keep='last')
|
||||
exp = base[5:].append(base[:5])
|
||||
tm.assert_index_equal(res, exp)
|
||||
res = Series(idx).drop_duplicates(keep='last')
|
||||
tm.assert_series_equal(res, Series(exp, index=np.arange(5, 36)))
|
||||
|
||||
res = idx.drop_duplicates(keep=False)
|
||||
tm.assert_index_equal(res, base[5:])
|
||||
res = Series(idx).drop_duplicates(keep=False)
|
||||
tm.assert_series_equal(res, Series(base[5:], index=np.arange(5, 31)))
|
||||
|
||||
def test_order_compat(self):
|
||||
def _check_freq(index, expected_index):
|
||||
if isinstance(index, PeriodIndex):
|
||||
assert index.freq == expected_index.freq
|
||||
|
||||
pidx = PeriodIndex(['2011', '2012', '2013'], name='pidx', freq='A')
|
||||
# for compatibility check
|
||||
iidx = Index([2011, 2012, 2013], name='idx')
|
||||
for idx in [pidx, iidx]:
|
||||
ordered = idx.sort_values()
|
||||
tm.assert_index_equal(ordered, idx)
|
||||
_check_freq(ordered, idx)
|
||||
|
||||
ordered = idx.sort_values(ascending=False)
|
||||
tm.assert_index_equal(ordered, idx[::-1])
|
||||
_check_freq(ordered, idx[::-1])
|
||||
|
||||
ordered, indexer = idx.sort_values(return_indexer=True)
|
||||
tm.assert_index_equal(ordered, idx)
|
||||
tm.assert_numpy_array_equal(indexer, np.array([0, 1, 2]),
|
||||
check_dtype=False)
|
||||
_check_freq(ordered, idx)
|
||||
|
||||
ordered, indexer = idx.sort_values(return_indexer=True,
|
||||
ascending=False)
|
||||
tm.assert_index_equal(ordered, idx[::-1])
|
||||
tm.assert_numpy_array_equal(indexer, np.array([2, 1, 0]),
|
||||
check_dtype=False)
|
||||
_check_freq(ordered, idx[::-1])
|
||||
|
||||
pidx = PeriodIndex(['2011', '2013', '2015', '2012',
|
||||
'2011'], name='pidx', freq='A')
|
||||
pexpected = PeriodIndex(
|
||||
['2011', '2011', '2012', '2013', '2015'], name='pidx', freq='A')
|
||||
# for compatibility check
|
||||
iidx = Index([2011, 2013, 2015, 2012, 2011], name='idx')
|
||||
iexpected = Index([2011, 2011, 2012, 2013, 2015], name='idx')
|
||||
for idx, expected in [(pidx, pexpected), (iidx, iexpected)]:
|
||||
ordered = idx.sort_values()
|
||||
tm.assert_index_equal(ordered, expected)
|
||||
_check_freq(ordered, idx)
|
||||
|
||||
ordered = idx.sort_values(ascending=False)
|
||||
tm.assert_index_equal(ordered, expected[::-1])
|
||||
_check_freq(ordered, idx)
|
||||
|
||||
ordered, indexer = idx.sort_values(return_indexer=True)
|
||||
tm.assert_index_equal(ordered, expected)
|
||||
|
||||
exp = np.array([0, 4, 3, 1, 2])
|
||||
tm.assert_numpy_array_equal(indexer, exp, check_dtype=False)
|
||||
_check_freq(ordered, idx)
|
||||
|
||||
ordered, indexer = idx.sort_values(return_indexer=True,
|
||||
ascending=False)
|
||||
tm.assert_index_equal(ordered, expected[::-1])
|
||||
|
||||
exp = np.array([2, 1, 3, 4, 0])
|
||||
tm.assert_numpy_array_equal(indexer, exp, check_dtype=False)
|
||||
_check_freq(ordered, idx)
|
||||
|
||||
pidx = PeriodIndex(['2011', '2013', 'NaT', '2011'], name='pidx',
|
||||
freq='D')
|
||||
|
||||
result = pidx.sort_values()
|
||||
expected = PeriodIndex(['NaT', '2011', '2011', '2013'],
|
||||
name='pidx', freq='D')
|
||||
tm.assert_index_equal(result, expected)
|
||||
assert result.freq == 'D'
|
||||
|
||||
result = pidx.sort_values(ascending=False)
|
||||
expected = PeriodIndex(
|
||||
['2013', '2011', '2011', 'NaT'], name='pidx', freq='D')
|
||||
tm.assert_index_equal(result, expected)
|
||||
assert result.freq == 'D'
|
||||
|
||||
def test_order(self):
|
||||
for freq in ['D', '2D', '4D']:
|
||||
idx = PeriodIndex(['2011-01-01', '2011-01-02', '2011-01-03'],
|
||||
freq=freq, name='idx')
|
||||
|
||||
ordered = idx.sort_values()
|
||||
tm.assert_index_equal(ordered, idx)
|
||||
assert ordered.freq == idx.freq
|
||||
|
||||
ordered = idx.sort_values(ascending=False)
|
||||
expected = idx[::-1]
|
||||
tm.assert_index_equal(ordered, expected)
|
||||
assert ordered.freq == expected.freq
|
||||
assert ordered.freq == freq
|
||||
|
||||
ordered, indexer = idx.sort_values(return_indexer=True)
|
||||
tm.assert_index_equal(ordered, idx)
|
||||
tm.assert_numpy_array_equal(indexer, np.array([0, 1, 2]),
|
||||
check_dtype=False)
|
||||
assert ordered.freq == idx.freq
|
||||
assert ordered.freq == freq
|
||||
|
||||
ordered, indexer = idx.sort_values(return_indexer=True,
|
||||
ascending=False)
|
||||
expected = idx[::-1]
|
||||
tm.assert_index_equal(ordered, expected)
|
||||
tm.assert_numpy_array_equal(indexer, np.array([2, 1, 0]),
|
||||
check_dtype=False)
|
||||
assert ordered.freq == expected.freq
|
||||
assert ordered.freq == freq
|
||||
|
||||
idx1 = PeriodIndex(['2011-01-01', '2011-01-03', '2011-01-05',
|
||||
'2011-01-02', '2011-01-01'], freq='D', name='idx1')
|
||||
exp1 = PeriodIndex(['2011-01-01', '2011-01-01', '2011-01-02',
|
||||
'2011-01-03', '2011-01-05'], freq='D', name='idx1')
|
||||
|
||||
idx2 = PeriodIndex(['2011-01-01', '2011-01-03', '2011-01-05',
|
||||
'2011-01-02', '2011-01-01'],
|
||||
freq='D', name='idx2')
|
||||
exp2 = PeriodIndex(['2011-01-01', '2011-01-01', '2011-01-02',
|
||||
'2011-01-03', '2011-01-05'],
|
||||
freq='D', name='idx2')
|
||||
|
||||
idx3 = PeriodIndex([pd.NaT, '2011-01-03', '2011-01-05',
|
||||
'2011-01-02', pd.NaT], freq='D', name='idx3')
|
||||
exp3 = PeriodIndex([pd.NaT, pd.NaT, '2011-01-02', '2011-01-03',
|
||||
'2011-01-05'], freq='D', name='idx3')
|
||||
|
||||
for idx, expected in [(idx1, exp1), (idx2, exp2), (idx3, exp3)]:
|
||||
ordered = idx.sort_values()
|
||||
tm.assert_index_equal(ordered, expected)
|
||||
assert ordered.freq == 'D'
|
||||
|
||||
ordered = idx.sort_values(ascending=False)
|
||||
tm.assert_index_equal(ordered, expected[::-1])
|
||||
assert ordered.freq == 'D'
|
||||
|
||||
ordered, indexer = idx.sort_values(return_indexer=True)
|
||||
tm.assert_index_equal(ordered, expected)
|
||||
|
||||
exp = np.array([0, 4, 3, 1, 2])
|
||||
tm.assert_numpy_array_equal(indexer, exp, check_dtype=False)
|
||||
assert ordered.freq == 'D'
|
||||
|
||||
ordered, indexer = idx.sort_values(return_indexer=True,
|
||||
ascending=False)
|
||||
tm.assert_index_equal(ordered, expected[::-1])
|
||||
|
||||
exp = np.array([2, 1, 3, 4, 0])
|
||||
tm.assert_numpy_array_equal(indexer, exp, check_dtype=False)
|
||||
assert ordered.freq == 'D'
|
||||
|
||||
def test_nat_new(self):
|
||||
|
||||
idx = pd.period_range('2011-01', freq='M', periods=5, name='x')
|
||||
result = idx._nat_new()
|
||||
exp = pd.PeriodIndex([pd.NaT] * 5, freq='M', name='x')
|
||||
tm.assert_index_equal(result, exp)
|
||||
|
||||
result = idx._nat_new(box=False)
|
||||
exp = np.array([tslib.iNaT] * 5, dtype=np.int64)
|
||||
tm.assert_numpy_array_equal(result, exp)
|
||||
|
||||
def test_shift(self):
|
||||
# This is tested in test_arithmetic
|
||||
pass
|
||||
|
||||
def test_repeat(self):
|
||||
index = pd.period_range('2001-01-01', periods=2, freq='D')
|
||||
exp = pd.PeriodIndex(['2001-01-01', '2001-01-01',
|
||||
'2001-01-02', '2001-01-02'], freq='D')
|
||||
for res in [index.repeat(2), np.repeat(index, 2)]:
|
||||
tm.assert_index_equal(res, exp)
|
||||
|
||||
index = pd.period_range('2001-01-01', periods=2, freq='2D')
|
||||
exp = pd.PeriodIndex(['2001-01-01', '2001-01-01',
|
||||
'2001-01-03', '2001-01-03'], freq='2D')
|
||||
for res in [index.repeat(2), np.repeat(index, 2)]:
|
||||
tm.assert_index_equal(res, exp)
|
||||
|
||||
index = pd.PeriodIndex(['2001-01', 'NaT', '2003-01'], freq='M')
|
||||
exp = pd.PeriodIndex(['2001-01', '2001-01', '2001-01',
|
||||
'NaT', 'NaT', 'NaT',
|
||||
'2003-01', '2003-01', '2003-01'], freq='M')
|
||||
for res in [index.repeat(3), np.repeat(index, 3)]:
|
||||
tm.assert_index_equal(res, exp)
|
||||
|
||||
def test_nat(self):
|
||||
assert pd.PeriodIndex._na_value is pd.NaT
|
||||
assert pd.PeriodIndex([], freq='M')._na_value is pd.NaT
|
||||
|
||||
idx = pd.PeriodIndex(['2011-01-01', '2011-01-02'], freq='D')
|
||||
assert idx._can_hold_na
|
||||
|
||||
tm.assert_numpy_array_equal(idx._isnan, np.array([False, False]))
|
||||
assert not idx.hasnans
|
||||
tm.assert_numpy_array_equal(idx._nan_idxs,
|
||||
np.array([], dtype=np.intp))
|
||||
|
||||
idx = pd.PeriodIndex(['2011-01-01', 'NaT'], freq='D')
|
||||
assert idx._can_hold_na
|
||||
|
||||
tm.assert_numpy_array_equal(idx._isnan, np.array([False, True]))
|
||||
assert idx.hasnans
|
||||
tm.assert_numpy_array_equal(idx._nan_idxs,
|
||||
np.array([1], dtype=np.intp))
|
||||
|
||||
@pytest.mark.parametrize('freq', ['D', 'M'])
|
||||
def test_equals(self, freq):
|
||||
# GH#13107
|
||||
idx = pd.PeriodIndex(['2011-01-01', '2011-01-02', 'NaT'],
|
||||
freq=freq)
|
||||
assert idx.equals(idx)
|
||||
assert idx.equals(idx.copy())
|
||||
assert idx.equals(idx.astype(object))
|
||||
assert idx.astype(object).equals(idx)
|
||||
assert idx.astype(object).equals(idx.astype(object))
|
||||
assert not idx.equals(list(idx))
|
||||
assert not idx.equals(pd.Series(idx))
|
||||
|
||||
idx2 = pd.PeriodIndex(['2011-01-01', '2011-01-02', 'NaT'],
|
||||
freq='H')
|
||||
assert not idx.equals(idx2)
|
||||
assert not idx.equals(idx2.copy())
|
||||
assert not idx.equals(idx2.astype(object))
|
||||
assert not idx.astype(object).equals(idx2)
|
||||
assert not idx.equals(list(idx2))
|
||||
assert not idx.equals(pd.Series(idx2))
|
||||
|
||||
# same internal, different tz
|
||||
idx3 = pd.PeriodIndex._simple_new(idx.asi8, freq='H')
|
||||
tm.assert_numpy_array_equal(idx.asi8, idx3.asi8)
|
||||
assert not idx.equals(idx3)
|
||||
assert not idx.equals(idx3.copy())
|
||||
assert not idx.equals(idx3.astype(object))
|
||||
assert not idx.astype(object).equals(idx3)
|
||||
assert not idx.equals(list(idx3))
|
||||
assert not idx.equals(pd.Series(idx3))
|
||||
|
||||
def test_freq_setter_deprecated(self):
|
||||
# GH 20678
|
||||
idx = pd.period_range('2018Q1', periods=4, freq='Q')
|
||||
|
||||
# no warning for getter
|
||||
with tm.assert_produces_warning(None):
|
||||
idx.freq
|
||||
|
||||
# warning for setter
|
||||
with tm.assert_produces_warning(FutureWarning):
|
||||
idx.freq = pd.offsets.Day()
|
||||
|
||||
|
||||
class TestPeriodIndexSeriesMethods(object):
|
||||
""" Test PeriodIndex and Period Series Ops consistency """
|
||||
|
||||
def _check(self, values, func, expected):
|
||||
idx = pd.PeriodIndex(values)
|
||||
result = func(idx)
|
||||
if isinstance(expected, pd.Index):
|
||||
tm.assert_index_equal(result, expected)
|
||||
else:
|
||||
# comp op results in bool
|
||||
tm.assert_numpy_array_equal(result, expected)
|
||||
|
||||
s = pd.Series(values)
|
||||
result = func(s)
|
||||
|
||||
exp = pd.Series(expected, name=values.name)
|
||||
tm.assert_series_equal(result, exp)
|
||||
|
||||
def test_pi_comp_period(self):
|
||||
idx = PeriodIndex(['2011-01', '2011-02', '2011-03',
|
||||
'2011-04'], freq='M', name='idx')
|
||||
|
||||
f = lambda x: x == pd.Period('2011-03', freq='M')
|
||||
exp = np.array([False, False, True, False], dtype=np.bool)
|
||||
self._check(idx, f, exp)
|
||||
f = lambda x: pd.Period('2011-03', freq='M') == x
|
||||
self._check(idx, f, exp)
|
||||
|
||||
f = lambda x: x != pd.Period('2011-03', freq='M')
|
||||
exp = np.array([True, True, False, True], dtype=np.bool)
|
||||
self._check(idx, f, exp)
|
||||
f = lambda x: pd.Period('2011-03', freq='M') != x
|
||||
self._check(idx, f, exp)
|
||||
|
||||
f = lambda x: pd.Period('2011-03', freq='M') >= x
|
||||
exp = np.array([True, True, True, False], dtype=np.bool)
|
||||
self._check(idx, f, exp)
|
||||
|
||||
f = lambda x: x > pd.Period('2011-03', freq='M')
|
||||
exp = np.array([False, False, False, True], dtype=np.bool)
|
||||
self._check(idx, f, exp)
|
||||
|
||||
f = lambda x: pd.Period('2011-03', freq='M') >= x
|
||||
exp = np.array([True, True, True, False], dtype=np.bool)
|
||||
self._check(idx, f, exp)
|
||||
|
||||
def test_pi_comp_period_nat(self):
|
||||
idx = PeriodIndex(['2011-01', 'NaT', '2011-03',
|
||||
'2011-04'], freq='M', name='idx')
|
||||
|
||||
f = lambda x: x == pd.Period('2011-03', freq='M')
|
||||
exp = np.array([False, False, True, False], dtype=np.bool)
|
||||
self._check(idx, f, exp)
|
||||
f = lambda x: pd.Period('2011-03', freq='M') == x
|
||||
self._check(idx, f, exp)
|
||||
|
||||
f = lambda x: x == tslib.NaT
|
||||
exp = np.array([False, False, False, False], dtype=np.bool)
|
||||
self._check(idx, f, exp)
|
||||
f = lambda x: tslib.NaT == x
|
||||
self._check(idx, f, exp)
|
||||
|
||||
f = lambda x: x != pd.Period('2011-03', freq='M')
|
||||
exp = np.array([True, True, False, True], dtype=np.bool)
|
||||
self._check(idx, f, exp)
|
||||
f = lambda x: pd.Period('2011-03', freq='M') != x
|
||||
self._check(idx, f, exp)
|
||||
|
||||
f = lambda x: x != tslib.NaT
|
||||
exp = np.array([True, True, True, True], dtype=np.bool)
|
||||
self._check(idx, f, exp)
|
||||
f = lambda x: tslib.NaT != x
|
||||
self._check(idx, f, exp)
|
||||
|
||||
f = lambda x: pd.Period('2011-03', freq='M') >= x
|
||||
exp = np.array([True, False, True, False], dtype=np.bool)
|
||||
self._check(idx, f, exp)
|
||||
|
||||
f = lambda x: x < pd.Period('2011-03', freq='M')
|
||||
exp = np.array([True, False, False, False], dtype=np.bool)
|
||||
self._check(idx, f, exp)
|
||||
|
||||
f = lambda x: x > tslib.NaT
|
||||
exp = np.array([False, False, False, False], dtype=np.bool)
|
||||
self._check(idx, f, exp)
|
||||
|
||||
f = lambda x: tslib.NaT >= x
|
||||
exp = np.array([False, False, False, False], dtype=np.bool)
|
||||
self._check(idx, f, exp)
|
||||
-141
@@ -1,141 +0,0 @@
|
||||
import pytest
|
||||
|
||||
import numpy as np
|
||||
|
||||
import pandas as pd
|
||||
from pandas.util import testing as tm
|
||||
from pandas import (Series, period_range, DatetimeIndex, PeriodIndex,
|
||||
DataFrame, _np_version_under1p12, Period)
|
||||
|
||||
|
||||
class TestPeriodIndex(object):
|
||||
|
||||
def setup_method(self, method):
|
||||
pass
|
||||
|
||||
def test_slice_with_negative_step(self):
|
||||
ts = Series(np.arange(20),
|
||||
period_range('2014-01', periods=20, freq='M'))
|
||||
SLC = pd.IndexSlice
|
||||
|
||||
def assert_slices_equivalent(l_slc, i_slc):
|
||||
tm.assert_series_equal(ts[l_slc], ts.iloc[i_slc])
|
||||
tm.assert_series_equal(ts.loc[l_slc], ts.iloc[i_slc])
|
||||
tm.assert_series_equal(ts.loc[l_slc], ts.iloc[i_slc])
|
||||
|
||||
assert_slices_equivalent(SLC[Period('2014-10')::-1], SLC[9::-1])
|
||||
assert_slices_equivalent(SLC['2014-10'::-1], SLC[9::-1])
|
||||
|
||||
assert_slices_equivalent(SLC[:Period('2014-10'):-1], SLC[:8:-1])
|
||||
assert_slices_equivalent(SLC[:'2014-10':-1], SLC[:8:-1])
|
||||
|
||||
assert_slices_equivalent(SLC['2015-02':'2014-10':-1], SLC[13:8:-1])
|
||||
assert_slices_equivalent(SLC[Period('2015-02'):Period('2014-10'):-1],
|
||||
SLC[13:8:-1])
|
||||
assert_slices_equivalent(SLC['2015-02':Period('2014-10'):-1],
|
||||
SLC[13:8:-1])
|
||||
assert_slices_equivalent(SLC[Period('2015-02'):'2014-10':-1],
|
||||
SLC[13:8:-1])
|
||||
|
||||
assert_slices_equivalent(SLC['2014-10':'2015-02':-1], SLC[:0])
|
||||
|
||||
def test_slice_with_zero_step_raises(self):
|
||||
ts = Series(np.arange(20),
|
||||
period_range('2014-01', periods=20, freq='M'))
|
||||
tm.assert_raises_regex(ValueError, 'slice step cannot be zero',
|
||||
lambda: ts[::0])
|
||||
tm.assert_raises_regex(ValueError, 'slice step cannot be zero',
|
||||
lambda: ts.loc[::0])
|
||||
tm.assert_raises_regex(ValueError, 'slice step cannot be zero',
|
||||
lambda: ts.loc[::0])
|
||||
|
||||
def test_slice_keep_name(self):
|
||||
idx = period_range('20010101', periods=10, freq='D', name='bob')
|
||||
assert idx.name == idx[1:].name
|
||||
|
||||
def test_pindex_slice_index(self):
|
||||
pi = PeriodIndex(start='1/1/10', end='12/31/12', freq='M')
|
||||
s = Series(np.random.rand(len(pi)), index=pi)
|
||||
res = s['2010']
|
||||
exp = s[0:12]
|
||||
tm.assert_series_equal(res, exp)
|
||||
res = s['2011']
|
||||
exp = s[12:24]
|
||||
tm.assert_series_equal(res, exp)
|
||||
|
||||
def test_range_slice_day(self):
|
||||
# GH 6716
|
||||
didx = DatetimeIndex(start='2013/01/01', freq='D', periods=400)
|
||||
pidx = PeriodIndex(start='2013/01/01', freq='D', periods=400)
|
||||
|
||||
# changed to TypeError in 1.12
|
||||
# https://github.com/numpy/numpy/pull/6271
|
||||
exc = IndexError if _np_version_under1p12 else TypeError
|
||||
|
||||
for idx in [didx, pidx]:
|
||||
# slices against index should raise IndexError
|
||||
values = ['2014', '2013/02', '2013/01/02', '2013/02/01 9H',
|
||||
'2013/02/01 09:00']
|
||||
for v in values:
|
||||
with pytest.raises(exc):
|
||||
idx[v:]
|
||||
|
||||
s = Series(np.random.rand(len(idx)), index=idx)
|
||||
|
||||
tm.assert_series_equal(s['2013/01/02':], s[1:])
|
||||
tm.assert_series_equal(s['2013/01/02':'2013/01/05'], s[1:5])
|
||||
tm.assert_series_equal(s['2013/02':], s[31:])
|
||||
tm.assert_series_equal(s['2014':], s[365:])
|
||||
|
||||
invalid = ['2013/02/01 9H', '2013/02/01 09:00']
|
||||
for v in invalid:
|
||||
with pytest.raises(exc):
|
||||
idx[v:]
|
||||
|
||||
def test_range_slice_seconds(self):
|
||||
# GH 6716
|
||||
didx = DatetimeIndex(start='2013/01/01 09:00:00', freq='S',
|
||||
periods=4000)
|
||||
pidx = PeriodIndex(start='2013/01/01 09:00:00', freq='S', periods=4000)
|
||||
|
||||
# changed to TypeError in 1.12
|
||||
# https://github.com/numpy/numpy/pull/6271
|
||||
exc = IndexError if _np_version_under1p12 else TypeError
|
||||
|
||||
for idx in [didx, pidx]:
|
||||
# slices against index should raise IndexError
|
||||
values = ['2014', '2013/02', '2013/01/02', '2013/02/01 9H',
|
||||
'2013/02/01 09:00']
|
||||
for v in values:
|
||||
with pytest.raises(exc):
|
||||
idx[v:]
|
||||
|
||||
s = Series(np.random.rand(len(idx)), index=idx)
|
||||
|
||||
tm.assert_series_equal(s['2013/01/01 09:05':'2013/01/01 09:10'],
|
||||
s[300:660])
|
||||
tm.assert_series_equal(s['2013/01/01 10:00':'2013/01/01 10:05'],
|
||||
s[3600:3960])
|
||||
tm.assert_series_equal(s['2013/01/01 10H':], s[3600:])
|
||||
tm.assert_series_equal(s[:'2013/01/01 09:30'], s[:1860])
|
||||
for d in ['2013/01/01', '2013/01', '2013']:
|
||||
tm.assert_series_equal(s[d:], s)
|
||||
|
||||
def test_range_slice_outofbounds(self):
|
||||
# GH 5407
|
||||
didx = DatetimeIndex(start='2013/10/01', freq='D', periods=10)
|
||||
pidx = PeriodIndex(start='2013/10/01', freq='D', periods=10)
|
||||
|
||||
for idx in [didx, pidx]:
|
||||
df = DataFrame(dict(units=[100 + i for i in range(10)]), index=idx)
|
||||
empty = DataFrame(index=idx.__class__([], freq='D'),
|
||||
columns=['units'])
|
||||
empty['units'] = empty['units'].astype('int64')
|
||||
|
||||
tm.assert_frame_equal(df['2013/09/01':'2013/09/30'], empty)
|
||||
tm.assert_frame_equal(df['2013/09/30':'2013/10/02'], df.iloc[:2])
|
||||
tm.assert_frame_equal(df['2013/10/01':'2013/10/02'], df.iloc[:2])
|
||||
tm.assert_frame_equal(df['2013/10/02':'2013/09/30'], empty)
|
||||
tm.assert_frame_equal(df['2013/10/15':'2013/10/17'], empty)
|
||||
tm.assert_frame_equal(df['2013-06':'2013-09'], empty)
|
||||
tm.assert_frame_equal(df['2013-11':'2013-12'], empty)
|
||||
@@ -1,546 +0,0 @@
|
||||
import pytest
|
||||
|
||||
import numpy as np
|
||||
|
||||
import pandas as pd
|
||||
import pandas.util._test_decorators as td
|
||||
from pandas.util import testing as tm
|
||||
from pandas import (PeriodIndex, period_range, DatetimeIndex, NaT,
|
||||
Index, Period, Series, DataFrame, date_range,
|
||||
offsets)
|
||||
|
||||
from ..datetimelike import DatetimeLike
|
||||
|
||||
|
||||
class TestPeriodIndex(DatetimeLike):
|
||||
_holder = PeriodIndex
|
||||
|
||||
def setup_method(self, method):
|
||||
self.indices = dict(index=tm.makePeriodIndex(10),
|
||||
index_dec=period_range('20130101', periods=10,
|
||||
freq='D')[::-1])
|
||||
self.setup_indices()
|
||||
|
||||
def create_index(self):
|
||||
return period_range('20130101', periods=5, freq='D')
|
||||
|
||||
def test_pickle_compat_construction(self):
|
||||
pass
|
||||
|
||||
@pytest.mark.parametrize('freq', ['D', 'M', 'A'])
|
||||
def test_pickle_round_trip(self, freq):
|
||||
idx = PeriodIndex(['2016-05-16', 'NaT', NaT, np.NaN], freq=freq)
|
||||
result = tm.round_trip_pickle(idx)
|
||||
tm.assert_index_equal(result, idx)
|
||||
|
||||
def test_where(self):
|
||||
# This is handled in test_indexing
|
||||
pass
|
||||
|
||||
def test_repeat(self):
|
||||
# GH10183
|
||||
idx = pd.period_range('2000-01-01', periods=3, freq='D')
|
||||
res = idx.repeat(3)
|
||||
exp = PeriodIndex(idx.values.repeat(3), freq='D')
|
||||
tm.assert_index_equal(res, exp)
|
||||
assert res.freqstr == 'D'
|
||||
|
||||
def test_fillna_period(self):
|
||||
# GH 11343
|
||||
idx = pd.PeriodIndex(['2011-01-01 09:00', pd.NaT,
|
||||
'2011-01-01 11:00'], freq='H')
|
||||
|
||||
exp = pd.PeriodIndex(['2011-01-01 09:00', '2011-01-01 10:00',
|
||||
'2011-01-01 11:00'], freq='H')
|
||||
tm.assert_index_equal(
|
||||
idx.fillna(pd.Period('2011-01-01 10:00', freq='H')), exp)
|
||||
|
||||
exp = pd.Index([pd.Period('2011-01-01 09:00', freq='H'), 'x',
|
||||
pd.Period('2011-01-01 11:00', freq='H')], dtype=object)
|
||||
tm.assert_index_equal(idx.fillna('x'), exp)
|
||||
|
||||
exp = pd.Index([pd.Period('2011-01-01 09:00', freq='H'),
|
||||
pd.Period('2011-01-01', freq='D'),
|
||||
pd.Period('2011-01-01 11:00', freq='H')], dtype=object)
|
||||
tm.assert_index_equal(idx.fillna(
|
||||
pd.Period('2011-01-01', freq='D')), exp)
|
||||
|
||||
def test_no_millisecond_field(self):
|
||||
with pytest.raises(AttributeError):
|
||||
DatetimeIndex.millisecond
|
||||
|
||||
with pytest.raises(AttributeError):
|
||||
DatetimeIndex([]).millisecond
|
||||
|
||||
def test_difference_freq(self):
|
||||
# GH14323: difference of Period MUST preserve frequency
|
||||
# but the ability to union results must be preserved
|
||||
|
||||
index = period_range("20160920", "20160925", freq="D")
|
||||
|
||||
other = period_range("20160921", "20160924", freq="D")
|
||||
expected = PeriodIndex(["20160920", "20160925"], freq='D')
|
||||
idx_diff = index.difference(other)
|
||||
tm.assert_index_equal(idx_diff, expected)
|
||||
tm.assert_attr_equal('freq', idx_diff, expected)
|
||||
|
||||
other = period_range("20160922", "20160925", freq="D")
|
||||
idx_diff = index.difference(other)
|
||||
expected = PeriodIndex(["20160920", "20160921"], freq='D')
|
||||
tm.assert_index_equal(idx_diff, expected)
|
||||
tm.assert_attr_equal('freq', idx_diff, expected)
|
||||
|
||||
def test_hash_error(self):
|
||||
index = period_range('20010101', periods=10)
|
||||
with tm.assert_raises_regex(TypeError, "unhashable type: %r" %
|
||||
type(index).__name__):
|
||||
hash(index)
|
||||
|
||||
def test_make_time_series(self):
|
||||
index = PeriodIndex(freq='A', start='1/1/2001', end='12/1/2009')
|
||||
series = Series(1, index=index)
|
||||
assert isinstance(series, Series)
|
||||
|
||||
def test_shallow_copy_empty(self):
|
||||
|
||||
# GH13067
|
||||
idx = PeriodIndex([], freq='M')
|
||||
result = idx._shallow_copy()
|
||||
expected = idx
|
||||
|
||||
tm.assert_index_equal(result, expected)
|
||||
|
||||
def test_dtype_str(self):
|
||||
pi = pd.PeriodIndex([], freq='M')
|
||||
assert pi.dtype_str == 'period[M]'
|
||||
assert pi.dtype_str == str(pi.dtype)
|
||||
|
||||
pi = pd.PeriodIndex([], freq='3M')
|
||||
assert pi.dtype_str == 'period[3M]'
|
||||
assert pi.dtype_str == str(pi.dtype)
|
||||
|
||||
def test_view_asi8(self):
|
||||
idx = pd.PeriodIndex([], freq='M')
|
||||
|
||||
exp = np.array([], dtype=np.int64)
|
||||
tm.assert_numpy_array_equal(idx.view('i8'), exp)
|
||||
tm.assert_numpy_array_equal(idx.asi8, exp)
|
||||
|
||||
idx = pd.PeriodIndex(['2011-01', pd.NaT], freq='M')
|
||||
|
||||
exp = np.array([492, -9223372036854775808], dtype=np.int64)
|
||||
tm.assert_numpy_array_equal(idx.view('i8'), exp)
|
||||
tm.assert_numpy_array_equal(idx.asi8, exp)
|
||||
|
||||
exp = np.array([14975, -9223372036854775808], dtype=np.int64)
|
||||
idx = pd.PeriodIndex(['2011-01-01', pd.NaT], freq='D')
|
||||
tm.assert_numpy_array_equal(idx.view('i8'), exp)
|
||||
tm.assert_numpy_array_equal(idx.asi8, exp)
|
||||
|
||||
def test_values(self):
|
||||
idx = pd.PeriodIndex([], freq='M')
|
||||
|
||||
exp = np.array([], dtype=np.object)
|
||||
tm.assert_numpy_array_equal(idx.values, exp)
|
||||
tm.assert_numpy_array_equal(idx.get_values(), exp)
|
||||
exp = np.array([], dtype=np.int64)
|
||||
tm.assert_numpy_array_equal(idx._ndarray_values, exp)
|
||||
|
||||
idx = pd.PeriodIndex(['2011-01', pd.NaT], freq='M')
|
||||
|
||||
exp = np.array([pd.Period('2011-01', freq='M'), pd.NaT], dtype=object)
|
||||
tm.assert_numpy_array_equal(idx.values, exp)
|
||||
tm.assert_numpy_array_equal(idx.get_values(), exp)
|
||||
exp = np.array([492, -9223372036854775808], dtype=np.int64)
|
||||
tm.assert_numpy_array_equal(idx._ndarray_values, exp)
|
||||
|
||||
idx = pd.PeriodIndex(['2011-01-01', pd.NaT], freq='D')
|
||||
|
||||
exp = np.array([pd.Period('2011-01-01', freq='D'), pd.NaT],
|
||||
dtype=object)
|
||||
tm.assert_numpy_array_equal(idx.values, exp)
|
||||
tm.assert_numpy_array_equal(idx.get_values(), exp)
|
||||
exp = np.array([14975, -9223372036854775808], dtype=np.int64)
|
||||
tm.assert_numpy_array_equal(idx._ndarray_values, exp)
|
||||
|
||||
def test_period_index_length(self):
|
||||
pi = PeriodIndex(freq='A', start='1/1/2001', end='12/1/2009')
|
||||
assert len(pi) == 9
|
||||
|
||||
pi = PeriodIndex(freq='Q', start='1/1/2001', end='12/1/2009')
|
||||
assert len(pi) == 4 * 9
|
||||
|
||||
pi = PeriodIndex(freq='M', start='1/1/2001', end='12/1/2009')
|
||||
assert len(pi) == 12 * 9
|
||||
|
||||
start = Period('02-Apr-2005', 'B')
|
||||
i1 = PeriodIndex(start=start, periods=20)
|
||||
assert len(i1) == 20
|
||||
assert i1.freq == start.freq
|
||||
assert i1[0] == start
|
||||
|
||||
end_intv = Period('2006-12-31', 'W')
|
||||
i1 = PeriodIndex(end=end_intv, periods=10)
|
||||
assert len(i1) == 10
|
||||
assert i1.freq == end_intv.freq
|
||||
assert i1[-1] == end_intv
|
||||
|
||||
end_intv = Period('2006-12-31', '1w')
|
||||
i2 = PeriodIndex(end=end_intv, periods=10)
|
||||
assert len(i1) == len(i2)
|
||||
assert (i1 == i2).all()
|
||||
assert i1.freq == i2.freq
|
||||
|
||||
end_intv = Period('2006-12-31', ('w', 1))
|
||||
i2 = PeriodIndex(end=end_intv, periods=10)
|
||||
assert len(i1) == len(i2)
|
||||
assert (i1 == i2).all()
|
||||
assert i1.freq == i2.freq
|
||||
|
||||
try:
|
||||
PeriodIndex(start=start, end=end_intv)
|
||||
raise AssertionError('Cannot allow mixed freq for start and end')
|
||||
except ValueError:
|
||||
pass
|
||||
|
||||
end_intv = Period('2005-05-01', 'B')
|
||||
i1 = PeriodIndex(start=start, end=end_intv)
|
||||
|
||||
try:
|
||||
PeriodIndex(start=start)
|
||||
raise AssertionError(
|
||||
'Must specify periods if missing start or end')
|
||||
except ValueError:
|
||||
pass
|
||||
|
||||
# infer freq from first element
|
||||
i2 = PeriodIndex([end_intv, Period('2005-05-05', 'B')])
|
||||
assert len(i2) == 2
|
||||
assert i2[0] == end_intv
|
||||
|
||||
i2 = PeriodIndex(np.array([end_intv, Period('2005-05-05', 'B')]))
|
||||
assert len(i2) == 2
|
||||
assert i2[0] == end_intv
|
||||
|
||||
# Mixed freq should fail
|
||||
vals = [end_intv, Period('2006-12-31', 'w')]
|
||||
pytest.raises(ValueError, PeriodIndex, vals)
|
||||
vals = np.array(vals)
|
||||
pytest.raises(ValueError, PeriodIndex, vals)
|
||||
|
||||
def test_fields(self):
|
||||
# year, month, day, hour, minute
|
||||
# second, weekofyear, week, dayofweek, weekday, dayofyear, quarter
|
||||
# qyear
|
||||
pi = PeriodIndex(freq='A', start='1/1/2001', end='12/1/2005')
|
||||
self._check_all_fields(pi)
|
||||
|
||||
pi = PeriodIndex(freq='Q', start='1/1/2001', end='12/1/2002')
|
||||
self._check_all_fields(pi)
|
||||
|
||||
pi = PeriodIndex(freq='M', start='1/1/2001', end='1/1/2002')
|
||||
self._check_all_fields(pi)
|
||||
|
||||
pi = PeriodIndex(freq='D', start='12/1/2001', end='6/1/2001')
|
||||
self._check_all_fields(pi)
|
||||
|
||||
pi = PeriodIndex(freq='B', start='12/1/2001', end='6/1/2001')
|
||||
self._check_all_fields(pi)
|
||||
|
||||
pi = PeriodIndex(freq='H', start='12/31/2001', end='1/1/2002 23:00')
|
||||
self._check_all_fields(pi)
|
||||
|
||||
pi = PeriodIndex(freq='Min', start='12/31/2001', end='1/1/2002 00:20')
|
||||
self._check_all_fields(pi)
|
||||
|
||||
pi = PeriodIndex(freq='S', start='12/31/2001 00:00:00',
|
||||
end='12/31/2001 00:05:00')
|
||||
self._check_all_fields(pi)
|
||||
|
||||
end_intv = Period('2006-12-31', 'W')
|
||||
i1 = PeriodIndex(end=end_intv, periods=10)
|
||||
self._check_all_fields(i1)
|
||||
|
||||
def _check_all_fields(self, periodindex):
|
||||
fields = ['year', 'month', 'day', 'hour', 'minute', 'second',
|
||||
'weekofyear', 'week', 'dayofweek', 'dayofyear',
|
||||
'quarter', 'qyear', 'days_in_month']
|
||||
|
||||
periods = list(periodindex)
|
||||
s = pd.Series(periodindex)
|
||||
|
||||
for field in fields:
|
||||
field_idx = getattr(periodindex, field)
|
||||
assert len(periodindex) == len(field_idx)
|
||||
for x, val in zip(periods, field_idx):
|
||||
assert getattr(x, field) == val
|
||||
|
||||
if len(s) == 0:
|
||||
continue
|
||||
|
||||
field_s = getattr(s.dt, field)
|
||||
assert len(periodindex) == len(field_s)
|
||||
for x, val in zip(periods, field_s):
|
||||
assert getattr(x, field) == val
|
||||
|
||||
def test_period_set_index_reindex(self):
|
||||
# GH 6631
|
||||
df = DataFrame(np.random.random(6))
|
||||
idx1 = period_range('2011/01/01', periods=6, freq='M')
|
||||
idx2 = period_range('2013', periods=6, freq='A')
|
||||
|
||||
df = df.set_index(idx1)
|
||||
tm.assert_index_equal(df.index, idx1)
|
||||
df = df.set_index(idx2)
|
||||
tm.assert_index_equal(df.index, idx2)
|
||||
|
||||
def test_factorize(self):
|
||||
idx1 = PeriodIndex(['2014-01', '2014-01', '2014-02', '2014-02',
|
||||
'2014-03', '2014-03'], freq='M')
|
||||
|
||||
exp_arr = np.array([0, 0, 1, 1, 2, 2], dtype=np.intp)
|
||||
exp_idx = PeriodIndex(['2014-01', '2014-02', '2014-03'], freq='M')
|
||||
|
||||
arr, idx = idx1.factorize()
|
||||
tm.assert_numpy_array_equal(arr, exp_arr)
|
||||
tm.assert_index_equal(idx, exp_idx)
|
||||
|
||||
arr, idx = idx1.factorize(sort=True)
|
||||
tm.assert_numpy_array_equal(arr, exp_arr)
|
||||
tm.assert_index_equal(idx, exp_idx)
|
||||
|
||||
idx2 = pd.PeriodIndex(['2014-03', '2014-03', '2014-02', '2014-01',
|
||||
'2014-03', '2014-01'], freq='M')
|
||||
|
||||
exp_arr = np.array([2, 2, 1, 0, 2, 0], dtype=np.intp)
|
||||
arr, idx = idx2.factorize(sort=True)
|
||||
tm.assert_numpy_array_equal(arr, exp_arr)
|
||||
tm.assert_index_equal(idx, exp_idx)
|
||||
|
||||
exp_arr = np.array([0, 0, 1, 2, 0, 2], dtype=np.intp)
|
||||
exp_idx = PeriodIndex(['2014-03', '2014-02', '2014-01'], freq='M')
|
||||
arr, idx = idx2.factorize()
|
||||
tm.assert_numpy_array_equal(arr, exp_arr)
|
||||
tm.assert_index_equal(idx, exp_idx)
|
||||
|
||||
def test_is_(self):
|
||||
create_index = lambda: PeriodIndex(freq='A', start='1/1/2001',
|
||||
end='12/1/2009')
|
||||
index = create_index()
|
||||
assert index.is_(index)
|
||||
assert not index.is_(create_index())
|
||||
assert index.is_(index.view())
|
||||
assert index.is_(index.view().view().view().view().view())
|
||||
assert index.view().is_(index)
|
||||
ind2 = index.view()
|
||||
index.name = "Apple"
|
||||
assert ind2.is_(index)
|
||||
assert not index.is_(index[:])
|
||||
assert not index.is_(index.asfreq('M'))
|
||||
assert not index.is_(index.asfreq('A'))
|
||||
assert not index.is_(index - 2)
|
||||
assert not index.is_(index - 0)
|
||||
|
||||
def test_contains(self):
|
||||
rng = period_range('2007-01', freq='M', periods=10)
|
||||
|
||||
assert Period('2007-01', freq='M') in rng
|
||||
assert not Period('2007-01', freq='D') in rng
|
||||
assert not Period('2007-01', freq='2M') in rng
|
||||
|
||||
def test_contains_nat(self):
|
||||
# see gh-13582
|
||||
idx = period_range('2007-01', freq='M', periods=10)
|
||||
assert pd.NaT not in idx
|
||||
assert None not in idx
|
||||
assert float('nan') not in idx
|
||||
assert np.nan not in idx
|
||||
|
||||
idx = pd.PeriodIndex(['2011-01', 'NaT', '2011-02'], freq='M')
|
||||
assert pd.NaT in idx
|
||||
assert None in idx
|
||||
assert float('nan') in idx
|
||||
assert np.nan in idx
|
||||
|
||||
def test_periods_number_check(self):
|
||||
with pytest.raises(ValueError):
|
||||
period_range('2011-1-1', '2012-1-1', 'B')
|
||||
|
||||
def test_index_duplicate_periods(self):
|
||||
# monotonic
|
||||
idx = PeriodIndex([2000, 2007, 2007, 2009, 2009], freq='A-JUN')
|
||||
ts = Series(np.random.randn(len(idx)), index=idx)
|
||||
|
||||
result = ts[2007]
|
||||
expected = ts[1:3]
|
||||
tm.assert_series_equal(result, expected)
|
||||
result[:] = 1
|
||||
assert (ts[1:3] == 1).all()
|
||||
|
||||
# not monotonic
|
||||
idx = PeriodIndex([2000, 2007, 2007, 2009, 2007], freq='A-JUN')
|
||||
ts = Series(np.random.randn(len(idx)), index=idx)
|
||||
|
||||
result = ts[2007]
|
||||
expected = ts[idx == 2007]
|
||||
tm.assert_series_equal(result, expected)
|
||||
|
||||
def test_index_unique(self):
|
||||
idx = PeriodIndex([2000, 2007, 2007, 2009, 2009], freq='A-JUN')
|
||||
expected = PeriodIndex([2000, 2007, 2009], freq='A-JUN')
|
||||
tm.assert_index_equal(idx.unique(), expected)
|
||||
assert idx.nunique() == 3
|
||||
|
||||
idx = PeriodIndex([2000, 2007, 2007, 2009, 2007], freq='A-JUN',
|
||||
tz='US/Eastern')
|
||||
expected = PeriodIndex([2000, 2007, 2009], freq='A-JUN',
|
||||
tz='US/Eastern')
|
||||
tm.assert_index_equal(idx.unique(), expected)
|
||||
assert idx.nunique() == 3
|
||||
|
||||
def test_shift(self):
|
||||
# This is tested in test_arithmetic
|
||||
pass
|
||||
|
||||
@td.skip_if_32bit
|
||||
def test_ndarray_compat_properties(self):
|
||||
super(TestPeriodIndex, self).test_ndarray_compat_properties()
|
||||
|
||||
def test_negative_ordinals(self):
|
||||
Period(ordinal=-1000, freq='A')
|
||||
Period(ordinal=0, freq='A')
|
||||
|
||||
idx1 = PeriodIndex(ordinal=[-1, 0, 1], freq='A')
|
||||
idx2 = PeriodIndex(ordinal=np.array([-1, 0, 1]), freq='A')
|
||||
tm.assert_index_equal(idx1, idx2)
|
||||
|
||||
def test_pindex_fieldaccessor_nat(self):
|
||||
idx = PeriodIndex(['2011-01', '2011-02', 'NaT',
|
||||
'2012-03', '2012-04'], freq='D', name='name')
|
||||
|
||||
exp = Index([2011, 2011, -1, 2012, 2012], dtype=np.int64, name='name')
|
||||
tm.assert_index_equal(idx.year, exp)
|
||||
exp = Index([1, 2, -1, 3, 4], dtype=np.int64, name='name')
|
||||
tm.assert_index_equal(idx.month, exp)
|
||||
|
||||
def test_pindex_qaccess(self):
|
||||
pi = PeriodIndex(['2Q05', '3Q05', '4Q05', '1Q06', '2Q06'], freq='Q')
|
||||
s = Series(np.random.rand(len(pi)), index=pi).cumsum()
|
||||
# Todo: fix these accessors!
|
||||
assert s['05Q4'] == s[2]
|
||||
|
||||
def test_numpy_repeat(self):
|
||||
index = period_range('20010101', periods=2)
|
||||
expected = PeriodIndex([Period('2001-01-01'), Period('2001-01-01'),
|
||||
Period('2001-01-02'), Period('2001-01-02')])
|
||||
|
||||
tm.assert_index_equal(np.repeat(index, 2), expected)
|
||||
|
||||
msg = "the 'axis' parameter is not supported"
|
||||
tm.assert_raises_regex(
|
||||
ValueError, msg, np.repeat, index, 2, axis=1)
|
||||
|
||||
def test_pindex_multiples(self):
|
||||
pi = PeriodIndex(start='1/1/11', end='12/31/11', freq='2M')
|
||||
expected = PeriodIndex(['2011-01', '2011-03', '2011-05', '2011-07',
|
||||
'2011-09', '2011-11'], freq='2M')
|
||||
tm.assert_index_equal(pi, expected)
|
||||
assert pi.freq == offsets.MonthEnd(2)
|
||||
assert pi.freqstr == '2M'
|
||||
|
||||
pi = period_range(start='1/1/11', end='12/31/11', freq='2M')
|
||||
tm.assert_index_equal(pi, expected)
|
||||
assert pi.freq == offsets.MonthEnd(2)
|
||||
assert pi.freqstr == '2M'
|
||||
|
||||
pi = period_range(start='1/1/11', periods=6, freq='2M')
|
||||
tm.assert_index_equal(pi, expected)
|
||||
assert pi.freq == offsets.MonthEnd(2)
|
||||
assert pi.freqstr == '2M'
|
||||
|
||||
def test_iteration(self):
|
||||
index = PeriodIndex(start='1/1/10', periods=4, freq='B')
|
||||
|
||||
result = list(index)
|
||||
assert isinstance(result[0], Period)
|
||||
assert result[0].freq == index.freq
|
||||
|
||||
def test_is_full(self):
|
||||
index = PeriodIndex([2005, 2007, 2009], freq='A')
|
||||
assert not index.is_full
|
||||
|
||||
index = PeriodIndex([2005, 2006, 2007], freq='A')
|
||||
assert index.is_full
|
||||
|
||||
index = PeriodIndex([2005, 2005, 2007], freq='A')
|
||||
assert not index.is_full
|
||||
|
||||
index = PeriodIndex([2005, 2005, 2006], freq='A')
|
||||
assert index.is_full
|
||||
|
||||
index = PeriodIndex([2006, 2005, 2005], freq='A')
|
||||
pytest.raises(ValueError, getattr, index, 'is_full')
|
||||
|
||||
assert index[:0].is_full
|
||||
|
||||
def test_with_multi_index(self):
|
||||
# #1705
|
||||
index = date_range('1/1/2012', periods=4, freq='12H')
|
||||
index_as_arrays = [index.to_period(freq='D'), index.hour]
|
||||
|
||||
s = Series([0, 1, 2, 3], index_as_arrays)
|
||||
|
||||
assert isinstance(s.index.levels[0], PeriodIndex)
|
||||
|
||||
assert isinstance(s.index.values[0][0], Period)
|
||||
|
||||
def test_convert_array_of_periods(self):
|
||||
rng = period_range('1/1/2000', periods=20, freq='D')
|
||||
periods = list(rng)
|
||||
|
||||
result = pd.Index(periods)
|
||||
assert isinstance(result, PeriodIndex)
|
||||
|
||||
def test_append_concat(self):
|
||||
# #1815
|
||||
d1 = date_range('12/31/1990', '12/31/1999', freq='A-DEC')
|
||||
d2 = date_range('12/31/2000', '12/31/2009', freq='A-DEC')
|
||||
|
||||
s1 = Series(np.random.randn(10), d1)
|
||||
s2 = Series(np.random.randn(10), d2)
|
||||
|
||||
s1 = s1.to_period()
|
||||
s2 = s2.to_period()
|
||||
|
||||
# drops index
|
||||
result = pd.concat([s1, s2])
|
||||
assert isinstance(result.index, PeriodIndex)
|
||||
assert result.index[0] == s1.index[0]
|
||||
|
||||
def test_pickle_freq(self):
|
||||
# GH2891
|
||||
prng = period_range('1/1/2011', '1/1/2012', freq='M')
|
||||
new_prng = tm.round_trip_pickle(prng)
|
||||
assert new_prng.freq == offsets.MonthEnd()
|
||||
assert new_prng.freqstr == 'M'
|
||||
|
||||
def test_map(self):
|
||||
# test_map_dictlike generally tests
|
||||
|
||||
index = PeriodIndex([2005, 2007, 2009], freq='A')
|
||||
result = index.map(lambda x: x.ordinal)
|
||||
exp = Index([x.ordinal for x in index])
|
||||
tm.assert_index_equal(result, exp)
|
||||
|
||||
def test_join_self(self, join_type):
|
||||
index = period_range('1/1/2000', periods=10)
|
||||
joined = index.join(index, how=join_type)
|
||||
assert index is joined
|
||||
|
||||
def test_insert(self):
|
||||
# GH 18295 (test missing)
|
||||
expected = PeriodIndex(
|
||||
['2017Q1', pd.NaT, '2017Q2', '2017Q3', '2017Q4'], freq='Q')
|
||||
for na in (np.nan, pd.NaT, None):
|
||||
result = period_range('2017Q1', periods=4, freq='Q').insert(1, na)
|
||||
tm.assert_index_equal(result, expected)
|
||||
-94
@@ -1,94 +0,0 @@
|
||||
import pytest
|
||||
import pandas.util.testing as tm
|
||||
from pandas import date_range, NaT, period_range, Period, PeriodIndex
|
||||
|
||||
|
||||
class TestPeriodRange(object):
|
||||
|
||||
@pytest.mark.parametrize('freq', ['D', 'W', 'M', 'Q', 'A'])
|
||||
def test_construction_from_string(self, freq):
|
||||
# non-empty
|
||||
expected = date_range(start='2017-01-01', periods=5,
|
||||
freq=freq, name='foo').to_period()
|
||||
start, end = str(expected[0]), str(expected[-1])
|
||||
|
||||
result = period_range(start=start, end=end, freq=freq, name='foo')
|
||||
tm.assert_index_equal(result, expected)
|
||||
|
||||
result = period_range(start=start, periods=5, freq=freq, name='foo')
|
||||
tm.assert_index_equal(result, expected)
|
||||
|
||||
result = period_range(end=end, periods=5, freq=freq, name='foo')
|
||||
tm.assert_index_equal(result, expected)
|
||||
|
||||
# empty
|
||||
expected = PeriodIndex([], freq=freq, name='foo')
|
||||
|
||||
result = period_range(start=start, periods=0, freq=freq, name='foo')
|
||||
tm.assert_index_equal(result, expected)
|
||||
|
||||
result = period_range(end=end, periods=0, freq=freq, name='foo')
|
||||
tm.assert_index_equal(result, expected)
|
||||
|
||||
result = period_range(start=end, end=start, freq=freq, name='foo')
|
||||
tm.assert_index_equal(result, expected)
|
||||
|
||||
def test_construction_from_period(self):
|
||||
# upsampling
|
||||
start, end = Period('2017Q1', freq='Q'), Period('2018Q1', freq='Q')
|
||||
expected = date_range(start='2017-03-31', end='2018-03-31', freq='M',
|
||||
name='foo').to_period()
|
||||
result = period_range(start=start, end=end, freq='M', name='foo')
|
||||
tm.assert_index_equal(result, expected)
|
||||
|
||||
# downsampling
|
||||
start, end = Period('2017-1', freq='M'), Period('2019-12', freq='M')
|
||||
expected = date_range(start='2017-01-31', end='2019-12-31', freq='Q',
|
||||
name='foo').to_period()
|
||||
result = period_range(start=start, end=end, freq='Q', name='foo')
|
||||
tm.assert_index_equal(result, expected)
|
||||
|
||||
# empty
|
||||
expected = PeriodIndex([], freq='W', name='foo')
|
||||
|
||||
result = period_range(start=start, periods=0, freq='W', name='foo')
|
||||
tm.assert_index_equal(result, expected)
|
||||
|
||||
result = period_range(end=end, periods=0, freq='W', name='foo')
|
||||
tm.assert_index_equal(result, expected)
|
||||
|
||||
result = period_range(start=end, end=start, freq='W', name='foo')
|
||||
tm.assert_index_equal(result, expected)
|
||||
|
||||
def test_errors(self):
|
||||
# not enough params
|
||||
msg = ('Of the three parameters: start, end, and periods, '
|
||||
'exactly two must be specified')
|
||||
with tm.assert_raises_regex(ValueError, msg):
|
||||
period_range(start='2017Q1')
|
||||
|
||||
with tm.assert_raises_regex(ValueError, msg):
|
||||
period_range(end='2017Q1')
|
||||
|
||||
with tm.assert_raises_regex(ValueError, msg):
|
||||
period_range(periods=5)
|
||||
|
||||
with tm.assert_raises_regex(ValueError, msg):
|
||||
period_range()
|
||||
|
||||
# too many params
|
||||
with tm.assert_raises_regex(ValueError, msg):
|
||||
period_range(start='2017Q1', end='2018Q1', periods=8, freq='Q')
|
||||
|
||||
# start/end NaT
|
||||
msg = 'start and end must not be NaT'
|
||||
with tm.assert_raises_regex(ValueError, msg):
|
||||
period_range(start=NaT, end='2018Q1')
|
||||
|
||||
with tm.assert_raises_regex(ValueError, msg):
|
||||
period_range(start='2017Q1', end=NaT)
|
||||
|
||||
# invalid periods param
|
||||
msg = 'periods must be a number, got foo'
|
||||
with tm.assert_raises_regex(TypeError, msg):
|
||||
period_range(start='2017Q1', periods='foo')
|
||||
-17
@@ -1,17 +0,0 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
"""Tests for PeriodIndex behaving like a vectorized Period scalar"""
|
||||
|
||||
from pandas import PeriodIndex, date_range
|
||||
import pandas.util.testing as tm
|
||||
|
||||
|
||||
class TestPeriodIndexOps(object):
|
||||
def test_start_time(self):
|
||||
index = PeriodIndex(freq='M', start='2016-01-01', end='2016-05-31')
|
||||
expected_index = date_range('2016-01-01', end='2016-05-31', freq='MS')
|
||||
tm.assert_index_equal(index.start_time, expected_index)
|
||||
|
||||
def test_end_time(self):
|
||||
index = PeriodIndex(freq='M', start='2016-01-01', end='2016-05-31')
|
||||
expected_index = date_range('2016-01-01', end='2016-05-31', freq='M')
|
||||
tm.assert_index_equal(index.end_time, expected_index)
|
||||
@@ -1,247 +0,0 @@
|
||||
import pytest
|
||||
|
||||
import numpy as np
|
||||
|
||||
import pandas as pd
|
||||
import pandas.util.testing as tm
|
||||
import pandas.core.indexes.period as period
|
||||
from pandas import period_range, PeriodIndex, Index, date_range
|
||||
|
||||
|
||||
def _permute(obj):
|
||||
return obj.take(np.random.permutation(len(obj)))
|
||||
|
||||
|
||||
class TestPeriodIndex(object):
|
||||
|
||||
def test_joins(self, join_type):
|
||||
index = period_range('1/1/2000', '1/20/2000', freq='D')
|
||||
|
||||
joined = index.join(index[:-5], how=join_type)
|
||||
|
||||
assert isinstance(joined, PeriodIndex)
|
||||
assert joined.freq == index.freq
|
||||
|
||||
def test_join_self(self, join_type):
|
||||
index = period_range('1/1/2000', '1/20/2000', freq='D')
|
||||
|
||||
res = index.join(index, how=join_type)
|
||||
assert index is res
|
||||
|
||||
def test_join_does_not_recur(self):
|
||||
df = tm.makeCustomDataframe(
|
||||
3, 2, data_gen_f=lambda *args: np.random.randint(2),
|
||||
c_idx_type='p', r_idx_type='dt')
|
||||
s = df.iloc[:2, 0]
|
||||
|
||||
res = s.index.join(df.columns, how='outer')
|
||||
expected = Index([s.index[0], s.index[1],
|
||||
df.columns[0], df.columns[1]], object)
|
||||
tm.assert_index_equal(res, expected)
|
||||
|
||||
def test_union(self):
|
||||
# union
|
||||
rng1 = pd.period_range('1/1/2000', freq='D', periods=5)
|
||||
other1 = pd.period_range('1/6/2000', freq='D', periods=5)
|
||||
expected1 = pd.period_range('1/1/2000', freq='D', periods=10)
|
||||
|
||||
rng2 = pd.period_range('1/1/2000', freq='D', periods=5)
|
||||
other2 = pd.period_range('1/4/2000', freq='D', periods=5)
|
||||
expected2 = pd.period_range('1/1/2000', freq='D', periods=8)
|
||||
|
||||
rng3 = pd.period_range('1/1/2000', freq='D', periods=5)
|
||||
other3 = pd.PeriodIndex([], freq='D')
|
||||
expected3 = pd.period_range('1/1/2000', freq='D', periods=5)
|
||||
|
||||
rng4 = pd.period_range('2000-01-01 09:00', freq='H', periods=5)
|
||||
other4 = pd.period_range('2000-01-02 09:00', freq='H', periods=5)
|
||||
expected4 = pd.PeriodIndex(['2000-01-01 09:00', '2000-01-01 10:00',
|
||||
'2000-01-01 11:00', '2000-01-01 12:00',
|
||||
'2000-01-01 13:00', '2000-01-02 09:00',
|
||||
'2000-01-02 10:00', '2000-01-02 11:00',
|
||||
'2000-01-02 12:00', '2000-01-02 13:00'],
|
||||
freq='H')
|
||||
|
||||
rng5 = pd.PeriodIndex(['2000-01-01 09:01', '2000-01-01 09:03',
|
||||
'2000-01-01 09:05'], freq='T')
|
||||
other5 = pd.PeriodIndex(['2000-01-01 09:01', '2000-01-01 09:05'
|
||||
'2000-01-01 09:08'],
|
||||
freq='T')
|
||||
expected5 = pd.PeriodIndex(['2000-01-01 09:01', '2000-01-01 09:03',
|
||||
'2000-01-01 09:05', '2000-01-01 09:08'],
|
||||
freq='T')
|
||||
|
||||
rng6 = pd.period_range('2000-01-01', freq='M', periods=7)
|
||||
other6 = pd.period_range('2000-04-01', freq='M', periods=7)
|
||||
expected6 = pd.period_range('2000-01-01', freq='M', periods=10)
|
||||
|
||||
rng7 = pd.period_range('2003-01-01', freq='A', periods=5)
|
||||
other7 = pd.period_range('1998-01-01', freq='A', periods=8)
|
||||
expected7 = pd.period_range('1998-01-01', freq='A', periods=10)
|
||||
|
||||
for rng, other, expected in [(rng1, other1, expected1),
|
||||
(rng2, other2, expected2),
|
||||
(rng3, other3, expected3), (rng4, other4,
|
||||
expected4),
|
||||
(rng5, other5, expected5), (rng6, other6,
|
||||
expected6),
|
||||
(rng7, other7, expected7)]:
|
||||
|
||||
result_union = rng.union(other)
|
||||
tm.assert_index_equal(result_union, expected)
|
||||
|
||||
def test_union_misc(self):
|
||||
index = period_range('1/1/2000', '1/20/2000', freq='D')
|
||||
|
||||
result = index[:-5].union(index[10:])
|
||||
tm.assert_index_equal(result, index)
|
||||
|
||||
# not in order
|
||||
result = _permute(index[:-5]).union(_permute(index[10:]))
|
||||
tm.assert_index_equal(result, index)
|
||||
|
||||
# raise if different frequencies
|
||||
index = period_range('1/1/2000', '1/20/2000', freq='D')
|
||||
index2 = period_range('1/1/2000', '1/20/2000', freq='W-WED')
|
||||
with pytest.raises(period.IncompatibleFrequency):
|
||||
index.union(index2)
|
||||
|
||||
msg = 'can only call with other PeriodIndex-ed objects'
|
||||
with tm.assert_raises_regex(ValueError, msg):
|
||||
index.join(index.to_timestamp())
|
||||
|
||||
index3 = period_range('1/1/2000', '1/20/2000', freq='2D')
|
||||
with pytest.raises(period.IncompatibleFrequency):
|
||||
index.join(index3)
|
||||
|
||||
def test_union_dataframe_index(self):
|
||||
rng1 = pd.period_range('1/1/1999', '1/1/2012', freq='M')
|
||||
s1 = pd.Series(np.random.randn(len(rng1)), rng1)
|
||||
|
||||
rng2 = pd.period_range('1/1/1980', '12/1/2001', freq='M')
|
||||
s2 = pd.Series(np.random.randn(len(rng2)), rng2)
|
||||
df = pd.DataFrame({'s1': s1, 's2': s2})
|
||||
|
||||
exp = pd.period_range('1/1/1980', '1/1/2012', freq='M')
|
||||
tm.assert_index_equal(df.index, exp)
|
||||
|
||||
def test_intersection(self):
|
||||
index = period_range('1/1/2000', '1/20/2000', freq='D')
|
||||
|
||||
result = index[:-5].intersection(index[10:])
|
||||
tm.assert_index_equal(result, index[10:-5])
|
||||
|
||||
# not in order
|
||||
left = _permute(index[:-5])
|
||||
right = _permute(index[10:])
|
||||
result = left.intersection(right).sort_values()
|
||||
tm.assert_index_equal(result, index[10:-5])
|
||||
|
||||
# raise if different frequencies
|
||||
index = period_range('1/1/2000', '1/20/2000', freq='D')
|
||||
index2 = period_range('1/1/2000', '1/20/2000', freq='W-WED')
|
||||
with pytest.raises(period.IncompatibleFrequency):
|
||||
index.intersection(index2)
|
||||
|
||||
index3 = period_range('1/1/2000', '1/20/2000', freq='2D')
|
||||
with pytest.raises(period.IncompatibleFrequency):
|
||||
index.intersection(index3)
|
||||
|
||||
def test_intersection_cases(self):
|
||||
base = period_range('6/1/2000', '6/30/2000', freq='D', name='idx')
|
||||
|
||||
# if target has the same name, it is preserved
|
||||
rng2 = period_range('5/15/2000', '6/20/2000', freq='D', name='idx')
|
||||
expected2 = period_range('6/1/2000', '6/20/2000', freq='D',
|
||||
name='idx')
|
||||
|
||||
# if target name is different, it will be reset
|
||||
rng3 = period_range('5/15/2000', '6/20/2000', freq='D', name='other')
|
||||
expected3 = period_range('6/1/2000', '6/20/2000', freq='D',
|
||||
name=None)
|
||||
|
||||
rng4 = period_range('7/1/2000', '7/31/2000', freq='D', name='idx')
|
||||
expected4 = PeriodIndex([], name='idx', freq='D')
|
||||
|
||||
for (rng, expected) in [(rng2, expected2), (rng3, expected3),
|
||||
(rng4, expected4)]:
|
||||
result = base.intersection(rng)
|
||||
tm.assert_index_equal(result, expected)
|
||||
assert result.name == expected.name
|
||||
assert result.freq == expected.freq
|
||||
|
||||
# non-monotonic
|
||||
base = PeriodIndex(['2011-01-05', '2011-01-04', '2011-01-02',
|
||||
'2011-01-03'], freq='D', name='idx')
|
||||
|
||||
rng2 = PeriodIndex(['2011-01-04', '2011-01-02',
|
||||
'2011-02-02', '2011-02-03'],
|
||||
freq='D', name='idx')
|
||||
expected2 = PeriodIndex(['2011-01-04', '2011-01-02'], freq='D',
|
||||
name='idx')
|
||||
|
||||
rng3 = PeriodIndex(['2011-01-04', '2011-01-02', '2011-02-02',
|
||||
'2011-02-03'],
|
||||
freq='D', name='other')
|
||||
expected3 = PeriodIndex(['2011-01-04', '2011-01-02'], freq='D',
|
||||
name=None)
|
||||
|
||||
rng4 = period_range('7/1/2000', '7/31/2000', freq='D', name='idx')
|
||||
expected4 = PeriodIndex([], freq='D', name='idx')
|
||||
|
||||
for (rng, expected) in [(rng2, expected2), (rng3, expected3),
|
||||
(rng4, expected4)]:
|
||||
result = base.intersection(rng)
|
||||
tm.assert_index_equal(result, expected)
|
||||
assert result.name == expected.name
|
||||
assert result.freq == 'D'
|
||||
|
||||
# empty same freq
|
||||
rng = date_range('6/1/2000', '6/15/2000', freq='T')
|
||||
result = rng[0:0].intersection(rng)
|
||||
assert len(result) == 0
|
||||
|
||||
result = rng.intersection(rng[0:0])
|
||||
assert len(result) == 0
|
||||
|
||||
def test_difference(self):
|
||||
# diff
|
||||
rng1 = pd.period_range('1/1/2000', freq='D', periods=5)
|
||||
other1 = pd.period_range('1/6/2000', freq='D', periods=5)
|
||||
expected1 = pd.period_range('1/1/2000', freq='D', periods=5)
|
||||
|
||||
rng2 = pd.period_range('1/1/2000', freq='D', periods=5)
|
||||
other2 = pd.period_range('1/4/2000', freq='D', periods=5)
|
||||
expected2 = pd.period_range('1/1/2000', freq='D', periods=3)
|
||||
|
||||
rng3 = pd.period_range('1/1/2000', freq='D', periods=5)
|
||||
other3 = pd.PeriodIndex([], freq='D')
|
||||
expected3 = pd.period_range('1/1/2000', freq='D', periods=5)
|
||||
|
||||
rng4 = pd.period_range('2000-01-01 09:00', freq='H', periods=5)
|
||||
other4 = pd.period_range('2000-01-02 09:00', freq='H', periods=5)
|
||||
expected4 = rng4
|
||||
|
||||
rng5 = pd.PeriodIndex(['2000-01-01 09:01', '2000-01-01 09:03',
|
||||
'2000-01-01 09:05'], freq='T')
|
||||
other5 = pd.PeriodIndex(
|
||||
['2000-01-01 09:01', '2000-01-01 09:05'], freq='T')
|
||||
expected5 = pd.PeriodIndex(['2000-01-01 09:03'], freq='T')
|
||||
|
||||
rng6 = pd.period_range('2000-01-01', freq='M', periods=7)
|
||||
other6 = pd.period_range('2000-04-01', freq='M', periods=7)
|
||||
expected6 = pd.period_range('2000-01-01', freq='M', periods=3)
|
||||
|
||||
rng7 = pd.period_range('2003-01-01', freq='A', periods=5)
|
||||
other7 = pd.period_range('1998-01-01', freq='A', periods=8)
|
||||
expected7 = pd.period_range('2006-01-01', freq='A', periods=2)
|
||||
|
||||
for rng, other, expected in [(rng1, other1, expected1),
|
||||
(rng2, other2, expected2),
|
||||
(rng3, other3, expected3),
|
||||
(rng4, other4, expected4),
|
||||
(rng5, other5, expected5),
|
||||
(rng6, other6, expected6),
|
||||
(rng7, other7, expected7), ]:
|
||||
result_union = rng.difference(other)
|
||||
tm.assert_index_equal(result_union, expected)
|
||||
@@ -1,331 +0,0 @@
|
||||
import numpy as np
|
||||
from datetime import datetime, timedelta
|
||||
import pytest
|
||||
|
||||
import pandas as pd
|
||||
import pandas.util.testing as tm
|
||||
import pandas.core.indexes.period as period
|
||||
from pandas.compat import lrange
|
||||
|
||||
from pandas._libs.tslibs.ccalendar import MONTHS
|
||||
|
||||
from pandas import (PeriodIndex, Period, DatetimeIndex, Timestamp, Series,
|
||||
date_range, to_datetime, period_range)
|
||||
|
||||
|
||||
class TestPeriodRepresentation(object):
|
||||
"""
|
||||
Wish to match NumPy units
|
||||
"""
|
||||
|
||||
def _check_freq(self, freq, base_date):
|
||||
rng = PeriodIndex(start=base_date, periods=10, freq=freq)
|
||||
exp = np.arange(10, dtype=np.int64)
|
||||
|
||||
tm.assert_numpy_array_equal(rng.asi8, exp)
|
||||
|
||||
def test_annual(self):
|
||||
self._check_freq('A', 1970)
|
||||
|
||||
def test_monthly(self):
|
||||
self._check_freq('M', '1970-01')
|
||||
|
||||
@pytest.mark.parametrize('freq', ['W-THU', 'D', 'B', 'H', 'T',
|
||||
'S', 'L', 'U', 'N'])
|
||||
def test_freq(self, freq):
|
||||
self._check_freq(freq, '1970-01-01')
|
||||
|
||||
def test_negone_ordinals(self):
|
||||
freqs = ['A', 'M', 'Q', 'D', 'H', 'T', 'S']
|
||||
|
||||
period = Period(ordinal=-1, freq='D')
|
||||
for freq in freqs:
|
||||
repr(period.asfreq(freq))
|
||||
|
||||
for freq in freqs:
|
||||
period = Period(ordinal=-1, freq=freq)
|
||||
repr(period)
|
||||
assert period.year == 1969
|
||||
|
||||
period = Period(ordinal=-1, freq='B')
|
||||
repr(period)
|
||||
period = Period(ordinal=-1, freq='W')
|
||||
repr(period)
|
||||
|
||||
|
||||
class TestPeriodIndex(object):
|
||||
def test_to_timestamp(self):
|
||||
index = PeriodIndex(freq='A', start='1/1/2001', end='12/1/2009')
|
||||
series = Series(1, index=index, name='foo')
|
||||
|
||||
exp_index = date_range('1/1/2001', end='12/31/2009', freq='A-DEC')
|
||||
result = series.to_timestamp(how='end')
|
||||
tm.assert_index_equal(result.index, exp_index)
|
||||
assert result.name == 'foo'
|
||||
|
||||
exp_index = date_range('1/1/2001', end='1/1/2009', freq='AS-JAN')
|
||||
result = series.to_timestamp(how='start')
|
||||
tm.assert_index_equal(result.index, exp_index)
|
||||
|
||||
def _get_with_delta(delta, freq='A-DEC'):
|
||||
return date_range(to_datetime('1/1/2001') + delta,
|
||||
to_datetime('12/31/2009') + delta, freq=freq)
|
||||
|
||||
delta = timedelta(hours=23)
|
||||
result = series.to_timestamp('H', 'end')
|
||||
exp_index = _get_with_delta(delta)
|
||||
tm.assert_index_equal(result.index, exp_index)
|
||||
|
||||
delta = timedelta(hours=23, minutes=59)
|
||||
result = series.to_timestamp('T', 'end')
|
||||
exp_index = _get_with_delta(delta)
|
||||
tm.assert_index_equal(result.index, exp_index)
|
||||
|
||||
result = series.to_timestamp('S', 'end')
|
||||
delta = timedelta(hours=23, minutes=59, seconds=59)
|
||||
exp_index = _get_with_delta(delta)
|
||||
tm.assert_index_equal(result.index, exp_index)
|
||||
|
||||
index = PeriodIndex(freq='H', start='1/1/2001', end='1/2/2001')
|
||||
series = Series(1, index=index, name='foo')
|
||||
|
||||
exp_index = date_range('1/1/2001 00:59:59', end='1/2/2001 00:59:59',
|
||||
freq='H')
|
||||
result = series.to_timestamp(how='end')
|
||||
tm.assert_index_equal(result.index, exp_index)
|
||||
assert result.name == 'foo'
|
||||
|
||||
def test_to_timestamp_repr_is_code(self):
|
||||
zs = [Timestamp('99-04-17 00:00:00', tz='UTC'),
|
||||
Timestamp('2001-04-17 00:00:00', tz='UTC'),
|
||||
Timestamp('2001-04-17 00:00:00', tz='America/Los_Angeles'),
|
||||
Timestamp('2001-04-17 00:00:00', tz=None)]
|
||||
for z in zs:
|
||||
assert eval(repr(z)) == z
|
||||
|
||||
def test_to_timestamp_to_period_astype(self):
|
||||
idx = DatetimeIndex([pd.NaT, '2011-01-01', '2011-02-01'], name='idx')
|
||||
|
||||
res = idx.astype('period[M]')
|
||||
exp = PeriodIndex(['NaT', '2011-01', '2011-02'], freq='M', name='idx')
|
||||
tm.assert_index_equal(res, exp)
|
||||
|
||||
res = idx.astype('period[3M]')
|
||||
exp = PeriodIndex(['NaT', '2011-01', '2011-02'], freq='3M', name='idx')
|
||||
tm.assert_index_equal(res, exp)
|
||||
|
||||
def test_dti_to_period(self):
|
||||
dti = DatetimeIndex(start='1/1/2005', end='12/1/2005', freq='M')
|
||||
pi1 = dti.to_period()
|
||||
pi2 = dti.to_period(freq='D')
|
||||
pi3 = dti.to_period(freq='3D')
|
||||
|
||||
assert pi1[0] == Period('Jan 2005', freq='M')
|
||||
assert pi2[0] == Period('1/31/2005', freq='D')
|
||||
assert pi3[0] == Period('1/31/2005', freq='3D')
|
||||
|
||||
assert pi1[-1] == Period('Nov 2005', freq='M')
|
||||
assert pi2[-1] == Period('11/30/2005', freq='D')
|
||||
assert pi3[-1], Period('11/30/2005', freq='3D')
|
||||
|
||||
tm.assert_index_equal(pi1, period_range('1/1/2005', '11/1/2005',
|
||||
freq='M'))
|
||||
tm.assert_index_equal(pi2, period_range('1/1/2005', '11/1/2005',
|
||||
freq='M').asfreq('D'))
|
||||
tm.assert_index_equal(pi3, period_range('1/1/2005', '11/1/2005',
|
||||
freq='M').asfreq('3D'))
|
||||
|
||||
@pytest.mark.parametrize('month', MONTHS)
|
||||
def test_to_period_quarterly(self, month):
|
||||
# make sure we can make the round trip
|
||||
freq = 'Q-%s' % month
|
||||
rng = period_range('1989Q3', '1991Q3', freq=freq)
|
||||
stamps = rng.to_timestamp()
|
||||
result = stamps.to_period(freq)
|
||||
tm.assert_index_equal(rng, result)
|
||||
|
||||
@pytest.mark.parametrize('off', ['BQ', 'QS', 'BQS'])
|
||||
def test_to_period_quarterlyish(self, off):
|
||||
rng = date_range('01-Jan-2012', periods=8, freq=off)
|
||||
prng = rng.to_period()
|
||||
assert prng.freq == 'Q-DEC'
|
||||
|
||||
@pytest.mark.parametrize('off', ['BA', 'AS', 'BAS'])
|
||||
def test_to_period_annualish(self, off):
|
||||
rng = date_range('01-Jan-2012', periods=8, freq=off)
|
||||
prng = rng.to_period()
|
||||
assert prng.freq == 'A-DEC'
|
||||
|
||||
def test_to_period_monthish(self):
|
||||
offsets = ['MS', 'BM']
|
||||
for off in offsets:
|
||||
rng = date_range('01-Jan-2012', periods=8, freq=off)
|
||||
prng = rng.to_period()
|
||||
assert prng.freq == 'M'
|
||||
|
||||
rng = date_range('01-Jan-2012', periods=8, freq='M')
|
||||
prng = rng.to_period()
|
||||
assert prng.freq == 'M'
|
||||
|
||||
msg = pd._libs.tslibs.frequencies._INVALID_FREQ_ERROR
|
||||
with tm.assert_raises_regex(ValueError, msg):
|
||||
date_range('01-Jan-2012', periods=8, freq='EOM')
|
||||
|
||||
def test_period_dt64_round_trip(self):
|
||||
dti = date_range('1/1/2000', '1/7/2002', freq='B')
|
||||
pi = dti.to_period()
|
||||
tm.assert_index_equal(pi.to_timestamp(), dti)
|
||||
|
||||
dti = date_range('1/1/2000', '1/7/2002', freq='B')
|
||||
pi = dti.to_period(freq='H')
|
||||
tm.assert_index_equal(pi.to_timestamp(), dti)
|
||||
|
||||
def test_combine_first(self):
|
||||
# GH 3367
|
||||
didx = pd.DatetimeIndex(start='1950-01-31', end='1950-07-31', freq='M')
|
||||
pidx = pd.PeriodIndex(start=pd.Period('1950-1'),
|
||||
end=pd.Period('1950-7'), freq='M')
|
||||
# check to be consistent with DatetimeIndex
|
||||
for idx in [didx, pidx]:
|
||||
a = pd.Series([1, np.nan, np.nan, 4, 5, np.nan, 7], index=idx)
|
||||
b = pd.Series([9, 9, 9, 9, 9, 9, 9], index=idx)
|
||||
|
||||
result = a.combine_first(b)
|
||||
expected = pd.Series([1, 9, 9, 4, 5, 9, 7], index=idx,
|
||||
dtype=np.float64)
|
||||
tm.assert_series_equal(result, expected)
|
||||
|
||||
@pytest.mark.parametrize('freq', ['D', '2D'])
|
||||
def test_searchsorted(self, freq):
|
||||
pidx = pd.PeriodIndex(['2014-01-01', '2014-01-02', '2014-01-03',
|
||||
'2014-01-04', '2014-01-05'], freq=freq)
|
||||
|
||||
p1 = pd.Period('2014-01-01', freq=freq)
|
||||
assert pidx.searchsorted(p1) == 0
|
||||
|
||||
p2 = pd.Period('2014-01-04', freq=freq)
|
||||
assert pidx.searchsorted(p2) == 3
|
||||
|
||||
msg = "Input has different freq=H from PeriodIndex"
|
||||
with tm.assert_raises_regex(period.IncompatibleFrequency, msg):
|
||||
pidx.searchsorted(pd.Period('2014-01-01', freq='H'))
|
||||
|
||||
msg = "Input has different freq=5D from PeriodIndex"
|
||||
with tm.assert_raises_regex(period.IncompatibleFrequency, msg):
|
||||
pidx.searchsorted(pd.Period('2014-01-01', freq='5D'))
|
||||
|
||||
with tm.assert_produces_warning(FutureWarning):
|
||||
pidx.searchsorted(key=p2)
|
||||
|
||||
|
||||
class TestPeriodIndexConversion(object):
|
||||
def test_tolist(self):
|
||||
index = PeriodIndex(freq='A', start='1/1/2001', end='12/1/2009')
|
||||
rs = index.tolist()
|
||||
for x in rs:
|
||||
assert isinstance(x, Period)
|
||||
|
||||
recon = PeriodIndex(rs)
|
||||
tm.assert_index_equal(index, recon)
|
||||
|
||||
def test_to_timestamp_pi_nat(self):
|
||||
# GH#7228
|
||||
index = PeriodIndex(['NaT', '2011-01', '2011-02'], freq='M',
|
||||
name='idx')
|
||||
|
||||
result = index.to_timestamp('D')
|
||||
expected = DatetimeIndex([pd.NaT, datetime(2011, 1, 1),
|
||||
datetime(2011, 2, 1)], name='idx')
|
||||
tm.assert_index_equal(result, expected)
|
||||
assert result.name == 'idx'
|
||||
|
||||
result2 = result.to_period(freq='M')
|
||||
tm.assert_index_equal(result2, index)
|
||||
assert result2.name == 'idx'
|
||||
|
||||
result3 = result.to_period(freq='3M')
|
||||
exp = PeriodIndex(['NaT', '2011-01', '2011-02'],
|
||||
freq='3M', name='idx')
|
||||
tm.assert_index_equal(result3, exp)
|
||||
assert result3.freqstr == '3M'
|
||||
|
||||
msg = ('Frequency must be positive, because it'
|
||||
' represents span: -2A')
|
||||
with tm.assert_raises_regex(ValueError, msg):
|
||||
result.to_period(freq='-2A')
|
||||
|
||||
def test_to_timestamp_preserve_name(self):
|
||||
index = PeriodIndex(freq='A', start='1/1/2001', end='12/1/2009',
|
||||
name='foo')
|
||||
assert index.name == 'foo'
|
||||
|
||||
conv = index.to_timestamp('D')
|
||||
assert conv.name == 'foo'
|
||||
|
||||
def test_to_timestamp_quarterly_bug(self):
|
||||
years = np.arange(1960, 2000).repeat(4)
|
||||
quarters = np.tile(lrange(1, 5), 40)
|
||||
|
||||
pindex = PeriodIndex(year=years, quarter=quarters)
|
||||
|
||||
stamps = pindex.to_timestamp('D', 'end')
|
||||
expected = DatetimeIndex([x.to_timestamp('D', 'end') for x in pindex])
|
||||
tm.assert_index_equal(stamps, expected)
|
||||
|
||||
def test_to_timestamp_pi_mult(self):
|
||||
idx = PeriodIndex(['2011-01', 'NaT', '2011-02'],
|
||||
freq='2M', name='idx')
|
||||
|
||||
result = idx.to_timestamp()
|
||||
expected = DatetimeIndex(['2011-01-01', 'NaT', '2011-02-01'],
|
||||
name='idx')
|
||||
tm.assert_index_equal(result, expected)
|
||||
|
||||
result = idx.to_timestamp(how='E')
|
||||
expected = DatetimeIndex(['2011-02-28', 'NaT', '2011-03-31'],
|
||||
name='idx')
|
||||
tm.assert_index_equal(result, expected)
|
||||
|
||||
def test_to_timestamp_pi_combined(self):
|
||||
idx = PeriodIndex(start='2011', periods=2, freq='1D1H', name='idx')
|
||||
|
||||
result = idx.to_timestamp()
|
||||
expected = DatetimeIndex(['2011-01-01 00:00', '2011-01-02 01:00'],
|
||||
name='idx')
|
||||
tm.assert_index_equal(result, expected)
|
||||
|
||||
result = idx.to_timestamp(how='E')
|
||||
expected = DatetimeIndex(['2011-01-02 00:59:59',
|
||||
'2011-01-03 01:59:59'],
|
||||
name='idx')
|
||||
tm.assert_index_equal(result, expected)
|
||||
|
||||
result = idx.to_timestamp(how='E', freq='H')
|
||||
expected = DatetimeIndex(['2011-01-02 00:00', '2011-01-03 01:00'],
|
||||
name='idx')
|
||||
tm.assert_index_equal(result, expected)
|
||||
|
||||
def test_period_astype_to_timestamp(self):
|
||||
pi = pd.PeriodIndex(['2011-01', '2011-02', '2011-03'], freq='M')
|
||||
|
||||
exp = pd.DatetimeIndex(['2011-01-01', '2011-02-01', '2011-03-01'])
|
||||
tm.assert_index_equal(pi.astype('datetime64[ns]'), exp)
|
||||
|
||||
exp = pd.DatetimeIndex(['2011-01-31', '2011-02-28', '2011-03-31'])
|
||||
tm.assert_index_equal(pi.astype('datetime64[ns]', how='end'), exp)
|
||||
|
||||
exp = pd.DatetimeIndex(['2011-01-01', '2011-02-01', '2011-03-01'],
|
||||
tz='US/Eastern')
|
||||
res = pi.astype('datetime64[ns, US/Eastern]')
|
||||
tm.assert_index_equal(pi.astype('datetime64[ns, US/Eastern]'), exp)
|
||||
|
||||
exp = pd.DatetimeIndex(['2011-01-31', '2011-02-28', '2011-03-31'],
|
||||
tz='US/Eastern')
|
||||
res = pi.astype('datetime64[ns, US/Eastern]', how='end')
|
||||
tm.assert_index_equal(res, exp)
|
||||
|
||||
def test_to_timestamp_1703(self):
|
||||
index = period_range('1/1/2012', periods=4, freq='D')
|
||||
|
||||
result = index.to_timestamp()
|
||||
assert result[0] == Timestamp('1/1/2012')
|
||||
Reference in New Issue
Block a user