Add files via upload

assistant/__init__.py

@@ -0,0 +1,34 @@
+# Ultroid - UserBot
+# Copyright (C) 2021-2023 TeamUltroid
+#
+# This file is a part of < https://github.com/TeamUltroid/Ultroid/ >
+# PLease read the GNU Affero General Public License in
+# <https://www.github.com/TeamUltroid/Ultroid/blob/main/LICENSE/>.
+
+from telethon import Button, custom
+
+from plugins import ATRA_COL, InlinePlugin
+from xteam import *
+from xteam import _ult_cache
+from xteam._misc import owner_and_sudos
+from xteam._misc._assistant import asst_cmd, callback, in_pattern
+from xteam.fns.helper import *
+from xteam.fns.tools import get_stored_file
+from strings import get_languages, get_string
+
+OWNER_NAME = ultroid_bot.full_name
+OWNER_ID = ultroid_bot.uid
+
+AST_PLUGINS = {}
+
+
+async def setit(event, name, value):
+    try:
+        udB.set_key(name, value)
+    except BaseException as er:
+        LOGS.exception(er)
+        return await event.edit("`Something Went Wrong`")
+
+
+def get_back_button(name):
+    return [Button.inline("« Bᴀᴄᴋ", data=f"{name}")]

assistant/callbackstuffs.py

