Upload 95 files

plugins/__init__.py

@@ -0,0 +1,102 @@
+# Ultroid - UserBot
+# Copyright (C) 2021-2023 TeamUltroid
+#
+# This file is a part of < https://github.com/TeamUltroid/Ultroid/ >
+# PLease read the GNU Affero General Public License in
+# <https://www.github.com/TeamUltroid/Ultroid/blob/main/LICENSE/>.
+
+import 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 telethon.tl.custom.message import CustomMarkdown
+
+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
+
+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")
+
+ultroid_bot.parse_mode = CustomMarkdown()
+
+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()
+
+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,350 @@
+# Ultroid - UserBot
+# Copyright (C) 2021-2023 TeamUltroid
+#
+# This file is a part of < https://github.com/TeamUltroid/Ultroid/ >
+# PLease read the GNU Affero General Public License in
+# <https://www.github.com/TeamUltroid/Ultroid/blob/main/LICENSE/>.
+
+import 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 check_reply_to, inline_mention
+from pyUltroid.fns.tools import (
+    async_searcher,
+    create_tl_btn,
+    get_chatbot_reply,
+    get_oracle_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
+
+if not udB.get_key("ORACLE_USERS"):
+    udB.set_key("ORACLE_USERS", {})
+if not udB.get_key("CHATBOT_USERS"):
+    udB.set_key("CHATBOT_USERS", {})
+
+@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):
+    if e.sender_id in udB.get_key("CHATBOT_USERS"):
+        xxrep = await check_reply_to(e)
+    else:
+        return
+
+    if xxrep:
+        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]:
+            # Simulate typing indicator
+            async with e.client.action(e.chat_id, "typing"):
+                msg = await get_chatbot_reply(e.message.message)
+                if msg:
+                    sleep = udB.get_key("CHATBOT_SLEEP") or 1.5
+                    await asyncio.sleep(sleep)
+
+                    # Check if the message length exceeds a certain threshold
+                    if len(msg) > 4096:
+                        # Create a temporary text file
+                        with tempfile.NamedTemporaryFile(
+                            mode="w+", delete=False
+                        ) as temp_file:
+                            temp_file.write(msg)
+
+                        # Send the text file with a caption
+                        await e.client.send_file(
+                            e.chat_id,
+                            temp_file.name,
+                            caption="Here is the response in a text file.",
+                        )
+
+                        # Delete the temporary text file
+                        os.remove(temp_file.name)
+                    else:
+                        # Send the message directly
+                        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.NewMessage(incoming=True))
+async def oracleBot_replies(e):
+    if e.sender_id in udB.get_key("ORACLE_USERS"):
+        xxxrep = await check_reply_to(e)
+    else:
+        return
+
+    if xxxrep:
+        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("ORACLE_USERS") or {}
+        if e.text and key.get(e.chat_id) and sender.id in key[e.chat_id]:
+            # Simulate typing indicator
+            async with e.client.action(e.chat_id, "typing"):
+                msg = await get_oracle_reply(
+                    e.message.message, user_id=sender.id, mongo_url=MONGO_URI
+                )
+                if msg:
+                    sleep = udB.get_key("ORACLE_SLEEP") or 1.5
+                    await asyncio.sleep(sleep)
+
+                    # Check if the message length exceeds a certain threshold
+                    if len(msg) > 4096:
+                        # Create a temporary text file
+                        with tempfile.NamedTemporaryFile(
+                            mode="w+", delete=False
+                        ) as temp_file:
+                            temp_file.write(msg)
+
+                        # Send the text file with a caption
+                        await e.client.send_file(
+                            e.chat_id,
+                            temp_file.name,
+                            caption="Here is the response in a text file",
+                        )
+
+                        # Delete the temporary text file
+                        os.remove(temp_file.name)
+                    else:
+                        # Send the message directly
+                        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-2023 TeamUltroid
+#
+# This file is a part of < https://github.com/TeamUltroid/Ultroid/ >
+# PLease read the GNU Affero General Public License in
+# <https://www.github.com/TeamUltroid/Ultroid/blob/main/LICENSE/>.
+
+from telethon.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,451 @@
+# Ultroid - UserBot
+# Copyright (C) 2021-2023 TeamUltroid
+#
+# This file is a part of < https://github.com/TeamUltroid/Ultroid/ >
+# PLease read the GNU Affero General Public License in
+# <https://www.github.com/TeamUltroid/Ultroid/blob/main/LICENSE/>.
+
+import re
+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]
+    link = f"https://spaceb.in/{ok}"
+    raw = f"https://spaceb.in/api/{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-2023 TeamUltroid
+#
+# This file is a part of < https://github.com/TeamUltroid/Ultroid/ >
+# PLease read the GNU Affero General Public License in
+# <https://www.github.com/TeamUltroid/Ultroid/blob/main/LICENSE/>.
+
+from telethon.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,297 @@
+# Ultroid - UserBot
+# Copyright (C) 2021-2023 TeamUltroid
+#
+# This file is a part of < https://github.com/TeamUltroid/Ultroid/ >
+# PLease read the GNU Affero General Public License in
+# <https://www.github.com/TeamUltroid/Ultroid/blob/main/LICENSE/>.
+
+import 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")
+    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-2023 TeamUltroid
+#
+# This file is a part of < https://github.com/TeamUltroid/Ultroid/ >
+# PLease read the GNU Affero General Public License in
+# <https://www.github.com/TeamUltroid/Ultroid/blob/main/LICENSE/>.
+
+import re
+
+from 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,472 @@
+# Ultroid - UserBot
+# Copyright (C) 2021-2023 TeamUltroid
+#
+# This file is a part of < https://github.com/TeamUltroid/Ultroid/ >
+# PLease read the GNU Affero General Public License in
+# <https://www.github.com/TeamUltroid/Ultroid/blob/main/LICENSE/>.
+
+from . 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,166 @@
+# Ultroid - UserBot
+# Copyright (C) 2021-2023 TeamUltroid
+#
+# This file is a part of < https://github.com/TeamUltroid/Ultroid/ >
+# PLease read the GNU Affero General Public License in
+# <https://www.github.com/TeamUltroid/Ultroid/blob/main/LICENSE/>.
+
+from . import get_help
+
+__doc__ = get_help("help_afk")
+
+
+import asyncio
+
+from telegraph import upload_file as uf
+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,
+)
+
+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)
+                iurl = uf(file)
+                media = f"https://graph.org{iurl[0]}"
+            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/afscrp.py

@@ -0,0 +1,95 @@
+import logging
+from bs4 import BeautifulSoup
+from googleapiclient.discovery import build
+from . import ultroid_cmd, async_searcher, run_async, LOGS
+import asyncio
+from io import BytesIO
+
+logging.getLogger("googleapiclient.discovery_cache").setLevel(logging.WARNING)
+
+async def fetch_full_content(url):
+    try:
+        api_url = f"https://scraper.api.airforce/scrape?url={url}"
+        response = await async_searcher(api_url)
+
+        soup = BeautifulSoup(response, "html.parser")
+        main_content = soup.select_one("article") or soup.select_one("main") or soup
+        paragraphs = [
+            para.get_text(separator=" ").strip()
+            for para in main_content.find_all("p")
+            if len(para.get_text(strip=True)) > 30
+            and not any(
+                keyword in para.get_text().lower()
+                for keyword in [
+                    "privacy",
+                    "cookie",
+                    "subscribe",
+                    "sign up",
+                    "terms",
+                    "all rights reserved",
+                    "see all",
+                    "see more",
+                ]
+            )
+        ]
+        full_text = (
+            " ".join(paragraphs[:5]) if paragraphs else "No main content available."
+        )
+        return full_text
+    except Exception as e:
+        return f"Error fetching content: {e}"
+
+async def google_search(query):
+    api_key = " AIzaSyCDOnsWu0cF8W-6jnWceUSHeuSmpC7b2g0 "
+    cse_id = "a44275f02ca2946da"
+    service = build("customsearch", "v1", developerKey=api_key)
+
+    results = service.cse().list(q=query, cx=cse_id, gl="AU").execute()
+    search_items = results.get("items", [])
+
+    search_results = await asyncio.gather(
+        *(fetch_search_result(item) for item in search_items)
+    )
+
+    return search_results
+
+async def fetch_search_result(item):
+    title = item.get("title")
+    link = item.get("link")
+    snippet = item.get("snippet")
+    full_content = await fetch_full_content(link) 
+    return (title, link, snippet, full_content)
+
+async def display_readable_results(results):
+    readable_res = ""
+    for idx, result in enumerate(results, start=1):
+        title, link, snippet, full_content = result
+        full_content = (
+            full_content if full_content else "No additional content available."
+        )
+        readable_res += f"Result {idx}:\n"
+        readable_res += f"Title: {title}\n"
+        readable_res += f"Link: {link}\n"
+        readable_res += f"Snippet: {snippet}\n"
+        readable_res += f"Full Content: {full_content.strip()}\n"
+        readable_res += "\n" + "=" * 80 + "\n"
+    return readable_res
+
+@ultroid_cmd(pattern="afscrp(?: (.*)|$)")
+async def google_search_cmd(event):
+    query = event.pattern_match.group(1)
+    if not query:
+        return await event.eor("Please provide a query to search.")
+    moi = await event.eor("Searching Google...")
+    results = await google_search(query)
+    readable_results = await display_readable_results(results)
+    
+    if len(readable_results) < 4095:
+        await moi.edit(readable_results)
+    else:
+        with BytesIO(readable_results.encode()) as file:
+            file.name = "google_search_results.txt"
+            await event.client.send_file(
+                event.chat_id, file, caption=f"Search results for: {query}", reply_to=event.reply_to_msg_id
+            )
+        await moi.delete()

plugins/antiflood.py

