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_with_tz_ambiguous_times(self):
tz = self.tz('US/Eastern')
# March 13, 2011, spring forward, skip from 2 AM to 3 AM
dr = date_range(datetime(2011, 3, 13, 1, 30),
periods=3,
freq=offsets.Hour())
pytest.raises(pytz.NonExistentTimeError, dr.tz_localize, tz)
# after dst transition, it works
dr = date_range(datetime(2011, 3, 13, 3, 30),
periods=3,
freq=offsets.Hour(),
tz=tz)
# November 6, 2011, fall back, repeat 2 AM hour
dr = date_range(datetime(2011, 11, 6, 1, 30),
periods=3,
freq=offsets.Hour())
pytest.raises(pytz.AmbiguousTimeError, dr.tz_localize, tz)
# UTC is OK
dr = date_range(datetime(2011, 3, 13),
periods=48,
freq=offsets.Minute(30),
tz=pytz.utc)
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 data_range_test():
times = pd.date_range('2019-01-01', '2019-02-01', )
print('指定开始、结束，默认频率为每天 \r\n', times)
times = pd.date_range(start='2019-01-01', periods=10)
print('指定日期数量的日期范围 \r\n', times)
times = pd.date_range(start='2019-01-01', periods=10, freq='M')
print('使用日期偏移量的日期范围 (每月) \r\n', times)
times = pd.date_range(start='2019-01-01 10:00:00', periods=10)
print('带时间信息的日期范围 \r\n', times)
times = pd.date_range(start='2019-01-01 10:00:00', periods=10, normalize=True)
print('规范化参数产生的日期范围 将时间变成00:00:00\r\n', times)
times = pd.date_range(start='2019-01-01', periods=10, freq='4h')
print('频率 每4小时\r\n', times)
times = pd.date_range(start='2019-01-01', periods=10, freq='2h30min')
print('频率 每2h30min小时\r\n', times)
times = pd.date_range(start='2019-01-01', periods=10, freq='wom-3FRI')
print('频率 每个月的第3个星期五\r\n', times)
hour = offset.Hour()
times = pd.date_range(start='2019-01-01', periods=10, freq=hour)
print('使用日期偏移量类 每小时 \r\n', times)
hour = offset.Hour(4)
times = pd.date_range(start='2019-01-01', periods=10, freq=hour)
print('使用日期偏移量类 每4小时 \r\n', times)
mins = offset.Minute(30)
times = pd.date_range(start='2019-01-01', periods=10, freq=hour + mins)
print('使用日期偏移量类 每4小时30分 \r\n', times)
def test_is_superperiod_subperiod():
assert (frequencies.is_superperiod(offsets.YearEnd(), offsets.MonthEnd()))
assert (frequencies.is_subperiod(offsets.MonthEnd(), offsets.YearEnd()))
assert (frequencies.is_superperiod(offsets.Hour(), offsets.Minute()))
assert (frequencies.is_subperiod(offsets.Minute(), offsets.Hour()))
assert (frequencies.is_superperiod(offsets.Second(), offsets.Milli()))
assert (frequencies.is_subperiod(offsets.Milli(), offsets.Second()))
assert (frequencies.is_superperiod(offsets.Milli(), offsets.Micro()))
assert (frequencies.is_subperiod(offsets.Micro(), offsets.Milli()))
assert (frequencies.is_superperiod(offsets.Micro(), offsets.Nano()))
assert (frequencies.is_subperiod(offsets.Nano(), offsets.Micro()))
def test_nat(self):
# GH 5546
dates = [NaT]
idx = DatetimeIndex(dates)
idx = idx.tz_localize('US/Pacific')
self.assert_(idx.equals(DatetimeIndex(dates, tz='US/Pacific')))
idx = idx.tz_convert('US/Eastern')
self.assert_(idx.equals(DatetimeIndex(dates, tz='US/Eastern')))
idx = idx.tz_convert('UTC')
self.assert_(idx.equals(DatetimeIndex(dates, tz='UTC')))
dates = ['2010-12-01 00:00', '2010-12-02 00:00', NaT]
idx = DatetimeIndex(dates)
idx = idx.tz_localize('US/Pacific')
self.assert_(idx.equals(DatetimeIndex(dates, tz='US/Pacific')))
idx = idx.tz_convert('US/Eastern')
expected = ['2010-12-01 03:00', '2010-12-02 03:00', NaT]
self.assert_(idx.equals(DatetimeIndex(expected, tz='US/Eastern')))
idx = idx + offsets.Hour(5)
expected = ['2010-12-01 08:00', '2010-12-02 08:00', NaT]
self.assert_(idx.equals(DatetimeIndex(expected, tz='US/Eastern')))
idx = idx.tz_convert('US/Pacific')
expected = ['2010-12-01 05:00', '2010-12-02 05:00', NaT]
self.assert_(idx.equals(DatetimeIndex(expected, tz='US/Pacific')))
if not _np_version_under1p7:
idx = idx + np.timedelta64(3, 'h')
expected = ['2010-12-01 08:00', '2010-12-02 08:00', NaT]
self.assert_(idx.equals(DatetimeIndex(expected, tz='US/Pacific')))
idx = idx.tz_convert('US/Eastern')
expected = ['2010-12-01 11:00', '2010-12-02 11:00', NaT]
self.assert_(idx.equals(DatetimeIndex(expected, tz='US/Eastern')))
def test_nat(self):
# GH 5546
dates = [NaT]
idx = DatetimeIndex(dates)
idx = idx.tz_localize('US/Pacific')
tm.assert_index_equal(idx, DatetimeIndex(dates, tz='US/Pacific'))
idx = idx.tz_convert('US/Eastern')
tm.assert_index_equal(idx, DatetimeIndex(dates, tz='US/Eastern'))
idx = idx.tz_convert('UTC')
tm.assert_index_equal(idx, DatetimeIndex(dates, tz='UTC'))
dates = ['2010-12-01 00:00', '2010-12-02 00:00', NaT]
idx = DatetimeIndex(dates)
idx = idx.tz_localize('US/Pacific')
tm.assert_index_equal(idx, DatetimeIndex(dates, tz='US/Pacific'))
idx = idx.tz_convert('US/Eastern')
expected = ['2010-12-01 03:00', '2010-12-02 03:00', NaT]
tm.assert_index_equal(idx, DatetimeIndex(expected, tz='US/Eastern'))
idx = idx + offsets.Hour(5)
expected = ['2010-12-01 08:00', '2010-12-02 08:00', NaT]
tm.assert_index_equal(idx, DatetimeIndex(expected, tz='US/Eastern'))
idx = idx.tz_convert('US/Pacific')
expected = ['2010-12-01 05:00', '2010-12-02 05:00', NaT]
tm.assert_index_equal(idx, DatetimeIndex(expected, tz='US/Pacific'))
idx = idx + np.timedelta64(3, 'h')
expected = ['2010-12-01 08:00', '2010-12-02 08:00', NaT]
tm.assert_index_equal(idx, DatetimeIndex(expected, tz='US/Pacific'))
idx = idx.tz_convert('US/Eastern')
expected = ['2010-12-01 11:00', '2010-12-02 11:00', NaT]
tm.assert_index_equal(idx, DatetimeIndex(expected, tz='US/Eastern'))
def test_with_tz(self):
tz = self.tz('US/Central')
# just want it to work
start = datetime(2011, 3, 12, tzinfo=pytz.utc)
dr = bdate_range(start, periods=50, freq=offsets.Hour())
assert dr.tz is pytz.utc
# DateRange with naive datetimes
dr = bdate_range('1/1/2005', '1/1/2009', tz=pytz.utc)
dr = bdate_range('1/1/2005', '1/1/2009', tz=tz)
# normalized
central = dr.tz_convert(tz)
assert central.tz is tz
comp = self.localize(
tz, central[0].to_pydatetime().replace(tzinfo=None)).tzinfo
assert central[0].tz is comp
# compare vs a localized tz
comp = self.localize(tz,
dr[0].to_pydatetime().replace(tzinfo=None)).tzinfo
assert central[0].tz is comp
# datetimes with tzinfo set
dr = bdate_range(datetime(2005, 1, 1, tzinfo=pytz.utc),
datetime(2009, 1, 1, tzinfo=pytz.utc))
pytest.raises(Exception,
bdate_range,
datetime(2005, 1, 1, tzinfo=pytz.utc),
'1/1/2009',
tz=tz)
def _construct_bt_dt_index(self):
""" constructs the t0 dates index that runs from t0 to T
if the price series is longer than the weights series use the the l
The function takes the weights index and prepends it either with the last available previous date from the
price index or else prepends t1 with a timedelta """
dt_t0_tmp = self.price_date_index.copy()
# where is first date
first_weight_date = self.trading_dt_index[0]
if dt_t0_tmp[0] < first_weight_date:
# prices start before first weight date, bt index starts at date closest to weight date start
# initialization date t0 is the date closest to the date of the first weight t1
initialization_date_index = dt_t0_tmp.get_loc(first_weight_date) - 1
dates_t0_index = dt_t0_tmp[initialization_date_index:]
else:
freq = self.frequency
if freq == 'B':
initialization_date = dt_t0_tmp[0] - time_offset.BDay(1)
elif freq == 'D':
initialization_date = dt_t0_tmp[0] - time_offset.Day(1)
elif freq == 'min':
initialization_date = dt_t0_tmp[0] - time_offset.Minute(1)
elif freq == 'H':
initialization_date = dt_t0_tmp[0] - time_offset.Hour(1)
else:
import pdb
pdb.set_trace()
assert freq == 'S'
initialization_date = dt_t0_tmp[0] - time_offset.Second(1)
# prepend index with "artificial" first datetime; interval chosen to match frequency of price index
dates_t0_index = dt_t0_tmp.append(pd.DatetimeIndex([initialization_date])).sort_values()
return dates_t0_index
def test_tzaware_offset(self):
dates = date_range('2012-11-01', periods=3, tz='US/Pacific')
offset = dates + offsets.Hour(5)
self.assertEqual(dates[0] + offsets.Hour(5), offset[0])
# GH 6818
for tz in ['UTC', 'US/Pacific', 'Asia/Tokyo']:
dates = date_range('2010-11-01 00:00', periods=3, tz=tz, freq='H')
expected = DatetimeIndex(['2010-11-01 05:00', '2010-11-01 06:00',
'2010-11-01 07:00'], freq='H', tz=tz)
offset = dates + offsets.Hour(5)
self.assertTrue(offset.equals(expected))
offset = dates + np.timedelta64(5, 'h')
self.assertTrue(offset.equals(expected))
offset = dates + timedelta(hours=5)
self.assertTrue(offset.equals(expected))
def test_resample_reresample():
dti = date_range(start=datetime(2005, 1, 1), end=datetime(2005, 1, 10), freq="D")
s = Series(np.random.rand(len(dti)), dti)
bs = s.resample("B", closed="right", label="right").mean()
result = bs.resample("8H").mean()
assert len(result) == 22
assert isinstance(result.index.freq, offsets.DateOffset)
assert result.index.freq == offsets.Hour(8)
def test_resample_reresample(self):
dti = DatetimeIndex(start=datetime(2005,1,1), end=datetime(2005,1,10),
freq='D')
s = Series(np.random.rand(len(dti)), dti)
bs = s.resample('B')
result = bs.resample('8H')
self.assertEquals(len(result), 22)
self.assert_(isinstance(result.index.freq, offsets.DateOffset))
self.assert_(result.index.freq == offsets.Hour(8))
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 = '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 = '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.assertRaisesRegexp(ValueError, 'Invalid frequency: 2h20m'):
frequencies.to_offset('2h20m')
def csv_to_df(csv):
usdjpy = csv[csv['<TICKER>'] == 'USDJPY']
del usdjpy['<TICKER>']
usdjpy.index = pd.to_datetime(usdjpy['<DTYYYYMMDD>'].map(str) + usdjpy['<TIME>'].map(lambda x: "{0:06d}".format(x)))
usdjpy.index += offsets.Hour(8)
del usdjpy['<DTYYYYMMDD>']
del usdjpy['<TIME>']
usdjpy.columns = ['Open', 'High', 'Low', 'Close']
return usdjpy
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_invalid(self):
# GH 13930
with tm.assertRaisesRegexp(ValueError, 'Invalid frequency: U1'):
frequencies.to_offset('U1')
with tm.assertRaisesRegexp(ValueError, 'Invalid frequency: -U'):
frequencies.to_offset('-U')
with tm.assertRaisesRegexp(ValueError, 'Invalid frequency: 3U1'):
frequencies.to_offset('3U1')
with tm.assertRaisesRegexp(ValueError, 'Invalid frequency: -2-3U'):
frequencies.to_offset('-2-3U')
with tm.assertRaisesRegexp(ValueError, 'Invalid frequency: -2D:3H'):
frequencies.to_offset('-2D:3H')
# ToDo: Must be fixed in #8419
with tm.assertRaisesRegexp(ValueError, 'Invalid frequency: .5S'):
frequencies.to_offset('.5S')
# 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.assertRaisesRegexp(ValueError,
'Invalid frequency: 2SMS-15-15'):
frequencies.to_offset('2SMS-15-15')
with tm.assertRaisesRegexp(ValueError, 'Invalid frequency: 2SMS-15D'):
frequencies.to_offset('2SMS-15D')
def test_ambiguous_infer(self):
# November 6, 2011, fall back, repeat 2 AM hour
# With no repeated hours, we cannot infer the transition
tz = self.tz('US/Eastern')
dr = date_range(datetime(2011, 11, 6, 0),
periods=5,
freq=offsets.Hour())
pytest.raises(pytz.AmbiguousTimeError, dr.tz_localize, tz)
# With repeated hours, we can infer the transition
dr = date_range(datetime(2011, 11, 6, 0),
periods=5,
freq=offsets.Hour(),
tz=tz)
times = [
'11/06/2011 00:00', '11/06/2011 01:00', '11/06/2011 01:00',
'11/06/2011 02:00', '11/06/2011 03:00'
]
di = DatetimeIndex(times)
localized = di.tz_localize(tz, ambiguous='infer')
tm.assert_index_equal(dr, localized)
with tm.assert_produces_warning(FutureWarning):
localized_old = di.tz_localize(tz, infer_dst=True)
tm.assert_index_equal(dr, localized_old)
tm.assert_index_equal(dr, DatetimeIndex(times,
tz=tz,
ambiguous='infer'))
# When there is no dst transition, nothing special happens
dr = date_range(datetime(2011, 6, 1, 0),
periods=10,
freq=offsets.Hour())
localized = dr.tz_localize(tz)
localized_infer = dr.tz_localize(tz, ambiguous='infer')
tm.assert_index_equal(localized, localized_infer)
with tm.assert_produces_warning(FutureWarning):
localized_infer_old = dr.tz_localize(tz, infer_dst=True)
tm.assert_index_equal(localized, localized_infer_old)
def test_localize_utc_conversion_explicit(self):
# Localizing to time zone should:
# 1) check for DST ambiguities
# 2) convert to UTC
rng = date_range('3/10/2012', '3/11/2012', freq='30T')
converted = rng.tz_localize(self.tz('US/Eastern'))
expected_naive = rng + offsets.Hour(5)
self.assert_(np.array_equal(converted.asi8, expected_naive.asi8))
# DST ambiguity, this should fail
rng = date_range('3/11/2012', '3/12/2012', freq='30T')
# Is this really how it should fail??
self.assertRaises(NonExistentTimeError, rng.tz_localize, self.tz('US/Eastern'))
def test_localize_utc_conversion(self):
# Localizing to time zone should:
# 1) check for DST ambiguities
# 2) convert to UTC
rng = date_range('3/10/2012', '3/11/2012', freq='30T')
converted = rng.tz_localize('US/Eastern')
expected_naive = rng + offsets.Hour(5)
self.assert_(np.array_equal(converted.asi8, expected_naive.asi8))
# DST ambiguity, this should fail
rng = date_range('3/11/2012', '3/12/2012', freq='30T')
self.assertRaises(Exception, rng.tz_localize, 'US/Eastern')
def test_is_superperiod_subperiod():
# input validation
assert not (frequencies.is_superperiod(offsets.YearEnd(), None))
assert not (frequencies.is_subperiod(offsets.MonthEnd(), None))
assert not (frequencies.is_superperiod(None, offsets.YearEnd()))
assert not (frequencies.is_subperiod(None, offsets.MonthEnd()))
assert not (frequencies.is_superperiod(None, None))
assert not (frequencies.is_subperiod(None, None))
assert (frequencies.is_superperiod(offsets.YearEnd(), offsets.MonthEnd()))
assert (frequencies.is_subperiod(offsets.MonthEnd(), offsets.YearEnd()))
assert (frequencies.is_superperiod(offsets.Hour(), offsets.Minute()))
assert (frequencies.is_subperiod(offsets.Minute(), offsets.Hour()))
assert (frequencies.is_superperiod(offsets.Second(), offsets.Milli()))
assert (frequencies.is_subperiod(offsets.Milli(), offsets.Second()))
assert (frequencies.is_superperiod(offsets.Milli(), offsets.Micro()))
assert (frequencies.is_subperiod(offsets.Micro(), offsets.Milli()))
assert (frequencies.is_superperiod(offsets.Micro(), offsets.Nano()))
assert (frequencies.is_subperiod(offsets.Nano(), offsets.Micro()))
def read(self, start_date=None, end_date=None,
time_offset=7, ohlc='c', **kwargs):
self.historical_data = pd.read_csv(self.read_dir, **kwargs)
self.historical_data.index += offsets.Hour(time_offset)
start_date = start_date if start_date is not None else 0
end_date = end_date if end_date is not None else -1
self.historical_data = self.historical_data[start_date:end_date]
if ohlc != 'ohlc':
if ohlc == 'o':
self.historical_data = self.historical_data['open']
elif ohlc == 'h':
self.historical_data = self.historical_data['high']
elif ohlc == 'l':
self.historical_data = self.historical_data['low']
elif ohlc == 'c':
self.historical_data = self.historical_data['close']
self.index = self.historical_data.index
self.ohlc = ohlc
def test_to_offset_multiple():
freqstr = '2h30min'
freqstr2 = '2h 30min'
result = to_offset(freqstr)
assert (result == to_offset(freqstr2))
expected = offsets.Minute(150)
assert (result == expected)
freqstr = '2h30min15s'
result = to_offset(freqstr)
expected = offsets.Second(150 * 60 + 15)
assert (result == expected)
freqstr = '2h 60min'
result = to_offset(freqstr)
expected = offsets.Hour(3)
assert (result == expected)
freqstr = '15l500u'
result = to_offset(freqstr)
expected = offsets.Micro(15500)
assert (result == expected)
freqstr = '10s75L'
result = to_offset(freqstr)
expected = offsets.Milli(10075)
assert (result == expected)
if not _np_version_under1p7:
freqstr = '2800N'
result = to_offset(freqstr)
expected = offsets.Nano(2800)
assert (result == expected)
# malformed
try:
to_offset('2h20m')
except ValueError:
pass
else:
assert (False)
def forward(df=None, periods=180):
'''Generate hourly prediction of events for the next `periods`'''
weekdays = {
1: 'Monday',
2: 'Tuesday',
3: 'Wednesday',
4: 'Thursday',
5: 'Friday',
6: 'Saturday',
7: 'Sunday'
}
dist = daily_hours(df, to_json=False, how='mean')
hourly = df.resample('H', how='sum')
h_range = pd.date_range(hourly.index[-1] + offsets.Hour(),
periods=periods,
freq='H')
forward = pd.DataFrame({'Events': h_range}, index=h_range)
to_tuple = lambda x: (x.hour, weekdays[x.isoweekday()])
forward['Events'] = forward['Events'].apply(to_tuple)
index_dist = lambda x: dist[x[1]][x[0]]
forward['Events'] = forward['Events'].apply(index_dist)
return forward
)
def test_period_str_to_code(obj, expected):
assert _period_str_to_code(obj) == expected
@pytest.mark.parametrize(
"p1,p2,expected",
[
# Input validation.
(offsets.MonthEnd(), None, False),
(offsets.YearEnd(), None, False),
(None, offsets.YearEnd(), False),
(None, offsets.MonthEnd(), False),
(None, None, False),
(offsets.YearEnd(), offsets.MonthEnd(), True),
(offsets.Hour(), offsets.Minute(), True),
(offsets.Second(), offsets.Milli(), True),
(offsets.Milli(), offsets.Micro(), True),
(offsets.Micro(), offsets.Nano(), True),
],
)
def test_super_sub_symmetry(p1, p2, expected):
assert is_superperiod(p1, p2) is expected
assert is_subperiod(p2, p1) is expected
@pytest.mark.parametrize(
"freq,expected,aliases",
[
("D", 6000, ["DAY", "DLY", "DAILY"]),
("M", 3000, ["MTH", "MONTH", "MONTHLY"]),
import re
import pytest
from pandas import Timedelta
import pandas.tseries.frequencies as frequencies
import pandas.tseries.offsets as offsets
@pytest.mark.parametrize(
"freq_input,expected",
[
(frequencies.to_offset("10us"), offsets.Micro(10)),
(offsets.Hour(), offsets.Hour()),
((5, "T"), offsets.Minute(5)),
("2h30min", offsets.Minute(150)),
("2h 30min", offsets.Minute(150)),
("2h30min15s", offsets.Second(150 * 60 + 15)),
("2h 60min", offsets.Hour(3)),
("2h 20.5min", offsets.Second(8430)),
("1.5min", offsets.Second(90)),
("0.5S", offsets.Milli(500)),
("15l500u", offsets.Micro(15500)),
("10s75L", offsets.Milli(10075)),
("1s0.25ms", offsets.Micro(1000250)),
("1s0.25L", offsets.Micro(1000250)),
("2800N", offsets.Nano(2800)),
("2SM", offsets.SemiMonthEnd(2)),
("2SM-16", offsets.SemiMonthEnd(2, day_of_month=16)),
("2SMS-14", offsets.SemiMonthBegin(2, day_of_month=14)),
def test_apply_ticks():
result = offsets.Hour(3)._apply(offsets.Hour(4))
exp = offsets.Hour(7)
assert result == exp
def test_tzaware_offset(self):
dates = date_range('2012-11-01', periods=3, tz='US/Pacific')
offset = dates + offsets.Hour(5)
self.assertEqual(dates[0] + offsets.Hour(5), offset[0])
def test_to_offset_multiple():
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 = '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 = '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
try:
frequencies.to_offset('2h20m')
except ValueError:
pass
else:
assert (False)
def test_is_superperiod_subperiod():
assert (fmod.is_superperiod(offsets.YearEnd(), offsets.MonthEnd()))
assert (fmod.is_subperiod(offsets.MonthEnd(), offsets.YearEnd()))
assert (fmod.is_superperiod(offsets.Hour(), offsets.Minute()))
assert (fmod.is_subperiod(offsets.Minute(), offsets.Hour()))
(("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)),
(offsets.Day(-2), (get_freq("D"), -2)),
(offsets.MonthEnd(), (get_freq("M"), 1)),
(offsets.MonthEnd(3), (get_freq("M"), 3)),
(offsets.MonthEnd(-2), (get_freq("M"), -2)),
(offsets.Week(), (get_freq("W"), 1)),
(offsets.Week(3), (get_freq("W"), 3)),
(offsets.Week(-2), (get_freq("W"), -2)),
(offsets.Hour(), (FreqGroup.FR_HR, 1)),
# Monday is weekday=0.
(offsets.Week(weekday=1), (get_freq("W-TUE"), 1)),
(offsets.Week(3, weekday=0), (get_freq("W-MON"), 3)),
(offsets.Week(-2, weekday=4), (get_freq("W-FRI"), -2)),
])
def test_get_freq_code(freq_input, expected):
assert get_freq_code(freq_input) == expected
def test_get_code_invalid():
with pytest.raises(ValueError, match="Invalid frequency"):
get_freq_code((5, "baz"))
