Merge branch 'main' into dependabot/pip/pillow-10.3.0

.github/workflows/pre-commit-autoupdate.yml

@@ -15,7 +15,7 @@ jobs:
       - name: Run pre-commit autoupdate
         run: pre-commit autoupdate
       - name: Create Pull Request
-        uses: peter-evans/create-pull-request@v5
+        uses: peter-evans/create-pull-request@v6
         with:
           token: ${{ secrets.GITHUB_TOKEN }}
           branch: update/pre-commit-autoupdate

.gitignore

@@ -1,18 +1,17 @@
 *.session
 *.session-journal
-Powers/config.py
-Powers/vars.py
 .vscode/
 postgres-data/
 *.env
 !sample.env
 logs/
 Powers/local_vars.py
-Powers/vars.py
 .idea/
+scrapped/
 
 # Byte-compiled / optimized / DLL files
 __pycache__/
+Youtube/
 *.py[cod]
 *$py.class
 

Powers/__init__.py

@@ -1,10 +1,10 @@
+import shutil
 from datetime import datetime
 from importlib import import_module as imp_mod
 from logging import (INFO, WARNING, FileHandler, StreamHandler, basicConfig,
                      getLogger)
 from os import environ, listdir, mkdir, path
 from platform import python_version
-from random import choice
 from sys import exit as sysexit
 from sys import stdout, version_info
 from time import time
@@ -13,6 +13,7 @@ from traceback import format_exc
 import lyricsgenius
 import pyrogram
 import pytz
+from apscheduler.schedulers.asyncio import AsyncIOScheduler
 
 LOG_DATETIME = datetime.now().strftime("%d_%m_%Y-%H_%M_%S")
 LOGDIR = f"{__name__}/logs"
@@ -20,6 +21,9 @@ LOGDIR = f"{__name__}/logs"
 # Make Logs directory if it does not exixts
 if not path.isdir(LOGDIR):
     mkdir(LOGDIR)
+else:
+    shutil.rmtree(LOGDIR)
+    mkdir(LOGDIR)
 
 LOGFILE = f"{LOGDIR}/{__name__}_{LOG_DATETIME}_log.txt"
 
@@ -47,7 +51,8 @@ if version_info[0] < 3 or version_info[1] < 7:
 
 # the secret configuration specific things
 try:
-    if environ.get("ENV"):
+    from Powers.vars import is_env
+    if is_env or environ.get("ENV"):
         from Powers.vars import Config
     else:
         from Powers.vars import Development as Config
@@ -55,12 +60,12 @@ except Exception as ef:
     LOGGER.error(ef)  # Print Error
     LOGGER.error(format_exc())
     sysexit(1)
-#time zone
+# time zone
 TIME_ZONE = pytz.timezone(Config.TIME_ZONE)
 
-path = "./Version"
+Vpath = "./Version"
 version = []
-for i in listdir(path):
+for i in listdir(Vpath):
     if i.startswith("version") and i.endswith("md"):
         version.append(i)
     else:
@@ -92,16 +97,16 @@ if Config.GENIUS_API_TOKEN:
     genius_lyrics.verbose = False
     LOGGER.info("Client setup complete")
 elif not Config.GENIUS_API_TOKEN:
-    LOGGER.error("Genius api not found lyrics command will not work")
+    LOGGER.info("Genius api not found lyrics command will not work")
     is_genius_lyrics = False
     genius_lyrics = False
 
-is_audd = False
-Audd = None
-if Config.AuDD_API:
-    is_audd = True
-    Audd = Config.AuDD_API
-    LOGGER.info("Found Audd api")
+# is_audd = False
+# Audd = None
+# if Config.AuDD_API:
+#     is_audd = True
+#     Audd = Config.AuDD_API
+#     LOGGER.info("Found Audd api")
 
 is_rmbg = False
 RMBG = None
@@ -114,25 +119,15 @@ API_ID = Config.API_ID
 API_HASH = Config.API_HASH
 
 # General Config
-MESSAGE_DUMP = Config.MESSAGE_DUMP
+MESSAGE_DUMP = Config.MESSAGE_DUMP if Config.MESSAGE_DUMP else Config.OWNER_ID
 SUPPORT_GROUP = Config.SUPPORT_GROUP
 SUPPORT_CHANNEL = Config.SUPPORT_CHANNEL
 
-# Users Config
+# Users Config 
 OWNER_ID = Config.OWNER_ID
-DEV = Config.DEV_USERS
-DEVS_USER = set(DEV)
-SUDO_USERS = Config.SUDO_USERS
-WHITELIST_USERS = Config.WHITELIST_USERS
-
-
-
-defult_dev = [1344569458, 1432756163, 5294360309] + [int(OWNER_ID)]
-
-Defult_dev = set(defult_dev)
-
-DEVS = DEVS_USER | Defult_dev
-DEV_USERS = list(DEVS)
+DEV_USERS = set(Config.DEV_USERS)
+SUDO_USERS = set(Config.SUDO_USERS)
+WHITELIST_USERS = set(Config.WHITELIST_USERS)
 
 # Plugins, DB and Workers
 DB_URI = Config.DB_URI
@@ -147,16 +142,31 @@ PREFIX_HANDLER = Config.PREFIX_HANDLER
 HELP_COMMANDS = {}  # For help menu
 UPTIME = time()  # Check bot uptime
 
-from apscheduler.schedulers.asyncio import AsyncIOScheduler
 
+#Make dir
+youtube_dir = "./Youtube/"
+if not path.isdir(youtube_dir):
+    mkdir(youtube_dir)
+else:
+    shutil.rmtree(youtube_dir)
+    mkdir(youtube_dir)
+
+scrap_dir = "./scrapped/"
+if not path.isdir(scrap_dir):
+    mkdir(scrap_dir)
+else:
+    shutil.rmtree(scrap_dir)
+    mkdir(scrap_dir)
 scheduler = AsyncIOScheduler(timezone=TIME_ZONE)
 
+
 async def load_cmds(all_plugins):
     """Loads all the plugins in bot."""
     for single in all_plugins:
         # If plugin in NO_LOAD, skip the plugin
         if single.lower() in [i.lower() for i in Config.NO_LOAD]:
-            LOGGER.warning(f"Not loading '{single}' s it's added in NO_LOAD list")
+            LOGGER.warning(
+                f"Not loading '{single}' s it's added in NO_LOAD list")
             continue
 
         imported_module = imp_mod(f"Powers.plugins.{single}")
@@ -197,6 +207,7 @@ async def load_cmds(all_plugins):
         LOGGER.warning(f"Not loading Plugins - {NO_LOAD}")
 
     return (
-        ", ".join((i.split(".")[1]).capitalize() for i in list(HELP_COMMANDS.keys()))
+        ", ".join((i.split(".")[1]).capitalize()
+                  for i in list(HELP_COMMANDS.keys()))
         + "\n"
     )

Powers/__main__.py

@@ -1,8 +1,6 @@
-import uvloop  # Comment it out if using on windows
+# import uvloop  # Comment it out if using on windows
 from Powers.bot_class import Gojo
 
 if __name__ == "__main__":
-    uvloop.install() # Comment it out if using on windows
+    # uvloop.install()  # Comment it out if using on windows
     Gojo().run()
-    
-    

Powers/bot_class.py

@@ -1,6 +1,7 @@
 from platform import python_version
 from threading import RLock
-from time import gmtime, strftime, time
+from time import gmtime, strftime
+from time import time as t
 
 from pyrogram import Client, __version__
 from pyrogram.raw.all import layer
@@ -24,7 +25,6 @@ if MESSAGE_DUMP == -100 or not str(MESSAGE_DUMP).startswith("-100"):
     )
 
 
-
 class Gojo(Client):
     """Starts the Pyrogram Client on the Bot Token when we do 'python3 -m Powers'"""
 
@@ -45,10 +45,11 @@ class Gojo(Client):
         await super().start()
         await self.set_bot_commands(
             [
-                BotCommand("start", "To check weather the bot is alive or not"),
+                BotCommand(
+                    "start", "To check weather the bot is alive or not"),
                 BotCommand("help", "To get help menu"),
                 BotCommand("donate", "To buy me a coffee"),
-                BotCommand("bug","To report bugs")
+                BotCommand("bug", "To report bugs")
             ]
         )
         meh = await self.get_me()  # Get bot info from pyrogram client
@@ -67,10 +68,11 @@ class Gojo(Client):
         # Get cmds and keys
         cmd_list = await load_cmds(await all_plugins())
         await load_support_users()
+        await cache_support()
         LOGGER.info(f"Plugins Loaded: {cmd_list}")
-        scheduler.add_job(clean_my_db,'cron',[self],hour=3,minute=0,second=0)
         if BDB_URI:
-            scheduler.add_job(send_wishish,'cron',[self],hour=0,minute=0,second=0)
+            scheduler.add_job(send_wishish, 'cron', [
+                              self], hour=0, minute=0, second=0)
             scheduler.start()
         # Send a message to MESSAGE_DUMP telling that the
         # bot has started and has loaded all plugins!
@@ -87,24 +89,22 @@ class Gojo(Client):
 
     async def stop(self):
         """Stop the bot and send a message to MESSAGE_DUMP telling that the bot has stopped."""
-        runtime = strftime("%Hh %Mm %Ss", gmtime(time() - UPTIME))
+        runtime = strftime("%Hh %Mm %Ss", gmtime(t() - UPTIME))
         LOGGER.info("Uploading logs before stopping...!\n")
         # Send Logs to MESSAGE_DUMP and LOG_CHANNEL
+        scheduler.remove_all_jobs()
+        if MESSAGE_DUMP:
+            # LOG_CHANNEL is not necessary
+            target = MESSAGE_DUMP
+        else:
+            target = OWNER_ID
         await self.send_document(
-            MESSAGE_DUMP,
+            target,
             document=LOGFILE,
             caption=(
                 "Bot Stopped!\n\n" f"Uptime: {runtime}\n" f"<code>{LOG_DATETIME}</code>"
             ),
         )
-        scheduler.remove_all_jobs()
-        if MESSAGE_DUMP:
-            # LOG_CHANNEL is not necessary
-            await self.send_document(
-                MESSAGE_DUMP,
-                document=LOGFILE,
-                caption=f"Uptime: {runtime}",
-            )
         await super().stop()
         MongoDB.close()
         LOGGER.info(

Powers/database/afk_db.py

@@ -13,43 +13,45 @@ class AFK(MongoDB):
     def __init__(self) -> None:
         super().__init__(self.db_name)
 
-    def insert_afk(self, chat_id, user_id, time, reason, media_type,media=None):
+    def insert_afk(self, chat_id, user_id, time, reason, media_type, media=None):
         with INSERTION_LOCK:
             curr = self.check_afk(chat_id=chat_id, user_id=user_id)
             if curr:
                 if reason:
-                    self.update({"chat_id":chat_id,"user_id":user_id},{"reason":reason,"time":time})
+                    self.update({"chat_id": chat_id, "user_id": user_id}, {
+                                "reason": reason, "time": time})
                 if media:
-                    self.update({"chat_id":chat_id,"user_id":user_id},{'media':media,'media_type':media_type,"time":time})
+                    self.update({"chat_id": chat_id, "user_id": user_id}, {
+                                'media': media, 'media_type': media_type, "time": time})
                 return True
             else:
                 self.insert_one(
                     {
-                        "chat_id":chat_id,
-                        "user_id":user_id,
-                        "reason":reason,
-                        "time":time,
-                        "media":media,
-                        "media_type":media_type
+                        "chat_id": chat_id,
+                        "user_id": user_id,
+                        "reason": reason,
+                        "time": time,
+                        "media": media,
+                        "media_type": media_type
                     }
                 )
                 return True
 
     def check_afk(self, chat_id, user_id):
-        curr = self.find_one({"chat_id":chat_id,"user_id":user_id})
+        curr = self.find_one({"chat_id": chat_id, "user_id": user_id})
         if curr:
             return True
         return False
-    
+
     def get_afk(self, chat_id, user_id):
-        curr = self.find_one({"chat_id":chat_id,"user_id":user_id})
+        curr = self.find_one({"chat_id": chat_id, "user_id": user_id})
         if curr:
             return curr
         return
-    
+
     def delete_afk(self, chat_id, user_id):
         with INSERTION_LOCK:
-            curr = self.check_afk(chat_id,user_id)
+            curr = self.check_afk(chat_id, user_id)
             if curr:
-                self.delete_one({"chat_id":chat_id,"user_id":user_id})
-            return
+                self.delete_one({"chat_id": chat_id, "user_id": user_id})
+            return

Powers/database/antispam_db.py

@@ -28,6 +28,7 @@ class GBan(MongoDB):
                 return self.update_gban_reason(user_id, reason)
 
             # If not already gbanned, then add to gban
+            ANTISPAM_BANNED.add(user_id)
             time_rn = datetime.now(TZ)
             return self.insert_one(
                 {
@@ -43,8 +44,8 @@ class GBan(MongoDB):
         with INSERTION_LOCK:
             # Check if  user is already gbanned or not
             if self.find_one({"_id": user_id}):
+                ANTISPAM_BANNED.remove(user_id)
                 return self.delete_one({"_id": user_id})
-
             return "User not gbanned!"
 
     def get_gban(self, user_id: int):

Powers/database/approve_db.py

@@ -1,11 +1,16 @@
 from threading import RLock
+
 from Powers import LOGGER
 from Powers.database import MongoDB
+
 INSERTION_LOCK = RLock()
+
+
 class Approve(MongoDB):
     """Class for managing Approves in Chats in Bot."""
     # Database name to connect to to preform operations
     db_name = "approve"
+
     def __init__(self, chat_id: int) -> None:
         super().__init__(self.db_name)
         self.chat_id = chat_id
@@ -22,7 +27,6 @@ class Approve(MongoDB):
                 else:
                     j = False
             return j
-                    
 
     def add_approve(self, user_id: int, user_name: str):
         with INSERTION_LOCK:
@@ -33,6 +37,7 @@ class Approve(MongoDB):
                     {"users": self.chat_info["users"]},
                 )
             return True
+
     def remove_approve(self, user_id: int):
         with INSERTION_LOCK:
             if self.check_approve(user_id):
@@ -47,50 +52,59 @@ class Approve(MongoDB):
                     {"users": self.chat_info["users"]},
                 )
             return True
+
     def unapprove_all(self):
         with INSERTION_LOCK:
             return self.delete_one(
                 {"_id": self.chat_id},
             )
+
     def clean_approve(self):
         with INSERTION_LOCK:
             return self.delete_one(
-                {"_id":self.chat_id}
+                {"_id": self.chat_id}
             )
+
     def list_approved(self):
         with INSERTION_LOCK:
             return self.chat_info["users"]
+
     def count_approved(self):
         with INSERTION_LOCK:
             return len(self.chat_info["users"])
+
     def load_from_db(self):
         return self.find_all()
+
     def __ensure_in_db(self):
         chat_data = self.find_one({"_id": self.chat_id})
         if not chat_data:
             new_data = {"_id": self.chat_id, "users": []}
             self.insert_one(new_data)
-            LOGGER.info(f"Initialized Approve Document for chat {self.chat_id}")
             return new_data
         return chat_data
     # Migrate if chat id changes!
+
     def migrate_chat(self, new_chat_id: int):
         old_chat_db = self.find_one({"_id": self.chat_id})
         new_data = old_chat_db.update({"_id": new_chat_id})
         self.insert_one(new_data)
         self.delete_one({"_id": self.chat_id})
+
     @staticmethod
     def count_all_approved():
         with INSERTION_LOCK:
             collection = MongoDB(Approve.db_name)
             all_data = collection.find_all()
             return sum(len(i["users"]) for i in all_data if len(i["users"]) >= 1)
+
     @staticmethod
     def count_approved_chats():
         with INSERTION_LOCK:
             collection = MongoDB(Approve.db_name)
             all_data = collection.find_all()
             return sum(len(i["users"]) >= 1 for i in all_data)
+
     @staticmethod
     def repair_db(collection):
         all_data = collection.find_all()

Powers/database/autojoin_db.py

@@ -15,36 +15,36 @@ class AUTOJOIN(MongoDB):
     def __init__(self) -> None:
         super().__init__(self.db_name)
 
-    def load_autojoin(self, chat,mode="auto"):
+    def load_autojoin(self, chat, mode="auto"):
         """
         type = auto or notify
         auto to auto accept join requests
         notify to notify the admins about the join requests
         """
-        curr = self.find_one({"chat_id":chat,})
+        curr = self.find_one({"chat_id": chat, })
         if not curr:
             with INSERTION_LOCK:
-                self.insert_one({"chat_id":chat,"type":mode})
+                self.insert_one({"chat_id": chat, "type": mode})
             return True
         return False
 
-    def get_autojoin(self,chat):
-        curr = self.find_one({"chat_id":chat})
+    def get_autojoin(self, chat):
+        curr = self.find_one({"chat_id": chat})
         if not curr:
             return False
         else:
             return curr["type"]
 
-    def update_join_type(self,chat,mode):
-        curr = self.find_one({"chat_id":chat})
+    def update_join_type(self, chat, mode):
+        curr = self.find_one({"chat_id": chat})
         if curr:
-            self.update({"chat_id":chat},{"type":mode})
-            return 
+            self.update({"chat_id": chat}, {"type": mode})
+            return
         else:
             return
 
-    def remove_autojoin(self,chat):
-        curr = self.find_one({"chat_id":chat})
+    def remove_autojoin(self, chat):
+        curr = self.find_one({"chat_id": chat})
         if curr:
-            self.delete_one({"chat_id":chat})
-        return
+            self.delete_one({"chat_id": chat})
+        return

Powers/database/blacklist_db.py

@@ -110,13 +110,12 @@ class Blacklist(MongoDB):
                 "reason": "Automated blacklisted word: {{}}",
             }
             self.insert_one(new_data)
-            LOGGER.info(f"Initialized Blacklist Document for chat {self.chat_id}")
             return new_data
         return chat_data
 
     def clean_blacklist(self):
         with INSERTION_LOCK:
-            return self.delete_one({"_id":self.chat_id})
+            return self.delete_one({"_id": self.chat_id})
 
     # Migrate if chat id changes!
     def migrate_chat(self, new_chat_id: int):

Powers/database/captcha_db.py

@@ -13,15 +13,15 @@ class CAPTCHA(MongoDB):
     def __init__(self) -> None:
         super().__init__(self.db_name)
 
-    def insert_captcha(self, chat, captcha_type:str="qr", captcha_action:str = "mute"):
+    def insert_captcha(self, chat, captcha_type: str = "qr", captcha_action: str = "mute"):
         with INSERTION_LOCK:
             curr = self.is_captcha(chat)
             if not curr:
                 self.insert_one(
                     {
-                        "chat_id":chat,
-                        "captcha_type":captcha_type,
-                        "captcha_action":captcha_action
+                        "chat_id": chat,
+                        "captcha_type": captcha_type,
+                        "captcha_action": captcha_action
                     }
                 )
             return
@@ -36,29 +36,31 @@ class CAPTCHA(MongoDB):
         with INSERTION_LOCK:
             curr = self.is_captcha(chat)
             if curr:
-                self.update({"chat_id":chat},{"captcha_type":captcha_type})
+                self.update({"chat_id": chat}, {"captcha_type": captcha_type})
             return
 
     def update_action(self, chat, captcha_action):
         with INSERTION_LOCK:
             curr = self.is_captcha(chat)
             if curr:
-                self.update({"chat_id":chat},{"captcha_action":captcha_action})
+                self.update({"chat_id": chat}, {
+                            "captcha_action": captcha_action})
             return
-    
+
     def remove_captcha(self, chat):
         with INSERTION_LOCK:
             curr = self.is_captcha(chat)
             if curr:
-                self.delete_one({"chat_id":chat})
+                self.delete_one({"chat_id": chat})
             return
 
     def get_captcha(self, chat):
-        curr = self.find_one({"chat_id":chat})
+        curr = self.find_one({"chat_id": chat})
         if curr:
             return curr
         return False
 
+
 class CAPTCHA_DATA(MongoDB):
     """class to store captcha data"""
     db_name = "captcha_data"
@@ -67,47 +69,57 @@ class CAPTCHA_DATA(MongoDB):
         super().__init__(self.db_name)
 
     def load_cap_data(self, chat, user, data):
-        curr = self.find_one({"chat_id":chat,"user_id":user})
+        curr = self.find_one({"chat_id": chat, "user_id": user})
         if not curr:
             with INSERTION_LOCK:
-                self.insert_one({"chat_id":chat,"user_id":user,"data":data})
+                self.insert_one(
+                    {"chat_id": chat, "user_id": user, "data": data})
             return True
         else:
             return
 
     def get_cap_data(self, chat, user):
-        curr = self.find_one({"chat_id":chat,"user_id":user})
+        curr = self.find_one({"chat_id": chat, "user_id": user})
         if curr:
             return curr["data"]
         else:
             return False
 
     def remove_cap_data(self, chat, user):
-        curr = self.find_one({"chat_id":chat,"user_id":user})
+        curr = self.find_one({"chat_id": chat, "user_id": user})
         if curr:
             with INSERTION_LOCK:
-                self.delete_one({"chat_id":chat,"user_id":user})
+                self.delete_one({"chat_id": chat, "user_id": user})
         return
 
     def store_message_id(self, chat, user, message):
-        curr = self.find_one({"chat_id":chat,"user_id":user})
+        curr = self.find_one({"chat_id": chat, "user_id": user})
         if not curr:
             with INSERTION_LOCK:
-                self.insert_one({"chat_id":chat,"user_id":user,"message_id":message})
+                self.insert_one(
+                    {"chat_id": chat, "user_id": user, "message_id": message})
                 return
         else:
-            return 
-    
-    def is_already_data(self, chat, user):
-        curr = self.find_one({"chat_id":chat,"user_id":user})
+            return
+        
+    def get_message_id(self, chat, user):
+        curr = self.find_one({"chat_id": chat, "user_id": user})
         if curr:
             return curr["message_id"]
         else:
             return False
 
+    def is_already_data(self, chat, user):
+        curr = self.find_one({"chat_id": chat, "user_id": user})
+        if curr:
+            return curr.get("message_id", False)
+        else:
+            return False
+
     def del_message_id(self, chat, user):
-        curr = self.find_one({"chat_id":chat,"user_id":user})
+        curr = self.find_one({"chat_id": chat, "user_id": user})
         if curr:
             with INSERTION_LOCK:
-                self.delete_one({"chat_id":chat,"user_id":user})
-        return
+                self.delete_one({"chat_id": chat, "user_id": user})
+
+        return curr["message_id"]

Powers/database/chats_db.py

@@ -107,7 +107,6 @@ class Chats(MongoDB):
         if not chat_data:
             new_data = {"_id": self.chat_id, "chat_name": "", "users": []}
             self.insert_one(new_data)
-            LOGGER.info(f"Initialized Chats Document for chat {self.chat_id}")
             return new_data
         return chat_data
 

Powers/database/disable_db.py

@@ -146,9 +146,9 @@ class Disabling(MongoDB):
                     "commands": [],
                     "action": "none",
                 }
-                DISABLED_CMDS[self.chat_id] = {"commands": [], "action": "none"}
+                DISABLED_CMDS[self.chat_id] = {
+                    "commands": [], "action": "none"}
                 self.insert_one(new_data)
-                LOGGER.info(f"Initialized Disabling Document for chat {self.chat_id}")
                 return new_data
             DISABLED_CMDS[self.chat_id] = chat_data
         return chat_data
@@ -163,7 +163,7 @@ class Disabling(MongoDB):
 
     def clean_disable(self):
         with INSERTION_LOCK:
-            return self.delete_one({"_id":self.chat_id})
+            return self.delete_one({"_id": self.chat_id})
 
     @staticmethod
     def repair_db(collection):

Powers/database/filters_db.py

@@ -24,7 +24,15 @@ class Filters(MongoDB):
             # Database update
             curr = self.find_one({"chat_id": chat_id, "keyword": keyword})
             if curr:
