def backtest(self,
start=datetime.datetime(2021, 3, 1),
end=datetime.datetime.now(),
log_schedule=[{
"minute": "30",
"hour": "9",
"day_of_week": "mon-fri"
}]):
self.init_broker(backtest=True, data=self.data)
log_trigger = build_trigger(log_schedule)
algo_trigger = OrTrigger([algo.trigger for algo in self.algos])
trigger = OrTrigger([algo_trigger, log_trigger])
logging = isinstance(log_schedule, dict) or len(log_schedule) > 0
if isinstance(start, int) and not isinstance(end, int):
start = trading_day_offset(end, -start)
if not isinstance(start, int) and isinstance(end, int):
end = trading_day_offset(start, end)
self.datetime = start
while self.datetime < end:
for algo in self.algos:
if equals_runtime(algo.trigger, self.datetime):
print(self.datetime)
time = Manager.timezone.localize(self.datetime)
self.broker.check_limit_orders(time=time)
algo.run_wrapper(time=time, update=False)
if logging and equals_runtime(log_trigger, self.datetime):
self.log_state()
self.datetime = next_runtime(trigger, self.datetime)
metrics = self.logger.metrics()
for metric, value in metrics.items():
print("{metric}: {value:.3f}".format(metric=metric, value=value))
self.logger.report()
return metrics
def __init__(self, name, enabled, args = argsTemplate, triggers = [], id = None, priority = -1):
self.priority = priority
self.name = name
self.args = args
self.triggers = triggers
self.trigger = OrTrigger(self.triggers)
self.enabled = enabled if self.triggers else False
self.id = id
def test_two_datetriggers(self, timezone, serializer):
date1 = datetime(2020, 5, 16, 14, 17, 30, 254212, tzinfo=timezone)
date2 = datetime(2020, 5, 18, 15, 1, 53, 940564, tzinfo=timezone)
trigger = OrTrigger([DateTrigger(date1), DateTrigger(date2)])
if serializer:
trigger = serializer.deserialize(serializer.serialize(trigger))
assert trigger.next() == date1
assert trigger.next() == date2
assert trigger.next() is None
def attAerador(self, agenda):
# atualiza o estado atual para nova configuração
# se agenda está vazia: deslige
if agenda:
now = dt.datetime.now()
last_on = []
last_off = []
for evento in agenda:
inicio = dt.datetime.combine(date=dt.date.today(),
time=evento[0])
if inicio > now:
inicio -= dt.timedelta(days=1)
last_on.append(inicio)
fim = dt.datetime.combine(date=dt.date.today(), time=evento[1])
if fim > now:
fim -= dt.timedelta(days=1)
last_off.append(fim)
last_on = max(last_on)
last_off = max(last_off)
if last_on > last_off:
ligar_aerador()
else:
desligar_aerador()
else:
desligar_aerador()
# exclui alarmes antigos
jobs = scheduler.get_jobs()
for job in jobs:
if job.id == 'ligar_aerador' or job.id == 'desligar_aerador':
job.remove()
# cria alarmes para o acionamento dos aeradores.
# coloquei o replace() para garantir que a açao de ligar será
# executada depois de desligar, assim se houver eventos de desligar e
# ligar no mesmo horário 'ligar' será o último a ser executador
lista_alarmes = [
self.geraCronTrigger(evento[0].replace(second=1))
for evento in agenda
]
trigger = OrTrigger(lista_alarmes)
scheduler.add_job(ligar_aerador, trigger, id='ligar_aerador')
# cria alarmes para o desligamento
lista_alarmes = [self.geraCronTrigger(evento[1]) for evento in agenda]
trigger = OrTrigger(lista_alarmes)
scheduler.add_job(desligar_aerador, trigger, id='desligar_aerador')
def test_repr(self, timezone):
date1 = timezone.localize(datetime(2020, 5, 16, 14, 17, 30, 254212))
date2 = timezone.localize(datetime(2020, 5, 18, 15, 1, 53, 940564))
trigger = OrTrigger([DateTrigger(date1), DateTrigger(date2)])
assert repr(trigger) == (
"OrTrigger([DateTrigger('2020-05-16T14:17:30.254212+02:00'), "
"DateTrigger('2020-05-18T15:01:53.940564+02:00')])")
def configure(self, scheduler, func=joinMeeting, jobstore = 'default', **changes):
if self.id:
changes = {change: changes[change] for change in changes if changes[change] is not None}
if 'triggers' in changes:
if changes['triggers'] == []:
self.disable(scheduler)
changes['trigger'] = OrTrigger(changes['triggers'])
self.triggers = changes['triggers']
self.trigger = changes['trigger']
changes.pop('triggers')
if 'enabled' in changes:
self.enable(scheduler) if changes['enabled'] else self.disable(scheduler)
changes.pop('enabled')
if 'link' in changes:
self.args = Task.args_from_browser(changes['link'])
changes['args'] = [self]
changes.pop('link')
if 'priority' in changes:
self.priority = changes['priority']
changes['args'] = [self]
changes.pop('priority')
job = scheduler.modify_job(self.id, jobstore, **changes)
self.__dict__.update(Task.task_from_job(job).__dict__)
else:
job = scheduler.add_job(func, trigger=self.trigger, args=[self], next_run_time = None, name=self.name, jobstore='default', executor='default')
if self.enabled:
scheduler.resume_job(job.id, jobstore)
self.__dict__.update(Task.task_from_job(job).__dict__)
def test_repr(self, timezone):
date1 = datetime(2020, 5, 16, 14, 17, 30, 254212, tzinfo=timezone)
date2 = datetime(2020, 5, 18, 15, 1, 53, 940564, tzinfo=timezone)
trigger = OrTrigger([DateTrigger(date1), DateTrigger(date2)])
assert repr(trigger) == (
"OrTrigger([DateTrigger('2020-05-16 14:17:30.254212+02:00'), "
"DateTrigger('2020-05-18 15:01:53.940564+02:00')])")
def start():
scheduler = BackgroundScheduler()
trigger = OrTrigger([
CronTrigger(hour='23', minute='59-60'),
])
# scheduler.add_job(notificationsJob, 'interval', minutes=30)
scheduler.add_job(notificationsJob, trigger)
scheduler.start()
def parse_triggers(data: Union[Dict, None]):
if data is None or not data.get("triggers", False): # No triggers
return None
if len(data["triggers"]) > 1: # Multiple triggers
return OrTrigger([get_trigger(t_data) for t_data in data["triggers"]])
else:
return get_trigger(data["triggers"][0])
def test_two_interval_triggers(self, timezone, serializer):
start_time = datetime(2020, 5, 16, 14, 17, 30, 254212, tzinfo=timezone)
end_time1 = start_time + timedelta(seconds=16)
end_time2 = start_time + timedelta(seconds=18)
trigger = OrTrigger([
IntervalTrigger(seconds=4,
start_time=start_time,
end_time=end_time1),
IntervalTrigger(seconds=6,
start_time=start_time,
end_time=end_time2)
])
if serializer:
trigger = serializer.deserialize(serializer.serialize(trigger))
assert trigger.next() == start_time
assert trigger.next() == start_time + timedelta(seconds=4)
assert trigger.next() == start_time + timedelta(seconds=6)
assert trigger.next() == start_time + timedelta(seconds=8)
assert trigger.next() == start_time + timedelta(seconds=12)
assert trigger.next() == start_time + timedelta(seconds=16)
# The end time of the 4 second interval has been reached
assert trigger.next() == start_time + timedelta(seconds=18)
# The end time of the 6 second interval has been reached
assert trigger.next() is None
def exposed_run_job(self, job_id, jobstore='default'):
job = scheduler.get_job(job_id)
trigger = job.trigger
job.modify(trigger = OrTrigger([Trigger(day_of_week=6, hour=0, minute=0)]))
job.modify(next_run_time = datetime.now())
if not trigger.triggers:
scheduler.pause_job(job_id, jobstore)
job.modify(trigger = trigger)
return scheduler.get_job(job_id)
def trigger(self, timezone):
return OrTrigger([
CronTrigger(month='5-8',
day='6-15',
end_date=timezone.localize(datetime(2017, 8, 10))),
CronTrigger(month='6-9',
day='*/3',
end_date=timezone.localize(datetime(2017, 9, 7)))
])
def create_alarm_range_time_week_am(cls, ext=None, template=None, values=None, history=[]):
try:
if cls.get_activation() == False:
return
#hora, minuto, rango ini, rango fin
values_x = values[0]
if isinstance(values_x, list):
duration_h = values_x[0]
duration_m = values_x[1]
range_week_start = values_x[2]
range_week_end = values_x[3]
else:
duration_h = values_x
duration_m = values[1]
range_week_start = values[2]
range_week_end = values[3]
duration_h = cls._replace_words_with_numbers(duration_h)
duration_m = cls._replace_words_with_numbers(duration_m)
for time_interval in time_intervals.values():
for variation in time_interval['variations']:
if variation in range_week_start:
range_week_start = time_interval['scheduler_interval']
break
for time_interval in time_intervals.values():
for variation in time_interval['variations']:
if variation in range_week_end:
range_week_end = time_interval['scheduler_interval']
break
if duration_h is not None and duration_m is not None:
idx = get_id()
m2 = str(duration_h) + ":" + str(duration_m) + " AM"
m2 = cls._time_conversion(m2)
m2 = m2.split(":")
duration_h = m2[0].strip()
duration_m = m2[1].strip()
day_of_week = range_week_start + "-" + range_week_end
cron1 = CronTrigger(day_of_week=day_of_week, hour=duration_h, minute=duration_m, timezone='America/Bogota')
trigger = OrTrigger([cron1])
job = cls.scheduler.add_job(cls._alarm_range_am, trigger, id=idx, args=[idx])
cls.alarm_pending.append({"id": idx, "job": job, "day_of_week": day_of_week, "hour": duration_h, "minute": duration_m})
if not cls.scheduler.running:
cls.scheduler.start()
r = template.format("He creado la alarma {0} {1} {2} am".format(day_of_week, duration_h, duration_m))
cls.response(r)
except Exception as e:
print(e)
r = template.format("No se pudo crear la alarma")
cls.response(r)
def build_trigger(schedule):
if isinstance(schedule, list) and len(schedule) != 1:
trigger = OrTrigger([CronTrigger(**cron) for cron in schedule])
elif isinstance(schedule, list) and len(schedule) == 1:
cron = schedule[0]
trigger = CronTrigger(**cron)
else:
cron = schedule
trigger = CronTrigger(**cron)
return trigger
def create_reminder_time_action_am(cls,
ext=None,
template=None,
values=None,
history=[]):
try:
if cls.get_activation() == False:
return
values_x = values[0]
duration_h = values_x[0]
duration_m = values_x[1]
action = values_x[2]
duration_h = int(cls._replace_words_with_numbers(duration_h))
duration_m = int(cls._replace_words_with_numbers(duration_m))
if duration_h and duration_m:
m2 = str(duration_h) + ":" + str(duration_m) + " AM"
m2 = cls._time_conversion(m2)
m2 = m2.split(":")
m2_h = m2[0].strip()
m2_m = m2[1].strip()
cron1 = CronTrigger(hour=m2_h,
minute=m2_m,
timezone='America/Bogota')
trigger = OrTrigger([cron1])
idx = "redimer_" + m2_h + "_" + m2_m
args = [idx, action, m2_h, m2_m]
job = cls.scheduler.add_job(cls.reminder_am,
trigger,
id=idx,
args=args)
cls.alarm_pending.append({
"id": idx,
"job": job,
"action": action
})
if not cls.scheduler.running:
cls.scheduler.start()
r = template.format(
"He creado un recordatorio en {}:{} am".format(
duration_h, duration_m))
cls.response(r)
except Exception as e:
print(e)
r = template.format("No se pudo crear el recordatorio")
cls.response(r)
def __init__(self, debug=False):
TORNADO_SETTINGS['debug'] = debug
if debug:
LOGGING_CONSOLE_CONFIG['level'] = logging.DEBUG
dictConfig(LOGGING_CONFIG)
tornado.web.Application.__init__(self, [
(r"/", common.HomeHandler),
(r"/api/xml/(?P<db_id>[\d\_]+)?/*", xml_list.XmlGridHandler),
(r"/api/xml/ie/(?P<db_id>[\d\_]+)?", xml_list.XmlImpExpHandler),
(r"/api/xml/validate/(?P<xml_id>[\d\_]+)?/",
xml_bldr.XmlValidationHandler),
(r"/api/xml/tree/(?P<xml_id>[\d\_]+)/(?P<node_id>[\d\_]+)?",
xml_bldr.XmlNodeHandler),
(r"/api/xml/attr/(?P<db_id>[\d\_]+)?",
xml_bldr.XmlNodeAttrHandler),
(r"/api/xml/attr/available/(?P<node_id>[\d\_]+)/?",
xml_bldr.XmlNodeAvailableAttrHandler),
(r"/api/xml/attr/validate/", xml_bldr.XmlNodeAttrValidateHandler),
(r"/api/xml/epoch/(?P<xml_id>[\d\_]+)/*",
xml_bldr.XmlEpochHandler),
(r"/api/xml/template/(?P<node_id>[\d\_]+)?/*",
xml_tpl.XmlTemplateHandler),
(r"/api/nrl/sensors/(?P<key>[^/]+)?",
xml_nrl.XmlNrlSensorsHandler),
(r"/api/nrl/sensor/response/", xml_nrl.XmlNrlSensorRespHandler),
(r"/api/nrl/dataloggers/(?P<key>[^/]+)?",
xml_nrl.XmlDataloggersHandler),
(r"/api/nrl/datalogger/response/",
xml_nrl.XmlDataloggerRespHandler),
(r"/api/nrl/channel/response/preview/",
xml_nrl.XmlChannelRespHandler),
(r"/api/wizard/channel/(?P<station_node_id>[\d\_]+)?/*",
wizard.CreateChannelHandler),
(r"/api/wizard/guess/code/", wizard.CreateGuessCodeHandler),
(r"/api/help/(?P<key>[\w\_]+)?/*", common.HelpHandler, None,
'HelpHandler'),
(r"/api/cfg/(?P<db_id>[\d\_]+)?/*", config.ConfigHandler),
(r"/api/attr/(?P<node_id>[\d\_]+)?/*", config.AttributeHandler),
],
default_handler_class=ErrorHandler,
**TORNADO_SETTINGS)
self.scheduler = TornadoScheduler()
self.scheduler.start()
# start sync nrl job
trigger = OrTrigger([
DateTrigger(run_date=datetime.now() + timedelta(seconds=10)),
CronTrigger(**NRL_CRON)
])
self.nrl_sync_job = self.scheduler.add_job(self.sync_nrl, trigger)
ProcessMixin.__init__(self)
def main():
if request.method == 'POST':
company_name = request.form['cname']
frequency = request.form['freq']
start_time = request.form['stime']
end_time = request.form['etime']
company_url = search_url(company_name)
if company_url:
c_url = requests.get(company_url)
soup = BS(c_url.text, "html.parser")
# Returns bse and nse contents if present
b, n = scrape(soup)
# Adding info to Database
bse_db = mongo.db.bse
nse_db = mongo.db.nse
if b:
bse_entry = bse_db.insert({'BSE Date': b['bse_date'], 'BSE Time': b['bse_time'], \
'BSE Current Price': b['bse_current_price'], 'BSE absolute price': b['bse_abs_price'],\
'BSE percentage': b['bse_per'], 'BSE Volume': b['bse_volume'], \
'BSE Prev close': b['bse_prev_close'], 'BSE Open price': b['bse_open_price'],\
'BSE bid price': b['bse_bid_price'], 'BSE offer price': b['bse_offer_price']})
if n:
nse_entry = nse_db.insert({'NSE Date': n['nse_date'], 'NSE Time':n['nse_time'], \
'NSE Current Price': n['nse_current_price'], 'NSE absolute price': n['nse_abs_price'], \
'NSE percentage': n['nse_per'], 'NSE Volume': n['nse_volume'], \
'NSE Prev close': n['nse_prev_close'], 'NSE Open price': n['nse_open_price'], \
'NSE bid price': n['nse_bid_price'], 'NSE offer price': n['nse_offer_price']})
# Job scheduling
if frequency and start_time and end_time:
# Check to ensure start time is before end time
if start_time < end_time:
trigger = OrTrigger([
CronTrigger(hour=start_time + '-' + end_time,
minute=frequency)
])
scheduler.add_job(main, trigger)
else:
error = "End time should be after start time"
return render_template('index.html', error=error)
if bse_db or nse_db:
return redirect(url_for('info'))
else:
error = "Sorry! Company not found."
return render_template('index.html', error=error)
return render_template('index.html')
def start_e_Ticketing(self):
try:
print("예약 시작")
trigger = OrTrigger([
c.CronTrigger(hour=self.re_hh_txt.text(),
minute=self.re_mm_txt.text())
# i.IntervalTrigger(seconds=0.5)
])
self.sched.add_job(self.start_Ticketing2, trigger)
self.sched.start()
except Exception as e:
print('예외 맨', e)
def exposed_run_job(self, job_id, jobstore='default'):
job = scheduler.get_job(job_id)
trigger = job.trigger
job.modify(trigger=OrTrigger([NeverTrigger()]))
# tree_print(job.trigger.triggers, 1)
job.modify(next_run_time=datetime.now())
# tree_print(job.trigger.triggers, 1)
if not trigger.triggers:
scheduler.pause_job(job_id, jobstore)
# tree_print(job.trigger, 1)
job.modify(trigger=trigger)
# tree_print(job.trigger, 1)
return scheduler.get_job(job_id)
def parse_triggers(data: Union[Dict, None]):
if data is None or not data.get("triggers", False): # No triggers
return None
if len(data["triggers"]) > 1: # Multiple triggers
triggers_list = [get_trigger(t_data) for t_data in data["triggers"]]
triggers_list = [
t for t in triggers_list if not check_expired_trigger(t)
]
if not triggers_list:
return None
return OrTrigger(triggers_list)
else:
trigger = get_trigger(data["triggers"][0])
if check_expired_trigger(trigger):
return None
return trigger
def start():
scheduler = BackgroundScheduler()
scheduler.add_jobstore(DjangoJobStore(), "default")
##run every 80 minutes from 8am EST to 6pm EST (1pm-11pm UTC)
#trigger = OrTrigger([
# CronTrigger(hour='13-23', minute='*/80' timezone='UTC')
#])
trigger = OrTrigger([CronTrigger(minute='*/1', timezone='UTC')])
scheduler.add_job(tweetNextEvent,
trigger=trigger,
name='tweetNextEvent',
jobstore='default',
max_instances=1,
replace_existing=True)
register_events(scheduler)
scheduler.start()
print("Scheduler started...", file=sys.stdout, flush=True)
def add_job(func,
*,
weeks=0,
days=0,
hours=0,
minutes=0,
seconds=0,
now=True,
**kwargs):
job = scheduler.add_job(
func,
**kwargs,
trigger=OrTrigger([
*([DateTrigger(run_date=datetime.now())] if now else []),
IntervalTrigger(
weeks=weeks,
days=days,
hours=hours,
minutes=minutes,
seconds=seconds,
),
]),
)
def schedule_stock_alerts():
global redis_store
try:
scheduler = BackgroundScheduler(timezone=utc)
_refresh_user_triggered_stock_alert_tracker(redis_store)
cron1 = CronTrigger(day_of_week='mon-fri',
hour='13',
minute='30,35,40,45,50,55',
timezone=utc)
cron2 = CronTrigger(day_of_week='mon-fri',
hour='14-20',
minute='*/5',
timezone=utc)
trigger = OrTrigger([cron1, cron2])
scheduler.add_job(send_stock_alerts, trigger)
scheduler.add_job(
lambda: _refresh_user_triggered_stock_alert_tracker(redis_store),
'cron',
day_of_week='mon-fri',
hour='13',
minute=30)
scheduler.start()
except Exception as e:
print('Error while scheduling alerts', e, file=sys.stderr)
c_sec = int(datetime.now().strftime("%S"))
print('%02d:%02d:%02d - Variable: %d ' %
(c_hour, c_min, c_sec, variable.value))
time.sleep(2)
if __name__ == "__main__":
m = multiprocessing.Manager()
variable = m.Value('i', 60)
schedfortest = BlockingScheduler()
trigger_test = OrTrigger([CronTrigger(minute='*/1')])
schedfortest.add_job(callbacktotal,
trigger_test,
minute='*/2',
max_instances=10)
schedfortest.start()
scheduler = AsyncIOScheduler()
scheduler.add_job(day_limits,
'cron',
hour=7,
misfire_grace_time=3600,
timezone='GB')
scheduler.add_job(night_limits,
def run_monthly(
self,
callback: Callable[['CallbackContext'], None],
when: datetime.time,
day: int,
context: object = None,
name: str = None,
day_is_strict: bool = True,
job_kwargs: JSONDict = None,
) -> 'Job':
"""Creates a new ``Job`` that runs on a monthly basis and adds it to the queue.
Args:
callback (:obj:`callable`): The callback function that should be executed by the new
job. Callback signature for context based API:
``def callback(CallbackContext)``
``context.job`` is the :class:`telegram.ext.Job` instance. It can be used to access
its ``job.context`` or change it to a repeating job.
when (:obj:`datetime.time`): Time of day at which the job should run. If the timezone
(``when.tzinfo``) is :obj:`None`, the default timezone of the bot will be used.
day (:obj:`int`): Defines the day of the month whereby the job would run. It should
be within the range of 1 and 31, inclusive.
context (:obj:`object`, optional): Additional data needed for the callback function.
Can be accessed through ``job.context`` in the callback. Defaults to :obj:`None`.
name (:obj:`str`, optional): The name of the new job. Defaults to
``callback.__name__``.
day_is_strict (:obj:`bool`, optional): If :obj:`False` and day > month.days, will pick
the last day in the month. Defaults to :obj:`True`.
job_kwargs (:obj:`dict`, optional): Arbitrary keyword arguments to pass to the
``scheduler.add_job()``.
Returns:
:class:`telegram.ext.Job`: The new ``Job`` instance that has been added to the job
queue.
"""
if not job_kwargs:
job_kwargs = {}
name = name or callback.__name__
job = Job(callback, context, name, self)
if day_is_strict:
j = self.scheduler.add_job(
callback,
trigger='cron',
args=self._build_args(job),
name=name,
day=day,
hour=when.hour,
minute=when.minute,
second=when.second,
timezone=when.tzinfo or self.scheduler.timezone,
**job_kwargs,
)
else:
trigger = OrTrigger(
[
CronTrigger(
day=day,
hour=when.hour,
minute=when.minute,
second=when.second,
timezone=when.tzinfo,
**job_kwargs,
),
CronTrigger(
day='last',
hour=when.hour,
minute=when.minute,
second=when.second,
timezone=when.tzinfo or self.scheduler.timezone,
**job_kwargs,
),
]
)
j = self.scheduler.add_job(
callback, trigger=trigger, args=self._build_args(job), name=name, **job_kwargs
)
job.job = j
return job
from apscheduler.schedulers.background import BackgroundScheduler
from apscheduler.triggers.combining import OrTrigger
from apscheduler.triggers.cron import CronTrigger
from django_apscheduler.jobstores import DjangoJobStore
from django_apscheduler.jobstores import register_events
from django_apscheduler.jobstores import register_job
from django.core.management import call_command
scheduler = BackgroundScheduler()
scheduler.add_jobstore(DjangoJobStore(), "default")
every_3_hours_trigger = OrTrigger([
CronTrigger(hour=hour)
for hour in range(0, 24, 3)
])
@register_job(scheduler, every_3_hours_trigger, replace_existing=True)
def update_games():
print('Starting: update_games')
call_command('update_games')
print('Done: update_games')
def start_scheduler():
if scheduler.state == 0:
register_events(scheduler)
scheduler.start()
print('Started scheduler.')
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='*/25')
])
sched.add_job(scheduled_job, trigger)
sched.start()
with open(h_l_pot_info_url, 'rb') as f:
h_l_pot_info = pickle.load(f)
if len(h_l_pot_info) != len(stk_list):
updatePotInfo()
except:
updatePotInfo()
else:
updatePotInfo()
sched = BlockingScheduler()
trigger = OrTrigger([
CronTrigger(hour='9', minute='31-59/5'),
CronTrigger(hour='10', minute='*/5'),
CronTrigger(hour='11', minute='1-29/5'),
CronTrigger(hour='13-15', minute='*/5')
])
sched.add_job(judgeAndSendMsg,
trigger,
day_of_week='mon-fri',
minute='*/5',
max_instances=10)
sched.add_job(func=updatePotInfo, trigger='cron', day_of_week='mon-fri', hour=5, minute=30, misfire_grace_time=3600, coalesce=True)
# sched.add_job(updatePotInfo,
# 'cron',
# max_instances=10,
# second='*/35', misfire_grace_time=3600, coalesce=True)
# encoding=utf-8
import pickle
from apscheduler.schedulers.blocking import BlockingScheduler
from apscheduler.triggers.combining import OrTrigger
from apscheduler.triggers.cron import CronTrigger
from CornerDetectAndAutoEmail.AveMaxMinDetect.Global import h_l_pot_info_url
from CornerDetectAndAutoEmail.AveMaxMinDetect.MaxMin import judgeAndSendMsg, updatePotInfo
from SDK.MyTimeOPT import get_current_datetime_str
def time_now():
print(str(get_current_datetime_str()))
trigger = OrTrigger([CronTrigger(hour='11', minute='1-59/3')])
sched = BlockingScheduler()
sched.add_job(time_now, trigger, day_of_week='mon-fri', max_instances=10)
sched.start()
'password': '******',
'charset': 'utf8'
}
db_name = 'stk_opt_info'
table_history = 'history'
table_now = 'now'
""" =========================== 定时器相关 ============================ """
sched = BlockingScheduler()
# schedfortest = BlockingScheduler()
trigger = OrTrigger([
CronTrigger(hour='9', minute='31-59/3'),
CronTrigger(hour='10', minute='*/3'),
CronTrigger(hour='11', minute='1-29/3'),
CronTrigger(hour='13-14', minute='*/3')
])
trigger_RT = OrTrigger([
CronTrigger(hour='9', minute='31-59', second='*/30'),
CronTrigger(hour='10', minute='*', second='*/30'),
CronTrigger(hour='11', minute='1-29', second='*/30'),
CronTrigger(hour='13-14', minute='*', second='*/30')
])
# trigger2public = OrTrigger([
# CronTrigger(hour='9', minute='31-59/15'),
# CronTrigger(hour='10', minute='*/15'),
# CronTrigger(hour='11', minute='1-29/15'),
# CronTrigger(hour='13-14', minute='*/15')
