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 pytest.raises(ValueError, match='Invalid frequency'):
frequencies.get_freq_code((5, 'baz'))
with pytest.raises(ValueError, match='Invalid frequency'):
frequencies.to_offset('100foo')
with pytest.raises(ValueError, match='Could not evaluate'):
frequencies.to_offset(('', ''))
def test_frequency_misc(self):
self.assertEquals(fmod.get_freq_group('T'),
fmod.FreqGroup.FR_MIN)
code, stride = fmod.get_freq_code(offsets.Hour())
self.assertEquals(code, fmod.FreqGroup.FR_HR)
code, stride = fmod.get_freq_code((5, 'T'))
self.assertEquals(code, fmod.FreqGroup.FR_MIN)
self.assertEquals(stride, 5)
offset = offsets.Hour()
result = fmod.to_offset(offset)
self.assertEquals(result, offset)
result = fmod.to_offset((5, 'T'))
expected = offsets.Minute(5)
self.assertEquals(result, expected)
self.assertRaises(KeyError, fmod.get_freq_code, (5, 'baz'))
self.assertRaises(ValueError, fmod.to_offset, '100foo')
self.assertRaises(ValueError, fmod.to_offset, ('', ''))
result = fmod.get_standard_freq(offsets.Hour())
self.assertEquals(result, 'H')
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(('', ''))
with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
result = frequencies.get_standard_freq(offsets.Hour())
assert result == 'H'
def _range_from_fields(year=None, month=None, quarter=None, day=None,
hour=None, minute=None, second=None, freq=None):
if hour is None:
hour = 0
if minute is None:
minute = 0
if second is None:
second = 0
if day is None:
day = 1
ordinals = []
if quarter is not None:
if freq is None:
freq = 'Q'
base = frequencies.FreqGroup.FR_QTR
else:
base, mult = frequencies.get_freq_code(freq)
if base != frequencies.FreqGroup.FR_QTR:
raise AssertionError("base must equal FR_QTR")
year, quarter = _make_field_arrays(year, quarter)
for y, q in compat.zip(year, quarter):
y, m = libperiod.quarter_to_myear(y, q, freq)
val = libperiod.period_ordinal(y, m, 1, 1, 1, 1, 0, 0, base)
ordinals.append(val)
else:
base, mult = frequencies.get_freq_code(freq)
arrays = _make_field_arrays(year, month, day, hour, minute, second)
for y, mth, d, h, mn, s in compat.zip(*arrays):
ordinals.append(libperiod.period_ordinal(
y, mth, d, h, mn, s, 0, 0, base))
return np.array(ordinals, dtype=np.int64), freq
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(('', ''))
with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
result = frequencies.get_standard_freq(offsets.Hour())
assert result == 'H'
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 pytest.raises(ValueError, match='Invalid frequency'):
frequencies.get_freq_code((5, 'baz'))
with pytest.raises(ValueError, match='Invalid frequency'):
frequencies.to_offset('100foo')
with pytest.raises(ValueError, match='Could not evaluate'):
frequencies.to_offset(('', ''))
def asfreq(self, freq=None, how='E'):
"""
Convert the Period Array/Index to the specified frequency `freq`.
Parameters
----------
freq : str
a frequency
how : str {'E', 'S'}
'E', 'END', or 'FINISH' for end,
'S', 'START', or 'BEGIN' for start.
Whether the elements should be aligned to the end
or start within pa period. January 31st ('END') vs.
January 1st ('START') for example.
Returns
-------
new : Period Array/Index with the new frequency
Examples
--------
>>> pidx = pd.period_range('2010-01-01', '2015-01-01', freq='A')
>>> pidx
<class 'pandas.core.indexes.period.PeriodIndex'>
[2010, ..., 2015]
Length: 6, Freq: A-DEC
>>> pidx.asfreq('M')
<class 'pandas.core.indexes.period.PeriodIndex'>
[2010-12, ..., 2015-12]
Length: 6, Freq: M
>>> pidx.asfreq('M', how='S')
<class 'pandas.core.indexes.period.PeriodIndex'>
[2010-01, ..., 2015-01]
Length: 6, Freq: M
"""
how = libperiod._validate_end_alias(how)
freq = Period._maybe_convert_freq(freq)
base1, mult1 = frequencies.get_freq_code(self.freq)
base2, mult2 = frequencies.get_freq_code(freq)
asi8 = self.asi8
# mult1 can't be negative or 0
end = how == 'E'
if end:
ordinal = asi8 + mult1 - 1
else:
ordinal = asi8
new_data = period_asfreq_arr(ordinal, base1, base2, end)
if self.hasnans:
new_data[self._isnan] = iNaT
return type(self)(new_data, freq=freq)
def dt64arr_to_periodarr(data, freq, tz=None):
if data.dtype != np.dtype('M8[ns]'):
raise ValueError('Wrong dtype: %s' % data.dtype)
freq = Period._maybe_convert_freq(freq)
base, mult = frequencies.get_freq_code(freq)
return libperiod.dt64arr_to_periodarr(data.view('i8'), base, tz)
def dt64arr_to_periodarr(data, freq, tz=None):
if data.dtype != np.dtype('M8[ns]'):
raise ValueError('Wrong dtype: %s' % data.dtype)
freq = Period._maybe_convert_freq(freq)
base, mult = frequencies.get_freq_code(freq)
return libperiod.dt64arr_to_periodarr(data.view('i8'), base, tz)
def get_anlz_factor(freq):
"""Find the number of periods per year given a frequency.
Parameters
----------
freq : str
Any frequency str or anchored offset str recognized by Pandas.
Returns
-------
float
Example
-------
>>> get_anlz_factor('D')
252.0
>>> get_anlz_factor('5D') # 5-business-day periods per year
50.4
>>> get_anlz_factor('Q')
4.0
>>> get_anlz_factor('Q-DEC')
4.0
>>> get_anlz_factor('BQS-APR')
4.0
"""
# 'Q-NOV' would give us (2001, 1); we just want (2000, 1).
try:
base, mult = get_freq_code(freq)
except (ValueError, AttributeError):
# The above will fail for a bunch of irregular frequencies, such
# as 'Q-NOV' or 'BQS-APR'
freq = freq.upper()
if freq.startswith(("A-", "BA-", "AS-", "BAS-")):
freq = "A"
elif freq.startswith(("Q-", "BQ-", "QS-", "BQS-")):
freq = "Q"
elif freq in {"MS", "BMS"}:
freq = "M"
else:
raise ValueError("Invalid frequency: %s" % freq)
base, mult = get_freq_code(freq)
return PERIODS_PER_YEAR[(base // 1000) * 1000] / mult
def get_anlz_factor(freq):
"""Find the number of periods per year given a frequency.
Parameters
----------
freq : str
Any frequency str or anchored offset str recognized by Pandas.
Returns
-------
float
Example
-------
>>> get_periods_per_year('D')
252.0
>>> get_periods_per_year('5D') # 5-business-day periods per year
50.4
>>> get_periods_per_year('Q')
4.0
>>> get_periods_per_year('Q-DEC')
4.0
>>> get_periods_per_year('BQS-APR')
4.0
"""
# 'Q-NOV' would give us (2001, 1); we just want (2000, 1).
try:
base, mult = get_freq_code(freq)
except ValueError:
# The above will fail for a bunch of irregular frequencies, such
# as 'Q-NOV' or 'BQS-APR'
freq = freq.upper()
if freq.startswith(('A-', 'BA-', 'AS-', 'BAS-')):
freq = 'A'
elif freq.startswith(('Q-', 'BQ-', 'QS-', 'BQS-')):
freq = 'Q'
elif freq in {'MS', 'BMS'}:
freq = 'M'
else:
raise ValueError('Invalid frequency: %s' % freq)
base, mult = get_freq_code(freq)
return PERIODS_PER_YEAR[(base // 1000) * 1000] / mult
def to_timestamp(self, freq=None, how='start'):
"""
Cast to DatetimeArray/Index
Parameters
----------
freq : string or DateOffset, optional
Target frequency. The default is 'D' for week or longer,
'S' otherwise
how : {'s', 'e', 'start', 'end'}
Returns
-------
DatetimeArray/Index
"""
from pandas.core.arrays import DatetimeArrayMixin
how = libperiod._validate_end_alias(how)
end = how == 'E'
if end:
if freq == 'B':
# roll forward to ensure we land on B date
adjust = Timedelta(1, 'D') - Timedelta(1, 'ns')
return self.to_timestamp(how='start') + adjust
else:
adjust = Timedelta(1, 'ns')
return (self + 1).to_timestamp(how='start') - adjust
if freq is None:
base, mult = frequencies.get_freq_code(self.freq)
freq = frequencies.get_to_timestamp_base(base)
else:
freq = Period._maybe_convert_freq(freq)
base, mult = frequencies.get_freq_code(freq)
new_data = self.asfreq(freq, how=how)
new_data = libperiod.periodarr_to_dt64arr(new_data._ndarray_values,
base)
return DatetimeArrayMixin(new_data, freq='infer')
def to_timestamp(self, freq=None, how='start'):
"""
Cast to DatetimeArray/Index
Parameters
----------
freq : string or DateOffset, optional
Target frequency. The default is 'D' for week or longer,
'S' otherwise
how : {'s', 'e', 'start', 'end'}
Returns
-------
DatetimeArray/Index
"""
from pandas.core.arrays import DatetimeArrayMixin
how = libperiod._validate_end_alias(how)
end = how == 'E'
if end:
if freq == 'B':
# roll forward to ensure we land on B date
adjust = Timedelta(1, 'D') - Timedelta(1, 'ns')
return self.to_timestamp(how='start') + adjust
else:
adjust = Timedelta(1, 'ns')
return (self + 1).to_timestamp(how='start') - adjust
if freq is None:
base, mult = frequencies.get_freq_code(self.freq)
freq = frequencies.get_to_timestamp_base(base)
else:
freq = Period._maybe_convert_freq(freq)
base, mult = frequencies.get_freq_code(freq)
new_data = self.asfreq(freq, how=how)
new_data = libperiod.periodarr_to_dt64arr(new_data._ndarray_values,
base)
return DatetimeArrayMixin(new_data, freq='infer')
def _get_ordinal_range(start, end, periods, freq, mult=1):
if com.count_not_none(start, end, periods) != 2:
raise ValueError('Of the three parameters: start, end, and periods, '
'exactly two must be specified')
if freq is not None:
_, mult = frequencies.get_freq_code(freq)
if start is not None:
start = Period(start, freq)
if end is not None:
end = Period(end, freq)
is_start_per = isinstance(start, Period)
is_end_per = isinstance(end, Period)
if is_start_per and is_end_per and start.freq != end.freq:
raise ValueError('start and end must have same freq')
if (start is NaT or end is NaT):
raise ValueError('start and end must not be NaT')
if freq is None:
if is_start_per:
freq = start.freq
elif is_end_per:
freq = end.freq
else: # pragma: no cover
raise ValueError('Could not infer freq from start/end')
if periods is not None:
periods = periods * mult
if start is None:
data = np.arange(end.ordinal - periods + mult,
end.ordinal + 1,
mult,
dtype=np.int64)
else:
data = np.arange(start.ordinal,
start.ordinal + periods,
mult,
dtype=np.int64)
else:
data = np.arange(start.ordinal, end.ordinal + 1, mult, dtype=np.int64)
return data, freq
def dt64arr_to_periodarr(data, freq, tz=None):
"""
Convert an datetime-like array to values Period ordinals.
Parameters
----------
data : Union[Series[datetime64[ns]], DatetimeIndex, ndarray[datetime64ns]]
freq : Optional[Union[str, Tick]]
Must match the `freq` on the `data` if `data` is a DatetimeIndex
or Series.
tz : Optional[tzinfo]
Returns
-------
ordinals : ndarray[int]
freq : Tick
The frequencey extracted from the Series or DatetimeIndex if that's
used.
"""
if data.dtype != np.dtype('M8[ns]'):
raise ValueError('Wrong dtype: %s' % data.dtype)
if freq is not None:
freq = Period._maybe_convert_freq(freq)
if isinstance(data, ABCIndexClass):
if freq is None:
freq = data.freq
elif freq != data.freq:
msg = DIFFERENT_FREQ_INDEX.format(freq.freqstr, data.freq.freqstr)
raise IncompatibleFrequency(msg)
data = data._values
elif isinstance(data, ABCSeries):
if freq is None:
freq = data.dt.freq
elif freq != data.dt.freq:
msg = DIFFERENT_FREQ_INDEX.format(freq.freqstr,
data.dt.freq.freqstr)
raise IncompatibleFrequency(msg)
data = data._values
base, mult = frequencies.get_freq_code(freq)
return libperiod.dt64arr_to_periodarr(data.view('i8'), base, tz), freq
def _get_ordinal_range(start, end, periods, freq, mult=1):
if com.count_not_none(start, end, periods) != 2:
raise ValueError('Of the three parameters: start, end, and periods, '
'exactly two must be specified')
if freq is not None:
_, mult = frequencies.get_freq_code(freq)
if start is not None:
start = Period(start, freq)
if end is not None:
end = Period(end, freq)
is_start_per = isinstance(start, Period)
is_end_per = isinstance(end, Period)
if is_start_per and is_end_per and start.freq != end.freq:
raise ValueError('start and end must have same freq')
if (start is NaT or end is NaT):
raise ValueError('start and end must not be NaT')
if freq is None:
if is_start_per:
freq = start.freq
elif is_end_per:
freq = end.freq
else: # pragma: no cover
raise ValueError('Could not infer freq from start/end')
if periods is not None:
periods = periods * mult
if start is None:
data = np.arange(end.ordinal - periods + mult,
end.ordinal + 1, mult,
dtype=np.int64)
else:
data = np.arange(start.ordinal, start.ordinal + periods, mult,
dtype=np.int64)
else:
data = np.arange(start.ordinal, end.ordinal + 1, mult, dtype=np.int64)
return data, freq
def dt64arr_to_periodarr(data, freq, tz=None):
"""
Convert an datetime-like array to values Period ordinals.
Parameters
----------
data : Union[Series[datetime64[ns]], DatetimeIndex, ndarray[datetime64ns]]
freq : Optional[Union[str, Tick]]
Must match the `freq` on the `data` if `data` is a DatetimeIndex
or Series.
tz : Optional[tzinfo]
Returns
-------
ordinals : ndarray[int]
freq : Tick
The frequencey extracted from the Series or DatetimeIndex if that's
used.
"""
if data.dtype != np.dtype('M8[ns]'):
raise ValueError('Wrong dtype: %s' % data.dtype)
if freq is None:
if isinstance(data, ABCIndexClass):
data, freq = data._values, data.freq
elif isinstance(data, ABCSeries):
data, freq = data._values, data.dt.freq
freq = Period._maybe_convert_freq(freq)
if isinstance(data, (ABCIndexClass, ABCSeries)):
data = data._values
base, mult = frequencies.get_freq_code(freq)
return libperiod.dt64arr_to_periodarr(data.view('i8'), base, tz), freq
def test_get_to_timestamp_base(self):
tsb = frequencies.get_to_timestamp_base
self.assertEqual(tsb(frequencies.get_freq_code('D')[0]),
frequencies.get_freq_code('D')[0])
self.assertEqual(tsb(frequencies.get_freq_code('W')[0]),
frequencies.get_freq_code('D')[0])
self.assertEqual(tsb(frequencies.get_freq_code('M')[0]),
frequencies.get_freq_code('D')[0])
self.assertEqual(tsb(frequencies.get_freq_code('S')[0]),
frequencies.get_freq_code('S')[0])
self.assertEqual(tsb(frequencies.get_freq_code('T')[0]),
frequencies.get_freq_code('S')[0])
self.assertEqual(tsb(frequencies.get_freq_code('H')[0]),
frequencies.get_freq_code('S')[0])
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_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 f(self):
base, mult = frequencies.get_freq_code(self.freq)
result = get_period_field_arr(alias, self.asi8, base)
return result
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_to_timestamp_base(self):
tsb = frequencies.get_to_timestamp_base
self.assertEqual(tsb(frequencies.get_freq_code('D')[0]),
frequencies.get_freq_code('D')[0])
self.assertEqual(tsb(frequencies.get_freq_code('W')[0]),
frequencies.get_freq_code('D')[0])
self.assertEqual(tsb(frequencies.get_freq_code('M')[0]),
frequencies.get_freq_code('D')[0])
self.assertEqual(tsb(frequencies.get_freq_code('S')[0]),
frequencies.get_freq_code('S')[0])
self.assertEqual(tsb(frequencies.get_freq_code('T')[0]),
frequencies.get_freq_code('S')[0])
self.assertEqual(tsb(frequencies.get_freq_code('H')[0]),
frequencies.get_freq_code('S')[0])
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_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 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 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 test_get_to_timestamp_base(self):
tsb = frequencies.get_to_timestamp_base
self.assertEqual(tsb(frequencies.get_freq_code("D")[0]), frequencies.get_freq_code("D")[0])
self.assertEqual(tsb(frequencies.get_freq_code("W")[0]), frequencies.get_freq_code("D")[0])
self.assertEqual(tsb(frequencies.get_freq_code("M")[0]), frequencies.get_freq_code("D")[0])
self.assertEqual(tsb(frequencies.get_freq_code("S")[0]), frequencies.get_freq_code("S")[0])
self.assertEqual(tsb(frequencies.get_freq_code("T")[0]), frequencies.get_freq_code("S")[0])
self.assertEqual(tsb(frequencies.get_freq_code("H")[0]), frequencies.get_freq_code("S")[0])
