def setup(webhook_url=None): """If webhook_url is not passed, run with long-polling.""" logging.basicConfig(level=logging.WARNING) if webhook_url: bot = Bot(TOKEN) update_queue = Queue() dp = Dispatcher(bot, update_queue) else: updater = Updater( TOKEN) # Create the EventHandler and pass it your bot's token. bot = updater.bot dp = updater.dispatcher # Get the dispatcher to register handlers dp.add_handler(CommandHandler( "open", open)) # on /start command answer in Telegram dp.add_handler(CommandHandler( "bieber", bieber)) # on /help command answer in Telegram dp.add_handler(CallbackQueryHandler(button)) # log all errors dp.add_error_handler(error) # Add your handlers here if webhook_url: bot.set_webhook(webhook_url=webhook_url) thread = Thread(target=dp.start, name='dispatcher') thread.start() return update_queue, bot else: bot.set_webhook() # Delete webhook updater.start_polling() # Start the Bot """Run the bot until you press Ctrl-C or the process receives SIGINT, SIGTERM or SIGABRT. This should be used most of the time, since start_polling() is non-blocking and will stop the bot gracefully.""" updater.idle()
def run(): from .Conversation import conv_handler, cancel # importing data from database bot_db_table = Bot_Table.objects.first() token = bot_db_table.token # initializing bot = Bot(token) update_queue = Queue() BotUpdateQueue().queue = update_queue dp = Dispatcher(bot, update_queue, use_context=True) if not Captain.objects.all(): # if db does not contain captains with open("captains.txt", "r", encoding="utf-8") as in_file: # cap1_name - cap1_id, ... entries = in_file.read().replace("\n", "").split(",") for entry in entries: anagraphic, id_str = entry.split(" - ") id = int(id_str) Captain.objects.create(id=id, anagraphic=anagraphic) dp.add_handler(CommandHandler("id", get_id)) dp.add_handler(CallbackQueryHandler(cap_queue_callback)) dp.add_handler(conv_handler) dp.add_handler(CommandHandler("stop", cancel)) dp.add_error_handler(error) thread = threading.Thread(target=dp.start, name="dispatcher") thread.start() set_webhook(token)
def set_handlers(dispatcher: Dispatcher): start_handler = CommandHandler('start', start) dispatcher.add_handler(start_handler) conv_handler = ConversationHandler( entry_points=[CommandHandler('get_menu', get_menu)], states={ MENU: [MessageHandler(Filters.regex( '^({})$'.format('|'.join(get_places_name()))), button_menu)], }, fallbacks=[CommandHandler('get_menu', get_menu)], ) dispatcher.add_handler(conv_handler) caps_handler = CommandHandler('caps', caps) dispatcher.add_handler(caps_handler) inline_caps_handler = InlineQueryHandler(inline_query) dispatcher.add_handler(inline_caps_handler) collect_handler = CommandHandler('start_collect', start_collect) dispatcher.add_handler(collect_handler) stop_handler = CommandHandler('stop_collect', stop_collect) dispatcher.add_handler(stop_handler) # log all errors dispatcher.add_error_handler(error) # unknown message handler, must be the last unknown_handler = MessageHandler(Filters.command, unknown) dispatcher.add_handler(unknown_handler)
def run(self, token, webhook_url=None): if webhook_url: bot = Bot(token) update_queue = Queue() job_queue = JobQueue(bot) dp = Dispatcher(bot, update_queue, job_queue=job_queue) else: updater = Updater(token) bot = updater.bot dp = updater.dispatcher for component in self.components.values(): component.init(dp) dp.add_error_handler(self._error_handler) if webhook_url: bot.set_webhook(webhook_url=webhook_url) job_queue.start() thread = Thread(target=dp.start, name='dispatcher') thread.start() return update_queue, bot else: bot.set_webhook() updater.start_polling() updater.idle()
class BotComm(object): exposed = True def __init__(self, TOKEN, NAME): super(BotComm, self).__init__() self.TOKEN = TOKEN self.NAME=NAME self.bot = telegram.Bot(self.TOKEN) try: self.bot.setWebhook("https://{}.herokuapp.com/{}".format(self.NAME, self.TOKEN)) except: raise RuntimeError("Failed to set the webhook") self.update_queue = Queue() self.dp = Dispatcher(self.bot, self.update_queue) self.dp.add_handler(CommandHandler("start", self._start)) self.dp.add_handler(MessageHandler(Filters.text, self._echo)) self.dp.add_error_handler(self._error) @cherrypy.tools.json_in() def POST(self, *args, **kwargs): update = cherrypy.request.json update = telegram.Update.de_json(update, self.bot) self.dp.process_update(update) def _error(self, error): cherrypy.log("Error occurred - {}".format(error)) def _start(self, bot, update): update.effective_message.reply_text("Hi!") def _echo(self, bot, update): update.effective_message.reply_text(update.effective_message.text)
class Bot(BotCommand): def __init__(self, token=None): super().__init__() self.TOKEN = token or os.environ.get('TOKEN') self.telegram_bot = telegram.Bot(token=self.TOKEN) update_queue = Queue() self.dp = Dispatcher(self.telegram_bot, update_queue) self.dp = self.add_update_handlers(self.dp) # log all errors self.dp.add_error_handler(error) def add_update_handlers(self, dp): # Create the EventHandler and pass it your bot's token. # on different commands - answer in Telegram dp.add_handler(CommandHandler("start", self.start)) dp.add_handler(RegexHandler('^(Понедельник|Вторник|Среда|Четверг|Пятница|Суббота)$', self.regular_choice)) dp.add_handler(RegexHandler('^Скрыть$', self.done)) dp.add_handler(CommandHandler("help", self.help_message)) dp.add_handler(CommandHandler("set", self.set_group, pass_args=True)) dp.add_handler(CommandHandler("week", self.lessons_week, pass_args=True)) dp.add_handler(CommandHandler("nextweek", self.lessons_next_week, pass_args=True)) dp.add_handler(CommandHandler("full", self.full_weeks, pass_args=True)) dp.add_handler(CommandHandler("today", self.lessons_today, pass_args=True)) dp.add_handler(CommandHandler("tomorrow", self.lessons_tomorrow, pass_args=True)) dp.add_handler(CommandHandler(["timetable", "tt"], self.call_schedule)) dp.add_handler(CommandHandler("weeknumber", self.week_number)) dp.add_handler(CommandHandler("exams", self.exams, pass_args=True)) dp.add_handler(CommandHandler('keyboard', self.keyboard_mode)) return dp
def configure_bot(dispatcher: Dispatcher): dispatcher.add_handler(CommandHandler("start", start)) dispatcher.add_handler(CommandHandler("help", help_command)) create_listener_hand = ConversationHandler( entry_points=[CommandHandler('create_listener', create_listener)], states={ ENTER_DESCRIPTION: [ MessageHandler(Filters.text & ~Filters.command, create_listener_get_description) ], }, fallbacks=[CommandHandler('cancel', cancel)]) dispatcher.add_handler(create_listener_hand) disable_listener_hand = ConversationHandler( entry_points=[CommandHandler('disable_listener', disable_listener)], states={ DISABLE_LISTENER: [CallbackQueryHandler(disable_get_listener_name)], }, fallbacks=[CommandHandler('cancel', cancel)]) dispatcher.add_handler(disable_listener_hand) dispatcher.add_error_handler(error)
def reply_text(bot, update): intent, reply = get_reply(update.message.text, update.message.chat_id) if intent == "get_news": articles = fetch_news(reply) for articles in articles: bot.send_message(chat_id=update.message.chat_id, text=article) else: bot.send_message(chat_id=update.message.chat_id, text=reply) def echo_sticker(bot, update): bot.send_sticker(chat_id=update.message.chat_id, sticker=update.message.sticker.file_id) def error(bot, update): logger.error("Update '%s' caused error '%s'", update, update.error) # def message_handler(update, context: CallbackContext): # update.message.reply_text(text) bot = Bot(TOKEN) try: bot.set_webhook("https://48c9acd55480.ngrok.io/" + TOKEN) except Exception as e: print(e) dp = Dispatcher(bot, None) dp.add_handler(CommandHandler("start", start)) dp.add_handler(CommandHandler("help", _help)) dp.add_handler(CommandHandler("news", news)) dp.add_handler(MessageHandler(Filters.text, reply_text)) dp.add_handler(MessageHandler(Filters.sticker, echo_sticker)) dp.add_error_handler(error) if __name__ == "__main__": app.run(port=8443)
def setup(webhook_url=None): """If webhook_url is not passed, run with long-polling.""" logging.basicConfig(level=logging.WARNING) if webhook_url: bot = Bot(TOKEN) update_queue = Queue() dp = Dispatcher(bot, update_queue) else: updater = Updater(TOKEN) bot = updater.bot dp = updater.dispatcher dp.add_handler(CommandHandler("start", start)) dp.add_handler(CommandHandler("help", help)) # on noncommand i.e message - echo the message on Telegram dp.add_handler(MessageHandler(Filters.text, echo)) # log all errors dp.add_error_handler(error) # Add your handlers here if webhook_url: bot.set_webhook(webhook_url=webhook_url) thread = Thread(target=dp.start, name='dispatcher') thread.start() return update_queue, bot else: bot.set_webhook() # Delete webhook updater.start_polling() updater.idle()
def run(message): bot = Bot(config.bot_token) dp = Dispatcher(bot, None, workers=0) # on different commands - answer in Telegram dp.add_handler(CommandHandler("ranking", ranking, pass_args=True)) dp.add_handler(CommandHandler("players", players, pass_args=True)) dp.add_handler(CommandHandler("player", player, pass_args=True)) dp.add_handler(CommandHandler("matchday", matchday, pass_args=True)) dp.add_handler(CommandHandler("scorers", scorers)) dp.add_handler(CommandHandler("help", help)) dp.add_handler( CommandHandler('info', info, filters=Filters.user(username='******'))) # on noncommand i.e message - echo the message on Telegram dp.add_handler(MessageHandler(Filters.text, echo)) # log all errors dp.add_error_handler(error) # inline inline_handler = InlineQueryHandler(inline) dp.add_handler(inline_handler) # decode update and try to process it update = Update.de_json(message, bot) dp.process_update(update)
class BotComm(object): exposed = True def __init__(self, TOKEN, NAME): super(BotComm, self).__init__() self.TOKEN = TOKEN self.NAME = NAME self.bot = telegram.Bot(self.TOKEN) try: self.bot.setWebhook("https://{}.herokuapp.com/{}".format( self.NAME, self.TOKEN)) except: raise RuntimeError("Failed to set the webhook") self.update_queue = Queue() self.dp = Dispatcher(self.bot, self.update_queue) self.dp.add_handler(CommandHandler("start", self._start)) self.dp.add_handler(MessageHandler(Filters.text, self._handler)) self.dp.add_error_handler(self._error) @cherrypy.tools.json_in() def POST(self, *args, **kwargs): update = cherrypy.request.json update = telegram.Update.de_json(update, self.bot) self.dp.process_update(update) def _error(self, error): cherrypy.log("Error occurred - {}".format(error)) def _start(self, bot, update): update.effective_message.reply_text("Hi!") def _handler(self, bot, update): global TOPIC global TOPIC_STATUS print("MESSAGE", update.message.chat_id, update.message.text) if update.message.text == 'kb' or update.message.text == 'keyboard': send_KB_() elif text_ON in update.message.text and text_topic[ 0] in update.message.text: mqttc.publish(TOPIC[0], "ON", 0, True) TOPIC_CHANGES[0] = 1 elif text_OFF in update.message.text and text_topic[ 0] in update.message.text: mqttc.publish(TOPIC[0], "OFF", 0, True) TOPIC_CHANGES[0] = 1 elif text_ON in update.message.text and text_topic[ 1] in update.message.text: mqttc.publish(TOPIC[1], "ON", 0, True) TOPIC_CHANGES[1] = 1 elif text_OFF in update.message.text and text_topic[ 1] in update.message.text: mqttc.publish(TOPIC[1], "OFF", 0, True) TOPIC_CHANGES[1] = 1 else: update.message.reply_text(text=update.message.text)
def register_handlers(dp: Dispatcher): for command in text_handlers: dp.add_handler( MessageHandler(Filters.regex('^/{}$'.format(command)), text_handlers[command])) dp.add_handler(MessageHandler(Filters.text, default_handler)) # log all errors dp.add_error_handler(error_handler)
def add_handlers(dispatcher: Dispatcher): for cmd in ALL: log.debug('Register command `%s`', cmd.__name__) dispatcher.add_handler(getattr(cmd, 'handler')) error = getattr(cmd, 'error_handler', None) if error is not None: log.debug('Register error handler `%s`', error.__name__) dispatcher.add_error_handler(error)
class BotDispatcher: def __init__(self): self.dispatcher = Dispatcher(bot, None, workers=0) self.dispatcher.add_handler(CommandHandler('start', start)) self.dispatcher.add_handler(CommandHandler('help', help)) self.dispatcher.add_handler(CallbackQueryHandler(button)) self.dispatcher.add_error_handler(error) def process_update(self, update): self.dispatcher.process_update(update)
def add_error_handlers(dispatcher: Dispatcher) -> bool: # Add error handlers try: dispatcher.add_error_handler(error) return True except Exception as e: logger.warning(f"Add error handlers error: {e}", exc_info=True) return False
def handle_request(bot, update): dispatcher = Dispatcher(bot, None) dispatcher.add_handler(CommandHandler('start', start)) dispatcher.add_handler(CommandHandler('help', help)) dispatcher.add_handler(CommandHandler('subscribe', subscribe)) dispatcher.add_handler(CommandHandler('unsubscribe', unsubscribe)) dispatcher.add_handler(CallbackQueryHandler(button)) dispatcher.add_error_handler(error) dispatcher.add_handler(MessageHandler(Filters.command, unknown)) dispatcher.process_update(update)
def add_handlers(self, dispatcher: Dispatcher) -> None: """Adds all ValeVistaBot handlers to 'dispatcher'.""" dispatcher.add_handler(CommandHandler("start", self.start)) dispatcher.add_handler(CommandHandler("set", self.set_rut)) dispatcher.add_handler(CommandHandler("get", self.get_rut)) dispatcher.add_handler(CommandHandler("debug", self.debug)) dispatcher.add_handler(CommandHandler("help", self.help)) dispatcher.add_handler(CommandHandler("subscribe", self.subscribe)) dispatcher.add_handler(CommandHandler("unsubscribe", self.unsubscribe)) dispatcher.add_handler(MessageHandler(Filters.text, self.msg)) dispatcher.add_error_handler(self.error)
def add_handlers(dp: Dispatcher): for list_of_handlers in list_of_list_of_handlers: for handler in list_of_handlers: if len(handler) == 1: dp.add_handler(handler[0]) elif len(handler) == 2: if isinstance(handler[1], int): dp.add_handler(handler[0], handler[1]) elif isinstance(handler[1], str): if handler[1] == 'error': dp.add_error_handler(handler[0])
def add_handlers(dp:Dispatcher): dp.add_error_handler(hs.error_handler) dp.add_handler(CommandHandler("salambrat",hs.greeting_message_handler)) dp.add_handler(CommandHandler("eledoyulyeti",hs.confirm_bro_handler)) dp.add_handler(CommandHandler("meneoyret",hs.improve_confirm_bro_handler)) dp.add_handler(CommandHandler("musuqu",hs.music_handler)) dp.add_handler(CommandHandler("musuquoyret",hs.improve_music_handler)) dp.add_handler(CommandHandler("meme",hs.random_meme_handler)) dp.add_handler(CommandHandler("info",hs.info_handler)) schedule.every(10).minutes.do(reset_all_spam_counts)
class BotComm: exposed = True def __init__(self, TOKEN, NAME): super(BotComm, self).__init__() self.TOKEN = TOKEN self.NAME = NAME self.bot = telegram.Bot(self.TOKEN) try: self.bot.setWebhook("https://{}.herokuapp.com/{}".format( self.NAME, self.TOKEN)) except: raise RuntimeError("Failed to set the webhook") self.update_queue = Queue() self.dp = Dispatcher(self.bot, self.update_queue) self.dp.add_handler(CommandHandler("start", self._start)) self.dp.add_handler(MessageHandler(Filters.text, self._process_update)) self.dp.add_error_handler(self._error) @cherrypy.tools.json_in() def POST(self, *args, **kwargs): update = cherrypy.request.json update = telegram.Update.de_json(update, self.bot) self.dp.process_update(update) def _error(self, error): cherrypy.log("Error occurred - {}".format(error)) def _start(self, bot, update): update.effective_message.reply_text( 'Милые девушки. Этот бот создан специально для вас. Сделайте заказ, например, "латте без сахара" или "черный чай с одним кусочком сахара и печенькой". А мы обеспечим оперативную доставку вашего желания прямо на ваше рабочее место' ) def _accept_order(self, bot, update): order_text = update.effective_message.text order_user = update.effective_message.from_user order_user_first_name = order_user.first_name order_user_last_name = order_user.last_name order_user_username = order_user.username text = "{first_name} {last_name} ({username}) " \ "желает: {order}".format(first_name=order_user_first_name, last_name=order_user_last_name, username=order_user_username, order=order_text) self.bot.send_message(chat_id=CHAT_ID, text=text) update.effective_message.reply_text("Ваш заказ принят!") def _process_update(self, bot, update): chat_id = update.effective_message.chat.id if not chat_id == CHAT_ID: self._accept_order(bot, update)
def get_handler(): bot = Bot(token=BOT_TOKEN) dp = Dispatcher(bot, None, workers=0) # on different commands - answer in Telegram dp.add_handler(CommandHandler("start", start)) dp.add_handler(InlineQueryHandler(inlinequery)) # log all errors dp.add_error_handler(error) return dp, bot
def setup(): '''GAE DISPATCHER SETUP''' global dispatcher dispatcher = Dispatcher(bot=bot, update_queue=None, workers=0) # ---Register handlers here--- dispatcher.add_handler(InlineQueryHandler(parseInlineQuery)) dispatcher.add_error_handler(error) return dispatcher
def setup(webhook_url=None): """If webhook_url is not passed, run with long-polling.""" logging.basicConfig(level=logging.WARNING) if webhook_url: bot = Bot(TOKEN) update_queue = Queue() dp = Dispatcher(bot, update_queue) else: updater = Updater(TOKEN) bot = updater.bot dp = updater.dispatcher dp.add_handler(CommandHandler("start", start)) dp.add_handler(CommandHandler("help", help)) dp.add_handler(CommandHandler("new_room", new_room, pass_args=True)) dp.add_handler(CommandHandler("new_bet", new_bet)) dp.add_handler(CommandHandler("remove_bet", remove_bet, pass_args=True)) dp.add_handler(CommandHandler("join", join_room, pass_args=True)) dp.add_handler(CommandHandler("bets", show_bets)) dp.add_handler(CommandHandler("close_bet", close_bet, pass_args=True)) dp.add_handler(CommandHandler("open_bet", open_bet, pass_args=True)) dp.add_handler( CommandHandler("submit_result", submit_result, pass_args=True)) dp.add_handler(CommandHandler("pred", modify_bet, pass_args=True)) dp.add_handler(CommandHandler("refill", refill_bets)) dp.add_handler(CommandHandler("show", show_predictions, pass_args=True)) dp.add_handler(CommandHandler("score_board", score_board)) dp.add_handler(CommandHandler("members", show_members)) dp.add_handler(CommandHandler("description", set_desc)) dp.add_handler(CommandHandler("delete_room", delete_room)) dp.add_handler(CommandHandler("hack", hack, pass_args=True)) dp.add_handler(CommandHandler("hack_score", hack_score, pass_args=True)) dp.add_handler(CommandHandler("hack_start", hack_start, pass_args=True)) # # on noncommand i.e message - echo the message on Telegram dp.add_handler(MessageHandler(Filters.text, echo)) # log all errors dp.add_error_handler(error) # Add your handlers here if webhook_url: bot.set_webhook(webhook_url=webhook_url) thread = Thread(target=dp.start, name='dispatcher') thread.start() return update_queue, bot else: bot.set_webhook() # Delete webhook updater.start_polling() updater.idle()
def setup(): '''GAE DISPATCHER SETUP''' global dispatcher # Note that update_queue is setted to None and # 0 workers are allowed on Google app Engine (If not-->Problems with multithreading) dispatcher = Dispatcher(bot=bot, update_queue=None, workers=0) # ---Register handlers here--- dispatcher.add_handler(CommandHandler("start", start)) dispatcher.add_handler(CommandHandler("help", help)) dispatcher.add_handler(MessageHandler([Filters.text], echo)) dispatcher.add_error_handler(error) return dispatcher
class TelegramFlask: def __init__(self, app=None): self.app = app if app is not None: self.init_app(app) def init_app(self, app): self.create_bot(app) app.extensions["telegram"] = self def create_bot(self, app): token = app.config.get("API_TOKEN") autodiscovery(app.config.get("APPS", [])) self.bot = telegram.Bot(token=token) self.dispatcher = Dispatcher(self.bot, None, workers=0) for handler in get_handlers(): self.dispatcher.add_handler(handler) # log all errors self.dispatcher.add_error_handler(self.error) def setup_webhook(self, app): domain = app.config.get("WEBHOOK_DOMAIN") path = app.config.get("WEBHOOK_PATH") webhook_url = f"https://{domain}/{path}" try: response = self.bot.get_webhook_info() except Exception: return False, "Unable to get telegram webhook" if response.url == webhook_url: return False, f"Keeping the same webhook url: {webhook_url}" try: success = self.bot.set_webhook(webhook_url) except Exception: return False, "Unable to set telegram webhook" if not success: return False, f"Unable to set telegram webhook, return: {success}" return True, f"Change webhook to the new url: {webhook_url}" @staticmethod def error(bot, update, error): """Log Errors caused by Updates.""" logger.warning('Update "%s" caused error "%s"', update, error)
def init_handlers(dispatcher: Dispatcher) -> None: """ Initializes all handlers for the bot. The handlers for the subscribe, unsubscribe and start command will be initialized in every case. The handlers for the survey and help command and for the end-survey-reminder callback will be only initialized, if the associated fields in the config are set to 'True'. If time-calculation is enabled the subscribe handler is an entry point in a conversation handler. This conversation handler handles the wakeup time query. :param dispatcher: The Dispatcher instance from the Updater :return: None """ global conversation_handler subscribe_handler = CommandHandler("subscribe", subscribe) dispatcher.add_handler(CommandHandler("unsubscribe", unsubscribe)) dispatcher.add_handler(CommandHandler("start", start)) if config_handler.config.help.helpEnabled: dispatcher.add_handler(CommandHandler("help", send_help)) if config_handler.config.surveyCommandEnabled: dispatcher.add_handler(CommandHandler("survey", send_survey)) if config_handler.config.endSurveyReminderEnabled: dispatcher.add_handler( CallbackQueryHandler(handle_end_survey_reminder_callback)) if config_handler.config.useTimeCalculation or config_handler.config.participantsEnterCondition: states: Dict[int, List[Handler]] = {} if config_handler.config.participantsEnterCondition: regex_str = "^[0-%d]$" % (config_handler.get_condition_count() - 1) regex_handler_condition = MessageHandler(Filters.regex(regex_str), subscribe_condition) states[CONDITION_STATE] = [regex_handler_condition] if config_handler.config.useTimeCalculation: regex_handler_wakeup = MessageHandler( Filters.regex("^(0[0-9]|1[0-9]|2[0-3]|[0-9]):[0-5][0-9]$"), subscribe_wakeup_time) states[TIME_STATE] = [regex_handler_wakeup] conversation_handler = ConversationHandler( entry_points=[subscribe_handler], states=states, fallbacks=[ MessageHandler(Filters.all, subscribe_wakeup_time_fallback) ]) dispatcher.add_handler(conversation_handler) else: dispatcher.add_handler(subscribe_handler) dispatcher.add_error_handler(error)
def setup(self, webhook_url=None): """If webhook_url is not passed, run with long-polling.""" logging.basicConfig(level=logging.WARNING) if webhook_url: self.bot = Bot(self.bot_token) update_queue = Queue() dp = Dispatcher(self.bot, update_queue) else: updater = Updater(self.bot_token) self.bot = updater.bot dp = updater.dispatcher dp.add_handler(CommandHandler('help', self.help)) dp.add_handler(CommandHandler('start', self.start)) dp.add_handler(CommandHandler('ongoing', self.competitions.ongoing)) dp.add_handler(CommandHandler('givememydb', self.admin.givememydb)) dp.add_handler(CommandHandler('getcfjson', self.admin.getcfjson)) dp.add_handler(CommandHandler('adminhandle', self.admin.adminhandle)) dp.add_handler(CommandHandler('adminud', self.adminupdate)) dp.add_handler(CommandHandler('adminuq', self.admqupd)) dp.add_handler(self.cf.conv_handler10) dp.add_handler(self.cc.conv_handler) dp.add_handler(self.competitions.conv_handler) dp.add_handler(self.competitions.conv_handler1) dp.add_handler(self.register.conv_handler) dp.add_handler(self.compiler.conv_handler) dp.add_handler(self.unregister.conv_handler) dp.add_handler(self.ques_of_the_day.conv_handler) dp.add_handler(self.ques_of_the_day.conv_handler1) dp.add_handler(self.ranklist.conv_handler) dp.add_handler(self.update.conv_handler) dp.add_handler(self.geeks_for_geeks.conv_handler) dp.add_handler(self.admin.conv_handler1) dp.add_handler(self.admin.conv_handler2) dp.add_handler(self.conv_handler) # log all errors dp.add_error_handler(self.error_handler) if webhook_url: self.bot.set_webhook(webhook_url=webhook_url) thread = Thread(target=dp.start, name='dispatcher') thread.start() return update_queue, self.bot else: self.bot.set_webhook() # Delete webhook updater.start_polling() updater.idle()
class MyBot: def __init__(self): self.bot = telegram.Bot(TOKEN) self.codes = dict() self.dispatcher = Dispatcher(self.bot, None, workers=0) self.add_handlers() self.set_webhook() def add_handlers(self): self.dispatcher.add_handler(CommandHandler("start", start, pass_args=True)) self.dispatcher.add_handler(CommandHandler("help", help_)) self.dispatcher.add_handler(CommandHandler("gettasks", tasks)) self.dispatcher.add_handler(MessageHandler(Filters.text, echo)) self.dispatcher.add_error_handler(error) def process_msg(self, msg): update = telegram.update.Update.de_json(msg, self.bot) self.dispatcher.process_update(update) def send_message(self, chat_id, text): self.bot.sendMessage(chat_id=chat_id, text=text, disable_web_page_preview=True) def send_mime_msg(self, chat_id, mime_msg): text_msg = repr_mime_msg(mime_msg) if len(text_msg) > 4096: text_msg = "TEXT IS TOO LONG\n\n" + text_msg log_line("Mime message was TOO LONG!") while len(text_msg) > 0: self.bot.sendMessage(chat_id=chat_id, text=text_msg[:4000], disable_web_page_preview=True, parse_mode=telegram.ParseMode.MARKDOWN) text_msg = text_msg[4000:] self.bot.sendMessage(chat_id=chat_id, text=text_msg, disable_web_page_preview=True, parse_mode=telegram.ParseMode.MARKDOWN) log_line("Mime message was sent!") def set_webhook(self): if not bool(self.bot.get_webhook_info().url): try: self.bot.setWebhook("https://{}.herokuapp.com/{}".format(NAME, TOKEN)) log_line("Webhook was set") except telegram.error.RetryAfter: log_line("telegram.error.RetryAfter WAS ENCOUNTERED :(") sleep(2) self.set_webhook()
def setup(token): # Create bot, update queue and dispatcher instances pp = PicklePersistence(filename='/tmp/conversationbot') bot = telegram.Bot(token=token) dispatcher = Dispatcher(bot, None, workers=0, use_context=True, persistence=pp) # Add conversation handler with the states GENDER, PHOTO, LOCATION and BIO conv_handler = ConversationHandler( entry_points=[CommandHandler('start', start)], allow_reentry=True, states={ CHOOSING: [ MessageHandler( Filters.regex('^(Возраст|Любимый цвет|Имя|Фамилия)$'), regular_choice), MessageHandler(Filters.regex('^Что то рандомное$'), custom_choice) ], TYPING_CHOICE: [MessageHandler(Filters.text, regular_choice)], TYPING_REPLY: [ MessageHandler(Filters.text, received_information), ], }, fallbacks=[ CommandHandler('cancel', cancel), MessageHandler(Filters.regex('^Все$'), done) ], name='my_conversation', persistent=True) dispatcher.add_handler(conv_handler) # log all errors dispatcher.add_error_handler(error) show_data_handler = CommandHandler('show_data', show_data) dispatcher.add_handler(show_data_handler) return dispatcher
def setup(webhook_url=None): """If webhook_url is not passed, run with long-polling.""" logging.basicConfig(level=logging.WARNING) if webhook_url: bot = Bot(TOKEN) update_queue = Queue() dp = Dispatcher(bot, update_queue) else: updater = Updater(TOKEN) bot = updater.bot dp = updater.dispatcher # ADMIN CONVERSATION HANDLER TO BROADCAST MESSAGES conv_handler1 = ConversationHandler( entry_points=[CommandHandler('broadcast', broadcast)], allow_reentry=True, states={BDC: [MessageHandler(Filters.text, broadcast_message)]}, fallbacks=[CommandHandler('cancel', cancel)]) # CONVERSATION HANDLER FOR REPLACING SQLITE DATABASE conv_handler2 = ConversationHandler( entry_points=[CommandHandler('senddb', getDb)], allow_reentry=True, states={DB: [MessageHandler(Filters.document, db)]}, fallbacks=[CommandHandler('cancel', cancel)]) dp.add_handler(conv_handler1) dp.add_handler(conv_handler2) dp.add_handler(CommandHandler('new', new20)) dp.add_handler(CommandHandler('subscribe', subscribe)) dp.add_handler(CommandHandler('unsubscribe', unsubscribe)) dp.add_handler(CommandHandler('givememydb', givememydb)) dp.add_handler(CommandHandler('start', start)) dp.add_handler(CommandHandler('help', help)) # log all errors dp.add_error_handler(error) # Add your handlers here if webhook_url: bot.set_webhook(webhook_url=webhook_url) thread = Thread(target=dp.start, name='dispatcher') thread.start() return update_queue, bot else: bot.set_webhook() # Delete webhook updater.start_polling() updater.idle()