Upload 216 files

.gitattributes

@@ -33,3 +33,13 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+resources/extras/logo_readme.jpg filter=lfs diff=lfs merge=lfs -text
+resources/extras/ultroid.jpg filter=lfs diff=lfs merge=lfs -text
+resources/fonts/11.otf filter=lfs diff=lfs merge=lfs -text
+resources/fonts/3.ttf filter=lfs diff=lfs merge=lfs -text
+resources/fonts/default.ttf filter=lfs diff=lfs merge=lfs -text
+resources/fonts/DroidSansMono.ttf filter=lfs diff=lfs merge=lfs -text
+resources/fonts/Quivira.otf filter=lfs diff=lfs merge=lfs -text
+resources/fonts/Roboto-Italic.ttf filter=lfs diff=lfs merge=lfs -text
+resources/fonts/Roboto-Medium.ttf filter=lfs diff=lfs merge=lfs -text
+resources/fonts/Roboto-Regular.ttf filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,47 @@
+.env
+*.session-journal
+*.session
+build
+test*
+*.mp3
+*.webm
+*.webp
+*.mp4
+*.tgs
+*.txt
+/*.jpg
+/*.png
+/*.mp4
+*.log
+target/npmlist.json
+package-lock.json
+ultroid.json
+resources/extras/thumbnail.jpg
+resources/auth/
+
+# Directories
+addons/
+vcbot/
+__pycache__/
+venv/
+node_modules/
+glitch_me/
+src/glitch-me
+.idea/
+.vscode/
+temp/
+bin-debug/
+bin-release/
+[Oo]bj/
+[Bb]in/
+.settings/
+*.swf
+*.air
+*.ipa
+*.apk
+
+# temporary files
+*.raw
+
+# fly.io configs
+fly.toml

Dockerfile

@@ -0,0 +1,20 @@
+# 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 theteamultroid/ultroid:main
+
+# set timezone
+ENV TZ=Asia/Karachi
+RUN ln -snf /usr/share/zoneinfo/$TZ /etc/localtime && echo $TZ > /etc/timezone
+
+COPY installer.sh .
+
+RUN bash installer.sh
+
+# changing workdir
+WORKDIR "/root/TeamUltroid"
+
+# start the bot.
+CMD ["bash", "startup"]

assistant/__init__.py

@@ -0,0 +1,34 @@
+# 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 telethon import Button, custom
+
+from plugins import ATRA_COL, InlinePlugin
+from pyUltroid import *
+from pyUltroid import _ult_cache
+from pyUltroid._misc import owner_and_sudos
+from pyUltroid._misc._assistant import asst_cmd, callback, in_pattern
+from pyUltroid.fns.helper import *
+from pyUltroid.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-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 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 pyUltroid.fns.gDrive import GDriveManager
+except ImportError:
+    GDriveManager = None
+from telethon import Button, events
+from catbox import CatboxUploader
+from telethon.tl.types import MessageMediaWebPage
+from telethon.utils import get_peer_id
+
+from pyUltroid.fns.helper import fast_download, progress
+from pyUltroid.fns.tools import Carbon, async_searcher, get_paste, telegraph_client
+from pyUltroid.startup.loader import Loader
+
+from . import *
+
+# --------------------------------------------------------------------#
+telegraph = telegraph_client()
+GDrive = GDriveManager() if GDriveManager else None
+uploader = CatboxUploader()
+# --------------------------------------------------------------------#
+
+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")
+        await bash("pip3 install -r requirements.txt --break-system-packages")
+        execl(sys.executable, sys.executable, "-m", "pyUltroid")
+
+@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:
+        _, data = await get_paste(hmm.read())
+    if not data.get("link"):
+        return await e.answer(key[:30], alert=True)
+    if not key.startswith("http"):
+        link, raw = data["link"], data["raw"]
+    else:
+        link = key
+        raw = f"{key}/raw"
+    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:
+                url = uploader.upload_file(media)
+                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:
+                url = uploader.upload_file(media)
+                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:
+                url = uploader.upload_file(media)
+                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/games.py

@@ -0,0 +1,331 @@
+# 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/>.
+
+"""
+• `{i}akinator` | `/akinator`
+   Start akinator game from Userbot/Assistant
+
+• `/startgame`
+   Open Portal for Games
+"""
+
+import asyncio
+import re, uuid, operator
+from random import choice, shuffle
+
+from akipy.async_akipy import Akinator
+from telethon.errors.rpcerrorlist import BotMethodInvalidError
+from telethon.events import Raw
+from telethon.tl.types import InputMediaPoll, Poll, PollAnswer, UpdateMessagePollVote
+
+from pyUltroid._misc._decorators import ultroid_cmd
+from logging import getLogger
+from html import unescape
+from telethon.tl.types import TextWithEntities
+from pyUltroid.fns.helper import inline_mention
+from pyUltroid.fns.tools import async_searcher
+from telethon.errors import ChatSendStickersForbiddenError
+
+from . import *  # Ensure this import matches your project structure
+
+games = {}
+aki_photo = "https://graph.org/file/3cc8825c029fd0cab9edc.jpg"
+
+akipyLOGS = getLogger("akipy")
+
+@ultroid_cmd(pattern="akinator")
+async def akina(e):
+    sta = Akinator()
+    games[e.chat_id] = {e.id: sta}
+    LOGS.info(f"Game started for chat {e.chat_id} with ID {e.id}.")
+    try:
+        m = await e.client.inline_query(asst.me.username, f"aki_{e.chat_id}_{e.id}")
+        await m[0].click(e.chat_id)
+        akipyLOGS.info(f"Clicked inline result for chat {e.chat_id}")
+    except BotMethodInvalidError as err:
+        akipyLOGS.error(f"BotMethodInvalidError: {err}")
+        await asst.send_file(
+            e.chat_id,
+            aki_photo,
+            buttons=Button.inline(get_string("aki_2"), data=f"aki_{e.chat_id}_{e.id}"),
+        )
+    except Exception as er:
+        akipyLOGS.error(f"Unexpected error: {er}")
+        return await e.eor(f"ERROR : {er}")
+    if e.out:
+        await e.delete()
+
+
+@asst_cmd(pattern="akinator", owner=True)
+async def _akokk(e):
+    await akina(e)
+
+
+@callback(re.compile("aki_(.*)"), owner=True)
+async def doai(e):
+    adt = e.pattern_match.group(1).strip().decode("utf-8")
+    dt = adt.split("_")
+    ch = int(dt[0])
+    mid = int(dt[1])
+    await e.edit(get_string("com_1"))
+    try:
+        await games[ch][mid].start_game(child_mode=False)
+        bts = [Button.inline(o, f"aka_{adt}_{o}") for o in ["Yes", "No", "Idk"]]
+        cts = [Button.inline(o, f"aka_{adt}_{o}") for o in ["Probably", "Probably Not"]]
+        bts = [bts, cts]
+        await e.edit(f"Q. {games[ch][mid].question}", buttons=bts)
+    except KeyError:
+        return await e.answer(get_string("aki_1"), alert=True)
+
+
+@callback(re.compile("aka_(.*)"), owner=True)
+async def okah(e):
+    try:
+        mk = e.pattern_match.group(1).decode("utf-8").split("_")
+        #akipyLOGS.info(f"Parsed values: {mk}")
+
+        if len(mk) < 3:
+            akipyLOGS.error("Pattern match did not return enough parts.")
+            return await e.answer("Invalid data received.", alert=True)
+
+        ch = int(mk[0])
+        mid = int(mk[1])
+        ans = mk[2]
+
+        gm = games[ch][mid]
+        await gm.answer(ans)
+
+        # Check for the final guess in the API response
+        if gm.name_proposition and gm.description_proposition:
+            gm.win = True
+            text = f"It's {gm.name_proposition}\n{gm.description_proposition}"
+            await e.edit(text, file=gm.photo)
+        else:
+            # Game is not won yet, continue asking questions
+            buttons = [
+                [Button.inline(o, f"aka_{ch}_{mid}_{o}") for o in ["Yes", "No", "Idk"]],
+                [Button.inline(o, f"aka_{ch}_{mid}_{o}") for o in ["Probably", "Probably Not"]],
+            ]
+            await e.edit(gm.question, buttons=buttons)
+
+    except KeyError:
+        await e.answer(get_string("aki_3"))
+    except Exception as ex:
+        akipyLOGS.error(f"An unexpected error occurred: {ex}")
+
+
+@in_pattern(re.compile("aki_?(.*)"), owner=True)
+async def eiagx(e):
+    bts = Button.inline(get_string("aki_2"), data=e.text)
+    ci = types.InputWebDocument(aki_photo, 0, "image/jpeg", [])
+    ans = [
+        await e.builder.article(
+            "Akinator",
+            type="photo",
+            content=ci,
+            text="Akinator",
+            thumb=ci,
+            buttons=bts,
+            include_media=True,
+        )
+    ]
+    await e.answer(ans)
+
+
+# ----------------------- Main Command ------------------- #
+
+GIMAGE = "https://graph.org/file/1c51015bae5205a65fd69.jpg"
+
+@asst_cmd(pattern="startgame", owner=True)
+async def magic(event):
+    buttons = [
+        [Button.inline("Trivia Quiz", "trzia")],
+        [Button.inline("Cancel ❌", "delit")],
+    ]
+    await event.reply(
+        get_string("games_1"),
+        file=GIMAGE,
+        buttons=buttons,
+    )
+
+
+# -------------------------- Trivia ----------------------- #
+
+TR_BTS = {}
+DIFI_KEYS = ["Easy", "Medium", "Hard"]
+TRIVIA_CHATS = {}
+POLLS = {}
+CONGO_STICKER = [
+    "CAADAgADSgIAAladvQrJasZoYBh68AI",
+    "CAADAgADXhIAAuyZKUl879mlR_dkOwI",
+    "CAADAgADpQAD9wLID-xfZCDwOI5LAg",
+    "CAADAgADjAADECECEFZM-SrKO9GgAg",
+    "CAADAgADSwIAAj-VzArAzNCDiGWAHAI",
+    "CAADAgADhQADwZxgDIuMHR9IU10iAg",
+    "CAADAgADiwMAAsSraAuoe2BwYu1sdQI",
+]
+
+
+@callback("delit", owner=True)
+async def delete_it(event):
+    await event.delete()
+
+
+@callback(re.compile("ctdown(.*)"), owner=True)
+async def ct_spam(e):
+    n = e.data_match.group(1).decode("utf-8")
+    await e.answer(f"Wait {n} seconds..", alert=True)
+
+
+@callback(re.compile("trzia(.*)"), owner=True)
+async def choose_cata(event):
+    match = event.data_match.group(1).decode("utf-8")
+    if not match:
+        if TR_BTS.get("category"):
+            buttons = TR_BTS["category"]
+        else:
+            req = (
+                await async_searcher(
+                    "https://opentdb.com/api_category.php", re_json=True
+                )
+            )["trivia_categories"]
+            btt = []
+            for i in req:
+                name = i["name"]
+                if ":" in name:
+                    name = name.split(":")[1]
+                btt.append(Button.inline(name, f"trziad_{i['id']}"))
+            buttons = list(zip(btt[::2], btt[1::2]))
+            if len(btt) % 2 == 1:
+                buttons.append((btt[-1],))
+            buttons.append([Button.inline("Cancel ❌", "delit")])
+            TR_BTS.update({"category": buttons})
+        text = get_string("games_2")
+    elif match[0] == "d":
+        cat = match[1:]
+        buttons = [[Button.inline(i, f"trziac{cat}_{i}") for i in DIFI_KEYS]]
+        buttons.append(get_back_button("trzia"))
+        text = get_string("games_3")
+    elif match[0] == "c":
+        m = match[1:]
+        buttons = [[Button.inline(str(i), f"trziat{m}_{i}") for i in range(10, 70, 20)]]
+        text = get_string("games_4")
+    elif match[0] == "t":
+        m_ = match[1:]
+        buttons = [
+            [Button.inline(str(i), f"trzias{m_}_{i}") for i in [10, 30, 60, 120]]
+        ]
+        text = get_string("games_5")
+    elif match[0] == "s":
+        chat = event.chat_id
+        cat, le, nu, in_ = match[2:].split("_")
+        msg = await event.edit(get_string("games_6").format(le, nu))
+        for i in reversed(range(5)):
+            msg = await msg.edit(buttons=Button.inline(f"{i} ⏰", f"ctdown{i}"))
+            await asyncio.sleep(1)
+        await msg.edit(
+            msg.text + "\n\n• Send /cancel to stop the Quiz...", buttons=None
+        )
+        qsss = await async_searcher(
+            f"https://opentdb.com/api.php?amount={nu}&category={cat}&difficulty={le.lower()}",
+            re_json=True,
+        )
+        qs = qsss["results"]
+        if not qs:
+            await event.respond("Sorry, No Question Found for the given Criteria..")
+            await event.delete()
+            return
+        TRIVIA_CHATS.update({chat: {}})
+        for copper, q in enumerate(qs):
+            if TRIVIA_CHATS[chat].get("cancel") is not None:
+                break
+            ansi = str(uuid.uuid1()).split("-")[0].encode()
+            opts = [PollAnswer(TextWithEntities(unescape(q["correct_answer"]), entities=[]), ansi)]
+            [
+                opts.append(
+                    PollAnswer(TextWithEntities(unescape(a), entities=[]), str(uuid.uuid1()).split("-")[0].encode())
+                )
+                for a in q["incorrect_answers"]
+            ]
+            shuffle(opts)
+            poll = InputMediaPoll(
+                Poll(
+                    0,
+                    TextWithEntities(
+                        f"[{copper+1}].  " + unescape(q["question"]),
+                        entities=[]
+                    ),
+                    answers=opts,
+                    public_voters=True,
+                    quiz=True,
+                    close_period=int(in_),
+                ),
+                correct_answers=[ansi],
+                solution="Join @TeamUltroid",
+                solution_entities=[],
+            )
+            m_ = await event.client.send_message(chat, file=poll)
+            POLLS.update({m_.poll.poll.id: {"chat": m_.chat_id, "answer": ansi}})
+            await asyncio.sleep(int(in_))
+        if not TRIVIA_CHATS[chat]:
+            await event.respond(
+                "No-One Got Any Score in the Quiz!\nBetter Luck Next Time!"
+            )
+        else:
+            try:
+                await event.respond(file=choice(CONGO_STICKER))
+            except ChatSendStickersForbiddenError:
+                pass
+            LBD = "🎯 **Scoreboard of the Quiz.**\n\n"
+            TRC = TRIVIA_CHATS[chat]
+            if "cancel" in TRC.keys():
+                del TRC["cancel"]
+            for userid, user_score in dict(
+                sorted(TRC.items(), key=operator.itemgetter(1), reverse=True)
+            ).items():
+                user = inline_mention(await event.client.get_entity(userid))
+                LBD += f"••• {user} - {user_score}\n"
+            await event.respond(LBD)
+        del TRIVIA_CHATS[chat]
+        list_ = list(POLLS.copy().keys())
+        for key in list_:
+            if POLLS[key]["chat"] == chat:
+                del POLLS[key]
+        return
+    await event.edit(text, buttons=buttons)
+
+
+@asst.on(
+    Raw(UpdateMessagePollVote, func=lambda x: TRIVIA_CHATS and POLLS.get(x.poll_id))
+)
+async def pollish(eve: UpdateMessagePollVote):
+    if POLLS.get(eve.poll_id)["chat"] not in TRIVIA_CHATS.keys():
+        return
+    if not eve.options:
+        # Consider as correct answer if no options selected
+        chat = POLLS.get(eve.poll_id)["chat"]
+        user = eve.peer.user_id
+        if not TRIVIA_CHATS.get(chat, {}).get(user):
+            TRIVIA_CHATS[chat][user] = 1
+        else:
+            TRIVIA_CHATS[chat][user] += 1
+        return
+    if POLLS[eve.poll_id]["answer"] != eve.options[0]:
+        return
+    chat = POLLS.get(eve.poll_id)["chat"]
+    user = eve.peer.user_id
+    if not TRIVIA_CHATS.get(chat, {}).get(user):
+        TRIVIA_CHATS[chat][user] = 1
+    else:
+        TRIVIA_CHATS[chat][user] += 1
+
+
+@asst_cmd("cancel", owner=True, func=lambda x: TRIVIA_CHATS.get(x.chat_id))
+async def cancelish(event):
+    chat = TRIVIA_CHATS.get(event.chat_id)
+    chat.update({"cancel": True})
+    await event.respond("Cancelled!")

assistant/initial.py

@@ -0,0 +1,84 @@
+# 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 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,623 @@
+# 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 base64
+import inspect
+from datetime import datetime
+from html import unescape
+from random import choice
+from re import compile as re_compile
+
+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 pyUltroid.fns.misc import google_search
+from pyUltroid.fns.tools import (
+    _webupload_cache,
+    async_searcher,
+    get_ofox,
+    saavn_search,
+    webuploader,
+)
+
+from . import *
+from . import _ult_cache
+
+SUP_BUTTONS = [
+    [
+        Button.url("• Repo •", url="https://github.com/TeamUltroid/Ultroid"),
+        Button.url("• Support •", url="t.me/UltroidSupportChat"),
+    ],
+]
+
+ofox = "https://graph.org/file/231f0049fcd722824f13b.jpg"
+gugirl = "https://graph.org/file/0df54ae4541abca96aa11.jpg"
+ultpic = "https://graph.org/file/4136aa1650bc9d4109cc5.jpg"
+
+apis = [
+    "QUl6YVN5QXlEQnNZM1dSdEI1WVBDNmFCX3c4SkF5NlpkWE5jNkZV",
+    "QUl6YVN5QkYwenhMbFlsUE1wOXh3TVFxVktDUVJxOERnZHJMWHNn",
+    "QUl6YVN5RGRPS253blB3VklRX2xiSDVzWUU0Rm9YakFLSVFWMERR",
+]
+
+
+@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-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 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/manager/__init__.py

@@ -0,0 +1,11 @@
+# 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 pyUltroid._misc._decorators import ultroid_cmd
+from pyUltroid.fns.helper import inline_mention
+
+from .. import *

assistant/manager/_help.py

@@ -0,0 +1,134 @@
+# 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 . import *
+
+START = """
+🪅 **Help Menu** 🪅
+
+✘  /start : Check I am Alive or not.
+✘  /help : Get This Message.
+✘  /repo : Get Bot's Repo..
+
+🧑‍💻 Join **@TeamUltroid**
+"""
+
+ADMINTOOLS = """✘ **AdminTools** ✘
+
+• /pin : Pins the Replied Message
+• /pinned : Get Pinned message in chat.
+• /unpin : Unpin the Replied message
+• /unpin all : Unpin all Pinned Messages.
+
+• /ban (username/id/reply) : Ban the User
+• /unban (username/id/reply) : UnBan the User.
+
+• /mute (username/id/reply) : Mute the User.
+• /unmute (username/id/reply) : Unmute the User.
+
+• /tban (username/id/reply) (time) : Temporary ban a user
+• /tmute (username/id/reply) (time) : temporary Mutes a User.
+
+• /purge (purge messages)
+
+• /setgpic (reply photo) : keep Chat Photo of Group.
+• /delgpic : remove current chat Photo."""
+
+UTILITIES = """
+✘ ** Utilities ** ✘
+
+• /info (reply/username/id) : get detailed info of user.
+• /id : get chat/user id.
+• /tr : Translate Languages..
+• /q : Create Quotes.
+
+• /paste (reply file/text) : paste content on Spaceb.in
+• /meaning (text) : Get Meaning of that Word.
+• /google (query) : Search Something on Google..
+
+• /suggest (query/reply) : Creates a Yes / No Poll.
+"""
+
+LOCKS = """
+✘ ** Locks ** ✘
+
+• /lock (query) : lock particular content in chat.
+• /unlock (query) : Unlock some content.
+
+• All Queries
+- `msgs` : for messages.
+- `inlines` : for inline queries.
+- `media` : for all medias.
+- `games` : for games.
+- `sticker` : for stickers.
+- `polls` : for polls.
+- `gif` : for gifs.
+- `pin` : for pins.
+- `changeinfo` : for change info right.
+"""
+
+MISC = """
+✘  **Misc**  ✘
+
+• /joke : Get Random Jokes.
+• /decide : Decide Something..
+
+**✘ Stickertools ✘**
+• /kang : add sticker to your pack.
+• /listpack : get all of yours pack..
+"""
+
+STRINGS = {"Admintools": ADMINTOOLS, "locks": LOCKS, "Utils": UTILITIES, "Misc": MISC}
+
+MNGE = udB.get_key("MNGR_EMOJI") or "•"
+
+
+def get_buttons():
+    BTTS = []
+    keys = STRINGS.copy()
+    while keys:
+        BT = []
+        for i in list(keys)[:2]:
+            text = f"{MNGE} {i} {MNGE}"
+            BT.append(Button.inline(text, f"hlp_{i}"))
+            del keys[i]
+        BTTS.append(BT)
+    url = f"https://t.me/{asst.me.username}?startgroup=true"
+    BTTS.append([Button.url("Add me to Group", url)])
+    return BTTS
+
+
+@asst_cmd(pattern="help")
+async def helpish(event):
+    if not event.is_private:
+        url = f"https://t.me/{asst.me.username}?start=start"
+        return await event.reply(
+            "Contact me in PM for help!", buttons=Button.url("Click me for Help", url)
+        )
+    if str(event.sender_id) in owner_and_sudos() and (
+        udB.get_key("DUAL_MODE") and (udB.get_key("DUAL_HNDLR") == "/")
+    ):
+        return
+    await event.reply(START, buttons=get_buttons())
+
+
+@callback("mngbtn", owner=True)
+async def ehwhshd(e):
+    buttons = get_buttons()
+    buttons.append([Button.inline("<< Back", "open")])
+    await e.edit(buttons=buttons)
+
+
+@callback("mnghome")
+async def home_aja(e):
+    await e.edit(START, buttons=get_buttons())
+
+
+@callback(re.compile("hlp_(.*)"))
+async def do_something(event):
+    match = event.pattern_match.group(1).strip().decode("utf-8")
+    await event.edit(STRINGS[match], buttons=Button.inline("<< Back", "mnghome"))

assistant/manager/_on_adds.py

@@ -0,0 +1,23 @@
+# 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 telethon import events
+
+from . import *
+
+
+@asst.on(events.ChatAction(func=lambda x: x.user_added))
+async def dueha(e):
+    user = await e.get_user()
+    if not user.is_self:
+        return
+    sm = udB.get_key("ON_MNGR_ADD")
+    if sm == "OFF":
+        return
+    if not sm:
+        sm = "Thanks for Adding me :)"
+    await e.reply(sm, link_preview=False)

assistant/manager/admins.py

@@ -0,0 +1,50 @@
+# 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 re
+
+from telethon.errors.rpcerrorlist import UserNotParticipantError
+
+from pyUltroid import _ult_cache
+
+from . import *
+
+
+@ultroid_cmd(pattern="d(kick|ban)", manager=True, require="ban_users")
+async def dowj(e):
+    replied = await e.get_reply_message()
+    if replied:
+        user = replied.sender_id
+    else:
+        return await e.eor("Reply to a message...")
+    try:
+        await replied.delete()
+        if e.pattern_match.group(1).strip() == "kick":
+            await e.client.kick_participant(e.chat_id, user)
+            te = "Kicked"
+        else:
+            await e.client.edit_permissions(e.chat_id, user, view_messages=False)
+            te = "Banned"
+        await e.eor(f"{te} Successfully!")
+    except Exception as E:
+        await e.eor(str(E))
+
+
+@callback(re.compile("cc_(.*)"), func=_ult_cache.get("admin_callback"))
+async def callback_(event):
+    data = event.data_match.group(1).decode("utf-8")
+    if data not in _ult_cache.get("admin_callback", {}):
+        return
+    try:
+        perm = await event.client.get_permissions(event.chat_id, event.sender_id)
+    except UserNotParticipantError:
+        return await event.answer("Join the Group First!", alert=True)
+    if not perm.is_admin:
+        return await event.answer("You are not an Admin!", alert=True)
+    _ult_cache["admin_callback"].update({data: (event.sender, perm)})
+    await event.answer("Verification Done!")
+    await event.delete()

assistant/manager/afk.py

@@ -0,0 +1,110 @@
+# 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 as dt
+
+from telethon.events import NewMessage
+from telethon.tl.types import (
+    Message,
+    MessageEntityMention,
+    MessageEntityMentionName,
+    User,
+)
+from telethon.utils import get_display_name
+
+from pyUltroid.fns.helper import inline_mention, time_formatter
+
+from . import asst, asst_cmd
+
+AFK = {}
+
+
+@asst_cmd(pattern="afk", func=lambda x: not x.is_private)
+async def go_afk(event):
+    sender = await event.get_sender()
+    if (not isinstance(sender, User)) or sender.bot:
+        return
+    try:
+        reason = event.text.split(" ", maxsplit=1)[1]
+    except IndexError:
+        reason = None
+    if event.is_reply and not reason:
+        replied = await event.get_reply_message()
+        if not reason and replied.text and not replied.media:
+            reason = replied.text
+        else:
+            reason = replied
+    time_ = dt.now()
+    if AFK.get(event.chat_id):
+        AFK[event.chat_id].update({event.sender_id: {"reason": reason, "time": time_}})
+    else:
+        AFK.update(
+            {event.chat_id: {event.sender_id: {"reason": reason, "time": time_}}}
+        )
+    mention = inline_mention(sender)
+    msg = f"**{mention} went AFK Now!**"
+    if reason and not isinstance(reason, str):
+        await event.reply(reason)
+    else:
+        msg += f"\n\n**Reason : ** `{reason}`"
+    await event.reply(msg)
+
+
+@asst.on(NewMessage(func=lambda x: AFK.get(x.chat_id) and not x.is_private))
+async def make_change(event):
+    if event.text.startswith("/afk"):
+        return
+    sender = await event.get_sender()
+    if (not isinstance(sender, User)) or sender.bot:
+        return
+    chat_ = AFK[event.chat_id]
+    if event.sender_id in chat_.keys():
+        name = get_display_name(event.sender)
+        cha_send = chat_[event.sender_id]
+        time_ = time_formatter((dt.now() - cha_send["time"]).seconds * 1000)
+        msg = f"**{name}** is No Longer AFK!\n**Was AFK for** {time_}"
+        await event.reply(msg)
+        del chat_[event.sender_id]
+        if not chat_:
+            del AFK[event.chat_id]
+    ST_SPAM = []
+    replied = await event.get_reply_message()
+    if replied:
+        name = get_display_name(replied.sender)
+        if replied.sender_id in chat_.keys():
+            s_der = chat_[replied.sender_id]
+            res_ = s_der["reason"]
+            time_ = time_formatter((dt.now() - s_der["time"]).seconds * 1000)
+            msg = f"**{name}** is AFK Currently!\n**From :** {time_}"
+            if res_ and isinstance(res_, str):
+                msg += f"\n**Reason :** {res_}"
+            elif res_ and isinstance(res_, Message):
+                await event.reply(res_)
+            await event.reply(msg)
+        ST_SPAM.append(replied.sender_id)
+    for ent, text in event.get_entities_text():
+        dont_send, entity = None, None
+        if isinstance(ent, MessageEntityMentionName):
+            c_id = ent.user_id
+        elif isinstance(ent, MessageEntityMention):
+            c_id = text
+        else:
+            c_id = None
+        if c_id:
+            entity = await event.client.get_entity(c_id)
+        if entity and entity.id in chat_.keys() and entity.id not in ST_SPAM:
+            ST_SPAM.append(entity.id)
+            s_der = chat_[entity.id]
+            name = get_display_name(entity)
+            res_ = s_der["reason"]
+            time_ = time_formatter((dt.now() - s_der["time"]).seconds * 1000)
+            msg = f"**{name}** is AFK Currently!\n**From :** {time_}"
+            if res_ and isinstance(res_, str):
+                msg += f"\n**Reason :** {res_}"
+            elif res_ and isinstance(res_, Message):
+                await event.reply(res_)
+            await event.reply(msg)

assistant/manager/misc.py

@@ -0,0 +1,64 @@
+# 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 random
+
+import aiohttp
+
+from pyUltroid.dB import DEVLIST
+from pyUltroid.fns.admins import admin_check
+
+from . import *
+
+
+@asst_cmd(pattern="decide")
+async def dheh(e):
+    text = ["Yes", "NoU", "Maybe", "IDK"]
+    text = random.choice(text)
+    ri = e.reply_to_msg_id or e.id
+    await e.client.send_message(e.chat_id, text, reply_to=ri)
+
+
+@asst_cmd(pattern="echo( (.*)|$)")
+async def oqha(e):
+    if not await admin_check(e):
+        return
+    if match := e.pattern_match.group(1).strip():
+        text = match
+        reply_to = e
+    elif e.is_reply:
+        text = (await e.get_reply_message()).text
+        reply_to = e.reply_to_msg_id
+    else:
+        return await e.eor("What to Echo?", time=5)
+    try:
+        await e.delete()
+    except BaseException as ex:
+        LOGS.error(ex)
+    await e.client.send_message(e.chat_id, text, reply_to=reply_to)
+
+
+@asst_cmd(pattern="kickme$")
+async def doit(e):
+    if e.sender_id in DEVLIST:
+        return await eod(e, "`I will Not Kick You, my Developer..`")
+    try:
+        await e.client.kick_participant(e.chat_id, e.sender_id)
+    except Exception as Fe:
+        return await e.eor(str(Fe), time=5)
+    await e.eor("Yes, You are right, get out.", time=5)
+
+
+@asst_cmd(pattern="joke$")
+async def do_joke(e):
+    e = await e.get_reply_message() if e.is_reply else e
+    link = "https://v2.jokeapi.dev/joke/Any?blacklistFlags=nsfw,religious,political,racist,sexist,explicit&type=single"
+    async with aiohttp.ClientSession() as ses:
+        async with ses.get(link) as out:
+            out = await out.json()
+    await e.reply(out["joke"])

assistant/manager/stickermanager.py

@@ -0,0 +1,180 @@
+# 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 random
+
+from telethon import errors
+from telethon.errors.rpcerrorlist import StickersetInvalidError
+from telethon.tl.functions.messages import GetStickerSetRequest as GetSticker
+from telethon.tl.functions.messages import UploadMediaRequest
+from telethon.tl.functions.stickers import AddStickerToSetRequest as AddSticker
+from telethon.tl.functions.stickers import CreateStickerSetRequest
+from telethon.tl.types import InputPeerSelf
+from telethon.tl.types import InputStickerSetItem as SetItem
+from telethon.tl.types import InputStickerSetShortName, User
+from telethon.utils import get_display_name, get_input_document
+
+from pyUltroid.fns.misc import Quotly
+from pyUltroid.fns.tools import TgConverter
+
+from . import LOGS, asst, asst_cmd, udB
+
+
+@asst_cmd(
+    pattern="kang",
+)
+async def kang_cmd(ult):
+    sender = await ult.get_sender()
+    if not isinstance(sender, User):
+        return
+    if not ult.is_reply:
+        return await ult.eor("`Reply to a sticker/photo..`", time=5)
+    reply = await ult.get_reply_message()
+    if sender.username:
+        pre = sender.username[:4]
+    else:
+        pre = random.random_string(length=3)
+    animated, dl, video = None, None, None
+    try:
+        emoji = ult.text.split(maxsplit=1)[1]
+    except IndexError:
+        emoji = None
+    if reply.sticker:
+        file = get_input_document(reply.sticker)
+        emoji = emoji or reply.file.emoji
+        name = reply.file.name
+        if name.endswith(".tgs"):
+            animated = True
+            dl = await reply.download_media()
+        elif name.endswith(".webm"):
+            video = True
+            dl = await reply.download_media()
+    elif reply.photo:
+        dl = await reply.download_media()
+        name = "sticker.webp"
+        image = TgConverter.resize_photo_sticker(dl)
+        image.save(name, "WEBP")
+    elif reply.text:
+        dl = await Quotly().create_quotly(reply)
+    else:
+        return await ult.eor("`Reply to sticker or text to add it in your pack...`")
+    if not emoji:
+        emoji = "🏵"
+    if dl:
+        upl = await ult.client.upload_file(dl)
+        file = get_input_document(
+            await ult.client(UploadMediaRequest(InputPeerSelf(), upl))
+        )
+    get_ = udB.get_key("STICKERS") or {}
+    type_ = "anim" if animated else "static"
+    if not get_.get(ult.sender_id) or not get_.get(ult.sender_id, {}).get(type_):
+        sn = f"{pre}_{ult.sender_id}"
+        title = f"{get_display_name(sender)}'s Kang Pack"
+        if animated:
+            type_ = "anim"
+            sn += "_anim"
+            title += " (Animated)"
+        elif video:
+            type_ = "vid"
+            sn += "_vid"
+            title += " (Video)"
+        sn += f"_by_{asst.me.username}"
+        try:
+            await asst(GetSticker(InputStickerSetShortName(sn), hash=0))
+            sn = sn.replace(str(ult.sender_id), f"{ult.sender_id}_{ult.id}")
+        except StickersetInvalidError:
+            pass
+        try:
+            pack = await ult.client(
+                CreateStickerSetRequest(
+                    user_id=sender.id,
+                    title=title,
+                    short_name=sn,
+                    stickers=[SetItem(file, emoji=emoji)],
+                    videos=video,
+                    animated=animated,
+                    software="@TeamUltroid",
+                )
+            )
+        except Exception as er:
+            return await ult.eor(str(er))
+        sn = pack.set.short_name
+        if not get_.get(ult.sender_id):
+            get_.update({ult.sender_id: {type_: [sn]}})
+        else:
+            get_[ult.sender_id].update({type_: [sn]})
+        udB.set_key("STICKERS", get_)
+        return await ult.reply(
+            f"**Kanged Successfully!\nEmoji :** {emoji}\n**Link :** [Click Here](https://t.me/addstickers/{sn})"
+        )
+    name = get_[ult.sender_id][type_][-1]
+    try:
+        await asst(GetSticker(InputStickerSetShortName(name), hash=0))
+    except StickersetInvalidError:
+        get_[ult.sender_id][type_].remove(name)
+    try:
+        await asst(
+            AddSticker(InputStickerSetShortName(name), SetItem(file, emoji=emoji))
+        )
+    except (errors.StickerpackStickersTooMuchError, errors.StickersTooMuchError):
+        sn = f"{pre}{ult.sender_id}_{ult.id}"
+        title = f"{get_display_name(sender)}'s Kang Pack"
+        if animated:
+            sn += "_anim"
+            title += " (Animated)"
+        elif video:
+            sn += "_vid"
+            title += "(Video)"
+        sn += f"_by_{asst.me.username}"
+        try:
+            pack = await ult.client(
+                CreateStickerSetRequest(
+                    user_id=sender.id,
+                    title=title,
+                    short_name=sn,
+                    stickers=[SetItem(file, emoji=emoji)],
+                    animated=animated,
+                )
+            )
+        except Exception as er:
+            return await ult.eor(str(er))
+        get_[ult.sender_id][type_].append(pack.set.short_name)
+        udB.set_key("STICKERS", get_)
+        return await ult.reply(
+            f"**Created New Kang Pack!\nEmoji :** {emoji}\n**Link :** [Click Here](https://t.me/addstickers/{sn})"
+        )
+    except Exception as er:
+        LOGS.exception(er)
+        return await ult.reply(str(er))
+    await ult.reply(
+        f"Sticker Added to Pack Successfully\n**Link :** [Click Here](https://t.me/addstickers/{name})"
+    )
+
+
+@asst_cmd(pattern="listpack")
+async def do_magic(ult):
+    ko = udB.get_key("STICKERS") or {}
+    if not ko.get(ult.sender_id):
+        return await ult.reply("No Sticker Pack Found!")
+    al_ = []
+    ul = ko[ult.sender_id]
+    for _ in ul.keys():
+        al_.extend(ul[_])
+    msg = "• **Stickers Owned by You!**\n\n"
+    for _ in al_:
+        try:
+            pack = await ult.client(GetSticker(InputStickerSetShortName(_), hash=0))
+            msg += f"• [{pack.set.title}](https://t.me/addstickers/{_})\n"
+        except StickerSetInvalidError:
+            if ul.get("anim") and _ in ul["anim"]:
+                ul["anim"].remove(_)
+            elif ul.get("vid") and _ in ul["vid"]:
+                ul["vid"].remove(_)
+            else:
+                ul["static"].remove(_)
+            udB.set_key("STICKERS", ko)
+    await ult.reply(msg)

assistant/pmbot.py

@@ -0,0 +1,150 @@
+# 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/>.
+
+# 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 pyUltroid.dB.base import KeyManager
+from pyUltroid.dB.botchat_db import *
+from pyUltroid.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,240 @@
+# 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 pyUltroid._misc import SUDO_M, owner_and_sudos
+from pyUltroid.dB.base import KeyManager
+from pyUltroid.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")}
+
+**Ultroid [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.inline("Lᴀɴɢᴜᴀɢᴇ 🌐", data="lang"),
+        Button.inline("Sᴇᴛᴛɪɴɢs ⚙️", data="setter"),
+    ],
+    [
+        Button.inline("Sᴛᴀᴛs ✨", data="stat"),
+        Button.inline("Bʀᴏᴀᴅᴄᴀsᴛ 📻", data="bcast"),
+    ],
+    [Button.inline("TɪᴍᴇZᴏɴᴇ 🌎", data="tz")],
+]
+
+
+@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 **@TeamUltroid**"
+    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 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,
+            )
+
+
+@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 = """Ultroid 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 pyUltroid.fns.helper import (
+    bash,
+    fast_download,
+    humanbytes,
+    numerize,
+    time_formatter,
+)
+from pyUltroid.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_])

docker-compose.yml

@@ -0,0 +1,14 @@
+services:
+  worker:
+    build: .
+    environment:
+      REDIS_URI: $REDIS_URI
+      REDIS_PASSWORD: $REDIS_PASSWORD
+      SESSION: $SESSION
+      API_ID: $API_ID  # defaults to None
+      API_HASH: $API_HASH  # defaults to None
+      MONGO_URI: $MONGO_URI  # defaults to None
+      BOT_TOKEN: $BOT_TOKEN # Not mandatory
+      LOG_CHANNEL: $LOG_CHANNEL # Not mandatory
+      DATABASE_URL: $DATABASE_URL  # defaults to None
+      OKTETO_TOKEN: $OKTETO_TOKEN

installer.sh

@@ -0,0 +1,241 @@
+#!/usr/bin/env bash
+
+REPO="https://github.com/TeamUltroid/Ultroid.git"
+CURRENT_DIR="$(pwd)"
+ENV_FILE_PATH=".env"
+DIR="/root/TeamUltroid"
+
+while [ $# -gt 0 ]; do
+    case "$1" in
+    --dir=*)
+        DIR="${1#*=}" || DIR="/root/TeamUltroid"
+        ;;
+    --branch=*)
+        BRANCH="${1#*=}" || BRANCH="main"
+        ;;
+    --env-file=*)
+        ENV_FILE_PATH="${1#*=}" || ENV_FILE_PATH=".env"
+        ;;
+    --no-root)
+        NO_ROOT=true
+        ;;
+    *)
+        echo "Unknown parameter passed: $1"
+        exit 1
+        ;;
+    esac
+    shift
+done
+
+check_dependencies() {
+    # check if debian
+    echo "Checking dependencies..."
+    # read file with root access
+    if ! [[ $(ls -l "/etc/sudoers" | cut -d " " -f1) =~ "r" ]]; then
+        # check dependencies if installed
+        echo -e "Root access not found. Checking if dependencies are installed." >&2
+        if ! [ -x "$(command -v python3)" ] || ! [ -x "$(command -v python)" ]; then
+            echo -e "Python3 isn't installed. Please install python3.8 or higher to run this bot." >&2
+            exit 1
+        fi
+        if [ $(python3 -c "import sys; print(sys.version_info[1])") -lt 8 ] || [ $(python -c "import sys; print(sys.version_info[1])") -lt 8 ]; then
+            echo -e "Python 3.8 or higher is required to run this bot." >&2
+            exit 1
+        fi
+        # check if any of ffmpeg, mediainfo, neofetch, git is not installed
+        if ! command -v ffmpeg &>/dev/null || ! command -v mediainfo &>/dev/null || ! command -v neofetch &>/dev/null || ! command -v git &>/dev/null; then
+            echo -e "Some dependencies aren't installed. Please install ffmpeg, mediainfo, neofetch and git to run this bot." >&2
+            exit 1
+        fi
+    fi
+    if [ -x "$(command -v apt-get)" ]; then
+        echo -e "Installing dependencies..."
+        # check if any of ffmpeg, mediainfo, neofetch, git is not installed via dpkg
+        if dpkg -l | grep -q ffmpeg || dpkg -l | grep -q mediainfo || dpkg -l | grep -q neofetch || dpkg -l | grep -q git; then
+            sudo apt-get -qq -o=Dpkg::Use-Pty=0 update
+            sudo apt-get install -qq -o=Dpkg::Use-Pty=0 python3 python3-pip ffmpeg mediainfo neofetch git -y
+        fi
+    elif [ -x "$(command -v pacman)" ]; then
+        echo -e "Installing dependencies..."
+        if pacman -Q | grep -q ffmpeg || pacman -Q | grep -q mediainfo || pacman -Q | grep -q neofetch || pacman -Q | grep -q git; then
+            sudo pacman -Sy python python-pip git ffmpeg mediainfo neofetch --noconfirm
+        fi
+    else
+        echo -e "Unknown OS. Checking if dependecies are installed" >&2
+        if ! [ -x "$(command -v python3)" ] || ! [ -x "$(command -v python)" ]; then
+            echo -e "Python3 isn't installed. Please install python3.8 or higher to run this bot." >&2
+            exit 1
+        fi
+        if [ $(python3 -c "import sys; print(sys.version_info[1])") -lt 8 ] || [ $(python -c "import sys; print(sys.version_info[1])") -lt 8 ]; then
+            echo -e "Python 3.8 or higher is required to run this bot." >&2
+            exit 1
+        fi
+        if ! command -v ffmpeg &>/dev/null || ! command -v mediainfo &>/dev/null || ! command -v neofetch &>/dev/null || ! command -v git &>/dev/null; then
+            echo -e "Some dependencies aren't installed. Please install ffmpeg, mediainfo, neofetch and git to run this bot." >&2
+            exit 1
+        fi
+    fi
+}
+
+check_python() {
+    # check if python is installed
+    if ! command -v python3 &>/dev/null; then
+        echo -e "Python3 isn't installed. Please install python3.8 or higher to run this bot."
+        exit 1
+    elif ! command -v python &>/dev/null; then
+        echo -e "Python3 isn't installed. Please install python3.8 or higher to run this bot."
+        exit 1
+    fi
+    if [ $(python3 -c "import sys; print(sys.version_info[1])") -lt 8 ]; then
+        echo -e "Python 3.8 or higher is required to run this bot."
+        exit 1
+    elif [ $(python -c "import sys; print(sys.version_info[1])") -lt 3 ]; then
+        if [ $(python -c "import sys; print(sys.version_info[1])") -lt 8 ]; then
+            echo -e "Python 3.8 or higher is required to run this bot."
+            exit 1
+        fi
+    fi
+}
+
+clone_repo() {
+    # check if pyultroid, startup, plugins folders exist
+    cd $DIR
+    if [ -d $DIR ]; then
+        if [ -d $DIR/.git ]; then
+            echo -e "Updating Ultroid ${BRANCH}... "
+            cd $DIR
+            git pull
+            currentbranch="$(git rev-parse --abbrev-ref HEAD)"
+            if [ ! $BRANCH ]; then
+                export BRANCH=$currentbranch
+            fi
+            case $currentbranch in
+            $BRANCH)
+                # do nothing
+                ;;
+            *)
+                echo -e "Switching to branch ${BRANCH}... "
+                echo -e $currentbranch
+                git checkout $BRANCH
+                ;;
+            esac
+        else
+            rm -rf $DIR
+            exit 1
+        fi
+        if [ -d "addons" ]; then
+            cd addons
+            git pull
+        fi
+        return
+    else
+        if [ ! $BRANCH ]; then
+            export BRANCH="main"
+        fi
+        mkdir -p $DIR
+        echo -e "Cloning Ultroid ${BRANCH}... "
+        git clone -b $BRANCH $REPO $DIR
+    fi
+}
+
+install_requirements() {
+    pip3 install -q --upgrade pip
+    echo -e "\n\nInstalling requirements... "
+    pip3 install -q --no-cache-dir -r $DIR/requirements.txt
+    pip3 install -q -r $DIR/resources/startup/optional-requirements.txt
+}
+
+railways_dep() {
+    if [ $RAILWAY_STATIC_URL ]; then
+        echo -e "Installing YouTube dependency... "
+        pip3 install -q yt-dlp
+    fi
+}
+
+misc_install() {
+    if [ $SETUP_PLAYWRIGHT ]
+    then
+        echo -e "Installing playwright."
+        pip3 install playwright
+        playwright install
+    fi
+    if [ $OKTETO_TOKEN ]; then
+        echo -e "Installing Okteto-CLI... "
+        curl https://get.okteto.com -sSfL | sh
+    elif [ $VCBOT ]; then
+        if [ -d $DIR/vcbot ]; then
+            cd $DIR/vcbot
+            git pull
+        else
+            echo -e "Cloning VCBOT.."
+            git clone https://github.com/TeamUltroid/VcBot $DIR/vcbot
+        fi
+        pip3 install pytgcalls==3.0.0.dev23 && pip3 install av -q --no-binary av
+    fi
+}
+
+dep_install() {
+    echo -e "\n\nInstalling DB Requirement..."
+    if [ $MONGO_URI ]; then
+        echo -e "   Installing MongoDB Requirements..."
+        pip3 install -q pymongo[srv]
+    elif [ $DATABASE_URL ]; then
+        echo -e "   Installing PostgreSQL Requirements..."
+        pip3 install -q psycopg2-binary
+    elif [ $REDIS_URI ]; then
+        echo -e "   Installing Redis Requirements..."
+        pip3 install -q redis hiredis
+    fi
+}
+
+main() {
+    echo -e "Starting Ultroid Setup..."
+    if [ -d "pyUltroid" ] && [ -d "resources" ] && [ -d "plugins" ]; then
+        DIR=$CURRENT_DIR
+    fi
+    if [ -f $ENV_FILE_PATH ]
+    then
+        set -a
+        source <(cat $ENV_FILE_PATH | sed -e '/^#/d;/^\s*$/d' -e "s/'/'\\\''/g" -e "s/=\(.*\)/='\1'/g")
+        set +a
+        cp $ENV_FILE_PATH .env
+    fi
+    (check_dependencies)
+    (check_python)
+    (clone_repo)
+    (install_requirements)
+    (railways_dep)
+    (dep_install)
+    (misc_install)
+    echo -e "\n\nSetup Completed."
+}
+
+if [ $NO_ROOT ]; then
+    echo -e "Running with non root"
+    main
+    return 0
+elif [ -t 0 ]; then
+    unameOut="$(uname -s)"
+    case "${unameOut}" in
+        Linux*)     machine=Linux;;
+        Darwin*)    machine=Mac;;
+        CYGWIN*)    machine=Cygwin;;
+        MINGW*)     machine=MinGw;;
+        *)          machine="UNKNOWN:${unameOut}"
+    esac
+    if machine != "Linux"; then
+        echo -e "This script is only for Linux. Please use the Windows installer."
+        exit 1
+    fi
+    # check if sudo is installed
+    if ! command -v sudo &>/dev/null; then
+        echo -e "Sudo isn't installed. Please install sudo to run this bot."
+        exit 1
+    fi
+    sudo echo "Sudo permission granted."
+    main
+else
+    echo "Not an interactive terminal, skipping sudo."
+    # run main function
+    main
+fi

plugins/__init__.py

@@ -0,0 +1,105 @@
+# 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 asyncio
+import os
+import time
+from random import choice
+
+import requests
+from telethon import Button, events
+from telethon.tl import functions, types  # pylint:ignore
+
+from pyUltroid import *
+from pyUltroid._misc._assistant import asst_cmd, callback, in_pattern
+from pyUltroid._misc._decorators import ultroid_cmd
+from pyUltroid._misc._wrappers import eod, eor
+from pyUltroid.dB import DEVLIST, ULTROID_IMAGES
+from pyUltroid.fns.helper import *
+from pyUltroid.fns.misc import *
+from pyUltroid.fns.tools import *
+from pyUltroid.startup._database import _BaseDatabase as Database
+from pyUltroid.version import __version__, ultroid_version
+from strings import get_help, get_string
+from catbox import CatboxUploader
+
+udB: Database
+
+Redis = udB.get_key
+con = TgConverter
+quotly = Quotly()
+OWNER_NAME = ultroid_bot.full_name
+OWNER_ID = ultroid_bot.uid
+
+ultroid_bot: UltroidClient
+asst: UltroidClient
+
+LOG_CHANNEL = udB.get_key("LOG_CHANNEL")
+
+
+def inline_pic():
+    INLINE_PIC = udB.get_key("INLINE_PIC")
+    if INLINE_PIC is None:
+        INLINE_PIC = choice(ULTROID_IMAGES)
+    elif INLINE_PIC == False:
+        INLINE_PIC = None
+    return INLINE_PIC
+
+
+Telegraph = telegraph_client()
+cat_uploader = CatboxUploader()
+
+upload_file = cat_uploader.upload_file
+
+List = []
+Dict = {}
+InlinePlugin = {}
+N = 0
+cmd = ultroid_cmd
+STUFF = {}
+
+# Chats, which needs to be ignore for some cases
+# Considerably, there can be many
+# Feel Free to Add Any other...
+
+NOSPAM_CHAT = [
+    -1001361294038,  # UltroidSupportChat
+    -1001387666944,  # PyrogramChat
+    -1001109500936,  # TelethonChat
+    -1001050982793,  # Python
+    -1001256902287,  # DurovsChat
+    -1001473548283,  # SharingUserbot
+]
+
+KANGING_STR = [
+    "Using Witchery to kang this sticker...",
+    "Plagiarising hehe...",
+    "Inviting this sticker over to my pack...",
+    "Kanging this sticker...",
+    "Hey that's a nice sticker!\nMind if I kang?!..",
+    "Hehe me stel ur stiker...",
+    "Ay look over there (☉｡☉)!→\nWhile I kang this...",
+    "Roses are red violets are blue, kanging this sticker so my pack looks cool",
+    "Imprisoning this sticker...",
+    "Mr.Steal-Your-Sticker is stealing this sticker... ",
+]
+
+
+ATRA_COL = [
+    "DarkCyan",
+    "DeepSkyBlue",
+    "DarkTurquoise",
+    "Cyan",
+    "LightSkyBlue",
+    "Turquoise",
+    "MediumVioletRed",
+    "Aquamarine",
+    "Lightcyan",
+    "Azure",
+    "Moccasin",
+    "PowderBlue",
+]

plugins/_chatactions.py

@@ -0,0 +1,253 @@
+# 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 asyncio
+
+from telethon import events
+from telethon.errors.rpcerrorlist import UserNotParticipantError
+from telethon.tl.functions.channels import GetParticipantRequest
+from telethon.utils import get_display_name
+
+from pyUltroid.dB import stickers
+from pyUltroid.dB.echo_db import check_echo
+from pyUltroid.dB.forcesub_db import get_forcesetting
+from pyUltroid.dB.gban_mute_db import is_gbanned
+from pyUltroid.dB.greetings_db import get_goodbye, get_welcome, must_thank
+from pyUltroid.dB.nsfw_db import is_profan
+from pyUltroid.fns.helper import inline_mention
+from pyUltroid.fns.tools import async_searcher, create_tl_btn, get_chatbot_reply
+
+try:
+    from ProfanityDetector import detector
+except ImportError:
+    detector = None
+from . import LOG_CHANNEL, LOGS, asst, get_string, types, udB, ultroid_bot
+from ._inline import something
+
+
+@ultroid_bot.on(events.ChatAction())
+async def Function(event):
+    try:
+        await DummyHandler(event)
+    except Exception as er:
+        LOGS.exception(er)
+
+
+async def DummyHandler(ult):
+    # clean chat actions
+    key = udB.get_key("CLEANCHAT") or []
+    if ult.chat_id in key:
+        try:
+            await ult.delete()
+        except BaseException:
+            pass
+
+    # thank members
+    if must_thank(ult.chat_id):
+        chat_count = (await ult.client.get_participants(ult.chat_id, limit=0)).total
+        if chat_count % 100 == 0:
+            stik_id = chat_count / 100 - 1
+            sticker = stickers[stik_id]
+            await ult.respond(file=sticker)
+    # force subscribe
+    if (
+        udB.get_key("FORCESUB")
+        and ((ult.user_joined or ult.user_added))
+        and get_forcesetting(ult.chat_id)
+    ):
+        user = await ult.get_user()
+        if not user.bot:
+            joinchat = get_forcesetting(ult.chat_id)
+            try:
+                await ultroid_bot(GetParticipantRequest(int(joinchat), user.id))
+            except UserNotParticipantError:
+                await ultroid_bot.edit_permissions(
+                    ult.chat_id, user.id, send_messages=False
+                )
+                res = await ultroid_bot.inline_query(
+                    asst.me.username, f"fsub {user.id}_{joinchat}"
+                )
+                await res[0].click(ult.chat_id, reply_to=ult.action_message.id)
+
+    if ult.user_joined or ult.added_by:
+        user = await ult.get_user()
+        chat = await ult.get_chat()
+        # gbans and @UltroidBans checks
+        if udB.get_key("ULTROID_BANS"):
+            try:
+                is_banned = await async_searcher(
+                    "https://bans.ultroid.tech/api/status",
+                    json={"userId": user.id},
+                    post=True,
+                    re_json=True,
+                )
+                if is_banned["is_banned"]:
+                    await ult.client.edit_permissions(
+                        chat.id,
+                        user.id,
+                        view_messages=False,
+                    )
+                    await ult.respond(
+                        f'**@UltroidBans:** Banned user detected and banned!\n`{str(is_banned)}`.\nBan reason: {is_banned["reason"]}',
+                    )
+
+            except BaseException:
+                pass
+        reason = is_gbanned(user.id)
+        if reason and chat.admin_rights:
+            try:
+                await ult.client.edit_permissions(
+                    chat.id,
+                    user.id,
+                    view_messages=False,
+                )
+                gban_watch = get_string("can_1").format(inline_mention(user), reason)
+                await ult.reply(gban_watch)
+            except Exception as er:
+                LOGS.exception(er)
+
+        # greetings
+        elif get_welcome(ult.chat_id):
+            user = await ult.get_user()
+            chat = await ult.get_chat()
+            title = chat.title or "this chat"
+            count = (
+                chat.participants_count
+                or (await ult.client.get_participants(chat, limit=0)).total
+            )
+            mention = inline_mention(user)
+            name = user.first_name
+            fullname = get_display_name(user)
+            uu = user.username
+            username = f"@{uu}" if uu else mention
+            wel = get_welcome(ult.chat_id)
+            msgg = wel["welcome"]
+            med = wel["media"] or None
+            userid = user.id
+            msg = None
+            if msgg:
+                msg = msgg.format(
+                    mention=mention,
+                    group=title,
+                    count=count,
+                    name=name,
+                    fullname=fullname,
+                    username=username,
+                    userid=userid,
+                )
+            if wel.get("button"):
+                btn = create_tl_btn(wel["button"])
+                await something(ult, msg, med, btn)
+            elif msg:
+                send = await ult.reply(
+                    msg,
+                    file=med,
+                )
+                await asyncio.sleep(150)
+                await send.delete()
+            else:
+                await ult.reply(file=med)
+    elif (ult.user_left or ult.user_kicked) and get_goodbye(ult.chat_id):
+        user = await ult.get_user()
+        chat = await ult.get_chat()
+        title = chat.title or "this chat"
+        count = (
+            chat.participants_count
+            or (await ult.client.get_participants(chat, limit=0)).total
+        )
+        mention = inline_mention(user)
+        name = user.first_name
+        fullname = get_display_name(user)
+        uu = user.username
+        username = f"@{uu}" if uu else mention
+        wel = get_goodbye(ult.chat_id)
+        msgg = wel["goodbye"]
+        med = wel["media"]
+        userid = user.id
+        msg = None
+        if msgg:
+            msg = msgg.format(
+                mention=mention,
+                group=title,
+                count=count,
+                name=name,
+                fullname=fullname,
+                username=username,
+                userid=userid,
+            )
+        if wel.get("button"):
+            btn = create_tl_btn(wel["button"])
+            await something(ult, msg, med, btn)
+        elif msg:
+            send = await ult.reply(
+                msg,
+                file=med,
+            )
+            await asyncio.sleep(150)
+            await send.delete()
+        else:
+            await ult.reply(file=med)
+
+
+@ultroid_bot.on(events.NewMessage(incoming=True))
+async def chatBot_replies(e):
+    sender = await e.get_sender()
+    if not isinstance(sender, types.User) or sender.bot:
+        return
+    if check_echo(e.chat_id, e.sender_id):
+        try:
+            await e.respond(e.message)
+        except Exception as er:
+            LOGS.exception(er)
+    key = udB.get_key("CHATBOT_USERS") or {}
+    if e.text and key.get(e.chat_id) and sender.id in key[e.chat_id]:
+        msg = await get_chatbot_reply(e.message.message)
+        if msg:
+            sleep = udB.get_key("CHATBOT_SLEEP") or 1.5
+            await asyncio.sleep(sleep)
+            await e.reply(msg)
+    chat = await e.get_chat()
+    if e.is_group and sender.username:
+        await uname_stuff(e.sender_id, sender.username, sender.first_name)
+    elif e.is_private and chat.username:
+        await uname_stuff(e.sender_id, chat.username, chat.first_name)
+    if detector and is_profan(e.chat_id) and e.text:
+        x, y = detector(e.text)
+        if y:
+            await e.delete()
+
+
+@ultroid_bot.on(events.Raw(types.UpdateUserName))
+async def uname_change(e):
+    await uname_stuff(e.user_id, e.usernames[0] if e.usernames else None, e.first_name)
+
+
+async def uname_stuff(id, uname, name):
+    if udB.get_key("USERNAME_LOG"):
+        old_ = udB.get_key("USERNAME_DB") or {}
+        old = old_.get(id)
+        # Ignore Name Logs
+        if old and old == uname:
+            return
+        if old and uname:
+            await asst.send_message(
+                LOG_CHANNEL,
+                get_string("can_2").format(old, uname),
+            )
+        elif old:
+            await asst.send_message(
+                LOG_CHANNEL,
+                get_string("can_3").format(f"[{name}](tg://user?id={id})", old),
+            )
+        elif uname:
+            await asst.send_message(
+                LOG_CHANNEL,
+                get_string("can_4").format(f"[{name}](tg://user?id={id})", uname),
+            )
+
+        old_[id] = uname
+        udB.set_key("USERNAME_DB", old_)

plugins/_help.py

@@ -0,0 +1,136 @@
+# 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 telethon.errors.rpcerrorlist import (
+    BotInlineDisabledError,
+    BotMethodInvalidError,
+    BotResponseTimeoutError,
+)
+from telethon.tl.custom import Button
+
+from pyUltroid.dB._core import HELP, LIST
+from pyUltroid.fns.tools import cmd_regex_replace
+
+from . import HNDLR, LOGS, OWNER_NAME, asst, get_string, inline_pic, udB, ultroid_cmd
+
+_main_help_menu = [
+    [
+        Button.inline(get_string("help_4"), data="uh_Official_"),
+        Button.inline(get_string("help_5"), data="uh_Addons_"),
+    ],
+    [
+        Button.inline(get_string("help_6"), data="uh_VCBot_"),
+        Button.inline(get_string("help_7"), data="inlone"),
+    ],
+    [
+        Button.inline(get_string("help_8"), data="ownr"),
+        Button.url(
+            get_string("help_9"), url=f"https://t.me/{asst.me.username}?start=set"
+        ),
+    ],
+    [Button.inline(get_string("help_10"), data="close")],
+]
+
+
+@ultroid_cmd(pattern="help( (.*)|$)")
+async def _help(ult):
+    plug = ult.pattern_match.group(1).strip()
+    chat = await ult.get_chat()
+    if plug:
+        try:
+            if plug in HELP["Official"]:
+                output = f"**Plugin** - `{plug}`\n"
+                for i in HELP["Official"][plug]:
+                    output += i
+                output += "\n© @TeamUltroid"
+                await ult.eor(output)
+            elif HELP.get("Addons") and plug in HELP["Addons"]:
+                output = f"**Plugin** - `{plug}`\n"
+                for i in HELP["Addons"][plug]:
+                    output += i
+                output += "\n© @TeamUltroid"
+                await ult.eor(output)
+            elif HELP.get("VCBot") and plug in HELP["VCBot"]:
+                output = f"**Plugin** - `{plug}`\n"
+                for i in HELP["VCBot"][plug]:
+                    output += i
+                output += "\n© @TeamUltroid"
+                await ult.eor(output)
+            else:
+                try:
+                    x = get_string("help_11").format(plug)
+                    for d in LIST[plug]:
+                        x += HNDLR + d
+                        x += "\n"
+                    x += "\n© @TeamUltroid"
+                    await ult.eor(x)
+                except BaseException:
+                    file = None
+                    compare_strings = []
+                    for file_name in LIST:
+                        compare_strings.append(file_name)
+                        value = LIST[file_name]
+                        for j in value:
+                            j = cmd_regex_replace(j)
+                            compare_strings.append(j)
+                            if j.strip() == plug:
+                                file = file_name
+                                break
+                    if not file:
+                        # the enter command/plugin name is not found
+                        text = f"`{plug}` is not a valid plugin!"
+                        best_match = None
+                        for _ in compare_strings:
+                            if plug in _ and not _.startswith("_"):
+                                best_match = _
+                                break
+                        if best_match:
+                            text += f"\nDid you mean `{best_match}`?"
+                        return await ult.eor(text)
+                    output = f"**Command** `{plug}` **found in plugin** - `{file}`\n"
+                    if file in HELP["Official"]:
+                        for i in HELP["Official"][file]:
+                            output += i
+                    elif HELP.get("Addons") and file in HELP["Addons"]:
+                        for i in HELP["Addons"][file]:
+                            output += i
+                    elif HELP.get("VCBot") and file in HELP["VCBot"]:
+                        for i in HELP["VCBot"][file]:
+                            output += i
+                    output += "\n© @TeamUltroid"
+                    await ult.eor(output)
+        except BaseException as er:
+            LOGS.exception(er)
+            await ult.eor("Error 🤔 occured.")
+    else:
+        try:
+            results = await ult.client.inline_query(asst.me.username, "ultd")
+        except BotMethodInvalidError:
+            z = []
+            for x in LIST.values():
+                z.extend(x)
+            cmd = len(z) + 10
+            if udB.get_key("MANAGER") and udB.get_key("DUAL_HNDLR") == "/":
+                _main_help_menu[2:3] = [[Button.inline("• Manager Help •", "mngbtn")]]
+            return await ult.reply(
+                get_string("inline_4").format(
+                    OWNER_NAME,
+                    len(HELP["Official"]),
+                    len(HELP["Addons"] if "Addons" in HELP else []),
+                    cmd,
+                ),
+                file=inline_pic(),
+                buttons=_main_help_menu,
+            )
+        except BotResponseTimeoutError:
+            return await ult.eor(
+                get_string("help_2").format(HNDLR),
+            )
+        except BotInlineDisabledError:
+            return await ult.eor(get_string("help_3"))
+        await results[0].click(chat.id, reply_to=ult.reply_to_msg_id, hide_via=True)
+        await ult.delete()

plugins/_inline.py

@@ -0,0 +1,455 @@
+# 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 re
+import time
+from datetime import datetime
+from os import remove
+
+from git import Repo
+from telethon import Button
+from telethon.tl.types import InputWebDocument, Message
+from telethon.utils import resolve_bot_file_id
+
+from pyUltroid._misc._assistant import callback, in_pattern
+from pyUltroid.dB._core import HELP, LIST
+from pyUltroid.fns.helper import gen_chlog, time_formatter, updater
+from pyUltroid.fns.misc import split_list
+
+from . import (
+    HNDLR,
+    LOGS,
+    OWNER_NAME,
+    InlinePlugin,
+    asst,
+    get_string,
+    inline_pic,
+    split_list,
+    start_time,
+    udB,
+)
+from ._help import _main_help_menu
+
+# ================================================#
+
+helps = get_string("inline_1")
+
+add_ons = udB.get_key("ADDONS")
+
+zhelps = get_string("inline_3") if add_ons is False else get_string("inline_2")
+PLUGINS = HELP.get("Official", [])
+ADDONS = HELP.get("Addons", [])
+upage = 0
+# ============================================#
+
+# --------------------BUTTONS--------------------#
+
+SUP_BUTTONS = [
+    [
+        Button.url("• Repo •", url="https://github.com/TeamUltroid/Ultroid"),
+        Button.url("• Support •", url="t.me/UltroidSupportChat"),
+    ],
+]
+
+# --------------------BUTTONS--------------------#
+
+
+@in_pattern(owner=True, func=lambda x: not x.text)
+async def inline_alive(o):
+    TLINK = inline_pic() or "https://graph.org/file/74d6259983e0642923fdb.jpg"
+    MSG = "• **Ultroid Userbot •**"
+    WEB0 = InputWebDocument(
+        "https://graph.org/file/acd4f5d61369f74c5e7a7.jpg", 0, "image/jpg", []
+    )
+    RES = [
+        await o.builder.article(
+            type="photo",
+            text=MSG,
+            include_media=True,
+            buttons=SUP_BUTTONS,
+            title="Ultroid Userbot",
+            description="Userbot | Telethon",
+            url=TLINK,
+            thumb=WEB0,
+            content=InputWebDocument(TLINK, 0, "image/jpg", []),
+        )
+    ]
+    await o.answer(
+        RES,
+        private=True,
+        cache_time=300,
+        switch_pm="👥 ULTROID PORTAL",
+        switch_pm_param="start",
+    )
+
+
+@in_pattern("ultd", owner=True)
+async def inline_handler(event):
+    z = []
+    for x in LIST.values():
+        z.extend(x)
+    text = get_string("inline_4").format(
+        OWNER_NAME,
+        len(HELP.get("Official", [])),
+        len(HELP.get("Addons", [])),
+        len(z),
+    )
+    if inline_pic():
+        result = await event.builder.photo(
+            file=inline_pic(),
+            link_preview=False,
+            text=text,
+            buttons=_main_help_menu,
+        )
+    else:
+        result = await event.builder.article(
+            title="Ultroid Help Menu", text=text, buttons=_main_help_menu
+        )
+    await event.answer([result], private=True, cache_time=300, gallery=True)
+
+
+@in_pattern("pasta", owner=True)
+async def _(event):
+    ok = event.text.split("-")[1]
+    if not ok.startswith("http"):
+        link = f"https://spaceb.in/{ok}"
+        raw = f"https://spaceb.in/api/v1/documents/{ok}/raw"
+    else:
+        link = ok
+        raw = f"{ok}/raw"
+    result = await event.builder.article(
+        title="Paste",
+        text="Pasted to Spacebin 🌌",
+        buttons=[
+            [
+                Button.url("SpaceBin", url=link),
+                Button.url("Raw", url=raw),
+            ],
+        ],
+    )
+    await event.answer([result])
+
+
+@callback("ownr", owner=True)
+async def setting(event):
+    z = []
+    for x in LIST.values():
+        z.extend(x)
+    await event.edit(
+        get_string("inline_4").format(
+            OWNER_NAME,
+            len(HELP.get("Official", [])),
+            len(HELP.get("Addons", [])),
+            len(z),
+        ),
+        file=inline_pic(),
+        link_preview=False,
+        buttons=[
+            [
+                Button.inline("•Pɪɴɢ•", data="pkng"),
+                Button.inline("•Uᴘᴛɪᴍᴇ•", data="upp"),
+            ],
+            [
+                Button.inline("•Stats•", data="alive"),
+                Button.inline("•Uᴘᴅᴀᴛᴇ•", data="doupdate"),
+            ],
+            [Button.inline("« Bᴀᴄᴋ", data="open")],
+        ],
+    )
+
+
+_strings = {"Official": helps, "Addons": zhelps, "VCBot": get_string("inline_6")}
+
+
+@callback(re.compile("uh_(.*)"), owner=True)
+async def help_func(ult):
+    key, count = ult.data_match.group(1).decode("utf-8").split("_")
+    if key == "VCBot" and HELP.get("VCBot") is None:
+        return await ult.answer(get_string("help_12"), alert=True)
+    elif key == "Addons" and HELP.get("Addons") is None:
+        return await ult.answer(get_string("help_13").format(HNDLR), alert=True)
+    if "|" in count:
+        _, count = count.split("|")
+    count = int(count) if count else 0
+    text = _strings.get(key, "").format(OWNER_NAME, len(HELP.get(key)))
+    await ult.edit(text, buttons=page_num(count, key), link_preview=False)
+
+
+@callback(re.compile("uplugin_(.*)"), owner=True)
+async def uptd_plugin(event):
+    key, file = event.data_match.group(1).decode("utf-8").split("_")
+    index = None
+    if "|" in file:
+        file, index = file.split("|")
+    key_ = HELP.get(key, [])
+    hel_p = f"Plugin Name - `{file}`\n"
+    help_ = ""
+    try:
+        for i in key_[file]:
+            help_ += i
+    except BaseException:
+        if file in LIST:
+            help_ = get_string("help_11").format(file)
+            for d in LIST[file]:
+                help_ += HNDLR + d
+                help_ += "\n"
+    if not help_:
+        help_ = f"{file} has no Detailed Help!"
+    help_ += "\n© @TeamUltroid"
+    buttons = []
+    if inline_pic():
+        data = f"sndplug_{key}_{file}"
+        if index is not None:
+            data += f"|{index}"
+        buttons.append(
+            [
+                Button.inline(
+                    "« Sᴇɴᴅ Pʟᴜɢɪɴ »",
+                    data=data,
+                )
+            ]
+        )
+    data = f"uh_{key}_"
+    if index is not None:
+        data += f"|{index}"
+    buttons.append(
+        [
+            Button.inline("« Bᴀᴄᴋ", data=data),
+        ]
+    )
+    try:
+        await event.edit(help_, buttons=buttons)
+    except Exception as er:
+        LOGS.exception(er)
+        help = f"Do `{HNDLR}help {key}` to get list of commands."
+        await event.edit(help, buttons=buttons)
+
+
+@callback(data="doupdate", owner=True)
+async def _(event):
+    if not await updater():
+        return await event.answer(get_string("inline_9"), cache_time=0, alert=True)
+    if not inline_pic():
+        return await event.answer(f"Do '{HNDLR}update' to update..")
+    repo = Repo.init()
+    changelog, tl_chnglog = await gen_chlog(
+        repo, f"HEAD..upstream/{repo.active_branch}"
+    )
+    changelog_str = changelog + "\n\n" + get_string("inline_8")
+    if len(changelog_str) > 1024:
+        await event.edit(get_string("upd_4"))
+        with open("ultroid_updates.txt", "w+") as file:
+            file.write(tl_chnglog)
+        await event.edit(
+            get_string("upd_5"),
+            file="ultroid_updates.txt",
+            buttons=[
+                [Button.inline("• Uᴘᴅᴀᴛᴇ Nᴏᴡ •", data="updatenow")],
+                [Button.inline("« Bᴀᴄᴋ", data="ownr")],
+            ],
+        )
+        remove("ultroid_updates.txt")
+    else:
+        await event.edit(
+            changelog_str,
+            buttons=[
+                [Button.inline("Update Now", data="updatenow")],
+                [Button.inline("« Bᴀᴄᴋ", data="ownr")],
+            ],
+            parse_mode="html",
+        )
+
+
+@callback(data="pkng", owner=True)
+async def _(event):
+    start = datetime.now()
+    end = datetime.now()
+    ms = (end - start).microseconds
+    pin = f"🌋Pɪɴɢ = {ms} microseconds"
+    await event.answer(pin, cache_time=0, alert=True)
+
+
+@callback(data="upp", owner=True)
+async def _(event):
+    uptime = time_formatter((time.time() - start_time) * 1000)
+    pin = f"🙋Uᴘᴛɪᴍᴇ = {uptime}"
+    await event.answer(pin, cache_time=0, alert=True)
+
+
+@callback(data="inlone", owner=True)
+async def _(e):
+    _InButtons = [
+        Button.switch_inline(_, query=InlinePlugin[_], same_peer=True)
+        for _ in list(InlinePlugin.keys())
+    ]
+    InButtons = split_list(_InButtons, 2)
+
+    button = InButtons.copy()
+    button.append(
+        [
+            Button.inline("« Bᴀᴄᴋ", data="open"),
+        ],
+    )
+    await e.edit(buttons=button, link_preview=False)
+
+
+@callback(data="open", owner=True)
+async def opner(event):
+    z = []
+    for x in LIST.values():
+        z.extend(x)
+    await event.edit(
+        get_string("inline_4").format(
+            OWNER_NAME,
+            len(HELP.get("Official", [])),
+            len(HELP.get("Addons", [])),
+            len(z),
+        ),
+        buttons=_main_help_menu,
+        link_preview=False,
+    )
+
+
+@callback(data="close", owner=True)
+async def on_plug_in_callback_query_handler(event):
+    await event.edit(
+        get_string("inline_5"),
+        buttons=Button.inline("Oᴘᴇɴ Aɢᴀɪɴ", data="open"),
+    )
+
+
+def page_num(index, key):
+    rows = udB.get_key("HELP_ROWS") or 5
+    cols = udB.get_key("HELP_COLUMNS") or 2
+    loaded = HELP.get(key, [])
+    emoji = udB.get_key("EMOJI_IN_HELP") or "✘"
+    List = [
+        Button.inline(f"{emoji} {x} {emoji}", data=f"uplugin_{key}_{x}|{index}")
+        for x in sorted(loaded)
+    ]
+    all_ = split_list(List, cols)
+    fl_ = split_list(all_, rows)
+    try:
+        new_ = fl_[index]
+    except IndexError:
+        new_ = fl_[0] if fl_ else []
+        index = 0
+    if index == 0 and len(fl_) == 1:
+        new_.append([Button.inline("« Bᴀᴄᴋ »", data="open")])
+    else:
+        new_.append(
+            [
+                Button.inline(
+                    "« Pʀᴇᴠɪᴏᴜs",
+                    data=f"uh_{key}_{index-1}",
+                ),
+                Button.inline("« Bᴀᴄᴋ »", data="open"),
+                Button.inline(
+                    "Nᴇxᴛ »",
+                    data=f"uh_{key}_{index+1}",
+                ),
+            ]
+        )
+    return new_
+
+
+# --------------------------------------------------------------------------------- #
+
+
+STUFF = {}
+
+
+@in_pattern("stf(.*)", owner=True)
+async def ibuild(e):
+    n = e.pattern_match.group(1).strip()
+    builder = e.builder
+    if not (n and n.isdigit()):
+        return
+    ok = STUFF.get(int(n))
+    txt = ok.get("msg")
+    pic = ok.get("media")
+    btn = ok.get("button")
+    if not (pic or txt):
+        txt = "Hey!"
+    if pic:
+        try:
+            include_media = True
+            mime_type, _pic = None, None
+            cont, results = None, None
+            try:
+                ext = str(pic).split(".")[-1].lower()
+            except BaseException:
+                ext = None
+            if ext in ["img", "jpg", "png"]:
+                _type = "photo"
+                mime_type = "image/jpg"
+            elif ext in ["mp4", "mkv", "gif"]:
+                mime_type = "video/mp4"
+                _type = "gif"
+            else:
+                try:
+                    if "telethon.tl.types" in str(type(pic)):
+                        _pic = pic
+                    else:
+                        _pic = resolve_bot_file_id(pic)
+                except BaseException:
+                    pass
+                if _pic:
+                    results = [
+                        await builder.document(
+                            _pic,
+                            title="Ultroid Op",
+                            text=txt,
+                            description="@TeamUltroid",
+                            buttons=btn,
+                            link_preview=False,
+                        )
+                    ]
+                else:
+                    _type = "article"
+                    include_media = False
+            if not results:
+                if include_media:
+                    cont = InputWebDocument(pic, 0, mime_type, [])
+                results = [
+                    await builder.article(
+                        title="Ultroid Op",
+                        type=_type,
+                        text=txt,
+                        description="@TeamUltroid",
+                        include_media=include_media,
+                        buttons=btn,
+                        thumb=cont,
+                        content=cont,
+                        link_preview=False,
+                    )
+                ]
+            return await e.answer(results)
+        except Exception as er:
+            LOGS.exception(er)
+    result = [
+        await builder.article("Ultroid Op", text=txt, link_preview=False, buttons=btn)
+    ]
+    await e.answer(result)
+
+
+async def something(e, msg, media, button, reply=True, chat=None):
+    if e.client._bot:
+        return await e.reply(msg, file=media, buttons=button)
+    num = len(STUFF) + 1
+    STUFF.update({num: {"msg": msg, "media": media, "button": button}})
+    try:
+        res = await e.client.inline_query(asst.me.username, f"stf{num}")
+        return await res[0].click(
+            chat or e.chat_id,
+            reply_to=bool(isinstance(e, Message) and reply),
+            hide_via=True,
+            silent=True,
+        )
+
+    except Exception as er:
+        LOGS.exception(er)

plugins/_ultroid.py

@@ -0,0 +1,66 @@
+# 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 telethon.errors import (
+    BotMethodInvalidError,
+    ChatSendInlineForbiddenError,
+    ChatSendMediaForbiddenError,
+)
+
+from . import LOG_CHANNEL, LOGS, Button, asst, eor, get_string, ultroid_cmd
+
+REPOMSG = """
+• **ULTROID USERBOT** •\n
+• Repo - [Click Here](https://github.com/TeamUltroid/Ultroid)
+• Addons - [Click Here](https://github.com/TeamUltroid/UltroidAddons)
+• Support - @UltroidSupportChat
+"""
+
+RP_BUTTONS = [
+    [
+        Button.url(get_string("bot_3"), "https://github.com/TeamUltroid/Ultroid"),
+        Button.url("Addons", "https://github.com/TeamUltroid/UltroidAddons"),
+    ],
+    [Button.url("Support Group", "t.me/UltroidSupportChat")],
+]
+
+ULTSTRING = """🎇 **Thanks for Deploying Ultroid Userbot!**
+
+• Here, are the Some Basic stuff from, where you can Know, about its Usage."""
+
+
+@ultroid_cmd(
+    pattern="repo$",
+    manager=True,
+)
+async def repify(e):
+    try:
+        q = await e.client.inline_query(asst.me.username, "")
+        await q[0].click(e.chat_id)
+        return await e.delete()
+    except (
+        ChatSendInlineForbiddenError,
+        ChatSendMediaForbiddenError,
+        BotMethodInvalidError,
+    ):
+        pass
+    except Exception as er:
+        LOGS.info(f"Error while repo command : {str(er)}")
+    await e.eor(REPOMSG)
+
+
+@ultroid_cmd(pattern="ultroid$")
+async def useUltroid(rs):
+    button = Button.inline("Start >>", "initft_2")
+    msg = await asst.send_message(
+        LOG_CHANNEL,
+        ULTSTRING,
+        file="https://graph.org/file/54a917cc9dbb94733ea5f.jpg",
+        buttons=button,
+    )
+    if not (rs.chat_id == LOG_CHANNEL and rs.client._bot):
+        await eor(rs, f"**[Click Here]({msg.message_link})**")

plugins/_userlogs.py

@@ -0,0 +1,299 @@
+# 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
+
+from telethon.errors.rpcerrorlist import (
+    ChannelPrivateError,
+    ChatWriteForbiddenError,
+    MediaCaptionTooLongError,
+    MediaEmptyError,
+    MessageTooLongError,
+    PeerIdInvalidError,
+    UserNotParticipantError,
+)
+from telethon.tl.types import MessageEntityMention, MessageEntityMentionName, User
+from telethon.utils import get_display_name
+
+from pyUltroid.dB.botchat_db import tag_add, who_tag
+
+from . import (
+    LOG_CHANNEL,
+    LOGS,
+    Button,
+    asst,
+    callback,
+    events,
+    get_string,
+    inline_mention,
+    udB,
+    ultroid_bot,
+)
+
+CACHE_SPAM = {}
+TAG_EDITS = {}
+
+
+@ultroid_bot.on(
+    events.NewMessage(
+        incoming=True,
+        func=lambda e: (e.mentioned),
+    ),
+)
+async def all_messages_catcher(e):
+    x = await e.get_sender()
+    if isinstance(x, User) and (x.bot or x.verified):
+        return
+    if not udB.get_key("TAG_LOG"):
+        return
+    NEEDTOLOG = udB.get_key("TAG_LOG")
+    if e.chat_id == NEEDTOLOG:
+        return
+    buttons = await parse_buttons(e)
+    try:
+        sent = await asst.send_message(NEEDTOLOG, e.message, buttons=buttons)
+        if TAG_EDITS.get(e.chat_id):
+            TAG_EDITS[e.chat_id].update({e.id: {"id": sent.id, "msg": e}})
+        else:
+            TAG_EDITS.update({e.chat_id: {e.id: {"id": sent.id, "msg": e}}})
+        tag_add(sent.id, e.chat_id, e.id)
+    except MediaEmptyError as er:
+        LOGS.debug(f"handling {er}.")
+        try:
+            msg = await asst.get_messages(e.chat_id, ids=e.id)
+            sent = await asst.send_message(NEEDTOLOG, msg, buttons=buttons)
+            if TAG_EDITS.get(e.chat_id):
+                TAG_EDITS[e.chat_id].update({e.id: {"id": sent.id, "msg": e}})
+            else:
+                TAG_EDITS.update({e.chat_id: {e.id: {"id": sent.id, "msg": e}}})
+            tag_add(sent.id, e.chat_id, e.id)
+        except Exception as me:
+            if not isinstance(me, (PeerIdInvalidError, ValueError)):
+                LOGS.exception(me)
+            if e.photo or e.sticker or e.gif:
+                try:
+                    media = await e.download_media()
+                    sent = await asst.send_message(
+                        NEEDTOLOG, e.message.text, file=media, buttons=buttons
+                    )
+                    if TAG_EDITS.get(e.chat_id):
+                        TAG_EDITS[e.chat_id].update({e.id: {"id": sent.id, "msg": e}})
+                    else:
+                        TAG_EDITS.update({e.chat_id: {e.id: {"id": sent.id, "msg": e}}})
+                    return os.remove(media)
+                except Exception as er:
+                    LOGS.exception(er)
+            await asst.send_message(NEEDTOLOG, get_string("com_4"), buttons=buttons)
+    except (PeerIdInvalidError, ValueError) as er:
+        LOGS.exception(er)
+        try:
+            CACHE_SPAM[NEEDTOLOG]
+        except KeyError:
+            await asst.send_message(
+                udB.get_key("LOG_CHANNEL"), get_string("userlogs_1")
+            )
+            CACHE_SPAM.update({NEEDTOLOG: True})
+    except ChatWriteForbiddenError:
+        try:
+            await asst.get_permissions(NEEDTOLOG, "me")
+            MSG = get_string("userlogs_4")
+        except UserNotParticipantError:
+            MSG = get_string("userlogs_2")
+        try:
+            CACHE_SPAM[NEEDTOLOG]
+        except KeyError:
+            await asst.send_message(LOG_CHANNEL, MSG)
+            CACHE_SPAM.update({NEEDTOLOG: True})
+    except Exception as er:
+        LOGS.exception(er)
+
+
+if udB.get_key("TAG_LOG"):
+
+    @ultroid_bot.on(events.MessageEdited(func=lambda x: not x.out))
+    async def upd_edits(event):
+        x = event.sender
+        if isinstance(x, User) and (x.bot or x.verified):
+            return
+        if event.chat_id not in TAG_EDITS:
+            if event.sender_id == udB.get_key("TAG_LOG"):
+                return
+            if event.is_private:
+                return
+            if entities := event.get_entities_text():
+                is_self = False
+                username = event.client.me.username
+                if username:
+                    username = username.lower()
+                for ent, text in entities:
+                    if isinstance(ent, MessageEntityMention):
+                        is_self = text[1:].lower() == username
+                    elif isinstance(ent, MessageEntityMentionName):
+                        is_self = ent.user_id == event.client.me.id
+                if is_self:
+                    text = f"**#Edited & #Mentioned**\n\n{event.text}"
+                    try:
+                        sent = await asst.send_message(
+                            udB.get_key("TAG_LOG"),
+                            text,
+                            buttons=await parse_buttons(event),
+                        )
+                    except Exception as er:
+                        return LOGS.exception(er)
+                    if TAG_EDITS.get(event.chat_id):
+                        TAG_EDITS[event.chat_id].update({event.id: {"id": sent.id}})
+                    else:
+                        TAG_EDITS.update({event.chat_id: {event.id: {"id": sent.id}}})
+            return
+        d_ = TAG_EDITS[event.chat_id]
+        if not d_.get(event.id):
+            return
+        d_ = d_[event.id]
+        if d_["msg"].text == event.text:
+            return
+        msg = None
+        if d_.get("count"):
+            d_["count"] += 1
+        else:
+            msg = True
+            d_.update({"count": 1})
+        if d_["count"] > 10:
+            return  # some limit to take edits
+        try:
+            MSG = await asst.get_messages(udB.get_key("TAG_LOG"), ids=d_["id"])
+        except Exception as er:
+            return LOGS.exception(er)
+        TEXT = MSG.text
+        if msg:
+            TEXT += "\n\n🖋 **Later Edited to !**"
+        strf = event.edit_date.strftime("%H:%M:%S")
+        if "\n" not in event.text:
+            TEXT += f"\n• `{strf}` : {event.text}"
+        else:
+            TEXT += f"\n• `{strf}` :\n-> {event.text}"
+        if d_["count"] == 10:
+            TEXT += "\n\n• __Only the first 10 Edits are shown.__"
+        try:
+            msg = await MSG.edit(TEXT, buttons=await parse_buttons(event))
+            d_["msg"] = msg
+        except (MessageTooLongError, MediaCaptionTooLongError):
+            del TAG_EDITS[event.chat_id][event.id]
+        except Exception as er:
+            LOGS.exception(er)
+
+    @ultroid_bot.on(
+        events.NewMessage(
+            outgoing=True,
+            chats=[udB.get_key("TAG_LOG")],
+            func=lambda e: e.reply_to,
+        )
+    )
+    async def idk(e):
+        id = e.reply_to_msg_id
+        chat, msg = who_tag(id)
+        if chat and msg:
+            try:
+                await ultroid_bot.send_message(chat, e.message, reply_to=msg)
+            except BaseException as er:
+                LOGS.exception(er)
+
+
+# log for assistant/user joins/add
+
+
+async def when_added_or_joined(event):
+    user = await event.get_user()
+    chat = await event.get_chat()
+    if not (user and user.is_self):
+        return
+    if getattr(chat, "username", None):
+        chat = f"[{chat.title}](https://t.me/{chat.username}/{event.action_message.id})"
+    else:
+        chat = f"[{chat.title}](https://t.me/c/{chat.id}/{event.action_message.id})"
+    key = "bot" if event.client._bot else "user"
+    buttons = Button.inline(
+        get_string("userlogs_3"), data=f"leave_ch_{event.chat_id}|{key}"
+    )
+    if event.user_added:
+        tmp = event.added_by
+        text = f"#ADD_LOG\n\n{inline_mention(tmp)} just added {inline_mention(user)} to {chat}."
+    elif event.from_request:
+        text = f"#APPROVAL_LOG\n\n{inline_mention(user)} just got Chat Join Approval to {chat}."
+    else:
+        text = f"#JOIN_LOG\n\n{inline_mention(user)} just joined {chat}."
+    await asst.send_message(udB.get_key("LOG_CHANNEL"), text, buttons=buttons)
+
+
+asst.add_event_handler(
+    when_added_or_joined, events.ChatAction(func=lambda x: x.user_added)
+)
+ultroid_bot.add_event_handler(
+    when_added_or_joined,
+    events.ChatAction(func=lambda x: x.user_added or x.user_joined),
+)
+_client = {"bot": asst, "user": ultroid_bot}
+
+
+@callback(
+    re.compile(
+        "leave_ch_(.*)",
+    ),
+    from_users=[ultroid_bot.uid],
+)
+async def leave_ch_at(event):
+    cht = event.data_match.group(1).decode("UTF-8")
+    ch_id, client = cht.split("|")
+    try:
+        client = _client[client]
+    except KeyError:
+        return
+    try:
+        name = (await client.get_entity(int(ch_id))).title
+        await client.delete_dialog(int(ch_id))
+    except UserNotParticipantError:
+        pass
+    except ChannelPrivateError:
+        return await event.edit(
+            "`[CANT_ACCESS_CHAT]` `Maybe already left or got banned.`"
+        )
+    except Exception as er:
+        LOGS.exception(er)
+        return await event.answer(str(er))
+    await event.edit(get_string("userlogs_5").format(name))
+
+
+@callback("do_nothing")
+async def _(event):
+    await event.answer()
+
+
+async def parse_buttons(event):
+    y, x = event.chat, event.sender
+    where_n, who_n = get_display_name(y), get_display_name(x)
+    where_l = event.message_link
+    buttons = [[Button.url(where_n, where_l)]]
+    if isinstance(x, User) and x.username:
+        try:
+            buttons.append(
+                [Button.mention(who_n, await asst.get_input_entity(x.username))]
+            )
+        except Exception as er:
+            LOGS.exception(er)
+            buttons.append([Button.url(who_n, f"t.me/{x.username}")])
+    elif getattr(x, "username"):
+        buttons.append([Button.url(who_n, f"t.me/{x.username}")])
+    else:
+        buttons.append([Button.url(who_n, where_l)])
+    replied = await event.get_reply_message()
+    if replied and replied.out:
+        button = Button.url("Replied to", replied.message_link)
+        if len(who_n) > 7:
+            buttons.append([button])
+        else:
+            buttons[-1].append(button)
+    return buttons

plugins/_wspr.py

@@ -0,0 +1,204 @@
+# 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 re
+
+from telethon import Button
+from telethon.errors.rpcerrorlist import (
+    BotInlineDisabledError,
+    BotResponseTimeoutError,
+    MessageNotModifiedError,
+)
+from telethon.tl import types
+from telethon.tl.functions.users import GetFullUserRequest as gu
+
+from . import (
+    HNDLR,
+    LOGS,
+    asst,
+    callback,
+    get_string,
+    in_pattern,
+    inline_mention,
+    ultroid_bot,
+    ultroid_cmd,
+)
+
+buddhhu = {}
+
+
+@ultroid_cmd(
+    pattern="wspr( (.*)|$)",
+)
+async def _(e):
+    if e.reply_to_msg_id:
+        okk = await e.get_reply_message()
+        put = f"@{okk.sender.username}" if okk.sender.username else okk.sender_id
+    else:
+        put = e.pattern_match.group(1).strip()
+    if put:
+        try:
+            results = await e.client.inline_query(asst.me.username, f"msg {put}")
+        except BotResponseTimeoutError:
+            return await e.eor(
+                get_string("help_2").format(HNDLR),
+            )
+        except BotInlineDisabledError:
+            return await e.eor(get_string("help_3"))
+        await results[0].click(e.chat_id, reply_to=e.reply_to_msg_id, hide_via=True)
+        return await e.delete()
+    await e.eor(get_string("wspr_3"))
+
+
+@in_pattern("wspr", owner=True)
+async def _(e):
+    iuser = e.query.user_id
+    zzz = e.text.split(maxsplit=2)
+    try:
+        query = zzz[1]
+        if query.isdigit():
+            query = int(query)
+        logi = await ultroid_bot.get_entity(query)
+        if not isinstance(logi, types.User):
+            raise ValueError("Invalid Username.")
+    except IndexError:
+        sur = await e.builder.article(
+            title="Give Username",
+            description="You Didn't Type Username or id.",
+            text="You Didn't Type Username or id.",
+        )
+        return await e.answer([sur])
+    except ValueError as er:
+        LOGS.exception(er)
+        sur = await e.builder.article(
+            title="User Not Found",
+            description="Make sure username or id is correct.",
+            text="Make sure username or id is correct.",
+        )
+        return await e.answer([sur])
+    try:
+        desc = zzz[2]
+    except IndexError:
+        sur = await e.builder.article(
+            title="Type ur msg", text="You Didn't Type Your Msg"
+        )
+        return await e.answer([sur])
+    button = [
+        [
+            Button.inline("Secret Msg", data=f"dd_{e.id}"),
+            Button.inline("Delete Msg", data=f"del_{e.id}"),
+        ],
+        [
+            Button.switch_inline(
+                "New", query=f"wspr {logi.username or logi.id}", same_peer=True
+            )
+        ],
+    ]
+    us = logi.username or logi.first_name
+    sur = await e.builder.article(
+        title=logi.first_name,
+        description=desc,
+        text=get_string("wspr_1").format(us),
+        buttons=button,
+    )
+    buddhhu.update({e.id: [logi.id, iuser, desc]})
+    await e.answer([sur])
+
+
+@in_pattern("msg", owner=True)
+async def _(e):
+    zzz = e.text.split(maxsplit=1)
+    desc = "Touch me"
+    try:
+        query = zzz[1]
+        if query.isdigit():
+            query = int(query)
+        logi = await ultroid_bot(gu(id=query))
+        user = logi.users[0]
+        mention = inline_mention(user)
+        x = user.status
+        if isinstance(x, types.UserStatusOnline):
+            status = "Online"
+        elif isinstance(x, types.UserStatusOffline):
+            status = "Offline"
+        elif isinstance(x, types.UserStatusRecently):
+            status = "Last Seen Recently"
+        elif isinstance(x, types.UserStatusLastMonth):
+            status = "Last seen months ago"
+        elif isinstance(x, types.UserStatusLastWeek):
+            status = "Last seen weeks ago"
+        else:
+            status = "Can't Tell"
+        text = f"**Name:**    `{user.first_name}`\n"
+        text += f"**Id:**    `{user.id}`\n"
+        if user.username:
+            text += f"**Username:**    `{user.username}`\n"
+            url = f"https://t.me/{user.username}"
+        else:
+            text += f"**Mention:**    `{mention}`\n"
+            url = f"tg://user?id={user.id}"
+        text += f"**Status:**    `{status}`\n"
+        text += f"**About:**    `{logi.full_user.about}`"
+        button = [
+            Button.url("Private", url=url),
+            Button.switch_inline(
+                "Secret msg",
+                query=f"wspr {query} Hello 👋",
+                same_peer=True,
+            ),
+        ]
+        sur = e.builder.article(
+            title=user.first_name,
+            description=desc,
+            text=text,
+            buttons=button,
+        )
+    except IndexError:
+        sur = e.builder.article(
+            title="Give Username",
+            description="You Didn't Type Username or id.",
+            text="You Didn't Type Username or id.",
+        )
+    except BaseException as er:
+        LOGS.exception(er)
+        name = get_string("wspr_4").format(query)
+        sur = e.builder.article(
+            title=name,
+            text=name,
+        )
+
+    await e.answer([sur])
+
+
+@callback(
+    re.compile(
+        "dd_(.*)",
+    ),
+)
+async def _(e):
+    ids = int(e.pattern_match.group(1).strip().decode("UTF-8"))
+    if buddhhu.get(ids):
+        if e.sender_id in buddhhu[ids]:
+            await e.answer(buddhhu[ids][-1], alert=True)
+        else:
+            await e.answer("Not For You", alert=True)
+    else:
+        await e.answer(get_string("wspr_2"), alert=True)
+
+
+@callback(re.compile("del_(.*)"))
+async def _(e):
+    ids = int(e.pattern_match.group(1).strip().decode("UTF-8"))
+    if buddhhu.get(ids):
+        if e.sender_id in buddhhu[ids]:
+            buddhhu.pop(ids)
+            try:
+                await e.edit(get_string("wspr_2"))
+            except MessageNotModifiedError:
+                pass
+        else:
+            await e.answer(get_string("wspr_5"), alert=True)

plugins/admintools.py

@@ -0,0 +1,471 @@
+# 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 . import get_help
+
+__doc__ = get_help("help_admintools")
+
+import asyncio
+
+from telethon.errors import BadRequestError
+from telethon.errors.rpcerrorlist import ChatNotModifiedError, UserIdInvalidError
+from telethon.tl.functions.channels import EditAdminRequest, GetFullChannelRequest
+from telethon.tl.functions.messages import GetFullChatRequest, SetHistoryTTLRequest
+from telethon.tl.types import InputMessagesFilterPinned
+from telethon.utils import get_display_name
+
+from pyUltroid.dB import DEVLIST
+from pyUltroid.fns.admins import ban_time
+from pyUltroid.fns.info import get_uinfo
+
+from . import HNDLR, LOGS, eod, eor, get_string, inline_mention, types, ultroid_cmd
+
+
+@ultroid_cmd(
+    pattern="promote( (.*)|$)",
+    admins_only=True,
+    manager=True,
+    require="add_admins",
+    fullsudo=True,
+)
+async def prmte(ult):
+    xx = await ult.eor(get_string("com_1"))
+    user, rank = await get_uinfo(ult)
+    rank = rank or "Admin"
+    FullRight = False
+    if not user:
+        return await xx.edit(get_string("pro_1"))
+    if rank.split()[0] == "-f":
+        try:
+            rank = rank.split(maxsplit=1)[1]
+        except IndexError:
+            rank = "Admin"
+        FullRight = True
+    try:
+        if FullRight:
+            await ult.client(
+                EditAdminRequest(ult.chat_id, user.id, ult.chat.admin_rights, rank)
+            )
+        else:
+            await ult.client.edit_admin(
+                ult.chat_id,
+                user.id,
+                invite_users=True,
+                ban_users=True,
+                delete_messages=True,
+                pin_messages=True,
+                manage_call=True,
+                title=rank,
+            )
+        await eod(
+            xx, get_string("pro_2").format(inline_mention(user), ult.chat.title, rank)
+        )
+    except Exception as ex:
+        return await xx.edit(f"`{ex}`")
+
+
+@ultroid_cmd(
+    pattern="demote( (.*)|$)",
+    admins_only=True,
+    manager=True,
+    require="add_admins",
+    fullsudo=True,
+)
+async def dmote(ult):
+    xx = await ult.eor(get_string("com_1"))
+    user, rank = await get_uinfo(ult)
+    if not rank:
+        rank = "Not Admin"
+    if not user:
+        return await xx.edit(get_string("de_1"))
+    try:
+        await ult.client.edit_admin(
+            ult.chat_id,
+            user.id,
+            invite_users=None,
+            ban_users=None,
+            delete_messages=None,
+            pin_messages=None,
+            manage_call=None,
+            title=rank,
+        )
+        await eod(xx, get_string("de_2").format(inline_mention(user), ult.chat.title))
+    except Exception as ex:
+        return await xx.edit(f"`{ex}`")
+
+
+@ultroid_cmd(
+    pattern="ban( (.*)|$)",
+    admins_only=True,
+    manager=True,
+    require="ban_users",
+    fullsudo=True,
+)
+async def bban(ult):
+    something = await get_uinfo(ult)
+    if not something:
+        return
+    user, reason = something
+    if not user:
+        return await eod(ult, get_string("ban_1"))
+    if user.id in DEVLIST:
+        return await eod(ult, get_string("ban_2"))
+    try:
+        await ult.client.edit_permissions(ult.chat_id, user.id, view_messages=False)
+    except UserIdInvalidError:
+        return await eod(ult, get_string("adm_1"))
+    except BadRequestError:
+        return await eod(ult, get_string("ban_3"))
+    senderme = inline_mention(await ult.get_sender())
+    userme = inline_mention(user)
+    text = get_string("ban_4").format(userme, senderme, ult.chat.title)
+    if reason:
+        text += get_string("ban_5").format(reason)
+    await eod(ult, text)
+
+
+@ultroid_cmd(
+    pattern="unban( (.*)|$)",
+    admins_only=True,
+    manager=True,
+    require="ban_users",
+    fullsudo=True,
+)
+async def uunban(ult):
+    xx = await ult.eor(get_string("com_1"))
+    if ult.text[1:].startswith("unbanall"):
+        return
+    something = await get_uinfo(ult)
+    if not something:
+        return
+    user, reason = something
+    if not user:
+        return await xx.edit(get_string("unban_1"))
+    try:
+        await ult.client.edit_permissions(ult.chat_id, user.id, view_messages=True)
+    except UserIdInvalidError:
+        return await eod(ult, get_string("adm_1"))
+    except BadRequestError:
+        return await xx.edit(get_string("adm_2"))
+    sender = inline_mention(await ult.get_sender())
+    text = get_string("unban_3").format(inline_mention(user), sender, ult.chat.title)
+    if reason:
+        text += get_string("ban_5").format(reason)
+    await xx.edit(text)
+
+
+@ultroid_cmd(
+    pattern="kick( (.*)|$)",
+    manager=True,
+    require="ban_users",
+    fullsudo=True,
+)
+async def kck(ult):
+    if "kickme" in ult.text:
+        return
+    if ult.is_private:
+        return await ult.eor("`Use this in Group/Channel.`", time=5)
+    ml = ult.text.split(" ", maxsplit=1)[0]
+    xx = await ult.eor(get_string("com_1"))
+    something = await get_uinfo(ult)
+    if not something:
+        return
+    user, reason = something
+    if not user:
+        return await xx.edit(get_string("adm_1"))
+    if user.id in DEVLIST:
+        return await xx.edit(get_string("kick_2"))
+    if getattr(user, "is_self", False):
+        return await xx.edit(get_string("kick_3"))
+    try:
+        await ult.client.kick_participant(ult.chat_id, user.id)
+    except BadRequestError as er:
+        LOGS.info(er)
+        return await xx.edit(get_string("kick_1"))
+    except Exception as e:
+        LOGS.exception(e)
+        return
+    text = get_string("kick_4").format(
+        inline_mention(user), inline_mention(await ult.get_sender()), ult.chat.title
+    )
+    if reason:
+        text += get_string("ban_5").format(reason)
+    await xx.edit(text)
+
+
+@ultroid_cmd(
+    pattern="tban( (.*)|$)",
+    admins_only=True,
+    manager=True,
+    require="ban_users",
+    fullsudo=True,
+)
+async def tkicki(e):
+    huh = e.text.split()
+    inputt = None
+    try:
+        tme = huh[1]
+    except IndexError:
+        return await e.eor(get_string("adm_3"), time=15)
+    try:
+        inputt = huh[2]
+    except IndexError:
+        if e.reply_to_msg_id:
+            inputt = (await e.get_reply_message()).sender_id
+    if not inputt:
+        return await e.eor(get_string("tban_1"))
+    userid = await e.client.parse_id(inputt)
+    try:
+        user = await e.client.get_entity(userid)
+    except Exception as ex:
+        return await eor(e, f"`{ex}`")
+    try:
+        bun = ban_time(tme)
+        await e.client.edit_permissions(
+            e.chat_id, user.id, until_date=bun, view_messages=False
+        )
+        await eod(
+            e,
+            get_string("tban_2").format(inline_mention(user), e.chat.title, tme),
+            time=15,
+        )
+    except Exception as m:
+        return await e.eor(str(m))
+
+
+@ultroid_cmd(pattern="pin$", manager=True, require="pin_messages", fullsudo=True)
+async def pin(msg):
+    if not msg.is_reply:
+        return await eor(msg, get_string("pin_1"))
+    me = await msg.get_reply_message()
+    if me.is_private:
+        text = "`Pinned.`"
+    else:
+        text = f"Pinned [This Message]({me.message_link}) !"
+    try:
+        await msg.client.pin_message(msg.chat_id, me.id, notify=False)
+    except BadRequestError:
+        return await eor(msg, get_string("adm_2"))
+    except Exception as e:
+        return await eor(msg, f"**ERROR:**`{e}`")
+    await eor(msg, text)
+
+
+@ultroid_cmd(
+    pattern="unpin($| (.*))",
+    manager=True,
+    require="pin_messages",
+    fullsudo=True,
+)
+async def unp(ult):
+    xx = await ult.eor(get_string("com_1"))
+    ch = (ult.pattern_match.group(1).strip()).strip()
+    msg = None
+    if ult.is_reply:
+        msg = ult.reply_to_msg_id
+    elif ch != "all":
+        return await xx.edit(get_string("unpin_1").format(HNDLR))
+    try:
+        await ult.client.unpin_message(ult.chat_id, msg)
+    except BadRequestError:
+        return await xx.edit(get_string("adm_2"))
+    except Exception as e:
+        return await xx.edit(f"**ERROR:**`{e}`")
+    await xx.edit("`Unpinned!`")
+
+
+@ultroid_cmd(
+    pattern="tpin( (.*)|$)",
+    admins_only=True,
+    manager=True,
+    require="pin_messages",
+    fullsudo=True,
+)
+async def pin_message(ult):
+    match = ult.pattern_match.group(1).strip()
+    if not ult.is_reply:
+        return await ult.eor("`Reply to message..`", time=6)
+    if not match:
+        return await ult.eor("`Please provide time..`", time=8)
+    msg = await ult.eor(get_string("com_1"))
+    msg_id = ult.reply_to_msg_id
+    try:
+        time = ban_time(match)
+        await ult.client.pin_message(ult.chat_id, msg_id)
+        await msg.eor(f"`pinned for time` `{time}`", time=8)
+    except Exception as er:
+        return await msg.edit(str(er))
+    await asyncio.sleep(time)
+    try:
+        await ult.client.unpin_message(ult.chat_id, msg_id)
+    except Exception as er:
+        LOGS.exception(er)
+
+
+@ultroid_cmd(pattern="purge( (.*)|$)", manager=True, require="delete_messages")
+async def fastpurger(purg):
+    match = purg.pattern_match.group(1).strip()
+    try:
+        ABC = purg.text[6]
+    except IndexError:
+        ABC = None
+    if ABC and purg.text[6] in ["m", "a"]:
+        return
+    if not purg._client._bot and (
+        (match)
+        or (purg.is_reply and (purg.is_private or isinstance(purg.chat, types.Chat)))
+    ):
+        p = 0
+        async for msg in purg.client.iter_messages(
+            purg.chat_id,
+            limit=int(match) if match else None,
+            min_id=purg.reply_to_msg_id if purg.is_reply else None,
+        ):
+            await msg.delete()
+            p += 0
+        return await eor(purg, f"Purged {p} Messages! ", time=5)
+    if not purg.reply_to_msg_id:
+        return await eor(purg, get_string("purge_1"), time=10)
+    try:
+        await purg.client.delete_messages(
+            purg.chat_id, list(range(purg.reply_to_msg_id, purg.id))
+        )
+
+    except Exception as er:
+        LOGS.info(er)
+    await purg.eor("__Fast purge complete!__", time=5)
+
+
+@ultroid_cmd(
+    pattern="purgeme( (.*)|$)",
+)
+async def fastpurgerme(purg):
+    if num := purg.pattern_match.group(1).strip():
+        try:
+            nnt = int(num)
+        except BaseException:
+            await eor(purg, get_string("com_3"), time=5)
+            return
+        mp = 0
+        async for mm in purg.client.iter_messages(
+            purg.chat_id, limit=nnt, from_user="me"
+        ):
+            await mm.delete()
+            mp += 1
+        await eor(purg, f"Purged {mp} Messages!", time=5)
+        return
+    elif not purg.reply_to_msg_id:
+        return await eod(
+            purg,
+            "`Reply to a message to purge from or use it like ``purgeme <num>`",
+            time=10,
+        )
+    chat = await purg.get_input_chat()
+    msgs = []
+    async for msg in purg.client.iter_messages(
+        chat,
+        from_user="me",
+        min_id=purg.reply_to_msg_id,
+    ):
+        msgs.append(msg)
+    if msgs:
+        await purg.client.delete_messages(chat, msgs)
+    await purg.eor(
+        "__Fast purge complete!__\n**Purged** `" + str(len(msgs)) + "` **messages.**",
+        time=5,
+    )
+
+
+@ultroid_cmd(
+    pattern="purgeall$",
+)
+async def _(e):
+    if not e.is_reply:
+        return await eod(
+            e,
+            get_string("purgeall_1"),
+        )
+
+    msg = await e.get_reply_message()
+    name = msg.sender
+    try:
+        await e.client.delete_messages(e.chat_id, from_user=msg.sender_id)
+        await e.eor(get_string("purgeall_2").format(name.first_name), time=5)
+    except Exception as er:
+        return await e.eor(str(er), time=5)
+
+@ultroid_cmd(pattern="pinned", manager=True, groups_only=True)
+async def djshsh(event):
+    chat = await event.get_chat()
+    if isinstance(chat, types.Chat):
+        FChat = await event.client(GetFullChatRequest(chat.id))
+    elif isinstance(chat, types.Channel):
+        FChat = await event.client(GetFullChannelRequest(chat.id))
+    else:
+        return
+    msg_id = FChat.full_chat.pinned_msg_id
+    if not msg_id:
+        return await event.eor(get_string("pinned_1"))
+    msg = await event.client.get_messages(chat.id, ids=msg_id)
+    if msg:
+        await event.eor(get_string("pinned_2").format(msg.message_link))
+
+
+@ultroid_cmd(
+    pattern="listpinned$",
+)
+async def get_all_pinned(event):
+    x = await event.eor(get_string("com_1"))
+    chat_id = (str(event.chat_id)).replace("-100", "")
+    chat_name = get_display_name(event.chat)
+    a = ""
+    c = 1
+    async for i in event.client.iter_messages(
+        event.chat_id, filter=InputMessagesFilterPinned
+    ):
+        if i.message:
+            t = " ".join(i.message.split()[:4])
+            txt = f"{t}...."
+        else:
+            txt = "Go to message."
+        a += f"{c}. <a href=https://t.me/c/{chat_id}/{i.id}>{txt}</a>\n"
+        c += 1
+
+    if c == 1:
+        m = f"<b>The pinned message in {chat_name}:</b>\n\n"
+    else:
+        m = f"<b>List of pinned message(s) in {chat_name}:</b>\n\n"
+
+    if not a:
+        return await eor(x, get_string("listpin_1"), time=5)
+
+    await x.edit(m + a, parse_mode="html")
+
+
+@ultroid_cmd(
+    pattern="autodelete( (.*)|$)",
+    admins_only=True,
+)
+async def autodelte(ult):
+    match = ult.pattern_match.group(1).strip()
+    if not match or match not in ["24h", "7d", "1m", "off"]:
+        return await ult.eor("`Please Use in Proper Format..`", time=5)
+    if match == "24h":
+        tt = 3600 * 24
+    elif match == "7d":
+        tt = 3600 * 24 * 7
+    elif match == "1m":
+        tt = 3600 * 24 * 31
+    else:
+        tt = 0
+    try:
+        await ult.client(SetHistoryTTLRequest(ult.chat_id, period=tt))
+    except ChatNotModifiedError:
+        return await ult.eor(
+            f"Auto Delete Setting is Already same to `{match}`", time=5
+        )
+    await ult.eor(f"Auto Delete Status Changed to `{match}` !")

plugins/afk.py

@@ -0,0 +1,165 @@
+# 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 . import get_help
+
+__doc__ = get_help("help_afk")
+
+
+import asyncio
+
+from telethon import events
+
+from pyUltroid.dB.afk_db import add_afk, del_afk, is_afk
+from pyUltroid.dB.base import KeyManager
+
+from . import (
+    LOG_CHANNEL,
+    NOSPAM_CHAT,
+    Redis,
+    asst,
+    get_string,
+    mediainfo,
+    udB,
+    ultroid_bot,
+    ultroid_cmd,
+    upload_file
+)
+
+old_afk_msg = []
+
+is_approved = KeyManager("PMPERMIT", cast=list).contains
+
+
+@ultroid_cmd(pattern="afk( (.*)|$)", owner_only=True)
+async def set_afk(event):
+    if event.client._bot or is_afk():
+        return
+    text, media, media_type = None, None, None
+    if event.pattern_match.group(1).strip():
+        text = event.text.split(maxsplit=1)[1]
+    reply = await event.get_reply_message()
+    if reply:
+        if reply.text and not text:
+            text = reply.text
+        if reply.media:
+            media_type = mediainfo(reply.media)
+            if media_type.startswith(("pic", "gif")):
+                file = await event.client.download_media(reply.media)
+                media = upload_file(file)
+            else:
+                media = reply.file.id
+    await event.eor("`Done`", time=2)
+    add_afk(text, media_type, media)
+    ultroid_bot.add_handler(remove_afk, events.NewMessage(outgoing=True))
+    ultroid_bot.add_handler(
+        on_afk,
+        events.NewMessage(
+            incoming=True, func=lambda e: bool(e.mentioned or e.is_private)
+        ),
+    )
+    msg1, msg2 = None, None
+    if text and media:
+        if "sticker" in media_type:
+            msg1 = await ultroid_bot.send_file(event.chat_id, file=media)
+            msg2 = await ultroid_bot.send_message(
+                event.chat_id, get_string("afk_5").format(text)
+            )
+        else:
+            msg1 = await ultroid_bot.send_message(
+                event.chat_id, get_string("afk_5").format(text), file=media
+            )
+    elif media:
+        if "sticker" in media_type:
+            msg1 = await ultroid_bot.send_file(event.chat_id, file=media)
+            msg2 = await ultroid_bot.send_message(event.chat_id, get_string("afk_6"))
+        else:
+            msg1 = await ultroid_bot.send_message(
+                event.chat_id, get_string("afk_6"), file=media
+            )
+    elif text:
+        msg1 = await event.respond(get_string("afk_5").format(text))
+    else:
+        msg1 = await event.respond(get_string("afk_6"))
+    old_afk_msg.append(msg1)
+    if msg2:
+        old_afk_msg.append(msg2)
+        return await asst.send_message(LOG_CHANNEL, msg2.text)
+    await asst.send_message(LOG_CHANNEL, msg1.text)
+
+
+async def remove_afk(event):
+    if event.is_private and udB.get_key("PMSETTING") and not is_approved(event.chat_id):
+        return
+    elif "afk" in event.text.lower():
+        return
+    elif event.chat_id in NOSPAM_CHAT:
+        return
+    if is_afk():
+        _, _, _, afk_time = is_afk()
+        del_afk()
+        off = await event.reply(get_string("afk_1").format(afk_time))
+        await asst.send_message(LOG_CHANNEL, get_string("afk_2").format(afk_time))
+        for x in old_afk_msg:
+            try:
+                await x.delete()
+            except BaseException:
+                pass
+        await asyncio.sleep(10)
+        await off.delete()
+
+
+async def on_afk(event):
+    if event.is_private and Redis("PMSETTING") and not is_approved(event.chat_id):
+        return
+    elif "afk" in event.text.lower():
+        return
+    elif not is_afk():
+        return
+    if event.chat_id in NOSPAM_CHAT:
+        return
+    sender = await event.get_sender()
+    if sender.bot or sender.verified:
+        return
+    text, media_type, media, afk_time = is_afk()
+    msg1, msg2 = None, None
+    if text and media:
+        if "sticker" in media_type:
+            msg1 = await event.reply(file=media)
+            msg2 = await event.reply(get_string("afk_3").format(afk_time, text))
+        else:
+            msg1 = await event.reply(
+                get_string("afk_3").format(afk_time, text), file=media
+            )
+    elif media:
+        if "sticker" in media_type:
+            msg1 = await event.reply(file=media)
+            msg2 = await event.reply(get_string("afk_4").format(afk_time))
+        else:
+            msg1 = await event.reply(get_string("afk_4").format(afk_time), file=media)
+    elif text:
+        msg1 = await event.reply(get_string("afk_3").format(afk_time, text))
+    else:
+        msg1 = await event.reply(get_string("afk_4").format(afk_time))
+    for x in old_afk_msg:
+        try:
+            await x.delete()
+        except BaseException:
+            pass
+    old_afk_msg.append(msg1)
+    if msg2:
+        old_afk_msg.append(msg2)
+
+
+if udB.get_key("AFK_DB"):
+    ultroid_bot.add_handler(remove_afk, events.NewMessage(outgoing=True))
+    ultroid_bot.add_handler(
+        on_afk,
+        events.NewMessage(
+            incoming=True, func=lambda e: bool(e.mentioned or e.is_private)
+        ),
+    )

plugins/aiwrapper.py

@@ -0,0 +1,396 @@
+# 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/>.
+
+"""
+✘ Commands Available -
+
+• `{i}gemini <prompt>`
+    Get response from Google Gemini.
+
+• `{i}antr <prompt>`
+    Get response from Anthropic Claude.
+
+• `{i}gpt <prompt>`
+    Get response from OpenAI GPT.
+
+• `{i}deepseek <prompt>`
+    Get response from DeepSeek AI.
+
+Set custom models using:
+    • OPENAI_MODEL
+    • ANTHROPIC_MODEL
+    • GEMINI_MODEL
+    • DEEPSEEK_MODEL
+"""
+
+import json
+from . import LOGS, eor, get_string, udB, ultroid_cmd, async_searcher
+import aiohttp
+import asyncio
+
+
+ENDPOINTS = {
+    "gpt": "https://api.openai.com/v1/chat/completions",
+    "antr": "https://api.anthropic.com/v1/messages",
+    "gemini": "https://generativelanguage.googleapis.com/v1/models/gemini-pro:generateContent",
+    "deepseek": "https://api.deepseek.com/chat/completions"
+}
+
+DEFAULT_MODELS = {
+    "gpt": "gpt-3.5-turbo",
+    "antr": "claude-3-opus-20240229",
+    "gemini": "gemini-pro",
+    "deepseek": "deepseek-chat"
+}
+
+
+def get_model(provider):
+    """Get model name from database or use default"""
+    model_keys = {
+        "gpt": "OPENAI_MODEL",
+        "antr": "ANTHROPIC_MODEL",
+        "gemini": "GEMINI_MODEL",
+        "deepseek": "DEEPSEEK_MODEL"
+    }
+    return udB.get_key(model_keys[provider]) or DEFAULT_MODELS[provider]
+
+
+async def stream_response(msg, text):
+    """Stream response by editing message"""
+    current = ""
+    # Split into chunks of ~100 characters at word boundaries
+    words = text.split()
+    chunks = []
+    current_chunk = []
+    
+    for word in words:
+        current_chunk.append(word)
+        if len(" ".join(current_chunk)) > 100:
+            chunks.append(" ".join(current_chunk[:-1]))
+            current_chunk = [word]
+    if current_chunk:
+        chunks.append(" ".join(current_chunk))
+    
+    for chunk in chunks:
+        current += chunk + " "
+        try:
+            await msg.edit(current)
+        except Exception:
+            pass
+        await asyncio.sleep(0.5)
+    return current
+
+
+async def get_ai_response(provider, prompt, api_key, stream=False):
+    """Get response from AI provider"""
+    try:
+        headers = {"Content-Type": "application/json"}
+        model = get_model(provider)
+        
+        if provider == "gpt":
+            headers["Authorization"] = f"Bearer {api_key}"
+            data = {
+                "model": model,
+                "messages": [{"role": "user", "content": prompt}],
+                "stream": stream
+            }
+            if not stream:
+                response = await async_searcher(
+                    ENDPOINTS[provider],
+                    headers=headers,
+                    post=True,
+                    json=data,
+                    re_json=True
+                )
+                yield response["choices"][0]["message"]["content"]
+                return
+                
+            async with aiohttp.ClientSession() as session:
+                async with session.post(
+                    ENDPOINTS[provider],
+                    headers=headers,
+                    json=data
+                ) as resp:
+                    async for line in resp.content:
+                        if line:
+                            try:
+                                json_line = json.loads(line.decode('utf-8').strip().strip('data:').strip())
+                                if 'choices' in json_line and json_line['choices']:
+                                    content = json_line['choices'][0].get('delta', {}).get('content', '')
+                                    if content:
+                                        yield content
+                            except Exception:
+                                continue
+
+        elif provider == "antr":
+            headers["x-api-key"] = api_key
+            headers["anthropic-version"] = "2023-06-01"
+            data = {
+                "model": model,
+                "messages": [{"role": "user", "content": prompt}],
+                "stream": stream
+            }
+            if not stream:
+                response = await async_searcher(
+                    ENDPOINTS[provider],
+                    headers=headers,
+                    post=True,
+                    json=data,
+                    re_json=True
+                )
+                yield response["content"][0]["text"]
+                return
+                
+            async with aiohttp.ClientSession() as session:
+                async with session.post(
+                    ENDPOINTS[provider],
+                    headers=headers,
+                    json=data
+                ) as resp:
+                    async for line in resp.content:
+                        if line:
+                            try:
+                                json_line = json.loads(line.decode('utf-8').strip())
+                                if 'content' in json_line:
+                                    content = json_line['content'][0]['text']
+                                    if content:
+                                        yield content
+                            except Exception:
+                                continue
+
+        elif provider == "gemini":
+            params = {"key": api_key}
+            data = {
+                "contents": [{
+                    "parts": [{"text": prompt}]
+                }]
+            }
+            response = await async_searcher(
+                ENDPOINTS[provider],
+                params=params,
+                headers=headers,
+                post=True,
+                json=data,
+                re_json=True
+            )
+            text = response["candidates"][0]["content"]["parts"][0]["text"]
+            if not stream:
+                yield text
+                return
+                
+            # Simulate streaming by yielding chunks
+            words = text.split()
+            buffer = []
+            for word in words:
+                buffer.append(word)
+                if len(' '.join(buffer)) > 20:  # Adjust chunk size as needed
+                    yield ' '.join(buffer) + ' '
+                    buffer = []
+            if buffer:
+                yield ' '.join(buffer)
+
+        elif provider == "deepseek":
+            headers["Authorization"] = f"Bearer {api_key}"
+            data = {
+                "model": model,
+                "messages": [{"role": "user", "content": prompt}],
+                "stream": stream
+            }
+            if not stream:
+                response = await async_searcher(
+                    ENDPOINTS[provider],
+                    headers=headers,
+                    post=True,
+                    json=data,
+                    re_json=True
+                )
+                yield response["choices"][0]["message"]["content"]
+                return
+                
+            async with aiohttp.ClientSession() as session:
+                async with session.post(
+                    ENDPOINTS[provider],
+                    headers=headers,
+                    json=data
+                ) as resp:
+                    async for line in resp.content:
+                        if line:
+                            try:
+                                json_line = json.loads(line.decode('utf-8').strip())
+                                if 'choices' in json_line and json_line['choices']:
+                                    content = json_line['choices'][0].get('delta', {}).get('content', '')
+                                    if content:
+                                        yield content
+                            except Exception:
+                                continue
+
+    except Exception as e:
+        LOGS.exception(e)
+        yield f"Error: {str(e)}"
+
+
+@ultroid_cmd(pattern="gemini( (.*)|$)")
+async def gemini_ai(event):
+    """Use Google Gemini"""
+    prompt = event.pattern_match.group(1).strip()
+    if not prompt:
+        return await event.eor("❌ Please provide a prompt!")
+
+    api_key = udB.get_key("GEMINI_API_KEY")
+    if not api_key:
+        return await event.eor("⚠️ Please set Gemini API key using `setdb GEMINI_API_KEY your_api_key`")
+
+    msg = await event.eor("🤔 Thinking...")
+    model = get_model("gemini")
+    
+    header = (
+        "🤖 **Google Gemini**\n"
+        f"**Model:** `{model}`\n"
+        "➖➖➖➖➖➖➖➖➖➖\n\n"
+        f"**🔍 Prompt:**\n{prompt}\n\n"
+        "**💡 Response:**\n"
+    )
+    
+    if event.client.me.bot:
+        await msg.edit(header)
+        response = ""
+        async for chunk in get_ai_response("gemini", prompt, api_key, stream=True):
+            response += chunk
+            try:
+                await msg.edit(header + response)
+            except Exception:
+                pass
+    else:
+        response = ""
+        async for chunk in get_ai_response("gemini", prompt, api_key, stream=True):
+            response += chunk
+        try:
+                await msg.edit(header + response)
+        except Exception:
+                pass
+
+@ultroid_cmd(pattern="antr( (.*)|$)")
+async def anthropic_ai(event):
+    """Use Anthropic Claude"""
+    prompt = event.pattern_match.group(1).strip()
+    if not prompt:
+        return await event.eor("❌ Please provide a prompt!")
+
+    api_key = udB.get_key("ANTHROPIC_KEY")
+    if not api_key:
+        return await event.eor("⚠️ Please set Anthropic API key using `setdb ANTHROPIC_KEY your_api_key`")
+
+    msg = await event.eor("🤔 Thinking...")
+    model = get_model("antr")
+    
+    formatted_response = (
+        "🧠 **Anthropic Claude**\n"
+        f"**Model:** `{model}`\n"
+        "➖➖➖➖➖➖➖➖➖➖\n\n"
+        f"**🔍 Prompt:**\n{prompt}\n\n"
+        f"**💡 Response:**\n"
+    )
+    
+    if event.client.me.bot:
+        await msg.edit(formatted_response)
+        response = ""
+        async for chunk in get_ai_response("antr", prompt, api_key, stream=True):
+            response += chunk
+            try:
+                await msg.edit(formatted_response + response)
+            except Exception:
+                pass
+    else:
+        response = ""
+        async for chunk in get_ai_response("antr", prompt, api_key, stream=True):
+            response += chunk
+        try:
+            await msg.edit(formatted_response + response)
+        except Exception:
+            pass
+
+@ultroid_cmd(pattern="gpt( (.*)|$)")
+async def openai_ai(event):
+    """Use OpenAI GPT"""
+    prompt = event.pattern_match.group(1).strip()
+    if not prompt:
+        return await event.eor("❌ Please provide a prompt!")
+
+    api_key = udB.get_key("OPENAI_API_KEY")
+    if not api_key:
+        return await event.eor("⚠️ Please set GPT API key using `setdb OPENAI_API_KEY your_api_key`")
+
+    msg = await event.eor("🤔 Thinking...")
+    model = get_model("gpt")
+    
+    header = (
+        "🌟 **OpenAI GPT**\n"
+        f"**Model:** `{model}`\n"
+        "➖➖➖➖➖➖➖➖➖➖\n\n"
+        f"**🔍 Prompt:**\n{prompt}\n\n"
+        "**💡 Response:**\n"
+    )
+    
+    if event.client.me.bot:
+        await msg.edit(header)
+        response = ""
+        async for chunk in get_ai_response("gpt", prompt, api_key, stream=True):
+            response += chunk
+            try:
+                await msg.edit(header + response)
+            except Exception:
+                pass
+    else:
+        response =""
+        async for chunk in get_ai_response("gpt", prompt, api_key, stream=True):
+            response += chunk
+        try:
+            await msg.edit(header + response)
+        except Exception:
+            pass
+
+@ultroid_cmd(pattern="deepseek( (.*)|$)")
+async def deepseek_ai(event):
+    """Use DeepSeek AI"""
+    prompt = event.pattern_match.group(1).strip()
+    if not prompt:
+        return await event.eor("❌ Please provide a prompt!")
+
+    api_key = udB.get_key("DEEPSEEK_API_KEY")
+    if not api_key:
+        return await event.eor("⚠️ Please set DeepSeek API key using `setdb DEEPSEEK_API_KEY your_api_key`")
+
+    msg = await event.eor("🤔 Thinking...")
+    model = get_model("deepseek")
+    
+    formatted_response = (
+        "🤖 **DeepSeek AI**\n"
+        f"**Model:** `{model}`\n"
+        "➖➖➖➖➖➖➖➖➖➖\n\n"
+        f"**🔍 Prompt:**\n{prompt}\n\n"
+        f"**💡 Response:**\n"
+    )
+    
+    if event.client.me.bot:
+        await msg.edit(formatted_response)
+        response = ""
+        async for chunk in get_ai_response("deepseek", prompt, api_key, stream=True):
+            response += chunk
+            try:
+                await msg.edit(formatted_response + response)
+            except Exception:
+                pass
+    else:
+        response = ""
+        async for chunk in get_ai_response("deepseek", prompt, api_key, stream=True):
+            response += chunk
+
+        try:
+            await msg.edit(formatted_response + response)
+        except Exception:
+            pass
+

plugins/antiflood.py

@@ -0,0 +1,121 @@
+# 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 . import get_help
+
+__doc__ = get_help("help_antiflood")
+
+
+import re
+
+from telethon.events import NewMessage as NewMsg
+
+from pyUltroid.dB import DEVLIST
+from pyUltroid.dB.antiflood_db import get_flood, get_flood_limit, rem_flood, set_flood
+from pyUltroid.fns.admins import admin_check
+
+from . import Button, Redis, asst, callback, eod, get_string, ultroid_bot, ultroid_cmd
+
+_check_flood = {}
+
+if Redis("ANTIFLOOD"):
+
+    @ultroid_bot.on(
+        NewMsg(
+            chats=list(get_flood().keys()),
+        ),
+    )
+    async def flood_checm(event):
+        count = 1
+        chat = (await event.get_chat()).title
+        if event.chat_id in _check_flood.keys():
+            if event.sender_id == list(_check_flood[event.chat_id].keys())[0]:
+                count = _check_flood[event.chat_id][event.sender_id]
+                _check_flood[event.chat_id] = {event.sender_id: count + 1}
+            else:
+                _check_flood[event.chat_id] = {event.sender_id: count}
+        else:
+            _check_flood[event.chat_id] = {event.sender_id: count}
+        if await admin_check(event, silent=True) or getattr(event.sender, "bot", None):
+            return
+        if event.sender_id in DEVLIST:
+            return
+        if _check_flood[event.chat_id][event.sender_id] >= int(
+            get_flood_limit(event.chat_id)
+        ):
+            try:
+                name = event.sender.first_name
+                await event.client.edit_permissions(
+                    event.chat_id, event.sender_id, send_messages=False
+                )
+                del _check_flood[event.chat_id]
+                await event.reply(f"#AntiFlood\n\n{get_string('antiflood_3')}")
+                await asst.send_message(
+                    int(Redis("LOG_CHANNEL")),
+                    f"#Antiflood\n\n`Muted `[{name}](tg://user?id={event.sender_id})` in {chat}`",
+                    buttons=Button.inline(
+                        "Unmute", data=f"anti_{event.sender_id}_{event.chat_id}"
+                    ),
+                )
+            except BaseException:
+                pass
+
+
+@callback(
+    re.compile(
+        "anti_(.*)",
+    ),
+)
+async def unmuting(e):
+    ino = (e.data_match.group(1)).decode("UTF-8").split("_")
+    user = int(ino[0])
+    chat = int(ino[1])
+    user_name = (await ultroid_bot.get_entity(user)).first_name
+    chat_title = (await ultroid_bot.get_entity(chat)).title
+    await ultroid_bot.edit_permissions(chat, user, send_messages=True)
+    await e.edit(
+        f"#Antiflood\n\n`Unmuted `[{user_name}](tg://user?id={user})` in {chat_title}`"
+    )
+
+
+@ultroid_cmd(
+    pattern="setflood ?(\\d+)",
+    admins_only=True,
+)
+async def setflood(e):
+    input_ = e.pattern_match.group(1).strip()
+    if not input_:
+        return await e.eor("`What?`", time=5)
+    if not input_.isdigit():
+        return await e.eor(get_string("com_3"), time=5)
+    if m := set_flood(e.chat_id, input_):
+        return await eod(e, get_string("antiflood_4").format(input_))
+
+
+@ultroid_cmd(
+    pattern="remflood$",
+    admins_only=True,
+)
+async def remove_flood(e):
+    hmm = rem_flood(e.chat_id)
+    try:
+        del _check_flood[e.chat_id]
+    except BaseException:
+        pass
+    if hmm:
+        return await e.eor(get_string("antiflood_1"), time=5)
+    await e.eor(get_string("antiflood_2"), time=5)
+
+
+@ultroid_cmd(
+    pattern="getflood$",
+    admins_only=True,
+)
+async def getflood(e):
+    if ok := get_flood_limit(e.chat_id):
+        return await e.eor(get_string("antiflood_5").format(ok), time=5)
+    await e.eor(get_string("antiflood_2"), time=5)

plugins/asstcmd.py

@@ -0,0 +1,100 @@
+# 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 . import get_help
+
+__doc__ = get_help("help_asstcmd")
+
+import os
+
+from pyUltroid.dB.asstcmd_db import add_cmd, cmd_reply, list_cmds, rem_cmd
+from pyUltroid.fns.tools import create_tl_btn, format_btn, get_msg_button
+from telethon import events, utils
+
+from . import asst, get_string, mediainfo, udB, ultroid_cmd, upload_file
+
+
+@ultroid_cmd(pattern="addcmd( (.*)|$)")
+async def ac(e):
+    wrd = (e.pattern_match.group(1).strip()).lower()
+    wt = await e.get_reply_message()
+    if not (wt and wrd):
+        return await e.eor(get_string("asstcmd_1"), time=5)
+    if "/" in wrd:
+        wrd = wrd.replace("/", "")
+    btn = format_btn(wt.buttons) if wt.buttons else None
+    if wt and wt.media:
+        wut = mediainfo(wt.media)
+        if wut.startswith(("pic", "gif")):
+            dl = await e.client.download_media(wt.media)
+            m = upload_file(dl)
+            os.remove(dl)
+        elif wut == "video":
+            if wt.media.document.size > 8 * 1000 * 1000:
+                return await e.eor(get_string("com_4"), time=5)
+            dl = await e.client.download_media(wt.media)
+            m = upload_file(dl)
+            os.remove(dl)
+        else:
+            m = utils.pack_bot_file_id(wt.media)
+        if wt.text:
+            txt = wt.text
+            if not btn:
+                txt, btn = get_msg_button(wt.text)
+            add_cmd(wrd, txt, m, btn)
+        else:
+            add_cmd(wrd, None, m, btn)
+    else:
+        txt = wt.text
+        if not btn:
+            txt, btn = get_msg_button(wt.text)
+        add_cmd(wrd, txt, None, btn)
+    asst.add_handler(
+        astcmds,
+        events.NewMessage(
+            func=lambda x: x.text.startswith("/") and x.text[1:] in list(list_cmds())
+        ),
+    )
+    await e.eor(get_string("asstcmd_4").format(wrd))
+
+
+@ultroid_cmd(pattern="remcmd( (.*)|$)")
+async def rc(e):
+    wrd = (e.pattern_match.group(1).strip()).lower()
+    if not wrd:
+        return await e.eor(get_string("asstcmd_2"), time=5)
+    wrd = wrd.replace("/", "")
+    rem_cmd(wrd)
+    await e.eor(get_string("asstcmd_3").format(wrd))
+
+
+@ultroid_cmd(pattern="listcmd$")
+async def lscmd(e):
+    if list_cmds():
+        ok = get_string("asstcmd_6")
+        for x in list_cmds():
+            ok += f"/{x}" + "\n"
+        return await e.eor(ok)
+    return await e.eor(get_string("asstcmd_5"))
+
+
+async def astcmds(e):
+    xx = (e.text.replace("/", "")).lower().split()[0]
+    if cmd_reply(xx):
+        msg, media, bt = cmd_reply(xx)
+        if bt:
+            bt = create_tl_btn(bt)
+        await e.reply(msg, file=media, buttons=bt)
+
+
+if udB.get_key("ASST_CMDS"):
+    asst.add_handler(
+        astcmds,
+        events.NewMessage(
+            func=lambda x: x.text.startswith("/") and x.text[1:] in list(list_cmds())
+        ),
+    )

plugins/audiotools.py

@@ -0,0 +1,163 @@
+# 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 time
+from datetime import datetime as dt
+
+from pyUltroid.fns.tools import set_attributes
+
+from . import (
+    LOGS,
+    ULTConfig,
+    bash,
+    downloader,
+    eod,
+    eor,
+    genss,
+    get_help,
+    get_string,
+    humanbytes,
+    mediainfo,
+    stdr,
+    time_formatter,
+    ultroid_cmd
+)
+
+__doc__ = get_help("help_audiotools")
+
+
+@ultroid_cmd(pattern="makevoice$")
+async def vnc(e):
+    if not e.reply_to:
+        return await eod(e, get_string("audiotools_1"))
+    r = await e.get_reply_message()
+    if not mediainfo(r.media).startswith(("audio", "video")):
+        return await eod(e, get_string("spcltool_1"))
+    xxx = await e.eor(get_string("com_1"))
+    file, _ = await e.client.fast_downloader(
+        r.document,
+    )
+    await xxx.edit(get_string("audiotools_2"))
+    await bash(
+        f"ffmpeg -i '{file.name}' -map 0:a -codec:a libopus -b:a 100k -vbr on out.opus"
+    )
+    try:
+        await e.client.send_message(
+            e.chat_id, file="out.opus", force_document=False, reply_to=r
+        )
+    except Exception as er:
+        LOGS.exception(er)
+        return await xxx.edit("`Failed to convert in Voice...`")
+    await xxx.delete()
+    os.remove(file.name)
+    os.remove("out.opus")
+
+
+@ultroid_cmd(pattern="atrim( (.*)|$)")
+async def trim_aud(e):
+    sec = e.pattern_match.group(1).strip()
+    if not sec or "-" not in sec:
+        return await eod(e, get_string("audiotools_3"))
+    a, b = sec.split("-")
+    if int(a) >= int(b):
+        return await eod(e, get_string("audiotools_4"))
+    vido = await e.get_reply_message()
+    if vido and vido.media and mediainfo(vido.media).startswith(("video", "audio")):
+        if hasattr(vido.media, "document"):
+            vfile = vido.media.document
+            name = vido.file.name
+        else:
+            vfile = vido.media
+            name = ""
+        if not name:
+            name = dt.now().isoformat("_", "seconds") + ".mp4"
+        xxx = await e.eor(get_string("audiotools_5"))
+        c_time = time.time()
+        file = await downloader(
+            f"resources/downloads/{name}",
+            vfile,
+            xxx,
+            c_time,
+            f"Downloading {name}...",
+        )
+
+        o_size = os.path.getsize(file.name)
+        d_time = time.time()
+        diff = time_formatter((d_time - c_time) * 1000)
+        file_name = (file.name).split("/")[-1]
+        out = file_name.replace(file_name.split(".")[-1], "_trimmed.aac")
+        if int(b) > int(await genss(file.name)):
+            os.remove(file.name)
+            return await eod(xxx, get_string("audiotools_6"))
+        ss, dd = stdr(int(a)), stdr(int(b))
+        xxx = await xxx.edit(
+            f"Downloaded `{file.name}` of `{humanbytes(o_size)}` in `{diff}`.\n\nNow Trimming Audio from `{ss}` to `{dd}`..."
+        )
+        cmd = f'ffmpeg -i "{file.name}" -preset ultrafast -ss {ss} -to {dd} -vn -acodec copy "{out}" -y'
+        await bash(cmd)
+        os.remove(file.name)
+        f_time = time.time()
+        n_file, _ = await e.client.fast_uploader(
+            out, show_progress=True, event=e, message="Uploading...", to_delete=True
+        )
+        attributes = await set_attributes(out)
+
+        caption = get_string("audiotools_7").format(ss, dd)
+        await e.client.send_file(
+            e.chat_id,
+            n_file,
+            thumb=ULTConfig.thumb,
+            caption=caption,
+            attributes=attributes,
+            force_document=False,
+            reply_to=e.reply_to_msg_id,
+        )
+        await xxx.delete()
+    else:
+        await e.eor(get_string("audiotools_1"), time=5)
+
+
+@ultroid_cmd(pattern="extractaudio$")
+async def ex_aud(e):
+    reply = await e.get_reply_message()
+    if not (reply and reply.media and mediainfo(reply.media).startswith("video")):
+        return await e.eor(get_string("audiotools_8"))
+    name = reply.file.name or "video.mp4"
+    vfile = reply.media.document
+    msg = await e.eor(get_string("com_1"))
+    c_time = time.time()
+    file = await downloader(
+        f"resources/downloads/{name}",
+        vfile,
+        msg,
+        c_time,
+        f"Downloading {name}...",
+    )
+
+    out_file = f"{file.name}.aac"
+    cmd = f"ffmpeg -i {file.name} -vn -acodec copy {out_file}"
+    o, err = await bash(cmd)
+    os.remove(file.name)
+    attributes = await set_attributes(out_file)
+
+    f_time = time.time()
+    try:
+        n_file, _ = await e.client.fast_uploader(
+            out_file, show_progress=True, event=e, message="Uploading...", to_delete=True
+        )
+
+    except FileNotFoundError:
+        return await eor(msg, get_string("audiotools_9"))
+    await e.reply(
+        get_string("audiotools_10"),
+        file=n_file,
+        thumb=ULTConfig.thumb,
+        attributes=attributes,
+    )
+    await msg.delete()

plugins/autoban.py

@@ -0,0 +1,59 @@
+# 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 . import get_help
+
+__doc__ = get_help("help_autoban")
+
+from telethon import events
+
+from pyUltroid.dB.base import KeyManager
+
+from . import LOGS, asst, ultroid_bot, ultroid_cmd
+
+Keym = KeyManager("DND_CHATS", cast=list)
+
+
+def join_func(e):
+    return e.user_joined and Keym.contains(e.chat_id)
+
+
+async def dnd_func(event):
+    for user in event.users:
+        try:
+            await (await event.client.kick_participant(event.chat_id, user)).delete()
+        except Exception as ex:
+            LOGS.error("Error in DND:")
+            LOGS.exception(ex)
+    await event.delete()
+
+
+@ultroid_cmd(
+    pattern="autokick (on|off)$",
+    admins_only=True,
+    manager=True,
+    require="ban_users",
+    fullsudo=True,
+)
+async def _(event):
+    match = event.pattern_match.group(1)
+    if match == "on":
+        if Keym.contains(event.chat_id):
+            return await event.eor("`Chat already in do not disturb mode.`", time=3)
+        Keym.add(event.chat_id)
+        event.client.add_handler(dnd_func, events.ChatAction(func=join_func))
+        await event.eor("`Do not disturb mode activated for this chat.`", time=3)
+    elif match == "off":
+        if not Keym.contains(event.chat_id):
+            return await event.eor("`Chat is not in do not disturb mode.`", time=3)
+        Keym.remove(event.chat_id)
+        await event.eor("`Do not disturb mode deactivated for this chat.`", time=3)
+
+
+if Keym.get():
+    ultroid_bot.add_handler(dnd_func, events.ChatAction(func=join_func))
+    asst.add_handler(dnd_func, events.ChatAction(func=join_func))

plugins/autopic.py

@@ -0,0 +1,84 @@
+# 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 asyncio
+import os
+import random
+from random import shuffle
+
+from telethon.tl.functions.photos import UploadProfilePhotoRequest
+
+from pyUltroid.fns.helper import download_file
+from pyUltroid.fns.tools import get_google_images
+
+from . import LOGS, get_help, get_string, udB, ultroid_bot, ultroid_cmd
+
+__doc__ = get_help("help_autopic")
+
+
+@ultroid_cmd(pattern="autopic( (.*)|$)")
+async def autopic(e):
+    search = e.pattern_match.group(1).strip()
+    if udB.get_key("AUTOPIC") and not search:
+        udB.del_key("AUTOPIC")
+        return await e.eor(get_string("autopic_5"))
+    if not search:
+        return await e.eor(get_string("autopic_1"), time=5)
+    e = await e.eor(get_string("com_1"))
+    gi = googleimagesdownload()
+    args = {
+        "keywords": search,
+        "limit": 50,
+        "format": "jpg",
+        "output_directory": "./resources/downloads/",
+    }
+    try:
+        pth = await gi.download(args)
+        ok = pth[0][search]
+    except Exception as er:
+        LOGS.exception(er)
+        return await e.eor(str(er))
+    if not ok:
+        return await e.eor(get_string("autopic_2").format(search), time=5)
+    await e.eor(get_string("autopic_3").format(search))
+    udB.set_key("AUTOPIC", search)
+    SLEEP_TIME = udB.get_key("SLEEP_TIME") or 1221
+    while True:
+        for lie in ok:
+            if udB.get_key("AUTOPIC") != search:
+                return
+            file = await e.client.upload_file(lie)
+            await e.client(UploadProfilePhotoRequest(file))
+            await asyncio.sleep(SLEEP_TIME)
+        shuffle(ok)
+
+
+if search := udB.get_key("AUTOPIC"):
+    images = {}
+    sleep = udB.get_key("SLEEP_TIME") or 1221
+
+    async def autopic_func():
+        search = udB.get_key("AUTOPIC")
+        if images.get(search) is None:
+            images[search] = await get_google_images(search)
+        if not images.get(search):
+            return
+        img = random.choice(images[search])
+        filee = await download_file(img["original"], "resources/downloads/autopic.jpg")
+        file = await ultroid_bot.upload_file(filee)
+        await ultroid_bot(UploadProfilePhotoRequest(file))
+        os.remove(filee)
+
+    try:
+        from apscheduler.schedulers.asyncio import AsyncIOScheduler
+
+        schedule = AsyncIOScheduler()
+        schedule.add_job(autopic_func, "interval", seconds=sleep)
+        schedule.start()
+    except ModuleNotFoundError as er:
+        LOGS.error(f"autopic: '{er.name}' not installed.")

plugins/beautify.py

@@ -0,0 +1,197 @@
+# 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 . import get_help
+
+__doc__ = get_help("help_beautify")
+
+
+import os
+import random
+
+from telethon.utils import get_display_name
+from urllib.parse import urlencode
+from . import Carbon, ultroid_cmd, get_string, inline_mention
+from secrets import token_hex
+
+_colorspath = "resources/colorlist.txt"
+
+if os.path.exists(_colorspath):
+    with open(_colorspath, "r") as f:
+        all_col = f.read().split()
+else:
+    all_col = []
+
+
+@ultroid_cmd(
+    pattern="(rc|c)arbon",
+)
+async def cr_bn(event):
+    xxxx = await event.eor(get_string("com_1"))
+    te = event.pattern_match.group(1)
+    col = random.choice(all_col) if te[0] == "r" else "White"
+    if event.reply_to_msg_id:
+        temp = await event.get_reply_message()
+        if temp.media:
+            b = await event.client.download_media(temp)
+            with open(b) as a:
+                code = a.read()
+            os.remove(b)
+        else:
+            code = temp.message
+    else:
+        try:
+            code = event.text.split(" ", maxsplit=1)[1]
+        except IndexError:
+            return await xxxx.eor(get_string("carbon_2"))
+    xx = await Carbon(code=code, file_name="ultroid_carbon", backgroundColor=col)
+    if isinstance(xx, dict):
+        await xxxx.edit(f"`{xx}`")
+        return
+    await xxxx.delete()
+    await event.reply(
+        f"Carbonised by {inline_mention(event.sender)}",
+        file=xx,
+    )
+
+
+@ultroid_cmd(
+    pattern="ccarbon( (.*)|$)",
+)
+async def crbn(event):
+    match = event.pattern_match.group(1).strip()
+    if not match:
+        return await event.eor(get_string("carbon_3"))
+    msg = await event.eor(get_string("com_1"))
+    if event.reply_to_msg_id:
+        temp = await event.get_reply_message()
+        if temp.media:
+            b = await event.client.download_media(temp)
+            with open(b) as a:
+                code = a.read()
+            os.remove(b)
+        else:
+            code = temp.message
+    else:
+        try:
+            match = match.split(" ", maxsplit=1)
+            code = match[1]
+            match = match[0]
+        except IndexError:
+            return await msg.eor(get_string("carbon_2"))
+    xx = await Carbon(code=code, backgroundColor=match)
+    await msg.delete()
+    await event.reply(
+        f"Carbonised by {inline_mention(event.sender)}",
+        file=xx,
+    )
+
+
+RaySoTheme = [
+    "meadow",
+    "breeze",
+    "raindrop",
+    "candy",
+    "crimson",
+    "falcon",
+    "sunset",
+    "noir",
+    "midnight",
+    "bitmap",
+    "ice",
+    "sand",
+    "forest",
+    "mono",
+]
+
+
+@ultroid_cmd(pattern="rayso")
+async def pass_on(ult):
+    try:
+        from playwright.async_api import async_playwright
+    except ImportError:
+        await ult.eor(
+            "`playwright` is not installed!\nPlease install it to use this command.."
+        )
+        return
+
+    proc = await ult.eor(get_string("com_1"))
+    spli = ult.text.split()
+    theme, dark, title, text = None, True, get_display_name(ult.chat), None
+    if len(spli) > 1:
+        if spli[1] in RaySoTheme:
+            theme = spli[1]
+            if len(spli) > 2:
+                text = " ".join(spli[2:])
+        else:
+            text = " ".join(spli[1:])
+    if ult.is_reply:
+        try:
+            msg = await ult.get_reply_message()
+            text = msg.message if not text else text
+            title = get_display_name(msg.sender)
+            if not theme and spli[1] in RaySoTheme:
+                theme = spli[1]
+        except Exception as sam:
+            LOGS.exception(sam)    
+    if not text:
+        await proc.eor("No text to beautify!")
+        return
+    if not theme:
+        theme = random.choice(RaySoTheme)
+    cleaned_text = "\n".join([line.strip() for line in text.splitlines()])
+    name = token_hex(8) + ".png"
+    data = {"darkMode": dark, "theme": theme, "title": title}
+    url = f"https://ray.so/#{urlencode(data)}"
+    async with async_playwright() as play:
+        try:
+            browser = await play.chromium.launch()
+            page = await browser.new_page()
+            await page.goto(url)
+            await page.wait_for_load_state("networkidle")
+            try:
+                await page.wait_for_selector(
+                    "div[class*='Editor_editor__']", timeout=60000
+                )
+                editor = await page.query_selector("div[class*='Editor_editor__']")
+                await editor.focus()
+                await editor.click()
+
+                for line in cleaned_text.split("\n"):
+                    await page.keyboard.type(line)
+                    await page.keyboard.press("Enter")
+
+                await page.evaluate(
+                    """() => {
+                    const button = document.querySelector('button[aria-label="Export as PNG"]');
+                    button.click();
+                }"""
+                )
+
+                async with page.expect_download() as download_info:
+                    download = await download_info.value
+                    await download.save_as(name)
+            except playwright._impl._errors.TimeoutError:
+                LOGS.error("Timeout error: Selector not found within 60 seconds.")
+                await proc.eor("Failed to find the editor within 60 seconds.")
+                return
+        except Exception as e:
+            LOGS.error(f"Error occurred during playwright operation: {e}")
+            await proc.eor("An error occurred during the operation.")
+            return
+        finally:
+            if os.path.exists(name):
+                try:
+                    await ult.reply(file=name)
+                    await proc.try_delete()
+                    os.remove(name)
+                except Exception as e:
+                    LOGS.error(f"Error occurred while replying with the file: {e}")
+                    await proc.eor("Failed to send the file.")
+            else:
+                LOGS.error(f"Error: File {name} not found or inaccessible.")
+                await proc.eor("Failed to save the file.")

plugins/blacklist.py

@@ -0,0 +1,69 @@
+# 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 . import get_help
+
+__doc__ = get_help("help_blacklist")
+
+
+from pyUltroid.dB.blacklist_db import (
+    add_blacklist,
+    get_blacklist,
+    list_blacklist,
+    rem_blacklist,
+)
+
+from . import events, get_string, udB, ultroid_bot, ultroid_cmd
+
+
+@ultroid_cmd(pattern="blacklist( (.*)|$)", admins_only=True)
+async def af(e):
+    wrd = e.pattern_match.group(1).strip()
+    chat = e.chat_id
+    if not (wrd):
+        return await e.eor(get_string("blk_1"), time=5)
+    wrd = e.text[11:]
+    heh = wrd.split(" ")
+    for z in heh:
+        add_blacklist(int(chat), z.lower())
+    ultroid_bot.add_handler(blacklist, events.NewMessage(incoming=True))
+    await e.eor(get_string("blk_2").format(wrd))
+
+
+@ultroid_cmd(pattern="remblacklist( (.*)|$)", admins_only=True)
+async def rf(e):
+    wrd = e.pattern_match.group(1).strip()
+    chat = e.chat_id
+    if not wrd:
+        return await e.eor(get_string("blk_3"), time=5)
+    wrd = e.text[14:]
+    heh = wrd.split(" ")
+    for z in heh:
+        rem_blacklist(int(chat), z.lower())
+    await e.eor(get_string("blk_4").format(wrd))
+
+
+@ultroid_cmd(pattern="listblacklist$", admins_only=True)
+async def lsnote(e):
+    if x := list_blacklist(e.chat_id):
+        sd = get_string("blk_5")
+        return await e.eor(sd + x)
+    await e.eor(get_string("blk_6"))
+
+
+async def blacklist(e):
+    if x := get_blacklist(e.chat_id):
+        text = e.text.lower().split()
+        if any((z in text) for z in x):
+            try:
+                await e.delete()
+            except BaseException:
+                pass
+
+
+if udB.get_key("BLACKLIST_DB"):
+    ultroid_bot.add_handler(blacklist, events.NewMessage(incoming=True))

plugins/bot.py

@@ -0,0 +1,366 @@
+# 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 . import get_help
+
+__doc__ = get_help("help_bot")
+
+import os
+import sys
+import time
+from platform import python_version as pyver
+from random import choice
+
+from telethon import __version__
+from telethon.errors.rpcerrorlist import (
+    BotMethodInvalidError,
+    ChatSendMediaForbiddenError,
+)
+
+from pyUltroid.version import __version__ as UltVer
+
+from . import HOSTED_ON, LOGS
+
+try:
+    from git import Repo
+except ImportError:
+    LOGS.error("bot: 'gitpython' module not found!")
+    Repo = None
+
+from telethon.utils import resolve_bot_file_id
+
+from . import (
+    ATRA_COL,
+    LOGS,
+    OWNER_NAME,
+    ULTROID_IMAGES,
+    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,
+)
+
+
+def ULTPIC():
+    return inline_pic() or choice(ULTROID_IMAGES)
+
+
+buttons = [
+    [
+        Button.url(get_string("bot_3"), "https://github.com/TeamUltroid/Ultroid"),
+        Button.url(get_string("bot_4"), "t.me/UltroidSupportChat"),
+    ]
+]
+
+# Will move to strings
+alive_txt = """
+The Ultroid Userbot
+
+  ◍ Version - {}
+  ◍ Py-Ultroid - {}
+  ◍ Telethon - {}
+"""
+
+in_alive = "{}\n\n🌀 <b>Ultroid Version -><b> <code>{}</code>\n🌀 <b>PyUltroid -></b> <code>{}</code>\n🌀 <b>Python -></b> <code>{}</code>\n🌀 <b>Uptime -></b> <code>{}</code>\n🌀 <b>Branch -></b>[ {} ]\n\n• <b>Join @TeamUltroid</b>"
+
+
+@callback("alive")
+async def alive(event):
+    text = alive_txt.format(ultroid_version, UltVer, __version__)
+    await event.answer(text, alert=True)
+
+
+@ultroid_cmd(
+    pattern="alive( (.*)|$)",
+)
+async def lol(ult):
+    match = ult.pattern_match.group(1).strip()
+    inline = None
+    if match in ["inline", "i"]:
+        try:
+            res = await ult.client.inline_query(asst.me.username, "alive")
+            return await res[0].click(ult.chat_id)
+        except BotMethodInvalidError:
+            pass
+        except BaseException as er:
+            LOGS.exception(er)
+        inline = True
+    pic = udB.get_key("ALIVE_PIC")
+    if isinstance(pic, list):
+        pic = choice(pic)
+    uptime = time_formatter((time.time() - start_time) * 1000)
+    header = udB.get_key("ALIVE_TEXT") or get_string("bot_1")
+    y = Repo().active_branch
+    xx = Repo().remotes[0].config_reader.get("url")
+    rep = xx.replace(".git", f"/tree/{y}")
+    kk = f" `[{y}]({rep})` "
+    if inline:
+        kk = f"<a href={rep}>{y}</a>"
+        parse = "html"
+        als = in_alive.format(
+            header,
+            f"{ultroid_version} [{HOSTED_ON}]",
+            UltVer,
+            pyver(),
+            uptime,
+            kk,
+        )
+
+        if _e := udB.get_key("ALIVE_EMOJI"):
+            als = als.replace("🌀", _e)
+    else:
+        parse = "md"
+        als = (get_string("alive_1")).format(
+            header,
+            OWNER_NAME,
+            f"{ultroid_version} [{HOSTED_ON}]",
+            UltVer,
+            uptime,
+            pyver(),
+            __version__,
+            kk,
+        )
+
+        if a := udB.get_key("ALIVE_EMOJI"):
+            als = als.replace("✵", a)
+    if pic:
+        try:
+            await ult.reply(
+                als,
+                file=pic,
+                parse_mode=parse,
+                link_preview=False,
+                buttons=buttons if inline else None,
+            )
+            return await ult.try_delete()
+        except ChatSendMediaForbiddenError:
+            pass
+        except BaseException as er:
+            LOGS.exception(er)
+            try:
+                await ult.reply(file=pic)
+                await ult.reply(
+                    als,
+                    parse_mode=parse,
+                    buttons=buttons if inline else None,
+                    link_preview=False,
+                )
+                return await ult.try_delete()
+            except BaseException as er:
+                LOGS.exception(er)
+    await eor(
+        ult,
+        als,
+        parse_mode=parse,
+        link_preview=False,
+        buttons=buttons if inline else None,
+    )
+
+
+@ultroid_cmd(pattern="ping$", chats=[], type=["official", "assistant"])
+async def _(event):
+    start = time.time()
+    x = await event.eor("Pong !")
+    end = round((time.time() - start) * 1000)
+    uptime = time_formatter((time.time() - start_time) * 1000)
+    await x.edit(get_string("ping").format(end, uptime))
+
+
+@ultroid_cmd(
+    pattern="cmds$",
+)
+async def cmds(event):
+    await allcmds(event, Telegraph)
+
+
+heroku_api = Var.HEROKU_API
+
+
+@ultroid_cmd(
+    pattern="restart$",
+    fullsudo=True,
+)
+async def restartbt(ult):
+    ok = await ult.eor(get_string("bot_5"))
+    call_back()
+    who = "bot" if ult.client._bot else "user"
+    udB.set_key("_RESTART", f"{who}_{ult.chat_id}_{ok.id}")
+    if heroku_api:
+        return await restart(ok)
+    await bash("git pull && pip3 install -r requirements.txt")
+    await bash("pip3 install -r requirements.txt --break-system-packages")
+    if len(sys.argv) > 1:
+        os.execl(sys.executable, sys.executable, "main.py")
+    else:
+        os.execl(sys.executable, sys.executable, "-m", "pyUltroid")
+
+
+@ultroid_cmd(
+    pattern="shutdown$",
+    fullsudo=True,
+)
+async def shutdownbot(ult):
+    await shutdown(ult)
+
+
+@ultroid_cmd(
+    pattern="logs( (.*)|$)",
+    chats=[],
+)
+async def _(event):
+    opt = event.pattern_match.group(1).strip()
+    file = f"ultroid{sys.argv[-1]}.log" if len(sys.argv) > 1 else "ultroid.log"
+    if opt == "heroku":
+        await heroku_logs(event)
+    elif opt == "carbon" and Carbon:
+        event = await event.eor(get_string("com_1"))
+        with open(file, "r") as f:
+            code = f.read()[-2500:]
+        file = await Carbon(
+            file_name="ultroid-logs",
+            code=code,
+            backgroundColor=choice(ATRA_COL),
+        )
+        if isinstance(file, dict):
+            await event.eor(f"`{file}`")
+            return
+        await event.reply("**Ultroid Logs.**", file=file)
+    elif opt == "open":
+        with open("ultroid.log", "r") as f:
+            file = f.read()[-4000:]
+        return await event.eor(f"`{file}`")
+    elif (
+        opt.isdigit() and 5 <= int(opt) <= 100
+    ):  # Check if input is a number between 10 and 100
+        num_lines = int(opt)
+        with open("ultroid.log", "r") as f:
+            lines = f.readlines()[-num_lines:]
+            file = "".join(lines)
+        return await event.eor(f"`{file}`")
+    else:
+        await def_logs(event, file)
+    await event.try_delete()
+
+
+@in_pattern("alive", owner=True)
+async def inline_alive(ult):
+    pic = udB.get_key("ALIVE_PIC")
+    if isinstance(pic, list):
+        pic = choice(pic)
+    uptime = time_formatter((time.time() - start_time) * 1000)
+    header = udB.get_key("ALIVE_TEXT") or get_string("bot_1")
+    y = Repo().active_branch
+    xx = Repo().remotes[0].config_reader.get("url")
+    rep = xx.replace(".git", f"/tree/{y}")
+    kk = f"<a href={rep}>{y}</a>"
+    als = in_alive.format(
+        header, f"{ultroid_version} [{HOSTED_ON}]", UltVer, pyver(), uptime, kk
+    )
+
+    if _e := udB.get_key("ALIVE_EMOJI"):
+        als = als.replace("🌀", _e)
+    builder = ult.builder
+    if pic:
+        try:
+            if ".jpg" in pic:
+                results = [
+                    await builder.photo(
+                        pic, text=als, parse_mode="html", buttons=buttons
+                    )
+                ]
+            else:
+                if _pic := resolve_bot_file_id(pic):
+                    pic = _pic
+                    buttons.insert(
+                        0, [Button.inline(get_string("bot_2"), data="alive")]
+                    )
+                results = [
+                    await builder.document(
+                        pic,
+                        title="Inline Alive",
+                        description="@TeamUltroid",
+                        parse_mode="html",
+                        buttons=buttons,
+                    )
+                ]
+            return await ult.answer(results)
+        except BaseException as er:
+            LOGS.exception(er)
+    result = [
+        await builder.article(
+            "Alive", text=als, parse_mode="html", link_preview=False, buttons=buttons
+        )
+    ]
+    await ult.answer(result)
+
+
+@ultroid_cmd(pattern="update( (.*)|$)")
+async def _(e):
+    xx = await e.eor(get_string("upd_1"))
+    if e.pattern_match.group(1).strip() and (
+        "fast" in e.pattern_match.group(1).strip()
+        or "soft" in e.pattern_match.group(1).strip()
+    ):
+        await bash("git pull -f && pip3 install -r requirements.txt")
+        await bash("pip3 install -r requirements.txt --break-system-packages")
+        call_back()
+        await xx.edit(get_string("upd_7"))
+        os.execl(sys.executable, "python3", "-m", "pyUltroid")
+        # return
+    m = await updater()
+    branch = (Repo.init()).active_branch
+    if m:
+        x = await asst.send_file(
+            udB.get_key("LOG_CHANNEL"),
+            ULTPIC(),
+            caption="• **Update Available** •",
+            force_document=False,
+            buttons=Button.inline("Changelogs", data="changes"),
+        )
+        Link = x.message_link
+        await xx.edit(
+            f'<strong><a href="{Link}">[ChangeLogs]</a></strong>',
+            parse_mode="html",
+            link_preview=False,
+        )
+    else:
+        await xx.edit(
+            f'<code>Your BOT is </code><strong>up-to-date</strong><code> with </code><strong><a href="https://github.com/TeamUltroid/Ultroid/tree/{branch}">[{branch}]</a></strong>',
+            parse_mode="html",
+            link_preview=False,
+        )
+
+
+@callback("updtavail", owner=True)
+async def updava(event):
+    await event.delete()
+    await asst.send_file(
+        udB.get_key("LOG_CHANNEL"),
+        ULTPIC(),
+        caption="• **Update Available** •",
+        force_document=False,
+        buttons=Button.inline("Changelogs", data="changes"),
+    )

plugins/broadcast.py

@@ -0,0 +1,216 @@
+# 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 . import get_help
+
+__doc__ = get_help("help_broadcast")
+
+import asyncio
+import io
+
+from telethon.utils import get_display_name
+
+from pyUltroid.dB.base import KeyManager
+
+from . import HNDLR, LOGS, eor, get_string, udB, ultroid_bot, ultroid_cmd
+
+KeyM = KeyManager("BROADCAST", cast=list)
+
+
+@ultroid_cmd(
+    pattern="addch( (.*)|$)",
+    allow_sudo=False,
+)
+async def broadcast_adder(event):
+    msgg = event.pattern_match.group(1).strip()
+    x = await event.eor(get_string("bd_1"))
+    if msgg == "all":
+        await x.edit(get_string("bd_2"))
+        chats = [
+            e.entity
+            for e in await event.client.get_dialogs()
+            if (e.is_group or e.is_channel)
+        ]
+        new = 0
+        for i in chats:
+            try:
+                if (
+                    i.broadcast
+                    and (i.creator or i.admin_rights)
+                    and not KeyM.contains(i.id)
+                ):
+                    new += 1
+                    cid = f"-100{i.id}"
+                    KeyM.add(int(cid))
+            except Exception as Ex:
+                LOGS.exception(Ex)
+        await x.edit(get_string("bd_3").format(KeyM.count(), new))
+        return
+    if event.reply_to_msg_id:
+        previous_message = await event.get_reply_message()
+        raw_text = previous_message.text
+        lines = raw_text.split("\n")
+        length = len(lines)
+        for line_number in range(1, length - 2):
+            channel_id = lines[line_number][4:-1]
+            if not KeyM.contains(channel_id):
+                KeyM.add(channel_id)
+        await x.edit(get_string("bd_4"))
+        await asyncio.sleep(3)
+        await event.delete()
+        return
+    chat_id = event.chat_id
+    if chat_id == udB.get_key("LOG_CHANNEL"):
+        return
+    if KeyM.contains(chat_id):
+        await x.edit(get_string("bd_6"))
+    elif xx := KeyM.add(chat_id):
+        await x.edit(get_string("bd_5"))
+    else:
+        await x.edit(get_string("sf_8"))
+    await asyncio.sleep(3)
+    await x.delete()
+
+
+@ultroid_cmd(
+    pattern="remch( (.*)|$)",
+    allow_sudo=False,
+)
+async def broadcast_remover(event):
+    chat_id = event.pattern_match.group(1).strip() or event.chat_id
+    x = await event.eor(get_string("com_1"))
+    if chat_id == "all":
+        await x.edit(get_string("bd_8"))
+        udB.del_key("BROADCAST")
+        await x.edit("Database cleared.")
+        return
+    if KeyM.contains(chat_id):
+        KeyM.remove(chat_id)
+        await x.edit(get_string("bd_7"))
+    else:
+        await x.edit(get_string("bd_9"))
+    await asyncio.sleep(3)
+    await x.delete()
+
+
+@ultroid_cmd(
+    pattern="listchannels$",
+)
+async def list_all(event):
+    x = await event.eor(get_string("com_1"))
+    channels = KeyM.get()
+    num = KeyM.count()
+    if not channels:
+        return await eor(x, "No chats were added.", time=5)
+    msg = "Channels in database:\n"
+    for channel in channels:
+        name = ""
+        try:
+            name = get_display_name(await event.client.get_entity(channel))
+        except ValueError:
+            name = ""
+        msg += f"=> **{name}** [`{channel}`]\n"
+    msg += f"\nTotal {num} channels."
+    if len(msg) > 4096:
+        MSG = msg.replace("*", "").replace("`", "")
+        with io.BytesIO(str.encode(MSG)) as out_file:
+            out_file.name = "channels.txt"
+            await event.reply(
+                "Channels in Database",
+                file=out_file,
+                force_document=True,
+                allow_cache=False,
+            )
+            await x.delete()
+    else:
+        await x.edit(msg)
+
+
+@ultroid_cmd(
+    pattern="forward$",
+    allow_sudo=False,
+)
+async def forw(event):
+    if not event.is_reply:
+        return await event.eor(get_string("ex_1"))
+    ultroid_bot = event.client
+    channels = KeyM.get()
+    x = await event.eor("Sending...")
+    if not channels:
+        return await x.edit(f"Please add channels by using `{HNDLR}add` in them.")
+    error_count = 0
+    sent_count = 0
+    previous_message = await event.get_reply_message()
+    error_count = 0
+    for channel in channels:
+        try:
+            await ultroid_bot.forward_messages(channel, previous_message)
+            sent_count += 1
+            await x.edit(
+                f"Sent : {sent_count}\nError : {error_count}\nTotal : {len(channels)}",
+            )
+        except Exception:
+            try:
+                await ultroid_bot.send_message(
+                    udB.get_key("LOG_CHANNEL"),
+                    f"Error in sending at {channel}.",
+                )
+            except Exception as Em:
+                LOGS.info(Em)
+            error_count += 1
+            await x.edit(
+                f"Sent : {sent_count}\nError : {error_count}\nTotal : {len(channels)}",
+            )
+    await x.edit(f"{sent_count} messages sent with {error_count} errors.")
+    if error_count > 0:
+        await ultroid_bot.send_message(
+            udB.get_key("LOG_CHANNEL"), f"{error_count} Errors"
+        )
+
+
+@ultroid_cmd(
+    pattern="broadcast( (.*)|$)",
+    allow_sudo=False,
+)
+async def sending(event):
+    x = await event.eor(get_string("com_1"))
+    if not event.is_reply:
+        return await x.edit(get_string("ex_1"))
+    channels = KeyM.get()
+    if not channels:
+        return await x.edit(f"Please add channels by using `{HNDLR}add` in them.")
+    await x.edit("Sending....")
+    if event.reply_to_msg_id:
+        previous_message = await event.get_reply_message()
+        if previous_message.poll:
+            return await x.edit(f"Reply `{HNDLR}forward` for polls.")
+        if previous_message:
+            error_count = 0
+            sent_count = 0
+            for channel in channels:
+                try:
+                    await ultroid_bot.send_message(channel, previous_message)
+                    sent_count += 1
+                    await x.edit(
+                        f"Sent : {sent_count}\nError : {error_count}\nTotal : {len(channels)}",
+                    )
+                except Exception as error:
+                    await ultroid_bot.send_message(
+                        udB.get_key("LOG_CHANNEL"),
+                        f"Error in sending at {channel}.\n\n{error}",
+                    )
+                    error_count += 1
+                    await x.edit(
+                        f"Sent : {sent_count}\nError : {error_count}\nTotal : {len(channels)}",
+                    )
+            await x.edit(f"{sent_count} messages sent with {error_count} errors.")
+            if error_count > 0:
+                await ultroid_bot.send_message(
+                    udB.get_key("LOG_CHANNEL"),
+                    f"{error_count} Errors",
+                )

plugins/button.py

@@ -0,0 +1,54 @@
+# 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 . import get_help
+
+__doc__ = get_help("help_button")
+
+import os
+
+from . import upload_file as uf
+from telethon.utils import pack_bot_file_id
+
+from pyUltroid.fns.tools import create_tl_btn, get_msg_button
+
+from . import HNDLR, get_string, mediainfo, ultroid_cmd
+from ._inline import something
+
+
+@ultroid_cmd(pattern="button")
+async def butt(event):
+    media, wut, text = None, None, None
+    if event.reply_to:
+        wt = await event.get_reply_message()
+        if wt.text:
+            text = wt.text
+        if wt.media:
+            wut = mediainfo(wt.media)
+        if wut and wut.startswith(("pic", "gif")):
+            dl = await wt.download_media()
+            media = uf(dl)
+        elif wut == "video":
+            if wt.media.document.size > 8 * 1000 * 1000:
+                return await event.eor(get_string("com_4"), time=5)
+            dl = await wt.download_media()
+            media = uf(dl)
+            os.remove(dl)
+        else:
+            media = pack_bot_file_id(wt.media)
+    try:
+        text = event.text.split(maxsplit=1)[1]
+    except IndexError:
+        if not text:
+            return await event.eor(
+                f"**Please give some text in correct format.**\n\n`{HNDLR}help button`",
+            )
+    text, buttons = get_msg_button(text)
+    if buttons:
+        buttons = create_tl_btn(buttons)
+    await something(event, text, media, buttons)
+    await event.delete()

plugins/calculator.py

@@ -0,0 +1,153 @@
+# 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 . import get_help
+
+__doc__ = get_help("help_calculator")
+
+import re
+
+from . import Button, asst, callback, get_string, in_pattern, udB, ultroid_cmd
+
+CALC = {}
+
+m = [
+    "AC",
+    "C",
+    "⌫",
+    "%",
+    "7",
+    "8",
+    "9",
+    "+",
+    "4",
+    "5",
+    "6",
+    "-",
+    "1",
+    "2",
+    "3",
+    "x",
+    "00",
+    "0",
+    ".",
+    "÷",
+]
+tultd = [Button.inline(f"{x}", data=f"calc{x}") for x in m]
+lst = list(zip(tultd[::4], tultd[1::4], tultd[2::4], tultd[3::4]))
+lst.append([Button.inline("=", data="calc=")])
+
+
+@ultroid_cmd(pattern="calc")
+async def icalc(e):
+    udB.del_key("calc")
+    if e.client._bot:
+        return await e.reply(get_string("calc_1"), buttons=lst)
+    results = await e.client.inline_query(asst.me.username, "calc")
+    await results[0].click(e.chat_id, silent=True, hide_via=True)
+    await e.delete()
+
+
+@in_pattern("calc", owner=True)
+async def _(e):
+    calc = e.builder.article("Calc", text=get_string("calc_1"), buttons=lst)
+    await e.answer([calc])
+
+
+@callback(re.compile("calc(.*)"), owner=True)
+async def _(e):
+    x = (e.data_match.group(1)).decode()
+    user = e.query.user_id
+    get = None
+    if x == "AC":
+        if CALC.get(user):
+            CALC.pop(user)
+        await e.edit(
+            get_string("calc_1"),
+            buttons=[Button.inline(get_string("calc_2"), data="recalc")],
+        )
+    elif x == "C":
+        if CALC.get(user):
+            CALC.pop(user)
+        await e.answer("cleared")
+    elif x == "⌫":
+        if CALC.get(user):
+            get = CALC[user]
+        if get:
+            CALC.update({user: get[:-1]})
+            await e.answer(str(get[:-1]))
+    elif x == "%":
+        if CALC.get(user):
+            get = CALC[user]
+        if get:
+            CALC.update({user: f"{get}/100"})
+            await e.answer(str(f"{get}/100"))
+    elif x == "÷":
+        if CALC.get(user):
+            get = CALC[user]
+        if get:
+            CALC.update({user: f"{get}/"})
+            await e.answer(str(f"{get}/"))
+    elif x == "x":
+        if CALC.get(user):
+            get = CALC[user]
+        if get:
+            CALC.update({user: f"{get}*"})
+            await e.answer(str(f"{get}*"))
+    elif x == "=":
+        if CALC.get(user):
+            get = CALC[user]
+        if get:
+            if get.endswith(("*", ".", "/", "-", "+")):
+                get = get[:-1]
+            out = eval(get)
+            try:
+                num = float(out)
+                await e.answer(f"Answer : {num}", cache_time=0, alert=True)
+            except BaseException:
+                CALC.pop(user)
+                await e.answer(get_string("sf_8"), cache_time=0, alert=True)
+        await e.answer("None")
+    else:
+        if CALC.get(user):
+            get = CALC[user]
+        if get:
+            CALC.update({user: get + x})
+            return await e.answer(str(get + x))
+        CALC.update({user: x})
+        await e.answer(str(x))
+
+
+@callback("recalc", owner=True)
+async def _(e):
+    m = [
+        "AC",
+        "C",
+        "⌫",
+        "%",
+        "7",
+        "8",
+        "9",
+        "+",
+        "4",
+        "5",
+        "6",
+        "-",
+        "1",
+        "2",
+        "3",
+        "x",
+        "00",
+        "0",
+        ".",
+        "÷",
+    ]
+    tultd = [Button.inline(f"{x}", data=f"calc{x}") for x in m]
+    lst = list(zip(tultd[::4], tultd[1::4], tultd[2::4], tultd[3::4]))
+    lst.append([Button.inline("=", data="calc=")])
+    await e.edit(get_string("calc_1"), buttons=lst)

plugins/channelhacks.py

@@ -0,0 +1,224 @@
+# 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 . import get_help
+
+__doc__ = get_help("help_channelhacks")
+
+
+import asyncio
+import io
+
+from telethon.errors.rpcerrorlist import FloodWaitError
+from telethon.utils import get_display_name, get_peer_id
+
+from pyUltroid.dB.base import KeyManager
+
+from . import LOGS, asst, eor, events, get_string, udB, ultroid_bot, ultroid_cmd
+
+ERROR = {}
+SourceM = KeyManager("CH_SOURCE", cast=list)
+DestiM = KeyManager("CH_DESTINATIONS", cast=list)
+
+
+async def autopost_func(e):
+    if not udB.get_key("AUTOPOST"):
+        return
+    x = SourceM.get()
+    th = await e.get_chat()
+    if get_peer_id(th) not in x:
+        return
+    y = DestiM.get()
+    for ys in y:
+        try:
+            await e.client.send_message(int(ys), e.message)
+        except Exception as ex:
+            try:
+                ERROR[str(ex)]
+            except KeyError:
+                ERROR.update({str(ex): ex})
+                Error = f"**Error on AUTOPOST**\n\n`{ex}`"
+                await asst.send_message(udB.get_key("LOG_CHANNEL"), Error)
+
+
+@ultroid_cmd(pattern="shift (.*)")
+async def _(e):
+    x = e.pattern_match.group(1).strip()
+    z = await e.eor(get_string("com_1"))
+    a, b = x.split("|")
+    try:
+        c = await e.client.parse_id(a)
+    except Exception:
+        await z.edit(get_string("cha_1"))
+        return
+    try:
+        d = await e.client.parse_id(b)
+    except Exception as er:
+        LOGS.exception(er)
+        await z.edit(get_string("cha_1"))
+        return
+    async for msg in e.client.iter_messages(int(c), reverse=True):
+        try:
+            await asyncio.sleep(2)
+            await e.client.send_message(int(d), msg)
+        except FloodWaitError as er:
+            await asyncio.sleep(er.seconds + 5)
+            await e.client.send_message(int(d), msg)
+        except BaseException as er:
+            LOGS.exception(er)
+    await z.edit("Done")
+
+
+@ultroid_cmd(pattern="asource (.*)")
+async def source(e):
+    if x := e.pattern_match.group(1).strip():
+        try:
+            y = await e.client.parse_id(x)
+        except Exception as er:
+            LOGS.exception(er)
+            return
+    else:
+        y = e.chat_id
+    if not SourceM.contains(y):
+        SourceM.add(y)
+        await e.eor(get_string("cha_2"))
+        ultroid_bot.add_handler(autopost_func, events.NewMessage())
+    else:
+        await e.eor(get_string("cha_3"))
+
+
+@ultroid_cmd(pattern="dsource( (.*)|$)")
+async def dd(event):
+    chat_id = event.pattern_match.group(1).strip()
+    x = await event.eor(get_string("com_1"))
+    if chat_id == "all":
+        await x.edit(get_string("bd_8"))
+        udB.del_key("CH_SOURCE")
+        await x.edit(get_string("cha_4"))
+        return
+    if chat_id:
+        try:
+            y = await event.client.parse_id(chat_id)
+        except Exception as er:
+            LOGS.exception(er)
+            return
+    else:
+        y = event.chat_id
+    if SourceM.contains(y):
+        SourceM.remove(y)
+        await eor(x, get_string("cha_5"), time=5)
+    else:
+        await eor(x, "Source channel is already removed from database. ", time=3)
+
+
+@ultroid_cmd(pattern="listsource")
+async def list_all(event):
+    x = await event.eor(get_string("com_1"))
+    num = SourceM.count()
+    if not num:
+        return await eor(x, "No chats were added.", time=5)
+    msg = get_string("cha_8")
+    channels = SourceM.get()
+    for channel in channels:
+        name = ""
+        try:
+            name = get_display_name(await event.client.get_entity(int(channel)))
+        except BaseException:
+            name = ""
+        msg += f"\n=> **{name}** [`{channel}`]"
+    msg += f"\nTotal {num} channels."
+    if len(msg) > 4096:
+        MSG = msg.replace("*", "").replace("`", "")
+        with io.BytesIO(str.encode(MSG)) as out_file:
+            out_file.name = "channels.txt"
+            await event.reply(
+                "Channels in database",
+                file=out_file,
+                force_document=True,
+                allow_cache=False,
+            )
+            await x.delete()
+    else:
+        await x.edit(msg)
+
+
+@ultroid_cmd(pattern="adest (.*)")
+async def destination(e):
+    if x := e.pattern_match.group(1).strip():
+        try:
+            y = await e.client.parse_id(x)
+        except Exception as er:
+            LOGS.exception(er)
+            return
+    else:
+        y = e.chat_id
+    if not DestiM.contains(y):
+        DestiM.add(y)
+        await e.eor("Destination added succesfully")
+    else:
+        await e.eor("Destination channel already added")
+
+
+@ultroid_cmd(pattern="ddest( (.*)|$)")
+async def dd(event):
+    chat_id = event.pattern_match.group(1).strip()
+    x = await event.eor(get_string("com_1"))
+    if chat_id == "all":
+        await x.edit(get_string("bd_8"))
+        udB.del_key("CH_DESTINATION")
+        await x.edit("Destinations database cleared.")
+        return
+    if chat_id:
+        try:
+            y = await event.client.parse_id(chat_id)
+        except Exception as er:
+            LOGS.exception(er)
+            return
+    else:
+        y = event.chat_id
+    if DestiM.contains(y):
+        DestiM.remove(y)
+        await eor(x, "Destination removed from database")
+    else:
+        await eor(x, "Destination channel is already removed from database. ", time=5)
+
+
+@ultroid_cmd(pattern="listdest")
+async def list_all(event):
+    ultroid_bot = event.client
+    x = await event.eor(get_string("com_1"))
+    channels = DestiM.get()
+    num = len(channels)
+    if not num:
+        return await eor(x, "No chats were added.", time=5)
+    msg = get_string("cha_7")
+    for channel in channels:
+        name = ""
+        try:
+            name = get_display_name(await ultroid_bot.get_entity(int(channel)))
+        except BaseException:
+            name = ""
+        msg += f"\n=> **{name}** [`{channel}`]"
+    msg += f"\nTotal {num} channels."
+    if len(msg) > 4096:
+        MSG = msg.replace("*", "").replace("`", "")
+        with io.BytesIO(str.encode(MSG)) as out_file:
+            out_file.name = "channels.txt"
+            await ultroid_bot.send_file(
+                event.chat_id,
+                out_file,
+                force_document=True,
+                allow_cache=False,
+                caption="Destination channels in database",
+                reply_to=event,
+            )
+            await x.delete()
+    else:
+        await x.edit(msg)
+
+
+if udB.get_key("AUTOPOST"):
+    ultroid_bot.add_handler(autopost_func, events.NewMessage())

plugins/chatbot.py

@@ -0,0 +1,89 @@
+# 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 . import get_help
+
+__doc__ = get_help("help_chatbot")
+
+
+from pyUltroid.fns.tools import get_chatbot_reply
+
+from . import LOGS, eod, get_string, inline_mention, udB, ultroid_cmd
+
+
+@ultroid_cmd(pattern="repai")
+async def im_lonely_chat_with_me(event):
+    if event.reply_to:
+        message = (await event.get_reply_message()).message
+    else:
+        try:
+            message = event.text.split(" ", 1)[1]
+        except IndexError:
+            return await eod(event, get_string("tban_1"), time=10)
+    reply_ = await get_chatbot_reply(message=message)
+    await event.eor(reply_)
+
+
+@ultroid_cmd(pattern="addai")
+async def add_chatBot(event):
+    await chat_bot_fn(event, type_="add")
+
+
+@ultroid_cmd(pattern="remai")
+async def rem_chatBot(event):
+    await chat_bot_fn(event, type_="remov")
+
+
+@ultroid_cmd(pattern="listai")
+async def lister(event):
+    key = udB.get_key("CHATBOT_USERS") or {}
+    users = key.get(event.chat_id, [])
+    if not users:
+        return await event.eor(get_string("chab_2"), time=5)
+    msg = "**Total List Of AI Enabled Users In This Chat :**\n\n"
+    for i in users:
+        try:
+            user = await event.client.get_entity(int(i))
+            user = inline_mention(user)
+        except BaseException:
+            user = f"`{i}`"
+        msg += f"• {user}\n"
+    await event.eor(msg, link_preview=False)
+
+
+async def chat_bot_fn(event, type_):
+    if event.reply_to:
+        user_ = (await event.get_reply_message()).sender
+    else:
+        temp = event.text.split(maxsplit=1)
+        try:
+            user_ = await event.client.get_entity(await event.client.parse_id(temp[1]))
+        except BaseException as er:
+            LOGS.exception(er)
+            user_ = event.chat if event.is_private else None
+    if not user_:
+        return await eod(
+            event,
+            get_string("chab_1"),
+        )
+    key = udB.get_key("CHATBOT_USERS") or {}
+    chat = event.chat_id
+    user = user_.id
+    if type_ == "add":
+        if key.get(chat):
+            if user not in key[chat]:
+                key[chat].append(user)
+        else:
+            key.update({chat: [user]})
+    elif type_ == "remov":
+        if key.get(chat):
+            if user in key[chat]:
+                key[chat].remove(user)
+            if chat in key and not key[chat]:
+                del key[chat]
+    udB.set_key("CHATBOT_USERS", key)
+    await event.eor(f"**ChatBot:**\n{type_}ed {inline_mention(user_)}")

plugins/chats.py

@@ -0,0 +1,368 @@
+# 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 . import get_help
+
+__doc__ = get_help("help_chats")
+
+
+from telethon.errors import ChatAdminRequiredError as no_admin
+from telethon.tl.functions.channels import (
+    CreateChannelRequest,
+    DeleteChannelRequest,
+    EditPhotoRequest,
+    GetFullChannelRequest,
+    UpdateUsernameRequest,
+)
+from telethon.tl.functions.messages import (
+    CreateChatRequest,
+    ExportChatInviteRequest,
+    GetFullChatRequest,
+)
+from telethon.tl.types import (
+    ChannelParticipantsKicked,
+    User,
+    UserStatusEmpty,
+    UserStatusLastMonth,
+    UserStatusLastWeek,
+    UserStatusOffline,
+    UserStatusOnline,
+    UserStatusRecently,
+)
+
+from . import HNDLR, LOGS, asst, con, get_string, mediainfo, os, types, udB, ultroid_cmd
+
+
+@ultroid_cmd(
+    pattern="delchat",
+    groups_only=True,
+)
+async def _(e):
+    xx = await e.eor(get_string("com_1"))
+    try:
+        match = e.text.split(" ", maxsplit=1)[1]
+        chat = await e.client.parse_id(match)
+    except IndexError:
+        chat = e.chat_id
+    try:
+        await e.client(DeleteChannelRequest(chat))
+    except TypeError:
+        return await xx.eor(get_string("chats_1"), time=10)
+    except no_admin:
+        return await xx.eor(get_string("chats_2"), time=10)
+    await e.client.send_message(
+        int(udB.get_key("LOG_CHANNEL")), get_string("chats_6").format(e.chat_id)
+    )
+
+
+@ultroid_cmd(
+    pattern="getlink( (.*)|$)",
+    groups_only=True,
+    manager=True,
+)
+async def _(e):
+    reply = await e.get_reply_message()
+    match = e.pattern_match.group(1).strip()
+    if reply and not isinstance(reply.sender, User):
+        chat = await reply.get_sender()
+    else:
+        chat = await e.get_chat()
+    if hasattr(chat, "username") and chat.username:
+        return await e.eor(f"Username: @{chat.username}")
+    request, usage, title, link = None, None, None, None
+    if match:
+        split = match.split(maxsplit=1)
+        request = split[0] in ["r", "request"]
+        title = "Created by Ultroid"
+        if len(split) > 1:
+            match = split[1]
+            spli = match.split(maxsplit=1)
+            if spli[0].isdigit():
+                usage = int(spli[0])
+            if len(spli) > 1:
+                title = spli[1]
+        elif not request:
+            if match.isdigit():
+                usage = int(match)
+            else:
+                title = match
+        if request and usage:
+            usage = 0
+    if request or title:
+        try:
+            r = await e.client(
+                ExportChatInviteRequest(
+                    e.chat_id,
+                    request_needed=request,
+                    usage_limit=usage,
+                    title=title,
+                ),
+            )
+        except no_admin:
+            return await e.eor(get_string("chats_2"), time=10)
+        link = r.link
+    else:
+        if isinstance(chat, types.Chat):
+            FC = await e.client(GetFullChatRequest(chat.id))
+        elif isinstance(chat, types.Channel):
+            FC = await e.client(GetFullChannelRequest(chat.id))
+        else:
+            return
+        Inv = FC.full_chat.exported_invite
+        if Inv and not Inv.revoked:
+            link = Inv.link
+    if link:
+        return await e.eor(f"Link:- {link}")
+    await e.eor("`Failed to getlink!\nSeems like link is inaccessible to you...`")
+
+
+@ultroid_cmd(
+    pattern="create (b|g|c)(?: |$)(.*)",
+)
+async def _(e):
+    type_of_group = e.pattern_match.group(1).strip()
+    group_name = e.pattern_match.group(2)
+    username = None
+    if " ; " in group_name:
+        group_ = group_name.split(" ; ", maxsplit=1)
+        group_name = group_[0]
+        username = group_[1]
+    xx = await e.eor(get_string("com_1"))
+    if type_of_group == "b":
+        try:
+            r = await e.client(
+                CreateChatRequest(
+                    users=[asst.me.username],
+                    title=group_name,
+                ),
+            )
+            created_chat_id = r.chats[0].id
+            result = await e.client(
+                ExportChatInviteRequest(
+                    peer=created_chat_id,
+                ),
+            )
+            await xx.edit(
+                get_string("chats_4").format(group_name, result.link),
+                link_preview=False,
+            )
+        except Exception as ex:
+            await xx.edit(str(ex))
+    elif type_of_group in ["g", "c"]:
+        try:
+            r = await e.client(
+                CreateChannelRequest(
+                    title=group_name,
+                    about=get_string("chats_5"),
+                    megagroup=type_of_group != "c",
+                )
+            )
+
+            created_chat_id = r.chats[0].id
+            if username:
+                await e.client(UpdateUsernameRequest(created_chat_id, username))
+                result = f"https://t.me/{username}"
+            else:
+                result = (
+                    await e.client(
+                        ExportChatInviteRequest(
+                            peer=created_chat_id,
+                        ),
+                    )
+                ).link
+            await xx.edit(
+                get_string("chats_6").format(f"[{group_name}]({result})"),
+                link_preview=False,
+            )
+        except Exception as ex:
+            await xx.edit(str(ex))
+
+
+# ---------------------------------------------------------------- #
+
+
+@ultroid_cmd(
+    pattern="setgpic( (.*)|$)", admins_only=True, manager=True, require="change_info"
+)
+async def _(ult):
+    if not ult.is_reply:
+        return await ult.eor("`Reply to a Media..`", time=5)
+    match = ult.pattern_match.group(1).strip()
+    if not ult.client._bot and match:
+        try:
+            chat = await ult.client.parse_id(match)
+        except Exception as ok:
+            return await ult.eor(str(ok))
+    else:
+        chat = ult.chat_id
+    reply = await ult.get_reply_message()
+    if reply.photo or reply.sticker or reply.video:
+        replfile = await reply.download_media()
+    elif reply.document and reply.document.thumbs:
+        replfile = await reply.download_media(thumb=-1)
+    else:
+        return await ult.eor("Reply to a Photo or Video..")
+    mediain = mediainfo(reply.media)
+    if "animated" in mediain:
+        replfile = await con.convert(replfile, convert_to="mp4")
+    else:
+        replfile = await con.convert(
+            replfile, outname="chatphoto", allowed_formats=["jpg", "png", "mp4"]
+        )
+    file = await ult.client.upload_file(replfile)
+    try:
+        if "pic" not in mediain:
+            file = types.InputChatUploadedPhoto(video=file)
+        await ult.client(EditPhotoRequest(chat, file))
+        await ult.eor("`Group Photo has Successfully Changed !`", time=5)
+    except Exception as ex:
+        await ult.eor(f"Error occured.\n`{str(ex)}`", time=5)
+    os.remove(replfile)
+
+
+@ultroid_cmd(
+    pattern="delgpic( (.*)|$)", admins_only=True, manager=True, require="change_info"
+)
+async def _(ult):
+    match = ult.pattern_match.group(1).strip()
+    chat = ult.chat_id
+    if not ult.client._bot and match:
+        chat = match
+    try:
+        await ult.client(EditPhotoRequest(chat, types.InputChatPhotoEmpty()))
+        text = "`Removed Chat Photo..`"
+    except Exception as E:
+        text = str(E)
+    return await ult.eor(text, time=5)
+
+
+@ultroid_cmd(pattern="unbanall$", manager=True, admins_only=True, require="ban_users")
+async def _(event):
+    xx = await event.eor("Searching Participant Lists.")
+    p = 0
+    title = (await event.get_chat()).title
+    async for i in event.client.iter_participants(
+        event.chat_id,
+        filter=ChannelParticipantsKicked,
+        aggressive=True,
+    ):
+        try:
+            await event.client.edit_permissions(event.chat_id, i, view_messages=True)
+            p += 1
+        except no_admin:
+            pass
+        except BaseException as er:
+            LOGS.exception(er)
+    await xx.eor(f"{title}: {p} unbanned", time=5)
+
+
+@ultroid_cmd(
+    pattern="rmusers( (.*)|$)",
+    groups_only=True,
+    admins_only=True,
+    fullsudo=True,
+)
+async def _(event):
+    xx = await event.eor(get_string("com_1"))
+    input_str = event.pattern_match.group(1).strip()
+    p, a, b, c, d, m, n, y, w, o, q, r = 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
+    async for i in event.client.iter_participants(event.chat_id):
+        p += 1  # Total Count
+        if isinstance(i.status, UserStatusEmpty):
+            if "empty" in input_str:
+                try:
+                    await event.client.kick_participant(event.chat_id, i)
+                    c += 1
+                except BaseException:
+                    pass
+            else:
+                y += 1
+        if isinstance(i.status, UserStatusLastMonth):
+            if "month" in input_str:
+                try:
+                    await event.client.kick_participant(event.chat_id, i)
+                    c += 1
+                except BaseException:
+                    pass
+            else:
+                m += 1
+        if isinstance(i.status, UserStatusLastWeek):
+            if "week" in input_str:
+                try:
+                    await event.client.kick_participant(event.chat_id, i)
+                    c += 1
+                except BaseException:
+                    pass
+            else:
+                w += 1
+        if isinstance(i.status, UserStatusOffline):
+            if "offline" in input_str:
+                try:
+                    await event.client.kick_participant(event.chat_id, i)
+                    c += 1
+                except BaseException:
+                    pass
+            else:
+                o += 1
+        if isinstance(i.status, UserStatusOnline):
+            if "online" in input_str:
+                try:
+                    await event.client.kick_participant(event.chat_id, i)
+                    c += 1
+                except BaseException:
+                    pass
+            else:
+                q += 1
+        if isinstance(i.status, UserStatusRecently):
+            if "recently" in input_str:
+                try:
+                    await event.client.kick_participant(event.chat_id, i)
+                    c += 1
+                except BaseException:
+                    pass
+            else:
+                r += 1
+        if i.bot:
+            if "bot" in input_str:
+                try:
+                    await event.client.kick_participant(event.chat_id, i)
+                    c += 1
+                except BaseException:
+                    pass
+            else:
+                b += 1
+        elif i.deleted:
+            if "deleted" in input_str:
+                try:
+                    await event.client.kick_participant(event.chat_id, i)
+                    c += 1
+                except BaseException:
+                    pass
+            else:
+                d += 1
+        elif i.status is None:
+            if "none" in input_str:
+                try:
+                    await event.client.kick_participant(event.chat_id, i)
+                    c += 1
+                except BaseException:
+                    pass
+            else:
+                n += 1
+    if input_str:
+        required_string = f"**>> Kicked** `{c} / {p}` **users**\n\n"
+    else:
+        required_string = f"**>> Total** `{p}` **users**\n\n"
+    required_string += f"  `{HNDLR}rmusers deleted`  **••**  `{d}`\n"
+    required_string += f"  `{HNDLR}rmusers empty`  **••**  `{y}`\n"
+    required_string += f"  `{HNDLR}rmusers month`  **••**  `{m}`\n"
+    required_string += f"  `{HNDLR}rmusers week`  **••**  `{w}`\n"
+    required_string += f"  `{HNDLR}rmusers offline`  **••**  `{o}`\n"
+    required_string += f"  `{HNDLR}rmusers online`  **••**  `{q}`\n"
+    required_string += f"  `{HNDLR}rmusers recently`  **••**  `{r}`\n"
+    required_string += f"  `{HNDLR}rmusers bot`  **••**  `{b}`\n"
+    required_string += f"  `{HNDLR}rmusers none`  **••**  `{n}`"
+    await xx.eor(required_string)

plugins/cleanaction.py

@@ -0,0 +1,48 @@
+# 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 . import get_help
+
+__doc__ = get_help("help_cleanaction")
+
+
+from telethon.utils import get_display_name
+
+from . import get_string, udB, ultroid_cmd
+
+
+@ultroid_cmd(pattern="addclean$", admins_only=True)
+async def _(e):
+    key = udB.get_key("CLEANCHAT") or []
+    if e.chat_id in key:
+        return await eod(e, get_string("clan_5"))
+    key.append(e.chat_id)
+    udB.set_key("CLEANCHAT", key)
+    await e.eor(get_string("clan_1"), time=5)
+
+
+@ultroid_cmd(pattern="remclean$")
+async def _(e):
+    key = udB.get_key("CLEANCHAT") or []
+    if e.chat_id in key:
+        key.remove(e.chat_id)
+        udB.set_key("CLEANCHAT", key)
+    await e.eor(get_string("clan_2"), time=5)
+
+
+@ultroid_cmd(pattern="listclean$")
+async def _(e):
+    if k := udB.get_key("CLEANCHAT"):
+        o = ""
+        for x in k:
+            try:
+                title = get_display_name(await e.client.get_entity(x))
+            except BaseException:
+                title = get_string("clan_3")
+            o += f"{x} {title}\n"
+        return await e.eor(o)
+    await e.eor(get_string("clan_4"), time=5)

plugins/compressor.py

@@ -0,0 +1,177 @@
+# 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 . import get_help
+
+__doc__ = get_help("help_compressor")
+
+
+import asyncio
+import os
+import re
+import time
+from datetime import datetime as dt
+
+from telethon.errors.rpcerrorlist import MessageNotModifiedError
+from telethon.tl.types import DocumentAttributeVideo
+
+from pyUltroid.fns.tools import metadata
+
+from . import (
+    ULTConfig,
+    bash,
+    downloader,
+    get_string,
+    humanbytes,
+    math,
+    mediainfo,
+    time_formatter,
+    ultroid_cmd,
+    uploader,
+)
+
+
+@ultroid_cmd(pattern="compress( (.*)|$)")
+async def _(e):
+    cr = e.pattern_match.group(1).strip()
+    crf = 27
+    to_stream = False
+    if cr:
+        k = e.text.split()
+        if len(k) == 2:
+            crf = int(k[1]) if k[1].isdigit() else 27
+        elif len(k) > 2:
+            crf = int(k[1]) if k[1].isdigit() else 27
+            to_stream = "stream" in k[2]
+    vido = await e.get_reply_message()
+    if vido and vido.media and "video" in mediainfo(vido.media):
+        if hasattr(vido.media, "document"):
+            vfile = vido.media.document
+            name = vido.file.name
+        else:
+            vfile = vido.media
+            name = ""
+        if not name:
+            name = "video_" + dt.now().isoformat("_", "seconds") + ".mp4"
+        xxx = await e.eor(get_string("audiotools_5"))
+        c_time = time.time()
+        file = await downloader(
+            f"resources/downloads/{name}",
+            vfile,
+            xxx,
+            c_time,
+            f"Downloading {name}...",
+        )
+
+        o_size = os.path.getsize(file.name)
+        d_time = time.time()
+        diff = time_formatter((d_time - c_time) * 1000)
+        file_name = (file.name).split("/")[-1]
+        out = file_name.replace(file_name.split(".")[-1], "compressed.mkv")
+        await xxx.edit(
+            f"`Downloaded {file.name} of {humanbytes(o_size)} in {diff}.\nNow Compressing...`"
+        )
+        x, y = await bash(
+            f'mediainfo --fullscan """{file.name}""" | grep "Frame count"'
+        )
+        if y and y.endswith("NOT_FOUND"):
+            return await xxx.edit(f"ERROR: `{y}`")
+        total_frames = x.split(":")[1].split("\n")[0]
+        progress = f"progress-{c_time}.txt"
+        with open(progress, "w"):
+            pass
+        proce = await asyncio.create_subprocess_shell(
+            f'ffmpeg -hide_banner -loglevel quiet -progress {progress} -i """{file.name}""" -preset ultrafast -vcodec libx265 -crf {crf} -c:a copy """{out}""" -y',
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+        )
+        while proce.returncode != 0:
+            await asyncio.sleep(3)
+            with open(progress, "r+") as fil:
+                text = fil.read()
+                frames = re.findall("frame=(\\d+)", text)
+                size = re.findall("total_size=(\\d+)", text)
+                speed = 0
+                if len(frames):
+                    elapse = int(frames[-1])
+                if len(size):
+                    size = int(size[-1])
+                    per = elapse * 100 / int(total_frames)
+                    time_diff = time.time() - int(d_time)
+                    speed = round(elapse / time_diff, 2)
+                if int(speed) != 0:
+                    some_eta = ((int(total_frames) - elapse) / speed) * 1000
+                    text = f"`Compressing {file_name} at {crf} CRF.\n`"
+                    progress_str = "`[{0}{1}] {2}%\n\n`".format(
+                        "".join("●" for _ in range(math.floor(per / 5))),
+                        "".join("" for _ in range(20 - math.floor(per / 5))),
+                        round(per, 2),
+                    )
+
+                    e_size = f"{humanbytes(size)} of ~{humanbytes((size / per) * 100)}"
+                    eta = f"~{time_formatter(some_eta)}"
+                    try:
+                        await xxx.edit(
+                            text
+                            + progress_str
+                            + "`"
+                            + e_size
+                            + "`"
+                            + "\n\n`"
+                            + eta
+                            + "`"
+                        )
+                    except MessageNotModifiedError:
+                        pass
+        os.remove(file.name)
+        c_size = os.path.getsize(out)
+        f_time = time.time()
+        difff = time_formatter((f_time - d_time) * 1000)
+        await xxx.edit(
+            f"`Compressed {humanbytes(o_size)} to {humanbytes(c_size)} in {difff}\nTrying to Upload...`"
+        )
+        differ = 100 - ((c_size / o_size) * 100)
+        caption = f"**Original Size: **`{humanbytes(o_size)}`\n"
+        caption += f"**Compressed Size: **`{humanbytes(c_size)}`\n"
+        caption += f"**Compression Ratio: **`{differ:.2f}%`\n"
+        caption += f"\n**Time Taken To Compress: **`{difff}`"
+        n_file, _ = await e.client.fast_uploader(
+            out, show_progress=True, event=e, message="Uploading...", to_delete=True
+        )
+        if to_stream:
+            data = await metadata(out)
+            width = data["width"]
+            height = data["height"]
+            duration = data["duration"]
+            attributes = [
+                DocumentAttributeVideo(
+                    duration=duration, w=width, h=height, supports_streaming=True
+                )
+            ]
+            await e.client.send_file(
+                e.chat_id,
+                n_file,
+                thumb=ULTConfig.thumb,
+                caption=caption,
+                attributes=attributes,
+                force_document=False,
+                reply_to=e.reply_to_msg_id,
+            )
+        else:
+            await e.client.send_file(
+                e.chat_id,
+                n_file,
+                thumb=ULTConfig.thumb,
+                caption=caption,
+                force_document=True,
+                reply_to=e.reply_to_msg_id,
+            )
+            await xxx.delete()
+            os.remove(out)
+            os.remove(progress)
+    else:
+        await e.eor(get_string("audiotools_8"), time=5)

plugins/converter.py

@@ -0,0 +1,196 @@
+# 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 . import get_help
+
+__doc__ = get_help("help_converter")
+
+import os
+import time
+
+from . import LOGS
+
+try:
+    import cv2
+except ImportError:
+    cv2 = None
+
+try:
+    from PIL import Image
+except ImportError:
+    LOGS.info(f"{__file__}: PIL  not Installed.")
+    Image = None
+
+from . import upload_file as uf
+
+from . import (
+    ULTConfig,
+    bash,
+    con,
+    downloader,
+    get_paste,
+    get_string,
+    udB,
+    ultroid_cmd,
+    uploader,
+)
+
+opn = []
+
+
+@ultroid_cmd(
+    pattern="thumbnail$",
+)
+async def _(e):
+    r = await e.get_reply_message()
+    if r.photo:
+        dl = await r.download_media()
+    elif r.document and r.document.thumbs:
+        dl = await r.download_media(thumb=-1)
+    else:
+        return await e.eor("`Reply to Photo or media with thumb...`")
+    nn = uf(dl)
+    os.remove(dl)
+    udB.set_key("CUSTOM_THUMBNAIL", str(nn))
+    await bash(f"wget {nn} -O resources/extras/ultroid.jpg")
+    await e.eor(get_string("cvt_6").format(nn), link_preview=False)
+
+
+@ultroid_cmd(
+    pattern="rename( (.*)|$)",
+)
+async def imak(event):
+    reply = await event.get_reply_message()
+    t = time.time()
+    if not reply:
+        return await event.eor(get_string("cvt_1"))
+    inp = event.pattern_match.group(1).strip()
+    if not inp:
+        return await event.eor(get_string("cvt_2"))
+    xx = await event.eor(get_string("com_1"))
+    if reply.media:
+        if hasattr(reply.media, "document"):
+            file = reply.media.document
+            image = await downloader(
+                reply.file.name or str(time.time()),
+                reply.media.document,
+                xx,
+                t,
+                get_string("com_5"),
+            )
+
+            file = image.name
+        else:
+            file = await event.client.download_media(reply.media)
+    if os.path.exists(inp):
+        os.remove(inp)
+    await bash(f'mv """{file}""" """{inp}"""')
+    if not os.path.exists(inp) or os.path.exists(inp) and not os.path.getsize(inp):
+        os.rename(file, inp)
+    k = time.time()
+    n_file, _ = await event.client.fast_uploader(
+        inp, show_progress=True, event=event, message="Uploading...", to_delete=True
+    )
+    await event.reply(
+        f"`{n_file.name}`",
+        file=n_file,
+        force_document=True,
+        thumb=ULTConfig.thumb,
+    )
+    os.remove(inp)
+    await xx.delete()
+
+
+conv_keys = {
+    "img": "png",
+    "sticker": "webp",
+    "webp": "webp",
+    "image": "png",
+    "webm": "webm",
+    "gif": "gif",
+    "json": "json",
+    "tgs": "tgs",
+}
+
+
+@ultroid_cmd(
+    pattern="convert( (.*)|$)",
+)
+async def uconverter(event):
+    xx = await event.eor(get_string("com_1"))
+    a = await event.get_reply_message()
+    if a is None:
+        return await event.eor("`Reply to Photo or media with thumb...`")
+    input_ = event.pattern_match.group(1).strip()
+    b = await a.download_media("resources/downloads/")
+    if not b and (a.document and a.document.thumbs):
+        b = await a.download_media(thumb=-1)
+    if not b:
+        return await xx.edit(get_string("cvt_3"))
+    try:
+        convert = conv_keys[input_]
+    except KeyError:
+        return await xx.edit(get_string("sts_3").format("gif/img/sticker/webm"))
+    file = await con.convert(b, outname="ultroid", convert_to=convert)
+    print(file)
+
+    if file:
+        await event.client.send_file(
+            event.chat_id, file, reply_to=event.reply_to_msg_id or event.id
+        )
+        os.remove(file)
+    else:
+        await xx.edit("`Failed to convert`")
+        return
+    await xx.delete()
+
+@ultroid_cmd(
+    pattern="doc( (.*)|$)",
+)
+async def _(event):
+    input_str = event.pattern_match.group(1).strip()
+    if not (input_str and event.is_reply):
+        return await event.eor(get_string("cvt_1"), time=5)
+    xx = await event.eor(get_string("com_1"))
+    a = await event.get_reply_message()
+    if not a.message:
+        return await xx.edit(get_string("ex_1"))
+    with open(input_str, "w") as b:
+        b.write(str(a.message))
+    await xx.edit(f"**Packing into** `{input_str}`")
+    await event.reply(file=input_str, thumb=ULTConfig.thumb)
+    await xx.delete()
+    os.remove(input_str)
+
+
+@ultroid_cmd(
+    pattern="open( (.*)|$)",
+)
+async def _(event):
+    a = await event.get_reply_message()
+    b = event.pattern_match.group(1).strip()
+    if not ((a and a.media) or (b and os.path.exists(b))):
+        return await event.eor(get_string("cvt_7"), time=5)
+    xx = await event.eor(get_string("com_1"))
+    rem = None
+    if not b:
+        b = await a.download_media()
+        rem = True
+    try:
+        with open(b) as c:
+            d = c.read()
+    except UnicodeDecodeError:
+        return await xx.eor(get_string("cvt_8"), time=5)
+    try:
+        await xx.edit(f"```{d}```")
+    except BaseException:
+        what, data = await get_paste(d)
+        await xx.edit(
+            f"**MESSAGE EXCEEDS TELEGRAM LIMITS**\n\nSo Pasted It On [SPACEBIN]({data['link']})"
+        )
+    if rem:
+        os.remove(b)

plugins/core.py

@@ -0,0 +1,124 @@
+# 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 . import get_help
+
+__doc__ = get_help("help_core")
+
+
+import os
+
+from pyUltroid.startup.loader import load_addons
+
+from . import LOGS, async_searcher, eod, get_string, safeinstall, ultroid_cmd, un_plug
+
+
+@ultroid_cmd(pattern="install", fullsudo=True)
+async def install(event):
+    await safeinstall(event)
+
+
+@ultroid_cmd(
+    pattern=r"unload( (.*)|$)",
+)
+async def unload(event):
+    shortname = event.pattern_match.group(1).strip()
+    if not shortname:
+        await event.eor(get_string("core_9"))
+        return
+    lsd = os.listdir("addons")
+    zym = f"{shortname}.py"
+    if zym in lsd:
+        try:
+            un_plug(shortname)
+            await event.eor(f"**Uɴʟᴏᴀᴅᴇᴅ** `{shortname}` **Sᴜᴄᴄᴇssғᴜʟʟʏ.**", time=3)
+        except Exception as ex:
+            LOGS.exception(ex)
+            return await event.eor(str(ex))
+    elif zym in os.listdir("plugins"):
+        return await event.eor(get_string("core_11"), time=3)
+    else:
+        await event.eor(f"**Nᴏ Pʟᴜɢɪɴ Nᴀᴍᴇᴅ** `{shortname}`", time=3)
+
+
+@ultroid_cmd(
+    pattern=r"uninstall( (.*)|$)",
+)
+async def uninstall(event):
+    shortname = event.pattern_match.group(1).strip()
+    if not shortname:
+        await event.eor(get_string("core_13"))
+        return
+    lsd = os.listdir("addons")
+    zym = f"{shortname}.py"
+    if zym in lsd:
+        try:
+            un_plug(shortname)
+            await event.eor(f"**Uɴɪɴsᴛᴀʟʟᴇᴅ** `{shortname}` **Sᴜᴄᴄᴇssғᴜʟʟʏ.**", time=3)
+            os.remove(f"addons/{shortname}.py")
+        except Exception as ex:
+            return await event.eor(str(ex))
+    elif zym in os.listdir("plugins"):
+        return await event.eor(get_string("core_15"), time=3)
+    else:
+        return await event.eor(f"**Nᴏ Pʟᴜɢɪɴ Nᴀᴍᴇᴅ** `{shortname}`", time=3)
+
+
+@ultroid_cmd(
+    pattern=r"load( (.*)|$)",
+    fullsudo=True,
+)
+async def load(event):
+    shortname = event.pattern_match.group(1).strip()
+    if not shortname:
+        await event.eor(get_string("core_16"))
+        return
+    try:
+        try:
+            un_plug(shortname)
+        except BaseException:
+            pass
+        load_addons(f"addons/{shortname}.py")
+        await event.eor(get_string("core_17").format(shortname), time=3)
+    except Exception as e:
+        LOGS.exception(e)
+        await eod(
+            event,
+            get_string("core_18").format(shortname, e),
+            time=3,
+        )
+
+
+@ultroid_cmd(pattern="getaddons( (.*)|$)", fullsudo=True)
+async def get_the_addons_lol(event):
+    thelink = event.pattern_match.group(1).strip()
+    xx = await event.eor(get_string("com_1"))
+    fool = get_string("gas_1")
+    if thelink is None:
+        return await xx.eor(fool, time=10)
+    split_thelink = thelink.split("/")
+    if not ("raw" in thelink and thelink.endswith(".py")):
+        return await xx.eor(fool, time=10)
+    name_of_it = split_thelink[-1]
+    plug = await async_searcher(thelink)
+    fil = f"addons/{name_of_it}"
+    await xx.edit("Packing the codes...")
+    with open(fil, "w", encoding="utf-8") as uult:
+        uult.write(plug)
+    await xx.edit("Packed. Now loading the plugin..")
+    shortname = name_of_it.split(".")[0]
+    try:
+        load_addons(fil)
+        await xx.eor(get_string("core_17").format(shortname), time=15)
+    except Exception as e:
+        LOGS.exception(e)
+        await eod(
+            xx,
+            get_string("core_18").format(shortname, e),
+            time=3,
+        )

plugins/database.py

@@ -0,0 +1,77 @@
+# 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 . import get_help
+
+__doc__ = get_help("help_database")
+
+
+import re
+
+from . import Redis, eor, get_string, udB, ultroid_cmd
+
+
+@ultroid_cmd(pattern="setdb( (.*)|$)", fullsudo=True)
+async def _(ult):
+    match = ult.pattern_match.group(1).strip()
+    if not match:
+        return await ult.eor("Provide key and value to set!")
+    try:
+        delim = " " if re.search("[|]", match) is None else " | "
+        data = match.split(delim, maxsplit=1)
+        if data[0] in ["--extend", "-e"]:
+            data = data[1].split(maxsplit=1)
+            data[1] = f"{str(udB.get_key(data[0]))} {data[1]}"
+        udB.set_key(data[0], data[1])
+        await ult.eor(
+            f"**DB Key Value Pair Updated\nKey :** `{data[0]}`\n**Value :** `{data[1]}`"
+        )
+
+    except BaseException:
+        await ult.eor(get_string("com_7"))
+
+
+@ultroid_cmd(pattern="deldb( (.*)|$)", fullsudo=True)
+async def _(ult):
+    key = ult.pattern_match.group(1).strip()
+    if not key:
+        return await ult.eor("Give me a key name to delete!", time=5)
+    _ = key.split(maxsplit=1)
+    try:
+        if _[0] == "-m":
+            for key in _[1].split():
+                k = udB.del_key(key)
+            key = _[1]
+        else:
+            k = udB.del_key(key)
+        if k == 0:
+            return await ult.eor("`No Such Key.`")
+        await ult.eor(f"`Successfully deleted key {key}`")
+    except BaseException:
+        await ult.eor(get_string("com_7"))
+
+
+@ultroid_cmd(pattern="rendb( (.*)|$)", fullsudo=True)
+async def _(ult):
+    match = ult.pattern_match.group(1).strip()
+    if not match:
+        return await ult.eor("`Provide Keys name to rename..`")
+    delim = " " if re.search("[|]", match) is None else " | "
+    data = match.split(delim)
+    if Redis(data[0]):
+        try:
+            udB.rename(data[0], data[1])
+            await eor(
+                ult,
+                f"**DB Key Rename Successful\nOld Key :** `{data[0]}`\n**New Key :** `{data[1]}`",
+            )
+
+        except BaseException:
+            await ult.eor(get_string("com_7"))
+    else:
+        await ult.eor("Key not found")