Added support for anon admins

Also made the code a little bit cleaner

sample_config.py

@@ -19,7 +19,9 @@ if HEROKU:
     MONGO_DB_URI = environ.get("MONGO_DB_URI", None)
     ARQ_API_URL = environ.get("ARQ_API_URL", None)
     ARQ_API_KEY = environ.get("ARQ_API_KEY", None)
-    LOG_MENTIONS = True if int(environ.get("LOG_MENTIONS", None)) == 1 else False
+    LOG_MENTIONS = (
+        True if int(environ.get("LOG_MENTIONS", None)) == 1 else False
+    )
 else:
     BOT_TOKEN = "467677575:YZfaakjwd545dfg-N6JStihhuw5gQeZHntc"
     API_ID = 123456

wbb/__init__.py

@@ -29,7 +29,6 @@ from os import path
 from aiohttp import ClientSession
 from motor.motor_asyncio import AsyncIOMotorClient as MongoClient
 from pyrogram import Client
-from pyromod import listen
 from Python_ARQ import ARQ
 from telegraph import Telegraph
 
@@ -40,7 +39,6 @@ if is_config:
 else:
     from sample_config import *
 
-listen = listen
 USERBOT_PREFIX = USERBOT_PREFIX
 GBAN_LOG_GROUP_ID = GBAN_LOG_GROUP_ID
 SUDOERS = SUDO_USERS_ID

wbb/core/decorators/errors.py

@@ -1,4 +1,5 @@
 """ WRITTEN BY @pokurt, https://github.com/pokurt"""
+
 import sys
 import traceback
 from functools import wraps

wbb/core/decorators/permissions.py

@@ -0,0 +1,60 @@
+from functools import wraps
+
+from pyrogram.errors.exceptions.forbidden_403 import ChatWriteForbidden
+from pyrogram.types import Message
+
+from wbb import SUDOERS, app
+from wbb.modules.admin import member_permissions
+
+
+async def authorised(func, subFunc2, client, message, *args, **kwargs):
+    chatID = message.chat.id
+    try:
+        await func(client, message, *args, **kwargs)
+    except ChatWriteForbidden:
+        await app.leave_chat(chatID)
+    except Exception as e:
+        try:
+            await message.reply_text(str(e))
+        except ChatWriteForbidden:
+            await app.leave_chat(chatID)
+    return subFunc2
+
+
+async def unauthorised(message: Message, permission, subFunc2):
+    chatID = message.chat.id
+    text = (
+        "You don't have the required permission to perform this action."
+        + f"\n**Permission:** __{permission}__"
+    )
+    try:
+        await message.reply_text(text)
+    except ChatWriteForbidden:
+        await app.leave_chat(chatID)
+    return subFunc2
+
+
+def adminsOnly(permission):
+    def subFunc(func):
+        @wraps(func)
+        async def subFunc2(client, message: Message, *args, **kwargs):
+            chatID = message.chat.id
+            if not message.from_user:
+                # For anonymous admins
+                if message.sender_chat:
+                    return await authorised(
+                        func, subFunc2, client, message, *args, **kwargs
+                    )
+                return await unauthorised(message, permission, subFunc2)
+            # For admins and sudo users
+            userID = message.from_user.id
+            permissions = await member_permissions(chatID, userID)
+            if userID not in SUDOERS and permission not in permissions:
+                return await unauthorised(message, permission, subFunc2)
+            return await authorised(
+                func, subFunc2, client, message, *args, **kwargs
+            )
+
+        return subFunc2
+
+    return subFunc

wbb/modules/admin.py

@@ -22,10 +22,9 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
 """
 import asyncio
-import traceback
 
 from pyrogram import filters
-from pyrogram.types import ChatPermissions
+from pyrogram.types import ChatPermissions, Message
 
 from wbb import BOT_ID, SUDOERS, app
 from wbb.core.decorators.errors import capture_err
@@ -36,6 +35,7 @@ __MODULE__ = "Admin"
 __HELP__ = """/ban - Ban A User
 /unban - Unban A User
 /warn - Warn A User
+/rmwarn - Remove 1 Warning Of A User
 /rmwarns - Remove All Warning of A User
 /warns - Show Warning Of A User
 /kick - Kick A User
@@ -50,15 +50,6 @@ __HELP__ = """/ban - Ban A User
 /report | @admins - Report A Message To Admins."""
 
 
-async def list_admins(chat_id: int):
-    list_of_admins = []
-    async for member in app.iter_chat_members(
-        chat_id, filter="administrators"
-    ):
-        list_of_admins.append(member.user.id)
-    return list_of_admins
-
-
 async def member_permissions(chat_id: int, user_id: int):
     perms = []
     member = await app.get_chat_member(chat_id, user_id)
@@ -83,6 +74,18 @@ async def member_permissions(chat_id: int, user_id: int):
     return perms
 
 
+from wbb.core.decorators.permissions import adminsOnly
+
+
+async def list_admins(chat_id: int):
+    list_of_admins = []
+    async for member in app.iter_chat_members(
+        chat_id, filter="administrators"
+    ):
+        list_of_admins.append(member.user.id)
+    return list_of_admins
+
+
 async def current_chat_permissions(chat_id):
     perms = []
     perm = (await app.get_chat(chat_id)).permissions
@@ -126,501 +129,340 @@ async def list_members(group_id):
 
 
 @app.on_message(filters.command("purge") & ~filters.edited)
-@capture_err
-async def purge(client, message):
-    try:
-        message_ids = []
-        chat_id = message.chat.id
-        user_id = message.from_user.id
-        if message.chat.type not in ("supergroup", "channel"):
-            return
-        permissions = await member_permissions(chat_id, user_id)
-        if "can_delete_messages" in permissions or user_id in SUDOERS:
-            if message.reply_to_message:
-                for a_s_message_id in range(
-                    message.reply_to_message.message_id, message.message_id
-                ):
-                    message_ids.append(a_s_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
-                    )
-            else:
-                await message.reply_text(
-                    "Reply To A Message To Delete It,"
-                    " Don't Make Fun Of Yourself!"
-                )
-        else:
-            await message.reply_text("Your Don't Have Enough Permissions!")
-        await message.delete()
-    except Exception as e:
-        await message.reply_text(str(e))
-        e = traceback.format_exc()
-        print(e)
+@adminsOnly("can_delete_messages")
+async def purgeFunc(client, message: Message):
+    chat_id = message.chat.id
+    message_ids = []
+    if message.chat.type not in ("supergroup", "channel"):
+        return
+    if not message.reply_to_message:
+        await message.reply_text(
+            "Reply To A Message To Delete From," " Don't Make Fun Of Yourself!"
+        )
+    for a_s_message_id in range(
+        message.reply_to_message.message_id, message.message_id
+    ):
+        message_ids.append(a_s_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
+        )
 
 
 # Kick members
 
 
 @app.on_message(filters.command("kick") & ~filters.edited)
-@capture_err
-async def kick(_, message):
-    try:
-        from_user_id = message.from_user.id
-        chat_id = message.chat.id
-        permissions = await member_permissions(chat_id, from_user_id)
-        if (
-            "can_restrict_members" not in permissions
-            and from_user_id not in SUDOERS
-        ):
-            await message.reply_text("You don't have enough permissions.")
-            return
-        if len(message.command) == 2:
-            user_id = (await app.get_users(message.text.split(None, 1)[1])).id
-        elif len(message.command) == 1 and message.reply_to_message:
-            user_id = message.reply_to_message.from_user.id
-        else:
-            await message.reply_text(
-                "Provide a username or reply to a user's message to kick."
-            )
-            return
-        if user_id in SUDOERS:
-            await message.reply_text("You Wanna Kick The Elevated One?")
-        else:
-            await message.chat.kick_member(user_id)
-            await asyncio.sleep(1)
-            await message.chat.unban_member(user_id)
-            await message.reply_text("Kicked!")
-    except Exception as e:
-        await message.reply_text(str(e))
-        e = traceback.format_exc()
-        print(e)
+@adminsOnly("can_restrict_members")
+async def kickFunc(_, message: Message):
+    if len(message.command) == 2:
+        user_id = (await app.get_users(message.text.split(None, 1)[1])).id
+    elif len(message.command) == 1 and message.reply_to_message:
+        user_id = message.reply_to_message.from_user.id
+    else:
+        await message.reply_text(
+            "Provide a username or reply to a user's message to kick."
+        )
+        return
+    if user_id in SUDOERS:
+        await message.reply_text("You Wanna Kick The Elevated One?")
+    else:
+        await message.chat.kick_member(user_id)
+        await asyncio.sleep(1)
+        await message.reply_text("Kicked!")
+        await message.chat.unban_member(user_id)
 
 
 # Ban members
 
 
 @app.on_message(filters.command("ban") & ~filters.edited)
