def run(self):
schedule.every().day.at("14:55").do(self.marketFunc)
while True:
schedule.run_pending()
logging.info('WAIT {} sec'.format(schedule.idle_seconds()))
time.sleep(max(schedule.idle_seconds(), 1))
def run(self):
schedule.every().day.at("21:00").do(self.tradeFunc)
schedule.every().day.at("09:00").do(self.tradeFunc)
while True:
schedule.run_pending()
logging.info('WAIT {} sec'.format(schedule.idle_seconds()))
sleep(max(schedule.idle_seconds(), 1))
def test_idle_seconds(self):
assert schedule.next_run() is None
assert schedule.idle_seconds() 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
assert schedule.idle_seconds() is None
def main(args):
# function that will be ran repeatedly
def f():
filename = copy(args.experiment,
src_file=args.filename,
verbose=args.no_verbose)
if args.gifs:
gif_filename = filename.split('/')[-1].split('.')[0]
mg.make_gif(filename,
os.path.join(args.experiment, 'gifs'),
map=args.map,
filename=gif_filename,
fps=25)
# scheduling the function to occur at given frequency
schedule.every(args.frequency).minutes.do(f)
# performing the function immediately
f()
# infinite loop calling the function or printing time until next call
while True:
n_seconds = schedule.idle_seconds()
if n_seconds > 0:
fmt_time = str(datetime.timedelta(seconds=int(n_seconds)))
print(f'Time til next copy: {fmt_time}', end='\r')
else:
schedule.run_pending()
time.sleep(1)
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 run_scheduled_tasks():
"""Run the scheduled tasks using the 'schedule' package."""
# always send a device update upon start up (in case the device is new to the server)
send_device_update()
try:
while True:
idle_seconds = schedule.idle_seconds()
if idle_seconds is None:
# no more jobs to run
LOGGER.warning("No more jobs for scheduler to run")
break
if idle_seconds > 0:
# sleep till the next scheduled job needs to be run
LOGGER.debug(f"scheduler sleeping for {idle_seconds} seconds.")
time.sleep(idle_seconds)
start = time.time()
schedule.run_pending()
end = time.time()
elapsed_time = end - start
LOGGER.debug(f"SCHEDULER - took: {elapsed_time} seconds to run")
except KeyboardInterrupt:
LOGGER.info("Stopping scheduler")
LOGGER.info("Scheduler is exiting")
async def run(self):
schedule.every().day.at('05:30').do(self.clean_rooms)
schedule.every().day.at('15:30').do(self.clean_rooms)
await asyncio.sleep(120)
while True:
await asyncio.sleep(schedule.idle_seconds() + 1)
schedule.run_pending()
def run(self):
# Compute start time
t = time(hour=0, minute=0)
soff = timedelta(minutes=self.starttime)
t = datetime.combine(date.today(), t) + soff
now = datetime.now()
soff = t - now
if soff.total_seconds() < 0:
# We missed the window. Wait until the next day.
soff = soff + timedelta(days=1)
print "First start is in %s" % soff
# Wait for first iteration
sleep(soff.total_seconds())
job = schedule.every(self.period).minutes.do(self.job)
# Do the first run
schedule.run_all()
while True:
print "Next run at %s" % job.next_run
sleep(schedule.idle_seconds() + 1)
schedule.run_pending()
def background_task(self):
schedule.run_pending()
# restart with proper interval here
self.bg_task = threading.Timer(schedule.idle_seconds(),
self.background_task)
self.bg_task.daemon = True # thread dies with main
self.bg_task.start()
def run_scheduled_refresh(args, config):
logger = get_logger(__name__)
reader = StatsReader(config)
ctx = RefreshContext(reader, args.database)
def job():
old_hosts = reader.hosts
try:
config = read_config(args.config)
reader.update_hosts(config)
except:
reader.hosts = old_hosts
ctx.refresh_all()
if not setup_scheduled_refresh(job, args, config):
return
exit_event = config['event'] if 'event' in config else Event()
if current_thread() is main_thread():
setup_signal_handlers(exit_event)
while not exit_event.is_set():
idle = schedule.idle_seconds()
if idle > 0:
exit_event.wait(idle)
if exit_event.is_set():
return
logger.debug('Run refresh')
schedule.run_pending()
def background_task(self):
schedule.run_pending()
# restart with proper interval here
self.bg_task = threading.Timer(schedule.idle_seconds(),
self.background_task)
self.bg_task.daemon = True # thread dies with main
self.bg_task.start()
def get_email(email, ticker):
# while True:
# schedule.every(20).seconds.do(job, email=email)
# schedule.run_pending()
# time.sleep(1)
schedule.every(5).seconds.do(job, args_=[email, ticker])
while 1:
n = schedule.idle_seconds()
if n is None:
break
elif n > 0:
time.sleep(0.5)
schedule.run_pending()
# import schedule
# import time
# def job():
# print('Hello')
# schedule.every(5).seconds.do(job)
# while 1:
# n = schedule.idle_seconds()
# if n is None:
# # no more jobs
# break
# elif n > 0:
# arr = [5,4,3,2,1]
# arr.sort()
# print(arr)
# time.sleep(n)
# schedule.run_pending()
def bgWorker():
global run_threads
sleeptime = 2
while run_threads:
if sleeptime > 0:
time.sleep(sleeptime)
jLog.debug('Running jobs...')
schedule.run_pending()
sleeptime = schedule.idle_seconds()
def run() -> None:
run_pipeline() # run once when starting to catch new errors when deploying
schedule.every().day.at('04:00').do(run_pipeline)
while True:
schedule.run_pending()
wait = schedule.idle_seconds()
print('Waiting {} seconds until the next run'.format(wait))
time.sleep(wait)
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)
assert schedule.idle_seconds() == 60 * 60
def main():
for t in range(24):
d = f'{t:02d}:5'
schedule.every().day.at(d).do(job)
while True:
schedule.run_pending()
til_next = int(schedule.idle_seconds()/60)
if til_next % 10 == 0:
print(f'Next Task running in: {til_next} minutes')
sleep(1)
class Zeitplan:
schedule.every(5).seconds.do(rssFetch)
while 1:
n = schedule.idle_seconds()
if n is None:
# no more jobs
break
elif n > 0:
# sleep exactly the right amount of time
time.sleep(n)
schedule.run_pending()
def main():
if not azan_time.exists():
logger.info('File "azan-time.txt" not exists.')
update_time()
schedule.every(3).seconds.do(create_job_once)
schedule.every().day.at('00:05').do(update_time)
schedule.every().day.at('00:10').do(create_job)
logger.info('Running service in background...')
while True:
n = schedule.idle_seconds()
logger.info(f'Next job in {round(n/60, 2)} minutes...')
if n is None: break
elif n > 0: time.sleep(n)
schedule.run_pending()
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():
bot = Bot(os.path.join(path, "vacancies.bot"))
bot.dp.add_handler(CommandHandler("run", lambda dummy, update: run_cmd(bot, update)))
schedule.every().day.at("08:00").do(loop_files, bot)
schedule.every().day.at("18:00").do(loop_files, bot)
while True:
try:
time.sleep(schedule.idle_seconds())
schedule.run_pending()
except (KeyboardInterrupt, SystemExit):
os._exit(1)
except:
logging.exception(f"{Storage.make_timestamp()}: An error occured", exc_info=True)
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 main():
"""The main program"""
for show in read_shows("./config.yml"):
schedule_show(show)
while True:
sleep_time = idle_seconds()
if sleep_time and sleep_time > 0:
info(f"Sleeping {sleep_time} seconds until next schedule")
sleep(sleep_time)
run_pending()
else:
info("Nothing is scheduled, so exiting")
return
async def add_onlinerooms_monitor():
monitors: List[DanmuRaffleMonitor] = []
schedule.every().day.at('05:00').do(clean_rooms, monitors)
schedule.every().day.at('15:00').do(clean_rooms, monitors)
area_id = 0
while True:
if schedule.idle_seconds() <= 3:
await asyncio.sleep(5)
schedule.run_pending()
await asyncio.sleep(120)
list_new_rooms = await refresh_online_roomid()
set_new_rooms = set(list_new_rooms)
set_common_rooms = set()
list_unique_old_index = [] # 过期（下线）的直播间
for i, monitor in enumerate(monitors):
room_id = monitor.room_id
if not monitor.paused and room_id and room_id in set_new_rooms:
set_common_rooms.add(room_id)
elif monitor.paused:
list_unique_old_index.append(i)
set_unique_new_rooms = set_new_rooms - set_common_rooms
print('监控重启的数目', len(set_unique_new_rooms), len(list_unique_old_index))
for monitor_index, new_roomid in zip_longest(list_unique_old_index,
set_unique_new_rooms):
if monitor_index is not None:
monitor = monitors[monitor_index]
if new_roomid is None:
pass # list_unique_old_index 肯定都是pause的了
else:
await monitor.reset_roomid(new_roomid)
monitor.resume()
else: # 新房间很多，老房间不够用，需要扩充
# list_unique_old_index先到了头，那么set_unique_new_rooms一定还有多余，一定非 None
monitor = DanmuRaffleMonitor(new_roomid, area_id)
loop.create_task(monitor.run())
if not area_id % 20:
await asyncio.sleep(0.2)
area_id += 1
monitors.append(monitor)
bili_statistics.max_room_num(area_id)
if set_unique_new_rooms:
await asyncio.sleep(7)
def run(add_delay=2.5, sort='votes', no_search=False, run_now=False, no_notifications=False, ignore_blacklist=False):
log.info("Automatic mode is now running...")
# Add tasks to schedule and do first run if enabled
if cfg.automatic.movies.interval:
movie_schedule = schedule.every(cfg.automatic.movies.interval).hours.do(
automatic_movies,
add_delay,
sort,
no_search,
not no_notifications,
ignore_blacklist,
int(cfg.filters.movies.rating_limit) if cfg.filters.movies.rating_limit != "" else None
)
if run_now:
movie_schedule.run()
# Sleep between tasks
time.sleep(add_delay)
if cfg.automatic.shows.interval:
shows_schedule = schedule.every(cfg.automatic.shows.interval).hours.do(
automatic_shows,
add_delay,
sort,
no_search,
not no_notifications,
ignore_blacklist
)
if run_now:
shows_schedule.run()
# Sleep between tasks
time.sleep(add_delay)
# Enter running schedule
while True:
try:
# Sleep until next run
log.info("Next job at %s", schedule.next_run())
time.sleep(max(schedule.idle_seconds(), 0))
# Check jobs to run
schedule.run_pending()
except Exception as e:
log.exception("Unhandled exception occurred while processing scheduled tasks: %s", e)
time.sleep(1)
def _run(self):
while True:
_schedule.run_pending()
nextsched = self.sched.run(False)
if nextsched is None:
nextsched = Inf
try:
nextschedule = _schedule.idle_seconds()
except Exception:
nextschedule = Inf
if nextsched == nextschedule == Inf:
self._delay(1) # Finish init
else:
self._delay(min(nextsched, nextschedule))
def __init__(self):
""" This creates a new queue executor.
This creates a new Executor object; it does not start the executor, or load
the queue from the database.
"""
# initialize logging system
if not Executor.log:
Executor.__init_log()
# say hi
self.log.info('Executor is starting up...')
# dummy telescope variable
self.telescope: telescope.Telescope = None
# create connection to database; this raises a fatal
# exception if it fails
self.db = database.Database()
# create calendar
self.log.info('Connecting to Google Calendar...')
self.calendar = calendar.Calendar()
# variable to store completed observations every night
self.completed_observations = []
# schedule the start function to run each night at the
# designated start time (in the servers timezone)
run.every().day.at(config.queue.start_time).do(self.start)
# the execution loop; this waits until the appropriate time
# and then runs self.start()
while True:
# we try and start the queue
self.start()
# otherwise wait until we are meant to start at night
self.log.info(f'Executor is initialized and waiting {run.idle_seconds()/60/60:.1f} hours to the designated start time...')
time.sleep(int((1/24)*run.idle_seconds())) # check in roughly every hour
self.log.info('Executor is awake; checking if any jobs need to be run...')
run.run_pending()
def run() -> None:
"""Loop eternally and run schedulers at configured times."""
for s in ALL_SCHEDULERS:
job = getattr(schedule.every(s.period), s.time_unit)
if s.at:
job = job.at(s.at)
job.do(s).tag(s.name)
log.info("Starting Schedule")
for j in schedule.jobs:
log.info("%s: %s", ", ".join(j.tags), j)
while True:
schedule.run_pending()
idle = schedule.idle_seconds()
if idle < 0:
log.info("Next job in queue is scheduled in the past, run it now.")
else:
log.info("Sleeping for %d seconds", idle)
sleep(idle)
def run(self):
# pip install schedule
import schedule
schedule.every().day.at("11:00").do(
lambda: self.about_show_message.emit("Пора в столовку"))
schedule.every().day.at("13:00").do(
lambda: self.about_show_message.emit("Иди прогуляйся"))
schedule.every().day.at("15:00").do(
lambda: self.about_show_message.emit("Иди прогуляйся"))
schedule.every().day.at("17:00").do(
lambda: self.about_show_message.emit("Иди прогуляйся"))
schedule.every().day.at("19:00").do(
lambda: self.about_show_message.emit("Вали домой"))
description = 'Jobs:\n'
description_gui = ''
for job in schedule.jobs:
description += ' ' + str(job) + "\n"
description_gui += str(job) + "\n"
# Костыль для показа сообщения вида "Every 1 day at 11:00:00"
import re
pattern = re.compile(
r' do <lambda>\(\) \(last run: .+?, next run: .+?\)')
description = pattern.sub('', description)
description_gui = pattern.sub('', description_gui)
print(description)
while True:
schedule.run_pending()
import time
time.sleep(1)
next_job_time = schedule.next_run().time()
idle_secs = int(schedule.idle_seconds())
local_description_gui = description_gui
local_description_gui += '\n\n'
local_description_gui += 'Следующий перерыв будет в {}, осталось {} секунд'.format(
next_job_time, idle_secs)
self.about_description.emit(local_description_gui)
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 _schedule_in_main_thread(self):
"""
Run scheduler in the main thread.
If ``run_continuous`` is true then it will continuously run the jobs on schedule.
Otherwise run all jobs at once.
"""
if self._run_continuous:
audit_params(Sc.OPERATION_START_JOBS, Sc.STATUS_STARTED,
Sc.MSG_JOB_STARTED.format(str(self._print_etr)))
self._started = True
while True:
try:
if not self._run_continuous:
print(Sc.MSG_SHUTDOWN_SCHEDULER_RUNNING_ALL)
schedule.run_all()
self.__wait = False
self._shutdown_requested = False
self._started = False
break
self._next_run = schedule.next_run()
self._idle_seconds = schedule.idle_seconds()
self._log_etr()
schedule.run_pending()
time.sleep(self._pulse)
except KeyboardInterrupt:
audit_params(operation=Sc.OPERATION_SHUTDOWN,
status=Sc.STATUS_INTERRUPTED,
comments=Sc.MSG_SCHEDULER_INTERRUPTED)
schedule.run_all()
self.__wait = False
self._shutdown_requested = False
self._started = False
break
else:
audit_params(Sc.OPERATION_START_JOBS, Sc.STATUS_STARTED,
Sc.MSG_JOB_STARTED.format(str(self._print_etr)))
schedule.run_all()
def main():
bot = Bot(os.path.join(path, "binck.bot"))
bot.dp.add_handler(CommandHandler("check", lambda dummy1, resp: check(resp, bot)))
bot.dp.add_handler(CommandHandler("cash", lambda dummy1, resp, args: cash(resp, bot, args[0]), pass_args=True))
schedule.every().monday.at("17:00").do(update, bot)
schedule.every().tuesday.at("17:00").do(update, bot)
schedule.every().wednesday.at("17:00").do(update, bot)
schedule.every().thursday.at("17:00").do(update, bot)
schedule.every().friday.at("17:00").do(update, bot)
while True:
try:
time.sleep(schedule.idle_seconds())
schedule.run_pending()
except (KeyboardInterrupt, SystemExit):
os._exit(1)
except:
raise
logging.exception(f"{Storage.make_timestamp()}: An error occured", exc_info=True)
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
