Upload 12 files

plugins/banned.py

@@ -0,0 +1,39 @@
+from pyrogram import Client, filters
+from utils import temp
+from pyrogram.types import Message
+from database.users_chats_db import db
+from pyrogram.types import InlineKeyboardButton, InlineKeyboardMarkup
+from info import SUPPORT_CHAT
+async def banned_users(_, client, message: Message):
+    return (
+        message.from_user is not None or not message.sender_chat
+    ) and message.from_user.id in temp.BANNED_USERS
+
+banned_user = filters.create(banned_users)
+
+async def disabled_chat(_, client, message: Message):
+    return message.chat.id in temp.BANNED_CHATS
+
+disabled_group=filters.create(disabled_chat)
+
+
+@Client.on_message(filters.private & banned_user & filters.incoming)
+async def ban_reply(bot, message):
+    ban = await db.get_ban_status(message.from_user.id)
+    await message.reply(f'Sorry Dude, You are Banned to use Me. \nBan Reason: {ban["ban_reason"]}')
+
+@Client.on_message(filters.group & disabled_group & filters.incoming)
+async def grp_bd(bot, message):
+    buttons = [[
+        InlineKeyboardButton('Support', url=f'https://t.me/{SUPPORT_CHAT}')
+    ]]
+    reply_markup=InlineKeyboardMarkup(buttons)
+    vazha = await db.get_chat(message.chat.id)
+    k = await message.reply(
+        text=f"CHAT NOT ALLOWED 🐞\n\nMy admins has restricted me from working here ! If you want to know more about it contact support..\nReason : <code>{vazha['reason']}</code>.",
+        reply_markup=reply_markup)
+    try:
+        await k.pin()
+    except:
+        pass
+    await bot.leave_chat(message.chat.id)

plugins/broadcast.py

@@ -0,0 +1,42 @@
+
+from pyrogram import Client, filters
+import datetime
+import time
+from database.users_chats_db import db
+from info import ADMINS
+from utils import broadcast_messages
+import asyncio
+        
+@Client.on_message(filters.command("broadcast") & filters.user(ADMINS) & filters.reply)
+# https://t.me/GetTGLink/4178
+async def verupikkals(bot, message):
+    users = await db.get_all_users()
+    b_msg = message.reply_to_message
+    sts = await message.reply_text(
+        text='Broadcasting your messages...'
+    )
+    start_time = time.time()
+    total_users = await db.total_users_count()
+    done = 0
+    blocked = 0
+    deleted = 0
+    failed =0
+
+    success = 0
+    async for user in users:
+        pti, sh = await broadcast_messages(int(user['id']), b_msg)
+        if pti:
+            success += 1
+        elif pti == False:
+            if sh == "Blocked":
+                blocked+=1
+            elif sh == "Deleted":
+                deleted += 1
+            elif sh == "Error":
+                failed += 1
+        done += 1
+        await asyncio.sleep(2)
+        if not done % 20:
+            await sts.edit(f"Broadcast in progress:\n\nTotal Users {total_users}\nCompleted: {done} / {total_users}\nSuccess: {success}\nBlocked: {blocked}\nDeleted: {deleted}")    
+    time_taken = datetime.timedelta(seconds=int(time.time()-start_time))
+    await sts.edit(f"Broadcast Completed:\nCompleted in {time_taken} seconds.\n\nTotal Users {total_users}\nCompleted: {done} / {total_users}\nSuccess: {success}\nBlocked: {blocked}\nDeleted: {deleted}")

plugins/channel.py

@@ -0,0 +1,20 @@
+from pyrogram import Client, filters
+from info import CHANNELS
+from database.ia_filterdb import save_file
+
+media_filter = filters.document | filters.video | filters.audio
+
+
+@Client.on_message(filters.chat(CHANNELS) & media_filter)
+async def media(bot, message):
+    """Media Handler"""
+    for file_type in ("document", "video", "audio"):
+        media = getattr(message, file_type, None)
+        if media is not None:
+            break
+    else:
+        return
+
+    media.file_type = file_type
+    media.caption = message.caption
+    await save_file(media)

plugins/commands.py

