Upload 5 files

Akeno/plugins/admin.py

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

Akeno/plugins/info.py

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

Akeno/plugins/limited.py

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

Akeno/plugins/purge.py

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

Akeno/plugins/zombies.py

@@ -0,0 +1,35 @@
+from pyrogram import Client, filters
+from pyrogram.types import Message
+from pyrogram import Client as ren
+from pyrogram.errors import *
+from pyrogram import *
+from pyrogram.types import *
+from Akeno.utils.handler import Akeno
+from config import CMD_HANDLER
+
+@Akeno(
+    ~filters.scheduled
+    & filters.command(["zombies"], CMD_HANDLER)
+    & filters.me
+    & ~filters.forwarded
+)
+async def akundeak(client: Client, message: Message):
+    chat_id = message.chat.id
+    deleted_users = []
+    banned_users = 0
+    m = await message.reply("Finding ghosts...")
+
+    async for i in client.get_chat_members(chat_id):
+        if i.user.is_deleted:
+            deleted_users.append(i.user.id)
+    if len(deleted_users) > 0:
+        for deleted_user in deleted_users:
+            try:
+                await message.chat.ban_member(deleted_user)
+            except ChatAdminRequired:
+                await m.edit_text("i not admin required")
+                return
+            banned_users += 1
+        await m.edit_text(f"Banned {banned_users} Deleted Accounts")
+    else:
+        await m.edit_text("There are no deleted accounts in this chat")