`SORTED IMPORT` and minor changes

Powers/__init__.py

@@ -1,12 +1,12 @@
-from time import time
 from datetime import datetime
-from traceback import format_exc
-from os import path, mkdir, environ
 from importlib import import_module as imp_mod
-from sys import exit as sysexit, stdout, version_info
-from logging import (
-    INFO, WARNING, FileHandler, StreamHandler, getLogger, basicConfig)
-
+from logging import (INFO, WARNING, FileHandler, StreamHandler, basicConfig,
+                     getLogger)
+from os import environ, mkdir, path
+from sys import exit as sysexit
+from sys import stdout, version_info
+from time import time
+from traceback import format_exc
 
 LOG_DATETIME = datetime.now().strftime("%d_%m_%Y-%H_%M_%S")
 LOGDIR = f"{__name__}/logs"
@@ -103,7 +103,8 @@ 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}")
@@ -144,6 +145,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/bot_class.py

@@ -1,16 +1,16 @@
+from platform import python_version
 from threading import RLock
-from Powers.vars import Config
+from time import gmtime, strftime, time
+
 from aiohttp import ClientSession
+from pyrogram import Client, __version__
 from pyrogram.raw.all import layer
+
+from Powers import (API_HASH, API_ID, BOT_TOKEN, LOG_DATETIME, LOGFILE, LOGGER,
+                    MESSAGE_DUMP, NO_LOAD, UPTIME, WORKERS, load_cmds)
 from Powers.database import MongoDB
-from platform import python_version
 from Powers.plugins import all_plugins
-from time import time, gmtime, strftime
-from pyrogram import Client, __version__
-from Powers import (
-    API_ID, LOGGER, UPTIME, LOGFILE, NO_LOAD, WORKERS, API_HASH, BOT_TOKEN,
-    LOG_DATETIME, MESSAGE_DUMP, load_cmds)
-
+from Powers.vars import Config
 
 INITIAL_LOCK = RLock()
 

Powers/database/__init__.py

@@ -1,8 +1,8 @@
 from sys import exit as exiter
+
+from Powers import DB_NAME, DB_URI, LOGGER
 from pymongo import MongoClient
 from pymongo.errors import PyMongoError
-from Powers import DB_URI, LOGGER, DB_NAME
-
 
 try:
     Powers_db_client = MongoClient(DB_URI)

Powers/database/antispam_db.py

@@ -1,7 +1,7 @@
-from threading import RLock
 from datetime import datetime
-from Powers.database import MongoDB
+from threading import RLock
 
+from Powers.database import MongoDB
 
 INSERTION_LOCK = RLock()
 ANTISPAM_BANNED = set()

Powers/database/approve_db.py

@@ -1,7 +1,7 @@
-from Powers import LOGGER
 from threading import RLock
-from Powers.database import MongoDB
 
+from Powers import LOGGER
+from Powers.database import MongoDB
 
 INSERTION_LOCK = RLock()
 
@@ -66,7 +66,8 @@ 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

@@ -1,9 +1,9 @@
+from threading import RLock
 from time import time
+
 from Powers import LOGGER
-from threading import RLock
 from Powers.database import MongoDB
 
-
 INSERTION_LOCK = RLock()
 
 
@@ -110,7 +110,8 @@ 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/chats_db.py

@@ -1,9 +1,9 @@
+from threading import RLock
 from time import time
+
 from Powers import LOGGER
-from threading import RLock
 from Powers.database import MongoDB
 
-
 INSERTION_LOCK = RLock()
 
 

Powers/database/disable_db.py

@@ -1,9 +1,9 @@
+from threading import RLock
 from time import time
+
 from Powers import LOGGER
-from threading import RLock
 from Powers.database import MongoDB
 
-
 INSERTION_LOCK = RLock()
 DISABLED_CMDS = {}
 
@@ -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

Powers/database/filters_db.py

@@ -1,8 +1,8 @@
 from threading import RLock
+
 from Powers.database import MongoDB
 from Powers.utils.msg_types import Types
 
-
 INSERTION_LOCK = RLock()
 
 
@@ -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/greetings_db.py

@@ -1,7 +1,7 @@
-from Powers import LOGGER
 from threading import RLock
-from Powers.database import MongoDB
 
+from Powers import LOGGER
+from Powers.database import MongoDB
 
 INSERTION_LOCK = RLock()
 
@@ -128,7 +128,8 @@ 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/group_blacklist.py

@@ -1,8 +1,8 @@
 from threading import RLock
+
 from Powers.database import MongoDB
 from Powers.database.chats_db import Chats
 
-
 INSERTION_LOCK = RLock()
 BLACKLIST_CHATS = []
 

Powers/database/notes_db.py

@@ -1,10 +1,10 @@
-from time import time
 from hashlib import md5
 from threading import RLock
+from time import time
+
 from Powers.database import MongoDB
 from Powers.utils.msg_types import Types
 
-
 INSERTION_LOCK = RLock()
 
 
@@ -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):

Powers/database/pins_db.py

@@ -1,7 +1,7 @@
-from Powers import LOGGER
 from threading import RLock
-from Powers.database import MongoDB
 
+from Powers import LOGGER
+from Powers.database import MongoDB
 
 INSERTION_LOCK = RLock()
 

Powers/database/reporting_db.py

@@ -1,9 +1,9 @@
+from threading import RLock
 from time import time
+
 from Powers import LOGGER
-from threading import RLock
 from Powers.database import MongoDB
 
-
 INSERTION_LOCK = RLock()
 
 
@@ -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
 

Powers/database/rules_db.py

@@ -1,9 +1,9 @@
+from threading import RLock
 from time import time
+
 from Powers import LOGGER
-from threading import RLock
 from Powers.database import MongoDB
 
-
 INSERTION_LOCK = RLock()
 
 
@@ -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/users_db.py

@@ -1,9 +1,9 @@
+from threading import RLock
 from time import time