-                return False
+                self.update(
+                    {"chat_id": chat_id, "keyword": keyword},
+                    {
+                        "filter_reply": filter_reply,
+                        "msgtype": msgtype,
+                        "fileid": fileid
+                    }
+                )
+                return
             return self.insert_one(
                 {
                     "chat_id": chat_id,
@@ -71,7 +79,8 @@ class Filters(MongoDB):
             curr = self.find_all()
             if curr:
                 return len(
-                    [z for z in (i["keyword"].split("|") for i in curr) if len(z) >= 2],
+                    [z for z in (i["keyword"].split("|")
+                                 for i in curr) if len(z) >= 2],
                 )
             return 0
 

Powers/database/flood_db.py

@@ -7,6 +7,7 @@ from Powers.utils.msg_types import Types
 
 INSERTION_LOCK = RLock()
 
+
 class Floods(MongoDB):
     """Class to store flood limit and action of a chat"""
     db_name = "flood"
@@ -24,7 +25,7 @@ class Floods(MongoDB):
         with INSERTION_LOCK:
             curr = self.find_one({"chat_id": chat_id})
             if curr:
-                if not(limit == int(curr['limit']) and within == int(curr['within']) and action == str(curr['action'])):
+                if not (limit == int(curr['limit']) and within == int(curr['within']) and action == str(curr['action'])):
                     return self.update(
                         {
                             "chat_id": chat_id
@@ -36,37 +37,37 @@ class Floods(MongoDB):
                         }
                     )
                 else:
-                    return 
+                    return
             else:
                 return self.insert_one(
                     {
-                        "chat_id" : chat_id,
+                        "chat_id": chat_id,
                         "limit": limit,
                         "within": within,
-                        "action" : action
+                        "action": action
                     },
                 )
-    
+
     def is_chat(self, chat_id: int):
         with INSERTION_LOCK:
             curr = self.find_one({"chat_id": chat_id})
             if curr:
-                action = [str(curr['limit']), str(curr['within']), str(curr['action'])]
+                action = [str(curr['limit']), str(
+                    curr['within']), str(curr['action'])]
                 return action
             return False
-    
+
     def get_action(self, chat_id: int):
         with INSERTION_LOCK:
             curr = self.find_one({"chat_id": chat_id})
             if curr:
                 return curr['action']
             return "Flood haven't set"
-    
+
     def rm_flood(self, chat_id: int):
         with INSERTION_LOCK:
             curr = self.find_one({"chat_id": chat_id})
             if curr:
-                self.delete_one({"chat_id":chat_id})
+                self.delete_one({"chat_id": chat_id})
                 return True
             return False
-            

Powers/database/greetings_db.py

@@ -45,6 +45,7 @@ class Greetings(MongoDB):
     def get_welcome_media(self):
         with INSERTION_LOCK:
             return self.chat_info["welcome_media"]
+
     def get_welcome_msgtype(self):
         with INSERTION_LOCK:
             return self.chat_info["welcome_mtype"]
@@ -78,32 +79,32 @@ class Greetings(MongoDB):
         with INSERTION_LOCK:
             return self.update({"_id": self.chat_id}, {"goodbye": status})
 
-    def set_welcome_text(self, welcome_text: str, mtype,media=None):
+    def set_welcome_text(self, welcome_text: str, mtype, media=None):
         with INSERTION_LOCK:
             self.update(
                 {"_id": self.chat_id},
-                {"welcome_text": welcome_text,"welcome_mtype":mtype},
+                {"welcome_text": welcome_text, "welcome_mtype": mtype},
             )
             if media:
                 self.update(
                     {"_id": self.chat_id},
-                    {"welcome_media": media,"welcome_mtype":mtype}
+                    {"welcome_media": media, "welcome_mtype": mtype}
                 )
 
-            return 
+            return
 
-    def set_goodbye_text(self, goodbye_text: str,mtype,media=None):
+    def set_goodbye_text(self, goodbye_text: str, mtype, media=None):
         with INSERTION_LOCK:
             self.update(
                 {"_id": self.chat_id},
-                {"goodbye_text": goodbye_text,"goodbye_mtype":mtype},
+                {"goodbye_text": goodbye_text, "goodbye_mtype": mtype},
             )
             if media:
                 self.update(
                     {"_id": self.chat_id},
-                    {"goodbye_media": media,"goodbye_mtype":mtype}
+                    {"goodbye_media": media, "goodbye_mtype": mtype}
                 )
-                return 
+                return
 
     def set_current_cleanservice_settings(self, status: bool):
         with INSERTION_LOCK:
@@ -154,13 +155,12 @@ class Greetings(MongoDB):
                 "welcome_text": "Hey {first}, welcome to {chatname}!",
                 "welcome": True,
                 "goodbye": True,
-                "welcome_media":False,
-                "welcome_mtype":False,
-                "goodbye_media":False,
-                "goodbye_mtype":False
+                "welcome_media": False,
+                "welcome_mtype": False,
+                "goodbye_media": False,
+                "goodbye_mtype": False
             }
             self.insert_one(new_data)
-            LOGGER.info(f"Initialized Greetings Document for chat {self.chat_id}")
             return new_data
         return chat_data
 
@@ -173,7 +173,7 @@ class Greetings(MongoDB):
 
     def clean_greetings(self):
         with INSERTION_LOCK:
-            return self.delete_one({"_id":self.chat_id})
+            return self.delete_one({"_id": self.chat_id})
 
     @staticmethod
     def count_chats(query: str):

Powers/database/locks_db.py

@@ -5,9 +5,13 @@ from Powers.database import MongoDB
 
 INSERTION_LOCK = RLock()
 
+lock_t = ["bot", "anti_c_send", "anti_fwd",
+          "anti_fwd_u", "anti_fwd_c", "anti_links"]
+
+
 class LOCKS(MongoDB):
     """Class to store locks"""
-    
+
     db_name = "locks"
 
     def __init__(self) -> None:
@@ -15,59 +19,98 @@ class LOCKS(MongoDB):
 
     def insert_lock_channel(self, chat: int, locktype: str):
         """
-        locktypes: anti_c_send, anti_fwd, anti_fwd_u, anti_fwd_c, anti_links
+        locktypes: all, bot, anti_c_send, anti_fwd, anti_fwd_u, anti_fwd_c, anti_links
         """
-        curr = self.find_one({"chat_id":chat,"locktype":locktype})
+        if locktype == "all":
+            for i in lock_t:
+                curr = self.find_one({"chat_id": chat, "locktype": i})
+                if curr:
+                    continue
+                if i in ["anti_fwd_u", "anti_fwd_c"]:
+                    continue
+                self.insert_one({"chat_id": chat, "locktype": i})
+            return True
+        curr = self.find_one({"chat_id": chat, "locktype": locktype})
         if curr:
             return False
         else:
             with INSERTION_LOCK:
-                hmm = self.merge_u_and_c(chat,locktype)
+                hmm = self.merge_u_and_c(chat, locktype)
                 if not hmm:
-                    self.insert_one({"chat_id":chat,"locktype":locktype})
+                    self.insert_one({"chat_id": chat, "locktype": locktype})
             return True
 
     def remove_lock_channel(self, chat: int, locktype: str):
         """
-        locktypes: anti_c_send, anti_fwd, anti_fwd_u, anti_fwd_c, anti_links
+        locktypes: all, bot, anti_c_send, anti_fwd, anti_fwd_u, anti_fwd_c, anti_links
         """
-        curr = self.find_one({"chat_id":chat,"locktype":locktype})
+        if locktype == "all":
+            for i in lock_t:
+                curr = self.find_one({"chat_id": chat, "locktype": i})
+                if curr:
+                    self.delete_one({"chat_id": chat, "locktype": i})
+            return True
+        curr = self.find_one({"chat_id": chat, "locktype": locktype})
         if curr:
             with INSERTION_LOCK:
-                self.delete_one({"chat_id":chat,"locktype":locktype})
+                self.delete_one({"chat_id": chat, "locktype": locktype})
             return True
         else:
             return False
 
-    def get_lock_channel(self, locktype: str="all"):
+    def get_lock_channel(self, chat: int, locktype: str = "all"):
         """
-        locktypes: anti_c_send, anti_fwd, anti_fwd_u, anti_fwd_c, anti_links
+        locktypes: anti_c_send, anti_fwd, anti_fwd_u, anti_fwd_c, anti_links, bot
         """
-        if locktype not in ["anti_c_send","anti_fwd","anti_fwd_u","anti_fwd_c","anti_links", "all"]:
+        if locktype not in ["anti_c_send", "anti_fwd", "anti_fwd_u", "anti_fwd_c", "anti_links", "bot", "all"]:
             return False
         else:
-            if locktype == "all":
-                find = {}
-            else:
-                find = {"locktype":locktype}
-            curr = self.find_all(find)
-            if not curr:
-                list_ = []
+            if locktype != "all":
+                curr = self.find_one(
+                    {"chat_id": chat, "locktype": locktype})
+                return bool(curr)
             else:
-                list_ = [i["chat_id"] for i in curr]
-            return list_
+                to_return = {
+                    "anti_channel": False,
+                    "anti_fwd": {
+                        "user": False,
+                        "chat": False
+                    },
+                    "anti_links": False,
+                    "bot": False
+                }
+                curr = self.find_all({"chat_id": chat})
+                if not curr:
+                    return None
+                else:
+                    for i in list(curr):
+                        if i["locktype"] == "anti_c_send":
+                            to_return["anti_channel"] = True
+                        elif i["locktype"] == "anti_fwd":
+                            to_return["anti_fwd"]["user"] = to_return["anti_fwd"]["chat"] = True
+                        elif i["locktype"] == "anti_fwd_u":
+                            to_return["anti_fwd"]["user"] = True
+                        elif i["locktype"] == "anti_fwd_c":
+                            to_return["anti_fwd"]["chat"] = True
+                        elif i["anti_links"] == "anti_links":
+                            to_return["anti_links"] = True
+                        elif i["locktype"] == "bot":
+                            to_return["bot"] = True
+                        else:
+                            continue
+                    return to_return
 
     def merge_u_and_c(self, chat: int, locktype: str):
         if locktype == "anti_fwd_u":
-            curr = self.find_one({"chat_id":chat,"locktype":"anti_fwd_c"})
+            curr = self.find_one({"chat_id": chat, "locktype": "anti_fwd_c"})
         elif locktype == "anti_fwd_c":
-            curr = self.find_one({"chat_id":chat,"locktype":"anti_fwd_u"})
+            curr = self.find_one({"chat_id": chat, "locktype": "anti_fwd_u"})
         else:
             return False
 
         if curr:
-            self.delete_one({"chat_id":chat,"locktype":locktype})
-            self.insert_one({"chat_id":chat,"locktype":"anti_fwd"})
+            self.delete_one({"chat_id": chat, "locktype": locktype})
+            self.insert_one({"chat_id": chat, "locktype": "anti_fwd"})
             return True
         else:
             return False
@@ -76,9 +119,8 @@ class LOCKS(MongoDB):
         """
         locktypes: anti_c_send, anti_fwd, anti_fwd_u, anti_fwd_c, anti_links
         """
-        curr = self.find_one({"chat_id":chat,"locktype":locktype})
+        curr = self.find_one({"chat_id": chat, "locktype": locktype})
         if curr:
             return True
         else:
             return False
-        

Powers/database/notes_db.py

@@ -57,7 +57,8 @@ class Notes(MongoDB):
     def get_all_notes(self, chat_id: int):
         with INSERTION_LOCK:
             curr = self.find_all({"chat_id": chat_id})
-            note_list = sorted([(note["note_name"], note["hash"]) for note in curr])
+            note_list = sorted([(note["note_name"], note["hash"])
+                               for note in curr])
             return note_list
 
     def rm_note(self, chat_id: int, note_name: str):
@@ -124,9 +125,9 @@ class NotesSettings(MongoDB):
         self.update({"_id": chat_id}, {"privatenotes": False})
         return False
 
-    def clean_notes(self,chat_id):
+    def clean_notes(self, chat_id):
         with INSERTION_LOCK:
-            return self.delete_one({"_id":chat_id})
+            return self.delete_one({"_id": chat_id})
 
     def list_chats(self):
         return self.find_all({"privatenotes": True})

Powers/database/pins_db.py

@@ -62,13 +62,12 @@ class Pins(MongoDB):
                 "cleanlinked": False,
             }
             self.insert_one(new_data)
-            LOGGER.info(f"Initialized Pins Document for chat {self.chat_id}")
             return new_data
         return chat_data
 
     def clean_pins(self):
         with INSERTION_LOCK:
-            return self.delete_one({"_id":self.chat_id})
+            return self.delete_one({"_id": self.chat_id})
 
     # Migrate if chat id changes!
     def migrate_chat(self, new_chat_id: int):

Powers/database/reporting_db.py

@@ -42,9 +42,9 @@ class Reporting(MongoDB):
         chat_data = self.find_one({"_id": self.chat_id})
         if not chat_data:
             chat_type = self.get_chat_type()
-            new_data = {"_id": self.chat_id, "status": True, "chat_type": chat_type}
+            new_data = {"_id": self.chat_id,
+                        "status": True, "chat_type": chat_type}
             self.insert_one(new_data)
-            LOGGER.info(f"Initialized Language Document for chat {self.chat_id}")
             return new_data
         return chat_data
 
@@ -57,7 +57,7 @@ class Reporting(MongoDB):
 
     def clean_reporting(self):
         with INSERTION_LOCK:
-            return self.delete_one({"_id":self.chat_id})
+            return self.delete_one({"_id": self.chat_id})
 
     @staticmethod
     def repair_db(collection):

Powers/database/rules_db.py

@@ -68,7 +68,6 @@ class Rules(MongoDB):
         if not chat_data:
             new_data = {"_id": self.chat_id, "privrules": False, "rules": ""}
             self.insert_one(new_data)
-            LOGGER.info(f"Initialized Language Document for chat {self.chat_id}")
             return new_data
         return chat_data
 

Powers/database/support_db.py

@@ -5,6 +5,7 @@ from Powers.database import MongoDB
 
 INSERTION_LOCK = RLock()
 
+
 class SUPPORTS(MongoDB):
     """
     class to store support users in database
@@ -12,7 +13,7 @@ class SUPPORTS(MongoDB):
     """
 
     db_name = "supports"
-    
+
     def __init__(self) -> None:
         super().__init__(self.db_name)
 
@@ -22,49 +23,48 @@ class SUPPORTS(MongoDB):
             with INSERTION_LOCK:
                 self.insert_one(
                     {
-                        "user_id":user_id,
-                        "support_type":support_type
+                        "user_id": user_id,
+                        "support_type": support_type
                     }
                 )
             return
 
-    def update_support_user_type(self,user,new_type):
+    def update_support_user_type(self, user, new_type):
         curr = self.is_support_user(user)
         if curr:
             with INSERTION_LOCK:
                 self.update(
                     {
-                        "user_id":user
+                        "user_id": user
                     },
                     {
-                        "support_type":new_type
+                        "support_type": new_type
                     }
                 )
         return
 
-
     def is_support_user(self, user_id):
-        curr = self.find_one({"user_id":user_id})
+        curr = self.find_one({"user_id": user_id})
         if curr:
             return True
         return False
 
-    def delete_support_user(self,user):
+    def delete_support_user(self, user):
         curr = self.is_support_user(user)
         if curr:
             with INSERTION_LOCK:
-                self.delete_one({"user_id":user})
+                self.delete_one({"user_id": user})
         return
 
-    def get_particular_support(self,support_type):
-        curr = self.find_all({"support_type":support_type})
+    def get_particular_support(self, support_type):
+        curr = self.find_all({"support_type": support_type})
         if curr:
             return [i['user_id'] for i in curr]
         else:
             return []
 
-    def get_support_type(self,user):
-        curr = self.find_one({"user_id":user})
+    def get_support_type(self, user):
+        curr = self.find_one({"user_id": user})
         if curr:
             return curr["support_type"]
-        return False
+        return False

Powers/database/users_db.py

@@ -67,9 +67,9 @@ class Users(MongoDB):
     def __ensure_in_db(self):
         chat_data = self.find_one({"_id": self.user_id})
         if not chat_data:
-            new_data = {"_id": self.user_id, "username": "", "name": "unknown_till_now"}
+            new_data = {"_id": self.user_id,
+                        "username": "", "name": "unknown_till_now"}
             self.insert_one(new_data)
-            LOGGER.info(f"Initialized User Document for {self.user_id}")
             return new_data
         return chat_data
 

Powers/database/warns_db.py

@@ -49,7 +49,7 @@ class Warns(MongoDB):
 
     def clean_warn(self):
         with INSERTION_LOCK:
-            return self.delete_one({"chat_id":self.chat_id})
+            return self.delete_one({"chat_id": self.chat_id})
 
     def get_warns(self, user_id: int):
         with INSERTION_LOCK:
@@ -93,12 +93,14 @@ class Warns(MongoDB):
                         f"Repairing Approve Database - setting '{key}:{val}' for {data['user_id']} in {data['chat_id']}",
                     )
                     collection.update(
-                        {"chat_id": data["chat_id"], "user_id": data["user_id"]},
+                        {"chat_id": data["chat_id"],
+                            "user_id": data["user_id"]},
                         {key: val},
                     )
 
     def __ensure_in_db(self, user_id: int):
-        chat_data = self.find_one({"chat_id": self.chat_id, "user_id": user_id})
+        chat_data = self.find_one(
+            {"chat_id": self.chat_id, "user_id": user_id})
         if not chat_data:
             new_data = {
                 "chat_id": self.chat_id,
@@ -107,7 +109,6 @@ class Warns(MongoDB):
                 "num_warns": 0,
             }
             self.insert_one(new_data)
-            LOGGER.info(f"Initialized Warn Document for {user_id} in {self.chat_id}")
             return new_data
         return chat_data
 
@@ -123,9 +124,9 @@ class WarnSettings(MongoDB):
     def __ensure_in_db(self):
         chat_data = self.find_one({"_id": self.chat_id})
         if not chat_data:
-            new_data = {"_id": self.chat_id, "warn_mode": "none", "warn_limit": 3}
+            new_data = {"_id": self.chat_id,
+                        "warn_mode": "none", "warn_limit": 3}
             self.insert_one(new_data)
-            LOGGER.info(f"Initialized Warn Settings Document for {self.chat_id}")
             return new_data
         return chat_data
 
@@ -140,7 +141,7 @@ class WarnSettings(MongoDB):
 
     def clean_warns(self):
         with INSERTION_LOCK:
-            return self.delete_one({"_id":self.chat_id})
+            return self.delete_one({"_id": self.chat_id})
 
     def get_warnmode(self):
         with INSERTION_LOCK:

Powers/plugins/__init__.py

@@ -38,3 +38,4 @@ def till_date(date):
     form = "%Y-%m-%d %H:%M:%S"
     z = datetime.strptime(date,form)
     return z
+

Powers/plugins/admin.py

@@ -6,26 +6,21 @@ from traceback import format_exc
 from pyrogram import filters
 from pyrogram.enums import ChatMemberStatus as CMS
 from pyrogram.enums import ChatType
-from pyrogram.errors import (ChatAdminInviteRequired, ChatAdminRequired,
-                             FloodWait, RightForbidden, RPCError,
-                             UserAdminInvalid)
+from pyrogram.errors import (BotChannelsNa, ChatAdminInviteRequired,
+                             ChatAdminRequired, FloodWait, RightForbidden,
+                             RPCError, UserAdminInvalid)
 from pyrogram.types import ChatPrivileges, Message
 
-from Powers import LOGGER, OWNER_ID
+from Powers import DEV_USERS, LOGGER, OWNER_ID, SUDO_USERS, WHITELIST_USERS
 from Powers.bot_class import Gojo
 from Powers.database.approve_db import Approve
 from Powers.database.reporting_db import Reporting
-from Powers.supports import get_support_staff
 from Powers.utils.caching import (ADMIN_CACHE, TEMP_ADMIN_CACHE_BLOCK,
                                   admin_cache_reload)
-from Powers.utils.custom_filters import (admin_filter, command, owner_filter,
-                                         promote_filter)
+from Powers.utils.custom_filters import admin_filter, command, promote_filter
 from Powers.utils.extract_user import extract_user
 from Powers.utils.parser import mention_html
-from Powers.vars import Config
 
-SUPPORT_STAFF = get_support_staff()
-DEV_LEVEL = get_support_staff("dev_level")
 
 @Gojo.on_message(command("adminlist"))
 async def adminlist_show(_, m: Message):
@@ -69,7 +64,7 @@ async def adminlist_show(_, m: Message):
         adminstr += "\n\n<b>Bots:</b>\n"
         adminstr += "\n".join(f"- {i}" for i in mention_bots)
         await m.reply_text(adminstr + "\n\n" + note)
-        LOGGER.info(f"Adminlist cmd use in {m.chat.id} by {m.from_user.id}")
+        
     except Exception as ef:
         if str(ef) == str(m.chat.id):
             await m.reply_text(text="Use /admincache to reload admins!")
@@ -83,25 +78,31 @@ async def adminlist_show(_, m: Message):
     return
 
 
+
 @Gojo.on_message(command("zombies") & admin_filter)
 async def zombie_clean(c: Gojo, m: Message):
     zombie = 0
     wait = await m.reply_text("Searching ... and banning ...")
+    failed = 0
     async for member in c.get_chat_members(m.chat.id):
         if member.user.is_deleted:
             zombie += 1
             try:
                 await c.ban_chat_member(m.chat.id, member.user.id)
             except UserAdminInvalid:
-                zombie -= 1
+                failed += 1
             except FloodWait as e:
-                await sleep(e.x)
+                await sleep(e.value)
+                try:
+                    await c.ban_chat_member(m.chat.id, member.user.id)
+                except:
+                    pass
     if zombie == 0:
         return await wait.edit_text("Group is clean!")
-    return await wait.edit_text(
-        text=f"<b>{zombie}</b> Zombies found and has been banned!",
-    )
-
+    await wait.delete()
+    txt=f"<b>{zombie}</b> Zombies found and {zombie - failed} has been banned!\n{failed} zombies' are immune to me",
+    await m.reply_animation("https://graph.org/file/02a1dcf7788186ffb36cb.mp4", caption=txt)
+    return
 
 @Gojo.on_message(command("admincache"))
 async def reload_admins(_, m: Message):
@@ -110,6 +111,7 @@ async def reload_admins(_, m: Message):
         return await m.reply_text(
             "This command is made to be used in groups only!",
         )
