def runJobs(): schedule.run_pending() if schedule.next_run() is None: return 60*60 delta = schedule.next_run() - datetime.now() secondsUntilNextRun = min(delta.total_seconds(), 60*60) #poll every hour return secondsUntilNextRun
def run_schedule(): while True: sleep_time = schedule.next_run() - datetime.now() print("Next job to run at {}, which is {} from now".format(str(schedule.next_run()), str(sleep_time))) # Sleep an extra second to make up for microseconds time.sleep(max(1, sleep_time.seconds + 1)) schedule.run_pending()
def run_schedule(): while True: sleep_time = schedule.next_run() - datetime.now() print('Next job to run at {}, which is {} from now' .format(str(schedule.next_run()), str(sleep_time))) # Sleep an extra second to make up for microseconds time.sleep(max(1, sleep_time.seconds + 1)) schedule.run_pending()
def test_idle_seconds(self): assert schedule.next_run() is None mock_job = make_mock_job() with mock_datetime(2020, 12, 9, 21, 46): job = every().hour.do(mock_job) assert schedule.idle_seconds() == 60 * 60 schedule.cancel_job(job) assert schedule.next_run() is None
def run(self): job = schedule.every(self.every).__getattribute__(self.timeunit) if self.at: job = job.at(self.at) job.do(self.scrape_once) while True: logger.debug('next run at ' + str(schedule.next_run())) schedule.run_pending() sleep_time = (schedule.next_run() - datetime.now()).total_seconds() logger.debug('sleeping for {} seconds'.format(sleep_time)) time.sleep(sleep_time)
def shell(): try: forecast = get_forecast() next_buses = [] for bus in user.which_bus: next_buses.append(get_bus_list(bus[0], bus[2])) bus_string, forecast_string = text_string(next_buses, user.which_bus, forecast) text_next_buses(bus_string, forecast_string, user.phone_numbers) print("\nThe next text will be sent at {} on {}".format(schedule.next_run().strftime("%H:%M:%S"), schedule.next_run().strftime("%d-%m-%Y"))) except KeyboardInterrupt: sys.exit("Keyboard Interrupt. Exiting...")
def test_next_run_with_tag(self): with mock_datetime(2014, 6, 28, 12, 0): job1 = every(5).seconds.do(make_mock_job(name="job1")).tag("tag1") job2 = every(2).hours.do(make_mock_job(name="job2")).tag("tag1", "tag2") job3 = ( every(1) .minutes.do(make_mock_job(name="job3")) .tag("tag1", "tag3", "tag2") ) assert schedule.next_run("tag1") == job1.next_run assert schedule.default_scheduler.get_next_run("tag2") == job3.next_run assert schedule.next_run("tag3") == job3.next_run assert schedule.next_run("tag4") is None
def play_turn(): global saved_turn, PLAY # Send cached message if telegram_handler is not None: telegram_handler.send_cached_data() if saved_turn is not None: saved_turn["battle_round"] = reign.battle_round try: reign.battle() except Exception: error_message = traceback.format_exc() app_logger.error(error_message) telegram_handler.bot.send_message(chat_id=config["telegram"]["chat_id_logging"], text=error_message) # If the war is not end schedule the next round if reign.remaining_empires > 1: next_run = schedule.next_run().strftime("%Y-%m-%d %H:%M:%S") app_logger.info("Next turn will be at %s", next_run) else: PLAY = False # Save the partial battle state save_temp()
def go_click(): global config config['dingtalk']['username'] = self.dingtalk_user.get() config['dingtalk']['password'] = self.dingtalk_pwd.get() config['schedule']['schedule_time'] = self.schd_time.get() with open('./config/xuexi.conf', 'w+') as f: json.dump(config, f) app.log(u'保存配置成功。配置及时生效') app.log(' 钉钉用户名: %s' % config['dingtalk']['username'], printtime=False) schedule.clear() if config['schedule']['schedule_time']: schedule.every().day.at( config['schedule']['schedule_time']).do(self.start_click, sched_task=True) else: schedule.every().day.at("08:00").do(self.start_click) if not self.task_monitor.isAlive(): self.task_monitor.setDaemon(True) self.task_monitor.start() app.log(' 下次学习时间: %s' % schedule.next_run(), printtime=False)
def register_jobs(jobs_config_path): with open(jobs_config_path) as json_file: config = json.load(json_file) query_hashes = set() for query in config['queries']: frequency = query['frequency'] query_hash = query['query_hash'] if query_hash in query_hashes: raise ValueError( f"Query hash {query_hash} is duplicated, a same query can't be set multiple time" ) query_hashes.add(query_hash) frequency_number = int(frequency[:-1]) if frequency[-1] == 's': schedule.every(frequency_number).seconds.do( run_threaded, job, query_hash) elif frequency[-1] == 'm': schedule.every(frequency_number).minutes.do( run_threaded, job, query_hash) elif frequency[-1] == 'h': schedule.every(frequency_number).hours.do(run_threaded, job, query_hash) else: raise ValueError( f'Config expect a frequency: <x>[s|m|h], got {frequency}') if len(query_hashes) == 0: raise ValueError('No query found') next_run: datetime.timedelta = schedule.next_run() - datetime.datetime.now( ) logger.info('Loaded %s queries with success, next run in %1.0f s', len(query_hashes), next_run.total_seconds())
def main(): setup_directories() setup_logging() logger.info("Completed the setup of directories & logging") logger.info("Setting up schedule jobs ...") schedule.every().hour.at(":00").do(run_gdelt_script) schedule.every().hour.at(":00").do(run_gdacs_script) schedule.every().hour.at(":15").do(run_gdelt_script) schedule.every().hour.at(":15").do(run_gdacs_script) schedule.every().hour.at(":30").do(run_gdelt_script) schedule.every().hour.at(":30").do(run_gdacs_script) schedule.every().hour.at(":45").do(run_gdelt_script) schedule.every().hour.at(":45").do(run_gdacs_script) logger.info("Completed the setup of schedule jobs") while 1: logger.debug("Waiting to run pending schedules ...") schedule.run_pending() time.sleep(1) logger.debug("Next run is at {}".format(schedule.next_run()))
def run(): N.UPDATE_JOBS_INTERVAL.do(schedule_update) while True: schedule.run_pending() if schedule.next_run() is None: break time.sleep(schedule.idle_seconds())
def test_next_run_time(self): # Monkey-patch datetime.datetime to get predictable (=testable) results class MockDate(datetime.datetime): @classmethod def today(cls): return cls(2010, 1, 6) @classmethod def now(cls): return cls(2010, 1, 6, 12, 15) original_datetime = datetime.datetime datetime.datetime = MockDate mock_job = make_mock_job() assert schedule.next_run() is None assert every().minute.do(mock_job).next_run.minute == 16 assert every(5).minutes.do(mock_job).next_run.minute == 20 assert every().hour.do(mock_job).next_run.hour == 13 assert every().day.do(mock_job).next_run.day == 7 assert every().day.at("09:00").do(mock_job).next_run.day == 7 assert every().day.at("12:30").do(mock_job).next_run.day == 6 assert every().week.do(mock_job).next_run.day == 13 datetime.datetime = original_datetime
def get_status(self): """ Compute the agent status. """ self.logger.info("Retrieving status..") license_key = self.config['license-key'] if license_key: self.logger.info( "Detected license key was: {0}".format(license_key)) agent_id = self.config['agent-id'] assert agent_id != None self.logger.info("Detected agent ID was: {0}".format(agent_id)) last_backup_time = 0 next_backup_time = schedule.next_run() self.logger.info( "Detected next run is for {0}".format(next_backup_time)) else: self.logger.info("No license was detected") agent_id = None last_backup_time = 0 next_backup_time = 0 return license_key, agent_id, last_backup_time, next_backup_time
def test_next_run_time(self): # Monkey-patch datetime.datetime to get predictable (=testable) results class MockDate(datetime.datetime): @classmethod def today(cls): return cls(2010, 1, 6) @classmethod def now(cls): return cls(2010, 1, 6, 12, 15) original_datetime = datetime.datetime datetime.datetime = MockDate mock_job = make_mock_job() assert schedule.next_run() is None assert every().minute.do(mock_job).next_run.minute == 16 assert every(5).minutes.do(mock_job).next_run.minute == 20 assert every().hour.do(mock_job).next_run.hour == 13 assert every().day.do(mock_job).next_run.day == 7 assert every().day.at('09:00').do(mock_job).next_run.day == 7 assert every().day.at('12:30').do(mock_job).next_run.day == 6 assert every().week.do(mock_job).next_run.day == 13 datetime.datetime = original_datetime
def run(self): while (True): seconds = (schedule.next_run() - datetime.datetime.now()).total_seconds() time.sleep(seconds) schedule.run_pending() client = FCMHandler(self.token) client.start()
def start(self): if self._running is False: self._running = True if schedule.next_run() is None: logging.info("no jobs to run") self.stop() else: self._timer()
def mainloop(self): while True: if self.timerRunning: d = schedule.next_run() strd = d.strftime("Next break at %H:%M") self.start.title = strd schedule.run_pending() time.sleep(1)
def _timer(self): """This is the callback function which is run each second""" if self._running: #logging.debug("{} Schedule wokeup, next job is {}".format(datetime.now(), schedule.next_run())) schedule.run_pending() if schedule.next_run() is None: logging.info("no jobs to run, stopping scheduler") self.stop() threading.Timer(1, self._timer).start()
def run(): s = schedule.every(1).week s.start_day = SLACK_REMINDER_DAY s.at(SLACK_REMINDER_TIME).do(report_to_slack) while True: sleep_time = schedule.next_run() - datetime.now() print(f'Next job to run at {schedule.next_run()}, which is {str(sleep_time)} from now.') time.sleep(max(1, sleep_time.seconds)) schedule.run_pending()
def test_next_run_property(self): original_datetime = datetime.datetime with mock_datetime(2010, 1, 6, 13, 16): hourly_job = make_mock_job("hourly") daily_job = make_mock_job("daily") every().day.do(daily_job) every().hour.do(hourly_job) assert len(schedule.jobs) == 2 # Make sure the hourly job is first assert schedule.next_run() == original_datetime(2010, 1, 6, 14, 16)
def cmd_run(options): logging.info('Starting scheduler') schedule.every().day.at(options.at).do(backup_all) last_next_run = None while True: next_run = schedule.next_run() if next_run != last_next_run: last_next_run = next_run next_run_str = schedule.next_run().strftime("%c") next_run_seconds = schedule.idle_seconds() logging.info('Next run is at ' + next_run_str + ' that is still ' + str(next_run_seconds) + ' seconds') schedule.run_pending() time.sleep(1)
def test_next_run_time(self): with mock_datetime(2010, 1, 6, 12, 15): mock_job = make_mock_job() assert schedule.next_run() is None assert every().minute.do(mock_job).next_run.minute == 16 assert every(5).minutes.do(mock_job).next_run.minute == 20 assert every().hour.do(mock_job).next_run.hour == 13 assert every().day.do(mock_job).next_run.day == 7 assert every().day.at('09:00').do(mock_job).next_run.day == 7 assert every().day.at('12:30').do(mock_job).next_run.day == 6 assert every().week.do(mock_job).next_run.day == 13
def run(self): while not self.xx_obj.login() and self.__running.isSet(): return self.__in_progress.set() while self.__running.isSet(): try: score = self.xx_obj.get_score() except Exception: app.log(u'网页被异常关闭,当前学习已被终止。') break if len(score) < 5: continue if score[1]['score'] < score[1]['target'] or score[3][ 'score'] < score[3]['target']: # read articles try: if not new_article: new_article = self.xx_obj.read_new_article() except NameError: new_article = self.xx_obj.read_new_article() try: next(new_article) except StopIteration: app.log(u'当日学习任务未完成。但爬取的文章已经全部阅读完毕。 ') self.__running.clear() except Exception: new_article = self.xx_obj.read_new_article() elif score[2]['score'] < score[2]['target'] or score[4][ 'score'] < score[4]['target']: # watch videos try: if not new_video: new_video = self.xx_obj.watch_new_video() except NameError: new_video = self.xx_obj.watch_new_video() try: next(new_video) except StopIteration: app.log(u'当日学习任务未完成。但爬取的视频已经全部观看完毕。 ') self.__running.clear() except Exception: new_video = self.xx_obj.watch_new_video() else: # all tasks are done, sleep app.log(u'当日学习任务已完成。 ') app.log('下次学习时间: %s' % schedule.next_run()) self.__running.clear() self.__in_progress.wait() # wait until next task self.xx_obj.close() # close the driver if finished.
def job(force=False): while True: now = datetime.datetime.now() end = now.replace(hour=13, minute=30, second=0, microsecond=0) if now < end or force: get_symbol('NIFTY') get_symbol('BANKNIFTY') get_symbol('RELIANCE', 'equities') if (force): print("First run done. next execution: {0}".format( schedule.next_run())) break print("next update in {0} minutes".format(sys.argv[1])) time.sleep(int(sys.argv[1]) * 60) else: print("job finished for day. next execution: {0}".format( schedule.next_run())) break
def start_main_job(): for round_time in schedule_config["rounds_at_time"]: if config["distribution"] == "production": schedule.every().day.at(round_time).do(run_threaded, play_turn).tag("main_job") elif config["distribution"] == "develop": schedule.every().minute.at(round_time).do(run_threaded, play_turn).tag("main_job") next_run = schedule.next_run().strftime("%Y-%m-%d %H:%M:%S") if war_continues: app_logger.info("The War continues. Next turn will be at %s", next_run)
def test_next_run_property(self): original_datetime = datetime.datetime with mock_datetime(2010, 1, 6, 13, 16): hourly_job = make_mock_job('hourly') daily_job = make_mock_job('daily') every().day.do(daily_job) every().hour.do(hourly_job) assert len(schedule.jobs) == 2 # Make sure the hourly job is first assert schedule.next_run() == original_datetime(2010, 1, 6, 14, 16) assert schedule.idle_seconds() == 60 * 60
def test_next_run_property(self): original_datetime = datetime.datetime with mock_datetime(2010, 1, 6, 13, 16): hourly_job = make_mock_job('hourly') daily_job = make_mock_job('daily') every().day.do(daily_job) every().hour.do(hourly_job) assert len(schedule.jobs) == 2 # Make sure the hourly job is first assert schedule.next_run() == original_datetime(2010, 1, 6, 14, 16, tzinfo=tzlocal()) assert schedule.idle_seconds() == 60 * 60
def run_monitor(self): self.__monitor_flag.set() while self.__monitor_flag.isSet(): schedule.run_pending() time.sleep(1) # self.__monitor_flag.wait() if schedule.next_run is not None: self.auto_status.set(u'运行中...\n下次运行时间:\n %s\n当前时间:\n %s' % (schedule.next_run(), datetime.now().strftime("%Y-%m-%d %H:%M:%S"))) else: self.auto_status.set(u'状态:无任务') self.auto_status.set(u'状态:停止')
def calculate_countdown(self): """ Calculates when the next scheduled download will begin and sends the update signal if there is one scheduled. """ if self.update_countdown: next_run = schedule.next_run() if next_run is not None: t = next_run - datetime.now() dur = system_util.format_time_delta(t) self.countdown.emit(dur) else: self.countdown.emit(None) self.update_countdown = False
def __schedule_loop(): while True: log.debug("Running pending scheduled tasks.") schedule.run_pending() sleep_time = SCHEDULING_SLEEP_INTERVAL if schedule.next_run() is not None: sleep_time = schedule.idle_seconds() if sleep_time < 0: sleep_time = SCHEDULING_SLEEP_INTERVAL log.debug("Scheduling thread sleeping for: '{}' seconds".format(sleep_time)) time.sleep(sleep_time)
def main(): win = gui.init_gui() gpio, kit = init_hardware() quadrants = loading.load_pills(win, gpio, kit) # external.sendemail("*****@*****.**", "Tylenol") while True: schedule.run_pending() gui.change_instruction_text( win, "Next pill will be dispensed at {}".format(schedule.next_run())) gui.change_button_text(win, ["Dispense", "", ""]) interface.pressed_red_button(gpio, win, quadrants[0], 1, kit) # need to run this every loop iteration gui.maintain_gui(win)
def run(cls): self.logger.debug("ScheduleThread run()") nextRun = None while not cease_continuous_run.is_set(): try: newNextRun = schedule.next_run() if newNextRun != nextRun: #self.logger.info("Der nächste SchedulerThread Job läuft um {}".format(newNextRun)) nextRun = newNextRun schedule.run_pending() time.sleep(interval) except: self.logger.exception("Fehler im SchedulerThread") self.logger.debug("ScheduleThread exit()") schedule.clear()
def _schedule_once(exit_handler: ExitHandler) -> float: try: log.debug("Running pending scheduled tasks.") schedule.run_pending() sleep_time = SCHEDULING_SLEEP_INTERVAL if schedule.next_run() is not None: sleep_time = schedule.idle_seconds() if sleep_time < 0: sleep_time = SCHEDULING_SLEEP_INTERVAL return sleep_time except Exception: log.error("Failed to run scheduling once") exit_handler.exit(SCHEDULE_ONCE_FAILURE_EXIT_CODE)
def test_next_run_property(self): class MockDate(datetime.datetime): @classmethod def today(cls): return cls(2010, 1, 6) @classmethod def now(cls): return cls(2010, 1, 6, 13, 16) original_datetime = datetime.datetime datetime.datetime = MockDate hourly_job = make_mock_job('hourly') daily_job = make_mock_job('daily') every().day.do(daily_job) every().hour.do(hourly_job) assert len(schedule.jobs) == 2 # Make sure the hourly job is first assert schedule.next_run() == original_datetime(2010, 1, 6, 14, 16) assert schedule.idle_seconds() == 60 * 60 datetime.datetime = original_datetime
print("* FILED - Get Organized *") print("* 2015 Will Kinard *") print("*******************************************************") print("\n") format = '%(asctime)s - %(name)s - %(levelname)s - %(message)s' logging.basicConfig(format=format) logger = logging.getLogger() logger.setLevel(getattr(logging, flags.logging_level)) # Set pika log level pika_logger = logging.getLogger('pika') pika_logger.setLevel(logging.ERROR) try: app = Filed() except Exception: logger.error("Error occured!", exc_info=True) sys.exit(1) if flags.schedule: schedule.every().day.at(flags.schedule).do(app.run) logger.info("Scheduled: " + schedule.next_run().strftime("%Y-%m-%d %I:%M %p")) while 1: schedule.run_pending() time.sleep(1) else: app.run()
def next_alarm(self): """Returns the datetime object of next scheduled alarm""" return schedule.next_run()
import pigpio, MySQLdb, DHT22, schedule, datetime, time pi = pigpio.pi() # Set second parameter to GPIO port of DHT22 data pin: s = DHT22.sensor(pi, 4) # Set database info: db_info = {'host':'localhost', 'user':'******', 'pw':'Pa$$w0rd', 'db':'DHT22Readings'} def get_readings_and_save_to_db(): s.trigger() dt = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S') con = MySQLdb.connect(db_info['host'], db_info['user'], db_info['pw'], db_info['db']) time.sleep(1) print('Reading for ' + dt + ":") print('Temperature: ' + '{:3.2f}'.format(s.temperature() / 1.)) print('Humidity: ' + '{:3.2f}'.format(s.humidity() / 1.)) with con: con.cursor().execute("INSERT INTO Reading(Datetime, Temperature, Humidity) \ VALUES ('" + dt + "'," + str(s.temperature()) + "," + str(s.humidity()) + ")") for t in range(0,24): schedule.every().day.at(str(t) + ":00").do(get_readings_and_save_to_db) print('Running... first readings at: ' + str(schedule.next_run())) while True: schedule.run_pending() time.sleep(1)
def log_time_of_next_run(self): self.log.info( 'Next update is scheduled to run {}'.format(schedule.next_run()))