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