+
 from Powers import LOGGER
-from threading import RLock
 from Powers.database import MongoDB
 
-
 INSERTION_LOCK = RLock()
 
 
@@ -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

@@ -1,9 +1,9 @@
+from threading import RLock
 from time import time
+
 from Powers import LOGGER
-from threading import RLock
 from Powers.database import MongoDB
 
-
 INSERTION_LOCK = RLock()
 
 
@@ -89,12 +89,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,
@@ -103,7 +105,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
 
@@ -119,9 +122,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
 

Powers/plugins/admin.py

@@ -1,24 +1,26 @@
-from os import remove
-from html import escape
 from asyncio import sleep
-from pyrogram import filters
-from Powers.vars import Config
+from html import escape
+from os import remove
 from traceback import format_exc
+
+from Powers import DEV_USERS, LOGGER, OWNER_ID, SUPPORT_GROUP, SUPPORT_STAFF
 from Powers.bot_class import Gojo
-from Powers.utils.parser import mention_html
 from Powers.database.approve_db import Approve
 from Powers.database.reporting_db import Reporting
+from Powers.utils.caching import (ADMIN_CACHE, TEMP_ADMIN_CACHE_BLOCK,
+                                  admin_cache_reload)
+from Powers.utils.custom_filters import (DEV_LEVEL, admin_filter, command,
+                                         owner_filter, promote_filter)
 from Powers.utils.extract_user import extract_user
-from pyrogram.types import Message, ChatPrivileges
-from pyrogram.enums import ChatType, ChatMemberStatus as CMS
-from Powers import LOGGER, OWNER_ID, DEV_USERS, SUPPORT_GROUP, SUPPORT_STAFF
-from Powers.utils.caching import (
-    ADMIN_CACHE, TEMP_ADMIN_CACHE_BLOCK, admin_cache_reload)
-from Powers.utils.custom_filters import (
-    DEV_LEVEL, command, admin_filter, owner_filter, promote_filter)
-from pyrogram.errors import (
-    RPCError, FloodWait, RightForbidden, UserAdminInvalid, ChatAdminRequired,
-    ChatAdminInviteRequired)
+from Powers.utils.parser import mention_html
+from Powers.vars import Config
+from pyrogram import filters
+from pyrogram.enums import ChatMemberStatus as CMS
+from pyrogram.enums import ChatType
+from pyrogram.errors import (ChatAdminInviteRequired, ChatAdminRequired,
+                             FloodWait, RightForbidden, RPCError,
+                             UserAdminInvalid)
+from pyrogram.types import ChatPrivileges, Message
 
 
 @Gojo.on_message(command("adminlist"))
@@ -37,7 +39,8 @@ async def adminlist_show(_, m: Message):
             note = "<i>Note:</i> These are up-to-date values!"
         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/antispam.py

@@ -1,18 +1,18 @@
-from io import BytesIO
 from datetime import datetime
-from Powers.vars import Config
+from io import BytesIO
 from traceback import format_exc
+
+from Powers import LOGGER, MESSAGE_DUMP, SUPPORT_GROUP, SUPPORT_STAFF
 from Powers.bot_class import Gojo
-from pyrogram.types import Message
-from Powers.database.users_db import Users
 from Powers.database.antispam_db import GBan
-from Powers.utils.parser import mention_html
+from Powers.database.users_db import Users
+from Powers.utils.clean_file import remove_markdown_and_html
 from Powers.utils.custom_filters import command
 from Powers.utils.extract_user import extract_user
-from Powers.utils.clean_file import remove_markdown_and_html
-from Powers import LOGGER, MESSAGE_DUMP, SUPPORT_GROUP, SUPPORT_STAFF
-from pyrogram.errors import PeerIdInvalid, UserIsBlocked, MessageTooLong
-
+from Powers.utils.parser import mention_html
+from Powers.vars import Config
+from pyrogram.errors import MessageTooLong, PeerIdInvalid, UserIsBlocked
+from pyrogram.types import Message
 
 # Initialize
 db = GBan()

Powers/plugins/approve.py

@@ -1,14 +1,14 @@
-from pyrogram import filters
-from Powers.bot_class import Gojo
-from Powers.utils.kbhelpers import ikb
 from Powers import LOGGER, SUPPORT_GROUP
-from Powers.utils.parser import mention_html
+from Powers.bot_class import Gojo
 from Powers.database.approve_db import Approve
-from pyrogram.types import Message, CallbackQuery
+from Powers.utils.custom_filters import admin_filter, command, owner_filter
 from Powers.utils.extract_user import extract_user
+from Powers.utils.kbhelpers import ikb
+from Powers.utils.parser import mention_html
+from pyrogram import filters
 from pyrogram.enums import ChatMemberStatus as CMS
-from pyrogram.errors import RPCError, PeerIdInvalid, UserNotParticipant
-from Powers.utils.custom_filters import command, admin_filter, owner_filter
+from pyrogram.errors import PeerIdInvalid, RPCError, UserNotParticipant
+from pyrogram.types import CallbackQuery, Message
 
 
 @Gojo.on_message(command("approve") & admin_filter)
@@ -89,7 +89,8 @@ 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,7 +160,8 @@ 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/bans.py

@@ -1,21 +1,21 @@
 from random import choice
-from pyrogram import enums
-from Powers.vars import Config
 from traceback import format_exc
+
+from Powers import LOGGER, OWNER_ID, SUPPORT_GROUP, SUPPORT_STAFF
 from Powers.bot_class import Gojo
-from pyrogram.filters import regex
-from Powers.utils.parser import mention_html
-from Powers.utils.string import extract_time
-from Powers.utils.extract_user import extract_user
-from Powers.utils.extras import BAN_GIFS, KICK_GIFS
 from Powers.utils.caching import ADMIN_CACHE, admin_cache_reload
 from Powers.utils.custom_filters import command, restrict_filter