@@ -0,0 +1,121 @@
+# Ultroid - UserBot
+# Copyright (C) 2021-2023 TeamUltroid
+#
+# This file is a part of < https://github.com/TeamUltroid/Ultroid/ >
+# PLease read the GNU Affero General Public License in
+# <https://www.github.com/TeamUltroid/Ultroid/blob/main/LICENSE/>.
+
+from . 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,107 @@
+# Ultroid - UserBot
+# Copyright (C) 2021-2023 TeamUltroid
+#
+# This file is a part of < https://github.com/TeamUltroid/Ultroid/ >
+# PLease read the GNU Affero General Public License in
+# <https://www.github.com/TeamUltroid/Ultroid/blob/main/LICENSE/>.
+
+from . 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
+
+try:
+    from telegraph import upload_file as uf
+except ImportError:
+    uf = None
+from telethon import events, utils
+
+from . import asst, get_string, mediainfo, udB, ultroid_cmd
+
+
+@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)
+            variable = uf(dl)
+            os.remove(dl)
+            m = f"https://graph.org{variable[0]}"
+        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)
+            variable = uf(dl)
+            os.remove(dl)
+            m = f"https://graph.org{variable[0]}"
+        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,160 @@
+# Ultroid - UserBot
+# Copyright (C) 2021-2023 TeamUltroid
+#
+# This file is a part of < https://github.com/TeamUltroid/Ultroid/ >
+# PLease read the GNU Affero General Public License in
+# <https://www.github.com/TeamUltroid/Ultroid/blob/main/LICENSE/>.
+
+
+import 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,
+    uploader,
+)
+
+__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()
+        mmmm = await uploader(out, out, f_time, xxx, f"Uploading {out}...")
+        attributes = await set_attributes(out)
+
+        caption = get_string("audiotools_7").format(ss, dd)
+        await e.client.send_file(
+            e.chat_id,
+            mmmm,
+            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:
+        fo = await uploader(out_file, out_file, f_time, msg, f"Uploading {out_file}...")
+
+    except FileNotFoundError:
+        return await eor(msg, get_string("audiotools_9"))
+    await e.reply(
+        get_string("audiotools_10"),
+        file=fo,
+        thumb=ULTConfig.thumb,
+        attributes=attributes,
+    )
+    await msg.delete()

plugins/autoban.py

@@ -0,0 +1,59 @@
+# Ultroid - UserBot
+# Copyright (C) 2021-2023 TeamUltroid
+#
+# This file is a part of < https://github.com/TeamUltroid/Ultroid/ >
+# PLease read the GNU Affero General Public License in
+# <https://www.github.com/TeamUltroid/Ultroid/blob/main/LICENSE/>.
+
+from . 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-2023 TeamUltroid
+#
+# This file is a part of < https://github.com/TeamUltroid/Ultroid/ >
+# PLease read the GNU Affero General Public License in
+# <https://www.github.com/TeamUltroid/Ultroid/blob/main/LICENSE/>.
+
+
+import 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,210 @@
+# Ultroid - UserBot
+# Copyright (C) 2021-2023 TeamUltroid
+#
+# This file is a part of < https://github.com/TeamUltroid/Ultroid/ >
+# PLease read the GNU Affero General Public License in
+# <https://www.github.com/TeamUltroid/Ultroid/blob/main/LICENSE/>.
+
+from . 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, LOGS
+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) > 2:
+        if spli[1] in RaySoTheme:
+            theme = spli[1]
+        dark = spli[2].lower().strip() in ["true", "t"]
+    elif len(spli) > 1:
+        if spli[1] in RaySoTheme:
+            theme = spli[1]
+        elif spli[1] == "list":
+            text = "**List of Rayso Themes:**\n" + "\n".join([f"- `{th_}`" for th_ in RaySoTheme])
+            await proc.eor(text)
+            return
+        else:
+            try:
+                text = ult.text.split(maxsplit=1)[1]
+            except IndexError:
+                pass
+    
+    if not theme or theme not in RaySoTheme:
+        theme = random.choice(RaySoTheme)
+    
+    if ult.is_reply:
+        try:
+            msg = await ult.get_reply_message()
+            text = msg.message
+            title = get_display_name(msg.sender)
+        except Exception as sam:
+            ErrInfo(sam)
+    
+    if not text:
+        await proc.eor("No text to beautify!")
+        return
+    
+    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(headless=False)  # Set to False for debugging
+            browser = await play.chromium.launch(headless=True, args=["--disable-crash-reporter"])
+            page = await browser.new_page()
+            await page.goto(url, timeout=60000)  # Increase timeout
+            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.info("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.info(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.info(f"Error occurred while replying with the file: {e}")
+                    await proc.eor("Failed to send the file.")
+            else:
+                LOGS.info(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-2023 TeamUltroid
+#
+# This file is a part of < https://github.com/TeamUltroid/Ultroid/ >
+# PLease read the GNU Affero General Public License in
+# <https://www.github.com/TeamUltroid/Ultroid/blob/main/LICENSE/>.
+
+from . 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,358 @@
+# Ultroid - UserBot
+# Copyright (C) 2021-2023 TeamUltroid
+#
+# This file is a part of < https://github.com/TeamUltroid/Ultroid/ >
+# PLease read the GNU Affero General Public License in
+# <https://www.github.com/TeamUltroid/Ultroid/blob/main/LICENSE/>.
+
+from . 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
+    y = "main"
+#    xx = Repo().remotes[0].config_reader.get("url")
+    xx = "https://github.com/ufoptg/UltroidBackup.git"
+    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")
+    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}`")
+    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")
+        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-2023 TeamUltroid
+#
+# This file is a part of < https://github.com/TeamUltroid/Ultroid/ >
+# PLease read the GNU Affero General Public License in
+# <https://www.github.com/TeamUltroid/Ultroid/blob/main/LICENSE/>.
+
+
+from . 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,56 @@
+# Ultroid - UserBot
+# Copyright (C) 2021-2023 TeamUltroid
+#
+# This file is a part of < https://github.com/TeamUltroid/Ultroid/ >
+# PLease read the GNU Affero General Public License in
+# <https://www.github.com/TeamUltroid/Ultroid/blob/main/LICENSE/>.
+
+from . import get_help
+
+__doc__ = get_help("help_button")
+
+import os
+
+from telegraph 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()
+            variable = uf(dl)
+            media = f"https://graph.org{variable[0]}"
+        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()
+            variable = uf(dl)
+            os.remove(dl)
+            media = f"https://graph.org{variable[0]}"
+        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-2023 TeamUltroid
+#
+# This file is a part of < https://github.com/TeamUltroid/Ultroid/ >
+# PLease read the GNU Affero General Public License in
+# <https://www.github.com/TeamUltroid/Ultroid/blob/main/LICENSE/>.
+
+
+from . 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-2023 TeamUltroid
+#
+# This file is a part of < https://github.com/TeamUltroid/Ultroid/ >
+# PLease read the GNU Affero General Public License in
+# <https://www.github.com/TeamUltroid/Ultroid/blob/main/LICENSE/>.
+from . 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,174 @@
+# Ultroid - UserBot
+# Copyright (C) 2021-2024 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, get_oracle_reply
+
+from . import LOGS, eod, get_string, inline_mention, udB, ultroid_bot, ultroid_cmd
+
+try:
+    mongouri = udB.get_key("MONGO_URI")
+except AttributeError:
+    if udB.get_key("MONGO_URI"):
+        mongouri = udB.get_key("MONGO_URI")
+    else:
+        udB.set_key("MONGO_URI", "")
+        LOGS.error("PLeasde set a MONGO_URI")
+
+
+@ultroid_cmd(pattern="repoai")
+async def im_oracle(event):
+    if event.reply_to:
+        message = (await event.get_reply_message()).text.strip()
+    else:
+        try:
+            message = event.text.split(" ", 1)[1]
+        except IndexError:
+            return await eod(event, get_string("tban_1"), time=10)
+    reply_ = await get_oracle_reply(
+        query=message, user_id=ultroid_bot.me.id, mongo_url=mongouri
+    )
+    await event.eor(reply_)
+
+
+@ultroid_cmd(pattern="addoai")
+async def add_oracle(event):
+    await oracle_bot_fn(event, type_="add")
+
+
+@ultroid_cmd(pattern="remoai")
+async def rem_oracle(event):
+    await oracle_bot_fn(event, type_="remov")
+
+
+@ultroid_cmd(pattern="listoai")
+async def listoracle(event):
+    key = udB.get_key("ORACLE_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 Oracle 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 oracle_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("ORACLE_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("ORACLE_USERS", key)
+    await event.eor(f"**Oracle:**\n{type_}ed {inline_mention(user_)}")
+
+
+@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-2023 TeamUltroid
+#
+# This file is a part of < https://github.com/TeamUltroid/Ultroid/ >
+# PLease read the GNU Affero General Public License in
+# <https://www.github.com/TeamUltroid/Ultroid/blob/main/LICENSE/>.
+from . 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-2023 TeamUltroid
+#
+# This file is a part of < https://github.com/TeamUltroid/Ultroid/ >
+# PLease read the GNU Affero General Public License in
+# <https://www.github.com/TeamUltroid/Ultroid/blob/main/LICENSE/>.
+
+from . 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/codefix.py

@@ -0,0 +1,241 @@
+import os
+from collections import deque
+from io import BytesIO
+
+from . import (
+    ultroid_cmd,
+    async_searcher,
+    udB,
+    LOGS,
+    get_paste,
+)
+
+CR_O_CHAT_HISTORY = deque(maxlen=30)
+
+TELEGRAM_CHAR_LIMIT = 4096  # Telegram's message character limit
+
+initprompt = """
+You are an expert coding assistant. Your primary goal is to analyze, repair, and enhance the code provided by the user.
+
+Follow this structured approach:
+
+1. **Clarify Code Intent:**
+   * If the purpose of the code is unclear, ask the user for clarification.
+   * Understand what the code is supposed to achieve.
+
+2. **Analyze and Diagnose:**
+   * Identify errors, bugs, security vulnerabilities, or logical flaws.
+   * Look for performance inefficiencies and suggest improvements.
+   * Ensure adherence to coding standards and best practices (e.g., PEP 8 for Python).
+
+3. **Repair and Optimize:**
+   * Correct bugs, errors, and vulnerabilities, providing explanations for each fix.
+   * Optimize the code for speed, memory usage, or overall efficiency.
+   * Recommend alternative libraries or methods where they might offer better solutions.
+
+4. **Enhance Readability and Maintainability:**
+   * Apply consistent formatting and clean coding practices.
+   * Add meaningful comments to clarify complex logic or structures.
+
+5. **Summarize Improvements:**
+   * Present the corrected, optimized code.
+   * Provide a brief summary of the changes made and explain the benefits of each.
+"""
+
+initset = False
+
+async def pastee(data):
+    err, linky = await get_paste(data)
+    if err:
+        return f">> [Raw Code Pasted Here](https://spaceb.in/{linky})\n"
+    else:
+        LOGS.error(linky)
+        return ""
+
+
+@ultroid_cmd(
+    pattern=r"codefix( ([\s\S]*))?$",
+)
+async def openai_chat_gpt(e):
+    global initset
+    api_key = "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"
+    if not api_key:
+        return await e.eor("`OPENAI_API` key missing..", time=10)
+
+    query = e.pattern_match.group(2)
+    reply = await e.get_reply_message()
+
+    file_content = None
+
+    if query:
+        # Check if query contains 'from filename'
+        if ' from ' in query:
+            query_text, filename = query.split(' from ', 1)
+            query_text = query_text.strip()
+            filename = filename.strip()
+            # Attempt to find and read the file from media in chat
+            file_found = False
+            async for message in e.client.iter_messages(e.chat_id, reverse=True, limit=50):
+                if message.media and message.file.name == filename:
+                    if (message.file.name.endswith(".txt") or message.file.name.endswith(".py")):
+                        file = await e.client.download_media(message)
+                        try:
+                            with open(file, "r", encoding='utf-8') as f:
+                                file_content = f.read()
+                        except Exception as exc:
+                            LOGS.error(f"Error reading file: {exc}")
+                            return await e.eor("`Failed to read file content.`", time=5)
+                        finally:
+                            os.remove(file)
+                        file_found = True
+                        break
+            if not file_found:
+                return await e.eor(f"`File {filename} not found in recent messages.`", time=5)
+            if file_content:
+                query = f"{query_text}\n\n{file_content}" if query_text else file_content
+            else:
+                return await e.eor("`Failed to read file content.`", time=5)
+        else:
+            if reply and reply.media and (reply.file.name.endswith(".txt") or reply.file.name.endswith(".py")):
+                # Use the query and the replied file content
+                file = await e.client.download_media(reply)
+                try:
+                    with open(file, "r", encoding='utf-8') as f:
+                        file_content = f.read()
+                except Exception as exc:
+                    LOGS.error(f"Error reading file: {exc}")
+                    return await e.eor("`Failed to read file content.`", time=5)
+                finally:
+                    os.remove(file)
+                query = f"{query}\n\n{file_content}"
+            elif reply and reply.message:
+                # Use the query and the replied text message content
+                query = f"{query}\n\n{reply.message}"
+            # Else, use query as is
+    else:
+        if reply and reply.media and (reply.file.name.endswith(".txt") or reply.file.name.endswith(".py")):
+            # Use the replied file content
+            file = await e.client.download_media(reply)
+            try:
+                with open(file, "r", encoding='utf-8') as f:
+                    file_content = f.read()
+            except Exception as exc:
+                LOGS.error(f"Error reading file: {exc}")
+                return await e.eor("`Failed to read file content.`", time=5)
+            finally:
+                os.remove(file)
+            query = file_content
+        elif reply and reply.message:
+            # Use the replied text message content
+            query = reply.message
+        else:
+            return await e.eor("`Please provide a question or reply to a message or .txt/.py file.`", time=5)
+
+    if query.strip() == "-c":
+        initset = False
+        CR_O_CHAT_HISTORY.clear()
+        return await e.eor("__Cleared o1-mini Chat History!__", time=6)
+
+    if initset == False:
+        CR_O_CHAT_HISTORY.append({"role": "user", "content": initprompt})
+        try:
+            data = {
+                "model": "o1-mini",
+                "messages": list(CR_O_CHAT_HISTORY),
+             }
+            request = await async_searcher(
+                "https://api.openai.com/v1/chat/completions",
+                 headers={
+                    "Content-Type": "application/json",
+                    "Authorization": f"Bearer {api_key}",
+                },
+                json=data,
+                re_json=True,
+                post=True,
+            )
+            response = request["choices"][0]["message"]["content"]
+            CR_O_CHAT_HISTORY.append({"role": "assistant", "content": response})
+            initset = True
+        except Exception as exc:
+            LOGS.warning(exc, exc_info=True)
+            CR_O_CHAT_HISTORY.pop()
+            return await e.edit(
+                f"**Error while requesting data from OpenAI:** \n> `{exc}`"
+            )
+
+    eris = await e.eor(f"__Generating answer for:__\n`{query[:20]} ...`")
+    CR_O_CHAT_HISTORY.append({"role": "user", "content": query})
+
+    try:
+        data = {
+            "model": "o1-mini",
+            "messages": list(CR_O_CHAT_HISTORY),
+        }
+        request = await async_searcher(
+            "https://api.openai.com/v1/chat/completions",
+            headers={
+                "Content-Type": "application/json",
+                "Authorization": f"Bearer {api_key}",
+            },
+            json=data,
+            re_json=True,
+            post=True,
+        )
+        response = request["choices"][0]["message"]["content"]
+        CR_O_CHAT_HISTORY.append({"role": "assistant", "content": response})
+    except Exception as exc:
+        LOGS.warning(exc, exc_info=True)
+        CR_O_CHAT_HISTORY.pop()
+        return await eris.edit(
+            f"**Error while requesting data from OpenAI:** \n> `{exc}`"
+        )
+
+    LOGS.debug(f'Tokens Used on query: {request["usage"]["completion_tokens"]}')
+
+    # Truncate query to 50 characters for display
+    truncated_query = query[:100]
+
+    # Prepare the full message
+    full_message = f"**Query:**\n~ __{truncated_query}__\n\n**o1-mini:**\n~ {response}"
+
+    # Check if response contains code blocks
+    code_blocks = []
+    in_code_block = False
+    code_block_lines = []
+    for line in response.split('\n'):
+        if line.strip().startswith('```'):
+            if in_code_block:
+                # End of code block
+                in_code_block = False
+                code_blocks.append('\n'.join(code_block_lines))
+                code_block_lines = []
+            else:
+                # Start of code block
+                in_code_block = True
+        elif in_code_block:
+            code_block_lines.append(line)
+
+    # If the response contains code blocks, select the largest one and paste it
+    if code_blocks:
+        # Select the largest code block based on length
+        largest_code_block = max(code_blocks, key=lambda block: len(block))
+        # Upload the largest code block to spaceb.in and get the link
+        paste_link = await pastee(largest_code_block)
+    else:
+        paste_link = ""
+
+    if len(full_message) <= TELEGRAM_CHAR_LIMIT:
+        # If it fits within the limit, send as a message
+        await eris.edit(full_message + f"\n\n{paste_link}")
+    else:
+        # If it exceeds the limit, send as a file and include paste link
+        file = BytesIO(full_message.encode('utf-8'))
+        file.name = "o1-mini-output.txt"
+        await eris.respond(
+            "__The query and response were too long, so they have been sent as a file.__\n\n" + paste_link,
+            file=file,
+            reply_to=e.reply_to_msg_id or e.id,
+            link_preview=False
+        )
+        await eris.delete()
+

plugins/codegpt.py

@@ -0,0 +1,302 @@
+import os
+from collections import deque
+from io import BytesIO
+
+from . import (
+    ultroid_cmd,
+    async_searcher,
+    udB,
+    LOGS,
+    get_paste,
+)
+
+CG_GPT_CHAT_HISTORY = deque(maxlen=30)
+
+TELEGRAM_CHAR_LIMIT = 4096  # Telegram's message character limit
+
+initprompt = """
+Your name is User Coding Helper. Your task is to create plugins for the Ultroid Telegram userbot. Follow these guidelines:
+1. Imports: Include all necessary imports as demonstrated in the example code provided below.
+2. Command Creation: Generate a random, suitable Ultroid command. Ensure that this command can either:
+   - Process a query, or
+   - Be used directly with the command.
+3. Code Submission: Do not send any code without a corresponding post request or without the user providing a code snippet.
+
+Example Code:
+```
+from os import system, remove
+from io import BytesIO
+
+try:
+    import openai
+except ImportError:
+    system("pip install -q openai")
+    import openai
+
+from . import ultroid_cmd, check_filename, udB, LOGS, fast_download, run_async
+
+@run_async
+def get_gpt_answer(gen_image, question, api_key):
+    openai.api_key = api_key
+    if gen_image:
+        x = openai.Image.create(
+            prompt=question,
+            n=1,
+            size="1024x1024",
+            user="arc",
+        )
+        return x["data"][0]["url"]
+    x = openai.ChatCompletion.create(
+        model="gpt-3.5-turbo",
+        messages=[{"role": "user", "content": question}],
+    )
+    LOGS.debug(f'Token Used on ({question}) > {x["usage"]["total_tokens"]}')
+    return x["choices"][0]["message"]["content"].lstrip("+AFw-n")
+
+@ultroid_cmd(pattern="(chat)?gpt( (.*)|$)")
+async def openai_chat_gpt(e):
+    api_key = udB.get_key("OPENAI_API")
+    gen_image = False
+    if not api_key:
+        return await e.eor("OPENAI_API key missing..")
+
+    args = e.pattern_match.group(3)
+    reply = await e.get_reply_message()
+    if not args:
+        if reply and reply.text:
+            args = reply.message
+    if not args:
+        return await e.eor("Gimme a Question to ask from ChatGPT")
+
+    moi = await e.eor(f"+2D3cIw")
+    if args.startswith("-i"):
+        gen_image = True
+        args = args[2:].strip()
+    try:
+        response = await get_gpt_answer(gen_image, args, api_key)
+    except Exception as exc:
+        LOGS.warning(exc, exc_info=True)
+        return await moi.edit(f"Error: +AFw-n> {exc}")
+    else:
+        if gen_image:
+            path, _ = await fast_download(
+                response, filename=check_filename("dall-e.png")
+            )
+            await e.client.send_file(
+                e.chat_id,
+                path,
+                caption=f"{args[:1020]}",
+                reply_to=e.reply_to_msg_id,
+            )
+            await moi.delete()
+            return remove(path)
+        if len(response) < 4095:
+            answer = f"<b></b>+AFw-n <i>{response}</i>"
+            return await moi.edit(answer, parse_mode="html")
+        with BytesIO(response.encode()) as file:
+            file.name = "gpt_response.txt"
+            await e.client.send_file(
+                e.chat_id, file, caption=f"{args[:1020]}", reply_to=e.reply_to_msg_id
+            )
+        await moi.delete()
+```
+
+Based on this template, whenever a new prompt is given, create a suitable Ultroid plugin code snippet that includes a POST request, handles the query, and assigns a new command.
+"""
+
+initset = False
+
+async def pastee(data):
+    err, linky = await get_paste(data)
+    if err:
+        return f">> [Raw Code Pasted Here](https://spaceb.in/{linky})\n"
+    else:
+        LOGS.error(linky)
+        return ""
+
+
+@ultroid_cmd(
+    pattern=r"codegen( ([\s\S]*))?$",
+)
+async def openai_chat_gpt(e):
+    global initset
+    api_key = "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"
+    if not api_key:
+        return await e.eor("`OPENAI_API` key missing..", time=10)
+
+    query = e.pattern_match.group(2)
+    reply = await e.get_reply_message()
+
+    file_content = None
+
+    if query:
+        # Check if query contains 'from filename'
+        if ' from ' in query:
+            query_text, filename = query.split(' from ', 1)
+            query_text = query_text.strip()
+            filename = filename.strip()
+            # Attempt to find and read the file from media in chat
+            file_found = False
+            async for message in e.client.iter_messages(e.chat_id, reverse=True, limit=50):
+                if message.media and message.file.name == filename:
+                    if (message.file.name.endswith(".txt") or message.file.name.endswith(".py")):
+                        file = await e.client.download_media(message)
+                        try:
+                            with open(file, "r", encoding='utf-8') as f:
+                                file_content = f.read()
+                        except Exception as exc:
+                            LOGS.error(f"Error reading file: {exc}")
+                            return await e.eor("`Failed to read file content.`", time=5)
+                        finally:
+                            os.remove(file)
+                        file_found = True
+                        break
+            if not file_found:
+                return await e.eor(f"`File {filename} not found in recent messages.`", time=5)
+            if file_content:
+                query = f"{query_text}\n\n{file_content}" if query_text else file_content
+            else:
+                return await e.eor("`Failed to read file content.`", time=5)
+        else:
+            if reply and reply.media and (reply.file.name.endswith(".txt") or reply.file.name.endswith(".py")):
+                # Use the query and the replied file content
+                file = await e.client.download_media(reply)
+                try:
+                    with open(file, "r", encoding='utf-8') as f:
+                        file_content = f.read()
+                except Exception as exc:
+                    LOGS.error(f"Error reading file: {exc}")
+                    return await e.eor("`Failed to read file content.`", time=5)
+                finally:
+                    os.remove(file)
+                query = f"{query}\n\n{file_content}"
+            elif reply and reply.message:
+                # Use the query and the replied text message content
+                query = f"{query}\n\n{reply.message}"
+            # Else, use query as is
+    else:
+        if reply and reply.media and (reply.file.name.endswith(".txt") or reply.file.name.endswith(".py")):
+            # Use the replied file content
+            file = await e.client.download_media(reply)
+            try:
+                with open(file, "r", encoding='utf-8') as f:
+                    file_content = f.read()
+            except Exception as exc:
+                LOGS.error(f"Error reading file: {exc}")
+                return await e.eor("`Failed to read file content.`", time=5)
+            finally:
+                os.remove(file)
+            query = file_content
+        elif reply and reply.message:
+            # Use the replied text message content
+            query = reply.message
+        else:
+            return await e.eor("`Please provide a question or reply to a message or .txt/.py file.`", time=5)
+
+    if query.strip() == "-c":
+        CG_GPT_CHAT_HISTORY.clear()
+        return await e.eor("__Cleared o1-mini Chat History!__", time=6)
+
+    if initset == False:
+        CG_GPT_CHAT_HISTORY.append({"role": "user", "content": initprompt})
+        try:
+            data = {
+                "model": "o1-mini",
+                "messages": list(CG_GPT_CHAT_HISTORY),
+             }
+            request = await async_searcher(
+                "https://api.openai.com/v1/chat/completions",
+                 headers={
+                    "Content-Type": "application/json",
+                    "Authorization": f"Bearer {api_key}",
+                },
+                json=data,
+                re_json=True,
+                post=True,
+            )
+            response = request["choices"][0]["message"]["content"]
+            CG_GPT_CHAT_HISTORY.append({"role": "assistant", "content": response})
+            initset = True
+        except Exception as exc:
+            LOGS.warning(exc, exc_info=True)
+            CG_GPT_CHAT_HISTORY.pop()
+            return await eris.edit(
+                f"**Error while requesting data from OpenAI:** \n> `{exc}`"
+            )
+
+    eris = await e.eor(f"__Generating answer for:__\n`{query[:20]} ...`")
+    CG_GPT_CHAT_HISTORY.append({"role": "user", "content": query})
+
+    try:
+        data = {
+            "model": "o1-mini",
+            "messages": list(CG_GPT_CHAT_HISTORY),
+        }
+        request = await async_searcher(
+            "https://api.openai.com/v1/chat/completions",
+            headers={
+                "Content-Type": "application/json",
+                "Authorization": f"Bearer {api_key}",
+            },
+            json=data,
+            re_json=True,
+            post=True,
+        )
+        response = request["choices"][0]["message"]["content"]
+        CG_GPT_CHAT_HISTORY.append({"role": "assistant", "content": response})
+    except Exception as exc:
+        LOGS.warning(exc, exc_info=True)
+        CG_GPT_CHAT_HISTORY.pop()
+        return await eris.edit(
+            f"**Error while requesting data from OpenAI:** \n> `{exc}`"
+        )
+
+    LOGS.debug(f'Tokens Used on query: {request["usage"]["completion_tokens"]}')
+
+    # Truncate query to 50 characters for display
+    truncated_query = query[:100]
+
+    # Prepare the full message
+    full_message = f"**Query:**\n~ __{truncated_query}__\n\n**o1-mini:**\n~ {response}"
+
+    # Check if response contains code blocks
+    code_blocks = []
+    in_code_block = False
+    code_block_lines = []
+    for line in response.split('\n'):
+        if line.strip().startswith('```'):
+            if in_code_block:
+                # End of code block
+                in_code_block = False
+                code_blocks.append('\n'.join(code_block_lines))
+                code_block_lines = []
+            else:
+                # Start of code block
+                in_code_block = True
+        elif in_code_block:
+            code_block_lines.append(line)
+
+    # If the response contains code blocks, select the largest one and paste it
+    if code_blocks:
+        # Select the largest code block based on length
+        largest_code_block = max(code_blocks, key=lambda block: len(block))
+        # Upload the largest code block to spaceb.in and get the link
+        paste_link = await pastee(largest_code_block)
+    else:
+        paste_link = ""
+
+    if len(full_message) <= TELEGRAM_CHAR_LIMIT:
+        # If it fits within the limit, send as a message
+        await eris.edit(full_message + f"\n\n{paste_link}")
+    else:
+        # If it exceeds the limit, send as a file and include paste link
+        file = BytesIO(full_message.encode('utf-8'))
+        file.name = "o1-mini-output.txt"
+        await eris.respond(
+            "__The query and response were too long, so they have been sent as a file.__\n\n" + paste_link,
+            file=file,
+            reply_to=e.reply_to_msg_id or e.id,
+            link_preview=False
+        )
+        await eris.delete()
+

plugins/compressor.py

@@ -0,0 +1,175 @@
+# Ultroid - UserBot
+# Copyright (C) 2021-2023 TeamUltroid
+#
+# This file is a part of < https://github.com/TeamUltroid/Ultroid/ >
+# PLease read the GNU Affero General Public License in
+# <https://www.github.com/TeamUltroid/Ultroid/blob/main/LICENSE/>.
+
+from . 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}`"
+        mmmm = await uploader(out, out, f_time, xxx, f"Uploading {out}...")
+        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,
+                mmmm,
+                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,
+                mmmm,
+                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,191 @@
+# Ultroid - UserBot
+# Copyright (C) 2021-2023 TeamUltroid
+#
+# This file is a part of < https://github.com/TeamUltroid/Ultroid/ >
+# PLease read the GNU Affero General Public License in
+# <https://www.github.com/TeamUltroid/Ultroid/blob/main/LICENSE/>.
+
+from . 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 telegraph 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...`")
+    variable = uf(dl)
+    os.remove(dl)
+    nn = f"https://graph.org{variable[0]}"
+    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()
+    xxx = await uploader(inp, inp, k, xx, get_string("com_6"))
+    await event.reply(
+        f"`{xxx.name}`",
+        file=xxx,
+        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)
+    if file:
+        await event.client.send_file(
+            event.chat_id, file, reply_to=event.reply_to_msg_id or event.id
+        )
+        os.remove(file)
+    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, key = await get_paste(d)
+        await xx.edit(
+            f"**MESSAGE EXCEEDS TELEGRAM LIMITS**\n\nSo Pasted It On [SPACEBIN](https://spaceb.in/{key})"
+        )
+    if rem:
+        os.remove(b)

plugins/core.py

@@ -0,0 +1,124 @@
+# Ultroid - UserBot
+# Copyright (C) 2021-2023 TeamUltroid
+#
+# This file is a part of < https://github.com/TeamUltroid/Ultroid/ >
+# PLease read the GNU Affero General Public License in
+# <https://www.github.com/TeamUltroid/Ultroid/blob/main/LICENSE/>.
+
+
+from . 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-2023 TeamUltroid
+#
+# This file is a part of < https://github.com/TeamUltroid/Ultroid/ >
+# PLease read the GNU Affero General Public License in
+# <https://www.github.com/TeamUltroid/Ultroid/blob/main/LICENSE/>.
+
+
+from . 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")

plugins/dbx.py

@@ -0,0 +1,123 @@
+import dns.resolver
+import re
+
+from motor.motor_asyncio import AsyncIOMotorClient
+from telethon import errors
+
+from . import ultroid_cmd, LOGS, run_async
+
+dns.resolver.default_resolver = dns.resolver.Resolver(configure=False)
+dns.resolver.default_resolver.nameservers = ['8.8.8.8']
+
+MONGO_URI = "mongodb+srv://xannychef:[email protected]/?retryWrites=true&w=majority&appName=vouchdb"
+mongo_client = AsyncIOMotorClient(MONGO_URI)
+db = mongo_client['vouchdata']
+vouch_collection = db['vouches']
+
+BATCH_SIZE = 1000
+
+AUTHORIZED_USERS = [5575183435]
+
+@ultroid_cmd(pattern=r"dbx(?: |$)(.*)", allow_sudo=True)
+async def db_command_handler(event):
+    try:
+        args = event.pattern_match.group(1).split()
+        user_id = event.sender_id
+
+        if user_id not in AUTHORIZED_USERS:
+            await event.reply("❌ You are not authorized to use this command.")
+            return
+
+        if len(args) < 2:
+            await event.reply("❌ Invalid command. Usage:\n.db -index <channel_id>\n.db -update <channel_id> <from_message_id>")
+            return
+
+        command = args[0]
+        try:
+            channel_id = int(args[1])
+        except ValueError:
+            await event.reply("❌ Channel ID must be an integer.")
+            return
+
+        from_message_id = int(args[2]) if command == "-update" and len(args) > 2 else None
+
+        if command not in ["-index", "-update"]:
+            await event.reply("❌ Invalid flag. Use -index or -update.")
+            return
+
+        processing_msg = await event.reply("🔍 Starting to process messages from the channel...")
+
+        total_message_count = 0
+        batch_data = []
+        progress_update_interval = 10000
+
+        try:
+            channel = await event.client.get_entity(channel_id)
+        except errors.ChannelPrivateError:
+            await processing_msg.edit("❌ Cannot access the specified channel. It might be private or you lack permissions.")
+            return
+        except Exception as e:
+            await processing_msg.edit(f"❌ Error accessing the channel: {str(e)}")
+            return
+
+        try:
+            if command == "-index":
+                total_messages = (await event.client.get_messages(channel, limit=1)).total
+                await processing_msg.edit(f"🔍 Total messages to process: {total_messages}")
+                
+                async for message in event.client.iter_messages(channel_id):
+                    await process_message(message, batch_data, processing_msg, total_message_count, progress_update_interval)
+                    total_message_count += 1
+
+            elif command == "-update":
+                if not from_message_id:
+                    await processing_msg.edit("❌ For -update, you must provide a from_message_id.")
+                    return
+
+                async for message in event.client.iter_messages(channel_id, min_id=from_message_id):
+                    await process_message(message, batch_data, processing_msg, total_message_count, progress_update_interval)
+                    total_message_count += 1
+
+            if batch_data:
+                await vouch_collection.insert_many(batch_data)
+                batch_data.clear()
+
+            await processing_msg.edit(f"✅ Completed {command[1:]}ing {total_message_count} messages.")
+        except Exception as e:
+            LOGS.error(f"Error during {command[1:]}ing: {str(e)}")
+            await processing_msg.edit(f"❌ Error during {command[1:]}ing: {str(e)}")
+    except Exception as e:
+        LOGS.error(f"Unexpected error: {str(e)}")
+        await event.reply(f"❌ An unexpected error occurred: {str(e)}")
+
+async def process_message(message, batch_data, processing_msg, total_message_count, progress_update_interval):
+    if message.sender and message.sender.username and message.sender.username.lower().endswith('bot'):
+        return
+
+    vouched_by = message.sender.username if message.sender else "Unknown"
+    description = message.message or "No description"
+    message_id = message.id
+
+    vouched_user_match = re.search(r"@\w+", description)
+    vouched_user = vouched_user_match.group(0) if vouched_user_match else "Unknown"
+
+    vouch_data = {
+        "vouched_by": vouched_by,
+        "description": description,
+        "vouched_user": vouched_user,
+        "message_id": message_id,
+        "channel_id": message.chat_id
+    }
+
+    existing_document = await vouch_collection.find_one({"message_id": message_id, "channel_id": message.chat_id})
+    if existing_document:
+        await vouch_collection.update_one({"_id": existing_document["_id"]}, {"$set": vouch_data})
+    else:
+        batch_data.append(vouch_data)
+
+    if len(batch_data) >= BATCH_SIZE:
+        await vouch_collection.insert_many(batch_data)
+        batch_data.clear()
+
+    if total_message_count and total_message_count % progress_update_interval == 0:
+        await processing_msg.edit(f"🔄 Processed {total_message_count} messages...")

