def test_period_ordinal_start_values(self):
# information for 1.1.1970
self.assertEqual(0, period_ordinal(1970, 1, 1, 0, 0, 0, 0, 0, get_freq("Y")))
self.assertEqual(0, period_ordinal(1970, 1, 1, 0, 0, 0, 0, 0, get_freq("M")))
self.assertEqual(1, period_ordinal(1970, 1, 1, 0, 0, 0, 0, 0, get_freq("W")))
self.assertEqual(0, period_ordinal(1970, 1, 1, 0, 0, 0, 0, 0, get_freq("D")))
self.assertEqual(0, period_ordinal(1970, 1, 1, 0, 0, 0, 0, 0, get_freq("B")))
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
self.assertEqual(0, period_ordinal(1970, 1, 1, 0, 0, 0, 0, 0, get_freq('Y')))
self.assertEqual(0, period_ordinal(1970, 1, 1, 0, 0, 0, 0, 0, get_freq('M')))
self.assertEqual(1, period_ordinal(1970, 1, 1, 0, 0, 0, 0, 0, get_freq('W')))
self.assertEqual(0, period_ordinal(1970, 1, 1, 0, 0, 0, 0, 0, get_freq('D')))
self.assertEqual(0, period_ordinal(1970, 1, 1, 0, 0, 0, 0, 0, get_freq('B')))
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 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_start_values(self):
# information for 1.1.1970
self.assertEqual(0, period_ordinal(1970, 1, 1, 0, 0, 0, 0, 0, get_freq('Y')))
self.assertEqual(0, period_ordinal(1970, 1, 1, 0, 0, 0, 0, 0, get_freq('M')))
self.assertEqual(1, period_ordinal(1970, 1, 1, 0, 0, 0, 0, 0, get_freq('W')))
self.assertEqual(0, period_ordinal(1970, 1, 1, 0, 0, 0, 0, 0, get_freq('D')))
self.assertEqual(0, period_ordinal(1970, 1, 1, 0, 0, 0, 0, 0, get_freq('B')))
def test_period_ordinal_week(self):
self.assertEqual(1, period_ordinal(1970, 1, 4, 0, 0, 0, 0, 0,
get_freq('W')))
self.assertEqual(2, period_ordinal(1970, 1, 5, 0, 0, 0, 0, 0,
get_freq('W')))
self.assertEqual(2284, period_ordinal(2013, 10, 6, 0, 0, 0, 0, 0,
get_freq('W')))
self.assertEqual(2285, period_ordinal(2013, 10, 7, 0, 0, 0, 0, 0,
get_freq('W')))
def test_period_ordinal_week(self):
self.assertEqual(
1, period_ordinal(1970, 1, 4, 0, 0, 0, 0, 0, get_freq('W')))
self.assertEqual(
2, period_ordinal(1970, 1, 5, 0, 0, 0, 0, 0, get_freq('W')))
self.assertEqual(
2284, period_ordinal(2013, 10, 6, 0, 0, 0, 0, 0, get_freq('W')))
self.assertEqual(
2285, period_ordinal(2013, 10, 7, 0, 0, 0, 0, 0, get_freq('W')))
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 = frequencies.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, DatetimeIndex):
base = frequencies.get_freq(freq)
x = data.index
if (base <= frequencies.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 = frequencies.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 = frequencies.get_freq(freq)
x = data.index
if (base <= frequencies.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, basestring):
freq = frequencies.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,
base=1, quarter=1, month=1, day=1, plot_obj=None):
if isinstance(freq, compat.string_types):
freq = frequencies.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, basestring):
freq = frequencies.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 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_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 __init__(self, freq, minor_locator=False, dynamic_mode=True,
plot_obj=None):
if isinstance(freq, compat.string_types):
freq = frequencies.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 _quarterly_finder(vmin, vmax, freq):
if isinstance(freq, basestring):
freq = frequencies.get_freq(freq)
if frequencies.get_freq_group(freq) != FreqGroup.FR_QTR:
raise ValueError("Unexpected frequency")
periodsperyear = 4
vmin_orig = vmin
(vmin, vmax) = (int(vmin), int(vmax))
span = vmax - vmin + 1
#............................................
info = np.zeros(span,
dtype=[('val', int), ('maj', bool), ('min', bool),
('fmt', '|S8')])
info['val'] = np.arange(vmin, vmax + 1)
info['fmt'] = ''
dates_ = info['val']
info_maj = info['maj']
info_fmt = info['fmt']
year_start = (dates_ % 4 == 0).nonzero()[0]
#..............
if span <= 3.5 * periodsperyear:
info_maj[year_start] = True
info['min'] = True
info_fmt[:] = 'Q%q'
info_fmt[year_start] = 'Q%q\n%F'
if not has_level_label(year_start, vmin_orig):
if dates_.size > 1:
idx = 1
else:
idx = 0
info_fmt[idx] = 'Q%q\n%F'
#..............
elif span <= 11 * periodsperyear:
info_maj[year_start] = True
info['min'] = True
info_fmt[year_start] = '%F'
#..............
else:
years = dates_[year_start] // 4 + 1
nyears = span / periodsperyear
(min_anndef, maj_anndef) = _get_default_annual_spacing(nyears)
major_idx = year_start[(years % maj_anndef == 0)]
info_maj[major_idx] = True
info['min'][year_start[(years % min_anndef == 0)]] = True
info_fmt[major_idx] = '%F'
#..............
return info
def _quarterly_finder(vmin, vmax, freq):
if isinstance(freq, basestring):
freq = frequencies.get_freq(freq)
if frequencies.get_freq_group(freq) != FreqGroup.FR_QTR:
raise ValueError("Unexpected frequency")
periodsperyear = 4
vmin_orig = vmin
(vmin, vmax) = (int(vmin), int(vmax))
span = vmax - vmin + 1
#............................................
info = np.zeros(span,
dtype=[('val', int), ('maj', bool), ('min', bool),
('fmt', '|S8')])
info['val'] = np.arange(vmin, vmax + 1)
info['fmt'] = ''
dates_ = info['val']
info_maj = info['maj']
info_fmt = info['fmt']
year_start = (dates_ % 4 == 1).nonzero()[0]
#..............
if span <= 3.5 * periodsperyear:
info_maj[year_start] = True
info['min'] = True
info_fmt[:] = 'Q%q'
info_fmt[year_start] = 'Q%q\n%F'
if not has_level_label(year_start, vmin_orig):
if dates_.size > 1:
idx = 1
else:
idx = 0
info_fmt[idx] = 'Q%q\n%F'
#..............
elif span <= 11 * periodsperyear:
info_maj[year_start] = True
info['min'] = True
info_fmt[year_start] = '%F'
#..............
else:
years = dates_[year_start] // 4 + 1
nyears = span / periodsperyear
(min_anndef, maj_anndef) = _get_default_annual_spacing(nyears)
major_idx = year_start[(years % maj_anndef == 0)]
info_maj[major_idx] = True
info['min'][year_start[(years % min_anndef == 0)]] = True
info_fmt[major_idx] = '%F'
#..............
return info
def get_finder(freq):
if isinstance(freq, basestring):
freq = frequencies.get_freq(freq)
fgroup = frequencies.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: %s" % (freq)
raise NotImplementedError(errmsg)
def get_finder(freq):
if isinstance(freq, compat.string_types):
freq = frequencies.get_freq(freq)
fgroup = frequencies.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: %s" % (freq)
raise NotImplementedError(errmsg)
def get_finder(freq):
if isinstance(freq, compat.string_types):
freq = frequencies.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
self.assertEqual(11415, period_ordinal(2013, 10, 3, 0, 0, 0, 0, 0, get_freq('B')))
# Friday
self.assertEqual(11416, period_ordinal(2013, 10, 4, 0, 0, 0, 0, 0, get_freq('B')))
# Saturday
self.assertEqual(11417, period_ordinal(2013, 10, 5, 0, 0, 0, 0, 0, get_freq('B')))
# Sunday
self.assertEqual(11417, period_ordinal(2013, 10, 6, 0, 0, 0, 0, 0, get_freq('B')))
# Monday
self.assertEqual(11417, period_ordinal(2013, 10, 7, 0, 0, 0, 0, 0, get_freq('B')))
# Tuesday
self.assertEqual(11418, period_ordinal(2013, 10, 8, 0, 0, 0, 0, 0, get_freq('B')))
def test_period_ordinal_business_day(self):
# Thursday
self.assertEqual(11415, period_ordinal(2013, 10, 3, 0, 0, 0, 0, 0, get_freq('B')))
# Friday
self.assertEqual(11416, period_ordinal(2013, 10, 4, 0, 0, 0, 0, 0, get_freq('B')))
# Saturday
self.assertEqual(11417, period_ordinal(2013, 10, 5, 0, 0, 0, 0, 0, get_freq('B')))
# Sunday
self.assertEqual(11417, period_ordinal(2013, 10, 6, 0, 0, 0, 0, 0, get_freq('B')))
# Monday
self.assertEqual(11417, period_ordinal(2013, 10, 7, 0, 0, 0, 0, 0, get_freq('B')))
# Tuesday
self.assertEqual(11418, period_ordinal(2013, 10, 8, 0, 0, 0, 0, 0, get_freq('B')))
def test_freq_code(self):
self.assertEqual(frequencies.get_freq('A'), 1000)
self.assertEqual(frequencies.get_freq('3A'), 1000)
self.assertEqual(frequencies.get_freq('-1A'), 1000)
self.assertEqual(frequencies.get_freq('W'), 4000)
self.assertEqual(frequencies.get_freq('W-MON'), 4001)
self.assertEqual(frequencies.get_freq('W-FRI'), 4005)
for freqstr, code in compat.iteritems(frequencies._period_code_map):
result = frequencies.get_freq(freqstr)
self.assertEqual(result, code)
result = frequencies.get_freq_group(freqstr)
self.assertEqual(result, code // 1000 * 1000)
result = frequencies.get_freq_group(code)
self.assertEqual(result, code // 1000 * 1000)
def test_freq_code(self):
self.assertEqual(frequencies.get_freq("A"), 1000)
self.assertEqual(frequencies.get_freq("3A"), 1000)
self.assertEqual(frequencies.get_freq("-1A"), 1000)
self.assertEqual(frequencies.get_freq("W"), 4000)
self.assertEqual(frequencies.get_freq("W-MON"), 4001)
self.assertEqual(frequencies.get_freq("W-FRI"), 4005)
for freqstr, code in compat.iteritems(frequencies._period_code_map):
result = frequencies.get_freq(freqstr)
self.assertEqual(result, code)
result = frequencies.get_freq_group(freqstr)
self.assertEqual(result, code // 1000 * 1000)
result = frequencies.get_freq_group(code)
self.assertEqual(result, code // 1000 * 1000)
def _annual_finder(vmin, vmax, freq):
if isinstance(freq, basestring):
freq = frequencies.get_freq(freq)
if frequencies.get_freq_group(freq) != FreqGroup.FR_ANN:
raise ValueError("Unexpected frequency")
(vmin, vmax) = (int(vmin), int(vmax + 1))
span = vmax - vmin + 1
# ..............
info = np.zeros(span, dtype=[("val", int), ("maj", bool), ("min", bool), ("fmt", "|S8")])
info["val"] = np.arange(vmin, vmax + 1)
info["fmt"] = ""
dates_ = info["val"]
# ..............
(min_anndef, maj_anndef) = _get_default_annual_spacing(span)
major_idx = dates_ % maj_anndef == 0
info["maj"][major_idx] = True
info["min"][(dates_ % min_anndef == 0)] = True
info["fmt"][major_idx] = "%Y"
# ..............
return info
def _annual_finder(vmin, vmax, freq):
if isinstance(freq, basestring):
freq = frequencies.get_freq(freq)
if frequencies.get_freq_group(freq) != FreqGroup.FR_ANN:
raise ValueError("Unexpected frequency")
(vmin, vmax) = (int(vmin), int(vmax + 1))
span = vmax - vmin + 1
#..............
info = np.zeros(span,
dtype=[('val', int), ('maj', bool), ('min', bool),
('fmt', '|S8')])
info['val'] = np.arange(vmin, vmax + 1)
info['fmt'] = ''
dates_ = info['val']
#..............
(min_anndef, maj_anndef) = _get_default_annual_spacing(span)
major_idx = dates_ % maj_anndef == 0
info['maj'][major_idx] = True
info['min'][(dates_ % min_anndef == 0)] = True
info['fmt'][major_idx] = '%Y'
#..............
return info
def _annual_finder(vmin, vmax, freq):
if isinstance(freq, basestring):
freq = frequencies.get_freq(freq)
if frequencies.get_freq_group(freq) != FreqGroup.FR_ANN:
raise ValueError("Unexpected frequency")
(vmin, vmax) = (int(vmin), int(vmax + 1))
span = vmax - vmin + 1
#..............
info = np.zeros(span,
dtype=[('val', int), ('maj', bool), ('min', bool),
('fmt', '|S8')])
info['val'] = np.arange(vmin, vmax + 1)
info['fmt'] = ''
dates_ = info['val']
#..............
(min_anndef, maj_anndef) = _get_default_annual_spacing(span)
major_idx = dates_ % maj_anndef == 0
info['maj'][major_idx] = True
info['min'][(dates_ % min_anndef == 0)] = True
info['fmt'][major_idx] = '%Y'
#..............
return info
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_intraday_conversion_factors(self):
self.assertEqual(period_asfreq(1, get_freq('D'), get_freq('H'), False), 24)
self.assertEqual(period_asfreq(1, get_freq('D'), get_freq('T'), False), 1440)
self.assertEqual(period_asfreq(1, get_freq('D'), get_freq('S'), False), 86400)
self.assertEqual(period_asfreq(1, get_freq('D'), get_freq('L'), False), 86400000)
self.assertEqual(period_asfreq(1, get_freq('D'), get_freq('U'), False), 86400000000)
self.assertEqual(period_asfreq(1, get_freq('D'), get_freq('N'), False), 86400000000000)
self.assertEqual(period_asfreq(1, get_freq('H'), get_freq('T'), False), 60)
self.assertEqual(period_asfreq(1, get_freq('H'), get_freq('S'), False), 3600)
self.assertEqual(period_asfreq(1, get_freq('H'), get_freq('L'), False), 3600000)
self.assertEqual(period_asfreq(1, get_freq('H'), get_freq('U'), False), 3600000000)
self.assertEqual(period_asfreq(1, get_freq('H'), get_freq('N'), False), 3600000000000)
self.assertEqual(period_asfreq(1, get_freq('T'), get_freq('S'), False), 60)
self.assertEqual(period_asfreq(1, get_freq('T'), get_freq('L'), False), 60000)
self.assertEqual(period_asfreq(1, get_freq('T'), get_freq('U'), False), 60000000)
self.assertEqual(period_asfreq(1, get_freq('T'), get_freq('N'), False), 60000000000)
self.assertEqual(period_asfreq(1, get_freq('S'), get_freq('L'), False), 1000)
self.assertEqual(period_asfreq(1, get_freq('S'), get_freq('U'), False), 1000000)
self.assertEqual(period_asfreq(1, get_freq('S'), get_freq('N'), False), 1000000000)
self.assertEqual(period_asfreq(1, get_freq('L'), get_freq('U'), False), 1000)
self.assertEqual(period_asfreq(1, get_freq('L'), get_freq('N'), False), 1000000)
self.assertEqual(period_asfreq(1, get_freq('U'), get_freq('N'), False), 1000)
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_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):
# freqstr
self.assertEqual(frequencies.get_freq_code("A"), (frequencies.get_freq("A"), 1))
self.assertEqual(frequencies.get_freq_code("3D"), (frequencies.get_freq("D"), 3))
self.assertEqual(frequencies.get_freq_code("-2M"), (frequencies.get_freq("M"), -2))
# tuple
self.assertEqual(frequencies.get_freq_code(("D", 1)), (frequencies.get_freq("D"), 1))
self.assertEqual(frequencies.get_freq_code(("A", 3)), (frequencies.get_freq("A"), 3))
self.assertEqual(frequencies.get_freq_code(("M", -2)), (frequencies.get_freq("M"), -2))
# numeric tuple
self.assertEqual(frequencies.get_freq_code((1000, 1)), (1000, 1))
# offsets
self.assertEqual(frequencies.get_freq_code(offsets.Day()), (frequencies.get_freq("D"), 1))
self.assertEqual(frequencies.get_freq_code(offsets.Day(3)), (frequencies.get_freq("D"), 3))
self.assertEqual(frequencies.get_freq_code(offsets.Day(-2)), (frequencies.get_freq("D"), -2))
self.assertEqual(frequencies.get_freq_code(offsets.MonthEnd()), (frequencies.get_freq("M"), 1))
self.assertEqual(frequencies.get_freq_code(offsets.MonthEnd(3)), (frequencies.get_freq("M"), 3))
self.assertEqual(frequencies.get_freq_code(offsets.MonthEnd(-2)), (frequencies.get_freq("M"), -2))
self.assertEqual(frequencies.get_freq_code(offsets.Week()), (frequencies.get_freq("W"), 1))
self.assertEqual(frequencies.get_freq_code(offsets.Week(3)), (frequencies.get_freq("W"), 3))
self.assertEqual(frequencies.get_freq_code(offsets.Week(-2)), (frequencies.get_freq("W"), -2))
# monday is weekday=0
self.assertEqual(frequencies.get_freq_code(offsets.Week(weekday=1)), (frequencies.get_freq("W-TUE"), 1))
self.assertEqual(frequencies.get_freq_code(offsets.Week(3, weekday=0)), (frequencies.get_freq("W-MON"), 3))
self.assertEqual(frequencies.get_freq_code(offsets.Week(-2, weekday=4)), (frequencies.get_freq("W-FRI"), -2))
def _monthly_finder(vmin, vmax, freq):
if isinstance(freq, basestring):
freq = frequencies.get_freq(freq)
if freq != FreqGroup.FR_MTH:
raise ValueError("Unexpected frequency")
periodsperyear = 12
vmin_orig = vmin
(vmin, vmax) = (int(vmin), int(vmax))
span = vmax - vmin + 1
# ..............
# Initialize the output
info = np.zeros(span, dtype=[("val", int), ("maj", bool), ("min", bool), ("fmt", "|S8")])
info["val"] = np.arange(vmin, vmax + 1)
dates_ = info["val"]
info["fmt"] = ""
year_start = (dates_ % 12 == 1).nonzero()[0]
info_maj = info["maj"]
info_fmt = info["fmt"]
# ..............
if span <= 1.15 * periodsperyear:
info_maj[year_start] = True
info["min"] = True
info_fmt[:] = "%b"
info_fmt[year_start] = "%b\n%Y"
if not has_level_label(year_start, vmin_orig):
if dates_.size > 1:
idx = 1
else:
idx = 0
info_fmt[idx] = "%b\n%Y"
# ..............
elif span <= 2.5 * periodsperyear:
quarter_start = (dates_ % 3 == 1).nonzero()
info_maj[year_start] = True
# TODO: Check the following : is it really info['fmt'] ?
info["fmt"][quarter_start] = True
info["min"] = True
info_fmt[quarter_start] = "%b"
info_fmt[year_start] = "%b\n%Y"
# ..............
elif span <= 4 * periodsperyear:
info_maj[year_start] = True
info["min"] = True
jan_or_jul = (dates_ % 12 == 1) | (dates_ % 12 == 7)
info_fmt[jan_or_jul] = "%b"
info_fmt[year_start] = "%b\n%Y"
# ..............
elif span <= 11 * periodsperyear:
quarter_start = (dates_ % 3 == 1).nonzero()
info_maj[year_start] = True
info["min"][quarter_start] = True
info_fmt[year_start] = "%Y"
# ..................
else:
nyears = span / periodsperyear
(min_anndef, maj_anndef) = _get_default_annual_spacing(nyears)
years = dates_[year_start] // 12 + 1
major_idx = year_start[(years % maj_anndef == 0)]
info_maj[major_idx] = True
info["min"][year_start[(years % min_anndef == 0)]] = True
info_fmt[major_idx] = "%Y"
# ..............
return info
def test_intraday_conversion_factors(self):
self.assertEqual(period_asfreq(1, get_freq("D"), get_freq("H"), False), 24)
self.assertEqual(period_asfreq(1, get_freq("D"), get_freq("T"), False), 1440)
self.assertEqual(period_asfreq(1, get_freq("D"), get_freq("S"), False), 86400)
self.assertEqual(period_asfreq(1, get_freq("D"), get_freq("L"), False), 86400000)
self.assertEqual(period_asfreq(1, get_freq("D"), get_freq("U"), False), 86400000000)
self.assertEqual(period_asfreq(1, get_freq("D"), get_freq("N"), False), 86400000000000)
self.assertEqual(period_asfreq(1, get_freq("H"), get_freq("T"), False), 60)
self.assertEqual(period_asfreq(1, get_freq("H"), get_freq("S"), False), 3600)
self.assertEqual(period_asfreq(1, get_freq("H"), get_freq("L"), False), 3600000)
self.assertEqual(period_asfreq(1, get_freq("H"), get_freq("U"), False), 3600000000)
self.assertEqual(period_asfreq(1, get_freq("H"), get_freq("N"), False), 3600000000000)
self.assertEqual(period_asfreq(1, get_freq("T"), get_freq("S"), False), 60)
self.assertEqual(period_asfreq(1, get_freq("T"), get_freq("L"), False), 60000)
self.assertEqual(period_asfreq(1, get_freq("T"), get_freq("U"), False), 60000000)
self.assertEqual(period_asfreq(1, get_freq("T"), get_freq("N"), False), 60000000000)
self.assertEqual(period_asfreq(1, get_freq("S"), get_freq("L"), False), 1000)
self.assertEqual(period_asfreq(1, get_freq("S"), get_freq("U"), False), 1000000)
self.assertEqual(period_asfreq(1, get_freq("S"), get_freq("N"), False), 1000000000)
self.assertEqual(period_asfreq(1, get_freq("L"), get_freq("U"), False), 1000)
self.assertEqual(period_asfreq(1, get_freq("L"), get_freq("N"), False), 1000000)
self.assertEqual(period_asfreq(1, get_freq("U"), get_freq("N"), False), 1000)
def test_intraday_conversion_factors(self):
self.assertEqual(period_asfreq(1, get_freq('D'), get_freq('H'), False),
24)
self.assertEqual(period_asfreq(1, get_freq('D'), get_freq('T'), False),
1440)
self.assertEqual(period_asfreq(1, get_freq('D'), get_freq('S'), False),
86400)
self.assertEqual(period_asfreq(1, get_freq('D'), get_freq('L'), False),
86400000)
self.assertEqual(period_asfreq(1, get_freq('D'), get_freq('U'), False),
86400000000)
self.assertEqual(period_asfreq(1, get_freq('D'), get_freq('N'), False),
86400000000000)
self.assertEqual(period_asfreq(1, get_freq('H'), get_freq('T'), False),
60)
self.assertEqual(period_asfreq(1, get_freq('H'), get_freq('S'), False),
3600)
self.assertEqual(period_asfreq(1, get_freq('H'), get_freq('L'), False),
3600000)
self.assertEqual(period_asfreq(1, get_freq('H'), get_freq('U'), False),
3600000000)
self.assertEqual(period_asfreq(1, get_freq('H'), get_freq('N'), False),
3600000000000)
self.assertEqual(period_asfreq(1, get_freq('T'), get_freq('S'), False),
60)
self.assertEqual(period_asfreq(1, get_freq('T'), get_freq('L'), False),
60000)
self.assertEqual(period_asfreq(1, get_freq('T'), get_freq('U'), False),
60000000)
self.assertEqual(period_asfreq(1, get_freq('T'), get_freq('N'), False),
60000000000)
self.assertEqual(period_asfreq(1, get_freq('S'), get_freq('L'), False),
1000)
self.assertEqual(period_asfreq(1, get_freq('S'), get_freq('U'), False),
1000000)
self.assertEqual(period_asfreq(1, get_freq('S'), get_freq('N'), False),
1000000000)
self.assertEqual(period_asfreq(1, get_freq('L'), get_freq('U'), False),
1000)
self.assertEqual(period_asfreq(1, get_freq('L'), get_freq('N'), False),
1000000)
self.assertEqual(period_asfreq(1, get_freq('U'), get_freq('N'), False),
1000)
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_get_freq_code(self):
# freqstr
self.assertEqual(frequencies.get_freq_code('A'),
(frequencies.get_freq('A'), 1))
self.assertEqual(frequencies.get_freq_code('3D'),
(frequencies.get_freq('D'), 3))
self.assertEqual(frequencies.get_freq_code('-2M'),
(frequencies.get_freq('M'), -2))
# tuple
self.assertEqual(frequencies.get_freq_code(('D', 1)),
(frequencies.get_freq('D'), 1))
self.assertEqual(frequencies.get_freq_code(('A', 3)),
(frequencies.get_freq('A'), 3))
self.assertEqual(frequencies.get_freq_code(('M', -2)),
(frequencies.get_freq('M'), -2))
# numeric tuple
self.assertEqual(frequencies.get_freq_code((1000, 1)), (1000, 1))
# offsets
self.assertEqual(frequencies.get_freq_code(offsets.Day()),
(frequencies.get_freq('D'), 1))
self.assertEqual(frequencies.get_freq_code(offsets.Day(3)),
(frequencies.get_freq('D'), 3))
self.assertEqual(frequencies.get_freq_code(offsets.Day(-2)),
(frequencies.get_freq('D'), -2))
self.assertEqual(frequencies.get_freq_code(offsets.MonthEnd()),
(frequencies.get_freq('M'), 1))
self.assertEqual(frequencies.get_freq_code(offsets.MonthEnd(3)),
(frequencies.get_freq('M'), 3))
self.assertEqual(frequencies.get_freq_code(offsets.MonthEnd(-2)),
(frequencies.get_freq('M'), -2))
self.assertEqual(frequencies.get_freq_code(offsets.Week()),
(frequencies.get_freq('W'), 1))
self.assertEqual(frequencies.get_freq_code(offsets.Week(3)),
(frequencies.get_freq('W'), 3))
self.assertEqual(frequencies.get_freq_code(offsets.Week(-2)),
(frequencies.get_freq('W'), -2))
# monday is weekday=0
self.assertEqual(frequencies.get_freq_code(offsets.Week(weekday=1)),
(frequencies.get_freq('W-TUE'), 1))
self.assertEqual(frequencies.get_freq_code(offsets.Week(3, weekday=0)),
(frequencies.get_freq('W-MON'), 3))
self.assertEqual(frequencies.get_freq_code(offsets.Week(-2, weekday=4)),
(frequencies.get_freq('W-FRI'), -2))
def _monthly_finder(vmin, vmax, freq):
if isinstance(freq, basestring):
freq = frequencies.get_freq(freq)
if freq != FreqGroup.FR_MTH:
raise ValueError("Unexpected frequency")
periodsperyear = 12
vmin_orig = vmin
(vmin, vmax) = (int(vmin), int(vmax))
span = vmax - vmin + 1
#..............
# Initialize the output
info = np.zeros(span,
dtype=[('val', int), ('maj', bool), ('min', bool),
('fmt', '|S8')])
info['val'] = np.arange(vmin, vmax + 1)
dates_ = info['val']
info['fmt'] = ''
year_start = (dates_ % 12 == 0).nonzero()[0]
info_maj = info['maj']
info_fmt = info['fmt']
#..............
if span <= 1.15 * periodsperyear:
info_maj[year_start] = True
info['min'] = True
info_fmt[:] = '%b'
info_fmt[year_start] = '%b\n%Y'
if not has_level_label(year_start, vmin_orig):
if dates_.size > 1:
idx = 1
else:
idx = 0
info_fmt[idx] = '%b\n%Y'
#..............
elif span <= 2.5 * periodsperyear:
quarter_start = (dates_ % 3 == 0).nonzero()
info_maj[year_start] = True
# TODO: Check the following : is it really info['fmt'] ?
info['fmt'][quarter_start] = True
info['min'] = True
info_fmt[quarter_start] = '%b'
info_fmt[year_start] = '%b\n%Y'
#..............
elif span <= 4 * periodsperyear:
info_maj[year_start] = True
info['min'] = True
jan_or_jul = (dates_ % 12 == 0) | (dates_ % 12 == 6)
info_fmt[jan_or_jul] = '%b'
info_fmt[year_start] = '%b\n%Y'
#..............
elif span <= 11 * periodsperyear:
quarter_start = (dates_ % 3 == 0).nonzero()
info_maj[year_start] = True
info['min'][quarter_start] = True
info_fmt[year_start] = '%Y'
#..................
else:
nyears = span / periodsperyear
(min_anndef, maj_anndef) = _get_default_annual_spacing(nyears)
years = dates_[year_start] // 12 + 1
major_idx = year_start[(years % maj_anndef == 0)]
info_maj[major_idx] = True
info['min'][year_start[(years % min_anndef == 0)]] = True
info_fmt[major_idx] = '%Y'
#..............
return info
def test_get_freq_code(self):
# freqstr
self.assertEqual(frequencies.get_freq_code('A'),
(frequencies.get_freq('A'), 1))
self.assertEqual(frequencies.get_freq_code('3D'),
(frequencies.get_freq('D'), 3))
self.assertEqual(frequencies.get_freq_code('-2M'),
(frequencies.get_freq('M'), -2))
# tuple
self.assertEqual(frequencies.get_freq_code(('D', 1)),
(frequencies.get_freq('D'), 1))
self.assertEqual(frequencies.get_freq_code(('A', 3)),
(frequencies.get_freq('A'), 3))
self.assertEqual(frequencies.get_freq_code(('M', -2)),
(frequencies.get_freq('M'), -2))
# numeric tuple
self.assertEqual(frequencies.get_freq_code((1000, 1)), (1000, 1))
# offsets
self.assertEqual(frequencies.get_freq_code(offsets.Day()),
(frequencies.get_freq('D'), 1))
self.assertEqual(frequencies.get_freq_code(offsets.Day(3)),
(frequencies.get_freq('D'), 3))
self.assertEqual(frequencies.get_freq_code(offsets.Day(-2)),
(frequencies.get_freq('D'), -2))
self.assertEqual(frequencies.get_freq_code(offsets.MonthEnd()),
(frequencies.get_freq('M'), 1))
self.assertEqual(frequencies.get_freq_code(offsets.MonthEnd(3)),
(frequencies.get_freq('M'), 3))
self.assertEqual(frequencies.get_freq_code(offsets.MonthEnd(-2)),
(frequencies.get_freq('M'), -2))
self.assertEqual(frequencies.get_freq_code(offsets.Week()),
(frequencies.get_freq('W'), 1))
self.assertEqual(frequencies.get_freq_code(offsets.Week(3)),
(frequencies.get_freq('W'), 3))
self.assertEqual(frequencies.get_freq_code(offsets.Week(-2)),
(frequencies.get_freq('W'), -2))
# monday is weekday=0
self.assertEqual(frequencies.get_freq_code(offsets.Week(weekday=1)),
(frequencies.get_freq('W-TUE'), 1))
self.assertEqual(frequencies.get_freq_code(offsets.Week(3, weekday=0)),
(frequencies.get_freq('W-MON'), 3))
self.assertEqual(
frequencies.get_freq_code(offsets.Week(-2, weekday=4)),
(frequencies.get_freq('W-FRI'), -2))
