Pre planned features for `V 2.2.0`

Powers/__init__.py

@@ -96,12 +96,12 @@ elif not Config.GENIUS_API_TOKEN:
     is_genius_lyrics = False
     genius_lyrics = False
 
-is_audd = False
-Audd = None
-if Config.AuDD_API:
-    is_audd = True
-    Audd = Config.AuDD_API
-    LOGGER.info("Found Audd api")
+# is_audd = False
+# Audd = None
+# if Config.AuDD_API:
+#     is_audd = True
+#     Audd = Config.AuDD_API
+#     LOGGER.info("Found Audd api")
 
 is_rmbg = False
 RMBG = None

Powers/plugins/afk.py

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

Powers/plugins/auto_join.py

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

Powers/plugins/botstaff.py

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

Powers/plugins/flood.py

@@ -15,7 +15,7 @@ from Powers.bot_class import Gojo
 from Powers.database.approve_db import Approve
 from Powers.database.flood_db import Floods
 from Powers.supports import get_support_staff
-from Powers.utils.custom_filters import admin_filter, command
+from Powers.utils.custom_filters import admin_filter, command, flood_filter
 from Powers.utils.extras import BAN_GIFS, KICK_GIFS, MUTE_GIFS
 from Powers.utils.kbhelpers import ikb
 from Powers.vars import Config
@@ -330,41 +330,17 @@ async def reverse_callbacks(c: Gojo, q: CallbackQuery):
         return
 
 dic = {}
-@Gojo.on_message(filters.all & ~filters.bot | ~filters.private, 10)
+@Gojo.on_message(flood_filter & ~admin_filter)
 async def flood_watcher(c: Gojo, m: Message):
     c_id = m.chat.id
     
-    if not m.chat:
-        return
-    
     Flood = Floods()
     
-    try:
-        u_id = m.from_user.id
-    except AttributeError:
-        return # Get this error when the message received is not by an user and return
+    u_id = m.from_user.id
     
     is_flood = Flood.is_chat(c_id)
     
-    if not is_flood:
-        return # return of chat is not in anti flood protection
-    
-    app_users = Approve(m.chat.id).list_approved()
-    
-    if u_id in {i[0] for i in app_users}:
-        return #return if the user is approved
-    
-    if not is_flood or u_id in SUPPORT_STAFF:
-        return #return if the user is in support_staff
-    
-    try:
-        user_status = (await m.chat.get_member(m.from_user.id)).status
-    except Exception:
-        return
-    
-    if user_status in [CMS.OWNER, CMS.ADMINISTRATOR]:
-        return #return if the user is owner or admin
-    
+
     action = is_flood[2]
     limit = int(is_flood[0])
     within = int(is_flood[1])

Powers/plugins/start.py

@@ -1,4 +1,3 @@
-import os
 from random import choice
 from time import gmtime, strftime, time
 
@@ -6,16 +5,18 @@ from pyrogram import enums, filters
 from pyrogram.enums import ChatMemberStatus as CMS
 from pyrogram.enums import ChatType
 from pyrogram.errors import (MediaCaptionTooLong, MessageNotModified,
-                             QueryIdInvalid, UserIsBlocked)
+                             QueryIdInvalid, RPCError, UserIsBlocked)
 from pyrogram.types import (CallbackQuery, InlineKeyboardButton,
                             InlineKeyboardMarkup, Message)
 
-from Powers import (HELP_COMMANDS, LOGGER, PYROGRAM_VERSION, PYTHON_VERSION,
-                    UPTIME, VERSION)
+from Powers import (HELP_COMMANDS, LOGGER, OWNER_ID, PYROGRAM_VERSION,
+                    PYTHON_VERSION, UPTIME, VERSION, WHITELIST_USERS)
 from Powers.bot_class import Gojo
+from Powers.supports import get_support_staff
 from Powers.utils.custom_filters import command
 from Powers.utils.extras import StartPic
 from Powers.utils.kbhelpers import ikb
