fix revert back and update

.gitattributes

@@ -0,0 +1,37 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text
+*.ttf filter=lfs diff=lfs merge=lfs -text
+*.pdf filter=lfs diff=lfs merge=lfs -text

Data.py

@@ -0,0 +1,56 @@
+from pyrogram.types import InlineKeyboardButton
+
+class Data:
+    START = """
+👋 **Hello {}!**
+
+**Welcome {}!**
+
+We’re glad to have you here. This bot is designed to help you generate a **String Session** easily and securely.  
+
+🚨 **Important Notes**:  
+If you don’t trust this bot:  
+1. **Don’t read this message**.  
+2. **Block the bot** or **delete the chat**.  
+
+🤖 **How This Bot Works**:  
+- This bot helps you generate a **String Session** for your Telegram account.  
+- **Recommendation**: Use a secondary account to generate the String Session. This avoids delays and keeps your main account secure.  
+"""
+
+    home_buttons = [
+        [InlineKeyboardButton("🔥 sᴛᴀʀᴛ ɢᴇɴᴇʀᴀᴛɪɴɢ sᴇssɪᴏɴ 🔥", callback_data="generate")],
+        [InlineKeyboardButton(text="ᴋᴇᴍʙᴀʟɪ", callback_data="home")],
+    ]
+
+    generate_button = [
+        [InlineKeyboardButton("🔥 sᴛᴀʀᴛ ɢᴇɴᴇʀᴀᴛɪɴɢ sᴇssɪᴏɴ 🔥", callback_data="generate")]
+    ]
+
+    buttons = [
+        [InlineKeyboardButton("🔥 sᴛᴀʀᴛ ɢᴇɴᴇʀᴀᴛɪɴɢ sᴇssɪᴏɴ 🔥", callback_data="generate")],
+        [
+            InlineKeyboardButton("ᴀʙᴏᴜᴛ", callback_data="about")
+        ]
+    ]
+
+    HELP = """
+**Available Commands**
+
+/about - About this Bot
+/help - This Message
+/start - Start bot
+/generate - Start Generating Session
+"""
+
+    ABOUT = """
+**About This Bot** 
+
+A telegram bot to retrieve pyrograms and telethon string session by @VegetaSessionBot
+
+Framework : [Pyrogram](docs.pyrogram.org)
+
+Language : [Python](www.python.org)
+
+Developer : @xpushz
+"""

Dockerfile

@@ -0,0 +1,60 @@
+FROM python:3.11.11
+
+RUN apt -qq update && \
+    apt -qq install -y --no-install-recommends \
+    ffmpeg \
+    curl \
+    git \
+    gnupg2 \
+    unzip \
+    wget \
+    xvfb \
+    libxi6 \
+    libgconf-2-4 \
+    libappindicator3-1 \
+    libxrender1 \
+    libxtst6 \
+    libnss3 \
+    libatk1.0-0 \
+    libxss1 \
+    fonts-liberation \
+    libasound2 \
+    libgbm-dev \
+    libu2f-udev \
+    libvulkan1 \
+    libgl1-mesa-dri \
+    xdg-utils \
+    python3-dev \
+    python3-pip \
+    libavformat-dev \
+    libavcodec-dev \
+    libavdevice-dev \
+    libavfilter-dev \
+    libavutil-dev \
+    libswscale-dev \
+    libswresample-dev \
+    neofetch && \
+    apt-get clean && \
+    rm -rf /var/lib/apt/lists/
+
+WORKDIR /app
+
+COPY requirements.txt .
+COPY . .
+
+RUN mkdir -p /app/.cache/akn && \
+    chmod -R 777 /app/.cache
+
+RUN chown -R 1000:0 .
+RUN pip3 install --upgrade pip setuptools
+RUN pip3 install -r requirements.txt
+
+RUN wget https://johnvansickle.com/ffmpeg/builds/ffmpeg-git-amd64-static.tar.xz && \
+    wget https://johnvansickle.com/ffmpeg/builds/ffmpeg-git-amd64-static.tar.xz.md5 && \
+    md5sum -c ffmpeg-git-amd64-static.tar.xz.md5 && \
+    tar xvf ffmpeg-git-amd64-static.tar.xz && \
+    mv ffmpeg-git*/ffmpeg ffmpeg-git*/ffprobe /usr/local/bin/
+
+EXPOSE 7860
+
+CMD ["bash", "-c", "python3 server.py & python3 -m akn"]

README.md

@@ -0,0 +1,11 @@
+---
+title: Akn
+emoji: 🏆
+colorFrom: pink
+colorTo: purple
+sdk: docker
+pinned: false
+license: mit
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

akn/Akeno/__init__.py

@@ -0,0 +1,11 @@
+from pyrogram.types import Message
+
+api_key_openai = "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"
+
+def ReplyCheck(message: Message):
+    reply_id = None
+    if message.reply_to_message:
+        reply_id = message.reply_to_message.id
+    elif not message.from_user.is_self:
+        reply_id = message.id
+    return reply_id

akn/Akeno/admin.py

@@ -0,0 +1,392 @@
+# Copyright (C) 2020-2023 TeamKillerX <https://github.com/TeamKillerX>
+#
+# This file is part of TeamKillerX project,
+# and licensed under GNU Affero General Public License v3.
+# See the GNU Affero General Public License for more details.
+#
+# All rights reserved. See COPYING, AUTHORS.
+#
+
+import asyncio
+import time
+from time import time as waktu
+
+from pyrogram import Client
+from pyrogram import Client as ren
+from pyrogram import *
+from pyrogram import filters
+from pyrogram.errors import *
+from pyrogram.types import *
+
+from akn.utils.handler import *
+from akn.Akeno.help import add_command_help
+from akn.utils.logger import LOGS
+from akn.utils.prefixprem import command
+from config import *
+
+admins_in_chat = {}
+
+unmute_permissions = ChatPermissions(
+    can_send_messages=True,
+    can_send_media_messages=True,
+    can_send_polls=True,
+    can_change_info=False,
+    can_invite_users=True,
+    can_pin_messages=False,
+)
+
+
+async def extract_userid(message, text: str):
+    def is_int(text: str):
+        try:
+            int(text)
+        except ValueError:
+            return False
+        return True
+
+    text = text.strip()
+
+    if is_int(text):
+        return int(text)
+
+    entities = message.entities
+    app = message._client
+    if len(entities) < 2:
+        return (await app.get_users(text)).id
+    entity = entities[1]
+    if entity.type == "mention":
+        return (await app.get_users(text)).id
+    if entity.type == "text_mention":
+        return entity.user.id
+    return None
+
+
+async def extract_user_and_reason(message, sender_chat=False):
+    args = message.text.strip().split()
+    text = message.text
+    user = None
+    reason = None
+    if message.reply_to_message:
+        reply = message.reply_to_message
+        if not reply.from_user:
+            if (
+                reply.sender_chat
+                and reply.sender_chat != message.chat.id
+                and sender_chat
+            ):
+                id_ = reply.sender_chat.id
+            else:
+                return None, None
+        else:
+            id_ = reply.from_user.id
+
+        if len(args) < 2:
+            reason = None
+        else:
+            reason = text.split(None, 1)[1]
+        return id_, reason
+
+    if len(args) == 2:
+        user = text.split(None, 1)[1]
+        return await extract_userid(message, user), None
+
+    if len(args) > 2:
+        user, reason = text.split(None, 2)[1:]
+        return await extract_userid(message, user), reason
+
+    return user, reason
+
+
+async def extract_user(message):
+    return (await extract_user_and_reason(message))[0]
+
+
+async def list_admins(client: Client, chat_id: int):
+    global admins_in_chat
+    if chat_id in admins_in_chat:
+        interval = time() - admins_in_chat[chat_id]["last_updated_at"]
+        if interval < 3600:
+            return admins_in_chat[chat_id]["data"]
+
+    admins_in_chat[chat_id] = {
+        "last_updated_at": waktu(),
+        "data": [
+            member.user.id
+            async for member in client.get_chat_members(
+                chat_id, filter=enums.ChatMembersFilter.ADMINISTRATORS
+            )
+        ],
+    }
+    return admins_in_chat[chat_id]["data"]
+
+
+@Akeno(
+    ~filters.scheduled & command(["ban", "dban", "hban"]) & filters.me & ~filters.forwarded
+)
+async def member_ban_user(client: Client, message: Message):
+    user_id, reason = await extract_user_and_reason(message, sender_chat=True)
+    rd = await message.edit_text("`Processing...`")
+    bot = (await client.get_chat_member(message.chat.id, client.me.id)).privileges
+    if not bot.can_restrict_members:
+        return await rd.edit_text("I don't have enough permissions")
+    if not user_id:
+        return await rd.edit_text("I can't find that user.")
+    if user_id == client.me.id:
+        return await rd.edit_text("I can't ban myself.")
+    if user_id == 1191668125:
+        return await rd.edit_text("I can't ban my developer!")
+    if user_id in (await list_admins(client, message.chat.id)):
+        return await rd.edit_text("I can't ban an admin, You know the rules, so do i.")
+    try:
+        mention = (await client.get_users(user_id)).mention
+    except IndexError:
+        mention = (
+            message.reply_to_message.sender_chat.title
+            if message.reply_to_message
+            else "Anon"
+        )
+    msg = (
+        f"**Banned User:** {mention}\n"
+        f"**Banned By:** {message.from_user.mention if message.from_user else 'Anon'}\n"
+    )
+    if message.command[0][0] == "d":
+        await message.reply_to_message.delete()
+    elif message.command[0][0] == "h":
+        await client.delete_user_history(message.chat.id, user_id)
+    if reason:
+        msg += f"**Reason:** {reason}"
+    await message.chat.ban_member(user_id)
+    await rd.edit_text(msg)
+
+
+@Akeno(
+    ~filters.scheduled & command(["unban"]) & filters.me & ~filters.forwarded
+)
+async def member_unban_user(client: Client, message: Message):
+    reply = message.reply_to_message
+    rd = await message.edit_text("`Processing...`")
+    bot = (await client.get_chat_member(message.chat.id, client.me.id)).privileges
+    if not bot.can_restrict_members:
+        return await rd.edit_text("I don't have enough permissions")
+    if reply and reply.sender_chat and reply.sender_chat != message.chat.id:
+        return await rd.edit_text("You cannot unban a channel")
+
+    if len(message.command) == 2:
+        user = message.text.split(None, 1)[1]
+    elif len(message.command) == 1 and reply:
+        user = message.reply_to_message.from_user.id
+    else:
+        return await rd.edit_text(
+            "Provide a username or reply to a user's message to unban."
+        )
+    await message.chat.unban_member(user)
+    umention = (await client.get_users(user)).mention
+    await rd.edit_text(f"Unbanned! {umention}")
+
+
+@Akeno(
+    ~filters.scheduled & command(["pin", "unpin"]) & filters.me & ~filters.forwarded
+)
+async def pin_message(client: Client, message: Message):
+    if not message.reply_to_message:
+        return await message.edit_text("Reply to a message to pin/unpin it.")
+    rd = await message.edit_text("`Processing...`")
+    bot = (await client.get_chat_member(message.chat.id, client.me.id)).privileges
+    if not bot.can_pin_messages:
+        return await rd.edit_text("I don't have enough permissions")
+    r = message.reply_to_message
+    if message.command[0][0] == "u":
+        await r.unpin()
+        return await rd.edit_text(
+            f"**Unpinned [this]({r.link}) message.**",
+            disable_web_page_preview=True,
+        )
+    await r.pin(disable_notification=True)
+    await rd.edit_text(
+        f"**Pinned [this]({r.link}) message.**",
+        disable_web_page_preview=True,
+    )
+
+@Akeno(
+    ~filters.scheduled & command(["mute", "dmute", "hmute"]) & filters.me & ~filters.forwarded
+)
+async def mute_user(client: Client, message: Message):
+    user_id, reason = await extract_user_and_reason(message)
+    rd = await message.edit_text("`Processing...`")
+    bot = (await client.get_chat_member(message.chat.id, client.me.id)).privileges
+    if not bot.can_restrict_members:
+        return await rd.edit_text("I don't have enough permissions")
+    if not user_id:
+        return await rd.edit_text("I can't find that user.")
+    if user_id == client.me.id:
+        return await rd.edit_text("I can't mute myself.")
+    if user_id == 1191668125:
+        return await rd.edit("I can't mute my developer!")
+    if user_id in (await list_admins(client, message.chat.id)):
+        return await rd.edit_text("I can't mute an admin, You know the rules, so do i.")
+    mention = (await client.get_users(user_id)).mention
+    msg = (
+        f"**Muted User:** {mention}\n"
+        f"**Muted By:** {message.from_user.mention if message.from_user else 'Anon'}\n"
+    )
+    if message.command[0][0] == "d":
+        await message.reply_to_message.delete()
+    elif message.command[0][0] == "h":
+        await client.delete_user_history(message.chat.id, user_id)
+    if reason:
+        msg += f"**Reason:** {reason}"
+    await message.chat.restrict_member(user_id, permissions=ChatPermissions())
+    await rd.edit_text(msg)
+
+@Akeno(
+    ~filters.scheduled & command(["unmute"]) & filters.me & ~filters.forwarded
+)
+async def unmute_user(client: Client, message: Message):
+    user_id = await extract_user(message)
+    rd = await message.edit_text("`Processing...`")
+    bot = (await client.get_chat_member(message.chat.id, client.me.id)).privileges
+    if not bot.can_restrict_members:
+        return await rd.edit_text("I don't have enough permissions")
+    if not user_id:
+        return await rd.edit_text("I can't find that user.")
+    await message.chat.restrict_member(user_id, permissions=unmute_permissions)
+    umention = (await client.get_users(user_id)).mention
+    await rd.edit_text(f"Unmuted! {umention}")
+
+@Akeno(
+    ~filters.scheduled & command(["kick", "dkick", "hkick"]) & filters.me & ~filters.forwarded
+)
+async def kick_user(client: Client, message: Message):
+    user_id, reason = await extract_user_and_reason(message)
+    rd = await message.edit_text("`Processing...`")
+    bot = (await client.get_chat_member(message.chat.id, client.me.id)).privileges
+    if not bot.can_restrict_members:
+        return await rd.edit_text("I don't have enough permissions")
+    if not user_id:
+        return await rd.edit_text("I can't find that user.")
+    if user_id == client.me.id:
+        return await rd.edit_text("I can't kick myself.")
+    if user_id == 1191668125:
+        return await rd.edit_text("I can't kick my developer.")
+    if user_id in (await list_admins(client, message.chat.id)):
+        return await rd.edit_text("I can't kick an admin, You know the rules, so do i.")
+    mention = (await client.get_users(user_id)).mention
+    msg = f"""
+**Kicked User:** {mention}
+**Kicked By:** {message.from_user.mention if message.from_user else 'Anon'}"""
+    if message.command[0][0] == "d":
+        await message.reply_to_message.delete()
+    elif message.command[0][0] == "h":
+        await client.delete_user_history(message.chat.id, user_id)
+    if reason:
+        msg += f"\n**Reason:** `{reason}`"
+    try:
+        await message.chat.ban_member(user_id)
+        await rd.edit_text(msg)
+        await asyncio.sleep(1)
+        await message.chat.unban_member(user_id)
+    except ChatAdminRequired:
+        return await rd.edit_text("**Maaf Anda Bukan admin**")
+
+@Akeno(
+    ~filters.scheduled & command(["promote", "fullpromote"]) & filters.me & ~filters.forwarded
+)
+async def promotte_user(client: Client, message: Message):
+    user_id = await extract_user(message)
+    umention = (await client.get_users(user_id)).mention
+    rd = await message.edit_text("`Processing...`")
+    if not user_id:
+        return await rd.edit_text("I can't find that user.")
+    bot = (await client.get_chat_member(message.chat.id, client.me.id)).privileges
+    if not bot.can_promote_members:
+        return await rd.edit_text("I don't have enough permissions")
+    if message.command[0][0] == "f":
+        await message.chat.promote_member(
+            user_id,
+            privileges=ChatPrivileges(
+                can_manage_chat=True,
+                can_delete_messages=True,
+                can_manage_video_chats=True,
+                can_restrict_members=True,
+                can_change_info=True,
+                can_invite_users=True,
+                can_pin_messages=True,
+                can_promote_members=True,
+            ),
+        )
+        return await rd.edit_text(f"Fully Promoted! {umention}")
+
+    await message.chat.promote_member(
+        user_id,
+        privileges=ChatPrivileges(
+            can_manage_chat=True,
+            can_delete_messages=True,
+            can_manage_video_chats=True,
+            can_restrict_members=True,
+            can_change_info=True,
+            can_invite_users=True,
+            can_pin_messages=True,
+            can_promote_members=False,
+        ),
+    )
+    await rd.edit_text(f"Promoted! {umention}")
+
+@Akeno(
+    ~filters.scheduled & command(["demote"]) & filters.me & ~filters.forwarded
+)
+async def demote_user(client: Client, message: Message):
+    user_id = await extract_user(message)
+    rd = await message.edit_text("`Processing...`")
+    if not user_id:
+        return await rd.edit_text("I can't find that user.")
+    if user_id == client.me.id:
+        return await rd.edit_text("I can't demote myself.")
+    await message.chat.promote_member(
+        user_id,
+        privileges=ChatPrivileges(
+            can_manage_chat=False,
+            can_delete_messages=False,
+            can_manage_video_chats=False,
+            can_restrict_members=False,
+            can_change_info=False,
+            can_invite_users=False,
+            can_pin_messages=False,
+            can_promote_members=False,
+        ),
+    )
+    umention = (await client.get_users(user_id)).mention
+    await rd.edit_text(f"Demoted! {umention}")
+
+add_command_help(
+    "admin",
+    [
+        ["ban [reply/username/userid]", "Ban someone."],
+        ["dban [reply]", "dban a user deleting the replied to message."],
+        ["unban [reply/username/userid]", "Unban someone."],
+        ["kick [reply/username/userid]", "kick out someone from your group."],
+        ["dkick [reply]", "dkick a user deleting the replied to message."],
+        ["promote `or` .fullpromote", "Promote someonen."],
+        ["demote", "Demote someone."],
+        ["mute [reply/username/userid]", "Mute someone."],
+        ["dmute [reply]", "dmute a user deleting the replied to message."],
+        ["unmute [reply/username/userid]", "Unmute someone."],
+        ["pin [reply]", "to pin any message."],
+        ["unpin [reply]", "To unpin any message."],
+        ["setgpic [reply ke image]", "To set an group profile pic."],
+    ],
+)
+module = modules_help.add_module("admin", __file__)
+module.add_command("ban", "Ban someone.")
+module.add_command("dban", "dban a user deleting the replied to message")
+module.add_command("hban", "hban a user deleting all the replied to message")
+module.add_command("kick", "kick out someone from your group")
+module.add_command("dkick", "dkick a user deleting the replied to message")
+module.add_command("hkick", "hkick a user deleting all the replied to message")
+module.add_command("promote", "Promote someonen")
+module.add_command("demote", "Demote someone")
+module.add_command("mute", "Mute someone")
+module.add_command("dmute", "dmute a user deleting the replied to message")
+module.add_command("hmute", "dmute a user deleting all the replied to message")
+module.add_command("pin", "to pin any message.")
+module.add_command("unpin", "To unpin any message")
+module.add_command("setgpic", "To set an group profile pic.")

akn/Akeno/alive.py

@@ -0,0 +1,128 @@
+import os
+import random
+import re
+import asyncio
+from random import choice
+from pyrogram import Client, filters
+from pyrogram.types import *
+from akn.utils.handler import *
+from akn import app
+from akn.utils.prefixprem import command
+from config import *
+from RyuzakiLib import __version__ as ryu_version
+from platform import python_version
+from pyrogram.raw import functions
+
+
+akeno_premium_text = """
+**Status Ubot**
+   **User Free**: [Ultra Premium]
+    {custom_emoji}**dc_id:** `{dc_id}`
+    {custom_emoji}**python_version:** `{python}`
+    {custom_emoji}**ryuzakilib_version:** `{ryu}`
+    {custom_emoji}**app_name:** `{app_name}`
+    {custom_emoji}**app_version:** `{app_version}`
+    {custom_emoji}**system_version:** `{system_version}`
+    {custom_emoji}**is_premium:** `{is_premium}`
+    {custom_emoji}**unlimited_by:** [aknuserbot]({aknuserbot})    
+"""
+
+ryuzaki_text = """
+**Status Ubot**
+   **User Free**: [PRO]
+     **dc_id:** `{dc_id}`
+     **python_version:** `{python}`
+     **ryuzakilib_version:** `{ryu}`
+     **app_name:** `{app_name}`
+     **app_version:** `{app_version}`
+     **system_version:** `{system_version}`
+     **is_premium:** null
+     **unlimited_by:** [aknuserbot]({aknuserbot})
+"""
+
+CUSTOM_EMOJI_ALL = [
+    5469770984670108755,
+    5301067044400146520,
+    5300950543412241242, 
+    5300928913956938544, 
+    5301155675345265040,
+    5300957668762987048, 
+    5366318141771096216,
+    6039606071314615141,
+    5971808079811972376,
+    5764623873974734153,
+    6048474766463996499,
+    5974226571601382719,
+    6041914500272098262,
+    5974083454701145202,
+    5328317370647715629
+]
+
+async def authorization(client: Client):
+    model = await client.invoke(
+        functions.account.GetAuthorizations()
+    )
+    app_name = model.authorizations[0].app_name
+    app_version = model.authorizations[0].app_version
+    system_version = model.authorizations[0].system_version
+    return app_name, app_version, system_version
+
+@Akeno(
+    ~filters.scheduled
+    & command(["alivepro"])
+    & filters.me
+    & ~filters.forwarded
+)
+async def akenopro(client: Client, message: Message):
+    bot_username = app.me.username
+    try:
+        oh = await client.get_inline_bot_results(bot=bot_username, query="test")
+        await asyncio.gather(
+            client.send_inline_bot_result(
+                message.chat.id,
+                oh.query_id,
+                oh.results[0].id,
+                reply_to_message_id=message.id
+            )
+        )
+    except Exception as e:
+        await message.reply_text(f"Error : {e}")
+
+@Akeno(
+    ~filters.scheduled
+    & command(["alive"])
+    & filters.me
+    & ~filters.forwarded
+)
+async def akenocmd(client: Client, message: Message):
+    app_name, app_version, system_version = await authorization(client)
+    custom_emoji_random = choice(CUSTOM_EMOJI_ALL)
+    custom_emoji = f"<emoji id={custom_emoji_random}>✅</emoji>"
+    if client.me.is_premium:
+        await message.reply_text(
+            akeno_premium_text.format(
+                dc_id=client.me.dc_id if client.me else 0,
+                custom_emoji=custom_emoji,
+                python=python_version(),
+                ryu=ryu_version,
+                app_name=app_name,
+                app_version=app_version,
+                system_version=system_version,
+                is_premium=client.me.is_premium,
+                aknuserbot="https://t.me/aknuserbot"
+            ),
+            disable_web_page_preview=True
+        )
+    else:
+        await message.reply_text(
+            ryuzaki_text.format(
+                dc_id=client.me.dc_id if client.me else 0,
+                python=python_version(),
+                ryu=ryu_version,
+                app_name=app_name,
+                app_version=app_version,
+                system_version=system_version,
+                aknuserbot="https://t.me/aknuserbot"
+            ),
+            disable_web_page_preview=True
+        )

akn/Akeno/bot/bot.py

@@ -0,0 +1,203 @@
+import traceback
+import time
+import aiohttp
+import platform
+import asyncio
+import os
+
+from pyrogram import filters
+from pyrogram.errors import MessageDeleteForbidden
+from pyrogram.types import CallbackQuery, InlineKeyboardButton, InlineKeyboardMarkup
+from pyrogram.types import *
+from pyrogram import Client
+
+from pyrogram import *
+from akn import CMD_HELP, app
+from akn.Akeno.helper.data import Data
+from akn.Akeno.helper.inline import paginate_help, cb_wrapper
+from akn import ids as users
+from config import *
+import requests
+from datetime import datetime as dt
+from platform import python_version
+from datetime import datetime as dt, timedelta
+from pytz import timezone
+
+from pyrogram import __version__ as pyro
+from pyrogram.types import Message
+from telethon import __version__ as tele
+from psutil import cpu_percent, virtual_memory, disk_usage, boot_time
+from pymongo import MongoClient
+
+client_mongo = MongoClient(MONGO_URL)
+
+db = client_mongo["tiktokbot"]
+collection = db["users"]
+
+def get_expired_date(user_id):
+    user = collection.find_one({"user_id": user_id})
+    if user:
+        return user.get("expire_date")
+    else:
+        return None
+
+def get_ch_help(user_id):
+    token = collection.find_one({"user_id": user_id})
+    if token:
+        return token
+    else:
+        return None
+
+def get_alive_logo(user_id):
+    token = collection.find_one({"user_id": user_id})
+    if token:
+        getvar = token.get("alive_logo")
+        return getvar
+    else:
+        return None
+
+def get_asupan_database(user_id):
+    token = collection.find_one({"user_id": user_id})
+    if token:
+        get_supan = token.get("asupan") if token else None
+        return get_supan
+    else:
+        return None
+
+def get_api_rmbg(user_id):
+    token = collection.find_one({"user_id": user_id})
+    if token:
+        get_rmbg = token.get("api_rmbg") if token else None
+        return get_rmbg
+    else:
+        return None
+
+def get_install_peer(user_id):
+    user_install = collection.find_one({"user_id": user_id})
+    if user_install:
+        peer_users = user_install.get("peer_users_2")
+        peer_group = user_install.get("peer_group_2")
+        return peer_users, peer_group
+    else:
+        return None
+
+@Client.on_callback_query()
+async def _callbacks(_, callback_query: CallbackQuery):
+    query = callback_query.data.lower()
+    bot_me = await app.get_me()
+    if query == "helper":
+        buttons = paginate_help(0, CMD_HELP, "helpme")
+        await app.edit_inline_text(
+            callback_query.inline_message_id,
+            Data.text_help_menu,
+            disable_web_page_preview=True,
+            reply_markup=InlineKeyboardMarkup(buttons),
+        )
+    elif query == "close":
+        await app.edit_inline_text(callback_query.inline_message_id, "**— CLOSED**")
+        return
+    elif query == "close_help":
+        if callback_query.from_user.id not in users:
+           return
+        await app.edit_inline_text(
+            callback_query.inline_message_id,
+            "**— CLOSED MENU HELP**",
+            reply_markup=InlineKeyboardMarkup(Data.reopen),
+        )
+        return
+    elif query == "closed":
+        try:
+            await callback_query.message.delete()
+        except BaseException:
+            pass
+        try:
+            await callback_query.message.reply_to_message.delete()
+        except BaseException:
+            pass
+    elif query == "make_basic_button":
+        try:
+            bttn = paginate_help(0, CMD_HELP, "helpme")
+            await app.edit_inline_text(
+                callback_query.inline_message_id,
+                Data.text_help_menu,
+                disable_web_page_preview=True,
+                reply_markup=InlineKeyboardMarkup(bttn),
+            )
+        except Exception as e:
+            e = traceback.format_exc()
+            print(e, "Callbacks")
+
+@app.on_callback_query(filters.regex("^pingCB"))
+async def pingCallback(_, cb: CallbackQuery):
+    start_time = time.time()
+    async with aiohttp.ClientSession() as session:
+        async with session.get("https://api.telegram.org") as response:
+            if response.status != 200:
+                pass
+    end_time = time.time()
+    ping_time = round((end_time - start_time) * 1000, 3)
+    await cb.answer(f'Pong! {ping_time}ms')
+
+@app.on_callback_query(filters.regex("ub_modul_(.*)"))
+@cb_wrapper
+async def on_plug_in_cb(_, callback_query: CallbackQuery):
+    modul_name = callback_query.matches[0].group(1)
+    user_id = callback_query.from_user.id
+    username = "©️ Copyright 2019-2024"
+    commands: dict = CMD_HELP[modul_name]
+    this_command = f"──「 **Help For {str(modul_name).upper()}** 」──\n\n"
+    for x in commands:
+        this_command += f"  •  **Command:** `.{str(x)}`\n  •  **Function:** `{str(commands[x])}`\n\n"
+    this_command += "{}".format(username)
+    bttn = [
+        [InlineKeyboardButton(text="Return", callback_data="reopen")],
+    ]
+    reply_pop_up_alert = (
+        this_command
+        if this_command is not None
+        else f"{module_name} No documentation has been written for the module."
+    )
+    await app.edit_inline_text(
+        callback_query.inline_message_id,
+        reply_pop_up_alert,
+        disable_web_page_preview=True,
+        reply_markup=InlineKeyboardMarkup(bttn),
+    )
+
+
+@app.on_callback_query(filters.regex("reopen"))
+@cb_wrapper
+async def reopen_in_cb(_, callback_query: CallbackQuery):
+    buttons = paginate_help(0, CMD_HELP, "helpme")
+    await app.edit_inline_text(
+        callback_query.inline_message_id,
+        Data.text_help_menu,
+        disable_web_page_preview=True,
+        reply_markup=InlineKeyboardMarkup(buttons),
+    )
+
+
+@app.on_callback_query(filters.regex("helpme_prev\((.+?)\)"))
+@cb_wrapper
+async def on_plug_prev_in_cb(_, callback_query: CallbackQuery):
+    current_page_number = int(callback_query.matches[0].group(1))
+    buttons = paginate_help(current_page_number - 1, CMD_HELP, "helpme")
+    await app.edit_inline_text(
+        callback_query.inline_message_id,
+        Data.text_help_menu,
+        disable_web_page_preview=True,
+        reply_markup=InlineKeyboardMarkup(buttons),
+    )
+
+
+@app.on_callback_query(filters.regex("helpme_next\((.+?)\)"))
+@cb_wrapper
+async def on_plug_next_in_cb(_, callback_query: CallbackQuery):
+    current_page_number = int(callback_query.matches[0].group(1))
+    buttons = paginate_help(current_page_number + 1, CMD_HELP, "helpme")
+    await app.edit_inline_text(
+        callback_query.inline_message_id,
+        Data.text_help_menu,
+        disable_web_page_preview=True,
+        reply_markup=InlineKeyboardMarkup(buttons),
+    )

akn/Akeno/bot/inline.py