@@ -0,0 +1,1187 @@
+import os
+import logging
+import random
+import asyncio
+from Script import script
+from pyrogram import Client, filters, enums
+from pyrogram.errors import ChatAdminRequired, FloodWait
+from pyrogram.types import InlineKeyboardButton, InlineKeyboardMarkup, ReplyKeyboardMarkup
+from database.admin_group import get_admingroup, remove_admingroup, add_admingroup
+from database.ia_filterdb import Media, get_file_details, unpack_new_file_id
+from database.users_chats_db import db
+from info import CHANNELS, ADMINS, AUTH_CHANNEL, LOG_CHANNEL, PICS, BATCH_FILE_CAPTION, CUSTOM_FILE_CAPTION, PROTECT_CONTENT
+from utils import get_settings, get_size, is_subscribed, save_group_settings, temp, send_more_files, gen_url, broadcast_messages, broadcast_notification, split_list
+from database.connections_mdb import active_connection
+from database.quickdb import remove_inst, get_ids, add_sent_files, get_verification, remove_verification, add_verification, count_sent_files, add_update_msg, remove_update_msg, get_update_msg
+from database.tvseriesfilters import add_tvseries_filter, update_tvseries_filter, getlinks, find_tvseries_filter, remove_tvseries, find_tvseries_by_first
+from database.notification import find_notification, remove_notification, update_notification, add_notification, find_allusers
+import re
+import json
+import base64
+import time
+logger = logging.getLogger(__name__)
+
+BATCH_FILES = {}
+
+
+@Client.on_message((filters.command("start") | filters.regex('Start')) & filters.incoming)
+async def start(client, message):
+    if message.chat.type in [enums.ChatType.GROUP, enums.ChatType.SUPERGROUP]:
+        buttons = [
+            [
+                InlineKeyboardButton('🤖 Updates', url='https://t.me/TMWAD')
+            ],
+            [
+                InlineKeyboardButton(
+                    'ℹ️ Help', url=f"https://t.me/{temp.U_NAME}?start=help"),
+            ]
+        ]
+        reply_markup = InlineKeyboardMarkup(buttons)
+        await message.reply(script.START_TXT.format(message.from_user.mention if message.from_user else message.chat.title, temp.U_NAME, temp.B_NAME), reply_markup=reply_markup)
+        # 😢 https://github.com/EvamariaTG/EvaMaria/blob/master/plugins/p_ttishow.py#L17 😬 wait a bit, before checking.
+        await asyncio.sleep(2)
+        if not await db.get_chat(message.chat.id):
+            total = await client.get_chat_members_count(message.chat.id)
+            await client.send_message(LOG_CHANNEL, script.LOG_TEXT_G.format(message.chat.title, message.chat.id, total, "Unknown"))
+            await db.add_chat(message.chat.id, message.chat.title)
+        return
+    if not await db.is_user_exist(message.from_user.id):
+        await db.add_user(message.from_user.id, message.from_user.first_name)
+        await client.send_message(LOG_CHANNEL, script.LOG_TEXT_P.format(message.from_user.id, message.from_user.mention))
+    if len(message.command) != 2:
+        buttons = [[
+            InlineKeyboardButton('➕ Add Me To Your Groups ➕',
+                                 url=f'http://t.me/{temp.U_NAME}?startgroup=true')
+        ], [
+            InlineKeyboardButton(
+                '🔍 Search', switch_inline_query_current_chat=''),
+            InlineKeyboardButton('🤖 Updates', url='https://t.me/TMWAD')
+        ], [
+            InlineKeyboardButton('ℹ️ Help', callback_data='help'),
+            InlineKeyboardButton('😊 About', callback_data='about')
+        ]]
+        reply_markup = InlineKeyboardMarkup(buttons)
+        await message.reply_photo(
+            photo=random.choice(PICS),
+            caption=script.START_TXT.format(
+                message.from_user.mention, temp.U_NAME, temp.B_NAME),
+            reply_markup=reply_markup,
+        )
+        return
+
+    user_stats = await get_verification(message.from_user.id)
+
+    if AUTH_CHANNEL and not await is_subscribed(client, message):
+        btn = [
+            [
+                InlineKeyboardButton(
+                    "🤖 Join Updates Channel", url="https://t.me/TMWAD"
+                )
+            ]
+        ]
+
+        if message.command[1] != "subscribe":
+            try:
+                kk, file_id = message.command[1].split("_", 1)
+                pre = 'checksubp' if kk == 'filep' else 'checksub'
+                btn.append([InlineKeyboardButton(
+                    " 🔄 Try Again", callback_data=f"{pre}#{file_id}")])
+            except IndexError:
+                btn.append([InlineKeyboardButton(
+                    " 🔄 Try Again", url=f"https://t.me/{temp.U_NAME}/{message.command[1]}")])
+            except:
+                return
+
+        await client.send_message(
+            chat_id=message.from_user.id,
+            text="**Please Join My Updates Channel to use this Bot!**",
+            reply_markup=InlineKeyboardMarkup(btn)
+        )
+        return
+    if len(message.command) == 2 and message.command[1] in ["subscribe", "error", "okay", "help"]:
+        buttons = [[
+            InlineKeyboardButton('➕ Add Me To Your Groups ➕',
+                                 url=f'http://t.me/{temp.U_NAME}?startgroup=true')
+        ], [
+            InlineKeyboardButton(
+                '🔍 Search', switch_inline_query_current_chat=''),
+            InlineKeyboardButton('🤖 Updates', url='https://t.me/TMWAD')
+        ], [
+            InlineKeyboardButton('ℹ️ Help', callback_data='help'),
+            InlineKeyboardButton('😊 About', callback_data='about')
+        ]]
+        reply_markup = InlineKeyboardMarkup(buttons)
+        await message.reply_photo(
+            photo=random.choice(PICS),
+            caption=script.START_TXT.format(
+                message.from_user.mention, temp.U_NAME, temp.B_NAME),
+            reply_markup=reply_markup,
+
+        )
+        return
+
+    data = message.command[1]
+    try:
+        pre, file_id = data.split('_', 1)
+    except:
+        file_id = data
+        pre = ""
+        
+    t = time.time()
+    await remove_verification(message.from_user.id)
+    file_id = data.split("-", 1)[1]
+    await add_verification(message.from_user.id, 'verified', file_id, t)
+
+    tt = time.localtime(t+43200)
+    current_time = time.strftime("%D  %H:%M:%S", tt)
+    await message.reply(
+        text=f"""
+            <p>you'r verified Succusfully. access until {current_time}</p>
+            """
+    )
+    idstring = await get_ids(file_id)
+
+    if idstring:
+        await remove_inst(file_id)
+        idstring = idstring['links']
+        fileids = idstring.split("L_I_N_K")
+        sendmsglist = []
+        for file_id in fileids:
+            files_ = await get_file_details(file_id)
+            if not files_:
+                try:
+                    msg = await client.send_cached_media(
+                        chat_id=message.from_user.id,
+                        file_id=file_id
+                    )
+                    filetype = msg.media
+                    file = getattr(msg, filetype)
+                    title = file.file_name
+                    size = get_size(file.file_size)
+                    f_caption = f"<code>{title}</code>"
+                    if CUSTOM_FILE_CAPTION:
+                        try:
+                            f_caption = CUSTOM_FILE_CAPTION.format(
+                                file_name='' if title is None else title, file_size='' if size is None else size, file_caption='')
+                        except:
+                            return
+                    await msg.edit_caption(f_caption)
+                    return
+                except:
+                    pass
+            files = files_[0]
+            title = files.file_name
+            size = get_size(files.file_size)
+            f_caption = files.caption
+            if CUSTOM_FILE_CAPTION:
+                try:
+                    f_caption = CUSTOM_FILE_CAPTION.format(
+                        file_name='' if title is None else title, file_size='' if size is None else size, file_caption='' if f_caption is None else f_caption)
+                except Exception as e:
+                    logger.exception(e)
+                    f_caption = f_caption
+            if f_caption is None:
+                f_caption = f"{files.file_name}"
+            k = await client.send_cached_media(
+                chat_id=message.from_user.id,
+                file_id=file_id,
+                caption=f_caption,
+            )
+            sendmsglist.append(k)
+            await add_sent_files(message.from_user.id, file_id)
+
+            await asyncio.sleep(2)
+
+        await message.reply('𝕋𝕙𝕒𝕟𝕜 𝕐𝕠𝕦 𝔽𝕠𝕣 𝕌𝕤𝕚𝕟𝕘 𝕄𝕖')
+        kk = await client.send_message(
+            chat_id=message.from_user.id,
+            text="""
+            This Files Will delete in 10min Please Forward To Saved Messages folder before download. \n\nTurned On /notification for get new movie|tv Serieses
+            """)
+
+        await asyncio.sleep(600)
+
+        for k in sendmsglist:
+            await k.delete()
+
+        sendmsglist = []
+
+        return await kk.delete()
+
+        files_ = await get_file_details(file_id)
+        if not files_:
+            try:
+                pre, file_id = ((base64.urlsafe_b64decode(
+                    data + "=" * (-len(data) % 4))).decode("ascii")).split("_", 1)
+                msg = await client.send_cached_media(
+                    chat_id=message.from_user.id,
+                    file_id=file_id,
+                    protect_content=True if pre == 'filep' else False,
+                )
+                filetype = msg.media
+                file = getattr(msg, filetype)
+                title = file.file_name
+                size = get_size(file.file_size)
+                f_caption = f"<code>{title}</code>"
+                if CUSTOM_FILE_CAPTION:
+                    try:
+                        f_caption = CUSTOM_FILE_CAPTION.format(
+                            file_name='' if title is None else title, file_size='' if size is None else size, file_caption='')
+                    except:
+                        return
+                await msg.edit_caption(f_caption)
+                return
+            except:
+                pass
+            return await message.reply('No such file exist.')
+        files = files_[0]
+        title = files.file_name
+        size = get_size(files.file_size)
+        f_caption = files.caption
+        if CUSTOM_FILE_CAPTION:
+            try:
+                f_caption = CUSTOM_FILE_CAPTION.format(
+                    file_name='' if title is None else title, file_size='' if size is None else size, file_caption='' if f_caption is None else f_caption)
+            except Exception as e:
+                logger.exception(e)
+                f_caption = f_caption
+        if f_caption is None:
+            f_caption = f"{files.file_name}"
+
+        k = await client.send_cached_media(
+            chat_id=message.from_user.id,
+            file_id=file_id,
+            caption=f_caption,
+            protect_content=True if pre == 'filep' else False,
+        )
+        sendmsglist = [k]
+        await add_sent_files(message.from_user.id, file_id)
+
+        files = await send_more_files(title)
+        if files:
+            for file in files[1:]:
+                k = await client.send_cached_media(
+                    chat_id=message.from_user.id,
+                    file_id=file.file_id,
+                    caption=f"<code>{file.file_name}</code>",
+                    protect_content=True if pre == 'filep' else False,
+                )
+                sendmsglist.append(k)
+                await add_sent_files(message.from_user.id, file.file_id)
+
+                await asyncio.sleep(2)
+
+            await message.reply("𝕋𝕙𝕒𝕟𝕜 𝕐𝕠𝕦 𝔽𝕠𝕣 𝕌𝕤𝕚𝕟𝕘 𝕄𝕖 \n\n⭐Rate Me: <a href='https://t.me/tlgrmcbot?start=spaciousuniversebot-review'>Here</a>")
+            kk = await client.send_message(
+                chat_id=message.from_user.id,
+                text="""
+                This Files Will delete in 10min Please Forward To Saved Messages folder before download. \n\nTurned On /notification for get new movie|tv Serieses
+                """)
+
+            await asyncio.sleep(600)
+
+            for k in sendmsglist:
+                await k.delete()
+            sendmsglist = []
+
+            return await kk.delete()
+
+    user_stats = await get_verification(message.from_user.id)
+    if user_stats is None:
+        t = time.time()
+        await add_verification(message.from_user.id, 'unverified', file_id, t)
+        button = [[
+            InlineKeyboardButton(
+                '🔹 Verfiy 🔹', url=gen_url(f'https://telegram.dog/SpaciousUniverseBot?start=REAL-{data}'))
+        ]]
+        return await message.reply(
+            text="""
+            <p>you'r not verified today. verfied your self and get unlimited access</p>
+            <br>
+            <small><a href="kalanakt.github.io/projects/telegram/baesuzy/">How To Verify !</a></small>
+            """,
+            reply_markup=InlineKeyboardMarkup(button)
+        )
+    elif data.split("-", 1)[0] == "REAL":
+        file_id = data.split("-", 1)[1]
+        if (str(user_stats["stats"]) == 'unverified') and (str(user_stats["file"]) == file_id):
+            file_id = data.split("-", 1)[1]
+            t = time.time()
+            await remove_verification(message.from_user.id)
+            await add_verification(message.from_user.id, 'verified', file_id, t)
+            t = time.localtime(t+43200)
+            current_time = time.strftime("%D  %H:%M:%S", t)
+            button = [[
+                InlineKeyboardButton(
+                    'Get Files', url=f'https://telegram.dog/SpaciousUniverseBot?start={file_id}')
+            ]]
+            return await message.reply(
+                text=f"""
+                <p>you'r verified Succusfully. access until {current_time}</p>
+                """,
+                reply_markup=InlineKeyboardMarkup(button)
+            )
+        elif data.split("-")[1] == "BATCH":
+            file_id = data.split("-", 2)[2]
+            t = time.time()
+            await remove_verification(message.from_user.id)
+            await add_verification(message.from_user.id, 'verified', file_id, t)
+            t = time.localtime(t+43200)
+            current_time = time.strftime("%D  %H:%M:%S", t)
+            button = [[
+                InlineKeyboardButton(
+                    'Get Files', url=f'https://telegram.dog/SpaciousUniverseBot?start={file_id}')
+            ]]
+            return await message.reply(
+                text=f"""
+                <p>you'r verified Succusfully. access until {current_time}</p>
+                """,
+                reply_markup=InlineKeyboardMarkup(button)
+            )
+        else:
+            t = time.time()
+            await remove_verification(message.from_user.id)
+            await add_verification(message.from_user.id, 'unverified', file_id, t)
+            t = time.localtime(t+43200)
+            current_time = time.strftime("%D  %H:%M:%S", t)
+            button = [[
+                InlineKeyboardButton(
+                    '🔹 Verfiy 🔹', url=gen_url(f'https://telegram.dog/SpaciousUniverseBot?start=REAL-{data}'))
+            ]]
+            return await message.reply(
+                text="""
+                <p>you'r using my old messages. please verify first</p>
+                """,
+                reply_markup=InlineKeyboardMarkup(button)
+            )
+
+    elif (str(user_stats["stats"]) == 'unverified') and (str(user_stats["file"]) != file_id):
+        t = time.time()
+        await remove_verification(message.from_user.id)
+        await add_verification(message.from_user.id, 'unverified', file_id, t)
+        button = [[
+            InlineKeyboardButton(
+                '🔹 Verfiy 🔹', url=gen_url(f'https://telegram.dog/SpaciousUniverseBot?start=REAL-{data}'))
+        ]]
+        return await message.reply(
+            text="""
+            <p>you'r not verified today. verfied your self and get unlimited access</p>
+            <br>
+            <small><a href="kalanakt.github.io/projects/telegram/baesuzy/">How To Verify !</a></small>
+            """,
+            reply_markup=InlineKeyboardMarkup(button)
+        )
+
+    elif (time.time() - int(float(user_stats["updat_time"]))) > 43200:
+        t = time.time()
+        await remove_verification(message.from_user.id)
+        await add_verification(message.from_user.id, 'unverified', file_id, user_stats["updat_time"])
+        button = [[
+            InlineKeyboardButton(
+                '🔹 Verfiy 🔹', url=gen_url(f'https://telegram.dog/SpaciousUniverseBot?start=REAL-{data}'))
+        ]]
+        return await message.reply(
+            text="""
+            <p>Your Verification Time Is expired. please verify again</p>
+            <br>
+            <small><a href="kalanakt.github.io/projects/telegram/baesuzy/">How To Verify</a></small>
+            """,
+            reply_markup=InlineKeyboardMarkup(button)
+        )
+
+    elif str(user_stats["stats"]) == 'verified':
+        if data.split("-", 1)[0] == "BATCH":
+            sts = await message.reply("Please wait")
+            file_id = data.split("-", 1)[1]
+            msgs = BATCH_FILES.get(file_id)
+            sendmsglist = []
+            if not msgs:
+                file = await client.download_media(file_id)
+                try:
+                    with open(file) as file_data:
+                        msgs = json.load(file_data)
+                except:
+                    await sts.edit("FAILED")
+                    return await client.send_message(LOG_CHANNEL, "UNABLE TO OPEN FILE.")
+                os.remove(file)
+                BATCH_FILES[file_id] = msgs
+            for msg in msgs:
+                title = msg.get("title")
+                size = get_size(int(msg.get("size", 0)))
+                f_caption = msg.get("caption", "")
+                if BATCH_FILE_CAPTION:
+                    try:
+                        f_caption = BATCH_FILE_CAPTION.format(
+                            file_name='' if title is None else title, file_size='' if size is None else size, file_caption='' if f_caption is None else f_caption)
+                    except Exception as e:
+                        logger.exception(e)
+                        f_caption = f_caption
+                if f_caption is None:
+                    f_caption = f"{title}"
+                try:
+                    k = await client.send_cached_media(
+                        chat_id=message.from_user.id,
+                        file_id=msg.get("file_id"),
+                        caption=f_caption,
+                        protect_content=msg.get('protect', False),
+                    )
+                    sendmsglist.append(k)
+                    await add_sent_files(message.from_user.id, msg.get("file_id"))
+
+                except FloodWait as e:
+                    await asyncio.sleep(e.x)
+                    logger.warning(f"Floodwait of {e.x} sec.")
+                    k = await client.send_cached_media(
+                        chat_id=message.from_user.id,
+                        file_id=msg.get("file_id"),
+                        caption=f_caption,
+                        protect_content=msg.get('protect', False),
+                    )
+                    sendmsglist.append(k)
+                    await add_sent_files(message.from_user.id, msg.get("file_id"))
+
+                except Exception as e:
+                    logger.warning(e, exc_info=True)
+                    continue
+                await asyncio.sleep(2)
+            await sts.delete()
+            await message.reply("𝕋𝕙𝕒𝕟𝕜 𝕐𝕠𝕦 𝔽𝕠𝕣 𝕌𝕤𝕚𝕟𝕘 𝕄𝕖 \n\n⭐Rate Me: <a href='https://t.me/tlgrmcbot?start=spaciousuniversebot-review'>Here</a>")
+            kk = await client.send_message(
+                chat_id=message.from_user.id,
+                text="""
+                This Files Will delete in 10min Please Forward To Saved Messages folder before download. \n\nTurned On /notification for get new movie|tv Serieses
+                """)
+
+            await asyncio.sleep(600)
+
+            for k in sendmsglist:
+                await k.delete()
+            sendmsglist = []
+
+            return await kk.delete()
+
+        idstring = await get_ids(file_id)
+
+        if idstring:
+            await remove_inst(file_id)
+            idstring = idstring['links']
+            fileids = idstring.split("L_I_N_K")
+            sendmsglist = []
+            for file_id in fileids:
+                files_ = await get_file_details(file_id)
+                if not files_:
+                    try:
+                        msg = await client.send_cached_media(
+                            chat_id=message.from_user.id,
+                            file_id=file_id
+                        )
+                        filetype = msg.media
+                        file = getattr(msg, filetype)
+                        title = file.file_name
+                        size = get_size(file.file_size)
+                        f_caption = f"<code>{title}</code>"
+                        if CUSTOM_FILE_CAPTION:
+                            try:
+                                f_caption = CUSTOM_FILE_CAPTION.format(
+                                    file_name='' if title is None else title, file_size='' if size is None else size, file_caption='')
+                            except:
+                                return
+                        await msg.edit_caption(f_caption)
+                        return
+                    except:
+                        pass
+                files = files_[0]
+                title = files.file_name
+                size = get_size(files.file_size)
+                f_caption = files.caption
+                if CUSTOM_FILE_CAPTION:
+                    try:
+                        f_caption = CUSTOM_FILE_CAPTION.format(
+                            file_name='' if title is None else title, file_size='' if size is None else size, file_caption='' if f_caption is None else f_caption)
+                    except Exception as e:
+                        logger.exception(e)
+                        f_caption = f_caption
+                if f_caption is None:
+                    f_caption = f"{files.file_name}"
+                try:
+                    k = await client.send_cached_media(
+                        chat_id=message.from_user.id,
+                        file_id=file_id,
+                        caption=f_caption,
+                    )
+                except FloodWait as e:
+                    await asyncio.sleep(e.x)
+                    logger.warning(f"Floodwait of {e.x} sec.")
+                    k = await client.send_cached_media(
+                        chat_id=message.from_user.id,
+                        file_id=file_id,
+                        caption=f_caption,
+                    )
+                sendmsglist.append(k)
+                await add_sent_files(message.from_user.id, file_id)
+
+                await asyncio.sleep(2)
+
+            await message.reply('𝕋𝕙𝕒𝕟𝕜 𝕐𝕠𝕦 𝔽𝕠𝕣 𝕌𝕤𝕚𝕟𝕘 𝕄𝕖')
+            kk = await client.send_message(
+                chat_id=message.from_user.id,
+                text="""
+                This Files Will delete in 10min Please Forward To Saved Messages folder before download. \n\nTurned On /notification for get new movie|tv Serieses
+                """)
+
+            await asyncio.sleep(600)
+
+            for k in sendmsglist:
+                await k.delete()
+
+            sendmsglist = []
+
+            return await kk.delete()
+
+        files_ = await get_file_details(file_id)
+        if not files_:
+            try:
+                pre, file_id = ((base64.urlsafe_b64decode(
+                    data + "=" * (-len(data) % 4))).decode("ascii")).split("_", 1)
+                msg = await client.send_cached_media(
+                    chat_id=message.from_user.id,
+                    file_id=file_id,
+                    protect_content=True if pre == 'filep' else False,
+                )
+                filetype = msg.media
+                file = getattr(msg, filetype)
+                title = file.file_name
+                size = get_size(file.file_size)
+                f_caption = f"<code>{title}</code>"
+                if CUSTOM_FILE_CAPTION:
+                    try:
+                        f_caption = CUSTOM_FILE_CAPTION.format(
+                            file_name='' if title is None else title, file_size='' if size is None else size, file_caption='')
+                    except:
+                        return
+                await msg.edit_caption(f_caption)
+                return
+            except:
+                pass
+            return await message.reply('No such file exist.')
+        files = files_[0]
+        title = files.file_name
+        size = get_size(files.file_size)
+        f_caption = files.caption
+        if CUSTOM_FILE_CAPTION:
+            try:
+                f_caption = CUSTOM_FILE_CAPTION.format(
+                    file_name='' if title is None else title, file_size='' if size is None else size, file_caption='' if f_caption is None else f_caption)
+            except Exception as e:
+                logger.exception(e)
+                f_caption = f_caption
+        if f_caption is None:
+            f_caption = f"{files.file_name}"
+
+        k = await client.send_cached_media(
+            chat_id=message.from_user.id,
+            file_id=file_id,
+            caption=f_caption,
+            protect_content=True if pre == 'filep' else False,
+        )
+        sendmsglist = [k]
+        await add_sent_files(message.from_user.id, file_id)
+
+        files = await send_more_files(title)
+        if files:
+            for file in files[1:]:
+                try:
+                    k = await client.send_cached_media(
+                        chat_id=message.from_user.id,
+                        file_id=file.file_id,
+                        caption=f"<code>{file.file_name}</code>",
+                        protect_content=True if pre == 'filep' else False,
+                    )
+                except FloodWait as e:
+                    await asyncio.sleep(e.x)
+                    logger.warning(f"Floodwait of {e.x} sec.")
+                    k = await client.send_cached_media(
+                        chat_id=message.from_user.id,
+                        file_id=file.file_id,
+                        caption=f"<code>{file.file_name}</code>",
+                        protect_content=True if pre == 'filep' else False,
+                    )
+
+                sendmsglist.append(k)
+                await add_sent_files(message.from_user.id, file.file_id)
+                await asyncio.sleep(2)
+
+            await message.reply("𝕋𝕙𝕒𝕟𝕜 𝕐𝕠𝕦 𝔽𝕠𝕣 𝕌𝕤𝕚𝕟𝕘 𝕄𝕖 \n\n⭐Rate Me: <a href='https://t.me/tlgrmcbot?start=spaciousuniversebot-review'>Here</a>")
+            kk = await client.send_message(
+                chat_id=message.from_user.id,
+                text="""
+                This Files Will delete in 10min Please Forward To Saved Messages folder before download. \n\nTurned On /notification for get new movie|tv Serieses
+                """)
+
+            await asyncio.sleep(600)
+
+            for k in sendmsglist:
+                await k.delete()
+            sendmsglist = []
+
+            return await kk.delete()
+
+
+@Client.on_message(filters.command("addseries") & filters.incoming & filters.user(ADMINS))
+async def tvseries_adder(bot, message):
+    sts = await message.reply("Checking Your Request...")
+    if " " not in message.text:
+        return await message.reply("Use correct format.<code>/addseries (name of series without space) (language eng/hindi/tamil/span) (quility 480/ 720/ 1080) (tv series batch links without space , use commas)</code>\n\n\nExample <code>/addseries strangerthings eng 480 https://tinyurl.com/23smxlh3,https://tinyurl.com/2yq2ghfh,https://tinyurl.com/27d9xyww,https://tinyurl.com/259az578</code>.")
+    data = message.text.strip().split(" ")
+    try:
+        cmd, name, lang, quty, links = data
+        await add_tvseries_filter(name, lang, quty, links)
+        await message.reply("your series added")
+
+    except:
+        return await message.reply("May Be Error is you puts space between links: \nUse correct format.<code>/addseries (name of series without space) (language eng/hindi/tamil/span) (quility 480/ 720/ 1080) (tv series batch links without space , use commas)</code>\n\n\nExample <code>/addseries strangerthings eng 480 https://tinyurl.com/23smxlh3,https://tinyurl.com/2yq2ghfh,https://tinyurl.com/27d9xyww,https://tinyurl.com/259az578</code>.")
+    await sts.delete()
+
+
+@Client.on_message(filters.command("updateseries") & filters.incoming & filters.user(ADMINS))
+async def tvseries_updater(bot, message):
+    sts = await message.reply("Checking Your Request...")
+    if " " not in message.text:
+        return await message.reply("Use correct format.<code>/updateseries (name of series without space) (language eng/hindi/tamil/span) (quility 480/ 720/ 1080) (tv series batch links without space , use commas)</code>\n\n\nExample <code>/addseries strangerthings eng 480 https://tinyurl.com/23smxlh3,https://tinyurl.com/2yq2ghfh,https://tinyurl.com/27d9xyww,https://tinyurl.com/259az578</code>.")
+    data = message.text.strip().split(" ")
+    try:
+        cmd, name, lang, quty, links = data
+        await update_tvseries_filter(name, lang, quty, links)
+        await message.reply("your series added")
+
+    except:
+        return await message.reply("May Be Error is you puts space between links: \nUse correct format.<code>/addseries (name of series without space) (language eng/hindi/tamil/span) (quility 480/ 720/ 1080) (tv series batch links without space , use commas)</code>\n\n\nExample <code>/addseries strangerthings eng 480 https://tinyurl.com/23smxlh3,https://tinyurl.com/2yq2ghfh,https://tinyurl.com/27d9xyww,https://tinyurl.com/259az578</code>.")
+    await sts.delete()
+
+
+@Client.on_message(filters.command("template") & filters.incoming)
+async def add_template(bot, message):
+    sts = await message.reply("Checking Your Request...")
+    if " " not in message.text:
+        return await message.reply("Use correct format. <code>/template (group id) (custom template)</code>")
+    data = message.text.strip().split(" ", 2)
+    try:
+        cmd, groupid, template = data
+        user = await bot.get_chat_member(int(groupid), message.from_user.id)
+        if user.status == enums.ChatMemberStatus.OWNER or user.status == enums.ChatMemberStatus.ADMINISTRATOR:
+            await add_admingroup(groupid, template)
+            await message.reply("your template added ")
+        else:
+            await message.reply("sorry, you'r not admin on that group")
+
+    except Exception as e:
+        return await message.reply(f"Error : {e}.")
+    await sts.delete()
+
+
+@Client.on_message(filters.command("viewtemp") & filters.incoming)
+async def template_get(bot, message):
+    data = message.text.strip().split(" ")
+    cmd, groupid = data
+    k = await get_admingroup(int(groupid))
+    await message.reply(k)
+
+
+@Client.on_message(filters.command("removetemplate") & filters.incoming)
+async def template_remover(bot, message):
+    sts = await message.reply("Checking Your Request...")
+    if " " not in message.text:
+        return await message.reply("Use correct format.<code>/removetemplate (group id)")
+    data = message.text.strip().split(" ")
+    try:
+        cmd, name = data
+        user = await bot.get_chat_member(name, message.from_user.id)
+        if user.status == enums.ChatMemberStatus.OWNER or user.status == enums.ChatMemberStatus.ADMINISTRATOR:
+            await remove_admingroup(int(name))
+            await message.reply("your group template is removed")
+        else:
+            await message.reply("sorry, you'r not admin on that group")
+
+    except:
+        return await message.reply("Not Found.")
+    await sts.delete()
+
+
+@Client.on_message(filters.command("removeseries") & filters.incoming & filters.user(ADMINS))
+async def tvseries_remover(bot, message):
+    sts = await message.reply("Checking Your Request...")
+    if " " not in message.text:
+        return await message.reply("Use correct format.<code>/removeseries (name of series without space)")
+    data = message.text.strip().split(" ")
+    try:
+        cmd, name = data
+        await remove_tvseries(name)
+        await message.reply("your series removed")
+
+    except:
+        return await message.reply("Not Found.")
+    await sts.delete()
+
+
+@Client.on_message(filters.command("alltvs") & filters.incoming)
+async def tvseries_get(bot, message):
+    k = await getlinks()
+    await message.reply(k)
+
+
+@Client.on_message(filters.command('channel') & filters.user(ADMINS))
+async def channel_info(bot, message):
+
+    """Send basic information of channel"""
+    if isinstance(CHANNELS, (int, str)):
+        channels = [CHANNELS]
+    elif isinstance(CHANNELS, list):
+        channels = CHANNELS
+    else:
+        raise ValueError("Unexpected type of CHANNELS")
+
+    text = '📑 **Indexed channels/groups**\n'
+    for channel in channels:
+        chat = await bot.get_chat(channel)
+        if chat.username:
+            text += '\n@' + chat.username
+        else:
+            text += '\n' + chat.title or chat.first_name
+
+    text += f'\n\n**Total:** {len(CHANNELS)}'
+
+    if len(text) < 4096:
+        await message.reply(text)
+    else:
+        file = 'Indexed channels.txt'
+        with open(file, 'w') as f:
+            f.write(text)
+        await message.reply_document(file)
+        os.remove(file)
+
+
+@Client.on_message(filters.command('dev') & filters.user(ADMINS))
+async def devve(bot, message):
+    try:
+        user_stats = await get_verification(message.from_user.id)
+        await message.reply_text(user_stats)
+    except Exception as e:
+        await message.reply(str(e))
+
+
+@Client.on_message((filters.command('notification') | filters.regex('Notification')) & filters.incoming)
+async def get_notification(bot, message):
+    await message.reply_text(
+        'Get Movies/ Tv series On realse Time 〽. Turned on notifications, you can change anytime',
+        reply_markup=InlineKeyboardMarkup(
+            [
+                [
+                    InlineKeyboardButton(
+                        text="On 🔛", callback_data="notification_on"
+                    ),
+                    InlineKeyboardButton(
+                        text="Off 📴", callback_data="notification_off"
+                    )
+                ]
+            ]
+        ),
+        quote=True,
+    )
+
+
+@Client.on_callback_query(filters.regex(r'^notification_on'))
+async def notification_on(bot, query):
+    user_id = query.from_user.id
+    userStatus = await find_notification(user_id)
+    if userStatus is None:
+        await add_notification(user_id, 'on')
+    else:
+        await update_notification(user_id, 'on')
+
+    return await query.message.edit('Succesfully Turned on notifications 💌. use /notification to change')
+
+
+@Client.on_callback_query(filters.regex(r'^notification_off'))
+async def notification_off(bot, query):
+    user_id = query.from_user.id
+    userStatus = await find_notification(user_id)
+    if userStatus is None:
+        await add_notification(user_id, 'off')
+    else:
+        await update_notification(user_id, 'off')
+    return await query.message.edit('Succesfully Turned off notifications 💌. use /notification to change')
+
+
+@Client.on_message(filters.command('sendnoti') & filters.user(ADMINS))
+async def sendnotifications(bot, message):
+    usersIdList = await find_allusers()
+    b_msg = message.reply_to_message
+    if not b_msg:
+        return await message.reply(f"Reply to message")
+    count = 0
+    msg = await message.reply("Processing...⏳", quote=True)
+    for usersId in usersIdList:
+        await broadcast_notification(int(usersId), b_msg)
+        await asyncio.sleep(2)
+        count += 1
+
+    await msg.delete()
+    return await message.reply(f"Succuesfully sended to {count} users")
+
+
+@Client.on_message(filters.command('tmwad') & filters.user(ADMINS))
+async def tmwad_update(bot, message):
+    updates = await get_update_msg()
+    if updates is not None:
+        await remove_update_msg()
+        prev_day_total_users = updates["totalUsers"]
+        prev_day_total_files = updates["files"]
+
+    else:
+        return
+
+    todaySentFiles = await count_sent_files()
+    total_users = await db.total_users_count()
+    files = await Media.count_documents()
+
+    todayUsers = int(total_users) - int(prev_day_total_users)
+    todayFiles = files - prev_day_total_files
+    t = time.localtime()
+    current_time = time.strftime("%D %H:%M:%S", t)
+
+    await add_update_msg(total_users, files)
+
+    try:
+        await bot.edit_message_text(
+            chat_id=str('TMWAD'),
+            message_id=int(49),
+            text=script.POST_TEXT.format(
+                todaySentFiles, todayUsers, todayFiles, total_users, files, current_time)
+        )
+        return await message.reply("Update Succusfully on @TMWAD")
+    except:
+        logger.exception('Some error occured!', exc_info=True)
+
+
+@Client.on_message(filters.command('logs') & filters.user(ADMINS))
+async def log_file(bot, message):
+    """Send log file"""
+    try:
+        await message.reply_document('TelegramBot.log')
+    except Exception as e:
+        await message.reply(str(e))
+
+
+@Client.on_message(filters.command('delete') & filters.user(ADMINS))
+async def delete(bot, message):
+    """Delete file from database"""
+    reply = message.reply_to_message
+    if reply and reply.media:
+        msg = await message.reply("Processing...⏳", quote=True)
+    else:
+        await message.reply('Reply to file with /delete which you want to delete', quote=True)
+        return
+
+    for file_type in ("document", "video", "audio"):
+        media = getattr(reply, file_type, None)
+        if media is not None:
+            break
+    else:
+        await msg.edit('This is not supported file format')
+        return
+
+    file_id, file_ref = unpack_new_file_id(media.file_id)
+
+    result = await Media.collection.delete_one({
+        '_id': file_id,
+    })
+    if result.deleted_count:
+        await msg.edit('File is successfully deleted from database')
+    else:
+        file_name = re.sub(r"(_|\-|\.|\+)", " ", str(media.file_name))
+        result = await Media.collection.delete_many({
+            'file_name': file_name,
+            'file_size': media.file_size,
+            'mime_type': media.mime_type
+        })
+        if result.deleted_count:
+            await msg.edit('File is successfully deleted from database')
+        else:
+            # files indexed before https://github.com/EvamariaTG/EvaMaria/commit/f3d2a1bcb155faf44178e5d7a685a1b533e714bf#diff-86b613edf1748372103e94cacff3b578b36b698ef9c16817bb98fe9ef22fb669R39
+            # have original file name.
+            result = await Media.collection.delete_many({
+                'file_name': media.file_name,
+                'file_size': media.file_size,
+                'mime_type': media.mime_type
+            })
+            if result.deleted_count:
+                await msg.edit('File is successfully deleted from database')
+            else:
+                await msg.edit('File not found in database')
+
+
+@Client.on_message(filters.command('deleteall') & filters.user(ADMINS))
+async def delete_all_index(bot, message):
+    await message.reply_text(
+        'This will delete all indexed files.\nDo you want to continue??',
+        reply_markup=InlineKeyboardMarkup(
+            [
+                [
+                    InlineKeyboardButton(
+                        text="YES", callback_data="autofilter_delete"
+                    )
+                ],
+                [
+                    InlineKeyboardButton(
+                        text="CANCEL", callback_data="close_data"
+                    )
+                ],
+            ]
+        ),
+        quote=True,
+    )
+
+
+@Client.on_callback_query(filters.regex(r'^autofilter_delete'))
+async def delete_all_index_confirm(bot, message):
+    await Media.collection.drop()
+    await message.answer('Piracy Is Crime')
+    await message.message.edit('Succesfully Deleted All The Indexed Files.')
+
+
+@Client.on_message(filters.regex('^[A-Z0-9]*$') & filters.private & filters.incoming)
+async def A2Z_tvseries(bot, update):
+    listD = await find_tvseries_by_first(update.text.lower())
+    Tvserieslist = [series["name"] for series in listD]
+    Tvserieslist = list(dict.fromkeys(Tvserieslist))
+    Tvserieslist.append("Back↩")
+    buttonz = ReplyKeyboardMarkup(split_list(
+        Tvserieslist, 3), resize_keyboard=True)
+    return await bot.send_message(
+        chat_id=update.chat.id,
+        text="Select Tv Series Name | if not found please request in @TMWAD",
+        disable_web_page_preview=True,
+        reply_markup=buttonz,
+        reply_to_message_id=update.id
+    )
+
+
+# @Client.on_message(filters.regex('^[A-Za-z0-9]*$') & filters.private & filters.incoming)
+# async def A2z_tvseries(bot, update):
+#     name = update.text.lower()
+#     if "-|-" in name:
+#         series = name.split("-|-", 1)[0]
+#         quality = name.split("-|-", 1)[1]
+#         listD = await find_tvseries_filter(series)
+#         Tvserieslist = [f"{name}-|-{series['quality']}" for series in listD]
+
+#     listD = await find_tvseries_filter(name)
+#     if listD is None:
+#         return
+#     Tvserieslist = [f"{name}-|-{series['quality']}" for series in listD]
+#     Tvserieslist.append("Back↩")
+#     buttonz = ReplyKeyboardMarkup(split_list(
+#         Tvserieslist, 3), resize_keyboard=True)
+#     return await bot.send_message(
+#         chat_id=update.chat.id,
+#         text="Select Tv Series Qulity | if not found please request in @TMWAD",
+#         disable_web_page_preview=True,
+#         reply_markup=buttonz,
+#         reply_to_message_id=update.id
+#     )
+
+
+@Client.on_message((filters.command('tvseries') | filters.regex('Tv▫Series🔷') | filters.regex("Back↩")) & filters.private)
+async def tvseries(bot, update):
+    buttonz = ReplyKeyboardMarkup(
+        [
+            ["A", "B", "C", "E", "F", "G"],
+            ["H", "I", "J", "K", "L", "M"],
+            ["N", "O", "P", "Q", "R", "S"],
+            ["T", "U", "V", "W", "X", "Y"],
+            ["Z", "1-9", "Home↩"]
+        ],
+        resize_keyboard=True
+    )
+    await bot.send_message(
+        chat_id=update.chat.id,
+        text="Selecet First leter of tv series",
+        disable_web_page_preview=True,
+        reply_markup=buttonz,
+        reply_to_message_id=update.id
+    )
+
+
+@Client.on_message(filters.regex('Home↩') & filters.private)
+async def homeseries(bot, update):
+    buttonz = ReplyKeyboardMarkup(
+        [
+            ["Tv▫Series🔷"],
+            ["Start", "Notification"]
+
+        ],
+        resize_keyboard=True
+    )
+    await bot.send_message(
+        chat_id=update.chat.id,
+        text="Selecet First leter of tv series",
+        disable_web_page_preview=True,
+        reply_markup=buttonz,
+        reply_to_message_id=update.id
+    )
+
+
+@Client.on_message(filters.command('settings'))
+async def settings(client, message):
+    userid = message.from_user.id if message.from_user else None
+    if not userid:
+        return await message.reply(f"You are anonymous admin. Use /connect {message.chat.id} in PM")
+    chat_type = message.chat.type
+
+    if chat_type == "private":
+        grpid = await active_connection(str(userid))
+        if grpid is not None:
+            grp_id = grpid
+            try:
+                chat = await client.get_chat(grpid)
+                title = chat.title
+            except:
+                await message.reply_text("Make sure I'm present in your group!!", quote=True)
+                return
+        else:
+            await message.reply_text("I'm not connected to any groups!", quote=True)
+            return
+
+    elif chat_type in ["group", "supergroup"]:
+        grp_id = message.chat.id
+        title = message.chat.title
+
+    else:
+        return
+
+    st = await client.get_chat_member(grp_id, userid)
+    if (
+            st.status != "administrator"
+            and st.status != "creator"
+            and str(userid) not in ADMINS
+    ):
+        return
+
+    settings = await get_settings(grp_id)
+
+    if settings is not None:
+        buttons = [
+            [
+                InlineKeyboardButton(
+                    'Filter Button',
+                    callback_data=f'setgs#button#{settings["button"]}#{grp_id}',
+                ),
+                InlineKeyboardButton(
+                    'Single' if settings["button"] else 'Double',
+                    callback_data=f'setgs#button#{settings["button"]}#{grp_id}',
+                ),
+            ],
+            [
+                InlineKeyboardButton(
+                    'Bot PM',
+                    callback_data=f'setgs#botpm#{settings["botpm"]}#{grp_id}',
+                ),
+                InlineKeyboardButton(
+                    '✅ Yes' if settings["botpm"] else '❌ No',
+                    callback_data=f'setgs#botpm#{settings["botpm"]}#{grp_id}',
+                ),
+            ],
+            [
+                InlineKeyboardButton(
+                    'File Secure',
+                    callback_data=f'setgs#file_secure#{settings["file_secure"]}#{grp_id}',
+                ),
+                InlineKeyboardButton(
+                    '✅ Yes' if settings["file_secure"] else '❌ No',
+                    callback_data=f'setgs#file_secure#{settings["file_secure"]}#{grp_id}',
+                ),
+            ],
+            [
+                InlineKeyboardButton(
+                    'IMDB',
+                    callback_data=f'setgs#imdb#{settings["imdb"]}#{grp_id}',
+                ),
+                InlineKeyboardButton(
+                    '✅ Yes' if settings["imdb"] else '❌ No',
+                    callback_data=f'setgs#imdb#{settings["imdb"]}#{grp_id}',
+                ),
+            ],
+            [
+                InlineKeyboardButton(
+                    'Spell Check',
+                    callback_data=f'setgs#spell_check#{settings["spell_check"]}#{grp_id}',
+                ),
+                InlineKeyboardButton(
+                    '✅ Yes' if settings["spell_check"] else '❌ No',
+                    callback_data=f'setgs#spell_check#{settings["spell_check"]}#{grp_id}',
+                ),
+            ],
+            [
+                InlineKeyboardButton(
+                    'Welcome',
+                    callback_data=f'setgs#welcome#{settings["welcome"]}#{grp_id}',
+                ),
+                InlineKeyboardButton(
+                    '✅ Yes' if settings["welcome"] else '❌ No',
+                    callback_data=f'setgs#welcome#{settings["welcome"]}#{grp_id}',
+                ),
+            ],
+        ]
+
+        reply_markup = InlineKeyboardMarkup(buttons)
+
+        await message.reply_text(
+            text=f"<b>Change Your Settings for {title} As Your Wish ⚙</b>",
+            reply_markup=reply_markup,
+            disable_web_page_preview=True,
+            reply_to_message_id=message.id
+        )
+
+
+@Client.on_message(filters.command('set_template'))
+async def save_template(client, message):
+    sts = await message.reply("Checking template")
+    userid = message.from_user.id if message.from_user else None
+    if not userid:
+        return await message.reply(f"You are anonymous admin. Use /connect {message.chat.id} in PM")
+    chat_type = message.chat.type
+
+    if chat_type == "private":
+        grpid = await active_connection(str(userid))
+        if grpid is not None:
+            grp_id = grpid
+            try:
+                chat = await client.get_chat(grpid)
+                title = chat.title
+            except:
+                await message.reply_text("Make sure I'm present in your group!!", quote=True)
+                return
+        else:
+            await message.reply_text("I'm not connected to any groups!", quote=True)
+            return
+
+    elif chat_type in ["group", "supergroup"]:
+        grp_id = message.chat.id
+        title = message.chat.title
+
+    else:
+        return
+
+    st = await client.get_chat_member(grp_id, userid)
+    if (
+            st.status != "administrator"
+            and st.status != "creator"
+            and str(userid) not in ADMINS
+    ):
+        return
+
+    if len(message.command) < 2:
+        return await sts.edit("No Input!!")
+    template = message.text.split(" ", 1)[1]
+    await save_group_settings(grp_id, 'template', template)
+    await sts.edit(f"Successfully changed template for {title} to\n\n{template}")

