def main(token, root_dir, rpc, whitelist, proxy): if proxy: request_kwargs = { 'proxy_url': 'socks5://{}:{}'.format(proxy['address'], proxy['port']), 'urllib3_proxy_kwargs': { 'username': proxy['username'], 'password': proxy['password'], } } else: request_kwargs = None t_service = TorrentService(rpc['address'], rpc['port'], rpc['username'], rpc['password']) f_service = FilesService(root_dir) a_service = AddService(f_service, t_service) s_service = SystemService(root_dir) updater = Updater(token, use_context=True, request_kwargs=request_kwargs) dp = updater.dispatcher fallbacks = [ CallbackQueryHandler(cancel, pattern='^cancel$'), MessageHandler( Filters.regex(r'^Torrents$') & Filters.chat(username=whitelist), t_service.torrent_list), MessageHandler( Filters.regex(r'^Files$') & Filters.chat(username=whitelist), f_service.file_list), MessageHandler(Filters.document & Filters.chat(username=whitelist), a_service.add_torrent_file), MessageHandler( Filters.regex(r'^magnet:\?') & Filters.chat(username=whitelist), a_service.add_torrent_magnet), MessageHandler( Filters.regex(r'^System commands$') & Filters.chat(username=whitelist), s_service.commands_list) ] torrents_handler = ConversationHandler( entry_points=[ MessageHandler( Filters.regex(r'^Torrents$') & Filters.chat(username=whitelist), t_service.torrent_list) ], states={ TORRENTLIST: [ CallbackQueryHandler(t_service.torrent_info, pattern='^t_info_\d+$') ], TORRENTINFO: [ CallbackQueryHandler(t_service.move_top, pattern='^t_top_\d+$'), CallbackQueryHandler(t_service.move_up, pattern='^t_up_\d+$'), CallbackQueryHandler(t_service.move_down, pattern='^t_down_\d+$'), CallbackQueryHandler(t_service.move_bottom, pattern='^t_bottom_\d+$'), CallbackQueryHandler(t_service.resume_torrent, pattern='^t_resume_\d+$'), CallbackQueryHandler(t_service.resume_torrent_now, pattern='^t_resume_now_\d+$'), CallbackQueryHandler(t_service.stop_torrent, pattern='^t_stop_\d+$'), CallbackQueryHandler(t_service.verify_torrent, pattern='^t_verify_(\d+?)$'), CallbackQueryHandler(t_service.remove_torrent_confirm, pattern='^t_remove_confirm_\d+$') ], REMOVETORRENT: [ CallbackQueryHandler(t_service.remove_torrent, pattern='^t_remove_\d+$'), CallbackQueryHandler(t_service.remove_torrent_complete, pattern='^t_remove_complete_\d+$') ] }, fallbacks=fallbacks) files_handler = ConversationHandler( entry_points=[ MessageHandler( Filters.regex(r'^Files$') & Filters.chat(username=whitelist), f_service.file_list) ], states={ FILESLIST: [ CallbackQueryHandler(f_service.file_list, pattern='^t_file_info_[0-9]*$'), CallbackQueryHandler(f_service.file_list_back, pattern='^t_file_info_back$'), CallbackQueryHandler(f_service.remove_file_confirm, pattern='^t_file_delete_confirm$') ], REMOVEFILECONFIRM: [ CallbackQueryHandler(f_service.remove_file, pattern='^t_file_delete$') ] }, fallbacks=fallbacks) add_handler = ConversationHandler( entry_points=[ MessageHandler(Filters.document & Filters.chat(username=whitelist), a_service.add_torrent_file), MessageHandler( Filters.regex(r'^magnet:\?') & Filters.chat(username=whitelist), a_service.add_torrent_magnet) ], states={ ADDFOLDERLIST: [ CallbackQueryHandler(a_service.choose_dir_for_torrent, pattern='^a_folder_info_[0-9]*$'), CallbackQueryHandler(a_service.choose_dir_for_torrent_back, pattern='^a_folder_info_back$'), CallbackQueryHandler(a_service.choose_dir_for_torrent_finish, pattern='^a_folder_info_finish$') ] }, fallbacks=fallbacks) commands_handler = ConversationHandler( entry_points=[ MessageHandler( Filters.regex(r'^System commands$') & Filters.chat(username=whitelist), s_service.commands_list) ], states={ SYSTEMCOMMANDS: [ CallbackQueryHandler(s_service.restart_minidlna, pattern='^restart_minidlna$'), CallbackQueryHandler(s_service.reboot, pattern='^reboot$'), CallbackQueryHandler(s_service.poweroff, pattern='^poweroff$'), CallbackQueryHandler(s_service.get_free_space, pattern='^free_space$') ] }, fallbacks=fallbacks) dp.add_handler(torrents_handler) dp.add_handler(files_handler) dp.add_handler(add_handler) dp.add_handler(commands_handler) dp.add_handler( CommandHandler('start', start, Filters.chat(username=whitelist))) dp.add_error_handler(error) updater.start_polling() updater.idle()
def help_command(update, context): message = emoji.emojize( ":eyes:" ) + """ This is a bot that stalks influencers on twitter.\n Use /update to get new followings by influencers that are followed. Use /add *usernamehere* to add another influencer to follow.\n\n""" + emoji.emojize( ":eyes:" ) + " Currently followed influencers: " + twitterbotv2.getCurrentInfluencers( ) context.bot.send_message(chat_id=update.effective_chat.id, text=message) #handles commands such as /start, /update from telegram.ext import CommandHandler, MessageHandler, Filters, PrefixHandler start_handler = CommandHandler('start', start) dispatcher.add_handler(start_handler) update_handler = CommandHandler('update', request) append_handler = PrefixHandler("/", "add", append) dispatcher.add_handler(append_handler) dispatcher.add_handler(update_handler) dispatcher.add_handler(CommandHandler("help", help_command)) dispatcher.add_handler(MessageHandler(Filters.text & ~Filters.command, append)) from telegram.ext import MessageHandler, Filters request_handler = MessageHandler(Filters.text & (~Filters.command), request) updater.start_polling()
âž© Admin only: - `/addblacklist <triggers>`*:* Add a trigger to the blacklist. Each line is considered one trigger, so using different lines will allow you to add multiple triggers. - `/unblacklist <triggers>`*:* Remove triggers from the blacklist. Same newline logic applies here, so you can remove multiple triggers at once. - `/blacklistmode <off/del/warn/ban/kick/mute/tban/tmute>`*:* Action to perform when someone sends blacklisted words. """ BLACKLIST_HANDLER = DisableAbleCommandHandler( "blacklist", blacklist, pass_args=True, admin_ok=True ) ADD_BLACKLIST_HANDLER = CommandHandler("addblacklist", add_blacklist) UNBLACKLIST_HANDLER = CommandHandler("unblacklist", unblacklist) BLACKLISTMODE_HANDLER = CommandHandler("blacklistmode", blacklist_mode, pass_args=True) BLACKLIST_DEL_HANDLER = MessageHandler( (Filters.text | Filters.command | Filters.sticker | Filters.photo) & Filters.group, del_blacklist, allow_edit=True, ) dispatcher.add_handler(BLACKLIST_HANDLER) dispatcher.add_handler(ADD_BLACKLIST_HANDLER) dispatcher.add_handler(UNBLACKLIST_HANDLER) dispatcher.add_handler(BLACKLISTMODE_HANDLER) dispatcher.add_handler(BLACKLIST_DEL_HANDLER, group=BLACKLIST_GROUP) __handlers__ = [ BLACKLIST_HANDLER, ADD_BLACKLIST_HANDLER, UNBLACKLIST_HANDLER, BLACKLISTMODE_HANDLER, (BLACKLIST_DEL_HANDLER, BLACKLIST_GROUP),
from telegram.ext import Updater, CommandHandler, MessageHandler, Filters last_uploaded_photo = "" def echo(bot, update): global last_uploaded_photo try: chat_id = update.message.chat_id bot_chat = bot.getChat(chat_id=chat_id) if bot_chat['photo']['small_file_id'] != last_uploaded_photo: bot.setChatPhoto(chat_id=chat_id, photo=open("telegram.jpg", "rb")) last_uploaded_photo = bot.getChat( chat_id=chat_id)['photo']['small_file_id'] except Exception as e: print(e) TOKEN = "" updater = Updater(token=TOKEN) dispatcher = updater.dispatcher dispatcher.add_handler(MessageHandler(Filters.all, echo)) dispatcher.add_handler(CommandHandler("start", echo)) updater.start_polling(clean=True)
✪ /goodbye*:* same usage and args as `/welcome`. ✪ /setwelcome <sometext>*:* set a custom welcome message. If used replying to media, uses that media. ✪ /setgoodbye <sometext>*:* set a custom goodbye message. If used replying to media, uses that media. ✪ /resetwelcome*:* reset to the default welcome message. ✪ /resetgoodbye*:* reset to the default goodbye message. ✪ /cleanwelcome <on/off>*:* On new member, try to delete the previous welcome message to avoid spamming the chat. ✪ /welcomemutehelp*:* gives information about welcome mutes. ✪ /cleanservice <on/off*:* deletes telegrams welcome/left service messages. *Example:* user joined chat, user left chat. *Welcome markdown:* ✪ `/welcomehelp`*:* view more formatting information for custom welcome/goodbye messages. """ NEW_MEM_HANDLER = MessageHandler(Filters.status_update.new_chat_members, new_member) LEFT_MEM_HANDLER = MessageHandler(Filters.status_update.left_chat_member, left_member) WELC_PREF_HANDLER = CommandHandler("welcome", welcome, filters=Filters.group) GOODBYE_PREF_HANDLER = CommandHandler("goodbye", goodbye, filters=Filters.group) SET_WELCOME = CommandHandler("setwelcome", set_welcome, filters=Filters.group) SET_GOODBYE = CommandHandler("setgoodbye", set_goodbye, filters=Filters.group) RESET_WELCOME = CommandHandler("resetwelcome", reset_welcome, filters=Filters.group) RESET_GOODBYE = CommandHandler("resetgoodbye", reset_goodbye, filters=Filters.group) WELCOMEMUTE_HANDLER = CommandHandler("welcomemute",
if button_mode == 1: add_like_buttons( bot, lang, config, chat_id, message_id, message, helper_database.get_default_button_options(chat_id)) else: add_compact_comment(bot, chat_id, config, message_id, message) elif mode == 3: logger.msg( { "channel_id": chat_id, "msg_id": message_id, "mode": mode, "button": button_mode, "action": "new channel post" }, tag="channel", log_level=90) add_inplace_comment( bot, chat_id, config, message_id, message, (helper_database.get_default_button_options(chat_id) if button_mode == 1 else [])) class FilterChannelPost(BaseFilter): def filter(self, message): return message.chat.type == "channel" channel_post_filter = FilterChannelPost() _handler = MessageHandler(channel_post_filter, channel_post_msg)
def main(): print("Starting bot") global pp, updater, globalsns globalsns = shelve.open(PERSISTENCE_GLOBAL_SNS_FILENAME, writeback=True) # Create the Updater and pass it your bot's token. pp = PicklePersistence(filename=PERSISTENCE_USER_FILENAME, store_user_data=True, store_chat_data=False, on_flush=True) updater = Updater(TELEGRAM_TOKEN, persistence=pp, user_sig_handler=stop_rta_thread) start_rta_update_thread() # Get the dispatcher to register handlers dp = updater.dispatcher updater.dispatcher.add_handler( CommandHandler('start', start, pass_user_data=True)) updater.dispatcher.add_handler( CommandHandler('dist', show_dist, pass_user_data=True)) updater.dispatcher.add_handler( CommandHandler('send', send_stake, pass_user_data=True, pass_args=True)) updater.dispatcher.add_handler( CommandHandler('balance', balance, pass_user_data=True)) updater.dispatcher.add_handler( CommandHandler('donate', donate, pass_user_data=True)) updater.dispatcher.add_handler( CommandHandler('sn', show_sn, pass_user_data=True, pass_args=True)) updater.dispatcher.add_handler( CommandHandler('sample', show_sample, pass_user_data=True, pass_args=True)) updater.dispatcher.add_handler( CommandHandler('height', show_height, pass_user_data=True, pass_args=True)) updater.dispatcher.add_handler( CommandHandler('nodes', show_nodes, pass_user_data=True, pass_args=True)) updater.dispatcher.add_handler( CommandHandler('snodes', show_snodes, pass_user_data=True, pass_args=True)) updater.dispatcher.add_handler( MessageHandler(Filters.text, msg_input, pass_user_data=True)) # log all errors dp.add_error_handler(error) # Start the Bot updater.start_polling() print("Bot started") # 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() print("Saving persistence and shutting down") pp.flush() globalsns.close()
context.bot.leaveChat(update.effective_message.chat.id) def __user_info__(user_id): if user_id == dispatcher.bot.id: return """I've seen them in... Wow. Are they stalking me? They're in all the same places I am... oh. It's me.""" num_chats = sql.get_user_num_chats(user_id) return """I've seen them in <code>{}</code> chats in total.""".format(num_chats) def __stats__(): return "× {} users, across {} chats".format(sql.num_users(), sql.num_chats()) def __migrate__(old_chat_id, new_chat_id): sql.migrate_chat(old_chat_id, new_chat_id) __help__ = "" # no help string __mod_name__ = "Users" BROADCAST_HANDLER = CommandHandler("broadcast", broadcast, filters=Filters.user(OWNER_ID)) USER_HANDLER = MessageHandler(Filters.all & Filters.group, log_user) CHATLIST_HANDLER = CommandHandler("chatlist", chats, filters=CustomFilters.sudo_filter) CHAT_CHECKER_HANDLER = MessageHandler(Filters.all & Filters.group, chat_checker) dispatcher.add_handler(USER_HANDLER, USERS_GROUP) dispatcher.add_handler(BROADCAST_HANDLER) dispatcher.add_handler(CHATLIST_HANDLER) dispatcher.add_handler(CHAT_CHECKER_HANDLER, CHAT_GROUP)
def get_config_handler(bot: 'Bot') -> ConversationHandler: """ Generates the conversation handler for whole configuration process. Args: bot: The parent `Bot` instance. Returns: The instantiated `ConversationHandler`. """ main_handler = ConversationHandler( entry_points=[bot.command_handler('config', BotConfig._main_menu)], states={ BotConfig.MAIN_MENU: [ CallbackQueryHandler(BotConfig._general_config, pattern='^' + str(BotConfig.GENERAL_CONFIG) + '$'), CallbackQueryHandler(BotConfig._surveillance_config, pattern='^' + str(BotConfig.SURVEILLANCE_CONFIG) + '$'), CallbackQueryHandler(BotConfig._end, pattern='^' + str(BotConfig.END) + '$') ], BotConfig.GENERAL_CONFIG: [ CallbackQueryHandler( BotConfig._change_timestamp, pattern='^' + str(BotConfig.CHANGE_TIMESTAMP) + '$'), CallbackQueryHandler( BotConfig._change_od_video_duration, pattern='^' + str(BotConfig.CHANGE_OD_VIDEO_DURATION) + '$'), CallbackQueryHandler(BotConfig._main_menu, pattern='^' + str(BotConfig.END) + '$') ], BotConfig.SURVEILLANCE_CONFIG: [ CallbackQueryHandler( BotConfig._change_srv_video_duration, pattern='^' + str(BotConfig.CHANGE_SRV_VIDEO_DURATION) + '$'), CallbackQueryHandler( BotConfig._change_srv_picture_interval, pattern='^' + str(BotConfig.CHANGE_SRV_PICTURE_INTERVAL) + '$'), CallbackQueryHandler( BotConfig._change_motion_contours, pattern='^' + str(BotConfig.CHANGE_SRV_MOTION_CONTOURS) + '$'), CallbackQueryHandler(BotConfig._main_menu, pattern='^' + str(BotConfig.END) + '$') ], BotConfig.BOOLEAN_INPUT: [ CallbackQueryHandler(BotConfig._boolean_input, pattern='^' + str(BotConfig.ENABLE) + '$|^' + str(BotConfig.DISABLE) + '$') ], BotConfig.INTEGER_INPUT: [MessageHandler(Filters.text, BotConfig._integer_input)] }, fallbacks=[bot.command_handler('stop_config', BotConfig._end)], ) return main_handler
__help__ = f""" Chatbot utilizes the CoffeeHouse API and allows Kai to talk and provides a more interactive group chat experience. *Commands:* *Admins only:* • `/addchat`*:* Enables Chatbot mode in the chat. • `/rmchat`*:* Disables Chatbot mode in the chat. Reports bugs at @{SUPPORT_CHAT} *Powered by CoffeeHouse* (https://coffeehouse.intellivoid.net/) from @Intellivoid """ ADD_CHAT_HANDLER = CommandHandler("addchat", add_chat) REMOVE_CHAT_HANDLER = CommandHandler("rmchat", remove_chat) CHATBOT_HANDLER = MessageHandler( Filters.text & (~Filters.regex(r"^#[^\s]+") & ~Filters.regex(r"^!") & ~Filters.regex(r"^\/")), chatbot) LIST_CB_CHATS_HANDLER = CommandHandler( "listaichats", list_chatbot_chats, filters=CustomFilters.dev_filter) # Filters for ignoring #note messages, !commands and sed. dispatcher.add_handler(ADD_CHAT_HANDLER) dispatcher.add_handler(REMOVE_CHAT_HANDLER) dispatcher.add_handler(CHATBOT_HANDLER) dispatcher.add_handler(LIST_CB_CHATS_HANDLER) __mod_name__ = "Chatbot" __command_list__ = ["addchat", "rmchat", "listaichats"] __handlers__ = [ ADD_CHAT_HANDLER, REMOVE_CHAT_HANDLER, CHATBOT_HANDLER, LIST_CB_CHATS_HANDLER
def run_bot(): updater = Updater(bot_settings.BOT_TOKEN) dp = updater.dispatcher # dp.add_handler(CommandHandler("start", start)) dp.add_handler(CommandHandler("help", help)) admin_handlers.register(dp) states_handlers = { REGISTER_USER: [ EmptyHandler(register_user_start, pass_user_data=True), MessageHandler(Filters.contact, register_user, pass_user_data=True) ], SELECT_REGION: [ EmptyHandler(select_region_start, pass_user_data=True), CallbackQueryHandler(select_region_button, pass_user_data=True) ], MENU: [ EmptyHandler(show_menu, pass_user_data=True), standard_callback_query_handler ], MAKE_BROADCAST: [ EmptyHandler(make_broadcast_start, pass_user_data=True), MessageHandler(Filters.text, make_broadcast, pass_user_data=True) ], MAKE_BROADCAST_CONFIRM: [ EmptyHandler(make_broadcast_confirm, pass_user_data=True), CallbackQueryHandler(make_broadcast_confirm_button, pass_user_data=True) ], SHOW_REGION_SETTINGS: [ EmptyHandler(show_region_settings_start, pass_user_data=True), standard_callback_query_handler ], MANAGE_ADMIN_RIGHTS: [ EmptyHandler(manage_admin_rights_start, pass_user_data=True), CallbackQueryHandler(manage_admin_rights_button, pass_user_data=True) ], ADD_ADMIN_RIGHTS: [ EmptyHandler(add_admin_rights_start, pass_user_data=True), MessageHandler(Filters.text | Filters.contact, add_admin_rights_text, pass_user_data=True), standard_callback_query_handler ], CHANGE_REGION_PUBLICITY: [ EmptyHandler(change_region_publicity_start, pass_user_data=True), CallbackQueryHandler(change_region_publicity_button, pass_user_data=True) ], } states_handlers.update(teams_handlers.state_handlers) states_handlers.update(agitation_process_handlers.state_handlers) conv_handler = ConversationHandler( user_model=models.User, conversation_state_model=models.ConversationState, entry_points=[CommandHandler("start", start)], unknown_state_handler=EmptyHandler(cancel, pass_user_data=True), states=states_handlers, pre_fallbacks=[], fallbacks=[ CommandHandler('menu', cancel, pass_user_data=True), CommandHandler('cancel', cancel, pass_user_data=True), CommandHandler("region", change_region, pass_user_data=True), CommandHandler("send_bug_report", send_bug_report, pass_user_data=True) ]) dp.add_handler(conv_handler) # log all errors dp.add_error_handler(error_handler) # 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()
update.effective_message.reply_text(res, parse_mode = "html") else: if int(userc_id) == int(user_id): return res = "{} is Offline!\nReason: <code>{}</code>".format(html.escape(fst_name), html.escape(user.reason)) update.effective_message.reply_text(res, parse_mode="html") __help__ = """ • `/afk <reason>`*:* mark yourself as AFK(away from keyboard) or Offline • `brb <reason>`*:* same as the afk command - but not a command. When marked as AFK, any mentions will be replied to with a message to say you're not available! """ AFK_HANDLER = DisableAbleCommandHandler("afk", afk) AFK_REGEX_HANDLER = DisableAbleMessageHandler( Filters.regex(r"^(?i)brb(.*)$"), afk, friendly="afk") NO_AFK_HANDLER = MessageHandler(Filters.all & Filters.group, no_longer_afk) AFK_REPLY_HANDLER = MessageHandler(Filters.all & Filters.group, reply_afk) dispatcher.add_handler(AFK_HANDLER, AFK_GROUP) dispatcher.add_handler(AFK_REGEX_HANDLER, AFK_GROUP) dispatcher.add_handler(NO_AFK_HANDLER, AFK_GROUP) dispatcher.add_handler(AFK_REPLY_HANDLER, AFK_REPLY_GROUP) __mod_name__ = "BRB" __command_list__ = ["afk"] __handlers__ = [(AFK_HANDLER, AFK_GROUP), (AFK_REGEX_HANDLER, AFK_GROUP), (NO_AFK_HANDLER, AFK_GROUP), (AFK_REPLY_HANDLER, AFK_REPLY_GROUP)]
• `/unlock <type>`*:* Unlock items of a certain type (not available in private) • `/locks`*:* The current list of locks in this chat. Locks can be used to restrict a group's users. eg: Locking urls will auto-delete all messages with urls, locking stickers will restrict all \ non-admin users from sending stickers, etc. Locking bots will stop non-admins from adding bots to the chat. *Note:* • Unlocking permission *info* will allow members (non-admins) to change the group information, such as the description or the group name • Unlocking permission *pin* will allow members (non-admins) to pinned a message in a group """ __mod_name__ = "Locks 🔐" LOCKTYPES_HANDLER = DisableAbleCommandHandler("locktypes", locktypes) LOCK_HANDLER = CommandHandler("lock", lock, pass_args=True) # , filters=Filters.group) UNLOCK_HANDLER = CommandHandler( "unlock", unlock, pass_args=True ) # , filters=Filters.group) LOCKED_HANDLER = CommandHandler("locks", list_locks) # , filters=Filters.group) dispatcher.add_handler(LOCK_HANDLER) dispatcher.add_handler(UNLOCK_HANDLER) dispatcher.add_handler(LOCKTYPES_HANDLER) dispatcher.add_handler(LOCKED_HANDLER) dispatcher.add_handler( MessageHandler(Filters.all & Filters.group, del_lockables), PERM_GROUP )
- /addwarn <keyword> <reply message>: set a warning filter on a certain keyword. If you want your keyword to \ be a sentence, encompass it with quotes, as such: `/addwarn "very angry" This is an angry user`. - /nowarn <keyword>: stop a warning filter - /warnlimit <num>: set the warning limit - /strongwarn <on/yes/off/no>: If set to on, exceeding the warn limit will result in a ban. Else, will just kick. """ __mod_name__ = "Warnings" WARN_HANDLER = CommandHandler("warn", warn_user, pass_args=True, filters=Filters.group) RESET_WARN_HANDLER = CommandHandler(["resetwarn", "resetwarns"], reset_warns, pass_args=True, filters=Filters.group) CALLBACK_QUERY_HANDLER = CallbackQueryHandler(button, pattern=r"rm_warn") MYWARNS_HANDLER = DisableAbleCommandHandler("warns", warns, pass_args=True, filters=Filters.group) ADD_WARN_HANDLER = CommandHandler("addwarn", add_warn_filter, filters=Filters.group) RM_WARN_HANDLER = CommandHandler(["nowarn", "stopwarn"], remove_warn_filter, filters=Filters.group) LIST_WARN_HANDLER = DisableAbleCommandHandler(["warnlist", "warnfilters"], list_warn_filters, filters=Filters.group, admin_ok=True) WARN_FILTER_HANDLER = MessageHandler(CustomFilters.has_text & Filters.group, reply_filter) WARN_LIMIT_HANDLER = CommandHandler("warnlimit", set_warn_limit, pass_args=True, filters=Filters.group) WARN_STRENGTH_HANDLER = CommandHandler("strongwarn", set_warn_strength, pass_args=True, filters=Filters.group) dispatcher.add_handler(WARN_HANDLER) dispatcher.add_handler(CALLBACK_QUERY_HANDLER) dispatcher.add_handler(RESET_WARN_HANDLER) dispatcher.add_handler(MYWARNS_HANDLER) dispatcher.add_handler(ADD_WARN_HANDLER) dispatcher.add_handler(RM_WARN_HANDLER) dispatcher.add_handler(LIST_WARN_HANDLER) dispatcher.add_handler(WARN_LIMIT_HANDLER) dispatcher.add_handler(WARN_STRENGTH_HANDLER) dispatcher.add_handler(WARN_FILTER_HANDLER, WARN_HANDLER_GROUP)
dp = up.dispatcher # Command Handlers dp.add_handler(CommandHandler('start', commands.start)) dp.add_handler(CommandHandler('help', commands.help)) dp.add_handler(CommandHandler('about', commands.about)) # Conversation Handler - /newevent command dp.add_handler( ConversationHandler( entry_points=[ CommandHandler('newevent', newevent.entry), ], states={ newevent.STATES.GET_EVENT_NAME: [ MessageHandler(Filters.text, newevent.handle_event_name), ], newevent.STATES.GET_RSVP: [ CallbackQueryHandler(newevent.handle_rsvp), CommandHandler('endevent', newevent.end_event), ], }, fallbacks=[ CommandHandler('abort', newevent.abort), MessageHandler(Filters.command, newevent.fallback), MessageHandler(Filters.text, newevent.fallback), ], persistent=True, name="conversation_newevent", per_user=False, ))
dispatcher = updater.dispatcher [dispatcher.add_handler(i) for i in [ CommandHandler('bug', bug), CommandHandler(['start', 'info'], start), CommandHandler(['weather', 'w'], weather, pass_args=True), CommandHandler( ['ibash', 'loglist', 'cat', 'dog'], random_content, pass_args=True ), CommandHandler('cmd', cmd, pass_args=True), CommandHandler('wset', wset, pass_args=True), CommandHandler('db', db, pass_args=True), CommandHandler('ping', pinger, pass_args=True), CallbackQueryHandler(buttons), MessageHandler(Filters.text, parser) ]] if MODE.lower() == 'webhook': try: LISTEN_IP except NameError: LISTEN_IP = "0.0.0.0" updater.start_webhook(listen=LISTEN_IP, port=WEBHOOK_PORT, url_path=BOT_TOKEN) updater.bot.set_webhook(WEBHOOK_URL) updater.idle() else: updater.start_polling() except sqlite3.ProgrammingError:
def __init__(self): logging.basicConfig( format='%(asctime)s - %(name)s - %(levelname)s - %(message)s', filename=Config.LOG_FILE_NAME, level=Config.LOG_LEVEL) consoleHandler = logging.StreamHandler() self.logger.addHandler(consoleHandler) try: self.db_engine = sqlalchemy.create_engine( Config.SQLALCHEMY_DB_CONN) self.connection = self.db_engine.connect() self.metadata = sqlalchemy.MetaData() Session = sessionmaker(self.db_engine) self.session = Session() except Exception as e: # TODO specify exceptions self.logger.critical(e) exit(errno.ECONNREFUSED) else: self.logger.warning('Connection to database established') try: self.parameters['adv_minutes'] = self.session.query( models.Parameter).get('adv_minutes').value self.parameters['adv_questions'] = self.session.query( models.Parameter).get('adv_questions').value self.parameters['base_points'] = self.session.query( models.Parameter).get('base_points').value self.parameters['current_broadcast'] = self.session.query( models.Parameter).get('current_broadcast').value self.parameters['google_points'] = self.session.query( models.Parameter).get('google_points').value self.parameters['hint_pause'] = self.session.query( models.Parameter).get('hint_pause').value self.parameters['max_time'] = self.session.query( models.Parameter).get('max_time').value self.parameters['min_members'] = self.session.query( models.Parameter).get('min_members').value self.parameters['next_pause'] = self.session.query( models.Parameter).get('next_pause').value self.parameters['series_max'] = self.session.query( models.Parameter).get('series_max').value self.parameters['top_limit'] = self.session.query( models.Parameter).get('top_limit').value except Exception as e: # TODO specify exceptions self.logger.error(e) self.parameters = Config.DEFAULT_PARAMETERS self.logger.warning('Cannot load parameters. Defaults used.') # TODO improvement: add different game types later from games import TextQuiz game = TextQuiz(self.session) self.games[game.name] = game for chat in self.session.query(models.Chat).all(): self.chats[chat.id] = Chat(c_id=chat.id, u_id=chat.u_id, q_id=chat.q_id, is_on=chat.is_on, lang=chat.lang, game=self.games[chat.game], parameters=self.parameters) for user in self.session.query(models.User).all(): self.chats[user.chat_id].users[user.id] = User( u_id=user.id, name=user.user_name, correct_answers=user.correct_answers, points=user.points) try: updater = Updater(Config.TELEGRAM_TOKEN, use_context=True) except Exception as e: self.logger.critical(e) exit(errno.ECONNREFUSED) else: self.logger.warning('Connection to Telegram established') dp = updater.dispatcher dp.add_handler(CommandHandler('start', self.cmd_start)) dp.add_handler(CommandHandler('play', self.cmd_play)) dp.add_handler(CommandHandler('stop', self.cmd_stop)) dp.add_handler(CommandHandler('hint', self.cmd_hint)) dp.add_handler(CommandHandler('score', self.cmd_score)) dp.add_handler(CommandHandler('ask', self.cmd_ask)) dp.add_handler(CommandHandler('lang', self.cmd_lang)) dp.add_handler(CommandHandler('next', self.cmd_next)) dp.add_handler( CommandHandler('setparameter', self.cmd_setparameter)) # dp.add_handler(CommandHandler('stop_bot', self.cmd_stop_bot)) # dp.add_handler( MessageHandler(Filters.regex('^(/top[\d]+)$'), self.cmd_top)) dp.add_handler(MessageHandler(Filters.text, self.message)) dp.add_error_handler(self.errors) self.logger.warning('Melissa Quiz started... ') 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()
dispatcher = updater.dispatcher def start(bot, update): keyboard = [[InlineKeyboardButton(text="Исходный код", url="https://github.com/NottHell/python_bot_cko_miet"), InlineKeyboardButton(text="Разработчик", url="https://vk.com/dyaleksyutenko")]] reply_markup = InlineKeyboardMarkup(keyboard) update.message.reply_text('Привет, давай пообщаемся?', reply_markup=reply_markup) def message(bot, update): request = apiai.ApiAI('afa19533e6be4289917e2335371aa453').text_request() request.lang = 'ru' request.session_id = 'PyBot_AI' request.query = update.message.text responseJson = json.loads(request.getresponse().read().decode('utf-8')) response = responseJson['result']['fulfillment']['speech'] if response: bot.send_message(chat_id=update.message.chat_id, text=response) else: bot.send_message(chat_id=update.message.chat_id, text='Я тебя не понял!') start_command_handler = CommandHandler('start', start) text_message_handler = MessageHandler(Filters.text, message) dispatcher.add_handler(start_command_handler) dispatcher.add_handler(text_message_handler) updater.start_polling(clean=True) updater.idle()
filters = data.get("filters", {}) for trigger in filters: sql.add_to_blacklist(chat_id, trigger) def __migrate__(old_chat_id, new_chat_id): sql.migrate_chat(old_chat_id, new_chat_id) def __chat_settings__(chat_id, user_id): cust_filters = sql.get_chat_triggers(chat_id) return "There are `{}` custom filters here.".format(len(cust_filters)) __mod_name__ = "Filters" FILTER_HANDLER = CommandHandler("filter", filters) STOP_HANDLER = CommandHandler("stop", stop_filter) RMALLFILTER_HANDLER = CommandHandler("rmallfilter", rmall_filters, filters=Filters.group) LIST_HANDLER = CommandHandler("filters", list_handlers, admin_ok=True) CUST_FILTER_HANDLER = MessageHandler( CustomFilters.has_text & ~Filters.update.edited_message, reply_filter) dispatcher.add_handler(FILTER_HANDLER) dispatcher.add_handler(STOP_HANDLER) dispatcher.add_handler(LIST_HANDLER) dispatcher.add_handler(CUST_FILTER_HANDLER, HANDLER_GROUP) dispatcher.add_handler(RMALLFILTER_HANDLER)
Anti-Spam, used by bot devs to ban spammers across all groups. This helps protect \ you and your groups by removing spam flooders as quickly as possible. *Note:* Users can appeal gbans or report spammers at @{SUPPORT_CHAT} This also integrates @Spamwatch API to remove Spammers as much as possible from your chatroom! *What is SpamWatch?* SpamWatch maintains a large constantly updated ban-list of spambots, trolls, bitcoin spammers and unsavoury characters[.](https://telegra.ph/file/f584b643c6f4be0b1de53.jpg) Constantly help banning spammers off from your group automatically So, you wont have to worry about spammers storming your group. *Note:* Users can appeal spamwatch bans at @SpamwatchSupport """ GBAN_HANDLER = CommandHandler("gban", gban) UNGBAN_HANDLER = CommandHandler("ungban", ungban) GBAN_LIST = CommandHandler("gbanlist", gbanlist) GBAN_STATUS = CommandHandler("antispam", gbanstat, filters=Filters.group) GBAN_ENFORCER = MessageHandler(Filters.all & Filters.group, enforce_gban) dispatcher.add_handler(GBAN_HANDLER) dispatcher.add_handler(UNGBAN_HANDLER) dispatcher.add_handler(GBAN_LIST) dispatcher.add_handler(GBAN_STATUS) __mod_name__ = "🔸 AntiSpam" __handlers__ = [GBAN_HANDLER, UNGBAN_HANDLER, GBAN_LIST, GBAN_STATUS] if STRICT_GBAN: # enforce GBANS if this is set dispatcher.add_handler(GBAN_ENFORCER, GBAN_ENFORCE_GROUP) __handlers__.append((GBAN_ENFORCER, GBAN_ENFORCE_GROUP))
cust_filters = sql.get_chat_triggers(chat_id) return "There are `{}` custom filters here.".format(len(cust_filters)) __help__ = """ - /filters: list all active filters in this chat. *Admin only:* - /filter <keyword> <reply message>: add a filter to this chat. The bot will now reply that message whenever 'keyword'\ is mentioned. If you reply to a sticker with a keyword, the bot will reply with that sticker. NOTE: all filter \ keywords are in lowercase. If you want your keyword to be a sentence, use quotes. eg: /filter "hey there" How you \ doin? - /stop <filter keyword>: stop that filter. """ __mod_name__ = "Filters" FILTER_HANDLER = DisableAbleCommandHandler("filter", filters) STOP_HANDLER = DisableAbleCommandHandler("stop", stop_filter) LIST_HANDLER = DisableAbleCommandHandler("filters", list_handlers, admin_ok=True) CUST_FILTER_HANDLER = MessageHandler(CustomFilters.has_text, reply_filter, edited_updates=True) dispatcher.add_handler(FILTER_HANDLER) dispatcher.add_handler(STOP_HANDLER) dispatcher.add_handler(LIST_HANDLER) dispatcher.add_handler(CUST_FILTER_HANDLER, HANDLER_GROUP)
is_afk = sql.is_afk(user_id) text = "<b>Currently AFK</b>: {}" if is_afk: text = text.format("Yes") else: text = text.format("No") return text def __gdpr__(user_id): sql.rm_afk(user_id) AFK_HANDLER = DisableAbleCommandHandler("afk", afk) AFK_REGEX_HANDLER = DisableAbleMessageHandler(Filters.regex("(?i)brb"), afk, friendly="afk") NO_AFK_HANDLER = MessageHandler( Filters.all & Filters.group & ~Filters.update.edited_message, no_longer_afk) AFK_REPLY_HANDLER = MessageHandler(Filters.all & Filters.group, reply_afk) # AFK_REPLY_HANDLER = MessageHandler(Filters.entity(MessageEntity.MENTION) | Filters.entity(MessageEntity.TEXT_MENTION), # reply_afk) dispatcher.add_handler(AFK_HANDLER, AFK_GROUP) dispatcher.add_handler(AFK_REGEX_HANDLER, AFK_GROUP) dispatcher.add_handler(NO_AFK_HANDLER, AFK_GROUP) dispatcher.add_handler(AFK_REPLY_HANDLER, AFK_REPLY_GROUP)
"/reset 'usuario' 'servidor1' 'servidor2' ...": "Formato para reiniciar 1 o varios servidores" } for c in helpReset: bot.send_message(chat_id=update.message.chat_id, text="{}{}{}".format(c, " : ", helpReset.get(c))) text_in += c + ': ' + helpReset.get(c) + '\n' write_logs(bot, update, ["/reset_help"]) bot.send_message(chat_id=update.message.chat_id, text=text_in) updater.start_polling() start_handler = CommandHandler('start', start) dispatcher.add_handler(start_handler) echo_handler = MessageHandler(Filters.text, echo) dispatcher.add_handler(echo_handler) caps_handler = CommandHandler('caps', caps, pass_args=True) dispatcher.add_handler(caps_handler) stop_handler = CommandHandler('stop', stop) dispatcher.add_handler(stop_handler) chat_id_handler = CommandHandler('chat_id', chat_id) dispatcher.add_handler(chat_id_handler) # test_handler = CommandHandler('test', test) # dispatcher.add_handler(test_handler) multi_msg_handler = CommandHandler('multi_msg', multi_msg, pass_args=True)
If you would like to retrieve the contents of a note without any formatting, use `/get <notename> noformat`. This can \ be useful when updating a current note. *Admins only:* • `/save <notename> <notedata>`*:* saves notedata as a note with name notename A button can be added to a note by using standard markdown link syntax - the link should just be prepended with a \ `buttonurl:` section, as such: `[somelink](buttonurl:example.com)`. Check `/markdownhelp` for more info. • `/save <notename>`*:* save the replied message as a note with name notename • `/clear <notename>`*:* clear note with this name *Note:* Note names are case-insensitive, and they are automatically converted to lowercase before getting saved. """ __mod_name__ = "Notes" GET_HANDLER = CommandHandler("get", cmd_get) HASH_GET_HANDLER = MessageHandler(Filters.regex(r"^#[^\s]+"), hash_get) SAVE_HANDLER = CommandHandler("save", save) DELETE_HANDLER = CommandHandler("clear", clear) LIST_HANDLER = DisableAbleCommandHandler(["notes", "saved"], list_notes, admin_ok=True) dispatcher.add_handler(GET_HANDLER) dispatcher.add_handler(SAVE_HANDLER) dispatcher.add_handler(LIST_HANDLER) dispatcher.add_handler(DELETE_HANDLER) dispatcher.add_handler(HASH_GET_HANDLER)
if __name__ == "__main__": settings = get_settings() if settings["proxy"]: updater = Updater( settings["token"], use_context=True, request_kwargs={ "proxy_url": f"socks5h://{settings['proxy_address']}" }, ) else: updater = Updater(settings["token"], use_context=True) dp = updater.dispatcher dp.add_handler( MessageHandler( filters=(Filters.chat_type.groups & Filters.text & Filters.reply), callback=get_code, )) dp.add_handler(CommandHandler("py", python3, Filters.chat_type.groups)) dp.add_handler(CommandHandler("c", clang, Filters.chat_type.groups)) dp.add_handler(CommandHandler("cpp", cpplang, Filters.chat_type.groups)) dp.add_handler(CommandHandler("mysql", mysql, Filters.chat_type.groups)) dp.add_handler( CommandHandler("sqlsv", sql_server, Filters.chat_type.groups)) dp.add_handler(CommandHandler("psql", psql, Filters.chat_type.groups)) dp.add_handler(CommandHandler("go", golang, Filters.chat_type.groups)) updater.start_polling() updater.idle()
def main(): # Setup logging logging.getLogger("pdfminer").setLevel(logging.WARNING) logging.getLogger("ocrmypdf").setLevel(logging.WARNING) redirect_logging() format_string = "{record.level_name}: {record.message}" StreamHandler(sys.stdout, format_string=format_string, level="INFO").push_application() log = Logger() q = mq.MessageQueue(all_burst_limit=3, all_time_limit_ms=3000) request = Request(con_pool_size=8) pdf_bot = MQBot(TELE_TOKEN, request=request, mqueue=q) # Create the EventHandler and pass it your bot's token. updater = Updater( bot=pdf_bot, use_context=True, request_kwargs={ "connect_timeout": TIMEOUT, "read_timeout": TIMEOUT }, ) def stop_and_restart(): updater.stop() os.execl(sys.executable, sys.executable, *sys.argv) def restart(_): Thread(target=stop_and_restart).start() job_queue = updater.job_queue job_queue.run_repeating(restart, interval=dt.timedelta(minutes=30)) # Get the dispatcher to register handlers dispatcher = updater.dispatcher # General commands handlers dispatcher.add_handler(CommandHandler("start", start_msg, run_async=True)) dispatcher.add_handler(CommandHandler("help", help_msg, run_async=True)) dispatcher.add_handler(CommandHandler("setlang", send_lang, run_async=True)) dispatcher.add_handler( CommandHandler("support", send_support_options, run_async=True)) dispatcher.add_handler( CommandHandler("send", send_msg, Filters.user(DEV_TELE_ID))) dispatcher.add_handler( CommandHandler("stats", get_stats, Filters.user(DEV_TELE_ID))) # Callback query handler dispatcher.add_handler( CallbackQueryHandler(process_callback_query, run_async=True)) # Payment handlers dispatcher.add_handler( MessageHandler(Filters.reply & TEXT_FILTER, receive_custom_amount, run_async=True)) dispatcher.add_handler( PreCheckoutQueryHandler(precheckout_check, run_async=True)) dispatcher.add_handler( MessageHandler(Filters.successful_payment, successful_payment, run_async=True)) # URL handler dispatcher.add_handler( MessageHandler(Filters.entity(MessageEntity.URL), url_to_pdf, run_async=True)) # PDF commands handlers dispatcher.add_handler(compare_cov_handler()) dispatcher.add_handler(merge_cov_handler()) dispatcher.add_handler(photo_cov_handler()) dispatcher.add_handler(text_cov_handler()) dispatcher.add_handler(watermark_cov_handler()) # PDF file handler dispatcher.add_handler(file_cov_handler()) # Feedback handler dispatcher.add_handler(feedback_cov_handler()) # Log all errors dispatcher.add_error_handler(error_callback) # Start the Bot if APP_URL is not None: updater.start_webhook(listen="0.0.0.0", port=PORT, url_path=TELE_TOKEN) updater.bot.set_webhook(APP_URL + TELE_TOKEN) log.notice("Bot started webhook") else: updater.start_polling() log.notice("Bot started polling") # Run the bot until the you 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()
reply = msg("reguser_ask_email") return reply, Chat.REGUSER_END @tg_handler(state=Chat.REGUSER_END) def reguser_end(bot, update, agent, chat, botuser): text = update.message.text if botuser is None: botuser = BotUser.objects.create(telegram=agent, email=text) else: botuser.email = text botuser.save() reply = msg("reguser_end_success").format( agent=agent, email=text, user_id=botuser.pk ) return reply, Chat.MAINMENU state_map = { "__meta__": { "caption": msg("mainmenu_reguser_caption"), "entry_state": Chat.REGUSER_ASK_EMAIL, "entry_point": reguser_ask_email, }, "states": { Chat.REGUSER_ASK_EMAIL: [MessageHandler(Filters.text, reguser_ask_email)], Chat.REGUSER_END: [MessageHandler(Filters.text, reguser_end)], }, }
__help__ = """ - /locktypes: a list of possible locktypes *Admin only:* - /lock <type>: lock items of a certain type (not available in private) - /unlock <type>: unlock items of a certain type (not available in private) - /locks: the current list of locks in this chat. Locks can be used to restrict a group's users. eg: Locking urls will auto-delete all messages with urls which haven't been whitelisted, locking stickers will delete all \ stickers, etc. Locking bots will stop non-admins from adding bots to the chat. """ __mod_name__ = "Locks" LOCKTYPES_HANDLER = DisableAbleCommandHandler("locktypes", locktypes) LOCK_HANDLER = CommandHandler("lock", lock, pass_args=True, filters=Filters.group) UNLOCK_HANDLER = CommandHandler("unlock", unlock, pass_args=True, filters=Filters.group) LOCKED_HANDLER = CommandHandler("locks", list_locks, filters=Filters.group) dispatcher.add_handler(LOCK_HANDLER) dispatcher.add_handler(UNLOCK_HANDLER) dispatcher.add_handler(LOCKTYPES_HANDLER) dispatcher.add_handler(LOCKED_HANDLER) dispatcher.add_handler(MessageHandler(Filters.all & Filters.group, del_lockables), PERM_GROUP) dispatcher.add_handler(MessageHandler(Filters.all & Filters.group, rest_handler), REST_GROUP)
user = sql.check_afk_status(user_id) if not user.reason: res = "{} is away from the keyboard ! reason :\n{} ".format( fst_name) else: res = "{} is away from the keyboard ! reason :\n{}. ".format( fst_name, user.reason) message.reply_text(res) __help__ = """ - /afk <reason>: mark yourself as AFK. - brb <reason>: same as the afk command - but not a command. When marked as AFK, any mentions will be replied to with a message to say you're not available! """ __mod_name__ = "AFK" AFK_HANDLER = DisableAbleCommandHandler("afk", afk) AFK_REGEX_HANDLER = DisableAbleRegexHandler("(?i)brb", afk, friendly="afk") NO_AFK_HANDLER = MessageHandler(Filters.all & Filters.group, no_longer_afk) AFK_REPLY_HANDLER = MessageHandler( Filters.entity(MessageEntity.MENTION) | Filters.entity(MessageEntity.TEXT_MENTION), reply_afk) dispatcher.add_handler(AFK_HANDLER, AFK_GROUP) dispatcher.add_handler(AFK_REGEX_HANDLER, AFK_GROUP) dispatcher.add_handler(NO_AFK_HANDLER, AFK_GROUP) dispatcher.add_handler(AFK_REPLY_HANDLER, AFK_REPLY_GROUP)
def __chat_settings__(chat_id, user_id): limit = sql.get_flood_limit(chat_id) if limit == 0: return "*Not* currently enforcing flood control." else: return "മെസ്സേജ് നിയന്ത്രണം `{}` എന്നതിലേക്ക് ആക്കിയിരിക്കുന്നു .".format( limit) __help__ = """ - /flood: നിങ്ങൾക്ക് നിലവിലുള്ള മെസ്സേജ് നിയന്ത്രണം അറിയാൻ.. *Admin only:* - /setflood <int/'no'/'off'>: enables or disables flood control """ __mod_name__ = "നിയന്ത്രണം" FLOOD_BAN_HANDLER = MessageHandler( Filters.all & ~Filters.status_update & Filters.group, check_flood) SET_FLOOD_HANDLER = CommandHandler("setflood", set_flood, pass_args=True, filters=Filters.group) FLOOD_HANDLER = CommandHandler("flood", flood, filters=Filters.group) dispatcher.add_handler(FLOOD_BAN_HANDLER, FLOOD_GROUP) dispatcher.add_handler(SET_FLOOD_HANDLER) dispatcher.add_handler(FLOOD_HANDLER)