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 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 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 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 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 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 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 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_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 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 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 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 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 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