-@capture_err
-async def ban(_, message):
-    try:
-        from_user_id = message.from_user.id
-        chat_id = message.chat.id
-        permissions = await member_permissions(chat_id, from_user_id)
-        if (
-            "can_restrict_members" not in permissions
-            and from_user_id not in SUDOERS
-        ):
-            await message.reply_text("You don't have enough permissions.")
-            return
-        if len(message.command) == 2:
-            user_id = (await app.get_users(message.text.split(None, 1)[1])).id
-        elif len(message.command) == 1 and message.reply_to_message:
-            user_id = message.reply_to_message.from_user.id
-        else:
-            await message.reply_text(
-                "Provide a username or reply to a user's message to ban."
-            )
-            return
-        if user_id in SUDOERS:
-            await message.reply_text("You Wanna Ban The Elevated One?")
-        else:
-            await message.chat.kick_member(user_id)
-            await message.reply_text("Banned!")
-    except Exception as e:
-        await message.reply_text(str(e))
-        e = traceback.format_exc()
-        print(e)
+@adminsOnly("can_restrict_members")
+async def banFunc(_, message: Message):
+    if len(message.command) == 2:
+        user_id = (await app.get_users(message.text.split(None, 1)[1])).id
+    elif len(message.command) == 1 and message.reply_to_message:
+        user_id = message.reply_to_message.from_user.id
+    else:
+        await message.reply_text(
+            "Provide a username or reply to a user's message to ban."
+        )
+        return
+    if user_id in SUDOERS:
+        await message.reply_text("You Wanna Ban The Elevated One?")
+    else:
+        await message.chat.kick_member(user_id)
+        await message.reply_text("Banned!")
 
 
 # Unban members
 
 
 @app.on_message(filters.command("unban") & ~filters.edited)
-@capture_err
-async def unban(_, message):
-    try:
-        from_user_id = message.from_user.id
-        chat_id = message.chat.id
-        permissions = await member_permissions(chat_id, from_user_id)
-        if (
-            "can_restrict_members" not in permissions
-            and from_user_id not in SUDOERS
-        ):
-            await message.reply_text("You don't have enough permissions.")
-            return
-        if len(message.command) == 2:
-            user = message.text.split(None, 1)[1]
-        elif len(message.command) == 1 and message.reply_to_message:
-            user = message.reply_to_message.from_user.id
-        else:
-            await message.reply_text(
-                "Provide a username or reply to a user's message to unban."
-            )
-            return
-        await message.chat.unban_member(user)
-        await message.reply_text("Unbanned!")
-    except Exception as e:
-        await message.reply_text(str(e))
-        e = traceback.format_exc()
-        print(e)
+@adminsOnly("can_restrict_members")
+async def unbanFunc(_, message: Message):
+    if len(message.command) == 2:
+        user = message.text.split(None, 1)[1]
+    elif len(message.command) == 1 and message.reply_to_message:
+        user = message.reply_to_message.from_user.id
+    else:
+        await message.reply_text(
+            "Provide a username or reply to a user's message to unban."
+        )
+        return
+    await message.chat.unban_member(user)
+    await message.reply_text("Unbanned!")
 
 
 # Delete messages
 
 
 @app.on_message(filters.command("del") & ~filters.edited)
-@capture_err
-async def delete(_, message):
+@adminsOnly("can_delete_messages")
+async def deleteFunc(_, message: Message):
     if not message.reply_to_message:
         await message.reply_text("Reply To A Message To Delete It")
         return
-    try:
-        from_user_id = message.from_user.id
-        chat_id = message.chat.id
-        permissions = await member_permissions(chat_id, from_user_id)
-        if (
-            "can_delete_messages" not in permissions
-            and from_user_id not in SUDOERS
-        ):
-            await message.reply_text(
-                "You Don't Have Enough Permissions,"
-                + " Consider Deleting Yourself!"
-            )
-            return
-        await message.reply_to_message.delete()
-        await message.delete()
-    except Exception as e:
-        await message.reply_text(str(e))
-        e = traceback.format_exc()
-        print(e)
+    await message.reply_to_message.delete()
+    await message.delete()
 
 
 # Promote Members
 
 
 @app.on_message(filters.command("promote") & ~filters.edited)