-from Powers import LOGGER, OWNER_ID, SUPPORT_GROUP, SUPPORT_STAFF
-from pyrogram.types import (
-    Message, CallbackQuery, InlineKeyboardButton, InlineKeyboardMarkup)
-from pyrogram.errors import (
-    RPCError, PeerIdInvalid, RightForbidden, UserAdminInvalid,
-    ChatAdminRequired)
+from Powers.utils.extract_user import extract_user
+from Powers.utils.extras import BAN_GIFS, KICK_GIFS
+from Powers.utils.parser import mention_html
+from Powers.utils.string import extract_time
+from Powers.vars import Config
+from pyrogram import enums
+from pyrogram.errors import (ChatAdminRequired, PeerIdInvalid, RightForbidden,
+                             RPCError, UserAdminInvalid)
+from pyrogram.filters import regex
+from pyrogram.types import (CallbackQuery, InlineKeyboardButton,
+                            InlineKeyboardMarkup, Message)
 
 
 @Gojo.on_message(command("tban") & restrict_filter)
@@ -908,7 +908,8 @@ async def kickme(_, m: Message):
     if len(m.text.split()) >= 2:
         reason = m.text.split(None, 1)[1]
     try:
-        LOGGER.info(f"{m.from_user.id} kickme used by {m.from_user.id} in {m.chat.id}")
+        LOGGER.info(
+            f"{m.from_user.id} kickme used by {m.from_user.id} in {m.chat.id}")
         await m.chat.ban_member(m.from_user.id)
         txt = "Why not let me help you!"
         txt += f"\n<b>Reason</b>: {reason}" if reason else ""

Powers/plugins/blacklist.py

@@ -1,12 +1,13 @@
 from html import escape
+
 from Powers import LOGGER
-from pyrogram import filters
 from Powers.bot_class import Gojo
-from Powers.utils.kbhelpers import ikb
-from pyrogram.types import Message, CallbackQuery
 from Powers.database.blacklist_db import Blacklist
-from pyrogram.enums import ChatMemberStatus as CMS
 from Powers.utils.custom_filters import command, owner_filter, restrict_filter
+from Powers.utils.kbhelpers import ikb
+from pyrogram import filters
+from pyrogram.enums import ChatMemberStatus as CMS
+from pyrogram.types import CallbackQuery, Message
 
 
 @Gojo.on_message(command("blacklist") & filters.group)
@@ -56,7 +57,8 @@ 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,10 +113,12 @@ 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!"
@@ -149,7 +153,8 @@ 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/botstaff.py

@@ -1,9 +1,9 @@
+from Powers import DEV_USERS, LOGGER, OWNER_ID, SUDO_USERS, WHITELIST_USERS
 from Powers.bot_class import Gojo
-from pyrogram.types import Message
-from pyrogram.errors import RPCError
-from Powers.utils.parser import mention_html
 from Powers.utils.custom_filters import command
-from Powers import LOGGER, OWNER_ID, DEV_USERS, SUDO_USERS, WHITELIST_USERS
+from Powers.utils.parser import mention_html
+from pyrogram.errors import RPCError
+from pyrogram.types import Message
 
 
 @Gojo.on_message(command("botstaff", dev_cmd=True))

Powers/plugins/chat_blacklist.py

@@ -1,11 +1,11 @@
-from Powers import LOGGER
 from traceback import format_exc
+
+from Powers import LOGGER
 from Powers.bot_class import Gojo
-from pyrogram.types import Message
-from Powers.utils.custom_filters import command
-from pyrogram.errors import RPCError, PeerIdInvalid
 from Powers.database.group_blacklist import GroupBlacklist
-
+from Powers.utils.custom_filters import command
+from pyrogram.errors import PeerIdInvalid, RPCError
+from pyrogram.types import Message
 
 # initialise database
 db = GroupBlacklist()
@@ -42,7 +42,8 @@ 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

@@ -1,19 +1,20 @@
 import sys
+from asyncio import create_subprocess_shell, sleep, subprocess
 from io import BytesIO, StringIO
+from time import gmtime, strftime, time
 from traceback import format_exc
+
+from Powers import LOGFILE, LOGGER, MESSAGE_DUMP, UPTIME
 from Powers.bot_class import Gojo
-from pyrogram.types import Message
-from Powers.utils.http_helper import *
-from time import time, gmtime, strftime
 from Powers.database.chats_db import Chats
+from Powers.utils.clean_file import remove_markdown_and_html
 from Powers.utils.custom_filters import command
+from Powers.utils.http_helper import *
 from Powers.utils.parser import mention_markdown
-from Powers import LOGGER, UPTIME, LOGFILE, MESSAGE_DUMP
-from Powers.utils.clean_file import remove_markdown_and_html
-from asyncio import sleep, subprocess, create_subprocess_shell
-from pyrogram.errors import (
-    RPCError, FloodWait, PeerIdInvalid, ChannelInvalid, ChannelPrivate,
-    MessageTooLong, ChatAdminRequired, EntityBoundsInvalid)
+from pyrogram.errors import (ChannelInvalid, ChannelPrivate, ChatAdminRequired,
+                             EntityBoundsInvalid, FloodWait, MessageTooLong,
+                             PeerIdInvalid, RPCError)
+from pyrogram.types import Message
 
 
 @Gojo.on_message(command("ping", sudo_cmd=True))
@@ -139,7 +140,8 @@ 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

@@ -1,13 +1,14 @@
 from html import escape
-from pyrogram import filters
+
+from Powers import HELP_COMMANDS, LOGGER
 from Powers.bot_class import Gojo
-from Powers import LOGGER, HELP_COMMANDS
 from Powers.database.disable_db import Disabling
+from Powers.utils.custom_filters import (admin_filter, can_change_filter,
+                                         command, owner_filter)
+from pyrogram import filters
 from pyrogram.enums import ChatMemberStatus as CMS