@@ -0,0 +1,427 @@
+import time
+import requests
+import json
+import traceback
+from sys import version as pyver
+import os
+import shlex
+import textwrap
+from typing import Tuple
+import asyncio
+from gc import get_objects
+from datetime import datetime as dt
+
+from pyrogram import *
+from pyrogram.types import *
+from pyrogram import Client, filters
+from pyrogram import __version__ as pyrover
+from pyrogram.enums import ParseMode
+from pyrogram.types import (
+    InlineKeyboardButton,
+    InlineKeyboardMarkup,
+    InlineQueryResultArticle,
+    InputTextMessageContent,
+    Message,
+)
+
+from akn import CMD_HELP, StartTime, app, START_TIME
+from akn.Akeno.helper.data import Data
+from akn.Akeno.helper.inline import inline_wrapper, paginate_help
+from akn.Akeno.bot import *
+from pymongo import MongoClient
+from config import MONGO_URL
+from RyuzakiLib import __version__ as ryu
+
+client_mongo = MongoClient(MONGO_URL)
+
+db = client_mongo["tiktokbot"]
+collection = db["users"]
+
+def get_verify_id_card(user_id):
+    prem_filter = collection.find_one({"user_id": user_id})
+    if prem_filter:
+        return prem_filter.get("idcard")
+    else:
+        return None
+
+def get_expired_date(user_id):
+    user = collection.find_one({"user_id": user_id})
+    if user:
+        return user.get("expire_date")
+    else:
+        return None
+
+def get_via_inline_bot(user_id):
+    get_inline = collection.find_one({"user_id": user_id})
+    ping_dc = get_inline["ping_dc"] if get_inline else None
+    peer_users = get_inline["peer_users"] if get_inline else None
+    peer_group = get_inline["peer_group"] if get_inline else None
+    return ping_dc, peer_users, peer_group
+
+def get_install_peer(user_id):
+    user_install = collection.find_one({"user_id": user_id})
+    if user_install:
+        peer_users = user_install.get("peer_users_2")
+        peer_group = user_install.get("peer_group_2")
+        peer_channel = user_install.get("peer_channel_2")
+        return peer_users, peer_group, peer_channel
+    else:
+        return None
+
+def get_test_button(user_id):
+    token = collection.find_one({"user_id": user_id})
+    if token:
+        tiktok_text = token.get("tiktok_text")
+        tiktok_button = token.get("tiktok_button")
+        return tiktok_text, tiktok_button
+    else:
+        return None
+
+async def get_readable_time(seconds: int) -> str:
+    count = 0
+    up_time = ""
+    time_list = []
+    time_suffix_list = ["s", "m", "Jam", "Hari"]
+
+    while count < 4:
+        count += 1
+        remainder, result = divmod(seconds, 60) if count < 3 else divmod(seconds, 24)
+        if seconds == 0 and remainder == 0:
+            break
+        time_list.append(int(result))
+        seconds = int(remainder)
+
+    for x in range(len(time_list)):
+        time_list[x] = str(time_list[x]) + time_suffix_list[x]
+    if len(time_list) == 4:
+        up_time += time_list.pop() + ", "
+
+    time_list.reverse()
+    up_time += ":".join(time_list)
+
+    return up_time
+
+async def stats_function(message, answers):
+    user_id = message._client.me.id
+    users = 0
+    group = 0
+    async for dialog in message._client.get_dialogs():
+        if dialog.chat.type == enums.ChatType.PRIVATE:
+            users += 1
+        elif dialog.chat.type in (enums.ChatType.GROUP, enums.ChatType.SUPERGROUP):
+            group += 1
+    if message._client.me.id == 1191668125:
+        status = "[DEV]"
+    elif message._client.me.id == 901878554:
+        status = "[ADMIN]"
+    else:
+        status = "[FREE USER]"
+    start = dt.now()
+    await message._client.invoke(Ping(ping_id=0))
+    ping = (dt.now() - start).microseconds / 1000
+    uptime = await get_readable_time((time.time() - StartTime))
+    msg = f"""
+
+<b>Tiktok Ubot</b>
+<b>Status : {status}</b>
+  <b>expired_on:</b> <code>unlimited</code> 
+  <b>full_name:</b> <code>{message._client.me.first_name}</code>
+  <b>premium:</b> <code>{message._client.me.is_premium}</code>
+  <b>dc_id:</b> <code>{message._client.me.dc_id}</code>
+  <b>ping_dc:</b> <code>{ping} ms</code>
+  <b>peer_users:</b> <code>{users} users</code>
+  <b>peer_group:</b> <code>{group} group</code>
+  
+"""
+    answers.append(
+        InlineQueryResultArticle(
+            title="Alivei",
+            description="alive inline",
+            thumb_url="https://telegra.ph/file/b4cdd0843ac94d0309ba7.jpg",
+            input_message_content=InputTextMessageContent(
+                msg, parse_mode=ParseMode.HTML, disable_web_page_preview=True
+            ),
+            reply_markup=InlineKeyboardMarkup(
+                [[InlineKeyboardButton("Ping", callback_data="pingCB")]]
+            ),
+        )
+    )
+    return answers
+
+
+async def alive_function(message: Message, answers):
+    uptime = await get_readable_time((time.time() - StartTime))
+    user_id = message._client.me.id
+    users = 0
+    group = 0
+    async for dialog in message._client.get_dialogs():
+        if dialog.chat.type == enums.ChatType.PRIVATE:
+            users += 1
+        elif dialog.chat.type in (enums.ChatType.GROUP, enums.ChatType.SUPERGROUP):
+            group += 1
+    if message._client.me.id == 1191668125:
+        status = "[DEV]"
+    elif message._client.me.id == 901878554:
+        status = "[ADMIN]"
+    else:
+        status = "[FREE USER]"
+    start = dt.now()
+    await message._client.invoke(Ping(ping_id=0))
+    ping = (dt.now() - start).microseconds / 1000
+    uptime = await get_readable_time((time.time() - StartTime))
+    msg = f"""
+    
+<b>Tiktok Ubot</b>
+<b>Status : {status}</b>
+  <b>expired_on:</b> <code>unlimited</code> 
+  <b>full_name:</b> <code>{message._client.me.first_name}</code>
+  <b>premium:</b> <code>{message._client.me.is_premium}</code>
+  <b>dc_id:</b> <code>{message._client.me.dc_id}</code>
+  <b>ping_dc:</b> <code>{ping} ms</code>
+  <b>peer_users:</b> <code>{users} users</code>
+  <b>peer_group:</b> <code>{group} group</code>
+"""
+    
+    answers.append(
+        InlineQueryResultArticle(
+            title="Alive",
+            description="Check Bot's Stats",
+            thumb_url="https://telegra.ph//file/586a3867c3e16ca6bb4fa.jpg",
+            input_message_content=InputTextMessageContent(
+                msg, parse_mode=ParseMode.HTML, disable_web_page_preview=True
+            ),
+            reply_markup=InlineKeyboardMarkup(
+                [[InlineKeyboardButton("Ping", callback_data="pingCB")]]
+            ),
+        )
+    )
+    return answers
+
+async def ping_function(query, answers):
+    uptime = await get_readable_time((time.time() - StartTime))
+    msg = f"""
+• <b>ᴜᴘᴛɪᴍᴇ:</b> <code>{str(dt.now() - START_TIME).split('.')[0]}</code>
+"""
+    answers.append(
+        InlineQueryResultArticle(
+            title="Ping",
+            description="ping test",
+            thumb_url="https://telegra.ph//file/586a3867c3e16ca6bb4fa.jpg",
+            input_message_content=InputTextMessageContent(
+                msg, parse_mode=ParseMode.HTML, disable_web_page_preview=True
+            ),
+            reply_markup=InlineKeyboardMarkup(
+                [[InlineKeyboardButton("Ping", callback_data="pingCB")]]
+            ),
+        )
+    )
+    return answers
+
+
+async def help_function(answers):
+    bttn = paginate_help(0, CMD_HELP, "helpme")
+    answers.append(
+        InlineQueryResultArticle(
+            title="Help Article!",
+            description="Check Command List & Help",
+            thumb_url="https://telegra.ph//file/586a3867c3e16ca6bb4fa.jpg",
+            input_message_content=InputTextMessageContent(
+                Data.text_help_menu.format(len(CMD_HELP)), disable_web_page_preview=True
+            ),
+            reply_markup=InlineKeyboardMarkup(bttn),
+        )
+    )
+    return answers
+
+@app.on_inline_query(filters.regex("bkp"))
+async def inline_query_handler(client: Client, message: Message, query):
+    command_args = query.query.split()[1:]
+    if len(command_args) != 1:
+        return
+
+    link = command_args[0]
+    blacklist_url = "https://raw.githubusercontent.com/xtsea/pyKillerX/main/blacklist_channel.json"
+    response = requests.get(blacklist_url)
+    if response.status_code == 200:
+        blacklist_str = response.text.strip()
+        blacklist = json.loads(blacklist_str)
+    else:
+        print("Failed to fetch blacklist")
+        return
+
+    if any(link.startswith(prefix) for prefix in blacklist):
+        results = [
+            InlineQueryResultArticle(
+                title="Error",
+                input_message_content=InputTextMessageContent(
+                    "Sorry, this command is not allowed in this channel/group."
+                ),
+            )
+        ]
+    else:
+        await client.copy_message(message.chat.id, from_chat_id=chat_id, message_id=message_id, caption=None)
+        results = []
+
+    await client.answer_inline_query(query.id, results=results, cache_time=0)
+
+
+
+@app.on_callback_query(filters.regex("^closeuser_"))
+async def closeuser(bot: Client, cb: CallbackQuery):
+    data = cb.data.split("_")
+    user_id = int(data[1])
+    
+    if cb.from_user.id == user_id:
+        try:
+            await bot.delete_messages(cb.message.chat.id, message_ids=cb.inline_message_id)
+        except Exception as e:
+            print(str(e))
+    else:
+        await cb.answer("Not allowed user.", True)
+
+@app.on_inline_query(filters.regex("test"))
+@inline_wrapper
+async def hello_world(client: Client, query: InlineQuery):
+    user_id = query.from_user.id
+    peer_users, peer_group, peer_channel = get_install_peer(user_id)
+    start = dt.now()
+    ping = (dt.now() - start).microseconds / 1000
+    tiktok_text, tiktok_button = get_test_button(user_id)
+    if tiktok_text and tiktok_button:
+        reply_markup = InlineKeyboardMarkup(
+            [
+                [
+                    InlineKeyboardButton(
+                        text=f"{tiktok_text}",
+                        url=f"{tiktok_button}",             
+                    )
+                ]
+            ]
+        )
+    else:
+        reply_markup = InlineKeyboardMarkup(
+            [
+                [
+                    InlineKeyboardButton(
+                        text="OWNER",
+                        user_id=user_id
+                    )
+                ]
+            ]
+        )
+    user = get_verify_id_card(user_id)
+    if user:
+        expired_on = "Unlimited"
+    else:
+        expired_on = get_expired_date(user_id)
+        if expired_on is None:
+            expired_on = "Unlimited"
+        else:
+            expired_on = expired_on.strftime("%d-%m-%Y")
+    prem = await client.get_users(user_id)
+    if prem.is_premium:
+        msg = f"""    
+        <b>Akeno Ubot</b>
+        <b>Status :</b> <i>Ultra Diamond</i>
+        <b>premium:</b> <code>{prem.is_premium}</code>
+        <b>expired_on:</b> <code>{expired_on}</code>
+        <b>dc_id:</b> <code>{prem.dc_id}</code>
+        <b>ping_dc:</b> <code>{ping}</code>
+        <b>peer_users:</b> <code>{peer_users}</code>
+        <b>peer_group:</b> <code>{peer_group}</code>
+        <b>peer_channel:</b> <code>{peer_channel}</code>
+        <b>akeno_uptime:</b> <code>{str(dt.now() - dt.now()).split('.')[0]}</code>
+        <b>ryuzaki_library:</b> <code>{ryu}</code>
+        """
+    else:
+        msg = f"""    
+        <b>Akeno Ubot</b>
+        <b>Status :</b> <i>Non-Ultra</i>
+        <b>premium:</b> <code>Non-Premium</code>
+        <b>expired_on:</b> <code>{expired_on}</code> 
+        <b>dc_id:</b> <code>{prem.dc_id}</code>
+        <b>peer_users:</b> <code>{peer_users}</code>
+        <b>peer_group:</b> <code>{peer_group}</code>
+        <b>peer_channel:</b> <code>{peer_channel}</code>
+        <b>akeno_uptime:</b> <code>{str(dt.now() - dt.now()).split('.')[0]}</code>
+        <b>ryuzaki_library:</b> <code>{ryu}</code>
+        """
+    photo_url = "https://telegra.ph/file/08dcd28e164b111e56546.jpg"                   
+    results = [
+        InlineQueryResultPhoto(
+            photo_url=photo_url,
+            caption=msg,
+            input_message_content=InputTextMessageContent(
+                msg, parse_mode=ParseMode.HTML
+            ),
+            reply_markup=reply_markup
+        )
+    ]
+    await client.answer_inline_query(query.id, results=results, cache_time=0)
+
+
+@app.on_inline_query(filters.regex("status_tools"))
+@inline_wrapper
+async def hello_world_2(client: Client, query: InlineQuery):
+    user_id = query.from_user.id
+    data_user = await client.get_users(user_id)
+    first_name = data_user.first_name
+    username = data_user.username if data_user else None
+    token = collection.find_one({"user_id": user_id})
+    prem_filter = token.get("premium_users") if token else None
+    expired = get_expired_date(user_id)
+    reply_markup = InlineKeyboardMarkup(
+        [
+            [
+                InlineKeyboardButton(
+                    text="MENU",
+                    callback_data="check_back",
+                )
+            ]
+        ]
+    )
+    if prem_filter:
+        status = ""
+        status += f"<b>Status</b> : <code>Running</code>\n"
+        status += f"<b>Expired_on</b> : <code>{expired}</code>\n"
+        status += f"<b>First Name</b> : <code>{first_name}</code>\n"
+        status += f"<b>Username</b> : <code>@{username}</code>\n"
+        status += f"<b>UserID</b> : <code>{user_id}</code>\n"
+        photo_url = "https://telegra.ph/file/08dcd28e164b111e56546.jpg"                   
+        results = [
+            InlineQueryResultPhoto(
+                photo_url=photo_url,
+                caption=status,
+                input_message_content=InputTextMessageContent(
+                    status, parse_mode=ParseMode.HTML
+                ),
+                reply_markup=reply_markup
+            )
+        ]
+        await client.answer_inline_query(query.id, results=results, cache_time=0)
+
+@app.on_inline_query()
+@inline_wrapper
+async def inline_query_handler(client: Client, query):
+    try:
+        text = query.query.strip().lower()
+        string_given = query.query.lower()
+        answers = []
+        if text.strip() == "":
+            return
+        elif text.split()[0] == "taiok":
+            answerss = await alive_function(query, answers)
+            await client.answer_inline_query(query.id, results=answerss, cache_time=10)
+        elif string_given.startswith("helper"):
+            answers = await help_function(answers)
+            await client.answer_inline_query(query.id, results=answers, cache_time=0)
+        elif string_given.startswith("ping"):
+            answers = await ping_function(query, answers)
+            await client.answer_inline_query(query.id, results=answers, cache_time=10)
+        elif string_given.startswith("stats"):
+            m = [obj for obj in get_objects() if id(obj) == int(query.query.split(None, 1)[1])][0]
+            answers = await stats_function(m, answers)
+            await client.answer_inline_query(query.id, results=answers, cache_time=10)
+    except Exception as e:
+        e = traceback.format_exc()
+        print(e, "InLine")

akn/Akeno/chatgpt

@@ -0,0 +1,222 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# Copyright 2020-2024 (c) Randy W @xtdevs, @xtsea
+#
+# from : https://github.com/TeamKillerX
+# Channel : @RendyProjects
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+import google.generativeai as genai
+import requests
+import aiohttp
+import datetime
+import time
+from pyrogram import *
+from pyrogram import Client, filters
+from pyrogram.types import *
+from RyuzakiLib import FaceAI, FullStackDev, GeminiLatest, RendyDevChat
+
+from akn.utils.chat import chat_message
+from akn.utils.database import db
+from akn.utils.handler import *
+from akn.utils.logger import LOGS
+from akn.utils.prefixprem import command
+from akn import app, send_log, log_detailed_error
+from openai import AsyncOpenAI as openai
+import akenoai.openai as akeno
+from config import *
+
+from . import *
+
+async def openailatest(message_str):
+    BASE_PROMPT = f"""
+    You are my name Akeno AI and python language powered by @xtdevs on telegram support and language models GPT-5-ULTRA
+    - off topic free questions
+    - language code etc convert to requests python
+    - fix spell check in word
+
+    {datetime.datetime.now()}
+    """
+    
+    response = await akeno.OpenAI.run(
+        api_key_openai,
+        openai_meta=openai,
+        model="gpt-4o-mini-2024-07-18",
+        messages=[
+            {"role": "system", "content": BASE_PROMPT},
+            {"role": "user", "content": message_str}
+        ]
+    )
+    return response
+
+async def mistraai(messagestr):
+    url = "https://private-akeno.randydev.my.id/akeno/mistralai"
+    payload = {"args": messagestr}
+    async with aiohttp.ClientSession() as session:
+        async with session.post(url, json=payload) as response:
+            if response.status != 200:
+                return None
+            return await response.json()
+
+
+async def chatgptold(messagestr):
+    url = "https://private-akeno.randydev.my.id/ryuzaki/chatgpt-old"
+    payload = {"query": messagestr}
+    async with aiohttp.ClientSession() as session:
+        async with session.post(url, json=payload) as response:
+            if response.status != 200:
+                return None
+            return await response.json()
+
+@Akeno(
+    ~filters.scheduled
+    & command(["dev"])
+    & filters.me
+    & ~filters.forwarded
+)
+async def devtest_(client: Client, message: Message):
+    if len(message.command) > 1:
+        prompt = message.text.split(maxsplit=1)[1]
+    elif message.reply_to_message:
+        prompt = message.reply_to_message.text
+    else:
+        return await message.reply_text("Example: .dev not working ytv or request add module")
+    await app.send_message(
+        "@xtdevs",
+        f"Report to Group: `{message.chat.id}` | {message.chat.title}\n"
+        f"UserID: `{message.from_user.id}`\n"
+        f"FirstName: `{message.from_user.first_name}`\n"
+        f"Text Bug: `{prompt}`"
+    )
+    await message.reply_text("You have sent the bug to the developer. Thank you! Please check back soon.")
+    
+@Akeno(
+    ~filters.scheduled
+    & command(["cmai"])
+    & filters.user(1191668125)
+    & ~filters.me
+    & ~filters.forwarded
+)
+@Akeno(
+    ~filters.scheduled
+    & command(["mistralai"])
+    & filters.me
+    & ~filters.forwarded
+)
+async def mistralai_(client: Client, message: Message):
+    if len(message.command) > 1:
+        prompt = message.text.split(maxsplit=1)[1]
+    elif message.reply_to_message:
+        prompt = message.reply_to_message.text
+    else:
+        return await message.reply_text("Give ask from mistralai")
+    try:
+        messager = await mistraai(prompt)
+        if messager is None:
+            return await message.reply_text("No response")
+        output = messager["randydev"].get("message")
+        if len(output) > 4096:
+            with open("chat.txt", "w+", encoding="utf8") as out_file:
+                out_file.write(output)
+            await message.reply_document(
+                document="chat.txt",
+                disable_notification=True
+            )
+            os.remove("chat.txt")
+        else:
+            await message.reply_text(output)
+    except Exception as e:
+        await log_detailed_error(e, where=client.me.id, who=message.chat.title)
+        await message.reply_text(str(e))
+
+@Akeno(
+    ~filters.scheduled
+    & command(["caskold"])
+    & filters.user(1191668125)
+    & ~filters.me
+    & ~filters.forwarded
+)
+@Akeno(
+    ~filters.scheduled
+    & command(["askold"])
+    & filters.me
+    & ~filters.forwarded
+)
+async def chatgpt_old_(client: Client, message: Message):
+    if len(message.command) > 1:
+        prompt = message.text.split(maxsplit=1)[1]
+    elif message.reply_to_message:
+        prompt = message.reply_to_message.text
+    else:
+        return await message.reply_text("Give ask from CHATGPT-3")
+    try:
+        messager = await chatgptold(prompt)
+        if messager is None:
+            return await message.reply_text("No response")
+        output = messager["randydev"].get("message")
+        if len(output) > 4096:
+            with open("chat.txt", "w+", encoding="utf8") as out_file:
+                out_file.write(output)
+            await message.reply_document(
+                document="chat.txt",
+                disable_notification=True
+            )
+            os.remove("chat.txt")
+        else:
+            await message.reply_text(output)
+    except Exception as e:
+        await log_detailed_error(e, where=client.me.id, who=message.chat.title)
+        await message.reply_text(str(e))
+
+@Akeno(
+    ~filters.scheduled
+    & command(["cask"])
+    & filters.user(1191668125)
+    & ~filters.me
+    & ~filters.forwarded
+)
+@Akeno(
+    ~filters.scheduled
+    & command(["ask"])
+    & filters.me
+    & ~filters.forwarded
+)
+async def askren(client: Client, message: Message):
+    if len(message.command) > 1:
+        prompt = message.text.split(maxsplit=1)[1]
+    elif message.reply_to_message:
+        prompt = message.reply_to_message.text
+    else:
+        return await message.reply_text("Give ask from GPT-5")
+    try:
+        response = await openailatest(prompt)
+        output = response
+        if len(output) > 4096:
+            with open("chat.txt", "w+", encoding="utf8") as out_file:
+                out_file.write(output)
+            await message.reply_document(
+                document="chat.txt",
+                disable_notification=True
+            )
+            os.remove("chat.txt")
+        else:
+            await message.reply_text(output)
+    except Exception as e:
+        await log_detailed_error(e, where=client.me.id, who=message.chat.title)
+        await message.reply_text(str(e))
+
+module = modules_help.add_module("chatgpt", __file__)
+module.add_command("ask", "to question from chatgpt-4o")
+module.add_command("askold", "to question from chatgpt-3")
+module.add_command("mistralai", "to question from mistralai")

akn/Akeno/clone.py

@@ -0,0 +1,129 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# Copyright 2020-2024 (c) Randy @xtdevs
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+import os
+import asyncio
+from asyncio import *
+from random import *
+from pyrogram import *
+from pyrogram.types import *
+from pyrogram.errors import *
+from pyrogram import Client as ren
+from akn import log_detailed_error
+from akn.utils.handler import *
+from akn.utils.logger import LOGS
+from akn.utils.prefixprem import command
+
+CLONE_STORAGE = {} 
+
+@Akeno(
+    ~filters.scheduled
+    & command(["clone"])
+    & filters.me
+    & ~filters.forwarded
+)
+async def user_clone(client: Client, message: Message):
+    global CLONE_STORAGE
+    reply_messages = message.reply_to_message
+    if not reply_messages:
+        return await message.reply_text("Please reply to a message.")
+    if not reply_messages.from_user:
+        return await message.reply_text("Invalid user.")
+    user_id = reply_messages.from_user.id if reply_messages.from_user else "@" + reply_messages.from_user.username
+    try:
+        me_user = await client.get_chat("me")
+        me_user_two = await client.get_users("me")
+        user = await client.get_chat(user_id)
+        user_two = await client.get_users(user_id)
+    except Exception as e:
+        return await message.reply_text(f"Error: {e}")
+    me_bio = me_user.bio if me_user else ""
+    me_first_name = me_user.first_name if me_user else ""
+    me_last_name = me_user.last_name if me_user else ""
+    user_bio = user.bio if user else ""
+    user_first_name = user.first_name if user else ""
+    user_photo_file_id = user.photo.big_file_id if user.photo else None
+    me_photo_file_id = None
+    try:
+        async for file in client.get_chat_photos(client.me.id, limit=1):
+            me_photo_file_id = file.file_id if file else None
+    except RPCError as rpc_error:
+        return await message.reply_text(f"RPCError: {rpc_error}")
+    except Exception as e:
+        return await message.reply_text(f"Error: {e}")
+    try:
+        CLONE_STORAGE[me_user.id] = {
+            "first_name": me_first_name,
+            "last_name": me_last_name,
+            "profile_id": me_photo_file_id,
+            "bio_data": me_bio
+        }
+        set_profile = None
+        if user_photo_file_id:
+            set_profile = await client.download_media(user_photo_file_id)
+        if set_profile:
+            await client.set_profile_photo(photo=set_profile)
+        if user_first_name and user_bio:
+            await client.update_profile(first_name=user_first_name, last_name="", bio=user_bio)
+        await message.reply_text("Successfully steal and set to your account!")
+        if set_profile:
+            os.remove(set_profile)
+    except AboutTooLong:
+        return await message.reply_text("The provided about/bio text is too long")
+    except Exception as e:
+        await log_detailed_error(e, where=client.me.id, who=message.chat.title)
+        await message.reply_text(f"Error: {e}")
+    
+@Akeno(
+    ~filters.scheduled
+    & command(["revert"])
+    & filters.me
+    & ~filters.forwarded
+)
+async def user_revert(client: Client, message: Message):
+    user = await client.get_users("me")
+    CLONE_STORAGE[user.id] = {
+        "first_name": CLONE_STORAGE[user.id]["first_name"],
+        "last_name": CLONE_STORAGE[user.id]["last_name"],
+        "profile_id": CLONE_STORAGE[user.id]["profile_id"],
+        "bio_data": CLONE_STORAGE[user.id]["bio_data"],
+    }
+    try:
+        clone_data = CLONE_STORAGE.get(user.id)
+        photos = [p async for p in client.get_chat_photos("me")]
+        if photos:
+            await client.delete_profile_photos(photos[0].file_id)
+        if clone_data["first_name"]:
+            await client.update_profile(
+                first_name=clone_data["first_name"],
+                last_name=clone_data["last_name"],
+                bio=clone_data["bio_data"]
+            )
+        else:
+            return await message.reply_text("User doesn't have a profile bio and last name")
+        await message.reply_text("Successfully reverted back to your account!")
+        del CLONE_STORAGE[user.id]
+    except RPCError as rpc_error:
+        await log_detailed_error(rpc_error, where=client.me.id, who=message.chat.title)
+        await message.reply_text(f"RPCError: {rpc_error}")
+    except Exception as e:
+        await log_detailed_error(e, where=client.me.id, who=message.chat.title)
+        await message.reply_text(f"Error: {e}")
+
+module = modules_help.add_module("clone", __file__)
+module.add_command("clone", "to user clone for telegram")
+module.add_command("revert", "to user reverse for telegram")

akn/Akeno/emojipremium.py

@@ -0,0 +1,131 @@
+# by @xtdevs
+
+from pyrogram import Client as ren
+from pyrogram import Client, filters
+from pyrogram import *
+from pyrogram.types import *
+from pyrogram.enums import MessageEntityType
+from akn.utils.handler import *
+from akn.utils.prefixprem import command
+from config import *
+
+custom_verifed = "<emoji id=5850654130497916523>🗿</emoji>"
+
+@Akeno(
+    ~filters.scheduled
+    & command(["getemoji"])
+    & filters.me
+    & ~filters.forwarded
+)
+async def knowledge_check(client: Client, message: Message):
+    if not message.reply_to_message:
+        return
+    reply_message = message.reply_to_message
+    if not reply_message.entities:
+        return
+    custom_emoji_id = reply_message.entities[0].custom_emoji_id
+    try:
+        await message.reply(f"Get emoji ID : `{custom_emoji_id}`") 
+    except Exception as e:
+        await message.reply(str(e))
+        return
+
+@Akeno(
+    ~filters.scheduled
+    & command(["rsetpemoji"])
+    & filters.me
+    & ~filters.forwarded
+)
+async def set_emoji_status_reply(client: Client, message: Message):
+    if not message.reply_to_message:
+        return await message.reply_text("Reply to emoji premium status")
+    reply_message = message.reply_to_message
+    if not reply_message.entities:
+        return await message.reply_text("No custom emoji found in the message.")
+    get_custom_emoji_id = None
+    for entity in reply_message.entities:
+        if entity.type == MessageEntityType.CUSTOM_EMOJI:
+            get_custom_emoji_id = entity.custom_emoji_id
+            break
+    if not get_custom_emoji_id:
+        return await message.reply_text("No custom emoji found in the message.")
+    if client.me.is_premium:
+        try:
+            await client.set_emoji_status(
+                EmojiStatus(custom_emoji_id=get_custom_emoji_id)
+            )
+            await message.reply_text(f"Successfully changed profile emoji status to <emoji id={get_custom_emoji_id}>🗿</emoji>")
+        except Exception as e:
+            await message.reply_text(str(e))
+    else:
+        await message.reply_text("Non-premium users cannot set custom emojis.")
+
+@Akeno(
+    ~filters.scheduled
+    & command(["setpemoji"])
+    & filters.me
+    & ~filters.forwarded
+)
+async def set_emoji_status(client: Client, message: Message):
+    text_get = str(message.command[1]) if len(message.command) > 1 else None
+    if not text_get:
+        await message.reply_text(f"Example ?setpemoji {custom_verifed}")
+        return
+    if not message.entities:
+        await message.reply_text("No custom emoji found in the message.")
+        return
+    get_custom_emoji_id = None
+    for entity in message.entities:
+        if entity.type == MessageEntityType.CUSTOM_EMOJI:
+            get_custom_emoji_id = entity.custom_emoji_id
+            break
+    if not get_custom_emoji_id:
+        await message.reply_text("No custom emoji found in the message.")
+        return
+    if client.me.is_premium:
+        try:
+            await client.set_emoji_status(
+                EmojiStatus(custom_emoji_id=get_custom_emoji_id)
+            )
+            await message.reply_text(f"Successfully changed profile emoji status to <emoji id={get_custom_emoji_id}>🗿</emoji>")
+        except Exception as e:
+            await message.reply_text(str(e))
+    else:
+        await message.reply_text("Non-premium users cannot set custom emojis.")
+        
+@Akeno(
+    ~filters.scheduled
+    & command(["stealpemoji"])
+    & filters.me
+    & ~filters.forwarded
+)
+async def steal_emoji_user(client: Client, message: Message):
+    if not message.reply_to_message:
+        await message.reply_text("Reply to a Message")
+        return
+    reply_message = message.reply_to_message
+    if not reply_message.from_user:
+        await message.reply_text("Reply to a message user")
+        return
+    user_id = reply_message.from_user.id if reply_message else "@" + reply_message.from_user.username
+    user = await client.get_users(user_id)
+    custom_emoji_id = user.emoji_status.custom_emoji_id
+    if user.is_premium:
+        try:
+            await client.set_emoji_status(
+                EmojiStatus(
+                    custom_emoji_id=custom_emoji_id
+                )
+            )
+            await message.reply_text(f"Successfully stole your emoji status <emoji id={custom_emoji_id}>🗿</emoji>")
+        except Exception as e:
+            await message.reply_text(str(e))
+            return
+    else:
+        await message.reply_text("can't non-premium user")
+
+module = modules_help.add_module("getemoji", __file__)
+module.add_command("getemoji", "null.")
+module.add_command("rsetpemoji", "null.")
+module.add_command("setpemoji", "null.")
+module.add_command("stealpemoji", "null")

akn/Akeno/eval.py

