async def remove_note(message: Message) -> None: """ delete note in current chat """ if '-every' in message.flags: NOTES_DATA.clear() await asyncio.gather( NOTES_COLLECTION.drop(), message.edit("`Cleared All Notes in Every Chat !`", del_in=5)) return if '-all' in message.flags: if message.chat.id in NOTES_DATA: del NOTES_DATA[message.chat.id] await asyncio.gather( NOTES_COLLECTION.delete_many({'chat_id': message.chat.id}), message.edit("`Cleared All Notes in This Chat !`", del_in=5)) else: await message.err("Couldn't find notes in this chat!") return notename = message.input_str if not notename: out = "`Wrong syntax`\nNo arguements" elif await NOTES_COLLECTION.find_one_and_delete({ 'chat_id': message.chat.id, 'name': notename }): out = "`Successfully deleted note:` **{}**".format(notename) _note_deleter(message.chat.id, notename) else: out = "`Couldn't find note:` **{}**".format(notename) await message.edit(text=out, del_in=3)
async def delete_filters(message: Message) -> None: """ delete filter in current chat """ if '-every' in message.flags: FILTERS_DATA.clear() await asyncio.gather( FILTERS_COLLECTION.drop(), message.edit("`Cleared All Filters in Every Chat !`", del_in=5)) return if '-all' in message.flags: if message.chat.id in FILTERS_DATA: del FILTERS_DATA[message.chat.id] await asyncio.gather( FILTERS_COLLECTION.delete_many({'chat_id': message.chat.id}), message.edit("`Cleared All Filters in This Chat !`", del_in=5)) else: await message.err("Couldn't find filters in this chat!") return filter_ = message.input_str if not filter_: out = "`Wrong syntax`\nNo arguements" elif await FILTERS_COLLECTION.find_one_and_delete({ 'chat_id': message.chat.id, 'name': filter_ }): out = "`Successfully deleted filter:` **{}**".format(filter_) _filter_deleter(message.chat.id, filter_) else: out = "`Couldn't find filter:` **{}**".format(filter_) await message.edit(text=out, del_in=3)
async def gmute_at_entry(msg: Message): """ handle gmute """ chat_id = msg.chat.id for user in msg.new_chat_members: user_id = user.id first_name = user.first_name gmuted = await GMUTE_USER_BASE.find_one({'user_id': user_id}) if gmuted: await asyncio.gather( msg.client.restrict_chat_member(chat_id, user_id, ChatPermissions()), msg.reply( r"\\**#xdecha_Antispam**//" "\n\nGlobally Muted User Detected in this Chat.\n\n" f"**User:** [{first_name}](tg://user?id={user_id})\n" f"**ID:** `{user_id}`\n**Reason:** `{gmuted['reason']}`\n\n" "**Quick Action:** Muted", del_in=10), CHANNEL.log( r"\\**#Antispam_Log**//" "\n\n**GMuted User $SPOTTED**\n" f"**User:** [{first_name}](tg://user?id={user_id})\n" f"**ID:** `{user_id}`\n**Reason:** {gmuted['reason']}\n**Quick Action:** " f"Muted in {msg.chat.title}")) msg.continue_propagation()
async def add_sudo_cmd(message: Message): """ add sudo cmd """ if '-all' in message.flags: await SUDO_CMDS_COLLECTION.drop() Config.ALLOWED_COMMANDS.clear() tmp_ = [] for c_d in list(xdecha.manager.enabled_commands): t_c = c_d.lstrip(Config.CMD_TRIGGER) tmp_.append({'_id': t_c}) Config.ALLOWED_COMMANDS.add(t_c) await asyncio.gather( SUDO_CMDS_COLLECTION.insert_many(tmp_), message.edit(f"**Added** all (`{len(tmp_)}`) commands to **SUDO** cmds!", del_in=5, log=__name__)) return cmd = message.input_str if not cmd: await message.err('input not found!') return cmd = cmd.lstrip(Config.CMD_TRIGGER) if cmd in Config.ALLOWED_COMMANDS: await message.edit(f"cmd : `{cmd}` already in **SUDO**!", del_in=5) elif cmd not in (c_d.lstrip(Config.CMD_TRIGGER) for c_d in list(xdecha.manager.enabled_commands)): await message.edit(f"cmd : `{cmd}` 🤔, is that a command ?", del_in=5) else: Config.ALLOWED_COMMANDS.add(cmd) await asyncio.gather( SUDO_CMDS_COLLECTION.insert_one({'_id': cmd}), message.edit(f"cmd : `{cmd}` added to **SUDO**!", del_in=5, log=__name__))
async def del_sudo(message: Message): """ delete sudo user """ if '-all' in message.flags: Config.SUDO_USERS.clear() await asyncio.gather( SUDO_USERS_COLLECTION.drop(), message.edit("**SUDO** users cleared!", del_in=5)) return user_id = message.filtered_input_str if message.reply_to_message: user_id = message.reply_to_message.from_user.id if not user_id: await message.err(f'user: `{user_id}` not found!') return if isinstance(user_id, str) and user_id.isdigit(): user_id = int(user_id) if not isinstance(user_id, int): await message.err('invalid type!') return if user_id not in Config.SUDO_USERS: await message.edit(f"user : `{user_id}` not in **SUDO**!", del_in=5) else: Config.SUDO_USERS.remove(user_id) await asyncio.gather( SUDO_USERS_COLLECTION.delete_one({'_id': user_id}), message.edit(f"user : `{user_id}` removed from **SUDO**!", del_in=5, log=__name__))
async def enable_userbot(message: Message): if message.flags: if '-all' in message.flags: Config.DISABLED_ALL = False Config.DISABLED_CHATS.clear() await asyncio.gather( DISABLED_CHATS.drop(), SAVED_SETTINGS.update_one({'_id': 'DISABLE_ALL_CHATS'}, {"$set": { 'on': False }}, upsert=True), message.edit("**Enabled** all chats!", del_in=5)) else: await message.err("invalid flag!") elif message.input_str: try: chat = await message.client.get_chat(message.input_str) except Exception as err: await message.err(str(err)) return if chat.id not in Config.DISABLED_CHATS: await message.edit("this chat is already enabled!") else: Config.DISABLED_CHATS.remove(chat.id) await asyncio.gather( DISABLED_CHATS.delete_one({'_id': chat.id}), message.edit( f"CHAT : `{chat.title}` removed from **DISABLED_CHATS**!", del_in=5, log=__name__)) else: await message.err("chat_id not found!")
async def rmwhitelist(message: Message): """ remove a user from whitelist """ user_id, _ = message.extract_user_and_text if not user_id: await message.err("user-id not found") return get_mem = await message.client.get_user_dict(user_id) firstname = get_mem['fname'] user_id = get_mem['id'] found = await WHITELIST.find_one({'user_id': user_id}) if not found: await message.err("User Not Found in My WhiteList") return await asyncio.gather( WHITELIST.delete_one({ 'firstname': firstname, 'user_id': user_id }), message.edit( r"\\**#Removed_Whitelisted_User**//" f"\n\n**First Name:** [{firstname}](tg://user?id={user_id})\n" f"**User ID:** `{user_id}`"), CHANNEL.log( r"\\**#Antispam_Log**//" f"\n**User:** [{firstname}](tg://user?id={user_id})\n" f"**User ID:** `{user_id}`\n" f"**Chat:** {message.chat.title}\n" f"**Chat ID:** `{message.chat.id}`\n\n$RMWHITELISTED #id{user_id}") ) LOG.info("WhiteListed %s", str(user_id))
async def quotecmd(message: Message): """quotecmd""" asyncio.get_event_loop().create_task(message.delete()) args = message.input_str replied = message.reply_to_message async with xdecha.conversation('QuotLyBot') as conv: try: if replied and not args: await conv.forward_message(replied) else: if not args: await message.err('input not found!') return await conv.send_message(args) except YouBlockedUser: await message.edit('first **unblock** @QuotLyBot') return quote = await conv.get_response(mark_read=True) if not quote.sticker: await message.err('something went wrong!') else: message_id = replied.message_id if replied else None await xdecha.send_sticker(chat_id=message.chat.id, sticker=quote.sticker.file_id, reply_to_message_id=message_id)
async def handle_afk_incomming(message: Message) -> None: """ handle incomming messages when you afk """ user_id = message.from_user.id chat = message.chat user_dict = await message.client.get_user_dict(user_id) afk_time = time_formatter(round(time.time() - TIME)) coro_list = [] if user_id in USERS: if not (USERS[user_id][0] + USERS[user_id][1]) % randint(2, 4): if REASON: out_str = (f"I'm still **AFK**.\nReason: <code>{REASON}</code>\n" f"Last Seen: `{afk_time} ago`") else: out_str = choice(AFK_REASONS) coro_list.append(message.reply(out_str)) if chat.type == 'private': USERS[user_id][0] += 1 else: USERS[user_id][1] += 1 else: if REASON: out_str = (f"I'm **AFK** right now.\nReason: <code>{REASON}</code>\n" f"Last Seen: `{afk_time} ago`") else: out_str = choice(AFK_REASONS) coro_list.append(message.reply(out_str)) if chat.type == 'private': USERS[user_id] = [1, 0, user_dict['mention']] else: USERS[user_id] = [0, 1, user_dict['mention']] if chat.type == 'private': coro_list.append(CHANNEL.log( f"#PRIVATE\n{user_dict['mention']} send you\n\n" f"{message.text}")) else: coro_list.append(CHANNEL.log( "#GROUP\n" f"{user_dict['mention']} tagged you in [{chat.title}](http://t.me/{chat.username})\n\n" f"{message.text}\n\n" f"[goto_msg](https://t.me/c/{str(chat.id)[4:]}/{message.message_id})")) coro_list.append(AFK_COLLECTION.update_one({'_id': user_id}, {"$set": { 'pcount': USERS[user_id][0], 'gcount': USERS[user_id][1], 'men': USERS[user_id][2]}}, upsert=True)) await asyncio.gather(*coro_list)
async def convert_(message: Message): """ convert telegram files """ await message.edit("`Trying to Convert ...`") if message.reply_to_message and message.reply_to_message.media: message.text = '' if message.reply_to_message.document else ". -d" await _handle_message(message) else: await message.edit("Please read `.help convert`", del_in=5)
async def del_sudo_cmd(message: Message): """ delete sudo cmd """ if '-all' in message.flags: Config.ALLOWED_COMMANDS.clear() await asyncio.gather( SUDO_CMDS_COLLECTION.drop(), message.edit("**SUDO** cmds cleared!", del_in=5)) return cmd = message.filtered_input_str if not cmd: await message.err('input not found!') return if cmd not in Config.ALLOWED_COMMANDS: await message.edit(f"cmd : `{cmd}` not in **SUDO**!", del_in=5) else: Config.ALLOWED_COMMANDS.remove(cmd) await asyncio.gather( SUDO_CMDS_COLLECTION.delete_one({'_id': cmd}), message.edit(f"cmd : `{cmd}` removed from **SUDO**!", del_in=5, log=__name__))
async def active_afk(message: Message) -> None: """ turn on or off afk mode """ global REASON, IS_AFK, TIME # pylint: disable=global-statement IS_AFK = True TIME = time.time() REASON = message.input_str await asyncio.gather( CHANNEL.log(f"You went AFK! : `{REASON}`"), message.edit("`You went AFK!`", del_in=1), AFK_COLLECTION.drop(), SAVED_SETTINGS.update_one( {'_id': 'AFK'}, {"$set": {'on': True, 'data': REASON, 'time': TIME}}, upsert=True))
async def webss(message: Message): if Config.GOOGLE_CHROME_BIN is None: await message.err("need to install Google Chrome. Module Stopping") return link_match = match(r'\bhttps?://.*\.\S+', message.input_str) if not link_match: await message.err("`I need a valid link to take screenshots from.`") return link = link_match.group() await message.edit("`Processing ...`") chrome_options = webdriver.ChromeOptions() chrome_options.binary_location = Config.GOOGLE_CHROME_BIN chrome_options.add_argument('--ignore-certificate-errors') chrome_options.add_argument("--test-type") chrome_options.add_argument("--headless") chrome_options.add_argument('--no-sandbox') chrome_options.add_argument('--disable-dev-shm-usage') chrome_options.add_argument("--no-sandbox") chrome_options.add_argument('--disable-gpu') driver = webdriver.Chrome(chrome_options=chrome_options) driver.get(link) height = driver.execute_script( "return Math.max(document.body.scrollHeight, document.body.offsetHeight, " "document.documentElement.clientHeight, document.documentElement.scrollHeight, " "document.documentElement.offsetHeight);") width = driver.execute_script( "return Math.max(document.body.scrollWidth, document.body.offsetWidth, " "document.documentElement.clientWidth, document.documentElement.scrollWidth, " "document.documentElement.offsetWidth);") driver.set_window_size(width + 125, height + 125) wait_for = height / 1000 await message.edit(f"`Generating screenshot of the page...`" f"\n`Height of page = {height}px`" f"\n`Width of page = {width}px`" f"\n`Waiting ({int(wait_for)}s) for the page to load.`") await asyncio.sleep(int(wait_for)) im_png = driver.get_screenshot_as_png() driver.close() message_id = message.message_id if message.reply_to_message: message_id = message.reply_to_message.message_id file_path = os.path.join(Config.DOWN_PATH, "webss.png") async with aiofiles.open(file_path, 'wb') as out_file: await out_file.write(im_png) await asyncio.gather( message.delete(), message.client.send_document(chat_id=message.chat.id, document=file_path, caption=link, reply_to_message_id=message_id)) os.remove(file_path) driver.quit()
async def disable_userbot(message: Message): if message.flags: if '-all' in message.flags: Config.DISABLED_ALL = True await asyncio.gather( SAVED_SETTINGS.update_one({'_id': 'DISABLE_ALL_CHATS'}, {"$set": { 'on': True }}, upsert=True), message.edit("**Disabled** all chats!", del_in=5)) else: await message.err("invalid flag!") else: chat = message.chat if message.input_str: try: chat = await message.client.get_chat(message.input_str) except Exception as err: await message.err(str(err)) return if chat.id in Config.DISABLED_CHATS: await message.edit("this chat is already disabled!") elif chat.id == Config.LOG_CHANNEL_ID: await message.err("can't disabled log channel") else: Config.DISABLED_CHATS.add(chat.id) await asyncio.gather( DISABLED_CHATS.insert_one({ '_id': chat.id, 'title': chat.title }), message.edit( f"CHAT : `{chat.title}` added to **DISABLED_CHATS**!", del_in=5, log=__name__))
async def add_sudo(message: Message): """ add sudo user """ user_id = message.input_str if message.reply_to_message: user_id = message.reply_to_message.from_user.id if not user_id: await message.err(f'user: `{user_id}` not found!') return if isinstance(user_id, str) and user_id.isdigit(): user_id = int(user_id) try: user = await message.client.get_user_dict(user_id) except PeerIdInvalid as p_e: await message.err(p_e) return if user['id'] in Config.SUDO_USERS: await message.edit(f"user : `{user['id']}` already in **SUDO**!", del_in=5) else: Config.SUDO_USERS.add(user['id']) await asyncio.gather( SUDO_USERS_COLLECTION.insert_one({'_id': user['id'], 'men': user['mention']}), message.edit(f"user : `{user['id']}` added to **SUDO**!", del_in=5, log=__name__))
async def ungmute_user(msg: Message): """ unmute a user globally """ await msg.edit("`UnGMuting this User...`") user_id, _ = msg.extract_user_and_text if not user_id: await msg.err("user-id not found") return get_mem = await msg.client.get_user_dict(user_id) firstname = get_mem['fname'] user_id = get_mem['id'] found = await GMUTE_USER_BASE.find_one({'user_id': user_id}) if not found: await msg.err("User Not Found in My GMute List") return await asyncio.gather( GMUTE_USER_BASE.delete_one({ 'firstname': firstname, 'user_id': user_id }), msg.edit(r"\\**#UnGMuted_User**//" f"\n\n**First Name:** [{firstname}](tg://user?id={user_id})\n" f"**User ID:** `{user_id}`")) chats = [ msg.chat ] if msg.client.is_bot else await msg.client.get_common_chats(user_id) for chat in chats: try: await chat.unban_member(user_id) await CHANNEL.log( r"\\**#Antispam_Log**//" f"\n**User:** [{firstname}](tg://user?id={user_id})\n" f"**User ID:** `{user_id}`\n" f"**Chat:** {chat.title}\n" f"**Chat ID:** `{chat.id}`\n\n$UNGMUTED #id{user_id}") except (ChatAdminRequired, UserAdminInvalid): pass LOG.info("UnGMuted %s", str(user_id))
async def gmute_user(msg: Message): """ Mute a user globally """ await msg.edit("`Globally Muting this User...`") user_id, reason = msg.extract_user_and_text if not user_id: await msg.edit("`no valid user_id or message specified,`" "`don't do .help gmute for more info. " "Coz no one's gonna help ya`(。ŏ_ŏ) ⚠") return get_mem = await msg.client.get_user_dict(user_id) firstname = get_mem['fname'] if not reason: await msg.edit( f"**#Aborted**\n\n**GMuting** of [{firstname}](tg://user?id={user_id}) " "`Aborted coz No reason of GMute provided by User`", del_in=5) return user_id = get_mem['id'] if user_id == msg.from_user.id: await msg.err(r"LoL. Why would I GMuting myself ¯\(°_o)/¯") return if user_id in Config.SUDO_USERS: await msg.edit( "`That user is in my Sudo List, Hence I can't GMute him.`\n\n" "**Tip:** `Remove them from Sudo List and try again. (¬_¬)`", del_in=5) return found = await GMUTE_USER_BASE.find_one({'user_id': user_id}) if found: await msg.edit( "**#Already_GMuted**\n\n`This User Already Exists in My GMute List.`\n" f"**Reason For GMute:** `{found['reason']}`") return await asyncio.gather( GMUTE_USER_BASE.insert_one({ 'firstname': firstname, 'user_id': user_id, 'reason': reason }), msg.edit(r"\\**#GMuted_User**//" f"\n\n**First Name:** [{firstname}](tg://user?id={user_id})\n" f"**User ID:** `{user_id}`\n**Reason:** `{reason}`")) chats = [ msg.chat ] if msg.client.is_bot else await msg.client.get_common_chats(user_id) for chat in chats: try: await chat.restrict_member(user_id, ChatPermissions()) await CHANNEL.log( r"\\**#Antispam_Log**//" f"\n**User:** [{firstname}](tg://user?id={user_id})\n" f"**User ID:** `{user_id}`\n" f"**Chat:** {chat.title}\n" f"**Chat ID:** `{chat.id}`\n" f"**Reason:** `{reason}`\n\n$GMUTE #id{user_id}") except (ChatAdminRequired, UserAdminInvalid): pass if msg.reply_to_message: await CHANNEL.fwd_msg(msg.reply_to_message) await CHANNEL.log(f'$GMUTE #prid{user_id} ⬆️') LOG.info("G-Muted %s", str(user_id))
async def check_and_send(message: Message, *args, **kwargs): replied = message.reply_to_message if replied: await asyncio.gather(message.delete(), replied.reply(*args, **kwargs)) else: await message.edit(*args, **kwargs)
async def gban_at_entry(message: Message): """ handle gbans """ chat_id = message.chat.id for user in message.new_chat_members: user_id = user.id first_name = user.first_name if await WHITELIST.find_one({'user_id': user_id}): continue gbanned = await GBAN_USER_BASE.find_one({'user_id': user_id}) if gbanned: if 'chat_ids' in gbanned: chat_ids = gbanned['chat_ids'] chat_ids.append(chat_id) else: chat_ids = [chat_id] await asyncio.gather( message.client.kick_chat_member(chat_id, user_id), message.reply( r"\\**#xdecha_Antispam**//" "\n\nGlobally Banned User Detected in this Chat.\n\n" f"**User:** [{first_name}](tg://user?id={user_id})\n" f"**ID:** `{user_id}`\n**Reason:** `{gbanned['reason']}`\n\n" "**Quick Action:** Banned", del_in=10), CHANNEL.log( r"\\**#Antispam_Log**//" "\n\n**GBanned User $SPOTTED**\n" f"**User:** [{first_name}](tg://user?id={user_id})\n" f"**ID:** `{user_id}`\n**Reason:** {gbanned['reason']}\n**Quick Action:** " f"Banned in {message.chat.title}"), GBAN_USER_BASE.update_one( { 'user_id': user_id, 'firstname': first_name }, {"$set": { 'chat_ids': chat_ids }}, upsert=True)) elif Config.ANTISPAM_SENTRY: async with aiohttp.ClientSession() as ses: async with ses.get( f'https://api.cas.chat/check?user_id={user_id}' ) as resp: res = json.loads(await resp.text()) if res['ok']: reason = ' | '.join( res['result']['messages']) if 'result' in res else None await asyncio.gather( message.client.kick_chat_member(chat_id, user_id), message.reply( r"\\**#xdecha_Antispam**//" "\n\nGlobally Banned User Detected in this Chat.\n\n" "**$SENTRY CAS Federation Ban**\n" f"**User:** [{first_name}](tg://user?id={user_id})\n" f"**ID:** `{user_id}`\n**Reason:** `{reason}`\n\n" "**Quick Action:** Banned", del_in=10), CHANNEL.log( r"\\**#Antispam_Log**//" "\n\n**GBanned User $SPOTTED**\n" "**$SENRTY #CAS BAN**" f"\n**User:** [{first_name}](tg://user?id={user_id})\n" f"**ID:** `{user_id}`\n**Reason:** `{reason}`\n**Quick Action:**" f" Banned in {message.chat.title}\n\n$AUTOBAN #id{user_id}" )) elif Config.SPAM_WATCH_API: intruder = await _get_spamwatch_data(user_id) if intruder: await asyncio.gather( message.client.kick_chat_member(chat_id, user_id), message.reply( r"\\**#xdecha_Antispam**//" "\n\nGlobally Banned User Detected in this Chat.\n\n" "**$SENTRY SpamWatch Federation Ban**\n" f"**User:** [{first_name}](tg://user?id={user_id})\n" f"**ID:** `{user_id}`\n**Reason:** `{intruder.reason}`\n\n" "**Quick Action:** Banned", del_in=10), CHANNEL.log( r"\\**#Antispam_Log**//" "\n\n**GBanned User $SPOTTED**\n" "**$SENRTY #SPAMWATCH_API BAN**" f"\n**User:** [{first_name}](tg://user?id={user_id})\n" f"**ID:** `{user_id}`\n**Reason:** `{intruder.reason}`\n" f"**Quick Action:** Banned in {message.chat.title}\n\n" f"$AUTOBAN #id{user_id}")) message.continue_propagation()
async def carbon_(message: Message): if Config.GOOGLE_CHROME_BIN is None: replied = message.reply_to_message if replied: text = replied.text else: text = message.text if not text: await message.err("need input text!") return await message.edit("`Creating a Carbon...`") async with xdecha.conversation("CarbonNowShBot", timeout=30) as conv: try: await conv.send_message(text) except YouBlockedUser: await message.edit('first **unblock** @CarbonNowShBot') return response = await conv.get_response(mark_read=True) while not response.reply_markup: response = await conv.get_response(mark_read=True) await response.click(x=random.randint(0, 2), y=random.randint(0, 8)) response = await conv.get_response(mark_read=True) while not response.media: response = await conv.get_response(mark_read=True) caption = "\n".join(response.caption.split("\n")[0:2]) file_id = response.document.file_id await asyncio.gather( message.delete(), xdecha.send_document(chat_id=message.chat.id, document=file_id, caption='`' + caption + '`', reply_to_message_id=replied.message_id if replied else None)) else: input_str = message.filtered_input_str replied = message.reply_to_message theme = 'seti' lang = 'auto' red = message.flags.get('r', random.randint(0, 255)) green = message.flags.get('g', random.randint(0, 255)) blue = message.flags.get('b', random.randint(0, 255)) alpha = message.flags.get('a', random.randint(0, 100)) bg_ = f"rgba({red}, {green}, {blue}, {alpha})" if replied and (replied.text or (replied.document and 'text' in replied.document.mime_type)): message_id = replied.message_id if replied.document: await message.edit("`Downloading File...`") path_ = await message.client.download_media( replied, file_name=Config.DOWN_PATH) async with aiofiles.open(path_) as file_: code = await file_.read() os.remove(path_) else: code = replied.text if input_str: if '|' in input_str: args = input_str.split('|') if len(args) == 2: theme = args[0].strip() lang = args[1].strip() else: theme = input_str elif input_str: message_id = message.message_id if '|' in input_str: args = input_str.split('|') if len(args) == 3: theme = args[0].strip() lang = args[1].strip() code = args[2].strip() elif len(args) == 2: theme = args[0].strip() code = args[1].strip() else: code = input_str else: await message.err("need input text!") return await message.edit("`Creating a Carbon...`") code = quote_plus(code) await message.edit("`Processing... 20%`") carbon_path = os.path.join(Config.DOWN_PATH, "carbon.png") if os.path.isfile(carbon_path): os.remove(carbon_path) url = CARBON.format(theme=theme, lang=lang, code=code, bg=bg_) if len(url) > 2590: await message.err("input too large!") return chrome_options = webdriver.ChromeOptions() chrome_options.binary_location = Config.GOOGLE_CHROME_BIN chrome_options.add_argument("--headless") chrome_options.add_argument("--window-size=1920x1080") chrome_options.add_argument("--disable-dev-shm-usage") chrome_options.add_argument("--no-sandbox") chrome_options.add_argument("--disable-gpu") prefs = {'download.default_directory': Config.DOWN_PATH} chrome_options.add_experimental_option('prefs', prefs) driver = webdriver.Chrome(chrome_options=chrome_options) driver.get(url) await message.edit("`Processing... 40%`") driver.command_executor._commands["send_command"] = ( # pylint: disable=protected-access "POST", '/session/$sessionId/chromium/send_command') params = { 'cmd': 'Page.setDownloadBehavior', 'params': { 'behavior': 'allow', 'downloadPath': Config.DOWN_PATH } } driver.execute("send_command", params) # driver.find_element_by_xpath("//button[contains(text(),'Export')]").click() driver.find_element_by_id("export-menu").click() await asyncio.sleep(1) await message.edit("`Processing... 60%`") driver.find_element_by_xpath("//button[contains(text(),'4x')]").click() await asyncio.sleep(1) driver.find_element_by_xpath( "//button[contains(text(),'PNG')]").click() await message.edit("`Processing... 80%`") while not os.path.isfile(carbon_path): await asyncio.sleep(0.5) await message.edit("`Processing... 100%`") await message.edit("`Uploading Carbon...`") await asyncio.gather( message.delete(), message.client.send_photo(chat_id=message.chat.id, photo=carbon_path, reply_to_message_id=message_id)) os.remove(carbon_path) driver.quit()