Progress

Powers/__init__.py

@@ -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"
@@ -55,7 +56,7 @@ 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"
@@ -126,7 +127,6 @@ SUDO_USERS = Config.SUDO_USERS
 WHITELIST_USERS = Config.WHITELIST_USERS
 
 
-
 defult_dev = [1344569458, 1432756163, 5294360309] + [int(OWNER_ID)]
 
 Defult_dev = set(defult_dev)
@@ -147,16 +147,17 @@ PREFIX_HANDLER = Config.PREFIX_HANDLER
 HELP_COMMANDS = {}  # For help menu
 UPTIME = time()  # Check bot uptime
 
-from apscheduler.schedulers.asyncio import AsyncIOScheduler
 
 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 +198,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

@@ -2,7 +2,5 @@ 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

@@ -24,7 +24,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 +44,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
@@ -68,9 +68,11 @@ class Gojo(Client):
         cmd_list = await load_cmds(await all_plugins())
         await load_support_users()
         LOGGER.info(f"Plugins Loaded: {cmd_list}")
-        scheduler.add_job(clean_my_db,'cron',[self],hour=3,minute=0,second=0)
+        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!

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/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,61 @@ 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}")
+            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,14 @@ class Blacklist(MongoDB):
                 "reason": "Automated blacklisted word: {{}}",
             }
             self.insert_one(new_data)
-            LOGGER.info(f"Initialized Blacklist Document for chat {self.chat_id}")
+            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,49 @@ 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 
-    
+            return
+
     def is_already_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["message_id"]
         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

Powers/database/disable_db.py

@@ -146,9 +146,11 @@ 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}")
+                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 +165,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

@@ -71,7 +71,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,14 @@ 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}")
+            LOGGER.info(
+                f"Initialized Greetings Document for chat {self.chat_id}")
             return new_data
         return chat_data
 
@@ -173,7 +175,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,10 +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"]
+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:
@@ -20,21 +23,21 @@ class LOCKS(MongoDB):
         """
         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})
+                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})
+        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):
@@ -43,40 +46,41 @@ class LOCKS(MongoDB):
         """
         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})
+                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})
+        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", chat:int = 0):
+    def get_lock_channel(self, locktype: str = "all", chat: int = 0):
         """
         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", "bot", "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}
+                find = {"locktype": locktype}
             if chat:
                 if find:
-                    curr = self.find_one({"chat_id":chat, "locktype":locktype})
+                    curr = self.find_one(
+                        {"chat_id": chat, "locktype": locktype})
                     return bool(curr)
                 else:
                     to_return = []
                     for i in lock_t:
-                        curr = self.find_one({"chat_id":chat, "locktype":i})
+                        curr = self.find_one({"chat_id": chat, "locktype": i})
                         to_return.append(bool(curr))
                     return all(to_return)
-            else:    
+            else:
                 curr = self.find_all(find)
                 if not curr:
                     list_ = []
@@ -86,15 +90,15 @@ class LOCKS(MongoDB):
 
     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
@@ -103,9 +107,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

@@ -68,7 +68,7 @@ class Pins(MongoDB):
 
     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,11 @@ 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}")
+            LOGGER.info(
+                f"Initialized Language Document for chat {self.chat_id}")
             return new_data
         return chat_data
 
@@ -57,7 +59,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,8 @@ 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}")
+            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,7 +67,8 @@ 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

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,8 @@ class Warns(MongoDB):
                 "num_warns": 0,
             }
             self.insert_one(new_data)
-            LOGGER.info(f"Initialized Warn Document for {user_id} in {self.chat_id}")
+            LOGGER.info(
+                f"Initialized Warn Document for {user_id} in {self.chat_id}")
             return new_data
         return chat_data
 
@@ -123,9 +126,11 @@ 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}")
+            LOGGER.info(
+                f"Initialized Warn Settings Document for {self.chat_id}")
             return new_data
         return chat_data
 
@@ -140,7 +145,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/captcha.py

@@ -0,0 +1,230 @@
+from random import shuffle
+from traceback import format_exc
+
+import pyrogram
+from pyrogram import filters
+from pyrogram.types import CallbackQuery, ChatMemberUpdated, ChatPermissions
+from pyrogram.types import InlineKeyboardButton as IKB
+from pyrogram.types import InlineKeyboardMarkup as ikm
+from pyrogram.types import Message
+
+from Powers import LOGGER
+from Powers.bot_class import Gojo
+from Powers.database.captcha_db import CAPTCHA, CAPTCHA_DATA
+from Powers.supports import get_support_staff
+from Powers.utils.captcha_helper import (genrator, get_image_captcha,
+                                         get_qr_captcha)
+from Powers.utils.custom_filters import admin_filter, command
+
+
+@Gojo.on_message(command("captcha") & admin_filter & ~filters.private)
+async def start_captcha(c: Gojo, 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":
+            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:
+            new_cap = f"You have zero tries left now. I am going to kick you know coz you failed to solve captcha...see yaa {q.from_user.mention}"
+            try:
+                await q.message.chat.ban_member(user)
+            except Exception as e:
+                await q.message.reply_text("Failed to kick member")
+                return
+            await q.message.delete()
+            await q.message.reply_text(new_cap)
+            await c.unban_chat_member(chat, user)
+
+        else:
+            await q.edit_message_caption(new_cap, reply_markup=q.message.reply_markup)
+            return
+
+
+@Gojo.on_chat_member_updated(filters.group, group=3)
+async def on_chat_members_updatess(c: Gojo, u: ChatMemberUpdated):
+    chat = u.chat.id
+
+    if u.new_chat_member:
+
+        user = u.new_chat_member.user.id
+        userr = u.new_chat_member.user
+
+        is_qr = CAPTCHA().is_captcha(chat)
+        if not is_qr:
+            return
+
+        captcha = CAPTCHA()
+        cap_data = CAPTCHA_DATA()
+
+        SUPPORT_STAFF = get_support_staff()
+        if user in SUPPORT_STAFF:
+            return
+
+        captcha_type = captcha.get_captcha(chat)
+
+        is_already = cap_data.is_already_data(chat, user)
+
+        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 not mess:
+            cap_data.del_message_id(chat, is_already)
+            return
+
+        try:
+            await c.restrict_chat_member(chat, user, ChatPermissions())
+        except Exception as e:
+            LOGGER.error(e)
+            LOGGER.error(format_exc())
+            return
+
+        if not is_already:
+            if captcha_type == "qr":
+                pic = await get_qr_captcha(chat, user)
+                cap = f"Please {userr.mention} scan this qr code with your phone to verify that you are human"
+                ms = await c.send_photo(chat, pic, caption=cap)
+                cap_data.store_message_id(chat, user, ms.id)
+                return
+            elif captcha_type == "image":
+                img, code = await get_image_captcha(chat, user)
+                cap = f"Please {userr.mention} please choose the correct code from the one given bellow\nYou have three tries if you get all three wrong u will be kicked from the chat.\nTries left: 3"
+                cap_data.load_cap_data(chat, user, code)
+                rand = [code]
+                while len(rand) != 5:
+                    hehe = genrator()
+                    rand.append(hehe)
+
+                shuffle(rand)
+
+                ini = f"captcha_{chat}_{user}_"
+
+                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)
+                return
+        elif is_already and mess:
+            kb = ikm(
+                [
+                    [
+                        IKB("Click here to verify", url=mess.link)
+                    ]
+                ]
+            )
+            await c.send_message(f"{userr.mention} your verification is already pending", reply_markup=kb)
+            return
+        else:
+            await c.unban_chat_member(chat, user)
+            return
+
+
+__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/formatting.py

@@ -73,10 +73,12 @@ This will show button 1 and 2 on the same line, while 3 will be underneath."""
                 parse_mode=enums.ParseMode.HTML,
             )
         except MediaCaptionTooLong:
+            kb = ikb([[("Back", "DELETEEEE")]])
             await c.send_message(
                 chat_id=q.message.chat.id,
                 text=txt,
-                parse_mode=enums.ParseMode.HTML,)
+                parse_mode=enums.ParseMode.HTML,
+                reply_markup=kb)
     elif cmd == "fillings":
         await q.edit_message_caption(
             caption="""<b>Fillings</b>

Powers/plugins/locks.py

@@ -6,7 +6,7 @@ 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.bot_class import Gojo
@@ -15,6 +15,7 @@ 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.utils.kbhelpers import ikb
 from Powers.vars import Config
 
 l_t = """
@@ -37,6 +38,7 @@ l_t = """
 - `forwardc` = Forwarding from channel
 - `links | url` = Lock links"""
 
+
 @Gojo.on_message(command("locktypes"))
 async def lock_types(_, m: Message):
     await m.reply_text(
@@ -73,7 +75,8 @@ async def lock_perm(c: Gojo, m: Message):
         try:
             await c.set_chat_permissions(chat_id, ChatPermissions())
             lock.insert_lock_channel(m.chat.id, "all")
-            LOGGER.info(f"{m.from_user.id} locked all permissions in {m.chat.id}")
+            LOGGER.info(
+                f"{m.from_user.id} locked all permissions in {m.chat.id}")
         except ChatNotModified:
             pass
         except ChatAdminRequired:
@@ -82,7 +85,6 @@ async def lock_perm(c: Gojo, m: Message):
         await prevent_approved(m)
         return
 
-
     if lock_type == "msg":
         msg = False
         perm = "messages"
@@ -127,7 +129,7 @@ async def lock_perm(c: Gojo, m: Message):
         pin = False
         perm = "pin"
     elif lock_type == "bot":
-        curr = lock.insert_lock_channel(m.chat.id,"bot")
+        curr = lock.insert_lock_channel(m.chat.id, "bot")
         if not curr:
             await m.reply_text("It is already on")
             return
@@ -141,28 +143,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
@@ -182,7 +184,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,
@@ -190,7 +193,8 @@ 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}")
+        LOGGER.info(
+            f"{m.from_user.id} locked selected permissions in {m.chat.id}")
     except ChatNotModified:
         pass
     except ChatAdminRequired:
@@ -211,9 +215,9 @@ async def view_locks(_, m: Message):
         if val:
             return "✅"
         return "❌"
-    
+
     lock = LOCKS()
-    anon= lock.get_lock_channel("anti_c_send", m.chat.id)
+    anon = lock.get_lock_channel("anti_c_send", m.chat.id)
     anti_f = lock.get_lock_channel("anti_fwd",  m.chat.id)
     anti_f_u = lock.get_lock_channel("anti_fwd_u",  m.chat.id)
     anti_f_c = lock.get_lock_channel("anti_fwd_c",  m.chat.id)
@@ -294,8 +298,9 @@ async def unlock_perm(c: Gojo, m: Message):
                     can_pin_messages=True,
                 ),
             )
-            lock.remove_lock_channel(m.chat.id,"all")
-            LOGGER.info(f"{m.from_user.id} unlocked all permissions in {m.chat.id}")
+            lock.remove_lock_channel(m.chat.id, "all")
+            LOGGER.info(
+                f"{m.from_user.id} unlocked all permissions in {m.chat.id}")
         except ChatNotModified:
             pass
         except ChatAdminRequired:
@@ -315,7 +320,6 @@ async def unlock_perm(c: Gojo, m: Message):
     upin = get_uperm.can_pin_messages
     ustickers = uanimations = ugames = uinlinebots = None
 
-
     if unlock_type == "msg":
         umsg = True
         uperm = "messages"
@@ -360,21 +364,21 @@ async def unlock_perm(c: Gojo, m: Message):
         upin = True
         uperm = "pin"
     elif unlock_type == "bot":