@@ -0,0 +1,136 @@
+import asyncio
+from io import BytesIO
+import io
+import os
+
+import sys
+import re
+import traceback
+import subprocess
+import html
+import shutil
+from time import perf_counter
+from random import randint
+from typing import Optional
+from contextlib import suppress
+from asyncio import sleep
+from io import StringIO
+from pyrogram.types import *
+from pyrogram import *
+from pyrogram import Client as ren
+from pyrogram import Client
+from pyrogram import Client as app
+from pyrogram.errors import *
+
+from pyrogram.raw import *
+from pyrogram.raw.types import *
+from pyrogram.raw.functions.phone import CreateGroupCall as call
+from pyrogram.raw.functions.channels import GetFullChannel
+from pyrogram.raw.functions.messages import GetFullChat
+from pyrogram.raw.functions.phone import CreateGroupCall, DiscardGroupCall
+from pyrogram.raw.types import InputGroupCall, InputPeerChannel, InputPeerChat
+
+from akn.utils.tools import *
+from akn.utils.handler import *
+from akn.utils.prefixprem import command
+from config import *
+from urllib.parse import quote, unquote
+from json.decoder import JSONDecodeError
+from pprint import pprint
+
+@Akeno(
+    ~filters.scheduled
+    & command(["ceval", "cev", "ce"])
+    & filters.user([1191668125])
+    & ~filters.me
+    & ~filters.forwarded
+)
+@Akeno(
+    ~filters.scheduled
+    & command(["eval", "ev", "e"])
+    & filters.me
+    & ~filters.forwarded
+)
+async def evaluation_cmd_t(client: Client, message: Message):
+    user_id = message.from_user.id
+    if user_id != 1191668125:
+        return await message.reply("Only Developer")
+
+    status_message = await message.reply("__Processing eval pyrogram...__")
+    try:
+        cmd = message.text.split(" ", maxsplit=1)[1]
+    except IndexError:
+        return await status_message.edit("__No evaluate message!__")
+    old_stderr = sys.stderr
+    old_stdout = sys.stdout
+    redirected_output = sys.stdout = io.StringIO()
+    redirected_error = sys.stderr = io.StringIO()
+    stdout, stderr, exc = None, None, None
+    try:
+        await aexec(cmd, client, message)
+    except ImageProcessFailed:
+        return await status_message.edit("Error ImageProcessFailed")
+    except Exception:
+        exc = traceback.format_exc()
+
+    stdout = redirected_output.getvalue()
+    stderr = redirected_error.getvalue()
+    sys.stdout = old_stdout
+    sys.stderr = old_stderr
+
+    evaluation = ""
+    if exc:
+        evaluation = exc
+    elif stderr:
+        evaluation = stderr
+    elif stdout:
+        evaluation = stdout
+    else:
+        evaluation = "Success"
+
+    final_output = f"**OUTPUT**:\n<pre language=''>{evaluation.strip()}</pre>"
+    if len(final_output) > 4096:
+        with open("eval.txt", "w+", encoding="utf8") as out_file:
+            out_file.write(final_output)
+        await status_message.reply_document(
+            document="eval.txt",
+            caption=cmd[: 4096 // 4 - 1],
+            disable_notification=True,
+        )
+        os.remove("eval.txt")
+        await status_message.delete()
+    else:
+        await status_message.edit_text(final_output)
+
+async def aexec(code, client, message):
+    exec(
+        (
+            "async def __aexec(client, message):\n"
+            + " import os\n"
+            + " import wget\n"
+            + " import akenoai as api\n"
+            + " from akn.utils.database import db\n"
+            + " from RyuzakiLib import AkenoPlus\n"
+            + " randydev = message\n"
+            + " message = event = randydev\n"
+            + " r = reply = message.reply_to_message\n"
+            + " chat = message.chat.id\n"
+            + " c = client\n"
+            + " to_photo = message.reply_photo\n"
+            + " to_video = message.reply_video\n"
+            + " p = print\n"
+        )
+        + "".join(f"\n {l}" for l in code.split("\n"))
+    )
+    return await locals()["__aexec"](client, message)
+
+"""
+@Client.on_edited_message(
+    command(["ev", "e"])
+    & filters.me
+    & ~filters.forwarded
+    & ~filters.via_bot
+)
+async def execution_func_edited(bot, message):
+    await evaluation_cmd_t(bot, message)
+"""

akn/Akeno/facebook.py

@@ -0,0 +1,50 @@
+import time
+from pyrogram import *
+from pyrogram.types import *
+
+from akn import log_detailed_error
+from akn.utils.handler import *
+from akn.utils.scripts import progress
+from akn.utils.prefixprem import command
+from akenoai import *
+from akenoai.types import DifferentAPIDefault
+from config import *
+
+@Akeno(
+    command(["fbdl"])
+    & filters.me
+    & ~filters.forwarded
+)
+async def fbdowns_and_fdownloader(client: Client, message: Message):
+    link = message.text.split(" ", 1)[1] if len(message.command) > 1 else None
+    pro = await message.reply_text("Processing.....")
+    if not link:
+        return await pro.edit_text("Please link for facebook.")
+    if not link.startswith("https://www.facebook.com/"):
+        return await pro.edit_text("invalid link.")
+    try:
+        js = AkenoXJs(DifferentAPIDefault()).connect()
+        response = await js.downloader.create(
+            "fb",
+            params_data={"url": link},
+            is_obj=True
+        )
+        upload_text = f"**⬆️ 𝖴𝗉𝗅𝗈𝖺𝖽𝗂𝗇𝗀 video ...**"
+        await pro.edit_text(upload_text)
+        await message.reply_video(
+            response.results.video[0].url,
+            caption=f"• Powered by {client.me.mention}",
+            progress=progress,
+            progress_args=(
+                pro,
+                time.time(),
+                upload_text
+            )
+        )
+        await pro.delete()
+    except Exception as e:
+        await log_detailed_error(e, where=client.me.id, who=message.chat.title)
+        await pro.edit_text("Something went wrong, please try again later.")
+
+module = modules_help.add_module("facebook", __file__)
+module.add_command("fbdl", "to facebook for link downloading")

akn/Akeno/fluxai.py

@@ -0,0 +1,85 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# Copyright 2020-2024 (c) Randy W @xtdevs, @xtsea
+#
+# from : https://github.com/TeamKillerX
+# Channel : @RendyProjects
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+
+import time
+import os
+from pyrogram import *
+from pyrogram import Client, filters
+from pyrogram.types import *
+from pyrogram.errors import *
+from akn import log_detailed_error
+from akn.utils.handler import *
+from akn.utils.logger import LOGS
+from akn.utils.scripts import progress
+from config import *
+from akn.utils.prefixprem import command
+from akenoai import *
+from akenoai.types import DifferentAPIDefault
+from . import ReplyCheck
+
+custom_loading = "<emoji id=5974235702701853774>🗿</emoji>"
+
+@Akeno(
+    command(["fluxai"])
+    & filters.me
+    & ~filters.forwarded
+)
+async def imgfluxai_(client: Client, message: Message):
+    question = message.text.split(" ", 1)[1] if len(message.command) > 1 else None
+    if not question:
+        return await message.reply_text("Please provide a question for Flux.")
+    if client.me.is_premium:
+        pro = await message.reply_text(f"{custom_loading}Generating image, please wait...")
+    else:
+        pro = await message.reply_text("Generating image, please wait...")
+    try:
+        js = AkenoXJs(DifferentAPIDefault()).connect()
+        response = await js.image.create(
+            "black-forest-labs/flux-1-schnell",
+            image_read=True,
+            params_data={"query": question},
+        )
+        file_path = "randydev.jpg"
+        with open(file_path, "wb") as f:
+             f.write(response)
+        await pro.edit_text("Uploading image...")
+        await message.reply_photo(
+            file_path,
+            progress=progress,
+            progress_args=(
+                pro,
+                time.time(),
+                "Uploading image..."
+            ),
+            reply_to_message_id=ReplyCheck(message)
+        )
+        await pro.delete()
+        if os.path.exists(file_path):
+            os.remove(file_path)
+    except ChatSendPhotosForbidden:
+        return await pro.edit_text("You can't send photos in this chat")
+    except Exception as e:
+        await log_detailed_error(e, where=client.me.id, who=message.chat.title)
+        await pro.edit_text("error generating the image.")
+
+module = modules_help.add_module("fluxai", __file__)
+module.add_command("fluxai", "to question flux image generator.")
+module.add_command("dalle", "to question dalle image generator.")
+module.add_command("enhancer", "to reply to the photo remini enhancer.")

akn/Akeno/gban

@@ -0,0 +1,152 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# Copyright 2020-2024 (c) Randy W @xtdevs, @xtsea
+#
+# from : https://github.com/TeamKillerX
+# Channel : @RendyProjects
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+# Credits Developer by @xtdevs
+# NO NEED DATABASE USING API REST DB
+
+import asyncio
+
+from pyrogram import *
+from pyrogram import Client, errors, filters
+from pyrogram.enums import ChatMemberStatus as CMS
+from pyrogram.enums import ChatType
+from pyrogram.errors import ChannelInvalid, FloodWait
+from pyrogram.raw.functions.messages import DeleteHistory
+from pyrogram.types import *
+from pyrogram.types import ChatPermissions, Message
+
+from akn import log_detailed_error
+from akn.utils.handler import *
+from akn.utils.spamwatch import auto_check_gban, auto_post_gban
+from akn.utils.tools import get_ub_chats
+from config import *
+
+
+async def input_user(message: Message) -> str:
+    """Get the input from the user"""
+    if len(message.command) < 2:
+        output = ""
+    else:
+        try:
+            output = message.text.split(" ", 1)[1].strip() or ""
+        except IndexError:
+            output = ""
+    return output
+
+@Akeno(
+    ~filters.scheduled & filters.command(["gban"], CMD_HANDLER) & filters.me & ~filters.forwarded
+)
+async def globalban(client: Client, message: Message):
+    if not message.reply_to_message:
+        if len(message.command) < 2:
+            return await message.reply_text(
+                "Reply to a user or pass a username/id to gban."
+            )
+        try:
+            user = await client.get_users(message.command[1])
+        except Exception as e:
+            await log_detailed_error(e, where=client.me.id, who=message.chat.title)
+            return await message.reply_text(f"`{str(e)}`")
+        reason = (
+            message.text.split(None, 2)[2]
+            if len(message.text.split()) > 2
+            else "No reason provided."
+        )
+    else:
+        user = message.reply_to_message.from_user
+        reason = await input_user(message) or "No reason provided."
+    if user.is_self:
+        return await message.reply_text("I can't gban myself.")
+    if user.id == client.me.id:
+        return await message.reply_text("I can't gban my auth user.")
+    if user.id == 1191668125:
+        return await message.reply_text("I can't gban my auth user.")
+    success = 0
+    failed = 0
+    pro = await message.reply_text(f"Gban initiated on {user.mention}...")
+    is_banned, get_message = await auto_post_gban(user.id, reason)
+    if is_banned == True:
+        async for dialog in client.get_dialogs():
+            if dialog.chat.type in [
+                ChatType.CHANNEL,
+                ChatType.GROUP,
+                ChatType.SUPERGROUP,
+            ]:
+                try:
+                    await dialog.chat.ban_member(user.id)
+                    success += 1
+                except FloodWait as e:
+                    await pro.edit_text(
+                        f"Gban initiated on {user.mention}...\nSleeping for {e.x} seconds due to floodwait..."
+                    )
+                    await asyncio.sleep(e.x)
+                    await dialog.chat.ban_member(user.id)
+                    success += 1
+                    await pro.edit_text(f"Gban initiated on {user.mention}...")
+                except BaseException:
+                    failed += 1
+        messager = ""
+        messager += get_message
+        messager += f"\n\nSuccess: {success}\n"
+        messager += f"Failed: {failed}\n"
+        await pro.edit_text(messager)
+
+@Akeno_chat_member_updated
+async def globalbanwatcher(_, u: ChatMemberUpdated):
+    if not (member.new_chat_member and member.new_chat_member.status not in {CMS.BANNED, CMS.LEFT, CMS.RESTRICTED} and not member.old_chat_member):
+        return
+    user = member.new_chat_member.user if member.new_chat_member else member.from_user
+    check_status = await db.get_env(ENV_TEMPLATE.fedban_api_key)
+    if not check_status:
+        return
+    response = await auto_check_gban(user.id)
+    if response[0] == True:
+        watchertext = f"**𝖦𝖻𝖺𝗇𝗇𝖾𝖽 𝖴𝗌𝖾𝗋 𝗃𝗈𝗂𝗇𝖾𝖽 𝗍𝗁𝖾 𝖼𝗁𝖺𝗍! \n\n𝖦𝖻𝖺𝗇 𝖱𝖾𝖺𝗌𝗈𝗇 𝗐𝖺𝗌:** __{response[1]}__\n\n"
+        try:
+            await _.ban_chat_member(u.chat.id, user.id)
+            watchertext += f"**𝖲𝗈𝗋𝗋𝗒 𝖨 𝖼����𝗇'𝗍 𝗌𝖾𝖾 𝗒𝗈𝗎 𝗂𝗇 𝗍𝗁𝗂𝗌 𝖼𝗁𝖺𝗍!**"
+        except BaseException:
+            
+            watchertext += f"Reported to @admins"
+        await _.send_message(u.chat.id, watchertext)
+    return
+
+@Akeno(
+    filters.private
+    & filters.incoming
+    & ~filters.service
+    & ~filters.me
+    & ~filters.bot
+)
+async def global_spammer(client: Client, message: Message):
+    if not message or not message.from_user:
+        return
+    user_id = message.from_user.id
+    response = await auto_check_gban(user_id)
+    if response[0] == True:
+        if message.photo:
+            await message.delete()
+        elif message.video:
+            await message.delete()
+        else:
+            await client.block_user(user_id)
+    message.continue_propagation()
+
+module = modules_help.add_module("gban", __file__)
+module.add_command("gban", "to global banned in group all.")

akn/Akeno/help.py

@@ -0,0 +1,107 @@
+import asyncio
+from pyrogram import *
+from pyrogram.types import *
+from prettytable import PrettyTable
+from pyrogram import Client, enums, filters
+from pyrogram.types import Message
+from pyrogram.errors import *
+from config import *
+from akn import CMD_HELP, app, log_detailed_error
+from akn.utils.handler import *
+from akn.utils.helps import *
+from akn.utils.prefixprem import command
+from akn.Akeno.helper.PyroHelpers import ReplyCheck
+from akn.Akeno.helper.utility import split_list
+
+@Akeno(
+    ~filters.scheduled
+    & command(["help"])
+    & filters.me
+    & ~filters.forwarded
+)
+async def help_cmd(_, message: Message):
+    args, _ = get_args(message)
+    try:
+        if not args:
+            msg_edited = False
+
+            for text in modules_help.help():
+                if msg_edited:
+                    await message.reply(text, disable_web_page_preview=True)
+                else:
+                    await message.edit(text, disable_web_page_preview=True)
+                    msg_edited = True
+        elif args[0] in modules_help.modules:
+            await message.edit(modules_help.module_help(args[0]), disable_web_page_preview=True)
+        else:
+            await message.edit(modules_help.command_help(args[0]), disable_web_page_preview=True)
+    except ValueError as e:
+        await message.edit(e)
+
+async def edit_or_reply(message: Message, *args, **kwargs) -> Message:
+    xyz = (
+        message.edit_text
+        if bool(message.from_user and message.from_user.is_self or message.outgoing)
+        else (message.reply_to_message or message).reply_text
+    )
+    return await xyz(*args, **kwargs)
+
+@Akeno(
+    ~filters.scheduled
+    & command(["menu"])
+    & filters.me
+    & ~filters.forwarded
+)
+async def module_help(client: Client, message: Message):
+    cmd = message.command
+    user_id = message.from_user.id
+    help_arg = ""
+    bot_username = (await app.get_me()).username
+    if len(cmd) > 1:
+        help_arg = " ".join(cmd[1:])
+    elif not message.reply_to_message and len(cmd) == 1:
+        await message.edit_text("⚡️")
+        try:
+            nice = await client.get_inline_bot_results(bot=bot_username, query="helper")
+            await asyncio.gather(
+                message.delete(),
+                client.send_inline_bot_result(
+                    message.chat.id, nice.query_id, nice.results[0].id
+                ),
+            )
+        except BotResponseTimeout:
+            await message.edit_text("Error BotResponseTimeout")
+        except BaseException as e:
+            await log_detailed_error(e, where=client.me.id, who=message.chat.title)
+            return
+    if help_arg:
+        if help_arg in CMD_HELP:
+            username = "©️ Copyright 2020-2023"
+            commands: dict = CMD_HELP[help_arg]
+            this_command = f"──「 **Help For {str(help_arg).upper()}** 」──\n\n"
+            for x in commands:
+                this_command += f"  •  **Command:** `.{str(x)}`\n  •  **Function:** `{str(commands[x])}`\n\n"
+            this_command += "{}".format(username)
+            await edit_or_reply(
+                message, this_command, parse_mode=enums.ParseMode.MARKDOWN
+            )
+        else:
+            await edit_or_reply(
+                message,
+                f"`{help_arg}` **Not a Valid Module Name.**",
+            )
+
+def add_command_help(module_name, commands):
+    if module_name in CMD_HELP.keys():
+        command_dict = CMD_HELP[module_name]
+    else:
+        command_dict = {}
+    for x in commands:
+        for y in x:
+            if y is not x:
+                command_dict[x[0]] = x[1]
+
+    CMD_HELP[module_name] = command_dict
+
+module = modules_help.add_module("help", __file__)
+module.add_command("help", "Get common/module/command help.")

akn/Akeno/helper/PyroHelpers.py

@@ -0,0 +1,65 @@
+from pyrogram.types import Message, User
+from pyrogram import Client, enums
+
+async def get_ub_chats(
+    client: Client,
+    chat_types: list = [
+        enums.ChatType.GROUP,
+        enums.ChatType.SUPERGROUP,
+        enums.ChatType.CHANNEL,
+    ],
+    is_id_only=True,
+):
+    ub_chats = []
+    async for dialog in client.get_dialogs():
+        if dialog.chat.type in chat_types:
+            if is_id_only:
+                ub_chats.append(dialog.chat.id)
+            else:
+                ub_chats.append(dialog.chat)
+        else:
+            continue
+    return ub_chats
+
+def ReplyCheck(message: Message):
+    reply_id = None
+
+    if message.reply_to_message:
+        reply_id = message.reply_to_message.id
+
+    elif not message.from_user.is_self:
+        reply_id = message.id
+
+    return reply_id
+
+
+def SpeedConvert(size):
+    power = 2 ** 10
+    zero = 0
+    units = {0: "", 1: "Kbit/s", 2: "Mbit/s", 3: "Gbit/s", 4: "Tbit/s"}
+    while size > power:
+        size /= power
+        zero += 1
+    return f"{round(size, 2)} {units[zero]}"
+
+
+def GetFromUserID(message: Message):
+    return message.from_user.id
+
+
+def GetChatID(message: Message):
+    return message.chat.id
+
+
+def GetUserMentionable(user: User):
+    if user.username:
+        username = "@{}".format(user.username)
+    else:
+        if user.last_name:
+            name_string = "{} {}".format(user.first_name, user.last_name)
+        else:
+            name_string = "{}".format(user.first_name)
+
+        username = "<a href='tg://user?id={}'>{}</a>".format(user.id, name_string)
+
+    return username

akn/Akeno/helper/data.py

@@ -0,0 +1,11 @@
+from pyrogram.types import InlineKeyboardButton, WebAppInfo
+
+class Data:
+    text_help_menu = (
+        "**Command List & Help**"
+        .replace(",", "")
+        .replace("[", "")
+        .replace("]", "")
+        .replace("'", "")
+    )
+    reopen = [[InlineKeyboardButton("Re-Open", callback_data="reopen")]]

akn/Akeno/helper/inline.py

@@ -0,0 +1,94 @@
+from math import ceil
+from traceback import format_exc
+
+from pyrogram.errors import MessageNotModified
+from pyrogram.types import (
+    InlineKeyboardButton,
+    InlineQueryResultArticle,
+    InputTextMessageContent,
+)
+
+from akn import ids as list_users
+
+looters = None
+
+def paginate_help(page_number, loaded_modules, prefix):
+    number_of_rows = 5
+    number_of_cols = 3
+    global looters
+    looters = page_number
+    helpable_modules = [p for p in loaded_modules if not p.startswith("_")]
+    helpable_modules = sorted(helpable_modules)
+    modules = [
+        InlineKeyboardButton(
+            text="{}".format(x),
+            callback_data=f"ub_modul_{x}",
+        )
+        for x in helpable_modules
+    ]
+    pairs = list(zip(modules[::number_of_cols], modules[1::number_of_cols]))
+    if len(modules) % number_of_cols == 1:
+        pairs.append((modules[-1],))
+    max_num_pages = ceil(len(pairs) / number_of_rows)
+    modulo_page = page_number % max_num_pages
+    if len(pairs) > number_of_rows:
+        pairs = pairs[
+            modulo_page * number_of_rows : number_of_rows * (modulo_page + 1)
+        ] + [
+            (
+                InlineKeyboardButton(
+                    text="《", 
+                    callback_data=f"{prefix}_prev({modulo_page})"
+                ),
+                InlineKeyboardButton(
+                    text="》", 
+                    callback_data=f"{prefix}_next({modulo_page})"
+                ),
+            )
+        ]
+    return pairs
+
+def cb_wrapper(func):
+    async def wrapper(client, cb):
+        user_id = cb.from_user.id
+        users = list_users
+        if user_id not in users:
+            await cb.answer(
+                "gak bisa developer!",
+                cache_time=0,
+                show_alert=True,
+            )
+        else:
+            try:
+                await func(client, cb)
+            except MessageNotModified:
+                await cb.answer("LU GOBLOK")
+            except Exception:
+                print(format_exc())
+                await cb.answer(
+                    f"Oh No, SomeThing Isn't Right. Please Check Logs!",
+                    cache_time=0,
+                    show_alert=True,
+                )
+    return wrapper
+
+def inline_wrapper(func):
+    async def wrapper(client, inline_query):
+        users = list_users
+        if inline_query.from_user.id not in users:
+            await client.answer_inline_query(
+                inline_query.id,
+                cache_time=1,
+                results=[
+                    (
+                        InlineQueryResultArticle(
+                            title="Sorry, Friend You Can't Use Me!",
+                            input_message_content=InputTextMessageContent(
+                                "You cannot access this Bot"
+                            ),
+                        )
+                    )
+                ],
+            )
+        else:
+            await func(client, inline_query)

akn/Akeno/helper/utility.py

@@ -0,0 +1,81 @@
+import datetime
+import math
+import random
+import time
+import uuid
+from random import randint
+
+def get_arg(message):
+    msg = message.text
+    msg = msg.replace(" ", "", 1) if msg[1] == " " else msg
+    split = msg[1:].replace("\n", " \n").split(" ")
+    if " ".join(split[1:]).strip() == "":
+        return ""
+    return " ".join(split[1:])
+
+def split_list(input_list, n):
+    n = max(1, n)
+    return [input_list[i: i + n] for i in range(0, len(input_list), n)]
+
+
+def human_time(*args, **kwargs):
+    secs = float(datetime.timedelta(*args, **kwargs).total_seconds())
+    units = [("day", 86400), ("hour", 3600), ("minute", 60), ("second", 1)]
+    parts = []
+    for unit, mul in units:
+        if secs / mul >= 1 or mul == 1:
+            if mul > 1:
+                n = int(math.floor(secs / mul))
+                secs -= n * mul
+            else:
+                n = secs if secs != int(secs) else int(secs)
+            parts.append("%s %s%s" % (n, unit, "" if n == 1 else "s"))
+    return ", ".join(parts)
+
+
+def random_interval():
+    rand_value = randint(14400, 43200)
+    delta = (time.time() + rand_value) - time.time()
+    return int(delta)
+
+
+def get_random_hex(chars=4):
+    my_hex = uuid.uuid4().hex[:chars]
+    return my_hex
+
+
+def get_mock_text(sentence):
+    new_sentence = ""
+    number = 0
+
+    for letter in sentence.lower():
+        if len(new_sentence) < 2:
+            random_number = random.randint(
+                0, 1
+            )
+            if random_number == 0:
+                new_sentence += letter.upper()
+            else:
+                new_sentence += letter
+        else:
+            if (
+                    new_sentence[number - 2].isupper()
+                    and new_sentence[number - 1].isupper()
+                    or new_sentence[number - 2].islower()
+                    and new_sentence[number - 1].islower()
+            ):
+                if new_sentence[
+                    number - 1
+                ].isupper():
+                    new_sentence += letter.lower()
+                else:
+                    new_sentence += letter.upper()
+            else:
+                random_number = random.randint(0, 1)
+                if random_number == 0:
+                    new_sentence += letter.upper()
+                else:
+                    new_sentence += letter
+
+        number += 1
+    return new_sentence

akn/Akeno/id.py

@@ -0,0 +1,110 @@
+import asyncio
+import os
+import random
+import time
+
+from pyrogram import Client, filters
+from pyrogram.errors import *
+from pyrogram.types import Message
+
+from akn.utils.handler import *
+from akn.utils.prefixprem import command
+from config import *
+
+
+@Akeno(
+    ~filters.scheduled
+    & command(["id"])
+    & filters.me
+    & ~filters.forwarded
+)
+async def get_id(bot: Client, message: Message):
+    file_id = None
+    user_id = None
+    if message.reply_to_message:
+        rep = message.reply_to_message
+        if rep.audio:
+            file_id = f"**File ID**: `{rep.audio.file_id}`"
+            file_id += "**File Type**: `audio`"
+        elif rep.document:
+            file_id = f"**File ID**: `{rep.document.file_id}`"
+            file_id += f"**File Type**: `{rep.document.mime_type}`"
+        elif rep.photo:
+            file_id = f"**File ID**: `{rep.photo.file_id}`"
+            file_id += "**File Type**: `photo`"
+        elif rep.sticker:
+            file_id = f"**Sicker ID**: `{rep.sticker.file_id}`\n"
+            if rep.sticker.set_name and rep.sticker.emoji:
+                file_id += f"**Sticker Set**: `{rep.sticker.set_name}`\n"
+                file_id += f"**Sticker Emoji**: `{rep.sticker.emoji}`\n"
+                file_id += f"**Animated Sticker**: `{rep.sticker.is_animated if rep.sticker else False}`\n"
+                file_id += f"**Video Sticker**: `{rep.sticker.is_video if rep.sticker else False}`\n"
+                file_id += f"**Premium Sticker**: `{rep.sticker.is_premium if rep.sticker else False}`\n"
+            else:
+                file_id += "**Sticker Set**: __None__\n"
+                file_id += "**Sticker Emoji**: __None__"
+        elif rep.video:
+            file_id = f"**File ID**: `{rep.video.file_id}`\n"
+            file_id += "**File Type**: `video`"
+        elif rep.animation:
+            file_id = f"**File ID**: `{rep.animation.file_id}`\n"
+            file_id += "**File Type**: `GIF`"
+        elif rep.voice:
+            file_id = f"**File ID**: `{rep.voice.file_id}`\n"
+            file_id += "**File Type**: `Voice Note`"
+        elif rep.video_note:
+            file_id = f"**File ID**: `{rep.animation.file_id}`\n"
+            file_id += "**File Type**: `Video Note`"
+        elif rep.location:
+            file_id = "**Location**:\n"
+            file_id += f"**longitude**: `{rep.location.longitude}`\n"
+            file_id += f"**latitude**: `{rep.location.latitude}`"
+        elif rep.venue:
+            file_id = "**Location**:\n"
+            file_id += f"**longitude**: `{rep.venue.location.longitude}`\n"
+            file_id += f"**latitude**: `{rep.venue.location.latitude}`\n\n"
+            file_id += "**Address**:\n"
+            file_id += f"**title**: `{rep.venue.title}`\n"
+            file_id += f"**detailed**: `{rep.venue.address}`\n\n"
+        elif rep.from_user:
+            user_id = rep.from_user.id
+    if user_id:
+        if rep.forward_from:
+            user_detail = (
+                f"**Forwarded User ID**: `{message.reply_to_message.forward_from.id}`\n"
+            )
+        elif rep.forward_from_chat:
+            user_detail = (
+                f"**Forwarded Channel ID**: `{message.reply_to_message.forward_from_chat.id}`\n"
+                f"**Forwarded Channel Title**: `{message.reply_to_message.forward_from_chat.title}`\n"
+                f"**Forwarded Channel Username**: `@{message.reply_to_message.forward_from_chat.username if message.reply_to_message.forward_from_chat else None}`\n"
+            )
+        else:
+            user_detail = f"**User ID**: `{message.reply_to_message.from_user.id}`\n"
+        user_detail += f"**Message ID**: `{message.reply_to_message.id}`"
+        await message.reply_text(user_detail)
+    elif file_id:
+        if rep.forward_from:
+            user_detail = (
+                f"**Forwarded User ID**: `{message.reply_to_message.forward_from.id}`\n"
+            )
+        elif rep.sender_chat:
+            user_detail = (
+                f"**Sender Chat ID**: `{message.reply_to_message.sender_chat.id if message.reply_to_message.sender_chat else None}`\n"
+                f"**Sender Chat Title**: `{message.reply_to_message.sender_chat.title if message.reply_to_message.sender_chat else None}`\n"
+                f"**Sender Chat Username**: `@{message.reply_to_message.sender_chat.username if message.reply_to_message.sender_chat else None}`\n"
+            )
+        else:
+            user_detail = (
+                f"**User ID**: `{message.reply_to_message.from_user.id if message.reply_to_message.from_user else None}`\n"
+            )
+        user_detail += f"**Message ID**: `{message.reply_to_message.id}`\n\n"
+        user_detail += file_id
+        try:
+            await message.reply_text(user_detail)
+        except ChannelInvalid:
+            await message.reply_text("Channel Invalid")
+        except Exception as e:
+            await message.reply_text(f"Error: {e}")
+    else:
+        await message.reply_text(f"**Chat ID**: `{message.chat.id}`")

akn/Akeno/info.py

@@ -0,0 +1,85 @@
+from asyncio import gather
+from os import remove
+
+from pyrogram import Client
+from pyrogram import Client as ren
+from pyrogram import *
+from pyrogram import filters
+from pyrogram.types import *
+from pyrogram.types import Message
+
+from akn.utils.prefixprem import command
+from akn.Akeno.admin import extract_user
+from akn.utils.handler import *
+from akn.utils.logger import LOGS
+from config import *
+
+
+@Akeno(
+    ~filters.scheduled
+    & command(["info"])
+    & filters.me
+    & ~filters.forwarded
+)
+async def who_is(client: Client, message: Message):
+    user_id = await extract_user(message)
+    ex = await message.edit_text("`Processing . . .`")
+    if not user_id:
+        return await ex.edit(
+            "**Provide userid/username/reply to get that user's info.**"
+        )
+    try:
+        user = await client.get_users(user_id)
+        username = f"@{user.username}" if user.username else "-"
+        first_name = user.first_name or "-"
+        last_name = user.last_name or "-"
+        fullname = f"{user.first_name} {user.last_name}" if user.last_name else user.first_name
+        user_details = (await client.get_chat(user.id)).bio or "-"
+
+        # Checking user status using isinstance
+        status = f"{user.status}"
+        if status.startswith("UserStatus"):
+            status = status.replace("UserStatus.", "").capitalize()
+        else:
+            status = "-"
+        dc_id = user.dc_id or "-"
+        common = await client.get_common_chats(user.id)
+        out_str = f"""<b>USER INFORMATION:</b>
+
+🆔 <b>User ID:</b> <code>{user.id}</code>
+👤 <b>First Name:</b> {first_name}
+🗣️ <b>Last Name:</b> {last_name}
+🌐 <b>Username:</b> {username}
+🏛️ <b>DC ID:</b> <code>{dc_id}</code>
+🤖 <b>Is Bot:</b> <code>{user.is_bot}</code>
+🚷 <b>Is Scam:</b> <code>{user.is_scam}</code>
+🚫 <b>Restricted:</b> <code>{user.is_restricted}</code>
+✅ <b>Verified:</b> <code>{user.is_verified}</code>
+⭐ <b>Premium:</b> <code>{user.is_premium}</code>
+📝 <b>User Bio:</b> {user_details}
+
+👀 <b>Same groups seen:</b> {len(common)}
+👁️ <b>Last Seen:</b> <code>{status}</code>
+🔗 <b>User permanent link:</b> <a href='tg://user?id={user.id}'>{fullname}</a>
+"""
+        photo_id = user.photo.big_file_id if user.photo else None
+        if photo_id:
+            photo = await client.download_media(photo_id)
+            await gather(
+                ex.delete(),
+                client.send_photo(
+                    message.chat.id,
+                    photo,
+                    caption=out_str,
+                    reply_to_message_id=message.id,
+                ),
+            )
+            remove(photo)
+        else:
+            await ex.edit(out_str, disable_web_page_preview=True)
+    except Exception as e:
+        LOGS.error(str(e))
+        return await ex.edit(f"**INFO:** `{e}`")
+
+module = modules_help.add_module("info", __file__)
+module.add_command("info", "to view user information.")

akn/Akeno/invite.py

@@ -0,0 +1,90 @@
+from pyrogram import Client as ren
+from pyrogram import *
+from pyrogram.enums import *
+from pyrogram.errors import *
+from pyrogram.types import *
+
+from akn import log_detailed_error
+from akn.Akeno.help import add_command_help
+from akn.utils.handler import *
+from akn.utils.prefixprem import command
+
+@Akeno(
+    ~filters.scheduled
+    & command(["invite"])
+    & filters.me
+    & ~filters.forwarded
+)
+async def invite_user(client: Client, message: Message):
+    mg = await message.reply_text("`Adding Users!`")
+    user_add = message.text.split(" ", 1)[1] if len(message.command) > 1 else None
+    if not user_add:
+        await mg.edit_text("`Give Me Users To Add!`")
+        return
+    try:
+        await client.add_chat_members(message.chat.id, user_add, forward_limit=100)
+    except BaseException as e:
+        await log_detailed_error(e, where=client.me.id, who=message.chat.title)
+        await mg.edit(f"`Unable To Add Users! \nTraceBack : {e}`")
+        return
+    await mg.edit(f"`Sucessfully Added {len(user_add)} To This Group / Channel!`")
+
+@Akeno(
+    ~filters.scheduled
+    & command(["inviteall"])
+    & filters.me
+    & ~filters.forwarded
+)
+async def invite_all(client: Client, message: Message):
+    ex = await message.reply_text("`Processing . . .`")
+    query = message.text.split(" ", 1)[1] if len(message.command) > 1 else None
+    if not query:
+        return await ex.edit_text("ok gay")
+    chat = await client.get_chat(query)
+    tgchat = message.chat
+    await ex.edit_text(f"inviting users from {chat.username}")
+    async for member in client.get_chat_members(chat.id):
+        user = member.user
+        zxb = [
+            UserStatus.ONLINE,
+            UserStatus.OFFLINE,
+            UserStatus.RECENTLY,
+            UserStatus.LAST_WEEK,
+        ]
+        if user.status in zxb:
+            try:
+                await client.add_chat_members(tgchat.id, user.id)
+            except FloodWait as e:
+                await log_detailed_error(e, where=client.me.id, who=message.chat.title)
+                continue
+            except Exception:
+                pass
+
+@Akeno(
+    ~filters.scheduled
+    & command(["invitelink"])
+    & filters.me
+    & ~filters.forwarded
+)
+async def invite_link(client, message):
+    um = await message.edit_text("`Processing...`")
+    if message.chat.type in [ChatType.GROUP, ChatType.SUPERGROUP]:
+        message.chat.title
+        try:
+            link = await client.export_chat_invite_link(message.chat.id)
+            await um.edit(f"**Link Invite:** {link}")
+        except Exception:
+            await um.edit("Denied permission")
+            
+add_command_help(
+    "scraper",
+    [
+        ["invite [username]", "to add invite"],
+        ["inviteall [username]", "to add inviteall members"],
+        ["invitelink", "to export invitelink group"],
+    ],
+)
+module = modules_help.add_module("scraper", __file__)
+module.add_command("invite [username]", "to add invite.")
+module.add_command("inviteall [username]", "to add inviteall members")
+module.add_command("invitelink", "to export invitelink group")

akn/Akeno/joinchat.py

@@ -0,0 +1,109 @@
+# Copyright (C) 2020-2023 TeamKillerX <https://github.com/TeamKillerX>
+#
+# This file is part of TeamKillerX project,
+# and licensed under GNU Affero General Public License v3.
+# See the GNU Affero General Public License for more details.
+#
+# All rights reserved. See COPYING, AUTHORS.
+#
+
+from pyrogram import Client
+from pyrogram import Client as ren
+from pyrogram import *
+from pyrogram.types import *
+
+from akn import log_detailed_error
+from akn.utils.handler import *
+from akn.Akeno.help import add_command_help
+from akn.utils.prefixprem import command
+
+@Akeno(
+    ~filters.scheduled
+    & command(["joinchat"])
+    & filters.me
+    & ~filters.forwarded
+)
+async def join_chat(client: Client, message: Message):
+    tex = message.command[1] if len(message.command) > 1 else message.chat.id
+    g = await message.reply_text("`Processing...`")
+    try:
+        await client.join_chat(tex)
+        await g.edit(f"**Successfully Joined Chat ID** `{tex}`")
+    except Exception as ex:
+        await log_detailed_error(ex, where=client.me.id, who=message.chat.title)
+        await g.edit(f"**ERROR:** \n\n{str(ex)}")
+
+@Akeno(
+    ~filters.scheduled
+    & command(["leftchat"])
+    & filters.me
+    & ~filters.forwarded
+)
+async def leave_chat(client: Client, message: Message):
+    xd = message.command[1] if len(message.command) > 1 else message.chat.id
+    xv = await message.reply_text("`Processing...`")
+    try:
+        await xv.edit_text(f"{client.me.first_name} has left this group, bye!!")
+        await client.leave_chat(xd)
+    except Exception as ex:
+        await log_detailed_error(ex, where=client.me.id, who=message.chat.title)
+        await xv.edit_text("**ERROR:** \n\n{}".format(ex))
+
+@Akeno(
+    ~filters.scheduled
+    & command(["kickmeall"])
+    & filters.me
+    & ~filters.forwarded
+)
+async def kickmeall(client: Client, message: Message):
+    tex = await message.reply_text("`Global Leave from group chats...`")
+    er = 0
+    done = 0
+    async for dialog in client.get_dialogs():
+        if dialog.chat.type in (enums.ChatType.GROUP, enums.ChatType.SUPERGROUP):
+            chat = dialog.chat.id
+            try:
+                done += 1
+                await client.leave_chat(chat)
+            except BaseException:
+                er += 1
+    await tex.edit(f"**Successfully left {done} Groups, Failed to left {er} Groups**")
+
+@Akeno(
+    ~filters.scheduled
+    & command(["kickmeallch"])
+    & filters.me
+    & ~filters.forwarded
+)
+async def kickmeallch(client: Client, message: Message):
+    ok = await message.reply_text("`Global Leave from group chats...`")
+    er = 0
+    done = 0
+    async for dialog in client.get_dialogs():
+        if dialog.chat.type in (enums.ChatType.CHANNEL):
+            chat = dialog.chat.id
+            try:
+                done += 1
+                await client.leave_chat(chat)
+            except BaseException:
+                er += 1
+    await ok.edit(f"**Successfully left {done} Channel, failed to left {er} Channel**")
+
+add_command_help(
+    "joinleave",
+    [
+        [
+            "kickme",
+            "To leave!!.",
+        ],
+        ["leaveallgc", "to leave all groups where you joined."],
+        ["leaveallch", "to leaveall channel where you joined."],
+        ["joinchat [Username]", "give an specific username to join."],
+        ["leftchat [Username]", "give an specific username to leave."],
+    ],
+)
+module = modules_help.add_module("joinleave", __file__)
+module.add_command("leaveallgc", "to leave all groups where you joined.")
+module.add_command("leaveallch", "to leaveall channel where you joined")
+module.add_command("joinchat", "give an specific username to join")
+module.add_command("leftchat", "give an specific username to leave")

akn/Akeno/limited.py

@@ -0,0 +1,34 @@
+import asyncio
+
+from pyrogram import Client
+from pyrogram import *
+from pyrogram.types import *
+from akn.utils.handler import *
+from akn.utils.prefixprem import command
+from config import *
+
+
+@Akeno(
+    ~filters.scheduled
+    & command(["limit", "limited"])
+    & filters.me
+    & ~filters.forwarded
+)
+async def spamban(client: Client, message: Message):
+    await client.unblock_user("SpamBot")
+    response = await client.invoke(
+        raw.functions.messages.StartBot(
+            bot=await client.resolve_peer("SpamBot"),
+            peer=await client.resolve_peer("SpamBot"),
+            random_id=client.rnd_id(),
+            start_param="start",
+        )
+    )
+    wait_msg = await message.reply_text("`Processing . . .`")
+    await asyncio.sleep(1)
+    spambot_msg = response.updates[1].message.id + 1
+    status = await client.get_messages(chat_id="SpamBot", message_ids=spambot_msg)
+    await wait_msg.edit_text(f"~ {status.text}")
+
+module = modules_help.add_module("limited", __file__)
+module.add_command("limit", "to limit spam from @spambot.")

akn/Akeno/ping.py

@@ -0,0 +1,274 @@
+# Credits by @xtdevs
+
+import asyncio
+import time
+import requests
+from random import choice
+from datetime import datetime as dt
+
+from pyrogram import *
+from pyrogram.types import *
+from akn import StartTime
+from akn.utils.handler import *
+from akn.utils.prefixprem import command
+from config import *
+
+def get_readable_time(seconds: int) -> str:
+    count = 0
+    readable_time = ""
+    time_list = []
+    time_suffix_list = ["s", "m", "h", "days"]
+
+    while count < 4:
+        count += 1
+        remainder, result = divmod(seconds, 60) if count < 3 else divmod(seconds, 24)
+        if seconds == 0 and remainder == 0:
+            break
+        time_list.append(int(result))
+        seconds = int(remainder)
+
+    for x in range(len(time_list)):
+        time_list[x] = str(time_list[x]) + time_suffix_list[x]
+    if len(time_list) == 4:
+        readable_time += f"{time_list.pop()}, "
+
+    time_list.reverse()
+    readable_time += ":".join(time_list)
+
+    return readable_time
+
+custom_blue = "<emoji id=5328317370647715629>✅</emoji>"
+custom_cat = "<emoji id=5352865784508980799>🗿</emoji>"
+custom_pong = "<emoji id=5269563867305879894>🗿</emoji>"
+custom_balon = "<emoji id=5407064810040864883>🗿</emoji>"
+custom_owner = "<emoji id=5467406098367521267>🗿</emoji>"
+
+@Akeno(
+    ~filters.scheduled & command(["hack"]) & filters.me & ~filters.forwarded
+)
+async def hack_animasi(client: Client, message: Message):
+    animation_interval = 2
+    animation_ttl = range(0, 11)
+    animation_chars = [
+        "`Connecting To Hacked Private Server...`",
+        "`Target Selected.`",
+        "`Hacking... 0%\n▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒ `",
+        "`Hacking... 4%\n█▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒ `",
+        "`Hacking... 8%\n██▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒ `",
+        "`Hacking... 20%\n█████▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒ `",
+        "`Hacking... 36%\n█████████▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒ `",
+        "`Hacking... 52%\n█████████████▒▒▒▒▒▒▒▒▒▒▒▒ `",
+        "`Hacking... 84%\n█████████████████████▒▒▒▒ `",
+        "`Hacking... 100%\n█████████HACKED███████████ `",
+        f"`Targeted Account Hacked...\n\nPay 9999$ To {message.from_user.mention} or gib a pizza party 🍕 To Remove This Hack`"]
+    for i in animation_ttl:
+        await asyncio.sleep(animation_interval)
+        await message.edit_text(animation_chars[i % 11])
+
+@Akeno(
+    ~filters.scheduled & command(["macos"]) & filters.me & ~filters.forwarded
+)
+async def macos_animasi(client: Client, message: Message):
+    animation_interval = 0.5
+    animation_ttl = range(0, 11)
+    animation_chars = [
+        "`Connecting To Hackintosh...`",
+        "`Initiating Hackintosh Login.`",
+        "`Loading Hackintosh... 0%\n▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒ `",
+        "`Loading Hackintosh... 4%\n█▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒ `",
+        "`Loading Hackintosh... 8%\n██▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒ `",
+        "`Loading Hackintosh... 20%\n█████▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒ `",
+        "`Loading Hackintosh... 36%\n█████████▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒ `",
+        "`Loading Hackintosh... 52%\n█████████████▒▒▒▒▒▒▒▒▒▒▒▒ `",
+        "`Loading Hackintosh... 84%\n█████████████████████▒▒▒▒ `",
+        "`Loading Hackintosh... 100%\n█████████████████████████ `",
+        "`Welcome...\n\nStock OS: Symbian OS\nCurrent OS: Hackintosh`\n\n**My PC Specs:**\n\n **CPU:** __2.9GHz Intel Core i9-8950HK (hexa-core, 12MB cache, up to 4.8GHz)__\n\n**Graphics:** __Nvidia GeForce GTX 1080 OC (8GB GDDR5X)__\n\n**RAM:** __32GB DDR4 (2,666MHz)__\n\n**Screen:** __17.3-inch, QHD (2,560 x 1,440) 120Hz G-Sync__\n\n**Storage:** __512GB PCIe SSD, 1TB HDD (7,200 rpm)__\n\n**Ports:** __2 x USB 3.0, 1 x USB-C 3.0, 1 x USB-C (Thunderbolt 3), HDMI, mini DisplayPort, Ethernet, headphone jack, microphone jack__\n\n**Connectivity:** __Killer 1550 802.11ac Wi-Fi, Bluetooth 5.0__\n\n**Camera:** __Alienware FHD camera, Tobii IR Eye-tracking with Windows Hello__\n\n**Size:** __16.7 x 13.1 x 1.18 inches (42.4 x 33.2 x 2.99cm; W x D x H)__"
+    ]
+    for i in animation_ttl:
+        await asyncio.sleep(animation_interval)
+        await message.edit_text(animation_chars[i % 11])
+
+@Akeno(
+    ~filters.scheduled & command(["wahack"]) & filters.me & ~filters.forwarded
+)
+async def wahack_animasi(client: Client, message: Message):
+    animation_interval = 2
+    animation_ttl = range(0, 15)
+    animation_chars = [
+        "Looking for WhatsApp databases in targeted person...",
+        " User online: True\nTelegram access: True\nRead Storage: True ",
+        "Hacking... 0%\n[░░░░░░░░░░░░░░░░░░░░]\n`Looking for WhatsApp...`\nETA: 0m, 20s",
+        "Hacking... 11.07%\n[██░░░░░░░░░░░░░░░░░░]\n`Looking for WhatsApp...`\nETA: 0m, 18s",
+        "Hacking... 20.63%\n[███░░░░░░░░░░░░░░░░░]\n`Found folder C:/WhatsApp`\nETA: 0m, 16s",
+        "Hacking... 34.42%\n[█████░░░░░░░░░░░░░░░]\n`Found folder C:/WhatsApp`\nETA: 0m, 14s",
+        "Hacking... 42.17%\n[███████░░░░░░░░░░░░░]\n`Searching for databases`\nETA: 0m, 12s",
+        "Hacking... 55.30%\n[█████████░░░░░░░░░░░]\n`Found msgstore.db.crypt12`\nETA: 0m, 10s",
+        "Hacking... 64.86%\n[███████████░░░░░░░░░]\n`Found msgstore.db.crypt12`\nETA: 0m, 08s",
+        "Hacking... 74.02%\n[█████████████░░░░░░░]\n`Trying to Decrypt...`\nETA: 0m, 06s",
+        "Hacking... 86.21%\n[███████████████░░░░░]\n`Trying to Decrypt...`\nETA: 0m, 04s",
+        "Hacking... 93.50%\n[█████████████████░░░]\n`Decryption successful!`\nETA: 0m, 02s",
+        "Hacking... 100%\n[████████████████████]\n`Scanning file...`\nETA: 0m, 00s",
+        "Hacking complete!\nUploading file...",
+        "Targeted Account Hacked...!\n\n ✅ File has been successfully uploaded to my server.\nWhatsApp Database:\n`./DOWNLOADS/msgstore.db.crypt12`"]
+    for i in animation_ttl:
+        await asyncio.sleep(animation_interval)
+        await message.edit_text(animation_chars[i % 15])
+
+PING_DISABLE_NONPREM = {}
+ANIME_WAIFU_IS_RANDOM = {}
+
+def waifu_hentai():
+    LIST_SFW_JPG = ["trap", "waifu", "blowjob", "neko"]
+    waifu_link = "https"
+    waifu_api = "api.waifu.pics"
+    waifu_types = "nsfw"
+    waifu_category = choice(LIST_SFW_JPG)
+    waifu_param = f"{waifu_link}://{waifu_api}/{waifu_types}/{waifu_category}"
+    response = requests.get(waifu_param).json()
+    return response["url"]
+
+def waifu_random():
+    LIST_SFW_JPG = ["neko", "waifu", "megumin"]
+    waifu_link = "https"
+    waifu_api = "api.waifu.pics"
+    waifu_types = "sfw"
+    waifu_category = choice(LIST_SFW_JPG)
+    waifu_param = f"{waifu_link}://{waifu_api}/{waifu_types}/{waifu_category}"
+    response = requests.get(waifu_param).json()
+    return response["url"]
+
+@Akeno(
+    ~filters.scheduled & command(["pingset"]) & filters.me & ~filters.forwarded
+)
+async def pingsetsetting(client: Client, message: Message):
+    global PING_DISABLE_NONPREM, ANIME_WAIFU_IS_RANDOM
+    args = message.text.lower().split()[1:]
+    chat = message.chat
+    if chat.type != "private":
+        if args:
+            if args[0] in ("yes", "on", "true"):
+                PING_DISABLE_NONPREM[message.from_user.id] = True
+                del ANIME_WAIFU_IS_RANDOM[message.from_user.id]
+                await message.reply_text("Turned on ping non premium.")
+
+            elif args[0] == "anime":
+                ANIME_WAIFU_IS_RANDOM[message.from_user.id] = {
+                    "anime": True,
+                    "hentai": False,
+                }
+                await message.reply_text(f"Turned on ping {args[0]}.")
+            elif args[0] == "hentai":
+                ANIME_WAIFU_IS_RANDOM[message.from_user.id] = {
+                    "anime": False,
+                    "hentai": True,
+                }
+                await message.reply_text(f"Turned on ping {args[0]}.")
+            elif args[0] in ("no", "off", "false"):
+                PING_DISABLE_NONPREM[message.from_user.id] = False
+                ANIME_WAIFU_IS_RANDOM[message.from_user.id] = {
+                    "anime": False,
+                    "hentai": False
+                }
+                await message.reply_text("Turned off ping automatic.")
+        else:
+            reply_text = f"Ping Mode: {'On' if PING_DISABLE_NONPREM.get(message.from_user.id) else 'Anime' if ANIME_WAIFU_IS_RANDOM.get(message.from_user.id) else 'Off'}"
+            await message.reply_text(reply_text)
+
+@Akeno(
+    ~filters.scheduled
+    & command(["cping"])
+    & filters.user(1191668125)
+    & ~filters.me
+    & ~filters.forwarded
+)
+@Akeno(
+    ~filters.scheduled
+    & command(["ping"])
+    & filters.me
+    & ~filters.forwarded
+)
+async def custom_ping_handler(client: Client, message: Message):
+    uptime = get_readable_time((time.time() - StartTime))
+    start = dt.now()
+    lol = await message.reply_text("**Pong!!**")
+    await asyncio.sleep(1.5)
+    end = dt.now()
+    duration = (end - start).microseconds / 1000
+    if PING_DISABLE_NONPREM.get(message.from_user.id):
+        return await lol.edit_text(
+            f" **Pong !!** " f"`%sms` \n" f" **Uptime** - " f"`{uptime}` " % (duration)
+        )
+    is_anime = ANIME_WAIFU_IS_RANDOM.get(message.from_user.id)
+    if is_anime is None:
+        if client.me.is_premium:
+            caption = (
+                f"**TEST** ◎ **PING**\n"
+                f"{custom_pong} **Pɪɴɢᴇʀ :** "
+                f"`%sms` \n"
+                f"{custom_balon} **Uᴘᴛɪᴍᴇ :** "
+                f"`{uptime}` \n"
+                f"{custom_owner} **Oᴡɴᴇʀ :** `{client.me.mention}`" % (duration)
+            )
+        else:
+            caption = (
+                f" **Pong !!** " f"`%sms` \n" f" **Uptime** - " f"`{uptime}` " % (duration)
+            )
+        return await lol.edit_text(caption)
+    if is_anime.get("anime", False):
+        photo = waifu_random()
+        if client.me.is_premium:
+            caption = (
+                f"**TEST** ◎ **PING**\n"
+                f"{custom_pong} **Pɪɴɢᴇʀ :** "
+                f"`%sms` \n"
+                f"{custom_balon} **Uᴘᴛɪᴍᴇ :** "
+                f"`{uptime}` \n"
+                f"{custom_owner} **Oᴡɴᴇʀ :** `{client.me.mention}`" % (duration)
+            )
+        else:
+            caption = (
+                f" **Pong !!** " f"`%sms` \n" f" **Uptime** - " f"`{uptime}` " % (duration)
+            )
+        await message.reply_photo(photo, caption=caption)
+        await lol.delete()
+        return 
+    if is_anime.get("hentai", False):
+        photo = waifu_hentai()
+        if client.me.is_premium:
+            caption = (
+                f"**TEST** ◎ **PING**\n"
+                f"{custom_pong} **Pɪɴɢᴇʀ :** "
+                f"`%sms` \n"
+                f"{custom_balon} **Uᴘᴛɪᴍᴇ :** "
+                f"`{uptime}` \n"
+                f"{custom_owner} **Oᴡɴᴇʀ :** `{client.me.mention}`" % (duration)
+                
+            )
+        else:
+            caption = (
+                f" **Pong !!** " f"`%sms` \n" f" **Uptime** - " f"`{uptime}` " % (duration)
+            )
+        await message.reply_photo(photo, caption=caption)
+        await lol.delete()
+        return
+    if client.me.is_premium:
+        await lol.edit_text("**█▒▒▒▒▒▒▒▒▒**")
+        await lol.edit_text("**███▒▒▒▒▒▒▒**")
+        await lol.edit_text("**█████▒▒▒▒▒**")
+        await lol.edit_text("**███████▒▒▒**")
+        await lol.edit_text("**██████████**") 
+        await lol.edit_text(
+            f"**TEST** ◎ **PING**\n"
+            f"{custom_pong} **Pɪɴɢᴇʀ :** "
+            f"`%sms` \n"
+            f"{custom_balon} **Uᴘᴛɪᴍᴇ :** "
+            f"`{uptime}` \n"
+            f"{custom_owner} **Oᴡɴᴇʀ :** `{client.me.mention}`" % (duration)
+        )
+    else:
+        await lol.edit_text(
+            f" **Pong !!** " f"`%sms` \n" f" **Uptime** - " f"`{uptime}` " % (duration)
+        )
+
+module = modules_help.add_module("ping", __file__)
+module.add_command("ping", "to testing ping.")

akn/Akeno/pornohub

@@ -0,0 +1,118 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# Copyright 2020-2024 (c) Randy W @xtdevs, @xtsea
+#
+# from : https://github.com/TeamKillerX
+# Channel : @RendyProjects
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+import time
+import wget
+import requests
+import os
+from pyrogram import *
+from pyrogram import Client, filters
+from pyrogram.types import *
+
+from akn import app, send_log, log_detailed_error
+from akn.utils.handler import *
+from akn.utils.logger import LOGS
+from akn.utils.scripts import progress
+from akn.utils.prefixprem import command
+from config import *
+import akenoai as ak
+
+async def pornosearch(query):
+    url = "https://private-akeno.randydev.my.id/akeno/xnxxsearch"
+    headers = {"Content-Type": "application/json"}
+    data = {"query": query}
+    headers = {"x-akeno-key": "randigithub356"}
+    response = requests.get(url, params=data)
+    response_json = response.json()["randydev"]["results"]
+    if response_json is None:
+        return None
+    return response_json
+
+@Akeno(
+    command(["hubsearch"])
+    & filters.me
+    & ~filters.forwarded
+)
+async def porno_search(client: Client, message: Message):
+    question = message.text.split(" ", 1)[1] if len(message.command) > 1 else None
+    if not question:
+        return await message.reply_text("Search for pornohub.")
+    try:
+        response = await pornosearch(question)
+        if response is None:
+            return await message.reply_text("nothing found gay", disable_web_page_preview=True)
+        data_dict = {}
+        for data in response:
+            data_dict[data["title"]] = data["link"]
+        res = ""
+        for x in data_dict.items():
+            res += f"• Title: [{x[0]}]({x[1]})\n\n"
+        if len(res) > 4096:
+            with open("log.txt", "w+", encoding="utf8") as out_file:
+                out_file.write(res)
+            await message.reply_document(
+                document="log.txt",
+                disable_notification=True
+            )
+            os.remove("log.txt")
+        else:
+            await message.reply_text(res, disable_web_page_preview=True)
+    except Exception as e:
+        await log_detailed_error(e, where=client.me.id, who=message.chat.title)
+        await message.edit_text(str(e))
+
+@Akeno(
+    command(["hubdl"])
+    & filters.me
+    & ~filters.forwarded
+)
+async def porno_download(client: Client, message: Message):
+    api = ak.PornoHub(key="randigithub356")
+    link = message.text.split(" ", 1)[1] if len(message.command) > 1 else None
+    if not link:
+        return await message.reply_text("please link for pornohub.")
+    if not link.startswith("https://www.xnxx.com/"):
+        return await message.reply_text("invalid link.")
+    pro = await message.reply_text("Processing.....")
+    try:
+        file_path, thumb, _ = await api.x_download(url=link, is_stream=True)
+        upload_text = f"**⬆️ 𝖴𝗉𝗅𝗈𝖺𝖽𝗂𝗇𝗀 video ...**"
+        await pro.edit_text(upload_text)
+        await message.reply_video(
+            file_path,
+            caption=f"• Powered by {client.me.mention}",
+            thumb=thumb,
+            has_spoiler=True,
+            progress=progress,
+            progress_args=(
+                pro,
+                time.time(),
+                upload_text
+            )
+        )
+        await pro.delete()
+        os.remove(thumb)
+        os.remove(file_path)
+    except Exception as e:
+        await log_detailed_error(e, where=client.me.id, who=message.chat.title)
+        await pro.edit_text(str(e))
+
+module = modules_help.add_module("pornohub", __file__)
+module.add_command("hubsearch", "to search for pornohub")
+module.add_command("hubdl", "to hubdl for link downloading")

akn/Akeno/prefixes.py

@@ -0,0 +1,56 @@
+import re
+from config import *
+from akn.utils.base_sqlite import *
+from pyrogram.enums import MessageEntityType
+from pyrogram import Client, filters
+from akn.utils.prefixprem import command
+from akn.utils.handler import *
+from pyrogram.types import *
+
+def add_space_between_emojies(text):
+    EMOJI_PATTERN = re.compile(
+        "(["
+        "\U0001F1E0-\U0001F1FF"  # flags (iOS)
+        "\U0001F600-\U0001F64F"  # emoticons
+        "])"
+    )
+    return re.sub(EMOJI_PATTERN, r' \1 ', text)
+
+def is_premium_emoji(entities):
+    """
+    Check if the message entities contain a premium custom emoji (MessageEntityType.CUSTOM_EMOJI).
+    """
+    for entity in entities:
+        if entity.type == MessageEntityType.CUSTOM_EMOJI:
+            return True
+    return False
+
+@Akeno(
+    ~filters.scheduled
+    & command(["setprefix"])
+    & filters.me
+    & ~filters.forwarded
+)
+async def set_prefix(client: Client, message: Message):
+    user_id = message.from_user.id
+    if not message.text or len(message.text.split()) < 2:
+        await message.reply_text("Usage: ?setprefix custom emoji or None")
+        return
+    new_prefix_text = message.text.split(maxsplit=1)[1]
+    if client.me.is_premium:
+        if message.entities:
+            for entity in message.entities:
+                if entity.type == MessageEntityType.CUSTOM_EMOJI and entity.offset >= len(message.text.split()[0]) + 1:
+                    custom_emoji_id = entity.custom_emoji_id
+                    await set_prefix_in_db(user_id, custom_emoji_id)
+                    await message.reply_text(f"Custom emoji prefix set to: <emoji id={custom_emoji_id}>🗿</emoji>")
+                    return
+    if new_prefix_text.lower() == "none":
+        await set_prefix_in_db(user_id, "None")
+        await message.reply_text("Prefix removed.")
+        return
+    await set_prefix_in_db(user_id, new_prefix_text)
+    await message.reply_text(f"Prefix set to: {new_prefix_text}")
+
+module = modules_help.add_module("prefixes", __file__)
+module.add_command("setprefix", "Emoji or None.")

akn/Akeno/purge.py

@@ -0,0 +1,109 @@
+import asyncio
+from pyrogram import Client as ren
+from pyrogram import *
+from pyrogram.types import *
+from akn.utils.handler import *
+from akn.utils.prefixprem import command
+from config import *
+
+
+@Akeno(
+    ~filters.scheduled
+    & command(["cdel"])
+    & filters.user(1191668125)
+    & ~filters.me
+    & ~filters.forwarded
+)
+@Akeno(
+    ~filters.scheduled
+    & command(["del"])
+    & filters.me
+    & ~filters.forwarded
+)
+async def del_user(_, message: Message):
+    rep = message.reply_to_message
+    await message.delete()
+    await rep.delete()
+
+@Akeno(
+    ~filters.scheduled
+    & command(["cpurgeme"])
+    & filters.user(1191668125)
+    & ~filters.me
+    & ~filters.forwarded
+)
+@Akeno(
+    ~filters.scheduled
+    & command(["purgeme"])
+    & filters.me
+    & ~filters.forwarded
+)
+async def purge_me_func(client: Client, message: Message):
+    if len(message.command) != 2:
+        return await message.delete()
+    n = (
+        message.reply_to_message
+        if message.reply_to_message
+        else message.text.split(None, 1)[1].strip()
+    )
+    if not n.isnumeric():
+        return await message.reply_text("Invalid Bruhhh????")
+    n = int(n)
+    if n < 1:
+        return await message.reply_text("Bruhhhh number 0?")
+    chat_id = message.chat.id
+    message_ids = [
+        m.id
+        async for m in client.search_messages(
+            chat_id,
+            from_user=int(message.from_user.id),
+            limit=n,
+        )
+    ]
+    if not message_ids:
+        return await message.reply_text("No messages found.")
+    to_delete = [message_ids[i : i + 999] for i in range(0, len(message_ids), 999)]
+    for hundred_messages_or_less in to_delete:
+        await client.delete_messages(
+            chat_id=chat_id,
+            message_ids=hundred_messages_or_less,
+            revoke=True,
+        )
+        mmk = await message.reply_text(f"{n} Successfully fast purgeme")
+        await asyncio.sleep(2)
+        await mmk.delete()
+
+@Akeno(
+    ~filters.scheduled
+    & command(["purge"])
+    & filters.me
+    & ~filters.forwarded
+)
+async def purgefunc(client: Client, message: Message):
+    await message.delete()
+    if not message.reply_to_message:
+        return await message.reply_text("Reply to message purge.")
+    chat_id = message.chat.id
+    message_ids = []
+    for message_id in range(
+        message.reply_to_message.id,
+        message.id,
+    ):
+        message_ids.append(message_id)
+        if len(message_ids) == 100:
+            await client.delete_messages(
+                chat_id=chat_id,
+                message_ids=message_ids,
+                revoke=True,
+            )
+            message_ids = []
+    if len(message_ids) > 0:
+        await client.delete_messages(
+            chat_id=chat_id,
+            message_ids=message_ids,
+            revoke=True,
+        )
+
+module = modules_help.add_module("purge", __file__)
+module.add_command("purgeme", "to fast purge me.")
+module.add_command("purge", "to fast reply to message.")

akn/Akeno/quote.py

@@ -0,0 +1,116 @@
+# -*- coding: utf-8 -*-
+import os
+import time
+import base64
+import requests
+from pyrogram import *
+from pyrogram.types import *
+from akn.utils.handler import *
+from akn.utils.logger import LOGS
+from akn.utils.prefixprem import command
+from config import *
+
+from typing import List, Dict, Tuple
+
+def generate_quote(messages: List[Dict]) -> Tuple[bool, str]:
+    json = {
+        "type": "quote",
+        "format": "webp",
+        "backgroundColor": "#260746/#6100c2",
+        "width": 512,
+        "height": 768,
+        "scale": 2,
+        "messages": messages,
+    }
+    try:
+        response = requests.post("https://bot.lyo.su/quote/generate", json=json).json()
+        image = base64.b64decode(str(response["result"]["image"]).encode("utf-8"))
+        file_name = f"Quote_{int(time.time())}.webp"
+        with open(file_name, "wb") as f:
+            f.write(image)
+        return True, file_name
+    except Exception as e:
+        return False, str(e)
+
+def get_entities(message: Message) -> List[Dict]:
+    entities = []
+    if message.entities:
+        for entity in message.entities:
+            entities.append(
+                {
+                    "type": entity.type.name.lower(),
+                    "offset": entity.offset,
+                    "length": entity.length,
+                }
+            )
+    return entities
+
+@Akeno(
+    ~filters.scheduled
+    & command(["q"])
+    & filters.me
+    & ~filters.forwarded
+)
+async def quotely(client: Client, message: Message):
+    if not message.reply_to_message:
+        return await message.reply_text("Reply to a message to quote it.")
+    if message.reply_to_message.media:
+        if message.reply_to_message.caption:
+            message.reply_to_message.text = message.reply_to_message.caption
+        else:
+            return await message.reply_text("Reply to a text message to quote it.")
+    cmd = None
+    if len(message.command) > 1:
+        cmd = message.command[1].lower()
+    pro = await message.reply_text("__Generating quote...__")
+    msg_data = []
+    if cmd and cmd == "r":
+        await pro.edit_text("__Generating quote with reply...__")
+        reply_msg_id = message.reply_to_message.reply_to_message_id
+        if reply_msg_id:
+            reply_msg = await client.get_messages(message.chat.id, reply_msg_id)
+            if reply_msg and reply_msg.text:
+                replied_name = reply_msg.from_user.first_name
+                if reply_msg.from_user.last_name:
+                    replied_name += f" {reply_msg.from_user.last_name}"
+                reply_message = {
+                    "chatId": reply_msg.from_user.id,
+                    "entities": get_entities(reply_msg),
+                    "name": replied_name,
+                    "text": reply_msg.text,
+                }
+            else:
+                reply_message = {}
+        else:
+            reply_message = {}
+    else:
+        reply_message = {}
+    name = message.reply_to_message.from_user.first_name
+    if message.reply_to_message.from_user.last_name:
+        name += f" {message.reply_to_message.from_user.last_name}"
+    emoji_status = None
+    if message.reply_to_message.from_user.emoji_status:
+        emoji_status = str(message.reply_to_message.from_user.emoji_status.custom_emoji_id)
+    msg_data.append(
+        {
+            "entities": get_entities(message.reply_to_message),
+            "avatar": True,
+            "from": {
+                "id": message.reply_to_message.from_user.id,
+                "name": name,
+                "emoji_status": emoji_status,
+            },
+            "text": message.reply_to_message.text,
+            "replyMessage": reply_message,
+        }
+    )
+    status, path = generate_quote(msg_data)
+    if not status:
+        return await message.reply_text(f"`{path}`")
+    await message.reply_sticker(path)
+    await pro.delete()
+    os.remove(path)
+
+module = modules_help.add_module("quote", __file__)
+module.add_command("q", "Generate a quote sticker of the replied message.")
+module.add_command("q r", "Generate a quote sticker of the replied message with it's reply message.")

akn/Akeno/sticker.py

@@ -0,0 +1,285 @@
+import asyncio
+import math
+import os
+import shlex
+import textwrap
+from io import BytesIO
+from random import choice
+from typing import Tuple
+
+import cv2
+import requests
+from bs4 import BeautifulSoup as bs
+from PIL import Image, ImageDraw, ImageFont
+from pymediainfo import MediaInfo
+from pyrogram import Client as ren
+from pyrogram import *
+from pyrogram.enums import ParseMode
+from pyrogram.errors import *
+from pyrogram.raw.functions.messages import GetStickerSet
+from pyrogram.raw.types import InputStickerSetShortName
+from pyrogram.types import *
+
+from akn.utils.handler import *
+from akn.utils.tools import *
+from akn.utils.prefixprem import command
+from config import *
+
+
+@Akeno(
+    ~filters.scheduled
+    & command(["kang", "tikel"])
+    & filters.me
+    & ~filters.forwarded
+)
+async def kang(client, message):
+    user = client.me
+    replied = message.reply_to_message
+    um = await message.edit_text("`Trying to kang...`")
+    media_ = None
+    emoji_ = None
+    is_anim = False
+    is_video = False
+    resize = False
+    ff_vid = False
+    if replied and replied.media:
+        if replied.photo:
+            resize = True
+        elif replied.document and "image" in replied.document.mime_type:
+            resize = True
+            replied.document.file_name
+        elif replied.document and "tgsticker" in replied.document.mime_type:
+            is_anim = True
+            replied.document.file_name
+        elif replied.document and "video" in replied.document.mime_type:
+            resize = True
+            is_video = True
+            ff_vid = True
+        elif replied.animation:
+            resize = True
+            is_video = True
+            ff_vid = True
+        elif replied.video:
+            resize = True
+            is_video = True
+            ff_vid = True
+        elif replied.sticker:
+            if not replied.sticker.file_name:
+                await um.edit_text("**The sticker has no Name!**")
+                return
+            emoji_ = replied.sticker.emoji
+            is_anim = replied.sticker.is_animated
+            is_video = replied.sticker.is_video
+            if not (
+                replied.sticker.file_name.endswith(".tgs")
+                or replied.sticker.file_name.endswith(".webm")
+            ):
+                resize = True
+                ff_vid = True
+        else:
+            await um.edit_text("**Unsupported Files**")
+            return
+        media_ = await client.download_media(replied, file_name="resources/")
+    else:
+        await um.edit_text("**Please Reply to Photo/GIF/Sticker Media!**")
+        return
+    if media_:
+        args = get_arg(message)
+        pack = 1
+        if len(args) == 2:
+            emoji_, pack = args
+        elif len(args) == 1:
+            if args[0].isnumeric():
+                pack = int(args[0])
+            else:
+                emoji_ = args[0]
+
+        if emoji_ and emoji_ not in (
+            getattr(emoji, _) for _ in dir(emoji) if not _.startswith("_")
+        ):
+            emoji_ = None
+        if not emoji_:
+            emoji_ = "🗿"
+
+        u_name = user.username
+        u_name = "@" + u_name if u_name else user.first_name or user.id
+        packname = f"Sticker_u{user.id}_v{pack}"
+        custom_packnick = f"{client.me.first_name} by {u_name}"
+        packnick = f"{custom_packnick} Vol.{pack}"
+        cmd = "/newpack"
+        if resize:
+            media_ = await resize_media(media_, is_video, ff_vid)
+        if is_anim:
+            packname += "_animated"
+            packnick += " (Animated)"
+            cmd = "/newanimated"
+        if is_video:
+            packname += "_video"
+            packnick += " (Video)"
+            cmd = "/newvideo"
+        exist = False
+        while True:
+            try:
+                exist = await client.invoke(
+                    GetStickerSet(
+                        stickerset=InputStickerSetShortName(short_name=packname), hash=0
+                    )
+                )
+            except StickersetInvalid:
+                exist = False
+                break
+            limit = 50 if (is_video or is_anim) else 120
+            if exist.set.count >= limit:
+                pack += 1
+                packname = f"a{user.id}_by_akeno_{pack}"
+                packnick = f"{custom_packnick} Vol.{pack}"
+                if is_anim:
+                    packname += f"_anim{pack}"
+                    packnick += f" (Animated){pack}"
+                if is_video:
+                    packname += f"_video{pack}"
+                    packnick += f" (Video){pack}"
+                await um.edit_text(
+                    f"`Create a New Sticker Pack {pack} Because the Sticker Pack Is Full`"
+                )
+                continue
+            break
+        if exist is not False:
+            try:
+                await client.send_message("stickers", "/addsticker")
+            except YouBlockedUser:
+                await client.unblock_user("stickers")
+                await client.send_message("stickers", "/addsticker")
+            except Exception as e:
+                return await um.edit(f"**ERROR:** `{e}`")
+            await asyncio.sleep(2)
+            await client.send_message("stickers", packname)
+            await asyncio.sleep(2)
+            limit = "50" if is_anim else "120"
+            while limit in await get_response(message, client):
+                pack += 1
+                packname = f"a{user.id}_by_{user.username}_{pack}"
+                packnick = f"{custom_packnick} vol.{pack}"
+                if is_anim:
+                    packname += "_anim"
+                    packnick += " (Animated)"
+                if is_video:
+                    packname += "_video"
+                    packnick += " (Video)"
+                await um.edit(
+                    "`Create a New Sticker Pack "
+                    + str(pack)
+                    + " Because the sticker pack is full`"
+                )
+                await client.send_message("stickers", packname)
+                await asyncio.sleep(2)
+                if await get_response(message, client) == "Invalid pack selected.":
+                    await client.send_message("stickers", cmd)
+                    await asyncio.sleep(2)
+                    await client.send_message("stickers", packnick)
+                    await asyncio.sleep(2)
+                    await client.send_document("stickers", media_)
+                    await asyncio.sleep(2)
+                    await client.send_message("Stickers", emoji_)
+                    await asyncio.sleep(2)
+                    await client.send_message("Stickers", "/publish")
+                    await asyncio.sleep(2)
+                    if is_anim:
+                        await client.send_message(
+                            "Stickers", f"<{packnick}>", parse_mode=ParseMode.MARKDOWN
+                        )
+                        await asyncio.sleep(2)
+                    await client.send_message("Stickers", "/skip")
+                    await asyncio.sleep(2)
+                    await client.send_message("Stickers", packname)
+                    await asyncio.sleep(2)
+                    await um.edit(
+                        f"**Sticker Added Successfully!**\n         **[CLICK HERE](https://t.me/addstickers/{packname})**\n**To Use Stickers**"
+                    )
+                    return
+            await client.send_document("stickers", media_)
+            await asyncio.sleep(2)
+            if (
+                await get_response(message, client)
+                == "Sorry, the file type is invalid."
+            ):
+                await um.edit_text(
+                    "**Failed to Add Sticker, Use @Stickers Bot To Add Your Sticker.**"
+                )
+                return
+            await client.send_message("Stickers", emoji_)
+            await asyncio.sleep(2)
+            await client.send_message("Stickers", "/done")
+        else:
+            await um.edit_text("`Create a New Sticker Pack`")
+            try:
+                await client.send_message("Stickers", cmd)
+            except YouBlockedUser:
+                await client.unblock_user("stickers")
+                await client.send_message("stickers", "/addsticker")
+            await asyncio.sleep(2)
+            await client.send_message("Stickers", packnick)
+            await asyncio.sleep(2)
+            await client.send_document("stickers", media_)
+            await asyncio.sleep(2)
+            if (
+                await get_response(message, client)
+                == "Sorry, the file type is invalid."
+            ):
+                await um.edit_text(
+                    "**Failed to Add Sticker, Use @Stickers Bot To Add Your Sticker.**"
+                )
+                return
+            await client.send_message("Stickers", emoji_)
+            await asyncio.sleep(2)
+            await client.send_message("Stickers", "/publish")
+            await asyncio.sleep(2)
+            if is_anim:
+                await client.send_message("Stickers", f"<{packnick}>")
+                await asyncio.sleep(2)
+            await client.send_message("Stickers", "/skip")
+            await asyncio.sleep(2)
+            await client.send_message("Stickers", packname)
+            await asyncio.sleep(2)
+        await um.edit_text(
+            f"**Sticker Added Successfully!**\n         **[CLICK HERE](https://t.me/addstickers/{packname})**"
+        )
+        if os.path.exists(str(media_)):
+            os.remove(media_)
+
+async def get_response(message, client):
+    return [x async for x in client.get_chat_history("Stickers", limit=1)][0].text
+
+@Akeno(
+    ~filters.scheduled
+    & command(["mmf"])
+    & filters.me
+    & ~filters.forwarded
+)
+async def memify(client, message):
+    if not message.reply_to_message_id:
+        await message.edit_text("**Plz reply to an sticker!**")
+        return
+    reply_message = message.reply_to_message
+    if not reply_message.media:
+        await message.text("**Please Reply to photo or sticker!**")
+        return
+    file = await client.download_media(reply_message)
+    mm = await message.edit_text("`Processing . . .`")
+    text = get_arg(message)
+    if len(text) < 1:
+        return await mm.edit("`Please Type `.mmf text")
+    meme = await add_text_img(file, text)
+    await asyncio.gather(
+        mm.delete(),
+        client.send_sticker(
+            message.chat.id,
+            sticker=meme,
+            reply_to_message_id=message.id,
+        ),
+    )
+    os.remove(meme)
+
+module = modules_help.add_module("sticker", __file__)
+module.add_command("kang", "Kang To Sticker Or Image To Add To Sticker Pack.")
+module.add_command("mmf", "Reply to Message Sticker or Photo will be changed into a specified meme text sticker")

akn/Akeno/story.py

@@ -0,0 +1,108 @@
+import os
+import time
+from pyrogram.types import *
+from pyrogram import *
+from pyrogram.errors import *
+from akn import log_detailed_error
+from akn.utils.handler import *
+from akn.utils.scripts import progress
+from akn.utils.prefixprem import command
+from config import *
+
+custom_loading = "<emoji id=5974235702701853774>🗿</emoji>"
+
+@Akeno(
+    ~filters.scheduled
+    & command(["hpyer", "hyper", "hek"])
+    & filters.me
+    & ~filters.forwarded
+)
+async def hyperok(client: Client, message: Message):
+    link = message.text.split(" ", 1)[1] if len(message.command) > 1 else None
+    if not link:
+        return
+    then_do = link.split("/")
+    developed_by_me = int(then_do[-1])
+    text = f">> [{developed_by_me}]({link})"
+    await message.edit_text(text, disable_web_page_preview=True)
+
+@Akeno(
+    ~filters.scheduled
+    & command(["copy"])
+    & filters.me
+    & ~filters.forwarded
+)
+async def get_story_dl(client: Client, message: Message):
+    command, *options = message.text.split(" ", 2) if message.command else [None, []]
+    if client.me.is_premium:
+        pro = await message.reply_text(f"{custom_loading}Processing...")
+    else:
+        pro = await message.reply_text("Processing...")
+    if not command:
+        await pro.edit_text("Invalid command")
+        return
+    copy_chat = False
+    copy_story = False
+    for option in options:
+        if option == "-c":
+            copy_chat = True
+        elif option == "-s":
+            copy_story = True
+    text_link = options[-1] if options else None
+    if not text_link or not text_link.startswith("https://t.me/"):
+        await pro.edit_text("Invalid story or copy(chats) link")
+        return
+    try:
+        target_link = text_link.split("/c/") if "/c/" in text_link else text_link.split("/")
+        random_id = int(target_link[-1].split("/")[-1]) if len(target_link) > 1 else None
+        desired_username = target_link[3] if len(target_link) > 3 else None
+        username = "@" + desired_username if desired_username else "-100" + target_link[1].split("/")[0] if len(target_link) > 1 else None
+        if copy_chat and copy_story:
+            await pro.edit_text("Invalid options. Choose either -c or -s.")
+            return
+        elif copy_chat:
+            await client.copy_message(message.chat.id, from_chat_id=username, message_id=random_id, protect_content=True)
+            await pro.delete()
+        elif copy_story:
+            stories = await client.get_stories(username, story_ids=[random_id])
+            if stories:
+                for story in stories:
+                    file_id = (
+                        story.photo.file_id if story and story.photo else None
+                        or story.video.file_id if story and story.video else None
+                    )
+                    caption = story.caption or f"By {client.me.mention}"
+                    if file_id:
+                        documents = await client.download_media(file_id)
+                        if documents.endswith((".mp4", ".gif")):
+                            send_function = client.send_video
+                        else:
+                            send_function = client.send_photo
+                        seconds_time = time.time()
+                        await send_function(
+                            message.chat.id,
+                            documents,
+                            caption=caption,
+                            progress=progress,
+                            progress_args=(pro, seconds_time, "Processing...")
+
+                        )
+                        await pro.delete()
+                        os.remove(documents)
+            else:
+                await pro.edit_text(f"Error: No stories found for {username}")
+        else:
+            await pro.edit_text("Invalid options. Choose either -c or -s.")
+    except ValueError as e:
+        await pro.edit_text(f"Error parsing for {username}: {e}")
+    except ChatWriteForbidden as e:
+        await pro.edit_text(f"Error: Bot doesn't have permission to write in the channel {username}")
+    except UserIsBlocked as e:
+        await pro.edit_text(f"Error: Bot is blocked by the user {username}")
+    except Exception as e:
+        await log_detailed_error(e, where=client.me.id, who=message.chat.title)
+        await pro.edit_text(f"Error retrieving or sending for {username}: {e}")
+
+module = modules_help.add_module("storydl", __file__)
+module.add_command("copy -c", "to copy chat group link")
+module.add_command("copy -s", "to copy story link")

akn/Akeno/translate.py

@@ -0,0 +1,44 @@
+from gpytranslate import SyncTranslator
+from pyrogram import *
+from pyrogram.types import *
+from akn.utils.handler import *
+from akn.utils.prefixprem import command
+from config import *
+
+trans = SyncTranslator()
+
+@Akeno(
+    ~filters.scheduled
+    & command(["tr"])
+    & filters.me
+    & ~filters.forwarded
+)
+async def translate(_, message: Message):
+    global to_translate
+    reply_msg = message.reply_to_message
+    if not reply_msg:
+        await message.reply_text("Reply to a message to translate it!")
+        return
+    if reply_msg.caption:
+        to_translate = reply_msg.caption
+    elif reply_msg.text:
+        to_translate = reply_msg.text
+    try:
+        args = message.text.split()[1].lower()
+        if "//" in args:
+            source = args.split("//")[0]
+            dest = args.split("//")[1]
+        else:
+            source = trans.detect(to_translate)
+            dest = args
+    except IndexError:
+        source = trans.detect(to_translate)
+        dest = "en"
+    translation = trans(to_translate, sourcelang=source, targetlang=dest)
+    reply = ""
+    reply += f"<b>Translated from {source} to {dest}</b>:\n"
+    reply += f"<code>{translation.text}</code>\n"
+    try:
+        await message.reply_text(reply)
+    except Exception as e:
+        await message.reply_text(f"Error : {e}")

akn/Akeno/youtube.py

@@ -0,0 +1,282 @@
+import os
+import time
+
+import requests
+from pyrogram.types import Message
+from pyrogram import Client, filters
+from youtube_search import YoutubeSearch
+from yt_dlp import YoutubeDL
+
+from akn import log_detailed_error
+from akn.utils.database import db
+from akn.utils.driver import YoutubeDriver
+from akn.utils.formatter import secs_to_mins
+from akn.utils.handler import *
+from akn.utils.logger import LOGS
+from akn.utils.scripts import progress
+from akn.utils.prefixprem import command
+from config import *
+
+custom_loading = "<emoji id=5974235702701853774>🗿</emoji>"
+
+@Akeno(
+    ~filters.scheduled
+    & command(["ytsa"])
+    & filters.me
+    & ~filters.forwarded
+)
+async def youtube_search_audio(client: Client, message: Message):
+    if len(message.command) < 2:
+        return await message.reply_text(
+            "Give a valid youtube search to download audio."
+        )
+    query = await input_user(message)
+    results = YoutubeSearch(query, max_results=5).to_dict()
+    watch = results[0]["url_suffix"]
+    url_suffix = watch.split("/")[1]
+    okk = f"https://youtube.com/{url_suffix}"
+    pro = await message.reply_text("Checking ...")
+    status, url = YoutubeDriver.check_url(okk)
+    if not status:
+        return await pro.edit_text(url)
+    if client.me.is_premium:
+        await pro.edit_text(f"{custom_loading}__Downloading audio ...__")
+    else:
+        await pro.edit_text(f"__Downloading audio ...__")
+    try:
+        with YoutubeDL(YoutubeDriver.song_options()) as ytdl:
+            yt_data = ytdl.extract_info(url, False)
+            yt_file = ytdl.prepare_filename(yt_data)
+            ytdl.process_info(yt_data)
+        if client.me.is_premium:
+            upload_text = f"**{custom_loading}𝖴𝗉𝗅𝗈𝖺𝖽𝗂𝗇𝗀 𝖲𝗈𝗇𝗀 ...** \n\n**𝖳𝗂𝗍𝗅𝖾:** `{yt_data['title'][:50]}`\n**𝖢𝗁𝖺𝗇𝗇𝖾𝗅:** `{yt_data['channel']}`"
+        else:
+            upload_text = f"**𝖴𝗉𝗅𝗈𝖺𝖽𝗂𝗇𝗀 𝖲𝗈𝗇𝗀 ...** \n\n**𝖳𝗂𝗍𝗅𝖾:** `{yt_data['title'][:50]}`\n**𝖢𝗁𝖺𝗇𝗇𝖾𝗅:** `{yt_data['channel']}`"
+        await pro.edit_text(upload_text)
+        response = requests.get(f"https://i.ytimg.com/vi/{yt_data['id']}/hqdefault.jpg")
+        with open(f"{yt_file}.jpg", "wb") as f:
+            f.write(response.content)
+        await message.reply_audio(
+            f"{yt_file}.mp3",
+            caption=f"**🎧 𝖳𝗂𝗍𝗅𝖾:** {yt_data['title']} \n\n**👀 𝖵𝗂𝖾𝗐𝗌:** `{yt_data['view_count']}` \n**⌛ 𝖣𝗎𝗋𝖺𝗍𝗂𝗈𝗇:** `{secs_to_mins(int(yt_data['duration']))}`",
+            duration=int(yt_data["duration"]),
+            performer="[Akeno UB]",
+            title=yt_data["title"],
+            thumb=f"{yt_file}.jpg",
+            progress=progress,
+            progress_args=(
+                pro,
+                time.time(),
+                upload_text,
+            ),
+        )
+        await pro.delete()
+    except Exception as e:
+        await log_detailed_error(e, where=client.me.id, who=message.chat.title)
+        return await pro.edit_text(f"**🍀 Audio not Downloaded:** `{e}`")
+    try:
+        os.remove(f"{yt_file}.jpg")
+        os.remove(f"{yt_file}.mp3")
+    except:
+        pass
+
+@Akeno(
+    ~filters.scheduled
+    & command(["yta"])
+    & filters.me
+    & ~filters.forwarded
+)
+async def youtube_audio(client: Client, message: Message):
+    if len(message.command) < 2:
+        return await message.reply_text(
+            "Give a valid youtube link to download audio."
+        )
+    query = await input_user(message)
+    pro = await message.reply_text("Checking ...")
+    status, url = YoutubeDriver.check_url(query)
+    if not status:
+        return await pro.edit_text(url)
+    if client.me.is_premium:
+        await pro.edit_text(f"{custom_loading}__Downloading audio ...__")
+    else:
+        await pro.edit_text(f"__Downloading audio ...__")
+    try:
+        with YoutubeDL(YoutubeDriver.song_options()) as ytdl:
+            yt_data = ytdl.extract_info(url, False)
+            yt_file = ytdl.prepare_filename(yt_data)
+            ytdl.process_info(yt_data)
+        if client.me.is_premium:
+            upload_text = f"**{custom_loading}𝖴𝗉𝗅𝗈𝖺𝖽𝗂𝗇𝗀 𝖲𝗈𝗇𝗀 ...** \n\n**𝖳𝗂𝗍𝗅𝖾:** `{yt_data['title'][:50]}`\n**𝖢𝗁𝖺𝗇𝗇𝖾𝗅:** `{yt_data['channel']}`"
+        else:
+            upload_text = f"**𝖴𝗉𝗅𝗈𝖺𝖽𝗂𝗇𝗀 𝖲𝗈𝗇𝗀 ...** \n\n**𝖳𝗂𝗍𝗅𝖾:** `{yt_data['title'][:50]}`\n**𝖢𝗁𝖺𝗇𝗇𝖾𝗅:** `{yt_data['channel']}`"
+        await pro.edit_text(upload_text)
+        response = requests.get(f"https://i.ytimg.com/vi/{yt_data['id']}/hqdefault.jpg")
+        with open(f"{yt_file}.jpg", "wb") as f:
+            f.write(response.content)
+        await message.reply_audio(
+            f"{yt_file}.mp3",
+            caption=f"**🎧 𝖳𝗂𝗍𝗅𝖾:** {yt_data['title']} \n\n**👀 𝖵𝗂𝖾𝗐𝗌:** `{yt_data['view_count']}` \n**⌛ 𝖣𝗎𝗋𝖺𝗍𝗂𝗈𝗇:** `{secs_to_mins(int(yt_data['duration']))}`",
+            duration=int(yt_data["duration"]),
+            performer="[Akeno UB]",
+            title=yt_data["title"],
+            thumb=f"{yt_file}.jpg",
+            progress=progress,
+            progress_args=(
+                pro,
+                time.time(),
+                upload_text,
+            ),
+        )
+        await pro.delete()
+    except Exception as e:
+        await log_detailed_error(e, where=client.me.id, who=message.chat.title)
+        return await pro.edit_text(f"**🍀 Audio not Downloaded:** `{e}`")
+    try:
+        os.remove(f"{yt_file}.jpg")
+        os.remove(f"{yt_file}.mp3")
+    except:
+        pass
+
+@Akeno(
+    ~filters.scheduled
+    & command(["ytva"])
+    & filters.me
+    & ~filters.forwarded
+)
+async def ytvideo_search(client: Client, message: Message):
+    if len(message.command) < 2:
+        return await message.reply_text(
+            "Give a valid youtube search to download video."
+        )
+    query = await input_user(message)
+    results = YoutubeSearch(query, max_results=5).to_dict()
+    watch = results[0]["url_suffix"]
+    url_suffix = watch.split("/")[1]
+    okk = f"https://youtube.com/{url_suffix}"
+    pro = await message.reply_text("Checking ...")
+    status, url = YoutubeDriver.check_url(okk)
+    if not status:
+        return await pro.edit_text(url)
+    if client.me.is_premium:
+        await pro.edit_text(f"{custom_loading}__Downloading audio ...__")
+    else:
+        await pro.edit_text(f"__Downloading audio ...__")
+    try:
+        with YoutubeDL(YoutubeDriver.video_options()) as ytdl:
+            yt_data = ytdl.extract_info(url, True)
+            yt_file = yt_data["id"]
+
+        if client.me.is_premium:
+            upload_text = f"**{custom_loading}𝖴𝗉𝗅𝗈𝖺𝖽𝗂𝗇𝗀 𝖲𝗈𝗇𝗀 ...** \n\n**𝖳𝗂𝗍𝗅𝖾:** `{yt_data['title'][:50]}`\n**𝖢𝗁𝖺𝗇𝗇𝖾𝗅:** `{yt_data['channel']}`"
+        else:
+            upload_text = f"**𝖴𝗉𝗅𝗈𝖺𝖽𝗂𝗇𝗀 𝖲𝗈𝗇𝗀 ...** \n\n**𝖳𝗂𝗍𝗅𝖾:** `{yt_data['title'][:50]}`\n**𝖢𝗁𝖺𝗇𝗇𝖾𝗅:** `{yt_data['channel']}`"
+        await pro.edit_text(upload_text)
+        response = requests.get(f"https://i.ytimg.com/vi/{yt_data['id']}/hqdefault.jpg")
+        with open(f"{yt_file}.jpg", "wb") as f:
+            f.write(response.content)
+        await message.reply_video(
+            f"{yt_file}.mp4",
+            caption=f"**🎧 𝖳𝗂𝗍𝗅𝖾:** {yt_data['title']} \n\n**👀 𝖵𝗂𝖾𝗐𝗌:** `{yt_data['view_count']}` \n**⌛ 𝖣𝗎𝗋𝖺𝗍𝗂𝗈𝗇:** `{secs_to_mins(int(yt_data['duration']))}`",
+            duration=int(yt_data["duration"]),
+            thumb=f"{yt_file}.jpg",
+            progress=progress,
+            progress_args=(
+                pro,
+                time.time(),
+                upload_text,
+            ),
+        )
+        await pro.delete()
+    except Exception as e:
+        await log_detailed_error(e, where=client.me.id, who=message.chat.title)
+        return await pro.edit_text(f"**🍀 Video not Downloaded:** `{e}`")
+    try:
+        os.remove(f"{yt_file}.jpg")
+        os.remove(f"{yt_file}.mp4")
+    except:
+        pass
+
+@Akeno(
+    ~filters.scheduled
+    & command(["ytv"])
+    & filters.me
+    & ~filters.forwarded
+)
+async def ytvideo(client: Client, message: Message):
+    if len(message.command) < 2:
+        return await message.reply_text(
+            "Give a valid youtube link to download video."
+        )
+    query = await input_user(message)
+    pro = await message.reply_text("Checking ...")
+    status, url = YoutubeDriver.check_url(query)
+    if not status:
+        return await pro.edit_text(url)
+    if client.me.is_premium:
+        await pro.edit_text(f"{custom_loading}__Downloading audio ...__")
+    else:
+        await pro.edit_text(f"__Downloading audio ...__")
+    try:
+        with YoutubeDL(YoutubeDriver.video_options()) as ytdl:
+            yt_data = ytdl.extract_info(url, True)
+            yt_file = yt_data["id"]
+
+        if client.me.is_premium:
+            upload_text = f"**{custom_loading}𝖴𝗉𝗅𝗈𝖺𝖽𝗂𝗇𝗀 𝖲𝗈𝗇𝗀 ...** \n\n**𝖳𝗂𝗍𝗅𝖾:** `{yt_data['title'][:50]}`\n**𝖢𝗁𝖺𝗇𝗇𝖾𝗅:** `{yt_data['channel']}`"
+        else:
+            upload_text = f"**𝖴𝗉𝗅𝗈𝖺𝖽𝗂𝗇𝗀 𝖲𝗈𝗇𝗀 ...** \n\n**𝖳𝗂𝗍𝗅𝖾:** `{yt_data['title'][:50]}`\n**𝖢𝗁𝖺𝗇𝗇𝖾𝗅:** `{yt_data['channel']}`"
+        await pro.edit_text(upload_text)
+        response = requests.get(f"https://i.ytimg.com/vi/{yt_data['id']}/hqdefault.jpg")
+        with open(f"{yt_file}.jpg", "wb") as f:
+            f.write(response.content)
+        await message.reply_video(
+            f"{yt_file}.mp4",
+            caption=f"**🎧 𝖳𝗂𝗍𝗅𝖾:** {yt_data['title']} \n\n**👀 𝖵𝗂𝖾𝗐𝗌:** `{yt_data['view_count']}` \n**⌛ 𝖣𝗎𝗋𝖺𝗍𝗂𝗈𝗇:** `{secs_to_mins(int(yt_data['duration']))}`",
+            duration=int(yt_data["duration"]),
+            thumb=f"{yt_file}.jpg",
+            progress=progress,
+            progress_args=(
+                pro,
+                time.time(),
+                upload_text,
+            ),
+        )
+        await pro.delete()
+    except Exception as e:
+        await log_detailed_error(e, where=client.me.id, who=message.chat.title)
+        return await pro.edit_text(f"**🍀 Video not Downloaded:** `{e}`")
+    try:
+        os.remove(f"{yt_file}.jpg")
+        os.remove(f"{yt_file}.mp4")
+    except:
+        pass
+
+@Akeno(
+    ~filters.scheduled
+    & command(["ytlink"])
+    & filters.me
+    & ~filters.forwarded
+)
+async def ytlink(_, message: Message):
+    if len(message.command) < 2:
+        return await message.reply_text("Give something to search on youtube.")
+    query = await input_user(message)
+    pro = await message.reply_text("Searching ...")
+    try:
+        results = YoutubeDriver(query, 7).to_dict()
+    except Exception as e:
+        await log_detailed_error(e, where=client.me.id, who=message.chat.title)
+        return await pro.edit_text(f"**🍀 Error:** `{e}`")
+    if not results:
+        return await pro.edit_text("No results found.")
+    text = f"**🔎 𝖳𝗈𝗍𝖺𝗅 𝖱𝖾𝗌𝗎𝗅𝗍𝗌 𝖥𝗈𝗎𝗇𝖽:** `{len(results)}`\n\n"
+    for result in results:
+        text += f"**𝖳𝗂𝗍𝗅𝖾:** `{result['title'][:50]}`\n**𝖢𝗁𝖺𝗇𝗇𝖾𝗅:** `{result['channel']}`\n**𝖵𝗂𝖾𝗐𝗌:** `{result['views']}`\n**𝖣𝗎𝗋𝖺𝗍𝗂𝗈𝗇:** `{result['duration']}`\n**𝖫𝗂𝗇𝗄:** `https://youtube.com{result['url_suffix']}`\n\n"
+    await pro.edit_text(text, disable_web_page_preview=True)
+
+module = modules_help.add_module("youtube", __file__)
+module.add_command("yta", "Download the youtube link video in .mp3 format!.")
+module.add_command("ytv", "Download the youtube link video in .mp3 format!.")
+module.add_command("ytsa", "Download the youtube search video in .mp3 format!.")
+module.add_command("ytva", "Download the youtube search video in .mp4 format!")
+module.add_command("ytlink", "Search for a video on youtube")

akn/AllDownloaderBot/allonedl.py

@@ -0,0 +1,87 @@
+import re
+from pyrogram import *
+from pyrogram.types import *
+from pyrogram.errors import *
+from pyrogram.enums import *
+from akn.AllDownloaderBot.support_sites import *
+from akn.utils.logger import *
+from akn.utils.database import db
+
+def is_video_url(url: str) -> bool:
+    patterns = (
+        r"tiktok\.com/(?:@|v/|t/|video/)",
+        r"(?:youtube\.com/watch\?v=|youtu\.be/)[\w-]{11}",
+        r"instagram\.com/(?:p|reel)/[\w-]+",
+        r"(?:twitter\.com|x\.com)/\w+/status/\d+",
+        r"facebook\.com/(?:watch|reel|share)/[\w-]+",
+    )
+    
+    return any(re.search(pattern, url, re.IGNORECASE) for pattern in patterns)
+
+@Client.on_message(
+    ~filters.scheduled
+    & filters.command(["alldl"])
+    & ~filters.forwarded
+)
+async def allone_downloader(client: Client, message: Message):
+    user_id = message.from_user.id
+    if await db.get_alldlbot_is_blacklist_user(client.me.id, user_id):
+        return
+    if message.chat.type.value != "supergroup":
+        return await message.reply_text("You can only group public not private")
+    await db.update_alldlbot_broadcast_in_group(client.me.id, message.chat.id, "add")
+    user_name = message.from_user.first_name
+    nn = "[" + user_name + "](tg://user?id=" + str(user_id) + ")"
+    if not await db.get_forcesub_only_bot(client.me.id):
+        return await message.reply_text("This is the command /addjoin username channel and becomes admin on the channel")
+    update_channel = await db.get_forcesub_only_bot(client.me.id)
+    if update_channel:
+        try:
+            user = await client.get_chat_member(update_channel, user_id)
+            if user.status == ChatMemberStatus.BANNED:
+                await client.send_message(
+                    message.chat.id,
+                    text=f"**❌ {nn} anda telah di blokir dari grup dukungan**",
+                    disable_web_page_preview=True,
+                )
+                return
+        except UserNotParticipant:
+            await client.send_message(
+                message.chat.id,
+                text=f"**👋🏻 Halo {nn}\nᴜɴᴛᴜᴋ ᴍᴇɴɢʜɪɴᴅᴀʀɪ ᴘᴇɴɢɢᴜɴᴀᴀɴ ʏᴀɴɢ ʙᴇʀʟᴇʙɪʜᴀɴ ʙᴏᴛ ɪɴɪ ᴅɪ ᴋʜᴜsᴜsᴋᴀɴ ᴜɴᴛᴜᴋ ʏᴀɴɢ sᴜᴅᴀʜ ᴊᴏɪɴ ᴅɪ ᴄʜᴀɴɴᴇʟ ᴋᴀᴍɪ​!**",
+                reply_markup=InlineKeyboardMarkup(
+                    [
+                        [
+                            InlineKeyboardButton(
+                                "Jᴏɪɴ Cʜᴀɴɴᴇʟ Dᴜʟᴜ",
+                                url=f"https://t.me/{update_channel}",
+                            )
+                        ]
+                    ]
+                ),
+            )
+        except ChatAdminRequired:
+            return await message.reply_text("Chat admins Required: before /addjoin username without @ and add bot to your channel as admin")
+
+    query_url = message.text.split(" ", 1)[1] if len(message.command) > 1 else None
+    if not query_url:
+        return await message.reply_text("?")
+    if not is_video_url(query_url):
+        return await message.reply_text("Invalid link")
+    dll = await message.reply_text("Processing....")
+    try:
+        result, caption = all_one_downloader(query_url)
+        if result:
+            await message.reply_video(
+                result,
+                caption=caption,
+                disable_notification=True
+            )
+            await dll.delete()
+            return
+        else:
+            return await message.reply_text("Try again")
+    except Exception as e:
+        await dll.delete()
+        LOGS.error(f"Error yt: {type(e).__name__}")
+        await message.reply_text(f"Free: Upgrade to premium only cookies")

akn/AllDownloaderBot/blacklistchat.py

@@ -0,0 +1,262 @@
+# credits original: yukki music
+# kurigram versions: latest
+# code by @xpushz
+
+from pyrogram import *
+from pyrogram.types import *
+from pyrogram.errors import *
+from akn.utils.logger import LOGS
+from akn.utils.database import db
+
+@Client.on_message(filters.new_chat_members, group=2)
+async def welcomecheck(client, message: Message):
+    chat_id = message.chat.id
+    if await db.get_alldlbot_is_blacklist_chat(client.me.id, chat_id):
+        return await client.leave_chat(chat_id)
+    return await client.send_message(
+        chat_id,
+        f"Thank you for using my bot: {client.me.first_name}"
+    )
+
+@Client.on_message(
+    ~filters.scheduled
+    & filters.command(["addblacklist"])
+    & ~filters.forwarded
+)
+async def blacklist_user(c, m):
+    is_sudo = await db.get_alldlbot_sudouser(c.me.id, m.from_user.id)
+    protect_own = await db.get_alldlbot_by_user_id(m.from_user.id)
+    if not protect_own and not is_sudo:
+        return await m.reply_text("You are not allowed here.")
+
+    if m.chat.type.value != "supergroup":
+        return await m.reply_text("You can only group public not private")
+    await db.update_alldlbot_broadcast_in_group(c.me.id, m.chat.id, "add")
+    user_id = None
+    if not m.reply_to_message:
+        if len(m.command) < 2:
+            return await m.reply_text(
+                "Reply to a user or pass a user_id to blacklist"
+            )
+        try:
+            getuser = m.command[1]
+        except Exception as e:
+            return await m.reply_text(f"`{str(e)}`")
+    else:
+        getuser = m.reply_to_message.from_user.id
+    try:
+        user_id = (await c.get_users(getuser)).id
+        await db.add_alldlbot_blacklist_user(c.me.id, user_id)
+        await m.reply_text(f"Successfully blacklist `{user_id}` from bots.")
+    except Exception as e:
+        await m.reply_text(f"Error: {e}")
+
+@Client.on_message(
+    ~filters.scheduled
+    & filters.command(["rmblacklist"])
+    & ~filters.forwarded
+)
+async def unblacklist_user(c, m):
+    is_sudo = await db.get_alldlbot_sudouser(c.me.id, m.from_user.id)
+    protect_own = await db.get_alldlbot_by_user_id(m.from_user.id)
+    if not protect_own and not is_sudo:
+        return await m.reply_text("You are not allowed here.")
+
+    if m.chat.type.value != "supergroup":
+        return await m.reply_text("You can only group public not private")
+    await db.update_alldlbot_broadcast_in_group(c.me.id, m.chat.id, "add")
+    user_id = None
+    if not m.reply_to_message:
+        if len(m.command) < 2:
+            return await m.reply_text(
+                "Reply to a user or pass a user_id to unblacklist."
+            )
+        try:
+            getuser = m.command[1]
+        except Exception as e:
+            return await m.reply_text(f"`{str(e)}`")
+    else:
+        getuser = m.reply_to_message.from_user.id
+    try:
+        user_id = (await c.get_users(getuser)).id
+        await db.add_alldlbot_unblacklist_user(c.me.id, user_id)
+        await m.reply_text(f"Successfully removed blacklist `{user_id}` from bots.")
+    except Exception as e:
+        await m.reply_text(f"Error: {e}")
+
+@Client.on_message(
+    ~filters.scheduled
+    & filters.command(["addsudo"])
+    & ~filters.forwarded
+)
+async def add_sudo_func(client, message: Message):
+    if message.chat.type.value != "supergroup":
+        return await message.reply_text("This command can only be used in supergroups.")
+    is_sudo = await db.get_alldlbot_sudouser(client.me.id, message.from_user.id)
+    protect_own = await db.get_alldlbot_by_user_id(message.from_user.id)
+    if not protect_own and not is_sudo:
+        return await message.reply_text("You are not allowed here.")
+    if len(message.command) != 2:
+        return await message.reply_text("**Usage:**\n/addsudo [USER_ID]")
+    user_id = int(message.text.strip().split()[1])
+    if await db.get_alldlbot_sudouser(client.me.id, user_id):
+        return await message.reply_text("User is already sudo.")
+    if user_id == client.me.id:
+        return await message.reply_text("You can't add yourself as sudo.")
+    update_sudo = await db.update_alldlbot_sudouser(client.me.id, user_id, "add")
+    if update_sudo:
+        await message.reply_text("User has been successfully added to sudo list")
+    else:
+        await message.reply_text("Something wrong happened.")
+
+@Client.on_message(
+    ~filters.scheduled
+    & filters.command(["delsudo"])
+    & ~filters.forwarded
+)
+async def delc_sudo_func(client, message: Message):
+    if message.chat.type.value != "supergroup":
+        return await message.reply_text("This command can only be used in supergroups.")
+    is_sudo = await db.get_alldlbot_sudouser(client.me.id, message.from_user.id)
+    protect_own = await db.get_alldlbot_by_user_id(message.from_user.id)
+    if not protect_own and not is_sudo:
+        return await message.reply_text("You are not allowed here.")
+    if len(message.command) != 2:
+        return await message.reply_text("**Usage:**\n/delsudo [USER_ID]")
+    user_id = int(message.text.strip().split()[1])
+    if not await db.get_alldlbot_sudouser(client.me.id, user_id):
+        return await message.reply_text("User is not sudo.")
+    if user_id == client.me.id:
+        return await message.reply_text("You can't remove yourself as sudo.")
+    update_sudo = await db.update_alldlbot_sudouser(client.me.id, user_id, "remove")
+    if update_sudo:
+        await message.reply_text("User has been successfully removed from sudo list")
+    else:
+        await message.reply_text("Something wrong happened.")
+
+@Client.on_message(
+    ~filters.scheduled
+    & filters.command(["blacklistchat"])
+    & ~filters.forwarded
+)
+async def blacklist_chat_func(client, message: Message):
+    if message.chat.type.value != "supergroup":
+        return await message.reply_text("This command can only be used in supergroups.")
+    is_sudo = await db.get_alldlbot_sudouser(client.me.id, message.from_user.id)
+    protect_own = await db.get_alldlbot_by_user_id(message.from_user.id)
+    if not protect_own and not is_sudo:
+        return await message.reply_text("You are not allowed here.")
+    if len(message.command) != 2:
+        return await message.reply_text("**Usage:**\n/blacklistchat [CHAT_ID]")
+    chat_id = int(message.text.strip().split()[1])
+    if await db.get_alldlbot_is_blacklist_chat(client.me.id, chat_id):
+        return await message.reply_text("Chat is already blacklisted.")
+    blacklisted = await db.add_alldlbot_blacklist_chat(client.me.id, chat_id)
+    if blacklisted:
+        await message.reply_text("Chat has been successfully blacklisted")
+    else:
+        await message.reply_text("Something wrong happened.")
+    try:
+        await client.leave_chat(chat_id)
+    except:
+        pass
+
+@Client.on_message(
+    ~filters.scheduled
+    & filters.command(["whitelistchat"])
+    & ~filters.forwarded
+)
+async def white_funciton(client, message: Message):
+    if message.chat.type.value != "supergroup":
+        return await message.reply_text("This command can only be used in supergroups.")
+    is_sudo = await db.get_alldlbot_sudouser(client.me.id, message.from_user.id)
+    protect_own = await db.get_alldlbot_by_user_id(message.from_user.id)
+    if not protect_own and not is_sudo:
+        return await message.reply_text("You are not allowed here.")
+    if len(message.command) != 2:
+        return await message.reply_text("**Usage:**\n/whitelistchat [CHAT_ID]")
+    chat_id = int(message.text.strip().split()[1])
+    if not await db.get_alldlbot_is_blacklist_chat(client.me.id, chat_id):
+        return await message.reply_text("Chat is already whitelisted")
+    whitelisted = await db.alldlbot_whitelist_chat(client.me.id, chat_id)
+    if whitelisted:
+        return await message.reply_text("Chat has been successfully whitelisted")
+    await message.reply_text("Something wrong happened.")
+
+@Client.on_message(
+    ~filters.scheduled
+    & filters.command(["blacklistedchat"])
+    & ~filters.forwarded
+)
+async def all_chats(client, message: Message):
+    if message.chat.type.value != "supergroup":
+        return await message.reply_text("This command can only be used in supergroups.")
+    is_sudo = await db.get_alldlbot_sudouser(client.me.id, message.from_user.id)
+    protect_own = await db.get_alldlbot_by_user_id(message.from_user.id)
+    if not protect_own and not is_sudo:
+        return await message.reply_text("You are not allowed here.")
+    text = "**Blacklisted Chats:**\n\n"
+    j = 0
+    for count, chat_id in enumerate(await db.get_alldlbot_blacklist_chat(client.me.id), 1):
+        try:
+            title = (await client.get_chat(chat_id)).title
+        except Exception:
+            title = "Private"
+        j = 1
+        text += f"**{count}. {title}** [`{chat_id}`]\n"
+    if j == 0:
+        await message.reply_text("No Blacklisted Chats")
+    else:
+        await message.reply_text(text)
+
+@Client.on_message(
+    ~filters.scheduled
+    & filters.command(["listsudo"])
+    & ~filters.forwarded
+)
+async def list_sudo_func(client, message: Message):
+    if message.chat.type.value != "supergroup":
+        return await message.reply_text("This command can only be used in supergroups.")
+    is_sudo = await db.get_alldlbot_sudouser(client.me.id, message.from_user.id)
+    protect_own = await db.get_alldlbot_by_user_id(message.from_user.id)
+    if not protect_own and not is_sudo:
+        return await message.reply_text("You are not allowed here.")
+    text = "**List SudoUser:**\n\n"
+    j = 0
+    for count, user_id in enumerate(await db.get_alldlbot_allsudouser(client.me.id), 1):
+        try:
+            title = (await client.get_users(user_id)).first_name
+        except Exception:
+            title = "Private"
+        j = 1
+        text += f"**{count}. {title}** [`{user_id}`]\n"
+    if j == 0:
+        await message.reply_text("No List SudoUser")
+    else:
+        await message.reply_text(text)
+
+@Client.on_message(
+    ~filters.scheduled
+    & filters.command(["viewblacklistuser"])
+    & ~filters.forwarded
+)
+async def view_blacklist_user_func(client, message: Message):
+    if message.chat.type.value != "supergroup":
+        return await message.reply_text("This command can only be used in supergroups.")
+    is_sudo = await db.get_alldlbot_sudouser(client.me.id, message.from_user.id)
+    protect_own = await db.get_alldlbot_by_user_id(message.from_user.id)
+    if not protect_own and not is_sudo:
+        return await message.reply_text("You are not allowed here.")
+    text = "**Blacklisted Users:**\n\n"
+    j = 0
+    for count, user_id in enumerate(await db.get_alldlbot_allblacklist_user(client.me.id), 1):
+        try:
+            title = (await client.get_users(user_id)).first_name
+        except Exception:
+            title = "Private"
+        j = 1
+        text += f"**{count}. {title}** [`{user_id}`]\n"
+    if j == 0:
+        await message.reply_text("No Blacklisted Users")
+    else:
+        await message.reply_text(text)

akn/AllDownloaderBot/broadcast.py

@@ -0,0 +1,110 @@
+# credits original: yukki music
+# kurigram versions: latest
+# code by @xpushz
+
+import time
+import os
+import asyncio
+from datetime import datetime
+from pyrogram import *
+from pyrogram.types import *
+from pyrogram.errors import *
+from akn.utils.logger import LOGS
+from akn.utils.database import db
+
+@Client.on_message(
+    ~filters.scheduled
+    & filters.command(["broadcast"])
+    & ~filters.forwarded
+)
+async def braodcast_message(client, message):
+    global IS_BROADCASTING
+    if message.reply_to_message:
+        x = message.reply_to_message.id
+        y = message.chat.id
+    else:
+        if len(message.command) < 2:
+            return await message.reply_text("**Usage**:\n/broadcast [MESSAGE] or [Reply to a Message]")
+        query = message.text.split(None, 1)[1]
+        if "-pin" in query:
+            query = query.replace("-pin", "")
+        if "-nobot" in query:
+            query = query.replace("-nobot", "")
+        if "-pinloud" in query:
+            query = query.replace("-pinloud", "")
+        if "-user" in query:
+            query = query.replace("-user", "")
+        if query == "":
+            return await message.reply_text("Please provide some text to broadcast.")
+
+    IS_BROADCASTING = True
+
+    if "-nobot" not in message.text:
+        sent = 0
+        pin = 0
+        chats = []
+        schats = await db.alldlbot_all_broadcast_group(client.me.id)
+        for chat in schats:
+            chats.append(int(chat))
+        for i in chats:
+            try:
+                m = (
+                    await client.forward_messages(i, y, x)
+                    if message.reply_to_message
+                    else await client.send_message(i, text=query)
+                )
+                if "-pin" in message.text:
+                    try:
+                        await m.pin(disable_notification=True)
+                        pin += 1
+                    except Exception:
+                        continue
+                elif "-pinloud" in message.text:
+                    try:
+                        await m.pin(disable_notification=False)
+                        pin += 1
+                    except Exception:
+                        continue
+                sent += 1
+            except FloodWait as e:
+                flood_time = int(e.x)
+                if flood_time > 200:
+                    continue
+                await asyncio.sleep(flood_time)
+            except Exception:
+                continue
+        try:
+            await message.reply_text(
+                f"Broadcasted Message In {sent}  Chats with {pin} Pins from Bot"
+            )
+        except:
+            pass
+
+    if "-user" in message.text:
+        susr = 0
+        served_users = []
+        susers = await db.alldlbot_all_broadcast(client.me.id)
+        for user in susers:
+            served_users.append(int(user))
+        for i in served_users:
+            try:
+                m = (
+                    await client.forward_messages(i, y, x)
+                    if message.reply_to_message
+                    else await client.send_message(i, text=query)
+                )
+                susr += 1
+            except FloodWait as e:
+                flood_time = int(e.x)
+                if flood_time > 200:
+                    continue
+                await asyncio.sleep(flood_time)
+            except Exception:
+                pass
+        try:
+            await message.reply_text(
+                f"**Broadcasted Message to {susr} Users.**"
+            )
+        except:
+            pass
+    IS_BROADCASTING = False

akn/AllDownloaderBot/main.py

@@ -0,0 +1,1262 @@
+# All credits to @xpushz
+# lu mau kanger kah pasti noob aja
+
+import time
+import requests
+import os
+import re
+import httpx
+import aiofiles
+import hashlib
+import urllib.parse
+import asyncio
+from pyrogram import *
+from pyrogram.enums import *
+from pyrogram import Client, filters
+from pyrogram.types import *
+from pyrogram.errors import *
+
+from akn.utils.logger import LOGS
+from akn.utils.scripts import progress
+from youtube_search import YoutubeSearch
+from yt_dlp import YoutubeDL
+
+from akn.utils.database import db
+from akn.utils.driver import YoutubeDriver
+from akn.utils.formatter import secs_to_mins
+
+import akenoai as js
+
+link_storage = {}
+storage = {}
+
+custom_loading = "<emoji id=5974235702701853774>🗿</emoji>"
+TIKTOK_WEB = "https://www.tikwm.com"
+
+OWNER_BOT_ID = 8109052455
+
+COMMAND = """
+**📥 Social Media Downloader Commands**  
+
+**🔗 Direct Link Downloaders**  
+- `/fbdl` – Download Facebook videos.  
+- `/igdl` – Download Instagram videos/reels.  
+- `/twdl` – Download Twitter/X videos.  
+- `/ttdl` – Download TikTok videos.
+- `/alldl` – Download Facebook, Instagram, Tiktok, Twitter(required cookies) etc videos.  
+- `/teraboxdl` – Download Terabox files (v1).  
+- `/terabox2dl` – Download Terabox files (v2).  
+
+**🎵 YouTube Tools**  
+- `/ytv` – Download YouTube videos in **MP4** format.  
+- `/yta` – Extract audio from YouTube videos in **MP3** format.  
+- `/ytva` – Search & download YouTube videos as **MP4**.  
+- `/ytsa` – Search & download YouTube audio as **MP3**.  
+- `/ytlink` – Search for YouTube videos.  
+"""
+
+@Client.on_callback_query(filters.regex("^cclose"))
+async def cb_cclose(client, query):
+    await query.message.delete()
+    
+@Client.on_callback_query(filters.regex("^author_cmd"))
+async def cb_author_command(client, query):
+    is_sudo = await db.get_alldlbot_sudouser(client.me.id, query.from_user.id)
+    protect_own = await db.get_alldlbot_by_user_id(query.from_user.id)
+    if not protect_own and not is_sudo:
+        return await query.answer("You are not allowed here.", True)
+
+    author_commands = """
+**🔐 Owner-Only Commands**
+
+**📌 Channel & User Management:**
+- `/addjoin` – Enable auto **force-subscribe** to a channel.
+- `/addblacklist` – Ban a user from using bot commands.
+- `/addsudo` – Add a user to the sudo list.
+- `/delsudo` – Remove a user from the sudo list.
+- `/listsudo` – View the list of sudo users.
+- `/rmblacklist` – Unban a blacklisted user.
+- `/blacklistchat` – Block a chat from using the bot. 
+- `/viewblacklistuser` – View the list of blacklisted users. 
+- `/whitelistchat` – Unblock a chat.
+- `/blacklistedchat` – View blacklisted chats.
+
+**📊 Stats & Maintenance:**  
+- `/stats` – View user statistics.  
+- `/rmdup` – Remove duplicate user entries.  
+- `/broadcast` – Send a message to all users.  
+
+**⚙️ Bot Settings:**  
+- `/nobutton` – Toggle **ON/OFF** the `/start` button.  
+- `/setpic` – Change the bot's display picture (resend if needed).
+- `/delpic` – Remove bot display picture (resend if needed).  
+"""
+    keyboard_back = InlineKeyboardMarkup(
+        [
+            [
+                InlineKeyboardButton(
+                    text="Close",
+                    callback_data="cclose"
+                )
+            ]
+        ]
+    )
+    await query.edit_message_text(
+        text=author_commands,
+        reply_markup=keyboard_back
+    )
+
+@Client.on_message(
+    ~filters.scheduled
+    & filters.command(["start"])
+    & filters.private
+    & ~filters.forwarded
+)
+async def startbot(c, m):
+    if await db.get_alldlbot_is_blacklist_user(c.me.id, m.from_user.id):
+        return
+    buttons = [
+        [
+            InlineKeyboardButton(
+                text="Developer",
+                url=f"https://t.me/xtdevs"
+            ),
+            InlineKeyboardButton(
+                text="Channel",
+                url='https://t.me/RendyProjects'
+            ),
+        ],
+        [
+            InlineKeyboardButton(
+                text="Author Commands",
+                callback_data='author_cmd'
+            )
+        ]
+    ]
+    buttons_start_in_group = [
+        [
+            InlineKeyboardButton(
+                text="Add to your group",
+                url=f"https://t.me/{c.me.username}?startgroup=true&admin=manage_chat+change_info+post_messages+edit_messages+delete_messages+invite_users+restrict_members+pin_messages+promote_members+manage_video_chats+anonymous=false"
+            )
+        ],
+        [
+            InlineKeyboardButton(
+                text="Author Commands",
+                callback_data='author_cmd'
+            )
+        ]
+    ]
+    user_now = await db.get_alldlbot_by_no_button(c.me.id)
+    reply_markup = InlineKeyboardMarkup(buttons_start_in_group) if user_now else InlineKeyboardMarkup(buttons)
+    try:
+        await db.update_alldlbot_broadcast(c.me.id, m.from_user.id, "add")
+        is_pic, catbox_link = await db.get_pic_in_allbot(c.me.id)
+        if is_pic and catbox_link:
+            return await m.reply_photo(
+                photo=catbox_link,
+                caption=COMMAND,
+                reply_markup=reply_markup
+            )
+        return await m.reply_text(
+            text=COMMAND,
+            disable_web_page_preview=True,
+            reply_markup=reply_markup
+        )
+    except Exception as e:
+        await m.reply_text(f"Error: {e}")
+
+class Tiktok:
+    @staticmethod
+    async def download(api_name, url):
+        response = requests.get("{}/api/?url={}".format(api_name, url))
+        if response.status_code != 200:
+            return "Error Response limits"
+        data_json = response.json()
+        author_tiktok = data_json["data"]["author"].get("nickname") or "Unknown"
+        play_tiktok = data_json["data"].get("play")
+        music_tiktok = data_json["data"]["music_info"].get("play")
+        return [
+            play_tiktok,
+            music_tiktok,
+            author_tiktok
+        ]
+
+def is_tiktok_url(url):
+    pattern = r"(https?)://(vt|www)\.tiktok\.com/(\w+)"
+    match = re.search(pattern, url)
+    return bool(match)
+
+def generate_callback_data(user_id, query):
+    identifier = hashlib.md5(query.encode()).hexdigest()
+    callback_data = f"audiodownload_{user_id}_{identifier}"
+    link_storage[callback_data] = query
+    return callback_data
+
+@Client.on_callback_query(filters.regex("^audiodownload_"))
+async def callback_button(client: Client, cb: CallbackQuery):
+    try:
+        data = cb.data
+        query = link_storage.get(data)
+        if query:
+            response = await Tiktok.download(TIKTOK_WEB, query)
+            await client.send_audio(cb.message.chat.id, response[1])
+            await cb.answer("Audio sent successfully!")
+        else:
+            await cb.answer("Invalid or expired link.", show_alert=True)
+    except Exception as e:
+        await cb.answer(f"Error: {str(e)}", show_alert=True)
+
+@Client.on_message(
+    ~filters.scheduled
+    & filters.command(["stats"])
+    & ~filters.forwarded
+)
+async def statscmd(c, m):
+    is_sudo = await db.get_alldlbot_sudouser(c.me.id, m.from_user.id)
+    protect_own = await db.get_alldlbot_by_user_id(m.from_user.id)
+    if not protect_own and not is_sudo:
+        return await m.reply_text("You are not allowed here.")
+    try:
+        if m.chat.type.value != "supergroup":
+            return await m.reply_text("You can only group public not private")
+        await db.update_alldlbot_broadcast_in_group(c.me.id, m.chat.id, "add")
+        total_bl_users = await db.alldlbot_blacklist_stats(c.me.id)
+        total_users = await db.alldlbot_broadcast_stats(c.me.id)
+        await m.reply_text(f"**Total Users:** `{total_users}`\n**Total Blacklist Users:** `{total_bl_users}`")
+    except Exception as e:
+        await m.reply_text(f"Error: {e.MESSAGE}")
+
+@Client.on_message(
+    ~filters.scheduled
+    & filters.command(["delpic"])
+    & ~filters.forwarded
+)
+async def delpicincatbox(c, m):
+    is_sudo = await db.get_alldlbot_sudouser(c.me.id, m.from_user.id)
+    protect_own = await db.get_alldlbot_by_user_id(m.from_user.id)
+    if not protect_own and not is_sudo:
+        return await m.reply_text("You are not allowed here.")
+    mode = m.text.split(" ", 1)[1] if len(m.command) > 1 else None
+    if not mode:
+        return await m.reply_text("Example: `/delpic yes`")
+    try:
+        if mode == "yes":
+            _, catbox_link = await db.get_pic_in_allbot(c.me.id)
+            if not catbox_link:
+                return await m.reply_text("Not found pic")
+            await db.set_pic_in_allbot(c.me.id, catbox_link, False)
+            await m.reply_text(f"Successfully removed pic `{catbox_link}`.")
+        else:
+            await m.reply_text(f"Invalid command: /delpic yes")
+    except Exception as e:
+        await m.reply_text(f"Error: {e.MESSAGE}")
+
+@Client.on_message(
+    ~filters.scheduled
+    & filters.command(["setpic"])
+    & ~filters.forwarded
+)
+async def setpicincatbox(c, m):
+    is_sudo = await db.get_alldlbot_sudouser(c.me.id, m.from_user.id)
+    protect_own = await db.get_alldlbot_by_user_id(m.from_user.id)
+    if not protect_own and not is_sudo:
+        return await m.reply_text("You are not allowed here.")
+    link = m.text.split(" ", 1)[1] if len(m.command) > 1 else None
+    if not link:
+        return await m.reply_text("Example: `/setpic https://files.catbox.moe/y93h4b.jpg`")
+    if not link.startswith("https://files.catbox.moe/"):
+        return await m.reply_text("Invalid Link")
+    try:
+        await db.set_pic_in_allbot(c.me.id, link, True)
+        await m.reply_text(f"Successfully added pic set `{link}`.")
+    except Exception as e:
+        await m.reply_text(f"Error: {e.MESSAGE}")
+
+@Client.on_message(
+    ~filters.scheduled
+    & filters.command(["rmdup"])
+    & ~filters.forwarded
+)
+async def duplicate_remove(c, m):
+    is_sudo = await db.get_alldlbot_sudouser(c.me.id, m.from_user.id)
+    protect_own = await db.get_alldlbot_by_user_id(m.from_user.id)
+    if not protect_own and not is_sudo:
+        return await m.reply_text("You are not allowed here.")
+    if m.chat.type.value != "supergroup":
+        return await m.reply_text("You can only group public not private")
+    await db.update_alldlbot_broadcast_in_group(c.me.id, m.chat.id, "add")
+    user_id = None
+    if not m.reply_to_message:
+        if len(m.command) < 2:
+            return await m.reply_text(
+                "Reply to a user or pass a user_id to remvoe duplicate"
+            )
+        try:
+            getuser = m.command[1]
+        except Exception as e:
+            return await m.reply_text(f"`{str(e)}`")
+    else:
+        getuser = m.reply_to_message.from_user.id
+    try:
+        user_id = (await c.get_users(getuser)).id
+        await db.update_alldlbot_broadcast(c.me.id, user_id, "remove")
+        await m.reply_text(f"Successfully remove duplicate `{user_id}` from bots.")
+    except Exception as e:
+        await m.reply_text(f"Error: {e.MESSAGE}")
+ 
+@Client.on_message(
+    ~filters.scheduled
+    & filters.command(["addjoin"])
+    & ~filters.forwarded
+)
+async def auto_force_sub(client: Client, message: Message):
+    protect_own = await db.get_alldlbot_by_user_id(message.from_user.id)
+    if not protect_own:
+        return await message.reply_text("You are not allowed to add a force sub.")
+
+    if len(message.command) < 2:
+        return await message.reply_text("Please provide a channel username or ID.")
+
+    channel = message.command[1]
+    await db.add_forcesub_only_bot(client.me.id, channel)
+    await message.reply_text("Successfully added to force sub.")
+
+@Client.on_message(
+    ~filters.scheduled
+    & filters.command(["nobutton"])
+    & ~filters.forwarded
+)
+async def mode_button(client, message: Message):
+    is_sudo = await db.get_alldlbot_sudouser(client.me.id, message.from_user.id)
+    protect_own = await db.get_alldlbot_by_user_id(message.from_user.id)
+    if not protect_own and not is_sudo:
+        return await m.reply_text("You are not allowed here.") # type: ignore
+
+    if len(message.command) < 2:
+        return await message.reply_text(f"**Please provide a cmd /nobutton on/off to start button disabled or enabled")
+
+    cmd = message.command[1].lower().strip()
+    if cmd in ["on", "yes"]:
+        await db.add_alldlbot_by_no_button(client.me.id, True)
+        await message.reply_text(f"**Button disabled now!**")
+    elif cmd in ["off", "no"]:
+        await db.add_alldlbot_by_no_button(client.me.id, False)
+        await message.reply_text(f"**Button enabled now!**")
+    
+@Client.on_message(
+    ~filters.scheduled
+    & filters.command(["ttdl"])
+    & ~filters.forwarded
+)
+async def tiktok_downloader(client: Client, message: Message):
+    user_id = message.from_user.id
+    if await db.get_alldlbot_is_blacklist_user(client.me.id, user_id):
+        return
+    if message.chat.type.value != "supergroup":
+        return await message.reply_text("You can only group public not private")
+    await db.update_alldlbot_broadcast_in_group(client.me.id, message.chat.id, "add")
+    user_name = message.from_user.first_name
+    nn = "[" + user_name + "](tg://user?id=" + str(user_id) + ")"
+    if not await db.get_forcesub_only_bot(client.me.id):
+        return await message.reply_text("This is the command /addjoin username channel and becomes admin on the channel")
+    update_channel = await db.get_forcesub_only_bot(client.me.id)
+    if update_channel:
+        try:
+            user = await client.get_chat_member(update_channel, user_id)
+            if user.status == ChatMemberStatus.BANNED:
+                await client.send_message(
+                    message.chat.id,
+                    text=f"**❌ {nn} anda telah di blokir dari grup dukungan**",
+                    disable_web_page_preview=True,
+                )
+                return
+        except UserNotParticipant:
+            await client.send_message(
+                message.chat.id,
+                text=f"**👋🏻 Halo {nn}\nᴜɴᴛᴜᴋ ᴍᴇɴɢʜɪɴᴅᴀʀɪ ᴘᴇɴɢɢᴜɴᴀᴀɴ ʏᴀɴɢ ʙᴇʀʟᴇʙɪʜᴀɴ ʙᴏᴛ ɪɴɪ ᴅɪ ᴋʜᴜsᴜsᴋᴀɴ ᴜɴᴛᴜᴋ ʏᴀɴɢ sᴜᴅᴀʜ ᴊᴏɪɴ ᴅɪ ᴄʜᴀɴɴᴇʟ ᴋᴀᴍɪ​!**",
+                reply_markup=InlineKeyboardMarkup(
+                    [
+                        [
+                            InlineKeyboardButton(
+                                "Jᴏɪɴ Cʜᴀɴɴᴇʟ Dᴜʟᴜ",
+                                url=f"https://t.me/{update_channel}",
+                            )
+                        ]
+                    ]
+                ),
+            )
+        except ChatAdminRequired:
+            return await message.reply_text("Chat admins Required: before /addjoin username without @ and add bot to your channel as admin")
+            return
+    query_url = message.text.split(" ", 1)[1] if len(message.command) > 1 else None
+    if not query_url:
+        return await message.reply_text("?")
+    if not is_tiktok_url(query_url):
+        return await message.reply_text("Invalid link")
+    callback_data = generate_callback_data(message.from_user.id, query_url)
+    keyboard = InlineKeyboardMarkup(
+        [
+            [
+                InlineKeyboardButton(
+                    text="Audio Download",
+                    callback_data=callback_data
+                )
+            ]
+        ]
+    )
+    try:
+        dll = await message.reply_text("Processing....")
+        response = await Tiktok.download(TIKTOK_WEB, query_url)
+        await message.reply_video(
+            response[0],
+            reply_markup=keyboard,
+            disable_notification=True
+        )
+        await dll.delete()
+    except Exception as e:
+        LOGS.info(str(e))
+        await dll.delete()
+        await message.reply_text(f"Error: {str(e)}")
+
+async def TeraboxDL(url):
+    try:
+        headers = {"x-api-key": os.environ.get("AKENOX_KEY")}
+        async with httpx.AsyncClient() as clientv:
+            response = await clientv.get(
+                f"https://randydev-ryu-js.hf.space/api/v1/dl/terabox-v4?url={url}",
+                headers=headers
+            )
+            response_json = response.json()
+            data = response_json.get("message", {}).get("resuls", "")
+
+        pattern = r"#EXTINF:\d+,\s*(https[^\s]+)"
+        matches = re.findall(pattern, data)
+
+        return {
+            "video_url": matches[0].split("?ulink=")[1] if matches else None,
+            "video_url_2": matches[1].split("?ulink=")[1] if len(matches) > 1 else None
+        }
+
+    except Exception as e:
+        return {"error": str(e)}
+
+async def download_m3u8(url, save_path="terabox.mp4"):
+    api_url = f"https://teraboxdownloaderonline.com/api/download-m3u8?terabox_link={url}"
+    
+    async with httpx.AsyncClient() as clientv:
+        response = await clientv.get(api_url)
+        if response.status_code != 200:
+            return None
+        with open(save_path, "wb") as file:
+            file.write(response.content)
+    return save_path
+
+@Client.on_message(
+    ~filters.scheduled
+    & filters.command(["terabox2dl"])
+    & ~filters.forwarded
+)
+async def terabox2_cmd(client: Client, message: Message):
+    user_id = message.from_user.id
+    user_name = message.from_user.first_name
+    nn = f"[{user_name}](tg://user?id={user_id})"
+
+    update_channel = await db.get_forcesub_only_bot(client.me.id)
+    if update_channel:
+        try:
+            user = await client.get_chat_member(update_channel, user_id)
+            if user.status == ChatMemberStatus.BANNED:
+                return await message.reply_text(f"❌ {nn} Anda telah diblokir dari grup dukungan.")
+        except UserNotParticipant:
+            return await message.reply_text(
+                f"👋🏻 Halo {nn}, Anda perlu join channel kami untuk menggunakan bot ini.",
+                reply_markup=InlineKeyboardMarkup([
+                    [InlineKeyboardButton("Join Channel", url=f"https://t.me/{update_channel}")]
+                ])
+            )
+
+    link = message.text.split(" ", 1)[1] if len(message.command) > 1 else None
+    if not link:
+        return await message.reply_text("Silakan masukkan link Terabox v2.")
+
+    pro = await message.reply_text("🚀 **Processing...**")
+
+    mp4_file = await download_m3u8(link)
+    if not mp4_file:
+        return await pro.edit_text("❌ Gagal mendapatkan file mp4.")
+    
+    upload_text = "**⬆️ Uploading video...**"
+    thumb_path = "terabox.jpg"
+        
+    async with httpx.AsyncClient() as clientv:
+        async with clientv.stream("GET", "https://images3.memedroid.com/images/UPLOADED822/63c5a9ca185df.jpeg") as thumb_response:
+            async with aiofiles.open(thumb_path, "wb") as file:
+                await file.write(await thumb_response.aread())
+                
+    await pro.edit_text(upload_text)
+    await message.reply_video(
+        mp4_file,
+        caption=f"• Powered by {client.me.mention}",
+        thumb=thumb_path,
+        progress=progress,
+        progress_args=(
+            pro,
+            time.time(),
+            "⬆️ Uploading video...."
+        )
+    )
+    os.remove(thumb_path)
+    os.remove(mp4_file)
+    await pro.delete()
+
+
+@Client.on_message(
+    ~filters.scheduled & filters.command(["teraboxdl"]) & ~filters.forwarded
+)
+async def terabox_cmd(client: Client, message):
+    user_id = message.from_user.id
+    if await db.get_alldlbot_is_blacklist_user(client.me.id, user_id):
+        return
+
+    user_name = message.from_user.first_name
+    nn = f"[{user_name}](tg://user?id={user_id})"
+
+    update_channel = await db.get_forcesub_only_bot(client.me.id)
+    if update_channel:
+        try:
+            user = await client.get_chat_member(update_channel, user_id)
+            if user.status == ChatMemberStatus.BANNED:
+                return await message.reply_text(f"❌ {nn}, Anda telah diblokir dari grup dukungan.")
+        except UserNotParticipant:
+            return await message.reply_text(
+                f"👋🏻 Halo {nn}, untuk menggunakan bot ini, silakan join channel kami!",
+                reply_markup=InlineKeyboardMarkup(
+                    [[InlineKeyboardButton("Join Channel", url=f"https://t.me/{update_channel}")]]
+                ),
+            )
+        except ChatAdminRequired:
+            return await message.reply_text("Chat admin diperlukan: /addjoin username tanpa @ dan tambahkan bot ke channel sebagai admin.")
+
+    if len(message.command) < 2:
+        return await message.reply_text("❌ Harap masukkan link untuk Terabox Downloader.")
+
+    link = message.text.split(" ", 1)[1]
+    pro = await message.reply_text("⏳ Processing...")
+
+    try:
+        response = await TeraboxDL(link)
+        if "error" in response or not response["video_url_2"]:
+            return await pro.edit_text("❌ Error: Gagal mendapatkan URL video.")
+
+        video_url = urllib.parse.unquote(response["video_url_2"])
+        video_path = "terabox.mp4"
+        thumb_path = "terabox.jpg"
+        
+        async with httpx.AsyncClient() as clientv:
+            async with clientv.stream("GET", video_url) as vid_response:
+                if vid_response.status_code != 200:
+                    return await pro.edit_text("❌ Error saat mengunduh video.")
+                
+                async with aiofiles.open(video_path, "wb") as file:
+                    async for chunk in vid_response.aiter_bytes():
+                        await file.write(chunk)
+
+            async with clientv.stream("GET", "https://images3.memedroid.com/images/UPLOADED822/63c5a9ca185df.jpeg") as thumb_response:
+                async with aiofiles.open(thumb_path, "wb") as file:
+                    await file.write(await thumb_response.aread())
+
+        await pro.edit_text("⬆️ Uploading video...")
+        await message.reply_video(
+            video_path,
+            caption=f"• Powered by {client.me.mention}",
+            thumb=thumb_path,
+            progress=progress,
+            progress_args=(
+                pro,
+                time.time(),
+                "⬆️ Uploading video...."
+            )
+        )
+
+        await pro.delete()
+        os.remove(video_path)
+        os.remove(thumb_path)
+
+    except Exception as e:
+        await pro.edit_text(f"❌ Error: {str(e)}")
+
+@Client.on_message(
+    ~filters.scheduled
+    & filters.command(["twdl"])
+    & ~filters.forwarded
+)
+async def twdl_cmd(client: Client, message: Message):
+    user_id = message.from_user.id
+    if await db.get_alldlbot_is_blacklist_user(client.me.id, user_id):
+        return
+    if message.chat.type.value != "supergroup":
+        return await message.reply_text("You can only group public not private")
+    await db.update_alldlbot_broadcast_in_group(client.me.id, message.chat.id, "add")
+    user_name = message.from_user.first_name
+    nn = "[" + user_name + "](tg://user?id=" + str(user_id) + ")"
+    if not await db.get_forcesub_only_bot(client.me.id):
+        return await message.reply_text("This is the command /addjoin username channel and becomes admin on the channel")
+    update_channel = await db.get_forcesub_only_bot(client.me.id)
+    if update_channel:
+        try:
+            user = await client.get_chat_member(update_channel, user_id)
+            if user.status == ChatMemberStatus.BANNED:
+                await client.send_message(
+                    message.chat.id,
+                    text=f"**❌ {nn} anda telah di blokir dari grup dukungan**",
+                    disable_web_page_preview=True,
+                )
+                return
+        except UserNotParticipant:
+            await client.send_message(
+                message.chat.id,
+                text=f"**👋🏻 Halo {nn}\nᴜɴᴛᴜᴋ ᴍᴇɴɢʜɪɴᴅᴀʀɪ ᴘᴇɴɢɢᴜɴᴀᴀɴ ʏᴀɴɢ ʙᴇʀʟᴇʙɪʜᴀɴ ʙᴏᴛ ɪɴɪ ᴅɪ ᴋʜᴜsᴜsᴋᴀɴ ᴜɴᴛᴜᴋ ʏᴀɴɢ sᴜᴅᴀʜ ᴊᴏɪɴ ᴅɪ ᴄʜᴀɴɴᴇʟ ᴋᴀᴍɪ​!**",
+                reply_markup=InlineKeyboardMarkup(
+                    [
+                        [
+                            InlineKeyboardButton(
+                                "Jᴏɪɴ Cʜᴀɴɴᴇʟ Dᴜʟᴜ",
+                                url=f"https://t.me/{update_channel}",
+                            )
+                        ]
+                    ]
+                ),
+            )
+            return
+        except ChatAdminRequired:
+            return await message.reply_text("Chat admins Required: before /addjoin username without @ and add bot to your channel as admin")
+
+    link = message.text.split(" ", 1)[1] if len(message.command) > 1 else None
+    pro = await message.reply_text("Processing.....")
+    if not link:
+        return await pro.edit_text("Please link for Twitter.")
+    urls = re.sub(r"(https?:\/\/)(?:www\.)?x\.com", r"\1twitter.com", link)
+    if not urls:
+        return await pro.edit_text("invalid link.")
+    try:
+        response = await js.fetch_and_extract_urls(
+            f"https://snapdownloader.com/tools/twitter-video-downloader/download?url={urls}",
+            href_url=r"https://video",
+            return_unsafe_href=True
+        )
+        upload_text = f"**⬆️ 𝖴𝗉𝗅𝗈𝖺𝖽𝗂𝗇𝗀 video ...**"
+        await pro.edit_text(upload_text)
+        await message.reply_video(
+            response[0],
+            caption=f"• Powered by {client.me.mention}",
+            progress=progress,
+            progress_args=(
+                pro,
+                time.time(),
+                upload_text
+            )
+        )
+        await pro.delete()
+    except Exception as e:
+        LOGS.error(str(e))
+        await pro.edit_text("Error: Try invalid")
+
+@Client.on_message(
+    ~filters.scheduled
+    & filters.command(["fbdl"])
+    & ~filters.forwarded
+)
+async def fbdl_cmd(client: Client, message: Message):
+    user_id = message.from_user.id
+    if await db.get_maintance():
+        return await message.reply_text("Bot is in maintance mode. By @xpushz")
+
+    if await db.get_alldlbot_is_blacklist_user(client.me.id, user_id):
+        return
+
+    if message.chat.type.value != "supergroup":
+        return await message.reply_text("You can only group public not private")
+    await db.update_alldlbot_broadcast_in_group(client.me.id, message.chat.id, "add")
+    user_name = message.from_user.first_name
+    nn = "[" + user_name + "](tg://user?id=" + str(user_id) + ")"
+    if not await db.get_forcesub_only_bot(client.me.id):
+        return await message.reply_text("This is the command /addjoin username channel and becomes admin on the channel")
+    update_channel = await db.get_forcesub_only_bot(client.me.id)
+    if update_channel:
+        try:
+            user = await client.get_chat_member(update_channel, user_id)
+            if user.status == ChatMemberStatus.BANNED:
+                await client.send_message(
+                    message.chat.id,
+                    text=f"**❌ {nn} anda telah di blokir dari grup dukungan**",
+                    disable_web_page_preview=True,
+                )
+                return
+        except UserNotParticipant:
+            await client.send_message(
+                message.chat.id,
+                text=f"**👋🏻 Halo {nn}\nᴜɴᴛᴜᴋ ᴍᴇɴɢʜɪɴᴅᴀʀɪ ᴘᴇɴɢɢᴜɴᴀᴀɴ ʏᴀɴɢ ʙᴇʀʟᴇʙɪʜᴀɴ ʙᴏᴛ ɪɴɪ ᴅɪ ᴋʜᴜsᴜsᴋᴀɴ ᴜɴᴛᴜᴋ ʏᴀɴɢ sᴜᴅᴀʜ ᴊᴏɪɴ ᴅɪ ᴄʜᴀɴɴᴇʟ ᴋᴀᴍɪ​!**",
+                reply_markup=InlineKeyboardMarkup(
+                    [
+                        [
+                            InlineKeyboardButton(
+                                "Jᴏɪɴ Cʜᴀɴɴᴇʟ Dᴜʟᴜ",
+                                url=f"https://t.me/{update_channel}",
+                            )
+                        ]
+                    ]
+                ),
+            )
+            return
+        except ChatAdminRequired:
+            return await message.reply_text("Chat admins Required: before /addjoin username without @ and add bot to your channel as admin")
+
+    link = message.text.split(" ", 1)[1] if len(message.command) > 1 else None
+    pro = await message.reply_text("Processing.....")
+    if not link:
+        return await pro.edit_text("Please link for facebook.")
+    if not link.startswith("https://www.facebook.com/"):
+        return await pro.edit_text("invalid link.")
+    try:
+        response = await js.AkenoXJs(
+            js.types.DifferentAPIDefault()
+        ).connect().downloader.create(
+            "fb",
+            params_data={"url": link},
+            is_obj=True
+        )
+        upload_text = f"**⬆️ 𝖴𝗉𝗅𝗈𝖺𝖽𝗂𝗇𝗀 video ...**"
+        await pro.edit_text(upload_text)
+        await message.reply_video(
+            response.results.video[0].url,
+            caption=f"• Powered by {client.me.mention}",
+            progress=progress,
+            progress_args=(
+                pro,
+                time.time(),
+                upload_text
+            )
+        )
+        await pro.delete()
+    except Exception as e:
+        LOGS.error(str(e))
+        await pro.edit_text("Error: Try invalid")
+
+@Client.on_message(
+    ~filters.scheduled
+    & filters.command(["igdl"])
+    & ~filters.forwarded
+)
+async def igdl_cmd(client: Client, message: Message):
+    user_id = message.from_user.id
+    if await db.get_maintance():
+        return await message.reply_text("Bot is in maintance mode. By @xpushz")
+
+    if await db.get_alldlbot_is_blacklist_user(client.me.id, user_id):
+        return
+    if message.chat.type.value != "supergroup":
+        return await message.reply_text("You can only group public not private")
+    await db.update_alldlbot_broadcast_in_group(client.me.id, message.chat.id, "add")
+    user_name = message.from_user.first_name
+    nn = "[" + user_name + "](tg://user?id=" + str(user_id) + ")"
+    if not await db.get_forcesub_only_bot(client.me.id):
+        return await message.reply_text("This is the command /addjoin username channel and becomes admin on the channel")
+    update_channel = await db.get_forcesub_only_bot(client.me.id)
+    if update_channel:
+        try:
+            user = await client.get_chat_member(update_channel, user_id)
+            if user.status == ChatMemberStatus.BANNED:
+                await client.send_message(
+                    message.chat.id,
+                    text=f"**❌ {nn} anda telah di blokir dari grup dukungan**",
+                    disable_web_page_preview=True,
+                )
+                return
+        except UserNotParticipant:
+            await client.send_message(
+                message.chat.id,
+                text=f"**👋🏻 Halo {nn}\nᴜɴᴛᴜᴋ ᴍᴇɴɢʜɪɴᴅᴀʀɪ ᴘᴇɴɢɢᴜɴᴀᴀɴ ʏᴀɴɢ ʙᴇʀʟᴇʙɪʜᴀɴ ʙᴏᴛ ɪɴɪ ᴅɪ ᴋʜᴜsᴜsᴋᴀɴ ᴜɴᴛᴜᴋ ʏᴀɴɢ sᴜᴅᴀʜ ᴊᴏɪɴ ᴅɪ ᴄʜᴀɴɴᴇʟ ᴋᴀᴍɪ!**",
+                reply_markup=InlineKeyboardMarkup(
+                    [
+                        [
+                            InlineKeyboardButton(
+                                "Jᴏɪɴ Cʜᴀɴɴᴇʟ Dᴜʟᴜ",
+                                url=f"https://t.me/{update_channel}",
+                            )
+                        ]
+                    ]
+                ),
+            )
+            return
+        except ChatAdminRequired:
+            return await message.reply_text("Chat admins Required: before /addjoin username without @ and add bot to your channel as admin")
+
+    link = message.text.split(" ", 1)[1] if len(message.command) > 1 else None
+    pro = await message.reply_text("Processing.....")
+    if not link:
+        return await pro.edit_text("Please link for Instagram.")
+    if not link.startswith("https://www.instagram.com/"):
+        return await pro.edit_text("invalid link.")
+    try:
+        params = {"link": link, "version": "v4"}
+        response = requests.get(f"https://learn.maiysacollection.com/api/v1/dl/ig/custom", params=params).json()
+        if response["response"]["results"] is None:
+            return await pro.edit_text("Not Found.")
+        upload_text = f"**⬆️ 𝖴𝗉𝗅𝗈𝖺𝖽𝗂𝗇𝗀 video ...**"
+        await pro.edit_text(upload_text)
+        await message.reply_video(
+            response["response"]["results"]["results"][0]["variants"][0]["url"],
+            caption=f"• Powered by {client.me.mention}",
+            progress=progress,
+            progress_args=(
+                pro,
+                time.time(),
+                upload_text
+            )
+        )
+        await pro.delete()
+    except Exception as e:
+        LOGS.error(str(e))
+        await pro.edit_text("Error: Try invalid")
+
+async def input_user(message: Message) -> str:
+    """Get the input from the user"""
+    if len(message.command) < 2:
+        output = ""
+    else:
+        try:
+            output = message.text.split(" ", 1)[1].strip() or ""
+        except IndexError:
+            output = ""
+    return output
+
+@Client.on_message(
+    ~filters.scheduled
+    & filters.command(["ytsa"])
+    & ~filters.forwarded
+)
+async def youtube_search_audio(client: Client, message: Message):
+    user_id = message.from_user.id
+    if await db.get_alldlbot_is_blacklist_user(client.me.id, user_id):
+        return
+    user_name = message.from_user.first_name
+    nn = "[" + user_name + "](tg://user?id=" + str(user_id) + ")"
+    if not await db.get_forcesub_only_bot(client.me.id):
+        return await message.reply_text("This is the command /addjoin username channel and becomes admin on the channel")
+    update_channel = await db.get_forcesub_only_bot(client.me.id)
+    if update_channel:
+        try:
+            user = await client.get_chat_member(update_channel, user_id)
+            if user.status == ChatMemberStatus.BANNED:
+                await client.send_message(
+                    message.chat.id,
+                    text=f"**❌ {nn} anda telah di blokir dari grup dukungan**",
+                    disable_web_page_preview=True,
+                )
+                return
+        except UserNotParticipant:
+            await client.send_message(
+                message.chat.id,
+                text=f"**👋🏻 Halo {nn}\nᴜɴᴛᴜᴋ ᴍᴇɴɢʜɪɴᴅᴀʀɪ ᴘᴇɴɢɢᴜɴᴀᴀɴ ʏᴀɴɢ ʙᴇʀʟᴇʙɪʜᴀɴ ʙᴏᴛ ɪɴɪ ᴅɪ ᴋʜᴜsᴜsᴋᴀɴ ᴜɴᴛᴜᴋ ʏᴀɴɢ sᴜᴅᴀʜ ᴊᴏɪɴ ᴅɪ ᴄʜᴀɴɴᴇʟ ᴋᴀᴍɪ​!**",
+                reply_markup=InlineKeyboardMarkup(
+                    [
+                        [
+                            InlineKeyboardButton(
+                                "Jᴏɪɴ Cʜᴀɴɴᴇʟ Dᴜʟᴜ",
+                                url=f"https://t.me/{update_channel}",
+                            )
+                        ]
+                    ]
+                ),
+            )
+            return
+        except ChatAdminRequired:
+            return await message.reply_text(f"Chat admins Required: before /addjoin username without @ and add bot to your channel as admin")
+
+    if len(message.command) < 2:
+        return await message.reply_text(
+            "Give a valid youtube search to download audio."
+        )
+    query = await input_user(message)
+    results = YoutubeSearch(query, max_results=5).to_dict()
+    watch = results[0]["url_suffix"]
+    url_suffix = watch.split("/")[1]
+    okk = f"https://youtube.com/{url_suffix}"
+    pro = await message.reply_text("Checking ...")
+    status, url = YoutubeDriver.check_url(okk)
+    if not status:
+        return await pro.edit_text(url)
+    if client.me.is_premium:
+        await pro.edit_text(f"{custom_loading}__Downloading audio ...__")
+    else:
+        await pro.edit_text(f"__Downloading audio ...__")
+    try:
+        with YoutubeDL(YoutubeDriver.song_options()) as ytdl:
+            yt_data = ytdl.extract_info(url, False)
+            yt_file = ytdl.prepare_filename(yt_data)
+            ytdl.process_info(yt_data)
+        if client.me.is_premium:
+            upload_text = f"**{custom_loading}𝖴𝗉𝗅𝗈𝖺𝖽𝗂𝗇𝗀 𝖲𝗈𝗇𝗀 ...** \n\n**𝖳𝗂𝗍𝗅𝖾:** `{yt_data['title'][:50]}`\n**𝖢𝗁𝖺𝗇𝗇𝖾𝗅:** `{yt_data['channel']}`"
+        else:
+            upload_text = f"**𝖴𝗉𝗅𝗈𝖺𝖽𝗂𝗇𝗀 𝖲𝗈𝗇𝗀 ...** \n\n**𝖳𝗂𝗍𝗅𝖾:** `{yt_data['title'][:50]}`\n**𝖢𝗁𝖺𝗇𝗇𝖾𝗅:** `{yt_data['channel']}`"
+        await pro.edit_text(upload_text)
+        response = requests.get(f"https://i.ytimg.com/vi/{yt_data['id']}/hqdefault.jpg")
+        with open(f"{yt_file}.jpg", "wb") as f:
+            f.write(response.content)
+        await message.reply_audio(
+            f"{yt_file}.mp3",
+            caption=f"**🎧 𝖳𝗂𝗍𝗅𝖾:** {yt_data['title']} \n\n**👀 𝖵𝗂𝖾𝗐𝗌:** `{yt_data['view_count']}` \n**⌛ 𝖣𝗎𝗋𝖺𝗍𝗂𝗈𝗇:** `{secs_to_mins(int(yt_data['duration']))}`",
+            duration=int(yt_data["duration"]),
+            performer="[Akeno UB]",
+            title=yt_data["title"],
+            thumb=f"{yt_file}.jpg",
+            progress=progress,
+            progress_args=(
+                pro,
+                time.time(),
+                upload_text,
+            ),
+        )
+        await pro.delete()
+    except Exception as e:
+        return await pro.edit_text(f"**🍀 Audio not Downloaded:** `{e}`")
+    try:
+        os.remove(f"{yt_file}.jpg")
+        os.remove(f"{yt_file}.mp3")
+    except:
+        pass
+
+@Client.on_message(
+    ~filters.scheduled
+    & filters.command(["yta"])
+    & ~filters.forwarded
+)
+async def youtube_audio(client: Client, message: Message):
+    user_id = message.from_user.id
+    if await db.get_alldlbot_is_blacklist_user(client.me.id, user_id):
+        return
+    user_name = message.from_user.first_name
+    nn = "[" + user_name + "](tg://user?id=" + str(user_id) + ")"
+    if not await db.get_forcesub_only_bot(client.me.id):
+        return await message.reply_text("This is the command /addjoin username channel and becomes admin on the channel")
+    update_channel = await db.get_forcesub_only_bot(client.me.id)
+    if update_channel:
+        try:
+            user = await client.get_chat_member(update_channel, user_id)
+            if user.status == ChatMemberStatus.BANNED:
+                await client.send_message(
+                    message.chat.id,
+                    text=f"**❌ {nn} anda telah di blokir dari grup dukungan**",
+                    disable_web_page_preview=True,
+                )
+                return
+        except UserNotParticipant:
+            await client.send_message(
+                message.chat.id,
+                text=f"**👋🏻 Halo {nn}\nᴜɴᴛᴜᴋ ᴍᴇɴɢʜɪɴᴅᴀʀɪ ᴘᴇɴɢɢᴜɴᴀᴀɴ ʏᴀɴɢ ʙᴇʀʟᴇʙɪʜᴀɴ ʙᴏᴛ ɪɴɪ ᴅɪ ᴋʜᴜsᴜsᴋᴀɴ ᴜɴᴛᴜᴋ ʏᴀɴɢ sᴜᴅᴀʜ ᴊᴏɪɴ ᴅɪ ᴄʜᴀɴɴᴇʟ ᴋᴀᴍɪ​!**",
+                reply_markup=InlineKeyboardMarkup(
+                    [
+                        [
+                            InlineKeyboardButton(
+                                "Jᴏɪɴ Cʜᴀɴɴᴇʟ Dᴜʟᴜ",
+                                url=f"https://t.me/{update_channel}",
+                            )
+                        ]
+                    ]
+                ),
+            )
+            return
+        except ChatAdminRequired:
+            return await message.reply_text("Chat admins Required: before /addjoin username without @ and add bot to your channel as admin")
+
+    if len(message.command) < 2:
+        return await message.reply_text(
+            "Give a valid youtube link to download audio."
+        )
+    query = await input_user(message)
+    pro = await message.reply_text("Checking ...")
+    status, url = YoutubeDriver.check_url(query)
+    if not status:
+        return await pro.edit_text(url)
+    if client.me.is_premium:
+        await pro.edit_text(f"{custom_loading}__Downloading audio ...__")
+    else:
+        await pro.edit_text(f"__Downloading audio ...__")
+    try:
+        with YoutubeDL(YoutubeDriver.song_options()) as ytdl:
+            yt_data = ytdl.extract_info(url, False)
+            yt_file = ytdl.prepare_filename(yt_data)
+            ytdl.process_info(yt_data)
+        if client.me.is_premium:
+            upload_text = f"**{custom_loading}𝖴𝗉𝗅𝗈𝖺𝖽𝗂𝗇𝗀 𝖲𝗈𝗇𝗀 ...** \n\n**𝖳𝗂𝗍𝗅𝖾:** `{yt_data['title'][:50]}`\n**𝖢𝗁𝖺𝗇𝗇𝖾𝗅:** `{yt_data['channel']}`"
+        else:
+            upload_text = f"**𝖴𝗉𝗅𝗈𝖺𝖽𝗂𝗇𝗀 𝖲𝗈𝗇𝗀 ...** \n\n**𝖳𝗂𝗍𝗅𝖾:** `{yt_data['title'][:50]}`\n**𝖢𝗁𝖺𝗇𝗇𝖾𝗅:** `{yt_data['channel']}`"
+        await pro.edit_text(upload_text)
+        response = requests.get(f"https://i.ytimg.com/vi/{yt_data['id']}/hqdefault.jpg")
+        with open(f"{yt_file}.jpg", "wb") as f:
+            f.write(response.content)
+        await message.reply_audio(
+            f"{yt_file}.mp3",
+            caption=f"**🎧 𝖳𝗂𝗍𝗅𝖾:** {yt_data['title']} \n\n**👀 𝖵𝗂𝖾𝗐𝗌:** `{yt_data['view_count']}` \n**⌛ 𝖣𝗎𝗋𝖺𝗍𝗂𝗈𝗇:** `{secs_to_mins(int(yt_data['duration']))}`",
+            duration=int(yt_data["duration"]),
+            performer="[Akeno UB]",
+            title=yt_data["title"],
+            thumb=f"{yt_file}.jpg",
+            progress=progress,
+            progress_args=(
+                pro,
+                time.time(),
+                upload_text,
+            ),
+        )
+        await pro.delete()
+    except Exception as e:
+        return await pro.edit_text(f"**🍀 Audio not Downloaded:** `{e}`")
+    try:
+        os.remove(f"{yt_file}.jpg")
+        os.remove(f"{yt_file}.mp3")
+    except:
+        pass
+
+@Client.on_message(
+    ~filters.scheduled
+    & filters.command(["ytva"])
+    & ~filters.forwarded
+)
+async def ytvideo_search(client: Client, message: Message):
+    user_id = message.from_user.id
+    if await db.get_alldlbot_is_blacklist_user(client.me.id, user_id):
+        return
+    user_name = message.from_user.first_name
+    nn = "[" + user_name + "](tg://user?id=" + str(user_id) + ")"
+    if not await db.get_forcesub_only_bot(client.me.id):
+        return await message.reply_text("This is the command /addjoin username channel and becomes admin on the channel")
+    update_channel = await db.get_forcesub_only_bot(client.me.id)
+    if update_channel:
+        try:
+            user = await client.get_chat_member(update_channel, user_id)
+            if user.status == ChatMemberStatus.BANNED:
+                await client.send_message(
+                    message.chat.id,
+                    text=f"**❌ {nn} anda telah di blokir dari grup dukungan**",
+                    disable_web_page_preview=True,
+                )
+                return
+        except UserNotParticipant:
+            await client.send_message(
+                message.chat.id,
+                text=f"**👋🏻 Halo {nn}\nᴜɴᴛᴜᴋ ᴍᴇɴɢʜɪɴᴅᴀʀɪ ᴘᴇɴɢɢᴜɴᴀᴀɴ ʏᴀɴɢ ʙᴇʀʟᴇʙɪʜᴀɴ ʙᴏᴛ ɪɴɪ ᴅɪ ᴋʜᴜsᴜsᴋᴀɴ ᴜɴᴛᴜᴋ ʏᴀɴɢ sᴜᴅᴀʜ ᴊᴏɪɴ ᴅɪ ᴄʜᴀɴɴᴇʟ ᴋᴀᴍɪ​!**",
+                reply_markup=InlineKeyboardMarkup(
+                    [
+                        [
+                            InlineKeyboardButton(
+                                "Jᴏɪɴ Cʜᴀɴɴᴇʟ Dᴜʟᴜ",
+                                url=f"https://t.me/{update_channel}",
+                            )
+                        ]
+                    ]
+                ),
+            )
+            return
+        except ChatAdminRequired:
+            return await message.reply_text(f"Chat admins Required: before /addjoin username without @ and add bot to your channel as admin")
+
+    if len(message.command) < 2:
+        return await message.reply_text(
+            "Give a valid youtube search to download video."
+        )
+    query = await input_user(message)
+    results = YoutubeSearch(query, max_results=5).to_dict()
+    watch = results[0]["url_suffix"]
+    url_suffix = watch.split("/")[1]
+    okk = f"https://youtube.com/{url_suffix}"
+    pro = await message.reply_text("Checking ...")
+    status, url = YoutubeDriver.check_url(okk)
+    if not status:
+        return await pro.edit_text(url)
+    if client.me.is_premium:
+        await pro.edit_text(f"{custom_loading}__Downloading audio ...__")
+    else:
+        await pro.edit_text(f"__Downloading audio ...__")
+    try:
+        with YoutubeDL(YoutubeDriver.video_options()) as ytdl:
+            yt_data = ytdl.extract_info(url, True)
+            yt_file = yt_data["id"]
+
+        if client.me.is_premium:
+            upload_text = f"**{custom_loading}𝖴𝗉𝗅𝗈𝖺𝖽𝗂𝗇𝗀 𝖲𝗈𝗇𝗀 ...** \n\n**𝖳𝗂𝗍𝗅𝖾:** `{yt_data['title'][:50]}`\n**𝖢𝗁𝖺𝗇𝗇𝖾𝗅:** `{yt_data['channel']}`"
+        else:
+            upload_text = f"**𝖴𝗉𝗅𝗈𝖺𝖽𝗂𝗇𝗀 𝖲𝗈𝗇𝗀 ...** \n\n**𝖳𝗂𝗍𝗅𝖾:** `{yt_data['title'][:50]}`\n**𝖢𝗁𝖺𝗇𝗇𝖾𝗅:** `{yt_data['channel']}`"
+        await pro.edit_text(upload_text)
+        response = requests.get(f"https://i.ytimg.com/vi/{yt_data['id']}/hqdefault.jpg")
+        with open(f"{yt_file}.jpg", "wb") as f:
+            f.write(response.content)
+        await message.reply_video(
+            f"{yt_file}.mp4",
+            caption=f"**🎧 𝖳𝗂𝗍𝗅𝖾:** {yt_data['title']} \n\n**👀 𝖵𝗂𝖾𝗐𝗌:** `{yt_data['view_count']}` \n**⌛ 𝖣𝗎𝗋𝖺𝗍𝗂𝗈𝗇:** `{secs_to_mins(int(yt_data['duration']))}`",
+            duration=int(yt_data["duration"]),
+            thumb=f"{yt_file}.jpg",
+            progress=progress,
+            progress_args=(
+                pro,
+                time.time(),
+                upload_text,
+            ),
+        )
+        await pro.delete()
+    except Exception as e:
+        return await pro.edit_text(f"**🍀 Video not Downloaded:** `{e}`")
+    try:
+        os.remove(f"{yt_file}.jpg")
+        os.remove(f"{yt_file}.mp4")
+    except:
+        pass
+
+@Client.on_message(
+    ~filters.scheduled
+    & filters.command(["ytv"])
+    & ~filters.forwarded
+)
+async def ytvideo(client: Client, message: Message):
+    user_id = message.from_user.id
+    if await db.get_alldlbot_is_blacklist_user(client.me.id, user_id):
+        return
+    user_name = message.from_user.first_name
+    nn = "[" + user_name + "](tg://user?id=" + str(user_id) + ")"
+    if not await db.get_forcesub_only_bot(client.me.id):
+        return await message.reply_text("This is the command /addjoin username channel and becomes admin on the channel")
+    update_channel = await db.get_forcesub_only_bot(client.me.id)
+    if update_channel:
+        try:
+            user = await client.get_chat_member(update_channel, user_id)
+            if user.status == ChatMemberStatus.BANNED:
+                await client.send_message(
+                    message.chat.id,
+                    text=f"**❌ {nn} anda telah di blokir dari grup dukungan**",
+                    disable_web_page_preview=True,
+                )
+                return
+        except UserNotParticipant:
+            await client.send_message(
+                message.chat.id,
+                text=f"**👋🏻 Halo {nn}\nᴜɴᴛᴜᴋ ᴍᴇɴɢʜɪɴᴅᴀʀɪ ᴘᴇɴɢɢᴜɴᴀᴀɴ ʏᴀɴɢ ʙᴇʀʟᴇʙɪʜᴀɴ ʙᴏᴛ ɪɴɪ ᴅɪ ᴋʜᴜsᴜsᴋᴀɴ ᴜɴᴛᴜᴋ ʏᴀɴɢ sᴜᴅᴀʜ ᴊᴏɪɴ ᴅɪ ᴄʜᴀɴɴᴇʟ ᴋᴀᴍɪ​!**",
+                reply_markup=InlineKeyboardMarkup(
+                    [
+                        [
+                            InlineKeyboardButton(
+                                "Jᴏɪɴ Cʜᴀɴɴᴇʟ Dᴜʟᴜ",
+                                url=f"https://t.me/{update_channel}",
+                            )
+                        ]
+                    ]
+                ),
+            )
+            return
+        except ChatAdminRequired:
+            return await message.reply_text("Chat admins Required: before /addjoin username without @ and add bot to your channel as admin")
+
+    if len(message.command) < 2:
+        return await message.reply_text(
+            "Give a valid youtube link to download video."
+        )
+    query = await input_user(message)
+    pro = await message.reply_text("Checking ...")
+    status, url = YoutubeDriver.check_url(query)
+    if not status:
+        return await pro.edit_text(url)
+    if client.me.is_premium:
+        await pro.edit_text(f"{custom_loading}__Downloading audio ...__")
+    else:
+        await pro.edit_text(f"__Downloading audio ...__")
+    try:
+        with YoutubeDL(YoutubeDriver.video_options()) as ytdl:
+            yt_data = ytdl.extract_info(url, True)
+            yt_file = yt_data["id"]
+
+        if client.me.is_premium:
+            upload_text = f"**{custom_loading}𝖴𝗉𝗅𝗈𝖺𝖽𝗂𝗇𝗀 𝖲𝗈𝗇𝗀 ...** \n\n**𝖳𝗂𝗍𝗅𝖾:** `{yt_data['title'][:50]}`\n**𝖢𝗁𝖺𝗇𝗇𝖾𝗅:** `{yt_data['channel']}`"
+        else:
+            upload_text = f"**𝖴𝗉𝗅𝗈𝖺𝖽𝗂𝗇𝗀 𝖲𝗈𝗇𝗀 ...** \n\n**𝖳𝗂𝗍𝗅𝖾:** `{yt_data['title'][:50]}`\n**𝖢𝗁𝖺𝗇𝗇𝖾𝗅:** `{yt_data['channel']}`"
+        await pro.edit_text(upload_text)
+        response = requests.get(f"https://i.ytimg.com/vi/{yt_data['id']}/hqdefault.jpg")
+        with open(f"{yt_file}.jpg", "wb") as f:
+            f.write(response.content)
+        await message.reply_video(
+            f"{yt_file}.mp4",
+            caption=f"**🎧 𝖳𝗂𝗍𝗅𝖾:** {yt_data['title']} \n\n**👀 𝖵𝗂𝖾𝗐𝗌:** `{yt_data['view_count']}` \n**⌛ 𝖣𝗎𝗋𝖺𝗍𝗂𝗈𝗇:** `{secs_to_mins(int(yt_data['duration']))}`",
+            duration=int(yt_data["duration"]),
+            thumb=f"{yt_file}.jpg",
+            progress=progress,
+            progress_args=(
+                pro,
+                time.time(),
+                upload_text,
+            ),
+        )
+        await pro.delete()
+    except Exception as e:
+        return await pro.edit_text(f"**🍀 Video not Downloaded:** `{e}`")
+    try:
+        os.remove(f"{yt_file}.jpg")
+        os.remove(f"{yt_file}.mp4")
+    except:
+        pass
+
+@Client.on_message(
+    ~filters.scheduled
+    & filters.command(["ytlink"])
+    & ~filters.forwarded
+)
+async def ytlink(client: Client, message: Message):
+    user_id = message.from_user.id
+    if await db.get_alldlbot_is_blacklist_user(client.me.id, user_id):
+        return
+    user_name = message.from_user.first_name
+    nn = "[" + user_name + "](tg://user?id=" + str(user_id) + ")"
+    if not await db.get_forcesub_only_bot(client.me.id):
+        return await message.reply_text("This is the command /addjoin username channel and becomes admin on the channel")
+    update_channel = await db.get_forcesub_only_bot(client.me.id)
+    if update_channel:
+        try:
+            user = await client.get_chat_member(update_channel, user_id)
+            if user.status == ChatMemberStatus.BANNED:
+                await client.send_message(
+                    message.chat.id,
+                    text=f"**❌ {nn} anda telah di blokir dari grup dukungan**",
+                    disable_web_page_preview=True,
+                )
+                return
+        except UserNotParticipant:
+            await client.send_message(
+                message.chat.id,
+                text=f"**👋🏻 Halo {nn}\nᴜɴᴛᴜᴋ ᴍᴇɴɢʜɪɴᴅᴀʀɪ ᴘᴇɴɢɢᴜɴᴀᴀɴ ʏᴀɴɢ ʙᴇʀʟᴇʙɪʜᴀɴ ʙᴏᴛ ɪɴɪ ᴅɪ ᴋʜᴜsᴜsᴋᴀɴ ᴜɴᴛᴜᴋ ʏᴀɴɢ sᴜᴅᴀʜ ᴊᴏɪɴ ᴅɪ ᴄʜᴀɴɴᴇʟ ᴋᴀᴍɪ​!**",
+                reply_markup=InlineKeyboardMarkup(
+                    [
+                        [
+                            InlineKeyboardButton(
+                                "Jᴏɪɴ Cʜᴀɴɴᴇʟ Dᴜʟᴜ",
+                                url=f"https://t.me/{update_channel}",
+                            )
+                        ]
+                    ]
+                ),
+            )
+            return
+        except ChatAdminRequired:
+            return await message.reply_text("Chat admins Required: before /addjoin username without @ and add bot to your channel as admin")
+
+    if len(message.command) < 2:
+        return await message.reply_text("Give something to search on youtube.")
+    query = await input_user(message)
+    pro = await message.reply_text("Searching ...")
+    try:
+        results = YoutubeDriver(query, 7).to_dict()
+    except Exception as e:
+        return await pro.edit_text(f"**🍀 Error:** `{e}`")
+    if not results:
+        return await pro.edit_text("No results found.")
+    text = f"**🔎 𝖳𝗈𝗍𝖺𝗅 𝖱𝖾𝗌𝗎𝗅𝗍𝗌 𝖥𝗈𝗎𝗇𝖽:** `{len(results)}`\n\n"
+    for result in results:
+        text += f"**𝖳𝗂𝗍𝗅𝖾:** `{result['title'][:50]}`\n**𝖢𝗁𝖺𝗇𝗇𝖾𝗅:** `{result['channel']}`\n**𝖵𝗂𝖾𝗐𝗌:** `{result['views']}`\n**𝖣𝗎𝗋𝖺𝗍𝗂𝗈𝗇:** `{result['duration']}`\n**𝖫𝗂𝗇𝗄:** `https://youtube.com{result['url_suffix']}`\n\n"
+    await pro.edit_text(text, disable_web_page_preview=True)

akn/AllDownloaderBot/support_sites.py

@@ -0,0 +1,21 @@
+import yt_dlp
+import os
+import uuid
+from akn.utils.logger import LOGS
+
+def all_one_downloader(url: str, download_path: str = "./downloads/"):
+    unique_id = str(uuid.uuid4())
+
+    ydl_opts = {
+        "outtmpl": os.path.join(download_path, f"{unique_id}.%(ext)s"),
+        "quiet": True,
+        "noplaylist": True,
+        "format": "best",
+    }
+
+    with yt_dlp.YoutubeDL(ydl_opts) as ydl:
+        info = ydl.extract_info(url, download=True)
+        video_title = info.get("title", "Video")
+        video_path = ydl.prepare_filename(info)
+
+    return video_path, video_title

akn/ApproveBot/join_request.py

@@ -0,0 +1,428 @@
+import os
+import time
+import json
+import asyncio
+import io
+import re
+import logging
+import string
+import random
+import requests
+from pyrogram import Client, filters
+from pyrogram.types import *
+from pyrogram.enums import *
+from pyrogram.errors import *
+
+from PIL import Image, ImageDraw, ImageFont, ImageFilter
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+captcha_texts = {}
+captcha_modes = {}
+
+NOT_ALLOWED_NON_PROGRAMMER = [
+    5575183435, # suku
+    948247711, # akay
+]
+
+def generate_math_captcha():
+    operations = ['+', '-', '*']
+    operation = random.choice(operations)
+    num1 = random.randint(1, 20)
+    num2 = random.randint(1, 20)
+
+    if operation == '+':
+        correct_answer = num1 + num2
+    elif operation == '-':
+        correct_answer = num1 - num2
+    else:
+        correct_answer = num1 * num2
+    captcha_text = f"{num1} {operation} {num2} = ?"
+    choices = [str(correct_answer)]
+    while len(choices) < 3:
+        wrong_answer = correct_answer + random.choice([-5, -3, -2, 2, 3, 5])
+        if str(wrong_answer) not in choices:
+            choices.append(str(wrong_answer))
+    random.shuffle(choices)
+
+    width, height = 250, 100
+    background_color = (random.randint(200, 255), random.randint(200, 255), random.randint(200, 255))  # Warna pastel
+    img = Image.new('RGB', (width, height), color=background_color)
+    d = ImageDraw.Draw(img)
+
+    for _ in range(1000):
+        x = random.randint(0, width)
+        y = random.randint(0, height)
+        noise_color = (random.randint(150, 200), random.randint(150, 200), random.randint(150, 200))
+        d.point((x, y), fill=noise_color)
+
+    try:
+        font = ImageFont.truetype("arial.ttf", 40)
+    except IOError:
+        font = ImageFont.load_default()
+
+    text_width, text_height = d.textsize(captcha_text, font=font)
+    text_x = (width - text_width) / 2
+    text_y = (height - text_height) / 2 - 20
+
+    text_image = Image.new('RGBA', (text_width, text_height), (255, 255, 255, 0))
+    text_draw = ImageDraw.Draw(text_image)
+    text_draw.text((0, 0), captcha_text, font=font, fill=(0, 0, 0))
+    rotated_text = text_image.rotate(random.randint(-25, 25), expand=1)
+    img.paste(rotated_text, (int(text_x), int(text_y)), rotated_text)
+
+    choice_font = ImageFont.truetype("arial.ttf", 30) if font else ImageFont.load_default()
+    for idx, choice in enumerate(choices):
+        choice_text = f"{idx + 1}. {choice}"
+        choice_width, choice_height = d.textsize(choice_text, font=choice_font)
+        choice_x = 50 + idx * 80
+        choice_y = height - choice_height - 20
+        d.text((choice_x, choice_y), choice_text, font=choice_font, fill=(0, 0, 0))
+    
+    for _ in range(5):
+        start = (random.randint(0, width), random.randint(0, height))
+        end = (random.randint(0, width), random.randint(0, height))
+        line_color = (random.randint(0, 150), random.randint(0, 150), random.randint(0, 150))
+        d.line([start, end], fill=line_color, width=2)
+
+    img = img.filter(ImageFilter.BLUR)
+
+    img_path = f"captcha_math_{captcha_text}.png"
+    img.save(img_path)
+    
+    return captcha_text, img_path, choices, correct_answer
+
+def generate_text_captcha():
+    letters = string.ascii_uppercase + string.digits
+    captcha_text = ''.join(random.choice(letters) for _ in range(5))
+
+    choices = [captcha_text]
+    while len(choices) < 3:
+        wrong_choice = ''.join(random.choice(letters) for _ in range(5))
+        if wrong_choice not in choices:
+            choices.append(wrong_choice)
+    random.shuffle(choices)
+
+    width, height = 200, 80
+    background_color = (random.randint(200, 255), random.randint(200, 255), random.randint(200, 255))  # Warna pastel
+    img = Image.new('RGB', (width, height), color=background_color)
+    d = ImageDraw.Draw(img)
+
+    for _ in range(500):
+        x = random.randint(0, width)
+        y = random.randint(0, height)
+        noise_color = (random.randint(150, 200), random.randint(150, 200), random.randint(150, 200))
+        d.point((x, y), fill=noise_color)
+
+    try:
+        font = ImageFont.truetype("arial.ttf", 45)
+    except IOError:
+        font = ImageFont.load_default()
+
+    text_width, text_height = d.textsize(captcha_text, font=font)
+    text_x = (width - text_width) / 2
+    text_y = (height - text_height) / 2
+
+    text_image = Image.new('RGBA', (text_width, text_height), (255, 255, 255, 0))
+    text_draw = ImageDraw.Draw(text_image)
+    text_draw.text((0, 0), captcha_text, font=font, fill=(0, 0, 0))
+    rotated_text = text_image.rotate(random.randint(-25, 25), expand=1)
+    img.paste(rotated_text, (int(text_x), int(text_y)), rotated_text)
+
+    choice_font = ImageFont.truetype("arial.ttf", 30) if font else ImageFont.load_default()
+    for idx, choice in enumerate(choices):
+        choice_text = f"{idx + 1}. {choice}"
+        choice_width, choice_height = d.textsize(choice_text, font=choice_font)
+        choice_x = 50 + idx * 80
+        choice_y = height - choice_height - 20
+        d.text((choice_x, choice_y), choice_text, font=choice_font, fill=(0, 0, 0))
+
+    for _ in range(5):
+        start = (random.randint(0, width), random.randint(0, height))
+        end = (random.randint(0, width), random.randint(0, height))
+        line_color = (random.randint(0, 150), random.randint(0, 150), random.randint(0, 150))
+        d.line([start, end], fill=line_color, width=2)
+
+    img = img.filter(ImageFilter.BLUR)
+    img_path = f"captcha_text_{captcha_text}.png"
+    img.save(img_path)
+
+    return captcha_text, img_path, choices, captcha_text
+
+def generate_captcha(user_id, mode='math'):
+    if mode == 'math':
+        return generate_math_captcha()
+    else:
+        return generate_text_captcha()
+
+def thanks_hacker_by_randydev():
+    url = "https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcR0u8UqJ2JDhfmPOCb_zAHjUQG2NYMjTwLbkq_sQhCQOxX8hn66YbaGFvLL&s=10"
+    response = requests.get(url)
+    image_hacker = "hacker.png"
+    with open(image_hacker, "wb") as f:
+        f.write(response.content)
+    return image_hacker
+
+def failed_hacker_by_randydev():
+    url = "https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcTM0vb4s59H9F1-_7FyELiLU04e8bCHy7o6KQV2mG3DFRLnzP547KjckKG2&s=10"
+    response = requests.get(url)
+    image_hacker = "failed_hacker.png"
+    with open(image_hacker, "wb") as f:
+        f.write(response.content)
+    return image_hacker
+
+async def remove_captcha_after_timeout(client, user_id, delay=300):
+    await asyncio.sleep(delay)
+    if user_id in captcha_texts:
+        captcha_data = captcha_texts.get(user_id)
+        chat_id = captcha_data['chat_id']
+        await client.decline_chat_join_request(
+            chat_id=chat_id,
+            user_id=user_id
+        )
+        await client.send_message(user_id, "⏰ Your CAPTCHA verification has expired. Please try again.")
+        del captcha_texts[user_id]
+        logger.info(f"CAPTCHA for user {user_id} has expired and been removed.")
+
+@Client.on_message(filters.command("settingmode") & filters.private)
+async def setting_mode(client: Client, message: Message):
+    if message.from_user.id in NOT_ALLOWED_NON_PROGRAMMER:
+        return
+    user_id = message.from_user.id
+    keyboard = InlineKeyboardMarkup(
+        [
+            [InlineKeyboardButton("🔢 Mathematics", callback_data="mode_math")],
+            [InlineKeyboardButton("🔤 Text", callback_data="mode_text")],
+            [InlineKeyboardButton("❌ Cancel", callback_data="cancel_mode")]
+        ]
+    )
+    await message.reply_text(
+        "📍 Select the CAPTCHA mode you want:",
+        reply_markup=keyboard
+    )
+
+@Client.on_callback_query(filters.regex("^mode_"))
+async def mode_callback(client: Client, cb: CallbackQuery):
+    user_id = cb.from_user.id
+    data = cb.data.split("_")
+    if len(data) != 2:
+        await cb.answer("❌ Invalid selection.", show_alert=True)
+        return
+    mode = data[1]
+    if mode not in ['math', 'text']:
+        await cb.answer("❌ Invalid mode.", show_alert=True)
+        return
+    captcha_modes[user_id] = mode
+    keyboard = InlineKeyboardMarkup(
+        [
+            [InlineKeyboardButton("🔢 Mathematics", callback_data="mode_math")],
+            [InlineKeyboardButton("🔤 Text", callback_data="mode_text")],
+            [InlineKeyboardButton("❌ Cancel", callback_data="cancel_mode")]
+        ]
+    )
+    await cb.edit_message_text(
+        f"✅ CAPTCHA mode has been set to **{'Mathematics' if mode == 'math' else 'Text'}**.",
+        reply_markup=keyboard
+    )
+    await cb.answer("The mode has been changed.", show_alert=False)
+    logger.info(f"User {user_id} set CAPTCHA mode to {mode}.")
+
+@Client.on_callback_query(filters.regex("^cancel_mode$"))
+async def cancel_mode_callback(client: Client, cb: CallbackQuery):
+    await cb.edit_message_text("❌ CAPTCHA mode setting has been canceled.")
+    await cb.answer("Cancellation successful.", show_alert=False)
+    logger.info(f"User {cb.from_user.id} canceled CAPTCHA mode setting.")
+
+@Client.on_chat_join_request(filters.chat("KillerXSupport"))
+async def join_request(client: Client, event: ChatJoinRequest):
+    member = await client.get_chat_member(event.chat.id, "me")
+    if member.status != ChatMemberStatus.ADMINISTRATOR:
+        return await client.send_message(event.chat.id, text="I am not an administrator in this group.")
+
+    try:
+        chat_link = await client.export_chat_invite_link(event.chat.id)
+    except ChatAdminRequired:
+        await client.send_message(event.chat.id, text="I need to be an administrator to perform this action.")
+        return
+
+    mode = captcha_modes.get(event.from_user.id, "text")
+    captcha_text, img_path, choices, correct_answer = generate_captcha(event.from_user.id, mode)
+    captcha_texts[event.from_user.id] = {
+        "captcha_text": captcha_text,
+        "correct_answer": correct_answer,
+        "chat_id": event.chat.id,
+        "chat_link": chat_link,
+        "first_name": event.from_user.first_name
+    }
+
+    buttons = [
+        [InlineKeyboardButton(choice, callback_data=f"verify_{event.from_user.id}_{choice}")]
+        for choice in choices
+    ]
+    buttons.append([
+        InlineKeyboardButton("🔄 Refresh CAPTCHA", callback_data="refresh_captcha"),
+        InlineKeyboardButton("❌ Cancel", callback_data="cancel_captcha")
+    ])
+    keyboard = InlineKeyboardMarkup(buttons)
+
+    if event.chat.type == ChatType.SUPERGROUP:
+        try:
+            await client.send_message(
+                event.chat.id,
+                text=f" 🕦 Verify that you {event.from_user.first_name} are human!",
+                reply_markup=create_button_userinfo(event.from_user.id, client.me.username)
+            )
+            await client.send_photo(
+                event.from_user.id,
+                photo=img_path,
+                caption=f"❗️ **Verify that you are human!**\n\n❔ Please select the correct CAPTCHA text shown in the image below.",
+                reply_markup=keyboard
+            )
+            os.remove(img_path)
+            asyncio.create_task(remove_captcha_after_timeout(client, event.from_user.id))
+        except Exception as e:
+            await client.send_message(
+                event.chat.id,
+                text=str(e)
+            )
+            logger.error(str(e))
+
+@Client.on_callback_query(filters.regex("^verify_"))
+async def verify_captcha_callback(client: Client, cb: CallbackQuery):
+    data = cb.data.split("_")
+    if len(data) != 3:
+        await cb.answer("❌ Format data tidak valid.", show_alert=True)
+        return
+    _, user_id_str, user_choice = data
+    try:
+        user_id = int(user_id_str)
+    except ValueError:
+        await cb.answer("❌ Invalid user ID.", show_alert=True)
+        return
+    if cb.from_user.id != user_id:
+        await cb.answer("❌ You have no right to do this.", show_alert=True)
+        logger.warning(f"User {cb.from_user.id} mencoba memverifikasi CAPTCHA milik user {user_id}.")
+        return
+    if user_id not in captcha_texts:
+        await cb.answer("❗️ No active CAPTCHA verification.", show_alert=True)
+        logger.warning(f"User {user_id} mencoba memverifikasi CAPTCHA tanpa aktif.")
+        return
+    captcha_data = captcha_texts.get(user_id)
+    captcha_text = captcha_data["captcha_text"]
+    correct_answer = captcha_data["correct_answer"]
+    chat_id = captcha_data["chat_id"]
+    chat_link = captcha_data["chat_link"]
+    first_name = captcha_data["first_name"]
+
+    failed_image = failed_hacker_by_randydev()
+    hacker_image = thanks_hacker_by_randydev()
+
+    try:
+        if str(user_choice) == str(correct_answer):
+            await cb.edit_message_media(
+                media=InputMediaPhoto(
+                    hacker_image,
+                    caption="✅ CAPTCHA verification successful!"
+                ),
+                reply_markup=create_button_join_group(chat_link)
+            )
+            logger.info(f"User {user_id} berhasil memverifikasi CAPTCHA.")
+            if user_id in NOT_ALLOWED_NON_PROGRAMMER:
+                await client.ban_chat_member(chat_id=chat_id, user_id=user_id)
+                return
+            await client.approve_chat_join_request(
+                chat_id=chat_id,
+                user_id=user_id
+            )
+            await client.send_message(chat_id, f"Thank you for joining {first_name}")
+            del captcha_texts[user_id]
+        else:
+            await cb.edit_message_media(
+                media=InputMediaPhoto(
+                    failed_image,
+                    caption="❌ **CAPTCHA verification failed.**\n\nPlease try again."
+                )
+            )
+            await client.decline_chat_join_request(
+                chat_id=chat_id,
+                user_id=user_id
+            )
+            await client.send_message(chat_id, f"Failed to join {first_name}")
+            logger.info(f"User {user_id} gagal memverifikasi CAPTCHA.")
+            del captcha_texts[user_id]
+    except Exception as e:
+        await cb.answer(f"Error CAPTCHA: {e}", show_alert=True)
+
+@Client.on_callback_query(filters.regex("^refresh_captcha$"))
+async def refresh_captcha_callback(client: Client, cb: CallbackQuery):
+    user_id = cb.from_user.id
+    mode = captcha_modes.get(user_id, 'math')
+    if user_id in captcha_texts:
+        del captcha_texts[user_id]
+        logger.info(f"Old CAPTCHA for user {user_id} has been removed.")
+    captcha_text, img_path, choices, correct_answer = generate_captcha(user_id, mode)
+    captcha_texts[user_id] = {
+        "captcha_text": captcha_text,
+        "correct_answer": correct_answer,
+        "chat_id": captcha_texts[user_id]["chat_id"],
+        "chat_link": captcha_texts[user_id]["chat_link"],
+        "first_name": captcha_texts[user_id]["first_name"]
+        
+    }
+    logger.info(f"Generated new {mode} CAPTCHA for user {user_id}: {captcha_text}")
+    buttons = [
+        [InlineKeyboardButton(choice, callback_data=f"verify_{user_id}_{choice}")]
+        for choice in choices
+    ]
+    buttons.append([
+        InlineKeyboardButton("🔄 Refresh CAPTCHA", callback_data="refresh_captcha"),
+        InlineKeyboardButton("❌ Cancel", callback_data="cancel_captcha")
+    ])
+    keyboard = InlineKeyboardMarkup(buttons)
+    try:
+        await cb.edit_message_media(
+            media=InputMediaPhoto(img_path),
+            reply_markup=keyboard
+        )
+        logger.info(f"Updated CAPTCHA image for user {user_id}.")
+    except Exception as e:
+        await cb.answer("❌ Failed to update CAPTCHA.", show_alert=True)
+        logger.error(f"Error refreshing CAPTCHA for user {user_id}: {e}")
+    os.remove(img_path)
+    await cb.answer("🔄 CAPTCHA has been updated!", show_alert=False)
+
+@Client.on_callback_query(filters.regex("^cancel_captcha$"))
+async def cancel_captcha_callback(client: Client, cb: CallbackQuery):
+    user_id = cb.from_user.id
+    if user_id in captcha_texts:
+        del captcha_texts[user_id]
+        logger.info(f"User {user_id} has canceled CAPTCHA verification.")
+        await cb.edit_message_caption(
+            caption="❌ **CAPTCHA verification has been canceled.**\n\nIf you want to try again.",
+        )
+        await cb.answer("CAPTCHA verification canceled.", show_alert=False)
+    else:
+        await cb.answer("❗️ No active CAPTCHA verification found.", show_alert=True)
+        logger.warning(f"User {user_id} attempted to cancel CAPTCHA without active verification.")
+
+@Client.on_callback_query(filters.regex("^close$"))
+async def close_final(client: Client, cb: CallbackQuery):
+    await cb.message.delete()
+    await cb.answer()
+
+def create_button_join_group(chat_link):
+    return InlineKeyboardMarkup(
+        [
+            [InlineKeyboardButton("👁️ Join chat", url=chat_link)],
+            [InlineKeyboardButton("🔘 Close", callback_data="close")],
+        ]
+    )
+
+def create_button_userinfo(user_id, username):
+    return InlineKeyboardMarkup(
+        [
+            [InlineKeyboardButton("👤 Chmod +W $USER", user_id=user_id)],
+            [InlineKeyboardButton("🔔 Check human Bot", url=f"https://t.me/{username}")],
+        ]
+    ) 

akn/ApproveBot/start.py

@@ -0,0 +1,89 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# Copyright 2020-2024 (c) Randy W @xtdevs, @xtsea
+#
+# from : https://github.com/TeamKillerX
+# Channel : @RendyProjects
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+import time
+import json
+import asyncio
+import io
+import os
+import re
+import logging
+
+from pyrogram import *
+from pyrogram.enums import ChatMemberStatus, ChatType
+from pyrogram import enums
+from pyrogram import Client, filters
+from pyrogram.types import *
+from pyrogram.errors import *
+
+START_TEXT = """
+👋 **Hey {name}!**
+
+I’m excited to let you know that I’m ready to serve as your **Approve Join Request CAPTCHA Bot Developer**.  
+
+✨ **What I Offer**:  
+- **Approve Join Requests**: Automatically approve or reject join requests based on your settings.  
+- **CAPTCHA Verification**: Add an extra layer of security with CAPTCHA challenges for new members.  
+
+🔧 **How to Get Started**:  
+1. Use the command `/settingmode` to configure your preferences.  
+2. Customize the bot to suit your group’s needs.  
+
+🚀 Let’s make your group safer and more efficient together!  
+"""
+
+NOT_ALLOWED_NON_PROGRAMMER = [
+    5575183435, #suku
+    948247711, # akay
+]
+
+@Client.on_message(
+    ~filters.scheduled
+    & filters.command(["start"])
+    & filters.private
+    & ~filters.forwarded
+)
+async def startbot(client: Client, message: Message):
+    if message.from_user.id in NOT_ALLOWED_NON_PROGRAMMER:
+        return
+    buttons = InlineKeyboardMarkup(
+        [
+            [
+                InlineKeyboardButton(
+                    text="Add your to group",
+                    url=f"https://t.me/{client.me.username}?startgroup=True"
+                ),
+            ],
+            [
+                InlineKeyboardButton(
+                    text="Developer",
+                    url=f"https://t.me/xpushz"
+                ),
+                InlineKeyboardButton(
+                    text="Channel",
+                    url='https://t.me/RendyProjects'
+                )
+            ],
+        ]
+    )
+    await message.reply_text(
+        text=START_TEXT.format(name=message.from_user.mention),
+        disable_web_page_preview=True,
+        reply_markup=buttons
+    )

akn/Gemini/gemini.py

@@ -0,0 +1,335 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# Copyright 2020-2024 (c) Randy W @xtdevs, @xtsea
+#
+# from : https://github.com/TeamKillerX
+# Channel : @RendyProjects
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+import requests
+import time
+import json
+import asyncio
+import io
+import os
+import re
+from PIL import Image
+
+from pyrogram import *
+from pyrogram import enums
+from pyrogram import Client, filters
+from pyrogram.types import *
+from pyrogram.errors import *
+from RyuzakiLib import FaceAI, FullStackDev, GeminiLatest, RendyDevChat
+from config import *
+
+from akn import send_log
+from akn.utils.database import db
+from akn.utils.logger import LOGS
+
+import google.generativeai as genai
+from google.api_core.exceptions import InvalidArgument
+
+async def geni_files_delete(name: str):
+    url = f"https://generativelanguage.googleapis.com/v1beta/{name}"
+    params = {"key": GOOGLE_API_KEY}
+    response = requests.delete(url, params=params)
+    if response.status_code != 200:
+        return None
+    return response.text
+
+DISABLED_COMMNAD = [
+    "onchat",
+    "offchat",
+    "start"
+]
+
+GEMINI_START_TEXT = """
+Hey! {name}
+
+I am ready to be a gemini bot developer
+
+- Command: /onchat (pm or group)
+- Command: /offchat (pm or group)
+"""
+
+@Client.on_message(
+    ~filters.scheduled
+    & filters.command(["start"])
+    & ~filters.forwarded
+)
+async def startbot(client: Client, message: Message):
+    buttons = [
+        [
+            InlineKeyboardButton(
+                text="Developer",
+                url=f"https://t.me/xtdevs"
+            ),
+            InlineKeyboardButton(
+                text="Channel",
+                url='https://t.me/RendyProjects'
+            ),
+        ],
+        [
+            InlineKeyboardButton(
+                text="Donate Via Web",
+                web_app=WebAppInfo(url="https://sociabuzz.com/randydev99/tribe")
+            )
+        ]
+    ]
+    await message.reply_text(
+        text=GEMINI_START_TEXT.format(name=message.from_user.mention),
+        disable_web_page_preview=True,
+        reply_markup=InlineKeyboardMarkup(buttons)
+    )
+
+@Client.on_message(
+    ~filters.scheduled
+    & filters.command(["onchat"])
+    & ~filters.forwarded
+)
+async def addchatbot_user(client: Client, message: Message):
+    await db.add_chatbot(message.chat.id, client.me.id)
+    await message.reply_text("Added chatbot user")
+
+@Client.on_message(
+    ~filters.scheduled
+    & filters.command(["offchat"])
+    & ~filters.forwarded
+)
+async def rmchatbot_user(client: Client, message: Message):
+    await db.remove_chatbot(message.chat.id)
+    await message.reply_text("ok stopped gemini")
+
+@Client.on_message(
+    filters.incoming
+    & (
+        filters.text
+        | filters.photo
+        | filters.video
+        | filters.audio
+        | filters.voice
+        | filters.regex(r"\b(Randy|Rendi)\b(.*)", flags=re.IGNORECASE)
+    )
+    & (filters.private | filters.group)
+    & ~filters.command(DISABLED_COMMNAD)
+    & ~filters.bot
+    & ~filters.via_bot
+    & ~filters.forwarded,
+    group=2,
+)
+async def chatbot_talk(client: Client, message: Message):
+    genai.configure(api_key=GOOGLE_API_KEY)
+    chat_user = await db.get_chatbot(message.chat.id)
+    if not chat_user:
+        return
+    if message.reply_to_message and message.reply_to_message.from_user:
+        if message.reply_to_message.from_user.id != client.me.id:
+            return
+    if message.photo:
+        await client.send_chat_action(message.chat.id, enums.ChatAction.UPLOAD_PHOTO)
+        await asyncio.sleep(1.5)
+        file_path = await message.download()
+        caption = message.caption or "What's this?"
+        x = GeminiLatest(api_keys=GOOGLE_API_KEY)
+        if client.me.is_premium:
+            ai_reply = await message.reply_text(f"{custom_loading}Processing...")
+        else:
+            ai_reply = await message.reply_text(f"Processing...")
+        try:
+            await client.send_chat_action(message.chat.id, enums.ChatAction.TYPING)
+            await asyncio.sleep(1.5)
+            backup_chat = await db._get_chatbot_chat_from_db(message.from_user.id)
+            backup_chat.append({"role": "user", "parts": [{"text": caption}]})
+            response_reads = x.get_response_image(caption, file_path)
+            if len(response_reads) > 4096:
+                with open("chat.txt", "w+", encoding="utf8") as out_file:
+                    out_file.write(response_reads)
+                await message.reply_document(
+                    document="chat.txt",
+                    disable_notification=True
+                )
+                await ai_reply.delete()
+                os.remove("chat.txt")
+            else:
+                await ai_reply.edit_text(response_reads)
+            backup_chat.append({"role": "model", "parts": [{"text": response_reads}]})
+            await db._update_chatbot_chat_in_db(message.from_user.id, backup_chat)
+            await client.send_chat_action(message.chat.id, enums.ChatAction.CANCEL)
+            os.remove(file_path)
+            return
+        except InvalidArgument as e:
+            return await ai_reply.edit_text(f"Error: {e}")
+        except Exception as e:
+            return await ai_reply.edit_text(f"Error: {e}")
+
+    if message.audio or message.voice:
+        await client.send_chat_action(message.chat.id, enums.ChatAction.UPLOAD_AUDIO)
+        await asyncio.sleep(1.5)
+        if client.me.is_premium:
+            ai_reply = await message.reply_text(f"{custom_loading}Processing...")
+        else:
+            ai_reply = await message.reply_text(f"Processing...")
+        if message.audio:
+            audio_file_name = await message.download()
+        if message.voice:
+            audio_file_name = await message.download()
+        caption = message.caption or "What's this?"
+        model = genai.GenerativeModel(
+            model_name="gemini-1.5-flash",
+            safety_settings={
+                genai.types.HarmCategory.HARM_CATEGORY_HATE_SPEECH: genai.types.HarmBlockThreshold.BLOCK_NONE,
+                genai.types.HarmCategory.HARM_CATEGORY_HARASSMENT: genai.types.HarmBlockThreshold.BLOCK_NONE,
+                genai.types.HarmCategory.HARM_CATEGORY_SEXUALLY_EXPLICIT: genai.types.HarmBlockThreshold.BLOCK_NONE,
+                genai.types.HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT: genai.types.HarmBlockThreshold.BLOCK_NONE,
+            }
+        )
+        backup_chat = await db._get_chatbot_chat_from_db(message.from_user.id)
+        backup_chat.append({"role": "user", "parts": [{"text": caption}]})
+        if client.me.is_premium:
+            await ai_reply.edit_text(f"{custom_loading}Uploading file..")
+        else:
+            await ai_reply.edit_text("Uploading file..")
+        audio_file = genai.upload_file(path=audio_file_name)
+        while audio_file.state.name == "PROCESSING":
+            await asyncio.sleep(10)
+            audio_file = genai.get_file(audio_file.name)
+        if audio_file.state.name == "FAILED":
+            return await ai_reply.edit_text(f"Error: {audio_file.state.name}")
+        try:
+            await client.send_chat_action(message.chat.id, enums.ChatAction.TYPING)
+            await asyncio.sleep(1.5)
+            response = model.generate_content(
+                [audio_file, caption],
+                request_options={"timeout": 600}
+            )
+            if len(response.text) > 4096:
+                with open("chat.txt", "w+", encoding="utf8") as out_file:
+                    out_file.write(response.text)
+                await message.reply_document(
+                    document="chat.txt",
+                    disable_notification=True
+                )
+                await ai_reply.delete()
+                os.remove("chat.txt")
+            else:
+                await ai_reply.edit_text(response.text)
+            backup_chat.append({"role": "model", "parts": [{"text": response.text}]})
+            await db._update_chatbot_chat_in_db(message.from_user.id, backup_chat)
+            await client.send_chat_action(message.chat.id, enums.ChatAction.CANCEL)
+            audio_file.delete()
+            os.remove(audio_file_name)
+            return
+        except InvalidArgument as e:
+            return await ai_reply.edit_text(f"Error: {e}")
+        except Exception as e:
+            return await ai_reply.edit_text(f"Error: {e}")
+
+    if message.video:
+        await client.send_chat_action(message.chat.id, enums.ChatAction.UPLOAD_VIDEO)
+        await asyncio.sleep(1.5)
+        if client.me.is_premium:
+            ai_reply = await message.reply_text(f"{custom_loading}Processing...")
+        else:
+            ai_reply = await message.reply_text(f"Processing...")
+        video_file_name = await message.download(file_name="newvideo.mp4")
+        caption = message.caption or "What's this?"
+        model = genai.GenerativeModel(
+            model_name="gemini-1.5-pro",
+            safety_settings={
+                genai.types.HarmCategory.HARM_CATEGORY_HATE_SPEECH: genai.types.HarmBlockThreshold.BLOCK_NONE,
+                genai.types.HarmCategory.HARM_CATEGORY_HARASSMENT: genai.types.HarmBlockThreshold.BLOCK_NONE,
+                genai.types.HarmCategory.HARM_CATEGORY_SEXUALLY_EXPLICIT: genai.types.HarmBlockThreshold.BLOCK_NONE,
+                genai.types.HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT: genai.types.HarmBlockThreshold.BLOCK_NONE,
+            }
+        )
+        backup_chat = await db._get_chatbot_chat_from_db(message.from_user.id)
+        backup_chat.append({"role": "user", "parts": [{"text": caption}]})
+        if client.me.is_premium:
+            await ai_reply.edit_text(f"{custom_loading}Uploading file..")
+        else:
+            await ai_reply.edit_text("Uploading file..")
+        video_file = genai.upload_file(path=video_file_name)
+        while video_file.state.name == "PROCESSING":
+            await asyncio.sleep(10)
+            video_file = genai.get_file(video_file.name)
+        if video_file.state.name == "FAILED":
+            return await ai_reply.edit_text(f"Error: {video_file.state.name}")
+        try:
+            await client.send_chat_action(message.chat.id, enums.ChatAction.TYPING)
+            await asyncio.sleep(1.5)
+            response = model.generate_content(
+                [video_file, caption],
+                request_options={"timeout": 600}
+            )
+            if len(response.text) > 4096:
+                with open("chat.txt", "w+", encoding="utf8") as out_file:
+                    out_file.write(response.text)
+                await message.reply_document(
+                    document="chat.txt",
+                    disable_notification=True
+                )
+                await ai_reply.delete()
+                os.remove("chat.txt")
+            else:
+                await ai_reply.edit_text(response.text)
+            backup_chat.append({"role": "model", "parts": [{"text": response.text}]})
+            await db._update_chatbot_chat_in_db(message.from_user.id, backup_chat)
+            await client.send_chat_action(message.chat.id, enums.ChatAction.CANCEL)
+            video_file.delete()
+            os.remove(video_file_name)
+            return
+        except InvalidArgument as e:
+            return await ai_reply.edit_text(f"Error: {e}")
+        except Exception as e:
+            return await ai_reply.edit_text(f"Error: {e}")
+
+    if message.text:
+        await client.send_chat_action(message.chat.id, enums.ChatAction.TYPING)
+        await asyncio.sleep(1.5)
+        query = message.text.strip()
+        match = re.search(r"\b(Randy|Rendi)\b(.*)", query, flags=re.IGNORECASE)
+        if match:
+            rest_of_sentence = match.group(2).strip()
+            query_base = rest_of_sentence if rest_of_sentence else query
+        else:
+            query_base = query
+        parts = query.split(maxsplit=1)
+        command = parts[0].lower()
+        pic_query = parts[1].strip() if len(parts) > 1 else ""
+        try:
+            model_flash = genai.GenerativeModel(
+                model_name="gemini-1.5-flash"
+            )
+            backup_chat = await db._get_chatbot_chat_from_db(message.from_user.id)
+            backup_chat.append({"role": "user", "parts": [{"text": query_base}]})
+            chat_session = model_flash.start_chat(history=backup_chat)
+            response_data = chat_session.send_message(query_base)
+            output = response_data.text
+            if len(output) > 4096:
+                with open("chat.txt", "w+", encoding="utf8") as out_file:
+                    out_file.write(output)
+                await message.reply_document(
+                    document="chat.txt",
+                    disable_notification=True
+                )
+                os.remove("chat.txt")
+            else:
+                await message.reply_text(output)
+            backup_chat.append({"role": "model", "parts": [{"text": output}]})
+            await db._update_chatbot_chat_in_db(message.from_user.id, backup_chat)
+            await client.send_chat_action(message.chat.id, enums.ChatAction.CANCEL)
+            return
+        except Exception as e:
+            return await message.reply_text(f"Error: {e}")