-from pyrogram.types import (
-    Message, CallbackQuery, InlineKeyboardButton, InlineKeyboardMarkup)
-from Powers.utils.custom_filters import (
-    command, admin_filter, owner_filter, can_change_filter)
+from pyrogram.types import (CallbackQuery, InlineKeyboardButton,
+                            InlineKeyboardMarkup, Message)
 
 
 @Gojo.on_message(command("disable") & can_change_filter)
@@ -117,7 +118,8 @@ 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

@@ -1,21 +1,21 @@
+from re import escape as re_escape
 from secrets import choice
-from pyrogram import filters
 from traceback import format_exc
-from re import escape as re_escape
-from pyrogram.errors import RPCError
-from Powers.utils.kbhelpers import ikb
+
 from Powers.bot_class import LOGGER, Gojo
-from Powers.utils.cmd_senders import send_cmd
 from Powers.database.filters_db import Filters
-from pyrogram.enums import ChatMemberStatus as CMS
-from Powers.utils.regex_utils import regex_searcher
+from Powers.utils.cmd_senders import send_cmd
+from Powers.utils.custom_filters import admin_filter, command, owner_filter
+from Powers.utils.kbhelpers import ikb
 from Powers.utils.msg_types import Types, get_filter_type
-from pyrogram.types import Message, CallbackQuery, InlineKeyboardMarkup
-from Powers.utils.custom_filters import command, admin_filter, owner_filter
-from Powers.utils.string import (
-    parse_button, split_quotes, build_keyboard,
-    escape_mentions_using_curly_brackets)
-
+from Powers.utils.regex_utils import regex_searcher
+from Powers.utils.string import (build_keyboard,
+                                 escape_mentions_using_curly_brackets,
+                                 parse_button, split_quotes)
+from pyrogram import filters
+from pyrogram.enums import ChatMemberStatus as CMS
+from pyrogram.errors import RPCError
+from pyrogram.types import CallbackQuery, InlineKeyboardMarkup, Message
 
 # Initialise
 db = Filters()
@@ -96,7 +96,8 @@ 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,7 +121,8 @@ 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>.",
             )
@@ -281,7 +283,8 @@ 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/formatting.py

@@ -1,9 +1,9 @@
 from Powers import LOGGER
 from Powers.bot_class import Gojo
-from pyrogram import enums, filters
-from Powers.utils.kbhelpers import ikb
 from Powers.utils.custom_filters import command
-from pyrogram.types import Message, CallbackQuery
+from Powers.utils.kbhelpers import ikb
+from pyrogram import enums, filters
+from pyrogram.types import CallbackQuery, Message
 
 
 async def gen_formatting_kb(m):

Powers/plugins/fun.py

@@ -1,14 +1,16 @@
 from html import escape
 from random import choice
-from pyrogram import enums
-from Powers.utils import extras
+
+from Powers import DEV_USERS, LOGGER
 from Powers.bot_class import Gojo
-from pyrogram.types import Message
-from Powers import LOGGER, DEV_USERS
-from pyrogram.errors import MessageTooLong
+from Powers.utils import extras
 from Powers.utils.custom_filters import command
 from Powers.utils.extract_user import extract_user
-from Powers.utils.extras import NOWYES as NO, YESWNO as YES
+from Powers.utils.extras import NOWYES as NO
+from Powers.utils.extras import YESWNO as YES
+from pyrogram import enums
+from pyrogram.errors import MessageTooLong
+from pyrogram.types import Message
 
 
 @Gojo.on_message(command("shout"))
@@ -72,7 +74,8 @@ 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,7 +114,8 @@ 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/greetings.py

@@ -1,20 +1,20 @@
 from html import escape
 from secrets import choice
+
 from Powers import DEV_USERS
-from Powers.vars import Config
 from Powers.bot_class import Gojo
-from pyrogram import enums, filters
 from Powers.database.antispam_db import GBan
 from Powers.database.greetings_db import Greetings
-from pyrogram.enums import ChatMemberStatus as CMS
+from Powers.utils.custom_filters import admin_filter, bot_admin_filter, command
 from Powers.utils.msg_types import Types, get_wlcm_type
-from pyrogram.errors import RPCError, ChatAdminRequired
-from Powers.utils.parser import mention_html, escape_markdown
-from pyrogram.types import Message, ChatMemberUpdated, InlineKeyboardMarkup
-from Powers.utils.custom_filters import command, admin_filter, bot_admin_filter
-from Powers.utils.string import (
-    parse_button, build_keyboard, escape_invalid_curly_brackets)
-
+from Powers.utils.parser import escape_markdown, mention_html
+from Powers.utils.string import (build_keyboard, escape_invalid_curly_brackets,
+                                 parse_button)
+from Powers.vars import Config
+from pyrogram import enums, filters
+from pyrogram.enums import ChatMemberStatus as CMS
+from pyrogram.errors import ChatAdminRequired, RPCError
+from pyrogram.types import ChatMemberUpdated, InlineKeyboardMarkup, Message
 
 # Initialize
 gdb = GBan()

Powers/plugins/info.py

@@ -1,20 +1,18 @@
 import os
 from asyncio import sleep
-from pyrogram import enums
 from datetime import datetime
-from Powers.vars import Config
 from traceback import format_exc
+
+from Powers import (DEV_USERS, LOGGER, SUDO_USERS, SUPPORT_STAFF,
+                    WHITELIST_USERS)
 from Powers.bot_class import Gojo
-from pyrogram.types import Message
-from pyrogram.enums import ChatType
 from Powers.database.antispam_db import GBan
 from Powers.utils.custom_filters import command
 from Powers.utils.extract_user import extract_user
-from Powers import (
-    LOGGER, DEV_USERS, SUDO_USERS, SUPPORT_STAFF, WHITELIST_USERS)
-from pyrogram.errors import (
-    RPCError, MessageTooLong, EntityBoundsInvalid, MediaCaptionTooLong)
-
+from Powers.vars import Config
+from pyrogram import enums
+from pyrogram.errors import EntityBoundsInvalid, MediaCaptionTooLong, RPCError
+from pyrogram.types import Message
 
 gban_db = GBan()
 