plugins/devtools.py

@@ -0,0 +1,404 @@
+# Ultroid - UserBot
+# Copyright (C) 2021-2023 TeamUltroid
+#
+# This file is a part of < https://github.com/TeamUltroid/Ultroid/ >
+# PLease read the GNU Affero General Public License in
+# <https://www.github.com/TeamUltroid/Ultroid/blob/main/LICENSE/>.
+
+from . import get_help
+
+__doc__ = get_help("help_devtools")
+
+import inspect
+import sys
+import traceback
+from io import BytesIO, StringIO
+from os import remove
+from pprint import pprint
+
+from telethon.utils import get_display_name
+
+from pyUltroid import _ignore_eval
+
+from . import *
+
+# Used for Formatting Eval Code, if installed
+try:
+    import black
+except ImportError:
+    black = None
+from random import choice
+
+try:
+    from yaml import safe_load
+except ImportError:
+    from pyUltroid.fns.tools import safe_load
+try:
+    from telegraph import upload_file as uf
+except ImportError:
+    uf = None
+from telethon.tl import functions
+
+fn = functions
+
+
+@ultroid_cmd(
+    pattern="sysinfo$",
+)
+async def _(e):
+    try:
+        remove("Dockerfile")
+    except Exception:
+        pass
+    xx = await e.eor(get_string("com_1"))
+    x, y = await bash("neofetch|sed 's/\x1B\\[[0-9;\\?]*[a-zA-Z]//g' >> neo.txt")
+    if y and y.endswith("NOT_FOUND"):
+        return await xx.edit(f"Error: `{y}`")
+    with open("neo.txt", "r", encoding="utf-8") as neo:
+        p = (neo.read()).replace("\n\n", "")
+    haa = await Carbon(code=p, file_name="neofetch", backgroundColor=choice(ATRA_COL))
+    if isinstance(haa, dict):
+        await xx.edit(f"`{haa}`")
+    else:
+        await e.reply(file=haa)
+        await xx.delete()
+    remove("neo.txt")
+
+
+@ultroid_cmd(pattern="bash", fullsudo=True, only_devs=True)
+async def _(event):
+    try:
+        remove("Dockerfile")
+    except Exception:
+        pass
+    carb, rayso, yamlf = None, None, False
+    try:
+        cmd = event.text.split(" ", maxsplit=1)[1]
+        if cmd.split()[0] in ["-c", "--carbon"]:
+            cmd = cmd.split(maxsplit=1)[1]
+            carb = True
+        if cmd.split()[0] in ["-r", "--rayso"]:
+            cmd = cmd.split(maxsplit=1)[1]
+            rayso = True
+    except IndexError:
+        return await event.eor(get_string("devs_1"), time=10)
+    xx = await event.eor(get_string("com_1"))
+    reply_to_id = event.reply_to_msg_id or event.id
+    stdout, stderr = await bash(cmd, run_code=1)
+    OUT = f"**[👩‍💻](emoji/5301083932211550593) Ⲃⲁⲋⲏ\n\n• COMMAND:**\n`{cmd}` \n\n"
+    err, out = "", ""
+    if stderr:
+        err = f"**[⚠️](emoji/5213205860498549992) Ⲉɴfⲟʀmⲁtⲓⲟɴ:** \n`{stderr}`\n\n"
+    if stdout:
+        if (carb or udB.get_key("CARBON_ON_BASH")) and (
+            event.is_private
+            or event.chat.admin_rights
+            or event.chat.creator
+            or event.chat.default_banned_rights.embed_links
+        ):
+            li = await Carbon(
+                code=stdout,
+                file_name="bash",
+                download=True,
+                backgroundColor=choice(ATRA_COL),
+            )
+            if isinstance(li, dict):
+                await xx.edit(
+                    f"Unknown Response from Carbon: `{li}`\n\nstdout`:{stdout}`\nstderr: `{stderr}`"
+                )
+                return
+            url = f"https://graph.org{uf(li)[-1]}"
+            OUT = f"[\xad]({url}){OUT}"
+            out = f"**[👨‍💻](emoji/5319161050128459957) Ⲟυⲧⲣυⲧ:**"
+            remove(li)
+        elif (rayso or udB.get_key("RAYSO_ON_BASH")) and (
+            event.is_private
+            or event.chat.admin_rights
+            or event.chat.creator
+            or event.chat.default_banned_rights.embed_links
+        ):
+            li = await Carbon(
+                code=stdout,
+                file_name="bash",
+                download=True,
+                backgroundColor=choice(ATRA_COL),
+                rayso=True,
+            )
+            if isinstance(li, dict):
+                await xx.edit(
+                    f"Unknown Response from Carbon: `{li}`\n\nstdout`:{stdout}`\nstderr: `{stderr}`"
+                )
+                return
+            url = f"https://graph.org{uf(li)[-1]}"
+            OUT = f"[\xad]({url}){OUT}"
+            out = f"**[👨‍💻](emoji/5319161050128459957) Ⲟυⲧⲣυⲧ:**"
+            remove(li)
+        else:
+            if "pip" in cmd and all(":" in line for line in stdout.split("\n")):
+                try:
+                    load = safe_load(stdout)
+                    stdout = ""
+                    for data in list(load.keys()):
+                        res = load[data] or ""
+                        if res and "http" not in str(res):
+                            res = f"`{res}`"
+                        stdout += f"**{data}**  :  {res}\n"
+                    yamlf = True
+                except Exception as er:
+                    stdout = f"`{stdout}`"
+                    LOGS.exception(er)
+            else:
+                stdout = f"`{stdout}`"
+            out = f"**[👨‍💻](emoji/5319161050128459957) Ⲟυⲧⲣυⲧ:**\n{stdout}"
+    if not stderr and not stdout:
+        out = f"**[👨‍💻](emoji/5319161050128459957) Ⲟυⲧⲣυⲧ:**\n`Ⲋυⲥⲥⲉⲋⲋ`"
+    OUT += err + out
+    if len(OUT) > 4096:
+        ultd = err + out
+        with BytesIO(str.encode(ultd)) as out_file:
+            out_file.name = "bash.txt"
+            await event.client.send_file(
+                event.chat_id,
+                out_file,
+                force_document=True,
+                thumb=ULTConfig.thumb,
+                allow_cache=False,
+                caption=f"`{cmd}`" if len(cmd) < 998 else None,
+                reply_to=reply_to_id,
+            )
+
+            await xx.delete()
+    else:
+        await xx.edit(OUT, link_preview=not yamlf)
+
+
+pp = pprint  # ignore: pylint
+bot = ultroid = ultroid_bot
+
+
+class u:
+    _ = ""
+
+
+def _parse_eval(value=None):
+    if not value:
+        return value
+    if hasattr(value, "stringify"):
+        try:
+            return value.stringify()
+        except TypeError:
+            pass
+    elif isinstance(value, dict):
+        try:
+            return json_parser(value, indent=1)
+        except BaseException:
+            pass
+    elif isinstance(value, list):
+        newlist = "["
+        for index, child in enumerate(value):
+            newlist += "\n  " + str(_parse_eval(child))
+            if index < len(value) - 1:
+                newlist += ","
+        newlist += "\n]"
+        return newlist
+    return str(value)
+
+
+@ultroid_cmd(pattern="eval", fullsudo=True, only_devs=True)
+async def _(event):
+    try:
+        remove("Dockerfile")
+    except Exception:
+        pass
+    try:
+        cmd = event.text.split(maxsplit=1)[1]
+    except IndexError:
+        return await event.eor(get_string("devs_2"), time=5)
+    xx = None
+    mode = ""
+    spli = cmd.split()
+
+    async def get_():
+        try:
+            cm = cmd.split(maxsplit=1)[1]
+        except IndexError:
+            await event.eor("->> Wrong Format <<-")
+            cm = None
+        return cm
+
+    if spli[0] in ["-s", "--silent"]:
+        await event.delete()
+        mode = "silent"
+    elif spli[0] in ["-n", "-noedit"]:
+        mode = "no-edit"
+        xx = await event.reply(get_string("com_1"))
+    elif spli[0] in ["-gs", "--source"]:
+        mode = "gsource"
+    elif spli[0] in ["-ga", "--args"]:
+        mode = "g-args"
+    if mode:
+        cmd = await get_()
+    if not cmd:
+        return
+    if mode != "silent" and not xx:
+        xx = await event.eor(get_string("com_1"))
+    if black:
+        try:
+            cmd = black.format_str(cmd, mode=black.Mode())
+        except BaseException:
+            # Consider it as Code Error, and move on to be shown ahead.
+            pass
+    reply_to_id = event.reply_to_msg_id or event
+    if (
+        any(item in cmd for item in KEEP_SAFE().All)
+        and not event.out
+        and event.sender_id != ultroid_bot.uid
+    ):
+        warning = await event.forward_to(udB.get_key("LOG_CHANNEL"))
+        await warning.reply(
+            f"Malicious Activities suspected by {inline_mention(await event.get_sender())}"
+        )
+        _ignore_eval.append(event.sender_id)
+        return await xx.edit(
+            f"`Malicious Activities suspected![⚠️](emoji/5213205860498549992)\nReported to owner. Aborted this request!`"
+        )
+    old_stderr = sys.stderr
+    old_stdout = sys.stdout
+    redirected_output = sys.stdout = StringIO()
+    redirected_error = sys.stderr = StringIO()
+    stdout, stderr, exc, timeg = None, None, None, None
+    tima = time.time()
+    try:
+        value = await aexec(cmd, event)
+    except Exception:
+        value = None
+        exc = traceback.format_exc()
+    tima = time.time() - tima
+    stdout = redirected_output.getvalue()
+    stderr = redirected_error.getvalue()
+    sys.stdout = old_stdout
+    sys.stderr = old_stderr
+    if value:
+        try:
+            if mode == "gsource":
+                exc = inspect.getsource(value)
+            elif mode == "g-args":
+                args = inspect.signature(value).parameters.values()
+                name = ""
+                if hasattr(value, "__name__"):
+                    name = value.__name__
+                exc = f"**{name}**\n\n" + "\n ".join([str(arg) for arg in args])
+        except Exception:
+            exc = traceback.format_exc()
+    evaluation = exc or stderr or stdout or _parse_eval(value) or get_string("instu_4")
+    if mode == "silent":
+        if exc:
+            msg = f"[⚠️](emoji/5213205860498549992) <b>EVAL Ⲉʀʀⲟʀ\n\n• CHAT:</b> <code>{get_display_name(event.chat)}</code> [<code>{event.chat_id}</code>]"
+            msg += f"\n\n∆ <b>CODE:</b>\n<code>{cmd}</code>\n\n∆ <b>Ⲉʀʀⲟʀ:</b>\n<code>{exc}</code>"
+            log_chat = udB.get_key("LOG_CHANNEL")
+            if len(msg) > 4000:
+                with BytesIO(msg.encode()) as out_file:
+                    out_file.name = "Eval-Error.txt"
+                return await event.client.send_message(
+                    log_chat, f"`{cmd}`", file=out_file
+                )
+            await event.client.send_message(log_chat, msg, parse_mode="html")
+        return
+    tmt = tima * 1000
+    timef = time_formatter(tmt)
+    timeform = timef if timef != "0s" else f"{tmt:.3f}ms"
+    final_output = (
+        "{} **Ⲉⳳⲁⳑ** (__in {}__)\n```{}``` \n\n{} **Ⲟυⲧⲣυⲧ**: \n```{}``` \n".format(
+            f"[👩‍💻](emoji/5300928913956938544)",
+            timeform,
+            cmd,
+            f"[👨‍💻](emoji/5319161050128459957)",
+            evaluation,
+        )
+    )
+    if len(final_output) > 4096:
+        final_output = evaluation
+        with BytesIO(str.encode(final_output)) as out_file:
+            out_file.name = "eval.txt"
+            await event.client.send_file(
+                event.chat_id,
+                out_file,
+                force_document=True,
+                thumb=ULTConfig.thumb,
+                allow_cache=False,
+                caption=f"```{cmd}```" if len(cmd) < 998 else None,
+                reply_to=reply_to_id,
+            )
+        return await xx.delete()
+    await xx.edit(final_output)
+
+
+def _stringify(text=None, *args, **kwargs):
+    if text:
+        u._ = text
+        text = _parse_eval(text)
+    return print(text, *args, **kwargs)
+
+
+async def aexec(code, event):
+    exec(
+        (
+            "async def __aexec(e, client): "
+            + "\n print = p = _stringify"
+            + "\n message = event = e"
+            + "\n u.r = reply = await event.get_reply_message()"
+            + "\n chat = event.chat_id"
+            + "\n u.lr = locals()"
+        )
+        + "".join(f"\n {l}" for l in code.split("\n"))
+    )
+
+    return await locals()["__aexec"](event, event.client)
+
+
+DUMMY_CPP = """#include <iostream>
+using namespace std;
+
+int main(){
+!code
+}
+"""
+
+
+@ultroid_cmd(pattern="cpp", only_devs=True)
+async def doie(e):
+    match = e.text.split(" ", maxsplit=1)
+    try:
+        match = match[1]
+    except IndexError:
+        return await e.eor(get_string("devs_3"))
+    msg = await e.eor(get_string("com_1"))
+    if "main(" not in match:
+        new_m = "".join(" " * 4 + i + "\n" for i in match.split("\n"))
+        match = DUMMY_CPP.replace("!code", new_m)
+    open("cpp-ultroid.cpp", "w").write(match)
+    m = await bash("g++ -o CppUltroid cpp-ultroid.cpp")
+    o_cpp = f"• **Eval-Cpp**\n`{match}`"
+    if m[1]:
+        o_cpp += f"\n\n**• Error :**\n`{m[1]}`"
+        if len(o_cpp) > 3000:
+            os.remove("cpp-ultroid.cpp")
+            if os.path.exists("CppUltroid"):
+                os.remove("CppUltroid")
+            with BytesIO(str.encode(o_cpp)) as out_file:
+                out_file.name = "error.txt"
+                return await msg.reply(f"`{match}`", file=out_file)
+        return await eor(msg, o_cpp)
+    m = await bash("./CppUltroid")
+    if m[0] != "":
+        o_cpp += f"\n\n**• Output :**\n`{m[0]}`"
+    if m[1]:
+        o_cpp += f"\n\n**• Error :**\n`{m[1]}`"
+    if len(o_cpp) > 3000:
+        with BytesIO(str.encode(o_cpp)) as out_file:
+            out_file.name = "eval.txt"
+            await msg.reply(f"`{match}`", file=out_file)
+    else:
+        await eor(msg, o_cpp)
+    os.remove("CppUltroid")
+    os.remove("cpp-ultroid.cpp")

plugins/downloadupload.py

@@ -0,0 +1,222 @@
+# Ultroid - UserBot
+# Copyright (C) 2021-2023 TeamUltroid
+#
+# This file is a part of < https://github.com/TeamUltroid/Ultroid/ >
+# PLease read the GNU Affero General Public License in
+# <https://www.github.com/TeamUltroid/Ultroid/blob/main/LICENSE/>.
+
+from . import get_help
+
+__doc__ = get_help("help_downloadupload")
+
+import asyncio
+import glob
+import os
+import time
+from datetime import datetime as dt
+
+from aiohttp.client_exceptions import InvalidURL
+from telethon.errors.rpcerrorlist import MessageNotModifiedError
+
+from pyUltroid.fns.helper import time_formatter
+from pyUltroid.fns.tools import get_chat_and_msgid, set_attributes
+
+from . import (
+    LOGS,
+    ULTConfig,
+    downloader,
+    eor,
+    fast_download,
+    get_all_files,
+    get_string,
+    progress,
+    time_formatter,
+    ultroid_cmd,
+)
+
+
+@ultroid_cmd(
+    pattern="download( (.*)|$)",
+)
+async def down(event):
+    matched = event.pattern_match.group(1).strip()
+    msg = await event.eor(get_string("udl_4"))
+    if not matched:
+        return await eor(msg, get_string("udl_5"), time=5)
+    try:
+        splited = matched.split(" | ")
+        link = splited[0]
+        filename = splited[1]
+    except IndexError:
+        filename = None
+    s_time = time.time()
+    try:
+        filename, d = await fast_download(
+            link,
+            filename,
+            progress_callback=lambda d, t: asyncio.get_event_loop().create_task(
+                progress(
+                    d,
+                    t,
+                    msg,
+                    s_time,
+                    f"Downloading from {link}",
+                )
+            ),
+        )
+    except InvalidURL:
+        return await msg.eor("`Invalid URL provided :(`", time=5)
+    await msg.eor(f"`{filename}` `downloaded in {time_formatter(d*1000)}.`")
+
+
+@ultroid_cmd(
+    pattern="dl( (.*)|$)",
+)
+async def download(event):
+    match = event.pattern_match.group(1).strip()
+    if match and "t.me/" in match:
+        chat, msg = get_chat_and_msgid(match)
+        if not (chat and msg):
+            return await event.eor(get_string("gms_1"))
+        match = ""
+        ok = await event.client.get_messages(chat, ids=msg)
+    elif event.reply_to_msg_id:
+        ok = await event.get_reply_message()
+    else:
+        return await event.eor(get_string("cvt_3"), time=8)
+    xx = await event.eor(get_string("com_1"))
+    if not (ok and ok.media):
+        return await xx.eor(get_string("udl_1"), time=5)
+    s = dt.now()
+    k = time.time()
+    if hasattr(ok.media, "document"):
+        file = ok.media.document
+        mime_type = file.mime_type
+        filename = match or ok.file.name
+        if not filename:
+            if "audio" in mime_type:
+                filename = "audio_" + dt.now().isoformat("_", "seconds") + ".ogg"
+            elif "video" in mime_type:
+                filename = "video_" + dt.now().isoformat("_", "seconds") + ".mp4"
+        try:
+            result = await downloader(
+                f"resources/downloads/{filename}",
+                file,
+                xx,
+                k,
+                f"Downloading {filename}...",
+            )
+
+        except MessageNotModifiedError as err:
+            return await xx.edit(str(err))
+        file_name = result.name
+    else:
+        d = "resources/downloads/"
+        file_name = await event.client.download_media(
+            ok,
+            d,
+            progress_callback=lambda d, t: asyncio.get_event_loop().create_task(
+                progress(
+                    d,
+                    t,
+                    xx,
+                    k,
+                    get_string("com_5"),
+                ),
+            ),
+        )
+    e = dt.now()
+    t = time_formatter(((e - s).seconds) * 1000)
+    await xx.eor(get_string("udl_2").format(file_name, t))
+
+
+@ultroid_cmd(
+    pattern="ul( (.*)|$)",
+)
+async def _(event):
+    msg = await event.eor(get_string("com_1"))
+    match = event.pattern_match.group(1)
+    if match:
+        match = match.strip()
+    if not event.out and match == ".env":
+        return await event.reply("`You can't do this...`")
+    stream, force_doc, delete, thumb = (
+        False,
+        True,
+        False,
+        ULTConfig.thumb,
+    )
+    if "--stream" in match:
+        stream = True
+        force_doc = False
+    if "--delete" in match:
+        delete = True
+    if "--no-thumb" in match:
+        thumb = None
+    arguments = ["--stream", "--delete", "--no-thumb"]
+    if any(item in match for item in arguments):
+        match = (
+            match.replace("--stream", "")
+            .replace("--delete", "")
+            .replace("--no-thumb", "")
+            .strip()
+        )
+    if match.endswith("/"):
+        match += "*"
+    results = glob.glob(match)
+    if not results and os.path.exists(match):
+        results = [match]
+    if not results:
+        try:
+            await event.reply(file=match)
+            return await event.try_delete()
+        except Exception as er:
+            LOGS.exception(er)
+        return await msg.eor(get_string("ls1"))
+    for result in results:
+        if os.path.isdir(result):
+            c, s = 0, 0
+            for files in get_all_files(result):
+                attributes = None
+                if stream:
+                    try:
+                        attributes = await set_attributes(files)
+                    except KeyError as er:
+                        LOGS.exception(er)
+                try:
+                    file, _ = await event.client.fast_uploader(
+                        files, show_progress=True, event=msg, to_delete=delete
+                    )
+                    await event.client.send_file(
+                        event.chat_id,
+                        file,
+                        supports_streaming=stream,
+                        force_document=force_doc,
+                        thumb=thumb,
+                        attributes=attributes,
+                        caption=f"`Uploaded` `{files}` `in {time_formatter(_*1000)}`",
+                        reply_to=event.reply_to_msg_id or event,
+                    )
+                    s += 1
+                except (ValueError, IsADirectoryError):
+                    c += 1
+            break
+        attributes = None
+        if stream:
+            try:
+                attributes = await set_attributes(result)
+            except KeyError as er:
+                LOGS.exception(er)
+        file, _ = await event.client.fast_uploader(
+            result, show_progress=True, event=msg, to_delete=delete
+        )
+        await event.client.send_file(
+            event.chat_id,
+            file,
+            supports_streaming=stream,
+            force_document=force_doc,
+            thumb=thumb,
+            attributes=attributes,
+            caption=f"`Uploaded` `{result}` `in {time_formatter(_*1000)}`",
+        )
+    await msg.try_delete()

