def set_handlers(queue: JobQueue, bot: Bot):
queue.run_daily(lambda _: daily_infection(get_group_chat_id(), bot),
DAILY_INFECTION_TIME,
name=JOB_QUEUE_DAILY_INFECTION_KEY)
queue.run_repeating(lambda _: random_cough(bot, queue),
REPEATING_COUGHING_INTERVAL,
name=JOB_QUEUE_REPEATING_COUGHING_KEY)
def set_mailing_job(job_queue: JobQueue, user_id, chat_id, language_code):
"""set new mailing job"""
job_time, mailing_status = get_job_attrs(user_id)
if mailing_status != consts.MAILING_ALLOWED:
return
job_queue.run_daily(
callback=mailing_job,
time=job_time,
days=(0, 1, 2, 3, 4, 5),
context=[user_id, chat_id, language_code],
name=consts.MAILING_JOB,
)
def add_notify_event(job_queue: JobQueue, job_model: Job):
job_name = str(job_model.chat_id) + '_' + job_model.name
if job_model.mode == JobMode.ONCE:
job_queue.run_once(
callback=notify_callback,
name=job_name,
when=create_time(job_model.time),
)
elif job_model.mode == JobMode.DAILY:
job_queue.run_daily(
callback=notify_callback,
name=job_name,
time=create_time(job_model.time),
days=(0, 2, 3, 4), # Monday-Friday
)
def init(*, bot: Bot, job_queue: JobQueue, callback: callable):
_load_all()
_configure_logging(bot)
for chat in auto_spins:
job = job_queue.run_daily(callback,
str_to_time(auto_spins[chat]),
context=chat)
auto_spin_jobs.update({chat: job})
def restart_user_jobs(chat_id: int,
chat_data: Dict[str, Dict[str, Union[int, str, dict]]],
job_queue: JobQueue):
current_jobs = job_queue.get_jobs_by_name(str(chat_id))
for job in current_jobs:
job.schedule_removal()
settings = chat_data.get('settings')
assert isinstance(settings, dict)
num_of_words = settings.get('num_of_words')
str_start_time = settings.get('start_time')
str_end_time = settings.get('end_time')
assert isinstance(num_of_words, int)
assert isinstance(str_start_time, str)
assert isinstance(str_end_time, str)
start_time = time.fromisoformat(str_start_time)
end_time = time.fromisoformat(str_end_time)
time_interval = timedelta()
days = 0 if start_time <= end_time else 1
if num_of_words > 0:
time_interval = timedelta(
days=days,
hours=end_time.hour - start_time.hour,
minutes=end_time.minute - start_time.minute) / num_of_words
job_times = []
for i in range(num_of_words):
job_datetime = datetime.combine(datetime.utcnow(),
start_time) + i * time_interval
job_time = job_datetime.timetz()
job_queue.run_daily(send_word,
job_time,
context={'chat_id': chat_id},
name=str(chat_id),
job_kwargs={'misfire_grace_time': 20 * 60})
job_times.append({'time': job_time.isoformat()})
set_to_database(chat_id, 'jobs', job_times)
return num_of_words
def change_standup_job_schedule(
jobs_queue: JobQueue, time_str: str, hour: int, minute: int,
):
jobs_queue.stop()
jobs = jobs_queue.jobs()
for job in jobs:
job.schedule_removal()
DB().set_standup_time(time_str)
jobs_queue.run_daily(
callback=standup_job_handler_callback,
time=datetime.time(hour=hour, minute=minute),
days=(0, 1, 2, 3, 4),
)
jobs_queue.start()
Logger().clear()
def load_all(dispatcher: Dispatcher, job_queue: JobQueue) -> None:
from .basic import (
callback_generic,
cmd_getid,
cmd_start,
)
from .broadcast import (
callback_broadcast,
cmd_broadcast,
)
from .conversation import cmd_mention
from .elections import load_all as load_elections_handlers
from .groups import load_all as load_groups_handlers
from .rooms import (
callback_dafi,
cmd_dafi,
job_dafi,
)
from .users import load_all as load_users_handlers
tzinfo = pytz.timezone('Europe/Madrid')
# Basic
dispatcher.add_handler(
CallbackQueryHandler(callback_generic, pattern='main'))
dispatcher.add_handler(CommandHandler('getid', cmd_getid))
dispatcher.add_handler(CommandHandler('start', cmd_start))
# Broadcast
dispatcher.add_handler(
CallbackQueryHandler(callback_broadcast, pattern='broadcast'))
dispatcher.add_handler(CommandHandler('broadcast', cmd_broadcast))
# Conversation
dispatcher.add_handler(CommandHandler('mencionar', cmd_mention))
# Rooms
dispatcher.add_handler(CallbackQueryHandler(callback_dafi, pattern='dafi'))
dispatcher.add_handler(CommandHandler('dafi', cmd_dafi))
job_queue.run_daily(job_dafi, time(hour=21, minute=10, tzinfo=tzinfo))
load_elections_handlers(dispatcher)
load_groups_handlers(dispatcher)
load_users_handlers(dispatcher)
def poll_electricity_command_handler(bot: Bot, update: Update, job_queue: JobQueue, chat_data: dict):
context = {
'chat_data': chat_data,
'chat_id': update.message.chat_id
}
if 'polling_time' in chat_data:
polling_time = chat_data['polling_time']
else:
polling_time = time(8, 0, 0)
job = job_queue.run_daily(poll_electricity_bill, time=polling_time, context=context)
chat_data['job'] = job
update.message.reply_text('Poll dianfei per day!')
def auto_spin_config(bot: Bot, update: Update, args: list,
job_queue: JobQueue):
msg = update.effective_message
if len(args) == 0:
return
is_moder = core.can_change_spin_name(msg.chat_id, msg.from_user.id, bot)
cmd = args.pop(0)
if cmd == "set" and is_moder:
try:
time = args[0].split(':')
time = "{:0>2}:{:0>2}".format(time[0], time[1])
job = job_queue.run_daily(auto_spin,
core.str_to_time(time),
context=msg.chat_id)
if msg.chat_id in core.auto_spins:
core.auto_spin_jobs[msg.chat_id].schedule_removal()
except (ValueError, IndexError):
msg.reply_text(
f"Ошибка! Проверьте время на правильность и отредактируйте сообщение"
)
return
core.auto_spins.update({msg.chat_id: time})
core.auto_spin_jobs.update({msg.chat_id: job})
msg.reply_text(
f"Автоматический розыгрыш установлен на {time} GMT+0\n\n"
f"ВНИМАНИЕ! Если розыгрыш уже был проведён до того, как запустится автоматический розыгрыш, то"
f" бот не напишет ничего в чат по наступлению времени розыгрыша")
elif cmd == 'del' and is_moder:
if msg.chat_id in core.auto_spins:
core.auto_spin_jobs.pop(msg.chat_id).schedule_removal()
core.auto_spins.pop(msg.chat_id)
msg.reply_text(
"Теперь автоматический розыгрыш отключен в этом чате")
else:
msg.reply_text(
"Автоматический розыгрыш ещё не был включен в этом чате")
elif cmd == 'status':
if msg.chat_id in core.auto_spins:
msg.reply_text(f"Автоматический розыгрыш установлен в этом чате"
f" на {core.auto_spins.get(msg.chat_id)} GMT+0")
else:
msg.reply_text("Автоматический розыгрыш отключен в этом чате")
def run_job(queue: JobQueue, message: ScheduledMessage, chat_id: int):
if message.period == 'daily':
insert_job_to_jobs(
chat_id,
queue.run_daily(
create_scheduled_message_callback(chat_id, message),
message.start_day.time()))
elif message.period == 'monthly':
insert_job_to_jobs(
chat_id,
queue.run_monthly(create_scheduled_message_callback(
chat_id, message),
message.start_day.time(),
message.start_day.date().day,
day_is_strict=False))
elif message.period == 'once':
insert_job_to_jobs(
chat_id,
queue.run_once(create_scheduled_message_callback(chat_id, message),
message.start_day))
else:
raise RuntimeError("Something strange happen")
def setup():
bot = Bot(token=conf['BOT_TOKEN'])
update_queue = Queue()
dp = Dispatcher(bot, update_queue)
jq = JobQueue(bot)
# Commands for admin
dp.add_handler(CommandHandler('start', start))
dp.add_handler(
CommandHandler('apod',
apod,
pass_args=True,
filters=Filters.user(username=conf['ADMIN'])))
dp.add_handler(
CommandHandler('epic',
epic,
pass_args=True,
filters=Filters.user(username=conf['ADMIN'])))
dp.add_handler(
CommandHandler('mars',
mars_photos,
pass_args=True,
filters=Filters.user(username=conf['ADMIN'])))
dp.add_handler(
CommandHandler('db',
test_db_command,
filters=Filters.user(username=conf['ADMIN'])))
dp.add_error_handler(error)
#
jq.run_repeating(check_apod_updates,
interval=3600,
first=0,
context=make_apod_context(bot, TESTING))
jq.run_repeating(check_epic_updates,
interval=3600,
first=15 if TESTING else 500,
context=make_epic_context(bot, TESTING))
jq.run_daily(check_mars_photos_updates,
time=time(9),
context={
'Curiosity': 2320,
'Opportunity': 5111,
'Spirit': 2208,
'all': ['Curiosity', 'Opportunity', 'Spirit']
})
s = bot.set_webhook(
url='https://salty-escarpment-89606.herokuapp.com/hook/' +
conf['BOT_TOKEN'])
if s:
print(s)
logger.info('webhook setup ok')
else:
print(s)
logger.info('webhook setup failed')
thread = Thread(target=dp.start, name='dispatcher')
thread.start()
jq.start()
return update_queue, bot
class JobQueueTest(BaseTest, unittest.TestCase):
"""
This object represents Tests for Updater, Dispatcher, WebhookServer and
WebhookHandler
"""
def setUp(self):
self.jq = JobQueue(MockBot('jobqueue_test'))
self.jq.start()
self.result = 0
self.job_time = 0
def tearDown(self):
if self.jq is not None:
self.jq.stop()
def job1(self, bot, job):
self.result += 1
def job2(self, bot, job):
raise Exception("Test Error")
def job3(self, bot, job):
self.result += 1
job.schedule_removal()
def job4(self, bot, job):
self.result += job.context
def job5(self, bot, job):
self.job_time = time.time()
def test_basic(self):
self.jq.put(Job(self.job1, 0.1))
sleep(1.5)
self.assertGreaterEqual(self.result, 10)
def test_job_with_context(self):
self.jq.put(Job(self.job4, 0.1, context=5))
sleep(1.5)
self.assertGreaterEqual(self.result, 50)
def test_noRepeat(self):
self.jq.put(Job(self.job1, 0.1, repeat=False))
sleep(0.5)
self.assertEqual(1, self.result)
def test_nextT(self):
self.jq.put(Job(self.job1, 0.1), next_t=0.5)
sleep(0.45)
self.assertEqual(0, self.result)
sleep(0.1)
self.assertEqual(1, self.result)
def test_multiple(self):
self.jq.put(Job(self.job1, 0.1, repeat=False))
self.jq.put(Job(self.job1, 0.2, repeat=False))
self.jq.put(Job(self.job1, 0.4))
sleep(1)
self.assertEqual(4, self.result)
def test_disabled(self):
j0 = Job(self.job1, 0.1)
j1 = Job(self.job1, 0.2)
self.jq.put(j0)
self.jq.put(Job(self.job1, 0.4))
self.jq.put(j1)
j0.enabled = False
j1.enabled = False
sleep(1)
self.assertEqual(2, self.result)
def test_schedule_removal(self):
j0 = Job(self.job1, 0.1)
j1 = Job(self.job1, 0.2)
self.jq.put(j0)
self.jq.put(Job(self.job1, 0.4))
self.jq.put(j1)
j0.schedule_removal()
j1.schedule_removal()
sleep(1)
self.assertEqual(2, self.result)
def test_schedule_removal_from_within(self):
self.jq.put(Job(self.job1, 0.4))
self.jq.put(Job(self.job3, 0.2))
sleep(1)
self.assertEqual(3, self.result)
def test_longer_first(self):
self.jq.put(Job(self.job1, 0.2, repeat=False))
self.jq.put(Job(self.job1, 0.1, repeat=False))
sleep(0.15)
self.assertEqual(1, self.result)
def test_error(self):
self.jq.put(Job(self.job2, 0.1))
self.jq.put(Job(self.job1, 0.2))
sleep(0.5)
self.assertEqual(2, self.result)
def test_jobs_tuple(self):
self.jq.stop()
jobs = tuple(Job(self.job1, t) for t in range(5, 25))
for job in jobs:
self.jq.put(job)
self.assertTupleEqual(jobs, self.jq.jobs())
def test_inUpdater(self):
u = Updater(bot="MockBot")
u.job_queue.start()
try:
u.job_queue.put(Job(self.job1, 0.5))
sleep(0.75)
self.assertEqual(1, self.result)
u.stop()
sleep(2)
self.assertEqual(1, self.result)
finally:
u.stop()
def test_time_unit_int(self):
# Testing seconds in int
delta = 2
expected_time = time.time() + delta
self.jq.put(Job(self.job5, delta, repeat=False))
sleep(2.5)
self.assertAlmostEqual(self.job_time, expected_time, delta=0.1)
def test_time_unit_dt_timedelta(self):
# Testing seconds, minutes and hours as datetime.timedelta object
# This is sufficient to test that it actually works.
interval = datetime.timedelta(seconds=2)
expected_time = time.time() + interval.total_seconds()
self.jq.put(Job(self.job5, interval, repeat=False))
sleep(2.5)
self.assertAlmostEqual(self.job_time, expected_time, delta=0.1)
def test_time_unit_dt_datetime(self):
# Testing running at a specific datetime
delta = datetime.timedelta(seconds=2)
next_t = datetime.datetime.now() + delta
expected_time = time.time() + delta.total_seconds()
self.jq.put(Job(self.job5, repeat=False), next_t=next_t)
sleep(2.5)
self.assertAlmostEqual(self.job_time, expected_time, delta=0.1)
def test_time_unit_dt_time_today(self):
# Testing running at a specific time today
delta = 2
next_t = (datetime.datetime.now() +
datetime.timedelta(seconds=delta)).time()
expected_time = time.time() + delta
self.jq.put(Job(self.job5, repeat=False), next_t=next_t)
sleep(2.5)
self.assertAlmostEqual(self.job_time, expected_time, delta=0.1)
def test_time_unit_dt_time_tomorrow(self):
# Testing running at a specific time that has passed today. Since we can't wait a day, we
# test if the jobs next_t has been calculated correctly
delta = -2
next_t = (datetime.datetime.now() +
datetime.timedelta(seconds=delta)).time()
expected_time = time.time() + delta + 60 * 60 * 24
self.jq.put(Job(self.job5, repeat=False), next_t=next_t)
self.assertAlmostEqual(self.jq.queue.get(False)[0],
expected_time,
delta=0.1)
def test_run_once(self):
delta = 2
expected_time = time.time() + delta
self.jq.run_once(self.job5, delta)
sleep(2.5)
self.assertAlmostEqual(self.job_time, expected_time, delta=0.1)
def test_run_repeating(self):
interval = 0.1
first = 1.5
self.jq.run_repeating(self.job1, interval, first=first)
sleep(2.505)
self.assertAlmostEqual(self.result, 10, delta=1)
def test_run_daily(self):
delta = 1
time_of_day = (datetime.datetime.now() +
datetime.timedelta(seconds=delta)).time()
expected_time = time.time() + 60 * 60 * 24 + delta
self.jq.run_daily(self.job1, time_of_day)
sleep(2 * delta)
self.assertEqual(self.result, 1)
self.assertAlmostEqual(self.jq.queue.get(False)[0],
expected_time,
delta=0.1)
class JobQueueTest(BaseTest, unittest.TestCase):
"""
This object represents Tests for Updater, Dispatcher, WebhookServer and
WebhookHandler
"""
def setUp(self):
self.jq = JobQueue(MockBot('jobqueue_test'))
self.jq.start()
self.result = 0
self.job_time = 0
def tearDown(self):
if self.jq is not None:
self.jq.stop()
def job1(self, bot, job):
self.result += 1
def job2(self, bot, job):
raise Exception("Test Error")
def job3(self, bot, job):
self.result += 1
job.schedule_removal()
def job4(self, bot, job):
self.result += job.context
def job5(self, bot, job):
self.job_time = time.time()
def test_basic(self):
self.jq.put(Job(self.job1, 0.1))
sleep(1.5)
self.assertGreaterEqual(self.result, 10)
def test_job_with_context(self):
self.jq.put(Job(self.job4, 0.1, context=5))
sleep(1.5)
self.assertGreaterEqual(self.result, 50)
def test_noRepeat(self):
self.jq.put(Job(self.job1, 0.1, repeat=False))
sleep(0.5)
self.assertEqual(1, self.result)
def test_nextT(self):
self.jq.put(Job(self.job1, 0.1), next_t=0.5)
sleep(0.45)
self.assertEqual(0, self.result)
sleep(0.1)
self.assertEqual(1, self.result)
def test_multiple(self):
self.jq.put(Job(self.job1, 0.1, repeat=False))
self.jq.put(Job(self.job1, 0.2, repeat=False))
self.jq.put(Job(self.job1, 0.4))
sleep(1)
self.assertEqual(4, self.result)
def test_disabled(self):
j0 = Job(self.job1, 0.1)
j1 = Job(self.job1, 0.2)
self.jq.put(j0)
self.jq.put(Job(self.job1, 0.4))
self.jq.put(j1)
j0.enabled = False
j1.enabled = False
sleep(1)
self.assertEqual(2, self.result)
def test_schedule_removal(self):
j0 = Job(self.job1, 0.1)
j1 = Job(self.job1, 0.2)
self.jq.put(j0)
self.jq.put(Job(self.job1, 0.4))
self.jq.put(j1)
j0.schedule_removal()
j1.schedule_removal()
sleep(1)
self.assertEqual(2, self.result)
def test_schedule_removal_from_within(self):
self.jq.put(Job(self.job1, 0.4))
self.jq.put(Job(self.job3, 0.2))
sleep(1)
self.assertEqual(3, self.result)
def test_longer_first(self):
self.jq.put(Job(self.job1, 0.2, repeat=False))
self.jq.put(Job(self.job1, 0.1, repeat=False))
sleep(0.15)
self.assertEqual(1, self.result)
def test_error(self):
self.jq.put(Job(self.job2, 0.1))
self.jq.put(Job(self.job1, 0.2))
sleep(0.5)
self.assertEqual(2, self.result)
def test_jobs_tuple(self):
self.jq.stop()
jobs = tuple(Job(self.job1, t) for t in range(5, 25))
for job in jobs:
self.jq.put(job)
self.assertTupleEqual(jobs, self.jq.jobs())
def test_inUpdater(self):
u = Updater(bot="MockBot")
u.job_queue.start()
try:
u.job_queue.put(Job(self.job1, 0.5))
sleep(0.75)
self.assertEqual(1, self.result)
u.stop()
sleep(2)
self.assertEqual(1, self.result)
finally:
u.stop()
def test_time_unit_int(self):
# Testing seconds in int
delta = 2
expected_time = time.time() + delta
self.jq.put(Job(self.job5, delta, repeat=False))
sleep(2.5)
self.assertAlmostEqual(self.job_time, expected_time, delta=0.1)
def test_time_unit_dt_timedelta(self):
# Testing seconds, minutes and hours as datetime.timedelta object
# This is sufficient to test that it actually works.
interval = datetime.timedelta(seconds=2)
expected_time = time.time() + interval.total_seconds()
self.jq.put(Job(self.job5, interval, repeat=False))
sleep(2.5)
self.assertAlmostEqual(self.job_time, expected_time, delta=0.1)
def test_time_unit_dt_datetime(self):
# Testing running at a specific datetime
delta = datetime.timedelta(seconds=2)
next_t = datetime.datetime.now() + delta
expected_time = time.time() + delta.total_seconds()
self.jq.put(Job(self.job5, repeat=False), next_t=next_t)
sleep(2.5)
self.assertAlmostEqual(self.job_time, expected_time, delta=0.1)
def test_time_unit_dt_time_today(self):
# Testing running at a specific time today
delta = 2
next_t = (datetime.datetime.now() + datetime.timedelta(seconds=delta)).time()
expected_time = time.time() + delta
self.jq.put(Job(self.job5, repeat=False), next_t=next_t)
sleep(2.5)
self.assertAlmostEqual(self.job_time, expected_time, delta=0.1)
def test_time_unit_dt_time_tomorrow(self):
# Testing running at a specific time that has passed today. Since we can't wait a day, we
# test if the jobs next_t has been calculated correctly
delta = -2
next_t = (datetime.datetime.now() + datetime.timedelta(seconds=delta)).time()
expected_time = time.time() + delta + 60 * 60 * 24
self.jq.put(Job(self.job5, repeat=False), next_t=next_t)
self.assertAlmostEqual(self.jq.queue.get(False)[0], expected_time, delta=0.1)
def test_run_once(self):
delta = 2
expected_time = time.time() + delta
self.jq.run_once(self.job5, delta)
sleep(2.5)
self.assertAlmostEqual(self.job_time, expected_time, delta=0.1)
def test_run_repeating(self):
interval = 0.1
first = 1.5
self.jq.run_repeating(self.job1, interval, first=first)
sleep(2.505)
self.assertAlmostEqual(self.result, 10, delta=1)
def test_run_daily(self):
delta = 1
time_of_day = (datetime.datetime.now() + datetime.timedelta(seconds=delta)).time()
expected_time = time.time() + 60 * 60 * 24 + delta
self.jq.run_daily(self.job1, time_of_day)
sleep(2 * delta)
self.assertEqual(self.result, 1)
self.assertAlmostEqual(self.jq.queue.get(False)[0], expected_time, delta=0.1)
ec.eventRemove,
pass_groups=True)
dispatcher.add_handler(eventRemove_handler)
event_handler = CommandHandler('event',
ec.eventAdd,
pass_args=True,
allow_edited=True)
dispatcher.add_handler(event_handler)
eventInfo_handler = RegexHandler('\/info_*', ec.eventInfo, pass_groups=True)
dispatcher.add_handler(eventInfo_handler)
logging.info('Events commands loaded correctly.')
#Jobs (Scheduler)
job_queue = JobQueue(updater.bot)
job_queue.run_daily(rmr.birthdayReminder,
time(hour=8, minute=0, second=0),
name='birthdayReminderJob')
job_queue.run_daily(rmr.eventReminder,
time(hour=20, minute=0, second=0),
name='eventWeeklyReminderJob',
context={
'monthly': False,
'weekly': True,
'daily': False,
'hourly': False
},
days=(6, ))
job_queue.run_daily(rmr.eventReminder,
time(hour=8, minute=0, second=0),
name='eventDailyReminderJob',
context={
chat_id_handler = CommandHandler('chatid', get_your_chat_id)
walletbalance_handler = CommandHandler('walletbalance', walletbalance)
networkinfo_handler = CommandHandler('networkinfo', networkinfo)
getinfo_handler = CommandHandler('getinfo', getinfo)
listpeers_handler = CommandHandler('listpeers', listpeers)
peeraliases_handler = CommandHandler('peeraliases', peeraliases)
networkcapacity_handler = CommandHandler('capacity', networkcapacity)
num_nodes_handler = CommandHandler('nodes', num_nodes)
subscribe_handler = CommandHandler('subscribe', subscribe)
unsubscribe_handler = CommandHandler('unsubscribe', unsubscribe)
chart_handler = CommandHandler('chart', chart)
dispatcher.add_handler(start_handler)
dispatcher.add_handler(help_handler)
dispatcher.add_handler(chat_id_handler)
dispatcher.add_handler(walletbalance_handler)
dispatcher.add_handler(networkinfo_handler)
dispatcher.add_handler(getinfo_handler)
dispatcher.add_handler(listpeers_handler)
dispatcher.add_handler(peeraliases_handler)
dispatcher.add_handler(networkcapacity_handler)
dispatcher.add_handler(num_nodes_handler)
dispatcher.add_handler(subscribe_handler)
dispatcher.add_handler(unsubscribe_handler)
dispatcher.add_handler(chart_handler)
job_queue.run_daily(db_connection.send_update,
datetime.time(hour=18, minute=0, second=0))
job_queue.start()
updater.start_polling()