-@capture_err
-async def promote(_, message):
-    try:
-        from_user_id = message.from_user.id
-        chat_id = message.chat.id
-        permissions = await member_permissions(chat_id, from_user_id)
-        if (
-            "can_promote_members" not in permissions
-            and from_user_id not in SUDOERS
-        ):
-            await message.reply_text("You don't have enough permissions")
-            return
-        bot = await app.get_chat_member(chat_id, BOT_ID)
-        if len(message.command) == 2:
-            username = message.text.split(None, 1)[1]
-            user_id = (await app.get_users(username)).id
-        elif len(message.command) == 1 and message.reply_to_message:
-            user_id = message.reply_to_message.from_user.id
-        else:
-            await message.reply_text(
-                "Reply To A User's Message Or Give A Username To Promote."
-            )
-            return
-        await message.chat.promote_member(
-            user_id=user_id,
-            can_change_info=bot.can_change_info,
-            can_invite_users=bot.can_invite_users,
-            can_delete_messages=bot.can_delete_messages,
-            can_restrict_members=False,
-            can_pin_messages=bot.can_pin_messages,
-            can_promote_members=bot.can_promote_members,
-            can_manage_chat=bot.can_manage_chat,
-            can_manage_voice_chats=bot.can_manage_voice_chats,
+@adminsOnly("can_promote_members")
+async def promoteFunc(_, message: Message):
+    chat_id = message.chat.id
+    bot = await app.get_chat_member(chat_id, BOT_ID)
+    if len(message.command) == 2:
+        username = message.text.split(None, 1)[1]
+        user_id = (await app.get_users(username)).id
+    elif len(message.command) == 1 and message.reply_to_message:
+        user_id = message.reply_to_message.from_user.id
+    else:
+        await message.reply_text(
+            "Reply To A User's Message Or Give A Username To Promote."
         )
-        await message.reply_text("Promoted!")
-
-    except Exception as e:
-        await message.reply_text(str(e))
-        e = traceback.format_exc()
-        print(e)
+        return
+    await message.chat.promote_member(
+        user_id=user_id,
+        can_change_info=bot.can_change_info,
+        can_invite_users=bot.can_invite_users,
+        can_delete_messages=bot.can_delete_messages,
+        can_restrict_members=False,
+        can_pin_messages=bot.can_pin_messages,
+        can_promote_members=bot.can_promote_members,
+        can_manage_chat=bot.can_manage_chat,
+        can_manage_voice_chats=bot.can_manage_voice_chats,
+    )
+    await message.reply_text("Promoted!")
 
 
 # Demote Member
 
 
 @app.on_message(filters.command("demote") & ~filters.edited)
-@capture_err
-async def demote(_, message):
-    try:
-        from_user_id = message.from_user.id
-        chat_id = message.chat.id
-        permissions = await member_permissions(chat_id, from_user_id)
-        if (
-            "can_promote_members" not in permissions
-            and from_user_id not in SUDOERS
-        ):
-            await message.reply_text("You don't have enough permissions")
-            return
-        if len(message.command) == 2:
-            username = message.text.split(None, 1)[1]
-            user_id = (await app.get_users(username)).id
-        elif len(message.command) == 1 and message.reply_to_message:
-            user_id = message.reply_to_message.from_user.id
-        else:
-            await message.reply_text(
-                "Reply To A User's Message Or Give A Username To Demote."
-            )
-            return
-        await message.chat.promote_member(
-            user_id=user_id,
-            can_change_info=False,
-            can_invite_users=False,
-            can_delete_messages=False,
-            can_restrict_members=False,
-            can_pin_messages=False,
-            can_promote_members=False,
-            can_manage_chat=False,
-            can_manage_voice_chats=False,
+@adminsOnly("can_promote_members")
+async def demote(_, message: Message):
+    if len(message.command) == 2:
+        username = message.text.split(None, 1)[1]
+        user_id = (await app.get_users(username)).id
+    elif len(message.command) == 1 and message.reply_to_message:
+        user_id = message.reply_to_message.from_user.id
+    else:
+        await message.reply_text(
+            "Reply To A User's Message Or Give A Username To Demote."
         )
-        await message.reply_text("Demoted!")
-
-    except Exception as e:
-        await message.reply_text(str(e))
-        e = traceback.format_exc()
-        print(e)
+        return
+    await message.chat.promote_member(
+        user_id=user_id,
+        can_change_info=False,
+        can_invite_users=False,
+        can_delete_messages=False,
+        can_restrict_members=False,
+        can_pin_messages=False,
+        can_promote_members=False,
+        can_manage_chat=False,
+        can_manage_voice_chats=False,
+    )
+    await message.reply_text("Demoted!")
 
 
 # Pin Messages
 
 
 @app.on_message(filters.command("pin") & ~filters.edited)
-@capture_err
-async def pin(_, message):
+@adminsOnly("can_pin_messages")
+async def pin(_, message: Message):
     if not message.reply_to_message:
         await message.reply_text("Reply To A Message To Pin.")
         return
-    try:
-        from_user_id = message.from_user.id
-        chat_id = message.chat.id
-        permissions = await member_permissions(chat_id, from_user_id)
-        if "can_pin_messages" in permissions or from_user_id in SUDOERS:
-            await message.reply_to_message.pin(disable_notification=True)
-        else:
-            await message.reply_text("You're Not An Admin, Stop Spamming!")
-            return
-    except Exception as e:
-        await message.reply_text(str(e))
-        e = traceback.format_exc()
-        print(e)
+    await message.reply_to_message.pin(disable_notification=True)
 
 
 # Mute members
 
 
 @app.on_message(filters.command("mute") & ~filters.edited)
-@capture_err
-async def mute(_, message):
-    try:
-        from_user_id = message.from_user.id
-        chat_id = message.chat.id
-        permissions = await member_permissions(chat_id, from_user_id)
-        if (
-            "can_restrict_members" not in permissions
-            and from_user_id not in SUDOERS
-        ):
-            await message.reply_text("You don't have enough permissions.")
-            return
-        if len(message.command) == 2:
-            user_id = (await app.get_users(message.text.split(None, 1)[1])).id
-        elif len(message.command) == 1 and message.reply_to_message:
-            user_id = message.reply_to_message.from_user.id
-        else:
-            await message.reply_text(
-                "Provide a username or reply to a user's message to mute."
-            )
-            return
-        if user_id in SUDOERS:
-            await message.reply_text("You Wanna Mute The Elevated One?")
-            return
-        await message.chat.restrict_member(
-            user_id, permissions=ChatPermissions()
+@adminsOnly("can_restrict_members")
+async def mute(_, message: Message):
+    if len(message.command) == 2:
+        user_id = (await app.get_users(message.text.split(None, 1)[1])).id
+    elif len(message.command) == 1 and message.reply_to_message:
+        user_id = message.reply_to_message.from_user.id
+    else:
+        await message.reply_text(
+            "Provide a username or reply to a user's message to mute."
         )
-        await message.reply_text("Muted!")
-    except Exception as e:
-        await message.reply_text(str(e))
-        e = traceback.format_exc()
-        print(e)
+        return
+    if user_id in SUDOERS:
+        await message.reply_text("You Wanna Mute The Elevated One?")
+        return
+    await message.chat.restrict_member(user_id, permissions=ChatPermissions())
+    await message.reply_text("Muted!")
 
 
 # Unmute members
 
 
 @app.on_message(filters.command("unmute") & ~filters.edited)
-@capture_err
-async def unmute(_, message):
-    try:
-        from_user_id = message.from_user.id
-        chat_id = message.chat.id
-        permissions = await member_permissions(chat_id, from_user_id)
-        if (
-            "can_restrict_members" not in permissions
-            and from_user_id not in SUDOERS
-        ):
-            await message.reply_text("You don't have enough permissions.")
-            return
-        if len(message.command) == 2:
-            user = message.text.split(None, 1)[1]
-        elif len(message.command) == 1 and message.reply_to_message:
-            user = message.reply_to_message.from_user.id
-        else:
-            await message.reply_text(
-                "Provide a username or reply to a user's message to Unmute"
-            )
-            return
-        await message.chat.unban_member(user)
-        await message.reply_text("Unmuted!")
-    except Exception as e:
-        await message.reply_text(str(e))
-        e = traceback.format_exc()
-        print(e)
+@adminsOnly("can_restrict_members")
+async def unmute(_, message: Message):
+    if len(message.command) == 2:
+        user = message.text.split(None, 1)[1]
+    elif len(message.command) == 1 and message.reply_to_message:
+        user = message.reply_to_message.from_user.id
+    else:
+        await message.reply_text(
+            "Provide a username or reply to a user's message to Unmute"
+        )
+        return
+    await message.chat.unban_member(user)
+    await message.reply_text("Unmuted!")
 
 
 # Ban deleted accounts
 
 
 @app.on_message(filters.command("ban_ghosts"))
-async def ban_deleted_accounts(_, message):
-    try:
-        from_user_id = message.from_user.id
-        chat_id = message.chat.id
-        permissions = await member_permissions(chat_id, from_user_id)
-        if "can_restrict_members" in permissions or from_user_id in SUDOERS:
-            deleted_users = []
-            banned_users = 0
-            async for i in app.iter_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.kick_member(deleted_user)
-                    except Exception as e:
-                        print(str(e))
-                        pass
-                    banned_users += 1
-                await message.reply_text(
-                    f"Banned {banned_users} Deleted Accounts"
-                )
-            else:
-                await message.reply_text("No Deleted Accounts In This Chat")
-                return
-        else:
-            await message.reply_text("You Don't Have Enough Permissions")
-    except Exception as e:
-        await message.reply_text(str(e))
-        e = traceback.format_exc()
-        print(e)
+@adminsOnly("can_restrict_members")
+async def ban_deleted_accounts(_, message: Message):
+    chat_id = message.chat.id
+    deleted_users = []
+    banned_users = 0
+    async for i in app.iter_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.kick_member(deleted_user)
+            except Exception:
+                pass
+            banned_users += 1
+        await message.reply_text(f"Banned {banned_users} Deleted Accounts")
+    else:
+        await message.reply_text("No Deleted Accounts In This Chat")
 
 
 @app.on_message(filters.command("warn") & ~filters.edited)
-@capture_err
-async def warn_user(_, message):
+@adminsOnly("can_restrict_members")
+async def warn_user(_, message: Message):
     if not message.reply_to_message:
         await message.reply_text("Reply to a message to warn a user.")
         return
-    try:
-        from_user_id = message.from_user.id
-        chat_id = message.chat.id
-        permissions = await member_permissions(chat_id, from_user_id)
-        if "can_restrict_members" in permissions or from_user_id in SUDOERS:
-            user_id = message.reply_to_message.from_user.id
-            mention = message.reply_to_message.from_user.mention
-            if user_id in SUDOERS:
-                await message.reply_text("You Wanna Warn The Elevated One?")
-            elif user_id == BOT_ID:
-                await message.reply_text("Huh, Can't warn myself.")
-            elif user_id in await list_admins(message.chat.id):
-                await message.reply_text("Can't warn an admin.")
-            elif user_id == from_user_id:
-                await message.reply_text("I wouldn't do that if i were you.")
+    chat_id = message.chat.id
+    user_id = message.reply_to_message.from_user.id
+    mention = message.reply_to_message.from_user.mention
+    if user_id in SUDOERS:
+        await message.reply_text("You Wanna Warn The Elevated One?")
+    elif user_id == BOT_ID:
+        await message.reply_text("Huh, Can't warn myself.")
+    elif user_id in await list_admins(message.chat.id):
+        await message.reply_text("Can't warn an admin.")
+    else:
+        if user_id in await list_members(chat_id):
+            warns = await get_warn(chat_id, await int_to_alpha(user_id))
+            if warns:
+                warns = warns["warns"]
             else:
-                if user_id in await list_members(chat_id):
-                    warns = await get_warn(
-                        chat_id, await int_to_alpha(user_id)
-                    )
-                    if warns:
-                        warns = warns["warns"]
-                    else:
-                        warn = {"warns": 1}
-                        await add_warn(
-                            chat_id, await int_to_alpha(user_id), warn
-                        )
-                        await message.reply_text(
-                            f"Warned {mention} !, 1/3 warnings now."
-                        )
-                        return
-                    if warns >= 2:
-                        await message.chat.kick_member(user_id)
-                        await message.reply_text(
-                            f"Number of warns of {mention} exceeded, Banned!"
-                        )
-                        await remove_warns(
-                            chat_id, await int_to_alpha(user_id)
-                        )
-                    else:
-                        warn = {"warns": warns + 1}
-                        await add_warn(
-                            chat_id, await int_to_alpha(user_id), warn
-                        )
-                        await message.reply_text(
-                            f"Warned {mention} !, {warns+1}/3 warnings now."
-                        )
-                else:
-                    await message.reply_text("This user isn't here.")
+                warn = {"warns": 1}
+                await add_warn(chat_id, await int_to_alpha(user_id), warn)
+                await message.reply_text(
+                    f"Warned {mention} !, 1/3 warnings now."
+                )
+                return
+            if warns >= 2:
+                await message.chat.kick_member(user_id)
+                await message.reply_text(
+                    f"Number of warns of {mention} exceeded, Banned!"
+                )
+                await remove_warns(chat_id, await int_to_alpha(user_id))
+            else:
+                warn = {"warns": warns + 1}
+                await add_warn(chat_id, await int_to_alpha(user_id), warn)
+                await message.reply_text(
+                    f"Warned {mention} !, {warns+1}/3 warnings now."
+                )
         else:
-            await message.reply_text("You don't have enough permissions.")
-    except Exception as e:
-        await message.reply_text(str(e))
-        e = traceback.format_exc()
-        print(e)
+            await message.reply_text("This user isn't here.")
+
+
+# Rmwarn
+
+
+@app.on_message(filters.command("rmwarn") & ~filters.edited)
+@adminsOnly("can_restrict_members")
+async def remove_warning(_, message: Message):
+    if not message.reply_to_message:
+        await message.reply_text(
+            "Reply to a message to remove a user's warning."
+        )
+        return
+    user_id = message.reply_to_message.from_user.id
+    mention = message.reply_to_message.from_user.mention
+    chat_id = message.chat.id
+    warns = await get_warn(chat_id, await int_to_alpha(user_id))
+    if warns:
+        warns = warns["warns"]
+    if warns == 0 or not warns:
+        await message.reply_text(f"{mention} have no warnings.")
+    else:
+        warn = {"warns": warns - 1}
+        await add_warn(chat_id, await int_to_alpha(user_id), warn)
+        await message.reply_text(f"Removed warning of {mention}.")
 
 
 # Rmwarns
 
 
 @app.on_message(filters.command("rmwarns") & ~filters.edited)
-@capture_err
-async def remove_warnings(_, message):
+@adminsOnly("can_restrict_members")
+async def remove_warnings(_, message: Message):
     if not message.reply_to_message:
         await message.reply_text(
             "Reply to a message to remove a user's warnings."
         )
         return
-    try:
-        from_user_id = message.from_user.id
-        user_id = message.reply_to_message.from_user.id
-        mention = message.reply_to_message.from_user.mention
-        chat_id = message.chat.id
-        permissions = await member_permissions(chat_id, from_user_id)
-        if "can_restrict_members" in permissions or from_user_id in SUDOERS:
-            warns = await get_warn(chat_id, await int_to_alpha(user_id))
-            if warns:
-                warns = warns["warns"]
-            if warns == 0 or not warns:
-                await message.reply_text(f"{mention} have no warnings.")
-            else:
-                await remove_warns(chat_id, await int_to_alpha(user_id))
-                await message.reply_text(f"Removed warnings of {mention}.")
-        else:
-            await message.reply_text("You don't have enough permissions")
-    except Exception as e:
-        await message.reply_text(str(e))
-        e = traceback.format_exc()
-        print(e)
+    user_id = message.reply_to_message.from_user.id
+    mention = message.reply_to_message.from_user.mention
+    chat_id = message.chat.id
+    warns = await get_warn(chat_id, await int_to_alpha(user_id))
+    if warns:
+        warns = warns["warns"]
+    if warns == 0 or not warns:
+        await message.reply_text(f"{mention} have no warnings.")
+    else:
+        await remove_warns(chat_id, await int_to_alpha(user_id))
+        await message.reply_text(f"Removed warnings of {mention}.")
 
 
 # Warns
@@ -628,41 +470,32 @@ async def remove_warnings(_, message):
 
 @app.on_message(filters.command("warns") & ~filters.edited)
 @capture_err
-async def check_warns(_, message):
+async def check_warns(_, message: Message):
     if not message.reply_to_message:
         await message.reply_text(
             "Reply to a message to check a user's warnings."
         )
         return
-    try:
-        user_id = message.reply_to_message.from_user.id
-        mention_user = message.reply_to_message.from_user.mention
-        mention_from_user = message.from_user.mention
-        chat_id = message.chat.id
-        if message.reply_to_message:
-            warns = await get_warn(chat_id, await int_to_alpha(user_id))
-            if warns:
-                warns = warns["warns"]
-            else:
-                await message.reply_text(f"{mention_user} have no warnings.")
-                return
-            await message.reply_text(
-                f"{mention_user} have {warns}/3 warnings."
-            )
-            return
+    user_id = message.reply_to_message.from_user.id
+    mention_user = message.reply_to_message.from_user.mention
+    mention_from_user = message.from_user.mention
+    chat_id = message.chat.id
+    if message.reply_to_message:
         warns = await get_warn(chat_id, await int_to_alpha(user_id))
         if warns:
             warns = warns["warns"]
         else:
             await message.reply_text(f"{mention_user} have no warnings.")
             return
-        await message.reply_text(
-            f"{mention_from_user} have {warns}/3 warnings."
-        )
-    except Exception as e:
-        await message.reply_text(str(e))
-        e = traceback.format_exc()
-        print(e)
+        await message.reply_text(f"{mention_user} have {warns}/3 warnings.")
+        return
+    warns = await get_warn(chat_id, await int_to_alpha(user_id))
+    if warns:
+        warns = warns["warns"]
+    else:
+        await message.reply_text(f"{mention_user} have no warnings.")
+        return
+    await message.reply_text(f"{mention_from_user} have {warns}/3 warnings.")
 
 
 # Report

wbb/modules/admin_misc.py

@@ -25,9 +25,8 @@ import os
 
 from pyrogram import filters
 
-from wbb import SUDOERS, app
-from wbb.core.decorators.errors import capture_err
-from wbb.modules.admin import member_permissions
+from wbb import app
+from wbb.core.decorators.permissions import adminsOnly
 
 __MODULE__ = "Admin Miscs"
 __HELP__ = """
@@ -38,85 +37,49 @@ __HELP__ = """
 
 
 @app.on_message(filters.command("set_chat_title") & ~filters.private)
-@capture_err
+@adminsOnly("can_change_info")
 async def set_chat_title(_, message):
-    try:
-        chat_id = message.chat.id
-        user_id = message.from_user.id
-        if user_id not in SUDOERS:
-            permissions = await member_permissions(chat_id, user_id)
-            if "can_change_info" not in permissions:
-                await message.reply_text("You Don't Have Enough Permissions.")
-                return
-        if len(message.command) < 2:
-            await message.reply_text("**Usage:**\n/set_chat_title NEW NAME")
-            return
-        old_title = message.chat.title
-        new_title = message.text.split(None, 1)[1]
-        await message.chat.set_title(new_title)
-        await message.reply_text(
-            f"Successfully Changed Group Title From {old_title} To {new_title}"
-        )
-    except Exception as e:
-        print(e)
-        await message.reply_text(e)
+    if len(message.command) < 2:
+        await message.reply_text("**Usage:**\n/set_chat_title NEW NAME")
+        return
+    old_title = message.chat.title
+    new_title = message.text.split(None, 1)[1]
+    await message.chat.set_title(new_title)
+    await message.reply_text(
+        f"Successfully Changed Group Title From {old_title} To {new_title}"
+    )
 
 
 @app.on_message(filters.command("set_user_title") & ~filters.private)
-@capture_err
+@adminsOnly("can_change_info")
 async def set_user_title(_, message):
-    try:
-        chat_id = message.chat.id
-        user_id = message.from_user.id
-        from_user = message.reply_to_message.from_user
-        if user_id not in SUDOERS:
-            permissions = await member_permissions(chat_id, user_id)
-            if "can_change_info" not in permissions:
-                await message.reply_text("You Don't Have Enough Permissions.")
-                return
-        if len(message.command) < 2:
-            await message.reply_text(
-                "**Usage:**\n/set_user_title NEW ADMINISTRATOR TITLE"
-            )
-            return
-        title = message.text.split(None, 1)[1]
-        await app.set_administrator_title(chat_id, from_user.id, title)
+    chat_id = message.chat.id
+    from_user = message.reply_to_message.from_user
+    if len(message.command) < 2:
         await message.reply_text(
-            f"Successfully Changed {from_user.mention}'s Admin Title To {title}"
+            "**Usage:**\n/set_user_title NEW ADMINISTRATOR TITLE"
         )
-    except Exception as e:
-        print(e)
-        await message.reply_text(e)
+        return
+    title = message.text.split(None, 1)[1]
+    await app.set_administrator_title(chat_id, from_user.id, title)
+    await message.reply_text(
+        f"Successfully Changed {from_user.mention}'s Admin Title To {title}"
+    )
 
 
 @app.on_message(filters.command("set_chat_photo") & ~filters.private)
-@capture_err
+@adminsOnly("can_change_info")
 async def set_chat_photo(_, message):
-    try:
-        chat_id = message.chat.id
-        user_id = message.from_user.id
-        if user_id not in SUDOERS:
-            permissions = await member_permissions(chat_id, user_id)
-            if "can_change_info" not in permissions:
-                await message.reply_text("You Don't Have Enough Permissions.")
-                return
-        if not message.reply_to_message:
-            await message.reply_text(
-                "Reply to a photo to set it as chat_photo"
-            )
-            return
-        if (
-            not message.reply_to_message.photo
-            and not message.reply_to_message.document
-        ):
-            await message.reply_text(
-                "Reply to a photo to set it as chat_photo"
-            )
-            return
-        photo = await message.reply_to_message.download()
-        await message.chat.set_photo(photo)
-        await message.reply_text("Successfully Changed Group Photo")
-        os.remove(photo)
-    except Exception as e:
-        print(e)
-        await message.reply_text(e)
+    if not message.reply_to_message:
+        await message.reply_text("Reply to a photo to set it as chat_photo")
+        return
+    if (
+        not message.reply_to_message.photo
+        and not message.reply_to_message.document
+    ):
+        await message.reply_text("Reply to a photo to set it as chat_photo")
+        return
+    photo = await message.reply_to_message.download()
+    await message.chat.set_photo(photo)
+    await message.reply_text("Successfully Changed Group Photo")
+    os.remove(photo)

wbb/modules/antiservice.py

@@ -4,8 +4,7 @@
 from pyrogram import filters
 
 from wbb import app
-from wbb.core.decorators.errors import capture_err
-from wbb.modules.admin import member_permissions
+from wbb.core.decorators.permissions import adminsOnly
 from wbb.utils.dbfunctions import (antiservice_off, antiservice_on,
                                    is_antiservice_on)
 
@@ -18,7 +17,7 @@ Plugin to delete service messages in a chat!
 
 
 @app.on_message(filters.command("antiservice") & ~filters.private)
-@capture_err
+@adminsOnly("can_change_info")
 async def anti_service(_, message):
     if len(message.command) != 2:
         await message.reply_text("Usage: /antiservice [enable | disable]")
@@ -26,11 +25,6 @@ async def anti_service(_, message):
     status = message.text.split(None, 1)[1].strip()
     status = status.lower()
     chat_id = message.chat.id
-    user_id = message.from_user.id
-    permissions = await member_permissions(chat_id, user_id)
-    if "can_change_info" not in permissions:
-        await message.reply_text("You don't have enough permissions.")
-        return
     if status == "enable":
         await antiservice_on(chat_id)
         await message.reply_text(
@@ -48,7 +42,6 @@ async def anti_service(_, message):
 
 
 @app.on_message(filters.service, group=11)
-@capture_err
 async def delete_service(_, message):
     chat_id = message.chat.id
     try:

wbb/modules/blacklist.py

@@ -22,14 +22,14 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
 """
 import re
-import traceback
 
 from pyrogram import filters
 from pyrogram.types import ChatPermissions
 
 from wbb import SUDOERS, app
 from wbb.core.decorators.errors import capture_err
-from wbb.modules.admin import list_admins, member_permissions
+from wbb.core.decorators.permissions import adminsOnly
+from wbb.modules.admin import list_admins
 from wbb.utils.dbfunctions import (delete_blacklist_filter,
                                    get_blacklisted_words,
                                    save_blacklist_filter)
@@ -46,21 +46,16 @@ __HELP__ = """
 @app.on_message(
     filters.command("blacklist") & ~filters.edited & ~filters.private
 )
-@capture_err
+@adminsOnly("can_restrict_members")
 async def save_filters(_, message):
     if len(message.command) < 2:
         await message.reply_text("Usage:\n/blacklist [WORD|SENTENCE]")
         return
-    chat_id = message.chat.id
-    user_id = message.from_user.id
-    permissions = await member_permissions(chat_id, user_id)
-    if "can_restrict_members" not in permissions and user_id not in SUDOERS:
-        await message.reply_text("**You don't have enough permissions**")
-        return
     word = message.text.split(None, 1)[1].strip()
     if not word:
         await message.reply_text("**Usage**\n__/blacklist [WORD|SENTENCE]__")
         return
+    chat_id = message.chat.id
     await save_blacklist_filter(chat_id, word)
     await message.reply_text(f"__**Blacklisted {word}.**__")
 
@@ -83,29 +78,25 @@ async def get_filterss(_, message):
 @app.on_message(
     filters.command("whitelist") & ~filters.edited & ~filters.private
 )
-@capture_err
+@adminsOnly("can_restrict_members")
 async def del_filter(_, message):
     if len(message.command) < 2:
         await message.reply_text("Usage:\n/whitelist [WORD|SENTENCE]")
         return
-    chat_id = message.chat.id
-    user_id = message.from_user.id
-    permissions = await member_permissions(chat_id, user_id)
-    if "can_restrict_members" not in permissions and user_id not in SUDOERS:
-        await message.reply_text("**You don't have enough permissions**")
-        return
     word = message.text.split(None, 1)[1].strip()
     if not word:
         await message.reply_text("Usage:\n/whitelist [WORD|SENTENCE]")
         return
+    chat_id = message.chat.id
     deleted = await delete_blacklist_filter(chat_id, word)
     if deleted:
-        await message.reply_text(f"**Whitelist {word}.**")
-    else:
-        await message.reply_text("**No such blacklist filter.**")
+        await message.reply_text(f"**Whitelisted {word}.**")
+        return
+    await message.reply_text("**No such blacklist filter.**")
 
 
 @app.on_message(filters.text & ~filters.private, group=blacklist_filters_group)
+@capture_err
 async def blacklist_filters_re(_, message):
     text = message.text.lower().strip()
     if not text:
@@ -116,26 +107,19 @@ async def blacklist_filters_re(_, message):
         return
     if user.id in SUDOERS:
         return
-    try:
-        list_of_filters = await get_blacklisted_words(chat_id)
-        for word in list_of_filters:
-            pattern = r"( |^|[^\w])" + re.escape(word) + r"( |$|[^\w])"
-            if re.search(pattern, text, flags=re.IGNORECASE):
-                if user.id in await list_admins(chat_id):
-                    return
-                try:
-                    await message.chat.restrict_member(
-                        user.id, ChatPermissions()
-                    )
-                except Exception:
-                    return
-                await app.send_message(
-                    chat_id,
-                    f"Muted {user.mention} [`{user.id}`] due to a blacklist "
-                    + f"match on {word}.",
-                )
+    list_of_filters = await get_blacklisted_words(chat_id)
+    for word in list_of_filters:
+        pattern = r"( |^|[^\w])" + re.escape(word) + r"( |$|[^\w])"
+        if re.search(pattern, text, flags=re.IGNORECASE):
+            if user.id in await list_admins(chat_id):
+                return
+            try:
+                await message.chat.restrict_member(user.id, ChatPermissions())
+            except Exception:
                 return
-    except Exception as e:
-        e = traceback.format_exc()
-        print(e)
-        pass
+            await app.send_message(
+                chat_id,
+                f"Muted {user.mention} [`{user.id}`] due to a blacklist "
+                + f"match on {word}.",
+            )
+            return

wbb/modules/filters.py

@@ -22,13 +22,12 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
 """
 import re
-import traceback
 
 from pyrogram import filters
 
-from wbb import SUDOERS, app
+from wbb import app
 from wbb.core.decorators.errors import capture_err
-from wbb.modules.admin import member_permissions
+from wbb.core.decorators.permissions import adminsOnly
 from wbb.utils.dbfunctions import (add_served_chat, blacklisted_chats,
                                    delete_filter, get_filter,
                                    get_filters_names, is_served_chat,
@@ -45,10 +44,8 @@ You can use markdown or html to save text too."""
 
 
 @app.on_message(filters.command("filter") & ~filters.edited & ~filters.private)
-@capture_err
+@adminsOnly("can_change_info")
 async def save_filters(_, message):
-    chat_id = message.chat.id
-    user_id = message.from_user.id
     if len(message.command) < 2 or not message.reply_to_message:
         await message.reply_text(
             "**Usage:**\nReply to a text or sticker with /filter [FILTER_NAME] to save it."
@@ -62,14 +59,11 @@ async def save_filters(_, message):
             "__**You can only save text or stickers in filters.**__"
         )
         return
-    permissions = await member_permissions(chat_id, user_id)
-    if "can_restrict_members" not in permissions and user_id not in SUDOERS:
-        await message.reply_text("**You don't have enough permissions**")
-        return
     name = message.text.split(None, 1)[1].strip()
     if not name:
         await message.reply_text("**Usage**\n__/filter [FILTER_NAME]__")
         return
+    chat_id = message.chat.id
     _type = "text" if message.reply_to_message.text else "sticker"
     _filter = {
         "type": _type,
@@ -97,21 +91,16 @@ async def get_filterss(_, message):
 
 
 @app.on_message(filters.command("stop") & ~filters.edited & ~filters.private)
-@capture_err
+@adminsOnly("can_change_info")
 async def del_filter(_, message):
-    chat_id = message.chat.id
-    user_id = message.from_user.id
     if len(message.command) < 2:
         await message.reply_text("**Usage**\n__/stop [FILTER_NAME]__")
         return
-    permissions = await member_permissions(chat_id, user_id)
-    if "can_restrict_members" not in permissions and user_id not in SUDOERS:
-        await message.reply_text("**You don't have enough permissions**")
-        return
     name = message.text.split(None, 1)[1].strip()
     if not name:
         await message.reply_text("**Usage**\n__/stop [FILTER_NAME]__")
         return
+    chat_id = message.chat.id
     deleted = await delete_filter(chat_id, name)
     if deleted:
         await message.reply_text(f"**Deleted filter {name}.**")
@@ -127,42 +116,35 @@ async def del_filter(_, message):
     & ~filters.forwarded,
     group=chat_filters_group,
 )
+@capture_err
 async def filters_re(_, message):
     text = message.text.lower().strip()
     if not text:
         return
     chat_id = message.chat.id
-    try:
-        list_of_filters = await get_filters_names(chat_id)
-        for word in list_of_filters:
-            pattern = r"( |^|[^\w])" + re.escape(word) + r"( |$|[^\w])"
-            if re.search(pattern, text, flags=re.IGNORECASE):
-                _filter = await get_filter(chat_id, word)
-                data_type = _filter["type"]
-                data = _filter["data"]
-                if data_type == "text":
-                    if message.reply_to_message:
-                        await message.reply_to_message.reply_text(
-                            data, disable_web_page_preview=True
-                        )
-                        if text[0] == "~":
-                            await message.delete()
-                        return
-                    await message.reply_text(
+    list_of_filters = await get_filters_names(chat_id)
+    for word in list_of_filters:
+        pattern = r"( |^|[^\w])" + re.escape(word) + r"( |$|[^\w])"
+        if re.search(pattern, text, flags=re.IGNORECASE):
+            _filter = await get_filter(chat_id, word)
+            data_type = _filter["type"]
+            data = _filter["data"]
+            if data_type == "text":
+                if message.reply_to_message:
+                    await message.reply_to_message.reply_text(
                         data, disable_web_page_preview=True
                     )
-                else:
-                    if message.reply_to_message:
-                        await message.reply_to_message.reply_sticker(data)
-                        if text[0] == "~":
-                            await message.delete()
-                        return
-                    await message.reply_sticker(data)
-
-    except Exception as e:
-        e = traceback.format_exc()
-        print(e)
-        pass
+                    if text[0] == "~":
+                        await message.delete()
+                    return
+                await message.reply_text(data, disable_web_page_preview=True)
+            else:
+                if message.reply_to_message:
+                    await message.reply_to_message.reply_sticker(data)
+                    if text[0] == "~":
+                        await message.delete()
+                    return
+                await message.reply_sticker(data)
 
     """ CHAT WATCHER """
     blacklisted_chats_list = await blacklisted_chats()

wbb/modules/greetings.py

@@ -36,7 +36,7 @@ from pyrogram.types import (ChatPermissions, InlineKeyboardButton,
 
 from wbb import SUDOERS, WELCOME_DELAY_KICK_SEC, app
 from wbb.core.decorators.errors import capture_err
-from wbb.modules.admin import member_permissions
+from wbb.core.decorators.permissions import adminsOnly
 from wbb.utils.dbfunctions import (captcha_off, captcha_on, del_welcome,
                                    get_captcha_cache, get_welcome,
                                    is_captcha_on, is_gbanned_user, set_welcome,
@@ -46,7 +46,7 @@ from wbb.utils.functions import generate_captcha
 
 __MODULE__ = "Greetings"
 __HELP__ = """
-/captcha [ON|OFF] - Enable/Disable captcha.
+/captcha [ENABLE|DISABLE] - Enable/Disable captcha.
 
 /set_welcome - Reply this to a message containing correct
 format for a welcome message, check end of this message.
@@ -322,24 +322,19 @@ async def _ban_restricted_user_until_date(
 
 
 @app.on_message(filters.command("captcha") & ~filters.private)
-@capture_err
+@adminsOnly("can_restrict_members")
 async def captcha_state(_, message):
-    usage = "**Usage:**\n/captcha [ON|OFF]"
+    usage = "**Usage:**\n/captcha [ENABLE|DISABLE]"
     if len(message.command) != 2:
         await message.reply_text(usage)
         return
-    user_id = message.from_user.id
     chat_id = message.chat.id
-    permissions = await member_permissions(chat_id, user_id)
-    if "can_restrict_members" not in permissions:
-        await message.reply_text("You don't have enough permissions.")
-        return
     state = message.text.split(None, 1)[1].strip()
     state = state.lower()
-    if state == "on":
+    if state == "enable":
         await captcha_on(chat_id)
         await message.reply_text("Enabled Captcha For New Users.")
-    elif state == "off":
+    elif state == "disable":
         await captcha_off(chat_id)
         await message.reply_text("Disabled Captcha For New Users.")
     else:
@@ -350,7 +345,7 @@ async def captcha_state(_, message):
 
 
 @app.on_message(filters.command("set_welcome") & ~filters.private)
-@capture_err
+@adminsOnly("can_change_info")
 async def set_welcome_func(_, message):
     usage = "You need to reply to a text, check the Greetings module in /help"
     if not message.reply_to_message:
@@ -359,38 +354,23 @@ async def set_welcome_func(_, message):
     if not message.reply_to_message.text:
         await message.reply_text(usage)
         return
-    user_id = message.from_user.id
     chat_id = message.chat.id
-    permissions = await member_permissions(chat_id, user_id)
-    if "can_change_info" not in permissions:
-        await message.reply_text("You don't have enough permissions.")
-        return
     raw_text = str(message.reply_to_message.text.markdown)
     await set_welcome(chat_id, raw_text)
     await message.reply_text("Welcome message has been successfully set.")
 
 
 @app.on_message(filters.command("del_welcome") & ~filters.private)
-@capture_err
+@adminsOnly("can_change_info")
 async def del_welcome_func(_, message):
-    user_id = message.from_user.id
     chat_id = message.chat.id
-    permissions = await member_permissions(chat_id, user_id)
-    if "can_change_info" not in permissions:
-        await message.reply_text("You don't have enough permissions.")
-        return
     await del_welcome(chat_id)
     await message.reply_text("Welcome message has been deleted.")
 
 
 @app.on_message(filters.command("get_welcome") & ~filters.private)
-@capture_err
+@adminsOnly("can_change_info")
 async def get_welcome_func(_, message):
-    user_id = message.from_user.id
     chat_id = message.chat.id
-    permissions = await member_permissions(chat_id, user_id)
-    if "can_change_info" not in permissions:
-        await message.reply_text("You don't have enough permissions.")
-        return
     welcome_message = await get_welcome(chat_id)
     await message.reply_text(welcome_message)

wbb/modules/locks.py

@@ -25,9 +25,10 @@ from pyrogram import filters
 from pyrogram.errors.exceptions.bad_request_400 import ChatNotModified
 from pyrogram.types import ChatPermissions
 
-from wbb import SUDOERS, app
+from wbb import app
 from wbb.core.decorators.errors import capture_err
-from wbb.modules.admin import current_chat_permissions, member_permissions
+from wbb.core.decorators.permissions import adminsOnly
+from wbb.modules.admin import current_chat_permissions
 
 __MODULE__ = "Locks"
 __HELP__ = """
@@ -84,47 +85,33 @@ async def tg_lock(message, permissions: list, perm: str, lock: bool):
 
 
 @app.on_message(filters.command(["lock", "unlock"]) & ~filters.private)
-@capture_err
+@adminsOnly("can_restrict_members")
 async def locks_func(_, message):
-    try:
-        user_id = message.from_user.id
-        chat_id = message.chat.id
-        if len(message.command) != 2:
-            await message.reply_text(incorrect_parameters)
-            return
-
-        parameter = message.text.strip().split(None, 1)[1].lower()
-        state = message.command[0].lower()
-        if parameter not in data and parameter != "all":
-            await message.reply_text(incorrect_parameters)
-            return
-
-        permissions = await member_permissions(chat_id, user_id)
-        if (
-            "can_restrict_members" not in permissions
-            and user_id not in SUDOERS
-        ):
-            await message.reply_text("You Don't Have Enough Permissions.")
-            return
-
-        permissions = await current_chat_permissions(chat_id)
-        if parameter in data:
-            await tg_lock(
-                message,
-                permissions,
-                data[parameter],
-                True if state == "lock" else False,
-            )
-            return
-        elif parameter == "all" and state == "lock":
-            await app.set_chat_permissions(chat_id, ChatPermissions())
-            await message.reply_text("Locked Everything.")
-    except Exception as e:
-        await message.reply_text(str(e))
-        print(e)
+    if len(message.command) != 2:
+        await message.reply_text(incorrect_parameters)
+        return
+    chat_id = message.chat.id
+    parameter = message.text.strip().split(None, 1)[1].lower()
+    state = message.command[0].lower()
+    if parameter not in data and parameter != "all":
+        await message.reply_text(incorrect_parameters)
+        return
+    permissions = await current_chat_permissions(chat_id)
+    if parameter in data:
+        await tg_lock(
+            message,
+            permissions,
+            data[parameter],
+            True if state == "lock" else False,
+        )
+        return
+    elif parameter == "all" and state == "lock":
+        await app.set_chat_permissions(chat_id, ChatPermissions())
+        await message.reply_text("Locked Everything.")
 
 
 @app.on_message(filters.command("locks") & ~filters.private)
+@capture_err
 async def locktypes(_, message):
     permissions = await current_chat_permissions(message.chat.id)
     if not permissions:

wbb/modules/notes.py

@@ -25,7 +25,7 @@ from pyrogram import filters
 
 from wbb import app
 from wbb.core.decorators.errors import capture_err
-from wbb.modules.admin import member_permissions
+from wbb.core.decorators.permissions import adminsOnly
 from wbb.utils.dbfunctions import (delete_note, get_note, get_note_names,
                                    save_note)
 
@@ -37,7 +37,7 @@ __HELP__ = """/notes To Get All The Notes In The Chat.
 
 
 @app.on_message(filters.command("save") & ~filters.edited & ~filters.private)
-@capture_err
+@adminsOnly("can_change_info")
 async def save_notee(_, message):
     if len(message.command) < 2 or not message.reply_to_message:
         await message.reply_text(
@@ -51,12 +51,6 @@ async def save_notee(_, message):
         await message.reply_text(
             "__**You can only save text or stickers in notes.**__"
         )
-
-    elif (
-        len(await member_permissions(message.chat.id, message.from_user.id))
-        < 1
-    ):
-        await message.reply_text("**You don't have enough permissions**")
     else:
         name = message.text.split(None, 1)[1].strip()
         if not name:
@@ -111,25 +105,18 @@ async def get_one_note(_, message):
 
 
 @app.on_message(filters.command("delete") & ~filters.edited & ~filters.private)
-@capture_err
+@adminsOnly("can_change_info")
 async def del_note(_, message):
     if len(message.command) < 2:
         await message.reply_text("**Usage**\n__/delete [NOTE_NAME]__")
-
-    elif (
-        len(await member_permissions(message.chat.id, message.from_user.id))
-        < 1
-    ):
-        await message.reply_text("**You don't have enough permissions**")
-
+        return
+    name = message.text.split(None, 1)[1].strip()
+    if not name:
+        await message.reply_text("**Usage**\n__/delete [NOTE_NAME]__")
+        return
+    chat_id = message.chat.id
+    deleted = await delete_note(chat_id, name)
+    if deleted:
+        await message.reply_text(f"**Deleted note {name} successfully.**")
     else:
-        name = message.text.split(None, 1)[1].strip()
-        if not name:
-            await message.reply_text("**Usage**\n__/delete [NOTE_NAME]__")
-            return
-        chat_id = message.chat.id
-        deleted = await delete_note(chat_id, name)
-        if deleted:
-            await message.reply_text(f"**Deleted note {name} successfully.**")
-        else:
-            await message.reply_text("**No such note.**")
+        await message.reply_text("**No such note.**")

wbb/modules/paste.py

@@ -25,16 +25,13 @@ import asyncio
 import os
 
 import aiofiles
-import aiohttp
 from pykeyboard import InlineKeyboard
 from pyrogram import filters
-from pyrogram.errors.exceptions.bad_request_400 import WebpageCurlFailed
 from pyrogram.types import InlineKeyboardButton
 
 from wbb import aiohttpsession as session
 from wbb import app
 from wbb.core.decorators.errors import capture_err
-from wbb.utils.functions import get_http_status_code
 from wbb.utils.pastebin import paste
 
 __MODULE__ = "Paste"

wbb/modules/pipes.py

@@ -1,171 +0,0 @@
-"""
-MIT License
-
-Copyright (c) 2021 TheHamkerCat
-
-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.
-"""
-import asyncio
-
-from pyrogram import filters
-from pyrogram.types import Message
-
-from wbb import BOT_ID, SUDOERS, USERBOT_ID, app, app2
-from wbb.core.decorators.errors import capture_err
-from wbb.utils.dbfunctions import (activate_pipe, deactivate_pipe,
-                                   is_pipe_active, show_pipes)
-from wbb.utils.filter_groups import pipes_group
-
-__MODULE__ = "Pipes"
-__HELP__ = """
-**THIS MODULE IS ONLY FOR DEVS**
-
-Use this module to create a pipe that will forward messages of one chat/channel to another.
-
-
-/activate_pipe [FROM_CHAT_ID] [TO_CHAT_ID] [BOT|USERBOT]
-
-Active a pipe.
-
-choose 'BOT' or 'USERBOT' according to your needs, this will decide
-which client will fetch the message from 'FROM_CHAT'.
-
-
-/deactivate_pipe [FROM_CHAT_ID] [TO_CHAT_ID]
-
-Deactivete a pipe.
-
-
-/show_pipes
-
-Show all the active pipes.
-"""
-pipes_list_bot = []
-pipes_list_userbot = []
-
-
-async def load_pipes():
-    print("[INFO]: LOADING PIPES")
-    global pipes_list_bot, pipes_list_userbot
-    pipes_list_bot = []
-    pipes_list_userbot = []
-    pipes = await show_pipes()
-    for pipe in pipes:
-        if pipe["fetcher"] == "bot":
-            pipes_list_bot.append(pipe)
-            continue
-        pipes_list_userbot.append(pipe)
-
-
-loop = asyncio.get_running_loop()
-loop.create_task(load_pipes())
-
-
-@app.on_message(~filters.me, group=pipes_group)
-@capture_err
-async def pipes_worker_bot(_, message: Message):
-    for pipe in pipes_list_bot:
-        if pipe["from_chat_id"] == message.chat.id:
-            await message.forward(pipe["to_chat_id"])
-
-
-@app2.on_message(~filters.me, group=pipes_group)
-@capture_err
-async def pipes_worker_userbot(_, message: Message):
-    for pipe in pipes_list_userbot:
-        if pipe["from_chat_id"] == message.chat.id:
-            if not message.text:
-                m, temp = await asyncio.gather(
-                    app.listen(USERBOT_ID), message.copy(BOT_ID)
-                )
-                caption = f"Forwarded from `{pipe['from_chat_id']}`"
-                caption = (
-                    f"{temp.caption}\n\n{caption}" if temp.caption else caption
-                )
-                await app.copy_message(
-                    pipe["to_chat_id"],
-                    USERBOT_ID,
-                    m.message_id,
-                    caption=caption,
-                )
-                await asyncio.sleep(10)
-                await temp.delete()
-                return
-            caption = f"Forwarded from `{pipe['from_chat_id']}`"
-            await app.send_message(
-                pipe["to_chat_id"], text=message.text + "\n\n" + caption
-            )
-
-
-@app.on_message(filters.command("activate_pipe") & filters.user(SUDOERS))
-@capture_err
-async def activate_pipe_func(_, message: Message):
-    if len(message.command) != 4:
-        await message.reply_text(
-            "**Usage:**\n/activate_pipe [FROM_CHAT_ID] [TO_CHAT_ID] [BOT|USERBOT]"
-        )
-        return
-    text = message.text.strip().split()
-    from_chat = int(text[1])
-    to_chat = int(text[2])
-    fetcher = text[3].lower()
-    if fetcher != "bot" and fetcher != "userbot":
-        await message.reply_text("Wrong fetcher, see help menu.")
-        return
-    if await is_pipe_active(from_chat, to_chat):
-        await message.reply_text("This pipe is already active.")
-        return
-    await activate_pipe(from_chat, to_chat, fetcher)
-    await load_pipes()
-    await message.reply_text("Activated pipe.")
-
-
-@app.on_message(filters.command("deactivate_pipe") & filters.user(SUDOERS))
-@capture_err
-async def deactivate_pipe_func(_, message: Message):
-    if len(message.command) != 3:
-        await message.reply_text(
-            "**Usage:**\n/deactivate_pipe [FROM_CHAT_ID] [TO_CHAT_ID]"
-        )
-        return
-    text = message.text.strip().split()
-    from_chat = int(text[1])
-    to_chat = int(text[2])
-    if not await is_pipe_active(from_chat, to_chat):
-        await message.reply_text("This pipe is already inactive.")
-        return
-    await deactivate_pipe(from_chat, to_chat)
-    await load_pipes()
-    await message.reply_text("Deactivated pipe.")
-
-
-@app.on_message(filters.command("pipes") & filters.user(SUDOERS))
-@capture_err
-async def show_pipes_func(_, message: Message):
-    pipes = pipes_list_bot + pipes_list_userbot
-    if not pipes:
-        await message.reply_text("No pipe is active.")
-        return
-    text = ""
-    for count, pipe in enumerate(pipes, 1):
-        text += (
-            f"**Pipe:** `{count}`\n**From:** `{pipe['from_chat_id']}`\n"
-            + f"**To:** `{pipe['to_chat_id']}`\n**Fetcher:** `{pipe['fetcher']}`\n\n"
-        )
-    await message.reply_text(text)

wbb/modules/regex.py

@@ -133,7 +133,7 @@ def separate_sed(sed_string):
                 and counter + 1 < len(sed_string)
                 and sed_string[counter + 1] == delim
             ):
-                sed_string = sed_string[:counter] + sed_string[counter + 1 :]
+                sed_string = sed_string[:counter] + sed_string[counter + 1:]
 
             elif sed_string[counter] == delim:
                 replace_with = sed_string[start:counter]

wbb/modules/stickers.py

@@ -27,10 +27,10 @@ from traceback import format_exc
 
 from pyrogram import filters
 from pyrogram.errors.exceptions.bad_request_400 import (PeerIdInvalid,
+                                                        ShortnameOccupyFailed,
                                                         StickerPngDimensions,
                                                         StickerPngNopng,
-                                                        UserIsBlocked,
-                                                        ShortnameOccupyFailed)
+                                                        UserIsBlocked)
 from pyrogram.types import InlineKeyboardButton, InlineKeyboardMarkup
 
 from wbb import BOT_USERNAME, app
@@ -100,7 +100,9 @@ async def kang(client, message):
                 await msg.edit("Format not supported! ({})".format(image_type))
                 return
             try:
-                temp_file_path = await resize_file_to_sticker_size(temp_file_path)
+                temp_file_path = await resize_file_to_sticker_size(
+                    temp_file_path
+                )
             except OSError as e:
                 await msg.edit_text("Something wrong happened.")
                 raise Exception(

wbb/modules/userbot.py

@@ -5,7 +5,6 @@
             https://github.com/pokurt/Nana-Remix/blob/master/nana/plugins/devs.py
 """
 
-import aiofiles
 import os
 import re
 import subprocess
@@ -16,6 +15,7 @@ from inspect import getfullargspec
 from io import StringIO
 from time import time
 
+import aiofiles
 from pyrogram import filters
 from pyrogram.types import Message
 
@@ -29,7 +29,7 @@ __HELP__ = """
 .approve | .disapprove - Approve Or Disapprove A User To PM You.
 .block | .unblock - Block Or Unblock A User.
 """
-
+arq = arq
 
 # Eval and Sh module from nana-remix
 
@@ -82,9 +82,7 @@ async def executor(client, message: Message):
         evaluation = stdout
     else:
         evaluation = "Success"
-    final_output = (
-        f"**INPUT:**\n```{escape(cmd)}```\n\n**OUTPUT**:\n```{escape(evaluation.strip())}```"
-    )
+    final_output = f"**INPUT:**\n```{escape(cmd)}```\n\n**OUTPUT**:\n```{escape(evaluation.strip())}```"
     if len(final_output) > 4096:
         filename = "output.txt"
         with open(filename, "w+", encoding="utf8") as out_file:
@@ -182,6 +180,7 @@ async def shellrunner(client, message: Message):
 
 """ C Eval """
 
+
 async def sendFile(message: Message, text: str):
     file = "output.txt"
     async with aiofiles.open(file, mode="w+") as f:
@@ -190,12 +189,14 @@ async def sendFile(message: Message, text: str):
     os.remove(file)
 
 
-@app2.on_message(filters.command("c", prefixes=USERBOT_PREFIX) & filters.user(SUDOERS))
+@app2.on_message(
+    filters.command("c", prefixes=USERBOT_PREFIX) & filters.user(SUDOERS)
+)
 async def cEval(_, message: Message):
     code = message.text.strip()[3:]
     file = "exec.c"
-    cmdCompile = ['gcc', '-g', 'exec.c', '-o', 'exec']
-    cmdRun = ['./exec']
+    cmdCompile = ["gcc", "-g", "exec.c", "-o", "exec"]
+    cmdRun = ["./exec"]
     async with aiofiles.open(file, mode="w+") as f:
         await f.write(code)
     t1 = time()

wbb/modules/ytdl.py

@@ -20,6 +20,7 @@ VIDEO_DATA = {}
 
 
 @app.on_message(filters.command("ytdl"))
+@capture_err
 async def ytdl_func(_, message):
     if len(message.command) != 2:
         await message.reply_text("**Usage:**/ytdl [VIDEO_LINK]")

wbb/utils/inlinefuncs.py

@@ -40,8 +40,10 @@ from pyrogram.types import (InlineKeyboardButton, InlineQueryResultArticle,
 from search_engine_parser import GoogleSearch
 
 from wbb import (BOT_USERNAME, MESSAGE_DUMP_CHAT, SUDOERS, USERBOT_ID,
-                 USERBOT_NAME, USERBOT_USERNAME, app, app2, arq, aiohttpsession)
-from wbb.core.types import InlineQueryResultCachedDocument, InlineQueryResultAudio
+                 USERBOT_NAME, USERBOT_USERNAME, aiohttpsession, app, app2,
+                 arq)
+from wbb.core.types import (InlineQueryResultAudio,
+                            InlineQueryResultCachedDocument)
 from wbb.modules.info import get_chat_info, get_user_info
 from wbb.modules.music import download_youtube_audio
 from wbb.modules.paste import isPreviewUp
@@ -352,11 +354,11 @@ async def shortify(url):
     payload = {"long_url": f"{url}"}
     payload = json.dumps(payload)
     async with aiohttpsession.post(
-            "https://api-ssl.bitly.com/v4/shorten",
-            headers=header,
-            data=payload,
-        ) as resp:
-            data = await resp.json()
+        "https://api-ssl.bitly.com/v4/shorten",
+        headers=header,
+        data=payload,
+    ) as resp:
+        data = await resp.json()
     msg = data["link"]
     a = []
     b = InlineQueryResultArticle(
@@ -1078,13 +1080,14 @@ async def randomAudioFunc(answers: list, query: str) -> list:
     url = f"https://www.zedge.net/api-zedge-web/browse/search?query={query}&contentType=ringtones"
     async with aiohttpsession.get(url) as resp:
         data = await resp.json()
-    items = data['items']
+    items = data["items"]
     answers = [
-            InlineQueryResultAudio(
-                audio_url=audio['audioUrl'],
-                thumb_url="https://tweety.drk1.workers.dev/0:/image_2021-05-22_20-56-47.png",
-                title=audio['title'],
-                mime_type="audio/mp3"
-                ) for audio in items
-            ]
+        InlineQueryResultAudio(
+            audio_url=audio["audioUrl"],
+            thumb_url="https://tweety.drk1.workers.dev/0:/image_2021-05-22_20-56-47.png",
+            title=audio["title"],
+            mime_type="audio/mp3",
+        )
+        for audio in items
+    ]
     return answers

wbb/utils/misc.py

@@ -85,7 +85,7 @@ def paginate_modules(page_n, module_dict, prefix, chat=None):
 
     # can only have a certain amount of buttons side by side
     if len(pairs) > 7:
-        pairs = pairs[modulo_page * 7 : 7 * (modulo_page + 1)] + [
+        pairs = pairs[modulo_page * 7: 7 * (modulo_page + 1)] + [
             (
                 EqInlineKeyboardButton(
                     "<",