plugins/echo.py

@@ -0,0 +1,76 @@
+# Ultroid - UserBot
+# Copyright (C) 2021-2023 TeamUltroid
+#
+# This file is a part of < https://github.com/TeamUltroid/Ultroid/ >
+# PLease read the GNU Affero General Public License in
+# <https://www.github.com/TeamUltroid/Ultroid/blob/main/LICENSE/>.
+
+from . import get_help
+
+__doc__ = get_help("help_echo")
+
+
+from telethon.utils import get_display_name
+
+from pyUltroid.dB.echo_db import add_echo, check_echo, list_echo, rem_echo
+
+from . import inline_mention, ultroid_cmd
+
+
+@ultroid_cmd(pattern="addecho( (.*)|$)")
+async def echo(e):
+    r = await e.get_reply_message()
+    if r:
+        user = r.sender_id
+    else:
+        try:
+            user = e.text.split()[1]
+            if user.startswith("@"):
+                ok = await e.client.get_entity(user)
+                user = ok.id
+            else:
+                user = int(user)
+        except BaseException:
+            return await e.eor("Reply To A user.", time=5)
+    if check_echo(e.chat_id, user):
+        return await e.eor("Echo already activated for this user.", time=5)
+    add_echo(e.chat_id, user)
+    ok = await e.client.get_entity(user)
+    user = inline_mention(ok)
+    await e.eor(f"Activated Echo For {user}.")
+
+
+@ultroid_cmd(pattern="remecho( (.*)|$)")
+async def rm(e):
+    r = await e.get_reply_message()
+    if r:
+        user = r.sender_id
+    else:
+        try:
+            user = e.text.split()[1]
+            if user.startswith("@"):
+                ok = await e.client.get_entity(user)
+                user = ok.id
+            else:
+                user = int(user)
+        except BaseException:
+            return await e.eor("Reply To A User.", time=5)
+    if check_echo(e.chat_id, user):
+        rem_echo(e.chat_id, user)
+        ok = await e.client.get_entity(user)
+        user = f"[{get_display_name(ok)}](tg://user?id={ok.id})"
+        return await e.eor(f"Deactivated Echo For {user}.")
+    await e.eor("Echo not activated for this user")
+
+
+@ultroid_cmd(pattern="listecho$")
+async def lstecho(e):
+    if k := list_echo(e.chat_id):
+        user = "**Activated Echo For Users:**\n\n"
+        for x in k:
+            ok = await e.client.get_entity(int(x))
+            kk = f"[{get_display_name(ok)}](tg://user?id={ok.id})"
+            user += f"•{kk}" + "\n"
+        await e.eor(user)
+    else:
+        await e.eor("`List is Empty, For echo`", time=5)

plugins/extra.py

@@ -0,0 +1,85 @@
+# Ultroid - UserBot
+# Copyright (C) 2021-2023 TeamUltroid
+#
+# This file is a part of < https://github.com/TeamUltroid/Ultroid/ >
+# PLease read the GNU Affero General Public License in
+# <https://www.github.com/TeamUltroid/Ultroid/blob/main/LICENSE/>.
+
+from . import get_help
+
+__doc__ = get_help("extra")
+
+import asyncio
+
+from . import get_string, ultroid_cmd
+
+
+@ultroid_cmd(
+    pattern="del$",
+    manager=True,
+)
+async def delete_it(delme):
+    msg_src = await delme.get_reply_message()
+    if not msg_src:
+        return
+    await msg_src.try_delete()
+    await delme.try_delete()
+
+
+@ultroid_cmd(
+    pattern="copy$",
+)
+async def copy(e):
+    reply = await e.get_reply_message()
+    if reply:
+        await reply.reply(reply)
+        return await e.try_delete()
+    await e.eor(get_string("ex_1"), time=5)
+
+
+@ultroid_cmd(
+    pattern="edit",
+)
+async def editer(edit):
+    message = edit.text
+    chat = await edit.get_input_chat()
+    string = str(message[6:])
+    reply = await edit.get_reply_message()
+    if reply and reply.text:
+        try:
+            await reply.edit(string)
+            await edit.delete()
+        except BaseException:
+            pass
+    else:
+        i = 1
+        async for message in edit.client.iter_messages(chat, from_user="me", limit=2):
+            if i == 2:
+                await message.edit(string)
+                await edit.delete()
+                break
+            i += 1
+
+
+@ultroid_cmd(
+    pattern="reply$",
+)
+async def _(e):
+    if e.reply_to_msg_id:
+        chat = e.chat_id
+        try:
+            msg = (await e.client.get_messages(e.chat_id, limit=1, max_id=e.id))[0]
+        except IndexError:
+            return await e.eor(
+                "`You have previously sent no message to reply again...`", time=5
+            )
+        except BaseException as er:
+            return await e.eor(f"**ERROR:** `{er}`")
+        await asyncio.wait(
+            [
+                e.client.delete_messages(chat, [e.id, msg.id]),
+                e.client.send_message(chat, msg, reply_to=e.reply_to_msg_id),
+            ]
+        )
+    else:
+        await e.try_delete()

plugins/fakeaction.py

@@ -0,0 +1,36 @@
+# Ultroid - UserBot
+# Copyright (C) 2021-2023 TeamUltroid
+#
+# This file is a part of < https://github.com/TeamUltroid/Ultroid/ >
+# PLease read the GNU Affero General Public License in
+# <https://www.github.com/TeamUltroid/Ultroid/blob/main/LICENSE/>.
+
+from . import get_help
+
+__doc__ = get_help("help_fakeaction")
+
+import math
+import time
+
+from pyUltroid.fns.admins import ban_time
+
+from . import asyncio, get_string, ultroid_cmd
+
+
+@ultroid_cmd(
+    pattern="f(typing|audio|contact|document|game|location|sticker|photo|round|video)( (.*)|$)"
+)
+async def _(e):
+    act = e.pattern_match.group(1).strip()
+    t = e.pattern_match.group(2)
+    if act in ["audio", "round", "video"]:
+        act = f"record-{act}"
+    if t.isdigit():
+        t = int(t)
+    elif t.endswith(("s", "h", "d", "m")):
+        t = math.ceil((ban_time(t)) - time.time())
+    else:
+        t = 60
+    await e.eor(get_string("fka_1").format(str(t)), time=5)
+    async with e.client.action(e.chat_id, act):
+        await asyncio.sleep(t)

plugins/fileshare.py

@@ -0,0 +1,95 @@
+# Ultroid - UserBot
+# Copyright (C) 2021-2023 TeamUltroid
+#
+# This file is a part of < https://github.com/TeamUltroid/Ultroid/ >
+# PLease read the GNU Affero General Public License in
+# <https://www.github.com/TeamUltroid/Ultroid/blob/main/LICENSE/>.
+
+from . import get_help
+
+__doc__ = get_help("help_fileshare")
+
+import os
+
+from pyUltroid.dB.filestore_db import del_stored, get_stored_msg, list_all_stored_msgs
+from pyUltroid.fns.tools import get_file_link
+
+from . import HNDLR, asst, get_string, in_pattern, udB, ultroid_bot, ultroid_cmd
+
+
+@ultroid_cmd(pattern="store$")
+async def filestoreplg(event):
+    msg = await event.get_reply_message()
+    if not msg:
+        return await event.eor(get_string("fsh_3"), time=10)
+    # allow storing both messages and media.
+    filehash = await get_file_link(msg)
+    link_to_file = f"https://t.me/{asst.me.username}?start={filehash}"
+    await event.eor(
+        get_string("fsh_2").format(link_to_file),
+        link_preview=False,
+    )
+
+
+@ultroid_cmd("delstored ?(.*)")
+async def _(event):
+    match = event.pattern_match.group(1)
+    if not match:
+        return await event.eor("`Give stored film's link to delete.`", time=5)
+    match = match.split("?start=")
+    botusername = match[0].split("/")[-1]
+    if botusername != asst.me.username:
+        return await event.eor(
+            "`Message/Media of provided link was not stored by this bot.`", time=5
+        )
+    msg_id = get_stored_msg(match[1])
+    if not msg_id:
+        return await event.eor(
+            "`Message/Media of provided link was already deleted.`", time=5
+        )
+    del_stored(match[1])
+    await ultroid_bot.delete_messages(udB.get_key("LOG_CHANNEL"), int(msg_id))
+    await event.eor("__Deleted__")
+
+
+@ultroid_cmd("liststored$")
+async def liststored(event):
+    files = list_all_stored_msgs()
+    if not files:
+        return await event.eor(get_string("fsh_4"), time=5)
+    msg = "**Stored files:**\n"
+    for c, i in enumerate(files, start=1):
+        msg += f"`{c}`. https://t.me/{asst.me.username}?start={i}\n"
+    if len(msg) > 4095:
+        with open("liststored.txt", "w") as f:
+            f.write(msg.replace("**", "").replace("`", ""))
+        await event.reply(get_string("fsh_1"), file="liststored.txt")
+        os.remove("liststored.txt")
+        return
+    await event.eor(msg, link_preview=False)
+
+
+@in_pattern("filestore", owner=True)
+async def file_short(event):
+    all_ = list_all_stored_msgs()
+    res = []
+    if all_:
+        LOG_CHA = udB.get_key("LOG_CHANNEL")
+        for msg in all_[:50]:
+            m_id = get_stored_msg(msg)
+            if not m_id:
+                continue
+            message = await asst.get_messages(LOG_CHA, ids=m_id)
+            if not message:
+                continue
+            if message.media:
+                res.append(await event.builder.document(title=msg, file=message.media))
+            elif message.text:
+                res.append(
+                    await event.builder.article(title=message.text, text=message.text)
+                )
+    if not res:
+        title = "You have no stored file :("
+        text = f"{title}\n\nRead `{HNDLR}help fileshare` to know how to store."
+        return await event.answer([await event.builder.article(title=title, text=text)])
+    await event.answer(res, switch_pm="• File Store •", switch_pm_param="start")

plugins/filter.py

@@ -0,0 +1,102 @@
+# Ultroid - UserBot
+# Copyright (C) 2021-2023 TeamUltroid
+#
+# This file is a part of < https://github.com/TeamUltroid/Ultroid/ >
+# PLease read the GNU Affero General Public License in
+# <https://www.github.com/TeamUltroid/Ultroid/blob/main/LICENSE/>.
+
+from . import get_help
+
+__doc__ = get_help("help_filter")
+
+import os
+import re
+
+from telegraph import upload_file as uf
+from telethon.tl.types import User
+from telethon.utils import pack_bot_file_id
+
+from pyUltroid.dB.filter_db import add_filter, get_filter, list_filter, rem_filter
+from pyUltroid.fns.tools import create_tl_btn, format_btn, get_msg_button
+
+from . import events, get_string, mediainfo, udB, ultroid_bot, ultroid_cmd
+from ._inline import something
+
+
+@ultroid_cmd(pattern="addfilter( (.*)|$)")
+async def af(e):
+    wrd = (e.pattern_match.group(1).strip()).lower()
+    wt = await e.get_reply_message()
+    chat = e.chat_id
+    if not (wt and wrd):
+        return await e.eor(get_string("flr_1"))
+    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 wt.download_media()
+            variable = uf(dl)
+            m = f"https://graph.org{variable[0]}"
+        elif wut == "video":
+            if wt.media.document.size > 8 * 1000 * 1000:
+                return await e.eor(get_string("com_4"), time=5)
+            dl = await wt.download_media()
+            variable = uf(dl)
+            os.remove(dl)
+            m = f"https://graph.org{variable[0]}"
+        else:
+            m = pack_bot_file_id(wt.media)
+        if wt.text:
+            txt = wt.text
+            if not btn:
+                txt, btn = get_msg_button(wt.text)
+            add_filter(chat, wrd, txt, m, btn)
+        else:
+            add_filter(chat, wrd, None, m, btn)
+    else:
+        txt = wt.text
+        if not btn:
+            txt, btn = get_msg_button(wt.text)
+        add_filter(chat, wrd, txt, None, btn)
+    await e.eor(get_string("flr_4").format(wrd))
+    ultroid_bot.add_handler(filter_func, events.NewMessage())
+
+
+@ultroid_cmd(pattern="remfilter( (.*)|$)")
+async def rf(e):
+    wrd = (e.pattern_match.group(1).strip()).lower()
+    chat = e.chat_id
+    if not wrd:
+        return await e.eor(get_string("flr_3"))
+    rem_filter(int(chat), wrd)
+    await e.eor(get_string("flr_5").format(wrd))
+
+
+@ultroid_cmd(pattern="listfilter$")
+async def lsnote(e):
+    if x := list_filter(e.chat_id):
+        sd = "Filters Found In This Chats Are\n\n"
+        return await e.eor(sd + x)
+    await e.eor(get_string("flr_6"))
+
+
+async def filter_func(e):
+    if isinstance(e.sender, User) and e.sender.bot:
+        return
+    xx = (e.text).lower()
+    chat = e.chat_id
+    if x := get_filter(chat):
+        for c in x:
+            pat = r"( |^|[^\w])" + re.escape(c) + r"( |$|[^\w])"
+            if re.search(pat, xx):
+                if k := x.get(c):
+                    msg = k["msg"]
+                    media = k["media"]
+                    if k.get("button"):
+                        btn = create_tl_btn(k["button"])
+                        return await something(e, msg, media, btn)
+                    await e.reply(msg, file=media)
+
+
+if udB.get_key("FILTERS"):
+    ultroid_bot.add_handler(filter_func, events.NewMessage())

plugins/flux2.py

@@ -0,0 +1,95 @@
+import requests
+import os
+import json
+from . import ultroid_cmd, LOGS, fast_download
+
+@ultroid_cmd(pattern="flux2(?:\s+(-p1|-p2|-l1|-l2|-s1|-s2|-hd)\s+(.*))?$")
+async def codegen(e):
+    # Default to "portrait_16_9" if no specific command is provided
+    args = e.pattern_match.group(2)
+    size_option = e.pattern_match.group(1) or "portrait_16_9"
+    
+    # Map the size_option to the corresponding image size
+    size_mapping = {
+        "-p1": "portrait_4_3",
+        "-p2": "portrait_16_9",
+        "-l1": "landscape_4_3",
+        "-l2": "landscape_16_9",
+        "-s1": "square",
+        "-s2": "square_hd",
+        "-hd": "square_hd"
+    }
+    image_size = size_mapping.get(size_option, "portrait_16_9")
+
+    # Handle when no prompt is provided
+    if not args:
+        reply = await e.get_reply_message()
+        if reply and reply.text:
+            args = reply.text
+    if not args:
+        return await e.eor("Please provide a prompt to generate images.")
+
+    # Prepare the request
+    API_URL = "http://fal.run/fal-ai/flux/schnell"
+    headers = {
+        "user-agent": "Python/3.x",
+        "content-type": "application/json; charset=utf-8",
+        "accept-encoding": "gzip",
+        "authorization": "Key f2438e21-b687-46c3-998f-0ed0deed8778:6a073a3d9bb73a9ed1c7aa8e8d905ced"
+    }
+    data = {
+        "prompt": args,
+        "image_size": image_size,
+        "num_inference_steps": 4,
+        "num_images": 4,
+        "embeddings": [],
+        "format": "jpeg",
+        "sync_mode": False,
+        "seed": "0",
+        "enable_safety_checker": False
+    }
+
+    # Notify the user that image generation is in progress
+    moi = await e.eor("🔄 Generating images, please wait...")
+
+    try:
+        response = requests.post(API_URL, headers=headers, json=data)
+
+        if response.status_code != 200:
+            LOGS.error(f"Request failed with status code {response.status_code}")
+            return await moi.edit("Failed to generate images. Please try again later.")
+
+        images = response.json().get("images", [])
+        if not images:
+            return await moi.edit("No images were generated.")
+
+        # Download images
+        image_paths = await download_images([img["url"] for img in images])
+
+        # Send images as a group
+        await send_images_as_group(e, args, image_paths)
+
+        # Clean up the files after sending
+        for path in image_paths:
+            os.remove(path)
+
+        await moi.delete()
+
+    except Exception as exc:
+        LOGS.error(f"Error: {exc}")
+        await moi.edit(f"An error occurred: {exc}")
+
+async def download_images(image_urls):
+    downloaded_paths = []
+    for i, url in enumerate(image_urls, start=1):
+        filename = f"image_{i}.png"
+        path, _ = await fast_download(url, filename=filename)
+        downloaded_paths.append(path)
+    return downloaded_paths
+
+async def send_images_as_group(e, query, image_paths):
+    caption = f"^^{query}^^"
+    media = [await e.client.upload_file(path) for path in image_paths]
+    await e.client.send_message(
+        e.chat_id, caption, file=media, parse_mode="markdown", reply_to=e.reply_to_msg_id
+    )

plugins/fontgen.py

@@ -0,0 +1,60 @@
+# Ultroid - UserBot
+# Copyright (C) 2021-2023 TeamUltroid
+#
+# This file is a part of < https://github.com/TeamUltroid/Ultroid/ >
+# PLease read the GNU Affero General Public License in
+# <https://www.github.com/TeamUltroid/Ultroid/blob/main/LICENSE/>.
+
+from . import get_help
+
+__doc__ = get_help("help_fontgen")
+
+import string
+
+from . import eod, ultroid_cmd
+
+_default = string.ascii_letters
+Fonts = {
+    "small caps": "ᴀʙᴄᴅᴇғɢʜɪᴊᴋʟᴍɴᴏᴘϙʀsᴛᴜᴠᴡxʏᴢABCDEFGHIJKLMNOPQRSTUVWXYZ",
+    "monospace": "𝚊𝚋𝚌𝚍𝚎𝚏𝚐𝚑𝚒𝚓𝚔𝚕𝚖𝚗𝚘𝚙𝚚𝚛𝚜𝚝𝚞𝚟𝚠𝚡𝚢𝚣𝙰𝙱𝙲𝙳𝙴𝙵𝙶𝙷𝙸𝙹𝙺𝙻𝙼𝙽𝙾𝙿𝚀𝚁𝚂𝚃𝚄𝚅𝚆𝚇𝚈𝚉",
+    "double stroke": "𝕒𝕓𝕔𝕕𝕖𝕗𝕘𝕙𝕚𝕛𝕜𝕝𝕞𝕟𝕠𝕡𝕢𝕣𝕤𝕥𝕦𝕧𝕨𝕩𝕪𝕫𝔸𝔹ℂ𝔻𝔼𝔽𝔾ℍ𝕀𝕁𝕂𝕃𝕄ℕ𝕆ℙℚℝ𝕊𝕋𝕌𝕍𝕎𝕏𝕐ℤ",
+    "script royal": "𝒶𝒷𝒸𝒹𝑒𝒻𝑔𝒽𝒾𝒿𝓀𝓁𝓂𝓃𝑜𝓅𝓆𝓇𝓈𝓉𝓊𝓋𝓌𝓍𝓎𝓏𝒜ℬ𝒞𝒟ℰℱ𝒢ℋℐ𝒥𝒦ℒℳ𝒩𝒪𝒫𝒬ℛ𝒮𝒯𝒰𝒱𝒲𝒳𝒴𝒵",
+}
+
+
+@ultroid_cmd(
+    pattern="font( (.*)|$)",
+)
+async def _(e):
+    input = e.pattern_match.group(1).strip()
+    reply = await e.get_reply_message()
+    if not input:
+        m = "**Available Fonts**\n\n"
+        for x in Fonts.keys():
+            m += f"• `{x}`\n"
+        return await e.eor(m, time=5)
+    if not reply:
+        try:
+            _ = input.split(":", maxsplit=1)
+            font = _[0][:-1]
+            text = _[1]
+        except IndexError:
+            return await eod(e, help)
+    elif not input:
+        return await eod(e, "`Give font dude :/`")
+    else:
+        font = input
+        text = reply.message
+    if font not in Fonts.keys():
+        return await e.eor(f"`{font} not in font list`.", time=5)
+    msg = gen_font(text, Fonts[font])
+    await e.eor(msg)
+
+
+def gen_font(text, new_font):
+    new_font = " ".join(new_font).split()
+    for q in text:
+        if q in _default:
+            new = new_font[_default.index(q)]
+            text = text.replace(q, new)
+    return text