+from Powers.utils.parser import mention_html
 from Powers.utils.start_utils import (gen_cmds_kb, gen_start_kb, get_help_msg,
                                       get_private_note, get_private_rules)
 from Powers.vars import Config
@@ -301,3 +302,53 @@ async def get_module_info(c: Gojo, q: CallbackQuery):
       await c.send_message(chat_id=q.message.chat.id,text=help_msg,)
     await q.answer()
     return
+
+DEV_USERS = get_support_staff("dev")
+SUDO_USERS = get_support_staff("sudo")
+
+@Gojo.on_callback_query(filters.regex("^give_bot_staffs$"))
+async def give_bot_staffs(c: Gojo, q: CallbackQuery):
+    try:
+        owner = await c.get_users(OWNER_ID)
+        reply = f"<b>🌟 Owner:</b> {(await mention_html(owner.first_name, OWNER_ID))} (<code>{OWNER_ID}</code>)\n"
+    except RPCError:
+        pass
+    true_dev = list(set(DEV_USERS) - {OWNER_ID})
+    reply += "\n<b>Developers ⚡️:</b>\n"
+    if not true_dev:
+        reply += "No Dev Users\n"
+    else:
+        for each_user in true_dev:
+            user_id = int(each_user)
+            try:
+                user = await c.get_users(user_id)
+                reply += f"• {(await mention_html(user.first_name, user_id))} (<code>{user_id}</code>)\n"
+            except RPCError:
+                pass
+    true_sudo = list(set(SUDO_USERS) - set(DEV_USERS))
+    reply += "\n<b>Sudo Users 🐉:</b>\n"
+    if true_sudo == []:
+        reply += "No Sudo Users\n"
+    else:
+        for each_user in true_sudo:
+            user_id = int(each_user)
+            try:
+                user = await c.get_users(user_id)
+                reply += f"• {(await mention_html(user.first_name, user_id))} (<code>{user_id}</code>)\n"
+            except RPCError:
+                pass
+    reply += "\n<b>Whitelisted Users 🐺:</b>\n"
+    if WHITELIST_USERS == []:
+        reply += "No additional whitelisted users\n"
+    else:
+        for each_user in WHITELIST_USERS:
+            user_id = int(each_user)
+            try:
+                user = await c.get_users(user_id)
+                reply += f"• {(await mention_html(user.first_name, user_id))} (<code>{user_id}</code>)\n"
+            except RPCError:
+                pass
+
+    await q.edit_message_caption(reply,reply_markup=InlineKeyboardMarkup([[InlineKeyboardButton("« Back","start_back")]]))
+    return
+

Powers/plugins/stickers.py

@@ -241,6 +241,32 @@ async def kang(c:Gojo, m: Message):
         LOGGER.error(format_exc())
     return
 
+@Gojo.on_message(command(["rmsticker", "removesticker"]))
+async def remove_sticker_from_pack(c: Gojo, m: Message):
+    if not m.reply_to_message or not m.reply_to_message.sticker:
+        return await m.reply_text(
+            "Reply to a sticker to remove it from the pack."
+        )
+    
+    sticker = m.reply_to_message.sticker
+
+    to_modify = await m.reply_text(f"Removing the sticker from your pack")
+    sticker_set = await get_sticker_set_by_name(c, sticker.set_name)
+
+    if not sticker_set:
+        await to_modify.edit_text("This sticker is not part for your pack")
+        return
+    
+    try:
+        await remove_sticker(c, sticker.file_id)
+        await to_modify.edit_text(f"Successfully removed [sticker]({m.reply_to_message.link}) from {sticker_set.set.title}")
+    except Exception as e:
+        await to_modify.delete()
+        await m.reply_text(f"Failed to remove sticker due to:\n{e}\nPlease report this bug using `/bug`")
+        LOGGER.error(e)
+        LOGGER.error(format_exc())
+    return
+    
 
 @Gojo.on_message(command(["mmfb","mmfw","mmf"]))
 async def memify_it(c: Gojo, m: Message):

Powers/plugins/utils.py