+    SUPPORT_STAFF = DEV_USERS.union(SUDO_USERS).union(WHITELIST_USERS)
     if (
         (m.chat.id in set(TEMP_ADMIN_CACHE_BLOCK.keys()))
         and (m.from_user.id not in SUPPORT_STAFF)
@@ -121,7 +123,6 @@ async def reload_admins(_, m: Message):
         await admin_cache_reload(m, "admincache")
         TEMP_ADMIN_CACHE_BLOCK[m.chat.id] = "manualblock"
         await m.reply_text(text="Reloaded all admins in this chat!")
-        LOGGER.info(f"Admincache cmd use in {m.chat.id} by {m.from_user.id}")
     except RPCError as ef:
         await m.reply_text(
             text=f"Some error occured, report it using `/bug` \n <b>Error:</b> <code>{ef}</code>"
@@ -164,8 +165,8 @@ async def fullpromote_usr(c: Gojo, m: Message):
         user_id, user_first_name, user_name = await extract_user(c, m)
     except Exception:
         return
-    bot = await c.get_chat_member(m.chat.id, Config.BOT_ID)
-    if user_id == Config.BOT_ID:
+    bot = await c.get_chat_member(m.chat.id, c.me.id)
+    if user_id == c.me.id:
         await m.reply_text("Huh, how can I even promote myself?")
         return
     if not bot.privileges.can_promote_members:
@@ -205,9 +206,6 @@ async def fullpromote_usr(c: Gojo, m: Message):
             except Exception as e:
                 LOGGER.error(e)
                 LOGGER.error(format_exc())
-        LOGGER.info(
-            f"{m.from_user.id} fullpromoted {user_id} in {m.chat.id} with title '{title}'",
-        )
         await m.reply_text(
             (
                 "{promoter} promoted {promoted} in chat <b>{chat_title}</b> with full rights!"
@@ -260,8 +258,8 @@ async def promote_usr(c: Gojo, m: Message):
         user_id, user_first_name, user_name = await extract_user(c, m)
     except Exception:
         return
-    bot = await c.get_chat_member(m.chat.id, Config.BOT_ID)
-    if user_id == Config.BOT_ID:
+    bot = await c.get_chat_member(m.chat.id, c.me.id)
+    if user_id == c.me.id:
         await m.reply_text("Huh, how can I even promote myself?")
         return
     if not bot.privileges.can_promote_members:
@@ -291,6 +289,8 @@ async def promote_usr(c: Gojo, m: Message):
                 can_pin_messages=bot.privileges.can_pin_messages,
                 can_manage_chat=bot.privileges.can_manage_chat,
                 can_manage_video_chats=bot.privileges.can_manage_video_chats,
+                can_post_messages=bot.privileges.can_post_messages,
+                can_edit_messages=bot.privileges.can_edit_messages
             ),
         )
         title = ""
@@ -308,9 +308,7 @@ async def promote_usr(c: Gojo, m: Message):
             except Exception as e:
                 LOGGER.error(e)
                 LOGGER.error(format_exc())
-        LOGGER.info(
-            f"{m.from_user.id} promoted {user_id} in {m.chat.id} with title '{title}'",
-        )
+        
         await m.reply_text(
             ("{promoter} promoted {promoted} in chat <b>{chat_title}</b>!").format(
                 promoter=(await mention_html(m.from_user.first_name, m.from_user.id)),
@@ -359,7 +357,7 @@ async def demote_usr(c: Gojo, m: Message):
         user_id, user_first_name, _ = await extract_user(c, m)
     except Exception:
         return
-    if user_id == Config.BOT_ID:
+    if user_id == c.me.id:
         await m.reply_text("Get an admin to demote me!")
         return
     # If user not already admin
@@ -379,7 +377,6 @@ async def demote_usr(c: Gojo, m: Message):
             user_id=user_id,
             privileges=ChatPrivileges(can_manage_chat=False),
         )
-        LOGGER.info(f"{m.from_user.id} demoted {user_id} in {m.chat.id}")
         # ----- Remove admin from cache -----
         try:
             admin_list = ADMIN_CACHE[m.chat.id]
@@ -408,6 +405,8 @@ async def demote_usr(c: Gojo, m: Message):
         await m.reply_text(
             "Cannot act on this user, maybe I wasn't the one who changed their permissions."
         )
+    except BotChannelsNa:
+        await m.reply_text("May be the user is bot and due to telegram restrictions I can't demote them. Please do it manually")
     except RPCError as ef:
         await m.reply_text(
             f"Some error occured, report it using `/bug` \n <b>Error:</b> <code>{ef}</code>"
@@ -420,6 +419,8 @@ async def demote_usr(c: Gojo, m: Message):
 @Gojo.on_message(command("invitelink"))
 async def get_invitelink(c: Gojo, m: Message):
     # Bypass the bot devs, sudos and owner
+    
+    DEV_LEVEL = DEV_USERS
     if m.from_user.id not in DEV_LEVEL:
         user = await m.chat.get_member(m.from_user.id)
         if not user.privileges.can_invite_users and user.status != CMS.OWNER:
@@ -431,7 +432,6 @@ async def get_invitelink(c: Gojo, m: Message):
             text=f"Invite Link for Chat <b>{m.chat.id}</b>: {link}",
             disable_web_page_preview=True,
         )
-        LOGGER.info(f"{m.from_user.id} exported invite link in {m.chat.id}")
     except ChatAdminRequired:
         await m.reply_text(text="I'm not admin or I don't have rights.")
     except ChatAdminInviteRequired:
@@ -508,7 +508,7 @@ async def set_user_title(c: Gojo, m: Message):
         return
     if not user_id:
         return await m.reply_text("Cannot find user!")
-    if user_id == Config.BOT_ID:
+    if user_id == c.me.id:
         return await m.reply_text("Huh, why ?")
     if not reason:
         return await m.reply_text("Read /help please!")

Powers/plugins/afk.py

@@ -0,0 +1,158 @@
+from datetime import datetime
+from random import choice
+
+from pyrogram import ContinuePropagation, filters
+from pyrogram.enums import ParseMode as PM
+from pyrogram.types import Message
+
+from Powers.bot_class import Gojo
+from Powers.database.afk_db import AFK
+from Powers.plugins import till_date
+from Powers.utils.cmd_senders import send_cmd
+from Powers.utils.custom_filters import afk_filter, command
+from Powers.utils.msg_types import Types, get_afk_type
+
+res = [
+    "{first} is resting for a while...",
+    "{first} living his real life, go and live yours.",
+    "{first} is quite busy now-a-days.",
+    "I am looking for {first} too...tell me if you see him/her around",
+    "{first} ran away from the chat...",
+    "{first} is busy in his/her work ||simping||",
+    "{first} is busy saving the world",
+    "{first} is now tired fighting all the curses"
+]
+
+back = [
+    "{first} is finally back to life",
+    "{first} welcome back",
+    "{first} the spy is back watch what you talk about"
+    "{first} is now finally back from the dead"
+]
+
+@Gojo.on_message(command(["afk","brb"]) & ~filters.private)
+async def going_afk(c: Gojo, m: Message):
+    user = m.from_user.id
+    chat = m.chat.id
+    afk = AFK()
+    text, data_type, content = await get_afk_type(m)
+    
+    time = str(datetime.now()).rsplit(".",1)[0]
+
+    if len(m.command) == 1:
+        text = choice(res)
+
+    elif len(m.command) > 1:
+        text = m.text.markdown.split(None,1)[1]
+
+    if not data_type:
+        data_type = Types.TEXT
+
+    afk.insert_afk(chat,user,str(time),text,data_type,content)
+
+    await m.reply_text(f"{m.from_user.mention} is now AFK")
+
+    return
+
+async def get_hours(hour:str):
+    tim = hour.strip().split(":")
+    txt = ""
+    if int(tim[0]):
+        txt += tim[0] + " hours "
+    if int(tim[1]):
+        txt += tim[1] + " minutes "
+    if int(round(float(tim[2]))):
+        txt += str(round(float(tim[2]))) + " seconds"
+    
+    return txt
+
+
+@Gojo.on_message(afk_filter & filters.group, 10000)
+async def afk_checker(c: Gojo, m: Message):
+    afk = AFK()
+    back_ = choice(back)
+    user = m.from_user.id
+    chat = m.chat.id
+    repl = m.reply_to_message
+    
+    if repl and repl.from_user:
+        rep_user = repl.from_user.id
+    else:
+        rep_user = False
+
+    is_afk = afk.check_afk(chat,user)
+    is_rep_afk = False
+    if rep_user:
+        is_rep_afk = afk.check_afk(chat,rep_user)
+
+    if is_rep_afk and rep_user != user:
+        con = afk.get_afk(chat,rep_user)
+        time = till_date(con["time"])
+        media = con["media"]
+        media_type = con["media_type"]
+        tim_ = datetime.now() - time
+        tim_ = str(tim_).split(",")
+        tim = await get_hours(tim_[-1])
+        if len(tim_) == 1:
+            tims = tim
+        elif len(tim_) == 2:
+            tims = tim_[0] + " " + tim
+        reason = f"{repl.from_user.first_name} is afk since {tims}\n"
+        if con['reason'] not in res:
+            reason += f"\nDue to: {con['reason'].format(first=repl.from_user.first_name)}"
+        else:
+            reason += f"\n{con['reason'].format(first=repl.from_user.first_name)}"
+        txt = reason
+
+        if media_type == Types.TEXT:        
+            await (await send_cmd(c,media_type))(
+                chat,
+                txt,
+                parse_mode=PM.MARKDOWN,
+                reply_to_message_id=m.id,
+            )
+        else:
+            await (await send_cmd(c,media_type))(
+                chat,
+                media,
+                txt,
+                parse_mode=PM.MARKDOWN,
+                reply_to_message_id=repl.id
+            )
+    
+    if is_afk:
+        txt = False
+        try:
+            txt = m.command[0]
+        except Exception:
+            pass
+
+        if txt and txt in ["afk","brb"]:
+            raise ContinuePropagation
+        else:
+            con = afk.get_afk(chat,user)
+            time = till_date(con["time"])
+            tim_ = datetime.now() - time
+            tim_ = str(tim_).split(",")
+            tim = await get_hours(tim_[-1])
+            if len(tim_) == 1:
+                tims = tim
+            elif len(tim_) == 2:
+                tims = tim_[0] + " " + tim
+            txt = back_.format(first=m.from_user.mention) + f"\n\nAfk for: {tims}"
+            await m.reply_text(txt)
+        afk.delete_afk(chat,user)
+    raise ContinuePropagation
+
+__PLUGIN__ = "afk"
+
+_DISABLE_CMDS_ = ["afk","brb"]
+
+__alt_name__ = ["brb"]
+
+__HELP__ = """
+**AFK**
+• /afk (/brb) [reason | reply to a message]
+
+`reply to a message` can be any media or text
+"""

Powers/plugins/antispam.py

@@ -5,20 +5,18 @@ from traceback import format_exc
 from pyrogram.errors import MessageTooLong, PeerIdInvalid, UserIsBlocked
 from pyrogram.types import Message
 
-from Powers import LOGGER, MESSAGE_DUMP, SUPPORT_GROUP, TIME_ZONE
+from Powers import (DEV_USERS, LOGGER, MESSAGE_DUMP, SUDO_USERS, SUPPORT_GROUP,
+                    WHITELIST_USERS)
 from Powers.bot_class import Gojo
 from Powers.database.antispam_db import GBan
 from Powers.database.users_db import Users
-from Powers.supports import get_support_staff
 from Powers.utils.clean_file import remove_markdown_and_html
 from Powers.utils.custom_filters import command
 from Powers.utils.extract_user import extract_user
 from Powers.utils.parser import mention_html
-from Powers.vars import Config
 
 # Initialize
 db = GBan()
-SUPPORT_STAFF = get_support_staff()
 
 @Gojo.on_message(command(["gban", "globalban"], sudo_cmd=True))
 async def gban(c: Gojo, m: Message):
@@ -39,11 +37,13 @@ async def gban(c: Gojo, m: Message):
     else:
         gban_reason = m.text.split(None, 2)[2]
 
+    SUPPORT_STAFF = DEV_USERS.union(SUDO_USERS).union(WHITELIST_USERS)
+
     if user_id in SUPPORT_STAFF:
         await m.reply_text(text="This user is part of my Support!, Can't ban our own!")
         return
 
-    if user_id == Config.BOT_ID:
+    if user_id == c.me.id:
         await m.reply_text(
             text="You don't dare use that command on me again nigga! \n Go straight and fuck your self......"
         )
@@ -60,7 +60,6 @@ async def gban(c: Gojo, m: Message):
             f"Added {user_first_name} to GBan List. \n They will now be banned in all groups where I'm admin!"
         )
     )
-    LOGGER.info(f"{m.from_user.id} gbanned {user_id} from {m.chat.id}")
     date = datetime.utcnow().strftime("%H:%M - %d-%m-%Y")
     log_msg = f"#GBAN \n <b>Originated from:</b> {m.chat.id} \n <b>Admin:</b> {await mention_html(m.from_user.first_name, m.from_user.id)} \n <b>Gbanned User:</b> {await mention_html(user_first_name, user_id)} \n <b>Gbanned User ID:</b> {user_id} \\ n<b>Event Stamp:</b> {date}"
     await c.send_message(MESSAGE_DUMP, log_msg)
@@ -70,6 +69,10 @@ async def gban(c: Gojo, m: Message):
             user_id,
             f"You have been added to my global ban list! \n <b>Reason:</b> <code>{gban_reason}</code> \n <b>Appeal Chat:</b> @{SUPPORT_GROUP}",
         )
+        try:
+            await c.ban_chat_member(m.chat.id, user_id)
+        except Exception as e:
+            await m.reply_text(f"Failed to ban this user\n{e}")    
     except UserIsBlocked:
         LOGGER.error("Could not send PM Message, user blocked bot")
     except PeerIdInvalid:
@@ -92,11 +95,13 @@ async def ungban(c: Gojo, m: Message):
 
     user_id, user_first_name, _ = await extract_user(c, m)
 
+    SUPPORT_STAFF = DEV_USERS.union(SUDO_USERS).union(WHITELIST_USERS)
+
     if user_id in SUPPORT_STAFF:
         await m.reply_text(text="This user is part of my Support!, Can't ban our own!")
         return
 
-    if user_id == Config.BOT_ID:
+    if user_id == c.me.id:
         await m.reply_text(
             text="""You can't gban me nigga!
         Fuck yourself.......!"""
@@ -107,7 +112,6 @@ async def ungban(c: Gojo, m: Message):
         db.remove_gban(user_id)
         await m.reply_text(text=f"Removed {user_first_name} from Global Ban List.")
         time = ((datetime.utcnow().strftime("%H:%M - %d-%m-%Y")),)
-        LOGGER.info(f"{m.from_user.id} ungbanned {user_id} from {m.chat.id}")
         log_msg = f"""#UNGBAN
         <b>Originated from:</b> {m.chat.id}
         <b>Admin:</b> {(await mention_html(m.from_user.first_name, m.from_user.id))}
@@ -137,7 +141,6 @@ async def gban_count(_, m: Message):
     await m.reply_text(
         text=f"Number of people gbanned: <code>{(db.count_gbans())}</code>"
     )
-    LOGGER.info(f"{m.from_user.id} counting gbans in {m.chat.id}")
     return
 
 
@@ -153,7 +156,8 @@ async def gban_list(_, m: Message):
 
     banfile = "Here are all the globally banned geys!\n\n"
     for user in banned_users:
-        banfile += f"[x] <b>{Users.get_user_info(user['_id'])['name']}</b> - <code>{user['_id']}</code>\n"
+        USER = Users.get_user_info(user['_id'])
+        banfile += f"[x] <b>{USER['name'] if USER else 'Name NA'}</b> - <code>{user['_id']}</code>\n"
         if user["reason"]:
             banfile += f"<b>Reason:</b> {user['reason']}\n"
 
@@ -166,6 +170,20 @@ async def gban_list(_, m: Message):
                 document=f, caption="Here are all the globally banned geys!\n\n"
             )
 
-    LOGGER.info(f"{m.from_user.id} exported gbanlist in {m.chat.id}")
 
     return
+
+__PLUGIN__ = "global"
+
+__alt_name__ = ["antispam", "global"]
+
+
+__HELP__ = """
+**Global**
+
+**Sudo commands:**
+• /gban [reply to user | user id | username]: Add the user in the global ban watchlist.
+• /ungban [reply to user | user id | username]: Remove the user from the global ban watchlist.
+• /numgbans : Give number of users who are banned globally.
+• /gbanlist : Give list of globally banned users.
+"""

Powers/plugins/approve.py

@@ -51,7 +51,6 @@ async def approve_user(c: Gojo, m: Message):
         )
         return
     db.add_approve(user_id, user_first_name)
-    LOGGER.info(f"{user_id} approved by {m.from_user.id} in {m.chat.id}")
 
     # Allow all permissions
     try:
@@ -90,7 +89,6 @@ async def disapprove_user(c: Gojo, m: Message):
     except UserNotParticipant:
         if already_approved:  # If user is approved and not in chat, unapprove them.
             db.remove_approve(user_id)
-            LOGGER.info(f"{user_id} disapproved in {m.chat.id} as UserNotParticipant")
         await m.reply_text("This user is not in this chat, unapproved them.")
         return
     except RPCError as ef:
@@ -110,7 +108,6 @@ async def disapprove_user(c: Gojo, m: Message):
         return
 
     db.remove_approve(user_id)
-    LOGGER.info(f"{user_id} disapproved by {m.from_user.id} in {m.chat.id}")
 
     # Set permission same as of current user by fetching them from chat!
     await m.chat.restrict_member(
@@ -147,7 +144,6 @@ async def check_approved(_, m: Message):
             pass
         msg += f"- `{user_id}`: {user_name}\n"
     await m.reply_text(msg)
-    LOGGER.info(f"{m.from_user.id} checking approved users in {m.chat.id}")
     return
 
 
@@ -160,7 +156,6 @@ async def check_approval(c: Gojo, m: Message):
     except Exception:
         return
     check_approve = db.check_approve(user_id)
-    LOGGER.info(f"{m.from_user.id} checking approval of {user_id} in {m.chat.id}")
 
     if not user_id:
         await m.reply_text(
@@ -218,7 +213,6 @@ async def unapproveall_callback(_, q: CallbackQuery):
             permissions=q.message.chat.permissions,
         )
     await q.message.delete()
-    LOGGER.info(f"{user_id} disapproved all users in {q.message.chat.id}")
     await q.answer("Disapproved all users!", show_alert=True)
     return
 

Powers/plugins/auto_join.py

@@ -0,0 +1,185 @@
+from traceback import format_exc
+
+from pyrogram import filters
+from pyrogram.enums import ChatMemberStatus as CMS
+from pyrogram.types import CallbackQuery, ChatJoinRequest
+from pyrogram.types import InlineKeyboardButton as ikb
+from pyrogram.types import InlineKeyboardMarkup as ikm
+from pyrogram.types import Message
+
+from Powers import DEV_USERS, LOGGER, SUDO_USERS, WHITELIST_USERS
+from Powers.bot_class import Gojo
+from Powers.database.autojoin_db import AUTOJOIN
+from Powers.utils.custom_filters import admin_filter, auto_join_filter, command
+
+
+@Gojo.on_message(command(["joinreq"]) & admin_filter)
+async def accept_join_requests(c: Gojo, m: Message):
+    if m.chat.id == m.from_user.id:
+        await m.reply_text("Use it in groups")
+        return
+
+    split = m.command
+    a_j = AUTOJOIN()
+
+    try:
+        status = (await m.chat.get_member(c.me.id)).status
+        if status != CMS.ADMINISTRATOR:
+            await m.reply_text("I should be admin to accept and reject join requests")
+            return
+    except Exception as ef:
+        await m.reply_text(f"Some error occured, report it using `/bug`\n<b>Error:</b> <code>{ef}</code>")
+        LOGGER.error(ef)
+        LOGGER.error(format_exc())
+        return
+    if len(split) == 1:
+        txt = "**USAGE**\n/joinreq [on | off]"
+        await m.reply_text(txt)
+        return
+    else:
+        yes_no = split[1].lower()
+        if yes_no not in ["on","off"]:
+            txt = "**USAGE**\n/joinreq [on | off]"
+            await m.reply_text(txt)
+            return
+        
+        else:
+            if yes_no == "on":
+                is_al = a_j.load_autojoin(m.chat.id)
+                
+                if is_al:
+                    txt = "Now I will approve all the join request of the chat\nIf you want that I will just notify admins about the join request use command\n/joinreqmode [manual | auto]"
+                    await m.reply_text(txt)
+                    return
+                else:
+                    txt = "Auto approve join request is already on for this chat\nIf you want that I will just notify admins about the join request use command\n/joinreqmode [manual | auto]"
+                    await m.reply_text(txt)
+                    return
+
+            elif yes_no == "off":
+                a_j.remove_autojoin(m.chat.id)
+                txt = "Now I will neither auto approve join request nor notify any admins about it"
+                await m.reply_text(txt)
+                return
+
+@Gojo.on_message(command("joinreqmode") & admin_filter)
+async def join_request_mode(c: Gojo, m: Message):
+    if m.chat.id == m.from_user.id:
+        await m.reply_text("Use it in groups")
+        return
+    u_text = "**USAGE**\n/joinreqmode [auto | manual]\nauto: auto approve joins\nmanual: will notify admin about the join request"
+        
+    split = m.command
+    a_j = AUTOJOIN()
+        
+    if len(split) == 1:
+        await m.reply_text(u_text)
+        return
+
+    else:
+        auto_manual = split[1]
+        if auto_manual not in ["auto","manual"]:
+            await m.reply_text(u_text)
+            return
+        else:
+            a_j.update_join_type(m.chat.id,auto_manual)
+            txt = "Changed join request type"
+            await m.reply_text(txt)
+            return
+
+
+@Gojo.on_chat_join_request(auto_join_filter)
+async def join_request_handler(c: Gojo, j: ChatJoinRequest):
+    user = j.from_user.id
+    userr = j.from_user
+    chat = j.chat.id
+    aj = AUTOJOIN()
+    join_type = aj.get_autojoin(chat)
+    SUPPORT_STAFF = DEV_USERS.union(SUDO_USERS).union(WHITELIST_USERS)
+
+    if not join_type:
+        return
+    if join_type == "auto" or user in SUPPORT_STAFF:
+        try:
+            await c.approve_chat_join_request(chat,user)
+            await c.send_message(chat, f"Accepted join request of the {userr.mention}")
+            return
+        except Exception as ef:
+            await c.send_message(chat,f"Some error occured while approving request, report it using `/bug`\n<b>Error:</b> <code>{ef}</code>")
+            LOGGER.error(ef)
+            LOGGER.error(format_exc())
+            return
+    elif join_type == "manual":
+        txt = "New join request is available\n**USER's INFO**\n"
+        txt += f"Name: {userr.full_name}"
+        txt += f"Mention: {userr.mention}"
+        txt += f"Id: {user}"
+        txt += f"Scam: {'True' if  userr.is_scam else 'False'}"
+        if userr.username:
+            txt+= f"Username: @{userr.username}"
+        kb = [
+            [
+                ikb("Accept",f"accept_joinreq_uest_{user}"),
+                ikb("Decline",f"decline_joinreq_uest_{user}")
+            ]
+        ]
+        await c.send_message(chat,txt,reply_markup=ikm(kb))
+        return
+
+@Gojo.on_callback_query(filters.regex("^accept_joinreq_uest_") | filters.regex("^decline_joinreq_uest_"))
+async def accept_decline_request(c:Gojo, q: CallbackQuery):
+    user_id = q.from_user.id
+    chat = q.message.chat.id
+    try:
+        user_status = (await q.message.chat.get_member(user_id)).status
+        if user_status not in {CMS.OWNER, CMS.ADMINISTRATOR}:
+            await q.answer(
+                "You're not even an admin, don't try this explosive shit!",
+                show_alert=True,
+            )
+            return
+    except:
+        await q.answer("Unknow error occured. You are not admin or owner")
+        return
+    split = q.data.split("_")
+    chat = q.message.chat.id
+    user = int(split[-1])
+    data = split[0]
+    try:
+        userr = await c.get_users(user)
+    except:
+        userr = None
+    if data == "accept":
+        try:
+            await c.approve_chat_join_request(chat,user)
+            await q.answer(f"Accepted join request of the {userr.mention if userr else user}",True)
+            await q.edit_message_text(f"Accepted join request of the {userr.mention if userr else user}")
+        except Exception as ef:
+            await c.send_message(chat,f"Some error occured while approving request, report it using `/bug`\n<b>Error:</b> <code>{ef}</code>")
+            LOGGER.error(ef)
+            LOGGER.error(format_exc())
+            
+    elif data == "decline":
+        try:
+            await c.decline_chat_join_request(chat,user)
+            await q.answer(f"DECLINED: {user}")
+            await q.edit_message_text()
+        except Exception as ef:
+            await c.send_message(chat,f"Some error occured while approving request, report it using `/bug`\n<b>Error:</b> <code>{ef}</code>")
+            LOGGER.error(ef)
+            LOGGER.error(format_exc())
+
+    return
+
+__PLUGIN__ = "auto join"
+
+__alt_name__ = ["join_request"]
+
+
+__HELP__ = """
+**Auto join request**
+
+**Admin commands:**
+• /joinreq [on | off]: To switch on auto accept join request 
+• /joinreqmode [auto | manual]: `auto` to accept join request automatically and `manual` to get notified when new join request is available
+"""

Powers/plugins/bans.py

@@ -3,24 +3,22 @@ from traceback import format_exc
 
 from pyrogram import enums
 from pyrogram.errors import (ChatAdminRequired, PeerIdInvalid, RightForbidden,
-                             RPCError, UserAdminInvalid)
+                             RPCError, UserAdminInvalid, UserNotParticipant)
 from pyrogram.filters import regex
 from pyrogram.types import (CallbackQuery, ChatPrivileges,
                             InlineKeyboardButton, InlineKeyboardMarkup,
                             Message)
 
-from Powers import LOGGER, MESSAGE_DUMP, OWNER_ID
+from Powers import (DEV_USERS, LOGGER, MESSAGE_DUMP, OWNER_ID, SUDO_USERS,
+                    WHITELIST_USERS)
 from Powers.bot_class import Gojo
-from Powers.supports import get_support_staff
 from Powers.utils.caching import ADMIN_CACHE, admin_cache_reload
 from Powers.utils.custom_filters import command, restrict_filter
 from Powers.utils.extract_user import extract_user
 from Powers.utils.extras import BAN_GIFS, KICK_GIFS
 from Powers.utils.parser import mention_html
 from Powers.utils.string import extract_time
-from Powers.vars import Config
 
-SUPPORT_STAFF = get_support_staff()
 
 @Gojo.on_message(command("tban") & restrict_filter)
 async def tban_usr(c: Gojo, m: Message):
@@ -36,17 +34,17 @@ async def tban_usr(c: Gojo, m: Message):
     if not user_id:
         await m.reply_text("Cannot find user to ban")
         return
-    if user_id == Config.BOT_ID:
+    if user_id == c.me.id:
         await m.reply_text("WTF??  Why would I ban myself?")
         await m.stop_propagation()
 
+    SUPPORT_STAFF = DEV_USERS.union(SUDO_USERS).union(WHITELIST_USERS)
+
     if user_id in SUPPORT_STAFF:
         await m.reply_text(
             text="This user is in my support staff, cannot restrict them."
         )
-        LOGGER.info(
-            f"{m.from_user.id} trying to ban {user_id} (SUPPORT_STAFF) in {m.chat.id}",
-        )
+        
         await m.stop_propagation()
 
     r_id = m.reply_to_message.id if m.reply_to_message else m.id
@@ -85,7 +83,6 @@ async def tban_usr(c: Gojo, m: Message):
         admin = await mention_html(m.from_user.first_name, m.from_user.id)
         banned = await mention_html(user_first_name, user_id)
         chat_title = m.chat.title
-        LOGGER.info(f"{m.from_user.id} tbanned {user_id} in {m.chat.id}")
         await m.chat.ban_member(
             user_id,
             until_date=bantime)
@@ -137,6 +134,8 @@ async def tban_usr(c: Gojo, m: Message):
         await m.reply_text(
             text="Cannot act on this user, maybe I wasn't the one who changed their permissions."
         )
+    except UserNotParticipant:
+        await m.reply_text("User is not part of the group")
     except RightForbidden:
         await m.reply_text(text="I don't have enough rights to ban this user.")
     except RPCError as ef:
@@ -158,6 +157,8 @@ async def stban_usr(c: Gojo, m: Message):
         await m.reply_text(text="I can't ban nothing!")
         await m.stop_propagation()
 
+    SUPPORT_STAFF = DEV_USERS.union(SUDO_USERS).union(WHITELIST_USERS)
+
     try:
         user_id, _, _ = await extract_user(c, m)
     except Exception:
@@ -166,7 +167,7 @@ async def stban_usr(c: Gojo, m: Message):
     if not user_id:
         await m.reply_text("Cannot find user to ban")
         return
-    if user_id == Config.BOT_ID:
+    if user_id == c.me.id:
         await m.reply_text("What the heck? Why would I ban myself?")
         await m.stop_propagation()
 
@@ -174,9 +175,7 @@ async def stban_usr(c: Gojo, m: Message):
         await m.reply_text(
             text="This user is in my support staff, cannot restrict them."
         )
-        LOGGER.info(
-            f"{m.from_user.id} trying to ban {user_id} (SUPPORT_STAFF) in {m.chat.id}",
-        )
+        
         await m.stop_propagation()
 
     if m.reply_to_message and len(m.text.split()) >= 2:
@@ -210,7 +209,6 @@ async def stban_usr(c: Gojo, m: Message):
         await m.stop_propagation()
 
     try:
-        LOGGER.info(f"{m.from_user.id} stbanned {user_id} in {m.chat.id}")
         await m.chat.ban_member(user_id, until_date=bantime)
         await m.delete()
         if m.reply_to_message:
@@ -227,6 +225,8 @@ async def stban_usr(c: Gojo, m: Message):
         await m.reply_text(
             text="Cannot act on this user, maybe I wasn't the one who changed their permissions."
         )
+    except UserNotParticipant:
+        await m.reply_text("User is not part of the group")
     except RightForbidden:
         await m.reply_text(text="I don't have enough rights to ban this user.")
     except RPCError as ef:
@@ -258,15 +258,15 @@ async def dtban_usr(c: Gojo, m: Message):
     if not user_id:
         await m.reply_text("Cannot find user to ban")
         return
-    if user_id == Config.BOT_ID:
+    if user_id == c.me.id:
         await m.reply_text("Huh, why would I ban myself?")
         await m.stop_propagation()
 
+    SUPPORT_STAFF = DEV_USERS.union(SUDO_USERS).union(WHITELIST_USERS)
+
     if user_id in SUPPORT_STAFF:
         await m.reply_text(text="I am not going to ban one of my support staff")
-        LOGGER.info(
-            f"{m.from_user.id} trying to ban {user_id} (SUPPORT_STAFF) in {m.chat.id}",
-        )
+        
         await m.stop_propagation()
 
     if m.reply_to_message and len(m.text.split()) >= 2:
@@ -303,7 +303,6 @@ async def dtban_usr(c: Gojo, m: Message):
         admin = await mention_html(m.from_user.first_name, m.from_user.id)
         banned = await mention_html(user_first_name, user_id)
         chat_title = m.chat.title
-        LOGGER.info(f"{m.from_user.id} dtbanned {user_id} in {m.chat.id}")
         await m.chat.ban_member(user_id, until_date=bantime)
         await m.reply_to_message.delete()
         txt = f"{admin} banned {banned} in <b>{chat_title}</b>!"
@@ -386,17 +385,17 @@ async def kick_usr(c: Gojo, m: Message):
         await m.reply_text("Cannot find user to kick")
         return
 
-    if user_id == Config.BOT_ID:
+    if user_id == c.me.id:
         await m.reply_text("Huh, why would I kick myself?")
         await m.stop_propagation()
 
+    SUPPORT_STAFF = DEV_USERS.union(SUDO_USERS).union(WHITELIST_USERS)
+
     if user_id in SUPPORT_STAFF:
         await m.reply_text(
             text="This user is in my support staff, cannot restrict them."
         )
-        LOGGER.info(
-            f"{m.from_user.id} trying to kick {user_id} (SUPPORT_STAFF) in {m.chat.id}",
-        )
+        
         await m.stop_propagation()
 
     try:
@@ -412,7 +411,6 @@ async def kick_usr(c: Gojo, m: Message):
         admin = await mention_html(m.from_user.first_name, m.from_user.id)
         kicked = await mention_html(user_first_name, user_id)
         chat_title = m.chat.title
-        LOGGER.info(f"{m.from_user.id} kicked {user_id} in {m.chat.id}")
         await m.chat.ban_member(user_id)
         txt = f"{admin} kicked {kicked} in <b>{chat_title}</b>!"
         if reason:
@@ -444,6 +442,8 @@ async def kick_usr(c: Gojo, m: Message):
         await m.reply_text(
             text="Cannot act on this user, maybe I wasn't the one who changed their permissions."
         )
+    except UserNotParticipant:
+        await m.reply_text("User is not part of the group")
     except RightForbidden:
         await m.reply_text(text="I don't have enough rights to ban this user.")
     except RPCError as ef:
@@ -473,17 +473,17 @@ async def skick_usr(c: Gojo, m: Message):
         await m.reply_text("Cannot find user to kick")
         return
 
-    if user_id == Config.BOT_ID:
-        await m.reply_text("Huh, why would I kick myself?")
+    if user_id == c.me.id:
+        await m.reply_text("Nuh Hu, why would I kick myself?")
         await m.stop_propagation()
 
+    SUPPORT_STAFF = DEV_USERS.union(SUDO_USERS).union(WHITELIST_USERS)
+
     if user_id in SUPPORT_STAFF:
         await m.reply_text(
             text="This user is in my support staff, cannot restrict them."
         )
-        LOGGER.info(
-            f"{m.from_user.id} trying to skick {user_id} (SUPPORT_STAFF) in {m.chat.id}",
-        )
+        
         await m.stop_propagation()
 
     try:
@@ -496,7 +496,6 @@ async def skick_usr(c: Gojo, m: Message):
         await m.stop_propagation()
 
     try:
-        LOGGER.info(f"{m.from_user.id} skicked {user_id} in {m.chat.id}")
         await m.chat.ban_member(user_id)
         await m.delete()
         if m.reply_to_message:
@@ -512,6 +511,8 @@ async def skick_usr(c: Gojo, m: Message):
         await m.reply_text(
             text="Cannot act on this user, maybe I wasn't the one who changed their permissions."
         )
+    except UserNotParticipant:
+        await m.reply_text("User is not part of the group")
     except RightForbidden:
         await m.reply_text(text="I don't have enough rights to kick this user.")
     except RPCError as ef:
@@ -543,17 +544,17 @@ async def dkick_usr(c: Gojo, m: Message):
         await m.reply_text("Cannot find user to kick")
         return
 
-    if user_id == Config.BOT_ID:
+    if user_id == c.me.id:
         await m.reply_text("Huh, why would I kick myself?")
         await m.stop_propagation()
 
+    SUPPORT_STAFF = DEV_USERS.union(SUDO_USERS).union(WHITELIST_USERS)
+
     if user_id in SUPPORT_STAFF:
         await m.reply_text(
             text="This user is in my support staff, cannot restrict them."
         )
-        LOGGER.info(
-            f"{m.from_user.id} trying to dkick {user_id} (SUPPORT_STAFF) in {m.chat.id}",
-        )
+        
         await m.stop_propagation()
 
     try:
@@ -566,7 +567,6 @@ async def dkick_usr(c: Gojo, m: Message):
         await m.stop_propagation()
 
     try:
-        LOGGER.info(f"{m.from_user.id} dkicked {user_id} in {m.chat.id}")
         await m.reply_to_message.delete()
         await m.chat.ban_member(user_id)
         admin = await mention_html(m.from_user.first_name, m.from_user.id)
@@ -601,6 +601,8 @@ async def dkick_usr(c: Gojo, m: Message):
         )
     except RightForbidden:
         await m.reply_text(text="I don't have enough rights to kick this user.")
+    except UserNotParticipant:
+        await m.reply_text("User is not part of the group")
     except RPCError as ef:
         await m.reply_text(
             text=f"""Some error occured, report it using `/bug`
@@ -690,17 +692,16 @@ async def sban_usr(c: Gojo, m: Message):
     if user_id == m.chat.id:
         await m.reply_text("That's an admin!")
         await m.stop_propagation()
-    if user_id == Config.BOT_ID:
+    if user_id == c.me.id:
         await m.reply_text("Huh, why would I ban myself?")
         await m.stop_propagation()
 
+    SUPPORT_STAFF = DEV_USERS.union(SUDO_USERS).union(WHITELIST_USERS)
+
     if user_id in SUPPORT_STAFF:
         await m.reply_text(
             text="This user is in my support staff, cannot restrict them."
         )
-        LOGGER.info(
-            f"{m.from_user.id} trying to sban {user_id} (SUPPORT_STAFF) in {m.chat.id}",
-        )
         await m.stop_propagation()
 
     try:
@@ -713,7 +714,6 @@ async def sban_usr(c: Gojo, m: Message):
         await m.stop_propagation()
 
     try:
-        LOGGER.info(f"{m.from_user.id} sbanned {user_id} in {m.chat.id}")
         await m.chat.ban_member(user_id)
         await m.delete()
         if m.reply_to_message:
@@ -730,6 +730,8 @@ async def sban_usr(c: Gojo, m: Message):
         )
     except RightForbidden:
         await m.reply_text(text="I don't have enough rights to ban this user.")