plugins/forcesubscribe.py

@@ -0,0 +1,179 @@
+# Ultroid - UserBot
+# Copyright (C) 2021-2023 TeamUltroid
+#
+# This file is a part of < https://github.com/TeamUltroid/Ultroid/ >
+# PLease read the GNU Affero General Public License in
+# <https://www.github.com/TeamUltroid/Ultroid/blob/main/LICENSE/>.
+"""
+✘ Commands Available -
+
+• `{i}fsub <chat username><id>`
+    Enable ForceSub in Used Chat !
+
+• `{i}checkfsub`
+    Check/Get Active ForceSub Setting of Used Chat.
+
+• `{i}remfsub`
+    Remove ForceSub from Used Chat !
+
+    Note - You Need to be Admin in Both Channel/Chats
+        in order to Use ForceSubscribe.
+"""
+
+import re
+
+from telethon.errors.rpcerrorlist import ChatAdminRequiredError, UserNotParticipantError
+from telethon.tl.custom import Button
+from telethon.tl.functions.channels import GetParticipantRequest
+from telethon.tl.functions.messages import ExportChatInviteRequest
+from telethon.tl.types import (
+    Channel,
+    ChannelParticipantBanned,
+    ChannelParticipantLeft,
+    User,
+)
+
+from pyUltroid.dB.forcesub_db import add_forcesub, get_forcesetting, rem_forcesub
+
+from . import (
+    LOGS,
+    asst,
+    callback,
+    events,
+    get_string,
+    in_pattern,
+    inline_mention,
+    udB,
+    ultroid_bot,
+    ultroid_cmd,
+)
+
+CACHE = {}
+
+
+@ultroid_cmd(pattern="fsub( (.*)|$)", admins_only=True, groups_only=True)
+async def addfor(e):
+    match = e.pattern_match.group(1).strip()
+    if not match:
+        return await e.eor(get_string("fsub_1"), time=5)
+    try:
+        match = await e.client.parse_id(match)
+    except BaseException:
+        return await e.eor(get_string("fsub_2"), time=5)
+    add_forcesub(e.chat_id, match)
+    await e.eor("Added ForceSub in This Chat !")
+    ultroid_bot.add_handler(force_sub, events.NewMessage(incoming=True))
+
+
+@ultroid_cmd(pattern="remfsub$")
+async def remor(e):
+    res = rem_forcesub(e.chat_id)
+    if not res:
+        return await e.eor(get_string("fsub_3"), time=5)
+    await e.eor("Removed ForceSub...")
+
+
+@ultroid_cmd(pattern="checkfsub$")
+async def getfsr(e):
+    res = get_forcesetting(e.chat_id)
+    if not res:
+        return await e.eor("ForceSub is Not Active In This Chat !", time=5)
+    cha = await e.client.get_entity(int(res))
+    await e.eor(f"**ForceSub Status** : `Active`\n- **{cha.title}** `({res})`")
+
+
+@in_pattern("fsub( (.*)|$)", owner=True)
+async def fcall(e):
+    match = e.pattern_match.group(1).strip()
+    spli = match.split("_")
+    user = await ultroid_bot.get_entity(int(spli[0]))
+    cl = await ultroid_bot.get_entity(int(spli[1]))
+    text = f"Hi {inline_mention(user)}, You Need to Join"
+    text += f" {cl.title} in order to Chat in this Group."
+    el = (
+        f"https://t.me/{cl.username}"
+        if cl.username
+        else (await ultroid_bot(ExportChatInviteRequest(cl))).link
+    )
+
+    res = [
+        await e.builder.article(
+            title="forcesub",
+            text=text,
+            buttons=[
+                [Button.url(text=get_string("fsub_4"), url=el)],
+                [Button.inline(get_string("fsub_5"), data=f"unm_{match}")],
+            ],
+        )
+    ]
+    await e.answer(res)
+
+
+@callback(re.compile("unm_(.*)"))
+async def diesoon(e):
+    match = (e.data_match.group(1)).decode("UTF-8")
+    spli = match.split("_")
+    if e.sender_id != int(spli[0]):
+        return await e.answer(get_string("fsub_7"), alert=True)
+    try:
+        values = await ultroid_bot(GetParticipantRequest(int(spli[1]), int(spli[0])))
+        if isinstance(values.participant, ChannelParticipantLeft) or (
+            isinstance(values.participant, ChannelParticipantBanned) and values.left
+        ):
+            raise UserNotParticipantError("")
+    except UserNotParticipantError:
+        return await e.answer(
+            "Please Join That Channel !\nThen Click This Button !", alert=True
+        )
+    await ultroid_bot.edit_permissions(
+        e.chat_id, int(spli[0]), send_messages=True, until_date=None
+    )
+    await e.edit(get_string("fsub_8"))
+
+
+async def force_sub(ult):
+    if not udB.get_key("FORCESUB"):
+        return
+    user = await ult.get_sender()
+    joinchat = get_forcesetting(ult.chat_id)
+    if (not joinchat) or (isinstance(user, User) and user.bot):
+        return
+    if CACHE.get(ult.chat_id):
+        if CACHE[ult.chat_id].get(user.id):
+            CACHE[ult.chat_id].update({user.id: CACHE[ult.chat_id][user.id] + 1})
+        else:
+            CACHE[ult.chat_id].update({user.id: 1})
+    else:
+        CACHE.update({ult.chat_id: {user.id: 1}})
+    count = CACHE[ult.chat_id][user.id]
+    if count == 11:
+        CACHE[ult.chat_id][user.id] = 1
+        return
+    if count in range(2, 11):
+        return
+    try:
+        await ultroid_bot.get_permissions(int(joinchat), user.id)
+        return
+    except UserNotParticipantError:
+        pass
+    if isinstance(user, Channel):
+        try:
+            await ultroid_bot.edit_permissions(
+                ult.chat_id, user.id, view_messages=False
+            )
+            return
+        except BaseException as er:
+            LOGS.exception(er)
+    try:
+        await ultroid_bot.edit_permissions(ult.chat_id, user.id, send_messages=False)
+    except ChatAdminRequiredError:
+        return
+    except Exception as e:
+        await ult.delete()
+        LOGS.info(e)
+    res = await ultroid_bot.inline_query(asst.me.username, f"fsub {user.id}_{joinchat}")
+    await res[0].click(ult.chat_id, reply_to=ult.id)
+
+
+if udB.get_key("FORCESUB"):
+    ultroid_bot.add_handler(force_sub, events.NewMessage(incoming=True))

plugins/gdrive.py

@@ -0,0 +1,232 @@
+# Ultroid - UserBot
+# Copyright (C) 2021-2023 TeamUltroid
+#
+# This file is a part of < https://github.com/TeamUltroid/Ultroid/ >
+# PLease read the GNU Affero General Public License in
+# <https://www.github.com/TeamUltroid/Ultroid/blob/main/LICENSE/>.
+"""
+✘ Commands Available
+
+• `{i}gdul <reply/file name>`
+    Reply to file to upload on Google Drive.
+    Add file name to upload on Google Drive.
+
+• `{i}gdown <file id/link> | <filename>`
+    Download from Gdrive link or file id.
+
+• `{i}gdsearch <file name>`
+    Search file name on Google Drive and get link.
+
+• `{i}gdlist`
+    List all GDrive files.
+
+• `{i}gdfolder`
+    Link to your Google Drive Folder.
+    If added then all files will be uploaded in this folder.
+"""
+
+import os
+import time
+
+from telethon.tl.types import Message
+
+from pyUltroid.fns.gDrive import GDriveManager
+from pyUltroid.fns.helper import time_formatter
+
+from . import ULTConfig, asst, eod, eor, get_string, ultroid_cmd
+
+
+@ultroid_cmd(
+    pattern="gdown( (.*)|$)",
+    fullsudo=True,
+)
+async def gdown(event):
+    GDrive = GDriveManager()
+    match = event.pattern_match.group(1).strip()
+    if not match:
+        return await eod(event, "`Give file id or Gdrive link to download from!`")
+    filename = match.split(" | ")[1].strip() if " | " in match else None
+    eve = await event.eor(get_string("com_1"))
+    _start = time.time()
+    status, response = await GDrive._download_file(eve, match, filename)
+    if not status:
+        return await eve.edit(response)
+    await eve.edit(
+        f"`Downloaded ``{response}`` in {time_formatter((time.time() - _start)*1000)}`"
+    )
+
+
+@ultroid_cmd(
+    pattern="gdlist$",
+    fullsudo=True,
+)
+async def files(event):
+    GDrive = GDriveManager()
+    if not os.path.exists(GDrive.token_file):
+        return await event.eor(get_string("gdrive_6").format(asst.me.username))
+    eve = await event.eor(get_string("com_1"))
+    msg = ""
+    if files := GDrive._list_files:
+        msg += f"{len(files.keys())} files found in gdrive.\n\n"
+        for _ in files:
+            msg += f"> [{files[_]}]({_})\n"
+    else:
+        msg += "Nothing in Gdrive"
+    if len(msg) < 4096:
+        await eve.edit(msg, link_preview=False)
+    else:
+        with open("drive-files.txt", "w") as f:
+            f.write(
+                msg.replace("[", "File Name: ")
+                .replace("](", "\n» Link: ")
+                .replace(")\n", "\n\n")
+            )
+        try:
+            await eve.delete()
+        except BaseException:
+            pass
+        await event.client.send_file(
+            event.chat_id,
+            "drive-files.txt",
+            thumb=ULTConfig.thumb,
+            reply_to=event,
+        )
+        os.remove("drive-files.txt")
+
+
+@ultroid_cmd(
+    pattern="gdul( (.*)|$)",
+    fullsudo=True,
+)
+async def _(event):
+    GDrive = GDriveManager()
+    if not os.path.exists(GDrive.token_file):
+        return await eod(event, get_string("gdrive_6").format(asst.me.username))
+    input_file = event.pattern_match.group(1).strip() or await event.get_reply_message()
+    if not input_file:
+        return await eod(event, "`Reply to file or give its location.`")
+    mone = await event.eor(get_string("com_1"))
+    if isinstance(input_file, Message):
+        location = "resources/downloads"
+        if input_file.photo:
+            filename = await input_file.download_media(location)
+        else:
+            filename = input_file.file.name
+            if not filename:
+                filename = str(round(time.time()))
+            filename = f"{location}/{filename}"
+            try:
+                filename, downloaded_in = await event.client.fast_downloader(
+                    file=input_file.media.document,
+                    filename=filename,
+                    show_progress=True,
+                    event=mone,
+                    message=get_string("com_5"),
+                )
+                filename = filename.name
+            except Exception as e:
+                return await eor(mone, str(e), time=10)
+        await mone.edit(
+            f"`Downloaded to ``{filename}`.`",
+        )
+    else:
+        filename = input_file.strip()
+        if not os.path.exists(filename):
+            return await eod(
+                mone,
+                "File Not found in local server. Give me a file path :((",
+                time=5,
+            )
+    folder_id = None
+    if os.path.isdir(filename):
+        files = os.listdir(filename)
+        if not files:
+            return await eod(
+                mone, "`Requested directory is empty. Can't create empty directory.`"
+            )
+        folder_id = GDrive.create_directory(filename)
+        c = 0
+        for files in sorted(files):
+            file = f"{filename}/{files}"
+            if not os.path.isdir(file):
+                try:
+                    await GDrive._upload_file(mone, path=file, folder_id=folder_id)
+                    c += 1
+                except Exception as e:
+                    return await mone.edit(
+                        f"Exception occurred while uploading to gDrive {e}"
+                    )
+        return await mone.edit(
+            f"`Uploaded `[{filename}](https://drive.google.com/folderview?id={folder_id})` with {c} files.`"
+        )
+    try:
+        g_drive_link = await GDrive._upload_file(
+            mone,
+            filename,
+        )
+        await mone.edit(
+            get_string("gdrive_7").format(filename.split("/")[-1], g_drive_link)
+        )
+    except Exception as e:
+        await mone.edit(f"Exception occurred while uploading to gDrive {e}")
+
+
+@ultroid_cmd(
+    pattern="gdsearch( (.*)|$)",
+    fullsudo=True,
+)
+async def _(event):
+    GDrive = GDriveManager()
+    if not os.path.exists(GDrive.token_file):
+        return await event.eor(get_string("gdrive_6").format(asst.me.username))
+    input_str = event.pattern_match.group(1).strip()
+    if not input_str:
+        return await event.eor("`Give filename to search on GDrive...`")
+    eve = await event.eor(f"`Searching for {input_str} in G-Drive...`")
+    files = GDrive.search(input_str)
+    msg = ""
+    if files:
+        msg += (
+            f"{len(files.keys())} files with {input_str} in title found in GDrive.\n\n"
+        )
+        for _ in files:
+            msg += f"> [{files[_]}]({_})\n"
+    else:
+        msg += f"`No files with title {input_str}`"
+    if len(msg) < 4096:
+        await eve.eor(msg, link_preview=False)
+    else:
+        with open("drive-files.txt", "w") as f:
+            f.write(
+                msg.replace("[", "File Name: ")
+                .replace("](", "\n» Link: ")
+                .replace(")\n", "\n\n")
+            )
+        try:
+            await eve.delete()
+        except BaseException:
+            pass
+        await event.client.send_file(
+            event.chat_id,
+            f"{input_str}.txt",
+            thumb=ULTConfig.thumb,
+            reply_to=event,
+        )
+        os.remove(f"{input_str}.txt")
+
+
+@ultroid_cmd(
+    pattern="gdfolder$",
+    fullsudo=True,
+)
+async def _(event):
+    GDrive = GDriveManager()
+    if not os.path.exists(GDrive.token_file):
+        return await event.eor(get_string("gdrive_6").format(asst.me.username))
+    if GDrive.folder_id:
+        await event.eor(
+            "`Your G-Drive Folder link : `\n"
+            + GDrive._create_folder_link(GDrive.folder_id)
+        )
+    else:
+        await eod(event, "Set FOLDERID from your Assistant bot's Settings ")

plugins/gemi.py