plugins/connection.py

@@ -0,0 +1,148 @@
+from pyrogram import filters, Client
+from pyrogram.types import InlineKeyboardButton, InlineKeyboardMarkup
+from database.connections_mdb import add_connection, all_connections, if_active, delete_connection
+from info import ADMINS
+import logging
+
+logger = logging.getLogger(__name__)
+logger.setLevel(logging.ERROR)
+
+
+@Client.on_message((filters.private | filters.group) & filters.command('connect'))
+async def addconnection(client, message):
+    userid = message.from_user.id if message.from_user else None
+    if not userid:
+        return await message.reply(f"You are anonymous admin. Use /connect {message.chat.id} in PM")
+    chat_type = message.chat.type
+
+    if chat_type == "private":
+        try:
+            cmd, group_id = message.text.split(" ", 1)
+        except:
+            await message.reply_text(
+                "<b>Enter in correct format!</b>\n\n"
+                "<code>/connect groupid</code>\n\n"
+                "<i>Get your Group id by adding this bot to your group and use  <code>/id</code></i>",
+                quote=True
+            )
+            return
+
+    elif chat_type in ["group", "supergroup"]:
+        group_id = message.chat.id
+
+    try:
+        group_id = message.chat.id
+        st = await client.get_chat_member(group_id, userid)
+        if (
+                st.status != "administrator"
+                and st.status != "creator"
+                and userid not in ADMINS
+        ):
+            await message.reply_text("You should be an admin in Given group!", quote=True)
+            return
+    except Exception as e:
+        logger.exception(e)
+        await message.reply_text(
+            "Invalid Group ID!\n\nIf correct, Make sure I'm present in your group!!",
+            quote=True,
+        )
+
+        return
+    try:
+        st = await client.get_chat_member(group_id, "me")
+        if st.status == "administrator":
+            ttl = await client.get_chat(group_id)
+            title = ttl.title
+
+            addcon = await add_connection(str(group_id), str(userid))
+            if addcon:
+                await message.reply_text(
+                    f"Successfully connected to **{title}**\nNow manage your group from my pm !",
+                    quote=True,
+                    parse_mode="md"
+                )
+                if chat_type in ["group", "supergroup"]:
+                    await client.send_message(
+                        userid,
+                        f"Connected to **{title}** !",
+                        parse_mode="md"
+                    )
+            else:
+                await message.reply_text(
+                    "You're already connected to this chat!",
+                    quote=True
+                )
+        else:
+            await message.reply_text("Add me as an admin in group", quote=True)
+    except Exception as e:
+        logger.exception(e)
+        await message.reply_text('Some error occurred! Try again later.', quote=True)
+        return
+
+
+@Client.on_message((filters.private | filters.group) & filters.command('disconnect'))
+async def deleteconnection(client, message):
+    userid = message.from_user.id if message.from_user else None
+    if not userid:
+        return await message.reply(f"You are anonymous admin. Use /connect {message.chat.id} in PM")
+    chat_type = message.chat.type
+
+    if chat_type == "private":
+        await message.reply_text("Run /connections to view or disconnect from groups!", quote=True)
+
+    elif chat_type in ["group", "supergroup"]:
+        group_id = message.chat.id
+
+        st = await client.get_chat_member(group_id, userid)
+        if (
+                st.status != "administrator"
+                and st.status != "creator"
+                and str(userid) not in ADMINS
+        ):
+            return
+
+        delcon = await delete_connection(str(userid), str(group_id))
+        if delcon:
+            await message.reply_text("Successfully disconnected from this chat", quote=True)
+        else:
+            await message.reply_text("This chat isn't connected to me!\nDo /connect to connect.", quote=True)
+
+
+@Client.on_message(filters.private & filters.command(["connections"]))
+async def connections(client, message):
+    userid = message.from_user.id
+
+    groupids = await all_connections(str(userid))
+    if groupids is None:
+        await message.reply_text(
+            "There are no active connections!! Connect to some groups first.",
+            quote=True
+        )
+        return
+    buttons = []
+    for groupid in groupids:
+        try:
+            ttl = await client.get_chat(int(groupid))
+            title = ttl.title
+            active = await if_active(str(userid), str(groupid))
+            act = " - ACTIVE" if active else ""
+            buttons.append(
+                [
+                    InlineKeyboardButton(
+                        text=f"{title}{act}", callback_data=f"groupcb:{groupid}:{act}"
+                    )
+                ]
+            )
+        except:
+            pass
+    if buttons:
+        await message.reply_text(
+            "Your connected group details ;\n\n",
+            reply_markup=InlineKeyboardMarkup(buttons),
+            quote=True
+        )
+    else:
+        await message.reply_text(
+            "There are no active connections!! Connect to some groups first.",
+            quote=True
+        )

plugins/filters.py

