def regress_em(df):
ret_list = []
predict_start = pd.to_datetime("2017-03-18", infer_datetime_format='%Y-%m-%d')
predict_end = pd.to_datetime("2017-04-22", infer_datetime_format='%Y-%m-%d')
train_end = predict_start - offsets.Day(1)
quarter_start = train_end - offsets.Week(13)
year_start = train_end - offsets.Week(52)
predict_df = take_df_by_period(df, predict_start, predict_end)
quarter_df = take_df_by_period(df, quarter_start, train_end).dropna(axis=0, subset=["visitors_nan"])
year_df = take_df_by_period(df, year_start, train_end).dropna(axis=0, subset=["visitors_nan"])
if predict_df.empty or quarter_df.empty:
return ret_list
li1 = linear_model.LinearRegression()
r1 = linear_model.Ridge(alpha=0.1)
r2 = linear_model.Ridge(alpha=0.5)
r3 = linear_model.Ridge(alpha=1.0)
l1 = linear_model.Lasso(alpha=0.1)
l2 = linear_model.Lasso(alpha=0.5)
l3 = linear_model.Lasso(alpha=1.0)
# h1 = linear_model.HuberRegressor()
models = [li1, r1, r2, r3, l1, l2, l3]
quarter_y_pred_list = do_regression(quarter_df, predict_df, models)
year_y_pred_list = do_regression(year_df, predict_df, models)
name_list = ["li1", "r1", "r2", "r3", "l1", "l2", "l3"]
temp_df = pd.DataFrame(index=predict_df.index)
for i in range(7):
col_name = "q_regress_" + name_list[i]
temp_df[col_name] = quarter_y_pred_list[i]
col_name = "y_regress_" + name_list[i]
temp_df[col_name] = year_y_pred_list[i]
ret_list.append(temp_df)
return ret_list
def businessIntelligence(result):
from pandas.tseries import offsets
result_1 = result[['index', 'enter','exit','Region']]
result_1['week_enter'] = result_1['enter'] + offsets.Week(weekday=6)
result_1['week_exit'] = result_1['exit'] + offsets.Week(weekday=6)
userEnter = result_1[['index','week_enter']].groupby(['week_enter']).count()
userExit = result_1[['index','week_exit']].groupby(['week_exit']).count()
userEnter = userEnter.reset_index()
userExit = userExit.reset_index()
userEnter.rename(columns={'index': 'enter'},inplace=True)
userExit.rename(columns={'index': 'exit'},inplace=True)
users_in_platform = pd.concat([userEnter, userExit], ignore_index=True)
users_in_platform['week'] = users_in_platform['week_enter'].fillna(users_in_platform['week_exit'])
users_in_platform = users_in_platform.drop(['week_exit','week_enter'],axis=1).fillna(0)
users_in_platform[['exit','enter']] = users_in_platform[['exit','enter']].fillna(0).astype(int)
users_in_platform['number_in'] = (users_in_platform['enter'] - users_in_platform['exit']).cumsum()
users_in_platform = users_in_platform.sort_values(by='week')
users_in_platform = users_in_platform.reset_index(drop=True)
users_in_platform = users_in_platform[users_in_platform['week'] <= pd.to_datetime('today')]
return users_in_platform
def get_dates_range(self,
scale='auto',
start=None,
end=None,
date_max='2010-01-01'):
'''
Returns a list of dates sampled according to the specified parameters.
:param scale: {'auto', 'maximum', 'daily', 'weekly', 'monthly',
'quarterly', 'yearly'}
Scale specifies the sampling intervals.
'auto' will heuristically choose a scale for quick processing
:param start: First date that will be included.
:param end: Last date that will be included
'''
if scale not in [
'auto', 'maximum', 'daily', 'weekly', 'monthly', 'quarterly',
'yearly'
]:
raise ValueError('Incorrect scale: %s' % scale)
start = Timestamp(start or self._start.min() or date_max)
# FIXME: start != start is true for NaN objects... is NaT the same?
start = Timestamp(date_max) if repr(start) == 'NaT' else start
end = Timestamp(end
or max(Timestamp(self._end.max()), self._start.max()))
# FIXME: end != end ?
end = datetime.utcnow() if repr(end) == 'NaT' else end
start = start if self.check_in_bounds(start) else self._lbound
end = end if self.check_in_bounds(end) else self._rbound
if scale == 'auto':
scale = self._auto_select_scale(start, end)
if scale == 'maximum':
start_dts = list(self._start.dropna().values)
end_dts = list(self._end.dropna().values)
dts = map(Timestamp, set(start_dts + end_dts))
dts = filter(
lambda ts: self.check_in_bounds(ts) and ts >= start and ts <=
end, dts)
return dts
freq = dict(daily='D',
weekly='W',
monthly='M',
quarterly='3M',
yearly='12M')
offset = dict(daily=off.Day(n=0),
weekly=off.Week(),
monthly=off.MonthEnd(),
quarterly=off.QuarterEnd(),
yearly=off.YearEnd())
# for some reason, weekly date range gives one week less:
end_ = end + off.Week() if scale == 'weekly' else end
ret = list(pd.date_range(start + offset[scale], end_,
freq=freq[scale]))
ret = [dt for dt in ret if dt <= end]
ret = [start] + ret if ret and start < ret[0] else ret
ret = ret + [end] if ret and end > ret[-1] else ret
ret = filter(lambda ts: self.check_in_bounds(ts), ret)
return ret
def test_get_rule_month():
result = frequencies._get_rule_month('W')
assert (result == 'DEC')
result = frequencies._get_rule_month(offsets.Week())
assert (result == 'DEC')
result = frequencies._get_rule_month('D')
assert (result == 'DEC')
result = frequencies._get_rule_month(offsets.Day())
assert (result == 'DEC')
result = frequencies._get_rule_month('Q')
assert (result == 'DEC')
result = frequencies._get_rule_month(offsets.QuarterEnd(startingMonth=12))
print(result == 'DEC')
result = frequencies._get_rule_month('Q-JAN')
assert (result == 'JAN')
result = frequencies._get_rule_month(offsets.QuarterEnd(startingMonth=1))
assert (result == 'JAN')
result = frequencies._get_rule_month('A-DEC')
assert (result == 'DEC')
result = frequencies._get_rule_month(offsets.YearEnd())
assert (result == 'DEC')
result = frequencies._get_rule_month('A-MAY')
assert (result == 'MAY')
result = frequencies._get_rule_month(offsets.YearEnd(month=5))
assert (result == 'MAY')
def test_freq_group(self):
assert frequencies.get_freq_group('A') == 1000
assert frequencies.get_freq_group('3A') == 1000
assert frequencies.get_freq_group('-1A') == 1000
assert frequencies.get_freq_group('A-JAN') == 1000
assert frequencies.get_freq_group('A-MAY') == 1000
assert frequencies.get_freq_group(offsets.YearEnd()) == 1000
assert frequencies.get_freq_group(offsets.YearEnd(month=1)) == 1000
assert frequencies.get_freq_group(offsets.YearEnd(month=5)) == 1000
assert frequencies.get_freq_group('W') == 4000
assert frequencies.get_freq_group('W-MON') == 4000
assert frequencies.get_freq_group('W-FRI') == 4000
assert frequencies.get_freq_group(offsets.Week()) == 4000
assert frequencies.get_freq_group(offsets.Week(weekday=1)) == 4000
assert frequencies.get_freq_group(offsets.Week(weekday=5)) == 4000
def get_date_ranges(self, start, end, scale='daily', include_bounds=True):
'''
Returns a list of dates sampled according to the specified parameters.
Parameters
----------
start: str
First date that will be included.
end: str
Last date that will be included
scale: {'daily', 'weekly', 'monthly', 'quarterly', 'yearly'}
Scale specifies the sampling intervals.
include_bounds: boolean
Include start and end in the result if they are not included yet.
'''
if scale not in ['daily', 'weekly', 'monthly', 'quarterly', 'yearly']:
raise ValueError('Incorrect scale: %s' % scale)
start = Timestamp(start)
end = Timestamp(end)
freq = dict(weekly='W', monthly='M', quarterly='3M', yearly='12M')
offset = dict(weekly=off.Week(),
monthly=off.MonthEnd(),
quarterly=off.QuarterEnd(),
yearly=off.YearEnd())
if scale == 'daily':
ret = pd.date_range(start, end, freq='D')
else:
ret = pd.date_range(start + offset[scale], end, freq=freq[scale])
ret = list(ret)
if include_bounds:
if start not in ret:
ret = [start] + ret
if end not in ret:
ret = ret + [end]
return ret
def __init__(self,
file_granularity: str,
file_path_format: str,
is_timezone_variable: bool,
timezone: timezone = None,
part_prefix: str = None,
file_extension='.csv'):
super(ReaderConfig,
self).__init__('Config for reading data from different mediums')
assert file_granularity in ['daily', 'monthly', 'weekly']
self.file_granularity = file_granularity
if self.file_granularity == 'daily':
self.date_offset = timedelta(days=1)
elif self.file_granularity == 'monthly':
self.date_offset = offsets.MonthBegin()
elif self.file_granularity == 'weekly':
self.date_offset = offsets.Week(weekday=0)
self.file_path_format = file_path_format
self.file_extension = file_extension
self.partwise = part_prefix is not None
self.part_prefix = part_prefix
self.is_timezone_variable = is_timezone_variable
self.timezone = timezone
def get_ctu_end_func(self, cfg):
"""
Depending on the input CTU, the end of CTU is required to get the target happening
after the current CTU
This function returns the end of the CTU date which added to the EVENT_DATE and the purchase window follow that
"""
if cfg['CTU_UNIT_NAME'] in cfg["TE_CTU_UNITS"]:
if cfg['CTU_UNIT_NAME'] == 'week':
return t_offset.Week(weekday=6)
elif cfg['CTU_UNIT_NAME'] == 'day':
return t_offset.Week(weekday=0)
else:
func_name = cfg['CTU_UNIT_NAME'].title()+'End'
return getattr(t_offset,func_name)(0)
else:
print("CTU should be one of", cfg["TE_CTU_UNITS"])
def test_freq_group(self):
self.assertEqual(frequencies.get_freq_group('A'), 1000)
self.assertEqual(frequencies.get_freq_group('3A'), 1000)
self.assertEqual(frequencies.get_freq_group('-1A'), 1000)
self.assertEqual(frequencies.get_freq_group('A-JAN'), 1000)
self.assertEqual(frequencies.get_freq_group('A-MAY'), 1000)
self.assertEqual(frequencies.get_freq_group(offsets.YearEnd()), 1000)
self.assertEqual(frequencies.get_freq_group(offsets.YearEnd(month=1)),
1000)
self.assertEqual(frequencies.get_freq_group(offsets.YearEnd(month=5)),
1000)
self.assertEqual(frequencies.get_freq_group('W'), 4000)
self.assertEqual(frequencies.get_freq_group('W-MON'), 4000)
self.assertEqual(frequencies.get_freq_group('W-FRI'), 4000)
self.assertEqual(frequencies.get_freq_group(offsets.Week()), 4000)
self.assertEqual(frequencies.get_freq_group(offsets.Week(weekday=1)),
4000)
self.assertEqual(frequencies.get_freq_group(offsets.Week(weekday=5)),
4000)
def vixExpiration(year, month):
"""
expriration date of a VX future
"""
t = datetime(year, month, 1) + offsets.relativedelta(months=1)
offset = offsets.Week(weekday=4)
if t.weekday() != 4:
t_new = t + 3 * offset
else:
t_new = t + 2 * offset
t_exp = t_new - offsets.relativedelta(days=30)
return t_exp
def test_freq_group(self):
assert resolution.get_freq_group('A') == 1000
assert resolution.get_freq_group('3A') == 1000
assert resolution.get_freq_group('-1A') == 1000
assert resolution.get_freq_group('A-JAN') == 1000
assert resolution.get_freq_group('A-MAY') == 1000
assert resolution.get_freq_group('Y') == 1000
assert resolution.get_freq_group('3Y') == 1000
assert resolution.get_freq_group('-1Y') == 1000
assert resolution.get_freq_group('Y-JAN') == 1000
assert resolution.get_freq_group('Y-MAY') == 1000
assert resolution.get_freq_group(offsets.YearEnd()) == 1000
assert resolution.get_freq_group(offsets.YearEnd(month=1)) == 1000
assert resolution.get_freq_group(offsets.YearEnd(month=5)) == 1000
assert resolution.get_freq_group('W') == 4000
assert resolution.get_freq_group('W-MON') == 4000
assert resolution.get_freq_group('W-FRI') == 4000
assert resolution.get_freq_group(offsets.Week()) == 4000
assert resolution.get_freq_group(offsets.Week(weekday=1)) == 4000
assert resolution.get_freq_group(offsets.Week(weekday=5)) == 4000
def vixExpiration(year, month, precise=True):
"""
expriration date of a VX future.
precise option loads data from file, but is limited
"""
if not precise:
t = datetime(year, month, 1) + offsets.relativedelta(months=1)
offset = offsets.Week(weekday=4)
if t.weekday() != 4:
t_new = t + 3 * offset
else:
t_new = t + 2 * offset
t_exp = t_new - offsets.relativedelta(days=30)
else:
t_exp = vixExpirations[(year, month)]
return t_exp
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 vixExpiration(year, month):
"""
expriration date of a VX future.
it first tries to load data from file and if it fails, falls back to calculation
"""
try:
t_exp = vixExpirations[(year, month)]
except KeyError: # no data present
t = dt.datetime(year, month, 1) + relativedelta(months=1)
offset = offsets.Week(weekday=4)
if t.weekday() != 4:
t_new = t + 3 * offset
else:
t_new = t + 2 * offset
t_exp = t_new - relativedelta(days=30)
return t_exp
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))
data['predict']['visit_date'] = pd.to_datetime(
data['predict']['visit_date_str'])
data['predict']['visit_date'] = data['predict']['visit_date'].dt.date
data['hol']['visit_datetime'] = pd.to_datetime(data['hol']['visit_date'])
data['hol']['visit_date'] = data['hol']['visit_datetime'].dt.date
data['hol']["year"] = data['hol']["visit_datetime"].dt.year
data['hol']["month"] = data['hol']["visit_datetime"].dt.month
data['hol']["day"] = data['hol']["visit_datetime"].dt.day
data['hol']["prev_month"] = data['hol']["visit_datetime"] - pd.DateOffset(
months=1)
data['hol']["prev_month_y"] = data['hol']["prev_month"].dt.year
data['hol']["prev_month_m"] = data['hol']["prev_month"].dt.month
data['hol']['dow'] = data['hol']['visit_datetime'].dt.dayofweek
data['hol']["week"] = data['hol']["visit_datetime"].dt.week
data['hol']["next_week"] = data['hol']["visit_datetime"] + offsets.Week(1)
data['hol']["prev_week"] = data['hol']["visit_datetime"] - offsets.Week(1)
data['hol']["next_week"] = data['hol']["next_week"].dt.week
data['hol']["prev_week"] = data['hol']["prev_week"].dt.week
data['hol']['dowh_flg'] = np.where(
(data['hol']["holiday_flg"] == 1) & (data['hol']["dow"] < 5), 1, 0)
grouped = data['hol'].groupby(["year", "week"])["dowh_flg"].sum().reset_index()
grouped.columns = ["year", "week", "week_hols"]
data['hol'] = pd.merge(data['hol'], grouped, how='left', on=["year", "week"])
grouped.columns = ["year", "next_week", "next_week_hols"]
data['hol'] = pd.merge(data['hol'],
grouped,
how='left',
on=["year", "next_week"])
grouped.columns = ["year", "prev_week", "prev_week_hols"]
data['hol'] = pd.merge(data['hol'],
import pytest
from pandas._libs.tslibs.frequencies import (INVALID_FREQ_ERR_MSG,
_period_str_to_code,
get_rule_month, is_subperiod,
is_superperiod)
from pandas.tseries import offsets
@pytest.mark.parametrize("obj,expected",
[("W", "DEC"), (offsets.Week(), "DEC"), ("D", "DEC"),
(offsets.Day(), "DEC"), ("Q", "DEC"),
(offsets.QuarterEnd(startingMonth=12), "DEC"),
("Q-JAN", "JAN"),
(offsets.QuarterEnd(startingMonth=1), "JAN"),
("A-DEC", "DEC"), ("Y-DEC", "DEC"),
(offsets.YearEnd(), "DEC"), ("A-MAY", "MAY"),
("Y-MAY", "MAY"), (offsets.YearEnd(month=5), "MAY")])
def test_get_rule_month(obj, expected):
result = get_rule_month(obj)
assert result == expected
@pytest.mark.parametrize("obj,expected", [("A", 1000), ("A-DEC", 1000),
("A-JAN", 1001), ("Y", 1000),
("Y-DEC", 1000), ("Y-JAN", 1001),
("Q", 2000), ("Q-DEC", 2000),
("Q-FEB", 2002), ("W", 4000),
("W-SUN", 4000), ("W-FRI", 4005),
("Min", 8000), ("ms", 10000),
import pytest
from pandas._libs.tslibs.parsing import get_rule_month
from pandas.tseries import offsets
@pytest.mark.parametrize(
"obj,expected",
[
("W", "DEC"),
(offsets.Week().freqstr, "DEC"),
("D", "DEC"),
(offsets.Day().freqstr, "DEC"),
("Q", "DEC"),
(offsets.QuarterEnd(startingMonth=12).freqstr, "DEC"),
("Q-JAN", "JAN"),
(offsets.QuarterEnd(startingMonth=1).freqstr, "JAN"),
("A-DEC", "DEC"),
("Y-DEC", "DEC"),
(offsets.YearEnd().freqstr, "DEC"),
("A-MAY", "MAY"),
("Y-MAY", "MAY"),
(offsets.YearEnd(month=5).freqstr, "MAY"),
],
)
def test_get_rule_month(obj, expected):
result = get_rule_month(obj)
assert result == expected
("3A", 1000),
("-1A", 1000),
("A-JAN", 1000),
("A-MAY", 1000),
("Y", 1000),
("3Y", 1000),
("-1Y", 1000),
("Y-JAN", 1000),
("Y-MAY", 1000),
(offsets.YearEnd(), 1000),
(offsets.YearEnd(month=1), 1000),
(offsets.YearEnd(month=5), 1000),
("W", 4000),
("W-MON", 4000),
("W-FRI", 4000),
(offsets.Week(), 4000),
(offsets.Week(weekday=1), 4000),
(offsets.Week(weekday=5), 4000),
("T", FreqGroup.FR_MIN),
])
def test_freq_group(freqstr, expected):
assert resolution.get_freq_group(freqstr) == expected
def test_freq_group_match(period_code_item):
freqstr, code = period_code_item
str_group = resolution.get_freq_group(freqstr)
code_group = resolution.get_freq_group(code)
assert str_group == code_group == code // 1000 * 1000
import pandas as pd
import pandas.tseries.offsets as offsets
week_ends = pd.date_range(start='01/02/2017', end='05/01/2017', freq='W')
print(week_ends)
print(week_ends[16] + offsets.Week(1))
exit(0)
month_ends = pd.date_range(start='01/01/2016', end='05/01/2017', freq='M')
print(month_ends[15].replace(day=22))
print(month_ends[15])
if month_ends[15].month == 4 and month_ends[15].year == 2017:
month_ends[15].replace(day=22)
print(month_ends[15])
print(month_ends)
exit(0)
for month_end in month_ends:
quarter_start = month_end - offsets.MonthBegin(3)
next_month_start = month_end + offsets.MonthBegin(1)
next_month_end = month_end + offsets.MonthEnd(1)
year_start = month_end - offsets.MonthBegin(12)
print("-"*30)
print(quarter_start)
print(next_month_start)
print(next_month_end)
print(year_start)
from pandas._libs.tslibs.frequencies import (
INVALID_FREQ_ERR_MSG,
_period_str_to_code,
is_subperiod,
is_superperiod,
)
from pandas._libs.tslibs.parsing import get_rule_month
from pandas.tseries import offsets
@pytest.mark.parametrize(
"obj,expected",
[
("W", "DEC"),
(offsets.Week(), "DEC"),
("D", "DEC"),
(offsets.Day(), "DEC"),
("Q", "DEC"),
(offsets.QuarterEnd(startingMonth=12), "DEC"),
("Q-JAN", "JAN"),
(offsets.QuarterEnd(startingMonth=1), "JAN"),
("A-DEC", "DEC"),
("Y-DEC", "DEC"),
(offsets.YearEnd(), "DEC"),
("A-MAY", "MAY"),
("Y-MAY", "MAY"),
(offsets.YearEnd(month=5), "MAY"),
],
)
def test_get_rule_month(obj, expected):
(dict(hours=1), frequencies.to_offset("60min")),
(dict(microseconds=1), offsets.Micro(1)),
(dict(microseconds=0), offsets.Nano(0)),
],
)
def test_to_offset_pd_timedelta(kwargs, expected):
# see gh-9064
td = Timedelta(**kwargs)
result = frequencies.to_offset(td)
assert result == expected
@pytest.mark.parametrize(
"shortcut,expected",
[
("W", offsets.Week(weekday=6)),
("W-SUN", offsets.Week(weekday=6)),
("Q", offsets.QuarterEnd(startingMonth=12)),
("Q-DEC", offsets.QuarterEnd(startingMonth=12)),
("Q-MAY", offsets.QuarterEnd(startingMonth=5)),
("SM", offsets.SemiMonthEnd(day_of_month=15)),
("SM-15", offsets.SemiMonthEnd(day_of_month=15)),
("SM-1", offsets.SemiMonthEnd(day_of_month=1)),
("SM-27", offsets.SemiMonthEnd(day_of_month=27)),
("SMS-2", offsets.SemiMonthBegin(day_of_month=2)),
("SMS-27", offsets.SemiMonthBegin(day_of_month=27)),
],
)
def test_anchored_shortcuts(shortcut, expected):
result = frequencies.to_offset(shortcut)
assert result == expected
