Looks good

Powers/__init__.py

@@ -99,8 +99,7 @@ async def load_cmds(all_plugins):
     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}")
@@ -141,7 +140,6 @@ 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/database/approve_db.py

@@ -66,8 +66,7 @@ class Approve(MongoDB):
         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
 

Powers/database/blacklist_db.py

@@ -110,8 +110,7 @@ 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
 

Powers/database/disable_db.py

@@ -146,11 +146,9 @@ class Disabling(MongoDB):
                     "commands": [],
                     "action": "none",
                 }
-                DISABLED_CMDS[self.chat_id] = {
-                    "commands": [], "action": "none"}
+                DISABLED_CMDS[self.chat_id] = {"commands": [], "action": "none"}
                 self.insert_one(new_data)
-                LOGGER.info(
-                    f"Initialized Disabling Document for chat {self.chat_id}")
+                LOGGER.info(f"Initialized Disabling Document for chat {self.chat_id}")
                 return new_data
             DISABLED_CMDS[self.chat_id] = chat_data
         return chat_data

Powers/database/filters_db.py

@@ -71,8 +71,7 @@ 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/greetings_db.py

@@ -128,8 +128,7 @@ class Greetings(MongoDB):
                 "goodbye": True,
             }
             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
 

Powers/database/notes_db.py

@@ -57,8 +57,7 @@ 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):

Powers/database/reporting_db.py

@@ -42,11 +42,9 @@ class Reporting(MongoDB):
         chat_data = self.find_one({"_id": self.chat_id})
         if not chat_data:
             chat_type = self.get_chat_type()
-            new_data = {"_id": self.chat_id,
-                        "status": True, "chat_type": chat_type}
+            new_data = {"_id": self.chat_id, "status": True, "chat_type": chat_type}
             self.insert_one(new_data)
-            LOGGER.info(
-                f"Initialized Language Document for chat {self.chat_id}")
+            LOGGER.info(f"Initialized Language Document for chat {self.chat_id}")
             return new_data
         return chat_data
 

Powers/database/rules_db.py

@@ -68,8 +68,7 @@ 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/users_db.py

@@ -67,8 +67,7 @@ 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/plugins/admin.py

@@ -40,8 +40,7 @@ async def adminlist_show(_, m: Message):
         adminstr = f"Admins in <b>{m.chat.title}</b>:" + "\n\n"
 
         bot_admins = [i for i in admin_list if (i[1].lower()).endswith("bot")]