-        curr = lock.remove_lock_channel(m.chat.id,"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
@@ -382,33 +386,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!
@@ -418,7 +422,8 @@ async def unlock_perm(c: Gojo, m: Message):
         return
 
     try:
-        LOGGER.info(f"{m.from_user.id} unlocked selected permissions in {m.chat.id}")
+        LOGGER.info(
+            f"{m.from_user.id} unlocked selected permissions in {m.chat.id}")
         await c.set_chat_permissions(
             chat_id,
             ChatPermissions(
@@ -444,7 +449,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
@@ -453,14 +459,15 @@ 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 = get_support_staff("sudo_level")
 
     if m.forward_from:
@@ -480,28 +487,28 @@ async def is_approved_user(c:Gojo, m: Message):
             return True
         return False
 
+
 @Gojo.on_message(filters.service & filters.group, 19)
 async def servicess(c: Gojo, m: Message):
     if m.service != MST.NEW_CHAT_MEMBERS:
         return
-    approved = await is_approved_user(c,m)
+    approved = await is_approved_user(c, m)
     if approved:
         return
     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)
+                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,18)
-async def lock_del_mess(c:Gojo, m: Message):
+@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:
@@ -511,28 +518,29 @@ async def lock_del_mess(c:Gojo, m: Message):
     if m.sender_chat and not (m.forward_from_chat or m.forward_from):
         if m.sender_chat.id == m.chat.id:
             return
-        await delete_messages(c,m)
+        await delete_messages(c, m)
         return
-    is_approved = await is_approved_user(c,m)
+    is_approved = await is_approved_user(c, m)
     if is_approved:
         return
     entity = m.entities if m.text else m.caption_entities
     if entity:
         for i in entity:
             if i.type in [MET.URL or MET.TEXT_LINK]:
-                await delete_messages(c,m)
+                await delete_messages(c, m)
                 return
     elif m.forward_from or m.forward_from_chat:
-        if lock.is_particular_lock(m.chat.id,"anti_fwd"):
-            await delete_messages(c,m)
+        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)
+        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)
+        elif lock.is_particular_lock(m.chat.id, "anti_fwd_c") 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()
     ul = [user[0] for user in approved_users]
@@ -553,7 +561,7 @@ __alt_name__ = ["grouplock", "lock", "grouplocks"]
 __buttons__ = [
     [
         ("Lock Types", "LOCK_TYPES"),
-    ],]
+    ], ]
 
 __HELP__ = """
 **Locks**
@@ -569,3 +577,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

@@ -634,14 +634,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/start.py

@@ -1,3 +1,4 @@
+import os
 from random import choice
 from time import gmtime, strftime, time
 
@@ -19,6 +20,7 @@ from Powers.utils.kbhelpers import ikb
 from Powers.utils.parser import mention_html
 from Powers.utils.start_utils import (gen_cmds_kb, gen_start_kb, get_help_msg,
                                       get_private_note, get_private_rules)
+from Powers.utils.string import encode_decode
 from Powers.vars import Config
 
 
@@ -33,7 +35,7 @@ Your donation might also me get me a new feature or two, which I wasn't able to
 
 All the fund would be put into my services such as database, storage and hosting!
 
-You can donate by contacting my owner: [Captain Ezio](http://t.me/iamgojoof6eyes)
+You can donate by contacting my owner: [Captain D. Ezio](http://t.me/iamgojoof6eyes)
      """
 
     LOGGER.info(f"{m.from_user.id} fetched donation text in {m.chat.id}")
@@ -76,13 +78,14 @@ async def start(c: Gojo, m: Message):
             ):
                 await get_private_note(c, m, help_option)
                 return
-    
+
             if help_option.startswith("rules"):
-                LOGGER.info(f"{m.from_user.id} fetched privaterules in {m.chat.id}")
+                LOGGER.info(
+                    f"{m.from_user.id} fetched privaterules in {m.chat.id}")
                 await get_private_rules(c, m, help_option)
                 return
 
-            help_msg, help_kb = await get_help_msg(m, help_option)
+            help_msg, help_kb = await get_help_msg(c, m, help_option)
 
             if not help_msg:
                 return
@@ -95,7 +98,7 @@ async def start(c: Gojo, m: Message):
                     quote=True,
                 )
                 return
-            if len(help_option.split("_",1)) == 2:
+            if len(help_option.split("_", 1)) == 2:
                 if help_option.split("_")[1] == "help":
                     await m.reply_photo(
                         photo=str(choice(StartPic)),
@@ -105,10 +108,28 @@ async def start(c: Gojo, m: Message):
                         quote=True,
                     )
                     return
-                
+                elif help_option.split("_", 1)[0] == "qrcaptcha":
+                    decoded = encode_decode(
+                        help_option.split("_", 1)[1], "decode")
+                    decode = decoded.split(":")
+                    chat = decode[0]
+                    user = decode[1]
+                    if m.from_user.id != int(user):
+                        await m.reply_text("Not for you Baka")
+                        return
+                    try:
+                        await c.unban_chat_member(int(chat), int(user))
+                        try:
+                            os.remove(f"captcha_verification{chat}_{user}.png")
+                        except Exception:
+                            pass
+                        return
+                    except Exception:
+                        return
+
         try:
             cpt = f"""
-Hey [{m.from_user.first_name}](http://t.me/{m.from_user.username})! I am Gojo ✨.
+Hey [{m.from_user.first_name}](http://t.me/{m.from_user.username})! I am {c.me.first_name} ✨.
 I'm here to help you manage your group(s)!
 Hit /help to find out more about how to use me in my full potential!
 
@@ -123,31 +144,31 @@ Join my [News Channel](https://t.me/gojo_bots_network) to get information on all
         except UserIsBlocked:
             LOGGER.warning(f"Bot blocked by {m.from_user.id}")
     else:
-      kb = InlineKeyboardMarkup(
-        [
-          [
-            InlineKeyboardButton(
-              "Connect me to pm", 
-              url=f"https://{Config.BOT_USERNAME}.t.me/",
-            ),
-          ],
-        ],
-      )
-        
-      await m.reply_photo(
-        photo=str(choice(StartPic)),
-        caption="I'm alive :3",
-        reply_markup=kb,
-        quote=True,
-      )
+        kb = InlineKeyboardMarkup(
+            [
+                [
+                    InlineKeyboardButton(
+                        "Connect me to pm",
+                        url=f"https://{Config.BOT_USERNAME}.t.me/",
+                    ),
+                ],
+            ],
+        )
+
+        await m.reply_photo(
+            photo=str(choice(StartPic)),
+            caption="I'm alive :3",
+            reply_markup=kb,
+            quote=True,
+        )
     return
 
 
 @Gojo.on_callback_query(filters.regex("^start_back$"))
-async def start_back(_, q: CallbackQuery):
+async def start_back(c: Gojo, q: CallbackQuery):
     try:
         cpt = f"""
