class Telegram(Channel):
name: str = "Telegram"
updater: Updater
update: Update
last_message: str = None
def save_message(self, update: Update, context: CallbackContext):
self.update = update
self.last_message = update.message.text
def __init__(self):
self.updater = Updater(
"1647754237:AAGo-sBhgQvyyZjm6Y94_pjENirXpwmqiDE")
echo_handler = MessageHandler(Filters.text & (~Filters.command),
self.save_message)
self.updater.dispatcher.add_handler(echo_handler)
self.updater.start_polling()
def get_input(self) -> str:
last_message = self.last_message
while True:
time.sleep(1)
if last_message != self.last_message:
return self.last_message
def output(self, output: str):
self.updater.bot.send_message(chat_id=self.update.effective_chat.id,
text=output)
def main():
updater = Updater(TELEGRAM["token"])
dp = updater.dispatcher
dp.add_handler(CallbackQueryHandler(answer_callback))
updater.start_polling()
updater.idle()
def main():
TOKEN = '<YOUR TOKEN>'
updater = Updater(TOKEN, use_context=True)
dp = updater.dispatcher
dp.add_handler(CommandHandler("start", start))
dp.add_handler(CommandHandler("set", set_vars))
dp.add_handler(CommandHandler("help", help))
dp.add_handler(CommandHandler("send", b_send))
dp.add_handler(CommandHandler("show", show))
dp.add_handler(CommandHandler("exchange", exchange))
updater.start_polling()
updater.idle()
def main():
# MarioNews_bot
tg_token = get_tg_admin_token()
updater = Updater(tg_token)
updater.dispatcher.add_handler(CommandHandler('start', start))
updater.dispatcher.add_handler(CommandHandler('help', start))
updater.dispatcher.add_handler(CommandHandler('echo', echo))
updater.dispatcher.add_handler(CommandHandler('hello', hello))
updater.dispatcher.add_handler(CommandHandler('favor', favor))
updater.dispatcher.add_handler(CommandHandler('binduser', binduser, pass_args=True))
updater.start_polling()
updater.idle()
def init_bot(self):
log.debug('initiating connection to telegram bot')
updater = Updater(token=self.bot_token)
dispatcher = updater.dispatcher
handlers, error_handlers = get_handler_lists()
for handler in handlers:
log.debug('registering handler %s', repr(handler))
dispatcher.add_handler(handler)
for error_handler in error_handlers:
log.debug('registering error handler %s', repr(error_handler))
dispatcher.add_error_handler(error_handler)
updater.start_polling()
updater.idle()
def main():
db.create_tables([
File, Publication, Vote, ParsingSource, VkPhoto, Contributor, Moderator
],
safe=True)
load_parsing_sources()
updater = Updater(cfg.token)
dp = updater.dispatcher
references.set_bot_reference(updater.bot)
[dp.add_handler(handler) for handler in handlers]
dp.add_error_handler(error)
updater.start_polling()
publication_service.prepare_publications()
schedule = Schedule()
schedule.start()
updater.idle()
def start_bot_thread():
print("Start bot Thread started...")
updater = Updater(main_bot_token)
dispatcher = updater.dispatcher
# logging.basicConfig(format='%(asctime)s - %(name)s - %(levelname)s - %(message)s', level=logging.INFO)
photo = MessageHandler(Filters.photo, photo_handler)
video = MessageHandler(Filters.video, video_handler)
audio = MessageHandler(Filters.audio, audio_handler)
voice = MessageHandler(Filters.voice, voice_handler)
document = MessageHandler(Filters.document, document_handler)
view_q = CommandHandler('viewqueue', view_queue_handler)
view_c = CommandHandler('viewchannel', view_target_channel)
change_c = CommandHandler('changechannel', change_target_channel)
empty_q = CommandHandler('emptyqueue', empty_queue_handler)
delete_p = CommandHandler('deletepost',
delete_post_handler,
pass_args=True)
send_p = CommandHandler('sendpost', manual_send_handler, pass_args=True)
get_q = CommandHandler('getqueue', get_queue_handler)
get_t = CommandHandler('gettasks', get_tasks_handler)
get_t_z_d = CommandHandler('gettimediff', get_time_zone_diff_handler)
set_t_z_d = CommandHandler('settimediff',
set_time_zone_diff_handler,
pass_args=True)
dispatcher.add_handler(photo)
dispatcher.add_handler(video)
dispatcher.add_handler(audio)
dispatcher.add_handler(voice)
dispatcher.add_handler(document)
dispatcher.add_handler(view_q)
dispatcher.add_handler(view_c)
dispatcher.add_handler(change_c)
dispatcher.add_handler(empty_q)
dispatcher.add_handler(delete_p)
dispatcher.add_handler(send_p)
dispatcher.add_handler(get_q)
dispatcher.add_handler(get_t)
dispatcher.add_handler(get_t_z_d)
dispatcher.add_handler(set_t_z_d)
updater.start_polling()
print("Ending initialization of the bot...")
def __init__(self):
self.config = {"api_token": os.getenv("API_TOKEN")}
self.db = load_db()
updater = Updater(self.config["api_token"])
dp = updater.dispatcher # type: Dispatcher
dp.add_handler(WelcomeConversationHandler(self))
dp.add_handler(NewOpConversationHandler(self, updater.bot))
dp.add_handler(OrderConversationHandler(self))
dp.add_handler(CommandHandler("myorders", self.command_myorders))
dp.add_handler(ListOpportunitiesConversationHandler(self))
# Todo: /notify (marudor-only) (Benachrichtigt alle Nutzer in einer Stadt)
dp.add_handler(MessageHandler(Filters.text, self.handle_fetch_op))
dp.add_error_handler(self.handle_error)
updater.start_polling()
updater.idle()
class UpdaterTest(BaseTest, unittest.TestCase):
"""
This object represents Tests for Updater, Dispatcher, WebhookServer and
WebhookHandler
"""
def setUp(self):
self.updater = None
self.received_message = None
self.message_count = 0
self.lock = Lock()
def _setup_updater(self, *args, **kwargs):
bot = MockBot(*args, **kwargs)
self.updater = Updater(workers=2, bot=bot)
def tearDown(self):
if self.updater is not None:
self.updater.stop()
def reset(self):
self.message_count = 0
self.received_message = None
def telegramHandlerTest(self, bot, update):
self.received_message = update.message.text
self.message_count += 1
def telegramInlineHandlerTest(self, bot, update):
self.received_message = (update.inline_query,
update.chosen_inline_result)
self.message_count += 1
@run_async
def asyncHandlerTest(self, bot, update, **kwargs):
sleep(1)
with self.lock:
self.received_message = update.message.text
self.message_count += 1
def stringHandlerTest(self, bot, update):
self.received_message = update
self.message_count += 1
def regexGroupHandlerTest(self, bot, update, groups=None, groupdict=None):
self.received_message = (groups, groupdict)
self.message_count += 1
def additionalArgsTest(self, bot, update, update_queue, args):
self.received_message = update
self.message_count += 1
if args[0] == 'resend':
update_queue.put('/test5 noresend')
elif args[0] == 'noresend':
pass
def contextTest(self, bot, update, context):
self.received_message = update
self.message_count += 1
self.context = context
@run_async
def asyncAdditionalHandlerTest(self, bot, update, update_queue=None,
**kwargs):
sleep(1)
with self.lock:
if update_queue is not None:
self.received_message = update.message.text
self.message_count += 1
def errorRaisingHandlerTest(self, bot, update):
raise TelegramError(update)
def errorHandlerTest(self, bot, update, error):
self.received_message = error.message
self.message_count += 1
def test_addRemoveTelegramMessageHandler(self):
self._setup_updater('Test')
d = self.updater.dispatcher
d.addTelegramMessageHandler(
self.telegramHandlerTest)
self.updater.start_polling(0.01)
sleep(.1)
self.assertEqual(self.received_message, 'Test')
# Remove handler
d.removeTelegramMessageHandler(self.telegramHandlerTest)
self.reset()
self.updater.bot.send_messages = 1
sleep(.1)
self.assertTrue(None is self.received_message)
def test_addTelegramMessageHandlerMultipleMessages(self):
self._setup_updater('Multiple', 100)
self.updater.dispatcher.addTelegramMessageHandler(
self.telegramHandlerTest)
self.updater.start_polling(0.0)
sleep(2)
self.assertEqual(self.received_message, 'Multiple')
self.assertEqual(self.message_count, 100)
def test_addRemoveTelegramRegexHandler(self):
self._setup_updater('Test2')
d = self.updater.dispatcher
regobj = re.compile('Te.*')
self.updater.dispatcher.addTelegramRegexHandler(regobj,
self.telegramHandlerTest)
self.updater.start_polling(0.01)
sleep(.1)
self.assertEqual(self.received_message, 'Test2')
# Remove handler
d.removeTelegramRegexHandler(regobj, self.telegramHandlerTest)
self.reset()
self.updater.bot.send_messages = 1
sleep(.1)
self.assertTrue(None is self.received_message)
def test_addRemoveTelegramCommandHandler(self):
self._setup_updater('/test')
d = self.updater.dispatcher
self.updater.dispatcher.addTelegramCommandHandler(
'test', self.telegramHandlerTest)
self.updater.start_polling(0.01)
sleep(.1)
self.assertEqual(self.received_message, '/test')
# Remove handler
d.removeTelegramCommandHandler('test', self.telegramHandlerTest)
self.reset()
self.updater.bot.send_messages = 1
sleep(.1)
self.assertTrue(None is self.received_message)
def test_addRemoveUnknownTelegramCommandHandler(self):
self._setup_updater('/test2')
d = self.updater.dispatcher
self.updater.dispatcher.addUnknownTelegramCommandHandler(
self.telegramHandlerTest)
self.updater.start_polling(0.01)
sleep(.1)
self.assertEqual(self.received_message, '/test2')
# Remove handler
d.removeUnknownTelegramCommandHandler(self.telegramHandlerTest)
self.reset()
self.updater.bot.send_messages = 1
sleep(.1)
self.assertTrue(None is self.received_message)
def test_addRemoveStringRegexHandler(self):
self._setup_updater('', messages=0)
d = self.updater.dispatcher
d.addStringRegexHandler('Te.*', self.stringHandlerTest)
queue = self.updater.start_polling(0.01)
queue.put('Test3')
sleep(.1)
self.assertEqual(self.received_message, 'Test3')
# Remove handler
d.removeStringRegexHandler('Te.*', self.stringHandlerTest)
self.reset()
queue.put('Test3')
sleep(.1)
self.assertTrue(None is self.received_message)
def test_addRemoveStringCommandHandler(self):
self._setup_updater('', messages=0)
d = self.updater.dispatcher
d.addStringCommandHandler(
'test3', self.stringHandlerTest)
queue = self.updater.start_polling(0.01)
queue.put('/test3')
sleep(.1)
self.assertEqual(self.received_message, '/test3')
# Remove handler
d.removeStringCommandHandler('test3', self.stringHandlerTest)
self.reset()
queue.put('/test3')
sleep(.1)
self.assertTrue(None is self.received_message)
def test_addRemoveUnknownStringCommandHandler(self):
self._setup_updater('/test')
d = self.updater.dispatcher
d.addUnknownStringCommandHandler(
self.stringHandlerTest)
queue = self.updater.start_polling(0.01)
queue.put('/test4')
sleep(.1)
self.assertEqual(self.received_message, '/test4')
# Remove handler
d.removeUnknownStringCommandHandler(self.stringHandlerTest)
self.reset()
self.updater.bot.send_messages = 1
sleep(.1)
self.assertTrue(None is self.received_message)
def test_addRemoveErrorHandler(self):
self._setup_updater('', messages=0)
d = self.updater.dispatcher
d.addErrorHandler(self.errorHandlerTest)
queue = self.updater.start_polling(0.01)
error = TelegramError("Unauthorized.")
queue.put(error)
sleep(.1)
self.assertEqual(self.received_message, "Unauthorized.")
# Remove handler
d.removeErrorHandler(self.errorHandlerTest)
self.reset()
queue.put(error)
sleep(.1)
self.assertTrue(None is self.received_message)
def test_errorInHandler(self):
self._setup_updater('', messages=0)
d = self.updater.dispatcher
d.addStringRegexHandler('.*', self.errorRaisingHandlerTest)
self.updater.dispatcher.addErrorHandler(self.errorHandlerTest)
queue = self.updater.start_polling(0.01)
queue.put('Test Error 1')
sleep(.1)
self.assertEqual(self.received_message, 'Test Error 1')
def test_cleanBeforeStart(self):
self._setup_updater('')
d = self.updater.dispatcher
d.addTelegramMessageHandler(self.telegramHandlerTest)
self.updater.start_polling(0.01, clean=True)
sleep(.1)
self.assertEqual(self.message_count, 0)
self.assertIsNone(self.received_message)
def test_errorOnGetUpdates(self):
self._setup_updater('', raise_error=True)
d = self.updater.dispatcher
d.addErrorHandler(self.errorHandlerTest)
self.updater.start_polling(0.01)
sleep(.1)
self.assertEqual(self.received_message, "Test Error 2")
def test_addRemoveTypeHandler(self):
self._setup_updater('', messages=0)
d = self.updater.dispatcher
d.addTypeHandler(dict, self.stringHandlerTest)
queue = self.updater.start_polling(0.01)
payload = {"Test": 42}
queue.put(payload)
sleep(.1)
self.assertEqual(self.received_message, payload)
# Remove handler
d.removeTypeHandler(dict, self.stringHandlerTest)
self.reset()
queue.put(payload)
sleep(.1)
self.assertTrue(None is self.received_message)
def test_addRemoveInlineHandlerQuery(self):
print('Testing add/removeInlineHandler')
self._setup_updater('', messages=0)
d = self.updater.dispatcher
d.addTelegramInlineHandler(self.telegramInlineHandlerTest)
queue = self.updater.start_polling(0.01)
update = Update(update_id=0, inline_query="testquery")
update2 = Update(update_id=0, chosen_inline_result="testresult")
queue.put(update)
sleep(.1)
self.assertEqual(self.received_message[0], "testquery")
queue.put(update2)
sleep(.1)
self.assertEqual(self.received_message[1], "testresult")
# Remove handler
d.removeTelegramInlineHandler(self.telegramInlineHandlerTest)
self.reset()
queue.put(update)
sleep(.1)
self.assertTrue(None is self.received_message)
def test_runAsync(self):
self._setup_updater('Test5', messages=2)
d = self.updater.dispatcher
d.addTelegramMessageHandler(
self.asyncHandlerTest)
self.updater.start_polling(0.01)
sleep(1.2)
self.assertEqual(self.received_message, 'Test5')
self.assertEqual(self.message_count, 2)
def test_additionalArgs(self):
self._setup_updater('', messages=0)
self.updater.dispatcher.addStringCommandHandler(
'test5', self.additionalArgsTest)
queue = self.updater.start_polling(0.01)
queue.put('/test5 resend')
sleep(.1)
self.assertEqual(self.received_message, '/test5 noresend')
self.assertEqual(self.message_count, 2)
def test_context(self):
context = "context_data"
self._setup_updater('', messages=0)
self.updater.dispatcher.addStringCommandHandler(
'test_context', self.contextTest)
queue = self.updater.start_polling(0.01)
queue.put('/test_context', context=context)
sleep(.5)
self.assertEqual(self.received_message, '/test_context')
self.assertEqual(self.message_count, 1)
self.assertEqual(self.context, context)
def test_regexGroupHandler(self):
self._setup_updater('', messages=0)
d = self.updater.dispatcher
d.addStringRegexHandler('^(This).*?(?P<testgroup>regex group).*',
self.regexGroupHandlerTest)
queue = self.updater.start_polling(0.01)
queue.put('This is a test message for regex group matching.')
sleep(.1)
self.assertEqual(self.received_message, (('This', 'regex group'),
{'testgroup': 'regex group'}))
def test_runAsyncWithAdditionalArgs(self):
self._setup_updater('Test6', messages=2)
d = self.updater.dispatcher
d.addTelegramMessageHandler(
self.asyncAdditionalHandlerTest)
self.updater.start_polling(0.01)
sleep(1.2)
self.assertEqual(self.received_message, 'Test6')
self.assertEqual(self.message_count, 2)
def test_webhook(self):
self._setup_updater('', messages=0)
d = self.updater.dispatcher
d.addTelegramMessageHandler(
self.telegramHandlerTest)
ip = '127.0.0.1'
port = randrange(1024, 49152) # Select random port for travis
self.updater.start_webhook(ip, port,
url_path='TOKEN',
cert='./tests/test_updater.py',
key='./tests/test_updater.py')
sleep(0.5)
# SSL-Wrapping will fail, so we start the server without SSL
Thread(target=self.updater.httpd.serve_forever).start()
# Now, we send an update to the server via urlopen
message = Message(1, User(1, "Tester"), datetime.now(),
Chat(1, "group", title="Test Group"))
message.text = "Webhook Test"
update = Update(1)
update.message = message
self._send_webhook_msg(ip, port, update.to_json(), 'TOKEN')
sleep(1)
self.assertEqual(self.received_message, 'Webhook Test')
print("Test other webhook server functionalities...")
response = self._send_webhook_msg(ip, port, None, 'webookhandler.py')
self.assertEqual(b'', response.read())
self.assertEqual(200, response.code)
response = self._send_webhook_msg(ip, port, None, 'webookhandler.py',
get_method=lambda: 'HEAD')
self.assertEqual(b'', response.read())
self.assertEqual(200, response.code)
# Test multiple shutdown() calls
self.updater.httpd.shutdown()
self.updater.httpd.shutdown()
self.assertTrue(True)
def test_webhook_no_ssl(self):
self._setup_updater('', messages=0)
d = self.updater.dispatcher
d.addTelegramMessageHandler(
self.telegramHandlerTest)
ip = '127.0.0.1'
port = randrange(1024, 49152) # Select random port for travis
self.updater.start_webhook(ip, port)
sleep(0.5)
# Now, we send an update to the server via urlopen
message = Message(1, User(1, "Tester 2"), datetime.now(),
Chat(1, 'group', title="Test Group 2"))
message.text = "Webhook Test 2"
update = Update(1)
update.message = message
self._send_webhook_msg(ip, port, update.to_json())
sleep(1)
self.assertEqual(self.received_message, 'Webhook Test 2')
def test_bootstrap_retries_success(self):
retries = 3
self._setup_updater('', messages=0, bootstrap_retries=retries)
self.updater._set_webhook('path', retries)
self.assertEqual(self.updater.bot.bootstrap_attempts, retries)
def test_bootstrap_retries_unauth(self):
retries = 3
self._setup_updater('', messages=0, bootstrap_retries=retries,
bootstrap_err=Unauthorized())
self.assertRaises(Unauthorized, self.updater._set_webhook, 'path',
retries)
self.assertEqual(self.updater.bot.bootstrap_attempts, 1)
def test_bootstrap_retries_invalid_token(self):
retries = 3
self._setup_updater('', messages=0, bootstrap_retries=retries,
bootstrap_err=InvalidToken())
self.assertRaises(InvalidToken, self.updater._set_webhook, 'path',
retries)
self.assertEqual(self.updater.bot.bootstrap_attempts, 1)
def test_bootstrap_retries_fail(self):
retries = 1
self._setup_updater('', messages=0, bootstrap_retries=retries)
self.assertRaisesRegexp(TelegramError, 'test',
self.updater._set_webhook, 'path', retries - 1)
self.assertEqual(self.updater.bot.bootstrap_attempts, 1)
def test_webhook_invalid_posts(self):
self._setup_updater('', messages=0)
ip = '127.0.0.1'
port = randrange(1024, 49152) # select random port for travis
thr = Thread(target=self.updater._start_webhook,
args=(ip, port, '', None, None, 0, None))
thr.start()
sleep(0.5)
try:
with self.assertRaises(HTTPError) as ctx:
self._send_webhook_msg(ip, port,
'<root><bla>data</bla></root>',
content_type='application/xml')
self.assertEqual(ctx.exception.code, 403)
with self.assertRaises(HTTPError) as ctx:
self._send_webhook_msg(ip, port, 'dummy-payload',
content_len=-2)
self.assertEqual(ctx.exception.code, 403)
# TODO: prevent urllib or the underlying from adding content-length
# with self.assertRaises(HTTPError) as ctx:
# self._send_webhook_msg(ip, port, 'dummy-payload',
# content_len=None)
# self.assertEqual(ctx.exception.code, 411)
with self.assertRaises(HTTPError) as ctx:
self._send_webhook_msg(ip, port, 'dummy-payload',
content_len='not-a-number')
self.assertEqual(ctx.exception.code, 403)
finally:
self.updater._stop_httpd()
thr.join()
def _send_webhook_msg(self, ip, port, payload_str, url_path='',
content_len=-1, content_type='application/json',
get_method=None):
headers = {
'content-type': content_type,
}
if not payload_str:
content_len = None
payload = None
else:
payload = bytes(payload_str, encoding='utf-8')
if content_len == -1:
content_len = len(payload)
if content_len is not None:
headers['content-length'] = str(content_len)
url = 'http://{ip}:{port}/{path}'.format(ip=ip, port=port,
path=url_path)
req = Request(url, data=payload, headers=headers)
if get_method is not None:
req.get_method = get_method
return urlopen(req)
def signalsender(self):
sleep(0.5)
os.kill(os.getpid(), signal.SIGTERM)
def test_idle(self):
self._setup_updater('Test6', messages=0)
self.updater.start_polling(poll_interval=0.01)
Thread(target=self.signalsender).start()
self.updater.idle()
# If we get this far, idle() ran through
sleep(1)
self.assertFalse(self.updater.running)
def test_createBot(self):
updater = Updater('123:abcd')
self.assertIsNotNone(updater.bot)
def test_mutualExclusiveTokenBot(self):
bot = Bot('123:zyxw')
self.assertRaises(ValueError, Updater, token='123:abcd', bot=bot)
def test_noTokenOrBot(self):
self.assertRaises(ValueError, Updater)
# getting the dispatcher required to handle the command /start and send message back to the user
# documentation: https://python-telegram-bot.readthedocs.io/en/latest/telegram.ext.dispatcher.html#telegram.ext.Dispatcher
dispatcher: Dispatcher = updater.dispatcher
def start(update: Update, context: CallbackContext):
"""
the callback for handling start command
"""
# getting the bot from context
# documentation: https://python-telegram-bot.readthedocs.io/en/latest/telegram.bot.html#telegram-bot
bot: Bot = context.bot
# sending message to the chat from where it has received the message
# documentation: https://python-telegram-bot.readthedocs.io/en/latest/telegram.bot.html#telegram.Bot.send_message
bot.send_message(chat_id=update.effective_chat.id,
text="You have just entered start command")
# register a handler (here command handler)
# documentation: https://python-telegram-bot.readthedocs.io/en/latest/telegram.ext.dispatcher.html#telegram.ext.Dispatcher.add_handler
dispatcher.add_handler(
# it can accept all the telegram.ext.Handler, CommandHandler inherits Handler class
# documentation: https://python-telegram-bot.readthedocs.io/en/latest/telegram.ext.commandhandler.html#telegram-ext-commandhandler
CommandHandler("start", start))
# starting polling updates from Telegram
# documentation: https://python-telegram-bot.readthedocs.io/en/latest/telegram.ext.updater.html#telegram.ext.Updater.start_polling
updater.start_polling()
class TelegramManager(Component):
INTERCOM_MESSAGE_EVENT_CHAT_START = 'telegram-event-chat-start'
INTERCOM_MESSAGE_EVENT_CHAT_MESSAGE = 'telegram-event-chat-message'
INTERCOM_MESSAGE_DO_VIDEO_MESSAGE = 'telegram-do-video-message'
INTERCOM_MESSAGE_DO_PHOTO_MESSAGE = 'telegram-do-photo-message'
INTERCOM_MESSAGE_DO_DOCUMENT_MESSAGE = 'telegram-do-document-message'
INTERCOM_MESSAGE_DO_CHAT_MESSAGE = 'telegram-do-chat-message'
INTERCOM_MESSAGE_DO_SEND_CAM_SNAPSHOT = 'telegram-do-send-cam-snapshot'
INTERCOM_MESSAGE_DO_SEND_CAM_VIDEO = 'telegram-do-send-cam-video'
_allowed_users = []
_token = None
_current_token = None
_updater = None
_bot = None
_runtime_file_mutex = Lock()
_chat_ids = {}
def _get_settings_file(cls):
return App.get_settings_path() + '/telegram.yml'
def _get_runtime_file(cls):
return App.get_settings_path() + '/telegram_runtime.yml'
def _load_runtime(self):
self._chat_ids = {}
runtime_file = self._get_runtime_file()
try:
runtime = yaml.load(open(runtime_file, 'r'))
Log.info("Loading runtime from " + runtime_file)
except:
Log.error("Loading runtime failed from " + runtime_file)
return
self._chat_ids = runtime['chat_ids']
def _save_runtime(self):
runtime_file = self._get_runtime_file()
runtime = {'chat_ids': self._chat_ids}
self._runtime_file_mutex.acquire()
yaml.dump(runtime, open(runtime_file, 'w'), default_flow_style=False)
self._runtime_file_mutex.release()
def _add_chat_id(self, user, chat_id):
must_save = (user not in self._chat_ids
or self._chat_ids[user] != chat_id)
self._chat_ids[user] = chat_id
if must_save:
self._save_runtime()
def get_variables(self):
if self.get_bot() is not None:
return {
'telegram_bot_name': self.get_bot().username,
'telegram_bot_first_name': self.get_bot().first_name,
'telegram_bot_last_name': self.get_bot().last_name,
}
else:
return {}
def load_settings(self):
self._allowed_users = []
settings_file = self._get_settings_file()
try:
settings = yaml.load(open(settings_file, 'r'))
Log.info("Loading settings from " + settings_file)
except:
Log.error("Loading settings failed from " + settings_file)
return
self._token = settings['token']
self._allowed_users = settings['users']
def get_is_allowed_message(self, update: Update):
"""
Return true if user is allowed to send messages
:param update:
:return:
"""
return update.message.from_user.username in self._allowed_users
def get_bot(self) -> Bot:
return self._bot
def get_chat_id(self, username):
if username not in self._chat_ids:
return None
return self._chat_ids[username]
def send_message(self, text, recipients=None):
if recipients is None:
recipients = self._allowed_users
for recipient in recipients:
chat_id = self.get_chat_id(recipient)
if chat_id is not None:
self.get_bot().sendMessage(chat_id, text)
else:
Log.error('Unknown chat ID for user ' + recipient +
', please send a message to this bot')
def send_picture(self, file_name, caption=None, recipients=None):
if file_name is None:
return
try:
if recipients is None:
recipients = self._allowed_users
for recipient in recipients:
chat_id = self.get_chat_id(recipient)
if chat_id is not None:
self.get_bot().sendPhoto(chat_id=chat_id,
photo=open(file_name, 'rb'),
caption=caption)
else:
Log.error('Unknown chat ID for user ' + recipient +
', please send a message to this bot')
except telegram.error.BadRequest:
pass
except FileNotFoundError:
Log.error('File ' + file_name + ' not found')
def send_video(self, file, caption=None, recipients=None):
if file is None:
return
try:
if recipients is None:
recipients = self._allowed_users
for recipient in recipients:
chat_id = self.get_chat_id(recipient)
if chat_id is not None:
self.get_bot().sendDocument(
chat_id=chat_id,
document=open(file, 'rb'),
filename=os.path.basename(file),
caption=caption)
else:
Log.error('Unknown chat ID for user ' + recipient +
', please send a message to this bot')
except telegram.error.BadRequest:
pass
except FileNotFoundError:
Log.error('File ' + file + ' not found')
send_document = send_video
def _on_intercom_message_send_chat(self, message: Message) -> Reply:
payload = message.message_payload
recipients = None
if 'to' in payload:
recipients = re.split(r'\s*,\s*', payload['to'])
self.send_message(text=payload['text'], recipients=recipients)
return Reply(Reply.INTERCOM_STATUS_SUCCESS)
def _send_cam_snapshot(self, cam: Cam, recipients):
cam_snapshot = self.send_intercom_message(
CamManager.INTERCOM_MESSAGE_DO_SNAPSHOT, {'cam': cam})
if cam_snapshot != Reply.INTERCOM_STATUS_SUCCESS:
return
caption = CamRepo.get_by_code(cam).name
reply_payload = cam_snapshot.get_payload()
for from_component, component_payload in reply_payload.items():
if component_payload['status'] == Reply.INTERCOM_STATUS_SUCCESS and \
from_component == CamManager.get_instance().get_code():
file_name = component_payload['payload']['filename']
# Async upload
threading.Thread(target=self.send_picture,
kwargs={
'file_name': file_name,
'caption': caption,
'recipients': recipients,
}).start()
def _send_cam_video(self, cam: Cam, recipients, duration):
res = self.send_intercom_message(
CamManager.INTERCOM_MESSAGE_DO_VIDEO_START, {'cam': cam})
if res != Reply.INTERCOM_STATUS_SUCCESS:
return
time.sleep(duration)
res = self.send_intercom_message(
CamManager.INTERCOM_MESSAGE_DO_VIDEO_STOP, {'cam': cam})
if res != Reply.INTERCOM_STATUS_SUCCESS:
return
caption = CamRepo.get_by_code(cam).name
reply_payload = res.get_payload()
for from_component, component_payload in reply_payload.items():
if component_payload['status'] == Reply.INTERCOM_STATUS_SUCCESS and \
from_component == CamManager.get_instance().get_code():
file_name = component_payload['payload']['filename']
# Async upload
threading.Thread(target=self.send_video,
kwargs={
'file_name': file_name,
'caption': caption,
'recipients': recipients,
}).start()
def _on_cam_action(self, message: Message) -> Reply:
payload = message.message_payload
cams = payload['cam'].split(',')
for cam in cams:
recipients = None
if 'to' in payload:
recipients = re.split(r'\s*,\s*', payload['to'])
if message == self.INTERCOM_MESSAGE_DO_SEND_CAM_SNAPSHOT:
self._send_cam_snapshot(cam=cam, recipients=recipients)
elif message == self.INTERCOM_MESSAGE_DO_SEND_CAM_VIDEO:
duration = 10
if 'duration' in message.message_payload:
duration = message.message_payload['duration']
self._send_cam_video(cam=cam,
recipients=recipients,
duration=duration)
return Reply(Reply.INTERCOM_STATUS_SUCCESS)
def _on_intercom_message_cam_action(self, message: Message) -> Reply:
payload = message.message_payload
cams = payload['cam'].split(',')
for cam in cams:
recipients = None
if 'to' in payload:
recipients = re.split(r'\s*,\s*', payload['to'])
# Async images send
threading.Thread(target=self._on_cam_action,
kwargs={
'cam': cam,
'recipients': recipients
}).start()
return Reply(Reply.INTERCOM_STATUS_SUCCESS)
def _on_intercom_message_complex_message(self, message: Message) -> Reply:
payload = message.message_payload
filename = message.message_payload['filename']
if not os.path.isfile(filename) or not App.can_access_file(filename):
return Reply(Reply.INTERCOM_STATUS_NON_BLOCKING_FAILURE)
caption = os.path.basename()
if 'caption' in message.message_payload:
caption = message.message_payload[filename]
recipients = None
if 'to' in payload:
recipients = re.split(r'\s*,\s*', payload['to'])
if message == self.INTERCOM_MESSAGE_DO_PHOTO_MESSAGE:
self.send_picture(file_name=filename,
caption=caption,
recipients=recipients)
elif message == self.INTERCOM_MESSAGE_DO_VIDEO_MESSAGE:
self.send_video(file=filename,
caption=caption,
recipients=recipients)
elif message == self.INTERCOM_MESSAGE_DO_DOCUMENT_MESSAGE:
self.send_video(file=filename,
caption=caption,
recipients=recipients)
return Reply(Reply.INTERCOM_STATUS_SUCCESS)
def _on_intercom_message(self, message: Message) -> Reply:
if message == self.INTERCOM_MESSAGE_DO_CHAT_MESSAGE:
return self._on_intercom_message_send_chat(message)
if message in [
self.INTERCOM_MESSAGE_DO_SEND_CAM_SNAPSHOT,
self.INTERCOM_MESSAGE_DO_SEND_CAM_VIDEO
]:
return self._on_cam_action(message)
if message in [
self.INTERCOM_MESSAGE_DO_PHOTO_MESSAGE,
self.INTERCOM_MESSAGE_DO_VIDEO_MESSAGE,
self.INTERCOM_MESSAGE_DO_DOCUMENT_MESSAGE
]:
return self._on_intercom_message_complex_message(message)
return Component._on_intercom_message(self, message)
def _get_update_info_for_payload(self, update: Update):
return {
'from': update.message.from_user.username,
'from_first_name': update.message.from_user.first_name,
'from_last_name': update.message.from_user.last_name,
'text': update.message.text,
}
def _on_command_start(self, bot: Bot, update: Update):
self._add_chat_id(update.message.from_user.username,
update.message.chat_id)
if self.get_is_allowed_message(update):
self.send_intercom_message(
self.INTERCOM_MESSAGE_EVENT_CHAT_START,
self._get_update_info_for_payload(update))
def _on_message(self, bot: Bot, update: Update):
self._add_chat_id(update.message.from_user.username,
update.message.chat_id)
if self.get_is_allowed_message(update):
self.send_intercom_message(
self.INTERCOM_MESSAGE_EVENT_CHAT_MESSAGE,
self._get_update_info_for_payload(update))
def _start_bot(self):
self._updater = Updater(token=self._token)
self._bot = self._updater.bot
self._updater.dispatcher.add_handler(
CommandHandler('start', self._on_command_start))
self._updater.dispatcher.add_handler(
MessageHandler([Filters.text], self._on_message))
self._updater.start_polling()
def _stop_bot(self):
if self._updater is not None:
self._updater.stop()
del self._updater
def _reload(self):
self.load_settings()
if self._current_token != self._token:
self._current_token = self._token
self._stop_bot()
self._load_runtime()
self._start_bot()
return True
def start(self):
Component.start(self)
self.reload()
class UpdaterTest(BaseTest, unittest.TestCase):
"""
This object represents Tests for Updater, Dispatcher, WebhookServer and
WebhookHandler
"""
def setUp(self):
self.updater = None
self.received_message = None
self.message_count = 0
self.lock = Lock()
def _setup_updater(self, *args, **kwargs):
bot = MockBot(*args, **kwargs)
self.updater = Updater(workers=2, bot=bot)
def tearDown(self):
if self.updater is not None:
self.updater.stop()
def reset(self):
self.message_count = 0
self.received_message = None
def telegramHandlerTest(self, bot, update):
self.received_message = update.message.text
self.message_count += 1
def telegramInlineHandlerTest(self, bot, update):
self.received_message = (update.inline_query,
update.chosen_inline_result)
self.message_count += 1
@run_async
def asyncHandlerTest(self, bot, update, **kwargs):
sleep(1)
with self.lock:
self.received_message = update.message.text
self.message_count += 1
def stringHandlerTest(self, bot, update):
self.received_message = update
self.message_count += 1
def regexGroupHandlerTest(self, bot, update, groups=None, groupdict=None):
self.received_message = (groups, groupdict)
self.message_count += 1
def additionalArgsTest(self, bot, update, update_queue, args):
self.received_message = update
self.message_count += 1
if args[0] == 'resend':
update_queue.put('/test5 noresend')
elif args[0] == 'noresend':
pass
def contextTest(self, bot, update, context):
self.received_message = update
self.message_count += 1
self.context = context
@run_async
def asyncAdditionalHandlerTest(self,
bot,
update,
update_queue=None,
**kwargs):
sleep(1)
with self.lock:
if update_queue is not None:
self.received_message = update.message.text
self.message_count += 1
def errorRaisingHandlerTest(self, bot, update):
raise TelegramError(update)
def errorHandlerTest(self, bot, update, error):
self.received_message = error.message
self.message_count += 1
def test_addRemoveTelegramMessageHandler(self):
self._setup_updater('Test')
d = self.updater.dispatcher
d.addTelegramMessageHandler(self.telegramHandlerTest)
self.updater.start_polling(0.01)
sleep(.1)
self.assertEqual(self.received_message, 'Test')
# Remove handler
d.removeTelegramMessageHandler(self.telegramHandlerTest)
self.reset()
self.updater.bot.send_messages = 1
sleep(.1)
self.assertTrue(None is self.received_message)
def test_addTelegramMessageHandlerMultipleMessages(self):
self._setup_updater('Multiple', 100)
self.updater.dispatcher.addTelegramMessageHandler(
self.telegramHandlerTest)
self.updater.start_polling(0.0)
sleep(2)
self.assertEqual(self.received_message, 'Multiple')
self.assertEqual(self.message_count, 100)
def test_addRemoveTelegramRegexHandler(self):
self._setup_updater('Test2')
d = self.updater.dispatcher
regobj = re.compile('Te.*')
self.updater.dispatcher.addTelegramRegexHandler(
regobj, self.telegramHandlerTest)
self.updater.start_polling(0.01)
sleep(.1)
self.assertEqual(self.received_message, 'Test2')
# Remove handler
d.removeTelegramRegexHandler(regobj, self.telegramHandlerTest)
self.reset()
self.updater.bot.send_messages = 1
sleep(.1)
self.assertTrue(None is self.received_message)
def test_addRemoveTelegramCommandHandler(self):
self._setup_updater('/test')
d = self.updater.dispatcher
self.updater.dispatcher.addTelegramCommandHandler(
'test', self.telegramHandlerTest)
self.updater.start_polling(0.01)
sleep(.1)
self.assertEqual(self.received_message, '/test')
# Remove handler
d.removeTelegramCommandHandler('test', self.telegramHandlerTest)
self.reset()
self.updater.bot.send_messages = 1
sleep(.1)
self.assertTrue(None is self.received_message)
def test_addRemoveUnknownTelegramCommandHandler(self):
self._setup_updater('/test2')
d = self.updater.dispatcher
self.updater.dispatcher.addUnknownTelegramCommandHandler(
self.telegramHandlerTest)
self.updater.start_polling(0.01)
sleep(.1)
self.assertEqual(self.received_message, '/test2')
# Remove handler
d.removeUnknownTelegramCommandHandler(self.telegramHandlerTest)
self.reset()
self.updater.bot.send_messages = 1
sleep(.1)
self.assertTrue(None is self.received_message)
def test_addRemoveStringRegexHandler(self):
self._setup_updater('', messages=0)
d = self.updater.dispatcher
d.addStringRegexHandler('Te.*', self.stringHandlerTest)
queue = self.updater.start_polling(0.01)
queue.put('Test3')
sleep(.1)
self.assertEqual(self.received_message, 'Test3')
# Remove handler
d.removeStringRegexHandler('Te.*', self.stringHandlerTest)
self.reset()
queue.put('Test3')
sleep(.1)
self.assertTrue(None is self.received_message)
def test_addRemoveStringCommandHandler(self):
self._setup_updater('', messages=0)
d = self.updater.dispatcher
d.addStringCommandHandler('test3', self.stringHandlerTest)
queue = self.updater.start_polling(0.01)
queue.put('/test3')
sleep(.1)
self.assertEqual(self.received_message, '/test3')
# Remove handler
d.removeStringCommandHandler('test3', self.stringHandlerTest)
self.reset()
queue.put('/test3')
sleep(.1)
self.assertTrue(None is self.received_message)
def test_addRemoveUnknownStringCommandHandler(self):
self._setup_updater('/test')
d = self.updater.dispatcher
d.addUnknownStringCommandHandler(self.stringHandlerTest)
queue = self.updater.start_polling(0.01)
queue.put('/test4')
sleep(.1)
self.assertEqual(self.received_message, '/test4')
# Remove handler
d.removeUnknownStringCommandHandler(self.stringHandlerTest)
self.reset()
self.updater.bot.send_messages = 1
sleep(.1)
self.assertTrue(None is self.received_message)
def test_addRemoveErrorHandler(self):
self._setup_updater('', messages=0)
d = self.updater.dispatcher
d.addErrorHandler(self.errorHandlerTest)
queue = self.updater.start_polling(0.01)
error = TelegramError("Unauthorized.")
queue.put(error)
sleep(.1)
self.assertEqual(self.received_message, "Unauthorized.")
# Remove handler
d.removeErrorHandler(self.errorHandlerTest)
self.reset()
queue.put(error)
sleep(.1)
self.assertTrue(None is self.received_message)
def test_errorInHandler(self):
self._setup_updater('', messages=0)
d = self.updater.dispatcher
d.addStringRegexHandler('.*', self.errorRaisingHandlerTest)
self.updater.dispatcher.addErrorHandler(self.errorHandlerTest)
queue = self.updater.start_polling(0.01)
queue.put('Test Error 1')
sleep(.1)
self.assertEqual(self.received_message, 'Test Error 1')
def test_cleanBeforeStart(self):
self._setup_updater('')
d = self.updater.dispatcher
d.addTelegramMessageHandler(self.telegramHandlerTest)
self.updater.start_polling(0.01, clean=True)
sleep(.1)
self.assertEqual(self.message_count, 0)
self.assertIsNone(self.received_message)
def test_errorOnGetUpdates(self):
self._setup_updater('', raise_error=True)
d = self.updater.dispatcher
d.addErrorHandler(self.errorHandlerTest)
self.updater.start_polling(0.01)
sleep(.1)
self.assertEqual(self.received_message, "Test Error 2")
def test_addRemoveTypeHandler(self):
self._setup_updater('', messages=0)
d = self.updater.dispatcher
d.addTypeHandler(dict, self.stringHandlerTest)
queue = self.updater.start_polling(0.01)
payload = {"Test": 42}
queue.put(payload)
sleep(.1)
self.assertEqual(self.received_message, payload)
# Remove handler
d.removeTypeHandler(dict, self.stringHandlerTest)
self.reset()
queue.put(payload)
sleep(.1)
self.assertTrue(None is self.received_message)
def test_addRemoveInlineHandlerQuery(self):
print('Testing add/removeInlineHandler')
self._setup_updater('', messages=0)
d = self.updater.dispatcher
d.addTelegramInlineHandler(self.telegramInlineHandlerTest)
queue = self.updater.start_polling(0.01)
update = Update(update_id=0, inline_query="testquery")
update2 = Update(update_id=0, chosen_inline_result="testresult")
queue.put(update)
sleep(.1)
self.assertEqual(self.received_message[0], "testquery")
queue.put(update2)
sleep(.1)
self.assertEqual(self.received_message[1], "testresult")
# Remove handler
d.removeTelegramInlineHandler(self.telegramInlineHandlerTest)
self.reset()
queue.put(update)
sleep(.1)
self.assertTrue(None is self.received_message)
def test_runAsync(self):
self._setup_updater('Test5', messages=2)
d = self.updater.dispatcher
d.addTelegramMessageHandler(self.asyncHandlerTest)
self.updater.start_polling(0.01)
sleep(1.2)
self.assertEqual(self.received_message, 'Test5')
self.assertEqual(self.message_count, 2)
def test_additionalArgs(self):
self._setup_updater('', messages=0)
self.updater.dispatcher.addStringCommandHandler(
'test5', self.additionalArgsTest)
queue = self.updater.start_polling(0.01)
queue.put('/test5 resend')
sleep(.1)
self.assertEqual(self.received_message, '/test5 noresend')
self.assertEqual(self.message_count, 2)
def test_context(self):
context = "context_data"
self._setup_updater('', messages=0)
self.updater.dispatcher.addStringCommandHandler(
'test_context', self.contextTest)
queue = self.updater.start_polling(0.01)
queue.put('/test_context', context=context)
sleep(.5)
self.assertEqual(self.received_message, '/test_context')
self.assertEqual(self.message_count, 1)
self.assertEqual(self.context, context)
def test_regexGroupHandler(self):
self._setup_updater('', messages=0)
d = self.updater.dispatcher
d.addStringRegexHandler('^(This).*?(?P<testgroup>regex group).*',
self.regexGroupHandlerTest)
queue = self.updater.start_polling(0.01)
queue.put('This is a test message for regex group matching.')
sleep(.1)
self.assertEqual(self.received_message, (('This', 'regex group'), {
'testgroup': 'regex group'
}))
def test_runAsyncWithAdditionalArgs(self):
self._setup_updater('Test6', messages=2)
d = self.updater.dispatcher
d.addTelegramMessageHandler(self.asyncAdditionalHandlerTest)
self.updater.start_polling(0.01)
sleep(1.2)
self.assertEqual(self.received_message, 'Test6')
self.assertEqual(self.message_count, 2)
def test_webhook(self):
self._setup_updater('', messages=0)
d = self.updater.dispatcher
d.addTelegramMessageHandler(self.telegramHandlerTest)
ip = '127.0.0.1'
port = randrange(1024, 49152) # Select random port for travis
self.updater.start_webhook(ip,
port,
url_path='TOKEN',
cert='./tests/test_updater.py',
key='./tests/test_updater.py')
sleep(0.5)
# SSL-Wrapping will fail, so we start the server without SSL
Thread(target=self.updater.httpd.serve_forever).start()
# Now, we send an update to the server via urlopen
message = Message(1, User(1, "Tester"), datetime.now(),
Chat(1, "group", title="Test Group"))
message.text = "Webhook Test"
update = Update(1)
update.message = message
self._send_webhook_msg(ip, port, update.to_json(), 'TOKEN')
sleep(1)
self.assertEqual(self.received_message, 'Webhook Test')
print("Test other webhook server functionalities...")
response = self._send_webhook_msg(ip, port, None, 'webookhandler.py')
self.assertEqual(b'', response.read())
self.assertEqual(200, response.code)
response = self._send_webhook_msg(ip,
port,
None,
'webookhandler.py',
get_method=lambda: 'HEAD')
self.assertEqual(b'', response.read())
self.assertEqual(200, response.code)
# Test multiple shutdown() calls
self.updater.httpd.shutdown()
self.updater.httpd.shutdown()
self.assertTrue(True)
def test_webhook_no_ssl(self):
self._setup_updater('', messages=0)
d = self.updater.dispatcher
d.addTelegramMessageHandler(self.telegramHandlerTest)
ip = '127.0.0.1'
port = randrange(1024, 49152) # Select random port for travis
self.updater.start_webhook(ip, port)
sleep(0.5)
# Now, we send an update to the server via urlopen
message = Message(1, User(1, "Tester 2"), datetime.now(),
Chat(1, 'group', title="Test Group 2"))
message.text = "Webhook Test 2"
update = Update(1)
update.message = message
self._send_webhook_msg(ip, port, update.to_json())
sleep(1)
self.assertEqual(self.received_message, 'Webhook Test 2')
def test_bootstrap_retries_success(self):
retries = 3
self._setup_updater('', messages=0, bootstrap_retries=retries)
self.updater._set_webhook('path', retries)
self.assertEqual(self.updater.bot.bootstrap_attempts, retries)
def test_bootstrap_retries_unauth(self):
retries = 3
self._setup_updater('',
messages=0,
bootstrap_retries=retries,
bootstrap_err=Unauthorized())
self.assertRaises(Unauthorized, self.updater._set_webhook, 'path',
retries)
self.assertEqual(self.updater.bot.bootstrap_attempts, 1)
def test_bootstrap_retries_invalid_token(self):
retries = 3
self._setup_updater('',
messages=0,
bootstrap_retries=retries,
bootstrap_err=InvalidToken())
self.assertRaises(InvalidToken, self.updater._set_webhook, 'path',
retries)
self.assertEqual(self.updater.bot.bootstrap_attempts, 1)
def test_bootstrap_retries_fail(self):
retries = 1
self._setup_updater('', messages=0, bootstrap_retries=retries)
self.assertRaisesRegexp(TelegramError, 'test',
self.updater._set_webhook, 'path', retries - 1)
self.assertEqual(self.updater.bot.bootstrap_attempts, 1)
def test_webhook_invalid_posts(self):
self._setup_updater('', messages=0)
ip = '127.0.0.1'
port = randrange(1024, 49152) # select random port for travis
thr = Thread(target=self.updater._start_webhook,
args=(ip, port, '', None, None, 0, None))
thr.start()
sleep(0.5)
try:
with self.assertRaises(HTTPError) as ctx:
self._send_webhook_msg(ip,
port,
'<root><bla>data</bla></root>',
content_type='application/xml')
self.assertEqual(ctx.exception.code, 403)
with self.assertRaises(HTTPError) as ctx:
self._send_webhook_msg(ip,
port,
'dummy-payload',
content_len=-2)
self.assertEqual(ctx.exception.code, 403)
# TODO: prevent urllib or the underlying from adding content-length
# with self.assertRaises(HTTPError) as ctx:
# self._send_webhook_msg(ip, port, 'dummy-payload',
# content_len=None)
# self.assertEqual(ctx.exception.code, 411)
with self.assertRaises(HTTPError) as ctx:
self._send_webhook_msg(ip,
port,
'dummy-payload',
content_len='not-a-number')
self.assertEqual(ctx.exception.code, 403)
finally:
self.updater._stop_httpd()
thr.join()
def _send_webhook_msg(self,
ip,
port,
payload_str,
url_path='',
content_len=-1,
content_type='application/json',
get_method=None):
headers = {
'content-type': content_type,
}
if not payload_str:
content_len = None
payload = None
else:
payload = bytes(payload_str, encoding='utf-8')
if content_len == -1:
content_len = len(payload)
if content_len is not None:
headers['content-length'] = str(content_len)
url = 'http://{ip}:{port}/{path}'.format(ip=ip,
port=port,
path=url_path)
req = Request(url, data=payload, headers=headers)
if get_method is not None:
req.get_method = get_method
return urlopen(req)
def signalsender(self):
sleep(0.5)
os.kill(os.getpid(), signal.SIGTERM)
def test_idle(self):
self._setup_updater('Test6', messages=0)
self.updater.start_polling(poll_interval=0.01)
Thread(target=self.signalsender).start()
self.updater.idle()
# If we get this far, idle() ran through
sleep(1)
self.assertFalse(self.updater.running)
def test_createBot(self):
updater = Updater('123:abcd')
self.assertIsNotNone(updater.bot)
def test_mutualExclusiveTokenBot(self):
bot = Bot('123:zyxw')
self.assertRaises(ValueError, Updater, token='123:abcd', bot=bot)
def test_noTokenOrBot(self):
self.assertRaises(ValueError, Updater)
class Server:
def __init__(self):
"""Initialize the Server object for the bot
TOKEN -> API key of the bot
"""
self.TOKEN = self.read_token_from_config_file(
'./configfiles/config.cfg')
self.updater = Updater(self.TOKEN, use_context=True)
self.dispatcher: Dispatcher = self.updater.dispatcher
self.dispatcher.add_handler(CommandHandler("start", self.start))
self.dialogflow = dialogflow_endpoint.DialogFlowWrapper()
self.dispatcher.add_handler(CommandHandler("end", self.end))
self.dispatcher.add_handler(
MessageHandler(Filters.all,
self.make_response,
pass_user_data=True))
self.lm = packages.location_mapper.LocationMapper()
self.covidwrapper = packages.covid_endpoint.CovidWrapper()
def read_token_from_config_file(self, config):
""" Reads the token from the config.cfg file
config -> Location of the config.cfg file
"""
parser = cfg.ConfigParser()
parser.read(config)
return parser.get('creds', 'token')
def prefix_reply(self, responses):
"""Returns a random string from a given set of responses"""
pos = random.randint(0, len(responses) - 1)
return responses[pos]
def start(self, update: Update, context: CallbackContext):
"""Callback for start command"""
bot: Bot = context.bot
responses = ['Hi ', 'Hello ', 'Whats up ', 'How are you ']
reply = self.prefix_reply(responses) + \
update.message.from_user.first_name
bot.send_message(chat_id=update.effective_chat.id, text=reply)
responses = ['😌', '🙂']
reply = self.prefix_reply(responses)
bot.send_message(chat_id=update.effective_chat.id, text=reply)
def end(self, update: Update, context: CallbackContext):
"""Callback for end command"""
bot: Bot = context.bot
responses = [
'Nice talking you ', 'See you soon ', 'Hope you liked it ',
'Thank you for your time '
]
reply = self.prefix_reply(responses) + \
update.message.from_user.first_name
bot.send_message(chat_id=update.effective_chat.id, text=reply)
responses = ['👋', '🖖', '🙏']
reply = self.prefix_reply(responses)
bot.send_message(chat_id=update.effective_chat.id, text=reply)
def respond_text(self, update: Update, context: CallbackContext):
"""Respond to user with a text reply"""
bot: Bot = context.bot
parent_dir = os.getcwd()
dir_name = os.path.join(parent_dir, 'logfiles')
file_name = 'messages.log'
reply = self.dialogflow.process_input(
update.message.text, update.message.chat_id,
update.message.from_user.first_name)
log_reply = reply.replace('\n', ' ')
log_reply = log_reply.replace(',', ' ')
line = f'{update.message.date}, {update.message.from_user.first_name}, {update.message.from_user.last_name}, {update.message.chat_id}, {update.message.text}, {log_reply}\n'
with open(os.path.join(dir_name, file_name), 'a') as file_pointer:
file_pointer.writelines(line)
bot.send_message(chat_id=update.message.chat_id, text=reply)
def respond_images(self, update: Update, context: CallbackContext):
"""Respond to user with a image reply"""
def respond_video(self, update: Update, context: CallbackContext):
"""Respond to user with a video reply"""
def respond_sticker(self, update: Update, context: CallbackContext):
"""Respond to user with a sticker reply"""
bot: Bot = context.bot
reply = "Wait there!! I am still learning"
bot.send_message(chat_id=update.effective_chat.id, text=reply)
responses = ['🙄', '🤔', '😬', '😐']
reply = self.prefix_reply(responses)
bot.send_message(chat_id=update.effective_chat.id, text=reply)
reply = 'This is all I can understand ' + update.message.sticker.emoji
bot.send_message(chat_id=update.effective_chat.id, text=reply)
def respond_location(self, update: Update, context: CallbackContext):
"""Respond to the location sent by the user"""
bot: Bot = context.bot
coordinates = f"{update.message['location']['latitude']}, {update.message['location']['longitude']}"
lst_location = self.lm.get_location_info(coordinates)
city_name = lst_location[0]
reply = ""
confirmed_cases, active_cases, recovered, deaths = self.covidwrapper.get_district_data(
city_name)
reply += f'The details for {city_name}\nConfirmed Cases: {confirmed_cases}\nActive Cases: {active_cases}\nRecovered: {recovered}\nDeaths: {deaths}\n'
state_name = lst_location[1]
bot.send_message(chat_id=update.effective_chat.id, text=reply)
reply = ""
confirmed_cases, active_cases, recovered, deaths = self.covidwrapper.get_state_data(
state_name)
reply += f'The details for {state_name}\nConfirmed Cases: {confirmed_cases}\nActive Cases: {active_cases}\nRecovered: {recovered}\nDeaths: {deaths}\n'
bot.send_message(chat_id=update.effective_chat.id, text=reply)
reply = ""
confirmed_cases, active_cases, recovered, deaths = self.covidwrapper.get_country_data(
)
reply += f'The details for India\nConfirmed Cases: {confirmed_cases}\nActive Cases: {active_cases}\nRecovered: {recovered}\nDeaths: {deaths}\n'
bot.send_message(chat_id=update.effective_chat.id, text=reply)
def reply_to_messages(self, update: Update, context: CallbackContext):
"""Determine message type and then reply accordingly"""
bot: Bot = context.bot
if update.message.text:
self.respond_text(update, context)
elif update.message.video:
self.respond_video(update, context)
elif update.message.photo:
self.respond_images(update, context)
elif update.message.sticker:
self.respond_sticker(update, context)
elif update.message.location:
self.respond_location(update, context)
elif update.message.contact:
# Respond to contact messages
pass
def make_response(self, update: Update, context: CallbackContext):
"""Callback for making reponses to the user"""
bot: Bot = context.bot
self.reply_to_messages(update, context)
def start_server(self):
self.updater.start_polling()
class TelegramMessageHandler(object):
def __init__(self):
self.updater = Updater(
'475775136:AAFkVNGakPSCINOHKdE6jv7MKRPZXN5WoQ4') #Token
def start(self, bot, update):
update.message.reply_text('Olá {}! Seja muito bem-vindo'.format(
update.message.from_user.first_name))
time.sleep(3)
update.message.reply_text('Muito prazer, eu sou o Jay')
time.sleep(3)
update.message.reply_text(
'e estou aqui para te ajudar a conhecer São José dos Campos. \nVamos lá!? \õ/'
)
def hello(self, bot, update):
update.message.reply_text('Oi {}! É bom ter você por aqui :D'.format(
update.message.from_user.first_name))
time.sleep(2)
self.reply_text('Olha... eu garanto que você não vai se arrepender!')
def support(self, bot, update):
update.message.reply_text(
'vejo que você precisa de ajuda uma ajuda {}'.format(
update.message.from_user.first_name))
time.sleep(2)
update.message.reply_text('me diz o que precisa..')
def mess_receive_user(self, bot, update):
nbCustom = NaiveBayesCustom()
nbCustom.classifyTextFromIM(
update.message.text) # self.get_last_mess()
place = nbCustom.getClassification()
probMax = nbCustom.getProbMaxClassification()
#print('\nProbabilidade Máxima: ', probMax)
#print('\nClasse: ', place)
if (probMax < 0.5000):
update.message.reply_text(
'não consigo te orientar porque não entendi o que vc quis dizer'
)
elif (probMax >= 0.5000 and probMax < 0.7500):
update.message.reply_text('olha {}, não é certeza mas.. '.format(
update.message.from_user.first_name))
time.sleep(2)
update.message.reply_text('talvez vc vai gostar de ir no ' + place)
elif (probMax <= 0.7500 and probMax < 0.8500):
update.message.reply_text(
place + ' seria um bom lugar pra vc ir {}'.format(
update.message.from_user.first_name))
else:
update.message.reply_text(
place + ' é o lugar pra vc ir com toda certeza!'.format(
update.message.from_user.first_name))
'''
def get_last_mess(self):
messages = self.updater.bot.getUpdates()
print(len(messages))
if (len(messages) == 0):
return ''
else:
print("mensagens: ", messages)
print("Ultima msg: ", messages[len(messages)-1]['message']['text'])
return messages[len(messages)-1]['message']['text']
'''
def run_dispatcher(self):
self.updater.dispatcher.add_handler(CommandHandler(
'start', self.start))
self.updater.dispatcher.add_handler(CommandHandler(
'hello', self.hello))
self.updater.dispatcher.add_handler(
CommandHandler('support', self.support))
receive_msg_handler = MessageHandler([Filters.text],
self.mess_receive_user)
self.updater.dispatcher.add_handler(receive_msg_handler)
def start_bot(self):
self.run_dispatcher()
self.updater.start_polling()
print("\n-------------------------------------------------")
print("|\tTelegram Bot Inicialized with Success \t|")
print("-------------------------------------------------\n")
self.updater.idle()
def stop_bot(self):
self.updater.stop()
msg = json.dumps(update.message.to_dict(), indent=True)
bot.send_message(chat_id=update.message.chat_id,
parse_mode='Markdown',
text=f'```{msg}```')
def error_callback(bot, update, error):
logging.error(error)
if __name__ == '__main__':
with open('token.txt') as token_file:
token = token_file.read().strip()
updater = Updater(token)
dispatcher = updater.dispatcher
dispatcher.add_handler(CommandHandler('start', start_cmd))
dispatcher.add_handler(CommandHandler('about', about_cmd))
dispatcher.add_handler(CommandHandler('help', help_cmd))
dispatcher.add_handler(CommandHandler('roll', roll_cmd, pass_args=True))
dispatcher.add_handler(CommandHandler('save', save_cmd, pass_args=True))
dispatcher.add_handler(CommandHandler('delete', delete_cmd, pass_args=True))
dispatcher.add_handler(MessageHandler(None, test))
dispatcher.add_error_handler(error_callback)
print('Starting bot...')
updater.start_polling()
