def init(client: '_client.Userge') -> None: """ initialize the conversation method """ async def _on_conversation(_, msg: RawMessage) -> None: data = _CONV_DICT[msg.chat.id] if isinstance(data, asyncio.Queue): data.put_nowait(msg) elif msg.from_user and msg.from_user.id == data[0]: data[1].put_nowait(msg) msg.continue_propagation() client.add_handler( MessageHandler( _on_conversation, filters.create( lambda _, __, query: _CONV_DICT and query.chat and query. chat.id in _CONV_DICT, 0)))
def __init__(self, command: str, source: str, result_str: str): self.command = command self.source = source.rstrip('/') self.RESULT_STR = result_str app.add_handler( MessageHandler( self.find, filters.command([command, f'{self.command}@{bot.username}']))) app.add_handler( CallbackQueryHandler(self.previous, filters.regex(f"{self.command}_previous"))) app.add_handler( CallbackQueryHandler(self.delete, filters.regex(f"{self.command}_delete"))) app.add_handler( CallbackQueryHandler(self.next, filters.regex(f"{self.command}_next")))
def init_message_handler(self) -> None: if self._listen_to_group[0] == 0: raise ValueError('listen_to_group value must be set') self.client_group[0].add_handler( MessageHandler( self.handle_set_target, filters.chat(self.owner) & filters.command('target'))) self.client_group[0].add_handler( MessageHandler( self.handle_resend_command, filters.user(self.owner) & filters.chat(self._listen_to_group) & filters.command('resend'))) self.client_group[0].add_handler( MessageHandler(self.handle_toggle_debug_command, filters.chat(self.owner) & filters.command('debug'))) self.client_group[0].add_handler( MessageHandler( self.handle_normal_resident, filters.chat(self._listen_to_group) & filters.user(self.WEREWOLF_BOT_ID) & filters.text)) self.client_group[0].add_handler( MessageHandler( self.handle_join_game, filters.chat(self._listen_to_group) & filters.user(self.WEREWOLF_BOT_ID))) self.client_group[0].add_handler( MessageHandler( self.handle_close_auto_join, filters.chat(self._listen_to_group) & filters.command('off'))) self.client_group[0].add_handler( MessageHandler( self.handle_set_num_worker, filters.chat(self._listen_to_group) & filters.command('setw'))) for x in self.client_group: x.add_handler( MessageHandler( self.handle_werewolf_game, filters.chat(self.WEREWOLF_BOT_ID) & filters.incoming)) logger.debug('Current workers: %d', len(self.client_group))
async def start(self: "Bot") -> None: self.log.info("Starting") await self.init_client() # Load modules self.load_all_modules() await self.dispatch_event("load") self.loaded = True # iter first because can't use *.keys() commands = [] for cmd in self.commands.keys(): commands.append(cmd) self.client.add_handler( MessageHandler(self.on_command, filters=(pyrogram.filters.command( commands, prefixes=".", case_sensitive=True) & pyrogram.filters.me & pyrogram.filters.outgoing)), 0) async with silent(): await self.client.start() user = await self.client.get_me() if not isinstance(user, pyrogram.types.User): raise TypeError("Missing full self user information") self.user = user self.uid = user.id await self.dispatch_event("start") self.log.info("Bot is ready") await self.dispatch_event("aria", await aria.initialize(self.http)) self.aria = aria2p.API( aria2p.Client(host="http://localhost", port=6800, secret="")) await self.dispatch_event("started")
async def get_name(client, message): """ Отримання імені Відсутнє обмеження на знаки/цифри і т.д., щоб обмежити це - при додаванні хендлера get_name можна додати filters.regex("^[a-zA-Z]+$") """ # Збережемо вибір статі в історію активності append_history(message.from_user.id, "Get name") # Name: 2-20 chars if 2 <= len(message.text) <= 20: await message.reply_text(f'Окей, {message.text}.') # Зберігаємо попереднє значення імені користувача previous_name = active_users[message.from_user.id]["name"] # Записуємо ім'я в словник під ключем телеграм айді користувача active_users[message.from_user.id]["name"] = message.text # Видаляємо попередній handler на отримання імені delete_handlers(message.from_user.id) # Якщо під ключем age вже було значення, це значить handler був доданий у change_age() if previous_name: # Зберігаємо інформацію про користувача await save_information(message) else: await message.reply_text("Введіть Ваш вік") # Створюємо новий handler на отримання віку active_users[message.from_user.id]["handler"].append( app.add_handler( MessageHandler(get_age, filters.regex("^[0-9]+$") & filters.user(message.from_user.id) & filters.private)) ) else: await message.reply_text("Ім'я повинно містити 2-20 літер")
def run(self) -> None: logger.info(mp.current_process().name) logger.info(threading.current_thread()) client = get_client(self.client_name, False) client.start() self.client = client me = client.get_me() logger.info(me) client.add_handler(DisconnectHandler(self.on_disconnect)) client.add_handler(MessageHandler(self.on_message)) client.add_handler(RawUpdateHandler(self.on_raw_update)) worker = ClientWorkerThread( client=client, index=0, db=self.db, task_queues=self.task_queues, ) worker.start() idle() client.stop()
def init_message_handler(self) -> None: self.app.add_handler( MessageHandler(self.handle_auth, filters.command('auth') & filters.private)) self.app.add_handler( MessageHandler(self.pre_check, filters.text & filters.private)) self.app.add_handler( MessageHandler(self.handle_passcode, filters.text & filters.private)) self.app.add_handler(CallbackQueryHandler(self.handle_callback_query)) self.app.add_handler( MessageHandler(self.pre_check_owner, filters.text & filters.private)) self.app.add_handler( MessageHandler(self.query_history, filters.command('h') & filters.private)) self.app.add_handler( MessageHandler(self.delete_user_manual, filters.command('del') & filters.private))
def prepare(self): admin_filter = filters.chat(self._config.admins) & filters.private self._mtproto.register( MessageHandler(self._new_document, filters.document & admin_filter)) self._mtproto.register( MessageHandler(self._new_document, filters.video & admin_filter)) self._mtproto.register( MessageHandler(self._new_document, filters.audio & admin_filter)) self._mtproto.register( MessageHandler(self._new_document, filters.animation & admin_filter)) self._mtproto.register( MessageHandler(self._new_document, filters.voice & admin_filter)) self._mtproto.register( MessageHandler(self._new_document, filters.video_note & admin_filter)) state_filter = create(lambda _, __, m: self._state_machine.get_state(m) [0] == States.SELECT) self._mtproto.register( MessageHandler(self._select_device, filters.text & admin_filter & state_filter))
from pyrogram import filters from pyrogram.handlers import MessageHandler from pyrogram.types import InlineKeyboardMarkup, InlineKeyboardButton from config import BANNED from strings import get_string as _ async def start(client, message): await message.reply_text(_("start_1", True), reply_markup=InlineKeyboardMarkup([[ InlineKeyboardButton( _("start_2"), switch_inline_query_current_chat="") ]])) __handlers__ = [[ MessageHandler(start, filters.command("start", "/") & filters.private & ~BANNED) ]] __help__ = {"start": [_("help_start"), False]}
if __name__ == "__main__": # create download directory, if not exist if not os.path.isdir(DOWNLOAD_LOCATION): os.makedirs(DOWNLOAD_LOCATION) # app = Client(SESSION_NAME, bot_token=TG_BOT_TOKEN, api_id=APP_ID, api_hash=API_HASH, workers=2) # app.set_parse_mode("html") # # STATUS ADMIN Command incoming_status_command = MessageHandler( sts, filters=filters.command(["status"]) & filters.user(AUTH_USERS)) app.add_handler(incoming_status_command) # BAN Admin Command incoming_ban_command = MessageHandler(ban, filters=filters.command(["ban_user"]) & filters.user(AUTH_USERS)) app.add_handler(incoming_ban_command) # UNBAN Admin Command incoming_unban_command = MessageHandler( unban, filters=filters.command(["unban_user"]) & filters.user(AUTH_USERS)) app.add_handler(incoming_unban_command) # BANNED_USERS Admin Command
def init_handle(self) -> None: self.app.add_handler( MessageHandler(self.get_msg_from_owner_group, filters.chat(self.owner_group_id) & filters.reply)) self.app.add_handler( MessageHandler( self.get_command_from_target, filters.chat(self.configure.predefined_group_list) & filters.text & filters.reply)) self.app.add_handler( MessageHandler( self.pre_check, filters.media & ~filters.private & ~filters.sticker & ~filters.voice & ~filters.web_page)) self.app.add_handler( MessageHandler( self.handle_photo, filters.photo & ~filters.private & ~filters.chat([self.configure.photo, self.configure.lowq]))) self.app.add_handler( MessageHandler( self.handle_video, filters.video & ~filters.private & ~filters.chat(self.configure.video))) self.app.add_handler( MessageHandler( self.handle_gif, filters.animation & ~filters.private & ~filters.chat(self.configure.gif))) self.app.add_handler( MessageHandler( self.handle_document, filters.document & ~filters.private & ~filters.chat(self.configure.doc))) self.app.add_handler( MessageHandler( self.handle_other, filters.media & ~filters.private & ~filters.sticker & ~filters.voice & ~filters.web_page)) self.app.add_handler(MessageHandler(self.pre_private, filters.private)) self.app.add_handler( MessageHandler(self.handle_add_bypass, filters.command('e') & filters.private)) self.app.add_handler( MessageHandler(self.process_query, filters.command('q') & filters.private)) self.app.add_handler( MessageHandler(self.handle_add_black_list, filters.command('b') & filters.private)) self.app.add_handler( MessageHandler(self.process_show_detail, filters.command('s') & filters.private)) self.app.add_handler( MessageHandler( self.set_forward_target_reply, filters.command('f') & filters.reply & filters.private)) self.app.add_handler( MessageHandler(self.set_forward_target, filters.command('f') & filters.private)) self.app.add_handler( MessageHandler(self.add_user, filters.command('a') & filters.private)) self.app.add_handler( MessageHandler(self.change_code, filters.command('pw') & filters.private)) self.app.add_handler( MessageHandler(self.undo_blacklist_operation, filters.command('undo') & filters.private)) self.app.add_handler( MessageHandler(self.switch_detail2, filters.command('sd2') & filters.private)) self.app.add_handler( MessageHandler(self.switch_detail, filters.command('sd') & filters.private)) self.app.add_handler( MessageHandler(self.show_help_message, filters.command('help') & filters.private)) self.app.add_handler( MessageHandler(self.process_private, filters.private))
def decorator(func): async def wrapper(client, message): chat_type = message.chat.type if only_if_admin and not await is_admin_or_owner( message, (client.me).id): await edit_or_reply( message, "`This Command Only Works, If You Are Admin Of The Chat!`") return if group_only and chat_type != "supergroup": await edit_or_reply(message, "`Are you sure this is a group?`") return if chnnl_only and chat_type != "channel": await edit_or_reply(message, "This Command Only Works In Channel!") return if pm_only and chat_type != "private": await edit_or_reply(message, "`This Cmd Only Works On PM!`") return if ignore_errors: await func(client, message) else: try: await func(client, message) except StopPropagation: raise StopPropagation except KeyboardInterrupt: pass except MessageNotModified: pass except MessageIdInvalid: logging.warning( "Please Don't Delete Commands While it's Processing..") except UserNotParticipant: pass except ContinuePropagation: raise ContinuePropagation except BaseException as e: logging.error( f"Exception - {func.__module__} - {func.__name__}") TZ = pytz.timezone(Config.TZ) datetime_tz = datetime.now(TZ) text = "**!ERROR - REPORT!**\n\n" text += f"\n**Trace Back : ** `{str(format_exc())}`" text += f"\n**Plugin-Name :** `{func.__module__}`" text += f"\n**Function Name :** `{func.__name__}` \n" text += datetime_tz.strftime( "**Date :** `%Y-%m-%d` \n**Time :** `%H:%M:%S`") text += "\n\n__You can Forward This to @WhiteDevil_Support, If You Think This is Serious A Error!__" try: await client.send_message(Config.LOG_GRP, text) except BaseException: logging.error(text) message.continue_propagation() Friday.add_handler(MessageHandler(wrapper, filters=filterm), group) if Friday2: Friday2.add_handler(MessageHandler(wrapper, filters=filterm), group) if Friday3: Friday3.add_handler(MessageHandler(wrapper, filters=filterm), group) if Friday4: Friday4.add_handler(MessageHandler(wrapper, filters=filterm), group) return wrapper
from pyrogram import filters from pyrogram.handlers import MessageHandler import player from helpers import State from config import SUDO_FILTER from strings import get_string as _ def skip(client, message): if player.STATE in (State.Playing, State.Streaming, State.Paused): player.STATE = State.Skipped player.abort() message.reply_text(_("skip_1")) else: message.reply_text(_("skip_2")) __handlers__ = [[ MessageHandler(skip, filters.command("skip", "/") & SUDO_FILTER) ]] __help__ = {"skip": [_("help_skip"), True]}
download( (m.edit, (_("downloading"), )), (m.edit, (_("downloaded_scheduled").format(player.q.qsize() + 1), )), [ player.play, [ None, (message.reply_text, (_("playing"), )), (message.reply_text, (_("finished_playing"), )), None, None, message.from_user.id, message.from_user.first_name, [ client.send_message, [ LOG_GROUP, _("group_log").format( "<a href=\"{}\">{}</a>", "<a href=\"tg://user?id={}\">{}</a>", "{}") ] ] if LOG_GROUP else None, None, (message.reply_text, (_("on_skip"), )) ] ], (m.edit, (_("not_live"), )), message.text, (m.edit, (_("err_occ"), )), [m.edit, [ _("dur_limit"), ]]) __handlers__ = [[ MessageHandler(message, filters.text & filters.private & ~filters.regex(r"^x .+")), 2 ]]
def start_bot(): scheduler = BlockingScheduler() scheduler = BackgroundScheduler() scheduler.add_job(new_clock, "interval", seconds=60) scheduler.add_job(second_clock, "interval", seconds=60) scheduler.start() print("开启监控") sys.stdout.flush() print("开始bot") print(Telegram_user_id) sys.stdout.flush() aria2.listen_to_notifications(on_download_complete=check_upload, threaded=True) start_message_handler = MessageHandler( test, filters=filters.command("start") & filters.user(int(Telegram_user_id)) filters=filters.command("start") & filters.create(chexk_group) ) pixivuser_message_handler = MessageHandler( start_download_pixiv, filters=filters.command("pixivuser") & filters.user(int(Telegram_user_id)) ) pixivid_message_handler = MessageHandler( start_download_id, filters=filters.command("pixivpid") & filters.user(int(Telegram_user_id)) ) magfile_message_handler = MessageHandler( send_telegram_file, filters=filters.command("magfile") & filters.user(int(Telegram_user_id)) ) http_download_message_handler = MessageHandler( start_http_download, filters=filters.command("mirror") & filters.user(int(Telegram_user_id)) ) magnet_download_message_handler = MessageHandler( start_download, filters=filters.command("magnet") & filters.user(int(Telegram_user_id)) ) telegram_file_message_handler = MessageHandler( get_telegram_file, filters=filters.command("downtgfile") & filters.user(int(Telegram_user_id)) ) seach_main_file_message_handler = MessageHandler( seach_main, filters=filters.command("search") & filters.user(int(Telegram_user_id)) ) start_download_idtg_message_handler = MessageHandler( start_download_pixivtg, filters=filters.command("pixivusertg") & filters.user(int(Telegram_user_id)) ) start_http_downloadtg_message_handler = MessageHandler( start_http_downloadtg, filters=filters.command("mirrortg") & filters.user(int(Telegram_user_id)) ) start_rclonecopy_message_handler = MessageHandler( start_rclonecopy, filters=filters.command("rclonecopy") & filters.user(int(Telegram_user_id)) ) start_rclonelsd_message_handler = MessageHandler( start_rclonelsd, filters=filters.command("rclonelsd") & filters.user(int(Telegram_user_id)) ) start_rclone_message_handler = MessageHandler( start_rclonels, filters=filters.command("rclone") & filters.user(int(Telegram_user_id)) ) start_rclonecopyurl_message_handler = MessageHandler( start_rclonecopyurl, filters=filters.command("rclonecopyurl") & filters.user(int(Telegram_user_id)) ) get_file_id_message_handler = MessageHandler( get_file_id, filters=filters.command("getfileid") & filters.user(int(Telegram_user_id)) ) sendfile_by_id_message_handler = MessageHandler( sendfile_by_id, filters=filters.command("getfile") & filters.user(int(Telegram_user_id)) ) start_download_pixivphoto_message_handler = MessageHandler( start_download_pixivphoto, filters=filters.command("pixivuserphoto") & filters.user(int(Telegram_user_id)) ) start_download_pixivtele_message_handler = MessageHandler( start_download_pixivtele, filters=filters.command("pixivusertele") & filters.user(int(Telegram_user_id)) ) start_get_video_info_message_handler = MessageHandler( start_get_video_info, filters=filters.command("video") & filters.user(int(Telegram_user_id)) ) start_Resume_handler = CallbackQueryHandler( callback=start_Resume, filters=filters.create(lambda _, __, query: "Resume" in query.data ) ) start_pause_handler = CallbackQueryHandler( callback=start_pause, filters=filters.create(lambda _, __, query: "Pause" in query.data ) ) start_remove_handler = CallbackQueryHandler( callback=start_remove, filters=filters.create(lambda _, __, query: "Remove" in query.data ) ) start_benzi_down_handler = CallbackQueryHandler( callback=start_benzi_down, filters=filters.create(lambda _, __, query: "down" in query.data ) ) start_download_video_handler = CallbackQueryHandler( callback=start_download_video, filters=filters.create(lambda _, __, query: "video" in query.data ) ) client.add_handler(start_download_video_handler, group=0) client.add_handler(start_Resume_handler, group=0) client.add_handler(start_pause_handler, group=0) client.add_handler(start_remove_handler, group=0) client.add_handler(start_benzi_down_handler, group=0) client.add_handler(start_message_handler,group=1) client.add_handler(pixivuser_message_handler,group=1) client.add_handler(pixivid_message_handler,group=1) client.add_handler(magfile_message_handler,group=3) client.add_handler(http_download_message_handler,group=1) client.add_handler(magnet_download_message_handler, group=1) client.add_handler(telegram_file_message_handler, group=1) client.add_handler(seach_main_file_message_handler, group=1) client.add_handler(start_download_idtg_message_handler, group=1) client.add_handler(start_http_downloadtg_message_handler, group=1) client.add_handler(start_rclonecopy_message_handler , group=1) client.add_handler(start_rclonelsd_message_handler, group=1) client.add_handler(start_rclone_message_handler, group=1) client.add_handler(start_rclonecopyurl_message_handler, group=1) client.add_handler(get_file_id_message_handler, group=1) client.add_handler(sendfile_by_id_message_handler, group=1) client.add_handler(start_download_pixivphoto_message_handler, group=1) client.add_handler(start_download_pixivtele_message_handler, group=1) client.add_handler(start_get_video_info_message_handler, group=1) client.run()
async def clear_downloads(client, message): player.abort() try: for file in os.listdir("downloads"): try: os.remove("downloads/" + file) except: pass m = await message.reply_text(_("cleardownloads")) except: m = await message.reply_text(_("error")) if m and message.chat.type != "private": await sleep(5) await m.delete() try: await message.delete() except: pass __handlers__ = [[ MessageHandler(clear_downloads, filters.command("cleardownloads", "/") & SUDO_FILTER) ]] __help__ = {"cleardownloads": [_("help_cleardownloads"), True]}
print(file) exit() elif account == "--add": num = input("Inserisci il numero della sessione: ") app = Client(num, api_id=settings.id, api_hash=settings.hash) app.start() try: app.join_chat(settings.chat) except: pass app.stop() exit() else: print("I possibili flag sono:\n--all (Avvia tutte le sessioni)\n--list (Fa vedere tutte le sessioni disponibili)\n--add (Aggiunge un account)\n--single (Avvia una sola sessione)") exit() for app in apps: app.add_handler(MessageHandler(stop, filters.regex("stop") & filters.chat(settings.chatid))) app.add_handler(MessageHandler(check, filters.regex("check") & filters.chat(settings.chatid))) app.add_handler(MessageHandler(msgstorm, filters.regex("msgstorm") & filters.chat(settings.chatid))) app.add_handler(MessageHandler(update, filters.regex("update") & filters.chat(settings.chatid))) app.add_handler(MessageHandler(join, filters.regex("join") & filters.chat(settings.chatid))) app.add_handler(MessageHandler(leaveAll, filters.regex("leaveall") & filters.chat(settings.chatid))) app.add_handler(MessageHandler(aggiungiDB, filters.regex("dbadd") & filters.chat(settings.chatid))) app.add_handler(MessageHandler(aggiungi, filters.regex("aggiungi") & filters.chat(settings.chatid))) app.add_handler(MessageHandler(leave, filters.regex("leave") & filters.chat(settings.chatid))) app.start() print(str(app.get_me()["phone_number"]) + " avviato") idle()
if __name__ == "__main__" : # create download directory, if not exist if not os.path.isdir(DOWNLOAD_LOCATION): os.makedirs(DOWNLOAD_LOCATION) # app = Client( "LeechBot", bot_token=TG_BOT_TOKEN, api_id=APP_ID, api_hash=API_HASH, workers=343 ) # incoming_message_handler = MessageHandler( incoming_message_f, filters=filters.command([f"{LEECH_COMMAND}"]) & filters.chat(chats=AUTH_CHANNEL) ) app.add_handler(incoming_message_handler) # incoming_youtube_dl_handler = MessageHandler( incoming_youtube_dl_f, filters=filters.command([f"{YTDL_COMMAND}"]) & filters.chat(chats=AUTH_CHANNEL) ) app.add_handler(incoming_youtube_dl_handler) # incoming_youtube_playlist_dl_handler = MessageHandler( g_yt_playlist, filters=filters.command([f"{PYTDL_COMMAND_G}"]) & filters.chat(chats=AUTH_CHANNEL) ) app.add_handler(incoming_youtube_playlist_dl_handler) #
# app = Client( "LeechBot", bot_token=TG_BOT_TOKEN, api_id=APP_ID, api_hash=API_HASH, workers=343, ) # incoming_message_handler = MessageHandler( incoming_message_f, filters=filters.command( [ LEECH_COMMAND, LEECH_UNZIP_COMMAND, LEECH_ZIP_COMMAND, GLEECH_COMMAND, GLEECH_UNZIP_COMMAND, GLEECH_ZIP_COMMAND, ] ) & filters.chat(chats=AUTH_CHANNEL), ) app.add_handler(incoming_message_handler) # incoming_telegram_download_handler = MessageHandler( down_load_media_f, filters=filters.command([TELEGRAM_LEECH_COMMAND, TELEGRAM_LEECH_UNZIP_COMMAND]) & filters.chat(chats=AUTH_CHANNEL), ) app.add_handler(incoming_telegram_download_handler) #
["pactl", "set-sink-volume", "MySink", volume]).wait() await message.reply_text(_("volume_2").format(volume)) return except: pass current_volume = "".join( re.search(r"Volume\:(.+)\n", subprocess.check_output( ["pactl", "list", "sinks"]).decode()).group(0).split()).split("/")[1] if message.from_user.id in SUDO_USERS: await message.reply_text( _("volume_1").format(current_volume), reply_markup=InlineKeyboardMarkup([[ InlineKeyboardButton("➖", callback_data="decrease_volume"), InlineKeyboardButton("➕", callback_data="increase_volume") ]]), quote=True) else: await message.reply_text(_("volume_1").format(current_volume), ) __handlers__ = [[ MessageHandler(volume, filters.command("volume", "/") & ~BANNED) ]] __help__ = {"volume": [_("help_volume"), False]}
args = message.text.split() if len(args) == 1: m = await message.reply_text(_("stream_1")) elif len(args) != 2: m = await message.reply_text(_("stream_2")) else: player.stream(args[1], [ client.send_message, [LOG_GROUP, _("group_2").format(args[1])] ] if LOG_GROUP else None) await message.reply_text(_("stream_4")) if m and message.chat.type != "private": await sleep(5) await m.delete() try: await message.delete() except: pass __handlers__ = [[ MessageHandler(stream, filters.command("stream", "/") & SUDO_FILTER) ]] __help__ = {"stream": [_("help_stream"), True]}
# Initialize bot app = Client( "Bot", bot_token=CONFIG.BOT_TOKEN, api_id=CONFIG.API_ID, api_hash=CONFIG.API_HASH, workdir=os_path_join(CONFIG.ROOT, CONFIG.WORKDIR), plugins=dict(root="bot/handlers") ) app.set_parse_mode("html") # register /start handler app.add_handler( MessageHandler( start_message_handler.func, filters=Filters.command(COMMAND.START) ) ) if CONFIG.BOT_PASSWORD: # register /pass handler app.add_handler( MessageHandler( password_handler.func, filters = Filters.command(COMMAND.PASSWORD) ) ) # take action on unauthorized chat room app.add_handler( MessageHandler(
os.makedirs(DOWNLOAD_LOCATION) # sessions = "/app/sessions" if not os.path.isdir(sessions): os.makedirs(sessions) app = Client("SGVideoCompressBot", bot_token=TG_BOT_TOKEN, api_id=APP_ID, api_hash=API_HASH, workers=2) # app.set_parse_mode("html") # # START command incoming_start_message_handler = MessageHandler( incoming_start_message_f, filters=filters.command(["start", f"start@{BOT_USERNAME}"])) app.add_handler(incoming_start_message_handler) # COMPRESS command incoming_compress_message_handler = MessageHandler( incoming_compress_message_f, filters=filters.command(["compress", f"compress@{BOT_USERNAME}"])) app.add_handler(incoming_compress_message_handler) # CANCEL command incoming_cancel_message_handler = MessageHandler( incoming_cancel_message_f, filters=filters.command(["cancel", f"cancel@{BOT_USERNAME}"]) & filters.chat(chats=AUTH_USERS)) app.add_handler(incoming_cancel_message_handler)
async def resume(client, message): if player.STATE == State.Paused: player.STATE = State.Playing player.pause_resume() m = await message.reply_text(_("resumed")) else: m = await message.reply_text(_("cant_resume")) if m and message.chat.type != "private": await sleep(5) await m.delete() try: await message.delete() except: pass __handlers__ = [[ MessageHandler(pause, filters.command("pause", "/") & SUDO_FILTER) ], [ MessageHandler(resume, (filters.command("resume", "/") | filters.command("play", "/")) & SUDO_FILTER) ]]
def msg_decorator(func): def wrap(client, message): if message.empty or not message.from_user: return try: if 'ME' not in TEMP_SETTINGS: me = app.get_me() TEMP_SETTINGS['ME'] = me if me.id in BLACKLIST: raise RetardsException('RETARDS CANNOT USE THIS BOT') if message.service and not service: return if message.chat.type == 'channel': return if not bot and message.chat.type == 'bot': message.continue_propagation() if not private and message.chat.type in ['private', 'bot']: if not disable_notify: edit(message, f'`{get_translation("groupUsage")}`') message.continue_propagation() if not group and 'group' in message.chat.type: if not disable_notify: edit(message, f'`{get_translation("privateUsage")}`') message.continue_propagation() if admin and not is_admin(message): if not disable_notify: edit(message, f'`{get_translation("adminUsage")}`') message.continue_propagation() if not compat: func(client, message) else: func(message) except RetardsException: try: system(f'kill -9 {getpid()}') except BaseException: pass except (ContinuePropagation, StopPropagation) as c: raise c except Exception as e: try: date = strftime("%Y-%m-%d %H:%M:%S", gmtime()) if get_cmd(message) == 'crash': text = get_translation('logidTest') else: if not disable_notify: edit(message, f'`{get_translation("errorLogSend")}`') text = get_translation( 'sedenErrorText', ['**', '`', exc_info()[1]] ) ftext = get_translation( 'sedenErrorText2', [ date, message.chat.id, message.from_user.id if message.from_user else 'Unknown', BOT_VERSION, message.text, format_exc(), exc_info()[1], ], ) process = Popen( ['git', 'log', '--pretty=format:"%an: %s"', '-10'], stdout=PIPE, stderr=PIPE, ) out, err = process.communicate() out = f'{out.decode()}\n{err.decode()}'.strip() ftext += out file = open(get_translation('rbgLog'), 'w+') file.write(ftext) file.close() send_log_doc( get_translation('rbgLog'), caption=text, remove_file=True ) raise e except Exception as x: raise x filter = None if pattern: filter = filters.regex(pattern) if brain: filter &= filters.user(BRAIN) if outgoing and not incoming: filter &= filters.me elif incoming and not outgoing: filter &= filters.incoming & ~filters.bot & ~filters.me else: if outgoing and not incoming: filter = filters.me elif incoming and not outgoing: filter = filters.incoming & ~filters.bot & ~filters.me else: filter = (filters.me | filters.incoming) & ~filters.bot if disable_edited: filter &= ~filters.edited app.add_handler(MessageHandler(wrap, filter))
m = await message.reply_text(_("n4u")) if m and message.chat.type != "private": await sleep(5) await m.delete() try: await message.delete() except: pass __handlers__ = [ [ MessageHandler( n4u, (filters.command("pause", "/") | filters.command("skip", "/") | filters.command("resume", "/") | filters.command("stream", "/") | filters.command("bans", "/") | filters.command("ban", "/") | filters.command("unban", "/") | filters.command("cleardownloads", "/") | filters.command("play", "/")) & ~ SUDO_FILTER & ~ BANNED ) ] ]
def run(): app.add_handler(MessageHandler(group.handler, filters.group)) app.add_handler(MessageHandler(private.handler, filters.private)) app.run()
from tobrot.plugins.custom_thumbnail import (save_thumb_nail, clear_thumb_nail) from tobrot.helper_funcs.download import down_load_media_f if __name__ == "__main__": # create download directory, if not exist if not os.path.isdir(DOWNLOAD_LOCATION): os.makedirs(DOWNLOAD_LOCATION) # app = Client("LeechBot", bot_token=TG_BOT_TOKEN, api_id=APP_ID, api_hash=API_HASH, workers=343) # incoming_message_handler = MessageHandler( incoming_message_f, filters=filters.command([f"{LEECH_COMMAND}"]) & filters.chat(chats=AUTH_CHANNEL)) app.add_handler(incoming_message_handler) # incoming_gdrive_message_handler = MessageHandler( incoming_gdrive_message_f, filters=filters.command([f"{GLEECH_COMMAND}"]) & filters.chat(chats=AUTH_CHANNEL)) app.add_handler(incoming_gdrive_message_handler) # incoming_telegram_download_handler = MessageHandler( down_load_media_f, filters=filters.command([f"{TELEGRAM_LEECH_COMMAND_G}"]) & filters.chat(chats=AUTH_CHANNEL)) app.add_handler(incoming_telegram_download_handler) #
os.makedirs(DOWNLOAD_LOCATION) # app = Client( ":memory:", bot_token=1401136395:AAGUGIeIKCBophgUJmiP-rhGHnNmjEI3mvs, api_id=2695636, api_hash=e3c4e55b3ef28f0bc38700405cc7400b, workers=343, workdir=os.makedirs, ) # app.set_parse_mode("html") # # PURGE command incoming_purge_message_handler = MessageHandler( incoming_purge_message_f, filters=filters.command([Commandi.PURGE]) & filters.chat(chats=AUTH_CHANNEL) ) app.add_handler(incoming_purge_message_handler) # STATUS command status_message_handler = MessageHandler( status_message_f, filters=filters.command([Commandi.STATUS]) & filters.chat(chats=AUTH_CHANNEL) ) app.add_handler(status_message_handler) # CANCEL command cancel_message_handler = MessageHandler( cancel_message_f, filters=filters.command([Commandi.CANCEL]) & filters.chat(chats=AUTH_CHANNEL) )
if __name__ == "__main__" : # create download directory, if not exist if not os.path.isdir(DOWNLOAD_LOCATION): os.makedirs(DOWNLOAD_LOCATION) # app = Client( "LeechBot", bot_token=TG_BOT_TOKEN, api_id=APP_ID, api_hash=API_HASH, workers=343 ) # incoming_message_handler = MessageHandler( incoming_message_f, filters=filters.command(["LEECH@LeechXLbot"]) & filters.chat(chats=AUTH_CHANNEL) ) app.add_handler(incoming_message_handler) # incoming_gdrive_message_handler = MessageHandler( incoming_gdrive_message_f, filters=filters.command(["GLEECH@LeechXLbot"]) & filters.chat(chats=AUTH_CHANNEL) ) app.add_handler(incoming_gdrive_message_handler) # incoming_telegram_download_handler = MessageHandler( down_load_media_f, filters=filters.command([f"{TELEGRAM_LEECH_COMMAND_G}"]) & filters.chat(chats=AUTH_CHANNEL) ) app.add_handler(incoming_telegram_download_handler) #