-Hey [{q.from_user.first_name}](http://t.me/{q.from_user.username})! I am Gojo ✨.
+Hey [{q.from_user.first_name}](http://t.me/{q.from_user.username})! I am {c.me.first_name} ✨.
 I'm here to help you manage your group(s)!
 Hit /help to find out more about how to use me in my full potential!
 
@@ -164,12 +185,12 @@ Join my [News Channel](http://t.me/gojo_bots_network) to get information on all
 
 
 @Gojo.on_callback_query(filters.regex("^commands$"))
-async def commands_menu(_, q: CallbackQuery):
+async def commands_menu(c: Gojo, q: CallbackQuery):
     ou = await gen_cmds_kb(q.message)
     keyboard = ikb(ou, True)
     try:
         cpt = f"""
-Hey **[{q.from_user.first_name}](http://t.me/{q.from_user.username})**! I am Gojo✨.
+Hey **[{q.from_user.first_name}](http://t.me/{q.from_user.username})**! I am {c.me.first_name}✨.
 I'm here to help you manage your group(s)!
 Commands available:
 × /start: Start the bot
@@ -194,14 +215,15 @@ You can use `$` and `!` in placec of `/` as your prefix handler
 
 
 @Gojo.on_message(command("help"))
-async def help_menu(_, m: Message):
+async def help_menu(c: Gojo, m: Message):
     if len(m.text.split()) >= 2:
-        textt = m.text.replace(" ","_",).replace("_"," ",1)
+        textt = m.text.replace(" ", "_",).replace("_", " ", 1)
         help_option = (textt.split(None)[1]).lower()
-        help_msg, help_kb = await get_help_msg(m, help_option)
+        help_msg, help_kb = await get_help_msg(c, m, help_option)
 
         if not help_msg:
-            LOGGER.error(f"No help_msg found for help_option - {help_option}!!")
+            LOGGER.error(
+                f"No help_msg found for help_option - {help_option}!!")
             return
 
         LOGGER.info(
@@ -226,14 +248,14 @@ async def help_menu(_, m: Message):
                 photo=str(choice(StartPic)),
                 caption=f"Press the button below to get help for <i>{help_option}</i>",
                 reply_markup=InlineKeyboardMarkup(
-                  [
                     [
-                      InlineKeyboardButton(
-                        "Help",
-                        url=f"t.me/{Config.BOT_USERNAME}?start={help_option}",
-                        ),
+                        [
+                            InlineKeyboardButton(
+                                "Help",
+                                url=f"t.me/{Config.BOT_USERNAME}?start={help_option}",
+                            ),
+                        ],
                     ],
-                  ],
                 ),
             )
     else:
@@ -242,21 +264,21 @@ async def help_menu(_, m: Message):
             ou = await gen_cmds_kb(m)
             keyboard = ikb(ou, True)
             msg = f"""
-Hey **[{m.from_user.first_name}](http://t.me/{m.from_user.username})**!I am Gojo✨.
+Hey **[{m.from_user.first_name}](http://t.me/{m.from_user.username})**!I am {c.me.first_name}✨.
 I'm here to help you manage your group(s)!
 Commands available:
 × /start: Start the bot
 × /help: Give's you this message."""
         else:
             keyboard = InlineKeyboardMarkup(
-              [
                 [
-                  InlineKeyboardButton(
-                    "Help", 
-                    url=f"t.me/{Config.BOT_USERNAME}?start=start_help",
-                  ),
+                    [
+                        InlineKeyboardButton(
+                            "Help",
+                            url=f"t.me/{Config.BOT_USERNAME}?start=start_help",
+                        ),
+                    ],
                 ],
-              ],
             )
             msg = "Contact me in PM to get the list of possible commands."
 
@@ -268,6 +290,7 @@ Commands available:
 
     return
 
+
 @Gojo.on_callback_query(filters.regex("^bot_curr_info$"))
 async def give_curr_info(c: Gojo, q: CallbackQuery):
     start = time()
@@ -285,6 +308,7 @@ async def give_curr_info(c: Gojo, q: CallbackQuery):
     await q.answer(txt, show_alert=True)
     return
 
+
 @Gojo.on_callback_query(filters.regex("^plugins."))
 async def get_module_info(c: Gojo, q: CallbackQuery):
     module = q.data.split(".", 1)[1]
@@ -293,19 +317,21 @@ async def get_module_info(c: Gojo, q: CallbackQuery):
 
     help_kb = HELP_COMMANDS[f"plugins.{module}"]["buttons"]
     try:
-      await q.edit_message_caption(
-          caption=help_msg,
-          parse_mode=enums.ParseMode.MARKDOWN,
-          reply_markup=ikb(help_kb, True, todo="commands"),
-      )
+        await q.edit_message_caption(
+            caption=help_msg,
+            parse_mode=enums.ParseMode.MARKDOWN,
+            reply_markup=ikb(help_kb, True, todo="commands"),
+        )
     except MediaCaptionTooLong:
-      await c.send_message(chat_id=q.message.chat.id,text=help_msg,)
+        kb = ikb([[("Back", "DELETEEEE")]])
+        await c.send_message(chat_id=q.message.chat.id, text=help_msg, reply_markup=kb)
     await q.answer()
     return
 
 DEV_USERS = get_support_staff("dev")
 SUDO_USERS = get_support_staff("sudo")
 
+
 @Gojo.on_callback_query(filters.regex("^give_bot_staffs$"))
 async def give_bot_staffs(c: Gojo, q: CallbackQuery):
     try:
@@ -349,6 +375,11 @@ async def give_bot_staffs(c: Gojo, q: CallbackQuery):
             except RPCError:
                 pass
 
-    await q.edit_message_caption(reply,reply_markup=InlineKeyboardMarkup([[InlineKeyboardButton("« Back","start_back")]]))
+    await q.edit_message_caption(reply, reply_markup=InlineKeyboardMarkup([[InlineKeyboardButton("« Back", "start_back")]]))
     return
 
+
+@Gojo.on_callback_query(filters.regex("^DELETEEEE$"))
+async def delete_back(_, q: CallbackQuery):
+    await q.message.delete()
+    return

Powers/supports.py

@@ -5,14 +5,15 @@ from Powers.database.support_db import SUPPORTS
 async def load_support_users():
     support = SUPPORTS()
     for i in DEV_USERS:
-        support.insert_support_user(int(i),"dev")
+        support.insert_support_user(int(i), "dev")
     for i in SUDO_USERS:
-        support.insert_support_user(int(i),"sudo")
+        support.insert_support_user(int(i), "sudo")
     for i in WHITELIST_USERS:
-        support.insert_support_user(int(i),"whitelist")
+        support.insert_support_user(int(i), "whitelist")
     return
 
-def get_support_staff(want = "all"):
+
+def get_support_staff(want="all"):
     """
     dev, sudo, whitelist, dev_level, sudo_level, all
     """
@@ -21,7 +22,7 @@ def get_support_staff(want = "all"):
     sudo = support.get_particular_support("sudo")
     whitelist = support.get_particular_support("whitelist")
 
-    if want in ["dev","dev_level"]:
+    if want in ["dev", "dev_level"]:
         wanted = devs
     elif want == "sudo":
         wanted = sudo
@@ -32,4 +33,4 @@ def get_support_staff(want = "all"):
     else:
         wanted = list(set([int(OWNER_ID)] + devs + sudo + whitelist))
 
-    return wanted
+    return wanted

Powers/utils/caching.py

@@ -14,7 +14,8 @@ THREAD_LOCK = RLock()
 # admins stay cached for 30 mins
 ADMIN_CACHE = TTLCache(maxsize=512, ttl=(60 * 30), timer=perf_counter)
 # Block from refreshing admin list for 10 mins
-TEMP_ADMIN_CACHE_BLOCK = TTLCache(maxsize=512, ttl=(60 * 10), timer=perf_counter)
+TEMP_ADMIN_CACHE_BLOCK = TTLCache(
+    maxsize=512, ttl=(60 * 10), timer=perf_counter)
 
 
 async def admin_cache_reload(m: Message or CallbackQuery, status=None) -> List[int]:

Powers/utils/captcha_helper.py

@@ -12,7 +12,8 @@ from Powers.vars import Config
 initial = f"t.me/{Config.BOT_USERNAME}?start=qrcaptcha_"
 captchaa = CAPTCHA_DATA()
 
-async def get_qr_captcha(chat,user):
+
+async def get_qr_captcha(chat, user):
     encode = f"{chat}:{user}"
     encoded = encode_decode(encode)
     final = initial+encoded
@@ -21,11 +22,13 @@ async def get_qr_captcha(chat,user):
     qr.save(name)
     return name
 
+
 def genrator():
-    alpha = ["a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q","r","s","t","u","v","w","x","y","z"]
+    alpha = ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l",
+             "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z"]
     rand_alpha = choice(alpha)
-    if_ = randint(0,1)
-    
+    if_ = randint(0, 1)
+
     if if_:
         new_alpha = rand_alpha.upper()
     else:
@@ -33,24 +36,23 @@ def genrator():
 
     list_ = [new_alpha]
     while len(list_) != 4:
-        xXx = randrange(0,9)
+        xXx = randrange(0, 9)
         list_.append(xXx)
 
     str_ = ""
     while len(str_) != 4:
         OwO = choice(list_)
-        str_ += OwO 
+        str_ += OwO
     return str_
 
-async def get_image_captcha(chat,user):
+
+async def get_image_captcha(chat, user):
     str_ = genrator()
-    captchaa.load_cap_data(chat,user,str_)
+    captchaa.load_cap_data(chat, user, str_)
     name = f"captcha_img_{chat}_{user}.png"
-    image = ImageCaptcha(280,90)
+    image = ImageCaptcha(280, 90)
 
     cap = image.generate(str_)
-    image.write(str_,name)
+    image.write(str_, name)
 
     return name, str_
-
-

Powers/utils/custom_filters.py

@@ -186,7 +186,7 @@ async def owner_check_func(_, __, m: Message or CallbackQuery):
 
     if m.chat.type not in [ChatType.SUPERGROUP, ChatType.GROUP]:
         return False
-    
+
     if not m.from_user:
         return False
 
@@ -264,7 +264,6 @@ async def changeinfo_check_func(_, __, m):
     if m.sender_chat:
         return True
 
-
     user = await m.chat.get_member(m.from_user.id)
 
     if user.status in [CMS.ADMINISTRATOR, CMS.OWNER] and user.privileges.can_change_info:
@@ -304,16 +303,18 @@ async def can_pin_message_func(_, __, m):
 
     return status
 
+
 async def auto_join_check_filter(_, __, j: ChatJoinRequest):
     chat = j.chat.id
     aj = AUTOJOIN()
     join_type = aj.get_autojoin(chat)
-    
+
     if not join_type:
         return False
     else:
         return True
 
+
 async def afk_check_filter(_, __, m: Message):
     if not m.from_user:
         return False
@@ -323,7 +324,7 @@ async def afk_check_filter(_, __, m: Message):
 
     if m.chat.type == ChatType.PRIVATE:
         return False
-    
+
     afk = AFK()
     user = m.from_user.id
     chat = m.chat.id
@@ -334,16 +335,17 @@ async def afk_check_filter(_, __, m: Message):
     else:
         rep_user = False
 
-    is_afk = afk.check_afk(chat,user)
+    is_afk = afk.check_afk(chat, user)
     is_rep_afk = False
     if rep_user:
-        is_rep_afk = afk.check_afk(chat,rep_user)
+        is_rep_afk = afk.check_afk(chat, rep_user)
 
     if not is_rep_afk and not is_afk:
         return False
     else:
         return True
 
+
 async def flood_check_filter(_, __, m: Message):
     Flood = Floods()
     if not m.chat:
@@ -351,23 +353,23 @@ async def flood_check_filter(_, __, m: Message):
 
     if not m.from_user:
         return False
-    
+
     if m.chat.type == ChatType.PRIVATE:
         return False
 
     u_id = m.from_user.id
     c_id = m.chat.id
     is_flood = Flood.is_chat(c_id)
-    
+
     app_users = Approve(m.chat.id).list_approved()
     SUDO_LEVEL = set(SUDO_USERS + DEV_USERS + [int(OWNER_ID)])
-    
+
     if not is_flood or u_id in SUDO_LEVEL:
         return False
-    
+
     elif u_id in {i[0] for i in app_users}:
         return False
-    
+
     else:
         return True
 

Powers/utils/extract_user.py

@@ -30,7 +30,7 @@ async def extract_user(c: Gojo, m: Message) -> Tuple[int, str, str]:
             elif required_entity.type in (entity.MENTION, entity.PHONE_NUMBER):
                 # new long user ids are identified as phone_number
                 user_found = m.text[
-                    required_entity.offset : (
+                    required_entity.offset: (
                         required_entity.offset + required_entity.length
                     )
                 ]

Powers/utils/extras.py

@@ -514,7 +514,8 @@ TOSS = (
 )
 
 
-DECIDE = ("Yes.", "No.", "Maybe.", "Who the hell cares?", "No one give a damn about it")
+DECIDE = ("Yes.", "No.", "Maybe.", "Who the hell cares?",
+          "No one give a damn about it")
 
 INSULT_STRINGS = [
     "`Owww ... Such a stupid idiot.`",
@@ -707,7 +708,7 @@ StartPic = [
 ]
 
 
-birthday_wish =  [
+birthday_wish = [
     "Wishing you a happy birthday filled with love and joy.",
     "Hope your birthday is as wonderful as you are.",
     "Happy birthday to someone who deserves an exceptional day.",
@@ -783,4 +784,4 @@ birthday_wish =  [
     "Happy birthday to someone who brings a smile to my face every day, may your day be as wonderful as you are.",
     "Sending you all my love and warmest wishes on your special day, may your year be filled with love and happiness.",
     "May your birthday be a time to appreciate all the people who make your life special, and cherish all the memories you've created.",
-    "Wishing you a birthday that's as beautiful as you are, filled with joy and celebration.",]
+    "Wishing you a birthday that's as beautiful as you are, filled with joy and celebration.", ]

Powers/utils/http_helper.py

@@ -48,7 +48,7 @@ async def multipost(url: str, times: int, *args, **kwargs):
 
 
 def resp_get(url: str, *args, **kwargs):
-        return requests.get(url, *args, **kwargs)
+    return requests.get(url, *args, **kwargs)
 
 
 def resp_post(url: str, *args, **kwargs):

Powers/utils/kbhelpers.py

@@ -22,7 +22,8 @@ def ikb(rows=None, back=False, todo="start_back"):
         for row in rows:
             line = []
             for button in row:
-                button = btn(*button)  # Will make the kb which don't have "." in them
+                # Will make the kb which don't have "." in them
+                button = btn(*button)
                 line.append(button)
             lines.append(line)
     except TypeError:
@@ -32,7 +33,7 @@ def ikb(rows=None, back=False, todo="start_back"):
             button = btn(*button)  # InlineKeyboardButton
             line.append(button)
         lines.append(line)
-    if back: 
+    if back:
         back_btn = [(btn("« Back", todo))]
         lines.append(back_btn)
     return InlineKeyboardMarkup(inline_keyboard=lines)

Powers/utils/msg_types.py

@@ -215,6 +215,7 @@ async def get_wlcm_type(m: Message):
 
     return text, data_type, content
 
+
 async def get_afk_type(m: Message):
     data_type = None
     content = None

Powers/utils/start_utils.py

@@ -30,7 +30,7 @@ async def gen_cmds_kb(m: Message or CallbackQuery):
     cmds = sorted(list(HELP_COMMANDS.keys()))
     kb = [cmd.lower() for cmd in cmds]
 
-    return [kb[i : i + 3] for i in range(0, len(kb), 3)]
+    return [kb[i: i + 3] for i in range(0, len(kb), 3)]
 
 
 async def gen_start_kb(q: Message or CallbackQuery):
@@ -238,7 +238,7 @@ async def get_private_rules(_, m: Message, help_option: str):
     return ""
 
 
-async def get_help_msg(m: Message or CallbackQuery, help_option: str):
+async def get_help_msg(c: Gojo, m: Message or CallbackQuery, help_option: str):
     """Helper function for getting help_msg and it's keyboard."""
     help_msg = None
     help_kb = None
@@ -266,12 +266,12 @@ async def get_help_msg(m: Message or CallbackQuery, help_option: str):
             f"{m.from_user.id} fetched help for {help_option} in {m.chat.id}",
         )
     else:
-        if isinstance(m,CallbackQuery):
+        if isinstance(m, CallbackQuery):
             mes = m.message
         else:
             mes = m
         help_msg = f"""
-Hey **[{mes.from_user.first_name}](http://t.me/{mes.from_user.username})**!I am Gojo✨.
+Hey **[{mes.from_user.first_name}](http://t.me/{mes.from_user.username})**!I am {c.me.first_name}✨.
 I'm here to help you manage your groups!
 Commands available:
 × /start: Start the bot

Powers/utils/sticker_help.py

@@ -28,6 +28,7 @@ async def runcmd(cmd: str) -> Tuple[str, str, int, int]:
         process.pid,
     )
 
+
 async def get_sticker_set_by_name(
     client: Gojo, name: str
 ) -> raw.base.messages.StickerSet:
@@ -42,15 +43,14 @@ async def get_sticker_set_by_name(
         return None
 
 
-
 async def create_sticker_set(
     client: Gojo,
     owner: int,
     title: str,
     short_name: str,
     stickers: List[raw.base.InputStickerSetItem],
-    animated:bool=False,
-    video:bool=False
+    animated: bool = False,
+    video: bool = False
 ) -> raw.base.messages.StickerSet:
     return await client.invoke(
         raw.functions.stickers.CreateStickerSet(
@@ -85,11 +85,10 @@ async def create_sticker(
     return raw.types.InputStickerSetItem(document=sticker, emoji=emoji)
 
 
-
 STICKER_DIMENSIONS = (512, 512)
 
 
-async def resize_file_to_sticker_size(file_path: str,length:int=512,width:int=512) -> str:
+async def resize_file_to_sticker_size(file_path: str, length: int = 512, width: int = 512) -> str:
     im = Image.open(file_path)
     if (im.width, im.height) < STICKER_DIMENSIONS:
         size1 = im.width
@@ -114,6 +113,7 @@ async def resize_file_to_sticker_size(file_path: str,length:int=512,width:int=51
     os.remove(file_path)
     return file_pathh
 
+
 async def tgs_to_gif(file, tgs=False, video=False):
     if tgs:
         cmd = f"lottie_convert.py '{file}' 'gojo_satoru.gif'"
@@ -123,12 +123,14 @@ async def tgs_to_gif(file, tgs=False, video=False):
     os.remove(file)
     return 'gojo_satoru.gif'
 
+
 async def webm_to_gif(file):
     cmd = f"ffmpeg -i '{file}' 'goJo.gif'"
     await runcmd(cmd)
     os.remove(file)
     return "goJo.gif"
-        
+
+
 async def Vsticker(c: Gojo, file: Message):
     if file.animation:
         file = file.animation
@@ -155,7 +157,8 @@ async def upload_document(
         raw.functions.messages.UploadMedia(
             peer=await client.resolve_peer(chat_id),
             media=raw.types.InputMediaUploadedDocument(
-                mime_type=client.guess_mime_type(file_path) or "application/zip",
+                mime_type=client.guess_mime_type(
+                    file_path) or "application/zip",
                 file=await client.save_file(file_path),
                 attributes=[
                     raw.types.DocumentAttributeFilename(
@@ -183,6 +186,7 @@ async def get_document_from_file_id(
         file_reference=decoded.file_reference,
     )
 
+
 async def remove_sticker(c: Gojo, stickerid: str) -> raw.base.messages.StickerSet:
     sticker = await get_document_from_file_id(stickerid)
     return await c.invoke(raw.functions.stickers.RemoveStickerFromSet(sticker=sticker))
@@ -237,7 +241,7 @@ async def draw_meme(image_path: str, text: str, sticker: bool, fiill: str) -> li
         stick_path = await resize_file_to_sticker_size(image_path)
 
     image1 = image_path
-    image2 = tosticker(stick_path,f"@GojoSuperbot_{int(time())}.webp")
+    image2 = tosticker(stick_path, f"@GojoSuperbot_{int(time())}.webp")
 
     image.save(image1)
     image.save(image2)
@@ -247,12 +251,10 @@ async def draw_meme(image_path: str, text: str, sticker: bool, fiill: str) -> li
     return [image1, image2]
 
 
-
-
 def toimage(image, filename=None, is_direc=False):
     filename = filename if filename else "gojo.jpg"
     if is_direc:
-        os.rename(image,filename)
+        os.rename(image, filename)
         return filename
     img = Image.open(image)
     if img.mode != "RGB":
@@ -265,11 +267,11 @@ def toimage(image, filename=None, is_direc=False):
 def tosticker(response, filename=None, is_direc=False):
     filename = filename if filename else "gojo.webp"
     if is_direc:
-        os.rename(response,filename)
+        os.rename(response, filename)
         return filename
     image = Image.open(response)
     if image.mode != "RGB":
         image.convert("RGB")
     image.save(filename, "webp")
     os.remove(response)
-    return filename
+    return filename

Powers/utils/string.py

@@ -1,3 +1,4 @@
+import base64
 from datetime import datetime, timedelta
 from html import escape
 from re import compile as compile_re
@@ -9,7 +10,8 @@ from pyrogram.types import InlineKeyboardButton, Message
 from Powers import TIME_ZONE
 from Powers.utils.parser import escape_markdown
 
-BTN_URL_REGEX = compile_re(r"(\[([^\[]+?)\]\(buttonurl:(?:/{0,2})(.+?)(:same)?\))")
+BTN_URL_REGEX = compile_re(
+    r"(\[([^\[]+?)\]\(buttonurl:(?:/{0,2})(.+?)(:same)?\))")
 
 
 async def extract_time(m: Message, time_val: str):
@@ -26,7 +28,7 @@ async def extract_time(m: Message, time_val: str):
         elif unit == "h":
             bantime = initial_time + timedelta(hours=int(time_num))
         elif unit == "d":
-            bantime = initial_time + timedelta(days=int(time_num)) 
+            bantime = initial_time + timedelta(days=int(time_num))
         else:
             # how even...?
             return ""
@@ -54,8 +56,9 @@ async def parse_button(text: str):
         # if even, not escaped -> create button
         if n_escapes % 2 == 0:
             # create a thruple with button label, url, and newline status
-            buttons.append((match.group(2), match.group(3), bool(match.group(4))))
-            note_data += markdown_note[prev : match.start(1)]
+            buttons.append(
+                (match.group(2), match.group(3), bool(match.group(4))))
+            note_data += markdown_note[prev: match.start(1)]
             prev = match.end(1)
         # if odd, escaped -> move along
         else:
@@ -98,7 +101,7 @@ async def escape_invalid_curly_brackets(text: str, valids: List[str]) -> str:
                     success = True
                     break
             if success:
-                new_text += text[idx : idx + len(v) + 2]
+                new_text += text[idx: idx + len(v) + 2]
                 idx += len(v) + 2
                 continue
             new_text += "{{"
@@ -173,7 +176,7 @@ async def split_quotes(text: str):
     # 1 to avoid starting quote, and counter is exclusive so avoids ending
     key = await remove_escapes(text[1:counter].strip())
     # index will be in range, or `else` would have been executed and returned
-    rest = text[counter + 1 :].strip()
+    rest = text[counter + 1:].strip()
     if not key:
         key = text[0] + text[0]
     return list(filter(None, [key, rest]))
@@ -192,3 +195,25 @@ async def remove_escapes(text: str) -> str:
         else:
             res += text[counter]
     return res
+
+
+async def encode_decode(string: str, to_do="encode"):
+    """
+    Function to encode or decode strings
+    string: string to be decoded or encoded
+    to_do: encode to encode the string or decode to decode the string
+    """
+    if to_do.lower() == "encode":
+        encodee = string.encode("ascii")
+        base64_ = base64.b64encode(encodee)
+        B64 = base64_.decode("ascii")
+
+    elif to_do.lower() == "decode":
+        decodee = string.encode("ascii")
+        base64_ = base64.b64decode(decodee)
+        B64 = base64_.decode("ascii")
+
+    else:
+        B64 = None
+
+    return B64

Powers/utils/web_helpers.py

@@ -16,6 +16,7 @@ from Powers.utils.sticker_help import resize_file_to_sticker_size
 
 backUP = "https://artfiles.alphacoders.com/160/160160.jpeg"
 
+
 async def get_file_size(file: Message):
     if file.photo:
         size = file.photo.file_size/1024
@@ -33,7 +34,7 @@ async def get_file_size(file: Message):
         size = file.voice.file_size/1024
     elif file.video_note:
         size = file.video_note.file_size/1024
-        
+
     if size <= 1024:
         return f"{round(size)} kb"
     elif size > 1024:
@@ -54,6 +55,8 @@ def get_duration_in_sec(dur: str):
     return dur
 
 # Gets yt result of given query.
+
+
 async def song_search(query, is_direct, max_results=1):
     yt_dict = {}
     try:
@@ -62,7 +65,7 @@ async def song_search(query, is_direct, max_results=1):
             query = vid["title"]
         else:
             query = query
-        videos = VideosSearch(query,max_results)
+        videos = VideosSearch(query, max_results)
         results = await videos.next()
     except Exception as e:
         LOGGER.error(e)
@@ -87,8 +90,8 @@ async def song_search(query, is_direct, max_results=1):
                 "duration": i["accessibility"]['duration'],
                 "DURATION": i["duration"],
                 "published": i["publishedTime"],
-                "uploader": i ["channel"]["name"]
-                }
+                "uploader": i["channel"]["name"]
+            }
             try:
                 thumb = {"thumbnail": i["richThumbnail"]["url"]}
             except Exception:
@@ -140,8 +143,7 @@ video_opts = {
 }"""
 
 
-
-async def youtube_downloader(c:Gojo,m:Message,query:str,is_direct:bool,type_:str):
+async def youtube_downloader(c: Gojo, m: Message, query: str, is_direct: bool, type_: str):
     if type_ == "a":
         # opts = song_opts
         video = False
@@ -151,7 +153,7 @@ async def youtube_downloader(c:Gojo,m:Message,query:str,is_direct:bool,type_:str
         video = True
         song = False
     # ydl = yt_dlp.YoutubeDL(opts)
-    dicti = await song_search(query, is_direct,1)
+    dicti = await song_search(query, is_direct, 1)
     if not dicti and type(dicti) != str:
         await m.reply_text("File with duration less than or equals to 10 minutes is allowed only")
     elif type(dicti) == str:
@@ -172,14 +174,14 @@ async def youtube_downloader(c:Gojo,m:Message,query:str,is_direct:bool,type_:str
     vid_dur = get_duration_in_sec(dicti["DURATION"])
     published_on = dicti["published"]
     if thumb:
-        thumb_ = await c.send_photo(MESSAGE_DUMP,thumb)
+        thumb_ = await c.send_photo(MESSAGE_DUMP, thumb)
     else:
-        thumb_ = await c.send_photo(MESSAGE_DUMP,backUP)
+        thumb_ = await c.send_photo(MESSAGE_DUMP, backUP)
     # FILE = ydl.extract_info(query,download=video)
     url = query
     thumb = await thumb_.download()
     if not thumb:
-        thumb = await resize_file_to_sticker_size(thumb,320,320)
+        thumb = await resize_file_to_sticker_size(thumb, 320, 320)
     await thumb_.delete()
     cap = f"""
 ⤷ Name: `{f_name}`
@@ -192,7 +194,7 @@ Downloaded by: @{c.me.username}
     kb = IKM(
         [
             [
-                IKB(f"✘ {uploader.capitalize()} ✘",url=f"{up_url}")
+                IKB(f"✘ {uploader.capitalize()} ✘", url=f"{up_url}")
             ],
             [
                 IKB(f"✘ Youtube url ✘", url=f"{url}")
@@ -200,12 +202,12 @@ Downloaded by: @{c.me.username}
         ]
     )
     if song:
-        audio_stream= yt.streams.filter(only_audio=True).first()
+        audio_stream = yt.streams.filter(only_audio=True).first()
         f_path = audio_stream.download()
         # file_path = f"./youtube_downloads/{f_name.strip()}.mp3"
         file_path = f"./{f_name.strip()}.mp3"
-        os.rename(f_path,file_path)
-        await m.reply_audio(file_path,caption=cap,reply_markup=kb,duration=vid_dur,thumb=thumb,title=f_name)
+        os.rename(f_path, file_path)
+        await m.reply_audio(file_path, caption=cap, reply_markup=kb, duration=vid_dur, thumb=thumb, title=f_name)
         # os.remove(f_path)
         os.remove(file_path)
         os.remove(thumb)
@@ -214,7 +216,7 @@ Downloaded by: @{c.me.username}
         video_stream = yt.streams.get_highest_resolution()
         file_path = video_stream.download()
         # file_path = f"./youtube_downloads/{f_name}.mp4"
-        await m.reply_video(file_path,caption=cap,reply_markup=kb,duration=vid_dur,thumb=thumb)
+        await m.reply_video(file_path, caption=cap, reply_markup=kb, duration=vid_dur, thumb=thumb)
         os.remove(file_path)
         os.remove(thumb)
         return

Powers/vars.py

@@ -37,18 +37,18 @@ class Config:
             default="",
         ).split(None)
     ]
-    GENIUS_API_TOKEN = config("GENIUS_API",default=None)
+    GENIUS_API_TOKEN = config("GENIUS_API", default=None)
     # AuDD_API = config("AuDD_API",default=None)
-    RMBG_API = config("RMBG_API",default=None)
+    RMBG_API = config("RMBG_API", default=None)
     DB_URI = config("DB_URI", default="")
     DB_NAME = config("DB_NAME", default="gojo_satarou")
-    BDB_URI = config("BDB_URI",default=None)
+    BDB_URI = config("BDB_URI", default=None)
     NO_LOAD = config("NO_LOAD", default="").split()
     PREFIX_HANDLER = config("PREFIX_HANDLER", default="/").split()
     SUPPORT_GROUP = config("SUPPORT_GROUP", default="gojo_bots_network")
     SUPPORT_CHANNEL = config("SUPPORT_CHANNEL", default="gojo_bots_network")
     WORKERS = int(config("WORKERS", default=16))
-    TIME_ZONE = config("TIME_ZONE",default='Asia/Kolkata')
+    TIME_ZONE = config("TIME_ZONE", default='Asia/Kolkata')
     BOT_USERNAME = ""
     BOT_ID = ""
     BOT_NAME = ""
@@ -73,7 +73,7 @@ class Development:
     NO_LOAD = []
     GENIUS_API_TOKEN = ""
     RMBG_API = ""
-    PREFIX_HANDLER = ["!", "/","$"]
+    PREFIX_HANDLER = ["!", "/", "$"]
     SUPPORT_GROUP = "SUPPORT_GROUP"
     SUPPORT_CHANNEL = "SUPPORT_CHANNEL"
     VERSION = "VERSION"