-        user_admins = [i for i in admin_list if not (
-            i[1].lower()).endswith("bot")]
+        user_admins = [i for i in admin_list if not (i[1].lower()).endswith("bot")]
 
         # format is like: (user_id, username/name,anonyamous or not)
         mention_users = [

Powers/plugins/approve.py

@@ -88,8 +88,7 @@ async def disapprove_user(c: Gojo, m: Message):
     except UserNotParticipant:
         if already_approved:  # If user is approved and not in chat, unapprove them.
             db.remove_approve(user_id)
-            LOGGER.info(
-                f"{user_id} disapproved in {m.chat.id} as UserNotParticipant")
+            LOGGER.info(f"{user_id} disapproved in {m.chat.id} as UserNotParticipant")
         await m.reply_text("This user is not in this chat, unapproved them.")
         return
     except RPCError as ef:
@@ -159,8 +158,7 @@ async def check_approval(c: Gojo, m: Message):
     except Exception:
         return
     check_approve = db.check_approve(user_id)
-    LOGGER.info(
-        f"{m.from_user.id} checking approval of {user_id} in {m.chat.id}")
+    LOGGER.info(f"{m.from_user.id} checking approval of {user_id} in {m.chat.id}")
 
     if not user_id:
         await m.reply_text(

Powers/plugins/blacklist.py

@@ -55,8 +55,7 @@ async def add_blacklist(_, m: Message):
             ", ".join([f"<code>{i}</code>" for i in bl_words])
             + " already added in blacklist, skipped them!"
         )
-    LOGGER.info(
-        f"{m.from_user.id} added new blacklists ({bl_words}) in {m.chat.id}")
+    LOGGER.info(f"{m.from_user.id} added new blacklists ({bl_words}) in {m.chat.id}")
     trigger = ", ".join(f"<code>{i}</code>" for i in bl_words)
     await m.reply_text(
         text=f"Added <code>{trigger}</code> in blacklist words!"
@@ -111,12 +110,10 @@ async def rm_blacklist(_, m: Message):
 
     if non_found_words:
         rep_text = (
-            "Could not find " +
-            ", ".join(f"<code>{i}</code>" for i in non_found_words)
+            "Could not find " + ", ".join(f"<code>{i}</code>" for i in non_found_words)
         ) + " in blcklisted words, skipped them."
 
-    LOGGER.info(
-        f"{m.from_user.id} removed blacklists ({bl_words}) in {m.chat.id}")
+    LOGGER.info(f"{m.from_user.id} removed blacklists ({bl_words}) in {m.chat.id}")
     bl_words = ", ".join(f"<code>{i}</code>" for i in bl_words)
     await m.reply_text(
         text=f"Removed <b>{bl_words}</b> from blacklist words!"
@@ -151,8 +148,7 @@ async def set_bl_action(_, m: Message):
         await m.reply_text(text=f"Set action for blacklist for this to <b>{action}</b>")
     elif len(m.text.split()) == 1:
         action = db.get_action()
-        LOGGER.info(
-            f"{m.from_user.id} checking blacklist action in {m.chat.id}")
+        LOGGER.info(f"{m.from_user.id} checking blacklist action in {m.chat.id}")
         await m.reply_text(
             text=f"""The current action for blacklists in this chat is <i><b>{action}</b></i>
       All blacklist modes delete the message containing blacklist word."""

Powers/plugins/chat_blacklist.py

@@ -42,8 +42,7 @@ async def unblacklist_chat(c: Gojo, m: Message):
     if len(m.text.split()) >= 2:
         chat_ids = m.text.split()[1:]
         replymsg = await m.reply_text(f"Removing {len(chat_ids)} chats from blacklist")
-        LOGGER.info(
-            f"{m.from_user.id} removed blacklisted {chat_ids} groups for bot")
+        LOGGER.info(f"{m.from_user.id} removed blacklisted {chat_ids} groups for bot")
         bl_chats = db.list_all_chats()
         for chat in chat_ids:
             try:

Powers/plugins/dev.py

@@ -129,8 +129,7 @@ async def evaluate_code(c: Gojo, m: Message):
 
 
 async def aexec(code, c, m):
-    exec("async def __aexec(c, m): " +
-         "".join(f"\n {l}" for l in code.split("\n")))
+    exec("async def __aexec(c, m): " + "".join(f"\n {l}" for l in code.split("\n")))
     return await locals()["__aexec"](c, m)
 
 

Powers/plugins/disable.py

@@ -116,8 +116,7 @@ async def rm_alldisbl(_, m: Message):
                         "Confirm",
                         callback_data="enableallcmds",
                     ),
-                    InlineKeyboardButton(
-                        "Cancel", callback_data="close_admin"),
+                    InlineKeyboardButton("Cancel", callback_data="close_admin"),
                 ],
             ],
         ),

Powers/plugins/filters.py

@@ -95,8 +95,7 @@ async def add_filter(_, m: Message):
         )
 
     add = db.save_filter(m.chat.id, keyword, teks, msgtype, file_id)