@@ -0,0 +1,229 @@
+import io
+from pyrogram import filters, Client
+from pyrogram.types import InlineKeyboardButton, InlineKeyboardMarkup
+from database.filters_mdb import(
+    add_filter,
+    get_filters,
+    delete_filter,
+    count_filters
+)
+
+from database.connections_mdb import active_connection
+from utils import get_file_id, parser, split_quotes
+from info import ADMINS
+
+
+@Client.on_message(filters.command(['filter', 'add']) & filters.incoming)
+async def addfilter(client, message):  # sourcery skip: low-code-quality
+    userid = message.from_user.id if message.from_user else None
+    if not userid:
+        return await message.reply(f"You are anonymous admin. Use /connect {message.chat.id} in PM")
+    chat_type = message.chat.type
+    args = message.text.html.split(None, 1)
+
+    if chat_type == "private":
+        grpid = await active_connection(str(userid))
+        if grpid is not None:
+            grp_id = grpid
+            try:
+                chat = await client.get_chat(grpid)
+                title = chat.title
+            except Exception:
+                await message.reply_text("Make sure I'm present in your group!!", quote=True)
+                return
+        else:
+            await message.reply_text("I'm not connected to any groups!", quote=True)
+            return
+
+    elif chat_type in ["group", "supergroup"]:
+        grp_id = message.chat.id
+        title = message.chat.title
+
+    else:
+        return
+
+    st = await client.get_chat_member(grp_id, userid)
+    if (
+        st.status != "administrator"
+        and st.status != "creator"
+        and str(userid) not in ADMINS
+    ):
+        return
+
+    if len(args) < 2:
+        await message.reply_text("Command Incomplete :(", quote=True)
+        return
+
+    extracted = split_quotes(args[1])
+    text = extracted[0].lower()
+
+    if not message.reply_to_message and len(extracted) < 2:
+        await message.reply_text("Add some content to save your filter!", quote=True)
+        return
+
+    if (len(extracted) >= 2) and not message.reply_to_message:
+        reply_text, btn, alert = parser(extracted[1], text)
+        fileid = None
+        if not reply_text:
+            await message.reply_text("You cannot have buttons alone, give some text to go with it!", quote=True)
+            return
+
+    elif message.reply_to_message and message.reply_to_message.reply_markup:
+        try:
+            rm = message.reply_to_message.reply_markup
+            btn = rm.inline_keyboard
+            if msg := get_file_id(message.reply_to_message):
+                fileid = msg.file_id
+                reply_text = message.reply_to_message.caption.html
+            else:
+                reply_text = message.reply_to_message.text.html
+                fileid = None
+            alert = None
+        except Exception:
+            reply_text = ""
+            btn = "[]"
+            fileid = None
+            alert = None
+
+    elif message.reply_to_message and message.reply_to_message.media:
+        try:
+            msg = get_file_id(message.reply_to_message)
+            fileid = msg.file_id if msg else None
+            reply_text, btn, alert = parser(extracted[1], text) if message.reply_to_message.sticker else parser(
+                message.reply_to_message.caption.html, text)
+        except Exception:
+            reply_text = ""
+            btn = "[]"
+            alert = None
+    elif message.reply_to_message and message.reply_to_message.text:
+        try:
+            fileid = None
+            reply_text, btn, alert = parser(
+                message.reply_to_message.text.html, text)
+        except Exception:
+            reply_text = ""
+            btn = "[]"
+            alert = None
+    else:
+        return
+
+    await add_filter(grp_id, text, reply_text, btn, fileid, alert)
+
+    await message.reply_text(
+        f"Filter for  `{text}`  added in  **{title}**",
+        quote=True,
+        parse_mode="md"
+    )
+
+
+@Client.on_message(filters.command(['viewfilters', 'filters']) & filters.incoming)
+async def get_all(client, message):
+    chat_type = message.chat.type
+    userid = message.from_user.id if message.from_user else None
+    if not userid:
+        return await message.reply(f"You are anonymous admin. Use /connect {message.chat.id} in PM")
+
+    if chat_type == "private":
+        userid = message.from_user.id
+        grpid = await active_connection(str(userid))
+        if grpid is not None:
+            grp_id = grpid
+            try:
+                chat = await client.get_chat(grpid)
+                title = chat.title
+            except Exception:
+                await message.reply_text("Make sure I'm present in your group!!", quote=True)
+                return
+        else:
+            await message.reply_text("I'm not connected to any groups!", quote=True)
+            return
+    elif chat_type in ["group", "supergroup"]:
+        grp_id = message.chat.id
+        title = message.chat.title
+    else:
+        return
+    st = await client.get_chat_member(grp_id, userid)
+    if st.status != "administrator" and st.status != "creator" and str(userid) not in ADMINS:
+        return
+    texts = await get_filters(grp_id)
+    count = await count_filters(grp_id)
+    if count:
+        filterlist = f"Total number of filters in **{title}** : {count}\n\n"
+        for text in texts:
+            keywords = f" ×  `{text}`\n"
+            filterlist += keywords
+        if len(filterlist) > 4096:
+            with io.BytesIO(str.encode(filterlist.replace("`", ""))) as keyword_file:
+                keyword_file.name = "keywords.txt"
+                await message.reply_document(document=keyword_file, quote=True)
+            return
+    else:
+        filterlist = f"There are no active filters in **{title}**"
+    await message.reply_text(text=filterlist, quote=True, parse_mode="md")
+
+
+@Client.on_message(filters.command('del') & filters.incoming)
+async def deletefilter(client, message):
+    userid = message.from_user.id if message.from_user else None
+    if not userid:
+        return await message.reply(f"You are anonymous admin. Use /connect {message.chat.id} in PM")
+
+    chat_type = message.chat.type
+    if chat_type == "private":
+        grpid = await active_connection(str(userid))
+        if grpid is not None:
+            grp_id = grpid
+            try:
+                chat = await client.get_chat(grpid)
+                title = chat.title
+            except Exception:
+                await message.reply_text("Make sure I'm present in your group!!", quote=True)
+                return
+        else:
+            await message.reply_text("I'm not connected to any groups!", quote=True)
+    elif chat_type in ["group", "supergroup"]:
+        grp_id = message.chat.id
+        title = message.chat.title
+    else:
+        return
+    st = await client.get_chat_member(grp_id, userid)
+    if st.status != "administrator" and st.status != "creator" and str(userid) not in ADMINS:
+        return
+    try:
+        cmd, text = message.text.split(" ", 1)
+    except Exception:
+        await message.reply_text("<i>Mention the filtername which you wanna delete!</i>\n\n<code>/del filtername</code>\n\nUse /viewfilters to view all available filters", quote=True)
+
+        return
+    query = text.lower()
+    await delete_filter(message, query, grp_id)
+
+
+@Client.on_message(filters.command('delall') & filters.incoming)
+async def delallconfirm(client, message):
+    userid = message.from_user.id if message.from_user else None
+    if not userid:
+        return await message.reply(f"You are anonymous admin. Use /connect {message.chat.id} in PM")
+
+    chat_type = message.chat.type
+    if chat_type == "private":
+        grpid = await active_connection(str(userid))
+        if grpid is not None:
+            grp_id = grpid
+            try:
+                chat = await client.get_chat(grpid)
+                title = chat.title
+            except Exception:
+                await message.reply_text("Make sure I'm present in your group!!", quote=True)
+                return
+        else:
+            await message.reply_text("I'm not connected to any groups!", quote=True)
+            return
+    elif chat_type in ["group", "supergroup"]:
+        grp_id = message.chat.id
+        title = message.chat.title
+    else:
+        return
+    st = await client.get_chat_member(grp_id, userid)
+    if st.status == "creator" or str(userid) in ADMINS:
+        await message.reply_text(f"This will delete all filters from '{title}'.\nDo you want to continue??", reply_markup=InlineKeyboardMarkup([[InlineKeyboardButton(text="YES", callback_data="delallconfirm")], [InlineKeyboardButton(text="CANCEL", callback_data="delallcancel")]]), quote=True)

plugins/genlink.py

@@ -0,0 +1,105 @@
+import re
+from pyrogram import filters, Client, enums
+from pyrogram.errors.exceptions.bad_request_400 import ChannelInvalid, UsernameInvalid, UsernameNotModified
+from info import ADMINS, LOG_CHANNEL, FILE_STORE_CHANNEL, PUBLIC_FILE_STORE
+from database.ia_filterdb import unpack_new_file_id
+from utils import temp
+import re
+import os
+import json
+import base64
+import logging
+
+logger = logging.getLogger(__name__)
+logger.setLevel(logging.INFO)
+
+
+async def allowed(_, __, message):
+    if PUBLIC_FILE_STORE:
+        return True
+    return bool(message.from_user and message.from_user.id in ADMINS)
+
+
+@Client.on_message(filters.command(['batch', 'pbatch']) & filters.create(allowed))
+async def gen_link_batch(bot, message):  # sourcery skip: low-code-quality
+    if " " not in message.text:
+        return await message.reply("Use correct format.\nExample <code>/batch https://t.me/TeamEvamaria/10 https://t.me/TeamEvamaria/20</code>.")
+    links = message.text.strip().split(" ")
+    if len(links) != 3:
+        return await message.reply("Use correct format.\nExample <code>/batch https://t.me/TeamEvamaria/10 https://t.me/TeamEvamaria/20</code>.")
+    cmd, first, last = links
+    regex = re.compile(
+        "(https://)?(t\.me/|telegram\.me/|telegram\.dog/)(c/)?(\d+|[a-zA-Z_0-9]+)/(\d+)$")
+    match = regex.match(first)
+    if not match:
+        return await message.reply('Invalid link')
+    f_chat_id = match[4]
+    f_msg_id = int(match[5])
+    if f_chat_id.isnumeric():
+        f_chat_id = int(f"-100{f_chat_id}")
+
+    match = regex.match(last)
+    if not match:
+        return await message.reply('Invalid link')
+    l_chat_id = match[4]
+    l_msg_id = int(match[5])
+    if l_chat_id.isnumeric():
+        l_chat_id = int(f"-100{l_chat_id}")
+
+    if f_chat_id != l_chat_id:
+        return await message.reply("Chat ids not matched.")
+    try:
+        chat_id = (await bot.get_chat(f_chat_id)).id
+    except ChannelInvalid:
+        return await message.reply('This may be a private channel / group. Make me an admin over there to index the files.')
+    except (UsernameInvalid, UsernameNotModified):
+        return await message.reply('Invalid Link specified.')
+    except Exception as e:
+        return await message.reply(f'Errors - {e}')
+
+    sts = await message.reply("Generating link for your message.\nThis may take time depending upon number of messages")
+
+    FRMT = "Generating Link...\nTotal Messages: `{total}`\nDone: `{current}`\nRemaining: `{rem}`\nStatus: `{sts}`"
+
+    outlist = []
+
+    # file store without db channel
+    og_msg = 0
+    tot = 0
+    async for msg in bot.iter_messages(f_chat_id, l_msg_id, f_msg_id):
+        tot += 1
+        if msg.empty or msg.service:
+            continue
+        if not msg.media:
+            # only media messages supported.
+            continue
+        try:
+            file_type = msg.media
+            file = getattr(msg, file_type.value)
+            caption = getattr(msg, 'caption', '')
+            if caption:
+                caption = caption.html
+            if file:
+                file = {
+                    "file_id": file.file_id,
+                    "caption": caption,
+                    "title": getattr(file, "file_name", ""),
+                    "size": file.file_size,
+                    "protect": cmd.lower().strip() == "/pbatch",
+                }
+
+                og_msg += 1
+                outlist.append(file)
+        except Exception:
+            pass
+        if not og_msg % 20:
+            try:
+                await sts.edit(FRMT.format(total=l_msg_id-f_msg_id, current=tot, rem=((l_msg_id-f_msg_id) - tot), sts="Saving Messages"))
+            except Exception:
+                pass
+    with open(f"batchmode_{message.from_user.id}.json", "w+") as out:
+        json.dump(outlist, out)
+    post = await bot.send_document(LOG_CHANNEL, f"batchmode_{message.from_user.id}.json", file_name="Batch.json", caption="⚠️Generated for filestore.")
+    os.remove(f"batchmode_{message.from_user.id}.json")
+    file_id, ref = unpack_new_file_id(post.document.file_id)
+    await sts.edit(f"Here is your link\nContains `{og_msg}` files.\n https://t.me/{temp.U_NAME}?start=BATCH-{file_id}")

plugins/index.py

@@ -0,0 +1,155 @@
+from distutils.log import error
+import logging
+import asyncio
+from queue import Empty
+from pyrogram import Client, filters, enums
+from pyrogram.errors import FloodWait
+from pyrogram.errors.exceptions.bad_request_400 import ChannelInvalid, ChatAdminRequired, UsernameInvalid, UsernameNotModified
+from info import ADMINS
+from info import INDEX_REQ_CHANNEL as LOG_CHANNEL
+from database.ia_filterdb import save_file
+from pyrogram.types import InlineKeyboardMarkup, InlineKeyboardButton
+from utils import temp
+import re
+logger = logging.getLogger(__name__)
+logger.setLevel(logging.INFO)
+lock = asyncio.Lock()
+
+
+@Client.on_callback_query(filters.regex('^index'))
+async def index_files(bot, query):
+    if query.data.startswith('index_cancel'):
+        temp.CANCEL = True
+        return await query.answer("Cancelling Indexing")
+    _, raju, chat, lst_msg_id, from_user = query.data.split("#")
+    if raju == 'reject':
+        await query.message.delete()
+        await bot.send_message(int(from_user), f'Your Submission for indexing {chat} has been decliened by our moderators.', reply_to_message_id=int(lst_msg_id))
+
+        return
+    if lock.locked():
+        return await query.answer('Wait until previous process complete.', show_alert=True)
+
+    msg = query.message
+    await query.answer('Processing...⏳', show_alert=True)
+    if int(from_user) not in ADMINS:
+        await bot.send_message(int(from_user), f'Your Submission for indexing {chat} has been accepted by our moderators and will be added soon.', reply_to_message_id=int(lst_msg_id))
+
+    await msg.edit("Starting Indexing", reply_markup=InlineKeyboardMarkup([[InlineKeyboardButton('Cancel', callback_data='index_cancel')]]))
+
+    try:
+        chat = int(chat)
+    except Exception:
+        chat = chat
+    await index_files_to_db(int(lst_msg_id), chat, msg, bot)
+
+
+@Client.on_message(filters.forwarded & filters.private & filters.incoming)
+async def send_for_index(bot, message):
+    if message.chat.type in [enums.ChatType.PRIVATE, enums.ChatType.BOT]:
+        return await message.reply(f'Privet Channel Groups And Bots Not Accept')
+    last_msg_id = message.forward_from_message_id
+    chat_id = message.forward_from_chat.id
+    try:
+        await bot.get_chat(chat_id)
+    except ChannelInvalid:
+        return await message.reply('This may be a private channel / group. Make me an admin over there to index the files.')
+    except (UsernameInvalid, UsernameNotModified):
+        return await message.reply('Invalid Link specified.')
+    except Exception as e:
+        logger.exception(e)
+        return await message.reply(f'Errors - {e}')
+    try:
+        k = await bot.get_messages(chat_id, last_msg_id)
+    except Exception:
+        return await message.reply('Make Sure That Iam An Admin In The Channel, if channel is private')
+    if k.empty:
+        return await message.reply('This may be group and iam not a admin of the group.')
+
+    if message.from_user.id in ADMINS:
+        buttons = [
+            [
+                InlineKeyboardButton('Yes',
+                                     callback_data=f'index#accept#{chat_id}#{last_msg_id}#{message.from_user.id}')
+            ],
+            [
+                InlineKeyboardButton('close', callback_data='close_data'),
+            ]
+        ]
+        reply_markup = InlineKeyboardMarkup(buttons)
+        return await message.reply(
+            f'Do you Want To Index This Channel/ Group ?\n\nChat ID/ Username: <code>{chat_id}</code>\nLast Message ID: <code>{last_msg_id}</code>',
+            reply_markup=reply_markup)
+
+    if type(chat_id) is int:
+        try:
+            link = (await bot.create_chat_invite_link(chat_id)).invite_link
+        except ChatAdminRequired:
+            return await message.reply('Make sure iam an admin in the chat and have permission to invite users.')
+    else:
+        link = f"@{message.forward_from_chat.username}"
+    buttons = [
+        [
+            InlineKeyboardButton('Accept Index',
+                                 callback_data=f'index#accept#{chat_id}#{last_msg_id}#{message.from_user.id}')
+        ],
+        [
+            InlineKeyboardButton('Reject Index',
+                                 callback_data=f'index#reject#{chat_id}#{message.message_id}#{message.from_user.id}'),
+        ]
+    ]
+    reply_markup = InlineKeyboardMarkup(buttons)
+    await bot.send_message(LOG_CHANNEL,
+                           f'#IndexRequest\n\nBy : {message.from_user.mention} (<code>{message.from_user.id}</code>)\nChat ID/ Username - <code> {chat_id}</code>\nLast Message ID - <code>{last_msg_id}</code>\nInviteLink - {link}',
+                           reply_markup=reply_markup)
+    await message.reply('ThankYou For the Contribution, Wait For My Moderators to verify the files.')
+
+
+async def index_files_to_db(lst_msg_id, chat, msg, bot):
+    # sourcery skip: low-code-quality
+    errors, total_files, duplicate, deleted, no_media, unsupported, current = 0, 0, 0, 0, 0, 0, 0
+    msg_id = lst_msg_id
+    try:
+        for msgs in range(abs(lst_msg_id)):
+            current += 1
+            if current % 20 == 0:
+                can = [[InlineKeyboardButton(
+                    'Cancel', callback_data='index_cancel')]]
+                reply = InlineKeyboardMarkup(can)
+                await msg.edit_text(
+                    text=f"Total messages fetched: <code>{current}</code>\nTotal messages saved: <code>{total_files}</code>\nDuplicate Files Skipped: <code>{duplicate}</code>\nDeleted Messages Skipped: <code>{deleted}</code>\nNon-Media messages skipped: <code>{no_media + unsupported}</code>(Unsupported Media - `{unsupported}` )\nErrors Occurred: <code>{errors}</code>",
+                    reply_markup=reply)
+            message = await bot.get_messages(chat, msg_id)
+            if message.empty or not message.media:
+                no_media += 1
+                continue
+
+            for file_type in ("document", "video"):
+                media = getattr(message, file_type, None)
+                if media is not None:
+                    break
+
+            if not media:
+                no_media += 1
+                continue
+
+            media.file_type = file_type
+            media.caption = message.caption
+
+            aynav, vnay = await save_file(media)
+
+            if aynav:
+                total_files += 1
+            elif vnay == 0:
+                duplicate += 1
+            elif vnay == 2:
+                errors += 1
+
+            msgs += 1
+            msg_id -= 1
+
+    except Exception as e:
+        logger.exception(e)
+        await msg.edit(f'Error: {e}')
+    else:
+        await msg.edit(f'Succesfully saved <code>{total_files}</code> to dataBase!\nDuplicate Files Skipped: <code>{duplicate}</code>\nDeleted Messages Skipped: <code>{deleted}</code>\nNon-Media messages skipped: <code>{no_media + unsupported}</code>(Unsupported Media - `{unsupported}` )\nErrors Occurred: <code>{errors}</code>')