+    except UserNotParticipant:
+        await m.reply_text("User is not part of the group")
     except RPCError as ef:
         await m.reply_text(
             text=f"""Some error occured, report it using `/bug`
@@ -767,17 +769,16 @@ async def dban_usr(c: Gojo, m: Message):
     if user_id == m.chat.id:
         await m.reply_text("That's an admin!")
         await m.stop_propagation()
-    if user_id == Config.BOT_ID:
+    if user_id == c.me.id:
         await m.reply_text("Huh, why would I ban myself?")
         await m.stop_propagation()
 
+    SUPPORT_STAFF = DEV_USERS.union(SUDO_USERS).union(WHITELIST_USERS)
+
     if user_id in SUPPORT_STAFF:
         await m.reply_text(
             text="This user is in my support staff, cannot restrict them."
         )
-        LOGGER.info(
-            f"{m.from_user.id} trying to dban {user_id} (SUPPORT_STAFF) in {m.chat.id}",
-        )
         await m.stop_propagation()
 
     try:
@@ -794,7 +795,6 @@ async def dban_usr(c: Gojo, m: Message):
         reason = m.text.split(None, 1)[1]
 
     try:
-        LOGGER.info(f"{m.from_user.id} dbanned {user_id} in {m.chat.id}")
         await m.reply_to_message.delete()
         await m.chat.ban_member(user_id)
         txt = f"{m.from_user.mention} banned {m.reply_to_message.from_user.mention} in <b>{m.chat.title}</b>!"
@@ -830,6 +830,8 @@ async def dban_usr(c: Gojo, m: Message):
         )
     except RightForbidden:
         await m.reply_text(text="I don't have enough rights to ban this user.")
+    except UserNotParticipant:
+        await m.reply_text("User is not part of the group")
     except RPCError as ef:
         await m.reply_text(
             text=f"""Some error occured, report it using `/bug`
@@ -864,17 +866,16 @@ async def ban_usr(c: Gojo, m: Message):
     if user_id == m.chat.id:
         await m.reply_text("That's an admin!")
         await m.stop_propagation()
-    if user_id == Config.BOT_ID:
+    if user_id == c.me.id:
         await m.reply_text("Huh, why would I ban myself?")
         await m.stop_propagation()
 
+    SUPPORT_STAFF = DEV_USERS.union(SUDO_USERS).union(WHITELIST_USERS)
+
     if user_id in SUPPORT_STAFF:
         await m.reply_text(
             text="This user is in my support staff, cannot restrict them."
         )
-        LOGGER.info(
-            f"{m.from_user.id} trying to ban {user_id} (SUPPORT_STAFF) in {m.chat.id}",
-        )
         await m.stop_propagation()
 
     try:
@@ -897,7 +898,6 @@ async def ban_usr(c: Gojo, m: Message):
             reason = m.text.split(None, 2)[2]
 
     try:
-        LOGGER.info(f"{m.from_user.id} banned {user_id} in {m.chat.id}")
         await m.chat.ban_member(user_id)
         banned = await mention_html(user_first_name, user_id)
         txt = f"{m.from_user.mention} banned {banned} in <b>{m.chat.title}</b>!"
@@ -938,6 +938,8 @@ async def ban_usr(c: Gojo, m: Message):
         await m.reply_text(
             "I have not seen this user yet...!\nMind forwarding one of their message so I can recognize them?",
         )
+    except UserNotParticipant:
+        await m.reply_text("User is not part of the group")
     except UserAdminInvalid:
         await m.reply_text(
             text="Cannot act on this user, maybe I wasn't the one who changed their permissions."
@@ -968,7 +970,7 @@ async def unbanbutton(c: Gojo, q: CallbackQuery):
         )
         return
 
-    if not user.privileges.can_restrict_members and q.from_user.id != OWNER_ID:
+    elif user and not user.privileges.can_restrict_members and q.from_user.id != OWNER_ID:
         await q.answer(
             "You don't have enough permission to do this!\nStay in your limits!",
             show_alert=True,
@@ -991,7 +993,6 @@ async def kickme(c: Gojo, m: Message):
     if len(m.text.split()) >= 2:
         reason = m.text.split(None, 1)[1]
     try:
-        LOGGER.info(f"{m.from_user.id} kickme used by {m.from_user.id} in {m.chat.id}")
         mem = await c.get_chat_member(m.chat.id,m.from_user.id)
         if mem.status in [enums.ChatMemberStatus.ADMINISTRATOR, enums.ChatMemberStatus.OWNER]:
             try:

Powers/plugins/birthday.py

@@ -125,7 +125,7 @@ async def who_is_next(c: Gojo, m: Message):
     if m.chat.type == ChatType.PRIVATE:
         await m.reply_text("Use it in group")
         return
-    curr = datetime.now(TIME_ZONE).date()
+    curr = datetime.now().date()
     xx = await m.reply_text("📆")
     users = []
     if blist:
@@ -147,8 +147,8 @@ async def who_is_next(c: Gojo, m: Message):
     for i in users:
         DOB = give_date(i["dob"])
         dete = date(curr.year, DOB.month, DOB.day)
-        leff = (dete - curr).days
-        txt += f"`{i['user_id']}` : {leff} days left"
+        leff = (dete - curr).days 
+        txt += f"`{i['user_id']}` : {leff} days left\n"
     txt += "\n\nYou can use /info [user id] to get info about the user"
     await xx.delete()
     await m.reply_text(txt)
@@ -173,22 +173,24 @@ async def cant_recall_it(c: Gojo, m: Message):
         await m.reply_text(f"Got an error\n{e}")
         return
     
-    curr = datetime.now(TIME_ZONE).date() 
+    curr = datetime.now().date() 
     u_dob = give_date(result["dob"])
     formatted = str(u_dob.strftime('%d' + '%B %Y'))[2:-5]
     day = int(result["dob"].split('/')[0])
-    suffix = {1: 'st', 2: 'nd', 3: 'rd'}.get(day if day < 20 else day % 10, 'th')
+    suffix = {1: 'st', 2: 'nd', 3: 'rd'}.get(day % 10, 'th')
     bday_on = f"{day}{suffix} {formatted}"
-    if u_dob.month < curr.month:
+    if (u_dob.day,u_dob.month) < (curr.day,curr.month):
         next_b = date(curr.year + 1, u_dob.month, u_dob.day)
         days_left = (next_b - curr).days
-        txt = f"{men} 's birthday is passed 🫤\nDays left until next one {days_left}"
+        txt = f"{men} 's birthday is passed 🫤\nDays left until next one {abs(days_left)}"
         txt += f"\nBirthday on: {bday_on}"
         txt += f"\n\nDate of birth: {result['dob']}"
+    elif (u_dob.day,u_dob.month) == (curr.day,curr.month):
+        txt = f"Today is {men}'s birthday."
     else:
         u_dobm = date(curr.year, u_dob.month, u_dob.day)
         days_left = (u_dobm - curr).days
-        txt = f"User's birthday is coming🥳\nDays left : {days_left}"
+        txt = f"User's birthday is coming🥳\nDays left: {abs(days_left)}"
         txt += f"\nBirthday on: {bday_on}"
         txt += f"\n\nDate of birth: {result['dob']}"
     txt+= "\n\n**NOTE**:\nDOB may be wrong if user haven't entered his/her birth year"
@@ -216,7 +218,7 @@ async def chat_birthday_settings(c: Gojo, m: Message):
     await m.reply_text("Do you want to wish members for their birthday in the group?",reply_markup=kb)
     return
 
-@Gojo.on_callback_query(filters.regex("^switchh_"))
+@Gojo.on_callback_query(filters.regex(r"^switchh_(yes|no)$"))
 async def switch_on_off(c:Gojo, q: CallbackQuery):
     user = (await q.message.chat.get_member(q.from_user.id)).status
     await q.message.chat.get_member(q.from_user.id)
@@ -225,11 +227,11 @@ async def switch_on_off(c:Gojo, q: CallbackQuery):
         return
     data = q.data.split("_")[1]
     chats = q.message.chat.id
-    xXx = {"chat_id":chats}
+    query = {"chat_id":chats}
     if data == "yes":
-        bday_cinfo.delete_one(xXx)
+        bday_cinfo.delete_one(query)
     elif data == "no":
-        bday_cinfo.insert_one(xXx)
+        bday_cinfo.insert_one(query)
     await q.edit_message_text(f"Done! I will {'wish' if data == 'yes' else 'not wish'}",reply_markup=IKM([[IKB("Close", "f_close")]]))
     return
 

Powers/plugins/blacklist.py

@@ -15,8 +15,6 @@ from Powers.utils.kbhelpers import ikb
 async def view_blacklist(_, m: Message):
     db = Blacklist(m.chat.id)
 
-    LOGGER.info(f"{m.from_user.id} checking blacklists in {m.chat.id}")
-
     chat_title = m.chat.title
     blacklists_chat = f"Current Blacklisted words in <b>{chat_title}</b>:\n\n"
     all_blacklisted = db.get_blacklists()
@@ -58,7 +56,6 @@ async def add_blacklist(_, m: Message):
             ", ".join([f"<code>{i}</code>" for i in bl_words])
             + " already added in blacklist, skipped them!"
         )
-    LOGGER.info(f"{m.from_user.id} added new blacklists ({bl_words}) in {m.chat.id}")
     trigger = ", ".join(f"<code>{i}</code>" for i in bl_words)
     await m.reply_text(
         text=f"Added <code>{trigger}</code> in blacklist words!"
@@ -116,7 +113,6 @@ async def rm_blacklist(_, m: Message):
             "Could not find " + ", ".join(f"<code>{i}</code>" for i in non_found_words)
         ) + " in blcklisted words, skipped them."
 
-    LOGGER.info(f"{m.from_user.id} removed blacklists ({bl_words}) in {m.chat.id}")
     bl_words = ", ".join(f"<code>{i}</code>" for i in bl_words)
     await m.reply_text(
         text=f"Removed <b>{bl_words}</b> from blacklist words!"
@@ -145,13 +141,9 @@ async def set_bl_action(_, m: Message):
 
             return
         db.set_action(action)
-        LOGGER.info(
-            f"{m.from_user.id} set blacklist action to '{action}' in {m.chat.id}",
-        )
         await m.reply_text(text=f"Set action for blacklist for this to <b>{action}</b>")
     elif len(m.text.split()) == 1:
         action = db.get_action()
-        LOGGER.info(f"{m.from_user.id} checking blacklist action in {m.chat.id}")
         await m.reply_text(
             text=f"""The current action for blacklists in this chat is <i><b>{action}</b></i>
       All blacklist modes delete the message containing blacklist word."""
@@ -201,7 +193,6 @@ async def rm_allbl_callback(_, q: CallbackQuery):
         return
     db.rm_all_blacklist()
     await q.message.delete()
-    LOGGER.info(f"{user_id} removed all blacklists in {q.message.chat.id}")
     await q.answer("Cleared all Blacklists!", show_alert=True)
     return
 

Powers/plugins/botstaff.py

@@ -1,57 +0,0 @@
-from pyrogram.errors import RPCError
-from pyrogram.types import Message
-
-from Powers import LOGGER, OWNER_ID, WHITELIST_USERS
-from Powers.bot_class import Gojo
-from Powers.supports import get_support_staff
-from Powers.utils.custom_filters import command
-from Powers.utils.parser import mention_html
-
-DEV_USERS = get_support_staff("dev")
-SUDO_USERS = get_support_staff("sudo")
-
-@Gojo.on_message(command("botstaff", dev_cmd=True))
-async def botstaff(c: Gojo, m: Message):
-    try:
-        owner = await c.get_users(OWNER_ID)
-        reply = f"<b>🌟 Owner:</b> {(await mention_html(owner.first_name, OWNER_ID))} (<code>{OWNER_ID}</code>)\n"
-    except RPCError:
-        pass
-    true_dev = list(set(DEV_USERS) - {OWNER_ID})
-    reply += "\n<b>Developers ⚡️:</b>\n"
-    if not true_dev:
-        reply += "No Dev Users\n"
-    else:
-        for each_user in true_dev:
-            user_id = int(each_user)
-            try:
-                user = await c.get_users(user_id)
-                reply += f"• {(await mention_html(user.first_name, user_id))} (<code>{user_id}</code>)\n"
-            except RPCError:
-                pass
-    true_sudo = list(set(SUDO_USERS) - set(DEV_USERS))
-    reply += "\n<b>Sudo Users 🐉:</b>\n"
-    if true_sudo == []:
-        reply += "No Sudo Users\n"
-    else:
-        for each_user in true_sudo:
-            user_id = int(each_user)
-            try:
-                user = await c.get_users(user_id)
-                reply += f"• {(await mention_html(user.first_name, user_id))} (<code>{user_id}</code>)\n"
-            except RPCError:
-                pass
-    reply += "\n<b>Whitelisted Users 🐺:</b>\n"
-    if WHITELIST_USERS == []:
-        reply += "No additional whitelisted users\n"
-    else:
-        for each_user in WHITELIST_USERS:
-            user_id = int(each_user)
-            try:
-                user = await c.get_users(user_id)
-                reply += f"• {(await mention_html(user.first_name, user_id))} (<code>{user_id}</code>)\n"
-            except RPCError:
-                pass
-    await m.reply_text(reply)
-    LOGGER.info(f"{m.from_user.id} fetched botstaff in {m.chat.id}")
-    return

Powers/plugins/captcha.py

@@ -0,0 +1,269 @@
+import os
+from random import choice, shuffle
+from traceback import format_exc
+from typing import List
+
+import pyrogram
+from pyrogram import filters
+from pyrogram.enums import ChatMemberStatus as CMS
+from pyrogram.enums import ParseMode as PM
+from pyrogram.types import CallbackQuery, ChatPermissions
+from pyrogram.types import InlineKeyboardButton as IKB
+from pyrogram.types import InlineKeyboardMarkup as ikm
+from pyrogram.types import Message, User
+
+from Powers import DEV_USERS, LOGGER, MESSAGE_DUMP, SUDO_USERS, WHITELIST_USERS
+from Powers.bot_class import Gojo
+from Powers.database.captcha_db import CAPTCHA, CAPTCHA_DATA
+from Powers.utils.captcha_helper import (genrator, get_image_captcha,
+                                         get_qr_captcha)
+from Powers.utils.custom_filters import admin_filter, captcha_filter, command
+from Powers.utils.extras import BAN_GIFS
+
+
+@Gojo.on_message(command("captcha") & admin_filter & ~filters.private)
+async def start_captcha(_, m: Message):
+    captcha = CAPTCHA()
+    split = m.command
+    if len(split) == 1:
+        is_cap = captcha.is_captcha(m.chat.id)
+        if is_cap:
+            txt = "Captcha verification is currently **on** for this chat"
+        else:
+            txt = "Captcha verification is currently **off** for this chat"
+        await m.reply_text(txt)
+        return
+    else:
+        on_off = split[1].lower()
+        if on_off in ["on", "yes", "enable"]:
+            captcha.insert_captcha(m.chat.id)
+            await m.reply_text("Captcha verification is now **on** for this chat")
+            return
+        elif on_off in ["off", "no", "disable"]:
+            captcha.remove_captcha(m.chat.id)
+            await m.reply_text("Captcha verification is now **off** for this chat")
+            return
+        else:
+            await m.reply_text("**USAGE**\n/captcha [on | yes | enable | off | no | disable]")
+            return
+
+
+@Gojo.on_message(command("captchamode") & admin_filter & ~filters.private)
+async def set_captcha_mode(c: Gojo, m: Message):
+    split = m.command
+    captcha = CAPTCHA()
+    if len(split) == 1:
+        curr = captcha.get_captcha(m.chat.id)
+        if curr:
+            capatcha_type = curr["captcha_type"]
+            await m.reply_text(f"Current captcha verification methode is {capatcha_type}\nAvailable methodes:\n■ qr\n■ image")
+            return
+        else:
+            await m.reply_text("Captcha verification is off for the current chat")
+            return
+    else:
+        type_ = split[1].lower()
+        if type_ == "qr":
+            await m.reply_text("This feature is not implemented yet\nUse /captchamode image")
+            # captcha.update_type(m.chat.id, "qr")
+            # await m.reply_text("Captcha verification is now changed to qr code")
+            return
+        elif type_ == "image":
+            captcha.update_type(m.chat.id, "image")
+            await m.reply_text("Captcha verication is now changed to image")
+            return
+        else:
+            await m.reply_text("**USAGE**\n/captchamode [qr | image]")
+            return
+
+
+@Gojo.on_callback_query(filters.regex("^captcha_"))
+async def captcha_codes_check(c: Gojo, q: CallbackQuery):
+    split = q.data.split("_")
+    chat = int(split[1])
+    user = int(split[2])
+    code = split[3]
+
+    if q.from_user.id != user:
+        await q.answer("Not for you BAKA!")
+        return
+
+    c_data = CAPTCHA_DATA()
+    code_ = c_data.get_cap_data(chat, user)
+
+    if code_ == code:
+        cap = "You guessed the captcha right...Now you can talk in the chat with no restrictions"
+        c_data.remove_cap_data(chat, user)
+        await q.answer(cap, True)
+        try:
+            await q.message.chat.unban_member(user)
+        except Exception as e:
+            await q.message.reply_text(f"Unable to unmute {q.from_user.mention} this user")
+            await q.message.reply_text(e)
+            return
+        await c.send_message(chat, f"{q.from_user.mention} now you are free to talk")
+        await q.message.delete()
+        return
+    else:
+        caps = q.message.caption.split(":")
+        tries = int(caps[1].strip()) - 1
+        caps.pop(-1)
+        caps.append(f" {tries}")
+        new_cap = ":".join(caps)
+        await q.answer(f"Wrong\nTries left: {tries}", True)
+        if not tries:
+            txt = f"{q.from_user.mention} was not able to pass captcha verification thus banned from the group"
+            try:
+                await q.message.chat.ban_member(user)
+            except Exception as e:
+                await q.message.reply_text("Failed to ban member")
+                return
+            await q.message.delete()
+            keyboard = ikm(
+                [
+                    [
+                        IKB(
+                            "Unban",
+                            callback_data=f"unban_={user}",
+                        ),
+                    ],
+                ],
+            )
+            anim = choice(BAN_GIFS)
+            try:
+                await c.send_animation(
+                    chat_id=q.message.chat.id,
+                    animation=str(anim),
+                    caption=txt,
+                    reply_markup=keyboard,
+                    parse_mode=PM.HTML,
+                )
+            except Exception:
+                
+                await c.send_animation(
+                    chat_id=q.message.chat.id,
+                    text=txt,
+                    reply_markup=keyboard,
+                    parse_mode=PM.HTML,
+                )
+                await c.send_message(MESSAGE_DUMP,f"#REMOVE from BAN_GFIS\n{anim}")
+            c_data.remove_cap_data(chat, user)
+            c_data.del_message_id(q.message.chat.id, user)
+            return
+        else:
+            await q.edit_message_caption(new_cap, reply_markup=q.message.reply_markup)
+            return
+
+
+@Gojo.on_message(filters.group & captcha_filter & filters.new_chat_members, group=3)
+async def on_chat_members_updatess(c: Gojo, m: Message):
+    chat = m.chat.id
+
+    users: List[User] = m.new_chat_members
+    for user in users:
+        captcha = CAPTCHA()
+        cap_data = CAPTCHA_DATA()
+        
+        if user.is_bot:
+            continue
+        SUPPORT_STAFF = DEV_USERS.union(SUDO_USERS).union(WHITELIST_USERS)
+
+        try:
+            status = (await m.chat.get_member(user)).status
+            if status in [CMS.OWNER, CMS.ADMINISTRATOR]:
+                continue
+        except:
+            pass
+        if user.id in SUPPORT_STAFF:
+            continue
+        captcha_info = captcha.get_captcha(chat)
+        captcha_type = captcha_info["captcha_type"]
+        is_already = cap_data.is_already_data(chat, user.id)
+
+        mess = False
+        try:
+            if is_already:
+                mess = await c.get_messages(chat, int(is_already))
+        except Exception:
+            cap_data.del_message_id(chat, is_already)
+            mess = False
+            is_already = False
+
+        if is_already and mess.empty:
+            cap_data.del_message_id(chat, is_already)
+            continue
+
+        try:
+            await c.restrict_chat_member(chat, user.id, ChatPermissions())
+        except Exception as e:
+            LOGGER.error(e)
+            LOGGER.error(format_exc())
+            continue
+
+        if not is_already:
+            captcha_type = "image" # I am not going to apply qr captcha in this update
+            if captcha_type == "qr":
+                pic = await get_qr_captcha(chat, user.id, c.me.username)
+                cap = f"Please {user.mention} scan this qr code with your phone to verify that you are human"
+                ms = await c.send_photo(chat, pic, caption=cap)
+                os.remove(pic)
+                cap_data.store_message_id(chat, user.id, ms.id)
+                continue
+            elif captcha_type == "image":
+                img, code = await get_image_captcha(chat, user.id)
+                cap = f"Please {user.mention} please choose the correct code from the one given bellow\nYou have three tries if you get all three wrong u will be banned from the chat.\nTries left: 3"
+                cap_data.load_cap_data(chat, user.id, code)
+                rand = [code]
+                while len(rand) != 5:
+                    hehe = genrator()
+                    if hehe == code:
+                        continue
+                    rand.append(hehe)
+
+                shuffle(rand)
+
+                ini = f"captcha_{chat}_{user.id}_"
+
+                kb = ikm(
+                    [
+                        [
+                            IKB(rand[0], ini+rand[0])
+                        ],
+                        [
+                            IKB(rand[1], ini+rand[1])
+                        ],
+                        [
+                            IKB(rand[2], ini+rand[2])
+                        ],
+                        [
+                            IKB(rand[3], ini+rand[3])
+                        ],
+                        [
+                            IKB(rand[4], ini+rand[4])
+                        ]
+                    ]
+                )
+                await c.send_photo(chat, img, caption=cap, reply_markup=kb)
+                os.remove(img)
+                continue
+        elif is_already and mess:
+            kb = ikm(
+                [
+                    [
+                        IKB("Click here to verify", url=mess.link)
+                    ]
+                ]
+            )
+            await c.send_message(f"{user.mention} your verification is already pending", reply_markup=kb)
+            continue
+        else:
+            await c.unban_chat_member(chat, user.id)
+            continue
+
+
+__PLUGIN__ = "captcha"
+
+__HELP__ = """
+• /captcha [on|yes|enable|off|no|disable] : To enable or disable captcha verification
+• /captchamode [qr|image] : To change captcha mode
+"""

Powers/plugins/chat_blacklist.py

@@ -1,5 +1,6 @@
 from traceback import format_exc
 
+from pyrogram.enums import ChatType as CT
 from pyrogram.errors import PeerIdInvalid, RPCError
 from pyrogram.types import Message
 
@@ -17,7 +18,6 @@ async def blacklist_chat(c: Gojo, m: Message):
     if len(m.text.split()) >= 2:
         chat_ids = m.text.split()[1:]
         replymsg = await m.reply_text(f"Adding {len(chat_ids)} chats to blacklist")
-        LOGGER.info(f"{m.from_user.id} blacklisted {chat_ids} groups for bot")
         for chat in chat_ids:
             try:
                 get_chat = await c.get_chat(chat)
@@ -33,6 +33,13 @@ async def blacklist_chat(c: Gojo, m: Message):
         await replymsg.edit_text(
             f"Added the following chats to Blacklist.\n<code>{', '.join(chat_ids)}</code>.",
         )
+    else:
+        if m.chat.type == CT.PRIVATE:
+            await m.reply_text("Use in groups")
+        else:
+            chat_id = m.chat.id
+            db.add_chat(chat_id)
+            await m.reply_text("Added this chat to blacklist chats")
     return
 
 
@@ -43,7 +50,6 @@ async def unblacklist_chat(c: Gojo, m: Message):
     if len(m.text.split()) >= 2:
         chat_ids = m.text.split()[1:]
         replymsg = await m.reply_text(f"Removing {len(chat_ids)} chats from blacklist")
-        LOGGER.info(f"{m.from_user.id} removed blacklisted {chat_ids} groups for bot")
         bl_chats = db.list_all_chats()
         for chat in chat_ids:
             try:
@@ -63,6 +69,16 @@ async def unblacklist_chat(c: Gojo, m: Message):
         await replymsg.edit_text(
             f"Removed the following chats to Blacklist.\n<code>{', '.join(chat_ids)}</code>.",
         )
+    else:
+        if m.chat.type == CT.PRIVATE:
+            await m.reply_text("Use in groups")
+        else:
+            chat_id = m.chat.id
+            bl_chats = bl_chats = db.list_all_chats()
+            if chat_id not in bl_chats:
+                await m.reply_text("This chat is not in my list of blacklisted chats")
+            else:
+                await m.reply_text("Removed this chat from blacklist chats")
     return
 
 
@@ -71,7 +87,6 @@ async def unblacklist_chat(c: Gojo, m: Message):
 )
 async def list_blacklist_chats(_, m: Message):
     bl_chats = db.list_all_chats()
-    LOGGER.info(f"{m.from_user.id} checking group blacklists in {m.chat.id}")
     if bl_chats:
         txt = (
             (
@@ -84,3 +99,17 @@ async def list_blacklist_chats(_, m: Message):
         txt = "No chats are currently blacklisted!"
     await m.reply_text(txt)
     return
+
+
+__PLUGIN__ = "Chat blacklist"
+
+
+
+__HELP__ = """
+**Chat blacklist**
+
+**Dev commands:**
+• /blchat [space separated id or username of chats]: Add chats to black list if given or the current chat.
+• /rmblchat [space separated id or username of chats]: Remove chats from black list if given or the current chat.
+• /blchats: Give the list of blacklisted chats
+"""

Powers/plugins/clean_db.py

@@ -1,75 +0,0 @@
-import time
-from asyncio import sleep
-from traceback import format_exc
-
-from apscheduler.schedulers.asyncio import AsyncIOScheduler
-from pyrogram.enums import ChatMemberStatus as CMS
-from pyrogram.errors import PeerIdInvalid, UserNotParticipant
-
-from Powers import LOGGER, MESSAGE_DUMP, TIME_ZONE
-from Powers.bot_class import Gojo
-from Powers.database.approve_db import Approve
-from Powers.database.blacklist_db import Blacklist
-from Powers.database.chats_db import Chats
-from Powers.database.disable_db import Disabling
-from Powers.database.filters_db import Filters
-from Powers.database.flood_db import Floods
-from Powers.database.greetings_db import Greetings
-from Powers.database.notes_db import Notes, NotesSettings
-from Powers.database.pins_db import Pins
-from Powers.database.reporting_db import Reporting
-# from Powers.database.users_db import Users
-from Powers.database.warns_db import Warns, WarnSettings
-from Powers.utils.custom_filters import command
-from Powers.vars import Config
-
-
-async def clean_my_db(c:Gojo,is_cmd=False, id=None):
-    to_clean = list()
-    chats_list = Chats.list_chats_by_id()
-    to_clean.clear()
-    start = time.time()
-    for chats in chats_list:
-        try:
-            stat = await c.get_chat_member(chat_id=chats,user_id=Config.BOT_ID)
-            if stat.status not in [CMS.MEMBER, CMS.ADMINISTRATOR, CMS.OWNER]:
-                to_clean.append(chats)
-        except UserNotParticipant:
-            to_clean.append(chats)
-        except Exception as e:
-            LOGGER.error(e)
-            LOGGER.error(format_exc())
-            if not is_cmd:
-                return e
-            else:
-                to_clean.append(chats)
-    for i in to_clean:
-        Approve(i).clean_approve()
-        Blacklist(i).clean_blacklist()
-        Chats.remove_chat(i)
-        Disabling(i).clean_disable()
-        Filters().rm_all_filters(i)
-        Floods().rm_flood(i)
-        Greetings(i).clean_greetings()
-        Notes().rm_all_notes(i)
-        NotesSettings().clean_notes(i)
-        Pins(i).clean_pins()
-        Reporting(i).clean_reporting()
-        Warns(i).clean_warn()
-        WarnSettings(i).clean_warns()
-    x = len(to_clean)
-    txt = f"#INFO\n\nCleaned db:\nTotal chats removed: {x}"
-    to_clean.clear()
-    nums = time.time()-start
-    if is_cmd:
-        txt += f"\nClean type: Forced\nInitiated by: {(await c.get_users(user_ids=id)).mention}"
-        txt += f"\nClean type: Manual\n\tTook {round(nums,2)} seconds to complete the process"
-        await c.send_message(chat_id=MESSAGE_DUMP,text=txt)
-        return txt
-    else:
-        txt += f"\nClean type: Auto\n\tTook {round(nums,2)} seconds to complete the process"
-        await c.send_message(chat_id=MESSAGE_DUMP,text=txt)
-        return txt
-    
-
-

Powers/plugins/dev.py

@@ -1,6 +1,7 @@
 import subprocess as subp
 import sys
 from asyncio import create_subprocess_shell, sleep, subprocess
+from importlib.metadata import PackageNotFoundError, metadata
 from io import BytesIO, StringIO
 from os import execvp
 from sys import executable
@@ -15,15 +16,14 @@ from pyrogram.types import InlineKeyboardButton as IKB
 from pyrogram.types import InlineKeyboardMarkup as IKM
 from pyrogram.types import Message
 
-from Powers import (BOT_TOKEN, LOG_DATETIME, LOGFILE, LOGGER, MESSAGE_DUMP,
-                    OWNER_ID, UPTIME)
+from Powers import (BOT_TOKEN, DEV_USERS, LOG_DATETIME, LOGFILE, LOGGER,
+                    MESSAGE_DUMP, OWNER_ID, SUDO_USERS, UPTIME,
+                    WHITELIST_USERS)
 from Powers.bot_class import Gojo
 from Powers.database import MongoDB
 from Powers.database.chats_db import Chats
 from Powers.database.support_db import SUPPORTS
 from Powers.database.users_db import Users
-from Powers.plugins.scheduled_jobs import clean_my_db
-from Powers.supports import get_support_staff
 from Powers.utils.clean_file import remove_markdown_and_html
 from Powers.utils.custom_filters import command
 from Powers.utils.extract_user import extract_user
@@ -79,6 +79,12 @@ async def add_support(c: Gojo, m:Message):
                 return
             else:
                 support.insert_support_user(userr,to)
+                if to == "dev":
+                    DEV_USERS.add(userr)
+                elif to == "sudo":
+                    SUDO_USERS.add(userr)
+                else:
+                    WHITELIST_USERS.add(userr)
                 await m.reply_text(f"This user is now a {to} user")
                 return
         can_do = can_change_type(curr_user,to)
@@ -181,10 +187,13 @@ async def rm_support(c: Gojo, m: Message):
             return
     elif len(split) >= 2:
         try:
-            curr,_,_ = extract_user(m)
+            curr = int(split[1])
         except Exception:
-            await m.reply_text("Dunno who u r talking abt")
-            return
+            try:
+                curr,_,_ = extract_user(m)
+            except Exception:
+                await m.reply_text("Dunno who u r talking abt")
+                return
     else:
         await m.reply_text("**USAGE**\n/rmsupport [reply to user | user id | username]")
         return
@@ -192,6 +201,9 @@ async def rm_support(c: Gojo, m: Message):
     can_user = can_change_type(curr_user,to_user)
     if m.from_user.id == int(OWNER_ID) or can_user:
         support.delete_support_user(curr)
+        DEV_USERS.discard(curr)
+        SUDO_USERS.discard(curr)
+        WHITELIST_USERS.discard(curr)
         await m.reply_text("Done! User now no longer belongs to the support staff")
     else:
         await m.reply_text("Sorry you can't do that...")
@@ -199,13 +211,58 @@ async def rm_support(c: Gojo, m: Message):
 
 @Gojo.on_message(command("ping", sudo_cmd=True))
 async def ping(_, m: Message):
-    LOGGER.info(f"{m.from_user.id} used ping cmd in {m.chat.id}")
     start = time()
     replymsg = await m.reply_text(text="Pinging...", quote=True)
     delta_ping = time() - start
     await replymsg.edit_text(f"<b>Pong!</b>\n{delta_ping * 1000:.3f} ms")
     return
 
+"""
+
+['Metadata-Version', 'Name', 'Version', 'Summary', 'Home-page', 'Author', 'Author-email', 'License', 'Download-URL', 'Project-URL', 'Project-URL', 'Project-URL', 'Project-URL', 'Keywords', 'Platform', 'Classifier', 'Classifier', 'Classifier', 'Classifier', 'Classifier', 'Classifier', 'Classifier', 'Classifier', 'Classifier', 'Classifier', 'Classifier', 'Classifier', 'Classifier', 'Classifier', 'Classifier', 'Classifier', 'Classifier', 'Classifier', 'Classifier', 'Classifier', 'Classifier', 'Requires-Python', 'Description-Content-Type', 'License-File', 'License-File', 'License-File', 'Requires-Dist', 'Requires-Dist', 'Description']
+
+"""
+
+@Gojo.on_message(command(["minfo", "moduleinfo"], dev_cmd=True))
+async def check_module_info(_, m: Message):
+    if len(m.command) != 2:
+        await m.reply_text("**USAGE**\n/minfo [module name]")
+        return
+    
+    module = m.command[-1]
+
+    try:
+        minfo = metadata(module)
+    except PackageNotFoundError:
+        await m.reply_text(f"No module found with name {module}")
+        return
+    
+    name = minfo["Name"]
+    version = minfo["Version"]
+    summary = minfo["Summary"]
+    home_page = minfo["Home-Page"]
+    author = minfo["Author"]
+    license = minfo["License"]
+    download = minfo["Download-URL"]
+
+    txt = f"""
+Here are the info about the module **{name}**
+• Version: {version}
+
+• Summary: {summary}
+
+• Home page: {home_page}
+
+• Author: {author}
+
+• License: {license}
+
+• Download: {download}
+"""
+    await m.reply_text(txt, disable_web_page_preview=True)
+    return
+
+    
 
 @Gojo.on_message(command("logs", dev_cmd=True))
 async def send_log(c: Gojo, m: Message):
@@ -336,6 +393,10 @@ async def evaluate_code(c: Gojo, m: Message):
                 MESSAGE_DUMP,
                 f"@{m.from_user.username} TREID TO FETCH ENV OF BOT \n userid = {m.from_user.id}",
             )
+            final_output = f"**EVAL**: ```python\n{cmd}```\n\n<b>OUTPUT</b>:\n```powershell\n{evaluation}```</code> \n"
+            await sm.edit(final_output)
+            return
+
     for j in HARMFUL:
         if j in evaluation.split() or j in cmd:
             if m.from_user.id != OWNER_ID:
@@ -343,6 +404,9 @@ async def evaluate_code(c: Gojo, m: Message):
                 await c.send_message(
                     MESSAGE_DUMP,
                     f"@{m.from_user.username} TREID TO FETCH ENV OF BOT \n userid = {m.from_user.id}")
+                final_output = f"**EVAL**: ```python\n{cmd}```\n\n<b>OUTPUT</b>:\n```powershell\n{evaluation}```</code> \n"
+                await sm.edit(final_output)
+                return
     for i in evaluation.split():
         for j in i.split("="):
             if j and j[0] in HARMFUL:
@@ -352,10 +416,12 @@ async def evaluate_code(c: Gojo, m: Message):
                         MESSAGE_DUMP,
                         f"@{m.from_user.username} TREID TO FETCH ENV OF BOT \n userid = {m.from_user.id}"
                     )
-      
+                    final_output = f"**EVAL**: ```python\n{cmd}```\n\n<b>OUTPUT</b>:\n```powershell\n{evaluation}```</code> \n"
+                    await sm.edit(final_output)
+                    return
 
     try:
-        final_output = f"**EVAL**: ```python\n{cmd}```\n\n<b>OUTPUT</b>:\n```python\n{evaluation}```</code> \n"
+        final_output = f"**EVAL**: ```python\n{cmd}```\n\n<b>OUTPUT</b>:\n```powershell\n{evaluation}```</code> \n"
         await sm.edit(final_output)
     except MessageTooLong:
         final_output = f"<b>EVAL</b>: <code>{cmd}</code>\n\n<b>OUTPUT</b>:\n<code>{evaluation}</code> \n"
@@ -486,7 +552,7 @@ async def stop_and_send_logger(c:Gojo,is_update=False):
         )
     return
 
-@Gojo.on_message(command(["restart", "update"], owner_cmd=True),group=-100)
+@Gojo.on_message(command(["restart", "update"], owner_cmd=True))
 async def restart_the_bot(c:Gojo,m:Message):
     try:
         cmds = m.command
@@ -671,23 +737,6 @@ async def forward_type_broadcast(c: Gojo, m: Message):
     return
 
 
-@Gojo.on_message(command(["cleandb","cleandatabase"],sudo_cmd=True))
-async def cleeeen(c:Gojo,m:Message):
-    x = await m.reply_text("Cleaning the database...")
-    try:
-        z = await clean_my_db(c,True,m.from_user.id)
-        try:
-            await x.delete()
-        except Exception:
-            pass
-        await m.reply_text(z)
-        return
-    except Exception as e:
-        await m.reply_text(e)
-        await x.delete()
-        LOGGER.error(e)
-        LOGGER.error(format_exc())
-        return
 
 __PLUGIN__ = "devs"
 

Powers/plugins/disable.py

@@ -24,7 +24,6 @@ async def disableit(_, m: Message):
 
     db = Disabling(m.chat.id)
     disable_list = db.get_disabled()
-    LOGGER.info(f"{m.from_user.id} used disabled cmd in {m.chat.id}")
 
     if str(m.text.split(None, 1)[1]) in disable_list:
         return await m.reply_text("It's already disabled!")
@@ -48,8 +47,6 @@ async def set_dsbl_action(_, m: Message):
         cur = True
     args = m.text.split(" ", 1)
 
-    LOGGER.info(f"{m.from_user.id} disabledel used in {m.chat.id}")
-
     if len(args) >= 2:
         if args[1].lower() == "on":
             db.set_action("del")
@@ -73,7 +70,6 @@ async def enableit(_, m: Message):
     if str(m.text.split(None, 1)[1]) not in disable_list:
         return await m.reply_text("It's not disabled!")
     db.remove_disabled((str(m.text.split(None, 1)[1])).lower())
-    LOGGER.info(f"{m.from_user.id} enabled something in {m.chat.id}")
     return await m.reply_text(f"Enabled {m.text.split(None, 1)[1]}!")
 
 
@@ -86,7 +82,6 @@ async def disabling(_, m: Message):
     )
     tes = "List of commnds that can be disabled:\n"
     tes += "\n".join(f" • <code>{escape(i)}</code>" for i in disable_cmd_keys)