@@ -0,0 +1,1318 @@
+# Ultroid - UserBot
+# Copyright (C) 2021-2023 TeamUltroid
+#
+# This file is a part of < https://github.com/TeamUltroid/Ultroid/ >
+# PLease read the GNU Affero General Public License in
+# <https://www.github.com/TeamUltroid/Ultroid/blob/main/LICENSE/>.
+
+import ast
+import asyncio
+import re
+import sys
+import time
+from asyncio.exceptions import TimeoutError as AsyncTimeOut
+from os import execl, remove
+from random import choice
+
+from bs4 import BeautifulSoup as bs
+
+try:
+    from xteam.fns.gDrive import GDriveManager
+except ImportError:
+    GDriveManager = None
+from telegraph import upload_file as upl
+from telethon import Button, events
+from telethon.tl.types import MessageMediaWebPage
+from telethon.utils import get_peer_id
+
+from xteam.fns.helper import fast_download, progress
+from xteam.fns.tools import Carbon, async_searcher, get_paste, telegraph_client
+from xteam.startup.loader import Loader
+
+from . import *
+
+# --------------------------------------------------------------------#
+telegraph = telegraph_client()
+GDrive = GDriveManager() if GDriveManager else None
+# --------------------------------------------------------------------#
+
+
+def text_to_url(event):
+    """function to get media url (with|without) Webpage"""
+    if isinstance(event.media, MessageMediaWebPage):
+        webpage = event.media.webpage
+        if not isinstance(webpage, types.WebPageEmpty) and webpage.type in ["photo"]:
+            return webpage.display_url
+    return event.text
+
+
+# --------------------------------------------------------------------#
+
+_buttons = {
+    "otvars": {
+        "text": "Other Variables to set for @TeamUltroid:",
+        "buttons": [
+            [
+                Button.inline("Tᴀɢ Lᴏɢɢᴇʀ", data="taglog"),
+                Button.inline("SᴜᴘᴇʀFʙᴀɴ", data="cbs_sfban"),
+            ],
+            [
+                Button.inline("Sᴜᴅᴏ Mᴏᴅᴇ", data="sudo"),
+                Button.inline("Hᴀɴᴅʟᴇʀ", data="hhndlr"),
+            ],
+            [
+                Button.inline("Exᴛʀᴀ Pʟᴜɢɪɴs", data="plg"),
+                Button.inline("Aᴅᴅᴏɴs", data="eaddon"),
+            ],
+            [
+                Button.inline("Eᴍᴏᴊɪ ɪɴ Hᴇʟᴘ", data="emoj"),
+                Button.inline("Sᴇᴛ ɢDʀɪᴠᴇ", data="gdrive"),
+            ],
+            [
+                Button.inline("Iɴʟɪɴᴇ Pɪᴄ", data="inli_pic"),
+                Button.inline("Sᴜᴅᴏ HNDLR", data="shndlr"),
+            ],
+            [Button.inline("Dᴜᴀʟ Mᴏᴅᴇ", "cbs_oofdm")],
+            [Button.inline("« Bᴀᴄᴋ", data="setter")],
+        ],
+    },
+    "sfban": {
+        "text": "SuperFban Settings:",
+        "buttons": [
+            [Button.inline("FBᴀɴ Gʀᴏᴜᴘ", data="sfgrp")],
+            [Button.inline("Exᴄʟᴜᴅᴇ Fᴇᴅs", data="abs_sfexf")],
+            [Button.inline("« Bᴀᴄᴋ", data="cbs_otvars")],
+        ],
+    },
+    "apauto": {
+        "text": "This'll auto approve on outgoing messages",
+        "buttons": [
+            [Button.inline("Aᴜᴛᴏ Aᴘᴘʀᴏᴠᴇ ON", data="apon")],
+            [Button.inline("Aᴜᴛᴏ Aᴘᴘʀᴏᴠᴇ OFF", data="apof")],
+            [Button.inline("« Bᴀᴄᴋ", data="cbs_pmcstm")],
+        ],
+    },
+    "alvcstm": {
+        "text": f"Customise your {HNDLR}alive. Choose from the below options -",
+        "buttons": [
+            [Button.inline("Aʟɪᴠᴇ Tᴇxᴛ", data="abs_alvtx")],
+            [Button.inline("Aʟɪᴠᴇ ᴍᴇᴅɪᴀ", data="alvmed")],
+            [Button.inline("Dᴇʟᴇᴛᴇ Aʟɪᴠᴇ Mᴇᴅɪᴀ", data="delmed")],
+            [Button.inline("« Bᴀᴄᴋ", data="setter")],
+        ],
+    },
+    "pmcstm": {
+        "text": "Customise your PMPERMIT Settings -",
+        "buttons": [
+            [
+                Button.inline("Pᴍ Tᴇxᴛ", data="pmtxt"),
+                Button.inline("Pᴍ Mᴇᴅɪᴀ", data="pmmed"),
+            ],
+            [
+                Button.inline("Aᴜᴛᴏ Aᴘᴘʀᴏᴠᴇ", data="cbs_apauto"),
+                Button.inline("PMLOGGER", data="pml"),
+            ],
+            [
+                Button.inline("Sᴇᴛ Wᴀʀɴs", data="swarn"),
+                Button.inline("Dᴇʟᴇᴛᴇ Pᴍ Mᴇᴅɪᴀ", data="delpmmed"),
+            ],
+            [Button.inline("PMPermit Type", data="cbs_pmtype")],
+            [Button.inline("« Bᴀᴄᴋ", data="cbs_ppmset")],
+        ],
+    },
+    "pmtype": {
+        "text": "Select the type of PMPermit needed.",
+        "buttons": [
+            [Button.inline("Inline", data="inpm_in")],
+            [Button.inline("Normal", data="inpm_no")],
+            [Button.inline("« Bᴀᴄᴋ", data="cbs_pmcstm")],
+        ],
+    },
+    "ppmset": {
+        "text": "PMPermit Settings:",
+        "buttons": [
+            [Button.inline("Tᴜʀɴ PMPᴇʀᴍɪᴛ Oɴ", data="pmon")],
+            [Button.inline("Tᴜʀɴ PMPᴇʀᴍɪᴛ Oғғ", data="pmoff")],
+            [Button.inline("Cᴜsᴛᴏᴍɪᴢᴇ PMPᴇʀᴍɪᴛ", data="cbs_pmcstm")],
+            [Button.inline("« Bᴀᴄᴋ", data="setter")],
+        ],
+    },
+    "chatbot": {
+        "text": "From This Feature U can chat with ppls Via ur Assistant Bot.\n[More info](https://t.me/UltroidUpdates/2)",
+        "buttons": [
+            [
+                Button.inline("Cʜᴀᴛ Bᴏᴛ  Oɴ", data="onchbot"),
+                Button.inline("Cʜᴀᴛ Bᴏᴛ  Oғғ", data="ofchbot"),
+            ],
+            [
+                Button.inline("Bᴏᴛ Wᴇʟᴄᴏᴍᴇ", data="bwel"),
+                Button.inline("Bᴏᴛ Wᴇʟᴄᴏᴍᴇ Mᴇᴅɪᴀ", data="botmew"),
+            ],
+            [Button.inline("Bᴏᴛ Iɴғᴏ Tᴇxᴛ", data="botinfe")],
+            [Button.inline("Fᴏʀᴄᴇ Sᴜʙsᴄʀɪʙᴇ", data="pmfs")],
+            [Button.inline("« Bᴀᴄᴋ", data="setter")],
+        ],
+    },
+    "vcb": {
+        "text": "From This Feature U can play songs in group voice chat\n\n[moreinfo](https://t.me/UltroidUpdates/4)",
+        "buttons": [
+            [Button.inline("VC Sᴇssɪᴏɴ", data="abs_vcs")],
+            [Button.inline("« Bᴀᴄᴋ", data="setter")],
+        ],
+    },
+    "oofdm": {
+        "text": "About [Dual Mode](https://t.me/UltroidUpdates/18)",
+        "buttons": [
+            [
+                Button.inline("Dᴜᴀʟ Mᴏᴅᴇ Oɴ", "dmof"),
+                Button.inline("Dᴜᴀʟ Mᴏᴅᴇ Oғғ", "dmof"),
+            ],
+            [Button.inline("Dᴜᴀʟ Mᴏᴅᴇ Hɴᴅʟʀ", "dmhn")],
+            [Button.inline("« Back", data="cbs_otvars")],
+        ],
+    },
+    "apiset": {
+        "text": get_string("ast_1"),
+        "buttons": [
+            [Button.inline("Remove.bg API", data="abs_rmbg")],
+            [Button.inline("DEEP API", data="abs_dapi")],
+            [Button.inline("OCR API", data="abs_oapi")],
+            [Button.inline("« Back", data="setter")],
+        ],
+    },
+}
+
+_convo = {
+    "rmbg": {
+        "var": "RMBG_API",
+        "name": "Remove.bg API Key",
+        "text": get_string("ast_2"),
+        "back": "cbs_apiset",
+    },
+    "dapi": {
+        "var": "DEEP_AI",
+        "name": "Deep AI Api Key",
+        "text": "Get Your Deep Api from deepai.org and send here.",
+        "back": "cbs_apiset",
+    },
+    "oapi": {
+        "var": "OCR_API",
+        "name": "Ocr Api Key",
+        "text": "Get Your OCR api from ocr.space and send that Here.",
+        "back": "cbs_apiset",
+    },
+    "pmlgg": {
+        "var": "PMLOGGROUP",
+        "name": "Pm Log Group",
+        "text": "Send chat id of chat which you want to save as Pm log Group.",
+        "back": "pml",
+    },
+    "vcs": {
+        "var": "VC_SESSION",
+        "name": "Vc Session",
+        "text": "**Vc session**\nEnter the New session u generated for vc bot.\n\nUse /cancel to terminate the operation.",
+        "back": "cbs_vcb",
+    },
+    "settag": {
+        "var": "TAG_LOG",
+        "name": "Tag Log Group",
+        "text": f"Make a group, add your assistant and make it admin.\nGet the `{HNDLR}id` of that group and send it here for tag logs.\n\nUse /cancel to cancel.",
+        "back": "taglog",
+    },
+    "alvtx": {
+        "var": "ALIVE_TEXT",
+        "name": "Alive Text",
+        "text": "**Alive Text**\nEnter the new alive text.\n\nUse /cancel to terminate the operation.",
+        "back": "cbs_alvcstm",
+    },
+    "sfexf": {
+        "var": "EXCLUDE_FED",
+        "name": "Excluded Fed",
+        "text": "Send the Fed IDs you want to exclude in the ban. Split by a space.\neg`id1 id2 id3`\nSet is as `None` if you dont want any.\nUse /cancel to go back.",
+        "back": "cbs_sfban",
+    },
+}
+
+
+TOKEN_FILE = "resources/auths/auth_token.txt"
+
+
+@callback(
+    re.compile(
+        "sndplug_(.*)",
+    ),
+    owner=True,
+)
+async def send(eve):
+    key, name = (eve.data_match.group(1)).decode("UTF-8").split("_")
+    thumb = "resources/extras/inline.jpg"
+    await eve.answer("■ Sending ■")
+    data = f"uh_{key}_"
+    index = None
+    if "|" in name:
+        name, index = name.split("|")
+    key = "plugins" if key == "Official" else key.lower()
+    plugin = f"{key}/{name}.py"
+    _ = f"pasta-{plugin}"
+    if index is not None:
+        data += f"|{index}"
+        _ += f"|{index}"
+    buttons = [
+        [
+            Button.inline(
+                "« Pᴀsᴛᴇ »",
+                data=_,
+            )
+        ],
+        [
+            Button.inline("« Bᴀᴄᴋ", data=data),
+        ],
+    ]
+    try:
+        await eve.edit(file=plugin, thumb=thumb, buttons=buttons)
+    except Exception as er:
+        await eve.answer(str(er), alert=True)
+
+
+heroku_api, app_name = Var.HEROKU_API, Var.HEROKU_APP_NAME
+
+
+@callback("updatenow", owner=True)
+async def update(eve):
+    repo = Repo()
+    ac_br = repo.active_branch
+    ups_rem = repo.remote("upstream")
+    if heroku_api:
+        import heroku3
+
+        try:
+            heroku = heroku3.from_key(heroku_api)
+            heroku_app = None
+            heroku_applications = heroku.apps()
+        except BaseException as er:
+            LOGS.exception(er)
+            return await eve.edit("`Wrong HEROKU_API.`")
+        for app in heroku_applications:
+            if app.name == app_name:
+                heroku_app = app
+        if not heroku_app:
+            await eve.edit("`Wrong HEROKU_APP_NAME.`")
+            repo.__del__()
+            return
+        await eve.edit(get_string("clst_1"))
+        ups_rem.fetch(ac_br)
+        repo.git.reset("--hard", "FETCH_HEAD")
+        heroku_git_url = heroku_app.git_url.replace(
+            "https://", f"https://api:{heroku_api}@"
+        )
+
+        if "heroku" in repo.remotes:
+            remote = repo.remote("heroku")
+            remote.set_url(heroku_git_url)
+        else:
+            remote = repo.create_remote("heroku", heroku_git_url)
+        try:
+            remote.push(refspec=f"HEAD:refs/heads/{ac_br}", force=True)
+        except GitCommandError as error:
+            await eve.edit(f"`Here is the error log:\n{error}`")
+            repo.__del__()
+            return
+        await eve.edit("`Successfully Updated!\nRestarting, please wait...`")
+    else:
+        await eve.edit(get_string("clst_1"))
+        call_back()
+        await bash("git pull && pip3 install -r requirements.txt")
+        execl(sys.executable, sys.executable, "-m", "xteam")
+
+
+@callback(re.compile("changes(.*)"), owner=True)
+async def changes(okk):
+    match = okk.data_match.group(1).decode("utf-8")
+    await okk.answer(get_string("clst_3"))
+    repo = Repo.init()
+    button = [[Button.inline("Update Now", data="updatenow")]]
+    changelog, tl_chnglog = await gen_chlog(
+        repo, f"HEAD..upstream/{repo.active_branch}"
+    )
+    cli = "\n\nClick the below button to update!"
+    if not match:
+        try:
+            if len(tl_chnglog) > 700:
+                tl_chnglog = f"{tl_chnglog[:700]}..."
+                button.append([Button.inline("View Complete", "changesall")])
+            await okk.edit("• Writing Changelogs 📝 •")
+            img = await Carbon(
+                file_name="changelog",
+                code=tl_chnglog,
+                backgroundColor=choice(ATRA_COL),
+                language="md",
+            )
+            return await okk.edit(
+                f"**• Ultroid Userbot •**{cli}", file=img, buttons=button
+            )
+        except Exception as er:
+            LOGS.exception(er)
+    changelog_str = changelog + cli
+    if len(changelog_str) > 1024:
+        await okk.edit(get_string("upd_4"))
+        await asyncio.sleep(2)
+        with open("ultroid_updates.txt", "w+") as file:
+            file.write(tl_chnglog)
+        await okk.edit(
+            get_string("upd_5"),
+            file="ultroid_updates.txt",
+            buttons=button,
+        )
+        remove("ultroid_updates.txt")
+        return
+    await okk.edit(
+        changelog_str,
+        buttons=button,
+        parse_mode="html",
+    )
+
+
+@callback(
+    re.compile(
+        "pasta-(.*)",
+    ),
+    owner=True,
+)
+async def _(e):
+    ok = (e.data_match.group(1)).decode("UTF-8")
+    index = None
+    if "|" in ok:
+        ok, index = ok.split("|")
+    with open(ok, "r") as hmm:
+        _, key = await get_paste(hmm.read())
+    link = f"https://spaceb.in/{key}"
+    raw = f"https://spaceb.in/api/v1/documents/{key}/raw"
+    if not _:
+        return await e.answer(key[:30], alert=True)
+    if ok.startswith("addons"):
+        key = "Addons"
+    elif ok.startswith("vcbot"):
+        key = "VCBot"
+    else:
+        key = "Official"
+    data = f"uh_{key}_"
+    if index is not None:
+        data += f"|{index}"
+    await e.edit(
+        "",
+        buttons=[
+            [Button.url("Lɪɴᴋ", link), Button.url("Rᴀᴡ", raw)],
+            [Button.inline("« Bᴀᴄᴋ", data=data)],
+        ],
+    )
+
+
+@callback(re.compile("cbs_(.*)"), owner=True)
+async def _edit_to(event):
+    match = event.data_match.group(1).decode("utf-8")
+    data = _buttons.get(match)
+    if not data:
+        return
+    await event.edit(data["text"], buttons=data["buttons"], link_preview=False)
+
+
+@callback(re.compile("abs_(.*)"), owner=True)
+async def convo_handler(event: events.CallbackQuery):
+    match = event.data_match.group(1).decode("utf-8")
+    if not _convo.get(match):
+        return
+    await event.delete()
+    get_ = _convo[match]
+    back = get_["back"]
+    async with event.client.conversation(event.sender_id) as conv:
+        await conv.send_message(get_["text"])
+        response = await conv.get_response()
+        themssg = response.message
+        try:
+            themssg = ast.literal_eval(themssg)
+        except Exception:
+            pass
+        if themssg == "/cancel":
+            return await conv.send_message(
+                "Cancelled!!",
+                buttons=get_back_button(back),
+            )
+        await setit(event, get_["var"], themssg)
+        await conv.send_message(
+            f"{get_['name']} changed to `{themssg}`",
+            buttons=get_back_button(back),
+        )
+
+
+@callback("authorise", owner=True)
+async def _(e):
+    if not e.is_private:
+        return
+    url = GDrive._create_token_file()
+    await e.edit("Go to the below link and send the code!")
+    async with asst.conversation(e.sender_id) as conv:
+        await conv.send_message(url)
+        code = await conv.get_response()
+        if GDrive._create_token_file(code=code.text):
+            await conv.send_message(
+                "`Success!\nYou are all set to use Google Drive with Ultroid Userbot.`",
+                buttons=Button.inline("Main Menu", data="setter"),
+            )
+        else:
+            await conv.send_message("Wrong code! Click authorise again.")
+
+
+@callback("folderid", owner=True, func=lambda x: x.is_private)
+async def _(e):
+    if not e.is_private:
+        return
+    msg = (
+        "Send your FOLDER ID\n\n"
+        + "For FOLDER ID:\n"
+        + "1. Open Google Drive App.\n"
+        + "2. Create Folder.\n"
+        + "3. Make that folder public.\n"
+        + "4. Send link of that folder."
+    )
+    await e.delete()
+    async with asst.conversation(e.sender_id, timeout=150) as conv:
+        await conv.send_message(msg)
+        repl = await conv.get_response()
+        id = repl.text
+        if id.startswith("https"):
+            id = id.split("?id=")[-1]
+        udB.set_key("GDRIVE_FOLDER_ID", id)
+        await repl.reply(
+            "`Success.`",
+            buttons=get_back_button("gdrive"),
+        )
+
+
+@callback("gdrive", owner=True)
+async def _(e):
+    if not e.is_private:
+        return
+    await e.edit(
+        "Click Authorise and send the code.\n\nYou can use your own CLIENT ID and SECRET by [this](https://t.me/UltroidUpdates/37)",
+        buttons=[
+            [
+                Button.inline("Folder ID", data="folderid"),
+                Button.inline("Authorise", data="authorise"),
+            ],
+            [Button.inline("« Back", data="cbs_otvars")],
+        ],
+        link_preview=False,
+    )
+
+
+@callback("dmof", owner=True)
+async def rhwhe(e):
+    if udB.get_key("DUAL_MODE"):
+        udB.del_key("DUAL_MODE")
+        key = "Off"
+    else:
+        udB.set_key("DUAL_MODE", "True")
+        key = "On"
+    Msg = f"Dual Mode : {key}"
+    await e.edit(Msg, buttons=get_back_button("cbs_otvars"))
+
+
+@callback("dmhn", owner=True)
+async def hndlrr(event):
+    await event.delete()
+    pru = event.sender_id
+    var = "DUAL_HNDLR"
+    name = "Dual Handler"
+    CH = udB.get_key(var) or "/"
+    async with event.client.conversation(pru) as conv:
+        await conv.send_message(
+            f"Send The Symbol Which u want as Handler/Trigger to use your Assistant bot\nUr Current Handler is [ `{CH}` ]\n\n use /cancel to cancel.",
+        )
+        response = conv.wait_event(events.NewMessage(chats=pru))
+        response = await response
+        themssg = response.message.message
+        if themssg == "/cancel":
+            await conv.send_message(
+                "Cancelled!!",
+                buttons=get_back_button("cbs_otvars"),
+            )
+        elif len(themssg) > 1:
+            await conv.send_message(
+                "Incorrect Handler",
+                buttons=get_back_button("cbs_otvars"),
+            )
+        else:
+            await setit(event, var, themssg)
+            await conv.send_message(
+                f"{name} changed to {themssg}",
+                buttons=get_back_button("cbs_otvars"),
+            )
+
+
+@callback("emoj", owner=True)
+async def emoji(event):
+    await event.delete()
+    pru = event.sender_id
+    var = "EMOJI_IN_HELP"
+    name = f"Emoji in `{HNDLR}help` menu"
+    async with event.client.conversation(pru) as conv:
+        await conv.send_message("Send emoji u want to set 🙃.\n\nUse /cancel to cancel.")
+        response = conv.wait_event(events.NewMessage(chats=pru))
+        response = await response
+        themssg = response.message.message
+        if themssg == "/cancel":
+            await conv.send_message(
+                "Cancelled!!",
+                buttons=get_back_button("cbs_otvars"),
+            )
+        elif themssg.startswith(("/", HNDLR)):
+            await conv.send_message(
+                "Incorrect Emoji",
+                buttons=get_back_button("cbs_otvars"),
+            )
+        else:
+            await setit(event, var, themssg)
+            await conv.send_message(
+                f"{name} changed to {themssg}\n",
+                buttons=get_back_button("cbs_otvars"),
+            )
+
+
+@callback("plg", owner=True)
+async def pluginch(event):
+    await event.delete()
+    pru = event.sender_id
+    var = "PLUGIN_CHANNEL"
+    name = "Plugin Channel"
+    async with event.client.conversation(pru) as conv:
+        await conv.send_message(
+            "Send id or username of a channel from where u want to install all plugins\n\nOur Channel~ @ultroidplugins\n\nUse /cancel to cancel.",
+        )
+        response = conv.wait_event(events.NewMessage(chats=pru))
+        response = await response
+        themssg = response.message.message
+        if themssg == "/cancel":
+            await conv.send_message(
+                "Cancelled!!",
+                buttons=get_back_button("cbs_otvars"),
+            )
+        elif themssg.startswith(("/", HNDLR)):
+            await conv.send_message(
+                "Incorrect channel",
+                buttons=get_back_button("cbs_otvars"),
+            )
+        else:
+            await setit(event, var, themssg)
+            await conv.send_message(
+                f"{name} changed to {themssg}\n After Setting All Things Do Restart",
+                buttons=get_back_button("cbs_otvars"),
+            )
+
+
+@callback("hhndlr", owner=True)
+async def hndlrr(event):
+    await event.delete()
+    pru = event.sender_id
+    var = "HNDLR"
+    name = "Handler/ Trigger"
+    async with event.client.conversation(pru) as conv:
+        await conv.send_message(
+            f"Send The Symbol Which u want as Handler/Trigger to use bot\nUr Current Handler is [ `{HNDLR}` ]\n\n use /cancel to cancel.",
+        )
+        response = conv.wait_event(events.NewMessage(chats=pru))
+        response = await response
+        themssg = response.message.message
+        if themssg == "/cancel":
+            await conv.send_message(
+                "Cancelled!!",
+                buttons=get_back_button("cbs_otvars"),
+            )
+        elif len(themssg) > 1:
+            await conv.send_message(
+                "Incorrect Handler",
+                buttons=get_back_button("cbs_otvars"),
+            )
+        elif themssg.startswith(("/", "#", "@")):
+            await conv.send_message(
+                "This cannot be used as handler",
+                buttons=get_back_button("cbs_otvars"),
+            )
+        else:
+            await setit(event, var, themssg)
+            await conv.send_message(
+                f"{name} changed to {themssg}",
+                buttons=get_back_button("cbs_otvars"),
+            )
+
+
+@callback("shndlr", owner=True)
+async def hndlrr(event):
+    await event.delete()
+    pru = event.sender_id
+    var = "SUDO_HNDLR"
+    name = "Sudo Handler"
+    async with event.client.conversation(pru) as conv:
+        await conv.send_message(
+            "Send The Symbol Which u want as Sudo Handler/Trigger to use bot\n\n use /cancel to cancel."
+        )
+
+        response = conv.wait_event(events.NewMessage(chats=pru))
+        response = await response
+        themssg = response.message.message
+        if themssg == "/cancel":
+            await conv.send_message(
+                "Cancelled!!",
+                buttons=get_back_button("cbs_otvars"),
+            )
+        elif len(themssg) > 1:
+            await conv.send_message(
+                "Incorrect Handler",
+                buttons=get_back_button("cbs_otvars"),
+            )
+        elif themssg.startswith(("/", "#", "@")):
+            await conv.send_message(
+                "This cannot be used as handler",
+                buttons=get_back_button("cbs_otvars"),
+            )
+        else:
+            await setit(event, var, themssg)
+            await conv.send_message(
+                f"{name} changed to {themssg}",
+                buttons=get_back_button("cbs_otvars"),
+            )
+
+
+@callback("taglog", owner=True)
+async def tagloggrr(e):
+    BUTTON = [
+        [Button.inline("SET TAG LOG", data="abs_settag")],
+        [Button.inline("DELETE TAG LOG", data="deltag")],
+        get_back_button("cbs_otvars"),
+    ]
+    await e.edit(
+        "Choose Options",
+        buttons=BUTTON,
+    )
+
+
+@callback("deltag", owner=True)
+async def _(e):
+    udB.del_key("TAG_LOG")
+    await e.answer("Done!!! Tag Logger has been turned Off")
+
+
+@callback("eaddon", owner=True)
+async def pmset(event):
+    BT = (
+        [Button.inline("Aᴅᴅᴏɴs  Oғғ", data="edof")]
+        if udB.get_key("ADDONS")
+        else [Button.inline("Aᴅᴅᴏɴs  Oɴ", data="edon")]
+    )
+
+    await event.edit(
+        "ADDONS~ Extra Plugins:",
+        buttons=[
+            BT,
+            [Button.inline("« Bᴀᴄᴋ", data="cbs_otvars")],
+        ],
+    )
+
+
+@callback("edon", owner=True)
+async def eddon(event):
+    var = "ADDONS"
+    await setit(event, var, "True")
+    await event.edit(
+        "Done! ADDONS has been turned on!!\n\n After Setting All Things Do Restart",
+        buttons=get_back_button("eaddon"),
+    )
+
+
+@callback("edof", owner=True)
+async def eddof(event):
+    udB.set_key("ADDONS", "False")
+    await event.edit(
+        "Done! ADDONS has been turned off!! After Setting All Things Do Restart",
+        buttons=get_back_button("eaddon"),
+    )
+
+
+@callback("sudo", owner=True)
+async def pmset(event):
+    BT = (
+        [Button.inline("Sᴜᴅᴏ Mᴏᴅᴇ  Oғғ", data="ofsudo")]
+        if udB.get_key("SUDO")
+        else [Button.inline("Sᴜᴅᴏ Mᴏᴅᴇ  Oɴ", data="onsudo")]
+    )
+
+    await event.edit(
+        f"SUDO MODE ~ Some peoples can use ur Bot which u selected. To know More use `{HNDLR}help sudo`",
+        buttons=[
+            BT,
+            [Button.inline("« Bᴀᴄᴋ", data="cbs_otvars")],
+        ],
+    )
+
+
+@callback("onsudo", owner=True)
+async def eddon(event):
+    var = "SUDO"
+    await setit(event, var, "True")
+    await event.edit(
+        "Done! SUDO MODE has been turned on!!\n\n After Setting All Things Do Restart",
+        buttons=get_back_button("sudo"),
+    )
+
+
+@callback("ofsudo", owner=True)
+async def eddof(event):
+    var = "SUDO"
+    await setit(event, var, "False")
+    await event.edit(
+        "Done! SUDO MODE has been turned off!! After Setting All Things Do Restart",
+        buttons=get_back_button("sudo"),
+    )
+
+
+@callback("sfgrp", owner=True)
+async def sfgrp(event):
+    await event.delete()
+    name = "FBan Group ID"
+    var = "FBAN_GROUP_ID"
+    pru = event.sender_id
+    async with asst.conversation(pru) as conv:
+        await conv.send_message(
+            f"Make a group, add @MissRose_Bot, send `{HNDLR}id`, copy that and send it here.\nUse /cancel to go back.",
+        )
+        response = conv.wait_event(events.NewMessage(chats=pru))
+        response = await response
+        themssg = response.message.message
+        if themssg == "/cancel":
+            return await conv.send_message(
+                "Cancelled!!",
+                buttons=get_back_button("cbs_sfban"),
+            )
+        await setit(event, var, themssg)
+        await conv.send_message(
+            f"{name} changed to {themssg}",
+            buttons=get_back_button("cbs_sfban"),
+        )
+
+
+@callback("alvmed", owner=True)
+async def media(event):
+    await event.delete()
+    pru = event.sender_id
+    var = "ALIVE_PIC"
+    name = "Alive Media"
+    async with event.client.conversation(pru) as conv:
+        await conv.send_message(
+            "**Alive Media**\nSend me a pic/gif/media to set as alive media.\n\nUse /cancel to terminate the operation.",
+        )
+        response = await conv.get_response()
+        try:
+            themssg = response.message
+            if themssg == "/cancel":
+                return await conv.send_message(
+                    "Operation cancelled!!",
+                    buttons=get_back_button("cbs_alvcstm"),
+                )
+        except BaseException as er:
+            LOGS.exception(er)
+        if (
+            not (response.text).startswith("/")
+            and response.text != ""
+            and (not response.media or isinstance(response.media, MessageMediaWebPage))
+        ):
+            url = text_to_url(response)
+        elif response.sticker:
+            url = response.file.id
+        else:
+            media = await event.client.download_media(response, "alvpc")
+            try:
+                x = upl(media)
+                url = f"https://graph.org/{x[0]}"
+                remove(media)
+            except BaseException as er:
+                LOGS.exception(er)
+                return await conv.send_message(
+                    "Terminated.",
+                    buttons=get_back_button("cbs_alvcstm"),
+                )
+        await setit(event, var, url)
+        await conv.send_message(
+            f"{name} has been set.",
+            buttons=get_back_button("cbs_alvcstm"),
+        )
+
+
+@callback("delmed", owner=True)
+async def dell(event):
+    try:
+        udB.del_key("ALIVE_PIC")
+        return await event.edit(
+            get_string("clst_5"), buttons=get_back_button("cbs_alabs_vcstm")
+        )
+    except BaseException as er:
+        LOGS.exception(er)
+        return await event.edit(
+            get_string("clst_4"),
+            buttons=get_back_button("cbs_alabs_vcstm"),
+        )
+
+
+@callback("inpm_in", owner=True)
+async def inl_on(event):
+    var = "INLINE_PM"
+    await setit(event, var, "True")
+    await event.edit(
+        "Done!! PMPermit type has been set to inline!",
+        buttons=[[Button.inline("« Bᴀᴄᴋ", data="cbs_pmtype")]],
+    )
+
+
+@callback("inpm_no", owner=True)
+async def inl_on(event):
+    var = "INLINE_PM"
+    await setit(event, var, "False")
+    await event.edit(
+        "Done!! PMPermit type has been set to normal!",
+        buttons=[[Button.inline("« Bᴀᴄᴋ", data="cbs_pmtype")]],
+    )
+
+
+@callback("pmtxt", owner=True)
+async def name(event):
+    await event.delete()
+    pru = event.sender_id
+    var = "PM_TEXT"
+    name = "PM Text"
+    async with event.client.conversation(pru) as conv:
+        await conv.send_message(
+            "**PM Text**\nEnter the new Pmpermit text.\n\nu can use `{name}` `{fullname}` `{count}` `{mention}` `{username}` to get this from user Too\n\nUse /cancel to terminate the operation.",
+        )
+        response = conv.wait_event(events.NewMessage(chats=pru))
+        response = await response
+        themssg = response.message.message
+        if themssg == "/cancel":
+            return await conv.send_message(
+                "Cancelled!!",
+                buttons=get_back_button("cbs_pmcstm"),
+            )
+        if len(themssg) > 4090:
+            return await conv.send_message(
+                "Message too long!\nGive a shorter message please!!",
+                buttons=get_back_button("cbs_pmcstm"),
+            )
+        await setit(event, var, themssg)
+        await conv.send_message(
+            f"{name} changed to {themssg}\n\nAfter Setting All Things Do restart",
+            buttons=get_back_button("cbs_pmcstm"),
+        )
+
+
+@callback("swarn", owner=True)
+async def name(event):
+    m = range(1, 10)
+    tultd = [Button.inline(f"{x}", data=f"wrns_{x}") for x in m]
+    lst = list(zip(tultd[::3], tultd[1::3], tultd[2::3]))
+    lst.append([Button.inline("« Bᴀᴄᴋ", data="cbs_pmcstm")])
+    await event.edit(
+        "Select the number of warnings for a user before getting blocked in PMs.",
+        buttons=lst,
+    )
+
+
+@callback(re.compile(b"wrns_(.*)"), owner=True)
+async def set_wrns(event):
+    value = int(event.data_match.group(1).decode("UTF-8"))
+    if dn := udB.set_key("PMWARNS", value):
+        await event.edit(
+            f"PM Warns Set to {value}.\nNew users will have {value} chances in PMs before getting banned.",
+            buttons=get_back_button("cbs_pmcstm"),
+        )
+    else:
+        await event.edit(
+            f"Something went wrong, please check your {HNDLR}logs!",
+            buttons=get_back_button("cbs_pmcstm"),
+        )
+
+
+@callback("pmmed", owner=True)
+async def media(event):
+    await event.delete()
+    pru = event.sender_id
+    var = "PMPIC"
+    name = "PM Media"
+    async with event.client.conversation(pru) as conv:
+        await conv.send_message(
+            "**PM Media**\nSend me a pic/gif/sticker/link  to set as pmpermit media.\n\nUse /cancel to terminate the operation.",
+        )
+        response = await conv.get_response()
+        try:
+            themssg = response.message
+            if themssg == "/cancel":
+                return await conv.send_message(
+                    "Operation cancelled!!",
+                    buttons=get_back_button("cbs_pmcstm"),
+                )
+        except BaseException as er:
+            LOGS.exception(er)
+        media = await event.client.download_media(response, "pmpc")
+        if (
+            not (response.text).startswith("/")
+            and response.text != ""
+            and (not response.media or isinstance(response.media, MessageMediaWebPage))
+        ):
+            url = text_to_url(response)
+        elif response.sticker:
+            url = response.file.id
+        else:
+            try:
+                x = upl(media)
+                url = f"https://graph.org/{x[0]}"
+                remove(media)
+            except BaseException as er:
+                LOGS.exception(er)
+                return await conv.send_message(
+                    "Terminated.",
+                    buttons=get_back_button("cbs_pmcstm"),
+                )
+        await setit(event, var, url)
+        await conv.send_message(
+            f"{name} has been set.",
+            buttons=get_back_button("cbs_pmcstm"),
+        )
+
+
+@callback("delpmmed", owner=True)
+async def dell(event):
+    try:
+        udB.del_key("PMPIC")
+        return await event.edit(
+            get_string("clst_5"), buttons=get_back_button("cbs_pmcstm")
+        )
+    except BaseException as er:
+        LOGS.exception(er)
+        return await event.edit(
+            get_string("clst_4"),
+            buttons=[[Button.inline("« Sᴇᴛᴛɪɴɢs", data="setter")]],
+        )
+
+
+@callback("apon", owner=True)
+async def apon(event):
+    var = "AUTOAPPROVE"
+    await setit(event, var, "True")
+    await event.edit(
+        "Done!! AUTOAPPROVE  Started!!",
+        buttons=[[Button.inline("« Bᴀᴄᴋ", data="cbs_apauto")]],
+    )
+
+
+@callback("apof", owner=True)
+async def apof(event):
+    try:
+        udB.set_key("AUTOAPPROVE", "False")
+        return await event.edit(
+            "Done! AUTOAPPROVE Stopped!!",
+            buttons=[[Button.inline("« Bᴀᴄᴋ", data="cbs_apauto")]],
+        )
+    except BaseException as er:
+        LOGS.exception(er)
+        return await event.edit(
+            get_string("clst_4"),
+            buttons=[[Button.inline("« Sᴇᴛᴛɪɴɢs", data="setter")]],
+        )
+
+
+@callback("pml", owner=True)
+async def l_vcs(event):
+    BT = (
+        [Button.inline("PMLOGGER OFF", data="pmlogof")]
+        if udB.get_key("PMLOG")
+        else [Button.inline("PMLOGGER ON", data="pmlog")]
+    )
+
+    await event.edit(
+        "PMLOGGER This Will Forward Ur Pm to Ur Private Group -",
+        buttons=[
+            BT,
+            [Button.inline("PᴍLᴏɢɢᴇʀ Gʀᴏᴜᴘ", "abs_pmlgg")],
+            [Button.inline("« Bᴀᴄᴋ", data="cbs_pmcstm")],
+        ],
+    )
+
+
+@callback("pmlog", owner=True)
+async def pmlog(event):
+    await setit(event, "PMLOG", "True")
+    await event.edit(
+        "Done!! PMLOGGER  Started!!",
+        buttons=[[Button.inline("« Bᴀᴄᴋ", data="pml")]],
+    )
+
+
+@callback("pmlogof", owner=True)
+async def pmlogof(event):
+    try:
+        udB.del_key("PMLOG")
+        return await event.edit(
+            "Done! PMLOGGER Stopped!!",
+            buttons=[[Button.inline("« Bᴀᴄᴋ", data="pml")]],
+        )
+    except BaseException as er:
+        LOGS.exception(er)
+        return await event.edit(
+            get_string("clst_4"),
+            buttons=[[Button.inline("« Sᴇᴛᴛɪɴɢs", data="setter")]],
+        )
+
+
+@callback("pmon", owner=True)
+async def pmonn(event):
+    var = "PMSETTING"
+    await setit(event, var, "True")
+    await event.edit(
+        "Done! PMPermit has been turned on!!",
+        buttons=[[Button.inline("« Bᴀᴄᴋ", data="cbs_ppmset")]],
+    )
+
+
+@callback("pmoff", owner=True)
+async def pmofff(event):
+    var = "PMSETTING"
+    await setit(event, var, "False")
+    await event.edit(
+        "Done! PMPermit has been turned off!!",
+        buttons=[[Button.inline("« Bᴀᴄᴋ", data="cbs_ppmset")]],
+    )
+
+
+@callback("botmew", owner=True)
+async def hhh(e):
+    async with e.client.conversation(e.chat_id) as conv:
+        await conv.send_message("Send Any Media to keep at your Bot's welcome ")
+        msg = await conv.get_response()
+        if not msg.media or msg.text.startswith("/"):
+            return await conv.send_message(
+                "Terminated!", buttons=get_back_button("cbs_chatbot")
+            )
+        udB.set_key("STARTMEDIA", msg.file.id)
+        await conv.send_message("Done!", buttons=get_back_button("cbs_chatbot"))
+
+
+@callback("botinfe", owner=True)
+async def hhh(e):
+    async with e.client.conversation(e.chat_id) as conv:
+        await conv.send_message(
+            "Send message to set to Display, when user Press Info button in Bot Welcome!\n\nsend `False` to completely remove that button.."
+        )
+        msg = await conv.get_response()
+        if msg.media or msg.text.startswith("/"):
+            return await conv.send_message(
+                "Terminated!", buttons=get_back_button("cbs_chatbot")
+            )
+        udB.set_key("BOT_INFO_START", msg.text)
+        await conv.send_message("Done!", buttons=get_back_button("cbs_chatbot"))
+
+
+@callback("pmfs", owner=True)
+async def heheh(event):
+    Ll = []
+    err = ""
+    async with event.client.conversation(event.chat_id) as conv:
+        await conv.send_message(
+            "• Send The Chat Id(s), which you want user to Join Before using Chat/Pm Bot\n\n• Send /clear to disable PmBot Force sub..\n• • Send /cancel to stop this process.."
+        )
+        await conv.send_message(
+            "Example : \n`-1001234567\n-100778888`\n\nFor Multiple Chat(s)."
+        )
+        try:
+            msg = await conv.get_response()
+        except AsyncTimeOut:
+            return await conv.send_message("**• TimeUp!**\nStart from /start back.")
+        if not msg.text or msg.text.startswith("/"):
+            timyork = "Cancelled!"
+            if msg.text == "/clear":
+                udB.del_key("PMBOT_FSUB")
+                timyork = "Done! Force Subscribe Stopped\nRestart your Bot!"
+            return await conv.send_message(
+                "Cancelled!", buttons=get_back_button("cbs_chatbot")
+            )
+        for chat in msg.message.split("\n"):
+            if chat.startswith("-") or chat.isdigit():
+                chat = int(chat)
+            try:
+                CHSJSHS = await event.client.get_entity(chat)
+                Ll.append(get_peer_id(CHSJSHS))
+            except Exception as er:
+                err += f"**{chat}** : {er}\n"
+        if err:
+            return await conv.send_message(err)
+        udB.set_key("PMBOT_FSUB", str(Ll))
+        await conv.send_message(
+            "Done!\nRestart Your Bot.", buttons=get_back_button("cbs_chatbot")
+        )
+
+
+@callback("bwel", owner=True)
+async def name(event):
+    await event.delete()
+    pru = event.sender_id
+    var = "STARTMSG"
+    name = "Bot Welcome Message:"
+    async with event.client.conversation(pru) as conv:
+        await conv.send_message(
+            "**BOT WELCOME MSG**\nEnter the msg which u want to show when someone start your assistant Bot.\nYou Can use `{me}` , `{mention}` Parameters Too\nUse /cancel to terminate the operation.",
+        )
+        response = conv.wait_event(events.NewMessage(chats=pru))
+        response = await response
+        themssg = response.message.message
+        if themssg == "/cancel":
+            return await conv.send_message(
+                "Cancelled!!",
+                buttons=get_back_button("cbs_chatbot"),
+            )
+        await setit(event, var, themssg)
+        await conv.send_message(
+            f"{name} changed to {themssg}",
+            buttons=get_back_button("cbs_chatbot"),
+        )
+
+
+@callback("onchbot", owner=True)
+async def chon(event):
+    var = "PMBOT"
+    await setit(event, var, "True")
+    Loader(path="assistant/pmbot.py", key="PM Bot").load()
+    if AST_PLUGINS.get("pmbot"):
+        for i, e in AST_PLUGINS["pmbot"]:
+            event.client.remove_event_handler(i)
+        for i, e in AST_PLUGINS["pmbot"]:
+            event.client.add_event_handler(i, events.NewMessage(**e))
+    await event.edit(
+        "Done! Now u Can Chat With People Via This Bot",
+        buttons=[Button.inline("« Bᴀᴄᴋ", data="cbs_chatbot")],
+    )
+
+
+@callback("ofchbot", owner=True)
+async def chon(event):
+    var = "PMBOT"
+    await setit(event, var, "False")
+    if AST_PLUGINS.get("pmbot"):
+        for i, e in AST_PLUGINS["pmbot"]:
+            event.client.remove_event_handler(i)
+    await event.edit(
+        "Done! Chat People Via This Bot Stopped.",
+        buttons=[Button.inline("« Bᴀᴄᴋ", data="cbs_chatbot")],
+    )
+
+
+@callback("inli_pic", owner=True)
+async def media(event):
+    await event.delete()
+    pru = event.sender_id
+    var = "INLINE_PIC"
+    name = "Inline Media"
+    async with event.client.conversation(pru) as conv:
+        await conv.send_message(
+            "**Inline Media**\nSend me a pic/gif/ or link  to set as inline media.\n\nUse /cancel to terminate the operation.",
+        )
+        response = await conv.get_response()
+        try:
+            themssg = response.message
+            if themssg == "/cancel":
+                return await conv.send_message(
+                    "Operation cancelled!!",
+                    buttons=get_back_button("setter"),
+                )
+        except BaseException as er:
+            LOGS.exception(er)
+        media = await event.client.download_media(response, "inlpic")
+        if (
+            not (response.text).startswith("/")
+            and response.text != ""
+            and (not response.media or isinstance(response.media, MessageMediaWebPage))
+        ):
+            url = text_to_url(response)
+        else:
+            try:
+                x = upl(media)
+                url = f"https://graph.org/{x[0]}"
+                remove(media)
+            except BaseException as er:
+                LOGS.exception(er)
+                return await conv.send_message(
+                    "Terminated.",
+                    buttons=get_back_button("setter"),
+                )
+        await setit(event, var, url)
+        await conv.send_message(
+            f"{name} has been set.",
+            buttons=get_back_button("setter"),
+        )
+
+
+FD_MEDIA = {}
+
+
+@callback(re.compile("fd(.*)"), owner=True)
+async def fdroid_dler(event):
+    uri = event.data_match.group(1).decode("utf-8")
+    if FD_MEDIA.get(uri):
+        return await event.edit(file=FD_MEDIA[uri])
+    await event.answer("• Starting Download •", alert=True)
+    await event.edit("• Downloading.. •")
+    URL = f"https://f-droid.org/packages/{uri}"
+    conte = await async_searcher(URL, re_content=True)
+    BSC = bs(conte, "html.parser", from_encoding="utf-8")
+    dl_ = BSC.find("p", "package-version-download").find("a")["href"]
+    title = BSC.find("h3", "package-name").text.strip()
+    thumb = BSC.find("img", "package-icon")["src"]
+    if thumb.startswith("/"):
+        thumb = f"https://f-droid.org{thumb}"
+    thumb, _ = await fast_download(thumb, filename=f"{uri}.png")
+    s_time = time.time()
+    file, _ = await fast_download(
+        dl_,
+        filename=f"{title}.apk",
+        progress_callback=lambda d, t: asyncio.get_event_loop().create_task(
+            progress(
+                d,
+                t,
+                event,
+                s_time,
+                "Downloading...",
+            )
+        ),
+    )
+
+    time.time()
+    n_file = await event.client.fast_uploader(
+        file, show_progress=True, event=event, message="Uploading...", to_delete=True
+    )
+    buttons = Button.switch_inline("Search Back", query="fdroid", same_peer=True)
+    try:
+        msg = await event.edit(
+            f"**• [{title}]({URL}) •**", file=n_file, thumb=thumb, buttons=buttons
+        )
+    except Exception as er:
+        LOGS.exception(er)
+        try:
+            msg = await event.client.edit_message(
+                await event.get_input_chat(),
+                event.message_id,
+                f"**• [{title}]({URL}) •**",
+                buttons=buttons,
+                thumb=thumb,
+                file=n_file,
+            )
+        except Exception as er:
+            os.remove(thumb)
+            LOGS.exception(er)
+            return await event.edit(f"**ERROR**: `{er}`", buttons=buttons)
+    if msg and hasattr(msg, "media"):
+        FD_MEDIA.update({uri: msg.media})
+    os.remove(thumb)

