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 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 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()))