-    LOGGER.info(f"{m.from_user.id} checked disableable {m.chat.id}")
     return await m.reply_text(tes)
 
 
@@ -99,7 +94,6 @@ async def disabled(_, m: Message):
         return
     tex = "Disabled commands:\n"
     tex += "\n".join(f" • <code>{escape(i)}</code>" for i in disable_list)
-    LOGGER.info(f"{m.from_user.id} checked disabled {m.chat.id}")
     return await m.reply_text(tex)
 
 
@@ -145,6 +139,25 @@ async def enablealll(_, q: CallbackQuery):
         return
     db = Disabling(q.message.chat.id)
     db.rm_all_disabled()
-    LOGGER.info(f"{user_id} enabled all in {q.message.chat.id}")
     await q.message.edit_text("Enabled all!", show_alert=True)
     return
+
+
+__PLUGIN__ = "disable able"
+
+__alt_name__ = ["disable commands", "disable"]
+
+
+__HELP__ = """
+**Disable commands**
+
+**Admin commands:**
+• /disable [command]: To disable the given command.
+• /disabledel [on | off]: Will delete the command which is disabled.
+• /enable [command]: To enable the given command.
+• /disableable : Give all disableable commands.
+• /disabled : Give all disabled commands.
+
+**Owner command:**
+• /enableall : Enable all the disabled commands.
+"""

Powers/plugins/filters.py

@@ -25,8 +25,6 @@ db = Filters()
 
 @Gojo.on_message(command("filters") & filters.group & ~filters.bot)
 async def view_filters(_, m: Message):
-    LOGGER.info(f"{m.from_user.id} checking filters in {m.chat.id}")
-
     filters_chat = f"Filters in <b>{m.chat.title}</b>:\n"
     all_filters = db.get_all_filters(m.chat.id)
     actual_filters = [j for i in all_filters for j in i.split("|")]
@@ -66,9 +64,9 @@ async def add_filter(_, m: Message):
     extracted = await split_quotes(args[1])
     keyword = extracted[0].lower()
 