plugins/inline.py

@@ -0,0 +1,108 @@
+import logging
+from pyrogram import Client, emoji, filters
+from pyrogram.errors.exceptions.bad_request_400 import QueryIdInvalid
+from pyrogram.types import InlineKeyboardButton, InlineKeyboardMarkup, InlineQueryResultCachedDocument, InlineQuery
+from database.ia_filterdb import get_search_results
+from utils import is_subscribed, get_size, temp
+from info import CACHE_TIME, AUTH_USERS, AUTH_CHANNEL, CUSTOM_FILE_CAPTION
+
+logger = logging.getLogger(__name__)
+cache_time = 0 if AUTH_USERS or AUTH_CHANNEL else CACHE_TIME
+
+async def inline_users(query: InlineQuery):
+    if AUTH_USERS:
+        return bool(query.from_user and query.from_user.id in AUTH_USERS)
+    return bool(query.from_user and query.from_user.id not in temp.BANNED_USERS)
+
+@Client.on_inline_query()
+async def answer(bot, query):
+    """Show search results for given inline query"""
+
+    if not await inline_users(query):
+        await query.answer(results=[],
+                           cache_time=0,
+                           switch_pm_text='okDa',
+                           switch_pm_parameter="hehe")
+        return
+
+    if AUTH_CHANNEL and not await is_subscribed(bot, query):
+        await query.answer(results=[],
+                           cache_time=0,
+                           switch_pm_text='You have to subscribe my channel to use the bot',
+                           switch_pm_parameter="subscribe")
+        return
+
+    results = []
+    if '|' in query.query:
+        string, file_type = query.query.split('|', maxsplit=1)
+        string = string.strip()
+        file_type = file_type.strip().lower()
+    else:
+        string = query.query.strip()
+        file_type = None
+
+    offset = int(query.offset or 0)
+    reply_markup = get_reply_markup(query=string)
+    files, next_offset, total = await get_search_results(string,
+                                                  file_type=file_type,
+                                                  max_results=10,
+                                                  offset=offset)
+
+    for file in files:
+        title=file.file_name
+        size=get_size(file.file_size)
+        f_caption=file.caption
+        if CUSTOM_FILE_CAPTION:
+            try:
+                f_caption=CUSTOM_FILE_CAPTION.format(file_name= '' if title is None else title, file_size='' if size is None else size, file_caption='' if f_caption is None else f_caption)
+            except Exception as e:
+                logger.exception(e)
+                f_caption=f_caption
+        if f_caption is None:
+            f_caption = f"{file.file_name}"
+        results.append(
+            InlineQueryResultCachedDocument(
+                title=file.file_name,
+                file_id=file.file_id,
+                caption=f_caption,
+                description=f'Size: {get_size(file.file_size)}\nType: {file.file_type}',
+                reply_markup=reply_markup))
+
+    if results:
+        switch_pm_text = f"{emoji.FILE_FOLDER} Results - {total}"
+        if string:
+            switch_pm_text += f" for {string}"
+        try:
+            await query.answer(results=results,
+                           is_personal = True,
+                           cache_time=cache_time,
+                           switch_pm_text=switch_pm_text,
+                           switch_pm_parameter="start",
+                           next_offset=str(next_offset))
+        except QueryIdInvalid:
+            pass
+        except Exception as e:
+            logging.exception(str(e))
+    else:
+        switch_pm_text = f'{emoji.CROSS_MARK} No results'
+        if string:
+            switch_pm_text += f' for "{string}"'
+
+        await query.answer(results=[],
+                           is_personal = True,
+                           cache_time=cache_time,
+                           switch_pm_text=switch_pm_text,
+                           switch_pm_parameter="okay")
+
+
+def get_reply_markup(query):
+    buttons = [
+        [
+            InlineKeyboardButton('Search again', switch_inline_query_current_chat=query)
+        ]
+        ]
+    return InlineKeyboardMarkup(buttons)
+
+
+
+

plugins/misc.py

@@ -0,0 +1,212 @@
+import os
+from pyrogram import Client, filters
+from pyrogram.errors.exceptions.bad_request_400 import UserNotParticipant, MediaEmpty, PhotoInvalidDimensions, WebpageMediaEmpty
+from info import IMDB_TEMPLATE
+from utils import extract_user, get_file_id, get_poster, last_online
+import time
+from datetime import datetime
+from pyrogram.types import InlineKeyboardMarkup, InlineKeyboardButton, CallbackQuery
+import logging
+logger = logging.getLogger(__name__)
+logger.setLevel(logging.ERROR)
+
+
+@Client.on_message(filters.command('id'))
+async def showid(client, message):
+    chat_type = message.chat.type
+    if chat_type == "private":
+        user_id = message.chat.id
+        first = message.from_user.first_name
+        last = message.from_user.last_name or ""
+        username = message.from_user.username or ""
+        dc_id = message.from_user.dc_id or ""
+        await message.reply_text(
+            f"<b>➲ First Name:</b> {first}\n<b>➲ Last Name:</b> {last}\n<b>➲ Username:</b> {username}\n<b>➲ Telegram ID:</b> <code>{user_id}</code>\n<b>➲ Data Centre:</b> <code>{dc_id}</code>",
+            quote=True
+        )
+
+    elif chat_type in ["group", "supergroup"]:
+        _id = ""
+        _id += (
+            "<b>➲ Chat ID</b>: "
+            f"<code>{message.chat.id}</code>\n"
+        )
+        if message.reply_to_message:
+            _id += (
+                "<b>➲ User ID</b>: "
+                f"<code>{message.from_user.id if message.from_user else 'Anonymous'}</code>\n"
+                "<b>➲ Replied User ID</b>: "
+                f"<code>{message.reply_to_message.from_user.id if message.reply_to_message.from_user else 'Anonymous'}</code>\n"
+            )
+            file_info = get_file_id(message.reply_to_message)
+        else:
+            _id += (
+                "<b>➲ User ID</b>: "
+                f"<code>{message.from_user.id if message.from_user else 'Anonymous'}</code>\n"
+            )
+            file_info = get_file_id(message)
+        if file_info:
+            _id += (
+                f"<b>{file_info.message_type}</b>: "
+                f"<code>{file_info.file_id}</code>\n"
+            )
+        await message.reply_text(
+            _id,
+            quote=True
+        )
+
+
+@Client.on_message(filters.command(["info"]))
+async def who_is(client, message):
+    # https://github.com/SpEcHiDe/PyroGramBot/blob/master/pyrobot/plugins/admemes/whois.py#L19
+    status_message = await message.reply_text(
+        "`Fetching user info...`"
+    )
+    await status_message.edit(
+        "`Processing user info...`"
+    )
+    from_user = None
+    from_user_id, _ = extract_user(message)
+    try:
+        from_user = await client.get_users(from_user_id)
+    except Exception as error:
+        await status_message.edit(str(error))
+        return
+    if from_user is None:
+        return await status_message.edit("no valid user_id / message specified")
+    message_out_str = ""
+    message_out_str += f"<b>➲First Name:</b> {from_user.first_name}\n"
+    last_name = from_user.last_name or "<b>None</b>"
+    message_out_str += f"<b>➲Last Name:</b> {last_name}\n"
+    message_out_str += f"<b>➲Telegram ID:</b> <code>{from_user.id}</code>\n"
+    username = from_user.username or "<b>None</b>"
+    dc_id = from_user.dc_id or "[User Doesn't Have A Valid DP]"
+    message_out_str += f"<b>➲Data Centre:</b> <code>{dc_id}</code>\n"
+    message_out_str += f"<b>➲User Name:</b> @{username}\n"
+    message_out_str += f"<b>➲User 𝖫𝗂𝗇𝗄:</b> <a href='tg://user?id={from_user.id}'><b>Click Here</b></a>\n"
+    if message.chat.type in (("supergroup", "channel")):
+        try:
+            chat_member_p = await message.chat.get_member(from_user.id)
+            joined_date = datetime.fromtimestamp(
+                chat_member_p.joined_date or time.time()
+            ).strftime("%Y.%m.%d %H:%M:%S")
+            message_out_str += (
+                "<b>➲Joined this Chat on:</b> <code>"
+                f"{joined_date}"
+                "</code>\n"
+            )
+        except UserNotParticipant:
+            pass
+    if chat_photo := from_user.photo:
+        local_user_photo = await client.download_media(
+            message=chat_photo.big_file_id
+        )
+        buttons = [[
+            InlineKeyboardButton('🔐 Close', callback_data='close_data')
+        ]]
+        reply_markup = InlineKeyboardMarkup(buttons)
+        await message.reply_photo(
+            photo=local_user_photo,
+            quote=True,
+            reply_markup=reply_markup,
+            caption=message_out_str,
+            disable_notification=True
+        )
+        os.remove(local_user_photo)
+    else:
+        buttons = [[
+            InlineKeyboardButton('🔐 Close', callback_data='close_data')
+        ]]
+        reply_markup = InlineKeyboardMarkup(buttons)
+        await message.reply_text(
+            text=message_out_str,
+            reply_markup=reply_markup,
+            quote=True,
+            disable_notification=True
+        )
+    await status_message.delete()
+
+
+@Client.on_message(filters.command(["imdb", 'search']))
+async def imdb_search(client, message):
+    if ' ' in message.text:
+        k = await message.reply('Searching ImDB')
+        r, title = message.text.split(None, 1)
+        movies = await get_poster(title, bulk=True)
+        if not movies:
+            return await message.reply("No results Found")
+        btn = [
+            [
+                InlineKeyboardButton(
+                    text=f"{movie.get('title')} - {movie.get('year')}",
+                    callback_data=f"imdb#{movie.movieID}",
+                )
+            ]
+            for movie in movies
+        ]
+        await k.edit('Here is what i found on IMDb', reply_markup=InlineKeyboardMarkup(btn))
+    else:
+        await message.reply('Give me a movie / series Name')
+
+
+@Client.on_callback_query(filters.regex('^imdb'))
+async def imdb_callback(bot: Client, quer_y: CallbackQuery):
+    i, movie = quer_y.data.split('#')
+    imdb = await get_poster(query=movie, id=True)
+    btn = [
+        [
+            InlineKeyboardButton(
+                text=f"{imdb.get('title')}",
+                url=imdb['url'],
+            )
+        ]
+    ]
+    message = quer_y.message.reply_to_message or quer_y.message
+    if imdb:
+        caption = IMDB_TEMPLATE.format(
+            query=imdb['title'],
+            title=imdb['title'],
+            votes=imdb['votes'],
+            aka=imdb["aka"],
+            seasons=imdb["seasons"],
+            box_office=imdb['box_office'],
+            localized_title=imdb['localized_title'],
+            kind=imdb['kind'],
+            imdb_id=imdb["imdb_id"],
+            cast=imdb["cast"],
+            runtime=imdb["runtime"],
+            countries=imdb["countries"],
+            certificates=imdb["certificates"],
+            languages=imdb["languages"],
+            director=imdb["director"],
+            writer=imdb["writer"],
+            producer=imdb["producer"],
+            composer=imdb["composer"],
+            cinematographer=imdb["cinematographer"],
+            music_team=imdb["music_team"],
+            distributors=imdb["distributors"],
+            release_date=imdb['release_date'],
+            year=imdb['year'],
+            genres=imdb['genres'],
+            poster=imdb['poster'],
+            plot=imdb['plot'],
+            rating=imdb['rating'],
+            url=imdb['url'],
+            **locals()
+        )
+    else:
+        caption = "No Results"
+    if imdb.get('poster'):
+        try:
+            await quer_y.message.reply_photo(photo=imdb['poster'], caption=caption, reply_markup=InlineKeyboardMarkup(btn))
+        except (MediaEmpty, PhotoInvalidDimensions, WebpageMediaEmpty):
+            pic = imdb.get('poster')
+            poster = pic.replace('.jpg', "._V1_UX360.jpg")
+            await quer_y.message.reply_photo(photo=poster, caption=caption, reply_markup=InlineKeyboardMarkup(btn))
+        except Exception as e:
+            logger.exception(e)
+            await quer_y.message.reply(caption, reply_markup=InlineKeyboardMarkup(btn), disable_web_page_preview=False)
+        await quer_y.message.delete()
+    else:
+        await quer_y.message.edit(caption, reply_markup=InlineKeyboardMarkup(btn), disable_web_page_preview=False)
+    await quer_y.answer()

plugins/p_ttishow.py

