Initial commit: Drag Inline Bot

.gitignore

@@ -0,0 +1,109 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# Environment variables
+.env
+.env.local
+.env.development.local
+.env.test.local
+.env.production.local
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# OS
+.DS_Store
+.DS_Store?
+._*
+.Spotlight-V100
+.Trashes
+ehthumbs.db
+Thumbs.db
+
+# Logs
+*.log
+logs/
+
+# Database
+*.db
+*.sqlite
+*.sqlite3
+
+# Temporary files
+*.tmp
+*.temp
+
+# Compiled files
+*.pyc
+*.pyo
+*.pyd
+__pycache__/
+*.so
+
+# Virtual environments
+venv/
+env/
+ENV/
+env.bak/
+venv.bak/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# pyenv
+.python-version
+
+# pipenv
+Pipfile.lock
+
+# PEP 582
+__pypackages__/
+
+# Celery
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/

.pre-commit-config.yaml

@@ -0,0 +1,20 @@
+repos:
+  - repo: https://github.com/pycqa/isort
+    rev: 6.0.0
+    hooks:
+      - id: isort
+        types: [python]
+        args: [
+            '--profile=black',
+            '--line-length=99',
+            '--trailing-comma',
+            '--use-parentheses',
+            '--ensure-newline-before-comments',
+        ]
+
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v5.0.0
+    hooks:
+      - id: check-yaml
+      - id: end-of-file-fixer
+      - id: trailing-whitespace

AkenoX/__main__.py

@@ -0,0 +1,26 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# Copyright 2017-2025 (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 config
+
+run_code = config.loaded_cache("compiler/install_perfomance.pyc")
+exec(run_code, globals())
+
+if __name__ == "__main__":
+    loop.run_until_complete(main())

AkenoX/core/database.py

@@ -0,0 +1,74 @@
+from datetime import datetime as dt
+
+from motor import motor_asyncio
+from motor.core import AgnosticClient
+from motor.motor_asyncio import AsyncIOMotorClient
+
+from AkenoX.core.logger import *
+from config import *
+
+
+class Database:
+    def __init__(self, uri: str) -> None:
+        self.client: AgnosticClient = motor_asyncio.AsyncIOMotorClient(uri)
+        self.db = self.client["Akeno"]
+        self.env = self.db["env"]
+        self.pmpermit = self.db["pmpermit"]
+
+    async def connect(self):
+        try:
+            await self.client.admin.command("ping")
+            LOGS.info(
+                f"Database Connection Established!"
+            )
+        except Exception as e:
+            LOGS.info(f"DatabaseErr: {e} ")
+            quit(1)
+
+    def get_datetime(self) -> str:
+        return dt.now().strftime("%d/%m/%Y - %H:%M")
+
+    async def set_env(self, name: str, value: str) -> None:
+        await self.env.update_one(
+            {"name": name}, {"$set": {"value": value}}, upsert=True
+        )
+
+    async def get_env(self, name: str) -> None:
+        if await self.is_env(name):
+            data = await self.env.find_one({"name": name})
+            return data["value"]
+        return None
+
+    async def rm_env(self, name: str) -> None:
+        await self.env.delete_one({"name": name})
+
+    async def is_env(self, name: str) -> bool:
+        if await self.env.find_one({"name": name}):
+            return True
+        return False
+
+    async def get_all_env(self) -> list:
+        return [i async for i in self.env.find({})]
+
+    async def add_pmpermit(self, client: int, user: int):
+        await self.pmpermit.update_one(
+            {"client": client, "user": user},
+            {"$set": {"date": self.get_datetime()}},
+            upsert=True,
+        )
+
+    async def rm_pmpermit(self, client: int, user: int):
+        await self.pmpermit.delete_one({"client": client, "user": user})
+
+    async def is_pmpermit(self, client: int, user: int) -> bool:
+        data = await self.get_pmpermit(client, user)
+        return True if data else False
+
+    async def get_pmpermit(self, client: int, user: int):
+        data = await self.pmpermit.find_one({"client": client, "user": user})
+        return data
+
+    async def get_all_pmpermits(self, client: int) -> list:
+        return [i async for i in self.pmpermit.find({"client": client})]
+
+db_client = Database(mongo_url)

AkenoX/core/helper_button.py

@@ -0,0 +1,65 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# Credits @xpushz on telegram
+# Copyright 2020-2024 (c) Randy W @xtdevs, @xtsea on telegram
+#
+# 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/>.
+
+from config import *
+
+run_code = loaded_cache("compiler/deserialize.pyc")
+exec(run_code, globals())
+
+def parse_buttons(button_text: str):
+    lines = button_text.strip().split("\n")
+    buttons = []
+    row = []
+
+    for line in lines:
+        if "(buttonurl://" in line:
+            parts = line.split("(buttonurl://")
+            label = parts[0].strip("[]")
+            url = parts[1].strip(")").replace(":same", "").strip()
+            row.append(InlineKeyboardButton(text=label, url=url))
+
+        elif "(callback_data://" in line:
+            parts = line.split("(callback_data://")
+            label = parts[0].strip("[]")
+            callback_data = parts[1].strip(")").replace(":same", "").strip()
+            row.append(InlineKeyboardButton(text=label, callback_data=callback_data))
+
+        elif "(copy_text://" in line:
+            parts = line.split("(copy_text://")
+            label = parts[0].strip("[]")
+            copy_text = parts[1].strip(")").replace(":same", "").strip()
+            row.append(InlineKeyboardButton(text=label, copy_text=copy_text))
+
+        elif "(alert://" in line:
+            parts = line.split("(alert://")
+            label = parts[0].strip("[]")
+            doesshow = parts[1].strip(")").replace(":same", "").strip()
+            row.append(InlineKeyboardButton(text=label, callback_data=f"alert_{doesshow}"))
+        else:
+            continue
+
+        if ":same" not in line:
+            buttons.append(row)
+            row = []
+
+    if row:
+        buttons.append(row)
+
+    return InlineKeyboardMarkup(buttons)

AkenoX/core/helper_prefix.py

