def scheduled_tasks(): ctx = app.test_request_context() ctx.push() now = datetime.now(timezone(app.config['TIMEZONE'])).replace(second=0, microsecond=0) tasks = ScheduledTask.list({'is_online': True}) for task in tasks: if task['frequency'] == 'day': if task['frequency_hour'] == now.hour and task['frequency_minute'] == now.minute: execute_task.apply_async((task,), countdown=0) else: created_at = task['created_at'].replace(second=0, microsecond=0, tzinfo=now.tzinfo) if task['frequency'] == 'week': rule = rrule(WEEKLY, interval=task['frequency_count'], byminute=task['frequency_minute'], byhour=task['frequency_hour'], byweekday=task['frequency_day'], dtstart=created_at, until=now) elif task['frequency'] == 'month': rule = rrule(MONTHLY, interval=task['frequency_count'], byminute=task['frequency_minute'], byhour=task['frequency_hour'], bymonthday=task['frequency_day'], dtstart=created_at, until=now) elif task['frequency'] == 'year': rule = rrule(YEARLY, interval=task['frequency_count'], byminute=task['frequency_minute'], byhour=task['frequency_hour'], byyearday=task['frequency_day'], dtstart=created_at, until=now) if now in rule: execute_task.apply_async((task,), countdown=0)
def create_from_ical(self, cal): for component in cal.walk('vevent'): start_date = component.get('dtstart').dt end_date = component.get('dtend').dt summary = component.get('summary') recur = component.get('RRULE') if recur is not None: FREQ, COUNT, INTERVAL = "", "", "" #Get the frequency m = re.search("'FREQ': \['(.*?)'\]", str(recur), re.IGNORECASE) FREQ = m.group(1) #Get the Count m = re.search("'COUNT': \[(.*?)\]", str(recur), re.IGNORECASE) COUNT = int(m.group(1)) #Get the interval m = re.search("'INTERVAL': \[(.*?)\]", str(recur), re.IGNORECASE) INTERVAL = int(m.group(1)) #Expand out the dates starts = list(rrule(DAILY, count=COUNT, interval=INTERVAL, dtstart=start_date)) ends = list(rrule(DAILY, count=COUNT, interval=INTERVAL, dtstart=end_date)) for i in range(len(starts)): self._add_ica_event_to_schedule(starts[i], ends[i], summary) else: self._add_ica_event_to_schedule(start_date, end_date, summary) self._fix_up_calendar();
def test31(): """ check interval task """ # interval every 30 minute : now = datetime.now() tasks('add_task', 'test31', 'logging.notice', minute='*/30') task = tasks('by_name', 'test31') times=list(rrule(MINUTELY, byminute=[0,30], bysecond=0, count=3, dtstart=now)) assert times[0] == task.schedule(test=True) assert times[1] == task.schedule(test=True, now=times[0]) assert times[2] == task.schedule(test=True, now=times[1]) tasks('del_task', task.id) # interval 45 minute, must not trigger at "0" min tasks('add_task', 'test31bis', 'logging.notice', minute='*/45') task = tasks('by_name', 'test31bis') times=list(rrule(MINUTELY, byminute=[0,45], bysecond=0, count=3, dtstart=now)) assert times[0] == task.schedule(test=True) assert times[1] == task.schedule(test=True, now=times[0]) assert times[2] == task.schedule(test=True, now=times[1]) tasks('del_task', task.id)
def computeRecurrings(firstRecurringDatetime, repeat): """Compute recurring datetimes according to repeat value""" #get tzinfo tzinfo = firstRecurringDatetime.tzinfo #create new datetime without tzinfo (mandatory to use dateutil.rrule lib:S) dt = datetime(firstRecurringDatetime.year, firstRecurringDatetime.month, firstRecurringDatetime.day, firstRecurringDatetime.hour, firstRecurringDatetime.minute) #get current date infos now = datetime.now() today = datetime(now.year, now.month, now.day) until = today + relativedelta(months=+2) #compute reccurings recurrings = [] if repeat==0: #not a recurring schedule recurrings = [dt] elif repeat==1: #repeat every day recurrings = list(rrule(DAILY, until=until, dtstart=dt)) elif repeat==7: #repeat every week recurrings = list(rrule(WEEKLY, until=until, dtstart=dt)) elif repeat==31: #repeat every month recurrings = list(rrule(MONTHLY, until=until, dtstart=dt)) elif repeat==365: #repeat every year #need to save at least 2 schedules, otherwise it will be lost by purge until = today + relativedelta(years=+1, months=+1) recurrings = list(rrule(YEARLY, until=until, dtstart=dt)) #read tzinfo to computed recurrings fixedRecurrings = [] for recurring in recurrings: fixedRecurrings.append(datetime(recurring.year, recurring.month, recurring.day, recurring.hour, recurring.minute, 0, 0, tzinfo)) return fixedRecurrings
def expand_recurring_events(request): try: cursor=request.POST.get('cursor') recurring_events_q=Event.all().filter('repeats_frequency >=', 'MONTHLY').filter('status =', 'approved') if cursor: recurring_events_q=recurring_events_q.with_cursor(cursor) events=recurring_events_q.fetch(1) if events: taskqueue.add(url='/events/expand_recurring_events/', params={'cursor':recurring_events_q.cursor()}) for event in events: logging.warning("expanding %s" % event.title) if event.repeats_frequency == 'WEEKLY': rule=rrule(WEEKLY, dtstart=event.site.today, byweekday=event.local_start.weekday(), count=5) copies=event.copy(rule) db.put(copies) elif event.repeats_frequency == 'MONTHLY': ordinal=event.repeats_setpos weekday=(MO,TU,WE,TH,FR,SU)[event.local_start.weekday()](ordinal) logging.warning(ordinal) rule=rrule(MONTHLY, dtstart=event.site.today, byweekday=weekday(ordinal), count=5, wkst=MO) copies=event.copy(rule) db.put(copies) except Exception,e: logging.error("%s in \n%s"% (traceback.format_exc(),str(request.POST)))
def schedule_edit(year, month): schedules = Schedule.query.filter(Schedule.year==year, Schedule.month==month) \ .order_by(Schedule.type).all() if month == 1: last_month_days = rrule(DAILY, dtstart=datetime.date(year-1, 12, 26), \ until=datetime.date(year, month, 1) - datetime.timedelta(days=1)) else: last_month_days = rrule(DAILY, dtstart=datetime.date(year, month-1, 26), \ until=datetime.date(year, month, 1) - datetime.timedelta(days=1)) this_month_days = rrule(DAILY, dtstart=datetime.date(year, month, 1), \ until=datetime.date(year, month, 25)) last_month = [] this_month = [] for day in last_month_days: last_month.append(1) if day.isoweekday() in [ 6, 7 ] else last_month.append(0) for day in this_month_days: this_month.append(1) if day.isoweekday() in [ 6, 7 ] else this_month.append(0) return render_template('schedule_edit.html', year=year, month=month, count=len(last_month)+len(this_month), \ last_month=last_month, this_month=this_month, staffs=schedules)
def listDates(dtstart, dtend, freq, values): # freq 0=byweekday, 1=bymonthday, 2=MONTHLY, 3=YEARLY dates = [] date = [] dtexec = dtstart while dtexec <= dtend: if freq == 0: date = list(rrule(DAILY, count=2, byweekday=values, dtstart=dtexec, cache=True)) elif freq == 1: date = list(rrule(DAILY, count=2, bymonthday=values, dtstart=dtexec, cache=True)) elif freq == 2: date = list(rrule(MONTHLY, count=2, dtstart=dtexec, interval=values, cache=True)) elif freq == 3: date = list(rrule(YEARLY, count=2, dtstart=dtexec, interval=values, cache=True)) if len(date) > 0: dtexec = date[0] if dtexec <= dtend: dates.append(dtexec) dtexec = date[1] else: break return dates
def get_filter_dates(): from_date = rrule(MONTHLY, count=1, dtstart=add_months(date.today(), -1), bymonthday=25)[0] to_date = rrule(MONTHLY, count=1, dtstart=date.today(), bymonthday=24)[0] return from_date, to_date
def create_instances(self): self.destroy_instances(fromNow=True) end_time_delta = relative_delta(self.end_time, self.start_time) repeat_end = self.repeat_end or datetime.now() + relativedelta(years=1) dates = [] if self.repeat_interval is EventRepeat.Once: dates = [start_time] elif self.repeat_interval is EventRepeat.MonthlyByDayOfWeek: dates = list( rrule(self.repeat_interval, dtstart=self.start_time, until=repeat_end, byweekday=self.start_time.weekday())) else: dates = list( rrule(self.repeat_interval, dtstart=self.start_time, until=repeat_end)) for dt in dates: self.create_instance(dt, dt + end_time_delta) db.session.commit()
def computeRecurrings(recurringDatetime, repeat, months): global nowUtc #get tzinfo tzinfo = recurringDatetime.tzinfo #create start datetime (without tzinfo because its mandatory to use dateutil.rrule lib:S) start = datetime(recurringDatetime.year, recurringDatetime.month, recurringDatetime.day, recurringDatetime.hour, recurringDatetime.minute) #compute current datetime eoy = datetime(nowUtc.year, 12, 31) #end of year #compute reccurings recurrings = [] if repeat==0: #not a recurring schedule recurrings = [start] elif repeat==1: #repeat every day recurrings = list(rrule(DAILY, bymonth=months, until=eoy, dtstart=start)) elif repeat==7: #repeat every week recurrings = list(rrule(WEEKLY, bymonth=months, until=eoy, dtstart=start)) elif repeat==31: #repeat every month recurrings = list(rrule(MONTHLY, bymonth=months, until=eoy, dtstart=start)) elif repeat==365: #repeat every year #need to save at least 2 schedules, otherwise it will be lost by purge until = start + relativedelta(years=+1, months=+1) recurrings = list(rrule(YEARLY, until=until, dtstart=start)) #re-add tzinfo for recurring in recurrings: recurring.replace(tzinfo=tzinfo) return recurrings
def run_scheduler(self, cr, uid, automatic=False, use_new_cursor=False, context=None): if not context: context = {} maintenance_type_obj = self.pool.get('maintenance.type') type_ids = maintenance_type_obj.search(cr, uid, [('planificado', '=', True),('on_stop', '=', False)]) type_objs = maintenance_type_obj.browse(cr, uid, type_ids, context) dias = { 'lunes':MO, 'martes':TU, 'miercoles':WE, 'jueves':TH, 'viernes':FR, 'sabado':SA, 'domingo':SU, } for type_obj in type_objs: if type_obj.planificado: ultima_ej = datetime.strptime(type_obj.ultima_ejecucion or type_obj.inicio, "%Y-%m-%d") fin = (datetime.now() + relativedelta(months=+1)) - relativedelta(days=-1) fechas_excluidas = [] for dia in dias.keys(): if type_obj[dia] : fechas_excluidas += rrule(int(type_obj.intervalo), byweekday=dias[dia], dtstart=ultima_ej).between(ultima_ej, fin, inc=True) fechas = rrule(int(type_obj.intervalo), dtstart=ultima_ej, interval=type_obj.interval_count).between(ultima_ej, fin, inc=True) if fechas: ultima_creacion = ultima_ej for fecha in fechas: crear_solicitud = True if fecha in fechas_excluidas: fecha_cambiada = False nueva_fecha = fecha while not fecha_cambiada: nueva_fecha = nueva_fecha + relativedelta(days=+1) # si el intervalo es diario if nueva_fecha in fechas or nueva_fecha > fin: crear_solicitud = False break if nueva_fecha not in fechas_excluidas: fecha = nueva_fecha fecha_cambiada = True if crear_solicitud: ultima_creacion = fecha element_ids = [] for obj in type_obj.element_ids: element_ids.append(obj.id) args_request = { 'maintenance_type_id':type_obj.id, 'element_ids':[(6, 0, element_ids)], 'fecha_solicitud':fecha, 'department_id': type_obj.department_id and type_obj.department_id.id or False, 'executor_department_id': type_obj.department_id and type_obj.department_id.id or False, } self.pool.get('intervention.request').create(cr, uid, args_request, context) maintenance_type_obj.write(cr, uid, type_obj.id, {'ultima_ejecucion': ultima_creacion}, context) return True
def create_backtest_dates(beg, end, freq='M', holiday_list=None): '''Return list of backtest dates in MM/DD/YYYY format Positional ARGS: beg -- str of start date end -- str of end date Keyword ARGS: freq -- frequency of dates Currently Supports: M=MONTHLY, W=WEEKLY, D=DAILY*, Y=YEARLY, S=SEMI-ANNUALLY, Q=QUARTERLY Defaults to MONTHLY *DAILY only includes WEEKDAYS holiday_list -- list of dates to exclude Currently only used when freq='D' Exceptions: ValueError -- if conversion of beg/end fails ''' beg_dt = create_datetime(beg) end_dt = create_datetime(end) if beg_dt == end_dt: return [beg_dt.strftime('%m/%d/%Y')] if freq == 'M': date_list = [ date.strftime('%m/%d/%Y') for date in list( rrule(MONTHLY, dtstart=beg_dt, until=end_dt, interval=1)) ] elif freq == 'W': date_list = [ date.strftime('%m/%d/%Y') for date in list( rrule(WEEKLY, dtstart=beg_dt, until=end_dt, interval=1)) ] elif freq == 'D': date_list = [ date.strftime('%m/%d/%Y') for date in list( rrule(DAILY, dtstart=beg_dt, until=end_dt, interval=1, byweekday=(MO, TU, WE, TH, FR))) ] if holiday_list != None: for d in holiday_list: try: date_list.remove(d) except ValueError: pass elif freq == 'S': date_list = [ date.strftime('%m/%d/%Y') for date in list( rrule(MONTHLY, dtstart=beg_dt, until=end_dt, interval=6)) ] elif freq == 'Q': date_list = [ date.strftime('%m/%d/%Y') for date in list[rrule( MONTHLY, dtstart=beg_dt, until=end_dt, interval=3)] ] return date_list
def generate_recurrence_dates(self, recurrence_start_date, recurrence_end_date, recurrence_type): rec_args = recurrence_type.split("_") #rec_type - type of repeating “day”,”week”,”month”,”year” rec_type = rec_args[0] #count - how much intervals of “type” come between events count = rec_args[1] #count2 and day - used to define day of month ( first Monday, third Friday, etc ) day = rec_args[2] count2 = rec_args[3] #days - comma separated list of affected week days days = rec_args[4].split("#")[0] #extra - extra info extra = rec_args[4].split("#")[1] rrule_count = None if (extra != "no") and (extra != ""): try: rrule_count = int(extra) except TypeError: rrule_count = None freq_map = {"day":DAILY,"week":WEEKLY,"month":MONTHLY,"year":YEARLY} freq = freq_map[rec_type] if count != "": interval = int(count) else: interval = 1 byweekday=None day_map = {0:SU,1:MO,2:TU,3:WE,4:TU,5:FR,6:SA} if (count2 != "") and (day != ""): byweekday = day_map[int(day)](+int(count2)) elif (days != ""): byweekday = map(int,days.split(",")) if rrule_count is not None: if byweekday is not None: return list(rrule(freq, dtstart=recurrence_start_date, until=recurrence_end_date, count=rrule_count, byweekday=byweekday, interval=interval)) else: return list(rrule(freq, dtstart=recurrence_start_date, until=recurrence_end_date, count=rrule_count, interval=interval)) else: if byweekday is not None: return list(rrule(freq, dtstart=recurrence_start_date, until=recurrence_end_date, byweekday=byweekday, interval=interval)) else: return list(rrule(freq, dtstart=recurrence_start_date, until=recurrence_end_date, interval=interval))
def date_range(start, end, q): """Date Range""" r = (end + timedelta(days=1) - start).days if int(q) <= 2: return list(rrule(DAILY, dtstart=parse(str(start)), until=parse(str(end)))) if int(q) >= 3: return list(rrule(HOURLY, interval=1, dtstart=parse(str(start)), until=parse(str(end)))) else: return [start + timedelta(days=i) for i in range(r)]
def work_days_diff(start_date, end_date): if end_date > start_date: rr = rrule(HOURLY, byweekday=(MO, TU, WE, TH, FR), byhour=range(9, 17), dtstart=start_date, until=end_date) return [rr.count(), rr] elif start_date > end_date: rr = rrule(HOURLY, byweekday=(MO, TU, WE, TH, FR), byhour=range(9, 17), dtstart=end_date, until=start_date) return [-(rr.count()), rr] else: return [0, None]
def process_dates(): global calendar_events_keep_alive global event_id_list start_connection() start_date_list = list( rrule(DAILY, byweekday=tuple(check_button_list), dtstart=parse(start_date_selector.get() + " " + start_time_input.get()), until=parse(end_date_selector.get() + " " + start_time_input.get()))) stop_date_list = list( rrule( DAILY, byweekday=tuple(check_button_list), dtstart=parse(start_date_selector.get() + " " + start_time_input.get()) + datetime.timedelta(hours=float(end_time_entry.get())), until=parse(end_date_selector.get() + " " + start_time_input.get()) + datetime.timedelta(hours=float(end_time_entry.get())))) date_list = zip(start_date_list, stop_date_list) hours = 0.0 days = 0 event_id_list = [] try: for start, stop in date_list: if not calendar_events_keep_alive: break else: event_id_list.append( insert_event_into_cal(rfc3339.rfc3339(start), rfc3339.rfc3339(stop))) days += 1 hours += float(end_time_entry.get()) except googleapiclient.errors.HttpError: root_window.withdraw() tkinter.messagebox.showerror( "Error Adding Event", "Error when attempting to create events,\n does the calendar still exist?" ) raise SystemExit message_text = "Calendar event(s) created for \"{0}\" event," \ " for {1} hours, over the course of {2} days." \ " The event days are between {3} and {4}".\ format(event_input.get(), str(hours), str(days), str(start_date_selector.get()), str(end_date_selector.get())) notify_message = create_message( 'me', notification_input.get(), '{} Calendar Event Created'.format(event_input.get()), message_text) send_message(email_service, 'me', notify_message) print(message_text)
def schedule_list(page=1): now = datetime.datetime.now() start_month = now + relativedelta(months=-10) end_month = now + relativedelta(months=3) date = [ str(i.year) + '-' + str(i.month) for i in list(rrule(MONTHLY, dtstart=start_month, until=end_month)) ] date.reverse() lists = [] for i in date: year, month = int(i.split('-')[0]), int(i.split('-')[1]) schedules = Schedule.query.filter(Schedule.year == year, Schedule.month == month).order_by( Schedule.type).all() if schedules: if month == 1: last_month_days = rrule(DAILY, dtstart=datetime.date(year-1, 12, 26), \ until=datetime.date(year, month, 1) - datetime.timedelta(days=1)) else: last_month_days = rrule(DAILY, dtstart=datetime.date(year, month-1, 26), \ until=datetime.date(year, month, 1) - datetime.timedelta(days=1)) this_month_days = rrule(DAILY, dtstart=datetime.date(year, month, 1), \ until=datetime.date(year, month, 25)) last_month = [] this_month = [] for day in last_month_days: last_month.append(1) if day.isoweekday() in [ 6, 7 ] else last_month.append(0) for day in this_month_days: this_month.append(1) if day.isoweekday() in [ 6, 7 ] else this_month.append(0) lists.append({ 'year': year, 'month': month, 'count': len(last_month) + len(this_month), 'last_month': last_month, 'this_month': this_month, 'staffs': schedules }) #print lists return render_template('schedule_list.html', lists=lists, current_year=now.year, current_month=now.month)
def parse_freq(string, end_date): if string.count("*") == 0: return [ str(rrule(freq=WEEKLY, interval=1, until=end_date)).split("\n")[1] + "Z" ] elif string.count("*") == 1: return [ str(rrule(freq=WEEKLY, interval=2, until=end_date)).split("\n")[1] + "Z" ]
def scheduler(): lost_sch = False querysets = schedule() if not querysets: querysets = get_lost_schedule() lost_sch = True for item in querysets: #print datetime.date(item.date), datetime.time(item.time) cdatetime = getdatetime(datetime.date(item.date), datetime.time(item.time)) if any([item.frequency != " ", item.due_dates != '0']): load.schedule(args=(item.user.username, item.amount, item.type, item.phone_no), eta=cdatetime) try: inter, loop = item.frequency.split('-') # eg 2-month except ValueError: loop = '' if loop == 'month': freq = MONTHLY elif loop == 'week': freq = WEEKLY elif loop == 'day': freq = DAILY elif loop == 'hour': freq = HOURLY else: if item.due_dates == '0': return a = rrule( MONTHLY, interval=1, count=2, bymonthday=(map(int, item.due_dates.split(','))), dtstart=cdatetime) if item.due_dates != '0' else rrule( freq, interval=int(inter), count=2, dtstart=cdatetime) sch_datetime = a.after(cdatetime, inc=False) print sch_datetime if sch_datetime is None: return item.date = sch_datetime if lost_sch is False else ( datetime.now() + timedelta(days=datetime.now().day)) item.time = sch_datetime update_schedule(item)
def calculate_no_payments(start_date, end_date, freq): if freq == "W": # weekly freq no_payments = len(list(rrule(WEEKLY, dtstart=start_date, until=end_date))) elif freq == "BW": # bi-weekly freq no_payments = len(list(rrule(WEEKLY, interval=2, dtstart=start_date, until=end_date))) elif freq == "M": # monthly no_payments = len(list(rrule(MONTHLY, bymonthday=(MO, -1), bysetpos=1, dtstart=start_date, until=end_date))) return no_payments
def nextDate(dtstart, freq, values): # freq 0=byweekday, 1=bymonthday, 2=MONTHLY, 3=YEARLY date = [] if freq == 0: date = list(rrule(DAILY, count=1, byweekday=values, dtstart=dtstart, cache=True)) elif freq == 1: date = list(rrule(DAILY, count=1, bymonthday=values, dtstart=dtstart, cache=True)) elif freq == 2: date = list(rrule(MONTHLY, count=1, dtstart=dtstart, interval=values, cache=True)) elif freq == 3: date = list(rrule(YEARLY, count=1, dtstart=dtstart, interval=values, cache=True)) return date
def select_options(self): start_year = getattr(settings, 'START_YEAR', 2008) years = [ dict(val=six.text_type(y), text=y) for y in range(start_year, datetime.utcnow().year + 1) ] years.reverse() months = [ dict(val="%02d" % m, text=calendar.month_name[m]) for m in range(1, 13) ] now = datetime.now() three_month_earlier = now - relativedelta(months=3) first_friday = rrule(DAILY, dtstart=datetime(three_month_earlier.year, three_month_earlier.month, 1), until=now, byweekday=FR)[0] if first_friday.day != 1: first_friday = first_friday - relativedelta(days=7) fridays = rrule(WEEKLY, dtstart=first_friday, until=now, byweekday=FR) weeks = [] value = None text = None for idx, val in enumerate(fridays): try: value = '{0}|{1}'.format(val.strftime("%Y-%m-%d"), fridays[idx + 1].strftime("%Y-%m-%d")) text = '{0} - {1}'.format( ews_date_format(val), ews_date_format(fridays[idx + 1] - relativedelta(days=1))) except IndexError: next_thursday = val + relativedelta(days=6) value = '{0}|{1}'.format(val.strftime("%Y-%m-%d"), next_thursday.strftime("%Y-%m-%d")) text = '{0} - {1}'.format(ews_date_format(val), ews_date_format(next_thursday)) finally: weeks.append(dict(val=value, text=text)) return [{ 'text': 'Week (Friday - Thursday)', 'val': 2, 'firstOptions': weeks, 'secondOptions': [] }, { 'text': 'Month', 'val': 1, 'firstOptions': months, 'secondOptions': years }]
def time_between(self,start,end,fpago): atraso = "" if fpago == "Semanal": atraso = rrule(WEEKLY,dtstart=start,until =end) print "fue semanal" elif fpago == "Quincenal": atraso = rrule(MONTHLY,dtstart=start,until =end) elif fpago == "Mensual": atraso = rrule(MONTHLY,dtstart=start,until =end) print "Este es el atraso de time between" ,atraso return atraso.count()
def time_between(self, start, end, fpago): atraso = "" if fpago == "Semanal": atraso = rrule(WEEKLY, dtstart=start, until=end) print "fue semanal" elif fpago == "Quincenal": atraso = rrule(MONTHLY, dtstart=start, until=end) elif fpago == "Mensual": atraso = rrule(MONTHLY, dtstart=start, until=end) print "Este es el atraso de time between", atraso return atraso.count()
def time_arranger(year, month): ini_time = dt.datetime(year, month, 1, 20, 1) bg_time = ini_time + relativedelta(days=-1) ed_time = ini_time + relativedelta(months=+1) ed_time += relativedelta(days=-1) day = list(rrule(DAILY, dtstart=bg_time, until=ed_time, interval=1)) ed_time += relativedelta(minutes=-1) time_list = list( rrule(MINUTELY, dtstart=bg_time, until=ed_time, interval=1)) time_list = np.array(time_list) time_array = time_list.reshape((len(day) - 1, 24, 60)) data_store_array = np.zeros((len(day) - 1, 24, 60)) return time_array, data_store_array
def sports(): sports_url = 'http://www.goprincetontigers.com/main/Schedule.dbml' response = requests.get(sports_url, headers=headers) soup = BeautifulSoup(response.text) game = soup.select('tr.home') for g in game: print g.get_text().strip() date_info = g.select('td.date')[0].get_text().strip().split('-') date = parse(date_info[0].encode('ascii', errors='ignore'), fuzzy=True) end_date = None if len(date_info) > 1: end_date = parse(date_info[1].encode('utf-8'), fuzzy=True) name = g.select('td.team')[0].get_text().strip() name = name + ' vs. ' + g.select('td.opponent')[0].get_text().strip() name = re.sub(' \*', ' Conference Game', name) location = g.select('td.location')[0].get_text().strip() time = g.select('td.time')[0].get_text().strip() start_datetime = date end_datetime = date if re.search('\d', time): temp_time = time.split(' ') hr = int(temp_time[0].split(':')[0]) min = int(temp_time[0].split(':')[1]) if 'P' in temp_time[1]: if hr < 12: hr += 12 time = datetime.time(hr, min) start_datetime = datetime.datetime.combine(date, time) end_datetime = start_datetime + relativedelta(hours=2) list_of_start_dates = None if end_date: list_of_start_dates = list(rrule(DAILY, dtstart=start_datetime, until=end_date)) list_of_end_dates = list(rrule(DAILY, dtstart=end_datetime, until=end_date)) # if the event is multi-day, put all of them into event if list_of_start_dates: for s, e in zip(list_of_start_dates, list_of_end_dates): e = event.Event(name, s, e, location, 'watching') all_events.append(e) # if event is not multi-day, insert it into database: else: e = event.Event(name, start_datetime, end_datetime, location, 'watching') all_events.append(e)
def create_reminder_readings(sender, instance, created, **kwargs): if created is True: if instance.repeat_mode != '0': if instance.repeat_mode == '1': repeat = DAILY elif instance.repeat_mode == '2': repeat = WEEKLY elif instance.repeat_mode == '3': repeat = MONTHLY elif instance.repeat_mode == '4': repeat = YEARLY if instance.repeat_i_counter is None: repeat_counter = 20 else: repeat_counter = instance.repeat_i_counter if instance.repeat_every_x is not None: interval = instance.repeat_every_x else: interval = 1 if instance.end_date is None: list_of_dates = list( rrule(repeat, interval=interval, count=repeat_counter, dtstart=instance.start_date)) else: list_of_dates = list( rrule(repeat, interval=interval, dtstart=instance.start_date, until=instance.end_date)) for d in list_of_dates: reading_date = d reading = ReminderReadings(user=instance.user, reminder=instance, updated_by=instance.user, reading_date=reading_date) reading.save() else: reading = ReminderReadings(user=instance.user, reminder=instance, updated_by=instance.user, reading_date=instance.start_date) reading.save()
def get_list_of_history_entries(): he_list = {} month_list = list(rrule(MONTHLY, dtstart=date(2006, 3, 1), until=date.today())) for month in month_list: d = date(month.year, month.month, month.day) he_list[d] = HistoryEntry() he_list[d].month = d user_list = User.objects.all() for u in user_list: entry = get_date_of_entry(u) entry = date(entry.year, entry.month, 1) num = he_list[entry].new_member num += 1 he_list[entry].new_member = num end = get_date_of_exit(u) if end is not None: end = date(end.year, end.month, 1) num = he_list[end].resigned_member num += 1 he_list[end].resigned_member = num num = 0 for month in month_list: he = he_list[month.date()] num += he.new_member num -= he.resigned_member he.num_member = num return he_list
def is_day_within_staff_schedule(schedule, day): #populate rruleset with staff schedule hours rules = rruleset() #push rrule to rruleset if rules are present if schedule.rRule != None: rules.rrule(rrulestr(schedule.rRule, dtstart=parse(schedule.startDate))) if schedule.exDate != None: #exclude all days that are in exDate field exDates = schedule.exDate.split(',') for exDate in exDates: rules.exdate(parse(exDate)) #make rule and push it to rrule if rrule field is empty else: rules.rrule( rrule(MINUTELY, interval=1, dtstart=parse(schedule.startDate), until=parse(schedule.endDate))) #get day information from provided day info and hours, minutes from schedule year = day.year month = day.month day = day.day start_hour = parse(schedule.startDate).hour end_hour = parse(schedule.endDate).hour start_minute = parse(schedule.startDate).minute end_minute = parse(schedule.endDate).minute return datetime(year, month, day, start_hour, start_minute, tzinfo=timezone.utc) in rules
def get_rule(self): """ Get the recurrence rule for the periods """ slots = self.slots if not slots: return None match = re.match("\s*(\d*)\s*([hdwmy]{1}).*", slots) if match: num, delta = match.groups() deltas = { "h": HOURLY, "d": DAILY, "w": WEEKLY, "m": MONTHLY, "y": YEARLY, } if delta not in deltas: # @todo: handle "continuous" and "automatic" return None else: num = int(num) if num else 1 return rrule(deltas[delta], dtstart=self.start, until=self.end, interval=num) else: return None
def week_span_from_date(day): first_last_day_week = arrow.get(day).span('week') # Business days list week_dates = [r for r in rrule(DAILY, byweekday=(MO, TU, WE, TH, FR), dtstart=first_last_day_week[0], until=first_last_day_week[-1])] return week_dates
def get_list_of_history_entries(): he_list = {} month_list = list( rrule(MONTHLY, dtstart=date(2006, 3, 1), until=date.today())) for month in month_list: d = date(month.year, month.month, month.day) he_list[d] = HistoryEntry() he_list[d].month = d user_list = User.objects.all() for u in user_list: entry = get_date_of_entry(u) entry = date(entry.year, entry.month, 1) num = he_list[entry].new_member num += 1 he_list[entry].new_member = num end = get_date_of_exit(u) if end is not None: end = date(end.year, end.month, 1) num = he_list[end].resigned_member num += 1 he_list[end].resigned_member = num num = 0 for month in month_list: he = he_list[month.date()] num += he.new_member num -= he.resigned_member he.num_member = num return he_list
def mth_between(st_mth, et_mth): mth_format = "%Y-%m" st_mth_dt = datetime.datetime.strptime(st_mth, mth_format) et_mth_dt = datetime.datetime.strptime(et_mth, mth_format) tgt_list = list(rrule(MONTHLY, dtstart=st_mth_dt).between(st_mth_dt, et_mth_dt, inc=True)) full_mth_list = [mth_dt.strftime(mth_format) for mth_dt in tgt_list] return full_mth_list
def get_day_trade_minute_line(product, date): """ 返回一天内指定合约交易时段内所有分钟计算点 最后一分钟没有交易 :param symbol: :param date: DateTime :return: """ entries = get_trade_timetable_template(product) result = [] for w in range(len(entries)): s, e = entries[w][:2] dts = DateTime(date.year, date.month, date.day, s.hour, s.minute, s.second) dte = DateTime(date.year, date.month, date.day, e.hour, e.minute, e.second) # - TimeDelta(minutes=1) if len(entries[w]) == 3 and entries[w][-1].count('-'): # 跨天 dts += TimeDelta(days=1) dte += TimeDelta(days=1) else: if dte < dts: # 跨天的行情 dte = dte + TimeDelta(days=1) dte -= TimeDelta(minutes=1) # 不包括收尾分钟 mins = list(rrule(MINUTELY, interval=1, dtstart=dts, until=dte)) result += mins return result
def transform_to_utc(*args, **kargs): global data_count data = request.data request_body = json.loads(data) data_count = kargs['data']['count'] min_day = int(datetime.now().strftime("%d")) min_month = int(datetime.now().strftime("%m")) min_year = int(datetime.now().strftime("%Y")) day = int(request_body['day']) year = int(request_body['year']) month = int(request_body['month']) how_many = int(request_body['count']) if year < min_year or ((month < min_month) and (year <= min_year)) or \ (day < min_day and (month <= min_month and year <= min_year)): raise ProcessingException(description='Date not accept', code=400) else: del kargs['data']['day'] del kargs['data']['month'] del kargs['data']['year'] del kargs['data']['count'] start_date = str(month) + " " + str(day) + " " + str(year) + " 0:0:0 " all_dates = \ list(rrule(MONTHLY, count=how_many, dtstart=parse(start_date))) for var in all_dates: db.session.add(Dates(var)) db.session.commit() pass
def review(_inventory_level, _order_arrival): # inventory level today count = _inventory_level + _order_arrival # place an order, update stats if count <= min_level: order_is_placed.append(1) date_of_order.append(clock) if min_lt == max_lt: #deterministic order_lt = min_lt else: #not deterministic order_lt = np.around( np.random.triangular(min_lt, mode_lt, max_lt, size=None)) order_lt = order_lt.astype(int) # calculate order date excluding weekends date_delivery = rrule(DAILY, byweekday=(MO, TU, WE, TH, FR), dtstart=clock)[order_lt] date_delivery = date_delivery.date() # calculate order volume based on order position order_quantity = max_level - inventory_level - sum( orderq_schedule) #calculate order quantity order_quantity = np.ceil( order_quantity / unit_of_order ) * unit_of_order #ensure an order is placed in the units required delivery_schedule.append( date_delivery) #add delivery date to schedule orderq_schedule.append( order_quantity) # add order quantity to schedule
def add_work_days(date, duration): if duration: l_days = [] l_days = list(rrule(HOURLY, count=duration + 1, byweekday=(MO, TU, WE, TH, FR), byhour=range(9, 17), dtstart=date)) return l_days[-1] else: return date
def update_missing_eod(conn, curs, instrument): monthstr = [ 'JAN', 'FEB', 'MAR', 'APR', 'MAY', 'JUN', 'JUL', 'AUG', 'SEP', 'OCT', 'NOV', 'DEC' ] dates = [] #yyyy,mm,dd if instrument == "stock": starting_date = datetime(1994, 11, 3) else: #fo #starting_date = datetime(2000,6,12) starting_date = datetime(2006, 1, 1) for i in list( rrule(DAILY, dtstart=starting_date, until=datetime.now(), byweekday=(MO, TU, WE, TH, FR))): print 'Checking ', i, curs.execute( "select timestamp from historical_%s_data where timestamp='%d %s %d'" % (instrument, i.day, monthstr[i.month - 1], i.year)) r = curs.fetchall() if r == []: print ' not found, adding to fetch list' dates.append(i) else: print ' found' update_common(dates, conn, curs, instrument)
def update_eod_data(dates, conn, curs, instrument): update_common( list( rrule(DAILY, dtstart=dates[0], until=dates[1], byweekday=(MO, TU, WE, TH, FR))), conn, curs, instrument)
def get_recurrence_rule(self): ''' Returns the dateutil.rrule object instance associated with this Event ''' if self.rule: return rrule(eval(self.rule.frequency), dtstart=self.startdatetime, **self.rule.get_params()) return None
def test_get_recurrence_rule(self): event = Event.objects.get(pk=1) event_rule = event.get_recurrence_rule() rule = rrule(WEEKLY,byweekday=[SA,], until=datetime(2014,10,1,1,10,0, tzinfo=utc)) self.assertEqual(rule._freq, event_rule._freq) self.assertEqual(rule._byweekday, event_rule._byweekday) self.assertEqual(rule._until, event_rule._until)
def get_dates(dates) : """ Return a list of dates on which classes could be held. """ # base rule, e.g., available M, W, F's base = rrule(WEEKLY, dtstart=dates['start'], \ until=dates['end'], byweekday=(dates['days'])) # generate lecture dates lecturedates = rruleset() lecturedates.rrule(base) for d in dates['holiday'] : lecturedates.exdate(d[0]) for exam in dates['exam'] : lecturedates.exdate(exam[0]) # generate all meaningful dates to list alldates = rruleset() alldates.rrule(base) for exam in dates['exam'] : alldates.rdate(exam[0]) for hw in dates['homework'] : alldates.rdate(hw[0]) # given alldates.rdate(hw[1]) # due for exam in dates['other'] : alldates.rdate(exam[0]) return list(lecturedates), list(alldates)
def check_task_expire(): tasks = Task.query.filter(Task.type==1, Task.status==4).all() for task in tasks: if rrule(DAILY, dtstart=task.expired_time, until=datetime.datetime.now()).count() != 0: task.expire = 1 db.session.commit()
def rangeTimes(freq, tS, tE): # Function returns a list of times between two datetimes # Where freq must be one of YEARLY, MONTHLY, WEEKLY, DAILY, HOURLY, MINUTELY, or SECONDLY. timeList = list(rrule(freq, dtstart=tS, until=tE)) arr = np.empty((0,2)) for tStart, tEnd in zip(timeList, timeList[1:]): arr = np.append(arr, np.array([[tStart,tEnd]]),0) return arr
def _proc_repeats(toks): if not toks.singledate: interval = toks.weekly_ or toks.monthly or WEEKLY kwargs = {} kwargs['byweekday'] = toks.weekday or None kwargs['dtstart'] = toks.dtstart or NOW kwargs['count'] = 3 #toks.qty or 3 return list(rrule(interval, **kwargs))
def select_options(self): start_year = getattr(settings, 'START_YEAR', 2008) years = [dict(val=unicode(y), text=y) for y in range(start_year, datetime.utcnow().year + 1)] years.reverse() months = [dict(val="%02d" % m, text=calendar.month_name[m]) for m in range(1, 13)] now = datetime.now() three_month_earlier = now - relativedelta(months=3) first_friday = rrule(DAILY, dtstart=datetime(three_month_earlier.year, three_month_earlier.month, 1), until=now, byweekday=FR)[0] if first_friday.day != 1: first_friday = first_friday - relativedelta(days=7) fridays = rrule(WEEKLY, dtstart=first_friday, until=now, byweekday=FR) weeks = [] value = None text = None for idx, val in enumerate(fridays): try: value = '{0}|{1}'.format(val.strftime("%Y-%m-%d"), fridays[idx + 1].strftime("%Y-%m-%d")) text = '{0} - {1}'.format( ews_date_format(val), ews_date_format(fridays[idx + 1] - relativedelta(days=1)) ) except IndexError: next_thursday = val + relativedelta(days=6) value = '{0}|{1}'.format(val.strftime("%Y-%m-%d"), next_thursday.strftime("%Y-%m-%d")) text = '{0} - {1}'.format(ews_date_format(val), ews_date_format(next_thursday)) finally: weeks.append(dict(val=value, text=text)) return [ { 'text': 'Week (Friday - Thursday)', 'val': 2, 'firstOptions': weeks, 'secondOptions': [] }, { 'text': 'Month', 'val': 1, 'firstOptions': months, 'secondOptions': years } ]
def __init__(self, frequency, **kwargs): """ :Parameters: * `frequency`: a `dateutil` constant that defines this recurrence, e.g. `DAILY`, `WEEKLY` * `kwargs`: are valid arguments for `dateutil.rrule`s. """ kwargs['dtstart'] = kwargs['dtstart'] or self.way_old_date self.rule = rrule(frequency, **kwargs)
def loadtags(self): self._tags['sunset'] = self.getsunset().strftime("%H:%M:%S") self._tags['sunrise'] = self.getsunrise().strftime("%H:%M:%S") self._tags['issunset'] = '0' self._tags['issunrise'] = '0' self.rrules = {} for tag, params in self.config.items(): startdate = parse(params["start"]) enddate = parse(params["end"]) untildate = parse(params["until"]) freq = eval(params['freq']) startrr = rrule( freq, dtstart=startdate, until=untildate, cache=True) endrr = rrule(freq, dtstart=enddate, until=untildate, cache=True) self._tags[tag] = '0' tagrrule = self.rrules.setdefault(tag, {}) tagrrule["startrr"] = startrr tagrrule["endrr"] = endrr
def graph(self, graph_type, start=None): by, kid, count, start = self.graph_util(graph_type, start) result = [] for dt in rrule(by, count=count, dtstart=start): k = get_keys(self.key, dt)[kid] print k result.append([dt, self.formatter(self.red.get(k))]) return result
def _dynamic_fields(self): months = list(rrule(MONTHLY, dtstart=date.today() - relativedelta(months=12), count=12)) months.reverse() fields = [] for month in months: name = month.strftime("%b/%Y") fields.append((month, name + ' Updates', UPDATE_TYPE)) fields.append((month, name + ' Installs', INSTALL_TYPE)) return fields