@@ -0,0 +1,413 @@
+# Nimbus ~ UserBot
+# Copyright (C) 2023 NimbusTheCloud
+#
+# This file is a part of < https://github.com/ufoptg/Nimbus/ >
+# PLease read the GNU Affero General Public License in
+# <https://www.github.com/ufoptg/Nimbus/blob/main/LICENSE/>.
+# by @SoulOfSukuna
+"""
+Gemini Command Handler
+
+This script provides the `.gemini` command to interact with Google's Gemini AI for generating content, selecting models, and managing chat history. 
+
+Available Gemini Models:
+- `gemini-2.0-flash-exp` ➔ Trait: `g2f-exp` (Default model)
+- `gemini-1.5-flash` ➔ Trait: `g1f`
+- `gemini-1.5-flash-8b` ➔ Trait: `g1f8b`
+- `gemini-1.5-pro` ➔ Trait: `g1p`
+
+Features:
+1. Query Gemini AI:
+   - `.gemini <your query>` ➔ Generates a response using the currently selected model.
+   - Example: `.gemini Write a poem about the stars.`
+
+2. Select a Model:
+   - `.gemini -m <trait>` ➔ Selects a specific model based on its trait.
+   - Example: `.gemini -m g1f` ➔ Switches to the `gemini-1.5-flash` model.
+   - If an invalid trait is provided, an error message will be returned.
+
+3. Clear Chat History:
+   - `.gemini -c` ➔ Clears the chat history stored in memory.
+   - Example: `.gemini -c` ➔ Removes all previous queries and responses.
+
+4. Handle Long Responses:
+   - If the response exceeds Telegram's character limit (4096 characters), it will be sent as a `.txt` file.
+
+5. Reply-Based Query:
+   - Reply to a message with `.gemini write a cool caption for this image` ➔ Uses the replied message's content as the query and processes the image.
+
+Examples:
+- `.gemini Tell me a joke about programmers.`
+- `.gemini -m g2f-exp`
+- `.gemini -c`
+- Reply to an image with `.gemini write a cool caption for this image`
+"""
+
+import asyncio
+import mimetypes
+from collections import deque, defaultdict
+from io import BytesIO
+from os import system, path, remove
+from googleapiclient.discovery import build
+import time
+import logging
+from bs4 import BeautifulSoup
+
+try:
+    import google.generativeai as genai
+except ImportError:
+    system("pip install -q google-generativeai")
+    import google.generativeai as genai
+
+try:
+    from PIL import Image
+except ImportError:
+    system("pip install -q Pillow")
+    from PIL import Image
+
+from typing import Optional
+
+from . import (
+    ultroid_cmd,
+    async_searcher,
+    check_filename,
+    udB,
+    LOGS,
+    download_file,
+    run_async,
+)
+
+MODELS = [
+    {"id": "gemini-2.0-flash-exp", "traits": ["g2f-exp"]},
+    {"id": "gemini-1.5-flash", "traits": ["g1f"]},
+    {"id": "gemini-1.5-flash-8b", "traits": ["g1f8b"]},
+    {"id": "gemini-1.5-pro", "traits": ["g1p"]},
+]
+
+
+def select_model(trait: str) -> Optional[str]:
+    """Selects the Gemini model ID based on the provided trait."""
+    for model in MODELS:
+        if trait in model["traits"]:
+            return model["id"]
+    return None
+
+logging.getLogger("googleapiclient.discovery_cache").setLevel(logging.WARNING)
+
+CONFIG = {"model": select_model("g2f-exp")}
+
+GEMINI_CHAT_HISTORY = defaultdict(lambda: deque(maxlen=80))
+
+async def generate_content_with_search(prompt, model):
+    try:
+        search_results = await google_search(prompt)
+        
+        search_summary = "\n".join(
+            [f"{idx + 1}. {res['title']} - {res['snippet']}" for idx, res in enumerate(search_results)]
+        )
+
+
+        enhanced_prompt = (
+            f"Use the following search results to create a comprehensive response:\n\n"
+            f"{search_summary}\n\n"
+            f"Original Query: {prompt}"
+        )
+
+        response = await model.generate_content_async(enhanced_prompt)
+        return response.text.strip()
+
+    except Exception as e:
+        return f"An error occurred while including search results: {e}. Generating content...\n\n{model.generate_content(prompt).text.strip()}"
+
+async def fetch_full_content(url):
+    try:
+        api_url = f"https://scraper.api.airforce/scrape?url={url}"
+        response = await async_searcher(api_url)
+
+        soup = BeautifulSoup(response, "html.parser")
+        main_content = soup.select_one("article") or soup.select_one("main") or soup
+        paragraphs = [
+            para.get_text(separator=" ").strip()
+            for para in main_content.find_all("p")
+            if len(para.get_text(strip=True)) > 30
+            and not any(
+                keyword in para.get_text().lower()
+                for keyword in [
+                    "privacy",
+                    "cookie",
+                    "subscribe",
+                    "sign up",
+                    "terms",
+                    "all rights reserved",
+                    "see all",
+                    "see more",
+                ]
+            )
+        ]
+        full_text = (
+            " ".join(paragraphs[:5]) if paragraphs else "No main content available."
+        )
+        return full_text
+
+    except Exception as e:
+        return f"Error fetching content: {e}"
+
+async def google_search(query):
+    api_key = "AIzaSyAOhKEVXRX-DJbxjyUz5Ol54qCygeRQRTA"
+    cse_id = "a44275f02ca2946da"
+    service = build("customsearch", "v1", developerKey=api_key)
+
+    results = service.cse().list(q=query, cx=cse_id, gl="AU").execute()
+    search_items = results.get("items", [])
+
+    search_results = await asyncio.gather(
+        *(fetch_search_result(item) for item in search_items)
+    )
+
+    return search_results
+
+async def fetch_search_result(item):
+    title = item.get("title")
+    link = item.get("link")
+    snippet = item.get("snippet")
+    full_content = await fetch_full_content(link)
+    return {
+        "title": title,
+        "link": link,
+        "snippet": snippet,
+        "full_content": full_content or "No additional content available."
+    }
+
+async def process_file(file_path: str) -> str:
+    """
+    Uploads a file to Gemini and returns the file URL.
+    """
+    try:
+        mime_type, _ = mimetypes.guess_type(file_path)
+        if not mime_type:
+            mime_type = 'application/octet-stream'
+        file_url = await asyncio.to_thread(genai.upload_file, file_path, mime_type=mime_type)
+        return file_url
+    except Exception as exc:
+        LOGS.error(f"File upload failed: {exc}")
+        raise
+
+async def process_video_file(file_path: str) -> str:
+    """
+    Uploads a video to Gemini and returns the file URL.
+    """
+    try:
+        video_file = await asyncio.to_thread(genai.upload_file, path=file_path)
+        while video_file.state.name == "PROCESSING":
+            await asyncio.sleep(10)
+            video_file = genai.get_file(video_file.name)
+
+        if video_file.state.name == "FAILED":
+            raise ValueError(video_file.state.name)
+        return video_file
+    except Exception as exc:
+        LOGS.error(f"File upload failed: {exc}")
+        raise
+
+async def process_image_with_pillow(file_path: str) -> Optional[str]:
+    """
+    Processes an image file using PIL.Image, saves it temporarily,
+    uploads it to Gemini, and returns the file URL.
+    """
+    try:
+        with Image.open(file_path) as img:
+            img = img.convert("RGB")
+            buffer = BytesIO()
+            buffer.name = "processed_image.jpeg"
+            img.save(buffer, format="JPEG", quality=90)
+            buffer.seek(0)
+
+            temp_image_path = "temp_processed_image.jpeg"
+            with open(temp_image_path, "wb") as temp_file:
+                temp_file.write(buffer.read())
+
+        file_url = await process_file(temp_image_path)
+
+        remove(temp_image_path)
+
+        return file_url
+    except Exception as exc:
+        LOGS.error(f"Image processing failed: {exc}")
+        return None
+
+
+async def handle_multimodal_input(event, e) -> Optional[str]:
+    """
+    Checks and processes images, audio, or video in a replied message.
+    Ensures cleanup of downloaded files.
+    Returns the file URL or None if processing fails.
+    """
+    temp_file = None
+    try:
+        if event.photo:
+            temp_file = await event.download_media()
+            await e.eor("Processing image with Pillow...")
+            return await process_image_with_pillow(temp_file)
+        elif event.voice or event.audio:
+            temp_file = await event.download_media()
+            await e.eor("Uploading audio...")
+            return await process_file(temp_file)
+        elif event.video:
+            temp_file = await event.download_media()
+            await e.eor("Uploading video...")
+            return await process_video_file(temp_file)
+    except Exception as exc:
+        LOGS.error(f"Error processing media: {exc}")
+    finally:
+        if temp_file and path.exists(temp_file):
+            try:
+                remove(temp_file)
+                LOGS.info(f"Cleaned up temporary file: {temp_file}")
+            except Exception as cleanup_exc:
+                LOGS.warning(f"Failed to clean up temporary file: {cleanup_exc}")
+    return None
+
+
+async def get_gemini_response(user_id: int, query: str, api_key: str, file_url: Optional[str] = None) -> str:
+    """
+    Generates a response from the selected Gemini model based on the user query.
+    Includes the user's chat history in the request.
+    If a file URL is provided, it is included in the content generation.
+    """
+    try:
+        genai.configure(api_key=api_key)
+        model = genai.GenerativeModel(CONFIG["model"])
+
+        chat_history = GEMINI_CHAT_HISTORY[user_id]
+
+        if chat_history:
+            formatted_history = "\n".join(
+                [f"{msg['role']}: {msg['content']}" for msg in chat_history]
+            )
+            if file_url:
+                content = [file_url, "\n\n", f"{formatted_history}\nuser: {query}"]
+            else:
+                content = f"{formatted_history}\nuser: {query}"
+        else:
+            if file_url:
+                content = [file_url, "\n\n", query]
+            else:
+                content = query
+
+        # Key Addition: Handle queries without file_url using Google Search
+        if not file_url:
+            response = await generate_content_with_search(query, model)
+            return response
+
+        response = await asyncio.to_thread(model.generate_content, content)
+        return response.text.strip()
+    except Exception as exc:
+        LOGS.error(f"Error generating response: {exc}")
+        raise
+
+
+@ultroid_cmd(pattern=r"gemi(?:\s+([\s\S]*))?$")
+async def gemini_handler(e):
+    """
+    Handles the .gemini command with optional model selection.
+    """
+    args = e.pattern_match.group(1)
+
+    trait = None
+    user_query = None
+    file_url = None
+
+    try:
+        user_id = e.sender.id
+    except AttributeError:
+        user_id = e.from_id.user_id
+
+    if args:
+        if args.startswith("-m"):
+            trait = args[3:].lower().strip()
+            selected_model = select_model(trait)
+            if not selected_model:
+                return await e.eor("❌ **Error:** Invalid model trait specified.", time=10)
+            CONFIG["model"] = selected_model
+            return await e.eor(f"✅ **Success:** Selected Model: `{CONFIG['model']}`", time=10)
+        elif args.strip().lower() == "-c":
+            GEMINI_CHAT_HISTORY[user_id].clear()
+            return await e.eor("🧹 **Success:** Cleared your Gemini Chat History!", time=6)
+        else:
+            user_query = args.strip()
+
+    api_key = udB.get_key("GEMINI_API")
+    if not api_key:
+        return await e.eor(
+            "⚠️ **Error:** `GEMINI_API` key missing. Please set it using `.setvar GEMINI_API your_api_key_here`.",
+            time=10,
+        )
+
+    query = user_query
+    file_url = None
+
+    reply = await e.get_reply_message()
+    if reply:
+        # New logic to handle file content
+        if (
+            reply.file
+            and reply.file.mime_type in ["text/x-python", "text/plain"]
+        ):
+            # Download the file and read its content
+            file = await reply.download_media(BytesIO())
+            file.seek(0)
+            query = file.read().decode("utf-8")
+
+        multimodal_content = await handle_multimodal_input(reply, e)
+        if multimodal_content:
+            file_url = multimodal_content
+            if not query:
+                if reply.photo:
+                    query = "Analyse this image"
+                elif reply.voice or reply.audio:
+                    query = "Analyse this audio."
+                elif reply.video:
+                    query = "Analyse this video"
+        elif reply.text and not query:
+            query = reply.text.strip()
+
+    if not query and not file_url:
+        return await e.eor(
+            "💬 **Usage:** `.gemini <your query>`\n*Provide a query or reply with media to generate content using Gemini AI.*",
+            time=5,
+        )
+
+    processing_message = await e.eor(f"🔄 **Processing your request using `{CONFIG['model']}`...**")
+
+    GEMINI_CHAT_HISTORY[user_id].append({"role": "user", "content": query})
+
+    try:
+        response = await get_gemini_response(user_id, query, api_key, file_url=file_url)
+        GEMINI_CHAT_HISTORY[user_id].append({"role": "assistant", "content": response})
+    except Exception as exc:
+        LOGS.warning(f"Gemini response generation failed: {exc}", exc_info=True)
+        if query:
+            GEMINI_CHAT_HISTORY[user_id].pop()
+        return await processing_message.edit(f"❌ **Error:** {exc}")
+
+    if len(response) < 4096:
+        reply_text = f"📄 **Gemini Response:**\n\n{response}"
+        await processing_message.edit(reply_text, parse_mode="markdown")
+    else:
+        buffer = BytesIO()
+        try:
+            buffer.write(response.encode('utf-8'))
+            buffer.seek(0)
+            buffer.name = "gemini_response.txt"
+            await e.client.send_file(
+                e.chat_id,
+                buffer,
+                caption="📄 **Gemini Response:**",
+                reply_to=e.reply_to_msg_id,
+            )
+        except Exception as exc:
+            LOGS.error(f"Error sending file: {exc}")
+            await processing_message.edit("❌ **Error:** Failed to send the response as a file.")
+        finally:
+            buffer.close()
+        await processing_message.delete()

plugins/giftools.py

@@ -0,0 +1,128 @@
+# Ultroid - UserBot
+# Copyright (C) 2021-2023 TeamUltroid
+#
+# This file is a part of < https://github.com/TeamUltroid/Ultroid/ >
+# PLease read the GNU Affero General Public License in
+# <https://www.github.com/TeamUltroid/Ultroid/blob/main/LICENSE/>.
+"""
+✘ Commands Available
+
+•`{i}invertgif`
+  Make Gif Inverted(negative).
+
+•`{i}bwgif`
+  Make Gif black and white
+
+•`{i}rvgif`
+  Reverse a gif
+
+•`{i}vtog`
+  Reply To Video , It will Create Gif
+  Video to Gif
+
+•`{i}gif <query>`
+   Send video regarding to query.
+"""
+import os
+import random
+import time
+from datetime import datetime as dt
+
+from . import HNDLR, LOGS, bash, downloader, get_string, mediainfo, ultroid_cmd
+
+
+@ultroid_cmd(pattern="(bw|invert)gif$")
+async def igif(e):
+    match = e.pattern_match.group(1).strip()
+    a = await e.get_reply_message()
+    if not (a and a.media):
+        return await e.eor("`Reply To gif only`", time=5)
+    wut = mediainfo(a.media)
+    if "gif" not in wut:
+        return await e.eor("`Reply To Gif Only`", time=5)
+    xx = await e.eor(get_string("com_1"))
+    z = await a.download_media()
+    if match == "bw":
+        cmd = f'ffmpeg -i "{z}" -vf format=gray ult.gif -y'
+    else:
+        cmd = f'ffmpeg -i "{z}" -vf lutyuv="y=negval:u=negval:v=negval" ult.gif -y'
+    try:
+        await bash(cmd)
+        await e.client.send_file(e.chat_id, "ult.gif", supports_streaming=True)
+        os.remove(z)
+        os.remove("ult.gif")
+        await xx.delete()
+    except Exception as er:
+        LOGS.info(er)
+
+
+@ultroid_cmd(pattern="rvgif$")
+async def reverse_gif(event):
+    a = await event.get_reply_message()
+    if not (a and a.media) and "video" not in mediainfo(a.media):
+        return await event.eor("`Reply To Video only`", time=5)
+    msg = await event.eor(get_string("com_1"))
+    file = await a.download_media()
+    await bash(f'ffmpeg -i "{file}" -vf reverse -af areverse reversed.mp4 -y')
+    await event.respond("- **Reversed Video/GIF**", file="reversed.mp4")
+    await msg.delete()
+    os.remove(file)
+    os.remove("reversed.mp4")
+
+
+@ultroid_cmd(pattern="gif( (.*)|$)")
+async def gifs(ult):
+    get = ult.pattern_match.group(1).strip()
+    xx = random.randint(0, 5)
+    n = 0
+    if ";" in get:
+        try:
+            n = int(get.split(";")[-1])
+        except IndexError:
+            pass
+    if not get:
+        return await ult.eor(f"`{HNDLR}gif <query>`")
+    m = await ult.eor(get_string("com_2"))
+    gifs = await ult.client.inline_query("gif", get)
+    if not n:
+        await gifs[xx].click(
+            ult.chat_id, reply_to=ult.reply_to_msg_id, silent=True, hide_via=True
+        )
+    else:
+        for x in range(n):
+            await gifs[x].click(
+                ult.chat_id, reply_to=ult.reply_to_msg_id, silent=True, hide_via=True
+            )
+    await m.delete()
+
+
+@ultroid_cmd(pattern="vtog$")
+async def vtogif(e):
+    a = await e.get_reply_message()
+    if not (a and a.media):
+        return await e.eor("`Reply To video only`", time=5)
+    wut = mediainfo(a.media)
+    if "video" not in wut:
+        return await e.eor("`Reply To Video Only`", time=5)
+    xx = await e.eor(get_string("com_1"))
+    dur = a.media.document.attributes[0].duration
+    tt = time.time()
+    if int(dur) < 120:
+        z = await a.download_media()
+        await bash(
+            f'ffmpeg -i {z} -vf "fps=10,scale=320:-1:flags=lanczos,split[s0][s1];[s0]palettegen[p];[s1][p]paletteuse" -loop 0 ult.gif -y'
+        )
+    else:
+        filename = a.file.name
+        if not filename:
+            filename = "video_" + dt.now().isoformat("_", "seconds") + ".mp4"
+        vid = await downloader(filename, a.media.document, xx, tt, get_string("com_5"))
+        z = vid.name
+        await bash(
+            f'ffmpeg -ss 3 -t 100 -i {z} -vf "fps=10,scale=320:-1:flags=lanczos,split[s0][s1];[s0]palettegen[p];[s1][p]paletteuse" -loop 0 ult.gif'
+        )
+
+    await e.client.send_file(e.chat_id, "ult.gif", support_stream=True)
+    os.remove(z)
+    os.remove("ult.gif")
+    await xx.delete()

plugins/glitch.py

@@ -0,0 +1,42 @@
+# Ultroid - UserBot
+# Copyright (C) 2021-2023 TeamUltroid
+#
+# This file is a part of < https://github.com/TeamUltroid/Ultroid/ >
+# PLease read the GNU Affero General Public License in
+# <https://www.github.com/TeamUltroid/Ultroid/blob/main/LICENSE/>.
+"""
+✘ Commands Available -
+
+•`{i}glitch <reply to media>`
+    gives a glitchy gif.
+"""
+import os
+
+from . import bash, get_string, mediainfo, ultroid_cmd
+
+
+@ultroid_cmd(pattern="glitch$")
+async def _(e):
+    try:
+        import glitch_me  # ignore :pylint
+    except ModuleNotFoundError:
+        await bash(
+            "pip install -e git+https://github.com/1Danish-00/glitch_me.git#egg=glitch_me"
+        )
+    reply = await e.get_reply_message()
+    if not reply or not reply.media:
+        return await e.eor(get_string("cvt_3"))
+    xx = await e.eor(get_string("glitch_1"))
+    wut = mediainfo(reply.media)
+    if wut.startswith(("pic", "sticker")):
+        ok = await reply.download_media()
+    elif reply.document and reply.document.thumbs:
+        ok = await reply.download_media(thumb=-1)
+    else:
+        return await xx.eor(get_string("com_4"))
+    cmd = f"glitch_me gif --line_count 200 -f 10 -d 50 '{ok}' ult.gif"
+    await bash(cmd)
+    await e.reply(file="ult.gif", force_document=False)
+    await xx.delete()
+    os.remove(ok)
+    os.remove("ult.gif")

plugins/globaltools.py