-    for k in keyword.split("|"):
-        if k in actual_filters:
-            return await m.reply_text(f"Filter <code>{k}</code> already exists!")
+    # for k in keyword.split("|"):
+    #     if k in actual_filters:
+    #         return await m.reply_text(f"Filter <code>{k}</code> already exists!")
 
     if not keyword:
         return await m.reply_text(
@@ -98,7 +96,6 @@ async def add_filter(_, m: Message):
         )
 
     add = db.save_filter(m.chat.id, keyword, teks, msgtype, file_id)
-    LOGGER.info(f"{m.from_user.id} added new filter ({keyword}) in {m.chat.id}")
     if add:
         await m.reply_text(
             f"Saved filter for '<code>{', '.join(keyword.split('|'))}</code>' in <b>{m.chat.title}</b>!",
@@ -110,7 +107,7 @@ async def add_filter(_, m: Message):
 async def stop_filter(_, m: Message):
     args = m.command
 
-    if len(args) < 1:
+    if len(args) <= 1:
         return await m.reply_text("What should I stop replying to?")
 
     chat_filters = db.get_all_filters(m.chat.id)
@@ -122,7 +119,6 @@ async def stop_filter(_, m: Message):
     for keyword in act_filters:
         if keyword == m.text.split(None, 1)[1].lower():
             db.rm_filter(m.chat.id, m.text.split(None, 1)[1].lower())
-            LOGGER.info(f"{m.from_user.id} removed filter ({keyword}) in {m.chat.id}")
             await m.reply_text(
                 f"Okay, I'll stop replying to that filter and it's aliases in <b>{m.chat.title}</b>.",
             )
@@ -171,7 +167,6 @@ async def rm_allfilters_callback(_, q: CallbackQuery):
         return
     db.rm_all_filters(q.message.chat.id)
     await q.message.edit_text(f"Cleared all filters for {q.message.chat.title}")
-    LOGGER.info(f"{user_id} removed all filter from {q.message.chat.id}")
     await q.answer("Cleared all Filters!", show_alert=True)
     return
 
@@ -283,7 +278,6 @@ async def filters_watcher(c: Gojo, m: Message):
         if match:
             try:
                 msgtype = await send_filter_reply(c, m, trigger)
-                LOGGER.info(f"Replied with {msgtype} to {trigger} in {m.chat.id}")
             except Exception as ef:
                 await m.reply_text(f"Error: {ef}")
                 LOGGER.error(ef)

Powers/plugins/flood.py

@@ -1,4 +1,5 @@
 import time
+from datetime import datetime, timedelta
 from random import choice
 from traceback import format_exc
 
@@ -10,21 +11,46 @@ from pyrogram.types import (CallbackQuery, ChatPermissions,
                             InlineKeyboardButton, InlineKeyboardMarkup,
                             Message)
 
-from Powers import LOGGER, SUPPORT_GROUP
+from Powers import DEV_USERS, LOGGER, SUDO_USERS, WHITELIST_USERS
 from Powers.bot_class import Gojo
-from Powers.database.approve_db import Approve
 from Powers.database.flood_db import Floods
-from Powers.supports import get_support_staff
-from Powers.utils.custom_filters import admin_filter, command
+from Powers.utils.custom_filters import admin_filter, command, flood_filter
 from Powers.utils.extras import BAN_GIFS, KICK_GIFS, MUTE_GIFS
-from Powers.utils.kbhelpers import ikb
-from Powers.vars import Config
-
-SUPPORT_STAFF = get_support_staff()
 
 on_key = ["on", "start", "disable"]
 off_key = ["off", "end", "enable", "stop"]
 
+async def get_what_temp(what):
+    temp_duration = InlineKeyboardMarkup(
+        [
+            [
+                InlineKeyboardButton(
+                    "5 minutes",
+                    f"f_temp_{what}_5min"
+                ),
+                InlineKeyboardButton(
+                    "10 minute",
+                    f"f_temp_{what}_10min",
+                ),
+                InlineKeyboardButton(
+                    "30 minute",
+                    f"f_temp_{what}_30min"
+                ),
+                InlineKeyboardButton(
+                    "1 hour",
+                    f"f_temp_{what}_60min"
+                )
+            ],
+            [
+                InlineKeyboardButton(
+                    "« Back",
+                    "f_temp_back"
+                )
+            ]
+        ]
+    )
+    return temp_duration
+
 close_kb =InlineKeyboardMarkup(
     [
         [
@@ -52,6 +78,16 @@ action_kb = InlineKeyboardMarkup(
                 callback_data="f_kick"
             )
         ],
+        [
+            InlineKeyboardButton(
+                "Temp Mute 🔇",
+                "f_temp_mute"
+            ),
+            InlineKeyboardButton(
+                "Temp Ban 🚷",
+                "f_temp_ban"
+            )
+        ],
         [
             InlineKeyboardButton(
                 "➡️ Skip",
@@ -114,7 +150,7 @@ limit_kb = InlineKeyboardMarkup(
 @Gojo.on_message(command(['floodaction','actionflood']) & admin_filter)
 async def flood_action(c: Gojo, m: Message):
     Flood = Floods()
-    bot = await c.get_chat_member(m.chat.id, Config.BOT_ID)
+    bot = await c.get_chat_member(m.chat.id, c.me.id)
     status = bot.status
     if not status in [CMS.OWNER, CMS.ADMINISTRATOR]:
       if not bot.privileges.can_restrict_members:
@@ -151,7 +187,7 @@ async def flood_on_off(c: Gojo, m: Message):
 
 @Gojo.on_message(command(['setflood']) & ~filters.bot & admin_filter)
 async def flood_set(c: Gojo, m: Message):
-    bot = await c.get_chat_member(m.chat.id, Config.BOT_ID)
+    bot = await c.get_chat_member(m.chat.id, c.me.id)
     Flood = Floods()
     status = bot.status
     if not status in [CMS.OWNER, CMS.ADMINISTRATOR]:
@@ -176,12 +212,17 @@ async def flood_set(c: Gojo, m: Message):
         c_id = m.chat.id
         if split[1].lower() in on_key:
             if is_flood:    
-                return await m.reply_text(f"Flood is on for this chat\n**Action**:{saction}\n**Messages**:{slimit} within {swithin} sec")
-            Flood.save_flood(m.chat.id, 5, 5, 'mute')
-            await m.reply_text("Flood protection has been started for this group.")
+                saction = is_flood[2]
+                slimit = is_flood[0]
+                swithin = is_flood[1]
+
+            await m.reply_text(f"Flood is on for this chat\n**Action**:{saction}\n**Messages**:{slimit} within {swithin} sec")
             return
         if split[1].lower() in off_key:
             x = Flood.rm_flood(c_id)
+            if not is_flood:
+                await m.reply_text("Flood protection is already off for this chat")
+                return
             if x:
                 await m.reply_text("Flood protection has been stopped for this chat")
                 return
@@ -192,6 +233,7 @@ async def flood_set(c: Gojo, m: Message):
 
 @Gojo.on_callback_query(filters.regex("^f_"))
 async def callbacks(c: Gojo, q: CallbackQuery):
+    SUPPORT_STAFF = DEV_USERS.union(SUDO_USERS).union(WHITELIST_USERS)
     data = q.data
     if data == "f_close":
         await q.answer("Closed")
@@ -229,6 +271,28 @@ async def callbacks(c: Gojo, q: CallbackQuery):
                     f"Set the limit of message after the flood protection will be activated\n **CURRENT LIMIT** {slimit} messages",
                     reply_markup=limit_kb
                 )
+        elif data.startswith("f_temp_"):
+            splited = data.split("_")
+            if len(splited) == 3:
+                to_do = splited[-1]
+                if to_do == "back":
+                    kb = action_kb
+                    await q.edit_message_text(
+                        f"Choose a action given bellow to do when flood happens.\n **CURRENT ACTION** is {saction}",
+                        reply_markup=action_kb
+                    )
+                    return
+                kb = await get_what_temp(to_do)
+                await q.answer(f"Choose temp {to_do} time", True)
+                await q.edit_message_text(f"What shoud be temp {to_do} time?", reply_markup=kb)
+            else:
+                change = f"{splited[-2]}_{splited[-1]}"
+                Flood.save_flood(c_id, slimit, swithin, change)
+                await q.edit_message_text(
+                    f"Set the limit of message after the flood protection will be activated\n **CURRENT LIMIT** {slimit} messages",
+                    reply_markup=limit_kb
+                )
+                return
         elif data in ["f_5", "f_10", "f_15", "f_f_f_skip"]:
             try:
                 change = int(data.split("_")[-1])
@@ -263,8 +327,8 @@ async def callbacks(c: Gojo, q: CallbackQuery):
                     "Flood protection setting has been updated",
                     reply_markup=close_kb
                 )
-                return
                 await q.answer("skip")
+                return
             if not change == swithin:
                 Flood.save_flood(c_id, slimit, change, saction)
                 await q.answer("Updated", show_alert=True)
@@ -291,6 +355,7 @@ async def reverse_callbacks(c: Gojo, q: CallbackQuery):
     data = q.data.split("_")
     action = data[1]
     user_id = int(q.data.split("=")[1])
+    SUPPORT_STAFF = DEV_USERS.union(SUDO_USERS).union(WHITELIST_USERS)
     if not q.from_user:
         return q.answer("Looks like you are not an user 👀")
     if action == "ban":
@@ -330,41 +395,17 @@ async def reverse_callbacks(c: Gojo, q: CallbackQuery):
         return
 
 dic = {}
-@Gojo.on_message(filters.all & ~filters.bot | ~filters.private, 10)
+@Gojo.on_message(flood_filter, 18)
 async def flood_watcher(c: Gojo, m: Message):
     c_id = m.chat.id
     
-    if not m.chat:
-        return
-    
     Flood = Floods()
     
-    try:
-        u_id = m.from_user.id
-    except AttributeError:
-        return # Get this error when the message received is not by an user and return
+    u_id = m.from_user.id
     
     is_flood = Flood.is_chat(c_id)
     
-    if not is_flood:
-        return # return of chat is not in anti flood protection
-    
-    app_users = Approve(m.chat.id).list_approved()
-    
-    if u_id in {i[0] for i in app_users}:
-        return #return if the user is approved
-    
-    if not is_flood or u_id in SUPPORT_STAFF:
-        return #return if the user is in support_staff
-    
-    try:
-        user_status = (await m.chat.get_member(m.from_user.id)).status
-    except Exception:
-        return
-    
-    if user_status in [CMS.OWNER, CMS.ADMINISTRATOR]:
-        return #return if the user is owner or admin
-    
+
     action = is_flood[2]
     limit = int(is_flood[0])
     within = int(is_flood[1])
@@ -398,6 +439,101 @@ async def flood_watcher(c: Gojo, m: Message):
     
     if len(dic[c_id][u_id][1]) == limit:
         if y-x <= within:
+            action = action.split("_")
+            if len(action) == 2:
+                try:
+                    to_do = action[0]
+                    for_tim = int(action[1].replace("min",""))
+                except:
+                    for_tim = 30
+                for_how_much = datetime.now() + timedelta(minutes=for_tim)
+                if to_do == "ban":
+                    try:
+                        await m.chat.ban_member(u_id, until_date=for_how_much)
+                        keyboard = InlineKeyboardMarkup(
+                            [
+                                [
+                                    InlineKeyboardButton(
+                                        "Unban",
+                                        callback_data=f"un_ban_={u_id}",
+                                    ),
+                                ],
+                            ],
+                        )
+                        txt = f"Don't dare to spam here if I am around! Nothing can escape my 6 eyes\nAction: Baned\nReason: Spaming\nUntril: {for_how_much}"
+                        await m.reply_animation(
+                            animation=str(choice(BAN_GIFS)),
+                            caption=txt,
+                            reply_markup=keyboard,
+                        )
+                        dic[c_id][u_id][1].clear()
+                        dic[c_id][u_id][0].clear()
+                        return
+
+                    except UserAdminInvalid:
+                        await m.reply_text(
+                            "I can't protect this chat from this user",
+                            )
+                        dic[c_id][u_id][1].clear()
+                        dic[c_id][u_id][0].clear()
+                        return
+                    except RPCError as ef:
+                        await m.reply_text(
+                            text=f"""Some error occured, report it using `/bug`
+
+                            <b>Error:</b> <code>{ef}</code>"""
+                            )
+                        LOGGER.error(ef)
+                        LOGGER.error(format_exc())
+                        dic[c_id][u_id][1].clear()
+                        dic[c_id][u_id][0].clear()
+                        return
+                else:
+                    try:
+                        await m.chat.restrict_member(
+                            u_id,
+                            ChatPermissions(),
+                            until_date=for_how_much
+                        )
+                        keyboard = InlineKeyboardMarkup(
+                            [
+                                [
+                                    InlineKeyboardButton(
+                                        "Unmute",
+                                        callback_data=f"un_mute_={u_id}",
+                                    ),
+                                ],
+                            ],
+                        )
+                        txt = f"Don't dare to spam here if I am around! Nothing can escape my 6 eyes\nAction: Muted\nReason: Spaming\nUntil: {for_how_much}"
+                        await m.reply_animation(
+                            animation=str(choice(MUTE_GIFS)),
+                            caption=txt,
+                            reply_markup=keyboard,
+                        )
+                        dic[c_id][u_id][1].clear()
+                        dic[c_id][u_id][0].clear()
+                        return
+                    except UserAdminInvalid:
+                        await m.reply_text(
+                            "I can't protect this chat from this user",
+                        )
+                        dic[c_id][u_id][1].clear()
+                        dic[c_id][u_id][0].clear()
+                        return
+                    except RPCError as ef:
+                        await m.reply_text(
+                            text=f"""Some error occured, report it using `/bug`
+
+                            <b>Error:</b> <code>{ef}</code>"""
+                        )
+                        LOGGER.error(ef)
+                        LOGGER.error(format_exc())
+                        dic[c_id][u_id][1].clear()
+                        dic[c_id][u_id][0].clear()
+                        return
+            else:
+                action = action[0]
             if action == "ban":
                 try:
                     await m.chat.ban_member(u_id)
@@ -442,13 +578,14 @@ async def flood_watcher(c: Gojo, m: Message):
                 
             elif action == "kick":
                 try:
-                    await m.chat.ban_member(u_id)
-                    txt = "Don't dare to spam here if I am around! Nothing can escape my 6 eyes\nAction: kicked\nReason: Spaming"
+                    d = datetime.now()+timedelta(seconds=31) #will automatically unban user after 31 seconds kind of fail safe if unban members doesn't work properly
+                    await m.chat.ban_member(u_id, until_date=d)
+                    success = await c.unban_chat_member(m.chat.id, u_id)
+                    txt = f"Don't dare to spam here if I am around! Nothing can escape my 6 eyes\nAction: {'kicked' if success else 'banned for 30 seconds'}\nReason: Spaming"
                     await m.reply_animation(
                         animation=str(choice(KICK_GIFS)),
-                        caption=txt,
+                        caption=txt
                     )
-                    await m.chat.unban_member(u_id)
                     dic[c_id][u_id][1].clear()
                     dic[c_id][u_id][0].clear()
                     return
@@ -470,6 +607,12 @@ async def flood_watcher(c: Gojo, m: Message):
                     dic[c_id][u_id][1].clear()
                     dic[c_id][u_id][0].clear()
                     return
+                except Exception as e:
+                    LOGGER.error(e)
+                    LOGGER.error(format_exc())
+                    dic[c_id][u_id][1].clear()
+                    dic[c_id][u_id][0].clear()
+                    return
             elif action == "mute":
                 try:
                     await m.chat.restrict_member(

Powers/plugins/formatting.py

@@ -35,18 +35,10 @@ async def markdownhelp(_, m: Message):
         quote=True,
         reply_markup=(await gen_formatting_kb(m)),
     )
-    LOGGER.info(f"{m.from_user.id} used cmd '{m.command}' in {m.chat.id}")
     return
 
 
-@Gojo.on_callback_query(filters.regex("^formatting."))
-async def get_formatting_info(c: Gojo, q: CallbackQuery):
-    cmd = q.data.split(".")[1]
-    kb = ikb([[("Back", "back.formatting")]])
-
-    if cmd == "md_formatting":
-        
-        txt = """<b>Markdown Formatting</b>
+md_txt = """<b>Markdown Formatting</b>
 You can format your message using <b>bold</b>, <i>italic</i>, <u>underline</u>, <strike>strike</strike> and much more. Go ahead and experiment!
 
 **Note**: It supports telegram user based formatting as well as html and markdown formattings.
@@ -66,17 +58,74 @@ If you would like to send buttons on the same row, use the <code>:same</code> fo
 <code>[button 2](buttonurl://example.com:same)</code>
 <code>[button 3](buttonurl://example.com)</code>
 This will show button 1 and 2 on the same line, while 3 will be underneath."""
+
+async def get_splited_formatting(msg, page=1):
+    msg = msg.split("\n")
+    l = len(msg)
+    new_msg = ""
+    total = l // 10
+    first = 10 * (page - 1)
+    last = 10 * page
+    if not first:
+        for i in msg[first:last]:
+            new_msg += f"{i}\n"
+        kb = [
+            [
+                ("Next page ▶️", f"next_format_{page+1}")
+            ]
+        ]
+    else:
+        first += 1
+        if page == total:
+            for i in msg[first:]:
+                new_msg += f"{i}\n"
+            kb = [
+                [
+                    ("◀️ Previous page", f"next_format_{page-1}")
+                ]
+            ]
+        else:
+            for i in msg[first:last]:
+                new_msg += f"{i}\n"
+            kb = [
+                    [
+                        ("◀️ Previous page", f"next_format_{page-1}"),
+                        ("Next page ▶️", f"next_format_{page+1}")
+                    ]
+                ]
+
+
+    kb = ikb(kb, True, "back.formatting")
+
+    return new_msg, kb
+
+@Gojo.on_callback_query(filters.regex(r"^next_format_.*[0-9]$"))
+async def change_formatting_page(c: Gojo, q: CallbackQuery):
+    page = q.data.split("_")[-1]
+    txt, kb = await get_splited_formatting(md_txt, int(page))
+    await q.edit_message_caption(txt, reply_markup=kb,parse_mode=enums.ParseMode.HTML,)
+    return
+
+@Gojo.on_callback_query(filters.regex("^formatting."))
+async def get_formatting_info(c: Gojo, q: CallbackQuery):
+    cmd = q.data.split(".")[1]
+    kb = ikb([[("Back", "back.formatting")]])
+
+    if cmd == "md_formatting":
+        
         try:
             await q.edit_message_caption(
-                caption=txt,
+                caption=md_txt,
                 reply_markup=kb,
                 parse_mode=enums.ParseMode.HTML,
             )
         except MediaCaptionTooLong:
-            await c.send_message(
-                chat_id=q.message.chat.id,
-                text=txt,
-                parse_mode=enums.ParseMode.HTML,)
+            txt, kb = await get_splited_formatting(md_txt)
+            await q.edit_message_caption(
+                caption=txt,
+                reply_markup=kb,
+                parse_mode=enums.ParseMode.HTML,
+            )
     elif cmd == "fillings":
         await q.edit_message_caption(
             caption="""<b>Fillings</b>

Powers/plugins/fun.py

@@ -5,15 +5,13 @@ from pyrogram import enums
 from pyrogram.errors import MessageTooLong
 from pyrogram.types import Message
 
-from Powers import LOGGER
+from Powers import DEV_USERS
 from Powers.bot_class import Gojo
-from Powers.supports import get_support_staff
 from Powers.utils import extras
 from Powers.utils.custom_filters import command
 from Powers.utils.extras import NOWYES as NO
 from Powers.utils.extras import YESWNO as YES
 
-DEV_USERS = get_support_staff("dev")
 
 @Gojo.on_message(command("shout"))
 async def fun_shout(_, m: Message):
@@ -33,7 +31,6 @@ async def fun_shout(_, m: Message):
         result = "".join(result)
         msg = "```\n" + result + "```"
         await m.reply_text(msg, parse_mode=enums.ParseMode.MARKDOWN)
-        LOGGER.info(f"{m.from_user.id} shouted in {m.chat.id}")
         return
     except MessageTooLong as e:
         await m.reply_text(f"Error: {e}")
@@ -43,7 +40,6 @@ async def fun_shout(_, m: Message):
 @Gojo.on_message(command("runs"))
 async def fun_run(_, m: Message):
     await m.reply_text(choice(extras.RUN_STRINGS))
-    LOGGER.info(f"{m.from_user.id} runed in {m.chat.id}")
     return
 
 
@@ -79,7 +75,6 @@ async def fun_slap(c: Gojo, m: Message):
 
     reply = temp.format(user1=user1, user2=user2, item=item, hits=hit, throws=throw)
     await reply_text(reply)
-    LOGGER.info(f"{m.from_user.id} slaped in {m.chat.id}")
     return
 
 
@@ -87,7 +82,6 @@ async def fun_slap(c: Gojo, m: Message):
 async def fun_roll(_, m: Message):
     reply_text = m.reply_to_message.reply_text if m.reply_to_message else m.reply_text
     await reply_text(choice(range(1, 7)))
-    LOGGER.info(f"{m.from_user.id} roll in {m.chat.id}")
     return
 
 
@@ -95,7 +89,6 @@ async def fun_roll(_, m: Message):
 async def fun_toss(_, m: Message):
     reply_text = m.reply_to_message.reply_text if m.reply_to_message else m.reply_text
     await reply_text(choice(extras.TOSS))
-    LOGGER.info(f"{m.from_user.id} tossed in {m.chat.id}")
     return
 
 
@@ -108,13 +101,9 @@ async def insult(c: Gojo, m: Message):
     user_first_name = m.reply_to_message.from_user.first_name
     if user_id in DEV_USERS:
         await m.reply_text("Sorry! I can't insult my devs....")
-        return LOGGER.info(
-            f"{m.from_user.id} tried to insult {user_first_name} in {m.chat.id}"
-        )
     else:
         Insult_omp = choice(extras.INSULT_STRINGS)
         await m.reply_to_message.reply_text(Insult_omp)
-        LOGGER.info(f"{m.from_user.id} insulted {user_first_name} in {m.chat.id}")
 
 
 @Gojo.on_message(command("yes"))
@@ -122,7 +111,6 @@ async def yesw(c: Gojo, m: Message):
     reply_text = m.reply_to_message.reply_text if m.reply_to_message else m.reply_text
     rtext = YES[0]
     await reply_text(rtext)
-    LOGGER.info(f"{m.from_user.id} said YES or may be NO in {m.chat.id}")
     return
 
 
@@ -131,7 +119,6 @@ async def now(c: Gojo, m: Message):
     reply_text = m.reply_to_message.reply_text if m.reply_to_message else m.reply_text
     rtext = NO[0]
     await reply_text(rtext)
-    LOGGER.info(f"{m.from_user.id} said NO or may be YES in {m.chat.id}")
     return
 
 
@@ -139,7 +126,6 @@ async def now(c: Gojo, m: Message):
 async def fun_shrug(_, m: Message):
     reply_text = m.reply_to_message.reply_text if m.reply_to_message else m.reply_text
     await reply_text(r"¯\_(ツ)_/¯")
-    LOGGER.info(f"{m.from_user.id} shruged in {m.chat.id}")
     return
 
 
@@ -149,7 +135,6 @@ async def fun_bluetext(_, m: Message):
     await reply_text(
         "|| /BLUE /TEXT\n/MUST /CLICK\n/I /AM /A /STUPID /ANIMAL /THAT /IS /ATTRACTED /TO /COLORS ||",
     )
-    LOGGER.info(f"{m.from_user.id} bluetexted in {m.chat.id}")
     return
 
 
@@ -157,7 +142,6 @@ async def fun_bluetext(_, m: Message):
 async def fun_decide(_, m: Message):
     reply_text = m.reply_to_message.reply_text if m.reply_to_message else m.reply_text
     await reply_text(choice(extras.DECIDE))
-    LOGGER.info(f"{m.from_user.id} decided in {m.chat.id}")
     return
 
 
@@ -165,7 +149,6 @@ async def fun_decide(_, m: Message):
 async def fun_table(_, m: Message):
     reply_text = m.reply_to_message.reply_text if m.reply_to_message else m.reply_text
     await reply_text(choice(extras.REACTIONS))
-    LOGGER.info(f"{m.from_user.id} reacted in {m.chat.id}")
     return
 
 
@@ -199,7 +182,6 @@ async def weebify(_, m: Message):
         text=f"""<b>Weebified String:</b>
         <code>{string}</code>"""
     )
-    LOGGER.info(f"{m.from_user.id} weebified '{args}' in {m.chat.id}")
     return
 
 

Powers/plugins/greetings.py

@@ -1,45 +1,38 @@
 from html import escape
 from secrets import choice
 from traceback import format_exc
+from typing import List
 
-from pyrogram import enums, filters
-from pyrogram.enums import ChatMemberStatus as CMS
-from pyrogram.errors import ChatAdminRequired, RPCError
-from pyrogram.types import ChatMemberUpdated, Message
+from pyrogram import emoji, enums, filters
+from pyrogram.errors import ChannelPrivate, ChatAdminRequired, RPCError
+from pyrogram.types import Message, User
 
-from Powers import LOGGER
+from Powers import DEV_USERS, LOGGER
 from Powers.bot_class import Gojo
 from Powers.database.antispam_db import GBan
 from Powers.database.greetings_db import Greetings
-from Powers.supports import get_support_staff
 from Powers.utils.cmd_senders import send_cmd
-from Powers.utils.custom_filters import admin_filter, bot_admin_filter, command
+from Powers.utils.custom_filters import (admin_filter, bot_admin_filter,
+                                         captcha_filter, command)
 from Powers.utils.kbhelpers import ikb
 from Powers.utils.msg_types import Types, get_wlcm_type
 from Powers.utils.parser import escape_markdown, mention_html
 from Powers.utils.string import (build_keyboard, escape_invalid_curly_brackets,
                                  parse_button)
-from Powers.vars import Config
 
 # Initialize
 gdb = GBan()
 
-DEV_USERS = get_support_staff("dev")
-
 ChatType = enums.ChatType
 
 
-async def escape_mentions_using_curly_brackets_wl(
-    m: ChatMemberUpdated,
-    n: bool,
+async def  escape_mentions_using_curly_brackets_wl(
+    user: User,
+    m: Message,
     text: str,
     parse_words: list,
 ) -> str:
     teks = await escape_invalid_curly_brackets(text, parse_words)
-    if n:
-        user = m.new_chat_member.user if m.new_chat_member else m.from_user
-    else:
-        user = m.old_chat_member.user if m.old_chat_member else m.from_user
     if teks:
         teks = teks.format(
             first=escape(user.first_name),
@@ -239,115 +232,101 @@ async def cleannnnn(_, m: Message):
     except Exception:
         pass
 
-
-@Gojo.on_chat_member_updated(filters.group, group=69)
-async def member_has_joined(c: Gojo, member: ChatMemberUpdated):
-
-    if (
-        member.new_chat_member
-        and member.new_chat_member.status not in {CMS.BANNED, CMS.LEFT, CMS.RESTRICTED}
-        and not member.old_chat_member
-    ):
-        pass
-    else:
-        return
-
-    user = member.new_chat_member.user if member.new_chat_member else member.from_user
-
-    db = Greetings(member.chat.id)
-    banned_users = gdb.check_gban(user.id)
-    try:
-        if user.id == Config.BOT_ID:
-            return
-        if user.id in DEV_USERS:
-            await c.send_animation(
-                chat_id=member.chat.id,
-                animation="./extras/william.gif",
-                caption="😳 My **DEV** has also joined the chat!",
-            )
-            return
-        if banned_users:
-            await member.chat.ban_member(user.id)
-            await c.send_message(
-                member.chat.id,
-                f"{user.mention} was globally banned so i banned!",
-            )
-            return
-        if user.is_bot:
-            return  # ignore bots
-    except ChatAdminRequired:
-        return
-    status = db.get_welcome_status()
-    oo = db.get_welcome_text()
-    UwU = db.get_welcome_media()
-    mtype = db.get_welcome_msgtype()
-    parse_words = [
-        "first",
-        "last",
-        "fullname",
-        "username",
-        "mention",
-        "id",
-        "chatname",
-    ]
-    hmm = await escape_mentions_using_curly_brackets_wl(member, True, oo, parse_words)
-    if status:
-        tek, button = await parse_button(hmm)
-        button = await build_keyboard(button)
-        button = ikb(button) if button else None
-
-        if "%%%" in tek:
-            filter_reply = tek.split("%%%")
-            teks = choice(filter_reply)
-        else:
-            teks = tek
-        ifff = db.get_current_cleanwelcome_id()
-        gg = db.get_current_cleanwelcome_settings()
-        if ifff and gg:
-            try:
-                await c.delete_messages(member.chat.id, int(ifff))
-            except RPCError:
-                pass
-        if not teks:
-            teks = "Hey {first}, welcome to {chatname}"
+@Gojo.on_message(filters.group & filters.new_chat_members & ~captcha_filter, group=69)
+async def member_has_joined(c: Gojo, m: Message):
+    users: List[User] = m.new_chat_members
+    db = Greetings(m.chat.id)
+    for user in users:
+        banned_users = gdb.check_gban(user.id)
         try:
-            if not UwU:
-                jj = await c.send_message(
-                    member.chat.id,
-                    text=teks,
-                    reply_markup=button,
-                    disable_web_page_preview=True,
+            if user.id == c.me.id:
+                continue
+            if user.id in DEV_USERS:
+                await c.send_animation(
+                    chat_id=m.chat.id,
+                    animation="./extras/william.gif",
+                    caption=f"😳 My **DEV** {user.mention} has also joined the chat!",
                 )
-            elif UwU:
-                jj = await (await send_cmd(c,mtype))(
-                    member.chat.id,
-                    UwU,
-                    caption=teks,
-                    reply_markup=button,
+                continue
+            if banned_users:
+                await m.chat.ban_member(user.id)
+                await c.send_message(
+                    m.chat.id,
+                    f"{user.mention} was globally banned so i banned!",
                 )
+                continue
+            if user.is_bot:
+                continue # ignore bots
+        except ChatAdminRequired:
+            continue
+        status = db.get_welcome_status()
+        oo = db.get_welcome_text()
+        UwU = db.get_welcome_media()
+        mtype = db.get_welcome_msgtype()
+        parse_words = [
+            "first",
+            "last",
+            "fullname",
+            "username",
+            "mention",
+            "id",
+            "chatname",
+        ]
+        hmm = await escape_mentions_using_curly_brackets_wl(user, m, oo, parse_words)
+        if status:
+            tek, button = await parse_button(hmm)
+            button = await build_keyboard(button)
+            button = ikb(button) if button else None
+
+            if "%%%" in tek:
+                filter_reply = tek.split("%%%")
+                teks = choice(filter_reply)
+            else:
+                teks = tek
+
+            if not teks:
+                teks = f"A wild {user.mention} appeared in {m.chat.title}! Everyone be aware."
+
+            ifff = db.get_current_cleanwelcome_id()
+            gg = db.get_current_cleanwelcome_settings()
+            if ifff and gg:
+                try:
+                    await c.delete_messages(m.chat.id, int(ifff))
+                except RPCError:
+                    pass
+            if not teks:
+                teks = "Hey {first}, welcome to {chatname}"
+            try:
+                if not UwU:
+                    jj = await c.send_message(
+                        m.chat.id,
+                        text=teks,
+                        reply_markup=button,
+                        disable_web_page_preview=True,
+                    )
+                elif UwU:
+                    jj = await (await send_cmd(c,mtype))(
+                        m.chat.id,
+                        UwU,
+                        caption=teks,
+                        reply_markup=button,
+                    )
+
+                if jj:
+                    db.set_cleanwlcm_id(int(jj.id))
+            except ChannelPrivate:
+                continue
+            except RPCError as e:
+                LOGGER.error(e)
+                LOGGER.error(format_exc(e))
+                continue
+        else:
+            continue
 
-            if jj:
-                db.set_cleanwlcm_id(int(jj.id))
-        except RPCError as e:
-            LOGGER.error(e)
-            LOGGER.error(format_exc(e))
-            return
-    else:
-        return
-
-
-@Gojo.on_chat_member_updated(filters.group, group=99)
-async def member_has_left(c: Gojo, member: ChatMemberUpdated):
 
-    if (
-        not member.new_chat_member
-        and member.old_chat_member.status not in {CMS.BANNED, CMS.RESTRICTED}
-        and member.old_chat_member
-    ):
-        pass
-    else:
-        return
-    db = Greetings(member.chat.id)
+@Gojo.on_message(filters.group & filters.left_chat_member, group=99)
+async def member_has_left(c: Gojo, m: Message):
+    db = Greetings(m.chat.id)
     status = db.get_goodbye_status()
     oo = db.get_goodbye_text()
     UwU = db.get_goodbye_media()
@@ -362,9 +341,9 @@ async def member_has_left(c: Gojo, member: ChatMemberUpdated):
         "chatname",
     ]
 
-    user = member.old_chat_member.user if member.old_chat_member else member.from_user
+    user = m.left_chat_member if m.left_chat_member else m.from_user
 
-    hmm = await escape_mentions_using_curly_brackets_wl(member, False, oo, parse_words)
+    hmm = await escape_mentions_using_curly_brackets_wl(user, m, oo, parse_words)
     if status:
         tek, button = await parse_button(hmm)
         button = await build_keyboard(button)
@@ -375,17 +354,21 @@ async def member_has_left(c: Gojo, member: ChatMemberUpdated):
             teks = choice(filter_reply)
         else:
             teks = tek
+
+        if not teks: #Just in case
+            teks = f"Thanks for being part of this group {user.mention}. But I don't like your arrogance and leaving the group {emoji.EYES}"
+       
         ifff = db.get_current_cleangoodbye_id()
         iii = db.get_current_cleangoodbye_settings()
         if ifff and iii:
             try:
-                await c.delete_messages(member.chat.id, int(ifff))
+                await c.delete_messages(m.chat.id, int(ifff))
             except RPCError:
                 pass
         if user.id in DEV_USERS:
             await c.send_message(
-                member.chat.id,
-                "Will miss you master :(",
+                m.chat.id,
+                f"Will miss you my master {user.mention} :(",
             )
             return
         if not teks:
@@ -393,14 +376,14 @@ async def member_has_left(c: Gojo, member: ChatMemberUpdated):
         try:
             if not UwU:
                 ooo = await c.send_message(
-                    member.chat.id,
+                    m.chat.id,
                     text=teks,
                     reply_markup=button,
                     disable_web_page_preview=True,
                 )
             elif UwU:
                 ooo = await (await send_cmd(c,mtype))(
-                    member.chat.id,
+                    m.chat.id,
                     UwU,
                     caption=teks,
                     reply_markup=button,
@@ -409,6 +392,8 @@ async def member_has_left(c: Gojo, member: ChatMemberUpdated):
             if ooo:
                 db.set_cleangoodbye_id(int(ooo.id))
             return
+        except ChannelPrivate:
+            pass
         except RPCError as e:
             LOGGER.error(e)
             LOGGER.error(format_exc(e))
@@ -541,8 +526,6 @@ async def goodbye(c: Gojo, m: Message):
             reply_markup=button,
         )
     return
-    return
-
 
 __PLUGIN__ = "greetings"
 __alt_name__ = ["welcome", "goodbye", "cleanservice"]

Powers/plugins/info.py

@@ -9,13 +9,11 @@ from pyrogram.raw.functions.channels import GetFullChannel
 from pyrogram.raw.functions.users import GetFullUser
 from pyrogram.types import Message
 
-from Powers import LOGGER, OWNER_ID
+from Powers import DEV_USERS, LOGGER, OWNER_ID, SUDO_USERS, WHITELIST_USERS
 from Powers.bot_class import Gojo
 from Powers.database.antispam_db import GBan
-from Powers.supports import get_support_staff
 from Powers.utils.custom_filters import command
 from Powers.utils.extract_user import extract_user
-from Powers.vars import Config
 
 gban_db = GBan()
 
@@ -83,10 +81,7 @@ async def user_info(c: Gojo, user, already=False):
         about = ll.full_user.about
     except Exception:
         pass
-    SUPPORT_STAFF = get_support_staff()
-    DEV_USERS = get_support_staff("dev")
-    SUDO_USERS = get_support_staff("sudo")
-    WHITELIST_USERS = get_support_staff("whitelist")
+    SUPPORT_STAFF = DEV_USERS.union(SUDO_USERS).union(WHITELIST_USERS)
     username = user.username
     first_name = user.first_name
     last_name = user.last_name
@@ -96,17 +91,17 @@ async def user_info(c: Gojo, user, already=False):
     is_restricted = user.is_restricted
     photo_id = user.photo.big_file_id if user.photo else None
     is_support = True if user_id in SUPPORT_STAFF else False
-    if user_id == Config.BOT_ID:
+    if user_id == c.me.id:
         is_support = "A person is a great support to himself"
     omp = "Hmmm.......Who is that again?"
-    if is_support or Config.BOT_ID:
+    if is_support or c.me.id:
         if user_id in DEV_USERS:
             omp = "Dev"
         elif user_id in SUDO_USERS:
             omp = "Sudoer"
         elif user_id in WHITELIST_USERS:
             omp = "Whitelist"
-        elif user_id == Config.BOT_ID:
+        elif user_id == c.me.id:
             omp = "I am the targeted user"
         elif user_id == OWNER_ID:
             omp = "Owner of the bot"
@@ -146,10 +141,15 @@ async def user_info(c: Gojo, user, already=False):
 <b>🔅 Second Name</b>: <code>{last_name}</code>
 <b>🔍 Username</b>: {("@" + username) if username else "NA"}
 <b>✍️ Bio</b>: `{about}`
-<b>🧑‍💻 Support</b>: {is_support}
-<b>🥷 Support user type</b>: <code>{omp}</code>
-<b>💣 Gbanned</b>: {gban}
-<b>☠️ Gban reason</b>: <code>{reason}</code>
+<b>🧑‍💻 Support</b>: {is_support}\n"""
+    if is_support:
+        caption += f"<b>🥷 Support user type</b>: <code>{omp}</code>\n<b>💣 Gbanned</b>: {gban}\n"
+    else:
+        caption += f"<b>💣 Gbanned</b>: {gban}\n"
+
+    if gban:
+        caption += f"<b>☠️ Gban reason</b>: <code>{reason}</code>\n"
+    caption += f"""
 <b>🌐 DC ID</b>: {dc_id}
 <b>✋ RESTRICTED</b>: {is_restricted}
 <b>✅ VERIFIED</b>: {is_verified}
@@ -157,7 +157,6 @@ async def user_info(c: Gojo, user, already=False):
 <b>⚠️ SCAM</b> : {is_scam} 
 <b>🤖 BOT</b>: {is_bot}
 <b>👀 Last seen</b>: <code>{last_date}</code>
-
 """
 
     return caption, photo_id
@@ -242,8 +241,12 @@ async def info_func(c: Gojo, message: Message):
     if message.reply_to_message and message.reply_to_message.sender_chat:
         await message.reply_text("This is not a user, but rather a channel. Use `/chinfo` to fetch its information.")
         return
-    user, _, user_name = await extract_user(c, message)
-
+    try:
+        user, _, user_name = await extract_user(c, message)
+    except:
+        await message.reply_text("Got Some errors failed to fetch user info")
+        LOGGER.error(e)
+        LOGGER.error(format_exc)
     if not user:
         await message.reply_text("Can't find user to fetch info!")
 
@@ -281,6 +284,10 @@ async def info_func(c: Gojo, message: Message):
             LOGGER.error(rpc)
             LOGGER.error(format_exc())
     except Exception as e:
+        if e == "User not found ! Error: 'InputPeerChannel' object has no attribute 'user_id'":
+            await m.reply_text("Looks like you are trying to fetch info of a chat not an user. In that case please use /chinfo")
+            return
+        
         await message.reply_text(text=e)
         LOGGER.error(e)
         LOGGER.error(format_exc())

Powers/plugins/locks.py

@@ -1,21 +1,20 @@
 from asyncio import sleep
+from datetime import datetime, timedelta
 from traceback import format_exc
 
 from pyrogram import filters
 from pyrogram.enums import MessageEntityType as MET
+from pyrogram.enums import MessageServiceType as MST
 from pyrogram.errors import ChatAdminRequired, ChatNotModified, RPCError
-from pyrogram.types import ChatPermissions, Message
+from pyrogram.types import CallbackQuery, ChatPermissions, Message
 
-from Powers import LOGGER
+from Powers import DEV_USERS, LOGGER, SUDO_USERS
 from Powers.bot_class import Gojo
 from Powers.database.approve_db import Approve
 from Powers.database.locks_db import LOCKS
-from Powers.supports import get_support_staff
 from Powers.utils.caching import ADMIN_CACHE, admin_cache_reload
 from Powers.utils.custom_filters import command, restrict_filter
-from Powers.vars import Config
-
-SUDO_LEVEL = get_support_staff("sudo_level")
+from Powers.utils.kbhelpers import ikb
 
 l_t = """
 **Lock Types:**
@@ -35,7 +34,10 @@ l_t = """
 - `forwardall` = Forwarding from channel and user
 - `forwardu` = Forwarding from user
 - `forwardc` = Forwarding from channel
-- `links | url` = Lock links"""
+- `links | url` = Lock links
+- `bot` = Adding bot will be forbidden
+"""
+
 
 @Gojo.on_message(command("locktypes"))
 async def lock_types(_, m: Message):
@@ -67,11 +69,12 @@ async def lock_perm(c: Gojo, m: Message):
     invite = get_perm.can_invite_users
     pin = get_perm.can_pin_messages
     stickers = animations = games = inlinebots = None
+    lock = LOCKS()
 
     if lock_type == "all":
         try:
             await c.set_chat_permissions(chat_id, ChatPermissions())
-            LOGGER.info(f"{m.from_user.id} locked all permissions in {m.chat.id}")
+            lock.insert_lock_channel(m.chat.id, "all")
         except ChatNotModified:
             pass
         except ChatAdminRequired:
@@ -80,8 +83,6 @@ async def lock_perm(c: Gojo, m: Message):
         await prevent_approved(m)
         return
 
-    lock = LOCKS()
-
     if lock_type == "msg":
         msg = False
         perm = "messages"
@@ -125,6 +126,13 @@ async def lock_perm(c: Gojo, m: Message):
     elif lock_type == "pin":
         pin = False
         perm = "pin"
+    elif lock_type == "bot":
+        curr = lock.insert_lock_channel(m.chat.id, "bot")
+        if not curr:
+            await m.reply_text("It is already on")
+            return
+        await m.reply_text("Restricted adding bots in the chat.")
+        return
     elif lock_type in ["links", "url"]:
         curr = lock.insert_lock_channel(m.chat.id, "anti_links")
         if not curr:
@@ -133,28 +141,28 @@ async def lock_perm(c: Gojo, m: Message):
         await m.reply_text("Locked links in the chat")
         return
     elif lock_type == "anonchannel":
-        curr = lock.insert_lock_channel(m.chat.id,"anti_c_send")
+        curr = lock.insert_lock_channel(m.chat.id, "anti_c_send")
         if not curr:
             await m.reply_text("It is already on")
             return
         await m.reply_text("Locked Send As Chat")
         return
     elif lock_type == "forwardall":
-        curr = lock.insert_lock_channel(m.chat.id,"anti_fwd")
+        curr = lock.insert_lock_channel(m.chat.id, "anti_fwd")
         if not curr:
             await m.reply_text("It is already on")
             return
         await m.reply_text("Locked Forward from user as well as channel")
         return
     elif lock_type == "forwardu":
-        curr = lock.insert_lock_channel(m.chat.id,"anti_fwd_u")
+        curr = lock.insert_lock_channel(m.chat.id, "anti_fwd_u")
         if not curr:
             await m.reply_text("It is already on")
             return
         await m.reply_text("Locked Forward message from user")
         return
     elif lock_type == "forwardc":
-        curr = lock.insert_lock_channel(m.chat.id,"anti_fwd_c")
+        curr = lock.insert_lock_channel(m.chat.id, "anti_fwd_c")
         if not curr:
             await m.reply_text("It is already on")
             return
@@ -174,7 +182,8 @@ Use /locktypes to get the lock types"""
             ChatPermissions(
                 can_send_messages=msg,
                 can_send_media_messages=media,
-                can_send_other_messages=any([stickers, animations, games, inlinebots]),
+                can_send_other_messages=any(
+                    [stickers, animations, games, inlinebots]),
                 can_add_web_page_previews=webprev,
                 can_send_polls=polls,
                 can_change_info=info,
@@ -182,7 +191,6 @@ Use /locktypes to get the lock types"""
                 can_pin_messages=pin,
             ),
         )
-        LOGGER.info(f"{m.from_user.id} locked selected permissions in {m.chat.id}")
     except ChatNotModified:
         pass
     except ChatAdminRequired:
@@ -205,24 +213,13 @@ async def view_locks(_, m: Message):
         return "❌"
 
     lock = LOCKS()
-    anti_c_send = lock.get_lock_channel("anti_c_send")
-    anti_forward = lock.get_lock_channel("anti_fwd")
-    anti_forward_u = lock.get_lock_channel("anti_fwd_u")
-    anti_forward_c = lock.get_lock_channel("anti_fwd_c")
-    anti_links = lock.get_lock_channel("anti_links")
-    anon = False
-    if m.chat.id in anti_c_send:
-        anon = True
-    anti_f = anti_f_u = anti_f_c = False
-    if m.chat.id in anti_forward:
-        anti_f = True
-    if m.chat.id in anti_forward_u:
-        anti_f_u = True
-    if m.chat.id in anti_forward_c:
-        anti_f_c = True
-    antil = False
-    if m.chat.id in anti_links:
-        antil = True
+    anon = lock.get_lock_channel(m.chat.id, "anti_c_send")
+    anti_f = lock.get_lock_channel(m.chat.id, "anti_fwd")
+    anti_f_u = lock.get_lock_channel(m.chat.id, "anti_fwd_u")
+    anti_f_c = lock.get_lock_channel(m.chat.id, "anti_fwd_c")
+    antil = lock.get_lock_channel(m.chat.id, "anti_links")
+    bots = lock.get_lock_channel(m.chat.id, "bot")
+
     vmsg = await convert_to_emoji(v_perm.can_send_messages)
     vmedia = await convert_to_emoji(v_perm.can_send_media_messages)
     vother = await convert_to_emoji(v_perm.can_send_other_messages)
@@ -236,6 +233,7 @@ async def view_locks(_, m: Message):
     vantiu = await convert_to_emoji(anti_f_u)
     vantic = await convert_to_emoji(anti_f_c)
     vantil = await convert_to_emoji(antil)
+    vantibot = await convert_to_emoji(bots)
 
     if v_perm is not None:
         try:
@@ -256,11 +254,9 @@ async def view_locks(_, m: Message):
       <b>Can forward:</b> {vanti}
       <b>Can forward from user:</b> {vantiu}
       <b>Can forward from channel and chats:</b> {vantic}
-      <b>Can send links:</b> {antil}
+      <b>Can send links:</b> {vantil}
+      <b>Can bot send messages:</b> {vantibot}
       """
-            LOGGER.info(f"{m.from_user.id} used locks cmd in {m.chat.id}")
-            await chkmsg.edit_text(permission_view_str)
-
         except RPCError as e_f:
             await chkmsg.edit_text(text="Something went wrong!")
             await m.reply_text(e_f)
@@ -279,6 +275,7 @@ async def unlock_perm(c: Gojo, m: Message):
         await m.reply_text(text="Specify a permission to unlock!")
         return
 
+    lock = LOCKS()
     if unlock_type == "all":
         try:
             await c.set_chat_permissions(
@@ -294,7 +291,7 @@ async def unlock_perm(c: Gojo, m: Message):
                     can_pin_messages=True,
                 ),
             )
-            LOGGER.info(f"{m.from_user.id} unlocked all permissions in {m.chat.id}")
+            lock.remove_lock_channel(m.chat.id, "all")
         except ChatNotModified:
             pass
         except ChatAdminRequired:
@@ -314,8 +311,6 @@ async def unlock_perm(c: Gojo, m: Message):
     upin = get_uperm.can_pin_messages
     ustickers = uanimations = ugames = uinlinebots = None
 
-    lock = LOCKS()
-
     if unlock_type == "msg":
         umsg = True
         uperm = "messages"
@@ -359,16 +354,22 @@ async def unlock_perm(c: Gojo, m: Message):
     elif unlock_type == "pin":
         upin = True
         uperm = "pin"
+    elif unlock_type == "bot":
+        curr = lock.remove_lock_channel(m.chat.id, "bot")
+        if not curr:
+            m.reply_text("User already can add bots in the chat")
+            return
+        await m.reply_text("User are now allowed to add bots in the chat.")
     elif unlock_type == "anonchannel":
-        curr = lock.remove_lock_channel(m.chat.id,"anti_c_send")
-        
+        curr = lock.remove_lock_channel(m.chat.id, "anti_c_send")
+
         if not curr:
             await m.reply_text("Send as chat is not allowed in this chat")
             return
         await m.reply_text("Send as chat is now enabled for this chat")
         return
     elif unlock_type in ["links", "url"]:
-        curr = lock.remove_lock_channel(m.chat.id,"anti_links")
+        curr = lock.remove_lock_channel(m.chat.id, "anti_links")
         if curr:
             await m.reply_text("Sending link is now allowed")
             return
@@ -376,33 +377,33 @@ async def unlock_perm(c: Gojo, m: Message):
             await m.reply_text("Sending link is not allowed")
             return
     elif unlock_type == "forwardall":
-        curr = lock.remove_lock_channel(m.chat.id,"anti_fwd")
-    
+        curr = lock.remove_lock_channel(m.chat.id, "anti_fwd")
+
         if not curr:
             await m.reply_text("Forwarding content is not allowed in this chat")
             return
         await m.reply_text("Forwarding content is now enabled for this chat")
         return
-        
+
     elif unlock_type == "forwardu":
-        curr = lock.remove_lock_channel(m.chat.id,"anti_fwd_u")
-        
+        curr = lock.remove_lock_channel(m.chat.id, "anti_fwd_u")
+
         if not curr:
             await m.reply_text("Forwarding content from users is not allowed in this chat")
             return
-        
+
         await m.reply_text("Forwarding content from users is now enabled for this chat")
         return
-        
+
     elif unlock_type == "forwardc":
-        curr = lock.remove_lock_channel(m.chat.id,"anti_fwd_c")
-        
+        curr = lock.remove_lock_channel(m.chat.id, "anti_fwd_c")
+
         if not curr:
             await m.reply_text("Forwarding content from channel is not allowed in this chat")
             return
         await m.reply_text("Forwarding content from channel is now enabled for this chat")
         return
-        
+
     else:
         await m.reply_text(
             text="""Invalid Lock Type!
@@ -412,7 +413,6 @@ async def unlock_perm(c: Gojo, m: Message):
         return
 
     try:
-        LOGGER.info(f"{m.from_user.id} unlocked selected permissions in {m.chat.id}")
         await c.set_chat_permissions(
             chat_id,
             ChatPermissions(
@@ -438,7 +438,8 @@ async def unlock_perm(c: Gojo, m: Message):
     await prevent_approved(m)
     return
 
-async def delete_messages(c:Gojo, m: Message):
+
+async def delete_messages(c: Gojo, m: Message):
     try:
         await m.delete()
         return
@@ -447,63 +448,87 @@ async def delete_messages(c:Gojo, m: Message):
         LOGGER.error(format_exc())
         return
 
-async def is_approved_user(c:Gojo, m: Message):
+
+async def is_approved_user(c: Gojo, m: Message):
     approved_users = Approve(m.chat.id).list_approved()
     ul = [user[0] for user in approved_users]
     try:
         admins_group = {i[0] for i in ADMIN_CACHE[m.chat.id]}
     except KeyError:
         admins_group = await admin_cache_reload(m, "lock")
-    
+
+    SUDO_LEVEL = DEV_USERS.union(SUDO_USERS)
+
     if m.forward_from:
-        if m.from_user.id in ul or m.from_user.id in SUDO_LEVEL or m.from_user.id in admins_group or m.from_user.id == Config.BOT_ID:
+        if m.from_user and (m.from_user.id in ul or m.from_user.id in SUDO_LEVEL or m.from_user.id in admins_group or m.from_user.id == c.me.id):
             return True
         return False
     elif m.forward_from_chat:
-        x_chat = (await c.get_chat(m.forward_from_chat.id)).linked_chat
-        if m.from_user.id in ul or m.from_user.id in SUDO_LEVEL or m.from_user.id in admins_group or m.from_user.id == Config.BOT_ID:
+        if m.from_user and (m.from_user.id in ul or m.from_user.id in SUDO_LEVEL or m.from_user.id in admins_group or m.from_user.id == c.me.id):
             return True
-        if not x_chat:
-            return False
-        elif x_chat and x_chat.id == m.chat.id:
+        elif m.automatic_forward:
             return True
+        else:
+            return False
     elif m.from_user:
-        if m.from_user.id in ul or m.from_user.id in SUDO_LEVEL or m.from_user.id in admins_group or m.from_user.id == Config.BOT_ID:
+        if m.from_user.id in ul or m.from_user.id in SUDO_LEVEL or m.from_user.id in admins_group or m.from_user.id == c.me.id:
             return True
         return False
+    else:
+        return False
 
-@Gojo.on_message(filters.group & ~filters.me,18)
-async def lock_del_mess(c:Gojo, m: Message):
-    lock = LOCKS()
-    all_chats = lock.get_lock_channel()
-    if not all_chats:
+
+@Gojo.on_message(filters.service & filters.group, 19)
+async def servicess(c: Gojo, m: Message):
+    if m.service != MST.NEW_CHAT_MEMBERS:
         return
-    if m.chat.id not in all_chats:
+    approved = await is_approved_user(c, m)
+    if approved:
         return
-    if m.sender_chat and not (m.forward_from_chat or m.forward_from):
-        if m.sender_chat.id == m.chat.id:
+    for i in m.new_chat_members:
+        if i.is_bot:
+            try:
+                timee = datetime.now() + timedelta(minutes=5)
+                await m.chat.ban_member(i.id, until_date=timee)
+                sleep(1)
+            except Exception as ef:
+                LOGGER.error(ef)
+                LOGGER.error(format_exc())
+    return
+
+
+@Gojo.on_message(filters.group & ~filters.me, 3)
+async def lock_del_mess(c: Gojo, m: Message):
+    lock = LOCKS()
+    chat_locks = lock.get_lock_channel(m.chat.id)
+    if not chat_locks:
+        return
+
+    if chat_locks["anti_channel"] and m.sender_chat and not (m.forward_from_chat or m.forward_from):
+        if m.chat.is_admin:
             return
-        await delete_messages(c,m)
+        await delete_messages(c, m)
+        return
+    is_approved = await is_approved_user(c, m)
+    if is_approved:
         return
-    is_approved = await is_approved_user(c,m)
     entity = m.entities if m.text else m.caption_entities
-    if entity:
+    if entity and chat_locks["anti_links"]:
         for i in entity:
             if i.type in [MET.URL or MET.TEXT_LINK]:
-                if not is_approved:
-                    await delete_messages(c,m)
-                    return
-    elif m.forward_from or m.forward_from_chat:
-        if not is_approved:
-            if lock.is_particular_lock(m.chat.id,"anti_fwd"):
-                await delete_messages(c,m)
-                return
-            elif lock.is_particular_lock(m.chat.id,"anti_fwd_u") and not m.forward_from_chat:
-                await delete_messages(c,m)
-                return
-            elif lock.is_particular_lock(m.chat.id,"anti_fwd_c") and m.forward_from_chat:
-                await delete_messages(c,m)
+                await delete_messages(c, m)
                 return
+    elif any(chat_locks["anti_fwd"].values()) and (m.forward_from or m.forward_from_chat):
+        if all(chat_locks["anti_fwd"].values()):
+            await delete_messages(c, m)
+            return
+        elif chat_locks["anti_fwd"]["user"] and not m.forward_from_chat:
+            await delete_messages(c, m)
+            return
+        elif chat_locks["anti_fwd"]["chat"] and m.forward_from_chat:
+            await delete_messages(c, m)
+            return
+
 
 async def prevent_approved(m: Message):
     approved_users = Approve(m.chat.id).list_approved()
@@ -513,7 +538,6 @@ async def prevent_approved(m: Message):
             await m.chat.unban_member(user_id=i)
         except (ChatAdminRequired, ChatNotModified, RPCError):
             continue
-        LOGGER.info(f"Approved {i} in {m.chat.id}")
         await sleep(0.1)
     return
 
@@ -525,7 +549,7 @@ __alt_name__ = ["grouplock", "lock", "grouplocks"]
 __buttons__ = [
     [
         ("Lock Types", "LOCK_TYPES"),
-    ],]
+    ], ]
 
 __HELP__ = """
 **Locks**
@@ -541,3 +565,21 @@ Allows you to lock and unlock permission types in the chat.
 
 **Example:**
 `/lock media`: this locks all the media messages in the chat."""
+
+
+@Gojo.on_callback_query(filters.regex("^LOCK_TYPES"))
+async def lock_types_callback(c: Gojo, q: CallbackQuery):
+    data = q.data
+
+    if data == "LOCK_TYPES":
+        kb = ikb([[("Back", "LOCK_TYPES_back")]])
+        await q.edit_message_caption(
+            l_t,
+            reply_markup=kb
+        )
+    else:
+        kb = ikb([[("Lock Types", "LOCK_TYPES")]])
+        await q.edit_message_caption(
+            __HELP__,
+            reply_markup=kb
+        )

Powers/plugins/muting.py

@@ -9,18 +9,15 @@ from pyrogram.types import (CallbackQuery, ChatPermissions,
                             InlineKeyboardButton, InlineKeyboardMarkup,
                             Message)
 
-from Powers import LOGGER, MESSAGE_DUMP, OWNER_ID
+from Powers import DEV_USERS, LOGGER, MESSAGE_DUMP, SUDO_USERS, WHITELIST_USERS
 from Powers.bot_class import Gojo
-from Powers.supports import get_support_staff
 from Powers.utils.caching import ADMIN_CACHE, admin_cache_reload
 from Powers.utils.custom_filters import command, restrict_filter
 from Powers.utils.extract_user import extract_user
 from Powers.utils.extras import MUTE_GIFS
 from Powers.utils.parser import mention_html
 from Powers.utils.string import extract_time
-from Powers.vars import Config
 
-SUPPORT_STAFF = get_support_staff()
 
 @Gojo.on_message(command("tmute") & restrict_filter)
 async def tmute_usr(c: Gojo, m: Message):
@@ -36,14 +33,14 @@ async def tmute_usr(c: Gojo, m: Message):
     if not user_id:
         await m.reply_text("Cannot find user to mute !")
         return
-    if user_id == Config.BOT_ID:
+    if user_id == c.me.id:
         await m.reply_text("Huh, why would I mute myself?")
         return
 
+    SUPPORT_STAFF = DEV_USERS.union(SUDO_USERS).union(WHITELIST_USERS)
+
     if user_id in SUPPORT_STAFF:
-        LOGGER.info(
-            f"{m.from_user.id} trying to mute {user_id} (SUPPORT_STAFF) in {m.chat.id}",
-        )
+        
         await m.reply_text(
             text="This user is in my support staff, cannot restrict them."
         )
@@ -86,7 +83,6 @@ async def tmute_usr(c: Gojo, m: Message):
             ChatPermissions(),
             mutetime,
         )
-        LOGGER.info(f"{m.from_user.id} tmuted {user_id} in {m.chat.id}")
         admin = await mention_html(m.from_user.first_name, m.from_user.id)
         muted = await mention_html(user_first_name, user_id)
         txt = f"Admin {admin} muted {muted}!"
@@ -148,14 +144,13 @@ async def dtmute_usr(c: Gojo, m: Message):
     if not user_id:
         await m.reply_text("Cannot find user to mute !")
         return
-    if user_id == Config.BOT_ID:
+    if user_id == c.me.id:
         await m.reply_text("Huh, why would I mute myself?")
         return
 
+    SUPPORT_STAFF = DEV_USERS.union(SUDO_USERS).union(WHITELIST_USERS)
     if user_id in SUPPORT_STAFF:
-        LOGGER.info(
-            f"{m.from_user.id} trying to mute {user_id} (SUPPORT_STAFF) in {m.chat.id}",
-        )
+        
         await m.reply_text(
             text="This user is in my support staff, cannot restrict them."
         )
@@ -196,7 +191,6 @@ async def dtmute_usr(c: Gojo, m: Message):
             ChatPermissions(),
             mutetime,
         )
-        LOGGER.info(f"{m.from_user.id} dtmuted {user_id} in {m.chat.id}")
         await m.reply_to_message.delete()
         admin = await mention_html(m.from_user.first_name, m.from_user.id)
         muted = await mention_html(user_first_name, user_id)
@@ -256,14 +250,12 @@ async def stmute_usr(c: Gojo, m: Message):
     if not user_id:
         await m.reply_text("Cannot find user to mute !")
         return
-    if user_id == Config.BOT_ID:
+    if user_id == c.me.id:
         await m.reply_text("Huh, why would I mute myself?")
         return
 
+    SUPPORT_STAFF = DEV_USERS.union(SUDO_USERS).union(WHITELIST_USERS)
     if user_id in SUPPORT_STAFF:
-        LOGGER.info(
-            f"{m.from_user.id} trying to mute {user_id} (SUPPORT_STAFF) in {m.chat.id}",
-        )
         await m.reply_text(
             text="This user is in my support staff, cannot restrict them."
         )
@@ -305,7 +297,6 @@ async def stmute_usr(c: Gojo, m: Message):
             ChatPermissions(),
             mutetime,
         )
-        LOGGER.info(f"{m.from_user.id} stmuted {user_id} in {m.chat.id}")
         await m.delete()
         if m.reply_to_message:
             await m.reply_to_message.delete()
@@ -349,14 +340,13 @@ async def mute_usr(c: Gojo, m: Message):
     if not user_id:
         await m.reply_text("Cannot find user to mute")
         return
-    if user_id == Config.BOT_ID:
+    if user_id == c.me.id:
         await m.reply_text("Huh, why would I mute myself?")
         return
 
+    SUPPORT_STAFF = DEV_USERS.union(SUDO_USERS).union(WHITELIST_USERS)
     if user_id in SUPPORT_STAFF:
-        LOGGER.info(
-            f"{m.from_user.id} trying to mute {user_id} (SUPPORT_STAFF) in {m.chat.id}",
-        )
+        
         await m.reply_text(
             text="This user is in my support staff, cannot restrict them."
         )
@@ -376,7 +366,6 @@ async def mute_usr(c: Gojo, m: Message):
             user_id,
             ChatPermissions(),
         )
-        LOGGER.info(f"{m.from_user.id} muted {user_id} in {m.chat.id}")
         admin = await mention_html(m.from_user.first_name, m.from_user.id)
         muted = await mention_html(user_first_name, user_id)
         txt = f"Admin {admin} muted {muted}!"
@@ -434,14 +423,13 @@ async def smute_usr(c: Gojo, m: Message):
     if not user_id:
         await m.reply_text("Cannot find user to mute")
         return
-    if user_id == Config.BOT_ID:
+    if user_id == c.me.id:
         await m.reply_text("Huh, why would I mute myself?")
         return
 
+    SUPPORT_STAFF = DEV_USERS.union(SUDO_USERS).union(WHITELIST_USERS)
+
     if user_id in SUPPORT_STAFF:
-        LOGGER.info(
-            f"{m.from_user.id} trying to mute {user_id} (SUPPORT_STAFF) in {m.chat.id}",
-        )
         await m.reply_text(
             text="This user is in my support staff, cannot restrict them."
         )
@@ -461,7 +449,6 @@ async def smute_usr(c: Gojo, m: Message):
             user_id,
             ChatPermissions(),
         )
-        LOGGER.info(f"{m.from_user.id} smuted {user_id} in {m.chat.id}")
         await m.delete()
         if m.reply_to_message:
             await m.reply_to_message.delete()
@@ -505,14 +492,13 @@ async def dmute_usr(c: Gojo, m: Message):
     if not user_id:
         await m.reply_text("Cannot find user to mute")
         return
-    if user_id == Config.BOT_ID:
+    if user_id == c.me.id:
         await m.reply_text("Huh, why would I mute myself?")
         return
 
+
+    SUPPORT_STAFF = DEV_USERS.union(SUDO_USERS).union(WHITELIST_USERS)
     if user_id in SUPPORT_STAFF:
-        LOGGER.info(
-            f"{m.from_user.id} trying to mute {user_id} (SUPPORT_STAFF) in {m.chat.id}",
-        )
         await m.reply_text(
             text="This user is in my support staff, cannot restrict them."
         )
@@ -532,7 +518,6 @@ async def dmute_usr(c: Gojo, m: Message):
             user_id,
             ChatPermissions(),
         )
-        LOGGER.info(f"{m.from_user.id} dmuted {user_id} in {m.chat.id}")
         await m.reply_to_message.delete()
         admin = await mention_html(m.from_user.first_name, m.from_user.id)
         muted = await mention_html(user_first_name, user_id)
@@ -587,7 +572,7 @@ async def unmute_usr(c: Gojo, m: Message):
     except Exception:
         return
 
-    if user_id == Config.BOT_ID:
+    if user_id == c.me.id:
         await m.reply_text("Huh, why would I unmute myself if you are using me?")
         return
     try:
@@ -600,7 +585,6 @@ async def unmute_usr(c: Gojo, m: Message):
         LOGGER.exception(format_exc())
     try:
         await m.chat.unban_member(user_id)
-        LOGGER.info(f"{m.from_user.id} unmuted {user_id} in {m.chat.id}")
         admin = await mention_html(m.from_user.first_name, m.from_user.id)
         unmuted = await mention_html(user_first_name, user_id)
         await m.reply_text(text=f"Admin {admin} unmuted {unmuted}!")
@@ -626,14 +610,14 @@ async def unmutebutton(c: Gojo, q: CallbackQuery):
     user_id = int(splitter[1])
     user = await q.message.chat.get_member(q.from_user.id)
 
-    if not user:
+    if not user or not user.privileges:
         await q.answer(
             "You don't have enough permission to do this!\nStay in your limits!",
             show_alert=True,
         )
         return
 
-    if not user.privileges.can_restrict_members and user.id != OWNER_ID:
+    if not user.privileges.can_restrict_members:
         await q.answer(
             "You don't have enough permission to do this!\nStay in your limits!",
             show_alert=True,

Powers/plugins/notes.py

@@ -4,7 +4,7 @@ from traceback import format_exc
 from pyrogram import enums, filters
 from pyrogram.enums import ChatMemberStatus as CMS
 from pyrogram.errors import RPCError
-from pyrogram.types import CallbackQuery, InlineKeyboardMarkup, Message
+from pyrogram.types import CallbackQuery, Message
 
 from Powers import LOGGER
 from Powers.bot_class import Gojo
@@ -16,7 +16,6 @@ from Powers.utils.msg_types import Types, get_note_type
 from Powers.utils.string import (build_keyboard,
                                  escape_mentions_using_curly_brackets,
                                  parse_button)
-from Powers.vars import Config
 
 # Initialise
 db = Notes()
@@ -60,7 +59,6 @@ async def save_note(_, m: Message):
         return
 
     db.save_note(m.chat.id, note_name, text, data_type, content)
-    LOGGER.info(f"{m.from_user.id} saved note ({note_name}) in {m.chat.id}")
     await m.reply_text(
         f"Saved note <code>{note_name}</code>!\nGet it with <code>/get {note_name}</code> or <code>#{note_name}</code>",
     )
@@ -84,7 +82,7 @@ async def get_note_func(c: Gojo, m: Message, note_name, priv_notes_status):
                     [
                         (
                             "Click Me!",
-                            f"https://t.me/{Config.BOT_USERNAME}?start=note_{m.chat.id}_{note_hash}",
+                            f"https://t.me/{c.me.username}?start=note_{m.chat.id}_{note_hash}",
                             "url",
                         ),
                     ],
@@ -194,9 +192,7 @@ async def get_note_func(c: Gojo, m: Message, note_name, priv_notes_status):
                 reply_markup=button,
                 reply_to_message_id=reply_msg_id,
             )
-        LOGGER.info(
-            f"{m.from_user.id} fetched note {note_name} (type - {getnotes}) in {m.chat.id}",
-        )
+        
     except Exception as e:
         await m.reply_text(f"Error in notes: {e}")
     return
@@ -245,9 +241,7 @@ async def get_raw_note(c: Gojo, m: Message, note: str):
             parse_mode=enums.ParseMode.DISABLED,
             reply_to_message_id=msg_id,
         )
-    LOGGER.info(
-        f"{m.from_user.id} fetched raw note {note} (type - {getnotes}) in {m.chat.id}",
-    )
+    
     return
 
 
@@ -302,11 +296,9 @@ async def priv_notes(_, m: Message):
         option = (m.text.split())[1]
         if option in ("on", "yes"):
             db_settings.set_privatenotes(chat_id, True)
-            LOGGER.info(f"{m.from_user.id} enabled privatenotes in {m.chat.id}")
             msg = "Set private notes to On"
         elif option in ("off", "no"):
             db_settings.set_privatenotes(chat_id, False)
-            LOGGER.info(f"{m.from_user.id} disabled privatenotes in {m.chat.id}")
             msg = "Set private notes to Off"
         else:
             msg = "Enter correct option"
@@ -314,7 +306,6 @@ async def priv_notes(_, m: Message):
     elif len(m.text.split()) == 1:
         curr_pref = db_settings.get_privatenotes(m.chat.id)
         msg = msg = f"Private Notes: {curr_pref}"
-        LOGGER.info(f"{m.from_user.id} fetched privatenotes preference in {m.chat.id}")
         await m.reply_text(msg)
     else:
         await m.replt_text("Check help on how to use this command!")
@@ -323,8 +314,7 @@ async def priv_notes(_, m: Message):
 
 
 @Gojo.on_message(command("notes") & filters.group & ~filters.bot)
-async def local_notes(_, m: Message):
-    LOGGER.info(f"{m.from_user.id} listed all notes in {m.chat.id}")
+async def local_notes(c: Gojo, m: Message):
     getnotes = db.get_all_notes(m.chat.id)
 
     if not getnotes:
@@ -341,7 +331,7 @@ async def local_notes(_, m: Message):
                 [
                     (
                         "All Notes",
-                        f"https://t.me/{Config.BOT_USERNAME}?start=notes_{m.chat.id}",
+                        f"https://t.me/{c.me.username}?start=notes_{m.chat.id}",
                         "url",
                     ),
                 ],
@@ -372,7 +362,6 @@ async def clear_note(_, m: Message):
 
     note = m.text.split()[1].lower()
     getnote = db.rm_note(m.chat.id, note)
-    LOGGER.info(f"{m.from_user.id} cleared note ({note}) in {m.chat.id}")
     if not getnote:
         await m.reply_text("This note does not exist!")
         return
@@ -415,7 +404,6 @@ async def clearallnotes_callback(_, q: CallbackQuery):
         )
         return
     db.rm_all_notes(q.message.chat.id)
-    LOGGER.info(f"{user_id} removed all notes in {q.message.chat.id}")
     await q.message.edit_text("Cleared all notes!")
     return
 

Powers/plugins/pin.py

@@ -26,9 +26,7 @@ async def pin_message(_, m: Message):
             await m.reply_to_message.pin(
                 disable_notification=disable_notification,
             )
-            LOGGER.info(
-                f"{m.from_user.id} pinned msgid-{m.reply_to_message.id} in {m.chat.id}",
-            )
+            
 
             if m.chat.username:
                 # If chat has a username, use this format
@@ -71,9 +69,7 @@ async def unpin_message(c: Gojo, m: Message):
     try:
         if m.reply_to_message:
             await m.reply_to_message.unpin()
-            LOGGER.info(
-                f"{m.from_user.id} unpinned msgid: {m.reply_to_message.id} in {m.chat.id}",
-            )
+            
             await m.reply_text(text="Unpinned last message.")
         else:
             m_id = (await c.get_chat(m.chat.id)).pinned_message.id
@@ -121,7 +117,6 @@ async def unpinall_calllback(c: Gojo, q: CallbackQuery):
         return
     try:
         await c.unpin_all_chat_messages(q.message.chat.id)
-        LOGGER.info(f"{q.from_user.id} unpinned all messages in {q.message.chat.id}")
         await q.message.edit_text(text="Unpinned all messages in this chat.")
     except ChatAdminRequired:
         await q.message.edit_text(text="I'm not admin or I don't have rights.")
@@ -149,11 +144,9 @@ async def anti_channel_pin(_, m: Message):
     if len(m.text.split()) == 2:
         if m.command[1] in ("yes", "on", "true"):
             pinsdb.antichannelpin_on()
-            LOGGER.info(f"{m.from_user.id} enabled antichannelpin in {m.chat.id}")
             msg = "Turned on AntiChannelPin, now all message pinned by channel will be unpinned automtically!"
         elif m.command[1] in ("no", "off", "false"):
             pinsdb.antichannelpin_off()
-            LOGGER.info(f"{m.from_user.id} disabled antichannelpin in {m.chat.id}")
             msg = "Turned off AntiChannelPin, now all message pinned by channel will stay pinned!"
         else:
             await m.reply_text(
@@ -201,11 +194,9 @@ async def clean_linked(_, m: Message):
     if len(m.text.split()) == 2:
         if m.command[1] in ("yes", "on", "true"):
             pinsdb.cleanlinked_on()
-            LOGGER.info(f"{m.from_user.id} enabled CleanLinked in {m.chat.id}")
             msg = "Turned on CleanLinked! Now all the messages from linked channel will be deleted!"
         elif m.command[1] in ("no", "off", "false"):
             pinsdb.cleanlinked_off()
-            LOGGER.info(f"{m.from_user.id} disabled CleanLinked in {m.chat.id}")
             msg = "Turned off CleanLinked! Messages from linked channel will not be deleted!"
         else:
             await m.reply_text(
@@ -220,7 +211,6 @@ async def clean_linked(_, m: Message):
 @Gojo.on_message(command("permapin") & admin_filter)
 async def perma_pin(_, m: Message):
     if m.reply_to_message or len(m.text.split()) > 1:
-        LOGGER.info(f"{m.from_user.id} used permampin in {m.chat.id}")
         if m.reply_to_message:
             text = m.reply_to_message.text
         elif len(m.text.split()) > 1:

Powers/plugins/purge.py

@@ -99,7 +99,6 @@ async def spurge(c: Gojo, m: Message):
 
 @Gojo.on_message(
     command("del") & admin_filter,
-    group=9,
 )
 async def del_msg(c: Gojo, m: Message):