@@ -6,7 +6,7 @@ from os import remove
 import aiofiles
 from gpytranslate import Translator
 from pyrogram import enums, filters
-from pyrogram.errors import MessageTooLong, PeerIdInvalid
+from pyrogram.errors import MessageTooLong, PeerIdInvalid, RPCError
 from pyrogram.types import InlineKeyboardButton, InlineKeyboardMarkup, Message
 from wikipedia import summary
 from wikipedia.exceptions import DisambiguationError, PageError
@@ -21,6 +21,9 @@ from Powers.utils.extract_user import extract_user
 from Powers.utils.http_helper import *
 from Powers.utils.parser import mention_html
 
+DEV_USERS = get_support_staff("dev")
+SUDO_USERS = get_support_staff("sudo")
+
 
 @Gojo.on_message(command("wiki"))
 async def wiki(_, m: Message):
@@ -331,8 +334,8 @@ async def paste_func(_, message: Message):
             content = r.text
             exe = "txt"
         if r.document:
-            if r.document.file_size > 40000:
-                return await m.edit("You can only paste files smaller than 40KB.")
+            # if r.document.file_size > 40000:
+            #     return await m.edit("You can only paste files smaller than 40KB.")
 
             if not pattern.search(r.document.mime_type):
                 return await m.edit("Only text files can be pasted.")
@@ -419,6 +422,54 @@ async def reporting_query(c: Gojo, m: Message):
     await c.send_message(OWNER_ID,f"New bug report\n{ppost}",disable_web_page_preview=True)
     return
 
+
+@Gojo.on_message(command("botstaffs"))
+async def botstaff(c: Gojo, m: Message):
+    try:
+        owner = await c.get_users(OWNER_ID)
+        reply = f"<b>🌟 Owner:</b> {(await mention_html(owner.first_name, OWNER_ID))} (<code>{OWNER_ID}</code>)\n"
+    except RPCError:
+        pass
+    true_dev = list(set(DEV_USERS) - {OWNER_ID})
+    reply += "\n<b>Developers ⚡️:</b>\n"
+    if not true_dev:
+        reply += "No Dev Users\n"
+    else:
+        for each_user in true_dev:
+            user_id = int(each_user)
+            try:
+                user = await c.get_users(user_id)
+                reply += f"• {(await mention_html(user.first_name, user_id))} (<code>{user_id}</code>)\n"
+            except RPCError:
+                pass
+    true_sudo = list(set(SUDO_USERS) - set(DEV_USERS))
+    reply += "\n<b>Sudo Users 🐉:</b>\n"
+    if true_sudo == []:
+        reply += "No Sudo Users\n"
+    else:
+        for each_user in true_sudo:
+            user_id = int(each_user)
+            try:
+                user = await c.get_users(user_id)
+                reply += f"• {(await mention_html(user.first_name, user_id))} (<code>{user_id}</code>)\n"
+            except RPCError:
+                pass
+    reply += "\n<b>Whitelisted Users 🐺:</b>\n"
+    if WHITELIST_USERS == []:
+        reply += "No additional whitelisted users\n"
+    else:
+        for each_user in WHITELIST_USERS:
+            user_id = int(each_user)
+            try:
+                user = await c.get_users(user_id)
+                reply += f"• {(await mention_html(user.first_name, user_id))} (<code>{user_id}</code>)\n"
+            except RPCError:
+                pass
+    await m.reply_text(reply)
+    LOGGER.info(f"{m.from_user.id} fetched botstaff in {m.chat.id}")
+    return
+
+
 __PLUGIN__ = "utils"
 _DISABLE_CMDS_ = ["paste", "wiki", "id", "gifid", "tr", "github", "git", "bug"]
 __alt_name__ = ["util", "misc", "tools"]