@@ -0,0 +1,753 @@
+# Ultroid - UserBot
+# Copyright (C) 2021-2023 TeamUltroid
+#
+# This file is a part of < https://github.com/TeamUltroid/Ultroid/ >
+# PLease read the GNU Affero General Public License in
+# <https://www.github.com/TeamUltroid/Ultroid/blob/main/LICENSE/>.
+"""
+✘ Commands Available -
+
+• `{i}gban <reply user/ username>`
+• `{i}ungban`
+    Ban/Unban Globally.
+
+• `{i}gstat <reply to user/userid/username>`
+   Check if user is GBanned.
+
+• `{i}listgban` : List all GBanned users.
+
+• `{i}gmute` | `{i}ungmute` <reply user/ username>
+    Mute/UnMute Globally.
+
+• `{i}gkick <reply/username>` `Globally Kick User`
+• `{i}gcast <text/reply>` `Globally Send msg in all grps`
+
+• `{i}gadmincast <text/reply>` `Globally broadcast in your admin chats`
+• `{i}gucast <text/reply>` `Globally send msg in all pm users`
+
+• `{i}gblacklist <chat id/username/nothing (for current chat)`
+   Add chat to blacklist and ignores global broadcast.
+• `{i}ungblacklist` `Remove the chat from blacklist.`
+
+• `{i}gpromote <reply to user> <channel/group/all> <rank>`
+    globally promote user where you are admin
+    - Set whether To promote only in groups/channels/all.
+    Eg- `gpromote group boss` ~ promotes user in all grps.
+        `gpromote @username all sar` ~ promote the user in all group & channel
+• `{i}gdemote` - `demote user globally`
+"""
+import asyncio
+import os
+
+from telethon.errors.rpcerrorlist import ChatAdminRequiredError, FloodWaitError
+from telethon.tl.functions.channels import EditAdminRequest
+from telethon.tl.functions.contacts import BlockRequest, UnblockRequest
+from telethon.tl.types import ChatAdminRights, User
+
+from pyUltroid.dB import DEVLIST
+from pyUltroid.dB.base import KeyManager
+from pyUltroid.dB.gban_mute_db import (
+    gban,
+    gmute,
+    is_gbanned,
+    is_gmuted,
+    list_gbanned,
+    ungban,
+    ungmute,
+)
+from pyUltroid.fns.tools import create_tl_btn, format_btn, get_msg_button
+
+from . import (
+    HNDLR,
+    LOGS,
+    NOSPAM_CHAT,
+    OWNER_NAME,
+    eod,
+    eor,
+    get_string,
+    inline_mention,
+    ultroid_bot,
+    ultroid_cmd,
+)
+from ._inline import something
+
+_gpromote_rights = ChatAdminRights(
+    add_admins=False,
+    invite_users=True,
+    change_info=False,
+    ban_users=True,
+    delete_messages=True,
+    pin_messages=True,
+)
+
+_gdemote_rights = ChatAdminRights(
+    add_admins=False,
+    invite_users=False,
+    change_info=False,
+    ban_users=False,
+    delete_messages=False,
+    pin_messages=False,
+)
+
+keym = KeyManager("GBLACKLISTS", cast=list)
+
+
+@ultroid_cmd(pattern="gpromote( (.*)|$)", fullsudo=True)
+async def _(e):
+    x = e.pattern_match.group(1).strip()
+    ultroid_bot = e.client
+    if not x:
+        return await e.eor(get_string("schdl_2"), time=5)
+    user = await e.get_reply_message()
+    if user:
+        ev = await e.eor("`Promoting Replied User Globally`")
+        ok = e.text.split()
+        key = "all"
+        if len(ok) > 1 and (("group" in ok[1]) or ("channel" in ok[1])):
+            key = ok[1]
+        rank = ok[2] if len(ok) > 2 else "AdMin"
+        c = 0
+        user.id = user.peer_id.user_id if e.is_private else user.from_id.user_id
+        async for x in e.client.iter_dialogs():
+            if (
+                "group" in key.lower()
+                and x.is_group
+                or "group" not in key.lower()
+                and "channel" in key.lower()
+                and x.is_channel
+            ):
+                try:
+                    await e.client(
+                        EditAdminRequest(
+                            x.id,
+                            user.id,
+                            _gpromote_rights,
+                            rank,
+                        ),
+                    )
+                    c += 1
+                except BaseException:
+                    pass
+            elif (
+                ("group" not in key.lower() or x.is_group)
+                and (
+                    "group" in key.lower()
+                    or "channel" not in key.lower()
+                    or x.is_channel
+                )
+                and (
+                    "group" in key.lower()
+                    or "channel" in key.lower()
+                    or x.is_group
+                    or x.is_channel
+                )
+            ):
+                try:
+                    await e.client(
+                        EditAdminRequest(
+                            x.id,
+                            user.id,
+                            _gpromote_rights,
+                            rank,
+                        ),
+                    )
+                    c += 1
+                except Exception as er:
+                    LOGS.info(er)
+        await eor(ev, f"Promoted The Replied Users in Total : {c} {key} chats")
+    else:
+        k = e.text.split()
+        if not k[1]:
+            return await eor(
+                e, "`Give someone's username/id or replied to user.", time=5
+            )
+        user = k[1]
+        if user.isdigit():
+            user = int(user)
+        try:
+            name = await e.client.get_entity(user)
+        except BaseException:
+            return await e.eor(f"`No User Found Regarding {user}`", time=5)
+        ev = await e.eor(f"`Promoting {name.first_name} globally.`")
+        key = "all"
+        if len(k) > 2 and (("group" in k[2]) or ("channel" in k[2])):
+            key = k[2]
+        rank = k[3] if len(k) > 3 else "AdMin"
+        c = 0
+        async for x in e.client.iter_dialogs():
+            if (
+                "group" in key.lower()
+                and x.is_group
+                or "group" not in key.lower()
+                and "channel" in key.lower()
+                and x.is_channel
+                or "group" not in key.lower()
+                and "channel" not in key.lower()
+                and (x.is_group or x.is_channel)
+            ):
+                try:
+                    await ultroid_bot(
+                        EditAdminRequest(
+                            x.id,
+                            user,
+                            _gpromote_rights,
+                            rank,
+                        ),
+                    )
+                    c += 1
+                except BaseException:
+                    pass
+        await eor(ev, f"Promoted {name.first_name} in Total : {c} {key} chats.")
+
+
+@ultroid_cmd(pattern="gdemote( (.*)|$)", fullsudo=True)
+async def _(e):
+    x = e.pattern_match.group(1).strip()
+    ultroid_bot = e.client
+    if not x:
+        return await e.eor(get_string("schdl_2"), time=5)
+    user = await e.get_reply_message()
+    if user:
+        user.id = user.peer_id.user_id if e.is_private else user.from_id.user_id
+        ev = await e.eor("`Demoting Replied User Globally`")
+        ok = e.text.split()
+        key = "all"
+        if len(ok) > 1 and (("group" in ok[1]) or ("channel" in ok[1])):
+            key = ok[1]
+        rank = "Not AdMin"
+        c = 0
+        async for x in e.client.iter_dialogs():
+            if (
+                "group" in key.lower()
+                and x.is_group
+                or "group" not in key.lower()
+                and "channel" in key.lower()
+                and x.is_channel
+                or "group" not in key.lower()
+                and "channel" not in key.lower()
+                and (x.is_group or x.is_channel)
+            ):
+                try:
+                    await ultroid_bot(
+                        EditAdminRequest(
+                            x.id,
+                            user.id,
+                            _gdemote_rights,
+                            rank,
+                        ),
+                    )
+                    c += 1
+                except BaseException:
+                    pass
+        await eor(ev, f"Demoted The Replied Users in Total : {c} {key} chats")
+    else:
+        k = e.text.split()
+        if not k[1]:
+            return await eor(
+                e, "`Give someone's username/id or replied to user.", time=5
+            )
+        user = k[1]
+        if user.isdigit():
+            user = int(user)
+        try:
+            name = await ultroid_bot.get_entity(user)
+        except BaseException:
+            return await e.eor(f"`No User Found Regarding {user}`", time=5)
+        ev = await e.eor(f"`Demoting {name.first_name} globally.`")
+        key = "all"
+        if len(k) > 2 and (("group" in k[2]) or ("channel" in k[2])):
+            key = k[2]
+        rank = "Not AdMin"
+        c = 0
+        async for x in ultroid_bot.iter_dialogs():
+            if (
+                "group" in key.lower()
+                and x.is_group
+                or "group" not in key.lower()
+                and "channel" in key.lower()
+                and x.is_channel
+                or "group" not in key.lower()
+                and "channel" not in key.lower()
+                and (x.is_group or x.is_channel)
+            ):
+                try:
+                    await ultroid_bot(
+                        EditAdminRequest(
+                            x.id,
+                            user,
+                            _gdemote_rights,
+                            rank,
+                        ),
+                    )
+                    c += 1
+                except BaseException:
+                    pass
+        await eor(ev, f"Demoted {name.first_name} in Total : {c} {key} chats.")
+
+
+@ultroid_cmd(pattern="ungban( (.*)|$)", fullsudo=True)
+async def _(e):
+    xx = await e.eor("`UnGbanning...`")
+    match = e.pattern_match.group(1).strip()
+    peer = None
+    if e.reply_to_msg_id:
+        userid = (await e.get_reply_message()).sender_id
+    elif match:
+        try:
+            userid = int(match)
+        except ValueError:
+            userid = match
+        try:
+            userid = (await e.client.get_entity(userid)).id
+        except Exception as er:
+            return await xx.edit(f"Failed to get User...\nError: {er}")
+    elif e.is_private:
+        userid = e.chat_id
+    else:
+        return await xx.eor("`Reply to some msg or add their id.`", time=5)
+    if not is_gbanned(userid):
+        return await xx.edit("`User/Channel is not Gbanned...`")
+    try:
+        if not peer:
+            peer = await e.client.get_entity(userid)
+        name = inline_mention(peer)
+    except BaseException:
+        userid = int(userid)
+        name = str(userid)
+    chats = 0
+    if e.client._dialogs:
+        dialog = e.client._dialogs
+    else:
+        dialog = await e.client.get_dialogs()
+        e.client._dialogs.extend(dialog)
+    for ggban in dialog:
+        if ggban.is_group or ggban.is_channel:
+            try:
+                await e.client.edit_permissions(ggban.id, userid, view_messages=True)
+                chats += 1
+            except FloodWaitError as fw:
+                LOGS.info(
+                    f"[FLOOD_WAIT_ERROR] : on Ungban\nSleeping for {fw.seconds+10}"
+                )
+                await asyncio.sleep(fw.seconds + 10)
+                try:
+                    await e.client.edit_permissions(
+                        ggban.id, userid, view_messages=True
+                    )
+                    chats += 1
+                except BaseException as er:
+                    LOGS.exception(er)
+            except (ChatAdminRequiredError, ValueError):
+                pass
+            except BaseException as er:
+                LOGS.exception(er)
+    ungban(userid)
+    if isinstance(peer, User):
+        await e.client(UnblockRequest(userid))
+    await xx.edit(
+        f"`Ungbaned` {name} in {chats} `chats.\nRemoved from gbanwatch.`",
+    )
+
+
+@ultroid_cmd(pattern="gban( (.*)|$)", fullsudo=True)
+async def _(e):
+    xx = await e.eor("`Gbanning...`")
+    reason = ""
+    if e.reply_to_msg_id:
+        userid = (await e.get_reply_message()).sender_id
+        try:
+            reason = e.text.split(" ", maxsplit=1)[1]
+        except IndexError:
+            pass
+    elif e.pattern_match.group(1).strip():
+        usr = e.text.split(maxsplit=2)[1]
+        try:
+            userid = await e.client.parse_id(usr)
+        except ValueError:
+            userid = usr
+        try:
+            reason = e.text.split(maxsplit=2)[2]
+        except IndexError:
+            pass
+    elif e.is_private:
+        userid = e.chat_id
+        try:
+            reason = e.text.split(" ", maxsplit=1)[1]
+        except IndexError:
+            pass
+    else:
+        return await xx.eor("`Reply to some msg or add their id.`", time=5)
+    user = None
+    try:
+        user = await e.client.get_entity(userid)
+        name = inline_mention(user)
+    except BaseException:
+        userid = int(userid)
+        name = str(userid)
+    chats = 0
+    if userid == ultroid_bot.uid:
+        return await xx.eor("`I can't gban myself.`", time=3)
+    elif userid in DEVLIST:
+        return await xx.eor("`I can't gban my Developers.`", time=3)
+    elif is_gbanned(userid):
+        return await eod(
+            xx,
+            "`User is already gbanned and added to gbanwatch.`",
+            time=4,
+        )
+    if e.client._dialogs:
+        dialog = e.client._dialogs
+    else:
+        dialog = await e.client.get_dialogs()
+        e.client._dialogs.extend(dialog)
+    for ggban in dialog:
+        if ggban.is_group or ggban.is_channel:
+            try:
+                await e.client.edit_permissions(ggban.id, userid, view_messages=False)
+                chats += 1
+            except FloodWaitError as fw:
+                LOGS.info(
+                    f"[FLOOD_WAIT_ERROR] : on GBAN Command\nSleeping for {fw.seconds+10}"
+                )
+                await asyncio.sleep(fw.seconds + 10)
+                try:
+                    await e.client.edit_permissions(
+                        ggban.id, userid, view_messages=False
+                    )
+                    chats += 1
+                except BaseException as er:
+                    LOGS.exception(er)
+            except (ChatAdminRequiredError, ValueError):
+                pass
+            except BaseException as er:
+                LOGS.exception(er)
+    gban(userid, reason)
+    if isinstance(user, User):
+        await e.client(BlockRequest(userid))
+    gb_msg = f"**#Gbanned** {name} `in {chats} chats and added to gbanwatch!`"
+    if reason:
+        gb_msg += f"\n**Reason** : {reason}"
+    await xx.edit(gb_msg)
+
+
+@ultroid_cmd(pattern="g(admin|)cast( (.*)|$)", fullsudo=True)
+async def gcast(event):
+    text, btn, reply = "", None, None
+    if xx := event.pattern_match.group(2):
+        msg, btn = get_msg_button(event.text.split(maxsplit=1)[1])
+    elif event.is_reply:
+        reply = await event.get_reply_message()
+        msg = reply.text
+        if reply.buttons:
+            btn = format_btn(reply.buttons)
+        else:
+            msg, btn = get_msg_button(msg)
+    else:
+        return await eor(
+            event, "`Give some text to Globally Broadcast or reply a message..`"
+        )
+
+    kk = await event.eor("`Globally Broadcasting Msg...`")
+    er = 0
+    done = 0
+    err = ""
+    if event.client._dialogs:
+        dialog = event.client._dialogs
+    else:
+        dialog = await event.client.get_dialogs()
+        event.client._dialogs.extend(dialog)
+    for x in dialog:
+        if x.is_group:
+            chat = x.entity.id
+            if (
+                not keym.contains(chat)
+                and int(f"-100{str(chat)}") not in NOSPAM_CHAT
+                and (
+                    (
+                        event.text[2:7] != "admin"
+                        or (x.entity.admin_rights or x.entity.creator)
+                    )
+                )
+            ):
+                try:
+                    if btn:
+                        bt = create_tl_btn(btn)
+                        await something(
+                            event,
+                            msg,
+                            reply.media if reply else None,
+                            bt,
+                            chat=chat,
+                            reply=False,
+                        )
+                    else:
+                        await event.client.send_message(
+                            chat, msg, file=reply.media if reply else None
+                        )
+                    done += 1
+                except FloodWaitError as fw:
+                    await asyncio.sleep(fw.seconds + 10)
+                    try:
+                        if btn:
+                            bt = create_tl_btn(btn)
+                            await something(
+                                event,
+                                msg,
+                                reply.media if reply else None,
+                                bt,
+                                chat=chat,
+                                reply=False,
+                            )
+                        else:
+                            await event.client.send_message(
+                                chat, msg, file=reply.media if reply else None
+                            )
+                        done += 1
+                    except Exception as rr:
+                        err += f"• {rr}\n"
+                        er += 1
+                except BaseException as h:
+                    err += f"• {str(h)}" + "\n"
+                    er += 1
+    text += f"Done in {done} chats, error in {er} chat(s)"
+    if err != "":
+        open("gcast-error.log", "w+").write(err)
+        text += f"\nYou can do `{HNDLR}ul gcast-error.log` to know error report."
+    await kk.edit(text)
+
+
+@ultroid_cmd(pattern="gucast( (.*)|$)", fullsudo=True)
+async def gucast(event):
+    msg, btn, reply = "", None, None
+    if xx := event.pattern_match.group(1).strip():
+        msg, btn = get_msg_button(event.text.split(maxsplit=1)[1])
+    elif event.is_reply:
+        reply = await event.get_reply_message()
+        msg = reply.text
+        if reply.buttons:
+            btn = format_btn(reply.buttons)
+        else:
+            msg, btn = get_msg_button(msg)
+    else:
+        return await eor(
+            event, "`Give some text to Globally Broadcast or reply a message..`"
+        )
+    kk = await event.eor("`Globally Broadcasting Msg...`")
+    er = 0
+    done = 0
+    if event.client._dialogs:
+        dialog = event.client._dialogs
+    else:
+        dialog = await event.client.get_dialogs()
+        event.client._dialogs.extend(dialog)
+    for x in dialog:
+        if x.is_user and not x.entity.bot:
+            chat = x.id
+            if not keym.contains(chat):
+                try:
+                    if btn:
+                        bt = create_tl_btn(btn)
+                        await something(
+                            event,
+                            msg,
+                            reply.media if reply else None,
+                            bt,
+                            chat=chat,
+                            reply=False,
+                        )
+                    else:
+                        await event.client.send_message(
+                            chat, msg, file=reply.media if reply else None
+                        )
+                    done += 1
+                except BaseException:
+                    er += 1
+    await kk.edit(f"Done in {done} chats, error in {er} chat(s)")
+
+
+@ultroid_cmd(pattern="gkick( (.*)|$)", fullsudo=True)
+async def gkick(e):
+    xx = await e.eor("`Gkicking...`")
+    if e.reply_to_msg_id:
+        userid = (await e.get_reply_message()).sender_id
+    elif e.pattern_match.group(1).strip():
+        userid = await e.client.parse_id(e.pattern_match.group(1).strip())
+    elif e.is_private:
+        userid = e.chat_id
+    else:
+        return await xx.edit("`Reply to some msg or add their id.`", time=5)
+    name = (await e.client.get_entity(userid)).first_name
+    chats = 0
+    if userid == ultroid_bot.uid:
+        return await xx.eor("`I can't gkick myself.`", time=3)
+    if userid in DEVLIST:
+        return await xx.eor("`I can't gkick my Developers.`", time=3)
+    if e.client._dialogs:
+        dialog = e.client._dialogs
+    else:
+        dialog = await e.client.get_dialogs()
+        e.client._dialogs.extend(dialog)
+    for gkick in dialog:
+        if gkick.is_group or gkick.is_channel:
+            try:
+                await e.client.kick_participant(gkick.id, userid)
+                chats += 1
+            except BaseException:
+                pass
+    await xx.edit(f"`Gkicked` [{name}](tg://user?id={userid}) `in {chats} chats.`")
+
+
+@ultroid_cmd(pattern="gmute( (.*)|$)", fullsudo=True)
+async def _(e):
+    xx = await e.eor("`Gmuting...`")
+    if e.reply_to_msg_id:
+        userid = (await e.get_reply_message()).sender_id
+    elif e.pattern_match.group(1).strip():
+        userid = await e.client.parse_id(e.pattern_match.group(1).strip())
+    elif e.is_private:
+        userid = e.chat_id
+    else:
+        return await xx.eor("`Reply to some msg or add their id.`", tome=5, time=5)
+    name = await e.client.get_entity(userid)
+    chats = 0
+    if userid == ultroid_bot.uid:
+        return await xx.eor("`I can't gmute myself.`", time=3)
+    if userid in DEVLIST:
+        return await xx.eor("`I can't gmute my Developers.`", time=3)
+    if is_gmuted(userid):
+        return await xx.eor("`User is already gmuted.`", time=4)
+    if e.client._dialogs:
+        dialog = e.client._dialogs
+    else:
+        dialog = await e.client.get_dialogs()
+        e.client._dialogs.extend(dialog)
+    for onmute in dialog:
+        if onmute.is_group:
+            try:
+                await e.client.edit_permissions(onmute.id, userid, send_messages=False)
+                chats += 1
+            except BaseException:
+                pass
+    gmute(userid)
+    await xx.edit(f"`Gmuted` {inline_mention(name)} `in {chats} chats.`")
+
+
+@ultroid_cmd(pattern="ungmute( (.*)|$)", fullsudo=True)
+async def _(e):
+    xx = await e.eor("`UnGmuting...`")
+    if e.reply_to_msg_id:
+        userid = (await e.get_reply_message()).sender_id
+    elif e.pattern_match.group(1).strip():
+        userid = await e.client.parse_id(e.pattern_match.group(1).strip())
+    elif e.is_private:
+        userid = e.chat_id
+    else:
+        return await xx.eor("`Reply to some msg or add their id.`", time=5)
+    name = (await e.client.get_entity(userid)).first_name
+    chats = 0
+    if not is_gmuted(userid):
+        return await xx.eor("`User is not gmuted.`", time=3)
+    if e.client._dialogs:
+        dialog = e.client._dialogs
+    else:
+        dialog = await e.client.get_dialogs()
+        e.client._dialogs.extend(dialog)
+    for hurr in dialog:
+        if hurr.is_group:
+            try:
+                await e.client.edit_permissions(hurr.id, userid, send_messages=True)
+                chats += 1
+            except BaseException:
+                pass
+    ungmute(userid)
+    await xx.edit(f"`Ungmuted` {inline_mention(name)} `in {chats} chats.`")
+
+
+@ultroid_cmd(
+    pattern="listgban$",
+)
+async def list_gengbanned(event):
+    users = list_gbanned()
+    x = await event.eor(get_string("com_1"))
+    msg = ""
+    if not users:
+        return await x.edit("`You haven't GBanned anyone!`")
+    for i in users:
+        try:
+            name = await event.client.get_entity(int(i))
+        except BaseException:
+            name = i
+        msg += f"<strong>User</strong>: {inline_mention(name, html=True)}\n"
+        reason = users[i]
+        msg += f"<strong>Reason</strong>: {reason}\n\n" if reason is not None else "\n"
+    gbanned_users = f"<strong>List of users GBanned by {OWNER_NAME}</strong>:\n\n{msg}"
+    if len(gbanned_users) > 4096:
+        with open("gbanned.txt", "w") as f:
+            f.write(
+                gbanned_users.replace("<strong>", "")
+                .replace("</strong>", "")
+                .replace("<a href=tg://user?id=", "")
+                .replace("</a>", "")
+            )
+        await x.reply(
+            file="gbanned.txt",
+            message=f"List of users GBanned by {inline_mention(ultroid_bot.me)}",
+        )
+        os.remove("gbanned.txt")
+        await x.delete()
+    else:
+        await x.edit(gbanned_users, parse_mode="html")
+
+
+@ultroid_cmd(
+    pattern="gstat( (.*)|$)",
+)
+async def gstat_(e):
+    xx = await e.eor(get_string("com_1"))
+    if e.is_private:
+        userid = (await e.get_chat()).id
+    elif e.reply_to_msg_id:
+        userid = (await e.get_reply_message()).sender_id
+    elif e.pattern_match.group(1).strip():
+        try:
+            userid = await e.client.parse_id(e.pattern_match.group(1).strip())
+        except Exception as err:
+            return await xx.eor(f"{err}", time=10)
+    else:
+        return await xx.eor("`Reply to some msg or add their id.`", time=5)
+    name = (await e.client.get_entity(userid)).first_name
+    msg = f"**{name} is "
+    is_banned = is_gbanned(userid)
+    reason = list_gbanned().get(userid)
+    if is_banned:
+        msg += "Globally Banned"
+        msg += f" with reason** `{reason}`" if reason else ".**"
+    else:
+        msg += "not Globally Banned.**"
+    await xx.edit(msg)
+
+
+@ultroid_cmd(pattern="gblacklist$")
+async def blacklist_(event):
+    await gblacker(event, "add")
+
+
+@ultroid_cmd(pattern="ungblacklist$")
+async def ungblacker(event):
+    await gblacker(event, "remove")
+
+
+async def gblacker(event, type_):
+    try:
+        chat_id = int(event.text.split(maxsplit=1)[1])
+        try:
+            chat_id = (await event.client.get_entity(chat_id)).id
+        except Exception as e:
+            return await event.eor(f"**ERROR**\n`{str(e)}`")
+    except IndexError:
+        chat_id = event.chat_id
+    if type_ == "add":
+        keym.add(chat_id)
+    elif type_ == "remove":
+        keym.remove(chat_id)
+    await event.eor(f"Global Broadcasts: \n{type_}ed {chat_id}")

plugins/gpt.py