assistant/initial.py

@@ -0,0 +1,84 @@
+# Ultroid - UserBot
+# Copyright (C) 2021-2023 TeamUltroid
+#
+# This file is a part of < https://github.com/TeamUltroid/Ultroid/ >
+# PLease read the GNU Affero General Public License in
+# <https://www.github.com/TeamUltroid/Ultroid/blob/main/LICENSE/>.
+
+import re
+
+from . import *
+
+STRINGS = {
+    1: """🎇 **Thanks for Deploying Ultroid Userbot!**
+
+• Here, are the Some Basic stuff from, where you can Know, about its Usage.""",
+    2: """🎉** About Ultroid**
+
+🧿 Ultroid is Pluggable and powerful Telethon Userbot, made in Python from Scratch. It is Aimed to Increase Security along with Addition of Other Useful Features.
+
+❣ Made by **@TeamUltroid**""",
+    3: """**💡• FAQs •**
+
+-> [Username Tracker](https://t.me/UltroidUpdates/24)
+-> [Keeping Custom Addons Repo](https://t.me/UltroidUpdates/28)
+-> [Disabling Deploy message](https://t.me/UltroidUpdates/27)
+-> [Setting up TimeZone](https://t.me/UltroidUpdates/22)
+-> [About Inline PmPermit](https://t.me/UltroidUpdates/21)
+-> [About Dual Mode](https://t.me/UltroidUpdates/18)
+-> [Custom Thumbnail](https://t.me/UltroidUpdates/13)
+-> [About FullSudo](https://t.me/UltroidUpdates/11)
+-> [Setting Up PmBot](https://t.me/UltroidUpdates/2)
+-> [Also Check](https://t.me/UltroidUpdates/14)
+
+**• To Know About Updates**
+  - Join @TeamUltroid.""",
+    4: f"""• `To Know All Available Commands`
+
+  - `{HNDLR}help`
+  - `{HNDLR}cmds`""",
+    5: """• **For Any Other Query or Suggestion**
+  - Move to **@UltroidSupportChat**.
+
+• Thanks for Reaching till END.""",
+}
+
+
+@callback(re.compile("initft_(\\d+)"))
+async def init_depl(e):
+    CURRENT = int(e.data_match.group(1))
+    if CURRENT == 5:
+        return await e.edit(
+            STRINGS[5],
+            buttons=Button.inline("<< Back", "initbk_4"),
+            link_preview=False,
+        )
+
+    await e.edit(
+        STRINGS[CURRENT],
+        buttons=[
+            Button.inline("<<", f"initbk_{str(CURRENT - 1)}"),
+            Button.inline(">>", f"initft_{str(CURRENT + 1)}"),
+        ],
+        link_preview=False,
+    )
+
+
+@callback(re.compile("initbk_(\\d+)"))
+async def ineiq(e):
+    CURRENT = int(e.data_match.group(1))
+    if CURRENT == 1:
+        return await e.edit(
+            STRINGS[1],
+            buttons=Button.inline("Start Back >>", "initft_2"),
+            link_preview=False,
+        )
+
+    await e.edit(
+        STRINGS[CURRENT],
+        buttons=[
+            Button.inline("<<", f"initbk_{str(CURRENT - 1)}"),
+            Button.inline(">>", f"initft_{str(CURRENT + 1)}"),
+        ],
+        link_preview=False,
+    )

