def test_period_ordinal_start_values(self):
# information for 1.1.1970
assert period_ordinal(1970, 1, 1, 0, 0, 0, 0, 0, get_freq('A')) == 0
assert period_ordinal(1970, 1, 1, 0, 0, 0, 0, 0, get_freq('M')) == 0
assert period_ordinal(1970, 1, 1, 0, 0, 0, 0, 0, get_freq('W')) == 1
assert period_ordinal(1970, 1, 1, 0, 0, 0, 0, 0, get_freq('D')) == 0
assert period_ordinal(1970, 1, 1, 0, 0, 0, 0, 0, get_freq('B')) == 0
def test_period_ordinal_week(self):
assert period_ordinal(1970, 1, 4, 0, 0, 0, 0, 0, get_freq('W')) == 1
assert period_ordinal(1970, 1, 5, 0, 0, 0, 0, 0, get_freq('W')) == 2
assert period_ordinal(2013, 10, 6, 0, 0, 0, 0, 0,
get_freq('W')) == 2284
assert period_ordinal(2013, 10, 7, 0, 0, 0, 0, 0,
get_freq('W')) == 2285
def test_period_ordinal_week(self):
assert period_ordinal(1970, 1, 4, 0, 0, 0, 0, 0, get_freq('W')) == 1
assert period_ordinal(1970, 1, 5, 0, 0, 0, 0, 0, get_freq('W')) == 2
assert period_ordinal(2013, 10, 6, 0,
0, 0, 0, 0, get_freq('W')) == 2284
assert period_ordinal(2013, 10, 7, 0,
0, 0, 0, 0, get_freq('W')) == 2285
def test_period_ordinal_start_values(self):
# information for 1.1.1970
assert period_ordinal(1970, 1, 1, 0, 0, 0, 0, 0, get_freq('A')) == 0
assert period_ordinal(1970, 1, 1, 0, 0, 0, 0, 0, get_freq('M')) == 0
assert period_ordinal(1970, 1, 1, 0, 0, 0, 0, 0, get_freq('W')) == 1
assert period_ordinal(1970, 1, 1, 0, 0, 0, 0, 0, get_freq('D')) == 0
assert period_ordinal(1970, 1, 1, 0, 0, 0, 0, 0, get_freq('B')) == 0
def _use_dynamic_x(ax, data):
freq = _get_index_freq(data)
ax_freq = _get_ax_freq(ax)
if freq is None: # convert irregular if axes has freq info
freq = ax_freq
else: # do not use tsplot if irregular was plotted first
if (ax_freq is None) and (len(ax.get_lines()) > 0):
return False
if freq is None:
return False
if isinstance(freq, DateOffset):
freq = freq.rule_code
else:
freq = get_base_alias(freq)
freq = frequencies.get_period_alias(freq)
if freq is None:
return False
# hack this for 0.10.1, creating more technical debt...sigh
if isinstance(data.index, ABCDatetimeIndex):
base = get_freq(freq)
x = data.index
if base <= FreqGroup.FR_DAY:
return x[:1].is_normalized
return Period(x[0], freq).to_timestamp(tz=x.tz) == x[0]
return True
def _use_dynamic_x(ax, data):
freq = _get_index_freq(data)
ax_freq = _get_ax_freq(ax)
if freq is None: # convert irregular if axes has freq info
freq = ax_freq
else: # do not use tsplot if irregular was plotted first
if (ax_freq is None) and (len(ax.get_lines()) > 0):
return False
if freq is None:
return False
if isinstance(freq, DateOffset):
freq = freq.rule_code
else:
freq = get_base_alias(freq)
freq = frequencies.get_period_alias(freq)
if freq is None:
return False
# hack this for 0.10.1, creating more technical debt...sigh
if isinstance(data.index, ABCDatetimeIndex):
base = get_freq(freq)
x = data.index
if (base <= FreqGroup.FR_DAY):
return x[:1].is_normalized
return Period(x[0], freq).to_timestamp(tz=x.tz) == x[0]
return True
def __init__(self, freq, minor_locator=False, dynamic_mode=True,
base=1, quarter=1, month=1, day=1, plot_obj=None):
if isinstance(freq, str):
freq = get_freq(freq)
self.freq = freq
self.base = base
(self.quarter, self.month, self.day) = (quarter, month, day)
self.isminor = minor_locator
self.isdynamic = dynamic_mode
self.offset = 0
self.plot_obj = plot_obj
self.finder = get_finder(freq)
def __init__(self, freq, minor_locator=False, dynamic_mode=True, plot_obj=None):
if isinstance(freq, str):
freq = get_freq(freq)
self.format = None
self.freq = freq
self.locs = []
self.formatdict = None
self.isminor = minor_locator
self.isdynamic = dynamic_mode
self.offset = 0
self.plot_obj = plot_obj
self.finder = get_finder(freq)
def __init__(self, freq, minor_locator=False, dynamic_mode=True,
base=1, quarter=1, month=1, day=1, plot_obj=None):
if isinstance(freq, str):
freq = get_freq(freq)
self.freq = freq
self.base = base
(self.quarter, self.month, self.day) = (quarter, month, day)
self.isminor = minor_locator
self.isdynamic = dynamic_mode
self.offset = 0
self.plot_obj = plot_obj
self.finder = get_finder(freq)
def test_freq_code(self):
assert get_freq('A') == 1000
assert get_freq('3A') == 1000
assert get_freq('-1A') == 1000
assert get_freq('Y') == 1000
assert get_freq('3Y') == 1000
assert get_freq('-1Y') == 1000
assert get_freq('W') == 4000
assert get_freq('W-MON') == 4001
assert get_freq('W-FRI') == 4005
for freqstr, code in compat.iteritems(_period_code_map):
result = 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_code(self):
assert get_freq('A') == 1000
assert get_freq('3A') == 1000
assert get_freq('-1A') == 1000
assert get_freq('Y') == 1000
assert get_freq('3Y') == 1000
assert get_freq('-1Y') == 1000
assert get_freq('W') == 4000
assert get_freq('W-MON') == 4001
assert get_freq('W-FRI') == 4005
for freqstr, code in compat.iteritems(_period_code_map):
result = 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 __init__(self, freq, minor_locator=False, dynamic_mode=True,
plot_obj=None):
if isinstance(freq, str):
freq = get_freq(freq)
self.format = None
self.freq = freq
self.locs = []
self.formatdict = None
self.isminor = minor_locator
self.isdynamic = dynamic_mode
self.offset = 0
self.plot_obj = plot_obj
self.finder = get_finder(freq)
def get_finder(freq):
if isinstance(freq, str):
freq = get_freq(freq)
fgroup = resolution.get_freq_group(freq)
if fgroup == FreqGroup.FR_ANN:
return _annual_finder
elif fgroup == FreqGroup.FR_QTR:
return _quarterly_finder
elif freq == FreqGroup.FR_MTH:
return _monthly_finder
elif (freq >= FreqGroup.FR_BUS) or fgroup == FreqGroup.FR_WK:
return _daily_finder
else: # pragma: no cover
raise NotImplementedError(f"Unsupported frequency: {freq}")
def get_finder(freq):
if isinstance(freq, str):
freq = get_freq(freq)
fgroup = resolution.get_freq_group(freq)
if fgroup == FreqGroup.FR_ANN:
return _annual_finder
elif fgroup == FreqGroup.FR_QTR:
return _quarterly_finder
elif freq == FreqGroup.FR_MTH:
return _monthly_finder
elif ((freq >= FreqGroup.FR_BUS) or fgroup == FreqGroup.FR_WK):
return _daily_finder
else: # pragma: no cover
errmsg = "Unsupported frequency: {freq}".format(freq=freq)
raise NotImplementedError(errmsg)
def get_finder(freq):
if isinstance(freq, compat.string_types):
freq = get_freq(freq)
fgroup = resolution.get_freq_group(freq)
if fgroup == FreqGroup.FR_ANN:
return _annual_finder
elif fgroup == FreqGroup.FR_QTR:
return _quarterly_finder
elif freq == FreqGroup.FR_MTH:
return _monthly_finder
elif ((freq >= FreqGroup.FR_BUS) or fgroup == FreqGroup.FR_WK):
return _daily_finder
else: # pragma: no cover
errmsg = "Unsupported frequency: {freq}".format(freq=freq)
raise NotImplementedError(errmsg)
def test_period_ordinal_business_day(self):
# Thursday
assert period_ordinal(2013, 10, 3, 0,
0, 0, 0, 0, get_freq('B')) == 11415
# Friday
assert period_ordinal(2013, 10, 4, 0,
0, 0, 0, 0, get_freq('B')) == 11416
# Saturday
assert period_ordinal(2013, 10, 5, 0,
0, 0, 0, 0, get_freq('B')) == 11417
# Sunday
assert period_ordinal(2013, 10, 6, 0,
0, 0, 0, 0, get_freq('B')) == 11417
# Monday
assert period_ordinal(2013, 10, 7, 0,
0, 0, 0, 0, get_freq('B')) == 11417
# Tuesday
assert period_ordinal(2013, 10, 8, 0,
0, 0, 0, 0, get_freq('B')) == 11418
def test_period_ordinal_business_day(self):
# Thursday
assert period_ordinal(2013, 10, 3, 0, 0, 0, 0, 0,
get_freq('B')) == 11415
# Friday
assert period_ordinal(2013, 10, 4, 0, 0, 0, 0, 0,
get_freq('B')) == 11416
# Saturday
assert period_ordinal(2013, 10, 5, 0, 0, 0, 0, 0,
get_freq('B')) == 11417
# Sunday
assert period_ordinal(2013, 10, 6, 0, 0, 0, 0, 0,
get_freq('B')) == 11417
# Monday
assert period_ordinal(2013, 10, 7, 0, 0, 0, 0, 0,
get_freq('B')) == 11417
# Tuesday
assert period_ordinal(2013, 10, 8, 0, 0, 0, 0, 0,
get_freq('B')) == 11418
def test_period_ordinal_start_values(freq, expected):
# information for Jan. 1, 1970.
assert period_ordinal(1970, 1, 1, 0, 0, 0,
0, 0, get_freq(freq)) == expected
def test_intra_day_conversion_factors(freq1, freq2, expected):
assert period_asfreq(1, get_freq(freq1),
get_freq(freq2), False) == expected
@pytest.mark.parametrize("args", [
(0.5, "N"),
# Too much precision in the input can prevent.
(0.3429324798798269273987982, "H")
])
def test_cat(args):
msg = "Could not convert to integer offset at any resolution"
with pytest.raises(ValueError, match=msg):
_reso.get_stride_from_decimal(*args)
@pytest.mark.parametrize("freq_input,expected", [
# Frequency string.
("A", (get_freq("A"), 1)),
("3D", (get_freq("D"), 3)),
("-2M", (get_freq("M"), -2)),
# Tuple.
(("D", 1), (get_freq("D"), 1)),
(("A", 3), (get_freq("A"), 3)),
(("M", -2), (get_freq("M"), -2)),
((5, "T"), (FreqGroup.FR_MIN, 5)),
# Numeric Tuple.
((1000, 1), (1000, 1)),
# Offsets.
(offsets.Day(), (get_freq("D"), 1)),
(offsets.Day(3), (get_freq("D"), 3)),
# Too much precision in the input can prevent.
(0.3429324798798269273987982, "H")
])
def test_cat(args):
msg = "Could not convert to integer offset at any resolution"
with pytest.raises(ValueError, match=msg):
_reso.get_stride_from_decimal(*args)
@pytest.mark.parametrize(
"freq_input,expected",
[
# Frequency string.
("A", (get_freq("A"), 1)),
("3D", (get_freq("D"), 3)),
("-2M", (get_freq("M"), -2)),
# Tuple.
(("D", 1), (get_freq("D"), 1)),
(("A", 3), (get_freq("A"), 3)),
(("M", -2), (get_freq("M"), -2)),
((5, "T"), (FreqGroup.FR_MIN, 5)),
# Numeric Tuple.
((1000, 1), (1000, 1)),
# Offsets.
(offsets.Day(), (get_freq("D"), 1)),
(offsets.Day(3), (get_freq("D"), 3)),
def test_intraday_conversion_factors(self):
assert period_asfreq(1, get_freq('D'), get_freq('H'), False) == 24
assert period_asfreq(1, get_freq('D'), get_freq('T'), False) == 1440
assert period_asfreq(1, get_freq('D'), get_freq('S'), False) == 86400
assert period_asfreq(1, get_freq('D'), get_freq('L'),
False) == 86400000
assert period_asfreq(1, get_freq('D'), get_freq('U'),
False) == 86400000000
assert period_asfreq(1, get_freq('D'), get_freq('N'),
False) == 86400000000000
assert period_asfreq(1, get_freq('H'), get_freq('T'), False) == 60
assert period_asfreq(1, get_freq('H'), get_freq('S'), False) == 3600
assert period_asfreq(1, get_freq('H'), get_freq('L'), False) == 3600000
assert period_asfreq(1, get_freq('H'), get_freq('U'),
False) == 3600000000
assert period_asfreq(1, get_freq('H'), get_freq('N'),
False) == 3600000000000
assert period_asfreq(1, get_freq('T'), get_freq('S'), False) == 60
assert period_asfreq(1, get_freq('T'), get_freq('L'), False) == 60000
assert period_asfreq(1, get_freq('T'), get_freq('U'),
False) == 60000000
assert period_asfreq(1, get_freq('T'), get_freq('N'),
False) == 60000000000
assert period_asfreq(1, get_freq('S'), get_freq('L'), False) == 1000
assert period_asfreq(1, get_freq('S'), get_freq('U'), False) == 1000000
assert period_asfreq(1, get_freq('S'), get_freq('N'),
False) == 1000000000
assert period_asfreq(1, get_freq('L'), get_freq('U'), False) == 1000
assert period_asfreq(1, get_freq('L'), get_freq('N'), False) == 1000000
assert period_asfreq(1, get_freq('U'), get_freq('N'), False) == 1000
def test_intraday_conversion_factors(self):
assert period_asfreq(1, get_freq('D'), get_freq('H'), False) == 24
assert period_asfreq(1, get_freq('D'), get_freq('T'), False) == 1440
assert period_asfreq(1, get_freq('D'), get_freq('S'), False) == 86400
assert period_asfreq(1, get_freq('D'),
get_freq('L'), False) == 86400000
assert period_asfreq(1, get_freq('D'),
get_freq('U'), False) == 86400000000
assert period_asfreq(1, get_freq('D'),
get_freq('N'), False) == 86400000000000
assert period_asfreq(1, get_freq('H'), get_freq('T'), False) == 60
assert period_asfreq(1, get_freq('H'), get_freq('S'), False) == 3600
assert period_asfreq(1, get_freq('H'),
get_freq('L'), False) == 3600000
assert period_asfreq(1, get_freq('H'),
get_freq('U'), False) == 3600000000
assert period_asfreq(1, get_freq('H'),
get_freq('N'), False) == 3600000000000
assert period_asfreq(1, get_freq('T'), get_freq('S'), False) == 60
assert period_asfreq(1, get_freq('T'), get_freq('L'), False) == 60000
assert period_asfreq(1, get_freq('T'),
get_freq('U'), False) == 60000000
assert period_asfreq(1, get_freq('T'),
get_freq('N'), False) == 60000000000
assert period_asfreq(1, get_freq('S'), get_freq('L'), False) == 1000
assert period_asfreq(1, get_freq('S'),
get_freq('U'), False) == 1000000
assert period_asfreq(1, get_freq('S'),
get_freq('N'), False) == 1000000000
assert period_asfreq(1, get_freq('L'), get_freq('U'), False) == 1000
assert period_asfreq(1, get_freq('L'),
get_freq('N'), False) == 1000000
assert period_asfreq(1, get_freq('U'), get_freq('N'), False) == 1000
def test_get_freq_code(self):
# frequency str
assert (get_freq_code('A') == (get_freq('A'), 1))
assert (get_freq_code('3D') == (get_freq('D'), 3))
assert (get_freq_code('-2M') == (get_freq('M'), -2))
# tuple
assert (get_freq_code(('D', 1)) == (get_freq('D'), 1))
assert (get_freq_code(('A', 3)) == (get_freq('A'), 3))
assert (get_freq_code(('M', -2)) == (get_freq('M'), -2))
# numeric tuple
assert get_freq_code((1000, 1)) == (1000, 1)
# offsets
assert (get_freq_code(offsets.Day()) == (get_freq('D'), 1))
assert (get_freq_code(offsets.Day(3)) == (get_freq('D'), 3))
assert (get_freq_code(offsets.Day(-2)) == (get_freq('D'), -2))
assert (get_freq_code(offsets.MonthEnd()) == (get_freq('M'), 1))
assert (get_freq_code(offsets.MonthEnd(3)) == (get_freq('M'), 3))
assert (get_freq_code(offsets.MonthEnd(-2)) == (get_freq('M'), -2))
assert (get_freq_code(offsets.Week()) == (get_freq('W'), 1))
assert (get_freq_code(offsets.Week(3)) == (get_freq('W'), 3))
assert (get_freq_code(offsets.Week(-2)) == (get_freq('W'), -2))
# Monday is weekday=0
assert (get_freq_code(offsets.Week(weekday=1)) == (get_freq('W-TUE'),
1))
assert (get_freq_code(offsets.Week(3,
weekday=0)) == (get_freq('W-MON'),
3))
assert (get_freq_code(offsets.Week(-2,
weekday=4)) == (get_freq('W-FRI'),
-2))
def test_freq_code_match(period_code_item):
freqstr, code = period_code_item
assert get_freq(freqstr) == code
def test_freq_code(freqstr, expected):
assert get_freq(freqstr) == expected
def test_period_ordinal_week(dt, expected):
args = dt + (get_freq("W"),)
assert period_ordinal(*args) == expected
def test_period_ordinal_business_day(day, expected):
args = (2013, 10, day, 0, 0, 0, 0, 0, get_freq("B"))
assert period_ordinal(*args) == expected
def test_freq_code(freqstr, expected):
assert get_freq(freqstr) == expected
def test_freq_code_match(period_code_item):
freqstr, code = period_code_item
assert get_freq(freqstr) == code
def test_get_freq_code(self):
# frequency str
assert (get_freq_code('A') ==
(get_freq('A'), 1))
assert (get_freq_code('3D') ==
(get_freq('D'), 3))
assert (get_freq_code('-2M') ==
(get_freq('M'), -2))
# tuple
assert (get_freq_code(('D', 1)) ==
(get_freq('D'), 1))
assert (get_freq_code(('A', 3)) ==
(get_freq('A'), 3))
assert (get_freq_code(('M', -2)) ==
(get_freq('M'), -2))
# numeric tuple
assert get_freq_code((1000, 1)) == (1000, 1)
# offsets
assert (get_freq_code(offsets.Day()) ==
(get_freq('D'), 1))
assert (get_freq_code(offsets.Day(3)) ==
(get_freq('D'), 3))
assert (get_freq_code(offsets.Day(-2)) ==
(get_freq('D'), -2))
assert (get_freq_code(offsets.MonthEnd()) ==
(get_freq('M'), 1))
assert (get_freq_code(offsets.MonthEnd(3)) ==
(get_freq('M'), 3))
assert (get_freq_code(offsets.MonthEnd(-2)) ==
(get_freq('M'), -2))
assert (get_freq_code(offsets.Week()) ==
(get_freq('W'), 1))
assert (get_freq_code(offsets.Week(3)) ==
(get_freq('W'), 3))
assert (get_freq_code(offsets.Week(-2)) ==
(get_freq('W'), -2))
# Monday is weekday=0
assert (get_freq_code(offsets.Week(weekday=1)) ==
(get_freq('W-TUE'), 1))
assert (get_freq_code(offsets.Week(3, weekday=0)) ==
(get_freq('W-MON'), 3))
assert (get_freq_code(offsets.Week(-2, weekday=4)) ==
(get_freq('W-FRI'), -2))
