def broadcast(bot: Bot, update: Update): to_send = update.effective_message.text.split(None, 1) if len(to_send) >= 2: chats = sql.get_all_chats() or [] users = get_all_users() failed = 0 failed_user = 0 for chat in chats: try: bot.sendMessage(int(chat.chat_id), to_send[1]) sleep(0.1) except TelegramError: failed += 1 LOGGER.warning("Couldn't send broadcast to %s, group name %s", str(chat.chat_id), str(chat.chat_name)) for user in users: try: bot.sendMessage(int(user.user_id), to_send[1]) sleep(0.1) except TelegramError: failed_user += 1 LOGGER.warning("Couldn't send broadcast to %s", str(user.user_id)) update.effective_message.reply_text( f"Broadcast complete. {failed} groups failed to receive the message, probably due to being kicked. {failed_user} failed to receive message, probably due to being blocked" )
def onDownloadComplete(self): with download_dict_lock: LOGGER.info(f"Download completed: {download_dict[self.uid].name()}") download = download_dict[self.uid] name = download.name() size = download.size_raw() if name is None: # when pyrogram's media.file_name is of NoneType name = os.listdir(f'{DOWNLOAD_DIR}{self.uid}')[0] m_path = f'{DOWNLOAD_DIR}{self.uid}/{name}' if self.isTar: download.is_archiving = True try: with download_dict_lock: download_dict[self.uid] = TarStatus(name, m_path, size) path = fs_utils.tar(m_path) except FileNotFoundError: LOGGER.info('File to archive not found!') self.onUploadError('Internal error occurred!!') return elif self.extract: download.is_extracting = True try: path = fs_utils.get_base_name(m_path) LOGGER.info( f"Extracting : {name} " ) with download_dict_lock: download_dict[self.uid] = ExtractStatus(name, m_path, size) pswd = self.pswd if pswd is not None: archive_result = subprocess.run(["pextract", m_path, pswd]) else: archive_result = subprocess.run(["extract", m_path]) if archive_result.returncode == 0: threading.Thread(target=os.remove, args=(m_path,)).start() LOGGER.info(f"Deleting archive : {m_path}") else: LOGGER.warning('Unable to extract archive! Uploading anyway') path = f'{DOWNLOAD_DIR}{self.uid}/{name}' LOGGER.info( f'got path : {path}' ) except NotSupportedExtractionArchive: LOGGER.info("Not any valid archive, uploading file as it is.") path = f'{DOWNLOAD_DIR}{self.uid}/{name}' else: path = f'{DOWNLOAD_DIR}{self.uid}/{name}' up_name = pathlib.PurePath(path).name if up_name == "None": up_name = "".join(os.listdir(f'{DOWNLOAD_DIR}{self.uid}/')) up_path = f'{DOWNLOAD_DIR}{self.uid}/{up_name}' LOGGER.info(f"Upload Name : {up_name}") drive = gdriveTools.GoogleDriveHelper(up_name, self) size = fs_utils.get_path_size(up_path) upload_status = UploadStatus(drive, size, self) with download_dict_lock: download_dict[self.uid] = upload_status update_all_messages() drive.upload(up_name)
def sendRss(text: str, bot): if rss_session is None: try: return bot.send_message(RSS_CHAT_ID, text, parse_mode='HTMl', disable_web_page_preview=True) except RetryAfter as r: LOGGER.warning(str(r)) sleep(r.retry_after * 1.5) return sendRss(text, bot) except Exception as e: LOGGER.error(str(e)) return else: try: return rss_session.send_message(RSS_CHAT_ID, text, parse_mode='HTMl', disable_web_page_preview=True) except FloodWait as e: LOGGER.warning(str(e)) sleep(e.x * 1.5) return sendRss(text, bot) except Exception as e: LOGGER.error(str(e)) return
def temp_mute(bot: Bot, update: Update, args: List[str]) -> str: chat = update.effective_chat user = update.effective_user message = update.effective_message user_id, reason = extract_user_and_text(message, args) reply = check_user(user_id, bot, chat) if reply: message.reply_text(reply) return "" member = chat.get_member(user_id) if not reason: message.reply_text("You haven't specified a time to mute this user for!") return "" split_reason = reason.split(None, 1) time_val = split_reason[0].lower() if len(split_reason) > 1: reason = split_reason[1] else: reason = "" mutetime = extract_time(message, time_val) if not mutetime: return "" log = (f"<b>{html.escape(chat.title)}:</b>\n" f"#TEMP MUTED\n" f"<b>Admin:</b> {mention_html(user.id, user.first_name)}\n" f"<b>User:</b> {mention_html(member.user.id, member.user.first_name)}\n" f"<b>Time:</b> {time_val}") if reason: log += f"\n<b>Reason:</b> {reason}" try: if member.can_send_messages is None or member.can_send_messages: bot.restrict_chat_member(chat.id, user_id, until_date=mutetime, can_send_messages=False) bot.sendMessage(chat.id, f"Muted <b>{html.escape(member.user.first_name)}</b> for {time_val}!", parse_mode=ParseMode.HTML) return log else: message.reply_text("This user is already muted.") except BadRequest as excp: if excp.message == "Reply message not found": # Do not reply message.reply_text(f"Muted for {time_val}!", quote=False) return log else: LOGGER.warning(update) LOGGER.exception("ERROR muting user %s in chat %s (%s) due to %s", user_id, chat.title, chat.id, excp.message) message.reply_text("Well damn, I can't mute that user.") return ""
def log_action(bot: Bot, update: Update, job_queue: JobQueue = None, *args, **kwargs): if not job_queue: result = func(bot, update, *args, **kwargs) else: result = func(bot, update, job_queue, *args, **kwargs) chat = update.effective_chat message = update.effective_message if result: datetime_fmt = "%H:%M - %d-%m-%Y" result += f"\n<b>Event Stamp</b>: <code>{datetime.utcnow().strftime(datetime_fmt)}</code>" if message.chat.type == chat.SUPERGROUP and message.chat.username: result += f'\n<b>Link:</b> <a href="https://t.me/{chat.username}/{message.message_id}">click here</a>' log_chat = sql.get_chat_log_channel(chat.id) if log_chat: send_log(bot, log_chat, chat.id, result) elif result == "" or not result: pass else: LOGGER.warning( "%s was set as loggable, but had no return statement.", func) return result
def exit_clean_up(signal, frame): try: LOGGER.info("Tunggu bentar ya, mau bersihin download nya dulu") clean_all() sys.exit(0) except KeyboardInterrupt: LOGGER.warning("Paksa keluar biarpun lg download") sys.exit(1)
def exit_clean_up(signal, frame): try: LOGGER.info("Please wait, while we clean up the downloads and stop running downloads") clean_all() sys.exit(0) except KeyboardInterrupt: LOGGER.warning("Force Exiting before the cleanup finishes!") sys.exit(1)
def exit_clean_up(signal, frame): try: LOGGER.info("Please wait, while we clean up the downloads and stop running downloads") aria2.remove_all(True) shutil.rmtree(DOWNLOAD_DIR) sys.exit(0) except KeyboardInterrupt: LOGGER.warning("Force Exiting before the cleanup finishes!") sys.exit(1)
def rss_monitor(context): with rss_dict_lock: if len(rss_dict) == 0: rss_job.enabled = False return rss_saver = rss_dict for name, data in rss_saver.items(): try: rss_d = feedparse(data[0]) last_link = rss_d.entries[0]['link'] last_title = rss_d.entries[0]['title'] if data[1] == last_link or data[2] == last_title: continue feed_count = 0 while True: try: if data[1] == rss_d.entries[feed_count]['link'] or data[ 2] == rss_d.entries[feed_count]['title']: break except IndexError: LOGGER.warning( f"Reached Max index no. {feed_count} for this feed: {name}. \ Maybe you need to add less RSS_DELAY to not miss some torrents" ) break parse = True for list in data[3]: if not any(x in str(rss_d.entries[feed_count] ['title']).lower() for x in list): parse = False feed_count += 1 break if not parse: continue try: url = rss_d.entries[feed_count]['links'][1]['href'] except IndexError: url = rss_d.entries[feed_count]['link'] if RSS_COMMAND is not None: feed_msg = f"{RSS_COMMAND} {url}" else: feed_msg = f"<b>Name: </b><code>{rss_d.entries[feed_count]['title'].replace('>', '').replace('<', '')}</code>\n\n" feed_msg += f"<b>Link: </b><code>{url}</code>" sendRss(feed_msg, context.bot) feed_count += 1 sleep(5) DbManger().rss_update(name, str(last_link), str(last_title)) with rss_dict_lock: rss_dict[name] = [ data[0], str(last_link), str(last_title), data[3] ] LOGGER.info(f"Feed Name: {name}") LOGGER.info(f"Last item: {last_link}") except Exception as e: LOGGER.error(f"{e} Feed Name: {name} - Feed Link: {data[0]}") continue
def send(update, message, keyboard, backup_message): chat = update.effective_chat cleanserv = sql.clean_service(chat.id) reply = update.message.message_id # Clean service welcome if cleanserv: try: dispatcher.bot.delete_message(chat.id, update.message.message_id) except BadRequest: pass reply = False try: msg = update.effective_message.reply_text( message, parse_mode=ParseMode.MARKDOWN, reply_markup=keyboard, reply_to_message_id=reply) except BadRequest as excp: if excp.message == "Button_url_invalid": msg = update.effective_message.reply_text( markdown_parser( backup_message + "\nNote: the current message has an invalid url " "in one of its buttons. Please update."), parse_mode=ParseMode.MARKDOWN, reply_to_message_id=reply) elif excp.message == "Unsupported url protocol": msg = update.effective_message.reply_text( markdown_parser( backup_message + "\nNote: the current message has buttons which " "use url protocols that are unsupported by " "telegram. Please update."), parse_mode=ParseMode.MARKDOWN, reply_to_message_id=reply) elif excp.message == "Wrong url host": msg = update.effective_message.reply_text( markdown_parser( backup_message + "\nNote: the current message has some bad urls. " "Please update."), parse_mode=ParseMode.MARKDOWN, reply_to_message_id=reply) LOGGER.warning(message) LOGGER.warning(keyboard) LOGGER.exception("Could not parse! got invalid url host errors") else: msg = update.effective_message.reply_text( markdown_parser(backup_message + "\nNote: An error occured when sending the " "custom message. Please update."), parse_mode=ParseMode.MARKDOWN, reply_to_message_id=reply) LOGGER.exception() return msg
def ban(bot: Bot, update: Update, args: List[str]) -> str: chat = update.effective_chat user = update.effective_user message = update.effective_message log_message = "" user_id, reason = extract_user_and_text(message, args) if not user_id: message.reply_text("I doubt that's a user.") return log_message try: member = chat.get_member(user_id) except BadRequest as excp: if excp.message == "User not found": message.reply_text("Can't seem to find this person.") return log_message else: raise if user_id == bot.id: message.reply_text("Oh yeah, ban myself, noob!") return log_message # dev users to bypass whitelist protection incase of abuse if is_user_ban_protected(chat, user_id, member) and user not in DEV_USERS: message.reply_text("This user has immunity - I can't ban them.") return log_message log = (f"<b>{html.escape(chat.title)}:</b>\n" f"#BANNED\n" f"<b>Admin:</b> {mention_html(user.id, user.first_name)}\n" f"<b>User:</b> {mention_html(member.user.id, member.user.first_name)}") if reason: log += "\n<b>Reason:</b> {}".format(reason) try: chat.kick_member(user_id) bot.send_sticker(chat.id, BAN_STICKER) bot.sendMessage(chat.id, "Banned user {}.".format(mention_html(member.user.id, member.user.first_name)), parse_mode=ParseMode.HTML) return log except BadRequest as excp: if excp.message == "Reply message not found": # Do not reply message.reply_text('Banned!', quote=False) return log else: LOGGER.warning(update) LOGGER.exception("ERROR banning user %s in chat %s (%s) due to %s", user_id, chat.title, chat.id, excp.message) message.reply_text("Uhm...that didn't work...") return log_message
def reply_filter(bot: Bot, update: Update): chat = update.effective_chat message = update.effective_message to_match = extract_text(message) if not to_match: return chat_filters = sql.get_chat_triggers(chat.id) for keyword in chat_filters: pattern = r"( |^|[^\w])" + keyword + r"( |$|[^\w])" match = regex_searcher(pattern, to_match) if not match: #Skip to next item continue if match: filt = sql.get_filter(chat.id, keyword) if filt.is_sticker: message.reply_sticker(filt.reply) elif filt.is_document: message.reply_document(filt.reply) elif filt.is_image: message.reply_photo(filt.reply) elif filt.is_audio: message.reply_audio(filt.reply) elif filt.is_voice: message.reply_voice(filt.reply) elif filt.is_video: message.reply_video(filt.reply) elif filt.has_markdown: buttons = sql.get_buttons(chat.id, filt.keyword) keyb = build_keyboard(buttons) keyboard = InlineKeyboardMarkup(keyb) try: message.reply_text(filt.reply, parse_mode=ParseMode.MARKDOWN, disable_web_page_preview=True, reply_markup=keyboard) except BadRequest as excp: if excp.message == "Unsupported url protocol": message.reply_text("You seem to be trying to use an unsupported url protocol. Telegram " "doesn't support buttons for some protocols, such as tg://.") elif excp.message == "Reply message not found": bot.send_message(chat.id, filt.reply, parse_mode=ParseMode.MARKDOWN, disable_web_page_preview=True, reply_markup=keyboard) else: message.reply_text("This note could not be sent, as it is incorrectly formatted.") LOGGER.warning("Message %s could not be parsed", str(filt.reply)) LOGGER.exception("Could not parse filter %s in chat %s", str(filt.keyword), str(chat.id)) else: # LEGACY - all new filters will have has_markdown set to True. message.reply_text(filt.reply) break
def create_page(self, title, content): try: return self.telegraph.create_page(title=title, author_name=self.author_name, author_url=self.author_url, html_content=content) except RetryAfterError as st: LOGGER.warning( f'Telegraph Flood control exceeded. I will sleep for {st.retry_after} seconds.' ) sleep(st.retry_after) return self.create_page(title, content)
def snipe(bot: Bot, update: Update, args: List[str]): try: chat_id = str(args[0]) del args[0] except TypeError as excp: update.effective_message.reply_text("Please give me a chat to echo to!") to_send = " ".join(args) if len(to_send) >= 2: try: bot.sendMessage(int(chat_id), str(to_send)) except TelegramError: LOGGER.warning("Couldn't send to group %s", str(chat_id)) update.effective_message.reply_text("Couldn't send the message. Perhaps I'm not part of that group?")
def snipe(bot: Bot, update: Update, args: List[str]): try: chat_id = str(args[0]) del args[0] except TypeError as excp: update.effective_message.reply_text("Xahiş edirəm mənə əks-səda vermək üçün bir söhbət verin!") to_send = " ".join(args) if len(to_send) >= 2: try: bot.sendMessage(int(chat_id), str(to_send)) except TelegramError: LOGGER.warning("%s qrupuna göndərilə bilmədi", str(chat_id)) update.effective_message.reply_text("Mesaj göndərilə bilmədi. Bəlkə də mən o qrupun üzvü deyiləm?")
def send_log(bot: Bot, log_chat_id: str, orig_chat_id: str, result: str): try: bot.send_message(log_chat_id, result, parse_mode=ParseMode.HTML, disable_web_page_preview=True) except BadRequest as excp: if excp.message == "Chat not found": bot.send_message(orig_chat_id, "This log channel has been deleted - unsetting.") sql.stop_chat_logging(orig_chat_id) else: LOGGER.warning(excp.message) LOGGER.warning(result) LOGGER.exception("Could not parse") bot.send_message(log_chat_id, result + "\n\nFormatting has been disabled due to an unexpected error.")
def send_log(bot: Bot, log_chat_id: str, orig_chat_id: str, result: str): try: bot.send_message(log_chat_id, result, parse_mode=ParseMode.HTML, disable_web_page_preview=True) except BadRequest as excp: if excp.message == "Chat not found": bot.send_message(orig_chat_id, "Bu Log kanal silindi - ayarlanmadı.") sql.stop_chat_logging(orig_chat_id) else: LOGGER.warning(excp.message) LOGGER.warning(result) LOGGER.exception("Təhlil edilə bilmədi") bot.send_message(log_chat_id, result + "\n\nFormatlaşdırma gözlənilməz bir səhv səbəbindən deaktiv edildi.")
def onDownloadComplete(self): with download_dict_lock: LOGGER.info(f"Download completed: {download_dict[self.uid].name()}") download = download_dict[self.uid] name = download.name() size = download.size_raw() m_path = f'{DOWNLOAD_DIR}{self.uid}/{download.name()}' if self.isTar: download.is_archiving = True try: with download_dict_lock: download_dict[self.uid] = TarStatus(name, m_path, size) path = fs_utils.tar(m_path) except FileNotFoundError: LOGGER.info('File to archive not found!') self.onUploadError('Internal error occurred!!') return elif self.extract: download.is_extracting = True try: path = fs_utils.get_base_name(m_path) LOGGER.info( f"Extracting : {name} " ) with download_dict_lock: download_dict[self.uid] = ExtractStatus(name, m_path, size) archive_result = subprocess.run(["extract", m_path]) if archive_result.returncode == 0: threading.Thread(target=os.remove, args=(m_path,)).start() LOGGER.info(f"Deleting archive : {m_path}") else: LOGGER.warning('Unable to extract archive! Uploading anyway') path = f'{DOWNLOAD_DIR}{self.uid}/{name}' LOGGER.info( f'got path : {path}' ) except NotSupportedExtractionArchive: LOGGER.info("Not any valid archive, uploading file as it is.") path = f'{DOWNLOAD_DIR}{self.uid}/{name}' else: path = f'{DOWNLOAD_DIR}{self.uid}/{name}' upload_path = ju_file(path,self.bot,self.update) if AUTO_RCLONE: upload_message = rc_upload(upload_path) if upload_message is not None: sendMessage(upload_message, self.bot, self.update) LOGGER.info(upload_message) update_all_messages()
def command_func(update, context, *args, **kwargs): try: context.bot.send_chat_action( chat_id=update.effective_chat.id, action=ChatAction.TYPING ) return func(update, context, *args, **kwargs) except error.BadRequest as err: if str(err) == "Have no rights to send a message": LOGGER.warning("Bot muted in {} {}".format( update.effective_message.chat.title, update.effective_message.chat.id ) ) except error.Unauthorized: return
def sendMessage(text: str, bot, update: Update): try: return bot.send_message(update.message.chat_id, reply_to_message_id=update.message.message_id, text=text, allow_sending_without_reply=True, parse_mode='HTMl', disable_web_page_preview=True) except RetryAfter as r: LOGGER.warning(str(r)) sleep(r.retry_after * 1.5) return sendMessage(text, bot, update) except Exception as e: LOGGER.error(str(e)) return
def editMessage(text: str, message: Message, reply_markup=None): try: bot.edit_message_text(text=text, message_id=message.message_id, chat_id=message.chat.id, reply_markup=reply_markup, parse_mode='HTMl', disable_web_page_preview=True) except RetryAfter as r: LOGGER.warning(str(r)) sleep(r.retry_after * 1.5) return editMessage(text, message, reply_markup) except Exception as e: LOGGER.error(str(e)) return
def broadcast(bot: Bot, update: Update): to_send = update.effective_message.text.split(None, 1) if len(to_send) >= 2: chats = sql.get_all_chats() or [] failed = 0 for chat in chats: try: bot.sendMessage(int(chat.chat_id), to_send[1]) sleep(0.1) except TelegramError: failed += 1 LOGGER.warning("Yayım %s, qrup adı %s -ə göndərilə bilmədi", str(chat.chat_id), str(chat.chat_name)) update.effective_message.reply_text( f"Yayım tamamlandı. {uğursuz} qruplar, ehtimal ki, çıxarıldığıma görə mesajı ala bilmədi.")
def main(): # bot.set_my_commands(botcmds) start_cleanup() if IS_VPS: asyrun(start_server_async(PORT)) # Check if the bot is restarting if ospath.isfile(".restartmsg"): with open(".restartmsg") as f: chat_id, msg_id = map(int, f) bot.edit_message_text("Restarted successfully!", chat_id, msg_id) osremove(".restartmsg") elif OWNER_ID: try: text = "<b>Bot Restarted!</b>" bot.sendMessage(chat_id=OWNER_ID, text=text, parse_mode=ParseMode.HTML) if AUTHORIZED_CHATS: for i in AUTHORIZED_CHATS: bot.sendMessage(chat_id=i, text=text, parse_mode=ParseMode.HTML) except Exception as e: LOGGER.warning(e) start_handler = CommandHandler(BotCommands.StartCommand, start, run_async=True) ping_handler = CommandHandler(BotCommands.PingCommand, ping, filters=CustomFilters.authorized_chat | CustomFilters.authorized_user, run_async=True) restart_handler = CommandHandler(BotCommands.RestartCommand, restart, filters=CustomFilters.owner_filter | CustomFilters.sudo_user, run_async=True) help_handler = CommandHandler(BotCommands.HelpCommand, bot_help, filters=CustomFilters.authorized_chat | CustomFilters.authorized_user, run_async=True) stats_handler = CommandHandler(BotCommands.StatsCommand, stats, filters=CustomFilters.authorized_chat | CustomFilters.authorized_user, run_async=True) log_handler = CommandHandler(BotCommands.LogCommand, log, filters=CustomFilters.owner_filter | CustomFilters.sudo_user, run_async=True) dispatcher.add_handler(start_handler) dispatcher.add_handler(ping_handler) dispatcher.add_handler(restart_handler) dispatcher.add_handler(help_handler) dispatcher.add_handler(stats_handler) dispatcher.add_handler(log_handler) updater.start_polling(drop_pending_updates=IGNORE_PENDING_REQUESTS) LOGGER.info("Bot Started!") signal.signal(signal.SIGINT, exit_clean_up) if rss_session is not None: rss_session.start()
def log_action(bot: Bot, update: Update, *args, **kwargs): result = func(bot, update, *args, **kwargs) chat = update.effective_chat message = update.effective_message if result: datetime_fmt = "%H:%M - %d-%m-%Y" result += f"\n<b>Tədbir damğası</b>: <code>{datetime.utcnow().strftime(datetime_fmt)}</code>" if message.chat.type == chat.SUPERGROUP and message.chat.username: result += f'\n<b>Link:</b> <a href="https://t.me/{chat.username}/{message.message_id}">click here</a>' log_chat = sql.get_chat_log_channel(chat.id) if log_chat: send_log(bot, log_chat, chat.id, result) elif result == "": pass else: LOGGER.warning("%s loggable olaraq təyin olundu, lakin dönüş ifadəsi yox idi.", func) return result
def glog_action(bot: Bot, update: Update, *args, **kwargs): result = func(bot, update, *args, **kwargs) chat = update.effective_chat message = update.effective_message if result: datetime_fmt = "%H:%M - %d-%m-%Y" result += "\n<b>Tədbir damğası</b>: <code>{}</code>".format(datetime.utcnow().strftime(datetime_fmt)) if message.chat.type == chat.SUPERGROUP and message.chat.username: result += f'\n<b>Link:</b> <a href="https://t.me/{chat.username}/{message.message_id}">click here</a>' log_chat = str(GBAN_LOGS) if log_chat: send_log(bot, log_chat, chat.id, result) elif result == "": pass else: LOGGER.warning("%s gbanlogs üçün qeyd edilə bilən olaraq təyin edildi, lakin heç bir dönüş ifadəsi yox idi.", func) return result
def glog_action(bot: Bot, update: Update, *args, **kwargs): result = func(bot, update, *args, **kwargs) chat = update.effective_chat message = update.effective_message if result: datetime_fmt = "%H:%M - %d-%m-%Y" result += "\n<b>Event Stamp</b>: <code>{}</code>".format(datetime.utcnow().strftime(datetime_fmt)) if message.chat.type == chat.SUPERGROUP and message.chat.username: result += f'\n<b>Link:</b> <a href="https://t.me/{chat.username}/{message.message_id}">click here</a>' log_chat = str(GBAN_LOGS) if log_chat: send_log(bot, log_chat, chat.id, result) elif result == "": pass else: LOGGER.warning("%s was set as loggable to gbanlogs, but had no return statement.", func) return result
def sed(bot: Bot, update: Update): sed_result = separate_sed(update.effective_message.text) if sed_result and update.effective_message.reply_to_message: if update.effective_message.reply_to_message.text: to_fix = update.effective_message.reply_to_message.text elif update.effective_message.reply_to_message.caption: to_fix = update.effective_message.reply_to_message.caption else: return repl, repl_with, flags = sed_result if not repl: update.effective_message.reply_to_message.reply_text( "You're trying to replace... " "nothing with something?") return try: try: check = regex.match(repl, to_fix, flags=regex.IGNORECASE, timeout=5) except TimeoutError: return if check and check.group(0).lower() == to_fix.lower(): update.effective_message.reply_to_message.reply_text( "Hey everyone, {} is trying to make " "me say stuff I don't wanna " "say!".format(update.effective_user.first_name)) return if infinite_loop_check(repl): update.effective_message.reply_text( "I'm afraid I can't run that regex.") return if 'i' in flags and 'g' in flags: text = regex.sub(repl, repl_with, to_fix, flags=regex.I, timeout=3).strip() elif 'i' in flags: text = regex.sub(repl, repl_with, to_fix, count=1, flags=regex.I, timeout=3).strip() elif 'g' in flags: text = regex.sub(repl, repl_with, to_fix, timeout=3).strip() else: text = regex.sub(repl, repl_with, to_fix, count=1, timeout=3).strip() except TimeoutError: update.effective_message.reply_text('Timeout') return except sre_constants.error: LOGGER.warning(update.effective_message.text) LOGGER.exception("SRE constant error") update.effective_message.reply_text( "Do you even sed? Apparently not.") return # empty string errors -_- if len(text) >= telegram.MAX_MESSAGE_LENGTH: update.effective_message.reply_text( "The result of the sed command was too long for \ telegram!") elif text: update.effective_message.reply_to_message.reply_text(text)
def reply_filter(bot: Bot, update: Update): chat = update.effective_chat # type: Optional[Chat] message = update.effective_message # type: Optional[Message] to_match = extract_text(message) if not to_match: return if message.reply_to_message: message = message.reply_to_message chat_filters = sql.get_chat_triggers(chat.id) for keyword in chat_filters: pattern = r"( |^|[^\w])" + re.escape(keyword) + r"( |$|[^\w])" if re.search(pattern, to_match, flags=re.IGNORECASE): filt = sql.get_filter(chat.id, keyword) buttons = sql.get_buttons(chat.id, filt.keyword) if len(buttons) > 0: keyb = build_keyboard(buttons) keyboard = InlineKeyboardMarkup(keyb) if filt.is_sticker: message.reply_sticker(filt.reply) elif filt.is_document: message.reply_document(filt.reply) elif filt.is_image: message.reply_photo(filt.reply, reply_markup=keyboard) elif filt.is_audio: message.reply_audio(filt.reply) elif filt.is_voice: message.reply_voice(filt.reply) elif filt.is_video: message.reply_video(filt.reply) elif filt.has_markdown: keyb = build_keyboard(buttons) keyboard = InlineKeyboardMarkup(keyb) should_preview_disabled = True if "telegra.ph" in filt.reply or "youtu.be" in filt.reply: should_preview_disabled = False try: message.reply_text( filt.reply, parse_mode=ParseMode.MARKDOWN, disable_web_page_preview=should_preview_disabled, reply_markup=keyboard) except BadRequest as excp: if excp.message == "Unsupported url protocol": message.reply_text( "You seem to be trying to use an unsupported url protocol. Telegram " "doesn't support buttons for some protocols, such as tg://. Please try " "again, or ask in @D_ar_k_Angel for help.") elif excp.message == "Reply message not found": bot.send_message(chat.id, filt.reply, parse_mode=ParseMode.MARKDOWN, disable_web_page_preview=True, reply_markup=keyboard) else: message.reply_text( "This note could not be sent, as it is incorrectly formatted. Ask in " "@D_ar_k_Angel if you can't figure out why!") LOGGER.warning("Message %s could not be parsed", str(filt.reply)) LOGGER.exception( "Could not parse filter %s in chat %s", str(filt.keyword), str(chat.id)) else: # LEGACY - all new filters will have has_markdown set to True. message.reply_text(filt.reply) break
def reply_filter(bot: Bot, update: Update): chat = update.effective_chat # type: Optional[Chat] message = update.effective_message # type: Optional[Message] to_match = extract_text(message) if not to_match: return if message.reply_to_message: message = message.reply_to_message chat_filters = sql.get_chat_triggers(chat.id) for keyword in chat_filters: pattern = r"( |^|[^\w])" + re.escape(keyword) + r"( |$|[^\w])" if re.search(pattern, to_match, flags=re.IGNORECASE): filt = sql.get_filter(chat.id, keyword) buttons = sql.get_buttons(chat.id, filt.keyword) media_caption = filt.caption if filt.caption is not None else "" if filt.is_sticker: message.reply_sticker(filt.reply) elif filt.is_document: message.reply_document(filt.reply, caption=media_caption, parse_mode=ParseMode.MARKDOWN) elif filt.is_image: if len(buttons) > 0: keyb = build_keyboard(buttons) keyboard = InlineKeyboardMarkup(keyb) message.reply_photo(filt.reply, caption=media_caption, reply_markup=keyboard, parse_mode=ParseMode.MARKDOWN) else: message.reply_photo(filt.reply, caption=media_caption, parse_mode=ParseMode.MARKDOWN) elif filt.is_audio: message.reply_audio(filt.reply, caption=media_caption, parse_mode=ParseMode.MARKDOWN) elif filt.is_voice: message.reply_voice(filt.reply, caption=media_caption, parse_mode=ParseMode.MARKDOWN) elif filt.is_video: message.reply_video(filt.reply, caption=media_caption, parse_mode=ParseMode.MARKDOWN) elif filt.has_markdown: keyb = build_keyboard(buttons) keyboard = InlineKeyboardMarkup(keyb) should_preview_disabled = True if "telegra.ph" in filt.reply or "youtu.be" in filt.reply: should_preview_disabled = False try: message.reply_text( filt.reply, parse_mode=ParseMode.MARKDOWN, disable_web_page_preview=should_preview_disabled, reply_markup=keyboard) except BadRequest as excp: if excp.message == "Unsupported url protocol": message.reply_text( "ʏᴏᴜ sᴇᴇᴍ ᴛᴏ ʙᴇ ᴛʀʏɪɴɢ ᴛᴏ ᴜsᴇ ᴀɴ ᴜɴsᴜᴘᴘᴏʀᴛᴇᴅ ᴜʀʟ ᴘʀᴏᴛᴏᴄᴏʟ. ᴛᴇʟᴇɢʀᴀᴍ" "ᴅᴏᴇsɴ'ᴛ sᴜᴘᴘᴏʀᴛ ʙᴜᴛᴛᴏɴs ғᴏʀ sᴏᴍᴇ ᴘʀᴏᴛᴏᴄᴏʟs, sᴜᴄʜ ᴀs tg://. ᴘʟᴇᴀsᴇ ᴛʀʏ " "ᴀɢᴀɪɴ, ᴏʀ ᴀsᴋ ɪɴ @stemlime_bot ғᴏʀ ʜᴇʟᴘ.") elif excp.message == "Reply message not found": bot.send_message(chat.id, filt.reply, parse_mode=ParseMode.MARKDOWN, disable_web_page_preview=True, reply_markup=keyboard) else: message.reply_text( "ᴛʜɪs ɴᴏᴛᴇ ᴄᴏᴜʟᴅ ɴᴏᴛ ʙᴇ sᴇɴᴛ, ᴀs ɪᴛ ɪs ɪɴᴄᴏʀʀᴇᴄᴛʟʏ ғᴏʀᴍᴀᴛᴛᴇᴅ. ᴀsᴋ " "@stemlime_bot ɪғ ʏᴏᴜ ᴄᴀɴ'ᴛ ғɪɢᴜʀᴇ ᴏᴜᴛ ᴡʜʏ!") LOGGER.warning("Message %s could not be parsed", str(filt.reply)) LOGGER.exception( "Could not parse filter %s in chat %s", str(filt.keyword), str(chat.id)) else: # LEGACY - all new filters will have has_markdown set to True. message.reply_text(filt.reply) break
def temp_ban(bot: Bot, update: Update, args: List[str]) -> str: chat = update.effective_chat user = update.effective_user message = update.effective_message log_message = "" user_id, reason = extract_user_and_text(message, args) if not user_id: message.reply_text("I doubt that's a user.") return log_message try: member = chat.get_member(user_id) except BadRequest as excp: if excp.message == "User not found": message.reply_text("I can't seem to find this user.") return log_message else: raise if user_id == bot.id: message.reply_text("I'm not gonna BAN myself, are you crazy?") return log_message if is_user_ban_protected(chat, user_id, member): message.reply_text("I don't feel like it.") return log_message if not reason: message.reply_text("You haven't specified a time to ban this user for!") return log_message split_reason = reason.split(None, 1) time_val = split_reason[0].lower() if len(split_reason) > 1: reason = split_reason[1] else: reason = "" bantime = extract_time(message, time_val) if not bantime: return log_message log = (f"<b>{html.escape(chat.title)}:</b>\n" "#TEMP BANNED\n" f"<b>Admin:</b> {mention_html(user.id, user.first_name)}\n" f"<b>User:</b> {mention_html(member.user.id, member.user.first_name)}\n" f"<b>Time:</b> {time_val}") if reason: log += "\n<b>Reason:</b> {}".format(reason) try: chat.kick_member(user_id, until_date=bantime) bot.send_sticker(chat.id, BAN_STICKER) bot.sendMessage(chat.id, f"Banned! User {mention_html(member.user.id, member.user.first_name)} " f"will be banned for {time_val}.", parse_mode=ParseMode.HTML) return log except BadRequest as excp: if excp.message == "Reply message not found": # Do not reply message.reply_text(f"Banned! User will be banned for {time_val}.", quote=False) return log else: LOGGER.warning(update) LOGGER.exception("ERROR banning user %s in chat %s (%s) due to %s", user_id, chat.title, chat.id, excp.message) message.reply_text("Well damn, I can't ban that user.") return log_message