assistant/inlinestuff.py

@@ -0,0 +1,736 @@
+# Ultroid - UserBot
+# Copyright (C) 2021-2023 TeamUltroid
+#
+# This file is a part of < https://github.com/TeamUltroid/Ultroid/ >
+# PLease read the GNU Affero General Public License in
+# <https://www.github.com/TeamUltroid/Ultroid/blob/main/LICENSE/>.
+
+import base64
+import inspect
+import asyncio
+import os
+import sys
+import time
+from datetime import datetime
+from html import unescape
+from random import choice
+from re import compile as re_compile
+from platform import python_version as pyver
+from telethon import __version__
+from xteam.version import __version__ as UltVer
+from bs4 import BeautifulSoup as bs
+from telethon import Button
+from telethon.tl.alltlobjects import LAYER, tlobjects
+from telethon.tl.types import DocumentAttributeAudio as Audio
+from telethon.tl.types import InputWebDocument as wb
+from secrets import choice
+from telethon.tl.types import InputMessagesFilterVideo, InputMessagesFilterVoice
+from telethon.tl.types import InputMessagesFilterPhotos
+from xteam.fns.misc import google_search
+from xteam.fns.tools import (
+    _webupload_cache,
+    async_searcher,
+    get_ofox,
+    saavn_search,
+    webuploader,
+)
+
+from . import *
+from . import _ult_cache
+from plugins import (
+    ATRA_COL,
+    LOGS,
+    OWNER_NAME,
+    ULTROID_IMAGES,
+    ALIVE_TEXT,
+    ALIVE_NAME,
+    stickers,
+    Button,
+    Carbon,
+    Telegraph,
+    Var,
+    allcmds,
+    asst,
+    bash,
+    call_back,
+    callback,
+    def_logs,
+    eor,
+    get_string,
+    heroku_logs,
+    in_pattern,
+    inline_pic,
+    restart,
+    shutdown,
+    start_time,
+    time_formatter,
+    udB,
+    ultroid_cmd,
+    ultroid_version,
+    updater,
+)
+
+SUP_BUTTONS = [
+    [
+        Button.url("• Repo •", url="https://github.com/TeamUltroid/Ultroid"),
+        Button.url("• Support •", url="t.me/UltroidSupportChat"),
+    ],
+]
+
+PING_ALIVE = [
+    [
+        Button.inline("PING", data="ping"),
+        Button.inline("ALIVE", data="alive"),
+    ],
+    [
+        Button.inline("CLOSE", data="close"),
+    ],
+]
+
+
+ofox = "https://graph.org/file/231f0049fcd722824f13b.jpg"
+gugirl = "https://graph.org/file/0df54ae4541abca96aa11.jpg"
+ultpic = "https://telegra.ph/file/8d7b534e34e13316a7dd2.jpg"
+xteam = "https://telegra.ph/file/8d7b534e34e13316a7dd2.jpg"
+apis = [
+    "QUl6YVN5QXlEQnNZM1dSdEI1WVBDNmFCX3c4SkF5NlpkWE5jNkZV",
+    "QUl6YVN5QkYwenhMbFlsUE1wOXh3TVFxVktDUVJxOERnZHJMWHNn",
+    "QUl6YVN5RGRPS253blB3VklRX2xiSDVzWUU0Rm9YakFLSVFWMERR",
+]
+
+
+
+@in_pattern(owner=False, func=lambda x: not x.text)
+async def help(e):
+    TLINK = inline_pic() or "https://telegra.ph/file/cad7038fe82e47f79c609.jpg"
+    MSG = "═════════════♢.✰.♢═════════════"
+    WEB0 = wb(
+        "https://telegra.ph/file/8d7b534e34e13316a7dd2.jpg", 0, "image/jpg", []
+    )
+    res = [
+        await e.builder.article(
+            type="photo",
+            text=MSG,
+            include_media=True,
+            buttons=PING_ALIVE,
+            title="Inline",
+            description="Userbot",
+            url=TLINK,
+            thumb=WEB0,
+            content=wb(TLINK, 0, "image/jpg", []),
+        )
+    ]
+    await e.answer(
+        res,
+        private=True,
+        cache_time=300,
+        switch_pm="xteam-userbot",
+        switch_pm_param="start",
+    )
+
+@callback("ping", owner=False)
+async def _(event):
+    start = datetime.now()
+    end = datetime.now()
+    uptime = time_formatter((time.time() - start_time) * 1000)
+    ms = (end - start).microseconds
+    pin = f"🎯 Pong = {ms} ms\n⏰ Uptime = {uptime}"
+    await event.answer(pin, cache_time=0, alert=True)
+
+
+
+alive_txt = """
+━━━━✿ ᴜꜱᴇʀʙᴏᴛ ɪꜱ ᴀʟɪᴠᴇ ✿━━━
+  ❍ ᴜꜱᴇʀʙᴏᴛ - {}
+  ❍ ᴅᴀᴛᴀʙᴀꜱᴇ - {}
+  ❍ ᴛᴇʟᴇᴛʜᴏɴ - {}  
+━━━━✿ ᴜꜱᴇʀʙᴏᴛ ɪꜱ ᴀʟɪᴠᴇ ✿━━━
+"""
+
+
+@callback("alive")
+async def alive(event):
+    text = alive_txt.format(ultroid_version, UltVer, __version__)
+    await event.answer(text, alert=True)
+
+
+@callback("close", owner=False)
+async def on_plug_in_callback_query_handler(event):
+    await event.edit(
+        get_string("inline_5"),
+        buttons=Button.inline("Oᴘᴇɴ Aɢᴀɪɴ", data="open"),
+    )
+
+@in_pattern("ofox", owner=True)
+async def _(e):
+    try:
+        match = e.text.split(" ", maxsplit=1)[1]
+    except IndexError:
+        kkkk = e.builder.article(
+            title="Enter Device Codename",
+            thumb=wb(ofox, 0, "image/jpeg", []),
+            text="**OFᴏx🦊Rᴇᴄᴏᴠᴇʀʏ**\n\nYou didn't search anything",
+            buttons=Button.switch_inline("Sᴇᴀʀᴄʜ Aɢᴀɪɴ", query="ofox ", same_peer=True),
+        )
+        return await e.answer([kkkk])
+    device, releases = await get_ofox(match)
+    if device.get("detail") is None:
+        fox = []
+        fullname = device["full_name"]
+        codename = device["codename"]
+        str(device["supported"])
+        maintainer = device["maintainer"]["name"]
+        link = f"https://orangefox.download/device/{codename}"
+        for data in releases["data"]:
+            release = data["type"]
+            version = data["version"]
+            size = humanbytes(data["size"])
+            release_date = datetime.utcfromtimestamp(data["date"]).strftime("%Y-%m-%d")
+            text = f"[\xad]({ofox})**OʀᴀɴɢᴇFᴏx Rᴇᴄᴏᴠᴇʀʏ Fᴏʀ**\n\n"
+            text += f"`  Fᴜʟʟ Nᴀᴍᴇ: {fullname}`\n"
+            text += f"`  Cᴏᴅᴇɴᴀᴍᴇ: {codename}`\n"
+            text += f"`  Mᴀɪɴᴛᴀɪɴᴇʀ: {maintainer}`\n"
+            text += f"`  Bᴜɪʟᴅ Tʏᴘᴇ: {release}`\n"
+            text += f"`  Vᴇʀsɪᴏɴ: {version}`\n"
+            text += f"`  Sɪᴢᴇ: {size}`\n"
+            text += f"`  Bᴜɪʟᴅ Dᴀᴛᴇ: {release_date}`"
+            fox.append(
+                await e.builder.article(
+                    title=f"{fullname}",
+                    description=f"{version}\n{release_date}",
+                    text=text,
+                    thumb=wb(ofox, 0, "image/jpeg", []),
+                    link_preview=True,
+                    buttons=[
+                        Button.url("Dᴏᴡɴʟᴏᴀᴅ", url=f"{link}"),
+                        Button.switch_inline(
+                            "Sᴇᴀʀᴄʜ Aɢᴀɪɴ", query="ofox ", same_peer=True
+                        ),
+                    ],
+                )
+            )
+        await e.answer(
+            fox, switch_pm="OrangeFox Recovery Search.", switch_pm_param="start"
+        )
+    else:
+        await e.answer(
+            [], switch_pm="OrangeFox Recovery Search.", switch_pm_param="start"
+        )
+
+
+@in_pattern("fl2lnk ?(.*)", owner=True)
+async def _(e):
+    match = e.pattern_match.group(1)
+    chat_id, msg_id = match.split(":")
+    filename = _webupload_cache[int(chat_id)][int(msg_id)]
+    if "/" in filename:
+        filename = filename.split("/")[-1]
+    __cache = f"{chat_id}:{msg_id}"
+    buttons = [
+        [
+            Button.inline("anonfiles", data=f"flanonfiles//{__cache}"),
+            Button.inline("transfer", data=f"fltransfer//{__cache}"),
+        ],
+        [
+            Button.inline("bayfiles", data=f"flbayfiles//{__cache}"),
+            Button.inline("x0.at", data=f"flx0.at//{__cache}"),
+        ],
+        [
+            Button.inline("file.io", data=f"flfile.io//{__cache}"),
+            Button.inline("siasky", data=f"flsiasky//{__cache}"),
+        ],
+    ]
+    try:
+        lnk = [
+            await e.builder.article(
+                title=f"Upload {filename}",
+                text=f"**File:**\n{filename}",
+                buttons=buttons,
+            )
+        ]
+    except BaseException as er:
+        LOGS.exception(er)
+        lnk = [
+            await e.builder.article(
+                title="fl2lnk",
+                text="File not found",
+            )
+        ]
+    await e.answer(lnk, switch_pm="File to Link.", switch_pm_param="start")
+
+
+@callback(
+    re_compile(
+        "fl(.*)",
+    ),
+    owner=True,
+)
+async def _(e):
+    t = (e.data).decode("UTF-8")
+    data = t[2:]
+    host = data.split("//")[0]
+    chat_id, msg_id = data.split("//")[1].split(":")
+    filename = _webupload_cache[int(chat_id)][int(msg_id)]
+    if "/" in filename:
+        filename = filename.split("/")[-1]
+    await e.edit(f"Uploading `{filename}` on {host}")
+    link = (await webuploader(chat_id, msg_id, host)).strip().replace("\n", "")
+    await e.edit(f"Uploaded `{filename}` on {host}.", buttons=Button.url("View", link))
+
+
+@in_pattern("repo", owner=True)
+async def repo(e):
+    res = [
+        await e.builder.article(
+            title="Ultroid Userbot",
+            description="Userbot | Telethon",
+            thumb=wb(ultpic, 0, "image/jpeg", []),
+            text="• **ULTROID USERBOT** •",
+            buttons=SUP_BUTTONS,
+        ),
+    ]
+    await e.answer(res, switch_pm="Ultroid Repo.", switch_pm_param="start")
+
+
+@in_pattern("go", owner=True)
+async def gsearch(q_event):
+    try:
+        match = q_event.text.split(maxsplit=1)[1]
+    except IndexError:
+        return await q_event.answer(
+            [], switch_pm="Google Search. Enter a query!", switch_pm_param="start"
+        )
+    searcher = []
+    gresults = await google_search(match)
+    for i in gresults:
+        try:
+            title = i["title"]
+            link = i["link"]
+            desc = i["description"]
+            searcher.append(
+                await q_event.builder.article(
+                    title=title,
+                    description=desc,
+                    thumb=wb(gugirl, 0, "image/jpeg", []),
+                    text=f"**Gᴏᴏɢʟᴇ Sᴇᴀʀᴄʜ**\n\n**••Tɪᴛʟᴇ••**\n`{title}`\n\n**••Dᴇsᴄʀɪᴘᴛɪᴏɴ••**\n`{desc}`",
+                    link_preview=False,
+                    buttons=[
+                        [Button.url("Lɪɴᴋ", url=f"{link}")],
+                        [
+                            Button.switch_inline(
+                                "Sᴇᴀʀᴄʜ Aɢᴀɪɴ",
+                                query="go ",
+                                same_peer=True,
+                            ),
+                            Button.switch_inline(
+                                "Sʜᴀʀᴇ",
+                                query=f"go {match}",
+                                same_peer=False,
+                            ),
+                        ],
+                    ],
+                ),
+            )
+        except IndexError:
+            break
+    await q_event.answer(searcher, switch_pm="Google Search.", switch_pm_param="start")
+
+
+@in_pattern("mods", owner=True)
+async def _(e):
+    try:
+        quer = e.text.split(" ", maxsplit=1)[1]
+    except IndexError:
+        return await e.answer(
+            [], switch_pm="Mod Apps Search. Enter app name!", switch_pm_param="start"
+        )
+    start = 0 * 3 + 1
+    da = base64.b64decode(choice(apis)).decode("ascii")
+    url = f"https://www.googleapis.com/customsearch/v1?key={da}&cx=25b3b50edb928435b&q={quer}&start={start}"
+    data = await async_searcher(url, re_json=True)
+    search_items = data.get("items", [])
+    modss = []
+    for a in search_items:
+        title = a.get("title")
+        desc = a.get("snippet")
+        link = a.get("link")
+        text = f"**••Tɪᴛʟᴇ••** `{title}`\n\n"
+        text += f"**Dᴇsᴄʀɪᴘᴛɪᴏɴ** `{desc}`"
+        modss.append(
+            await e.builder.article(
+                title=title,
+                description=desc,
+                text=text,
+                link_preview=True,
+                buttons=[
+                    [Button.url("Dᴏᴡɴʟᴏᴀᴅ", url=f"{link}")],
+                    [
+                        Button.switch_inline(
+                            "Mᴏʀᴇ Mᴏᴅs",
+                            query="mods ",
+                            same_peer=True,
+                        ),
+                        Button.switch_inline(
+                            "Sʜᴀʀᴇ",
+                            query=f"mods {quer}",
+                            same_peer=False,
+                        ),
+                    ],
+                ],
+            ),
+        )
+    await e.answer(modss, switch_pm="Search Mod Applications.", switch_pm_param="start")
+
+
+APP_CACHE = {}
+RECENTS = {}
+PLAY_API = "https://googleplay.onrender.com/api/apps?q="
+
+
+@in_pattern("app", owner=True)
+async def _(e):
+    try:
+        f = e.text.split(maxsplit=1)[1].lower()
+    except IndexError:
+        get_string("instu_1")
+        res = []
+        if APP_CACHE and RECENTS.get(e.sender_id):
+            res.extend(
+                APP_CACHE[a][0] for a in RECENTS[e.sender_id] if APP_CACHE.get(a)
+            )
+        return await e.answer(
+            res, switch_pm=get_string("instu_2"), switch_pm_param="start"
+        )
+    try:
+        return await e.answer(
+            APP_CACHE[f], switch_pm="Application Searcher.", switch_pm_param="start"
+        )
+    except KeyError:
+        pass
+    foles = []
+    url = PLAY_API + f.replace(" ", "+")
+    aap = await async_searcher(url, re_json=True)
+    for z in aap["results"][:50]:
+        url = "https://play.google.com/store/apps/details?id=" + z["appId"]
+        name = z["title"]
+        desc = unescape(z["summary"])[:300].replace("<br>", "\n") + "..."
+        dev = z["developer"]["devId"]
+        text = f"**••Aᴘᴘ Nᴀᴍᴇ••** [{name}]({url})\n"
+        text += f"**••Dᴇᴠᴇʟᴏᴘᴇʀ••** `{dev}`\n"
+        text += f"**••Dᴇsᴄʀɪᴘᴛɪᴏɴ••**\n`{desc}`"
+        foles.append(
+            await e.builder.article(
+                title=name,
+                description=dev,
+                thumb=wb(z["icon"], 0, "image/jpeg", []),
+                text=text,
+                link_preview=True,
+                buttons=[
+                    [Button.url("Lɪɴᴋ", url=url)],
+                    [
+                        Button.switch_inline(
+                            "Mᴏʀᴇ Aᴘᴘs",
+                            query="app ",
+                            same_peer=True,
+                        ),
+                        Button.switch_inline(
+                            "Sʜᴀʀᴇ",
+                            query=f"app {f}",
+                            same_peer=False,
+                        ),
+                    ],
+                ],
+            ),
+        )
+    APP_CACHE.update({f: foles})
+    if RECENTS.get(e.sender_id):
+        RECENTS[e.sender_id].append(f)
+    else:
+        RECENTS.update({e.sender_id: [f]})
+    await e.answer(foles, switch_pm="Application Searcher.", switch_pm_param="start")
+
+
+PISTON_URI = "https://emkc.org/api/v2/piston/"
+PISTON_LANGS = {}
+
+
+@in_pattern("run", owner=True)
+async def piston_run(event):
+    try:
+        lang = event.text.split()[1]
+        code = event.text.split(maxsplit=2)[2]
+    except IndexError:
+        result = await event.builder.article(
+            title="Bad Query",
+            description="Usage: [Language] [code]",
+            thumb=wb(
+                "https://graph.org/file/e33c57fc5f1044547e4d8.jpg", 0, "image/jpeg", []
+            ),
+            text=f'**Inline Usage**\n\n`@{asst.me.username} run python print("hello world")`\n\n[Language List](https://graph.org/Ultroid-09-01-6)',
+        )
+        return await event.answer([result])
+    if not PISTON_LANGS:
+        se = await async_searcher(f"{PISTON_URI}runtimes", re_json=True)
+        PISTON_LANGS.update({lang.pop("language"): lang for lang in se})
+    if lang in PISTON_LANGS.keys():
+        version = PISTON_LANGS[lang]["version"]
+    else:
+        result = await event.builder.article(
+            title="Unsupported Language",
+            description="Usage: [Language] [code]",
+            thumb=wb(
+                "https://graph.org/file/e33c57fc5f1044547e4d8.jpg", 0, "image/jpeg", []
+            ),
+            text=f'**Inline Usage**\n\n`@{asst.me.username} run python print("hello world")`\n\n[Language List](https://graph.org/Ultroid-09-01-6)',
+        )
+        return await event.answer([result])
+    output = await async_searcher(
+        f"{PISTON_URI}execute",
+        post=True,
+        json={
+            "language": lang,
+            "version": version,
+            "files": [{"content": code}],
+        },
+        re_json=True,
+    )
+
+    output = output["run"]["output"] or get_string("instu_4")
+    if len(output) > 3000:
+        output = f"{output[:3000]}..."
+    result = await event.builder.article(
+        title="Result",
+        description=output,
+        text=f"• **Language:**\n`{lang}`\n\n• **Code:**\n`{code}`\n\n• **Result:**\n`{output}`",
+        thumb=wb(
+            "https://graph.org/file/871ee4a481f58117dccc4.jpg", 0, "image/jpeg", []
+        ),
+        buttons=Button.switch_inline("Fork", query=event.text, same_peer=True),
+    )
+    await event.answer([result], switch_pm="• Piston •", switch_pm_param="start")
+
+
+FDROID_ = {}
+
+
+@in_pattern("fdroid", owner=True)
+async def do_magic(event):
+    try:
+        match = event.text.split(" ", maxsplit=1)[1].lower()
+    except IndexError:
+        return await event.answer(
+            [], switch_pm="Enter Query to Search", switch_pm_param="start"
+        )
+    if FDROID_.get(match):
+        return await event.answer(
+            FDROID_[match], switch_pm=f"• Results for {match}", switch_pm_param="start"
+        )
+    link = "https://search.f-droid.org/?q=" + match.replace(" ", "+")
+    content = await async_searcher(link, re_content=True)
+    BSC = bs(content, "html.parser", from_encoding="utf-8")
+    ress = []
+    for dat in BSC.find_all("a", "package-header")[:10]:
+        image = dat.find("img", "package-icon")["src"]
+        if image.endswith("/"):
+            image = "https://graph.org/file/a8dd4a92c5a53a89d0eff.jpg"
+        title = dat.find("h4", "package-name").text.strip()
+        desc = dat.find("span", "package-summary").text.strip()
+        text = f"• **Name :** `{title}`\n\n"
+        text += f"• **Description :** `{desc}`\n"
+        text += f"• **License :** `{dat.find('span', 'package-license').text.strip()}`"
+        imga = wb(image, 0, "image/jpeg", [])
+        ress.append(
+            await event.builder.article(
+                title=title,
+                type="photo",
+                description=desc,
+                text=text,
+                content=imga,
+                thumb=imga,
+                include_media=True,
+                buttons=[
+                    Button.inline(
+                        "• Download •", "fd" + dat["href"].split("packages/")[-1]
+                    ),
+                    Button.switch_inline("• Share •", query=event.text),
+                ],
+            )
+        )
+    msg = f"Showing {len(ress)} Results!" if ress else "No Results Found"
+    FDROID_.update({match: ress})
+    await event.answer(ress, switch_pm=msg, switch_pm_param="start")
+
+
+# Thanks to OpenSource
+_bearer_collected = [
+    "AAAAAAAAAAAAAAAAAAAAALIKKgEAAAAA1DRuS%2BI7ZRKiagD6KHYmreaXomo%3DP5Vaje4UTtEkODg0fX7nCh5laSrchhtLxeyEqxXpv0w9ZKspLD",
+    "AAAAAAAAAAAAAAAAAAAAAL5iUAEAAAAAmo6FYRjqdKlI3cNziIm%2BHUQB9Xs%3DS31pj0mxARMTOk2g9dvQ1yP9wknvY4FPBPUlE00smJcncw4dPR",
+    "AAAAAAAAAAAAAAAAAAAAAN6sVgEAAAAAMMjMMWrwgGyv7YQOWN%2FSAsO5SGM%3Dg8MG9Jq93Rlllaok6eht7HvRCruN4Vpzp4NaVsZaaHHWSTzKI8",
+]
+
+
+@in_pattern("twitter", owner=True)
+async def twitter_search(event):
+    try:
+        match = event.text.split(maxsplit=1)[1].lower()
+    except IndexError:
+        return await event.answer(
+            [], switch_pm="Enter Query to Search", switch_pm_param="start"
+        )
+    try:
+        return await event.answer(
+            _ult_cache["twitter"][match],
+            switch_pm="• Twitter Search •",
+            switch_pm_param="start",
+        )
+    except KeyError:
+        pass
+    headers = {"Authorization": f"bearer {choice(_bearer_collected)}"}
+    res = await async_searcher(
+        f"https://api.twitter.com/1.1/users/search.json?q={match}",
+        headers=headers,
+        re_json=True,
+    )
+    reso = []
+    for user in res:
+        thumb = wb(user["profile_image_url_https"], 0, "image/jpeg", [])
+        if user.get("profile_banner_url"):
+            url = user["profile_banner_url"]
+            text = f"[\xad]({url})• **Name :** `{user['name']}`\n"
+        else:
+            text = f"• **Name :** `{user['name']}`\n"
+        text += f"• **Description :** `{user['description']}`\n"
+        text += f"• **Username :** `@{user['screen_name']}`\n"
+        text += f"• **Followers :** `{user['followers_count']}`    • **Following :** `{user['friends_count']}`\n"
+        pro_ = "https://twitter.com/" + user["screen_name"]
+        text += f"• **Link :** [Click Here]({pro_})\n_"
+        reso.append(
+            await event.builder.article(
+                title=user["name"],
+                description=user["description"],
+                url=pro_,
+                text=text,
+                thumb=thumb,
+            )
+        )
+    swi_ = f"🐦 Showing {len(reso)} Results!" if reso else "No User Found :("
+    await event.answer(reso, switch_pm=swi_, switch_pm_param="start")
+    if _ult_cache.get("twitter"):
+        _ult_cache["twitter"].update({match: reso})
+    else:
+        _ult_cache.update({"twitter": {match: reso}})
+
+
+_savn_cache = {}
+
+
+@in_pattern("saavn", owner=True)
+async def savn_s(event):
+    try:
+        query = event.text.split(maxsplit=1)[1].lower()
+    except IndexError:
+        return await event.answer(
+            [], switch_pm="Enter Query to search 🔍", switch_pm_param="start"
+        )
+    if query in _savn_cache:
+        return await event.answer(
+            _savn_cache[query],
+            switch_pm=f"Showing Results for {query}",
+            switch_pm_param="start",
+        )
+    results = await saavn_search(query)
+    swi = "🎵 Saavn Search" if results else "No Results Found!"
+    res = []
+    for song in results:
+        thumb = wb(song["image"], 0, "image/jpeg", [])
+        text = f"• **Title :** {song['title']}"
+        text += f"\n• **Year :** {song['year']}"
+        text += f"\n• **Lang :** {song['language']}"
+        text += f"\n• **Artist :** {song['artists']}"
+        text += f"\n• **Release Date :** {song['release_date']}"
+        res.append(
+            await event.builder.article(
+                title=song["title"],
+                description=song["artists"],
+                type="audio",
+                text=text,
+                include_media=True,
+                buttons=Button.switch_inline(
+                    "Search Again 🔍", query="saavn", same_peer=True
+                ),
+                thumb=thumb,
+                content=wb(
+                    song["url"],
+                    0,
+                    "audio/mp4",
+                    [
+                        Audio(
+                            title=song["title"],
+                            duration=int(song["duration"]),
+                            performer=song["artists"],
+                        )
+                    ],
+                ),
+            )
+        )
+    await event.answer(res, switch_pm=swi, switch_pm_param="start")
+    _savn_cache.update({query: res})
+
+
+@in_pattern("tl", owner=True)
+async def inline_tl(ult):
+    try:
+        match = ult.text.split(maxsplit=1)[1]
+    except IndexError:
+        text = f"**Telegram TlObjects Searcher.**\n__(Don't use if you don't know what it is!)__\n\n• Example Usage\n`@{asst.me.username} tl GetFullUserRequest`"
+        return await ult.answer(
+            [
+                await ult.builder.article(
+                    title="How to Use?",
+                    description="Tl Searcher by Ultroid",
+                    url="https://t.me/TeamUltroid",
+                    text=text,
+                )
+            ],
+            switch_pm="Tl Search 🔍",
+            switch_pm_param="start",
+        )
+    res = []
+    for key in tlobjects.values():
+        if match.lower() in key.__name__.lower():
+            tyyp = "Function" if "tl.functions." in str(key) else "Type"
+            text = f"**Name:** `{key.__name__}`\n"
+            text += f"**Category:** `{tyyp}`\n"
+            text += f"\n`from {key.__module__} import {key.__name__}`\n\n"
+            if args := str(inspect.signature(key))[1:][:-1]:
+                text += "**Parameter:**\n"
+                for para in args.split(","):
+                    text += " " * 4 + "`" + para + "`\n"
+            text += f"\n**Layer:** `{LAYER}`"
+            res.append(
+                await ult.builder.article(
+                    title=key.__name__,
+                    description=tyyp,
+                    url="https://t.me/TeamUltroid",
+                    text=text[:4000],
+                )
+            )
+    mo = f"Showing {len(res)} results!" if res else f"No Results for {match}!"
+    await ult.answer(res[:50], switch_pm=mo, switch_pm_param="start")
+
+
+InlinePlugin.update(
+    {
+        "Pʟᴀʏ Sᴛᴏʀᴇ Aᴘᴘs": "app telegram",
+        "Mᴏᴅᴅᴇᴅ Aᴘᴘs": "mods minecraft",
+        "Sᴇᴀʀᴄʜ Oɴ Gᴏᴏɢʟᴇ": "go TeamUltroid",
+        "WʜɪSᴘᴇʀ": "wspr @username Hello🎉",
+        "YᴏᴜTᴜʙᴇ Dᴏᴡɴʟᴏᴀᴅᴇʀ": "yt Ed Sheeran Perfect",
+        "Piston Eval": "run javascript console.log('Hello Ultroid')",
+        "OʀᴀɴɢᴇFᴏx🦊": "ofox beryllium",
+        "Tᴡɪᴛᴛᴇʀ Usᴇʀ": "twitter theultroid",
+        "Fᴅʀᴏɪᴅ Sᴇᴀʀᴄʜ": "fdroid telegram",
+        "Sᴀᴀᴠɴ sᴇᴀʀᴄʜ": "saavn",
+        "Tʟ Sᴇᴀʀᴄʜ": "tl",
+    }
+)

