806 lines
30 KiB
Python
806 lines
30 KiB
Python
from datetime import datetime, timedelta
|
|
from pandas.compat import range
|
|
|
|
import pytest
|
|
import numpy as np
|
|
|
|
from pandas import (Index, DatetimeIndex, Timestamp, Series,
|
|
date_range, period_range)
|
|
|
|
from pandas._libs.tslibs.frequencies import (_period_code_map,
|
|
_INVALID_FREQ_ERROR)
|
|
from pandas._libs.tslibs.ccalendar import MONTHS
|
|
from pandas._libs.tslibs import resolution
|
|
import pandas.tseries.frequencies as frequencies
|
|
from pandas.core.tools.datetimes import to_datetime
|
|
|
|
import pandas.tseries.offsets as offsets
|
|
from pandas.core.indexes.period import PeriodIndex
|
|
import pandas.compat as compat
|
|
from pandas.compat import is_platform_windows
|
|
|
|
import pandas.util.testing as tm
|
|
from pandas import Timedelta
|
|
|
|
|
|
class TestToOffset(object):
|
|
|
|
def test_to_offset_multiple(self):
|
|
freqstr = '2h30min'
|
|
freqstr2 = '2h 30min'
|
|
|
|
result = frequencies.to_offset(freqstr)
|
|
assert (result == frequencies.to_offset(freqstr2))
|
|
expected = offsets.Minute(150)
|
|
assert (result == expected)
|
|
|
|
freqstr = '2h30min15s'
|
|
result = frequencies.to_offset(freqstr)
|
|
expected = offsets.Second(150 * 60 + 15)
|
|
assert (result == expected)
|
|
|
|
freqstr = '2h 60min'
|
|
result = frequencies.to_offset(freqstr)
|
|
expected = offsets.Hour(3)
|
|
assert (result == expected)
|
|
|
|
freqstr = '2h 20.5min'
|
|
result = frequencies.to_offset(freqstr)
|
|
expected = offsets.Second(8430)
|
|
assert (result == expected)
|
|
|
|
freqstr = '1.5min'
|
|
result = frequencies.to_offset(freqstr)
|
|
expected = offsets.Second(90)
|
|
assert (result == expected)
|
|
|
|
freqstr = '0.5S'
|
|
result = frequencies.to_offset(freqstr)
|
|
expected = offsets.Milli(500)
|
|
assert (result == expected)
|
|
|
|
freqstr = '15l500u'
|
|
result = frequencies.to_offset(freqstr)
|
|
expected = offsets.Micro(15500)
|
|
assert (result == expected)
|
|
|
|
freqstr = '10s75L'
|
|
result = frequencies.to_offset(freqstr)
|
|
expected = offsets.Milli(10075)
|
|
assert (result == expected)
|
|
|
|
freqstr = '1s0.25ms'
|
|
result = frequencies.to_offset(freqstr)
|
|
expected = offsets.Micro(1000250)
|
|
assert (result == expected)
|
|
|
|
freqstr = '1s0.25L'
|
|
result = frequencies.to_offset(freqstr)
|
|
expected = offsets.Micro(1000250)
|
|
assert (result == expected)
|
|
|
|
freqstr = '2800N'
|
|
result = frequencies.to_offset(freqstr)
|
|
expected = offsets.Nano(2800)
|
|
assert (result == expected)
|
|
|
|
freqstr = '2SM'
|
|
result = frequencies.to_offset(freqstr)
|
|
expected = offsets.SemiMonthEnd(2)
|
|
assert (result == expected)
|
|
|
|
freqstr = '2SM-16'
|
|
result = frequencies.to_offset(freqstr)
|
|
expected = offsets.SemiMonthEnd(2, day_of_month=16)
|
|
assert (result == expected)
|
|
|
|
freqstr = '2SMS-14'
|
|
result = frequencies.to_offset(freqstr)
|
|
expected = offsets.SemiMonthBegin(2, day_of_month=14)
|
|
assert (result == expected)
|
|
|
|
freqstr = '2SMS-15'
|
|
result = frequencies.to_offset(freqstr)
|
|
expected = offsets.SemiMonthBegin(2)
|
|
assert (result == expected)
|
|
|
|
# malformed
|
|
with tm.assert_raises_regex(ValueError,
|
|
'Invalid frequency: 2h20m'):
|
|
frequencies.to_offset('2h20m')
|
|
|
|
def test_to_offset_negative(self):
|
|
freqstr = '-1S'
|
|
result = frequencies.to_offset(freqstr)
|
|
assert (result.n == -1)
|
|
|
|
freqstr = '-5min10s'
|
|
result = frequencies.to_offset(freqstr)
|
|
assert (result.n == -310)
|
|
|
|
freqstr = '-2SM'
|
|
result = frequencies.to_offset(freqstr)
|
|
assert (result.n == -2)
|
|
|
|
freqstr = '-1SMS'
|
|
result = frequencies.to_offset(freqstr)
|
|
assert (result.n == -1)
|
|
|
|
def test_to_offset_invalid(self):
|
|
# GH 13930
|
|
with tm.assert_raises_regex(ValueError,
|
|
'Invalid frequency: U1'):
|
|
frequencies.to_offset('U1')
|
|
with tm.assert_raises_regex(ValueError,
|
|
'Invalid frequency: -U'):
|
|
frequencies.to_offset('-U')
|
|
with tm.assert_raises_regex(ValueError,
|
|
'Invalid frequency: 3U1'):
|
|
frequencies.to_offset('3U1')
|
|
with tm.assert_raises_regex(ValueError,
|
|
'Invalid frequency: -2-3U'):
|
|
frequencies.to_offset('-2-3U')
|
|
with tm.assert_raises_regex(ValueError,
|
|
'Invalid frequency: -2D:3H'):
|
|
frequencies.to_offset('-2D:3H')
|
|
with tm.assert_raises_regex(ValueError,
|
|
'Invalid frequency: 1.5.0S'):
|
|
frequencies.to_offset('1.5.0S')
|
|
|
|
# split offsets with spaces are valid
|
|
assert frequencies.to_offset('2D 3H') == offsets.Hour(51)
|
|
assert frequencies.to_offset('2 D3 H') == offsets.Hour(51)
|
|
assert frequencies.to_offset('2 D 3 H') == offsets.Hour(51)
|
|
assert frequencies.to_offset(' 2 D 3 H ') == offsets.Hour(51)
|
|
assert frequencies.to_offset(' H ') == offsets.Hour()
|
|
assert frequencies.to_offset(' 3 H ') == offsets.Hour(3)
|
|
|
|
# special cases
|
|
assert frequencies.to_offset('2SMS-15') == offsets.SemiMonthBegin(2)
|
|
with tm.assert_raises_regex(ValueError,
|
|
'Invalid frequency: 2SMS-15-15'):
|
|
frequencies.to_offset('2SMS-15-15')
|
|
with tm.assert_raises_regex(ValueError,
|
|
'Invalid frequency: 2SMS-15D'):
|
|
frequencies.to_offset('2SMS-15D')
|
|
|
|
def test_to_offset_leading_zero(self):
|
|
freqstr = '00H 00T 01S'
|
|
result = frequencies.to_offset(freqstr)
|
|
assert (result.n == 1)
|
|
|
|
freqstr = '-00H 03T 14S'
|
|
result = frequencies.to_offset(freqstr)
|
|
assert (result.n == -194)
|
|
|
|
def test_to_offset_leading_plus(self):
|
|
freqstr = '+1d'
|
|
result = frequencies.to_offset(freqstr)
|
|
assert (result.n == 1)
|
|
|
|
freqstr = '+2h30min'
|
|
result = frequencies.to_offset(freqstr)
|
|
assert (result.n == 150)
|
|
|
|
for bad_freq in ['+-1d', '-+1h', '+1', '-7', '+d', '-m']:
|
|
with tm.assert_raises_regex(ValueError, 'Invalid frequency:'):
|
|
frequencies.to_offset(bad_freq)
|
|
|
|
def test_to_offset_pd_timedelta(self):
|
|
# Tests for #9064
|
|
td = Timedelta(days=1, seconds=1)
|
|
result = frequencies.to_offset(td)
|
|
expected = offsets.Second(86401)
|
|
assert (expected == result)
|
|
|
|
td = Timedelta(days=-1, seconds=1)
|
|
result = frequencies.to_offset(td)
|
|
expected = offsets.Second(-86399)
|
|
assert (expected == result)
|
|
|
|
td = Timedelta(hours=1, minutes=10)
|
|
result = frequencies.to_offset(td)
|
|
expected = offsets.Minute(70)
|
|
assert (expected == result)
|
|
|
|
td = Timedelta(hours=1, minutes=-10)
|
|
result = frequencies.to_offset(td)
|
|
expected = offsets.Minute(50)
|
|
assert (expected == result)
|
|
|
|
td = Timedelta(weeks=1)
|
|
result = frequencies.to_offset(td)
|
|
expected = offsets.Day(7)
|
|
assert (expected == result)
|
|
|
|
td1 = Timedelta(hours=1)
|
|
result1 = frequencies.to_offset(td1)
|
|
result2 = frequencies.to_offset('60min')
|
|
assert (result1 == result2)
|
|
|
|
td = Timedelta(microseconds=1)
|
|
result = frequencies.to_offset(td)
|
|
expected = offsets.Micro(1)
|
|
assert (expected == result)
|
|
|
|
td = Timedelta(microseconds=0)
|
|
pytest.raises(ValueError, lambda: frequencies.to_offset(td))
|
|
|
|
def test_anchored_shortcuts(self):
|
|
result = frequencies.to_offset('W')
|
|
expected = frequencies.to_offset('W-SUN')
|
|
assert (result == expected)
|
|
|
|
result1 = frequencies.to_offset('Q')
|
|
result2 = frequencies.to_offset('Q-DEC')
|
|
expected = offsets.QuarterEnd(startingMonth=12)
|
|
assert (result1 == expected)
|
|
assert (result2 == expected)
|
|
|
|
result1 = frequencies.to_offset('Q-MAY')
|
|
expected = offsets.QuarterEnd(startingMonth=5)
|
|
assert (result1 == expected)
|
|
|
|
result1 = frequencies.to_offset('SM')
|
|
result2 = frequencies.to_offset('SM-15')
|
|
expected = offsets.SemiMonthEnd(day_of_month=15)
|
|
assert (result1 == expected)
|
|
assert (result2 == expected)
|
|
|
|
result = frequencies.to_offset('SM-1')
|
|
expected = offsets.SemiMonthEnd(day_of_month=1)
|
|
assert (result == expected)
|
|
|
|
result = frequencies.to_offset('SM-27')
|
|
expected = offsets.SemiMonthEnd(day_of_month=27)
|
|
assert (result == expected)
|
|
|
|
result = frequencies.to_offset('SMS-2')
|
|
expected = offsets.SemiMonthBegin(day_of_month=2)
|
|
assert (result == expected)
|
|
|
|
result = frequencies.to_offset('SMS-27')
|
|
expected = offsets.SemiMonthBegin(day_of_month=27)
|
|
assert (result == expected)
|
|
|
|
# ensure invalid cases fail as expected
|
|
invalid_anchors = ['SM-0', 'SM-28', 'SM-29',
|
|
'SM-FOO', 'BSM', 'SM--1',
|
|
'SMS-1', 'SMS-28', 'SMS-30',
|
|
'SMS-BAR', 'SMS-BYR' 'BSMS',
|
|
'SMS--2']
|
|
for invalid_anchor in invalid_anchors:
|
|
with tm.assert_raises_regex(ValueError,
|
|
'Invalid frequency: '):
|
|
frequencies.to_offset(invalid_anchor)
|
|
|
|
|
|
def test_ms_vs_MS():
|
|
left = frequencies.get_offset('ms')
|
|
right = frequencies.get_offset('MS')
|
|
assert left == offsets.Milli()
|
|
assert right == offsets.MonthBegin()
|
|
|
|
|
|
def test_rule_aliases():
|
|
rule = frequencies.to_offset('10us')
|
|
assert rule == offsets.Micro(10)
|
|
|
|
|
|
class TestFrequencyCode(object):
|
|
|
|
def test_freq_code(self):
|
|
assert frequencies.get_freq('A') == 1000
|
|
assert frequencies.get_freq('3A') == 1000
|
|
assert frequencies.get_freq('-1A') == 1000
|
|
|
|
assert frequencies.get_freq('Y') == 1000
|
|
assert frequencies.get_freq('3Y') == 1000
|
|
assert frequencies.get_freq('-1Y') == 1000
|
|
|
|
assert frequencies.get_freq('W') == 4000
|
|
assert frequencies.get_freq('W-MON') == 4001
|
|
assert frequencies.get_freq('W-FRI') == 4005
|
|
|
|
for freqstr, code in compat.iteritems(_period_code_map):
|
|
result = frequencies.get_freq(freqstr)
|
|
assert result == code
|
|
|
|
result = resolution.get_freq_group(freqstr)
|
|
assert result == code // 1000 * 1000
|
|
|
|
result = resolution.get_freq_group(code)
|
|
assert result == code // 1000 * 1000
|
|
|
|
def test_freq_group(self):
|
|
assert resolution.get_freq_group('A') == 1000
|
|
assert resolution.get_freq_group('3A') == 1000
|
|
assert resolution.get_freq_group('-1A') == 1000
|
|
assert resolution.get_freq_group('A-JAN') == 1000
|
|
assert resolution.get_freq_group('A-MAY') == 1000
|
|
|
|
assert resolution.get_freq_group('Y') == 1000
|
|
assert resolution.get_freq_group('3Y') == 1000
|
|
assert resolution.get_freq_group('-1Y') == 1000
|
|
assert resolution.get_freq_group('Y-JAN') == 1000
|
|
assert resolution.get_freq_group('Y-MAY') == 1000
|
|
|
|
assert resolution.get_freq_group(offsets.YearEnd()) == 1000
|
|
assert resolution.get_freq_group(offsets.YearEnd(month=1)) == 1000
|
|
assert resolution.get_freq_group(offsets.YearEnd(month=5)) == 1000
|
|
|
|
assert resolution.get_freq_group('W') == 4000
|
|
assert resolution.get_freq_group('W-MON') == 4000
|
|
assert resolution.get_freq_group('W-FRI') == 4000
|
|
assert resolution.get_freq_group(offsets.Week()) == 4000
|
|
assert resolution.get_freq_group(offsets.Week(weekday=1)) == 4000
|
|
assert resolution.get_freq_group(offsets.Week(weekday=5)) == 4000
|
|
|
|
def test_get_to_timestamp_base(self):
|
|
tsb = frequencies.get_to_timestamp_base
|
|
|
|
assert (tsb(frequencies.get_freq_code('D')[0]) ==
|
|
frequencies.get_freq_code('D')[0])
|
|
assert (tsb(frequencies.get_freq_code('W')[0]) ==
|
|
frequencies.get_freq_code('D')[0])
|
|
assert (tsb(frequencies.get_freq_code('M')[0]) ==
|
|
frequencies.get_freq_code('D')[0])
|
|
|
|
assert (tsb(frequencies.get_freq_code('S')[0]) ==
|
|
frequencies.get_freq_code('S')[0])
|
|
assert (tsb(frequencies.get_freq_code('T')[0]) ==
|
|
frequencies.get_freq_code('S')[0])
|
|
assert (tsb(frequencies.get_freq_code('H')[0]) ==
|
|
frequencies.get_freq_code('S')[0])
|
|
|
|
def test_freq_to_reso(self):
|
|
Reso = frequencies.Resolution
|
|
|
|
assert Reso.get_str_from_freq('A') == 'year'
|
|
assert Reso.get_str_from_freq('Q') == 'quarter'
|
|
assert Reso.get_str_from_freq('M') == 'month'
|
|
assert Reso.get_str_from_freq('D') == 'day'
|
|
assert Reso.get_str_from_freq('H') == 'hour'
|
|
assert Reso.get_str_from_freq('T') == 'minute'
|
|
assert Reso.get_str_from_freq('S') == 'second'
|
|
assert Reso.get_str_from_freq('L') == 'millisecond'
|
|
assert Reso.get_str_from_freq('U') == 'microsecond'
|
|
assert Reso.get_str_from_freq('N') == 'nanosecond'
|
|
|
|
for freq in ['A', 'Q', 'M', 'D', 'H', 'T', 'S', 'L', 'U', 'N']:
|
|
# check roundtrip
|
|
result = Reso.get_freq(Reso.get_str_from_freq(freq))
|
|
assert freq == result
|
|
|
|
for freq in ['D', 'H', 'T', 'S', 'L', 'U']:
|
|
result = Reso.get_freq(Reso.get_str(Reso.get_reso_from_freq(freq)))
|
|
assert freq == result
|
|
|
|
def test_resolution_bumping(self):
|
|
# see gh-14378
|
|
Reso = frequencies.Resolution
|
|
|
|
assert Reso.get_stride_from_decimal(1.5, 'T') == (90, 'S')
|
|
assert Reso.get_stride_from_decimal(62.4, 'T') == (3744, 'S')
|
|
assert Reso.get_stride_from_decimal(1.04, 'H') == (3744, 'S')
|
|
assert Reso.get_stride_from_decimal(1, 'D') == (1, 'D')
|
|
assert (Reso.get_stride_from_decimal(0.342931, 'H') ==
|
|
(1234551600, 'U'))
|
|
assert Reso.get_stride_from_decimal(1.2345, 'D') == (106660800, 'L')
|
|
|
|
with pytest.raises(ValueError):
|
|
Reso.get_stride_from_decimal(0.5, 'N')
|
|
|
|
# too much precision in the input can prevent
|
|
with pytest.raises(ValueError):
|
|
Reso.get_stride_from_decimal(0.3429324798798269273987982, 'H')
|
|
|
|
def test_get_freq_code(self):
|
|
# frequency str
|
|
assert (frequencies.get_freq_code('A') ==
|
|
(frequencies.get_freq('A'), 1))
|
|
assert (frequencies.get_freq_code('3D') ==
|
|
(frequencies.get_freq('D'), 3))
|
|
assert (frequencies.get_freq_code('-2M') ==
|
|
(frequencies.get_freq('M'), -2))
|
|
|
|
# tuple
|
|
assert (frequencies.get_freq_code(('D', 1)) ==
|
|
(frequencies.get_freq('D'), 1))
|
|
assert (frequencies.get_freq_code(('A', 3)) ==
|
|
(frequencies.get_freq('A'), 3))
|
|
assert (frequencies.get_freq_code(('M', -2)) ==
|
|
(frequencies.get_freq('M'), -2))
|
|
|
|
# numeric tuple
|
|
assert frequencies.get_freq_code((1000, 1)) == (1000, 1)
|
|
|
|
# offsets
|
|
assert (frequencies.get_freq_code(offsets.Day()) ==
|
|
(frequencies.get_freq('D'), 1))
|
|
assert (frequencies.get_freq_code(offsets.Day(3)) ==
|
|
(frequencies.get_freq('D'), 3))
|
|
assert (frequencies.get_freq_code(offsets.Day(-2)) ==
|
|
(frequencies.get_freq('D'), -2))
|
|
|
|
assert (frequencies.get_freq_code(offsets.MonthEnd()) ==
|
|
(frequencies.get_freq('M'), 1))
|
|
assert (frequencies.get_freq_code(offsets.MonthEnd(3)) ==
|
|
(frequencies.get_freq('M'), 3))
|
|
assert (frequencies.get_freq_code(offsets.MonthEnd(-2)) ==
|
|
(frequencies.get_freq('M'), -2))
|
|
|
|
assert (frequencies.get_freq_code(offsets.Week()) ==
|
|
(frequencies.get_freq('W'), 1))
|
|
assert (frequencies.get_freq_code(offsets.Week(3)) ==
|
|
(frequencies.get_freq('W'), 3))
|
|
assert (frequencies.get_freq_code(offsets.Week(-2)) ==
|
|
(frequencies.get_freq('W'), -2))
|
|
|
|
# Monday is weekday=0
|
|
assert (frequencies.get_freq_code(offsets.Week(weekday=1)) ==
|
|
(frequencies.get_freq('W-TUE'), 1))
|
|
assert (frequencies.get_freq_code(offsets.Week(3, weekday=0)) ==
|
|
(frequencies.get_freq('W-MON'), 3))
|
|
assert (frequencies.get_freq_code(offsets.Week(-2, weekday=4)) ==
|
|
(frequencies.get_freq('W-FRI'), -2))
|
|
|
|
def test_frequency_misc(self):
|
|
assert (resolution.get_freq_group('T') ==
|
|
frequencies.FreqGroup.FR_MIN)
|
|
|
|
code, stride = frequencies.get_freq_code(offsets.Hour())
|
|
assert code == frequencies.FreqGroup.FR_HR
|
|
|
|
code, stride = frequencies.get_freq_code((5, 'T'))
|
|
assert code == frequencies.FreqGroup.FR_MIN
|
|
assert stride == 5
|
|
|
|
offset = offsets.Hour()
|
|
result = frequencies.to_offset(offset)
|
|
assert result == offset
|
|
|
|
result = frequencies.to_offset((5, 'T'))
|
|
expected = offsets.Minute(5)
|
|
assert result == expected
|
|
|
|
with tm.assert_raises_regex(ValueError, 'Invalid frequency'):
|
|
frequencies.get_freq_code((5, 'baz'))
|
|
|
|
with tm.assert_raises_regex(ValueError, 'Invalid frequency'):
|
|
frequencies.to_offset('100foo')
|
|
|
|
with tm.assert_raises_regex(ValueError, 'Could not evaluate'):
|
|
frequencies.to_offset(('', ''))
|
|
|
|
|
|
_dti = DatetimeIndex
|
|
|
|
|
|
class TestFrequencyInference(object):
|
|
|
|
def test_raise_if_period_index(self):
|
|
index = PeriodIndex(start="1/1/1990", periods=20, freq="M")
|
|
pytest.raises(TypeError, frequencies.infer_freq, index)
|
|
|
|
def test_raise_if_too_few(self):
|
|
index = _dti(['12/31/1998', '1/3/1999'])
|
|
pytest.raises(ValueError, frequencies.infer_freq, index)
|
|
|
|
def test_business_daily(self):
|
|
index = _dti(['01/01/1999', '1/4/1999', '1/5/1999'])
|
|
assert frequencies.infer_freq(index) == 'B'
|
|
|
|
def test_business_daily_look_alike(self):
|
|
# GH 16624, do not infer 'B' when 'weekend' (2-day gap) in wrong place
|
|
index = _dti(['12/31/1998', '1/3/1999', '1/4/1999'])
|
|
assert frequencies.infer_freq(index) is None
|
|
|
|
def test_day(self):
|
|
self._check_tick(timedelta(1), 'D')
|
|
|
|
def test_day_corner(self):
|
|
index = _dti(['1/1/2000', '1/2/2000', '1/3/2000'])
|
|
assert frequencies.infer_freq(index) == 'D'
|
|
|
|
def test_non_datetimeindex(self):
|
|
dates = to_datetime(['1/1/2000', '1/2/2000', '1/3/2000'])
|
|
assert frequencies.infer_freq(dates) == 'D'
|
|
|
|
def test_hour(self):
|
|
self._check_tick(timedelta(hours=1), 'H')
|
|
|
|
def test_minute(self):
|
|
self._check_tick(timedelta(minutes=1), 'T')
|
|
|
|
def test_second(self):
|
|
self._check_tick(timedelta(seconds=1), 'S')
|
|
|
|
def test_millisecond(self):
|
|
self._check_tick(timedelta(microseconds=1000), 'L')
|
|
|
|
def test_microsecond(self):
|
|
self._check_tick(timedelta(microseconds=1), 'U')
|
|
|
|
def test_nanosecond(self):
|
|
self._check_tick(np.timedelta64(1, 'ns'), 'N')
|
|
|
|
def _check_tick(self, base_delta, code):
|
|
b = Timestamp(datetime.now())
|
|
for i in range(1, 5):
|
|
inc = base_delta * i
|
|
index = _dti([b + inc * j for j in range(3)])
|
|
if i > 1:
|
|
exp_freq = '%d%s' % (i, code)
|
|
else:
|
|
exp_freq = code
|
|
assert frequencies.infer_freq(index) == exp_freq
|
|
|
|
index = _dti([b + base_delta * 7] + [b + base_delta * j for j in range(
|
|
3)])
|
|
assert frequencies.infer_freq(index) is None
|
|
|
|
index = _dti([b + base_delta * j for j in range(3)] + [b + base_delta *
|
|
7])
|
|
|
|
assert frequencies.infer_freq(index) is None
|
|
|
|
def test_weekly(self):
|
|
days = ['MON', 'TUE', 'WED', 'THU', 'FRI', 'SAT', 'SUN']
|
|
|
|
for day in days:
|
|
self._check_generated_range('1/1/2000', 'W-%s' % day)
|
|
|
|
def test_week_of_month(self):
|
|
days = ['MON', 'TUE', 'WED', 'THU', 'FRI', 'SAT', 'SUN']
|
|
|
|
for day in days:
|
|
for i in range(1, 5):
|
|
self._check_generated_range('1/1/2000', 'WOM-%d%s' % (i, day))
|
|
|
|
def test_fifth_week_of_month(self):
|
|
# Only supports freq up to WOM-4. See #9425
|
|
func = lambda: date_range('2014-01-01', freq='WOM-5MON')
|
|
pytest.raises(ValueError, func)
|
|
|
|
def test_fifth_week_of_month_infer(self):
|
|
# Only attempts to infer up to WOM-4. See #9425
|
|
index = DatetimeIndex(["2014-03-31", "2014-06-30", "2015-03-30"])
|
|
assert frequencies.infer_freq(index) is None
|
|
|
|
def test_week_of_month_fake(self):
|
|
# All of these dates are on same day of week and are 4 or 5 weeks apart
|
|
index = DatetimeIndex(["2013-08-27", "2013-10-01", "2013-10-29",
|
|
"2013-11-26"])
|
|
assert frequencies.infer_freq(index) != 'WOM-4TUE'
|
|
|
|
def test_monthly(self):
|
|
self._check_generated_range('1/1/2000', 'M')
|
|
|
|
def test_monthly_ambiguous(self):
|
|
rng = _dti(['1/31/2000', '2/29/2000', '3/31/2000'])
|
|
assert rng.inferred_freq == 'M'
|
|
|
|
def test_business_monthly(self):
|
|
self._check_generated_range('1/1/2000', 'BM')
|
|
|
|
def test_business_start_monthly(self):
|
|
self._check_generated_range('1/1/2000', 'BMS')
|
|
|
|
def test_quarterly(self):
|
|
for month in ['JAN', 'FEB', 'MAR']:
|
|
self._check_generated_range('1/1/2000', 'Q-%s' % month)
|
|
|
|
def test_annual(self):
|
|
for month in MONTHS:
|
|
self._check_generated_range('1/1/2000', 'A-%s' % month)
|
|
|
|
def test_business_annual(self):
|
|
for month in MONTHS:
|
|
self._check_generated_range('1/1/2000', 'BA-%s' % month)
|
|
|
|
def test_annual_ambiguous(self):
|
|
rng = _dti(['1/31/2000', '1/31/2001', '1/31/2002'])
|
|
assert rng.inferred_freq == 'A-JAN'
|
|
|
|
def _check_generated_range(self, start, freq):
|
|
freq = freq.upper()
|
|
|
|
gen = date_range(start, periods=7, freq=freq)
|
|
index = _dti(gen.values)
|
|
if not freq.startswith('Q-'):
|
|
assert frequencies.infer_freq(index) == gen.freqstr
|
|
else:
|
|
inf_freq = frequencies.infer_freq(index)
|
|
is_dec_range = inf_freq == 'Q-DEC' and gen.freqstr in (
|
|
'Q', 'Q-DEC', 'Q-SEP', 'Q-JUN', 'Q-MAR')
|
|
is_nov_range = inf_freq == 'Q-NOV' and gen.freqstr in (
|
|
'Q-NOV', 'Q-AUG', 'Q-MAY', 'Q-FEB')
|
|
is_oct_range = inf_freq == 'Q-OCT' and gen.freqstr in (
|
|
'Q-OCT', 'Q-JUL', 'Q-APR', 'Q-JAN')
|
|
assert is_dec_range or is_nov_range or is_oct_range
|
|
|
|
gen = date_range(start, periods=5, freq=freq)
|
|
index = _dti(gen.values)
|
|
|
|
if not freq.startswith('Q-'):
|
|
assert frequencies.infer_freq(index) == gen.freqstr
|
|
else:
|
|
inf_freq = frequencies.infer_freq(index)
|
|
is_dec_range = inf_freq == 'Q-DEC' and gen.freqstr in (
|
|
'Q', 'Q-DEC', 'Q-SEP', 'Q-JUN', 'Q-MAR')
|
|
is_nov_range = inf_freq == 'Q-NOV' and gen.freqstr in (
|
|
'Q-NOV', 'Q-AUG', 'Q-MAY', 'Q-FEB')
|
|
is_oct_range = inf_freq == 'Q-OCT' and gen.freqstr in (
|
|
'Q-OCT', 'Q-JUL', 'Q-APR', 'Q-JAN')
|
|
|
|
assert is_dec_range or is_nov_range or is_oct_range
|
|
|
|
def test_infer_freq(self):
|
|
rng = period_range('1959Q2', '2009Q3', freq='Q')
|
|
rng = Index(rng.to_timestamp('D', how='e').astype(object))
|
|
assert rng.inferred_freq == 'Q-DEC'
|
|
|
|
rng = period_range('1959Q2', '2009Q3', freq='Q-NOV')
|
|
rng = Index(rng.to_timestamp('D', how='e').astype(object))
|
|
assert rng.inferred_freq == 'Q-NOV'
|
|
|
|
rng = period_range('1959Q2', '2009Q3', freq='Q-OCT')
|
|
rng = Index(rng.to_timestamp('D', how='e').astype(object))
|
|
assert rng.inferred_freq == 'Q-OCT'
|
|
|
|
def test_infer_freq_tz(self):
|
|
|
|
freqs = {'AS-JAN':
|
|
['2009-01-01', '2010-01-01', '2011-01-01', '2012-01-01'],
|
|
'Q-OCT':
|
|
['2009-01-31', '2009-04-30', '2009-07-31', '2009-10-31'],
|
|
'M': ['2010-11-30', '2010-12-31', '2011-01-31', '2011-02-28'],
|
|
'W-SAT':
|
|
['2010-12-25', '2011-01-01', '2011-01-08', '2011-01-15'],
|
|
'D': ['2011-01-01', '2011-01-02', '2011-01-03', '2011-01-04'],
|
|
'H': ['2011-12-31 22:00', '2011-12-31 23:00',
|
|
'2012-01-01 00:00', '2012-01-01 01:00']}
|
|
|
|
# GH 7310
|
|
for tz in [None, 'Australia/Sydney', 'Asia/Tokyo', 'Europe/Paris',
|
|
'US/Pacific', 'US/Eastern']:
|
|
for expected, dates in compat.iteritems(freqs):
|
|
idx = DatetimeIndex(dates, tz=tz)
|
|
assert idx.inferred_freq == expected
|
|
|
|
def test_infer_freq_tz_transition(self):
|
|
# Tests for #8772
|
|
date_pairs = [['2013-11-02', '2013-11-5'], # Fall DST
|
|
['2014-03-08', '2014-03-11'], # Spring DST
|
|
['2014-01-01', '2014-01-03']] # Regular Time
|
|
freqs = ['3H', '10T', '3601S', '3600001L', '3600000001U',
|
|
'3600000000001N']
|
|
|
|
for tz in [None, 'Australia/Sydney', 'Asia/Tokyo', 'Europe/Paris',
|
|
'US/Pacific', 'US/Eastern']:
|
|
for date_pair in date_pairs:
|
|
for freq in freqs:
|
|
idx = date_range(date_pair[0], date_pair[
|
|
1], freq=freq, tz=tz)
|
|
assert idx.inferred_freq == freq
|
|
|
|
index = date_range("2013-11-03", periods=5,
|
|
freq="3H").tz_localize("America/Chicago")
|
|
assert index.inferred_freq is None
|
|
|
|
def test_infer_freq_businesshour(self):
|
|
# GH 7905
|
|
idx = DatetimeIndex(
|
|
['2014-07-01 09:00', '2014-07-01 10:00', '2014-07-01 11:00',
|
|
'2014-07-01 12:00', '2014-07-01 13:00', '2014-07-01 14:00'])
|
|
# hourly freq in a day must result in 'H'
|
|
assert idx.inferred_freq == 'H'
|
|
|
|
idx = DatetimeIndex(
|
|
['2014-07-01 09:00', '2014-07-01 10:00', '2014-07-01 11:00',
|
|
'2014-07-01 12:00', '2014-07-01 13:00', '2014-07-01 14:00',
|
|
'2014-07-01 15:00', '2014-07-01 16:00', '2014-07-02 09:00',
|
|
'2014-07-02 10:00', '2014-07-02 11:00'])
|
|
assert idx.inferred_freq == 'BH'
|
|
|
|
idx = DatetimeIndex(
|
|
['2014-07-04 09:00', '2014-07-04 10:00', '2014-07-04 11:00',
|
|
'2014-07-04 12:00', '2014-07-04 13:00', '2014-07-04 14:00',
|
|
'2014-07-04 15:00', '2014-07-04 16:00', '2014-07-07 09:00',
|
|
'2014-07-07 10:00', '2014-07-07 11:00'])
|
|
assert idx.inferred_freq == 'BH'
|
|
|
|
idx = DatetimeIndex(
|
|
['2014-07-04 09:00', '2014-07-04 10:00', '2014-07-04 11:00',
|
|
'2014-07-04 12:00', '2014-07-04 13:00', '2014-07-04 14:00',
|
|
'2014-07-04 15:00', '2014-07-04 16:00', '2014-07-07 09:00',
|
|
'2014-07-07 10:00', '2014-07-07 11:00', '2014-07-07 12:00',
|
|
'2014-07-07 13:00', '2014-07-07 14:00', '2014-07-07 15:00',
|
|
'2014-07-07 16:00', '2014-07-08 09:00', '2014-07-08 10:00',
|
|
'2014-07-08 11:00', '2014-07-08 12:00', '2014-07-08 13:00',
|
|
'2014-07-08 14:00', '2014-07-08 15:00', '2014-07-08 16:00'])
|
|
assert idx.inferred_freq == 'BH'
|
|
|
|
def test_not_monotonic(self):
|
|
rng = _dti(['1/31/2000', '1/31/2001', '1/31/2002'])
|
|
rng = rng[::-1]
|
|
assert rng.inferred_freq == '-1A-JAN'
|
|
|
|
def test_non_datetimeindex2(self):
|
|
rng = _dti(['1/31/2000', '1/31/2001', '1/31/2002'])
|
|
|
|
vals = rng.to_pydatetime()
|
|
|
|
result = frequencies.infer_freq(vals)
|
|
assert result == rng.inferred_freq
|
|
|
|
def test_invalid_index_types(self):
|
|
|
|
# test all index types
|
|
for i in [tm.makeIntIndex(10), tm.makeFloatIndex(10),
|
|
tm.makePeriodIndex(10)]:
|
|
pytest.raises(TypeError, lambda: frequencies.infer_freq(i))
|
|
|
|
# GH 10822
|
|
# odd error message on conversions to datetime for unicode
|
|
if not is_platform_windows():
|
|
for i in [tm.makeStringIndex(10), tm.makeUnicodeIndex(10)]:
|
|
pytest.raises(ValueError, lambda: frequencies.infer_freq(i))
|
|
|
|
def test_string_datetimelike_compat(self):
|
|
|
|
# GH 6463
|
|
expected = frequencies.infer_freq(['2004-01', '2004-02', '2004-03',
|
|
'2004-04'])
|
|
result = frequencies.infer_freq(Index(['2004-01', '2004-02', '2004-03',
|
|
'2004-04']))
|
|
assert result == expected
|
|
|
|
def test_series(self):
|
|
|
|
# GH6407
|
|
# inferring series
|
|
|
|
# invalid type of Series
|
|
for s in [Series(np.arange(10)), Series(np.arange(10.))]:
|
|
pytest.raises(TypeError, lambda: frequencies.infer_freq(s))
|
|
|
|
# a non-convertible string
|
|
pytest.raises(ValueError, lambda: frequencies.infer_freq(
|
|
Series(['foo', 'bar'])))
|
|
|
|
# cannot infer on PeriodIndex
|
|
for freq in [None, 'L']:
|
|
s = Series(period_range('2013', periods=10, freq=freq))
|
|
pytest.raises(TypeError, lambda: frequencies.infer_freq(s))
|
|
|
|
# DateTimeIndex
|
|
for freq in ['M', 'L', 'S']:
|
|
s = Series(date_range('20130101', periods=10, freq=freq))
|
|
inferred = frequencies.infer_freq(s)
|
|
assert inferred == freq
|
|
|
|
s = Series(date_range('20130101', '20130110'))
|
|
inferred = frequencies.infer_freq(s)
|
|
assert inferred == 'D'
|
|
|
|
def test_legacy_offset_warnings(self):
|
|
freqs = ['WEEKDAY', 'EOM', 'W@MON', 'W@TUE', 'W@WED', 'W@THU',
|
|
'W@FRI', 'W@SAT', 'W@SUN', 'Q@JAN', 'Q@FEB', 'Q@MAR',
|
|
'A@JAN', 'A@FEB', 'A@MAR', 'A@APR', 'A@MAY', 'A@JUN',
|
|
'A@JUL', 'A@AUG', 'A@SEP', 'A@OCT', 'A@NOV', 'A@DEC',
|
|
'Y@JAN', 'WOM@1MON', 'WOM@2MON', 'WOM@3MON',
|
|
'WOM@4MON', 'WOM@1TUE', 'WOM@2TUE', 'WOM@3TUE',
|
|
'WOM@4TUE', 'WOM@1WED', 'WOM@2WED', 'WOM@3WED',
|
|
'WOM@4WED', 'WOM@1THU', 'WOM@2THU', 'WOM@3THU',
|
|
'WOM@4THU', 'WOM@1FRI', 'WOM@2FRI', 'WOM@3FRI',
|
|
'WOM@4FRI']
|
|
|
|
msg = _INVALID_FREQ_ERROR
|
|
for freq in freqs:
|
|
with tm.assert_raises_regex(ValueError, msg):
|
|
frequencies.get_offset(freq)
|
|
|
|
with tm.assert_raises_regex(ValueError, msg):
|
|
date_range('2011-01-01', periods=5, freq=freq)
|