@@ -0,0 +1,183 @@
+import os
+from collections import deque
+from io import BytesIO
+
+from . import (
+    ultroid_cmd,
+    async_searcher,
+    udB,
+    LOGS,
+    get_paste,
+)
+
+GPT_CHAT_HISTORY = deque(maxlen=30)
+
+TELEGRAM_CHAR_LIMIT = 4096  # Telegram's message character limit
+
+
+async def pastee(data):
+    err, linky = await get_paste(data)
+    if err:
+        return f">> [Raw Code Pasted Here](https://spaceb.in/{linky})\n"
+    else:
+        LOGS.error(linky)
+        return ""
+
+
+@ultroid_cmd(
+    pattern=r"gpt( ([\s\S]*))?$",
+)
+async def openai_chat_gpt(e):
+    api_key = "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"
+    if not api_key:
+        return await e.eor("`OPENAI_API` key missing..", time=10)
+
+    query = e.pattern_match.group(2)
+    reply = await e.get_reply_message()
+
+    file_content = None
+
+    if query:
+        # Check if query contains 'from filename'
+        if ' from ' in query:
+            query_text, filename = query.split(' from ', 1)
+            query_text = query_text.strip()
+            filename = filename.strip()
+            # Attempt to find and read the file from media in chat
+            file_found = False
+            async for message in e.client.iter_messages(e.chat_id, reverse=True, limit=50):
+                if message.media and message.file.name == filename:
+                    if (message.file.name.endswith(".txt") or message.file.name.endswith(".py")):
+                        file = await e.client.download_media(message)
+                        try:
+                            with open(file, "r", encoding='utf-8') as f:
+                                file_content = f.read()
+                        except Exception as exc:
+                            LOGS.error(f"Error reading file: {exc}")
+                            return await e.eor("`Failed to read file content.`", time=5)
+                        finally:
+                            os.remove(file)
+                        file_found = True
+                        break
+            if not file_found:
+                return await e.eor(f"`File {filename} not found in recent messages.`", time=5)
+            if file_content:
+                query = f"{query_text}\n\n{file_content}" if query_text else file_content
+            else:
+                return await e.eor("`Failed to read file content.`", time=5)
+        else:
+            if reply and reply.media and (reply.file.name.endswith(".txt") or reply.file.name.endswith(".py")):
+                # Use the query and the replied file content
+                file = await e.client.download_media(reply)
+                try:
+                    with open(file, "r", encoding='utf-8') as f:
+                        file_content = f.read()
+                except Exception as exc:
+                    LOGS.error(f"Error reading file: {exc}")
+                    return await e.eor("`Failed to read file content.`", time=5)
+                finally:
+                    os.remove(file)
+                query = f"{query}\n\n{file_content}"
+            elif reply and reply.message:
+                # Use the query and the replied text message content
+                query = f"{query}\n\n{reply.message}"
+            # Else, use query as is
+    else:
+        if reply and reply.media and (reply.file.name.endswith(".txt") or reply.file.name.endswith(".py")):
+            # Use the replied file content
+            file = await e.client.download_media(reply)
+            try:
+                with open(file, "r", encoding='utf-8') as f:
+                    file_content = f.read()
+            except Exception as exc:
+                LOGS.error(f"Error reading file: {exc}")
+                return await e.eor("`Failed to read file content.`", time=5)
+            finally:
+                os.remove(file)
+            query = file_content
+        elif reply and reply.message:
+            # Use the replied text message content
+            query = reply.message
+        else:
+            return await e.eor("`Please provide a question or reply to a message or .txt/.py file.`", time=5)
+
+    if query.strip() == "-c":
+        GPT_CHAT_HISTORY.clear()
+        return await e.eor("__Cleared o1-mini Chat History!__", time=6)
+
+    eris = await e.eor(f"__Generating answer for:__\n`{query[:20]} ...`")
+    GPT_CHAT_HISTORY.append({"role": "user", "content": query})
+
+    try:
+        data = {
+            "model": "o1-mini",
+            "messages": list(GPT_CHAT_HISTORY),
+        }
+        request = await async_searcher(
+            "https://api.openai.com/v1/chat/completions",
+            headers={
+                "Content-Type": "application/json",
+                "Authorization": f"Bearer {api_key}",
+            },
+            json=data,
+            re_json=True,
+            post=True,
+        )
+        response = request["choices"][0]["message"]["content"]
+        GPT_CHAT_HISTORY.append({"role": "assistant", "content": response})
+    except Exception as exc:
+        LOGS.warning(exc, exc_info=True)
+        GPT_CHAT_HISTORY.pop()
+        return await eris.edit(
+            f"**Error while requesting data from OpenAI:** \n> `{exc}`"
+        )
+
+    LOGS.debug(f'Tokens Used on query: {request["usage"]["completion_tokens"]}')
+
+    # Truncate query to 50 characters for display
+    truncated_query = query[:100]
+
+    # Prepare the full message
+    full_message = f"**Query:**\n~ __{truncated_query}__\n\n**o1-mini:**\n~ {response}"
+
+    # Check if response contains code blocks
+    code_blocks = []
+    in_code_block = False
+    code_block_lines = []
+    for line in response.split('\n'):
+        if line.strip().startswith('```'):
+            if in_code_block:
+                # End of code block
+                in_code_block = False
+                code_blocks.append('\n'.join(code_block_lines))
+                code_block_lines = []
+            else:
+                # Start of code block
+                in_code_block = True
+        elif in_code_block:
+            code_block_lines.append(line)
+
+    # If the response contains code blocks, select the largest one and paste it
+    if code_blocks:
+        # Select the largest code block based on length
+        largest_code_block = max(code_blocks, key=lambda block: len(block))
+        # Upload the largest code block to spaceb.in and get the link
+        paste_link = await pastee(largest_code_block)
+    else:
+        paste_link = ""
+
+    if len(full_message) <= TELEGRAM_CHAR_LIMIT:
+        # If it fits within the limit, send as a message
+        await eris.edit(full_message + f"\n\n{paste_link}")
+    else:
+        # If it exceeds the limit, send as a file and include paste link
+        file = BytesIO(full_message.encode('utf-8'))
+        file.name = "o1-mini-output.txt"
+        await eris.respond(
+            "__The query and response were too long, so they have been sent as a file.__\n\n" + paste_link,
+            file=file,
+            reply_to=e.reply_to_msg_id or e.id,
+            link_preview=False
+        )
+        await eris.delete()
+

plugins/greetings.py

@@ -0,0 +1,205 @@
+# Ultroid - UserBot
+# Copyright (C) 2021-2023 TeamUltroid
+#
+# This file is a part of < https://github.com/TeamUltroid/Ultroid/ >
+# PLease read the GNU Affero General Public License in
+# <https://www.github.com/TeamUltroid/Ultroid/blob/main/LICENSE/>.
+"""
+✘ Commands Available -
+
+---- Welcomes ----
+• `{i}setwelcome <message/reply to message>`
+    Set welcome message in the current chat.
+
+• `{i}clearwelcome`
+    Delete the welcome in the current chat.
+
+• `{i}getwelcome`
+    Get the welcome message in the current chat.
+
+---- GoodByes ----
+• `{i}setgoodbye <message/reply to message>`
+    Set goodbye message in the current chat.
+
+• `{i}cleargoodbye`
+    Delete the goodbye in the current chat.
+
+• `{i}getgoodbye`
+    Get the goodbye message in the current chat.
+
+• `{i}thankmembers on/off`
+    Send a thank you sticker on hitting a members count of 100*x in your groups.
+"""
+import os
+
+from telegraph import upload_file as uf
+from telethon.utils import pack_bot_file_id
+
+from pyUltroid.dB.greetings_db import (
+    add_goodbye,
+    add_thanks,
+    add_welcome,
+    delete_goodbye,
+    delete_welcome,
+    get_goodbye,
+    get_welcome,
+    must_thank,
+    remove_thanks,
+)
+from pyUltroid.fns.tools import create_tl_btn, format_btn, get_msg_button
+
+from . import HNDLR, eor, get_string, mediainfo, ultroid_cmd
+from ._inline import something
+
+Note = "\n\nNote: `{mention}`, `{group}`, `{count}`, `{name}`, `{fullname}`, `{username}`, `{userid}` can be used as formatting parameters.\n\n"
+
+
+@ultroid_cmd(pattern="setwelcome", groups_only=True)
+async def setwel(event):
+    x = await event.eor(get_string("com_1"))
+    r = await event.get_reply_message()
+    btn = format_btn(r.buttons) if (r and r.buttons) else None
+    try:
+        text = event.text.split(maxsplit=1)[1]
+    except IndexError:
+        text = r.text if r else None
+    if r and r.media:
+        wut = mediainfo(r.media)
+        if wut.startswith(("pic", "gif")):
+            dl = await r.download_media()
+            variable = uf(dl)
+            os.remove(dl)
+            m = f"https://graph.org{variable[0]}"
+        elif wut == "video":
+            if r.media.document.size > 8 * 1000 * 1000:
+                return await eor(x, get_string("com_4"), time=5)
+            dl = await r.download_media()
+            variable = uf(dl)
+            os.remove(dl)
+            m = f"https://graph.org{variable[0]}"
+        elif wut == "web":
+            m = None
+        else:
+            m = pack_bot_file_id(r.media)
+        if r.text:
+            txt = r.text
+            if not btn:
+                txt, btn = get_msg_button(r.text)
+            add_welcome(event.chat_id, txt, m, btn)
+        else:
+            add_welcome(event.chat_id, None, m, btn)
+        await eor(x, get_string("grt_1"))
+    elif text:
+        if not btn:
+            txt, btn = get_msg_button(text)
+        add_welcome(event.chat_id, txt, None, btn)
+        await eor(x, get_string("grt_1"))
+    else:
+        await eor(x, get_string("grt_3"), time=5)
+
+
+@ultroid_cmd(pattern="clearwelcome$", groups_only=True)
+async def clearwel(event):
+    if not get_welcome(event.chat_id):
+        return await event.eor(get_string("grt_4"), time=5)
+    delete_welcome(event.chat_id)
+    await event.eor(get_string("grt_5"), time=5)
+
+
+@ultroid_cmd(pattern="getwelcome$", groups_only=True)
+async def listwel(event):
+    wel = get_welcome(event.chat_id)
+    if not wel:
+        return await event.eor(get_string("grt_4"), time=5)
+    msgg, med = wel["welcome"], wel["media"]
+    if wel.get("button"):
+        btn = create_tl_btn(wel["button"])
+        return await something(event, msgg, med, btn)
+    await event.reply(f"**Welcome Note in this chat**\n\n`{msgg}`", file=med)
+    await event.delete()
+
+
+@ultroid_cmd(pattern="setgoodbye", groups_only=True)
+async def setgb(event):
+    x = await event.eor(get_string("com_1"))
+    r = await event.get_reply_message()
+    btn = format_btn(r.buttons) if (r and r.buttons) else None
+    try:
+        text = event.text.split(maxsplit=1)[1]
+    except IndexError:
+        text = r.text if r else None
+    if r and r.media:
+        wut = mediainfo(r.media)
+        if wut.startswith(("pic", "gif")):
+            dl = await r.download_media()
+            variable = uf(dl)
+            os.remove(dl)
+            m = f"https://graph.org{variable[0]}"
+        elif wut == "video":
+            if r.media.document.size > 8 * 1000 * 1000:
+                return await eor(x, get_string("com_4"), time=5)
+            dl = await r.download_media()
+            variable = uf(dl)
+            os.remove(dl)
+            m = f"https://graph.org{variable[0]}"
+        elif wut == "web":
+            m = None
+        else:
+            m = pack_bot_file_id(r.media)
+        if r.text:
+            txt = r.text
+            if not btn:
+                txt, btn = get_msg_button(r.text)
+            add_goodbye(event.chat_id, txt, m, btn)
+        else:
+            add_goodbye(event.chat_id, None, m, btn)
+        await eor(x, "`Goodbye note saved`")
+    elif text:
+        if not btn:
+            txt, btn = get_msg_button(text)
+        add_goodbye(event.chat_id, txt, None, btn)
+        await eor(x, "`Goodbye note saved`")
+    else:
+        await eor(x, get_string("grt_7"), time=5)
+
+
+@ultroid_cmd(pattern="cleargoodbye$", groups_only=True)
+async def clearwgb(event):
+    if not get_goodbye(event.chat_id):
+        return await event.eor(get_string("grt_6"), time=5)
+    delete_goodbye(event.chat_id)
+    await event.eor("`Goodbye Note Deleted`", time=5)
+
+
+@ultroid_cmd(pattern="getgoodbye$", groups_only=True)
+async def listgd(event):
+    wel = get_goodbye(event.chat_id)
+    if not wel:
+        return await event.eor(get_string("grt_6"), time=5)
+    msgg = wel["goodbye"]
+    med = wel["media"]
+    if wel.get("button"):
+        btn = create_tl_btn(wel["button"])
+        return await something(event, msgg, med, btn)
+    await event.reply(f"**Goodbye Note in this chat**\n\n`{msgg}`", file=med)
+    await event.delete()
+
+
+@ultroid_cmd(pattern="thankmembers (on|off)", groups_only=True)
+async def thank_set(event):
+    type_ = event.pattern_match.group(1).strip()
+    if not type_ or type_ == "":
+        await eor(
+            event,
+            f"**Current Chat Settings:**\n**Thanking Members:** `{must_thank(event.chat_id)}`\n\nUse `{HNDLR}thankmembers on` or `{HNDLR}thankmembers off` to toggle current settings!",
+        )
+        return
+    chat = event.chat_id
+    if type_.lower() == "on":
+        add_thanks(chat)
+    elif type_.lower() == "off":
+        remove_thanks(chat)
+    await eor(
+        event,
+        f"**Done! Thank you members has been turned** `{type_.lower()}` **for this chat**!",
+    )

plugins/imagetools.py

@@ -0,0 +1,292 @@
+# Ultroid - UserBot
+# Copyright (C) 2021-2023 TeamUltroid
+#
+# This file is a part of < https://github.com/TeamUltroid/Ultroid/ >
+# PLease read the GNU Affero General Public License in
+# <https://www.github.com/TeamUltroid/Ultroid/blob/main/LICENSE/>.
+"""
+✘ Commands Available -
+
+• `{i}border <reply to photo/sticker>`
+    To create border around that media..
+    Ex - `{i}border 12,22,23`
+       - `{i}border 12,22,23 ; width (in number)`
+
+• `{i}grey <reply to any media>`
+    To make it black nd white.
+
+• `{i}color <reply to any Black nd White media>`
+    To make it Colorfull.
+
+• `{i}toon <reply to any media>`
+    To make it toon.
+
+• `{i}danger <reply to any media>`
+    To make it look Danger.
+
+• `{i}negative <reply to any media>`
+    To make negative image.
+
+• `{i}blur <reply to any media>`
+    To make it blurry.
+
+• `{i}quad <reply to any media>`
+    create a Vortex.
+
+• `{i}mirror <reply to any media>`
+    To create mirror pic.
+
+• `{i}flip <reply to any media>`
+    To make it flip.
+
+• `{i}sketch <reply to any media>`
+    To draw its sketch.
+
+• `{i}blue <reply to any media>`
+    just cool.
+
+• `{i}csample <color name /color code>`
+   example : `{i}csample red`
+             `{i}csample #ffffff`
+
+• `{i}pixelator <reply image>`
+    Create a Pixelated Image..
+"""
+import os
+
+from . import LOGS, con
+
+try:
+    import cv2
+except ImportError:
+    LOGS.error(f"{__file__}: OpenCv not Installed.")
+
+import numpy as np
+
+try:
+    from PIL import Image
+except ImportError:
+    Image = None
+    LOGS.info(f"{__file__}: PIL  not Installed.")
+from telegraph import upload_file as upf
+from telethon.errors.rpcerrorlist import (
+    ChatSendMediaForbiddenError,
+    MessageDeleteForbiddenError,
+)
+
+from . import (
+    Redis,
+    async_searcher,
+    download_file,
+    get_string,
+    requests,
+    udB,
+    ultroid_cmd,
+)
+
+
+@ultroid_cmd(pattern="color$")
+async def _(event):
+    reply = await event.get_reply_message()
+    if not (reply and reply.media):
+        return await event.eor("`Reply To a Black and White Image`")
+    xx = await event.eor("`Coloring image 🎨🖌️...`")
+    image = await reply.download_media()
+    img = cv2.VideoCapture(image)
+    ret, frame = img.read()
+    cv2.imwrite("ult.jpg", frame)
+    if udB.get_key("DEEP_API"):
+        key = Redis("DEEP_API")
+    else:
+        key = "quickstart-QUdJIGlzIGNvbWluZy4uLi4K"
+    r = requests.post(
+        "https://api.deepai.org/api/colorizer",
+        files={"image": open("ult.jpg", "rb")},
+        headers={"api-key": key},
+    )
+    os.remove("ult.jpg")
+    os.remove(image)
+    if "status" in r.json():
+        return await event.edit(
+            r.json()["status"] + "\nGet api nd set `{i}setdb DEEP_API key`"
+        )
+    r_json = r.json()["output_url"]
+    await event.client.send_file(event.chat_id, r_json, reply_to=reply)
+    await xx.delete()
+
+
+@ultroid_cmd(pattern="(grey|blur|negative|danger|mirror|quad|sketch|flip|toon)$")
+async def ult_tools(event):
+    match = event.pattern_match.group(1)
+    ureply = await event.get_reply_message()
+    if not (ureply and (ureply.media)):
+        await event.eor(get_string("cvt_3"))
+        return
+    ultt = await ureply.download_media()
+    xx = await event.eor(get_string("com_1"))
+    if ultt.endswith(".tgs"):
+        xx = await xx.edit(get_string("sts_9"))
+    file = await con.convert(ultt, convert_to="png", outname="ult")
+    ult = cv2.imread(file)
+    if match == "grey":
+        ultroid = cv2.cvtColor(ult, cv2.COLOR_BGR2GRAY)
+    elif match == "blur":
+        ultroid = cv2.GaussianBlur(ult, (35, 35), 0)
+    elif match == "negative":
+        ultroid = cv2.bitwise_not(ult)
+    elif match == "danger":
+        dan = cv2.cvtColor(ult, cv2.COLOR_BGR2RGB)
+        ultroid = cv2.cvtColor(dan, cv2.COLOR_HSV2BGR)
+    elif match == "mirror":
+        ish = cv2.flip(ult, 1)
+        ultroid = cv2.hconcat([ult, ish])
+    elif match == "flip":
+        trn = cv2.flip(ult, 1)
+        ish = cv2.rotate(trn, cv2.ROTATE_180)
+        ultroid = cv2.vconcat([ult, ish])
+    elif match == "quad":
+        ult = cv2.imread(file)
+        roid = cv2.flip(ult, 1)
+        mici = cv2.hconcat([ult, roid])
+        fr = cv2.flip(mici, 1)
+        trn = cv2.rotate(fr, cv2.ROTATE_180)
+        ultroid = cv2.vconcat([mici, trn])
+    elif match == "sketch":
+        gray_image = cv2.cvtColor(ult, cv2.COLOR_BGR2GRAY)
+        inverted_gray_image = 255 - gray_image
+        blurred_img = cv2.GaussianBlur(inverted_gray_image, (21, 21), 0)
+        inverted_blurred_img = 255 - blurred_img
+        ultroid = cv2.divide(gray_image, inverted_blurred_img, scale=256.0)
+    elif match == "toon":
+        height, width, _ = ult.shape
+        samples = np.zeros([height * width, 3], dtype=np.float32)
+        count = 0
+        for x in range(height):
+            for y in range(width):
+                samples[count] = ult[x][y]
+                count += 1
+        _, labels, centers = cv2.kmeans(
+            samples,
+            12,
+            None,
+            (cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_MAX_ITER, 10000, 0.0001),
+            5,
+            cv2.KMEANS_PP_CENTERS,
+        )
+        centers = np.uint8(centers)
+        ish = centers[labels.flatten()]
+        ultroid = ish.reshape(ult.shape)
+    cv2.imwrite("ult.jpg", ultroid)
+    await ureply.reply(
+        file="ult.jpg",
+        force_document=False,
+    )
+    await xx.delete()
+    os.remove("ult.jpg")
+    os.remove(file)
+
+
+@ultroid_cmd(pattern="csample (.*)")
+async def sampl(ult):
+    if color := ult.pattern_match.group(1).strip():
+        img = Image.new("RGB", (200, 100), f"{color}")
+        img.save("csample.png")
+        try:
+            try:
+                await ult.delete()
+                await ult.respond(f"Colour Sample for `{color}` !", file="csample.png")
+            except MessageDeleteForbiddenError:
+                await ult.reply(f"Colour Sample for `{color}` !", file="csample.png")
+        except ChatSendMediaForbiddenError:
+            await ult.eor("Umm! Sending Media is disabled here!")
+
+    else:
+        await ult.eor("Wrong Color Name/Hex Code specified!")
+
+
+@ultroid_cmd(
+    pattern="blue$",
+)
+async def ultd(event):
+    ureply = await event.get_reply_message()
+    xx = await event.eor("`...`")
+    if not (ureply and (ureply.media)):
+        await xx.edit(get_string("cvt_3"))
+        return
+    ultt = await ureply.download_media()
+    if ultt.endswith(".tgs"):
+        await xx.edit(get_string("sts_9"))
+    file = await con.convert(ultt, convert_to="png", outname="ult")
+    got = upf(file)
+    lnk = f"https://graph.org{got[0]}"
+    r = await async_searcher(
+        f"https://nekobot.xyz/api/imagegen?type=blurpify&image={lnk}", re_json=True
+    )
+    ms = r.get("message")
+    if not r["success"]:
+        return await xx.edit(ms)
+    await download_file(ms, "ult.png")
+    img = Image.open("ult.png").convert("RGB")
+    img.save("ult.webp", "webp")
+    await event.client.send_file(
+        event.chat_id,
+        "ult.webp",
+        force_document=False,
+        reply_to=event.reply_to_msg_id,
+    )
+    await xx.delete()
+    os.remove("ult.png")
+    os.remove("ult.webp")
+    os.remove(ultt)
+
+
+@ultroid_cmd(pattern="border( (.*)|$)")
+async def ok(event):
+    hm = await event.get_reply_message()
+    if not (hm and (hm.photo or hm.sticker)):
+        return await event.eor("`Reply to Sticker or Photo..`")
+    col = event.pattern_match.group(1).strip()
+    wh = 20
+    if not col:
+        col = [255, 255, 255]
+    else:
+        try:
+            if ";" in col:
+                col_ = col.split(";", maxsplit=1)
+                wh = int(col_[1])
+                col = col_[0]
+            col = [int(col) for col in col.split(",")[:2]]
+        except ValueError:
+            return await event.eor("`Not a Valid Input...`")
+    okla = await hm.download_media()
+    img1 = cv2.imread(okla)
+    constant = cv2.copyMakeBorder(img1, wh, wh, wh, wh, cv2.BORDER_CONSTANT, value=col)
+    cv2.imwrite("output.png", constant)
+    await event.client.send_file(event.chat.id, "output.png")
+    os.remove("output.png")
+    os.remove(okla)
+    await event.delete()
+
+
+@ultroid_cmd(pattern="pixelator( (.*)|$)")
+async def pixelator(event):
+    reply_message = await event.get_reply_message()
+    if not (reply_message and (reply_message.photo or reply_message.sticker)):
+        return await event.eor("`Reply to a photo`")
+    hw = 50
+    try:
+        hw = int(event.pattern_match.group(1).strip())
+    except (ValueError, TypeError):
+        pass
+    msg = await event.eor(get_string("com_1"))
+    image = await reply_message.download_media()
+    input_ = cv2.imread(image)
+    height, width = input_.shape[:2]
+    w, h = (hw, hw)
+    temp = cv2.resize(input_, (w, h), interpolation=cv2.INTER_LINEAR)
+    output = cv2.resize(temp, (width, height), interpolation=cv2.INTER_NEAREST)
+    cv2.imwrite("output.jpg", output)
+    await msg.respond("• Pixelated by Ultroid", file="output.jpg")
+    await msg.delete()
+    os.remove("output.jpg")
+    os.remove(image)