assistant/localization.py

@@ -0,0 +1,47 @@
+# Ultroid - UserBot
+# Copyright (C) 2021-2023 TeamUltroid
+#
+# This file is a part of < https://github.com/TeamUltroid/Ultroid/ >
+# PLease read the GNU Affero General Public License in
+# <https://www.github.com/TeamUltroid/Ultroid/blob/main/LICENSE/>.
+
+import re
+
+from . import (
+    Button,
+    ULTConfig,
+    callback,
+    get_back_button,
+    get_languages,
+    get_string,
+    udB,
+)
+
+
+@callback("lang", owner=True)
+async def setlang(event):
+    languages = get_languages()
+    tultd = [
+        Button.inline(
+            f"{languages[ult]['natively']} [{ult.lower()}]",
+            data=f"set_{ult}",
+        )
+        for ult in languages
+    ]
+    buttons = list(zip(tultd[::2], tultd[1::2]))
+    if len(tultd) % 2 == 1:
+        buttons.append((tultd[-1],))
+    buttons.append([Button.inline("« Back", data="mainmenu")])
+    await event.edit(get_string("ast_4"), buttons=buttons)
+
+
+@callback(re.compile(b"set_(.*)"), owner=True)
+async def settt(event):
+    lang = event.data_match.group(1).decode("UTF-8")
+    languages = get_languages()
+    ULTConfig.lang = lang
+    udB.del_key("language") if lang == "en" else udB.set_key("language", lang)
+    await event.edit(
+        f"Your language has been set to {languages[lang]['natively']} [{lang}].",
+        buttons=get_back_button("lang"),
+    )