@@ -0,0 +1,270 @@
+from pyrogram import Client, filters
+from pyrogram.types import InlineKeyboardButton, InlineKeyboardMarkup
+from pyrogram.errors.exceptions.bad_request_400 import MessageTooLong, PeerIdInvalid
+from info import ADMINS, LOG_CHANNEL, SUPPORT_CHAT, MELCOW_NEW_USERS
+from database.users_chats_db import db
+from database.ia_filterdb import Media
+from utils import get_size, temp, get_settings
+from Script import script
+from pyrogram.errors import ChatAdminRequired
+
+"""-----------------------------------------https://t.me/GetTGLink/4179 --------------------------------------"""
+
+@Client.on_message(filters.new_chat_members & filters.group)
+async def save_group(bot, message):
+    r_j_check = [u.id for u in message.new_chat_members]
+    if temp.ME in r_j_check:
+        if not await db.get_chat(message.chat.id):
+            total=await bot.get_chat_members_count(message.chat.id)
+            r_j = message.from_user.mention if message.from_user else "Anonymous" 
+            await bot.send_message(LOG_CHANNEL, script.LOG_TEXT_G.format(message.chat.title, message.chat.id, total, r_j))       
+            await db.add_chat(message.chat.id, message.chat.title)
+        if message.chat.id in temp.BANNED_CHATS:
+            # Inspired from a boat of a banana tree
+            buttons = [[
+                InlineKeyboardButton('Support', url=f'https://t.me/{SUPPORT_CHAT}')
+            ]]
+            reply_markup=InlineKeyboardMarkup(buttons)
+            k = await message.reply(
+                text='<b>CHAT NOT ALLOWED 🐞\n\nMy admins has restricted me from working here ! If you want to know more about it contact support..</b>',
+                reply_markup=reply_markup,
+            )
+
+            try:
+                await k.pin()
+            except:
+                pass
+            await bot.leave_chat(message.chat.id)
+            return
+        buttons = [[
+            InlineKeyboardButton('ℹ️ Help', url=f"https://t.me/{temp.U_NAME}?start=help"),
+            InlineKeyboardButton('📢 Updates', url='https://t.me/TMWAD')
+        ]]
+        reply_markup=InlineKeyboardMarkup(buttons)
+        await message.reply_text(
+            text=f"<b>Thankyou For Adding Me In {message.chat.title} ❣️\n\nIf you have any questions & doubts about using me contact support.</b>",
+            reply_markup=reply_markup)
+    else:
+        settings = await get_settings(message.chat.id)
+        if settings["welcome"]:
+            for u in message.new_chat_members:
+                if (temp.MELCOW).get('welcome') is not None:
+                    try:
+                        await (temp.MELCOW['welcome']).delete()
+                    except:
+                        pass
+                temp.MELCOW['welcome'] = await message.reply(f"<b>Hey , {u.mention}, Welcome to {message.chat.title}</b>")
+
+
+@Client.on_message(filters.command('leave') & filters.user(ADMINS))
+async def leave_a_chat(bot, message):
+    if len(message.command) == 1:
+        return await message.reply('Give me a chat id')
+    chat = message.command[1]
+    try:
+        chat = int(chat)
+    except:
+        chat = chat
+    try:
+        buttons = [[
+            InlineKeyboardButton('Support', url=f'https://t.me/{SUPPORT_CHAT}')
+        ]]
+        reply_markup=InlineKeyboardMarkup(buttons)
+        await bot.send_message(
+            chat_id=chat,
+            text='<b>Hello Friends, \nMy admin has told me to leave from group so i go! If you wanna add me again contact my support group.</b>',
+            reply_markup=reply_markup,
+        )
+
+        await bot.leave_chat(chat)
+        await message.reply(f"left the chat `{chat}`")
+    except Exception as e:
+        await message.reply(f'Error - {e}')
+
+@Client.on_message(filters.command('disable') & filters.user(ADMINS))
+async def disable_chat(bot, message):
+    if len(message.command) == 1:
+        return await message.reply('Give me a chat id')
+    r = message.text.split(None)
+    if len(r) > 2:
+        reason = message.text.split(None, 2)[2]
+        chat = message.text.split(None, 2)[1]
+    else:
+        chat = message.command[1]
+        reason = "No reason Provided"
+    try:
+        chat_ = int(chat)
+    except:
+        return await message.reply('Give Me A Valid Chat ID')
+    cha_t = await db.get_chat(chat_)
+    if not cha_t:
+        return await message.reply("Chat Not Found In DB")
+    if cha_t['is_disabled']:
+        return await message.reply(f"This chat is already disabled:\nReason-<code> {cha_t['reason']} </code>")
+    await db.disable_chat(chat_, reason)
+    temp.BANNED_CHATS.append(chat_)
+    await message.reply('Chat Successfully Disabled')
+    try:
+        buttons = [[
+            InlineKeyboardButton('Support', url=f'https://t.me/{SUPPORT_CHAT}')
+        ]]
+        reply_markup=InlineKeyboardMarkup(buttons)
+        await bot.send_message(
+            chat_id=chat_, 
+            text=f'<b>Hello Friends, \nMy admin has told me to leave from group so i go! If you wanna add me again contact my support group.</b> \nReason : <code>{reason}</code>',
+            reply_markup=reply_markup)
+        await bot.leave_chat(chat_)
+    except Exception as e:
+        await message.reply(f"Error - {e}")
+
+
+@Client.on_message(filters.command('enable') & filters.user(ADMINS))
+async def re_enable_chat(bot, message):
+    if len(message.command) == 1:
+        return await message.reply('Give me a chat id')
+    chat = message.command[1]
+    try:
+        chat_ = int(chat)
+    except:
+        return await message.reply('Give Me A Valid Chat ID')
+    sts = await db.get_chat(int(chat))
+    if not sts:
+        return await message.reply("Chat Not Found In DB !")
+    if not sts.get('is_disabled'):
+        return await message.reply('This chat is not yet disabled.')
+    await db.re_enable_chat(chat_)
+    temp.BANNED_CHATS.remove(chat_)
+    await message.reply("Chat Successfully re-enabled")
+
+
+@Client.on_message(filters.command('stats') & filters.incoming)
+async def get_ststs(bot, message):
+    rju = await message.reply('Fetching stats..')
+    total_users = await db.total_users_count()
+    totl_chats = await db.total_chat_count()
+    files = await Media.count_documents()
+    size = await db.get_db_size()
+    free = 536870912 - size
+    size = get_size(size)
+    free = get_size(free)
+    await rju.edit(script.STATUS_TXT.format(files, total_users, totl_chats, size, free))
+
+
+# a function for trespassing into others groups, Inspired by a Vazha
+# Not to be used , But Just to showcase his vazhatharam.
+# @Client.on_message(filters.command('invite') & filters.user(ADMINS))
+async def gen_invite(bot, message):
+    if len(message.command) == 1:
+        return await message.reply('Give me a chat id')
+    chat = message.command[1]
+    try:
+        chat = int(chat)
+    except Exception:
+        return await message.reply('Give Me A Valid Chat ID')
+    try:
+        link = await bot.create_chat_invite_link(chat)
+    except ChatAdminRequired:
+        return await message.reply("Invite Link Generation Failed, Iam Not Having Sufficient Rights")
+    except Exception as e:
+        return await message.reply(f'Error {e}')
+    await message.reply(f'Here is your Invite Link {link.invite_link}')
+
+@Client.on_message(filters.command('ban') & filters.user(ADMINS))
+async def ban_a_user(bot, message):
+    if len(message.command) == 1:
+        return await message.reply('Give me a user id / username')
+    r = message.text.split(None)
+    if len(r) > 2:
+        reason = message.text.split(None, 2)[2]
+        chat = message.text.split(None, 2)[1]
+    else:
+        chat = message.command[1]
+        reason = "No reason Provided"
+    try:
+        chat = int(chat)
+    except:
+        pass
+    try:
+        k = await bot.get_users(chat)
+    except PeerIdInvalid:
+        return await message.reply("This is an invalid user, make sure ia have met him before.")
+    except IndexError:
+        return await message.reply("This might be a channel, make sure its a user.")
+    except Exception as e:
+        return await message.reply(f'Error - {e}')
+    else:
+        jar = await db.get_ban_status(k.id)
+        if jar['is_banned']:
+            return await message.reply(f"{k.mention} is already banned\nReason: {jar['ban_reason']}")
+        await db.ban_user(k.id, reason)
+        temp.BANNED_USERS.append(k.id)
+        await message.reply(f"Successfully banned {k.mention}")
+
+
+    
+@Client.on_message(filters.command('unban') & filters.user(ADMINS))
+async def unban_a_user(bot, message):
+    if len(message.command) == 1:
+        return await message.reply('Give me a user id / username')
+    r = message.text.split(None)
+    if len(r) > 2:
+        reason = message.text.split(None, 2)[2]
+        chat = message.text.split(None, 2)[1]
+    else:
+        chat = message.command[1]
+        reason = "No reason Provided"
+        
+    chat = int(chat)
+    try:
+        k = await bot.get_users(chat)
+    except PeerIdInvalid:
+        return await message.reply("This is an invalid user, make sure ia have met him before.")
+
+    except IndexError:
+        return await message.reply("Thismight be a channel, make sure its a user.")
+    except Exception as e:
+        return await message.reply(f'Error - {e}')
+    else:
+        jar = await db.get_ban_status(k.id)
+        if not jar['is_banned']:
+            return await message.reply(f"{k.mention} is not yet banned.")
+        await db.remove_ban(k.id)
+        temp.BANNED_USERS.remove(k.id)
+        await message.reply(f"Successfully unbanned {k.mention}")
+
+
+    
+@Client.on_message(filters.command('users') & filters.user(ADMINS))
+async def list_users(bot, message):
+    # https://t.me/GetTGLink/4184
+    raju = await message.reply('Getting List Of Users')
+    users = await db.get_all_users()
+    out = "Users Saved In DB Are:\n\n"
+    async for user in users:
+        out += f"<a href=tg://user?id={user['id']}>{user['name']}</a>"
+        if user['ban_status']['is_banned']:
+            out += '( Banned User )'
+        out += '\n'
+    try:
+        await raju.edit_text(out)
+    except MessageTooLong:
+        with open('users.txt', 'w+') as outfile:
+            outfile.write(out)
+        await message.reply_document('users.txt', caption="List Of Users")
+
+@Client.on_message(filters.command('chats') & filters.user(ADMINS))
+async def list_chats(bot, message):
+    raju = await message.reply('Getting List Of chats')
+    chats = await db.get_all_chats()
+    out = "Chats Saved In DB Are:\n\n"
+    async for chat in chats:
+        out += f"**Title:** `{chat['title']}`\n**- ID:** `{chat['id']}`"
+        if chat['chat_status']['is_disabled']:
+            out += '( Disabled Chat )'
+        out += '\n'
+    try:
+        await raju.edit_text(out)
+    except MessageTooLong:
+        with open('chats.txt', 'w+') as outfile:
+            outfile.write(out)
+        await message.reply_document('chats.txt', caption="List Of Chats")

plugins/pm_filter.py

