def add_mute(upd: Updater, handlers_group: int): logger.info("registering mute handlers") dp = upd.dispatcher dp.add_handler( CommandHandler( "mute", mute, filters=Filters.chat(username=get_group_chat_id().strip("@")) & admin_filter, run_async=True, ), handlers_group, ) dp.add_handler(CommandHandler("mute", mute_self, run_async=True), handlers_group) dp.add_handler( CommandHandler( "unmute", unmute, filters=Filters.chat(username=get_group_chat_id().strip("@")) & admin_filter, run_async=True, ), handlers_group, )
def test_filters_chat_id(self, message): assert not Filters.chat(chat_id=-1)(message) message.chat.id = -1 assert Filters.chat(chat_id=-1)(message) message.chat.id = -2 assert Filters.chat(chat_id=[-1, -2])(message) assert not Filters.chat(chat_id=[-3, -4])(message)
def test_filters_chat_username(self, message): assert not Filters.chat(username='******')(message) message.chat.username = '******' assert Filters.chat(username='******')(message) assert Filters.chat(username='******')(message) assert Filters.chat(username=['chat1', 'chat', 'chat2'])(message) assert not Filters.chat(username=['@chat1', 'chat_2'])(message)
def test_filters_chat_id(message): assert not Filters.chat(chat_id=-1)(message) message.chat.id = -1 assert Filters.chat(chat_id=-1)(message) message.chat.id = -2 assert Filters.chat(chat_id=[-1, -2])(message) assert not Filters.chat(chat_id=[-3, -4])(message)
def test_filters_chat_id(self, update): assert not Filters.chat(chat_id=-1)(update) update.message.chat.id = -1 assert Filters.chat(chat_id=-1)(update) update.message.chat.id = -2 assert Filters.chat(chat_id=[-1, -2])(update) assert not Filters.chat(chat_id=[-3, -4])(update)
def test_filters_chat_id(self): self.assertFalse(Filters.chat(chat_id=-1)(self.message)) self.message.chat.id = -1 self.assertTrue(Filters.chat(chat_id=-1)(self.message)) self.message.chat.id = -2 self.assertTrue(Filters.chat(chat_id=[-1, -2])(self.message)) self.assertFalse(Filters.chat(chat_id=-1)(self.message))
def test_filters_chat_username(message): assert not Filters.chat(username='******')(message) message.chat.username = '******' assert Filters.chat(username='******')(message) assert Filters.chat(username='******')(message) assert Filters.chat(username=['chat1', 'chat', 'chat2'])(message) assert not Filters.chat(username=['@chat1', 'chat_2'])(message)
def test_filters_chat_username(self): self.assertFalse(Filters.chat(username='******')(self.message)) self.message.chat.username = '******' self.assertTrue(Filters.chat(username='******')(self.message)) self.assertTrue(Filters.chat(username='******')(self.message)) self.assertTrue(Filters.chat(username=['chat1', 'chat', 'chat2'])(self.message)) self.assertFalse(Filters.chat(username=['@chat1', 'chat_2'])(self.message))
def test_filters_chat_username(self, update): assert not Filters.chat(username='******')(update) update.message.chat.username = '******' assert Filters.chat(username='******')(update) assert Filters.chat(username='******')(update) assert Filters.chat(username=['chat1', 'chat', 'chat2'])(update) assert not Filters.chat(username=['@chat1', 'chat_2'])(update)
def main() -> None: """ MQTT setup """ mqttClient.loop_start() mqttClient.subscribe(ESPRFID_MQTT_TOPIC) mqttClient.subscribe(ESPRFID_MQTT_TOPIC + '/send') mqttClient.subscribe(ESPRFID_MQTT_TOPIC + '/sync') mqttClient.subscribe(ESPRFID_MQTT_TOPIC + '/accesslist') mqttClient.on_message = on_mqtt_message ''' Telegram Bot setup ''' chat_filter = Filters.text & Filters.chat(DOORBOT_CHAT_ID) # /help dispatcher.add_handler(CommandHandler('help', help_command, chat_filter)) # /open dispatcher.add_handler(CommandHandler('open', open_command, chat_filter)) # /[unknown command] dispatcher.add_handler( MessageHandler(Filters.command & chat_filter, unknown_command)) # Callback from Inline Keyboard dispatcher.add_handler(CallbackQueryHandler(callback_message)) # Other messages dispatcher.add_handler( MessageHandler(~Filters.command & chat_filter, text_message)) # Other chat dispatcher.add_handler( MessageHandler(~Filters.chat(DOORBOT_CHAT_ID), unknown_chat)) updater.start_polling() updater.idle()
def test_filters_chat_username(self): self.assertFalse(Filters.chat(username='******')(self.message)) self.message.chat.username = '******' self.assertTrue(Filters.chat(username='******')(self.message)) self.assertTrue(Filters.chat(username='******')(self.message)) self.assertTrue( Filters.chat(username=['chat1', 'chat', 'chat2'])(self.message)) self.assertFalse( Filters.chat(username=['@chat1', 'chat_2'])(self.message))
def get_filter(users: Iterable[User]): username, chat_id = set(), set() for user in users: if isinstance(user, str): username.add(user) elif isinstance(user, int): chat_id.add(user) return Filters.chat(username=username, allow_empty=True) & Filters.chat( chat_id=chat_id, allow_empty=True)
def test_filters_chat_id(self, update): assert not Filters.chat(chat_id=1)(update) update.message.chat.id = 1 assert Filters.chat(chat_id=1)(update) update.message.chat.id = 2 assert Filters.chat(chat_id=[1, 2])(update) assert not Filters.chat(chat_id=[3, 4])(update) update.message.chat = None assert not Filters.chat(chat_id=[3, 4])(update)
def main(): """Start the bot.""" # Create the EventHandler and pass it your bot's token. updater = Updater(token) j = updater.job_queue # Get the dispatcher to register handlers dp = updater.dispatcher # on different commands - answer in Telegram dp.add_handler(CommandHandler("start", start)) dp.add_handler(CommandHandler("help", help)) dp.add_handler(CommandHandler("execute", execute, pass_args=True)) dp.add_handler( CommandHandler("todo", todoadd, filters=Filters.chat(chat_id=userid), pass_args=True)) dp.add_handler( CommandHandler("deletetodo", deletetodo, filters=Filters.chat(chat_id=userid), pass_args=True)) dp.add_handler( CommandHandler("noteadd", noteadd, filters=Filters.chat(chat_id=userid), pass_args=True)) dp.add_handler( CommandHandler("deletenote", deletenote, filters=Filters.chat(chat_id=userid), pass_args=True)) dp.add_handler( CommandHandler("eventadd", eventadd, filters=Filters.chat(chat_id=userid), pass_args=True)) # daily message job_minute = j.run_daily( bonjour, datetime.time(hour=dailyjob_hour, minute=dailyjob_min)) # on noncommand i.e message - echo the message on Telegram dp.add_handler(MessageHandler(Filters.text, ifbot)) # log all errors dp.add_error_handler(error) # Start the Bot updater.start_polling() # 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 __register_whitelist__(self, whitelist): if whitelist: chat_id_filter = Filters.chat( list(filter(lambda x: isinstance(x, int), whitelist))) chat_username_filter = Filters.chat( list(filter(lambda x: isinstance(x, str), whitelist))) self.__filters__ = merge_filters_and( self.__filters__, chat_id_filter | chat_username_filter) for u in whitelist: if isinstance(u, int): self.__bot__.send_message(u, self.__about_this_bot__())
def init(dispatcher: Dispatcher): """Provide handlers initialization.""" dispatcher.add_handler( CommandHandler('vip', vip, filters=Filters.chat(config.USER_IDS[0]), pass_args=True)) dispatcher.add_handler( CommandHandler('unvip', unvip, filters=Filters.chat(config.USER_IDS[0]), pass_args=True))
def init(dispatcher: Dispatcher): """Provide handlers initialization.""" dispatcher.add_handler( MessageHandler(Filters.group & Filters.chat(config.GROUP_IDS), process_message)) dispatcher.add_handler( MessageHandler(Filters.chat(config.USER_IDS[0]) & (Filters.text | Filters.caption), process_message_from_authorised_user)) dispatcher.add_handler( MessageHandler((~Filters.group) & (Filters.text | Filters.photo | Filters.document), process_message)) dispatcher.add_handler(CallbackQueryHandler(ignore_callback, pattern=r'^#$')) dispatcher.add_handler(CallbackQueryHandler(get_warning))
def main(): pers = PicklePersistence("persistence") defaults = Defaults(parse_mode="HTML", disable_notification=True) updater = Updater("", defaults=defaults, persistence=pers) dp = updater.dispatcher dp.add_handler(MessageHandler(Filters.update.channel_post & Filters.chat(CHANNEL_ID), new_post)) dp.add_handler(MessageHandler(Filters.update.edited_channel_post & Filters.chat(CHANNEL_ID), edited_post)) dp.add_handler(MessageHandler(Filters.status_update.pinned_message & Filters.chat(GROUP_ID), del_msg)) if "messages" not in dp.bot_data: dp.bot_data = {"messages": {}} updater.start_polling() updater.idle()
def main(): updater = Updater(cfg['TELEGRAM']['token'], use_context=True) for obj in objects: for key in list(obj.getCommands().keys()): updater.dispatcher.add_handler( CommandHandler(key, obj.getCommands()[key], ~Filters.chat(BANNED_CHANNELS))) updater.dispatcher.add_handler( MessageHandler(~Filters.chat(BANNED_CHANNELS), allMessages)) updater.start_polling() updater.idle()
def main() -> None: """Start the bot.""" updater = Updater(token) startup(updater) # Get the dispatcher to register handlers dispatcher = updater.dispatcher # dispatcher.add_handler(CommandHandler( # "start", start, Filters.user(username="******"))) dispatcher.add_handler(CommandHandler( "users", users, Filters.chat(chat_id=chat_ids))) dispatcher.add_handler(CommandHandler( "pwd", pwd, Filters.chat(chat_id=chat_ids))) dispatcher.add_handler(CommandHandler( "gep", get_execution_policy, Filters.chat(chat_id=chat_ids))) dispatcher.add_handler(CommandHandler( "uptime", uptime, Filters.chat(chat_id=chat_ids))) dispatcher.add_handler(CommandHandler( "get_screen", get_screen, Filters.chat(chat_id=chat_ids))) dispatcher.add_handler(CommandHandler("terminal", terminal, Filters.chat(chat_id=chat_ids), pass_args=True)) dispatcher.add_handler(CommandHandler("ls", list_dir, Filters.chat(chat_id=chat_ids), pass_args=True)) dispatcher.add_handler(CommandHandler("cd", cd_folder, Filters.chat(chat_id=chat_ids), pass_args=True)) # on noncommand i.e message - echo the message on Telegram # dispatcher.add_handler(MessageHandler( # Filters.text & ~Filters.command, echo)) updater.start_polling() updater.idle()
def main(): """Start the bot.""" # Create the EventHandler and pass it your bot's token. updater = Updater(TKN) # Get the dispatcher to register handlers dp = updater.dispatcher # on different commands - answer in Telegram # 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.chat(144149077) & Filters.text, echo)) # log all errors dp.add_error_handler(error) # Start the Bot updater.start_polling() # 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 main(): print('Bot started') updater = Updater("884268402:AAHekHDw4T3Badp3LKmBSnsNQ9BUDiwf56M", use_context=True) # Get the dispatcher to register handlers dp = updater.dispatcher tjan_filter = TjanFilter() no_you_filter = NoYouFilter() dp.add_handler( MessageHandler(Filters.status_update.new_chat_members, welcome)) # & Filters.chat(chat_id=-1001114719696), welcome)) dp.add_handler( CommandHandler("aboutGroup", aboutGroup, filters=Filters.chat(chat_id=-1001114719696))) dp.add_handler(MessageHandler(tjan_filter, tjan)) dp.add_handler(MessageHandler(Filters.user(username='******'), unca)) # DruzjDruzishka Caendaley dp.add_handler(MessageHandler(no_you_filter, noyou)) dp.add_handler(CommandHandler('poloznjak', poloznjak)) dp.add_handler(CommandHandler('otbros', otbros)) # log all errors dp.add_error_handler(error) # Start the Bot updater.start_polling(clean=True) # 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 main(): # Create the Updater and pass it your bot's token. # Make sure to set use_context=True to use the new context based callbacks # Post version 12 this will no longer be necessary updater = Updater(str(os.environ['TOKEN']), use_context=True) # Get the dispatcher to register handlers dp = updater.dispatcher # on different commands - answer in Telegram dp.add_handler(CommandHandler("start", start)) dp.add_handler(CommandHandler("help", help)) dp.add_handler(CommandHandler("id", id)) dp.add_handler(MessageHandler( Filters.chat(int(os.environ['CHAT_ID'])), hodor)) updater.dispatcher.add_handler(CallbackQueryHandler(button)) # on noncommand i.e message - echo the message on Telegram # log all errors dp.add_error_handler(error) # Start the Bot updater.start_polling() # Block until the user presses 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 set_handlers(dispatcher): message_filters = Filters.chat(chat_id=CHANNEL_ID) message_handler = MessageHandler( filters=message_filters, callback=chat_message_handler, ) dispatcher.add_handler(message_handler)
def poll(): # monitoring prometheus_server(8080) # chat whitelist whitelist = None if os.getenv("TG_SINGLE_CHAT"): whitelist = Filters.chat(chat_id=int(os.getenv("TG_SINGLE_CHAT"))) persistence = PicklePersistence(filename="data.pkl") updater = Updater(os.getenv("TG_TOKEN"), persistence=persistence) dp = updater.dispatcher # on different commands - answer in Telegram dp.add_handler(CommandHandler("start", start, filters=whitelist)) dp.add_handler(CommandHandler("stop", stop, filters=whitelist)) # on noncommand i.e message - check if it was correct dp.add_handler(MessageHandler(Filters.text, check)) # log all errors dp.add_error_handler(lambda update, context: logger.error( f"(on update {update}) {context.error}")) # start the bot updater.start_polling() updater.idle()
def start_bot(token): # Create the Updater and pass it your bot's token. updater = Updater(token, workers=1) # we have too small ram on oPi zero... # Get the dispatcher to register handlers dispatcher = updater.dispatcher dispatcher.add_handler(MessageHandler(~Filters.chat(chatId), unknownChat)) # on different commands - answer in Telegram dispatcher.add_handler(CommandHandler('start', start)) dispatcher.add_handler(CallbackQueryHandler(button)) dispatcher.add_handler(CommandHandler('keyboard', keyboard)) dispatcher.add_handler(CommandHandler('keyoff', keyboard_off)) dispatcher.add_handler(CommandHandler("help", help_command)) dispatcher.add_handler(CommandHandler("status", status)) dispatcher.add_handler(CommandHandler("photo", get_photo)) dispatcher.add_handler(CommandHandler("gif", get_gif)) dispatcher.add_handler(CommandHandler("video", get_video)) dispatcher.add_handler(CommandHandler("pause", pause_printing)) dispatcher.add_handler(CommandHandler("resume", resume_printing)) dispatcher.add_handler(CommandHandler("cancel", cancel_printing)) dispatcher.add_handler(CommandHandler("poweroff", power_off)) dispatcher.add_handler(CommandHandler("light", light_toggle)) dispatcher.add_handler(CommandHandler("files", get_gcode_files)) # on noncommand i.e message - echo the message on Telegram dispatcher.add_handler(MessageHandler(Filters.text & ~Filters.command, echo)) dispatcher.add_handler(MessageHandler(Filters.document & ~Filters.command, upload_file)) # Start the Bot updater.start_polling() return updater
def main(): updater = Updater(TOKEN, use_context=True) dp = updater.dispatcher dp.add_handler(CommandHandler('start', start)) dp.add_handler(CommandHandler('help', help)) dp.add_handler(CommandHandler('kosher', kosher)) dp.add_handler(CommandHandler('splclue', splclue, filters=Filters.chat(GROUP_ID))) dp.add_handler(MessageHandler(Filters.regex(clue_regex) & Filters.chat(GROUP_ID), get_clues)) dp.add_handler(MessageHandler(Filters.regex(emoji_regex), grin)) updater.start_polling() updater.idle()
def get_handlers(cls) -> List[MessageHandler]: """Возвращает хендлеры загрузчика.""" filters = (~Filters.command) & (Filters.chat(cls.loader.channel)) return [MessageHandler( Filters.video & filters, cls.upload, )]
def setup_dispatcher(dp): dp.add_handler(CommandHandler('start', start)) dp.add_handler(MessageHandler(Filters.chat_type.private, forward_to_chat)) dp.add_handler( MessageHandler( Filters.chat(TELEGRAM_SUPPORT_CHAT_ID) & Filters.reply, forward_to_user)) return dp
def register(self, dispatcher): user_filter = Filters.chat(username='******') dispatcher.add_handler(CommandHandler(['add'], self.add_command, user_filter, pass_args=True)) dispatcher.add_handler(CommandHandler(['list'], self.list_command, user_filter, pass_args=True)) dispatcher.add_handler(CommandHandler(['reset'], self.reset_command, user_filter, pass_args=True)) dispatcher.add_handler(CommandHandler(['remove'], self.remove_command, user_filter, pass_args=True)) dispatcher.add_handler(CommandHandler(['forceupdate'], self.forceupdate_command, user_filter, pass_args=True)) dispatcher.add_handler(MessageHandler(Filters.all, self.fallback))
def change_handlers(dp): dp.handlers.clear() dp.handlers = { 0: [CommandHandler("upload", upload, Filters.chat(TRANSLATION_CHAT_ID))], 1: [], 2: [] }
def manager_app(): handlers = [ *join_options_handlers, CommandHandler('start', start), CommandHandler('rank', custom_rank), CommandHandler('ranks', display_ranks), CommandHandler('addemoji', add_emoji), CommandHandler('churn', get_churn_list), CommandHandler('get_stats', group_data.get_stats), CommandHandler('activity', activity.activity_command, filters=Filters.group), CommandHandler('statistics', statistics_command, filters=Filters.group), CommandHandler('action', set_action, filters=Filters.group), CommandHandler('getd', get_file_data, filters=Filters.chat(dev_group)), MessageHandler(Filters.animation | Filters.sticker, sticker_and_gif_commands), join_options_welcomes_command, CommandHandler('tag_del', mention_options.delete_messages, filters=Filters.group), MessageHandler(Filters.group & Filters.text, mention_options.define_message_as_mention), CallbackQueryHandler(stats.buttons, pattern='^stats '), CallbackQueryHandler(group_data.buttons, pattern='^group_data '), CallbackQueryHandler(advanced_commands_buttons, pattern='^setAction '), CallbackQueryHandler(del_action, pattern='^delAction ') ] conv_handler = ConversationHandler( entry_points=[ CallbackQueryHandler(custom_helper_callback, pattern='^customHelper ') ], states={ GET_CLIENT_STR: [MessageHandler(Filters.regex('^tg.hl@'), get_client_str)] }, fallbacks=[], allow_reentry=False) handlers.append(conv_handler) for handler in handlers: dispatcher.add_handler(handler) # conv_handler = ConversationHandler( # entry_points=[CommandHandler('stt', start)], # states={ # # }, # fallbacks=[CommandHandler('cn', start)], # allow_reentry=True # # ) # # dp.add_handler(conv_handler) print(12) u.start_polling(clean=True)
def main(): updater = Updater(CONFIG["Telegram"]["bot_token"], use_context=True) dispatcher = updater.dispatcher dispatcher.add_handler( MessageHandler( Filters.chat(CONFIG.getint("Telegram", "chat_id")) & Filters.text & Filters.command, cmd)) updater.start_polling() updater.idle()
def test_filters_chat(self): with pytest.raises(ValueError, match='chat_id or username'): Filters.chat(chat_id=-1, username='******') with pytest.raises(ValueError, match='chat_id or username'): Filters.chat()
def test_filters_chat(self): with self.assertRaisesRegexp(ValueError, 'chat_id or username'): Filters.chat(chat_id=-1, username='******') with self.assertRaisesRegexp(ValueError, 'chat_id or username'): Filters.chat()