assistant/pmbot.py

@@ -0,0 +1,150 @@
+# Ultroid - UserBot
+# Copyright (C) 2021-2023 TeamUltroid
+#
+# This file is a part of < https://github.com/TeamUltroid/Ultroid/ >
+# PLease read the GNU Affero General Public License in
+# <https://www.github.com/TeamUltroid/Ultroid/blob/main/LICENSE/>.
+
+# https://github.com/xditya/TeleBot/blob/master/telebot/plugins/mybot/pmbot/incoming.py
+
+# --------------------------------------- Imports -------------------------------------------- #
+
+import os
+
+from telethon.errors.rpcerrorlist import UserNotParticipantError
+from telethon.tl.custom import Button
+from telethon.tl.functions.channels import GetFullChannelRequest
+from telethon.tl.functions.messages import GetFullChatRequest
+from telethon.tl.types import Channel, Chat
+from telethon.utils import get_display_name
+
+from xteam.dB.base import KeyManager
+from xteam.dB.botchat_db import *
+from xteam.fns.helper import inline_mention
+
+from . import *
+
+botb = KeyManager("BOTBLS", cast=list)
+FSUB = udB.get_key("PMBOT_FSUB")
+CACHE = {}
+# --------------------------------------- Incoming -------------------------------------------- #
+
+
+@asst_cmd(
+    load=AST_PLUGINS,
+    incoming=True,
+    func=lambda e: e.is_private and not botb.contains(e.sender_id),
+)
+async def on_new_mssg(event):
+    who = event.sender_id
+    # doesn't reply to that user anymore
+    if event.text.startswith("/") or who == OWNER_ID:
+        return
+    if FSUB:
+        MSG = ""
+        BTTS = []
+        for chat in FSUB:
+            try:
+                await event.client.get_permissions(chat, event.sender_id)
+            except UserNotParticipantError:
+                if not MSG:
+                    MSG += get_string("pmbot_1")
+                try:
+                    uri = ""
+                    TAHC_ = await event.client.get_entity(chat)
+                    if hasattr(TAHC_, "username") and TAHC_.username:
+                        uri = f"t.me/{TAHC_.username}"
+                    elif CACHE.get(chat):
+                        uri = CACHE[chat]
+                    else:
+                        if isinstance(TAHC_, Channel):
+                            FUGB = await event.client(GetFullChannelRequest(chat))
+                        elif isinstance(TAHC_, Chat):
+                            FUGB = await event.client(GetFullChatRequest(chat))
+                        else:
+                            return
+                        if FUGB.full_chat.exported_invite:
+                            CACHE[chat] = FUGB.full_chat.exported_invite.link
+                            uri = CACHE[chat]
+                    BTTS.append(Button.url(get_display_name(TAHC_), uri))
+                except Exception as er:
+                    LOGS.exception(f"Error On PmBot Force Sub!\n - {chat} \n{er}")
+        if MSG and BTTS:
+            return await event.reply(MSG, buttons=BTTS)
+    xx = await event.forward_to(OWNER_ID)
+    if event.fwd_from:
+        await xx.reply(f"From {inline_mention(event.sender)} [`{event.sender_id}`]")
+    add_stuff(xx.id, who)
+
+
+# --------------------------------------- Outgoing -------------------------------------------- #
+
+
+@asst_cmd(
+    load=AST_PLUGINS,
+    from_users=[OWNER_ID],
+    incoming=True,
+    func=lambda e: e.is_private and e.is_reply,
+)
+async def on_out_mssg(event):
+    x = event.reply_to_msg_id
+    to_user = get_who(x)
+    if event.text.startswith("/who"):
+        try:
+            k = await asst.get_entity(to_user)
+            photu = await event.client.download_profile_photo(k.id)
+            await event.reply(
+                f"• **Name :** {get_display_name(k)}\n• **ID :** `{k.id}`\n• **Link :** {inline_mention(k)}",
+                file=photu,
+            )
+            if photu:
+                os.remove(photu)
+            return
+        except BaseException as er:
+            return await event.reply(f"**ERROR : **{str(er)}")
+    elif event.text.startswith("/"):
+        return
+    if to_user:
+        await asst.send_message(to_user, event.message)
+
+
+# --------------------------------------- Ban/Unban -------------------------------------------- #
+
+
+@asst_cmd(
+    pattern="ban",
+    load=AST_PLUGINS,
+    from_users=[OWNER_ID],
+    func=lambda x: x.is_private,
+)
+async def banhammer(event):
+    if not event.is_reply:
+        return await event.reply(get_string("pmbot_2"))
+    target = get_who(event.reply_to_msg_id)
+    if botb.contains(target):
+        return await event.reply(get_string("pmbot_3"))
+
+    botb.add(target)
+    await event.reply(f"#BAN\nUser : {target}")
+    await asst.send_message(target, get_string("pmbot_4"))
+
+
+@asst_cmd(
+    pattern="unban",
+    load=AST_PLUGINS,
+    from_users=[OWNER_ID],
+    func=lambda x: x.is_private,
+)
+async def unbanhammer(event):
+    if not event.is_reply:
+        return await event.reply(get_string("pmbot_5"))
+    target = get_who(event.reply_to_msg_id)
+    if not botb.contains(target):
+        return await event.reply(get_string("pmbot_6"))
+
+    botb.remove(target)
+    await event.reply(f"#UNBAN\nUser : {target}")
+    await asst.send_message(target, get_string("pmbot_7"))
+
+
+# --------------------------------------- END -------------------------------------------- #

