def __init__(self, loop: Optional[asyncio.AbstractEventLoop] = None):
if loop is None:
self._loop = asyncio.get_event_loop()
else:
self._loop = loop
self._running = True
self._sched_daily_jobs = schedule.Scheduler()
self._sched_shedule = schedule.Scheduler()
self._monitors = []
def __init__(self, loop: Optional[asyncio.AbstractEventLoop] = None):
if loop is None:
self._loop = asyncio.get_event_loop()
else:
self._loop = loop
self._sched_running = True
self._force_sleeping = False # force_sleep 的使用，用于保证unique即不会重复处理
self._sched_daily_jobs = schedule.Scheduler()
self._sched_shedule = schedule.Scheduler()
self._monitors = []
self._switch_lock = asyncio.Lock()
def __init__(self):
self.bot = telegram.Bot(conf.token)
self.scheduler = schedule.Scheduler()
self.db_conn = db.Database(driver=conf.db_driver,
db_user=conf.db_user,
db_pass=conf.db_password,
db_host=conf.db_host,
db_name=conf.db_name)
self.user_jail = {}
self.can = {}
self.commands = {
'bot': {
'start': ReBot.cmd_start,
'help': ReBot.cmd_help,
'userreg': ReBot.cmd_userreg,
'userid': ReBot.cmd_user_id
}
}
# Admin CMDs (silent):
self.admin_commands = {
'del': ReBot.cmd_del,
'msg': ReBot.cmd_msg,
'msgc': ReBot.cmd_msg_chat
}
self.module_store = {}
self.module_chat_config = {}
self.modules = {}
self.handle_update = {}
self.chat_config = {}
def __init__(self):
super(ScheduledTasksManager, self).__init__(name='ScheduledTasksManager')
self.logger = None
self.abort_flag = threading.Event()
self.abort_flag.clear()
self.scheduler = schedule.Scheduler()
self.force_local_worker_timer = 0
def set_mode(mode=None):
wdog = schedule.Scheduler()
if mode is 0 or mode is None: # reset the power to the boar every hour. This keep the board on continuously
wdog.every(45).minutes.do(__toggle_1hour).tag('hourly-dog')
elif mode == 1: # reset the power to the boar every 2.5 minutes. This keep the board on continuously
wdog.clear('hourly-dog')
wdog.every(1).minutes.do(__toggle_3min.tag('3min-dog'))
print "Auto watchdog is set to 3 minutes"
return
elif mode == 3:
__go_sleep_3min()
return
elif mode == 2:
__go_sleep_1hour()
return
def __run_task(wdog=wdog):
wdog.run_all()
while True:
wdog.run_pending()
sleep(1)
# run a thread in background
st1 = threading.Thread(target=__run_task)
st1.start()
def watchdog(self, arg=1):
wdog = schedule.Scheduler()
if arg == 1:
try:
wdog.clear('three-minutes-dog')
except:
pass
wdog.every(1).hour.do(monitor.watchdog, value=1).tag('hourly-dog')
print "Auto watchdog is set to 1 hour"
elif arg == 'deactivate':
try:
wdog.clear('three-minutes-dog')
except:
pass
try:
wdog.clear('hourly-dog')
except:
pass
print "Auto watchdog is set to off"
else:
wdog.clear('hourly-dog')
wdog.every(3).minutes.do(monitor.watchdog,
value=3).tag('three-minutes-dog')
print "Auto watchdog is set to 3 minutes"
async def daily_gravitas():
gravscheduler = schedule.Scheduler()
gravscheduler.every().day.at("12:00").do(gravitas_func)
while True:
gravscheduler.run_pending()
# print(f'{date.today()}: Updating gravitas...')
await asyncio.sleep(gravscheduler.idle_seconds)
def scheduler(self):
scheduler = schedule.Scheduler()
scheduler.every().day.at('02:18').do(self.run_threaded, self.job)
scheduler.every().day.at('08:06').do(self.run_threaded, self.job)
scheduler.every().day.at('14:32').do(self.run_threaded, self.job)
scheduler.every().day.at('20:54').do(self.run_threaded, self.job)
return scheduler
def _start(self):
scheduler = schedule.Scheduler()
scheduler.every(15).minutes.do(self._run)
while True:
scheduler.run_pending()
time.sleep(1)
def test_gate_metadata_retry(custom_app):
gate = Gate(
'fixed_time_gate',
next_states=NoNextStates(),
exit_condition=ExitConditionProgram('false'),
triggers=[MetadataTrigger(metadata_path='foo.bar')],
)
app = create_app(custom_app, [gate])
def processor(*, state, **kwargs):
assert state == gate
processor.called = True
processor.called = False
scheduler = schedule.Scheduler()
configure_schedule(app, scheduler, processor)
assert len(scheduler.jobs) == 1, "Should have scheduled a single job"
job, = scheduler.jobs
assert job.next_run == datetime.datetime(2018, 1, 1, 12, 1)
assert processor.called is False
with freezegun.freeze_time(job.next_run):
job.run()
assert processor.called is True
assert job.next_run == datetime.datetime(2018, 1, 1, 12, 2)
def test_gate_at_fixed_time_with_specific_timezone(custom_app):
gate = Gate(
'fixed_time_gate',
next_states=NoNextStates(),
exit_condition=ExitConditionProgram('false'),
triggers=[TimezoneAwareTrigger(
datetime.time(12, 1),
timezone='Europe/London',
)],
)
app = create_app(custom_app, [gate])
def processor(*, state, **kwargs):
assert state == gate
processor.called = True
processor.called = False
scheduler = schedule.Scheduler()
configure_schedule(app, scheduler, processor)
assert len(scheduler.jobs) == 1, "Should have scheduled a single job"
job, = scheduler.jobs
assert job.next_run == datetime.datetime(2018, 1, 1, 12, 1)
assert processor.called is False
with freezegun.freeze_time(job.next_run):
job.run()
assert processor.called is True
assert job.next_run == datetime.datetime(2018, 1, 1, 12, 2)
def routine_volet(stop_event):
def ouverture():
logging.info("Ouverture volet")
GPIO.output(BROCHE_GPIO_OUVERTURE_VOLET, GPIO.HIGH)
time.sleep(DUREE_OUVERTURE_VOLET) # durée d'ouverture
GPIO.output(BROCHE_GPIO_OUVERTURE_VOLET, GPIO.LOW)
return
def fermeture():
logging.info("Fermeture volet")
GPIO.output(BROCHE_GPIO_FERMETURE_VOLET, GPIO.HIGH)
#time.sleep(30) # durée d'ouverture
time.sleep(DUREE_FERMETURE_VOLET) # pour les tests
GPIO.output(BROCHE_GPIO_FERMETURE_VOLET, GPIO.LOW)
return
my_sched = schedule.Scheduler()
# Ouvrir le volet tous les jours à 11h
my_sched.every().day.at(HORAIRE_OUVERTURE_ROUTINE_VOLET).do(ouverture).tag(
'routine-volet-ouverture')
# Fermer le volet tous les jours à 19h
my_sched.every().day.at(HORAIRE_FERMETURE_ROUTINE_VOLET).do(fermeture).tag(
'routine-volet-fermeture')
# tests
# my_sched.every(10).seconds.do(ouverture).tag('routine-volet-ouverture')
# my_sched.every(15).seconds.do(fermeture).tag('routine-volet-fermeture')
while True:
if not stop_event.is_set():
my_sched.run_pending()
time.sleep(0.5)
else:
my_sched.clear()
return
def run(self) -> None:
if len(self._schedules) == 0:
logger.info("No schedule defined for {}".format(self._name))
else:
logger.info("Starting schedule threads for {}...".format(
self._name))
for sched in self._schedules:
s = schedule.Scheduler()
job = s.every(sched[Save.C_SAVE_SCHEDS_EVERY])
job = job.__getattribute__(sched[Save.C_SAVE_SCHEDS_INTERVAL])
at = ""
if Save.C_SAVE_SCHEDS_AT in sched.keys():
job = job.at(sched[Save.C_SAVE_SCHEDS_AT])
at = sched[Save.C_SAVE_SCHEDS_AT]
job.do(self.save)
logger.info("setting up {} save every {} {} at {}".format(
self._name, sched[Save.C_SAVE_SCHEDS_EVERY],
sched[Save.C_SAVE_SCHEDS_INTERVAL], at))
try:
while self._run:
# Checks whether a scheduled task
# is pending to run or not
s.run_pending()
time.sleep(2)
except KeyboardInterrupt:
logger.warning("Caught KeyboardInterrupt")
logger.info("Terminating schedule thread")
def __init__(
self,
vision_project_delegator,
):
self._minutes_between_interactions = datetime.timedelta(
minutes=rospy.get_param(
"vision-project/controllers/minutes_between_interactions"))
self._scheduled_time_window_minutes = datetime.timedelta(
minutes=rospy.get_param(
"vision-project/controllers/scheduled_window_minutes"))
self._delegator = vision_project_delegator
self._state_database = state_database
self._seconds_between_updates = rospy.get_param(
"vision-project/controllers/update_window_seconds")
# action client to start interaction
start_interaction_action_name = rospy.get_param(
"controllers/is_start_interaction")
self._start_interaction_client = actionlib.SimpleActionClient(
start_interaction_action_name, StartInteractionAction)
# ROS publishers and subscribers
is_record_interaction_topic = rospy.get_param(
"controllers/is_record/interaction")
is_record_evaluation_topic = rospy.get_param(
"controllers/is_record/evaluation")
is_record_perseverance_topic = rospy.get_param(
"controllers/is_record/perseverance")
screen_tap_topic = rospy.get_param("cordial/screen_tap")
pick_topic = rospy.get_param("discord/pick")
choices_topic = rospy.get_param("discord/choices")
self._is_record_interaction_publisher = rospy.Publisher(
is_record_interaction_topic, Bool, queue_size=1)
self._is_record_evaluation_publisher = rospy.Publisher(
is_record_evaluation_topic, Bool, queue_size=1)
self._is_record_perseverance_publisher = rospy.Publisher(
is_record_perseverance_topic, Bool, queue_size=1)
self._screen_tap_listener = rospy.Subscriber(
screen_tap_topic,
MouseEvent,
callback=self._screen_tap_listener_callback,
queue_size=1)
self._pick_subscriber = rospy.Subscriber(
pick_topic,
String,
callback=self._discord_pick_callback,
queue_size=1)
self._choices_publisher = rospy.Publisher(choices_topic,
String,
queue_size=1)
# update scheduler
self._scheduler = schedule.Scheduler()
self._scheduler.every(self._seconds_between_updates).seconds.do(
self.update)
self._is_debug = rospy.get_param("vision-project/controllers/is_debug",
False)
def test_sequence(self):
# Start from a Monday
s = schedule.Scheduler(datetime.datetime(2000, 1, 3, 10, 0),
datetime.time(12), [0, 2, 4])
self.assertEqual(s.get_next(), datetime.datetime(2000, 1, 3, 12, 0))
self.assertEqual(s.get_next(), datetime.datetime(2000, 1, 5, 12, 0))
self.assertEqual(s.get_next(), datetime.datetime(2000, 1, 7, 12, 0))
self.assertEqual(s.get_next(), datetime.datetime(2000, 1, 10, 12, 0))
def __init__(self, patterns: List[str], file_watcher_filter: Callable, on_file_create: Callable,
check_file_changed_interval_seconds: int = _CHECK_FILE_CHANGED_INTERVAL_SECONDS):
super().__init__(patterns, ignore_directories=True, case_sensitive=False)
self._created_files = dict()
self._schedule = schedule.Scheduler()
self._schedule.every(check_file_changed_interval_seconds).seconds.do(self._check_created_files)
self._file_watcher_filter = file_watcher_filter
self._on_file_create = on_file_create
def __init__(self, sleep=1):
# sleep: interval in seconds in which the Scheduler checks for pending jobs
self._scheduler = schedule.Scheduler()
self.sleep = sleep
self.elapsed = 0
self.alarms = []
self.dispatcher = util.EventDispatcher("on_ringing_change")
self.ringing_alarms = 0
def do_backup(log: logging.Logger):
# Каждую неделю, в субботу, в 02:00 ночи
scheduler = schedule.Scheduler()
scheduler.every().week.saturday.at("02:00").do(db_create_backup, log)
while True:
scheduler.run_pending()
time.sleep(60)
def __init__(self):
self._lista_musicas = []
self._tempo_musica = 70
self._diretorio_usb_linux = "/media/constantino-radio/"
self._musica = '/home/constantino-radio/sino/sino_padrao.mp3'
self._horarios = []
self._sched = schedule.Scheduler()
self._horarios_sino_padrao = []
def __init__(self, *args, configuration=None):
super().__init__(*args)
self._nursery = None
self._scheduler = schedule.Scheduler()
for task in configuration["schedule"]:
self._scheduler.every().day.at(task["time"]).do(
self._spawn_command, task["command"])
def test_misconfigured_job_wont_break_scheduler(self):
"""
Ensure an interrupted job definition chain won't break
the scheduler instance permanently.
"""
scheduler = schedule.Scheduler()
scheduler.every()
scheduler.every(10).seconds
scheduler.run_pending()
def _start(self):
self.logger.debug('Запуск исполнителя KSS (Kristy Schedule Script) в потоке '
+ threading.current_thread().getName())
scheduler = schedule.Scheduler()
scheduler.every().minute.do(self._run)
while True:
scheduler.run_pending()
time.sleep(1)
def _is_it_wednesday(self):
self.logger.debug('Запуск жабы по средам в потоке ' +
threading.current_thread().getName())
scheduler = schedule.Scheduler()
scheduler.every().wednesday.at('09:00').do(self._it_is_wednesday)
while True:
scheduler.run_pending()
time.sleep(1)
def __init__(self, jid, password, room, nick):
sleekxmpp.ClientXMPP.__init__(self, jid, password)
self.room = room
self.nick = nick
self.command_prefix = "!"
self.schedule_scheduler = schedule.Scheduler()
self.add_event_handler("session_start", self.start)
self.add_event_handler("groupchat_message", self.muc_message)
self.add_event_handler("message", self.message)
def __init__(self, database_file):
self._interface = CordialInterface(
action_name="cordial/say_and_ask_on_gui",
seconds_until_timeout=None)
self._database = Database(database_file,
default_database_keys=database_keys)
self._interaction_plan = []
self._interaction_scheduler = schedule.Scheduler()
self._sleep_publisher = rospy.Publisher("cordial/sleep",
Bool,
queue_size=1)
def startScheduling(self):
myScheduler = schedule.Scheduler()
for executor in self.executors:
executor.execute()
for executor in self.executors:
myScheduler.every(executor.getInterval()).seconds.do(
executor.execute)
while True:
myScheduler.run_pending()
time.sleep(1)
def check_rendition():
global query_count
global query_iter
try:
rendition_query_scheduler = schedule.Scheduler()
rendition_query_scheduler.every(5).seconds.do(run_rendition_query)
while (query_count != 0 and query_iter <= query_iteration_limit):
rendition_query_scheduler.run_pending()
time.sleep(1)
return True
except Exception as e:
logging.error(f"Unable to run rendition query: \n {e}")
return False
def schedule_handler(self, running):
self.logger = logging.getLogger(
"UPnPServiceResponder.schedule_handler")
self.logger.info("PID: %s" % os.getpid())
register_worker_signal_handler(self.logger)
time.sleep(2)
self.do_notify(b"ssdp:alive")
sch = schedule.Scheduler()
sch.every(300).seconds.do(lambda: self.do_notify(b"ssdp:alive"))
while running.value:
sch.run_pending()
time.sleep(0.1)
self.logger.warn("Scheduler shutting down...")
def __init__(self, kwargs):
self._kwargs = kwargs
self._is_running = False
self._scheduler = schedule.Scheduler()
self._presence_detector = PresenceDetector(kwargs)
self._event_queue = TimedEventQueue()
self._event_processor = EventProcessor(self._event_queue, kwargs)
self._on_notification = None
self._presence_detection_job = None
self._next_notification_job = None
self._check_presence_every_seconds_cached = None
self._calculate_notification_every_seconds_cached = None
def __init__(self, *args, configuration):
super().__init__(*args)
self._nursery = None
if configuration["camera"] == "piCameraV2":
self.camera = picamera.PiCamera(resolution=(1640, 1232),
sensor_mode=3)
else:
raise UnknownCamera()
self._scheduler = schedule.Scheduler()
for task in configuration["schedule"]:
self._scheduler.every().day.at(task["time"]).do(
self._spawn_command, task["command"])
