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_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 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 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_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 __Process_download_pro_hsgt_top10_data(self, in_code,
in_download_start_date):
loc_start_date = in_download_start_date
loc_end_date = loc_start_date + offsets.YearEnd()
loc_today = date.today()
nYearStep = 1
while True:
tmp_df = self.ts_pro_api.hsgt_top10(
ts_code=in_code,
start_date=loc_start_date.strftime('%Y%m%d'),
end_date=loc_end_date.strftime('%Y%m%d'))
if tmp_df is not None:
self.my_logger.debug(
'save new data to database for share code: %s of year: %s'
% (in_code, loc_start_date.year))
tmp_df.to_sql(self.tablelst['pro_hsgt_top10_data'],
self.engine,
if_exists='append')
loc_start_date = date(loc_start_date.year + nYearStep,
loc_start_date.month, loc_start_date.day)
loc_end_date = date(loc_end_date.year + nYearStep,
loc_end_date.month, loc_end_date.day)
if (loc_start_date.year >= loc_today.year):
self.my_logger.debug(
'date for share code: %s is up to date to year: %s' %
(in_code, loc_start_date.year))
break
def get_calendar_days():
with MysqlManager('wind') as session:
try:
year_begain = (date.today() -
offsets.YearBegin()).strftime('%Y%m%d')
year_end = (date.today() + offsets.YearEnd()).strftime('%Y%m%d')
# AShareCalendar -- 中国A股交易日历; SSE -- 上海证券交易所
sql_fetch_all = """SELECT TRADE_DAYS FROM AShareCalendar
WHERE S_INFO_EXCHMARKET = 'SSE' AND TRADE_DAYS BETWEEN {0} AND {1}""".format(
year_begain, year_end)
trade_days = set(
session.read_sql(sql_fetch_all,
to_DataFrame=True)['TRADE_DAYS'].tolist())
all_days = set(
map(
lambda dt: dt.strftime('%Y%m%d'),
rrule.rrule(rrule.DAILY,
dtstart=datetime.strptime(
year_begain, '%Y%m%d'),
until=datetime.strptime(year_end, '%Y%m%d'))))
no_trade_days = all_days - trade_days
return trade_days, no_trade_days
except Exception as e:
print(e)
return None, None
finally:
print('pas de bras pas de chocolat. No chocolate without arms.')
def set_time_point(self, time_frequency='D'):
geo_time_db = pd.DatetimeIndex(self.dset_geo_point[self.column_db_tag_time].values).unique().sort_values()
time_start = geo_time_db[0] - offsets.YearBegin()
time_end = geo_time_db[-1] + offsets.YearEnd()
time_range = pd.date_range(start=time_start, end=time_end, freq=time_frequency)
time_range = pd.DatetimeIndex(time_range.format(formatter=lambda x: x.strftime('%Y-%m-%d')))
return time_range
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 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 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()))
("Y", 1000), ("3Y", 1000), ("-1Y", 1000),
("W", 4000), ("W-MON", 4001), ("W-FRI", 4005)
])
def test_freq_code(freqstr, expected):
assert get_freq(freqstr) == expected
def test_freq_code_match(period_code_item):
freqstr, code = period_code_item
assert get_freq(freqstr) == code
@pytest.mark.parametrize("freqstr,expected", [
("A", 1000), ("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)
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
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(), "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",
[
("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),
def test_is_superperiod_subperiod():
assert (fmod.is_superperiod(offsets.YearEnd(), offsets.MonthEnd()))
assert (fmod.is_subperiod(offsets.MonthEnd(), offsets.YearEnd()))
def get(self, request, employee_id):
ids_bests = request.session.get('ids_best_perf', [])
if int(employee_id) in ids_bests:
is_best = True
else:
is_best = False
employee = get_object_or_404(Employee, id=employee_id)
today = datetime.date.today().strftime('%Y-%m-%d')
# Territories part
territories = Territory.objects.filter(clerks=Employee.objects.get(
id=employee_id))
# TimExpPart
regular_amount_vac = 26
vacations_to_be_taken = 0
first_day_of_this_year = (datetime.date.today() -
offsets.YearBegin()).strftime('%Y-%m-%d')
last_day_of_this_year = (datetime.date.today() +
offsets.YearEnd()).strftime('%Y-%m-%d')
vacations_already_booked = len(
TimeExp.objects.filter(clerk=employee_id,
type=2,
date__gte=first_day_of_this_year).filter(
date__lte=last_day_of_this_year))
vacations_to_be_taken = regular_amount_vac - vacations_already_booked
all_vacations_to_happen = TimeExp.objects.filter(clerk=employee_id,
type=2,
date__gte=today)
all_trainings_to_happen = TimeExp.objects.filter(clerk=employee_id,
type=3,
date__gte=today)
# Productivity part
clerk_inbound_call = []
clerk_outbound_call = []
clerks_outbound_mail = []
clerks_inbound_mail = []
all_clerk_productivity = Productivity.objects.filter(clerk=employee_id)
all_dates_for_productivity = [
result.date for result in all_clerk_productivity
]
desired_dates = []
for date in all_dates_for_productivity:
if date not in desired_dates:
desired_dates.append(date)
desired_dates.sort()
desired_dates = desired_dates[-15:]
for date in desired_dates:
result_inbound_call = Productivity.objects.get(date=date,
clerk=employee_id,
type=1)
clerk_inbound_call.append(int(result_inbound_call.number))
result_outbound_call = Productivity.objects.get(date=date,
clerk=employee_id,
type=2)
clerk_outbound_call.append(int(result_outbound_call.number))
result_inbound_mail = Productivity.objects.get(date=date,
clerk=employee_id,
type=3)
clerks_inbound_mail.append(int(result_inbound_mail.number))
result_outbound_mail = Productivity.objects.get(date=date,
clerk=employee_id,
type=4)
clerks_outbound_mail.append(int(result_outbound_mail.number))
trace1 = go.Bar(x=desired_dates,
y=clerk_inbound_call,
name='Inbound Calls')
trace2 = go.Bar(x=desired_dates,
y=clerk_outbound_call,
name='Outbound Calls')
trace3 = go.Bar(x=desired_dates,
y=clerks_inbound_mail,
name='Inbound Mails')
trace4 = go.Bar(x=desired_dates,
y=clerks_outbound_mail,
name='Outbound Mails')
clerks_data = [trace1, trace2, trace3, trace4]
layout = go.Layout(barmode='group',
title='Productivity by Contact Type')
fig = go.Figure(data=clerks_data, layout=layout)
clerk_div = opy.plot(fig, auto_open=False, output_type='div')
# productivity tendencies
engine = create_engine(
'postgresql+psycopg2://postgres:coderslab@localhost/coll_db')
prod_clerk_df = pd.read_sql_query(
'SELECT "date", "number", "type" FROM mng_dashboard_productivity WHERE clerk_id={}'
.format(employee_id),
con=engine)
av_clerks_in_call = prod_clerk_df[prod_clerk_df.type ==
1].number.mean()
av_clerks_out_call = prod_clerk_df[prod_clerk_df.type ==
2].number.mean()
# av_clerks_in_mail = prod_clerk_df[prod_clerk_df.type==3].number.mean()
# av_clerks_out_mail = prod_clerk_df[prod_clerk_df.type==4].number.mean()
ctx = {
"employee": employee,
"active_employees": Employee.active_employees(),
"all_vacations_to_happen": all_vacations_to_happen,
"all_trainings_to_happen": all_trainings_to_happen,
"vacations_to_be_taken": vacations_to_be_taken,
"territories": territories,
"all_territories": Territory.objects.all(),
"clerk_prod_graph": clerk_div,
"is_best": is_best,
"av_in_calls": round(av_clerks_in_call, 2),
"av_out_calls": round(av_clerks_out_call, 2)
}
return render(request, "employee_details.html", ctx)
def get_since_until(
time_range: Optional[str] = None,
since: Optional[str] = None,
until: Optional[str] = None,
time_shift: Optional[str] = None,
relative_start: Optional[str] = None,
relative_end: Optional[str] = None,
) -> Tuple[datetime, datetime]:
"""Return `since` and `until` date time tuple from string representations of
time_range, since, until and time_shift.
This functiom supports both reading the keys separately (from `since` and
`until`), as well as the new `time_range` key. Valid formats are:
- ISO 8601
- X days/years/hours/day/year/weeks
- X days/years/hours/day/year/weeks ago
- X days/years/hours/day/year/weeks from now
- freeform
Additionally, for `time_range` (these specify both `since` and `until`):
- Last day
- Last week
- Last month
- Last quarter
- Last year
- No filter
- Last X seconds/minutes/hours/days/weeks/months/years
- Next X seconds/minutes/hours/days/weeks/months/years
"""
separator = " : "
relative_start = parse_human_datetime(relative_start if relative_start else "today")
relative_end = parse_human_datetime(relative_end if relative_end else "today")
common_time_frames = {
"Last day": (
relative_start - relativedelta(days=1), # type: ignore
relative_end,
),
"Last week": (
relative_start - relativedelta(weeks=1), # type: ignore
relative_end,
),
"Last month": (
relative_start - relativedelta(months=1), # type: ignore
relative_end,
),
"Last quarter": (
relative_start - relativedelta(months=3), # type: ignore
relative_end,
),
"Last year": (
relative_start - relativedelta(years=1), # type: ignore
relative_end,
),
"This year": (
date.today() - offsets.YearBegin(), # type: ignore
date.today() + offsets.YearEnd(),
),
"This month": (
relative_start - relativedelta(days=relative_start.day - 1) , # type: ignore
relative_end,
),
"This week": (
relative_start - relativedelta(days=relative_start.weekday()), # type: ignore
relative_end,
),
}
if time_range:
if separator in time_range:
since, until = time_range.split(separator, 1)
if since and since not in common_time_frames:
since = add_ago_to_since(since)
since = parse_human_datetime(since)
until = parse_human_datetime(until)
elif time_range in common_time_frames:
since, until = common_time_frames[time_range]
elif time_range == "No filter":
since = until = None
else:
rel, num, grain = time_range.split()
if rel == "Last":
since = relative_start - relativedelta( # type: ignore
**{grain: int(num)}
)
until = relative_end
else: # rel == 'Next'
since = relative_start
until = relative_end + relativedelta( # type: ignore
**{grain: int(num)}
)
else:
since = since or ""
if since:
since = add_ago_to_since(since)
since = parse_human_datetime(since)
until = parse_human_datetime(until) if until else relative_end
if time_shift:
time_delta = parse_past_timedelta(time_shift)
since = since if since is None else (since - time_delta) # type: ignore
until = until if until is None else (until - time_delta) # type: ignore
if since and until and since > until:
raise ValueError(_("From date cannot be larger than to date"))
return since, until # type: ignore
freqstr, code = period_code_item
assert get_freq(freqstr) == code
@pytest.mark.parametrize("freqstr,expected", [
("A", 1000),
("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):