@@ -429,7 +480,6 @@ __HELP__ = """
 Some utils provided by bot to make your tasks easy!
 
 • /id: Get the current group id. If used by replying to a message, get that user's id.
-• /info: Get information about a user.
 • /gifid: Reply to a gif to me to tell you its file ID.
 • /lyrics `<song name>`-`<artist name>` : Find your song and give the lyrics of the song
 • /wiki: `<query>`: wiki your query.
@@ -437,6 +487,7 @@ Some utils provided by bot to make your tasks easy!
 • /git `<username>`: Search for the user using github api!
 • /weebify `<text>` or `<reply to message>`: To weebify the text.
 • /bug <reply to text message> : To report a bug
+• /botstaffs : Give the list of the bot staffs.
 
 **Example:**
 `/git iamgojoof6eyes`: this fetches the information about a user from the database."""

Powers/utils/custom_filters.py

@@ -7,10 +7,14 @@ 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
+from pyrogram.types import CallbackQuery, ChatJoinRequest, Message
 
 from Powers import DEV_USERS, OWNER_ID, SUDO_USERS
+from Powers.database.afk_db import AFK
+from Powers.database.approve_db import Approve
+from Powers.database.autojoin_db import AUTOJOIN
 from Powers.database.disable_db import Disabling
+from Powers.database.flood_db import Floods
 from Powers.utils.caching import ADMIN_CACHE, admin_cache_reload
 from Powers.vars import Config
 
@@ -302,7 +306,75 @@ async def can_pin_message_func(_, __, m):
 
     return status
 
+async def auto_join_check_filter(_, __, j: ChatJoinRequest):
+    chat = j.chat.id
+    aj = AUTOJOIN()
+    join_type = aj.get_autojoin(chat)
+    
+    if not join_type:
+        return False
+    else:
+        return True
+
+async def afk_check_filter(_, __, m: Message):
+    if not m.from_user:
+        return False
+
+    if m.from_user.is_bot:
+        return False
+
+    if m.chat.type == ChatType.PRIVATE:
+        return False
+    
+    afk = AFK()
+    user = m.from_user.id
+    chat = m.chat.id
+    repl = m.reply_to_message
+
+    if repl and repl.from_user:
+        rep_user = repl.from_user.id
+    else:
+        rep_user = False
+
+    is_afk = afk.check_afk(chat,user)
+    is_rep_afk = False
+    if rep_user:
+        is_rep_afk = afk.check_afk(chat,rep_user)
+
+    if not is_rep_afk and not is_afk:
+        return False
+    else:
+        return True
+
+async def flood_check_filter(_, __, m: Message):
+    Flood = Floods()
+    if not m.chat:
+        return False
+
+    if not m.from_user:
+        return False
+    
+    if m.chat.type == ChatType.PRIVATE:
+        return False
+
+    u_id = m.from_user.id
+    c_id = m.chat.id
+    is_flood = Flood.is_chat(c_id)
+    
+    app_users = Approve(m.chat.id).list_approved()
+
+    if not is_flood or u_id in SUDO_LEVEL:
+        return False
+    
+    elif u_id in {i[0] for i in app_users}:
+        return False
+    
+    else:
+        return True
 
+flood_filter = create(flood_check_filter)
+afk_filter = create(afk_check_filter)
+auto_join_filter = create(auto_join_check_filter)
 admin_filter = create(admin_check_func)
 owner_filter = create(owner_check_func)
 restrict_filter = create(restrict_check_func)

Powers/utils/extract_user.py

@@ -98,6 +98,7 @@ async def extract_user(c: Gojo, m: Message) -> Tuple[int, str, str]:
                             user = await c.get_users(user_r.user_id)
                         except Exception as ef:
                             return await m.reply_text(f"User not found ! Error: {ef}")
+                    user_id = user.id
                     user_first_name = user.first_name
                     user_name = user.username
                     LOGGER.error(ef)

Powers/utils/start_utils.py