assistant/start.py

@@ -0,0 +1,320 @@
+# Ultroid - UserBot
+# Copyright (C) 2021-2025 TeamUltroid
+#
+# This file is a part of < https://github.com/TeamUltroid/Ultroid/ >
+# PLease read the GNU Affero General Public License in
+# <https://www.github.com/TeamUltroid/Ultroid/blob/main/LICENSE/>.
+
+from datetime import datetime
+
+from pytz import timezone as tz
+from telethon import Button, events
+from telethon.errors.rpcerrorlist import MessageDeleteForbiddenError
+from telethon.utils import get_display_name
+
+from xteam._misc import SUDO_M, owner_and_sudos
+from xteam.dB.base import KeyManager
+from xteam.fns.helper import inline_mention
+from strings import get_string
+
+from . import *
+
+Owner_info_msg = udB.get_key("BOT_INFO_START")
+custom_info = True
+if Owner_info_msg is None:
+    custom_info = False
+    Owner_info_msg = f"""
+**Owner** - {OWNER_NAME}
+**OwnerID** - `{OWNER_ID}`
+
+**Message Forwards** - {udB.get_key("PMBOT")}
+
+**Xteam [v{ultroid_version}](https://github.com/TeamUltroid/Ultroid), powered by @TeamUltroid**
+"""
+
+
+_settings = [
+    [
+        Button.inline("API Kᴇʏs", data="cbs_apiset"),
+        Button.inline("Pᴍ Bᴏᴛ", data="cbs_chatbot"),
+    ],
+    [
+        Button.inline("Aʟɪᴠᴇ", data="cbs_alvcstm"),
+        Button.inline("PᴍPᴇʀᴍɪᴛ", data="cbs_ppmset"),
+    ],
+    [
+        Button.inline("Fᴇᴀᴛᴜʀᴇs", data="cbs_otvars"),
+        Button.inline("VC Sᴏɴɢ Bᴏᴛ", data="cbs_vcb"),
+    ],
+    [Button.inline("« Bᴀᴄᴋ", data="mainmenu")],
+]
+
+_start = [
+    [
+        Button.url("🥰 OWNER 🥰", url="https://t.me/xteam_clone"),
+        #Button.inline("Restart ♻️️", data="restart"),
+    ],
+    [
+        Button.inline("⚙️ Settings ⚙️", data="setter"),
+        Button.inline("♻️️ Restart ♻️️", data="restart"),
+    ],
+    [
+        Button.inline("✨ Stats ✨", data="stat"),
+        Button.inline("📻 Broadcast 📻", data="bcast"),
+    ],
+    [
+        Button.inline("🌐 Bahasa 🌐", data="lang"),
+    ],
+]
+
+@callback("restart", owner=True)
+async def restart_callback(e):
+    global restart_counter
+    ok = await e.reply("`Processing...`")
+    who = "bot" if e.client._bot else "user"
+    udB.set_key("_RESTART", f"{who}_{e.chat_id}_{ok.id}")
+    if heroku_api and restart_counter < 10:
+        restart_counter += 1
+    #        return await restart_callback(e)
+    await bash("git pull && pip3 install -r requirements.txt")
+    os.execl(sys.executable, sys.executable, "-m", "xteam")
+    
+
+
+@callback("ownerinfo")
+async def own(event):
+    msg = Owner_info_msg.format(
+        mention=event.sender.mention, me=inline_mention(ultroid_bot.me)
+    )
+    if custom_info:
+        msg += "\n\n• Powered by **@xteam-cloner**"
+    await event.edit(
+        msg,
+        buttons=[Button.inline("Close", data="closeit")],
+        link_preview=False,
+    )
+
+
+@callback("closeit")
+async def closet(lol):
+    try:
+        await lol.delete()
+    except MessageDeleteForbiddenError:
+        await lol.answer("MESSAGE_TOO_OLD", alert=True)
+
+
+@asst_cmd(pattern="start( (.*)|$)", forwards=False, func=lambda x: not x.is_group)
+async def ultroid(event):
+    args = event.pattern_match.group(1).strip()
+    keym = KeyManager("BOT_USERS", cast=list)
+    if not keym.contains(event.sender_id) and event.sender_id not in owner_and_sudos():
+        keym.add(event.sender_id)
+        kak_uiw = udB.get_key("OFF_START_LOG")
+        if not kak_uiw or kak_uiw != True:
+            msg = f"{inline_mention(event.sender)} `[{event.sender_id}]` started your [Assistant bot](@{asst.me.username})."
+            buttons = [[Button.inline("Info", "itkkstyo")]]
+            if event.sender.username:
+                buttons[0].append(
+                    Button.mention(
+                        "User", await event.client.get_input_entity(event.sender_id)
+                    )
+                )
+            await event.client.send_message(
+                udB.get_key("LOG_CHANNEL"), msg, buttons=buttons
+            )
+    if event.sender_id not in SUDO_M.fullsudos:
+        ok = ""
+        me = inline_mention(ultroid_bot.me)
+        mention = inline_mention(event.sender)
+        if args and args != "set":
+            await get_stored_file(event, args)
+        if not udB.get_key("STARTMSG"):
+            if udB.get_key("PMBOT"):
+                ok = "You can contact my master using this bot!!\n\nSend your Message, I will Deliver it To Master."
+            await event.reply(
+                f"Hey there {mention}, this is Assistant of {me}!\n\n{ok}",
+                file=udB.get_key("STARTMEDIA"),
+                buttons=[Button.inline("Info.", data="ownerinfo")]
+                if Owner_info_msg
+                else None,
+            )
+        else:
+            await event.reply(
+                udB.get_key("STARTMSG").format(me=me, mention=mention),
+                file=udB.get_key("STARTMEDIA"),
+                buttons=[Button.inline("Info.", data="ownerinfo")]
+                if Owner_info_msg
+                else None,
+            )
+    else:
+        name = get_display_name(event.sender)
+        if args == "set":
+            await event.reply(
+                "Choose from the below options -",
+                buttons=_settings,
+            )
+        elif args:
+            await get_stored_file(event, args)
+        else:
+            await event.respond(
+                f"<blockquote>Hey {name}. Please browse through the options</blockquote>",
+                buttons=_start,
+                parse_mode="html",
+            )
+            await event.react("🔥")  # Add a thumbs-up emoji reaction
+            
+
+"""@asst_cmd(pattern="start( (.*)|$)", forwards=False, func=lambda x: not x.is_group)
+async def ultroid(event):
+    args = event.pattern_match.group(1).strip()
+    keym = KeyManager("BOT_USERS", cast=list)
+    if not keym.contains(event.sender_id) and event.sender_id not in owner_and_sudos():
+        keym.add(event.sender_id)
+        kak_uiw = udB.get_key("OFF_START_LOG")
+        if not kak_uiw or kak_uiw != True:
+            msg = f"{inline_mention(event.sender)} `[{event.sender_id}]` started your [Assistant bot](@{asst.me.username})."
+            buttons = [[Button.inline("Info", "itkkstyo")]]
+            if event.sender.username:
+                buttons[0].append(
+                    Button.mention(
+                        "User", await event.client.get_input_entity(event.sender_id)
+                    )
+                )
+            await event.client.send_message(
+                udB.get_key("LOG_CHANNEL"), msg, buttons=buttons
+            )
+    if event.sender_id not in SUDO_M.fullsudos:
+        ok = ""
+        me = inline_mention(ultroid_bot.me)
+        mention = inline_mention(event.sender)
+        if args and args != "set":
+            await get_stored_file(event, args)
+        if not udB.get_key("STARTMSG"):
+            if udB.get_key("PMBOT"):
+                ok = "You can contact my master using this bot!!\n\nSend your Message, I will Deliver it To Master. ✉️"
+            await event.reply(
+                f"Hey there {mention}, this is Ultroid Assistant of {me}! 👋\n\n{ok}",
+                file=udB.get_key("STARTMEDIA"),
+                buttons=[Button.inline("Info.", data="ownerinfo")]
+                if Owner_info_msg
+                else None,
+            )
+        else:
+            await event.reply(
+                udB.get_key("STARTMSG").format(me=me, mention=mention),
+                file=udB.get_key("STARTMEDIA"),
+                buttons=[Button.inline("Info.", data="ownerinfo")]
+                if Owner_info_msg
+                else None,
+            )
+    else:
+        name = get_display_name(event.sender)
+        if args == "set":
+            await event.reply(
+                "Choose from the below options - ⚙️",
+                buttons=_settings,
+            )
+        elif args:
+            await get_stored_file(event, args)
+        else:
+            await event.reply(
+                get_string("ast_3").format(name),
+                buttons=_start,
+            )
+            await event.react("🔥")
+"""
+@callback("itkkstyo", owner=True)
+async def ekekdhdb(e):
+    text = f"When New Visitor will visit your Assistant Bot. You will get this log message!\n\nTo Disable : {HNDLR}setdb OFF_START_LOG True"
+    await e.answer(text, alert=True)
+
+
+@callback("mainmenu", owner=True, func=lambda x: not x.is_group)
+async def ultroid(event):
+    await event.edit(
+        get_string("ast_3").format(OWNER_NAME),
+        buttons=_start,
+    )
+
+
+@callback("stat", owner=True)
+async def botstat(event):
+    ok = len(udB.get_key("BOT_USERS") or [])
+    msg = """Xteam Assistant - Stats
+Total Users - {}""".format(
+        ok,
+    )
+    await event.answer(msg, cache_time=0, alert=True)
+
+
+@callback("bcast", owner=True)
+async def bdcast(event):
+    keym = KeyManager("BOT_USERS", cast=list)
+    total = keym.count()
+    await event.edit(f"• Broadcast to {total} users.")
+    async with event.client.conversation(OWNER_ID) as conv:
+        await conv.send_message(
+            "Enter your broadcast message.\nUse /cancel to stop the broadcast.",
+        )
+        response = await conv.get_response()
+        if response.message == "/cancel":
+            return await conv.send_message("Cancelled!!")
+        success = 0
+        fail = 0
+        await conv.send_message(f"Starting a broadcast to {total} users...")
+        start = datetime.now()
+        for i in keym.get():
+            try:
+                await asst.send_message(int(i), response)
+                success += 1
+            except BaseException:
+                fail += 1
+        end = datetime.now()
+        time_taken = (end - start).seconds
+        await conv.send_message(
+            f"""
+**Broadcast completed in {time_taken} seconds.**
+Total Users in Bot - {total}
+**Sent to** : `{success} users.`
+**Failed for** : `{fail} user(s).`""",
+        )
+
+
+@callback("setter", owner=True)
+async def setting(event):
+    await event.edit(
+        "Choose from the below options -",
+        buttons=_settings,
+    )
+
+
+@callback("tz", owner=True)
+async def timezone_(event):
+    await event.delete()
+    pru = event.sender_id
+    var = "TIMEZONE"
+    name = "Timezone"
+    async with event.client.conversation(pru) as conv:
+        await conv.send_message(
+            "Send Your TimeZone From This List [Check From Here](http://www.timezoneconverter.com/cgi-bin/findzone.tzc)"
+        )
+        response = conv.wait_event(events.NewMessage(chats=pru))
+        response = await response
+        themssg = response.message.message
+        if themssg == "/cancel":
+            return await conv.send_message(
+                "Cancelled!!",
+                buttons=get_back_button("mainmenu"),
+            )
+        try:
+            tz(themssg)
+            await setit(event, var, themssg)
+            await conv.send_message(
+                f"{name} changed to {themssg}\n",
+                buttons=get_back_button("mainmenu"),
+            )
+        except BaseException:
+            await conv.send_message(
+                "Wrong TimeZone, Try again",
+                buttons=get_back_button("mainmenu"),
+            )