@@ -189,17 +187,12 @@ async def chat_info(c: Gojo, chat, already=False):
 
 @Gojo.on_message(command(["info", "whois"]))
 async def info_func(c: Gojo, message: Message):
-    try:
-        user, _, user_name = await extract_user(c, message)
-    except Exception as e:
-        return await message.reply_text(
-            f"Got an error while running extract_user function error is {e}.....Give this message in supoort group"
-        )
+    user, _, user_name = await extract_user(c, message)
 
     if not user:
         await message.reply_text("Can't find user to fetch info!")
 
-    m = await message.reply_text(f"Fetching user info from telegram's database...")
+    m = await message.reply_text(f"Fetching {('@' + user_name) if user_name else 'user'} info from telegram's database...")
 
     try:
         info_caption, photo_id = await user_info(c, user)

Powers/plugins/initial.py

@@ -1,19 +1,19 @@
 from Powers import LOGGER
-from pyrogram import filters
 from Powers.bot_class import Gojo
-from pyrogram.types import Message
-from pyrogram.errors import RPCError
-from Powers.database.pins_db import Pins
-from Powers.database.chats_db import Chats
-from Powers.database.rules_db import Rules
-from Powers.database.users_db import Users
 from Powers.database.approve_db import Approve
-from Powers.database.filters_db import Filters
-from Powers.database.disable_db import Disabling
 from Powers.database.blacklist_db import Blacklist
+from Powers.database.chats_db import Chats
+from Powers.database.disable_db import Disabling
+from Powers.database.filters_db import Filters
 from Powers.database.greetings_db import Greetings
-from Powers.database.reporting_db import Reporting
 from Powers.database.notes_db import Notes, NotesSettings
+from Powers.database.pins_db import Pins
+from Powers.database.reporting_db import Reporting
+from Powers.database.rules_db import Rules
+from Powers.database.users_db import Users
+from pyrogram import filters
+from pyrogram.errors import RPCError
+from pyrogram.types import Message
 
 
 @Gojo.on_message(filters.group, group=4)

Powers/plugins/locks.py

@@ -1,10 +1,11 @@
-from Powers import LOGGER
 from asyncio import sleep
+
+from Powers import LOGGER
 from Powers.bot_class import Gojo
 from Powers.database.approve_db import Approve
-from pyrogram.types import Message, ChatPermissions
 from Powers.utils.custom_filters import command, restrict_filter
-from pyrogram.errors import RPCError, ChatNotModified, ChatAdminRequired
+from pyrogram.errors import ChatAdminRequired, ChatNotModified, RPCError
+from pyrogram.types import ChatPermissions, Message
 
 
 @Gojo.on_message(command("locktypes"))