@@ -44,9 +44,8 @@ async def gen_start_kb(q: Message or CallbackQuery):
                     "url",
                 ),
                 (
-                    "Support 👥",
-                    f"https://t.me/{SUPPORT_GROUP}",
-                    "url",
+                    "Bot Staffs 🚔",
+                    f"give_bot_staffs",
                 ),
             ],
             [

Powers/utils/sticker_help.py

@@ -3,12 +3,14 @@ import math
 import os
 import shlex
 import textwrap
+from time import time
 from typing import List, Tuple
 
 from PIL import Image, ImageDraw, ImageFont
 from pyrogram import errors, raw
 from pyrogram.file_id import FileId
 from pyrogram.types import Message
+from unidecode import unidecode
 
 from Powers.bot_class import Gojo
 
@@ -181,6 +183,10 @@ async def get_document_from_file_id(
         file_reference=decoded.file_reference,
     )
 
+async def remove_sticker(c: Gojo, stickerid: str) -> raw.base.messages.StickerSet:
+    sticker = await get_document_from_file_id(stickerid)
+    return await c.invoke(raw.functions.stickers.RemoveStickerFromSet(sticker=sticker))
+
 
 async def draw_meme(image_path: str, text: str, sticker: bool, fiill: str) -> list:
     _split = text.split(";", 1)
@@ -194,19 +200,36 @@ async def draw_meme(image_path: str, text: str, sticker: bool, fiill: str) -> li
     image = Image.open(image_path)
     width, height = image.size
 
-    font_size = int(width / 11)
+    font_size = int((30 / 500) * width)
     font = ImageFont.truetype("./extras/comic.ttf", font_size)
 
     draw = ImageDraw.Draw(image)
 
-    upper_text_width, _ = draw.textsize(upper_text, font=font)
-    lower_text_width, lower_text_height = draw.textsize(lower_text, font=font)
-
-    upper_text_position = ((width - upper_text_width) // 2, height // 10)
-    lower_text_position = ((width - lower_text_width) // 2, height - lower_text_height - (height // 10))
-
-    draw.text(upper_text_position, upper_text, font=font, fill=fiill)
-    draw.text(lower_text_position, lower_text, font=font, fill=fiill)
+    curr_height, padding = 20, 5
+    for utext in textwrap.wrap(upper_text, 25):
+        upper_width = draw.textlength(utext, font=font)
+        draw.text(
+            ((width - upper_width) / 2, curr_height),
+            unidecode(utext),
+            (255, 255, 255),
+            font,
+            stroke_width=3,
+            stroke_fill=fiill,
+        )
+        curr_height += font_size + padding
+
+    curr_height = height - font_size
+    for ltext in reversed(textwrap.wrap(lower_text, 25)):
+        lower_width = draw.textlength(ltext, font=font)
+        draw.text(
+            ((width - lower_width) / 2, curr_height - font_size),
+            ltext,
+            (255, 255, 255),
+            font,
+            stroke_width=3,
+            stroke_fill=fiill,
+        )
+        curr_height -= font_size + padding
 
     if sticker:
         stick_path = image_path
@@ -214,7 +237,7 @@ async def draw_meme(image_path: str, text: str, sticker: bool, fiill: str) -> li
         stick_path = await resize_file_to_sticker_size(image_path)
 
     image1 = image_path
-    image2 = tosticker(stick_path,"@memesofdank_memer_hu_vai.webp")
+    image2 = tosticker(stick_path,f"@GojoSuperbot_{int(time())}.webp")
 
     image.save(image1)
     image.save(image2)
@@ -224,113 +247,7 @@ async def draw_meme(image_path: str, text: str, sticker: bool, fiill: str) -> li
     return [image1, image2]
 
 
-# async def draw_meme(image_path, text:str,stick):
-#     """Hellbot se churaya hai hue hue hue..."""
-#     img = Image.open(image_path)
-#     i_width, i_height = img.size
-#     m_font = ImageFont.truetype(
-#         "./extras/comic.ttf", int(i_width / 11)
-#     )
-#     if ";" in text:
-#         upper_text, lower_text = text.split(";")
-#     else:
-#         upper_text = text
-#         lower_text = ""
-#     draw = ImageDraw.Draw(img)
-#     current_h, pad = 10, 5
-#     if upper_text:
-#         for u_text in textwrap.wrap(upper_text,width=15,subsequent_indent=" "):
-#             u_width, u_height = draw.textsize(u_text, font=m_font)
-#             draw.text(
-#                 xy=(((i_width - u_width) / 2) - 1, int((current_h / 640) * i_width)),
-#                 text=u_text,
-#                 font=m_font,
-#                 fill=(0, 0, 0),
-#             )
-#             draw.text(
-#                 xy=(((i_width - u_width) / 2) + 1, int((current_h / 640) * i_width)),
-#                 text=u_text,
-#                 font=m_font,
-#                 fill=(0, 0, 0),
-#             )
-#             draw.text(
-#                 xy=((i_width - u_width) / 2, int(((current_h / 640) * i_width)) - 1),
-#                 text=u_text,
-#                 font=m_font,
-#                 fill=(0, 0, 0),
-#             )
-#             draw.text(
-#                 xy=(((i_width - u_width) / 2), int(((current_h / 640) * i_width)) + 1),
-#                 text=u_text,
-#                 font=m_font,
-#                 fill=(0, 0, 0),
-#             )
-#             draw.text(
-#                 xy=((i_width - u_width) / 2, int((current_h / 640) * i_width)),
-#                 text=u_text,
-#                 font=m_font,
-#                 fill=(255, 255, 255),
-#             )
-#             current_h += u_height + pad
-#     if lower_text:
-#         for l_text in textwrap.wrap(upper_text,width=15,subsequent_indent=" "):
-#             u_width, u_height = draw.textsize(l_text, font=m_font)
-#             draw.text(
-#                 xy=(
-#                     ((i_width - u_width) / 2) - 1,
-#                     i_height - u_height - int((20 / 640) * i_width),
-#                 ),
-#                 text=l_text,
-#                 font=m_font,
-#                 fill=(0, 0, 0),
-#             )
-#             draw.text(
-#                 xy=(
-#                     ((i_width - u_width) / 2) + 1,
-#                     i_height - u_height - int((20 / 640) * i_width),
-#                 ),
-#                 text=l_text,
-#                 font=m_font,
-#                 fill=(0, 0, 0),
-#             )
-#             draw.text(
-#                 xy=(
-#                     (i_width - u_width) / 2,
-#                     (i_height - u_height - int((20 / 640) * i_width)) - 1,
-#                 ),
-#                 text=l_text,
-#                 font=m_font,
-#                 fill=(0, 0, 0),
-#             )
-#             draw.text(
-#                 xy=(
-#                     (i_width - u_width) / 2,
-#                     (i_height - u_height - int((20 / 640) * i_width)) + 1,
-#                 ),
-#                 text=l_text,
-#                 font=m_font,
-#                 fill=(0, 0, 0),
-#             )
-#             draw.text(
-#                 xy=(
-#                     (i_width - u_width) / 2,
-#                     i_height - u_height - int((20 / 640) * i_width),
-#                 ),
-#                 text=l_text,
-#                 font=m_font,
-#                 fill=(255, 255, 255),
-#             )
-#             current_h += u_height + pad
-
-#     hue = image_path
-#     if stick:
-#         stick_path = image_path
-#     else:
-#         stick_path = await resize_file_to_sticker_size(hue)
-#     mee = tosticker(stick_path,"@memesofdank_memer_hu_vai.webp")
-#     img.save(hue)
-#     img.save(mee)
-#     return hue, mee
+
 
 def toimage(image, filename=None, is_direc=False):
     filename = filename if filename else "gojo.jpg"

Powers/vars.py

@@ -38,7 +38,7 @@ class Config:
         ).split(None)
     ]
     GENIUS_API_TOKEN = config("GENIUS_API",default=None)
-    AuDD_API = config("AuDD_API",default=None)
+    # AuDD_API = config("AuDD_API",default=None)
     RMBG_API = config("RMBG_API",default=None)
     DB_URI = config("DB_URI", default="")
     DB_NAME = config("DB_NAME", default="gojo_satarou")