async def scheduler(): schedule.every(15).minutes.do(lambda: habrhabr_news()) # loop = asyncio.get_event_loop() while True: await schedule.run_pending() await asyncio.sleep(2)
async def scheduler(): aioschedule.every().day.at("11:00").do(send_daily_updates) aioschedule.every().monday.at("23:00").do(send_daily_reminder_to_rate) while True: await aioschedule.run_pending() await asyncio.sleep(1)
def test_run_every_n_days_at_specific_time(self): mock_job = make_mock_job() with mock_datetime(2010, 1, 6, 11, 29): every(2).days.at('11:30').do(mock_job) self.run_async(schedule.run_pending) assert mock_job.call_count == 0 with mock_datetime(2010, 1, 6, 11, 31): self.run_async(schedule.run_pending) assert mock_job.call_count == 0 with mock_datetime(2010, 1, 7, 11, 31): self.run_async(schedule.run_pending) assert mock_job.call_count == 0 with mock_datetime(2010, 1, 8, 11, 29): self.run_async(schedule.run_pending) assert mock_job.call_count == 0 with mock_datetime(2010, 1, 8, 11, 31): self.run_async(schedule.run_pending) assert mock_job.call_count == 1 with mock_datetime(2010, 1, 10, 11, 31): self.run_async(schedule.run_pending) assert mock_job.call_count == 2
def run_reminder(): logging.info('starting program ...') loop = asyncio.get_event_loop() schedule.every().day.do(job) while True: loop.run_until_complete(schedule.run_pending()) time.sleep(0.1)
async def scheduler(): schedule.every().day.at("07:00").do(send_schedule_today) # schedule.every().day.at("22:45").do(send_schedule_today) # schedule.every(5).seconds.do(send_schedule_today) while True: await schedule.run_pending() # await asyncio.sleep(1) await asyncio.sleep(600)
async def set_timer(message): args = message.text.split() if len(args) > 1 and args[1].isdigit(): sec = int(args[1]) aioschedule.every(sec).seconds.do(beep, message.chat.id).tag(message.chat.id) else: await bot.reply_to(message, 'Usage: /set <seconds>')
def __init__(self): super().__init__() uic.loadUi('myform.ui', self) self.show() self.timer = QtCore.QTimer() self.timer.setInterval(1000) self.timer.timeout.connect(self.sch_run) self.timer.start() schedule.every().second.do(self.test)
async def scheduler(): aioschedule.every().day.at('00:54').do(job) # loop = asyncio.get_event_loop() while True: # loop.run_until_complete(aioschedule.run_pending()) # time.sleep(1) await aioschedule.run_pending() await asyncio.sleep(1)
async def scheduler(client): schedule.every(15).minutes.do(alertairingnow, client) schedule.every().day.at("00:15").do(verifyairing) schedule.every().day.at("07:00").do(alertairingtoday, client) schedule.every().day.at("23:59").do(deletedata) schedule.every().sunday.at("23:30").do(verifycompleted) while True: await schedule.run_pending() await asyncio.sleep(10)
async def job(): curr_day = str(datetime.today().day) curr_month = str(datetime.today().month) curr_year = str(datetime.today().year) birthdays = db.query(Birthday).filter(Birthday.month == int(curr_month), Birthday.day == int(curr_day)).all() for b in birthdays: aioschedule.every(1).day.at('00:55').do(lambda: send_notification(b, curr_year))
def test_run_every_weekday_at_specific_time_today(self): mock_job = make_mock_job() with mock_datetime(2010, 1, 6, 13, 16): every().wednesday.at('14:12').do(mock_job) self.run_async(schedule.run_pending) assert mock_job.call_count == 0 with mock_datetime(2010, 1, 6, 14, 16): self.run_async(schedule.run_pending) assert mock_job.call_count == 1
async def start(): aioschedule.every().day.at("23:00").do(delete_old_orders_) for day_num, day_name in enumerate(('monday', 'tuesday', 'wednesday', 'thursday', 'friday', 'saturday', 'sunday')): for break_num, (break_time_start, _) in broadcast_times[day_num].items(): getattr(aioschedule.every(), day_name).at(break_time_start).do(send_live_begin, break_num) while True: await aioschedule.run_pending() await asyncio.sleep(10)
def setup(bot: discord.ext.commands.Bot): global client client = bot vac = Vac() bot.add_cog(vac) async def job(): await vac.check_vac_status_and_send_results() schedule.every().hour.do(job)
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
async def tasks_scheduler(): aioschedule.every().day.at("4:00").do(run_db_backup) aioschedule.every().day.at("14:20").do(run_db_backup) aioschedule.every().day.at("0:01").do( last_jackpot_data.get_last_jackpot_data) aioschedule.every().day.at("00:00").do(reset_duels) aioschedule.every(4).minutes.do( handling_casino_sql.reset_old_confirmations_emails) while True: loop.create_task(aioschedule.run_pending()) await asyncio.sleep(60)
async def start_scheduler(post_poll: Callable, repeat_poll: Callable): logger.info('Scheduler started') for action_time in config.NEW_POLL_TIMES: schedule.every().day.at(action_time).do(post_poll) for repeat_time in config.REPEAT_POLL_TIMES: schedule.every().day.at(repeat_time).do(repeat_poll) while True: await schedule.run_pending() await asyncio.sleep(0.1)
def setup(bot: discord.ext.commands.Bot): global client client = bot vac = Vac() bot.add_cog(vac) channel = bot.get_channel(int(config.default_channel)) async def job(): await vac.check_vac_status_and_send_results(channel, False) schedule.every().day.at("12:00").do(job)
async def main(config: Dict[str, Any]) -> None: """ Main schedule """ redis_pool = await create_redis_pool( (config['REDIS_HOST'], int(config['REDIS_PORT'])), db=int(config['REDIS_DB'])) icmp_queue = AioRedisQueue(redis=redis_pool, queue_name=config['ICMP_QUEUE_NAME']) snmp_queue = AioRedisQueue(redis=redis_pool, queue_name=config['SNMP_QUEUE_NAME']) schedule.every(30).seconds.do(check_icmp, queue=icmp_queue) schedule.every(1).minutes.do(check_system, queue=snmp_queue, community=config['COMMUNITY']) schedule.every(1).minutes.do(check_interfaces, queue=snmp_queue, community=config['COMMUNITY']) schedule.every(5).minutes.do(find_hosts, redis=redis_pool, network=config['NETWORK']) await schedule.run_all() while True: await schedule.run_pending() await asyncio.sleep(1)
async def initialize(self): self.session = ClientSession(loop=self.loop, timeout=ClientTimeout(total=10)) self.db.load() self.settings = await self.db.process_settings() self.load_cogs() self.status, self.activity = self.get_presence() self.app_info: Optional[nextcord.AppInfo] = None self.set_cache() # self.load_music() schedule.every().day.at("06:00").do(self.auto_update_ytdl) self.loop.create_task(self.run_scheduler())
async def startSchedule(): schedule.every(1).minute.do(sendMainInfo) schedule.every().day.at("18:00").do(addCurrencyInfo, 10) schedule.every().day.at("22:00").do(addCurrencyInfo, 10) schedule.every().day.at("06:00").do(addCurrencyInfo, 50) while True: await schedule.run_pending() await asyncio.sleep(1)
def test_time_range_repr(self): mock_job = make_mock_job() with mock_datetime(2014, 6, 28, 12, 0): job_repr = repr(every(5).to(30).minutes.do(mock_job)) assert job_repr.startswith('Every 5 to 30 minutes do job()')
async def nslookup(redis: ConnectionsPool, domain: str) -> None: resolve, _ = Resolver() ttl = 180 ip_addresses = await resolve(domain, TYPES.A) loop = asyncio.get_event_loop() for ip_address in ip_addresses: new_ttl = ip_address.expires_at - loop.time() if new_ttl < ttl: ttl = new_ttl if ttl < 60: ttl = 60 await redis.rpush(domain, str(ip_address)) await redis.expire(domain, ttl) await redis.publish('channel:routes', str(ip_address)) schedule.clear(domain) schedule.every(ttl).seconds.do(nslookup, redis=redis, domain=domain).tag(domain)
def test_to_string(self): def job_fun(): pass s = str(every().minute.do(job_fun, 'foo', bar=23)) assert 'job_fun' in s assert 'foo' in s assert 'bar=23' in s
async def add_timer(content=None, rozmowy=None): if content.split(" ")[0][0].isdigit(): # pojedyncze powiadomienie day, hour, text = content.split(" ", 2) data = " ".join([day, hour]) data = datetime.strptime(data, '%d/%m/%y %H:%M') seconds = (data - datetime.today()).total_seconds() schedule.every(seconds).seconds.do(powiadomienie_pojedyncze, text=text, rozmowy=rozmowy) data = "```One-time notification added : {}, {}, \nTreść: {}```".format(day, hour, text) else: # powiadomienie powtarzane day, hour, text = content.split(" ", 2) eval(days.get(day)).at(hour).do(powiadomienie_powtarzane, text=text, rozmowy=rozmowy) data = "```Repeat notification added : {}, {}, \nTreść: {}```".format(day, hour, text) return data
def test_to_string_functools_partial_job_func(self): def job_fun(arg): pass job_fun = functools.partial(job_fun, 'foo') job_repr = repr(every().minute.do(job_fun, bar=True, somekey=23)) assert 'functools.partial' in job_repr assert 'bar=True' in job_repr assert 'somekey=23' in job_repr
def test_cancel_job(self): async def stop_job(): return schedule.CancelJob mock_job = make_mock_job() every().second.do(stop_job) mj = every().second.do(mock_job) assert len(schedule.jobs) == 2 self.run_async(schedule.run_all) assert len(schedule.jobs) == 1 assert schedule.jobs[0] == mj schedule.cancel_job('Not a job') assert len(schedule.jobs) == 1 schedule.default_scheduler.cancel_job('Not a job') assert len(schedule.jobs) == 1 schedule.cancel_job(mj) assert len(schedule.jobs) == 0
def test_run_all(self): mock_job = make_mock_job() every().minute.do(mock_job) every().hour.do(mock_job) every().day.at('11:00').do(mock_job) self.run_async(schedule.run_all) assert mock_job.call_count == 3
async def praise_schedule(time_interval): # Schedule to run 3 times a day. # Adjusted UTC times so that this occurs at 00:00, 08:00, 16:00 PST. Will # fix this so it adjusts timezone auto schedule.every().day.at("7:00").do(lambda: praise('')) schedule.every().day.at("15:00").do(lambda: praise('')) schedule.every().day.at("23:00").do(lambda: praise('')) # Testing case #schedule.every(3).seconds.do(lambda: praise('')) # Check for tasks to run every 'time_interval' seconds. while True: local_t = time.localtime() print("Checking for a scheduled task to execute (" + str(local_t.tm_hour).zfill(2) + ":" + str(local_t.tm_min).zfill(2) + ":" + str(local_t.tm_sec).zfill(2) + ")") await schedule.run_pending() await asyncio.sleep(time_interval)
async def on_ready(): print("Bot is ready") await client.change_presence(activity=discord.Activity( type=discord.ActivityType.watching, name="xYarin#2280 Raiders 😈")) for config in configs: utc_startHour = toUTC(config.getStartHour()) utc_endHour = toUTC(config.getEndHour()) schedule.every().day.at(utc_startHour).do(set_slowmode, config) print( f"[START HOUR SET] Server {config.serverId} start hour set to {utc_startHour}" ) for config in configs: utc_startHour = toUTC(config.getStartHour()) utc_endHour = toUTC(config.getEndHour()) schedule.every().day.at(utc_endHour).do(remove_slowmode, config) print( f"[END HOUR SET] Server {config.serverId} start hour set to {utc_endHour}" ) while True: await schedule.run_pending() await asyncio.sleep(1)
def test_time_range(self): with mock_datetime(2014, 6, 28, 12, 0): mock_job = make_mock_job() # Choose a sample size large enough that it's unlikely the # same value will be chosen each time. minutes = set([ every(5).to(30).minutes.do(mock_job).next_run.minute for i in range(100) ]) assert len(minutes) > 1 assert min(minutes) >= 5 assert max(minutes) <= 30