-    LOGGER.info(
-        f"{m.from_user.id} added new filter ({keyword}) in {m.chat.id}")
+    LOGGER.info(f"{m.from_user.id} added new filter ({keyword}) in {m.chat.id}")
     if add:
         await m.reply_text(
             f"Saved filter for '<code>{', '.join(keyword.split('|'))}</code>' in <b>{m.chat.title}</b>!",
@@ -120,8 +119,7 @@ async def stop_filter(_, m: Message):
     for keyword in act_filters:
         if keyword == m.text.split(None, 1)[1].lower():
             db.rm_filter(m.chat.id, m.text.split(None, 1)[1].lower())
-            LOGGER.info(
-                f"{m.from_user.id} removed filter ({keyword}) in {m.chat.id}")
+            LOGGER.info(f"{m.from_user.id} removed filter ({keyword}) in {m.chat.id}")
             await m.reply_text(
                 f"Okay, I'll stop replying to that filter and it's aliases in <b>{m.chat.title}</b>.",
             )
@@ -282,8 +280,7 @@ async def filters_watcher(c: Gojo, m: Message):
         if match:
             try:
                 msgtype = await send_filter_reply(c, m, trigger)
-                LOGGER.info(
-                    f"Replied with {msgtype} to {trigger} in {m.chat.id}")
+                LOGGER.info(f"Replied with {msgtype} to {trigger} in {m.chat.id}")
             except Exception as ef:
                 await m.reply_text(f"Error: {ef}")
                 LOGGER.error(ef)

Powers/plugins/fun.py

@@ -71,8 +71,7 @@ async def fun_slap(c: Gojo, m: Message):
     hit = choice(extras.HIT)
     throw = choice(extras.THROW)
 
-    reply = temp.format(user1=user1, user2=user2,
-                        item=item, hits=hit, throws=throw)
+    reply = temp.format(user1=user1, user2=user2, item=item, hits=hit, throws=throw)
     await reply_text(reply)
     LOGGER.info(f"{m.from_user.id} slaped in {m.chat.id}")
     return
@@ -111,8 +110,7 @@ async def insult(c: Gojo, m: Message):
             m.reply_to_message.reply_text if m.reply_to_message else m.reply_text
         )
         await reply_text(Insult_omp)
-        LOGGER.info(
-            f"{m.from_user.id} insulted {user_first_name} in {m.chat.id}")
+        LOGGER.info(f"{m.from_user.id} insulted {user_first_name} in {m.chat.id}")
 
 
 @Gojo.on_message(command("yes"))

Powers/plugins/locks.py

@@ -55,8 +55,7 @@ async def lock_perm(c: Gojo, m: Message):
     if lock_type == "all":
         try:
             await c.set_chat_permissions(chat_id, ChatPermissions())
-            LOGGER.info(
-                f"{m.from_user.id} locked all permissions in {m.chat.id}")
+            LOGGER.info(f"{m.from_user.id} locked all permissions in {m.chat.id}")
         except ChatNotModified:
             pass
         except ChatAdminRequired:
@@ -123,8 +122,7 @@ async def lock_perm(c: Gojo, m: Message):
             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,
@@ -132,8 +130,7 @@ async def lock_perm(c: Gojo, m: Message):
                 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:
@@ -215,8 +212,7 @@ async def unlock_perm(c: Gojo, m: Message):
                     can_pin_messages=True,
                 ),
             )
-            LOGGER.info(
-                f"{m.from_user.id} unlocked all permissions in {m.chat.id}")
+            LOGGER.info(f"{m.from_user.id} unlocked all permissions in {m.chat.id}")
         except ChatNotModified:
             pass
         except ChatAdminRequired:
@@ -289,8 +285,7 @@ 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(

Powers/plugins/notes.py

@@ -73,8 +73,7 @@ async def get_note_func(c: Gojo, m: Message, note_name, priv_notes_status):
 
     if priv_notes_status:
 
-        note_hash = next(i[1] for i in db.get_all_notes(
-            m.chat.id) if i[0] == note_name)
+        note_hash = next(i[1] for i in db.get_all_notes(m.chat.id) if i[0] == note_name)
         await reply_text(
             f"Click on the button to get the note <code>{note_name}</code>",
             reply_markup=ikb(
@@ -298,13 +297,11 @@ async def priv_notes(_, m: Message):
         option = (m.text.split())[1]
         if option in ("on", "yes"):
             db_settings.set_privatenotes(chat_id, True)
-            LOGGER.info(
-                f"{m.from_user.id} enabled privatenotes in {m.chat.id}")
+            LOGGER.info(f"{m.from_user.id} enabled privatenotes in {m.chat.id}")
             msg = "Set private notes to On"
         elif option in ("off", "no"):
             db_settings.set_privatenotes(chat_id, False)
-            LOGGER.info(
-                f"{m.from_user.id} disabled privatenotes in {m.chat.id}")
+            LOGGER.info(f"{m.from_user.id} disabled privatenotes in {m.chat.id}")
             msg = "Set private notes to Off"
         else:
             msg = "Enter correct option"
@@ -312,8 +309,7 @@ async def priv_notes(_, m: Message):
     elif len(m.text.split()) == 1:
         curr_pref = db_settings.get_privatenotes(m.chat.id)
         msg = msg = f"Private Notes: {curr_pref}"
-        LOGGER.info(
-            f"{m.from_user.id} fetched privatenotes preference in {m.chat.id}")
+        LOGGER.info(f"{m.from_user.id} fetched privatenotes preference in {m.chat.id}")
         await m.reply_text(msg)
     else:
         await m.replt_text("Check help on how to use this command!")

Powers/plugins/pin.py

@@ -92,8 +92,7 @@ async def unpin_message(c: Gojo, m: Message):
 async def unpinall_message(_, m: Message):
     await m.reply_text(
         "Do you really want to unpin all messages in this chat?",
-        reply_markup=ikb(
-            [[("Yes", "unpin all in this chat"), ("No", "close_admin")]]),
+        reply_markup=ikb([[("Yes", "unpin all in this chat"), ("No", "close_admin")]]),
     )
     return
 
@@ -116,8 +115,7 @@ async def unpinall_calllback(c: Gojo, q: CallbackQuery):
         return
     try:
         await c.unpin_all_chat_messages(q.message.chat.id)
-        LOGGER.info(
-            f"{q.from_user.id} unpinned all messages in {q.message.chat.id}")
+        LOGGER.info(f"{q.from_user.id} unpinned all messages in {q.message.chat.id}")
         await q.message.edit_text(text="Unpinned all messages in this chat.")
     except ChatAdminRequired:
         await q.message.edit_text(text="I'm not admin or I don't have rights.")
@@ -145,13 +143,11 @@ async def anti_channel_pin(_, m: Message):
     if len(m.text.split()) == 2:
         if m.command[1] in ("yes", "on", "true"):
             pinsdb.antichannelpin_on()
-            LOGGER.info(
-                f"{m.from_user.id} enabled antichannelpin in {m.chat.id}")
+            LOGGER.info(f"{m.from_user.id} enabled antichannelpin in {m.chat.id}")
             msg = "Turned on AntiChannelPin, now all message pinned by channel will be unpinned automtically!"
         elif m.command[1] in ("no", "off", "false"):
             pinsdb.antichannelpin_off()
-            LOGGER.info(
-                f"{m.from_user.id} disabled antichannelpin in {m.chat.id}")
+            LOGGER.info(f"{m.from_user.id} disabled antichannelpin in {m.chat.id}")
             msg = "Turned off AntiChannelPin, now all message pinned by channel will stay pinned!"
         else:
             await m.reply_text(
@@ -203,8 +199,7 @@ async def clean_linked(_, m: Message):
             msg = "Turned on CleanLinked! Now all the messages from linked channel will be deleted!"
         elif m.command[1] in ("no", "off", "false"):
             pinsdb.cleanlinked_off()
-            LOGGER.info(
-                f"{m.from_user.id} disabled CleanLinked in {m.chat.id}")
+            LOGGER.info(f"{m.from_user.id} disabled CleanLinked in {m.chat.id}")
             msg = "Turned off CleanLinked! Messages from linked channel will not be deleted!"
         else:
             await m.reply_text(

Powers/plugins/purge.py

@@ -19,7 +19,7 @@ async def purge(c: Gojo, m: Message):
 
         def divide_chunks(l: list, n: int = 100):
             for i in range(0, len(l), n):
-                yield l[i: i + n]
+                yield l[i : i + n]
 
         # Dielete messages in chunks of 100 messages
         m_list = list(divide_chunks(message_ids))
@@ -66,7 +66,7 @@ async def spurge(c: Gojo, m: Message):
 
         def divide_chunks(l: list, n: int = 100):
             for i in range(0, len(l), n):
-                yield l[i: i + n]
+                yield l[i : i + n]
 
         # Dielete messages in chunks of 100 messages
         m_list = list(divide_chunks(message_ids))

Powers/plugins/rules.py

@@ -93,13 +93,11 @@ async def priv_rules(_, m: Message):
         option = (m.text.split())[1]
         if option in ("on", "yes"):
             db.set_privrules(True)
-            LOGGER.info(
-                f"{m.from_user.id} enabled privaterules in {m.chat.id}")
+            LOGGER.info(f"{m.from_user.id} enabled privaterules in {m.chat.id}")
             msg = f"Private Rules have been turned <b>on</b> for chat <b>{m.chat.title}</b>"
         elif option in ("off", "no"):
             db.set_privrules(False)
-            LOGGER.info(
-                f"{m.from_user.id} disbaled privaterules in {m.chat.id}")
+            LOGGER.info(f"{m.from_user.id} disbaled privaterules in {m.chat.id}")
             msg = f"Private Rules have been turned <b>off</b> for chat <b>{m.chat.title}</b>"
         else:
             msg = "Option not valid, choose from <code>on</code>, <code>yes</code>, <code>off</code>, <code>no</code>"
@@ -109,8 +107,7 @@ async def priv_rules(_, m: Message):
         msg = (
             f"Current Preference for Private rules in this chat is: <b>{curr_pref}</b>"
         )
-        LOGGER.info(
-            f"{m.from_user.id} fetched privaterules preference in {m.chat.id}")
+        LOGGER.info(f"{m.from_user.id} fetched privaterules preference in {m.chat.id}")
         await m.reply_text(msg)
     else:
         await m.reply_text(text="Please check help on how to use this this command.")

Powers/plugins/start.py

@@ -69,8 +69,7 @@ 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
 
@@ -182,8 +181,7 @@ async def help_menu(_, m: Message):
         help_msg, help_kb = await get_help_msg(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(

Powers/plugins/warns.py

@@ -204,8 +204,7 @@ async def list_warns(c: Gojo, m: Message):
         await m.reply_text("This user has no warns!")
         return
     msg = f"{(await mention_html(user_first_name,user_id))} has <b>{num_warns}/{warn_settings['warn_limit']}</b> warns!\n\n<b>Reasons:</b>\n"
-    msg += "\n".join(
-        [("- No reason" if i is None else f" - {i}") for i in warns])
+    msg += "\n".join([("- No reason" if i is None else f" - {i}") for i in warns])
     await m.reply_text(msg)
     return
 

Powers/plugins/watchers.py

@@ -29,19 +29,16 @@ async def antichanpin_cleanlinked(c: Gojo, m: Message):
         curr = pins_db.get_settings()
         if curr["antichannelpin"]:
             await c.unpin_chat_message(chat_id=m.chat.id, message_id=msg_id)
-            LOGGER.info(
-                f"AntiChannelPin: msgid-{m.message_id} unpinned in {m.chat.id}")
+            LOGGER.info(f"AntiChannelPin: msgid-{m.message_id} unpinned in {m.chat.id}")
         if curr["cleanlinked"]:
             await c.delete_messages(m.chat.id, msg_id)
-            LOGGER.info(
-                f"CleanLinked: msgid-{m.message_id} cleaned in {m.chat.id}")
+            LOGGER.info(f"CleanLinked: msgid-{m.message_id} cleaned in {m.chat.id}")
     except ChatAdminRequired:
         await m.reply_text(
             "Disabled antichannelpin as I don't have enough admin rights!",
         )
         pins_db.antichannelpin_off()
-        LOGGER.warning(
-            f"Disabled antichannelpin in {m.chat.id} as i'm not an admin.")
+        LOGGER.warning(f"Disabled antichannelpin in {m.chat.id} as i'm not an admin.")
     except Exception as ef:
         LOGGER.error(ef)
         LOGGER.error(format_exc())
@@ -192,8 +189,7 @@ async def gban_watcher(c: Gojo, m: Message):
 
       To get unbanned, appeal at @{SUPPORT_GROUP}"""
             )
-            LOGGER.info(
-                f"Banned user {m.from_user.id} in {m.chat.id} due to antispam")
+            LOGGER.info(f"Banned user {m.from_user.id} in {m.chat.id} due to antispam")
             return
         except (ChatAdminRequired, UserAdminInvalid):
             # Bot not admin in group and hence cannot ban users!

Powers/utils/caching.py

@@ -13,8 +13,7 @@ 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/extract_user.py

@@ -27,7 +27,7 @@ async def extract_user(c: Gojo, m: Message) -> Tuple[int, str, str]:
             elif required_entity.type in ("mention", "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,8 +514,7 @@ 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.`",

Powers/utils/start_utils.py

@@ -28,7 +28,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):

Powers/utils/string.py

@@ -7,8 +7,7 @@ from Powers.utils.parser import escape_markdown
 from pyrogram.types import Message, InlineKeyboardButton
 
 
-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):
@@ -53,9 +52,8 @@ 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:
@@ -99,7 +97,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 +171,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]))