def test_cron_weekday_positional(self, timezone):
trigger = CronTrigger(year=2009, month=1, day="4th wed", timezone=timezone)
assert repr(trigger) == "<CronTrigger (year='2009', month='1', day='4th wed')>"
assert str(trigger) == "cron[year='2009', month='1', day='4th wed']"
start_date = timezone.localize(datetime(2009, 1, 1))
correct_next_date = timezone.localize(datetime(2009, 1, 28))
assert trigger.get_next_fire_time(None, start_date) == correct_next_date
def test_cron_trigger_4(self, timezone):
trigger = CronTrigger(year='2012', month='2', day='last', timezone=timezone)
assert repr(trigger) == ("<CronTrigger (year='2012', month='2', day='last', "
"timezone='Europe/Berlin')>")
start_date = timezone.localize(datetime(2012, 2, 1))
correct_next_date = timezone.localize(datetime(2012, 2, 29))
assert trigger.get_next_fire_time(None, start_date) == correct_next_date
def test_cron_trigger_3(self, timezone):
trigger = CronTrigger(year='2009', month='2', hour='8-10', timezone=timezone)
assert repr(trigger) == ("<CronTrigger (year='2009', month='2', hour='8-10', "
"timezone='Europe/Berlin')>")
start_date = timezone.localize(datetime(2009, 1, 1))
correct_next_date = timezone.localize(datetime(2009, 2, 1, 8))
assert trigger.get_next_fire_time(None, start_date) == correct_next_date
def test_cron_trigger_1(self, timezone):
trigger = CronTrigger(year="2009/2", month="1/3", day="5-13", timezone=timezone)
assert repr(trigger) == "<CronTrigger (year='2009/2', month='1/3', day='5-13')>"
assert str(trigger) == "cron[year='2009/2', month='1/3', day='5-13']"
start_date = timezone.localize(datetime(2008, 12, 1))
correct_next_date = timezone.localize(datetime(2009, 1, 5))
assert trigger.get_next_fire_time(None, start_date) == correct_next_date
def test_week_1(self, timezone):
trigger = CronTrigger(year=2009, month=2, week=8, timezone=timezone)
assert repr(trigger) == "<CronTrigger (year='2009', month='2', week='8')>"
assert str(trigger) == "cron[year='2009', month='2', week='8']"
start_date = timezone.localize(datetime(2009, 1, 1))
correct_next_date = timezone.localize(datetime(2009, 2, 16))
assert trigger.get_next_fire_time(None, start_date) == correct_next_date
def test_week_2(self, timezone):
trigger = CronTrigger(year=2009, week=15, day_of_week=2, timezone=timezone)
assert repr(trigger) == "<CronTrigger (year='2009', week='15', day_of_week='2')>"
assert str(trigger) == "cron[year='2009', week='15', day_of_week='2']"
start_date = timezone.localize(datetime(2009, 1, 1))
correct_next_date = timezone.localize(datetime(2009, 4, 8))
assert trigger.get_next_fire_time(None, start_date) == correct_next_date
def test_cron_year_list(self, timezone):
trigger = CronTrigger(year='2009,2008', timezone=timezone)
assert repr(trigger) == "<CronTrigger (year='2009,2008', timezone='Europe/Berlin')>"
assert str(trigger) == "cron[year='2009,2008']"
start_date = timezone.localize(datetime(2009, 1, 1))
correct_next_date = timezone.localize(datetime(2009, 1, 1))
assert trigger.get_next_fire_time(None, start_date) == correct_next_date
def add_random_tasks(self, module_name, cls_name, function_name, start_hour, end_hour, day_of_week, num_times_per_day, ignore_scheduler_lock=False):
# This function is fired at startup, and every day at midnight.
if end_hour < start_hour:
raise Exception("start_hour is after end_hour!")
# Get the next appropriate date
now = datetime.datetime.now()
# Work around crontab bug where if the hour has started, it's skipped.
adjusted_start_hour = start_hour
if adjusted_start_hour != 23:
adjusted_start_hour += 1
adjusted_start_hour = "%s" % adjusted_start_hour
ct = CronTrigger(hour=adjusted_start_hour, day_of_week=day_of_week)
fire_time = ct.get_next_fire_time(now)
# If it's today, schedule it. Otherwise, it'll be scheduled at midnight of its run day.
if fire_time.day == now.day:
# There are more efficient ways to do this, but this supports almost any n for num_times_per_day,
# and that seems more useful.
possible_times = []
for i in range(start_hour, end_hour):
for j in range(60):
possible_times.append((i,j))
times = random.sample(possible_times, num_times_per_day)
for hour, minute in times:
when = datetime.datetime(now.year, now.month, now.day, hour, minute)
# If we're starting up mid-day, this may not be true.
if when >= now:
self.add_single_random_task(when, module_name, cls_name, function_name, start_hour, end_hour, day_of_week, num_times_per_day, ignore_scheduler_lock=ignore_scheduler_lock)
def test_previous_fire_time_1(self, timezone):
"""Test for previous_fire_time arg in get_next_fire_time()"""
trigger = CronTrigger(day="*", timezone=timezone)
previous_fire_time = timezone.localize(datetime(2015, 11, 23))
now = timezone.localize(datetime(2015, 11, 26))
correct_next_date = timezone.localize(datetime(2015, 11, 24))
assert trigger.get_next_fire_time(previous_fire_time, now) == correct_next_date
def test_cron_weekday_nomatch(self, timezone):
trigger = CronTrigger(year=2009, month=1, day="6-10", day_of_week="0,6", timezone=timezone)
assert repr(trigger) == "<CronTrigger (year='2009', month='1', day='6-10', day_of_week='0,6')>"
assert str(trigger) == "cron[year='2009', month='1', day='6-10', day_of_week='0,6']"
start_date = timezone.localize(datetime(2009, 1, 1))
correct_next_date = None
assert trigger.get_next_fire_time(None, start_date) == correct_next_date
def test_different_tz(self, timezone):
alter_tz = pytz.FixedOffset(-600)
trigger = CronTrigger(year=2009, week=15, day_of_week=2, timezone=timezone)
assert repr(trigger) == "<CronTrigger (year='2009', week='15', day_of_week='2')>"
assert str(trigger) == "cron[year='2009', week='15', day_of_week='2']"
start_date = alter_tz.localize(datetime(2008, 12, 31, 22))
correct_next_date = timezone.localize(datetime(2009, 4, 8))
assert trigger.get_next_fire_time(None, start_date) == correct_next_date
def test_cron_weekday_overlap(self, timezone):
trigger = CronTrigger(year=2009, month=1, day='6-10', day_of_week='2-4', timezone=timezone)
assert repr(trigger) == ("<CronTrigger (year='2009', month='1', day='6-10', "
"day_of_week='2-4', timezone='Europe/Berlin')>")
assert str(trigger) == "cron[year='2009', month='1', day='6-10', day_of_week='2-4']"
start_date = timezone.localize(datetime(2009, 1, 1))
correct_next_date = timezone.localize(datetime(2009, 1, 7))
assert trigger.get_next_fire_time(None, start_date) == correct_next_date
def test_cron_start_date(self, timezone):
trigger = CronTrigger(year='2009', month='2', hour='8-10', start_date='2009-02-03 11:00:00', timezone=timezone)
assert repr(trigger) == \
"<CronTrigger (year='2009', month='2', hour='8-10', start_date='2009-02-03 11:00:00 CET')>"
assert str(trigger) == "cron[year='2009', month='2', hour='8-10']"
start_date = timezone.localize(datetime(2009, 1, 1))
correct_next_date = timezone.localize(datetime(2009, 2, 4, 8))
assert trigger.get_next_fire_time(None, start_date) == correct_next_date
def test_end_date(self, timezone):
end_date = timezone.localize(datetime(2014, 4, 13, 3))
trigger = CronTrigger(year=2014, hour=4, end_date=end_date)
start_date = timezone.localize(datetime(2014, 4, 13, 2, 30))
assert trigger.get_next_fire_time(None, start_date - timedelta(1)) == \
start_date.replace(day=12, hour=4, minute=0)
assert trigger.get_next_fire_time(None, start_date) is None
def test_cron_extra_coverage(self, timezone):
# This test has no value other than patching holes in test coverage
trigger = CronTrigger(day='6,8', timezone=timezone)
assert repr(trigger) == "<CronTrigger (day='6,8', timezone='Europe/Berlin')>"
assert str(trigger) == "cron[day='6,8']"
start_date = timezone.localize(datetime(2009, 12, 31))
correct_next_date = timezone.localize(datetime(2010, 1, 6))
assert trigger.get_next_fire_time(None, start_date) == correct_next_date
def test_cron_increment_weekday(self, timezone):
"""
Tests that incrementing the weekday field in the process of calculating the next matching
date won't cause problems.
"""
trigger = CronTrigger(hour='5-6', timezone=timezone)
assert repr(trigger) == "<CronTrigger (hour='5-6', timezone='Europe/Berlin')>"
assert str(trigger) == "cron[hour='5-6']"
start_date = timezone.localize(datetime(2009, 9, 25, 7))
correct_next_date = timezone.localize(datetime(2009, 9, 26, 5))
assert trigger.get_next_fire_time(None, start_date) == correct_next_date
def test_dst_change(self, trigger_args, start_date, start_date_dst, correct_next_date):
"""
Making sure that CronTrigger works correctly when crossing the DST switch threshold.
Note that you should explicitly compare datetimes as strings to avoid the internal datetime
comparison which would test for equality in the UTC timezone.
"""
timezone = pytz.timezone('US/Eastern')
trigger = CronTrigger(timezone=timezone, **trigger_args)
start_date = timezone.localize(start_date, is_dst=start_date_dst)
correct_next_date = timezone.localize(correct_next_date, is_dst=not start_date_dst)
assert str(trigger.get_next_fire_time(None, start_date)) == str(correct_next_date)
def test_timezone_change(self, timezone):
"""
Ensure that get_next_fire_time method returns datetimes in the timezone of the trigger and
not in the timezone of the passed in start_date.
"""
est = pytz.FixedOffset(-300)
cst = pytz.FixedOffset(-360)
trigger = CronTrigger(hour=11, minute='*/5', timezone=est)
start_date = cst.localize(datetime(2009, 9, 26, 10, 16))
correct_next_date = est.localize(datetime(2009, 9, 26, 11, 20))
assert str(trigger.get_next_fire_time(None, start_date)) == str(correct_next_date)
def add_periodic_task(self, module_name, cls_name, function_name, sched_args, sched_kwargs, ignore_scheduler_lock=False):
now = datetime.datetime.now()
ct = CronTrigger(*sched_args, **sched_kwargs)
when = ct.get_next_fire_time(now)
item = {
"type": "periodic_task",
"module_name": module_name,
"class_name": cls_name,
"function_name": function_name,
"sched_args": sched_args,
"sched_kwargs": sched_kwargs,
}
self.add_to_schedule(when, item, periodic_list=True, ignore_scheduler_lock=ignore_scheduler_lock)
def test_dst_change(self):
"""
Making sure that CronTrigger works correctly when crossing the DST switch threshold.
Note that you should explicitly compare datetimes as strings to avoid the internal datetime comparison which
would test for equality in the UTC timezone.
"""
eastern = pytz.timezone("US/Eastern")
trigger = CronTrigger(minute="*/30", timezone=eastern)
datetime_edt = eastern.localize(datetime(2013, 11, 3, 1, 5), is_dst=True)
correct_next_date = eastern.localize(datetime(2013, 11, 3, 1, 30), is_dst=True)
assert str(trigger.get_next_fire_time(None, datetime_edt)) == str(correct_next_date)
datetime_edt = eastern.localize(datetime(2013, 11, 3, 1, 35), is_dst=True)
correct_next_date = eastern.localize(datetime(2013, 11, 3, 1), is_dst=False)
assert str(trigger.get_next_fire_time(None, datetime_edt)) == str(correct_next_date)
def beat_init_handler(sender=None, **kwargs):
# def get_run_times(trigger, first_run_time, end_time):
# if end_time == None:
# end_time = datetime.datetime.now(pytz.utc)
# run_times = []
# while first_run_time and first_run_time <= end_time:
# run_times.append(first_run_time)
# first_run_time = trigger.get_next_fire_time(first_run_time, first_run_time)
# return run_times
for v in CELERYBEAT_SCHEDULE.itervalues():
trigger = CronTrigger(hour=','.join(str(h) for h in v['schedule'].hour),
start_date=v['options']['eta'],
end_date=v['options'].get('expires', None),
timezone=pytz.utc)
next_fire_time = trigger.start_date
while next_fire_time and next_fire_time <= (trigger.end_date if trigger.end_date else datetime.datetime.now(pytz.utc)):
task = signature(v['task'], v.get('args', ()) + (next_fire_time,), v.get('kwargs', {}), v.get('options', {}), app)
try:
task()
except Exception as e:
logger.exception(e)
next_fire_time = trigger.get_next_fire_time(next_fire_time, next_fire_time)
def test_cron_trigger_3(self, timezone):
trigger = CronTrigger(year="2009", month="2", hour="8-10", timezone=timezone)
assert repr(trigger) == "<CronTrigger (year='2009', month='2', hour='8-10')>"
start_date = timezone.localize(datetime(2009, 1, 1))
correct_next_date = timezone.localize(datetime(2009, 2, 1, 8))
assert trigger.get_next_fire_time(None, start_date) == correct_next_date
def prepare_batch_blocking(job, args):
# sched.shutdown()
# sched.add_job(job, 'interval', seconds=int(const.FREQUENCE), args=(args,))
sched.add_job(job, CronTrigger.from_crontab(const.TRANSMIT_CRON))
sched.start()
return "Start scheduler id: " + str(sched.get_jobs())
def test_cron_trigger_2(self, timezone):
trigger = CronTrigger(year='2009/2', month='1/3', day='5-13', timezone=timezone)
start_date = timezone.localize(datetime(2009, 10, 14))
correct_next_date = timezone.localize(datetime(2011, 1, 5))
assert trigger.get_next_fire_time(None, start_date) == correct_next_date
from apscheduler.schedulers.blocking import BlockingScheduler
from apscheduler.triggers.cron import CronTrigger
import datetime
from features.round import round_func
import os
from dotenv import load_dotenv
from rq import Queue
from worker import conn
scheduler = BlockingScheduler(timezone='utc')
q = Queue(connection=conn)
load_dotenv()
CRON = os.getenv("CRON")
def triggerround():
result = q.enqueue(round_func)
print("triggering round", result)
scheduler.add_job(triggerround, CronTrigger.from_crontab(CRON))
scheduler.print_jobs()
scheduler.start()
'''
Created on
@author: admin
'''
from apscheduler.schedulers.blocking import BlockingScheduler
from apscheduler.triggers.interval import IntervalTrigger
from apscheduler.triggers.cron import CronTrigger
import datetime
def my_job():
print 'hello world' + datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
def my_job1(ss, ss1):
print ss + '/' + ss1 + '->' + datetime.datetime.now().strftime(
'%Y-%m-%d %H:%M:%S')
if __name__ == "__main__":
sched = BlockingScheduler()
trigger = IntervalTrigger(seconds=30)
crontrigger = CronTrigger(minute='*/1')
sched.add_job(my_job, trigger)
sched.add_job(my_job1, crontrigger, ['aaaa', 'bbbb'])
sched.start()
def jobs(self):
trigger = CronTrigger(hour=5)
return ((trigger, self.drop_expired_logins), )
def __post_init__(self) -> None:
# make sure the time trigger is valid
CronTrigger.from_crontab(self.cron_expression)
def test_previous_fire_time_4(self, timezone):
trigger = CronTrigger(day="*", timezone=timezone)
previous_fire_time = timezone.localize(datetime(2016, 6, 4).replace(microsecond=0))
now = timezone.localize(datetime(2016, 6, 4).replace(microsecond=0))
correct_next_date = timezone.localize(datetime(2016, 6, 5).replace(microsecond=0))
assert trigger.get_next_fire_time(previous_fire_time, now) == correct_next_date
def ProgramarTareas(self):
Siguiente = -1
columna = 2 #Siempre 2 porque es donde van los botones
self.DictTareasProgramadasFilasColumnas = {}
self.DictTareasProgramadasByID = {}
self.ListaOrdenJobs = []
for datostarea in self.TareasProg:
Siguiente = Siguiente + 1
if datostarea.nombretipo == 'Fecha':
self.trigger = DateTrigger(run_date=datostarea.day_run_date)
self.job = self.scheduler.add_job(
id=str(datostarea.id_tareaconfig),
name=datostarea.nombretarea,
func=self.EjecutarQuery,
trigger=self.trigger,
args=[datostarea.query, datostarea.params])
elif datostarea.nombretipo == 'Cronometro':
self.trigger = CronTrigger(
year=datostarea.cron_year,
month=datostarea.cron_month,
day=datostarea.cron_day,
week=datostarea.cron_week,
day_of_week=datostarea.cron_day_of_week,
hour=datostarea.cron_hour,
minute=datostarea.cron_minute,
second=datostarea.cron_second,
start_date=datostarea.start_date,
end_date=datostarea.end_date)
self.job = self.scheduler.add_job(
id=str(datostarea.id_tareaconfig),
name=datostarea.nombretarea,
func=self.EjecutarQuery,
trigger=self.trigger,
args=[datostarea.query, datostarea.params])
elif datostarea.nombretipo == 'Interval':
self.trigger = IntervalTrigger(
weeks=datostarea.interval_weeks,
days=datostarea.interval_days,
hours=datostarea.interval_hours,
minutes=datostarea.interval_minutes,
seconds=datostarea.interval_seconds,
start_date=datostarea.start_date,
end_date=datostarea.end_date)
self.job = self.scheduler.add_job(
id=str(datostarea.id_tareaconfig),
name=datostarea.nombretarea,
func=self.EjecutarQuery,
trigger=self.trigger,
args=[datostarea.query, datostarea.params])
self.ListaOrdenJobs.append(self.job)
self.DictTareasProgramadasFilasColumnas[self.job] = [
Siguiente, columna
]
self.DictTareasProgramadasByID[str(
datostarea.id_tareaconfig)] = self.job
self.scheduler.start()
self.scheduler.print_jobs()
self.PintarFechasProxEjec()
import os
import smtplib
import time
from email.mime.multipart import MIMEMultipart
from email.mime.base import MIMEBase
from email.mime.text import MIMEText
from email.utils import COMMASPACE, formatdate
from email import encoders
from apscheduler.schedulers.background import BackgroundScheduler
from apscheduler.triggers.cron import CronTrigger
from concurrent.futures import ThreadPoolExecutor
from sqlalchemy import create_engine
sched = BackgroundScheduler()
trigger = CronTrigger(hour='8', minute='0', day='*')
# server['name'], server['user'], server['passwd']
_default_server = {
'name': 'smtp.mxhichina.com',
'user': '******',
'password': '******'
}
def send_mail(server=_default_server,
to_name=list(),
subject="",
html_text="",
files=list()):
msg = MIMEMultipart()
msg['From'] = server['user'] # 邮件的发件人
def set_check_steady_job(self):
cron_trigger = CronTrigger(minute='*/5')
self.scheduler.add_job(self.check_pin_states,
cron_trigger,
id=self.STEADY_ID)
def autosave(sched):
sched.add_job(commit, CronTrigger(second=0))
def get_trigger(self) -> Union[IntervalTrigger, CronTrigger]:
"""Get the relevant apscheduler trigger for this timing event"""
return IntervalTrigger(
seconds=self.seconds
) if self.seconds else CronTrigger.from_crontab(self.cron)
def __init__(self, bot):
self.bot = bot
self.message = "playing @Doob help | {users:,} members in {guilds:,} servers. Version - {VERSION}"
bot.scheduler.add_job(self.set, CronTrigger(second=0))
auth_data['return_uri'] = 'http://localhost'
auth_data['apikey'] = '{}@AMER.OAUTHAP'.format(event['client_id'])
auth_data['client_id'] = '{}@AMER.OAUTHAP'.format(event['client_id'])
longReply = lambda_client.invoke(FunctionName='levatrade-td-principals', InvocationType='RequestResponse', Payload=json.dumps(auth_data))
result = json.loads(longReply['Payload'].read().decode())
print('levatrade_auth_td() completed successfully at', date)
# TEMP: implementation of socket handling, will soon move to seperate class
if __name__ == "__main__":
socket_connected = False
td_connecting = True
sched = BackgroundScheduler(timezone="US/Eastern")
sched.add_job(start, CronTrigger.from_crontab('0 2 * * MON', timezone="US/Eastern"), id='start')
sched.add_job(stop, CronTrigger.from_crontab('0 22 * * FRI', timezone="US/Eastern"), id='stop')
sched.add_job(create_5_min_candles, CronTrigger.from_crontab('*/5 4-22 * * MON-FRI', timezone="US/Eastern"), id='create_5_min_candles')
sched.add_job(update, CronTrigger.from_crontab('*/1 4-22 * * *', timezone="US/Eastern"), id='update')
sched.add_job(auth_td, CronTrigger.from_crontab('0 12 * * MON-FRI', timezone="US/Eastern"), id='auth_td')
sched.add_job(reauth_td, CronTrigger.from_crontab('*/5 4-20 * * MON-FRI', timezone="US/Eastern"), id='reauth_td')
sched.configure()
sched.start()
scheduler_started = True
app = web.Application()
# post
app.add_routes([web.post("/action", handle_action)])
app.add_routes([web.post("/stop", handle_stop)])
def AgregarTareaProgramada(self, idtareaconfig):
self.CargarTareasProgramadas()
self.ListarTareasProgramadas()
self.NuevaTareaProg = self.BD.Seleccionar(
"""SELECT t365_JobsTipos.Nombre AS nombretipo, t365_Jobs.nombre AS nombretarea, t365_JobsConfig.id_tareaconfig,t365_JobsConfig.id_tarea, t365_JobsConfig.id_tipo, t365_JobsConfig.day_run_date, t365_JobsConfig.interval_weeks,
t365_JobsConfig.interval_days, t365_JobsConfig.interval_hours, t365_JobsConfig.interval_seconds, t365_JobsConfig.interval_minutes, t365_JobsConfig.start_date, t365_JobsConfig.end_date,
t365_JobsConfig.cron_year, t365_JobsConfig.cron_month, t365_JobsConfig.cron_day, t365_JobsConfig.cron_week, t365_JobsConfig.cron_day_of_week, t365_JobsConfig.cron_hour, t365_JobsConfig.cron_minute,
t365_JobsConfig.cron_second, t365_Jobs.query, t365_Jobs.params FROM t365_Jobs INNER JOIN
t365_JobsConfig ON t365_Jobs.id_tarea = t365_JobsConfig.id_tarea INNER JOIN
t365_JobsTipos ON t365_JobsConfig.id_tipo = t365_JobsTipos.id_tipo Where id_tareaconfig = ?""",
str(idtareaconfig[0][0]))
if self.NuevaTareaProg[0].nombretipo == 'Fecha':
self.trigger = DateTrigger(
run_date=self.NuevaTareaProg[0].day_run_date)
self.job = self.scheduler.add_job(
id=str(self.NuevaTareaProg[0].id_tareaconfig),
name=self.NuevaTareaProg[0].nombretarea,
func=self.EjecutarQuery,
trigger=self.trigger,
args=[
self.NuevaTareaProg[0].query, self.NuevaTareaProg[0].params
])
elif self.NuevaTareaProg[0].nombretipo == 'Cronometro':
self.trigger = CronTrigger(
year=self.NuevaTareaProg[0].cron_year,
month=self.NuevaTareaProg[0].cron_month,
day=self.NuevaTareaProg[0].cron_day,
week=self.NuevaTareaProg[0].cron_week,
day_of_week=self.NuevaTareaProg[0].cron_day_of_week,
hour=self.NuevaTareaProg[0].cron_hour,
minute=self.NuevaTareaProg[0].cron_minute,
second=self.NuevaTareaProg[0].cron_second,
start_date=self.NuevaTareaProg[0].start_date,
end_date=self.NuevaTareaProg[0].end_date)
self.job = self.scheduler.add_job(
id=str(self.NuevaTareaProg[0].id_tareaconfig),
name=self.NuevaTareaProg[0].nombretarea,
func=self.EjecutarQuery,
trigger=self.trigger,
args=[
self.NuevaTareaProg[0].query, self.NuevaTareaProg[0].params
])
elif self.NuevaTareaProg[0].nombretipo == 'Interval':
self.trigger = IntervalTrigger(
weeks=self.NuevaTareaProg[0].interval_weeks,
days=self.NuevaTareaProg[0].interval_days,
hours=self.NuevaTareaProg[0].interval_hours,
minutes=self.NuevaTareaProg[0].interval_minutes,
seconds=self.NuevaTareaProg[0].interval_seconds,
start_date=self.NuevaTareaProg[0].start_date,
end_date=self.NuevaTareaProg[0].end_date)
self.job = self.scheduler.add_job(
id=str(self.NuevaTareaProg[0].id_tareaconfig),
name=self.NuevaTareaProg[0].nombretarea,
func=self.EjecutarQuery,
trigger=self.trigger,
args=[
self.NuevaTareaProg[0].query, self.NuevaTareaProg[0].params
])
self.ListaOrdenJobs.append(self.job)
posicion = self.ListaOrdenJobs.index(self.job)
self.DictTareasProgramadasFilasColumnas[self.job] = [posicion, 2]
self.DictTareasProgramadasByID[str(
self.NuevaTareaProg[0].id_tareaconfig)] = self.job
self.PintarFechasProxEjec()
def test_space_in_expr(self, timezone):
trigger = CronTrigger(day='1-2, 4-7', timezone=timezone)
assert repr(
trigger
) == "<CronTrigger (day='1-2,4-7', timezone='Europe/Berlin')>"
from apscheduler.schedulers.background import BackgroundScheduler
from apscheduler.jobstores.base import JobLookupError
from apscheduler.triggers.combining import OrTrigger
from apscheduler.triggers.cron import CronTrigger
import time
from datetime import datetime
import sys
crawlingTrigger = OrTrigger([CronTrigger(hour=9,minute=00), CronTrigger(hour=18,minute=00), CronTrigger(hour=14,minute=38)]) #오전 9시, 오후 6시에 한 번씩 크롤링
class Scheduler():
def __init__(self):
self.sched = BackgroundScheduler()
self.sched.start()
def __del__(self):
print("Bye")
self.shutdown()
def kill_scheduler(self, job_id):
try:
self.sched.remove_job(job_id)
except JobLookupError as err:
print("fail to stop scheduler : ", err)
return
def shutdown(self):
self.sched.shutdown()
#복지로 Page Crawling
def bokjiroCrawling(self):
def jobs(self):
trigger = CronTrigger(minute='*/5')
job = (trigger, self.get_anime_update)
return (job, )
def __init__(self, bot):
self.bot = bot
self.log = None
self._message = "watching +help | {users:,} users in {guilds:,} servers"
self.bot.scheduler.add_job(self.set, CronTrigger(second=0))
import controller
import flask_restful
import utils
import json
import sys
import test
from flask_restful import Api
from flask_restful import Resource
from datetime import datetime
from flask import Flask
from apscheduler.schedulers.background import BackgroundScheduler
from apscheduler.triggers.cron import CronTrigger
utils.setLogFileName()
log = logpy.logging.getLogger(__name__)
app = Flask(__name__)
api = Api(app)
controller.setup_route(api)
if __name__=="__main__":
utils.setLogFileName()
utils.migrate_db('./migrate/010200001_init.db')
sched = BackgroundScheduler()
sched.start()
sched.add_job(utils.setLogFileName, CronTrigger.from_crontab('59 23 * * *'))
app.run(host="0.0.0.0", port=const.PORT, debug=True, use_reloader=False)
# test.migrate_db_test()
# test.query_bot_work_list_test()
# test.insert_bot_work_list_test()
def insert_stocks():
scheduler = BackgroundScheduler(executors=executors,
job_defaults=job_defaults)
scheduler.add_job(retrieve_stocks, CronTrigger.from_crontab('* * * * *'))
scheduler.start()
start_main(1, date, i, 'level_data_info')
strftime = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
print(f"{strftime} LevelDataInfo.py end")
def getDates(days):
import datetime
import time
begin_date = (datetime.date.today() - datetime.timedelta(days=days)).strftime("%Y-%m-%d")
date_list = []
begin_date = datetime.datetime.strptime(begin_date, "%Y-%m-%d")
end_date = datetime.datetime.strptime(time.strftime('%Y-%m-%d', time.localtime(time.time())),
"%Y-%m-%d")
while begin_date < end_date:
date_str = begin_date.strftime("%Y-%m-%d")
date_list.append(date_str)
begin_date += datetime.timedelta(days=1)
return date_list
if __name__ == '__main__':
# dates = getDates(4)
# print(f"【().dates={dates}】")
# for item in dates:
# print(f"【().item={item}】")
# getDataByDate(item)
# job_function()
sched = BlockingScheduler()
sched.add_job(job_function, CronTrigger.from_crontab('29 9 * * *'))
sched.start()
def test_previous_fire_time_3(self, timezone):
trigger = CronTrigger(day="*", timezone=timezone)
previous_fire_time = timezone.localize(datetime(2016, 4, 25))
now = timezone.localize(datetime(2016, 4, 25))
correct_next_date = timezone.localize(datetime(2016, 4, 26))
assert trigger.get_next_fire_time(previous_fire_time, now) == correct_next_date
else:
tornado_server.start(0)
try:
print('Server is running on http://{}:{}'.format(host, port))
ioloop.IOLoop.instance().current().start()
except KeyboardInterrupt:
ioloop.IOLoop.instance().stop()
print('"Ctrl+C" received, exiting.\n')
if __name__ == "__main__":
timez = pytz.timezone('Asia/Shanghai')
scheduler = BackgroundScheduler(timezone=timez)
scheduler.add_job(OtherMongoResource().reset_top,
trigger=CronTrigger.from_crontab("0 0 1 * *"))
scheduler.add_job(sync_douban,
trigger=CronTrigger.from_crontab("1 1 1 * *"))
scheduler.add_job(entry_dump,
trigger=CronTrigger.from_crontab("2 2 * * *"))
scheduler.add_job(ResourceLatestMongoResource().refresh_latest_resource,
'interval',
hours=1)
scheduler.add_job(OtherMongoResource().import_ban_user,
'interval',
seconds=300)
scheduler.start()
options.define("p", default=8888, help="running port", type=int)
options.define("h", default='127.0.0.1', help="listen address", type=str)
options.parse_command_line()
def test_month_rollover(self, timezone):
trigger = CronTrigger(timezone=timezone, day=30)
now = timezone.localize(datetime(2016, 2, 1))
expected = timezone.localize(datetime(2016, 3, 30))
assert trigger.get_next_fire_time(None, now) == expected
def create():
"""创建新任务。"""
project_id = request.args.get('project_id', type=int)
p = Project.query.get(project_id)
form = TaskApplyForm(project_id)
if current_user not in p.editors:
current_app.logger.warning(
f'user {current_user} is forbade to create task')
abort(403)
if form.validate_on_submit():
current_app.logger.debug('post {}'.format(
url_for('.create', project_id=project_id)))
task_name = f'{p.name}_{form.name.data}'
try:
jenkins.delete_job(task_name)
current_app.logger.warning(
f'{task_name} already exist in jenkins, delete it')
except JenkinsException:
pass
try:
_create_job(task_name, form.info.data, form.command.data,
form.result_statistics.data, p.server.host)
t = Task(
name=task_name,
nickname=form.name.data,
info=form.info.data,
command=form.command.data,
result_statistics=form.result_statistics.data,
crontab=form.crontab.data,
scheduler_enable=form.scheduler_enable.data,
email_receivers=form.email_receivers.data,
email_body=form.email_body.data,
email_attachments=form.email_attachments.data,
email_notification_enable=form.email_notification_enable.data,
project=p)
db.session.add(t)
db.session.commit()
current_app.logger.info('{} created the task {}'.format(
current_user, t))
if form.scheduler_enable.data:
if form.crontab.data:
current_app.logger.debug('add trigger to <Task {}>'.format(
t.name))
import xml.etree.ElementTree as ET
config = jenkins.get_job_config(t.name)
root = ET.fromstring(config)
# 校验crontab格式
scheduler.add_job('temp_id',
lambda: None,
trigger=CronTrigger.from_crontab(
form.crontab.data))
scheduler.remove_job('temp_id')
triggers = root.find('triggers')
timer_trigger = ET.SubElement(
triggers, 'hudson.triggers.TimerTrigger')
spec = ET.SubElement(timer_trigger, 'spec')
spec.text = form.crontab.data
jenkins.reconfig_job(t.name,
ET.tostring(root).decode('utf-8'))
else:
flash('未配置crontab', 'warning')
t.scheduler_enable = False
db.session.commit()
operating_record = OperatingRecord(user=current_user,
operation='创建',
task=t)
db.session.add(operating_record)
db.session.commit()
except ValueError as e:
t.scheduler_enable = False
db.session.commit()
current_app.logger.error('crontab wrong')
current_app.logger.exception(e)
flash('crontab格式错误', 'danger')
except JenkinsException as e:
current_app.logger.error('jenkins create job error: {}'.format(e))
flash('内部错误', 'danger')
try:
t.scheduler_enable = False
db.session.commit()
except NameError:
pass
return redirect(url_for('.task_list', project_id=project_id))
current_app.logger.debug('get {}'.format(
url_for('.create', project_id=project_id)))
return render_template('task/task.html', form=form, can_edit=True)
def test_month_rollover(self, timezone):
trigger = CronTrigger(timezone=timezone, day=30)
now = timezone.localize(datetime(2016, 2, 1))
expected = timezone.localize(datetime(2016, 3, 30))
assert trigger.get_next_fire_time(None, now) == expected
def task_info(task_id):
"""编辑任务。"""
t = Task.query.get(task_id)
form = TaskEditForm(t.project.id)
p = Project.query.get(t.project.id)
if form.validate_on_submit():
if current_user not in p.editors:
current_app.logger.warning(
f'user {current_user} is forbade to edit the task {t}')
abort(403)
current_app.logger.debug('post {}'.format(
url_for('.task_info', task_id=task_id)))
try:
import xml.etree.ElementTree as ET
config = jenkins.get_job_config(t.name)
root = ET.fromstring(config)
if form.info.data != t.info:
current_app.logger.debug('info updated')
root.find('description').text = form.info.data
if form.command.data != t.command:
current_app.logger.debug('command updated')
root.find('builders').find('hudson.tasks.Shell').find(
'command').text = form.command.data.replace('\r', '')
if form.result_statistics.data != t.result_statistics:
current_app.logger.debug('result_statistics updated')
root.find('.//org.jenkinsci.plugins.postbuildscript.model.PostBuildStep//command').text = \
form.result_statistics.data.replace('\r', '')
jenkins.reconfig_job(t.name, ET.tostring(root).decode('utf-8'))
t.nickname = form.name.data
t.info = form.info.data
t.command = form.command.data
t.result_statistics = form.result_statistics.data
t.email_receivers = form.email_receivers.data
t.email_body = form.email_body.data
t.email_attachments = form.email_attachments.data
t.email_notification_enable = form.email_notification_enable.data
db.session.commit()
if form.scheduler_enable.data:
if form.crontab.data:
current_app.logger.debug(
'edit trigger of <Task {}>'.format(form.name.data))
# 校验crontab格式
scheduler.add_job('temp_id',
lambda: None,
trigger=CronTrigger.from_crontab(
form.crontab.data))
scheduler.remove_job('temp_id')
triggers = root.find('triggers')
timer_trigger = triggers.find(
'hudson.triggers.TimerTrigger')
if timer_trigger:
timer_trigger.find('spec').text = form.crontab.data
else:
timer_trigger = ET.SubElement(
triggers, 'hudson.triggers.TimerTrigger')
spec = ET.SubElement(timer_trigger, 'spec')
spec.text = form.crontab.data
jenkins.reconfig_job(t.name,
ET.tostring(root).decode('utf-8'))
# 防止jenkins出错，对定时的设置单独修改
t.crontab = form.crontab.data
t.scheduler_enable = form.scheduler_enable.data
else:
flash('未配置crontab', 'warning')
t.scheduler_enable = False
else:
triggers = root.find('triggers')
timer_trigger = triggers.find('hudson.triggers.TimerTrigger')
if timer_trigger:
triggers.remove(timer_trigger)
jenkins.reconfig_job(t.name,
ET.tostring(root).decode('utf-8'))
t.crontab = form.crontab.data
t.scheduler_enable = form.scheduler_enable.data
current_app.logger.info(f'{current_user} edited {t}')
operating_record = OperatingRecord(user=current_user,
operation='修改',
task=t)
db.session.add(operating_record)
db.session.commit()
except ValueError as e:
t.scheduler_enable = False
db.session.commit()
current_app.logger.error('crontab wrong')
current_app.logger.exception(e)
flash('crontab格式错误', 'danger')
except JenkinsException as e:
current_app.logger.error('jenkins edit job error')
current_app.logger.exception(e)
flash('内部错误', 'danger')
return redirect(url_for('.task_list', project_id=t.project.id))
current_app.logger.debug('get {}'.format(
url_for('.task_info', project_id=t.project.id, task_id=task_id)))
form.name.data = t.nickname
form.info.data = t.info
form.command.data = t.command
form.result_statistics.data = t.result_statistics
form.crontab.data = t.crontab
form.scheduler_enable.data = t.scheduler_enable
form.email_receivers.data = t.email_receivers
form.email_body.data = t.email_body
form.email_attachments.data = t.email_attachments
form.email_notification_enable.data = t.email_notification_enable
if current_user in p.editors:
return render_template('task/task.html', form=form, can_edit=True)
else:
return render_template('task/task.html', form=form, can_edit=False)
def test_from_crontab(self, expr, expected_repr, timezone):
trigger = CronTrigger.from_crontab(expr, timezone)
assert repr(trigger) == expected_repr
def gracefully_exit(signum, frame):
logger.info('Stopping scheduler...')
scheduler.shutdown()
logger.info('Scheduler shutdown.')
logger.info('Adding shutdown signal handlers...')
signal.signal(signal.SIGINT, gracefully_exit)
signal.signal(signal.SIGTERM, gracefully_exit)
if CRON_EXPRESSION:
logger.info(
f'Adding job to run on the following cron schedule: {CRON_EXPRESSION}'
)
scheduler.add_job(
func=lambda: job(server_id=SERVER_ID),
trigger=CronTrigger.from_crontab(CRON_EXPRESSION),
)
elif SCHEDULE_INTERVAL:
logger.info(f'Adding job to run every {SCHEDULE_INTERVAL} minutes...')
scheduler.add_job(
func=lambda: job(server_id=SERVER_ID),
trigger='interval',
minutes=SCHEDULE_INTERVAL,
next_run_time=datetime.now() + timedelta(seconds=1),
)
else:
logger.critical('No schedule information set.')
logger.critical(
'Set either `CRON_EXPRESSION` or `SCHEDULE_INTERVAL` and restart the application.'
)
exit(1)
def get_schedule(self) -> CronTrigger:
return CronTrigger(hour=9)
printMsg('========定时任务结束========')
print("************************************************")
def my_listener(event):
if event.exception:
print('任务出错了！！！！！！')
else:
print('任务照常运行...')
if __name__ == '__main__':
scheduler = BlockingScheduler()
cronStr = "*/" + schedulerInterval
if schedulerCrontype == "second":
trigger = CronTrigger(second=cronStr)
elif schedulerCrontype == "minute":
trigger = CronTrigger(minute=cronStr)
# trigger = CronTrigger(second='*/3')
# trigger = CronTrigger(minute='*/1')
scheduler.add_job(getWeather, trigger)
# scheduler.add_job(getRain2H, 'cron', minute='*/5', hour='*')
scheduler.add_listener(my_listener, EVENT_JOB_EXECUTED | EVENT_JOB_ERROR)
scheduler._logger = logging # 行启用 scheduler 模块的日记记录
scheduler.daemon = True
try:
scheduler.start()
except Exception as e:
print("scheduler启动异常=" + e)
def test_cron_zero_value(self, timezone):
trigger = CronTrigger(year=2009, month=2, hour=0, timezone=timezone)
assert repr(trigger) == (
"<CronTrigger (year='2009', month='2', hour='0', "
"timezone='Europe/Berlin')>")
from apscheduler.schedulers.blocking import BlockingScheduler
from apscheduler.triggers.combining import OrTrigger
from apscheduler.triggers.cron import CronTrigger
import urllib.request
sched = BlockingScheduler()
# @sched.scheduled_job('cron', day_of_week='mon-fri', minute='*/1')
def scheduled_job():
url = "https://linebothook.herokuapp.com/"
conn = urllib.request.urlopen(url)
for key, value in conn.getheaders():
print(key, value)
trigger = OrTrigger([CronTrigger(hour='10-20', minute='*/20')])
sched.add_job(scheduled_job, trigger)
sched.start()
def test_cron_trigger_4(self, timezone):
trigger = CronTrigger(year="2012", month="2", day="last", timezone=timezone)
assert repr(trigger) == "<CronTrigger (year='2012', month='2', day='last')>"
start_date = timezone.localize(datetime(2012, 2, 1))
correct_next_date = timezone.localize(datetime(2012, 2, 29))
assert trigger.get_next_fire_time(None, start_date) == correct_next_date