assistant/ytdl.py

@@ -0,0 +1,307 @@
+# Ultroid - UserBot
+# Copyright (C) 2021-2025 TeamUltroid
+#
+# This file is a part of < https://github.com/TeamUltroid/Ultroid/ >
+# PLease read the GNU Affero General Public License in
+# <https://www.github.com/TeamUltroid/Ultroid/blob/main/LICENSE/>.
+
+
+import os
+import re
+
+try:
+    from PIL import Image
+except ImportError:
+    Image = None
+from telethon import Button
+from telethon.errors.rpcerrorlist import FilePartLengthInvalidError, MediaEmptyError
+from telethon.tl.types import DocumentAttributeAudio, DocumentAttributeVideo
+from telethon.tl.types import InputWebDocument as wb
+
+from xteam.fns.helper import (
+    bash,
+    fast_download,
+    humanbytes,
+    numerize,
+    time_formatter,
+)
+from xteam.fns.ytdl import dler, get_buttons, get_formats
+
+from . import LOGS, asst, callback, in_pattern, udB
+
+try:
+    from youtubesearchpython import VideosSearch
+except ImportError:
+    LOGS.info("'youtubesearchpython' not installed!")
+    VideosSearch = None
+
+
+ytt = "https://graph.org/file/afd04510c13914a06dd03.jpg"
+_yt_base_url = "https://www.youtube.com/watch?v="
+BACK_BUTTON = {}
+
+
+@in_pattern("yt", owner=True)
+async def _(event):
+    try:
+        string = event.text.split(" ", maxsplit=1)[1]
+    except IndexError:
+        fuk = event.builder.article(
+            title="Search Something",
+            thumb=wb(ytt, 0, "image/jpeg", []),
+            text="**YᴏᴜTᴜʙᴇ Sᴇᴀʀᴄʜ**\n\nYou didn't search anything",
+            buttons=Button.switch_inline(
+                "Sᴇᴀʀᴄʜ Aɢᴀɪɴ",
+                query="yt ",
+                same_peer=True,
+            ),
+        )
+        await event.answer([fuk])
+        return
+    results = []
+    search = VideosSearch(string, limit=50)
+    nub = search.result()
+    nibba = nub["result"]
+    for v in nibba:
+        ids = v["id"]
+        link = _yt_base_url + ids
+        title = v["title"]
+        duration = v["duration"]
+        views = v["viewCount"]["short"]
+        publisher = v["channel"]["name"]
+        published_on = v["publishedTime"]
+        description = (
+            v["descriptionSnippet"][0]["text"]
+            if v.get("descriptionSnippet")
+            and len(v["descriptionSnippet"][0]["text"]) < 500
+            else "None"
+        )
+        thumb = f"https://i.ytimg.com/vi/{ids}/hqdefault.jpg"
+        text = f"**Title: [{title}]({link})**\n\n"
+        text += f"`Description: {description}\n\n"
+        text += f"「 Duration: {duration} 」\n"
+        text += f"「 Views: {views} 」\n"
+        text += f"「 Publisher: {publisher} 」\n"
+        text += f"「 Published on: {published_on} 」`"
+        desc = f"{title}\n{duration}"
+        file = wb(thumb, 0, "image/jpeg", [])
+        buttons = [
+            [
+                Button.inline("Audio", data=f"ytdl:audio:{ids}"),
+                Button.inline("Video", data=f"ytdl:video:{ids}"),
+            ],
+            [
+                Button.switch_inline(
+                    "Sᴇᴀʀᴄʜ Aɢᴀɪɴ",
+                    query="yt ",
+                    same_peer=True,
+                ),
+                Button.switch_inline(
+                    "Sʜᴀʀᴇ",
+                    query=f"yt {string}",
+                    same_peer=False,
+                ),
+            ],
+        ]
+        BACK_BUTTON.update({ids: {"text": text, "buttons": buttons}})
+        results.append(
+            await event.builder.article(
+                type="photo",
+                title=title,
+                description=desc,
+                thumb=file,
+                content=file,
+                text=text,
+                include_media=True,
+                buttons=buttons,
+            ),
+        )
+    await event.answer(results[:50])
+
+
+@callback(
+    re.compile(
+        "ytdl:(.*)",
+    ),
+    owner=True,
+)
+async def _(e):
+    _e = e.pattern_match.group(1).strip().decode("UTF-8")
+    _lets_split = _e.split(":")
+    _ytdl_data = await dler(e, _yt_base_url + _lets_split[1])
+    _data = get_formats(_lets_split[0], _lets_split[1], _ytdl_data)
+    _buttons = get_buttons(_data)
+    _text = (
+        "`Select Your Format.`"
+        if _buttons
+        else "`Error downloading from YouTube.\nTry Restarting your bot.`"
+    )
+
+    await e.edit(_text, buttons=_buttons)
+
+
+@callback(
+    re.compile(
+        "ytdownload:(.*)",
+    ),
+    owner=True,
+)
+async def _(event):
+    url = event.pattern_match.group(1).strip().decode("UTF-8")
+    lets_split = url.split(":")
+    vid_id = lets_split[2]
+    link = _yt_base_url + vid_id
+    format = lets_split[1]
+    try:
+        ext = lets_split[3]
+    except IndexError:
+        ext = "mp3"
+    if lets_split[0] == "audio":
+        opts = {
+            "format": "bestaudio",
+            "addmetadata": True,
+            "key": "FFmpegMetadata",
+            "prefer_ffmpeg": True,
+            "geo_bypass": True,
+            "outtmpl": f"%(id)s.{ext}",
+            "logtostderr": False,
+            "postprocessors": [
+                {
+                    "key": "FFmpegExtractAudio",
+                    "preferredcodec": ext,
+                    "preferredquality": format,
+                },
+                {"key": "FFmpegMetadata"},
+            ],
+        }
+
+        ytdl_data = await dler(event, link, opts, True)
+        title = ytdl_data["title"]
+        if ytdl_data.get("artist"):
+            artist = ytdl_data["artist"]
+        elif ytdl_data.get("creator"):
+            artist = ytdl_data["creator"]
+        elif ytdl_data.get("channel"):
+            artist = ytdl_data["channel"]
+        views = numerize(ytdl_data.get("view_count")) or 0
+        thumb, _ = await fast_download(ytdl_data["thumbnail"], filename=f"{vid_id}.jpg")
+
+        likes = numerize(ytdl_data.get("like_count")) or 0
+        duration = ytdl_data.get("duration") or 0
+        description = (
+            ytdl_data["description"]
+            if len(ytdl_data["description"]) < 100
+            else ytdl_data["description"][:100]
+        )
+        description = description or "None"
+        filepath = f"{vid_id}.{ext}"
+        if not os.path.exists(filepath):
+            filepath = f"{filepath}.{ext}"
+        size = os.path.getsize(filepath)
+        file, _ = await event.client.fast_uploader(
+            filepath,
+            filename=f"{title}.{ext}",
+            show_progress=True,
+            event=event,
+            to_delete=True,
+        )
+
+        attributes = [
+            DocumentAttributeAudio(
+                duration=int(duration),
+                title=title,
+                performer=artist,
+            ),
+        ]
+    elif lets_split[0] == "video":
+        opts = {
+            "format": str(format),
+            "addmetadata": True,
+            "key": "FFmpegMetadata",
+            "prefer_ffmpeg": True,
+            "geo_bypass": True,
+            "outtmpl": f"%(id)s.{ext}",
+            "logtostderr": False,
+            "postprocessors": [{"key": "FFmpegMetadata"}],
+        }
+
+        ytdl_data = await dler(event, link, opts, True)
+        title = ytdl_data["title"]
+        if ytdl_data.get("artist"):
+            artist = ytdl_data["artist"]
+        elif ytdl_data.get("creator"):
+            artist = ytdl_data["creator"]
+        elif ytdl_data.get("channel"):
+            artist = ytdl_data["channel"]
+        views = numerize(ytdl_data.get("view_count")) or 0
+        thumb, _ = await fast_download(ytdl_data["thumbnail"], filename=f"{vid_id}.jpg")
+
+        try:
+            Image.open(thumb).save(thumb, "JPEG")
+        except Exception as er:
+            LOGS.exception(er)
+            thumb = None
+        description = (
+            ytdl_data["description"]
+            if len(ytdl_data["description"]) < 100
+            else ytdl_data["description"][:100]
+        )
+        likes = numerize(ytdl_data.get("like_count")) or 0
+        hi, wi = ytdl_data.get("height") or 720, ytdl_data.get("width") or 1280
+        duration = ytdl_data.get("duration") or 0
+        filepath = f"{vid_id}.mkv"
+        if not os.path.exists(filepath):
+            filepath = f"{filepath}.webm"
+        size = os.path.getsize(filepath)
+        file, _ = await event.client.fast_uploader(
+            filepath,
+            filename=f"{title}.mkv",
+            show_progress=True,
+            event=event,
+            to_delete=True,
+        )
+
+        attributes = [
+            DocumentAttributeVideo(
+                duration=int(duration),
+                w=wi,
+                h=hi,
+                supports_streaming=True,
+            ),
+        ]
+    description = description if description != "" else "None"
+    text = f"**Title: [{title}]({_yt_base_url}{vid_id})**\n\n"
+    text += f"`📝 Description: {description}\n\n"
+    text += f"「 Duration: {time_formatter(int(duration)*1000)} 」\n"
+    text += f"「 Artist: {artist} 」\n"
+    text += f"「 Views: {views} 」\n"
+    text += f"「 Likes: {likes} 」\n"
+    text += f"「 Size: {humanbytes(size)} 」`"
+    button = Button.switch_inline("Search More", query="yt ", same_peer=True)
+    try:
+        await event.edit(
+            text,
+            file=file,
+            buttons=button,
+            attributes=attributes,
+            thumb=thumb,
+        )
+    except (FilePartLengthInvalidError, MediaEmptyError):
+        file = await asst.send_message(
+            udB.get_key("LOG_CHANNEL"),
+            text,
+            file=file,
+            buttons=button,
+            attributes=attributes,
+            thumb=thumb,
+        )
+        await event.edit(text, file=file.media, buttons=button)
+    await bash(f"rm {vid_id}.jpg")
+
+
+@callback(re.compile("ytdl_back:(.*)"), owner=True)
+async def ytdl_back(event):
+    id_ = event.data_match.group(1).decode("utf-8")
+    if not BACK_BUTTON.get(id_):
+        return await event.answer("Query Expired! Search again 🔍")
+    await event.edit(**BACK_BUTTON[id_])