@@ -0,0 +1,72 @@
+import re
+from typing import List, Union
+
+from pyrogram import Client
+from pyrogram.enums import MessageEntityType
+from pyrogram.filters import Filter, create
+from pyrogram.types import Message
+
+from AkenoX.core.sqlite_prefix import *
+
+
+def command(commands: Union[str, List[str]], case_sensitive: bool = False):
+    command_re = re.compile(
+        r"([\"'])(.*?)(?<!\\)\1|(\S+)",
+        flags=re.UNICODE,
+    )
+
+    async def func(flt, client: Client, message: Message):
+        username = client.me.username or ""
+        user_id = client.me.id if client.me else 0
+        text = message.text or message.caption
+        message.command = None
+
+        if not text:
+            return False
+
+        stored_prefix = await get_prefix(user_id)
+        if stored_prefix is None:
+            stored_prefix = "None"
+
+        if stored_prefix == "None":
+            without_prefix = text.strip()
+            return await process_command(flt, client, message, without_prefix, command_re, username)
+
+        if message.entities:
+            for entity in message.entities:
+                if entity.type == MessageEntityType.CUSTOM_EMOJI and str(entity.custom_emoji_id) == stored_prefix:
+                    without_prefix = text[entity.length:].strip()
+                    return await process_command(flt, client, message, without_prefix, command_re, username)
+
+        if text.startswith(stored_prefix):
+            without_prefix = text[len(stored_prefix.encode("utf-16-le")) // 2:].strip()
+            return await process_command(flt, client, message, without_prefix, command_re, username)
+
+        return False
+
+    commands = commands if isinstance(commands, list) else [commands]
+    commands = {c if case_sensitive else c.lower() for c in commands}
+
+    return create(func, "CommandFilter", commands=commands, case_sensitive=case_sensitive)
+
+async def process_command(flt, client: Client, message: Message, without_prefix: str, command_re, username: str):
+    """Helper function to process command after prefix (if any) is removed."""
+    for cmd in flt.commands:
+        if re.match(
+            f"^(?:{cmd}(?:@?{username})?)(?:\s|$)",
+            without_prefix,
+            flags=0 if flt.case_sensitive else re.IGNORECASE,
+        ):
+            without_command = re.sub(
+                f"{cmd}(?:@?{username})?\s?",
+                "",
+                without_prefix,
+                count=1,
+                flags=0 if flt.case_sensitive else re.IGNORECASE,
+            )
+            message.command = [cmd] + [
+                re.sub(r"\\([\"'])", r"\1", m.group(2) or m.group(3) or "")
+                for m in command_re.finditer(without_command)
+            ]
+            return True
+    return False

AkenoX/core/logger.py

@@ -0,0 +1,6 @@
+import logging
+
+logging.basicConfig(level=logging.INFO)
+logging.getLogger("pyrogram").setLevel(logging.ERROR)
+
+LOGS = logging.getLogger("AkenoX")

AkenoX/core/scripts.py

@@ -0,0 +1,415 @@
+import asyncio
+import importlib
+import math
+import os
+import re
+import shlex
+import subprocess
+import sys
+import time
+import traceback
+from io import BytesIO
+from types import ModuleType
+from typing import Dict, List, Optional, Tuple, Union
+
+import psutil
+from PIL import Image
+from pyrogram import Client, enums, errors
+from pyrogram.errors import FloodWait, MessageNotModified
+from pyrogram.types import Message
+
+META_COMMENTS = re.compile(r"^ *# *meta +(\S+) *: *(.*?)\s*$", re.MULTILINE)
+interact_with_to_delete = []
+
+def with_args(text: str):
+    def decorator(func):
+        async def wrapped(client: Client, message: Message):
+            if message.text and len(message.text.split()) == 1:
+                await message.edit(text)
+            else:
+                return await func(client, message)
+
+        return wrapped
+
+    return decorator
+
+def get_args(
+    message: Union[Message, str], use_reply: bool = None
+) -> Tuple[List[str], Dict[str, str]]:
+    """Returns list of common args and a dictionary with named args.
+
+    Args:
+        message (Union[Message, str]): Message or text.
+
+        use_reply (bool, optional): Try to get args from reply message if no args in message. Defaults to None.
+
+    Returns:
+        List[str]: List of args.
+    """
+    raw_args = get_args_raw(message, use_reply)
+
+    try:
+        args = list(filter(lambda x: len(x) > 0, shlex.split(raw_args)))
+    except ValueError:
+        return [raw_args], {}
+
+    common_args = []
+    named_args = {}
+
+    i = 0
+    while i < len(args):
+        arg = args[i]
+        if arg.startswith("-"):
+            if i + 1 < len(args) and (
+                not args[i + 1].startswith("-") or len(args[i + 1].split()) > 1
+            ):
+                named_args[arg] = args[i + 1]
+                i += 2
+            else:
+                i += 1
+        else:
+            i += 1
+        common_args.append(arg)
+    return common_args, named_args
+
+def get_args_raw(message: Union[Message, str], use_reply: bool = None) -> str:
+    """Returns text after command.
+
+    Args:
+        message (Union[Message, str]): Message or text.
+
+        use_reply (bool, optional): Try to get args from reply message if no args in message. Defaults to None.
+
+    Returns:
+        str: Text after command or empty string.
+    """
+    if isinstance(message, Message):
+        text = message.text or message.caption
+        args = text.split(maxsplit=1)[1] if len(text.split()) > 1 else ""
+
+        if use_reply and not args:
+            args = message.reply_to_message.text or message.reply_to_message.caption
+
+    elif not isinstance(message, str):
+        return ""
+
+    return args or ""
+
+async def shell_exec(
+    command: str,
+    executable: Optional[str] = None,
+    timeout: Optional[Union[int, float]] = None,
+    stdout=asyncio.subprocess.PIPE,
+    stderr=asyncio.subprocess.PIPE,
+) -> Tuple[int, str, str]:
+    """Executes shell command and returns tuple with return code, decoded stdout, and stderr."""
+
+    if executable is None:
+        # Set a default shell based on the platform
+        if sys.platform == "win32":
+            executable = "cmd.exe"
+        else:
+            executable = "/bin/bash"
+
+    process = await asyncio.create_subprocess_shell(
+        cmd=command,
+        stdout=stdout,
+        stderr=stderr,
+        shell=True,
+        executable=executable
+    )
+
+    try:
+        stdout, stderr = await asyncio.wait_for(process.communicate(), timeout)
+    except asyncio.exceptions.TimeoutError as e:
+        process.kill()
+        raise e
+
+    return process.returncode, stdout.decode(), stderr.decode()
+
+
+def time_formatter(milliseconds: int) -> str:
+    """Time Formatter"""
+    seconds, milliseconds = divmod(int(milliseconds), 1000)
+    minutes, seconds = divmod(seconds, 60)
+    hours, minutes = divmod(minutes, 60)
+    days, hours = divmod(hours, 24)
+    tmp = (
+        ((str(days) + " day(s), ") if days else "")
+        + ((str(hours) + " hour(s), ") if hours else "")
+        + ((str(minutes) + " minute(s), ") if minutes else "")
+        + ((str(seconds) + " second(s), ") if seconds else "")
+        + ((str(milliseconds) + " millisecond(s), ") if milliseconds else "")
+    )
+    return tmp[:-2]
+
+
+def humanbytes(size):
+    """Convert Bytes To Bytes So That Human Can Read It"""
+    if not size:
+        return ""
+    power = 2**10
+    raised_to_pow = 0
+    dict_power_n = {0: "", 1: "Ki", 2: "Mi", 3: "Gi", 4: "Ti"}
+    while size > power:
+        size /= power
+        raised_to_pow += 1
+    return str(round(size, 2)) + " " + dict_power_n[raised_to_pow] + "B"
+
+
+async def edit_or_send_as_file(
+    tex: str,
+    message: Message,
+    client: Client,
+    caption: str = "<code>Result!</code>",
+    file_name: str = "result",
+):
+    """Send As File If Len Of Text Exceeds Tg Limit Else Edit Message"""
+    if not tex:
+        await message.edit("<code>Wait, What?</code>")
+        return
+    if len(tex) > 1024:
+        await message.edit("<code>OutPut is Too Large, Sending As File!</code>")
+        file_names = f"{file_name}.txt"
+        with open(file_names, "w") as fn:
+            fn.write(tex)
+        await client.send_document(message.chat.id, file_names, caption=caption)
+        await message.delete()
+        if os.path.exists(file_names):
+            os.remove(file_names)
+        return
+    return await message.edit(tex)
+
+
+def get_text(message: Message) -> None | str:
+    """Extract Text From Commands"""
+    text_to_return = message.text
+    if message.text is None:
+        return None
+    if " " in text_to_return:
+        try:
+            return message.text.split(None, 1)[1]
+        except IndexError:
+            return None
+    else:
+        return None
+
+
+async def progress(current, total, message, start, type_of_ps, file_name=None):
+    """Progress Bar For Showing Progress While Uploading / Downloading File - Normal"""
+    now = time.time()
+    diff = now - start
+    if round(diff % 10.00) == 0 or current == total:
+        percentage = current * 100 / total
+        speed = current / diff
+        elapsed_time = round(diff) * 1000
+        if elapsed_time == 0:
+            return
+        time_to_completion = round((total - current) / speed) * 1000
+        estimated_total_time = elapsed_time + time_to_completion
+        progress_str = f"{''.join(['▰' for i in range(math.floor(percentage / 10))])}"
+        progress_str += (
+            f"{''.join(['▱' for i in range(10 - math.floor(percentage / 10))])}"
+            )
+        progress_str += f"{round(percentage, 2)}%\n"
+        tmp = f"{progress_str}{humanbytes(current)} of {humanbytes(total)}\n"
+        tmp += f"ETA: {time_formatter(estimated_total_time)}"
+        if file_name:
+            try:
+                await message.edit(
+                    f"{type_of_ps}\n**File Name:** `{file_name}`\n{tmp}"
+                    )
+            except FloodWait as e:
+                await asyncio.sleep(e.x)
+            except MessageNotModified:
+                pass
+        else:
+            try:
+                await message.edit(
+                    f"{type_of_ps}\n{tmp}", parse_mode=enums.ParseMode.MARKDOWN
+                    )
+            except FloodWait as e:
+                await asyncio.sleep(e.x)
+            except MessageNotModified:
+                pass
+
+
+async def run_cmd(prefix: str) -> Tuple[str, str, int, int]:
+    """Run Commands"""
+    args = shlex.split(prefix)
+    process = await asyncio.create_subprocess_exec(
+        *args, stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE
+        )
+    stdout, stderr = await process.communicate()
+    return (
+        stdout.decode("utf-8", "replace").strip(),
+        stderr.decode("utf-8", "replace").strip(),
+        process.returncode,
+        process.pid,
+        )
+
+
+def mediainfo(media):
+    xx = str((str(media)).split("(", maxsplit=1)[0])
+    m = ""
+    if xx == "MessageMediaDocument":
+        mim = media.document.mime_type
+        if mim == "application/x-tgsticker":
+            m = "sticker animated"
+        elif "image" in mim:
+            if mim == "image/webp":
+                m = "sticker"
+            elif mim == "image/gif":
+                m = "gif as doc"
+            else:
+                m = "pic as doc"
+        elif "video" in mim:
+            if "DocumentAttributeAnimated" in str(media):
+                m = "gif"
+            elif "DocumentAttributeVideo" in str(media):
+                i = str(media.document.attributes[0])
+                if "supports_streaming=True" in i:
+                    m = "video"
+                m = "video as doc"
+            else:
+                m = "video"
+        elif "audio" in mim:
+            m = "audio"
+        else:
+            m = "document"
+    elif xx == "MessageMediaPhoto":
+        m = "pic"
+    elif xx == "MessageMediaWebPage":
+        m = "web"
+    return m
+
+
+async def edit_or_reply(message, txt):
+    """Edit Message If Its From Self, Else Reply To Message"""
+    if not message:
+        return await message.edit(txt)
+    if not message.from_user:
+        return await message.edit(txt)
+    return await message.edit(txt)
+
+
+def format_exc(e: Exception, suffix="") -> str:
+    traceback.print_exc()
+    err = traceback.format_exc()
+    if isinstance(e, errors.RPCError):
+        return (
+            f"<b>Telegram API error!</b>\n"
+            f"<code>[{e.CODE} {e.ID or e.NAME}] — {e.MESSAGE.format(value=e.value)}</code>\n\n<b>{suffix}</b>"
+            )
+    return f"<b>Error!</b>\n" f"<code>{err}</code>"
+
+
+def import_library(library_name: str, package_name: str = None):
+    """
+    Loads a library, or installs it in ImportError case
+    :param library_name: library name (import example...)
+    :param package_name: package name in PyPi (pip install example)
+    :return: loaded module
+    """
+    if package_name is None:
+        package_name = library_name
+    requirements_list.append(package_name)
+
+    try:
+        return importlib.import_module(library_name)
+    except ImportError as exc:
+        completed = subprocess.run(
+            [sys.executable, "-m", "pip", "install", "--upgrade", package_name], check=True)
+        if completed.returncode != 0:
+            raise AssertionError(
+                f"Failed to install library {package_name} (pip exited with code {completed.returncode})"
+                ) from exc
+        return importlib.import_module(library_name)
+
+
+def uninstall_library(package_name: str):
+    """
+    Uninstalls a library
+    :param package_name: package name in PyPi (pip uninstall example)
+    """
+    completed = subprocess.run(
+        [sys.executable, "-m", "pip", "uninstall", "-y", package_name], check=True)
+    if completed.returncode != 0:
+        raise AssertionError(
+            f"Failed to uninstall library {package_name} (pip exited with code {completed.returncode})"
+        )
+
+
+def resize_image(
+    input_img, output=None, img_type="PNG", size: int = 512, size2: int = None
+):
+    if output is None:
+        output = BytesIO()
+        output.name = f"sticker.{img_type.lower()}"
+
+    with Image.open(input_img) as img:
+        # We used to use thumbnail(size) here, but it returns with a *max* dimension of 512,512
+        # rather than making one side exactly 512, so we have to calculate dimensions manually :(
+        if size2 is not None:
+            size = (size, size2)
+        elif img.width == img.height:
+            size = (size, size)
+        elif img.width < img.height:
+            size = (max(size * img.width // img.height, 1), size)
+        else:
+            size = (size, max(size * img.height // img.width, 1))
+
+        img.resize(size).save(output, img_type)
+
+    return output
+
+
+def resize_new_image(image_path, output_path, desired_width=None, desired_height=None):
+    """
+    Resize an image to the desired dimensions while maintaining the aspect ratio.
+
+    Args:
+        image_path (str): Path to the input image file.
+        output_path (str): Path to save the resized image.
+        desired_width (int, optional): Desired width in pixels. If not provided, the aspect ratio will be maintained.
+        desired_height (int, optional): Desired height in pixels. If not provided, the aspect ratio will be maintained.
+    """
+    image = Image.open(image_path)
+
+    width, height = image.size
+
+    aspect_ratio = width / height
+
+    if desired_width and desired_height:
+        new_width, new_height = desired_width, desired_height
+    elif desired_height:
+        new_width, new_height = int(desired_height * aspect_ratio), desired_height
+    else:
+        new_width, new_height = 150, 150
+
+    resized_image = image.resize((new_width, new_height), Image.Resampling.LANCZOS)
+
+    resized_image.save(output_path)
+    if os.path.exists(image_path):
+        os.remove(image_path)
+
+
+def parse_meta_comments(code: str) -> Dict[str, str]:
+    try:
+        groups = META_COMMENTS.search(code).groups()
+    except AttributeError:
+        return {}
+
+    return {groups[i]: groups[i + 1] for i in range(0, len(groups), 2)}
+
+
+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_idhjj

AkenoX/core/sqlite_prefix.py

@@ -0,0 +1,41 @@
+import sqlite3
+
+conn = sqlite3.connect('bot_prefix.db')
+cursor = conn.cursor()
+
+cursor.execute('''
+    CREATE TABLE IF NOT EXISTS prefixes (
+        user_id INTEGER PRIMARY KEY,
+        prefix TEXT NOT NULL
+    )
+''')
+
+conn.commit()
+conn.close()
+
+async def set_prefix_in_db(user_id: int, prefix: str):
+    conn = sqlite3.connect('bot_prefix.db')
+    cursor = conn.cursor()
+
+    cursor.execute('''
+        INSERT INTO prefixes (user_id, prefix)
+        VALUES (?, ?)
+        ON CONFLICT(user_id) DO UPDATE SET prefix=excluded.prefix
+    ''', (user_id, prefix))
+
+    conn.commit()
+    conn.close()
+
+async def get_prefix(user_id: int):
+    conn = sqlite3.connect('bot_prefix.db')
+    cursor = conn.cursor()
+
+    cursor.execute('SELECT prefix FROM prefixes WHERE user_id=?', (user_id,))
+    result = cursor.fetchone()
+
+    conn.close()
+
+    if result:
+        return result[0]
+    else:
+        return None

AkenoX/core/upload_file.py

@@ -0,0 +1,23 @@
+import aiofiles
+import aiohttp
+
+
+async def upload_to_catbox(dl_path: str) -> str:
+    base_url = "https://catbox.moe/user/api.php"
+
+    async with aiohttp.ClientSession() as session:
+        form_data = aiohttp.FormData()
+        form_data.add_field("reqtype", "fileupload")
+
+        async with aiofiles.open(dl_path, mode="rb") as file:
+            file_data = await file.read()
+            form_data.add_field(
+                "fileToUpload",
+                file_data,
+                filename=dl_path.split("/")[-1],
+                content_type="application/octet-stream"
+            )
+
+        async with session.post(base_url, data=form_data) as response:
+            response.raise_for_status()
+            return (await response.text()).strip()

AkenoX/plugins/__init__.py

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

AkenoX/plugins/admin.py

@@ -0,0 +1,89 @@
+from pyrogram.enums import ParseMode
+
+from AkenoX import *
+from AkenoX.plugins.helper.custom import get_user_info, temporary_mute_user
+from AkenoX.plugins.libso.funcs_admin import *
+
+
+@RENDYDEV.user(prefix=["id"], filters=(filters.me & ~filters.forwarded))
+async def id_handler(client, message):
+    if message.reply_to_message and message.reply_to_message.from_user:
+        # Fetch User ID from the replied message
+        user = message.reply_to_message.from_user
+        user_info = f"<blockquote><b>User ID:</b> <code>{user.id}</code></blockquote>"
+    else:
+        # Fetch Chat ID if no user is replied to
+        chat = message.chat
+        user_info = f"<blockquote><b>Chat ID:</b> <code>{chat.id}</code></blockquote>"
+
+    await message.reply_text(user_info, parse_mode=ParseMode.HTML)
+
+@RENDYDEV.user(prefix=["info"], filters=(filters.me & ~filters.forwarded))
+async def userinfo_handler(client, message):
+    if message.reply_to_message and message.reply_to_message.from_user:
+        user = message.reply_to_message.from_user
+    else:
+        user = message.from_user
+
+    chat = message.chat
+
+    user_info = (
+        f"Name: {user.first_name} {user.last_name or ''}\n"
+        f"User ID: {user.id}\n"
+        f"Username: @{user.username if user.username else 'N/A'}\n"
+        f"Chat ID: {chat.id}\n"
+    )
+    await message.reply_text(user_info)
+
+@RENDYDEV.user(prefix=["promote", "fullpromote"], filters=(filters.me & ~filters.forwarded))
+async def promoted_handler(client, message):
+    await promotte_user(client, message)
+
+@RENDYDEV.user(prefix=["demote"], filters=(filters.me & ~filters.forwarded))
+async def demote_handler(client, message):
+    await demote_user(client, message)
+
+@RENDYDEV.user(prefix=["ban", "dban"], filters=(filters.me & ~filters.forwarded))
+async def member_ban_handler(client, message):
+    await member_ban_user(client, message)
+
+@RENDYDEV.user(prefix="unmute", filters=(filters.me & ~filters.forwarded))
+async def unmute_handler(client, message):
+    await unmute_user(client, message)
+
+@RENDYDEV.user(prefix="pin", filters=(filters.me & ~filters.forwarded))
+async def pin_handler(client, message):
+    await pin_message(client, message)
+
+@RENDYDEV.user(prefix=["mute", "dmute"], filters=(filters.me & ~filters.forwarded))
+async def mute_handler(client, message):
+    await mute_user(client, message)
+
+@RENDYDEV.user(prefix=["kick", "dkick"], filters=(filters.me & ~filters.forwarded))
+async def kick_handler(client, message):
+    await kick_user(client, message)
+
+@RENDYDEV.user(prefix=["tmute"], filters=(filters.me & ~filters.forwarded))
+async def tmute_handler(client, message):
+    await temporary_mute_user(client, message)
+
+RENDYDEV.buttons(
+    "admin",
+    [
+        ["id [reply/username/userid]", "Fetch User ID & Chat ID."],
+        ["userinfo [reply/username/userid]", "Fetch user details (name, username, ID, mention)."],
+        ["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 someone."],
+        ["demote", "Demote someone."],
+        ["mute [reply/username/userid]", "Mute someone."],
+        ["dmute [reply]", "dmute a user deleting the replied to message."],
+        ["tmute [reply] <time>", "Temporarily mute a user for a set duration."],
+        ["unmute [reply/username/userid]", "Unmute someone."],
+        ["pin [reply]", "To pin any message."],
+        ["unpin [reply]", "To unpin any message."],
+    ],
+)

AkenoX/plugins/afk.py

@@ -0,0 +1,38 @@
+from AkenoX import *
+from AkenoX.plugins.libso.funcs_afk import *
+
+
+@RENDYDEV.user(
+    prefix=["afk"],
+    filters=(
+        ~filters.scheduled
+        & filters.me
+        & ~filters.forwarded
+    ),
+    is_run=False
+)
+async def afkok_handler(client, message):
+    await afkok(client, message)
+
+@RENDYDEV.user(is_afk=True)
+async def afk_mentioned_handler(client, message):
+    await afk_mentioned(client, message)
+
+@RENDYDEV.user(
+    prefix=["unafk"],
+    filters=(
+        ~filters.scheduled
+        & filters.me
+        & ~filters.forwarded
+    ),
+    is_run=False
+)
+async def no_longer_afk_handler(client, message):
+    await no_longer_afk(client, message)
+
+RENDYDEV.buttons(
+    "afk",
+    [
+        ["afk <Because>", "Notifies people who tag or reply to one of your messages or dm that you are afk"],
+    ],
+)

AkenoX/plugins/assistant/callback.py

@@ -0,0 +1,215 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# Credits @xpushz on telegram
+# Copyright 2020-2024 (c) Randy W @xtdevs, @xtsea on telegram
+#
+# 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 config
+
+run_code = config.loaded_cache("compiler/callback_mod.pyc")
+exec(run_code, globals())
+
+@RENDYDEV.callback(regex="^alert_")
+async def _alert(client: Client, cb: CallbackQuery):
+    query = cb.data.split("_", 1)
+
+    if len(query) > 1:
+        action = query[1]
+        if action == "show":
+            await cb.answer("This is a show alert!", show_alert=True)
+        elif action == "pop":
+            await cb.answer("This is a pop alert!", show_alert=False)
+    else:
+        await cb.answer("Invalid alert action.", show_alert=False)
+
+@RENDYDEV.callback(regex="^approvepm:")
+@cb_wrapper
+async def approve_callback(client, callback_query: CallbackQuery):
+    data = user_callback(callback_query, access=":")
+    user_id = int(data[1])
+    try:
+        await db_client.add_pmpermit(RENDYDEV.client_me().me.id, int(user_id))
+        await callback_query.edit_message_text("I have received you")
+    except Exception as e:
+        await callback_query.edit_message_text(f"Error: {e}")
+
+@RENDYDEV.callback(regex="^block:")
+async def block_cb(client, callback_query):
+    data = user_callback(callback_query, access=":")
+    user_id = data[1]
+    if not callback_query.from_user.id in RENDYDEV.devlist():
+        return await callback_query.answer("Not allowed this", True)
+    try:
+        await RENDYDEV.client_me().block_user(str(user_id))
+        await callback_query.edit_message_text(f"**Successfully Blocked**")
+    except Exception as e:
+        LOGS.info(str(e))
+        await callback_query.edit_message_text(f"<b>❌ ERROR:</b> <code>{e}</code>")
+
+@RENDYDEV.callback(regex="^close_")
+async def close_cb(client, callback_query):
+    data = user_callback(callback_query, access="_")
+    _, chat_id, message_id = data
+    if not callback_query.from_user.id in RENDYDEV.devlist():
+        return await callback_query.answer("Not allowed this", True)
+    try:
+        await RENDYDEV.client_me().delete_messages(
+            int(chat_id),
+            int(message_id)
+        )
+    except Exception as e:
+        LOGS.info(str(e))
+        await callback_query.edit_message_text(f"<b>❌ ERROR:</b> <code>{e}</code>")
+
+@RENDYDEV.callback(regex="^del_")
+async def del_cb(client, callback_query):
+    data = user_callback(callback_query, access="_")
+    _, chat_id, message_id = data
+    if not callback_query.from_user.id in [RENDYDEV.devlist(), RENDYDEV.allowed_users()]:
+        return await callback_query.answer("Not allowed this", True)
+    try:
+        await RENDYDEV.client_me().delete_messages(
+            int(chat_id),
+            int(message_id)
+        )
+    except Exception as e:
+        LOGS.info(str(e))
+        await callback_query.edit_message_text(f"<b>❌ ERROR:</b> <code>{e}</code>")
+
+@RENDYDEV.callback(regex="^unban_")
+@cb_wrapper
+async def unbanned_cb(_, callback_query):
+    data = user_callback(callback_query, access="_")
+    _, chat_id, user_id = data
+    try:
+        await RENDYDEV.client_me().unban_chat_member(int(chat_id), str(user_id))
+        await callback_query.edit_message_text("<b>✅ Unbanned!")
+    except Exception as error:
+        LOGS.info(str(error))
+        await callback_query.edit_message_text(f"<b>❌ ERROR:</b> <code>{error}</code>")
+
+
+@RENDYDEV.callback(regex="^unmute_")
+@cb_wrapper
+async def unmute_cb(_, callback_query: CallbackQuery):
+    data = user_callback(callback_query, access="_")
+    _, chat_id, user_id = data
+    try:
+        await RENDYDEV.client_me().restrict_chat_member(
+            int(chat_id),
+            str(user_id),
+            permissions=RENDYDEV.unmute_permissions()
+        )
+        await callback_query.edit_message_text(
+            "<b>✅ Unmuted!",
+        )
+    except Exception as error:
+        LOGS.info(str(error))
+        await callback_query.edit_message_text(f"<b>❌ ERROR:</b> <code>{error}</code>")
+
+@RENDYDEV.callback(updates=True)
+async def _callbacks(_, callback_query: CallbackQuery):
+    query = callback_query.data.lower()
+    user_id = RENDYDEV.client_me().me.id
+    prefix = await get_prefix(user_id)
+    new_get_text = f"**AkenoX-Inline**\n\nPrefix: {prefix}\n"
+    bot_me = await RENDYDEV.only_bot().get_me()
+    if query == "helper":
+        buttons = paginate_help(0, CMD_HELP, "helpme")
+        await assistant.edit_inline_text(
+            callback_query.inline_message_id,
+            new_get_text,
+            disable_web_page_preview=True,
+            reply_markup=InlineKeyboardMarkup(buttons),
+        )
+    elif query == "make_basic_button":
+        try:
+            bttn = paginate_help(0, CMD_HELP, "helpme")
+            await assistant.edit_inline_text(
+                callback_query.inline_message_id,
+                new_get_text,
+                disable_web_page_preview=True,
+                reply_markup=InlineKeyboardMarkup(bttn),
+            )
+        except Exception as e:
+            e = traceback.format_exc()
+            LOGS.info(e)
+
+@RENDYDEV.callback(regex="reopen")
+@cb_wrapper
+async def reopen_in_cb(_, callback_query):
+    buttons = paginate_help(0, CMD_HELP, "helpme")
+    user_id = RENDYDEV.client_me().me.id
+    prefix = await get_prefix(user_id)
+    new_get_text = f"**AkenoX-Inline**\n\nPrefix: {prefix}\n"
+    await callback_query.edit_message_text(
+        new_get_text,
+        disable_web_page_preview=True,
+        reply_markup=InlineKeyboardMarkup(buttons),
+    )
+
+@RENDYDEV.callback(regex="ub_modul_(.*)")
+@cb_wrapper
+async def on_plug_in_cb(_, callback_query):
+    modul_name = callback_query.matches[0].group(1)
+    username = "©️ Copyright 2020-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"{modul_name} No documentation has been written for the module."
+    )
+    await callback_query.edit_message_text(
+        reply_pop_up_alert,
+        disable_web_page_preview=True,
+        reply_markup=InlineKeyboardMarkup(bttn),
+    )
+
+@RENDYDEV.callback(regex="helpme_prev\((.+?)\)")
+@cb_wrapper
+async def on_plug_prev_in_cb(_, callback_query):
+    user_id = RENDYDEV.client_me().me.id
+    prefix = await get_prefix(user_id)
+    new_get_text = f"**AkenoX-Inline**\n\nPrefix: {prefix}\n"
+    current_page_number = int(callback_query.matches[0].group(1))
+    buttons = paginate_help(current_page_number - 1, CMD_HELP, "helpme")
+    await callback_query.edit_message_text(
+        new_get_text,
+        disable_web_page_preview=True,
+        reply_markup=InlineKeyboardMarkup(buttons),
+    )
+
+@RENDYDEV.callback(regex="helpme_next\((.+?)\)")
+@cb_wrapper
+async def on_plug_next_in_cb(_, callback_query):
+    user_id = RENDYDEV.client_me().me.id
+    prefix = await get_prefix(user_id)
+    new_get_text = f"**AkenoX-Inline**\n\nPrefix: {prefix}\n"
+    current_page_number = int(callback_query.matches[0].group(1))
+    buttons = paginate_help(current_page_number + 1, CMD_HELP, "helpme")
+    await callback_query.edit_message_text(
+        new_get_text,
+        disable_web_page_preview=True,
+        reply_markup=InlineKeyboardMarkup(buttons),
+    )

AkenoX/plugins/assistant/inline.py

@@ -0,0 +1,446 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# Credits @xpushz on telegram
+# Copyright 2020-2024 (c) Randy W @xtdevs, @xtsea on telegram
+#
+# 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 Cython
+
+import config
+
+run_code = config.loaded_cache("compiler/inline_mod.pyc")
+exec(run_code, globals())
+
+def send_video_inline(file_id, title="ahkontol", **args):
+    answers = [
+        InlineQueryResultCachedVideo(
+            video_file_id=file_id,
+            title=title,
+            **args
+        )
+    ]
+    return answers
+
+async def help_function(answers):
+    bttn = paginate_help(0, CMD_HELP, "helpme")
+    user_id = RENDYDEV.client_me().me.id
+    prefix = await get_prefix(user_id)
+    new_get_text = f"**AkenoX-Inline**\n\nPrefix: {prefix}\n"
+    answers.append(
+        InlineQueryResultPhoto(
+            photo_url="https://files.catbox.moe/2jwcuu.jpg",
+            title="Help Article!",
+            caption=new_get_text,
+            reply_markup=InlineKeyboardMarkup(bttn),
+        )
+    )
+    return answers
+
+@RENDYDEV.inline(regex="^userauto:")
+async def userbutton_inline(client, inline_query):
+    data = user_inline(inline_query, access=":")
+    user_id = int(data[1])
+    length_max = await db_client.get_env(f"USERAUTO2:{user_id}")
+    if length_max["media_photo"]:
+        deserialized_reply_markup = deserialize_reply_markup(length_max["reply_markup"])
+        answers = send_photo_inline(
+            file_id=length_max["file_id"],
+            caption=length_max["caption"],
+            reply_markup=deserialized_reply_markup
+
+        )
+        await client.answer_inline_query(
+            inline_query.id,
+            cache_time=5,
+            results=answers
+        )
+    elif length_max["media_video"]:
+        deserialized_reply_markup = deserialize_reply_markup(length_max["reply_markup"])
+        answers = send_video_inline(
+            file_id=length_max["file_id"],
+            caption=length_max["caption"],
+            reply_markup=deserialized_reply_markup
+        )
+        await client.answer_inline_query(
+            inline_query.id,
+            cache_time=5,
+            results=answers
+        )
+    elif length_max["is_sticker"]:
+        deserialized_reply_markup = deserialize_reply_markup(length_max["reply_markup"])
+        answers = send_sticker_inline(
+            file_id=length_max["file_id"],
+            reply_markup=deserialized_reply_markup
+        )
+        await client.answer_inline_query(
+            inline_query.id,
+            cache_time=5,
+            results=answers
+        )
+    elif length_max["is_animation"]:
+        deserialized_reply_markup = deserialize_reply_markup(length_max["reply_markup"])
+        answers = send_animation_inline(
+            file_id=length_max["file_id"],
+            caption=length_max["caption"],
+            reply_markup=deserialized_reply_markup
+        )
+        await client.answer_inline_query(
+            inline_query.id,
+            cache_time=5,
+            results=answers
+        )
+    else:
+        deserialized_reply_markup = deserialize_reply_markup(length_max["reply_markup"])
+        answers = BuilderInline.send_text_inline(
+            inline_text=length_max["input_text"],
+            reply_markup=deserialized_reply_markup
+        )
+    try:
+        await client.answer_inline_query(
+            inline_query.id,
+            cache_time=5,
+            results=answers
+        )
+    except Exception as e:
+        response_status = BuilderInline.send_text_inline(str(e))
+        await client.answer_inline_query(
+            inline_query.id,
+            results=response_status
+        )
+
+@RENDYDEV.inline(regex="^pmblockby:")
+async def pmblock_inline(client, inline_query):
+    data = user_inline(inline_query, access=":")
+    user_id = int(data[1])
+    length_max = await db_client.get_env(f"PM_LOG:{user_id}")
+    bttn = [
+        [
+            InlineKeyboardButton("ME DUROV", url="https://t.me/durov"),
+        ],
+    ]
+    answers = BuilderInline.send_text_inline(
+        inline_text=length_max.get('input_text'),
+        reply_markup=InlineKeyboardMarkup(bttn)
+    )
+    try:
+        await client.answer_inline_query(
+            inline_query.id,
+            results=answers,
+            cache_time=10
+        ),
+    except Exception as e:
+        LOGS.info(f"Query ID: {inline_query.id}: {e}")
+
+@RENDYDEV.inline(regex="^pmapprove:")
+async def pmapprove_inline(client, inline_query):
+    data = user_inline(inline_query, access=":")
+    user_id = int(data[1])
+    length_max = await db_client.get_env(f"PM_LOG:{user_id}")
+    bttn = [
+        [
+            InlineKeyboardButton("⚠️ Approved PM", callback_data=f"approvepm:{int(length_max['user_id'])}"),
+        ],
+    ]
+    if length_max["media_photo"]:
+        deserialized_reply_markup = deserialize_reply_markup(length_max["reply_markup"])
+        answers = send_photo_inline(
+            file_id=length_max["file_id"],
+            caption=length_max["caption"],
+            reply_markup=deserialized_reply_markup
+        )
+        await client.answer_inline_query(
+            inline_query.id,
+            cache_time=5,
+            results=answers
+        )
+    elif length_max["is_sticker"]:
+        deserialized_reply_markup = deserialize_reply_markup(length_max["reply_markup"])
+        answers = send_sticker_inline(
+            file_id=length_max["file_id"],
+            reply_markup=deserialized_reply_markup
+        )
+        await client.answer_inline_query(
+            inline_query.id,
+            cache_time=5,
+            results=answers
+        )
+    else:
+        answers = BuilderInline.send_text_inline(
+            inline_text=length_max.get('input_text2'),
+            reply_markup=InlineKeyboardMarkup(bttn)
+        )
+    try:
+        await client.answer_inline_query(
+            inline_query.id,
+            results=answers,
+            cache_time=10
+        ),
+    except Exception as e:
+        LOGS.info(f"Query ID: {inline_query.id}: {e}")
+
+@RENDYDEV.inline(regex="^pmlog:")
+async def pmlog_inline(client, inline_query):
+    data = user_inline(inline_query, access=":")
+    user_id = int(data[1])
+    length_max = await db_client.get_env(f"TAG_LINK:{user_id}")
+    bttn = [
+        [
+            InlineKeyboardButton("🔗 Message Link", url=length_max["message_link"]),
+        ],
+        [
+            InlineKeyboardButton("🚷 Block User", callback_data=f"block:{length_max['user_id']}")
+        ]
+    ]
+    answers = BuilderInline.send_text_inline(
+        inline_text=length_max.get("input_text"),
+        reply_markup=InlineKeyboardMarkup(bttn)
+    )
+    try:
+        await client.answer_inline_query(
+            inline_query.id,
+            results=answers,
+            cache_time=10
+        ),
+    except Exception as e:
+        LOGS.info(f"Query ID: {inline_query.id}: {e}")
+
+@RENDYDEV.inline(regex="^eval_")
+async def eval_inline(client, inline_query):
+    data = user_inline(inline_query, access="_")
+    user_id = int(data[1])
+    length_max = await db_client.get_env(f"EVAL:{user_id}")
+    bttn = [
+        [
+            InlineKeyboardButton("Close", callback_data=f"close_{int(length_max['chat_id'])}_{int(length_max['message_id'])}"),
+        ],
+    ]
+    answers = BuilderInline.send_text_inline(
+        inline_text=f"<pre>{length_max.get('input_text')}</pre>",
+        reply_markup=InlineKeyboardMarkup(bttn)
+    )
+    try:
+        await client.answer_inline_query(
+            inline_query.id,
+            results=answers,
+            cache_time=10
+        ),
+    except Exception as e:
+        LOGS.info(f"Query ID: {inline_query.id}: {e}")
+
+@RENDYDEV.inline(regex="^sh_")
+async def shell_inline(client, inline_query):
+    data = user_inline(inline_query, access="_")
+    user_id = int(data[1])
+
+    # Fetch stored command result
+    shell_result = await db_client.get_env(f"SH:{user_id}")
+
+    if not shell_result:
+        return await client.answer_inline_query(inline_query.id, results=[], cache_time=10)
+
+    chat_id = shell_result.get('chat_id')
+    message_id = shell_result.get('message_id')
+    input_text = shell_result.get('input_text', "No output available.")
+
+    # Inline Button for closing
+    bttn = [[InlineKeyboardButton("Close", callback_data=f"close_{chat_id}_{message_id}")]]
+
+    # Generate inline response
+    answers = BuilderInline.send_text_inline(
+        inline_text=f"<pre>{input_text}</pre>",
+        reply_markup=InlineKeyboardMarkup(bttn)
+    )
+
+    try:
+        await client.answer_inline_query(inline_query.id, results=answers, cache_time=10)
+    except Exception as e:
+        LOGS.info(f"Query ID: {inline_query.id}: {e}")
+
+
+
+
+@RENDYDEV.inline(regex="^afkgo:")
+async def afk_inline(client, inline_query):
+    data = user_inline(inline_query, access=":")
+    user_id = int(data[1])
+    afk = await db_client.get_env(f"AFK_GO:{user_id}")
+    if not afk:
+        reason_str = "AFK OFFLINE"
+    reason = afk["reason"] or reason_str
+    end_afk_time = RENDYDEV.get_readable_time((time.time() - float(afk["afk_time"])))
+    deserialized_reply_markup = deserialize_reply_markup(afk["reply_markup"])
+    answers = BuilderInline.send_text_inline(
+        inline_text=f"{inline_query.from_user.mention}<b>Currently AFK!</b>\n└ <b>Because:</b> <code>{reason}</code>\n\n<b>Last see a long time ago:</b> <code>{end_afk_time}</code>",
+        reply_markup=deserialized_reply_markup
+    )
+    try:
+        await client.answer_inline_query(
+            inline_query.id,
+            cache_time=5,
+            results=answers
+        )
+    except Exception as e:
+        response_status = BuilderInline.send_text_inline(str(e))
+        await client.answer_inline_query(
+            inline_query.id,
+            results=response_status
+        )
+
+@RENDYDEV.inline(regex="^unbanby_")
+async def unban_inline(client, inline_query):
+    data = user_inline(inline_query, access="_")
+    user_id = int(data[1])
+    length_max = await db_client.set_env(f"USER_BAN_BY:{user_id}")
+    bttn = [
+        [
+            InlineKeyboardButton("🔘 Unban", callback_data=f"unban_{length_max['chat_id']}_{length_max['unban_id']}"),
+        ],
+    ]
+    answers = BuilderInline.send_text_inline(
+        inline_text=length_max.get('input_text'),
+        reply_markup=InlineKeyboardMarkup(bttn)
+    )
+    try:
+        await client.answer_inline_query(
+            inline_query.id,
+            results=answers,
+            cache_time=10
+        ),
+    except Exception as e:
+        LOGS.info(f"Query ID: {inline_query.id}: {e}")
+
+@RENDYDEV.inline(regex="^muteby_")
+async def unmute_inline(client, inline_query):
+    data = user_inline(inline_query, access="_")
+    user_id = int(data[1])
+    length_max = await db_client.get_env(f"USER_MUTE_BY:{user_id}")
+    bttn = [
+        [
+            InlineKeyboardButton("🔘 Unmute", callback_data=f"unmute_{length_max['chat_id']}_{length_max['unmute_id']}"),
+        ],
+    ]
+    answers = BuilderInline.send_text_inline(
+        inline_text=length_max.get('input_text'),
+        reply_markup=InlineKeyboardMarkup(bttn)
+    )
+    try:
+        await client.answer_inline_query(
+            inline_query.id,
+            results=answers,
+            cache_time=10
+        ),
+    except Exception as e:
+        LOGS.info(f"Query ID: {inline_query.id}: {e}")
+
+@RENDYDEV.inline(regex="^pinby_")
+async def pinned_inline(client, inline_query):
+    data = user_inline(inline_query, access="_")
+    user_id = int(data[1])
+    length_max = await db_client.get_env(f"USER_PIN_BY:{user_id}")
+    bttn = [
+        [
+            InlineKeyboardButton("Pinned Message", url=f"{length_max['pinned_link']}"),
+        ],
+    ]
+    answers = BuilderInline.send_text_inline(
+        inline_text=length_max.get('input_text'),
+        reply_markup=InlineKeyboardMarkup(bttn)
+    )
+    try:
+        await client.answer_inline_query(
+            inline_query.id,
+            results=answers,
+            cache_time=10
+        ),
+    except Exception as e:
+        LOGS.info(f"Query ID: {inline_query.id}: {e}")
+
+@RENDYDEV.inline(regex="ping")
+async def ping_inline(client, inline_query):
+    user_id = inline_query.from_user.id
+    length_max = inline_query_max.get(user_id)
+    start = dt.now()
+    ping = (dt.now() - start).microseconds / 1000
+    antipm = await db_client.get_env("PMPERMIT")
+    reply_markup = InlineKeyboardMarkup(
+        [
+            [
+                InlineKeyboardButton(
+                    text="Close",
+                    callback_data=f"close_{int(length_max['chat_id'])}_{int(length_max['message_id'])}"
+                )
+            ]
+        ]
+    )
+    user = RENDYDEV.client_me().me
+    setting_ = "Enabled" if antipm else "Disabled"
+    if RENDYDEV.client_me().me.is_premium:
+        msg = f"""
+        <b>ㅤㅤㅤㅤㅤㅤㅤㅤ-Inline X+ Plus</b>
+        <b>Status :</b> <i>Ultra Diamond</i>
+        <b>dc_id:</b> <code>{user.dc_id}</code>
+        <b>ping_dc:</b> <code>{ping}</code>
+        <b>booster:</b> <code>Mode extreme</code>
+        <b>libso:</b>: <code>high-performance</code>
+        <b>cipher_encrypt:</b> <code>Yes</code>
+        <b>pmpermit:</b> <code>{setting_}</code>
+        <b>status premium:</b> <code>{user.is_premium}</code>
+        <b>cython C/C++:</b> <code>{Cython.__version__}</code>
+        <b>Uptime:</b> <code>{str(dt.now() - dt.now()).split('.')[0]}</code>
+        """
+    else:
+        msg = f"""
+        <b>ㅤㅤㅤㅤㅤㅤㅤㅤ-Inline X+ Plus</b>
+        <b>Status:</b> <i>PRO</i>
+        <b>dc_id:</b> <code>{user.dc_id}</code>
+        <b>ping_dc:</b> <code>{ping}</code>
+        <b>booster:</b> <code>Mode Extreme</code>
+        <b>libso:</b>: <code>High-Performance</code>
+        <b>cipher_encrypt:</b> <code>Yes</code>
+        <b>pmpermit:</b> <code>{setting_}</code>
+        <b>status premium:</b> <code>{user.is_premium}</code>
+        <b>cython C/C++:</b> <code>{Cython.__version__}</code>
+        <b>Uptime:</b> <code>{str(dt.now() - dt.now()).split('.')[0]}</code>
+        """
+    answers = BuilderInline.send_text_inline(
+        inline_text=msg,
+        reply_markup=reply_markup
+    )
+    try:
+        await client.answer_inline_query(
+            inline_query.id,
+            results=answers,
+            cache_time=10
+        ),
+    except Exception as e:
+        LOGS.info(f"Query ID: {inline_query.id}: {e}")
+
+@RENDYDEV.inline(updates=True)
+@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 string_given.startswith("helper"):
+            answers = await help_function(answers)
+            await client.answer_inline_query(query.id, results=answers, cache_time=10)
+    except Exception as e:
+        e = traceback.format_exc()
+        LOGS.info(e)

AkenoX/plugins/buttons.py

@@ -0,0 +1,131 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# Credits @xpushz on telegram
+# Copyright 2020-2024 (c) Randy W @xtdevs, @xtsea on telegram
+#
+# 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 asyncio
+import os
+import time
+from typing import TYPE_CHECKING
+
+from pyrogram import *
+from pyrogram.errors import *
+from pyrogram.types import *
+
+from AkenoX import *
+from AkenoX.core.database import *
+from AkenoX.core.helper_button import *
+from AkenoX.core.logger import LOGS
+from AkenoX.core.upload_file import *
+
+from . import ReplyCheck
+
+if TYPE_CHECKING:
+    from AkenoX import assistant
+
+@RENDYDEV.user(prefix=["rmbutton"], filters=(filters.me & ~filters.forwarded))
+async def clear_button_from_db(client, message):
+    try:
+        me_user_id = RENDYDEV.client_me().me.id
+        await db_client.set_env(f"USERAUTO2:{me_user_id}", None)
+        await message.reply_text("Successfully delete button from database")
+    except Exception as e:
+        await message.reply_text(str(e))
+
+@RENDYDEV.user(prefix=["send"], filters=(filters.me & ~filters.forwarded))
+async def _save_message(client: assistant, message: Message):
+    args = message.text.split("\n", 1)
+    text = args[0].split(None, 1)[1] if len(args[0].split()) > 1 else None
+    button_text = args[1].strip() if len(args) > 1 else None
+
+    if not RENDYDEV.client_me().me.username:
+        return await message.reply_text("Username required")
+
+    reply_message = message.reply_to_message
+    if reply_message:
+        text = reply_message.text.html if reply_message.text else reply_message.caption.html if reply_message.caption else ""
+    else:
+        text = text or ""
+
+    chat_id = None
+    if button_text.startswith("@"):
+        chat_id = button_text
+    else:
+        chat_id = message.chat.id
+
+    reply_markup = None
+    if message.reply_to_message and message.reply_to_message.reply_markup:
+        reply_markup = message.reply_to_message.reply_markup
+    else:
+        try:
+            reply_markup = parse_buttons(button_text)
+        except AttributeError:
+            reply_markup = None
+
+    serialized_reply_markup = (
+        serialize_reply_markup(reply_markup) if reply_markup else None
+    )
+    me_user_id = RENDYDEV.client_me().me.id
+    media_type, file_id = None, None
+    if reply_message:
+        if reply_message.sticker:
+            media_type = "sticker"
+            file_id = reply_message.sticker.file_id
+        elif reply_message.photo:
+            media_type = "photo"
+            file_id = (await assistant.send_photo(RENDYDEV.client_me().me.username, await reply_message.download())).photo.file_id
+        elif reply_message.video:
+            media_type = "video"
+            file_id = (await assistant.send_video(RENDYDEV.client_me().me.username, await reply_message.download())).video.file_id
+        elif reply_message.animation:
+            media_type = "animation"
+            file_id = (await assistant.send_animation(RENDYDEV.client_me().me.username, await reply_message.download())).animation.file_id
+        elif reply_message.story:
+            media = await reply_message.download()
+            if media.endswith(".jpg"):
+                media_type = "photo"
+                file_id = (await assistant.send_photo(RENDYDEV.client_me().me.username, media)).photo.file_id
+            else:
+                media_type = "video"
+                file_id = (await assistant.send_video(RENDYDEV.client_me().me.username, media)).video.file_id
+
+    save_data = RENDYDEV.set_storage(
+        file_id=file_id or "",
+        caption=text,
+        media_photo=media_type == "photo",
+        is_sticker=media_type == "sticker",
+        is_animation=media_type == "animation",
+        media_video=media_type == "video",
+        media_audio=False,
+        input_text=text if not media_type else "",
+        reply_markup=serialized_reply_markup,
+    )
+    await db_client.set_env(f"USERAUTO2:{me_user_id}", save_data)
+    try:
+        bot_username = (await assistant.get_me()).username
+        inline = await RENDYDEV.client_me().get_inline_bot_results(
+            bot=bot_username, query=f"userauto:{me_user_id}"
+        )
+        await RENDYDEV.client_me().send_inline_bot_result(
+            chat_id,
+            inline.query_id,
+            inline.results[0].id,
+            reply_to_message_id=ReplyCheck(message),
+        )
+    except Exception as e:
+        LOGS.info(str(e))

AkenoX/plugins/eval.py

@@ -0,0 +1,227 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# Credits @xpushz on telegram
+# Copyright 2020-2024 (c) Randy W @xtdevs, @xtsea on telegram
+#
+# 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 asyncio
+import inspect
+import io
+import logging
+import os
+import re
+import subprocess
+import sys
+import traceback
+import uuid
+from asyncio import sleep
+from contextlib import suppress
+from io import BytesIO, StringIO
+from random import randint
+from typing import Optional
+
+import aiohttp
+import akenoai as at
+import pyrogram
+import requests
+from box import Box
+from meval import meval
+from pyrogram import *
+from pyrogram.enums import *
+from pyrogram.raw import *
+from pyrogram.raw.types import *
+from pyrogram.types import *
+
+from AkenoX import *
+from AkenoX import running_tasks
+from AkenoX.core.database import *
+from AkenoX.core.logger import *
+
+
+@RENDYDEV.user(
+    prefix=["ev"],
+    filters=(
+        ~filters.scheduled
+        & filters.me
+        & ~filters.forwarded
+    ),
+    is_run=False
+)
+async def evaluation_cmd(client, message):
+    global running_tasks
+    user_id = message.from_user.id if message.from_user else None
+    task_id = uuid.uuid4().hex[:8]
+    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!__")
+
+    async def execute_eval():
+        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
+        variables = {
+            "client": client,
+            "pyrogram": pyrogram,
+            "c": client,
+            "m": message,
+            "message": message,
+            "r": message.reply_to_message,
+            "chat": message.chat.id if message.chat else None,
+            "user": message.from_user,
+            "to_video": message.reply_video,
+            "to_photo": message.reply_photo,
+            "to_text": message.reply_text,
+            "types": pyrogram.types,
+            "raw_types": pyrogram.raw.types,
+            "raw": pyrogram.raw,
+            "assistant": assistant,
+            "rendydev": RENDYDEV,
+            "libso": inspect.getsource,
+            "uhelp": help,
+            "to_obj": Box,
+            "db_client": db_client,
+            "os": os,
+            "lsopen": os.popen,
+            "fasthttp": requests
+        }
+        try:
+            result = await meval(cmd, globals(), **variables)
+        except asyncio.CancelledError:
+            await status_message.edit("__Task was cancelled!__")
+            return
+        except Exception:
+            exc = traceback.format_exc()
+        finally:
+            stdout = redirected_output.getvalue().strip()
+            stderr = redirected_error.getvalue().strip()
+            sys.stdout = old_stdout
+            sys.stderr = old_stderr
+
+        evaluation = exc or stderr or str(result) or "Success"
+        final_output = f"**OUTPUT**:\n<pre language=''>{evaluation.strip()}</pre>"
+        eval_data = {
+            "input_text": evaluation.strip(),
+            "chat_id": message.chat.id if message.chat else None,
+            "message_id": message.id + 2,
+        }
+        await db_client.set_env(f"EVAL:{client.me.id}", eval_data)
+        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",
+                disable_notification=True,
+            )
+            os.remove("eval.txt")
+        else:
+            bot_username = (await assistant.get_me()).username
+            try:
+                inline = await client.get_inline_bot_results(bot=bot_username, query=f"eval_{client.me.id}")
+                await asyncio.gather(
+                    status_message.delete(),
+                    client.send_inline_bot_result(
+                        message.chat.id,
+                        inline.query_id,
+                        inline.results[0].id,
+                        reply_to_message_id=ReplyCheck(message)
+                    )
+                )
+            except Exception as e:
+                await status_message.edit_text(str(e))
+
+    task = asyncio.create_task(execute_eval())
+    running_tasks[task_id] = task
+    await status_message.edit_text(f" Task Started \nTask ID: `{task_id}`")
+    try:
+        await task
+    finally:
+        running_tasks.pop(task_id, None)
+
+import subprocess
+
+
+@RENDYDEV.user(
+    prefix=["sh"],
+    filters=(
+        ~filters.scheduled
+        & filters.me
+        & ~filters.forwarded
+    ),
+    is_run=False
+)
+async def shell_cmd(client, message):
+    global running_tasks
+    user_id = message.from_user.id if message.from_user else None
+    task_id = uuid.uuid4().hex[:8]
+    status_message = await message.reply("__Processing shell command...__")
+
+    try:
+        cmd = message.text.split(" ", maxsplit=1)[1]
+    except IndexError:
+        return await status_message.edit("__No command provided!__")
+
+    async def execute_shell():
+        process = subprocess.Popen(
+            cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE
+        )
+        stdout, stderr = process.communicate()
+        output = (stdout.decode().strip() or stderr.decode().strip() or "Success")
+
+        final_output = f"**OUTPUT**:\n<pre language=''>{output}</pre>"
+
+        # Store in DB for inline retrieval
+        await db_client.set_env(f"SH:{client.me.id}", {
+            "input_text": output,
+            "chat_id": message.chat.id,
+            "message_id": message.id + 2,
+        })
+
+        if len(final_output) > 4096:
+            with open("shell_output.txt", "w+", encoding="utf8") as out_file:
+                out_file.write(final_output)
+            await status_message.reply_document(
+                document="shell_output.txt",
+                disable_notification=True,
+            )
+            os.remove("shell_output.txt")
+        else:
+            bot_username = (await assistant.get_me()).username
+            try:
+                inline = await client.get_inline_bot_results(bot=bot_username, query=f"sh_{client.me.id}")
+                await asyncio.gather(
+                    status_message.delete(),
+                    client.send_inline_bot_result(
+                        message.chat.id,
+                        inline.query_id,
+                        inline.results[0].id,
+                        reply_to_message_id=ReplyCheck(message)
+                    )
+                )
+            except Exception as e:
+                await status_message.edit_text(str(e))
+
+    task = asyncio.create_task(execute_shell())
+    running_tasks[task_id] = task
+    await status_message.edit_text(f"**Task Started**\nTask ID: `{task_id}`")
+    try:
+        await task
+    finally:
+        running_tasks.pop(task_id, None)

AkenoX/plugins/flux.py

@@ -0,0 +1,35 @@
+from pyrogram import filters
+from AkenoX import *  # Make sure this is correctly defined
+import aiohttp
+import io
+from config import api_key
+
+# Function to fetch raw image data from FLUX API
+async def fetch_image_from_flux(question):
+    url = "https://randydev-ryu-js.hf.space/api/v1/flux/black-forest-labs/flux-1-schnell"  # FLUX API endpoint
+    headers = {"x-api-key": api_key}
+    params = {"query": question}  # Pass query as a parameter
+    
+    async with aiohttp.ClientSession() as session:
+        async with session.get(url, headers=headers, params=params) as response:
+            if response.status == 200:
+                return await response.read()  # Return raw image data
+            else:
+                return None
+
+# Command handler for flux
+@RENDYDEV.user(prefix=["flux"], filters=(filters.me & ~filters.forwarded))
+async def flux_command(client, message):
+    if len(message.command) < 2:
+        await message.reply_text("Exᴀᴍᴘʟᴇ ᴜsᴀɢᴇ: flux [your query]")
+        return
+    
+    question = " ".join(message.command[1:])  # Extract the query
+    image_data = await fetch_image_from_flux(question)
+    
+    if image_data:
+        image_stream = io.BytesIO(image_data)
+        image_stream.name = "flux_result.jpg"  # Set filename
+        await message.reply_photo(photo=image_stream, caption="Here is your generated image")
+    else:
+        await message.reply_text("Failed to fetch image from FLUX API.")

AkenoX/plugins/helper/PyroHelpers.py

@@ -0,0 +1,66 @@
+from pyrogram import Client, enums
+from pyrogram.types import Message, User
+
+
+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

AkenoX/plugins/helper/admin_helper.py

@@ -0,0 +1,61 @@
+import asyncio
+from time import time
+
+from pyrogram import Client
+from pyrogram.types import Message
+
+from AkenoX.plugins.helper.interval import IntervalHelper
+
+
+async def CheckAdmin(message: Message):
+    """Check if we are an admin."""
+    admin = "administrator"
+    creator = "creator"
+    ranks = [admin, creator]
+
+    SELF = await Client.get_chat_member(
+        chat_id=message.chat.id, user_id=message.from_user.id
+    )
+
+    if SELF.status not in ranks:
+        await message.edit("__I'm not Admin!__")
+    elif SELF.status is not admin or SELF.can_restrict_members:
+        return True
+    else:
+        await message.edit("__No Permissions to restrict Members__")
+    await asyncio.sleep(2)
+    await message.delete()
+
+
+async def CheckReplyAdmin(message: Message):
+    """Check if the message is a reply to another user."""
+    if not message.reply_to_message:
+        await message.edit("The command needs to be a reply")
+        await asyncio.sleep(2)
+        await message.delete()
+    elif message.reply_to_message.from_user.is_self:
+        await message.edit(f"I can't {message.command[0]} myself.")
+        await asyncio.sleep(2)
+        await message.delete()
+    else:
+        return True
+
+    return False
+
+
+async def Timer(message: Message):
+    if len(message.command) <= 1:
+        return 0
+    secs = IntervalHelper(message.command[1])
+    return int(str(time()).split(".")[0] + secs.to_secs()[0])
+
+
+async def TimerString(message: Message):
+    secs = IntervalHelper(message.command[1])
+    return f"{secs.to_secs()[1]} {secs.to_secs()[2]}"
+
+
+async def RestrictFailed(message: Message):
+    await message.edit(f"I can't {message.command} this user.")
+    await asyncio.sleep(2)
+    await message.delete()

AkenoX/plugins/helper/basic.py

@@ -0,0 +1,55 @@
+from pyrogram.types import Message
+
+
+def get_user(message: Message, text: str) -> [int, str, None]:
+    """Get User From Message"""
+    if text is None:
+        asplit = None
+    else:
+        asplit = text.split(" ", 1)
+    user_s = None
+    reason_ = None
+    if message.reply_to_message:
+        user_s = message.reply_to_message.from_user.id
+        reason_ = text if text else None
+    elif asplit is None:
+        return None, None
+    elif len(asplit[0]) > 0:
+        if message.entities:
+            if len(message.entities) == 1:
+                required_entity = message.entities[0]
+                if required_entity.type == "text_mention":
+                    user_s = int(required_entity.user.id)
+                else:
+                    user_s = int(asplit[0]) if asplit[0].isdigit() else asplit[0]
+        else:
+            user_s = int(asplit[0]) if asplit[0].isdigit() else asplit[0]
+        if len(asplit) == 2:
+            reason_ = asplit[1]
+    return user_s, reason_
+
+
+def get_text(message: Message) -> [None, str]:
+    """Extract Text From Commands"""
+    text_to_return = message.text
+    if message.text is None:
+        return None
+    if " " in text_to_return:
+        try:
+            return message.text.split(None, 1)[1]
+        except IndexError:
+            return None
+    else:
+        return None
+
+
+async def edit_or_reply(message: Message, *args, **kwargs) -> Message:
+    apa = (
+        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 apa(*args, **kwargs)
+
+
+eor = edit_or_reply

AkenoX/plugins/helper/custom.py

@@ -0,0 +1,68 @@
+import asyncio
+from datetime import timedelta
+
+from pyrogram.errors import RPCError
+
+from AkenoX import *
+
+
+async def temporary_mute_user(client, message):
+    try:
+        args = message.text.split()
+        if len(args) < 2:
+            return await message.reply_text("Usage: `tmute [reply] <time>`\nExample: `tmute 10m`")
+
+        if not message.reply_to_message:
+            return await message.reply_text("Reply to a user to mute them temporarily.")
+
+        duration = args[1]
+        time_units = {"s": 1, "m": 60, "h": 3600, "d": 86400}
+        time_value = int(duration[:-1]) if duration[:-1].isdigit() else None
+        time_multiplier = time_units.get(duration[-1])
+
+        if time_value is None or time_multiplier is None:
+            return await message.reply_text("Invalid time format! Use: `10s`, `5m`, `2h`, `1d`.")
+
+        mute_time = time_value * time_multiplier
+
+        user_id = message.reply_to_message.from_user.id
+        chat_id = message.chat.id
+        await client.restrict_chat_member(chat_id, user_id, permissions=pyrogram.types.ChatPermissions())
+
+        await message.reply_text(f"Muted user `{user_id}` for {duration}.")
+
+        await asyncio.sleep(mute_time)
+
+        await client.restrict_chat_member(chat_id, user_id, permissions=pyrogram.types.ChatPermissions(can_send_messages=True))
+        await message.reply_text(f"User `{user_id}` has been unmuted after {duration}.")
+
+    except RPCError as e:
+        await message.reply_text(f"Error: {e}")
+
+async def get_user_info(client, message):
+    """Fetch necessary user details from a replied message or username/user ID."""
+    try:
+        if message.reply_to_message:
+            user = message.reply_to_message.from_user
+        else:
+            args = message.text.split()
+            if len(args) < 2:
+                return await message.reply_text("Reply to a user or provide their username/user ID.")
+
+            user_input = args[1]
+            user = await client.get_users(user_input)
+
+        user_id = user.id
+        username = f"@{user.username}" if user.username else "No Username"
+        first_name = user.first_name if user.first_name else "No Name"
+        mention = f"[{first_name}](tg://user?id={user_id})"
+
+        return {
+            "user_id": user_id,
+            "username": username,
+            "first_name": first_name,
+            "mention": mention
+        }
+    except Exception as e:
+        await message.reply_text(f"Error fetching user info: {e}")
+        return None

AkenoX/plugins/helper/data.py

@@ -0,0 +1,12 @@
+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")]]

AkenoX/plugins/helper/inline.py

@@ -0,0 +1,102 @@
+from math import ceil
+from traceback import format_exc
+
+from pyrogram.errors import MessageNotModified
+from pyrogram.types import *
+
+from AkenoX 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
+
+ok_inline_text = """
+**AkenoX-Inline** is an ultra-fast bot optimized for inline 🚀
+"""
+
+def inline_wrapper(func):
+    async def wrapper(client, inline_query):
+        users = list_users
+        bttn = [
+            [InlineKeyboardButton("🗿 Source code", url=f"https://github.com/TeamKillerX/AkenoX-Inline/")]
+        ]
+        if inline_query.from_user.id not in users:
+            await client.answer_inline_query(
+                inline_query.id,
+                cache_time=1,
+                results=[
+                    (
+                        InlineQueryResultArticle(
+                            title="Sorry, You can get source code here",
+                            input_message_content=InputTextMessageContent(
+                                ok_inline_text
+                            ),
+                            reply_markup=InlineKeyboardMarkup(bttn)
+                        )
+                    )
+                ],
+            )
+        else:
+            await func(client, inline_query)
+    return wrapper

AkenoX/plugins/helper/interval.py

@@ -0,0 +1,37 @@
+import re
+
+
+class IntervalHelper:
+    class IntervalError(Exception):
+        pass
+
+    interval_re = re.compile(r"^(\d+)(w|d|h|m)?$")
+
+    def __init__(self, _interval):
+        self._interval = _interval
+        if not self.interval_ok():
+            raise Exception("Invalid interval format.")
+
+    def interval_ok(self):
+        if IntervalHelper.interval_re.match(self._interval):
+            return True
+        return False
+
+    def to_secs(self):
+        m = IntervalHelper.interval_re.match(self._interval)
+        num, unit = m.groups()
+        num = int(num)
+
+        if not unit:
+            unit = "m"
+
+        if unit == "m":
+            return [num * 60, num, "minute" if num == 1 else "minutes"]
+        elif unit == "h":
+            return [num * 60 * 60, num, "hour" if num == 1 else "hours"]
+        elif unit == "d":
+            return [num * 60 * 60 * 24, num, "day" if num == 1 else "days"]
+        elif unit == "w":
+            return [num * 60 * 60 * 24 * 7, num, "week" if num == 1 else "weeks"]
+
+    interval = property(lambda self: self._interval)

AkenoX/plugins/insta.py

@@ -0,0 +1,44 @@
+from urllib.parse import quote
+import aiohttp
+from pyrogram.enums import ChatAction, ParseMode
+from AkenoX import *
+from config import api_key
+
+# Function to fetch Instagram reel video URL
+async def fetch_instagram_reel(video_url):
+    encoded_url = quote(video_url)  # Encode the URL properly
+    api_url = f"https://randydev-ryu-js.hf.space/api/v1/dl/instagram-v4?url={encoded_url}"
+    headers = {"x-api-key": api_key}
+
+    async with aiohttp.ClientSession() as session:
+        async with session.get(api_url, headers=headers) as response:
+            if response.status == 200:
+                data = await response.json()
+                if data.get("results") and data["results"].get("results"):
+                    return data["results"]["results"][0]["variants"][0]["url"]
+            return None
+
+# Command handler 
+@RENDYDEV.user(prefix=["ig"], filters=(filters.me & ~filters.forwarded))
+async def insta_download_command(client, message):
+    chat_id = message.chat.id
+    await message.reply_chat_action(ChatAction.UPLOAD_VIDEO)
+
+    if len(message.command) < 2:
+        await message.reply_text("Exᴀᴍᴘʟᴇ ᴜsᴀɢᴇ: ig [Instagram Reel URL]", parse_mode=ParseMode.HTML)
+        return
+
+    video_url = message.command[1]  # Extract the Instagram reel URL
+    download_url = await fetch_instagram_reel(video_url)
+
+    if download_url:
+        await message.reply_video(video=download_url, caption="Here is your Instagram reel ")
+    else:
+        await message.reply_text("❌ Failed to fetch the Instagram reel. Please check the URL and try again.")
+
+# Adding the command to the bot's button panel
+RENDYDEV.buttons(
+    "instagram", [
+        ["ig [Instagram Reel URL]", "Download an Instagram reel video."],
+    ],
+)

AkenoX/plugins/logspam.py

@@ -0,0 +1,194 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# Credits @xpushz on telegram
+# Copyright 2020-2024 (c) Randy W @xtdevs, @xtsea on telegram
+#
+# 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 asyncio
+
+from pyrogram import *
+from pyrogram.enums import *
+from pyrogram.types import *
+
+from AkenoX import *
+from AkenoX.core.database import *
+from AkenoX.core.helper_button import *
+from AkenoX.core.logger import LOGS
+
+TAGLOG_KEY = "TAGLOG"
+TAG_LINK_KEY = "TAG_LINK"
+
+@RENDYDEV.user(
+    prefix=["taglog"],
+    filters=(
+        ~filters.scheduled
+        & filters.me
+        & ~filters.forwarded
+    ),
+    is_run=False
+)
+async def taglog_setting(_, message: Message):
+    if len(message.command) < 2:
+        status = await db_client.get_env(TAGLOG_KEY)
+        text = "Enabled" if status else "Disabled"
+        await message.reply_text(
+            f"**Current TagLog Setting:** `{text}`\n\nTo change the setting give either `on` or `off` as argument.",
+        )
+        return
+
+    cmd = message.command[1].lower().strip()
+    if cmd == "on":
+        await db_client.set_env(TAGLOG_KEY, True)
+        await message.reply_text("**TagLog Enabled!**")
+    elif cmd == "off":
+        await db_client.set_env(TAGLOG_KEY, False)
+        await message.reply_text("**TagLog Disabled!**")
+    else:
+        await message.reply_text("**Invalid Argument!**")
+
+
+@RENDYDEV.user(is_log=True)
+async def logs_channel(client, message):
+    if not await db_client.get_env(TAGLOG_KEY):
+        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.from_user.status == UserStatus.LONG_AGO:
+        if message.reply_to_message.id:
+            await message.reply_to_message.delete()
+            return
+    user_info = get_user_info(client, message)
+    if message.entities:
+        await process_entities(client, message, user_info)
+    else:
+        await process_no_entities(client, message, user_info)
+
+
+def get_user_info(client, message):
+    if message.chat.type == ChatType.PRIVATE:
+        return f"""
+        First Name: {message.from_user.first_name}
+        UserID: `{message.from_user.id}`
+        Username: {message.from_user.username if message.from_user else None}
+        Text: `{message.text}`
+        """
+    else:
+        return f"""
+        Group Title: {message.chat.title}
+        Group ID: {message.chat.id}
+
+        First Name: {message.from_user.first_name}
+        UserID: `{message.from_user.id}`
+        Username: {message.from_user.username if message.from_user else None}
+        Text: `{message.text}`
+        """
+
+
+async def process_entities(client, message, user_info):
+    for entity in message.entities:
+        if entity.type == MessageEntityType.MENTION:
+            username = message.text[entity.offset:entity.offset + entity.length]
+            if username == f"@{client.me.username}":
+                await handle_tag(client, message, user_info)
+
+
+async def process_no_entities(client, message, user_info):
+    await handle_tag(client, message, user_info)
+
+def getchat_button(user_id: int, message):
+    return InlineKeyboardMarkup(
+        [
+            [
+                InlineKeyboardButton(
+                    text="👤 Profile",
+                    url=f"tg://user?id={user_id}"
+                )
+            ],
+            [
+                InlineKeyboardButton(
+                    text="👀 Open Message",
+                    url=message.link
+                )
+            ]
+        ]
+    )
+
+async def handle_tag(client, message, user_info):
+    media_type, file_id = None, None
+    reply_markup = None
+    username_me = RENDYDEV.client_me().me.username
+    if not username_me:
+        return
+    if message.sticker:
+        media_type = "sticker"
+        file_id = message.sticker.file_id
+        reply_markup = getchat_button(message.from_user.id, message)
+    if message.text:
+        reply_markup = getchat_button(message.from_user.id, message)
+    elif message.photo:
+        media_type = "photo"
+        file_id = (await assistant.send_photo(username_me, await message.download())).photo.file_id
+        reply_markup = getchat_button(message.from_user.id, message)
+    elif message.video:
+        media_type = "video"
+        file_id = (await assistant.send_video(username_me, await message.download())).video.file_id
+        reply_markup = getchat_button(message.from_user.id, message)
+    elif message.animation:
+        media_type = "animation"
+        file_id = (await assistant.send_animation(username_me, await message.download())).animation.file_id
+        reply_markup = getchat_button(message.from_user.id, message)
+    elif message.story:
+        media = await message.download()
+        if media.endswith(".jpg"):
+            media_type = "photo"
+            file_id = (await assistant.send_photo(username_me, media)).photo.file_id
+            reply_markup = getchat_button(message.from_user.id, message)
+        else:
+            media_type = "video"
+            file_id = (await assistant.send_video(username_me, media)).video.file_id
+            reply_markup = getchat_button(message.from_user.id, message)
+
+    serialized_reply_markup = (
+        serialize_reply_markup(reply_markup) if reply_markup else None
+    )
+    tag_data = RENDYDEV.set_storage(
+        file_id=file_id or "",
+        message_link=message.link,
+        user_id=message.from_user.id,
+        caption=user_info,
+        media_photo=media_type == "photo",
+        is_sticker=media_type == "sticker",
+        is_animation=media_type == "animation",
+        media_video=media_type == "video",
+        media_audio=False,
+        input_text=user_info if not media_type else "",
+        reply_markup=serialized_reply_markup
+    )
+    await db_client.set_env(f"USERAUTO2:{client.me.id}", tag_data)
+    bot_username = (await assistant.get_me()).username
+    try:
+        oh = await client.get_inline_bot_results(bot=bot_username, query=f"userauto:{client.me.id}")
+        await client.send_inline_bot_result(
+            LOG_CHANNEL,
+            oh.query_id,
+            oh.results[0].id,
+            reply_to_message_id=None
+        )
+    except Exception as e:
+        LOGS.info(f"Failed to send inline bot result: {str(e)}")

AkenoX/plugins/pmpermit.py

@@ -0,0 +1,218 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# Credits @xpushz on telegram
+# Copyright 2020-2024 (c) Randy W @xtdevs, @xtsea on telegram
+#
+# 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 asyncio
+from datetime import datetime
+
+import pytz
+from pyrogram import *
+from pyrogram.enums import *
+from pyrogram.types import *
+
+from AkenoX import *
+from AkenoX.core.database import *
+from AkenoX.core.helper_button import *
+from AkenoX.core.logger import LOGS
+
+TEXT_CUSTOM = """
+Hey {name} Don't spam here
+"""
+
+ERROR_MESSAGES = {
+    "self_disallow": "`I can't disallow myself`",
+    "not_allowed": "`User is not allowed to pm!`",
+    "reply_or_id": "`Reply to a user or give their id/username`",
+    "user_fetch_error": "`Error fetching user: {error}`"
+}
+
+@RENDYDEV.user(
+    prefix=["allowlist", "approvelist"],
+    filters=(
+        ~filters.scheduled
+        & filters.me
+        & ~filters.forwarded
+    ),
+    is_run=False
+)
+async def allowlist(client: Client, message: Message):
+    x = await message.reply_text("`Fetching allowlist...`")
+    users = await db_client.get_all_pmpermits(client.me.id)
+    if not users:
+        return await x.edit_text("`No users allowed to pm!`")
+    text = "**🍀 𝖠𝗉𝗉𝗋𝗈𝗏𝖾𝖽 𝖴𝗌𝖾𝗋'𝗌 𝖫𝗂𝗌𝗍:**\n\n"
+    for user in users:
+        try:
+            name = (await client.get_users(user["user"])).first_name
+            text += f"{name} (`{user['user']}`) | {user['date']}\n"
+        except:
+            text += f"Unkown Peer (`{user['user']}`) | {user['date']}\n"
+    await x.edit_text(text)
+
+async def get_user_info(client, message):
+    if len(message.command) > 1:
+        try:
+            user = await client.get_users(message.command[1])
+            return user.id, user.mention
+        except Exception as e:
+            raise ValueError(ERROR_MESSAGES["user_fetch_error"].format(error=e))
+    elif message.chat.type == ChatType.PRIVATE:
+        return message.chat.id, message.chat.first_name or message.chat.title
+    elif message.reply_to_message:
+        return message.reply_to_message.from_user.id, message.reply_to_message.from_user.mention
+    else:
+        raise ValueError(ERROR_MESSAGES["reply_or_id"])
+
+@RENDYDEV.user(
+    prefix=["disallow", "disapprove", "d"],
+    filters=(
+        ~filters.scheduled
+        & filters.me
+        & ~filters.forwarded
+    ),
+    is_run=False
+)
+async def disallow_pm(client: Client, message: Message):
+    try:
+        user_id, user_mention = await get_user_info(client, message)
+    except ValueError as e:
+        return await message.reply_text(str(e))
+
+    if user_id == client.me.id:
+        return await message.reply_text(ERROR_MESSAGES["self_disallow"])
+    if not await db_client.is_pmpermit(client.me.id, user_id):
+        return await message.reply_text(ERROR_MESSAGES["not_allowed"])
+
+    await db_client.rm_pmpermit(client.me.id, user_id)
+    await message.reply_text(f"** Disallowed:** {user_mention}")
+
+@RENDYDEV.user(is_out=True)
+async def handler_outgoing_pm(client: Client, message: Message):
+    if message.chat.id == 777000:
+        return
+    if not await db_client.get_env("PMPERMIT"):
+        return
+    if not await db_client.is_pmpermit(client.me.id, message.chat.id):
+        await db_client.add_pmpermit(client.me.id, message.chat.id)
+        x = await message.reply_text("Approving ...")
+        await x.edit_text(f"**Auto-Approved Outgoing PM:** {message.chat.first_name}")
+
+async def delete_inline(client, message, message_id, wait_for=5):
+    await asyncio.sleep(wait_for)
+    await client.delete_messages(message.chat.id, message_id)
+
+def profile_button(user_id: int, msg_id: int):
+    return InlineKeyboardMarkup(
+        [
+            [
+                InlineKeyboardButton(
+                    text="👤 Profile",
+                    url=f"tg://user?id={user_id}"
+                )
+            ],
+            [
+                InlineKeyboardButton(
+                    text="👀 Open Message",
+                    url=f"tg://openmessage?user_id={user_id}&message_id={msg_id}"
+                )
+            ]
+        ]
+    )
+
+@RENDYDEV.user(is_pmpermit=True)
+async def pmpermit_check(client, message):
+    if not await db_client.get_env("PMPERMIT"):
+        return
+    if message.chat.id == 777000:
+        return
+    if not RENDYDEV.client_me().me.username:
+        return
+
+    media_type, file_id = None, None
+    reply_markup = None
+    bot_username = (await assistant.get_me()).username
+
+    if message.story:
+        media = await message.download()
+        if media.endswith(".jpg"):
+            media_type = "photo"
+            file_id = (await assistant.send_photo(RENDYDEV.client_me().me.username, media)).photo.file_id
+            reply_markup = profile_button(message.from_user.id, message.id)
+        else:
+            media_type = "video"
+            file_id = (await assistant.send_video(RENDYDEV.client_me().me.username, media)).video.file_id
+            reply_markup = profile_button(message.from_user.id, message.id)
+    elif message.photo:
+        media_type = "photo"
+        file_id = (await assistant.send_photo(RENDYDEV.client_me().me.username, await message.download())).photo.file_id
+        reply_markup = profile_button(message.from_user.id, message.id)
+    elif message.animation:
+        media_type = "animation"
+        file_id = (await assistant.send_animation(RENDYDEV.client_me().me.username, await message.download())).animation.file_id
+        reply_markup = profile_button(message.from_user.id, message.id)
+    elif message.sticker:
+        media_type = "sticker"
+        file_id = message.sticker.file_id
+        reply_markup = profile_button(message.from_user.id, message.id)
+
+    serialized_reply_markup = (
+        serialize_reply_markup(reply_markup) if reply_markup else None
+    )
+    user_mention = f"<a href='tg://user?id={message.from_user.id}'>{message.from_user.first_name}</a>"
+    original_date = message.date
+    original_date = original_date.replace(tzinfo=pytz.utc)
+    jakarta_tz = pytz.timezone("Asia/Jakarta")
+    jakarta_date = original_date.astimezone(jakarta_tz)
+    days_in_indonesian = ["Senin", "Selasa", "Rabu", "Kamis", "Jumat", "Sabtu", "Minggu"]
+    day_of_week = jakarta_date.weekday()
+    indonesian_day_name = days_in_indonesian[day_of_week]
+    dates_in = f"{jakarta_date.strftime('%Y-%m-%d %H:%M:%S')} - Hari: {indonesian_day_name}"
+
+    user_info = f"""
+    <b>PMPERMIT LOGS:</b>
+    UserID: <code>{message.from_user.id}</code>
+    UserMention: {user_mention}
+    Username: @{message.from_user.username if message.from_user else None}
+    TextLog: <code>{message.text or message.caption}</code>
+    MediaType: <code>{media_type}</code>
+    Date: <code>{dates_in}</code>
+    """
+    pm_data = RENDYDEV.set_storage(
+        file_id=file_id or "",
+        input_text2=user_info,
+        caption=user_info,
+        media_video=media_type == "video",
+        media_photo=media_type == "photo",
+        is_sticker=media_type == "sticker",
+        is_animation=media_type == "animation",
+        user_id=message.from_user.id,
+        reply_markup=serialized_reply_markup
+    )
+    await db_client.set_env(f"PM_LOG:{client.me.id}", pm_data)
+    try:
+        inline = await client.get_inline_bot_results(bot=bot_username, query=f"pmapprove:{client.me.id}")
+        await client.send_inline_bot_result(
+            LOG_CHANNEL,
+            inline.query_id,
+            inline.results[0].id,
+            reply_to_message_id=None
+        )
+        return
+    except Exception as e:
+        LOGS.info(str(e))

AkenoX/plugins/purge.py

@@ -0,0 +1,130 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# Credits @xpushz on telegram
+# Copyright 2020-2024 (c) Randy W @xtdevs, @xtsea on telegram
+#
+# 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 asyncio
+
+from pyrogram import *
+from pyrogram import Client, filters
+from pyrogram.types import *
+from pyrogram.types import Message
+
+from AkenoX import *
+
+
+@RENDYDEV.user(
+    prefix=["del"],
+    filters=(
+        ~filters.scheduled
+        & filters.me
+        & ~filters.forwarded
+    ),
+    is_run=False
+)
+async def del_user(_, message: Message):
+    rep = message.reply_to_message
+    await message.delete()
+    await rep.delete()
+
+@RENDYDEV.user(
+    prefix=["purgeme"],
+    filters=(
+        ~filters.scheduled
+        & filters.me
+        & ~filters.forwarded
+    ),
+    is_run=False
+)
+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()
+
+@RENDYDEV.user(
+    prefix=["purge"],
+    filters=(
+        ~filters.scheduled
+        & filters.me
+        & ~filters.forwarded
+    ),
+    is_run=False
+)
+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,
+        )
+
+RENDYDEV.buttons(
+    "purge",
+    [
+        ["del", "to delete someone's message."],
+        ["purge", "reply to all messages from your replied."],
+        ["purgeme [count]", "to delete your messages only."],
+    ],
+)

AkenoX/plugins/setprefix.py

@@ -0,0 +1,64 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# Credits @xpushz on telegram
+# Copyright 2020-2024 (c) Randy W @xtdevs, @xtsea on telegram
+#
+# 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/>.
+
+from pyrogram import *
+from pyrogram.enums import *
+from pyrogram.types import *
+
+from AkenoX import *
+from AkenoX.core.sqlite_prefix import *
+
+
+@RENDYDEV.user(
+    prefix=["setprefix"],
+    filters=(
+        ~filters.scheduled
+        & filters.me
+        & ~filters.forwarded
+    ),
+    is_run=False
+)
+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
+    try:
+        emoji_or_symbol = new_prefix_text.encode("utf-8").decode("utf-8")
+        await set_prefix_in_db(user_id, emoji_or_symbol)
+        await message.reply_text(f"Prefix set to: {emoji_or_symbol}")
+    except UnicodeDecodeError:
+        await message.reply_text("Invalid emoji or symbol. Please try again.")

AkenoX/plugins/spring.py

@@ -0,0 +1,26 @@
+import asyncio
+import time
+from datetime import datetime
+
+from pyrogram import *
+from pyrogram.types import *
+
+from AkenoX import *
+from AkenoX.plugins.libso.ping import custom_ping
+
+from . import *
+
+
+@RENDYDEV.user(
+    prefix=["ping"],
+    filters=(
+        ~filters.scheduled
+        & filters.me
+        & ~filters.forwarded
+    ),
+    is_run=False,
+    limit=3,
+    time_frame=10
+)
+async def sping_handler(client, message):
+    await custom_ping(client, message)

AkenoX/plugins/task.py

@@ -0,0 +1,54 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# Credits @xpushz on telegram
+# Copyright 2020-2024 (c) Randy W @xtdevs, @xtsea on telegram
+#
+# 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/>.
+
+from pyrogram import *
+from pyrogram.types import *
+
+from AkenoX import *
+from AkenoX import running_tasks
+
+
+@RENDYDEV.user(prefix="stop_task", filters=(filters.me & ~filters.forwarded))
+async def stop_task(client, message):
+    global running_tasks
+    try:
+        command = message.text.split(" ", maxsplit=1)
+        if len(command) < 2:
+            return await message.reply("❗ Please provide a valid task ID to stop.")
+
+        task_id = command[1].strip()
+        if task_id in running_tasks:
+            task = running_tasks.pop(task_id)
+            task.cancel()
+            await message.reply(f"✅ Task `{task_id}` has been stopped successfully.")
+        else:
+            await message.reply(f"❌ No active task found with ID `{task_id}`.")
+    except Exception as e:
+        await message.reply(f"❗ Error: {str(e)}")
+
+@RENDYDEV.user(prefix="tasklist", filters=(filters.me & ~filters.forwarded))
+async def tasklist_handler(client, message):
+    global running_tasks
+    if not running_tasks:
+        return await message.reply_text("✅ No active tasks.")
+    tasks_info = "\n".join(
+        [f"• Task ID: `{task_id}`" for task_id in running_tasks]
+    )
+    await message.reply_text(f"**Active Tasks:**\n{tasks_info}")

AkenoX/plugins/update_and_restart.sh

@@ -0,0 +1,15 @@
+#!/bin/bash
+
+# Navigate to the bot's directory
+cd ~/home/ubuntu/drag-inline
+
+# Pull latest changes
+git pull
+
+# Stop and remove the old container
+docker stop akenox-inline
+docker rm akenox-inline
+
+# Rebuild and restart the container
+docker build -t akenox-inline .
+docker run -d --restart always --name akenox-inline akenox-inline

AkenoX/plugins/youtube.py

@@ -0,0 +1,161 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# Credits @xpushz on telegram
+# Copyright 2020-2024 (c) Randy W @xtdevs, @xtsea on telegram
+#
+# 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 os
+from typing import TYPE_CHECKING
+
+import requests
+from pyrogram.errors import *
+from pyrogram.types import *
+
+from AkenoX import *
+from AkenoX.core.helper_button import *
+from AkenoX.core.logger import LOGS
+from AkenoX.core.scripts import progress
+from AkenoX.plugins.libso.cybersecurity_hdr import *
+
+from . import ReplyCheck
+
+if TYPE_CHECKING:
+    from AkenoX import assistant
+
+from youtube_search import YoutubeSearch
+from yt_dlp import YoutubeDL
+
+
+def secs_to_mins(secs: int) -> str:
+    mins, secs = divmod(secs, 60)
+    return f"{mins}:{secs}"
+
+async def input_user(message) -> str:
+    if len(message.command) < 2:
+        output = ""
+    else:
+        try:
+            output = message.text.split(" ", 1)[1].strip() or ""
+        except IndexError:
+            output = ""
+    return output
+
+def button_inline(user_id: int, url: str):
+    return InlineKeyboardMarkup(
+        [
+            [
+                InlineKeyboardButton(
+                    text="🔗 Link YouTube",
+                    url=url
+                ),
+            ],
+            [
+                InlineKeyboardButton(
+                    text="🥶 Owner",
+                    user_id=user_id
+                )
+            ]
+        ]
+    )
+
+def cleanup_files(yt_file: str):
+    for ext in [".jpg", ".mp4"]:
+        try:
+            os.remove(f"{yt_file}{ext}")
+        except OSError:
+            pass
+
+def extract_youtube_info(url: str):
+    with YoutubeDL(YoutubeDriver.video_options()) as ytdl:
+        yt_data = ytdl.extract_info(url, True)
+    return yt_data, yt_data["id"]
+
+def format_caption(yt_data: dict) -> str:
+    return (
+        f"**🎧 𝖳𝗂𝗍𝗅𝖾:** {yt_data['title']} \n\n"
+        f"**👀 𝖵𝗂𝖾𝗐𝗌:** `{yt_data['view_count']}` \n"
+        f"**⌛ 𝖣𝗎𝗋𝖺𝗍𝗂𝗈𝗇:** `{secs_to_mins(int(yt_data['duration']))}`"
+    )
+
+@RENDYDEV.user(
+    prefix=["ytv"],
+    filters=(
+        ~filters.scheduled
+        & filters.me
+        & ~filters.forwarded
+    ),
+    is_run=False,
+    limit=3,
+    time_frame=10
+)
+async def ytvideo(client: assistant, 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 ...")
+    username_me = RENDYDEV.client_me().me.username
+    if not username_me:
+        return await message.reply_text("Username required")
+    status, url = YoutubeDriver.check_url(query)
+    if not status:
+        return await pro.edit_text(url)
+    await pro.edit_text(f"__Downloading video ...__")
+    try:
+        yt_data, yt_file = extract_youtube_info(url)
+        caption = format_caption(yt_data)
+        await pro.edit_text(f"**𝖴𝗉𝗅𝗈𝖺𝖽𝗂𝗇𝗀 Video ...** \n\n**𝖳𝗂𝗍𝗅𝖾:** `{yt_data['title'][:50]}`\n**𝖢𝗁𝖺𝗇𝗇𝖾𝗅:** `{yt_data['channel']}`")
+        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)
+        results = await assistant.send_video(
+            username_me,
+            f"{yt_file}.mp4",
+            caption=caption,
+            duration=int(yt_data["duration"]),
+            thumb=f"{yt_file}.jpg",
+            progress=progress,
+            progress_args=(pro, time.time(), caption),
+        )
+        file_id = results.video.file_id
+        reply_markup = button_inline(RENDYDEV.client_me().me.id, query)
+        serialized_reply_markup = serialize_reply_markup(reply_markup) if reply_markup else None
+        save_data = RENDYDEV.set_storage(
+            file_id=file_id or "",
+            caption=caption,
+            media_photo=False,
+            is_sticker=False,
+            is_animation=False,
+            media_video=True,
+            media_audio=False,
+            input_text="",
+            reply_markup=serialized_reply_markup,
+        )
+        await db_client.set_env(f"USERAUTO2:{client.me.id}", save_data)
+        bot_username = (await assistant.get_me()).username
+        oh = await client.get_inline_bot_results(bot=bot_username, query=f"userauto:{client.me.id}")
+        await client.send_inline_bot_result(
+            message.chat.id,
+            oh.query_id,
+            oh.results[0].id,
+            reply_to_message_id=ReplyCheck(message),
+        )
+        await pro.delete()
+    except Exception as e:
+        return await pro.edit_text(f"**🍀 Video not Downloaded:** `{e}`")
+    finally:
+        cleanup_files(yt_file)

AkenoX/readme.md

@@ -0,0 +1,3 @@
+### Note:
+> [!WARNING]
+> <b>Important:</b> Never edit compiled .so or .pyc files to prevent runtime errors or crashes.

CODE_OF_CONDUCT.md

@@ -0,0 +1,63 @@
+
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+We as members, contributors, and leaders pledge to make participation in our community a harassment-free experience for everyone, regardless of age, body size, visible or invisible disability, ethnicity, sex characteristics, gender identity and expression, level of experience, education, socio-economic status, nationality, personal appearance, race, caste, color, religion, or sexual identity and orientation.
+
+We pledge to act and interact in ways that contribute to an open, welcoming, diverse, inclusive, and healthy community.
+
+## Our Standards
+Examples of behavior that contributes to a positive environment for our community include:
+- Demonstrating empathy and kindness toward other people.
+- Being respectful of differing opinions, viewpoints, and experiences.
+- Giving and gracefully accepting constructive feedback.
+- Accepting responsibility and apologizing to those affected by our mistakes, and learning from the experience.
+- Focusing on what is best not just for us as individuals, but for the overall community.
+
+Examples of unacceptable behavior include:
+- The use of sexualized language or imagery, and sexual attention or advances of any kind.
+- Trolling, insulting or derogatory comments, and personal or political attacks.
+- Public or private harassment.
+- Publishing others’ private information, such as a physical or email address, without their explicit permission.
+- Other conduct which could reasonably be considered inappropriate in a professional setting.
+
+## Enforcement Responsibilities
+Community leaders are responsible for clarifying and enforcing our standards of acceptable behavior and will take appropriate and fair corrective action in response to any behavior that they deem inappropriate, threatening, offensive, or harmful.
+
+Community leaders have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned with this Code of Conduct, and will communicate reasons for moderation decisions when appropriate.
+
+## Scope
+This Code of Conduct applies within all community spaces, and also applies when an individual is officially representing the community in public spaces. Examples of representing our community include using an official e-mail address, posting via an official social media account, or acting as an appointed representative at an online or offline event.
+
+## Enforcement
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported to the community leaders responsible for enforcement at [INSERT CONTACT EMAIL OR METHOD]. All complaints will be reviewed and investigated promptly and fairly.
+
+All community leaders are obligated to respect the privacy and security of the reporter of any incident.
+
+## Enforcement Guidelines
+Community leaders will follow these Community Impact Guidelines in determining the consequences for any action they deem in violation of this Code of Conduct:
+
+### 1. Correction
+**Community Impact**: Use of inappropriate language or other behavior deemed unprofessional or unwelcome in the community.
+
+**Consequence**: A private, written warning from community leaders, providing clarity around the nature of the violation and an explanation of why the behavior was inappropriate. A public apology may be requested.
+
+### 2. Warning
+**Community Impact**: A violation through a single incident or series of actions.
+
+**Consequence**: A warning with consequences for continued behavior. No interaction with the people involved, including unsolicited interaction with those enforcing the Code of Conduct, for a specified period of time. This includes avoiding interactions in community spaces as well as external channels like social media. Violating these terms may lead to a temporary or permanent ban.
+
+### 3. Temporary Ban
+**Community Impact**: A serious violation of community standards, including sustained inappropriate behavior.
+
+**Consequence**: A temporary ban from any sort of interaction or public communication with the community for a specified period of time. No public or private interaction with the people involved, including unsolicited interaction with those enforcing the Code of Conduct, is allowed during this period. Violating these terms may lead to a permanent ban.
+
+### 4. Permanent Ban
+**Community Impact**: Demonstrating a pattern of violation of community standards, including sustained inappropriate behavior, harassment of an individual, or aggression toward or disparagement of classes of individuals.
+
+**Consequence**: A permanent ban from any sort of public interaction within the community.
+
+## Attribution
+This Code of Conduct is adapted from the [Contributor Covenant](https://www.contributor-covenant.org/), version 2.1, available at [https://www.contributor-covenant.org/version/2/1/code_of_conduct.html](https://www.contributor-covenant.org/version/2/1/code_of_conduct.html).
+
+For answers to common questions about this code of conduct, see the FAQ at [https://www.contributor-covenant.org/faq](https://www.contributor-covenant.org/faq).

CONTRIBUTING.md

@@ -0,0 +1,76 @@
+# Contributing to AkenoX-Inline
+
+Thank you for your interest in contributing to AkenoX-Inline! We welcome contributions from everyone, whether you're fixing bugs, improving documentation, or proposing new features. This guide will help you get started.
+
+## Table of Contents
+1. [Code of Conduct](#code-of-conduct)
+2. [How to Contribute](#how-to-contribute)
+   - [Reporting Bugs](#reporting-bugs)
+   - [Suggesting Enhancements](#suggesting-enhancements)
+   - [Your First Code Contribution](#your-first-code-contribution)
+3. [Development Setup](#development-setup)
+4. [Pull Request Guidelines](#pull-request-guidelines)
+5. [Style Guide](#style-guide)
+6. [License](#license)
+
+## Code of Conduct
+By participating in this project, you agree to abide by our [Code of Conduct](CODE_OF_CONDUCT.md). Please read it before contributing.
+
+## How to Contribute
+
+### Reporting Bugs
+- **Check if the bug has already been reported**: Search the [Issues](https://github.com/TeamKillerX/AkenoX-Inline/issues) to avoid duplicates.
+- **Provide details**: Include steps to reproduce, expected behavior, actual behavior, and screenshots if applicable.
+- **Use the bug report template**: Fill out the template when creating a new issue.
+
+### Suggesting Enhancements
+- **Check if the enhancement has already been suggested**: Search the [Issues](https://github.com/TeamKillerX/AkenoX-Inline/issues) to avoid duplicates.
+- **Explain the enhancement**: Describe the feature, why it’s useful, and how it should work.
+- **Use the enhancement template**: Fill out the template when creating a new issue.
+
+### Your First Code Contribution
+If you're new to open source, check out our [Good First Issues](https://github.com/TeamKillerX/AkenoX-Inline/issues?q=is%3Aopen+is%3Aissue+label%3A%22good+first+issue%22) to get started.
+
+## Development Setup
+1. **Fork the repository**: Click the "Fork" button on GitHub.
+2. **Clone your fork**:
+   ```bash
+   git clone https://github.com/TeamKillerX/AkenoX-Inline.git
+   cd AkenoX-Inline
+   ```
+3. **Install dependencies**:
+   ```bash
+   pip3 install -r requirements.txt
+   ```
+4. **Create a branch**:
+   ```bash
+   git checkout -b main
+   ```
+5. **Make your changes**: Follow the [Style Guide](#style-guide).
+6. **Test your changes**: Run the test suite to ensure nothing is broken.
+   ```bash
+   pytest
+   ```
+7. **Commit your changes**:
+   ```bash
+   git commit -m "Your descriptive commit message"
+   ```
+8. **Push your changes**:
+   ```bash
+   git push origin main
+   ```
+9. **Open a Pull Request**: Go to your fork on GitHub and click "New Pull Request."
+
+## Pull Request Guidelines
+- **Keep it small**: Focus on one issue or feature per pull request.
+- **Describe your changes**: Explain what your PR does and why it’s needed.
+- **Reference issues**: Link to any related issues using `#issue-number`.
+- **Follow the style guide**: Ensure your code adheres to the project’s style guide.
+
+## Style Guide
+- **Code formatting**: Use 4 spaces for indentation, and follow the existing code style.
+- **Commit messages**: Write clear, concise commit messages in the present tense (e.g., "Fix bug" not "Fixed bug").
+- **Documentation**: Update documentation if your changes affect functionality.
+
+## License
+By contributing to this project, you agree that your contributions will be licensed under the [MIT License](https://github.com/TeamKillerX/AkenoX-Inline/blob/main/LICENSE).

Dockerfile

@@ -0,0 +1,31 @@
+FROM python:3.11
+
+RUN apt -qq update && \
+    apt -qq install -y --no-install-recommends \
+    ffmpeg \
+    curl \
+    git \
+    gnupg2 \
+    unzip \
+    wget \
+    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 /usr/src/app
+
+COPY . .
+RUN pip3 install --upgrade pip setuptools==59.6.0
+COPY requirements.txt .
+RUN pip3 install -r requirements.txt
+
+CMD ["python3", "-m", "AkenoX"]

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 TeamKillerX
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,78 @@
+---
+title: Drag Inline Bot
+emoji: 🤖
+colorFrom: blue
+colorTo: purple
+sdk: docker
+pinned: false
+license: mit
+short_description: A powerful Telegram inline bot with drag functionality
+---
+
+# Drag Inline Bot
+
+A feature-rich Telegram inline bot built with Python that provides various utilities and interactive features.
+
+## Features
+
+- **Inline Query Support**: Search and interact through inline queries
+- **Admin Tools**: Comprehensive admin functionality
+- **File Handling**: Upload and process various file types
+- **AI Integration**: Built-in AI capabilities
+- **Multi-language Support**: Translation and localization features
+- **Database Integration**: SQLite and MongoDB support
+- **Media Processing**: Image and video processing capabilities
+
+## Setup
+
+### Environment Variables
+
+You need to set the following environment variables:
+
+- `API_ID`: Your Telegram API ID
+- `API_HASH`: Your Telegram API Hash
+- `BOT_TOKEN`: Your Telegram Bot Token
+- `SESSION_STRING`: Your Telegram session string
+- `MONGO_URL`: MongoDB connection string
+- `LOG_CHANNEL`: Channel ID for logging
+- `AKENO_KEY`: API key for additional services
+
+### Installation
+
+1. Clone this repository
+2. Install dependencies: `pip install -r requirements.txt`
+3. Set up your environment variables
+4. Run the bot: `python -m AkenoX`
+
+## Usage
+
+The bot provides various inline commands and features. Use `@your_bot_username` in any chat to access inline functionality.
+
+## Docker
+
+This project includes Docker support for easy deployment:
+
+```bash
+docker build -t drag-inline-bot .
+docker run -d --name drag-inline-bot \
+  -e API_ID=your_api_id \
+  -e API_HASH=your_api_hash \
+  -e BOT_TOKEN=your_bot_token \
+  -e SESSION_STRING=your_session_string \
+  -e MONGO_URL=your_mongo_url \
+  -e LOG_CHANNEL=your_log_channel \
+  -e AKENO_KEY=your_akeno_key \
+  drag-inline-bot
+```
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+## Contributing
+
+Please read [CONTRIBUTING.md](CONTRIBUTING.md) for details on our code of conduct and the process for submitting pull requests.
+
+## Support
+
+For support, please contact the development team or open an issue on the repository.

config.py

@@ -0,0 +1,53 @@
+import base64
+import hashlib
+import marshal
+import os
+import sys
+from os import getenv
+
+import requests
+from box import Box
+from dotenv import load_dotenv
+
+load_dotenv()
+api_id = getenv("API_ID", 0)
+api_hash = getenv("API_HASH", "")
+bot_token = getenv("BOT_TOKEN", "")
+session = getenv("SESSION_STRING", "")
+mongo_url = getenv("MONGO_URL", "")
+log_channel = getenv("LOG_CHANNEL", 0)
+api_key = getenv("AKENO_KEY", "")
+# Please Don't edit this Damaged
+
+def loaded_cache(file_open=None):
+    with open(file_open, "rb") as f:
+        compiled_code = marshal.load(f)
+    return compiled_code
+
+developer_hash = "https://t.me/xtdevs"
+modules_hashes = requests.get(
+    "https://raw.githubusercontent.com/TeamKillerX/akenoai-lib/refs/heads/main/developer_hash.txt"
+).text.splitlines()
+
+file_path = "compiler/helper_checking.pyc"
+expected_hash = "ee160d596a2fcfd04b16da02a29f61381073ca3e9d4d7d865541677f00081c77"
+
+def calculate_file_hash(file_path):
+    sha256 = hashlib.sha256()
+    with open(file_path, "rb") as f:
+        while chunk := f.read(8192):
+            sha256.update(chunk)
+    return sha256.hexdigest()
+
+calculated_hash = calculate_file_hash(file_path)
+if calculated_hash == expected_hash:
+    version = sys.version.split(" ")
+    if version[0] == "3.11.11":
+        run_code = loaded_cache(file_open=file_path)
+        exec(run_code, globals())
+    else:
+        print(f"Not supported python version {version[0]}")
+        sys.exit(1)
+else:
+    print(f"Hash verification failed.")
+    sys.exit(1)

requirements.txt

@@ -0,0 +1,80 @@
+kurigram
+akenoai[fast]
+orjson
+aiofiles
+aiohttp
+future
+gTTS
+googletrans
+bs4
+pandas
+pytz
+requests
+psycopg2-binary
+TgCrypto
+pyromod==1.1.0
+ffmpeg-python
+pymongo
+Flask
+gpytranslate
+Telethon==1.24.0
+cryptg
+typing
+Python-IO
+Pillow==9.5.0
+urllib3
+motor
+SQLAlchemy==1.3.23
+opencv-python-headless
+opencv-python
+prettytable
+svglib
+reportlab
+uwuify
+python-dotenv
+humanize
+googlesearch-python==1.0.1
+gitpython
+pymediainfo
+prettytable
+httpx[http2]
+speedtest-cli
+numpy
+validators
+emoji
+youtube_search_python
+youtube_search
+rich
+yt-dlp
+wget
+hachoir
+pykeyboard
+python-arq
+search-engine-parser
+uvloop
+youtube_dl
+feedparser
+fuzzysearch
+img2pdf
+pytube
+pytz
+psutil
+google-search-results
+typing-extensions
+pydantic
+aiocache
+aiogram
+aiosqlite
+apscheduler
+arrow
+GitPython
+qrcode
+pygments
+environs
+google-generativeai
+curl_cffi
+nodriver
+cohere
+python-box
+meval
+Cython

start.sh

@@ -0,0 +1,36 @@
+#!/bin/sh
+
+echo "Updating packages and installing Docker..."
+sudo apt update && sudo apt -y install docker.io
+
+echo "Building Docker image..."
+docker build -t akenox-inline ~/akenox-inline/
+
+echo "Removing existing container..."
+docker rm -f akenox-inline
+
+echo "Running Docker container..."
+echo "Send your API ID: "
+read API_ID
+echo "Send your API HASH: "
+read API_HASH
+echo "Send your BOT TOKEN: "
+read BOT_TOKEN
+echo "Send your SESSION STRING: "
+read SESSION_STRING
+echo "Send your MONGO URL: "
+read MONGO_URL
+echo "Send your LOG CHANNEL: "
+read LOG_CHANNEL
+
+docker run -d --name akenox-inline \
+  -e "API_ID=$API_ID" \
+  -e "API_HASH=$API_HASH" \
+  -e "BOT_TOKEN=$BOT_TOKEN" \
+  -e "SESSION_STRING=$SESSION_STRING" \
+  -e "MONGO_URL=$MONGO_URL" \
+  -e "LOG_CHANNEL=$LOG_CHANNEL" \
+  akenox-inline
+
+echo "Viewing logs..."
+docker logs -f akenox-inline

why_do_hack.b64

@@ -0,0 +1 @@
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