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):