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"])