@@ -0,0 +1,1250 @@
+# Kanged From @TroJanZheX
+import asyncio
+import os
+import re
+import ast
+import time
+from PIL import Image
+import urllib.request
+from pyrogram.errors.exceptions.bad_request_400 import MediaEmpty, PhotoInvalidDimensions, WebpageMediaEmpty, MessageEmpty
+from Script import script
+import pyrogram
+from database.admin_group import get_admingroup
+from database.connections_mdb import active_connection, all_connections, delete_connection, if_active, make_active, \
+    make_inactive
+from info import ADMINS, AUTH_CHANNEL, AUTH_USERS, CUSTOM_FILE_CAPTION, AUTH_GROUPS, P_TTI_SHOW_OFF, IMDB, \
+    SINGLE_BUTTON, SPELL_CHECK_REPLY, IMDB_TEMPLATE
+from pyrogram.types import InlineKeyboardMarkup, InlineKeyboardButton, CallbackQuery
+from pyrogram import Client, filters, enums
+from pyrogram.errors import FloodWait, UserIsBlocked, MessageNotModified, PeerIdInvalid
+from utils import get_size, is_subscribed, get_poster, search_gagala, temp, get_settings, save_group_settings, get_name, getseries, send_more_files, gen_url
+from database.users_chats_db import db
+from database.ia_filterdb import Media, get_file_details, get_search_results
+from database.tvseriesfilters import add_tvseries_filter, update_tvseries_filter, getlinks, find_tvseries_filter, remove_tvseries
+from database.quickdb import remove_inst, get_ids, add_sent_files, get_verification, remove_verification, add_verification
+from database.filters_mdb import (
+    del_all,
+    find_filter,
+    get_filters,
+)
+import logging
+
+logger = logging.getLogger(__name__)
+logger.setLevel(logging.ERROR)
+
+BUTTONS = {}
+SPELL_CHECK = {}
+
+DOWNLOAD_LOCATION = "./DOWNLOADS"
+
+
+@Client.on_message(filters.group & filters.text & filters.incoming)
+async def give_filter(client, message):
+#     await tvseries_filters(client, message)
+    await auto_filter(client, message)
+#     await manual_filters(client, message)
+
+
+@Client.on_message(filters.private & filters.text & filters.incoming)
+async def pm_give_filter(client, message):
+    k = await tvseries_filters(client, message)
+
+    if k is False:
+        await pm_auto_filter(client, message)
+
+
+@Client.on_callback_query(filters.regex("^next"))
+async def next_page(bot, query):
+    ident, req, key, offset = query.data.split("_")
+    if int(req) not in [query.from_user.id, 0]:
+        return await query.answer("This is Not For You !!!", show_alert=True)
+    try:
+        offset = int(offset)
+    except Exception:
+        offset = 0
+    search = BUTTONS.get(key)
+    if not search:
+        await query.answer("You are using one of my old messages, please send the request again.", show_alert=True)
+
+        return
+    files, n_offset, total = await get_search_results(search, offset=offset, filter=True)
+
+    try:
+        n_offset = int(n_offset)
+    except Exception:
+        n_offset = 0
+    if not files:
+        return
+    fileids = [file.file_id for file in files]
+    dbid = fileids[0]
+    fileids = "L_I_N_K".join(fileids)
+
+    btn = [[InlineKeyboardButton(text=f"{get_size(file.file_size)} ║ {get_name(file.file_name)}", url=gen_url(
+        f'https://telegram.dog/SpaciousUniverseBot?start=FEND-{file.file_id}'))] for file in files]
+
+    btn.insert(0, [InlineKeyboardButton("◈ All Files ◈", url=gen_url(
+        f'https://telegram.dog/SpaciousUniverseBot?start=FEND-{dbid}'))])
+
+    if 0 < offset <= 10:
+        off_set = 0
+    elif offset == 0:
+        off_set = None
+    else:
+        off_set = offset - 10
+    if n_offset == 0:
+        btn.append([InlineKeyboardButton("◄ Back", callback_data=f"next_{req}_{key}_{off_set}"), InlineKeyboardButton(
+            f"❏ Pages {round(offset / 10) + 1} / {round(total / 10)}", callback_data="pages")])
+
+    elif off_set is None:
+        btn.append([InlineKeyboardButton(f"❏ {round(offset / 10) + 1} / {round(total / 10)}",
+                   callback_data="pages"), InlineKeyboardButton("Next ►", callback_data=f"next_{req}_{key}_{n_offset}")])
+
+    else:
+        btn.append([InlineKeyboardButton("◄ Back", callback_data=f"next_{req}_{key}_{off_set}"), InlineKeyboardButton(
+            f"❏ {round(offset / 10) + 1} / {round(total / 10)}", callback_data="pages"), InlineKeyboardButton("Next ►", callback_data=f"next_{req}_{key}_{n_offset}")])
+
+    try:
+        await query.edit_message_reply_markup(reply_markup=InlineKeyboardMarkup(btn))
+    except MessageNotModified:
+        pass
+    await query.answer()
+
+
+@Client.on_callback_query(filters.regex("^pmnext"))
+async def pm_next_page(bot, query):
+    ident, req, key, offset = query.data.split("_")
+    try:
+        offset = int(offset)
+    except Exception:
+        offset = 0
+    search = BUTTONS.get(key)
+    if not search:
+        await query.answer("You are using one of my old messages, please send the request again.", show_alert=True)
+
+        return
+    files, n_offset, total = await get_search_results(search, offset=offset, filter=True)
+
+    try:
+        n_offset = int(n_offset)
+    except Exception:
+        n_offset = 0
+    if not files:
+        return
+    fileids = [file.file_id for file in files]
+    dbid = fileids[0]
+    fileids = "L_I_N_K".join(fileids)
+    btn = [[InlineKeyboardButton(text=f"{get_size(file.file_size)} ║ {get_name(file.file_name)}",
+                                 callback_data=f'pmfiles#{file.file_id}')] for file in files]
+
+    if 0 < offset <= 10:
+        off_set = 0
+    elif offset == 0:
+        off_set = None
+    else:
+        off_set = offset - 10
+    if n_offset == 0:
+        btn.append([InlineKeyboardButton("◄ Back", callback_data=f"pmnext_{req}_{key}_{off_set}"), InlineKeyboardButton(
+            f"❏ Pages {round(offset / 10) + 1} / {round(total / 10)}", callback_data="pages")])
+
+    elif off_set is None:
+        btn.append([InlineKeyboardButton(f"❏ {round(offset / 10) + 1} / {round(total / 10)}", callback_data="pages"),
+                   InlineKeyboardButton("Next ►", callback_data=f"pmnext_{req}_{key}_{n_offset}")])
+
+    else:
+        btn.append([InlineKeyboardButton("◄ Back", callback_data=f"pmnext_{req}_{key}_{off_set}"), InlineKeyboardButton(
+            f"❏ {round(offset / 10) + 1} / {round(total / 10)}", callback_data="pages"), InlineKeyboardButton("Next ►", callback_data=f"pmnext_{req}_{key}_{n_offset}")])
+
+    btn.insert(0, [InlineKeyboardButton(
+        "◈ All Files ◈", callback_data=f'pmfiles#{dbid}')])
+
+    try:
+        await query.edit_message_reply_markup(reply_markup=InlineKeyboardMarkup(btn))
+    except MessageNotModified:
+        pass
+    await query.answer()
+
+
+@Client.on_callback_query(filters.regex("^spolling"))
+async def advantage_spoll_choker(bot, query):
+    _, user, movie_ = query.data.split('#')
+    if int(user) != 0 and query.from_user.id != int(user):
+        return await query.answer("This is not for you", show_alert=True)
+    if movie_ == "close_spellcheck":
+        return await query.message.delete()
+    try:
+        movies = SPELL_CHECK.get(query.message.reply_to_message.id)
+    except Exception:
+        return await query.answer('Something went wrong...')
+    if not movies:
+        return await query.answer("You are clicking on an old button which is expired.", show_alert=True)
+
+    movie = movies[int(movie_)]
+    await query.answer('Checking for Movie in database...')
+    k = await manual_filters(bot, query.message, text=movie)
+    if k == False:
+        files, offset, total_results = await get_search_results(movie, offset=0, filter=True)
+
+        if files:
+            k = movie, files, offset, total_results
+            await auto_filter(bot, query, k)
+        else:
+            try:
+                k = await query.message.edit('This Movie Not Found In DataBase. \nTry Request Again with correct spelling')
+
+                await asyncio.sleep(10)
+                await k.delete()
+            except Exception:
+                return
+
+
+@Client.on_callback_query()
+async def cb_handler(client: Client, query: CallbackQuery):
+    if query.data == "close_data":
+        await query.message.delete()
+    elif query.data == "delallconfirm":
+        userid = query.from_user.id
+        chat_type = query.message.chat.type
+
+        if chat_type == "private":
+            grpid = await active_connection(str(userid))
+            if grpid is not None:
+                grp_id = grpid
+                try:
+                    chat = await client.get_chat(grpid)
+                    title = chat.title
+                except:
+                    await query.message.edit_text("Make sure I'm present in your group!!", quote=True)
+                    return await query.answer('Piracy Is Crime')
+            else:
+                await query.message.edit_text(
+                    "I'm not connected to any groups!\nCheck /connections or connect to any groups",
+                    quote=True
+                )
+                return await query.answer('Piracy Is Crime')
+
+        elif chat_type in ["group", "supergroup"]:
+            grp_id = query.message.chat.id
+            title = query.message.chat.title
+
+        else:
+            return await query.answer('Piracy Is Crime')
+
+        st = await client.get_chat_member(grp_id, userid)
+        if (st.status == "creator") or (str(userid) in ADMINS):
+            await del_all(query.message, grp_id, title)
+        else:
+            await query.answer("You need to be Group Owner or an Auth User to do that!", show_alert=True)
+    elif query.data == "delallcancel":
+        userid = query.from_user.id
+        chat_type = query.message.chat.type
+
+        if chat_type == "private":
+            await query.message.reply_to_message.delete()
+            await query.message.delete()
+
+        elif chat_type in ["group", "supergroup"]:
+            grp_id = query.message.chat.id
+            st = await client.get_chat_member(grp_id, userid)
+            if (st.status == "creator") or (str(userid) in ADMINS):
+                await query.message.delete()
+                try:
+                    await query.message.reply_to_message.delete()
+                except:
+                    pass
+            else:
+                await query.answer("That's not for you!!", show_alert=True)
+    elif "groupcb" in query.data:
+        await query.answer()
+
+        group_id = query.data.split(":")[1]
+
+        act = query.data.split(":")[2]
+        hr = await client.get_chat(int(group_id))
+        title = hr.title
+        user_id = query.from_user.id
+
+        if act == "":
+            stat = "CONNECT"
+            cb = "connectcb"
+        else:
+            stat = "DISCONNECT"
+            cb = "disconnect"
+
+        keyboard = InlineKeyboardMarkup([
+            [InlineKeyboardButton(f"{stat}", callback_data=f"{cb}:{group_id}"),
+             InlineKeyboardButton("DELETE", callback_data=f"deletecb:{group_id}")],
+            [InlineKeyboardButton("BACK", callback_data="backcb")]
+        ])
+
+        await query.message.edit_text(
+            f"Group Name : **{title}**\nGroup ID : `{group_id}`",
+            reply_markup=keyboard,
+            parse_mode="md"
+        )
+        return await query.answer('Piracy Is Crime')
+    elif "connectcb" in query.data:
+        await query.answer()
+
+        group_id = query.data.split(":")[1]
+
+        hr = await client.get_chat(int(group_id))
+
+        title = hr.title
+
+        user_id = query.from_user.id
+
+        mkact = await make_active(str(user_id), str(group_id))
+
+        if mkact:
+            await query.message.edit_text(
+                f"Connected to **{title}**",
+                parse_mode="md"
+            )
+        else:
+            await query.message.edit_text('Some error occurred!!', parse_mode="md")
+        return await query.answer('Piracy Is Crime')
+    elif "disconnect" in query.data:
+        await query.answer()
+
+        group_id = query.data.split(":")[1]
+
+        hr = await client.get_chat(int(group_id))
+
+        title = hr.title
+        user_id = query.from_user.id
+
+        mkinact = await make_inactive(str(user_id))
+
+        if mkinact:
+            await query.message.edit_text(
+                f"Disconnected from **{title}**",
+                parse_mode="md"
+            )
+        else:
+            await query.message.edit_text(
+                f"Some error occurred!!",
+                parse_mode="md"
+            )
+        return await query.answer('Piracy Is Crime')
+    elif "deletecb" in query.data:
+        await query.answer()
+
+        user_id = query.from_user.id
+        group_id = query.data.split(":")[1]
+
+        delcon = await delete_connection(str(user_id), str(group_id))
+
+        if delcon:
+            await query.message.edit_text(
+                "Successfully deleted connection"
+            )
+        else:
+            await query.message.edit_text(
+                f"Some error occurred!!",
+                parse_mode="md"
+            )
+        return await query.answer('Piracy Is Crime')
+    elif query.data == "backcb":
+        await query.answer()
+
+        userid = query.from_user.id
+
+        groupids = await all_connections(str(userid))
+        if groupids is None:
+            await query.message.edit_text(
+                "There are no active connections!! Connect to some groups first.",
+            )
+            return await query.answer('Piracy Is Crime')
+        buttons = []
+        for groupid in groupids:
+            try:
+                ttl = await client.get_chat(int(groupid))
+                title = ttl.title
+                active = await if_active(str(userid), str(groupid))
+                act = " - ACTIVE" if active else ""
+                buttons.append(
+                    [
+                        InlineKeyboardButton(
+                            text=f"{title}{act}", callback_data=f"groupcb:{groupid}:{act}"
+                        )
+                    ]
+                )
+            except:
+                pass
+        if buttons:
+            await query.message.edit_text(
+                "Your connected group details ;\n\n",
+                reply_markup=InlineKeyboardMarkup(buttons)
+            )
+    elif "alertmessage" in query.data:
+        grp_id = query.message.chat.id
+        i = query.data.split(":")[1]
+        keyword = query.data.split(":")[2]
+        reply_text, btn, alerts, fileid = await find_filter(grp_id, keyword)
+        if alerts is not None:
+            alerts = ast.literal_eval(alerts)
+            alert = alerts[int(i)]
+            alert = alert.replace("\\n", "\n").replace("\\t", "\t")
+            await query.answer(alert, show_alert=True)
+
+    if query.data.startswith("gpfile"):
+        ident, file_id = query.data.split("#")
+        return await query.answer(url=f"https://t.me/{temp.U_NAME}?start={file_id}")
+
+    if query.data.startswith("pmfile"):
+        ident, file_id = query.data.split("#")
+        idstring = await get_ids(file_id)
+        if idstring:
+            await remove_inst(file_id)
+            idstring = idstring['links']
+            fileids = idstring.split("L_I_N_K")
+            sendmsglist = []
+            for file_id in fileids:
+                files_ = await get_file_details(file_id)
+                if not files_:
+                    try:
+                        msg = await client.send_cached_media(
+                            chat_id=query.from_user.id,
+                            file_id=file_id
+                        )
+                        filetype = msg.media
+                        file = getattr(msg, filetype)
+                        title = file.file_name
+                        size = get_size(file.file_size)
+                        f_caption = f"<code>{title}</code>"
+                        if CUSTOM_FILE_CAPTION:
+                            try:
+                                f_caption = CUSTOM_FILE_CAPTION.format(
+                                    file_name='' if title is None else title, file_size='' if size is None else size, file_caption='')
+                            except:
+                                return
+                        await msg.edit_caption(f_caption)
+                        return
+                    except:
+                        pass
+                files = files_[0]
+                title = files.file_name
+                size = get_size(files.file_size)
+                f_caption = files.caption
+                if CUSTOM_FILE_CAPTION:
+                    try:
+                        f_caption = CUSTOM_FILE_CAPTION.format(
+                            file_name='' if title is None else title, file_size='' if size is None else size, file_caption='' if f_caption is None else f_caption)
+                    except Exception as e:
+                        logger.exception(e)
+                        f_caption = f_caption
+                if f_caption is None:
+                    f_caption = f"{files.file_name}"
+                try:
+                    k = await client.send_cached_media(
+                        chat_id=query.from_user.id,
+                        file_id=file_id,
+                        caption=f_caption,
+                    )
+                except FloodWait as e:
+                    await asyncio.sleep(e.x)
+                    logger.warning(f"Floodwait of {e.x} sec.")
+                    k = await client.send_cached_media(
+                        chat_id=query.from_user.id,
+                        file_id=file_id,
+                        caption=f_caption,
+                    )
+                await asyncio.sleep(1)
+                sendmsglist.append(k)
+                await add_sent_files(query.from_user.id, file_id)
+
+            await query.answer('𝕋𝕙𝕒𝕟𝕜 𝕐𝕠𝕦 𝔽𝕠𝕣 𝕌𝕤𝕚𝕟𝕘 𝕄𝕖')
+            kk = await client.send_message(
+                chat_id=query.from_user.id,
+                text="""
+                This Files Will delete in 10min Please Forward To Saved Messages folder before download. \n\nTurned On /notification for get new movie|tv Serieses
+                """)
+
+            await asyncio.sleep(600)
+            for k in sendmsglist:
+                await k.delete()
+            sendmsglist = []
+            return await kk.delete()
+
+        files_ = await get_file_details(file_id)
+        if not files_:
+            return await query.answer('No such file exist.')
+
+        files = files_[0]
+        title = files.file_name
+        size = get_size(files.file_size)
+        f_caption = files.caption
+        settings = await get_settings(query.message.chat.id)
+        if CUSTOM_FILE_CAPTION:
+            try:
+                f_caption = CUSTOM_FILE_CAPTION.format(file_name='' if title is None else title,
+                                                       file_size='' if size is None else size,
+                                                       file_caption='' if f_caption is None else f_caption)
+            except Exception as e:
+                logger.exception(e)
+            f_caption = f_caption
+        if f_caption is None:
+            f_caption = f"{get_name(files.file_name)}"
+
+        try:
+            if AUTH_CHANNEL and not await is_subscribed(client, query):
+                return await query.answer(url=gen_url(f'https://telegram.dog/SpaciousUniverseBot?start=REAL-{file_id}'))
+
+            k = await client.send_cached_media(
+                chat_id=query.from_user.id,
+                file_id=file_id,
+                caption=f_caption,
+                protect_content=ident == "filep",
+            )
+            sendmsglist = [k]
+            await add_sent_files(query.from_user.id, file_id)
+            files = await send_more_files(title)
+            if files:
+                for file in files[1:]:
+                    try:
+                        k = await client.send_cached_media(
+                            chat_id=query.from_user.id,
+                            file_id=file.file_id,
+                            caption=f"<code>{file.file_name}</code>",
+                        )
+                    except FloodWait as e:
+                        await asyncio.sleep(e.x)
+                        logger.warning(f"Floodwait of {e.x} sec.")
+                        k = await client.send_cached_media(
+                            chat_id=query.from_user.id,
+                            file_id=file.file_id,
+                            caption=f"<code>{file.file_name}</code>",
+                        )
+                    await asyncio.sleep(1)
+                    sendmsglist.append(k)
+                    await add_sent_files(query.from_user.id, file.file_id)
+
+                await query.answer("𝕋𝕙𝕒𝕟𝕜 𝕐𝕠𝕦 𝔽𝕠𝕣 𝕌𝕤𝕚𝕟𝕘 𝕄𝕖 \n\n⭐Rate Me: <a href='https://t.me/tlgrmcbot?start=spaciousuniversebot-review'>Here</a>")
+                kk = await client.send_message(
+                    chat_id=query.from_user.id,
+                    text="""
+                    This Files Will delete in 10min Please Forward To Saved Messages folder before download. \n\nTurned On /notification for get new movie|tv Serieses
+                    """)
+                await asyncio.sleep(600)
+                for k in sendmsglist:
+                    await k.delete()
+                sendmsglist = []
+                return await kk.delete()
+
+        except UserIsBlocked:
+            await query.answer('Unblock the bot!', show_alert=True)
+        except PeerIdInvalid:
+            await query.answer(url=gen_url(f'https://telegram.dog/SpaciousUniverseBot?start=REAL-{file_id}'))
+        except Exception as e:
+            await query.answer(url=gen_url(f'https://telegram.dog/SpaciousUniverseBot?start=REAL-{file_id}'))
+
+    elif query.data.startswith("checksub"):
+        if AUTH_CHANNEL and not await is_subscribed(client, query):
+            await query.answer("I Like Your Smartness, But Don't Be Oversmart 😒", show_alert=True)
+            return
+        ident, file_id = query.data.split("#")
+        files_ = await get_file_details(file_id)
+        if not files_:
+            return await query.answer('No such file exist.')
+        files = files_[0]
+        title = files.file_name
+        size = get_size(files.file_size)
+        f_caption = files.caption
+        if CUSTOM_FILE_CAPTION:
+            try:
+                f_caption = CUSTOM_FILE_CAPTION.format(file_name='' if title is None else title,
+                                                       file_size='' if size is None else size,
+                                                       file_caption='' if f_caption is None else f_caption)
+            except Exception as e:
+                logger.exception(e)
+                f_caption = f_caption
+        if f_caption is None:
+            f_caption = f"{title}"
+        await query.answer()
+        await client.send_cached_media(
+            chat_id=query.from_user.id,
+            file_id=file_id,
+            caption=f_caption,
+            protect_content=ident == 'checksubp',
+        )
+    elif query.data == "pages":
+        await query.answer()
+    elif query.data == "start":
+        buttons = [[
+            InlineKeyboardButton('➕ Add Me To Your Groups ➕',
+                                 url=f'http://t.me/{temp.U_NAME}?startgroup=true')
+        ], [
+            InlineKeyboardButton(
+                '🔍 Search', switch_inline_query_current_chat=''),
+            InlineKeyboardButton('🤖 Updates', url='https://t.me/TMWAD')
+        ], [
+            InlineKeyboardButton('ℹ️ Help', callback_data='help'),
+            InlineKeyboardButton('😊 About', callback_data='about')
+        ]]
+        reply_markup = InlineKeyboardMarkup(buttons)
+        await query.message.edit_text(
+            text=script.START_TXT.format(
+                query.from_user.mention, temp.U_NAME, temp.B_NAME),
+            reply_markup=reply_markup,
+
+        )
+        await query.answer('Piracy Is Crime')
+    elif query.data == "help":
+        buttons = [[
+            InlineKeyboardButton(
+                'Manual Filter', callback_data='manuelfilter'),
+            InlineKeyboardButton('Auto Filter', callback_data='autofilter')
+        ], [
+            InlineKeyboardButton('Connection', callback_data='coct'),
+            InlineKeyboardButton('Extra Mods', callback_data='extra')
+        ], [
+            InlineKeyboardButton('🏠 Home', callback_data='start'),
+            InlineKeyboardButton('🔮 Status', callback_data='stats')
+        ]]
+        reply_markup = InlineKeyboardMarkup(buttons)
+        await query.message.edit_text(
+            text=script.HELP_TXT.format(query.from_user.mention),
+            reply_markup=reply_markup,
+
+        )
+    elif query.data == "about":
+        buttons = [[
+            InlineKeyboardButton('🤖 Updates', url='https://t.me/TMWAD'),
+            InlineKeyboardButton('♥️ Source', callback_data='source')
+        ], [
+            InlineKeyboardButton('🏠 Home', callback_data='start'),
+            InlineKeyboardButton('🔐 Close', callback_data='close_data')
+        ]]
+        reply_markup = InlineKeyboardMarkup(buttons)
+        await query.message.edit_text(
+            text=script.ABOUT_TXT.format(temp.B_NAME),
+            reply_markup=reply_markup,
+
+        )
+    elif query.data == "source":
+        buttons = [[
+            InlineKeyboardButton('👩‍🦯 Back', callback_data='about')
+        ]]
+        reply_markup = InlineKeyboardMarkup(buttons)
+        await query.message.edit_text(
+            text=script.SOURCE_TXT,
+            reply_markup=reply_markup,
+
+        )
+    elif query.data == "manuelfilter":
+        buttons = [[
+            InlineKeyboardButton('👩‍🦯 Back', callback_data='help'),
+            InlineKeyboardButton('⏹️ Buttons', callback_data='button')
+        ]]
+        reply_markup = InlineKeyboardMarkup(buttons)
+        await query.message.edit_text(
+            text=script.MANUELFILTER_TXT,
+            reply_markup=reply_markup,
+
+        )
+    elif query.data == "button":
+        buttons = [[
+            InlineKeyboardButton('👩‍🦯 Back', callback_data='manuelfilter')
+        ]]
+        reply_markup = InlineKeyboardMarkup(buttons)
+        await query.message.edit_text(
+            text=script.BUTTON_TXT,
+            reply_markup=reply_markup,
+
+        )
+    elif query.data == "autofilter":
+        buttons = [[
+            InlineKeyboardButton('👩‍🦯 Back', callback_data='help')
+        ]]
+        reply_markup = InlineKeyboardMarkup(buttons)
+        await query.message.edit_text(
+            text=script.AUTOFILTER_TXT,
+            reply_markup=reply_markup,
+
+        )
+    elif query.data == "coct":
+        buttons = [[
+            InlineKeyboardButton('👩‍🦯 Back', callback_data='help')
+        ]]
+        reply_markup = InlineKeyboardMarkup(buttons)
+        await query.message.edit_text(
+            text=script.CONNECTION_TXT,
+            reply_markup=reply_markup,
+
+        )
+    elif query.data == "extra":
+        buttons = [[
+            InlineKeyboardButton('👩‍🦯 Back', callback_data='help'),
+            InlineKeyboardButton('👮‍♂️ Admin', callback_data='admin')
+        ]]
+        reply_markup = InlineKeyboardMarkup(buttons)
+        await query.message.edit_text(
+            text=script.EXTRAMOD_TXT,
+            reply_markup=reply_markup,
+
+        )
+    elif query.data == "admin":
+        buttons = [[
+            InlineKeyboardButton('👩‍🦯 Back', callback_data='extra')
+        ]]
+        reply_markup = InlineKeyboardMarkup(buttons)
+        await query.message.edit_text(
+            text=script.ADMIN_TXT,
+            reply_markup=reply_markup,
+
+        )
+    elif query.data == "stats":
+        buttons = [[
+            InlineKeyboardButton('👩‍🦯 Back', callback_data='help'),
+            InlineKeyboardButton('♻️', callback_data='rfrsh')
+        ]]
+        reply_markup = InlineKeyboardMarkup(buttons)
+        total = await Media.count_documents()
+        users = await db.total_users_count()
+        chats = await db.total_chat_count()
+        monsize = await db.get_db_size()
+        free = 536870912 - monsize
+        monsize = get_size(monsize)
+        free = get_size(free)
+        await query.message.edit_text(
+            text=script.STATUS_TXT.format(total, users, chats, monsize, free),
+            reply_markup=reply_markup,
+
+        )
+    elif query.data == "rfrsh":
+        await query.answer("Fetching MongoDb DataBase")
+        buttons = [[
+            InlineKeyboardButton('👩‍🦯 Back', callback_data='help'),
+            InlineKeyboardButton('♻️', callback_data='rfrsh')
+        ]]
+        reply_markup = InlineKeyboardMarkup(buttons)
+        total = await Media.count_documents()
+        users = await db.total_users_count()
+        chats = await db.total_chat_count()
+        monsize = await db.get_db_size()
+        free = 536870912 - monsize
+        monsize = get_size(monsize)
+        free = get_size(free)
+        await query.message.edit_text(
+            text=script.STATUS_TXT.format(total, users, chats, monsize, free),
+            reply_markup=reply_markup,
+
+        )
+    elif query.data.startswith("setgs"):
+        ident, set_type, status, grp_id = query.data.split("#")
+        grpid = await active_connection(str(query.from_user.id))
+
+        if str(grp_id) != str(grpid):
+            await query.message.edit("Your Active Connection Has Been Changed. Go To /settings.")
+            return await query.answer('Piracy Is Crime')
+
+        if status == "True":
+            await save_group_settings(grpid, set_type, False)
+        else:
+            await save_group_settings(grpid, set_type, True)
+
+        settings = await get_settings(grpid)
+
+        if settings is not None:
+            buttons = [
+                [
+                    InlineKeyboardButton('Filter Button',
+                                         callback_data=f'setgs#button#{settings["button"]}#{str(grp_id)}'),
+                    InlineKeyboardButton('Single' if settings["button"] else 'Double',
+                                         callback_data=f'setgs#button#{settings["button"]}#{str(grp_id)}')
+                ],
+                [
+                    InlineKeyboardButton(
+                        'Bot PM', callback_data=f'setgs#botpm#{settings["botpm"]}#{str(grp_id)}'),
+                    InlineKeyboardButton('✅ Yes' if settings["botpm"] else '❌ No',
+                                         callback_data=f'setgs#botpm#{settings["botpm"]}#{str(grp_id)}')
+                ],
+                [
+                    InlineKeyboardButton('File Secure',
+                                         callback_data=f'setgs#file_secure#{settings["file_secure"]}#{str(grp_id)}'),
+                    InlineKeyboardButton('✅ Yes' if settings["file_secure"] else '❌ No',
+                                         callback_data=f'setgs#file_secure#{settings["file_secure"]}#{str(grp_id)}')
+                ],
+                [
+                    InlineKeyboardButton(
+                        'IMDB', callback_data=f'setgs#imdb#{settings["imdb"]}#{str(grp_id)}'),
+                    InlineKeyboardButton('✅ Yes' if settings["imdb"] else '❌ No',
+                                         callback_data=f'setgs#imdb#{settings["imdb"]}#{str(grp_id)}')
+                ],
+                [
+                    InlineKeyboardButton('Spell Check',
+                                         callback_data=f'setgs#spell_check#{settings["spell_check"]}#{str(grp_id)}'),
+                    InlineKeyboardButton('✅ Yes' if settings["spell_check"] else '❌ No',
+                                         callback_data=f'setgs#spell_check#{settings["spell_check"]}#{str(grp_id)}')
+                ],
+                [
+                    InlineKeyboardButton(
+                        'Welcome', callback_data=f'setgs#welcome#{settings["welcome"]}#{str(grp_id)}'),
+                    InlineKeyboardButton('✅ Yes' if settings["welcome"] else '❌ No',
+                                         callback_data=f'setgs#welcome#{settings["welcome"]}#{str(grp_id)}')
+                ]
+            ]
+            reply_markup = InlineKeyboardMarkup(buttons)
+            await query.message.edit_reply_markup(reply_markup)
+    await query.answer('Piracy Is Crime')
+
+
+async def auto_filter(client, msg, spoll=False):
+
+    if not spoll:
+        message = msg
+        if message.text.startswith("/"):
+            return  # ignore commands
+        if re.findall("((^\/|^,|^!|^\.|^[\U0001F600-\U000E007F]).*)", message.text):
+            return
+        if 2 < len(message.text) < 100:
+            search = message.text
+            files, offset, total_results = await get_search_results(search.lower(), offset=0, filter=True)
+            if not files:
+                return await advantage_spell_chok(msg)
+
+        else:
+            return
+    else:
+        message = msg.message.reply_to_message  # msg will be callback query
+        search, files, offset, total_results = spoll
+
+    fileids = [file.file_id for file in files]
+    dbid = fileids[0]
+    fileids = "L_I_N_K".join(fileids)
+
+    btn = [
+        [
+            InlineKeyboardButton(
+                text=f"{get_size(file.file_size)} ║ {get_name(file.file_name)}", url=gen_url(f'https://telegram.dog/SpaciousUniverseBot?start=FEND-{file.file_id}')
+            ),
+        ]
+        for file in files
+    ]
+    btn.insert(0,
+               [InlineKeyboardButton(
+                   "◈ All Files ◈", url=gen_url(f'https://telegram.dog/SpaciousUniverseBot?start=FEND-{dbid}'))]
+               )
+
+    if offset != "":
+        key = f"{message.chat.id}-{message.id}"
+        BUTTONS[key] = search
+        req = message.from_user.id if message.from_user else 0
+        btn.append(
+            [InlineKeyboardButton(text=f"❏ 1/{round(int(total_results) / 10)}", callback_data="pages"),
+             InlineKeyboardButton(text="Next ►", callback_data=f"next_{req}_{key}_{offset}")]
+        )
+
+    else:
+        btn.append(
+            [InlineKeyboardButton(text="❏ 1/1", callback_data="pages")]
+        )
+
+    imdb = await get_poster(message.text)
+    if message.chat.type in [enums.ChatType.GROUP, enums.ChatType.SUPERGROUP]:
+        Template = await get_admingroup(int(message.chat.id))
+        if Template is not None:
+            IMDB_TEMPLATE = Template["template"]
+
+    if imdb:
+        cap = IMDB_TEMPLATE.format(
+            query=search,
+            title=imdb['title'],
+            votes=imdb['votes'],
+            aka=imdb["aka"],
+            seasons=imdb["seasons"],
+            box_office=imdb['box_office'],
+            localized_title=imdb['localized_title'],
+            kind=imdb['kind'],
+            imdb_id=imdb["imdb_id"],
+            cast=imdb["cast"],
+            runtime=imdb["runtime"],
+            countries=imdb["countries"],
+            certificates=imdb["certificates"],
+            languages=imdb["languages"],
+            director=imdb["director"],
+            writer=imdb["writer"],
+            producer=imdb["producer"],
+            composer=imdb["composer"],
+            cinematographer=imdb["cinematographer"],
+            music_team=imdb["music_team"],
+            distributors=imdb["distributors"],
+            release_date=imdb['release_date'],
+            year=imdb['year'],
+            genres=imdb['genres'],
+            poster=imdb['poster'],
+            plot=imdb['plot'],
+            rating=imdb['rating'],
+            url=imdb['url'],
+            **locals()
+        )
+    else:
+        cap = f"Here is what i found for your query {search}"
+    if imdb and imdb.get('poster'):
+        try:
+            await message.reply_photo(photo=imdb.get('poster'), caption=cap[:1024],
+                                      reply_markup=InlineKeyboardMarkup(btn))
+        except (MediaEmpty, PhotoInvalidDimensions, WebpageMediaEmpty):
+            pic = imdb.get('poster')
+            poster = pic.replace('.jpg', "._V1_UX360.jpg")
+            await message.reply_photo(photo=poster, caption=cap[:1024], reply_markup=InlineKeyboardMarkup(btn))
+        except Exception as e:
+            logger.exception(e)
+    else:
+        await message.reply_text(cap, reply_markup=InlineKeyboardMarkup(btn))
+    if spoll:
+        await msg.message.delete()
+
+
+async def pm_auto_filter(client, msg, spoll=False):
+    if not spoll:
+        message = msg
+        if message.text.startswith("/"):
+            return  # ignore commands
+        if re.findall("((^\/|^,|^!|^\.|^[\U0001F600-\U000E007F]).*)", message.text):
+            return
+        if 2 < len(message.text) < 100:
+            search = message.text
+            files, offset, total_results = await get_search_results(search.lower(), offset=0, filter=True)
+            if not files:
+                return await advantage_spell_chok(msg)
+
+        else:
+            return
+    else:
+        message = msg.message.reply_to_message  # msg will be callback query
+        search, files, offset, total_results = spoll
+
+    fileids = [file.file_id for file in files]
+    dbid = fileids[0]
+    fileids = "L_I_N_K".join(fileids)
+
+    btn = [
+        [
+            InlineKeyboardButton(
+                text=f"{get_size(file.file_size)} ║ {get_name(file.file_name)}", callback_data=f'pmfiles#{file.file_id}'
+            ),
+        ]
+        for file in files
+    ]
+
+    if offset != "":
+        key = f"{message.chat.id}-{message.id}"
+        BUTTONS[key] = search
+        req = message.from_user.id if message.from_user else 0
+        btn.append(
+            [InlineKeyboardButton(text=f"❏ 1/{round(int(total_results) / 10)}", callback_data="pages"),
+             InlineKeyboardButton(text="Next ►", callback_data=f"pmnext_{req}_{key}_{offset}")]
+        )
+        btn.insert(0,
+                   [InlineKeyboardButton(
+                       "◈ All Files ◈", callback_data=f'pmfiles#{dbid}')]
+                   )
+
+    else:
+        btn.append(
+            [InlineKeyboardButton(text="❏ 1/1", callback_data="pages")]
+        )
+        btn.insert(0,
+                   [InlineKeyboardButton(
+                       "◈ All Files ◈", callback_data=f'pmfiles#{dbid}')]
+                   )
+
+    imdb = await get_poster(message.text)
+    if imdb:
+        cap = IMDB_TEMPLATE.format(
+            query=search,
+            title=imdb['title'],
+            votes=imdb['votes'],
+            aka=imdb["aka"],
+            seasons=imdb["seasons"],
+            box_office=imdb['box_office'],
+            localized_title=imdb['localized_title'],
+            kind=imdb['kind'],
+            imdb_id=imdb["imdb_id"],
+            cast=imdb["cast"],
+            runtime=imdb["runtime"],
+            countries=imdb["countries"],
+            certificates=imdb["certificates"],
+            languages=imdb["languages"],
+            director=imdb["director"],
+            writer=imdb["writer"],
+            producer=imdb["producer"],
+            composer=imdb["composer"],
+            cinematographer=imdb["cinematographer"],
+            music_team=imdb["music_team"],
+            distributors=imdb["distributors"],
+            release_date=imdb['release_date'],
+            year=imdb['year'],
+            genres=imdb['genres'],
+            poster=imdb['poster'],
+            plot=imdb['plot'],
+            rating=imdb['rating'],
+            url=imdb['url'],
+            **locals()
+        )
+    else:
+        cap = f"Here is what i found for your query {search}"
+    if imdb and imdb.get('poster'):
+        try:
+            await message.reply_photo(photo=imdb.get('poster'), caption=cap[:1024],
+                                      reply_markup=InlineKeyboardMarkup(btn))
+        except (MediaEmpty, PhotoInvalidDimensions, WebpageMediaEmpty):
+            pic = imdb.get('poster')
+            poster = pic.replace('.jpg', "._V1_UX360.jpg")
+            await message.reply_photo(photo=poster, caption=cap[:1024], reply_markup=InlineKeyboardMarkup(btn))
+        except Exception as e:
+            logger.exception(e)
+    else:
+        await message.reply_text(cap, reply_markup=InlineKeyboardMarkup(btn))
+    if spoll:
+        await msg.message.delete()
+
+
+async def advantage_spell_chok(msg):
+    query = re.sub(
+        r"\b(pl(i|e)*?(s|z+|ease|se|ese|(e+)s(e)?)|((send|snd|giv(e)?|gib)(\sme)?)|movie(s)?|new|latest|br((o|u)h?)*|^h(e|a)?(l)*(o)*|mal(ayalam)?|t(h)?amil|file|that|find|und(o)*|kit(t(i|y)?)?o(w)?|thar(u)?(o)*w?|kittum(o)*|aya(k)*(um(o)*)?|full\smovie|any(one)|with\ssubtitle(s)?)",
+        "", msg.text, flags=re.IGNORECASE)  # plis contribute some common words
+    query = query.strip() + " movie"
+    g_s = await search_gagala(query)
+    g_s += await search_gagala(msg.text)
+    gs_parsed = []
+    if not g_s:
+        k = await msg.reply("I couldn't find any movie in that name.")
+        await asyncio.sleep(8)
+        await k.delete()
+        return
+    # look for imdb / wiki results
+    regex = re.compile(r".*(imdb|wikipedia).*", re.IGNORECASE)
+    gs = list(filter(regex.match, g_s))
+    gs_parsed = [re.sub(
+        r'\b(\-([a-zA-Z-\s])\-\simdb|(\-\s)?imdb|(\-\s)?wikipedia|\(|\)|\-|reviews|full|all|episode(s)?|film|movie|series)',
+        '', i, flags=re.IGNORECASE) for i in gs]
+    if not gs_parsed:
+        reg = re.compile(r"watch(\s[a-zA-Z0-9_\s\-\(\)]*)*\|.*",
+                         re.IGNORECASE)  # match something like Watch Niram | Amazon Prime
+        for mv in g_s:
+            match = reg.match(mv)
+            if match:
+                gs_parsed.append(match.group(1))
+    user = msg.from_user.id if msg.from_user else 0
+    movielist = []
+    # removing duplicates https://stackoverflow.com/a/7961425
+    gs_parsed = list(dict.fromkeys(gs_parsed))
+    if len(gs_parsed) > 3:
+        gs_parsed = gs_parsed[:3]
+    if gs_parsed:
+        for mov in gs_parsed:
+            # searching each keyword in imdb
+            try:
+                imdb_s = await get_poster(mov.strip(), bulk=True)
+            except:
+                continue
+            if imdb_s:
+                movielist += [movie.get('title') for movie in imdb_s]
+    movielist += [(re.sub(r'(\-|\(|\)|_)', '', i, flags=re.IGNORECASE)).strip()
+                  for i in gs_parsed]
+    movielist = list(dict.fromkeys(movielist))  # removing duplicates
+    if not movielist:
+        name = msg.text
+        name = name.replace(" ", "%20")
+        btns = [
+            [
+                InlineKeyboardButton(
+                    text="Check Spelling On Google 🧩", url=f"https://www.google.com/search?q={name}")
+            ],
+            [
+                InlineKeyboardButton(
+                    text="IMDB 💠", url=f"https://www.imdb.com/find?q={name}"),
+                InlineKeyboardButton(
+                    text="Wikipedia 💠", url=f"https://en.m.wikipedia.org/w/index.php?search={name}")
+            ]
+        ]
+        try:
+            k = await msg.reply(
+                text="I couldn't find anything related to that.Please Check your spelling",
+                reply_markup=InlineKeyboardMarkup(btns),
+                disable_web_page_preview=True,
+            )
+        except Exception as e:
+            logger.exception(e)
+            k = await msg.reply(
+                text="I couldn't find anything related to that.Please Check your spelling",
+                disable_web_page_preview=True,
+            )
+        await asyncio.sleep(30)
+        await k.delete()
+        return
+    SPELL_CHECK[msg.id] = movielist
+    btn = [[
+        InlineKeyboardButton(
+            text=movie.strip(),
+            callback_data=f"spolling#{user}#{k}",
+        )
+    ] for k, movie in enumerate(movielist)]
+    btn.append([InlineKeyboardButton(
+        text="Close", callback_data=f'spolling#{user}#close_spellcheck')])
+    await msg.reply("I couldn't find anything related to that\nDid you mean any one of these?",
+                    reply_markup=InlineKeyboardMarkup(btn))
+
+
+async def manual_filters(client, message, text=False):
+    group_id = message.chat.id
+    name = text or message.text
+    reply_id = message.reply_to_message.id if message.reply_to_message else message.id
+    keywords = await get_filters(group_id)
+    for keyword in reversed(sorted(keywords, key=len)):
+        pattern = r"( |^|[^\w])" + re.escape(keyword) + r"( |$|[^\w])"
+        if re.search(pattern, name, flags=re.IGNORECASE):
+            reply_text, btn, alert, fileid = await find_filter(group_id, keyword)
+
+            if reply_text:
+                reply_text = reply_text.replace(
+                    "\\n", "\n").replace("\\t", "\t")
+
+            elif btn is not None:
+                if reply_text is None:
+                    break
+                try:
+                    if fileid == "None":
+                        if btn == "[]":
+                            await client.send_message(group_id, reply_text, disable_web_page_preview=True)
+                        else:
+                            button = eval(btn)
+                            await client.send_message(
+                                group_id,
+                                reply_text,
+                                disable_web_page_preview=True,
+                                reply_markup=InlineKeyboardMarkup(button),
+                                reply_to_message_id=reply_id
+                            )
+                    elif btn == "[]":
+                        await client.send_cached_media(
+                            group_id,
+                            fileid,
+                            caption=reply_text or "",
+                            reply_to_message_id=reply_id
+                        )
+                    else:
+                        button = eval(btn)
+                        await message.reply_cached_media(
+                            fileid,
+                            caption=reply_text or "",
+                            reply_markup=InlineKeyboardMarkup(button),
+                            reply_to_message_id=reply_id
+                        )
+                except Exception as e:
+                    logger.exception(e)
+                break
+    else:
+        return False
+
+
+async def tvseries_filters(client, message, text=False):
+    name = getseries(message.text)
+    if len(name) < 3:
+        return False
+
+    elif name:
+        seriess = await find_tvseries_filter(name)
+
+        if len(seriess) > 4:
+            return False
+    else:
+        return False
+
+    if seriess:
+        btns = [[InlineKeyboardButton(
+            text=f"{name.capitalize()} TV Series", callback_data="pages")]]
+        for series in seriess:
+            language = series['language']
+            quality = series['quality']
+            links = series['seasonlink']
+            links = links.split(",")
+
+            btn = [[InlineKeyboardButton(text=f'Season {link + 1}', url=links[link]), InlineKeyboardButton(
+                text=f'Season {link + 2}', url=links[link + 1])] for link in range(len(links) - 1) if link % 2 != 1]
+            if len(links) % 2 == 1:
+                btn.append([InlineKeyboardButton(
+                    text=f'Season {len(links)}', url=links[-1])])
+
+            btn.insert(0,
+                       [InlineKeyboardButton(
+                           text=f"{language} - {quality}", callback_data="pages")]
+                       )
+            btns.extend(btn)
+        
+        imdb = await get_poster(message.text)
+        if message.chat.type in [enums.ChatType.GROUP, enums.ChatType.SUPERGROUP]:
+            Template = await get_admingroup(int(message.chat.id))
+            if Template is not None:
+                IMDB_TEMPLATE = Template["template"]
+
+        if imdb:
+            cap = IMDB_TEMPLATE.format(
+                title=imdb['title'],
+                votes=imdb['votes'],
+                aka=imdb["aka"],
+                seasons=imdb["seasons"],
+                box_office=imdb['box_office'],
+                localized_title=imdb['localized_title'],
+                kind=imdb['kind'],
+                imdb_id=imdb["imdb_id"],
+                cast=imdb["cast"],
+                runtime=imdb["runtime"],
+                countries=imdb["countries"],
+                certificates=imdb["certificates"],
+                languages=imdb["languages"],
+                director=imdb["director"],
+                writer=imdb["writer"],
+                producer=imdb["producer"],
+                composer=imdb["composer"],
+                cinematographer=imdb["cinematographer"],
+                music_team=imdb["music_team"],
+                distributors=imdb["distributors"],
+                release_date=imdb['release_date'],
+                year=imdb['year'],
+                genres=imdb['genres'],
+                poster=imdb['poster'],
+                plot=imdb['plot'],
+                rating=imdb['rating'],
+                url=imdb['url'],
+                **locals()
+            )
+            if imdb.get('poster'):
+                try:
+                    if not os.path.isdir(DOWNLOAD_LOCATION):
+                        os.makedirs(DOWNLOAD_LOCATION)
+                    pic = imdb.get('poster')
+                    urllib.request.urlretrieve(pic, "gfg.png")
+                    im = Image.open("gfg.png")
+                    width, height = im.size
+                    left = 0
+                    right = width
+                    top = height / 5
+                    bottom = height * 3 / 5
+                    pic = im.crop((left, top, right, bottom))
+                    img_location = DOWNLOAD_LOCATION + "tvseries" + ".png"
+                    pic.save(img_location)
+
+                except Exception as e:
+                    logger.exception(e)
+                    pic = imdb.get('poster')
+
+                try:
+                    await message.reply_photo(photo=img_location, caption=cap[:1024], reply_markup=InlineKeyboardMarkup(btns))
+                except (MediaEmpty, PhotoInvalidDimensions, WebpageMediaEmpty):
+                    poster = img_location.replace('.jpg', "._V1_UX360.jpg")
+                    await message.reply_photo(photo=poster, caption=cap[:1024], reply_markup=InlineKeyboardMarkup(btns))
+                except Exception as e:
+                    logger.exception(e)
+                    cap = "Here is what i found for your Request"
+                    await message.reply_text(cap, reply_markup=InlineKeyboardMarkup(btns))
+
+                os.remove(img_location)
+        else:
+            cap = "Here is what i found for your Request"
+            await message.reply_text(cap, reply_markup=InlineKeyboardMarkup(btns))
+
+    else:
+        return False