@@ -55,7 +56,8 @@ 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:
@@ -122,7 +124,8 @@ 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,
@@ -130,7 +133,8 @@ 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:
@@ -212,7 +216,8 @@ 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:
@@ -285,7 +290,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(

Powers/plugins/muting.py

@@ -1,19 +1,20 @@
 from random import choice
-from Powers.vars import Config
+
+from Powers import LOGGER, OWNER_ID, SUPPORT_GROUP, SUPPORT_STAFF
 from Powers.bot_class import Gojo
-from pyrogram.filters import regex
+from Powers.utils.caching import ADMIN_CACHE, admin_cache_reload
+from Powers.utils.custom_filters import command, restrict_filter
+from Powers.utils.extract_user import extract_user
 from Powers.utils.extras import MUTE_GIFS
 from Powers.utils.parser import mention_html
 from Powers.utils.string import extract_time
-from Powers.utils.extract_user import extract_user
-from Powers.utils.caching import ADMIN_CACHE, admin_cache_reload
-from Powers.utils.custom_filters import command, restrict_filter
-from Powers import LOGGER, OWNER_ID, SUPPORT_GROUP, SUPPORT_STAFF
-from pyrogram.errors import (
-    RPCError, RightForbidden, ChatAdminRequired, UserNotParticipant)
-from pyrogram.types import (
-    Message, CallbackQuery, ChatPermissions, InlineKeyboardButton,
-    InlineKeyboardMarkup)
+from Powers.vars import Config
+from pyrogram.errors import (ChatAdminRequired, RightForbidden, RPCError,
+                             UserNotParticipant)
+from pyrogram.filters import regex
+from pyrogram.types import (CallbackQuery, ChatPermissions,
+                            InlineKeyboardButton, InlineKeyboardMarkup,
+                            Message)
 
 
 @Gojo.on_message(command("tmute") & restrict_filter)

Powers/plugins/notes.py

@@ -1,20 +1,21 @@
-from Powers import LOGGER
 from secrets import choice
-from Powers.vars import Config
 from traceback import format_exc
+
+from Powers import LOGGER
 from Powers.bot_class import Gojo
-from pyrogram import enums, filters
-from pyrogram.errors import RPCError
-from Powers.utils.kbhelpers import ikb
+from Powers.database.notes_db import Notes, NotesSettings
 from Powers.utils.cmd_senders import send_cmd
-from pyrogram.enums import ChatMemberStatus as CMS
+from Powers.utils.custom_filters import admin_filter, command, owner_filter
+from Powers.utils.kbhelpers import ikb
 from Powers.utils.msg_types import Types, get_note_type
-from Powers.database.notes_db import Notes, NotesSettings
-from pyrogram.types import Message, CallbackQuery, InlineKeyboardMarkup
-from Powers.utils.custom_filters import command, admin_filter, owner_filter
-from Powers.utils.string import (
-    parse_button, build_keyboard, escape_mentions_using_curly_brackets)
-
+from Powers.utils.string import (build_keyboard,
+                                 escape_mentions_using_curly_brackets,
+                                 parse_button)
+from Powers.vars import Config
+from pyrogram import enums, filters
+from pyrogram.enums import ChatMemberStatus as CMS
+from pyrogram.errors import RPCError
+from pyrogram.types import CallbackQuery, InlineKeyboardMarkup, Message
 
 # Initialise
 db = Notes()
@@ -74,7 +75,8 @@ 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(
@@ -300,11 +302,13 @@ 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,7 +316,8 @@ 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

@@ -1,14 +1,15 @@
-from Powers.bot_class import Gojo
-from pyrogram.filters import regex
-from Powers.utils.kbhelpers import ikb
 from html import escape as escape_html
+
 from Powers import LOGGER, SUPPORT_GROUP
+from Powers.bot_class import Gojo
 from Powers.database.pins_db import Pins
-from pyrogram.types import Message, CallbackQuery
+from Powers.utils.custom_filters import admin_filter, command
+from Powers.utils.kbhelpers import ikb
+from Powers.utils.string import build_keyboard, parse_button
 from pyrogram.enums import ChatMemberStatus as CMS
-from Powers.utils.string import parse_button, build_keyboard
-from Powers.utils.custom_filters import command, admin_filter
-from pyrogram.errors import RPCError, RightForbidden, ChatAdminRequired
+from pyrogram.errors import ChatAdminRequired, RightForbidden, RPCError
+from pyrogram.filters import regex
+from pyrogram.types import CallbackQuery, Message
 
 
 @Gojo.on_message(command("pin") & admin_filter)
@@ -36,10 +37,16 @@ async def pin_message(_, m: Message):
                 # If chat does not have a username, use this
                 link_chat_id = (str(m.chat.id)).replace("-100", "")
                 message_link = f"https://t.me/c/{link_chat_id}/{m.reply_to_message.id}"
-            await m.reply_text(
-                text=f"I have Pinned [this message]({message_link})!",
-                disable_web_page_preview=True,
-            )
+            if not disable_notification:
+                await m.reply_text(
+                    text=f"I have Pinned and Notified [this message]({message_link})!",
+                    disable_web_page_preview=True,
+                )
+            else:
+                await m.reply_text(
+                    text=f"I have Pinned [this message]({message_link})!",
+                    disable_web_page_preview=True,
+                )
 
         except ChatAdminRequired:
             await m.reply_text(text="I'm not admin or I don't have rights.")
@@ -89,7 +96,8 @@ 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
 
@@ -112,7 +120,8 @@ 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.")
@@ -140,11 +149,13 @@ 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(
@@ -196,7 +207,8 @@ 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

@@ -1,10 +1,11 @@
 from asyncio import sleep
+
 from Powers import SUPPORT_GROUP
 from Powers.bot_class import Gojo
-from pyrogram.types import Message
+from Powers.utils.custom_filters import admin_filter, command
 from pyrogram.enums import ChatType
-from pyrogram.errors import RPCError, MessageDeleteForbidden
-from Powers.utils.custom_filters import command, admin_filter
+from pyrogram.errors import MessageDeleteForbidden, RPCError
+from pyrogram.types import Message
 
 
 @Gojo.on_message(command("purge") & admin_filter)
@@ -19,7 +20,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 +67,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/report.py

@@ -1,14 +1,16 @@
-from pyrogram import filters
 from traceback import format_exc
+
+from Powers import LOGGER, SUPPORT_STAFF
 from Powers.bot_class import Gojo
-from pyrogram.errors import RPCError
+from Powers.database.reporting_db import Reporting
+from Powers.utils.custom_filters import admin_filter, command
 from Powers.utils.kbhelpers import ikb
-from Powers import LOGGER, SUPPORT_STAFF
 from Powers.utils.parser import mention_html
-from pyrogram.types import Message, CallbackQuery
-from Powers.database.reporting_db import Reporting
-from Powers.utils.custom_filters import command, admin_filter
-from pyrogram.enums import ChatType, ChatMembersFilter as cmf
+from pyrogram import filters
+from pyrogram.enums import ChatMembersFilter as cmf
+from pyrogram.enums import ChatType
+from pyrogram.errors import RPCError
+from pyrogram.types import CallbackQuery, Message
 
 
 @Gojo.on_message(

Powers/plugins/rules.py

@@ -1,11 +1,11 @@
 from Powers import LOGGER
-from pyrogram import filters
-from Powers.vars import Config
 from Powers.bot_class import Gojo
-from Powers.utils.kbhelpers import ikb
 from Powers.database.rules_db import Rules
-from pyrogram.types import Message, CallbackQuery
-from Powers.utils.custom_filters import command, admin_filter
+from Powers.utils.custom_filters import admin_filter, command
+from Powers.utils.kbhelpers import ikb
+from Powers.vars import Config
+from pyrogram import filters
+from pyrogram.types import CallbackQuery, Message
 
 
 @Gojo.on_message(command("rules") & filters.group)
@@ -93,11 +93,13 @@ 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>"
@@ -107,7 +109,8 @@ 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

@@ -1,17 +1,18 @@
 from random import choice
-from Powers.vars import Config
+
+from Powers import HELP_COMMANDS, LOGGER
 from Powers.bot_class import Gojo
-from pyrogram import enums, filters
-from Powers.utils.kbhelpers import ikb
-from Powers import LOGGER, HELP_COMMANDS
-from Powers.utils.extras import StartPic
 from Powers.utils.custom_filters import command
-from pyrogram.types import Message, CallbackQuery
-from pyrogram.enums import ChatType, ChatMemberStatus as CMS
-from pyrogram.errors import UserIsBlocked, QueryIdInvalid, MessageNotModified
-from Powers.utils.start_utils import (
-    gen_cmds_kb, gen_start_kb, get_help_msg, get_private_note,
-    get_private_rules)
+from Powers.utils.extras import StartPic
+from Powers.utils.kbhelpers import ikb
+from Powers.utils.start_utils import (gen_cmds_kb, gen_start_kb, get_help_msg,
+                                      get_private_note, get_private_rules)
+from Powers.vars import Config
+from pyrogram import enums, filters
+from pyrogram.enums import ChatMemberStatus as CMS
+from pyrogram.enums import ChatType
+from pyrogram.errors import MessageNotModified, QueryIdInvalid, UserIsBlocked
+from pyrogram.types import CallbackQuery, Message
 
 
 @Gojo.on_message(
@@ -69,7 +70,8 @@ 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
 
@@ -92,7 +94,7 @@ Hey [{m.from_user.first_name}](http://t.me/{m.from_user.username})! My self Gojo
 I'm here to help you manage your groups!
 Hit /help to find out more about how to use me in my full potential!
 
-Join my [News Channel](https://t.me/gojo_updates) to get information on all the latest updates."""
+Join my [News Channel](https://t.me/gojo_bots_network) to get information on all the latest updates."""
 
             await m.reply_photo(
                 photo=choice(StartPic),
@@ -131,7 +133,7 @@ Hey [{q.from_user.first_name}](http://t.me/{q.from_user.username})! My name is G
 I'm here to help you manage your groups!
 Hit /help to find out more about how to use me in my full potential!
 
-Join my [News Channel](http://t.me/gojo_updates) to get information on all the latest updates."""
+Join my [News Channel](http://t.me/gojo_bots_network) to get information on all the latest updates."""
 
         await q.edit_message_caption(
             caption=cpt,
@@ -147,7 +149,7 @@ Join my [News Channel](http://t.me/gojo_updates) to get information on all the l
 async def commands_menu(_, q: CallbackQuery):
     cmds = sorted(list(HELP_COMMANDS.keys()))
     kb = [cmd.lower() for cmd in cmds]
-    ou = [kb[i : i + 3] for i in range(0, len(kb), 3)]
+    ou = [kb[i: i + 3] for i in range(0, len(kb), 3)]
     keyboard = ikb(ou, True)
     try:
         cpt = f"""
@@ -179,7 +181,8 @@ 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(
@@ -220,7 +223,7 @@ async def help_menu(_, m: Message):
         if m.chat.type == ChatType.PRIVATE:
             cmds = sorted(list(HELP_COMMANDS.keys()))
             kb = [cmd.lower() for cmd in cmds]
-            ou = [kb[i : i + 3] for i in range(0, len(kb), 3)]
+            ou = [kb[i: i + 3] for i in range(0, len(kb), 3)]
             keyboard = ikb(ou, True)
             msg = f"""
 Hey **[{m.from_user.first_name}](http://t.me/{m.from_user.username})**!My name is Gojo✨.

Powers/plugins/stats.py

@@ -1,19 +1,19 @@
-from pyrogram import enums
 from Powers.bot_class import Gojo
-from pyrogram.types import Message
-from Powers.database.pins_db import Pins
-from Powers.database.chats_db import Chats
-from Powers.database.rules_db import Rules
-from Powers.database.users_db import Users
 from Powers.database.antispam_db import GBan
 from Powers.database.approve_db import Approve
-from Powers.database.filters_db import Filters
-from Powers.utils.custom_filters import command
-from Powers.database.disable_db import Disabling
 from Powers.database.blacklist_db import Blacklist
+from Powers.database.chats_db import Chats
+from Powers.database.disable_db import Disabling
+from Powers.database.filters_db import Filters
 from Powers.database.greetings_db import Greetings
-from Powers.database.warns_db import Warns, WarnSettings
 from Powers.database.notes_db import Notes, NotesSettings
+from Powers.database.pins_db import Pins
+from Powers.database.rules_db import Rules
+from Powers.database.users_db import Users
+from Powers.database.warns_db import Warns, WarnSettings
+from Powers.utils.custom_filters import command
+from pyrogram import enums
+from pyrogram.types import Message
 
 
 @Gojo.on_message(command("stats", dev_cmd=True))

Powers/plugins/utils.py

@@ -1,21 +1,22 @@
-import re
 import asyncio
+import re
+from io import BytesIO
+from os import remove
+
 import aiofiles
+from gpytranslate import Translator
 from Powers import *
-from os import remove
-from io import BytesIO
-from wikipedia import summary
 from Powers.bot_class import Gojo
-from gpytranslate import Translator
+from Powers.database.users_db import Users
+from Powers.utils.clean_file import remove_markdown_and_html
+from Powers.utils.custom_filters import command
+from Powers.utils.http_helper import *
 from pyrogram import enums, filters
 from pyrogram.enums import ChatType
-from Powers.utils.http_helper import *
-from Powers.database.users_db import Users
 from pyrogram.errors import MessageTooLong
-from Powers.utils.custom_filters import command
-from Powers.utils.clean_file import remove_markdown_and_html
-from wikipedia.exceptions import PageError, DisambiguationError
-from pyrogram.types import Message, InlineKeyboardButton, InlineKeyboardMarkup
+from pyrogram.types import InlineKeyboardButton, InlineKeyboardMarkup, Message
+from wikipedia import summary
+from wikipedia.exceptions import DisambiguationError, PageError
 
 
 @Gojo.on_message(command("wiki"))

Powers/plugins/warns.py

@@ -1,19 +1,20 @@
 from time import time
-from pyrogram import filters
-from Powers.vars import Config
-from Powers.bot_class import Gojo
-from pyrogram.errors import RPCError
+
 from Powers import LOGGER, SUPPORT_STAFF
+from Powers.bot_class import Gojo
 from Powers.database.rules_db import Rules
 from Powers.database.users_db import Users
-from Powers.utils.parser import mention_html
-from Powers.utils.extract_user import extract_user
 from Powers.database.warns_db import Warns, WarnSettings
 from Powers.utils.caching import ADMIN_CACHE, admin_cache_reload
-from Powers.utils.custom_filters import command, admin_filter, restrict_filter
-from pyrogram.types import (
-    Message, CallbackQuery, ChatPermissions, InlineKeyboardButton,
-    InlineKeyboardMarkup)
+from Powers.utils.custom_filters import admin_filter, command, restrict_filter
+from Powers.utils.extract_user import extract_user
+from Powers.utils.parser import mention_html
+from Powers.vars import Config
+from pyrogram import filters
+from pyrogram.errors import RPCError
+from pyrogram.types import (CallbackQuery, ChatPermissions,
+                            InlineKeyboardButton, InlineKeyboardMarkup,
+                            Message)
 
 
 @Gojo.on_message(
@@ -204,7 +205,8 @@ 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

@@ -1,21 +1,21 @@
+from re import escape as re_escape
 from time import time
-from pyrogram import filters
 from traceback import format_exc
+
+from Powers import LOGGER, MESSAGE_DUMP, SUPPORT_STAFF
 from Powers.bot_class import Gojo
-from re import escape as re_escape
-from Powers.database.pins_db import Pins
-from Powers.utils.parser import mention_html
+from Powers.database.antispam_db import ANTISPAM_BANNED, GBan
 from Powers.database.approve_db import Approve
 from Powers.database.blacklist_db import Blacklist
-from Powers.utils.regex_utils import regex_searcher
-from pyrogram.types import Message, ChatPermissions
-from Powers import LOGGER, MESSAGE_DUMP, SUPPORT_STAFF
-from Powers.database.warns_db import Warns, WarnSettings
 from Powers.database.group_blacklist import BLACKLIST_CHATS
-from Powers.database.antispam_db import ANTISPAM_BANNED, GBan
+from Powers.database.pins_db import Pins
+from Powers.database.warns_db import Warns, WarnSettings
 from Powers.utils.caching import ADMIN_CACHE, admin_cache_reload
-from pyrogram.errors import RPCError, UserAdminInvalid, ChatAdminRequired
-
+from Powers.utils.parser import mention_html
+from Powers.utils.regex_utils import regex_searcher
+from pyrogram import filters
+from pyrogram.errors import ChatAdminRequired, RPCError, UserAdminInvalid
+from pyrogram.types import ChatPermissions, Message
 
 # Initialise
 gban_db = GBan()
@@ -29,7 +29,8 @@ 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.id} unpinned in {m.chat.id}")
+            LOGGER.info(
+                f"AntiChannelPin: msgid-{m.id} unpinned in {m.chat.id}")
         if curr["cleanlinked"]:
             await c.delete_messages(m.chat.id, msg_id)
             LOGGER.info(f"CleanLinked: msgid-{m.id} cleaned in {m.chat.id}")
@@ -38,7 +39,8 @@ async def antichanpin_cleanlinked(c: Gojo, m: Message):
             "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())
@@ -189,7 +191,8 @@ 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/admin_check.py

@@ -1,8 +1,8 @@
 from traceback import format_exc
-from pyrogram.types import Message, CallbackQuery
-from pyrogram.enums import ChatMemberStatus as CMS
-from Powers import LOGGER, OWNER_ID, DEV_USERS, SUDO_USERS
 
+from Powers import DEV_USERS, LOGGER, OWNER_ID, SUDO_USERS
+from pyrogram.enums import ChatMemberStatus as CMS
+from pyrogram.types import CallbackQuery, Message
 
 SUDO_LEVEL = SUDO_USERS + DEV_USERS + [int(OWNER_ID)]
 DEV_LEVEL = DEV_USERS + [int(OWNER_ID)]

Powers/utils/caching.py

@@ -1,13 +1,13 @@
-from typing import List
-from Powers import LOGGER
 from threading import RLock
+from time import perf_counter, time
+from typing import List
+
 from cachetools import TTLCache
-from time import time, perf_counter
-from pyrogram.types import CallbackQuery
+from Powers import LOGGER
 from pyrogram.enums import ChatMembersFilter
+from pyrogram.types import CallbackQuery
 from pyrogram.types.messages_and_media.message import Message
 
-
 THREAD_LOCK = RLock()
 
 # admins stay cached for 30 mins

Powers/utils/custom_filters.py

@@ -1,15 +1,17 @@
+from re import compile as compile_re
+from re import escape
 from shlex import split
-from Powers.vars import Config
 from typing import List, Union
-from pyrogram.filters import create
-from re import escape, compile as compile_re
+
+from Powers import DEV_USERS, OWNER_ID, SUDO_USERS
 from Powers.database.disable_db import Disabling
-from pyrogram.types import Message, CallbackQuery
-from Powers import OWNER_ID, DEV_USERS, SUDO_USERS
-from pyrogram.errors import RPCError, UserNotParticipant
-from pyrogram.enums import ChatType, ChatMemberStatus as CMS
 from Powers.utils.caching import ADMIN_CACHE, admin_cache_reload
-
+from Powers.vars import Config
+from pyrogram.enums import ChatMemberStatus as CMS
+from pyrogram.enums import ChatType
+from pyrogram.errors import RPCError, UserNotParticipant
+from pyrogram.filters import create
+from pyrogram.types import CallbackQuery, Message
 
 SUDO_LEVEL = set(SUDO_USERS + DEV_USERS + [int(OWNER_ID)])
 DEV_LEVEL = set(DEV_USERS + [int(OWNER_ID)])

Powers/utils/extract_user.py

@@ -1,6 +1,7 @@
+from traceback import format_exc
 from typing import Tuple
+
 from Powers import LOGGER
-from traceback import format_exc
 from Powers.bot_class import Gojo
 from Powers.database.users_db import Users
 from pyrogram.enums import MessageEntityType as entity
@@ -28,7 +29,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.`",

Powers/utils/http_helper.py

@@ -1,4 +1,5 @@
 from asyncio import gather
+
 from Powers.bot_class import aiohttpsession as session