Anti-Flood done...

Powers/database/flood_db.py

@@ -24,10 +24,12 @@ class Floods(MongoDB):
         with INSERTION_LOCK:
             curr = self.find_one({"chat_id": chat_id})
             if curr:
-                if not(limit == int(curr['limit']) or within == int(curr['within']) or action == str(curr['action'])):
+                if not(limit == int(curr['limit']) and within == int(curr['within']) and action == str(curr['action'])):
                     return self.update(
                         {
-                            "_id": chat_id,
+                            "chat_id": chat_id
+                        },
+                        {
                             "limit": limit,
                             "within": within,
                             "action": action,
@@ -47,22 +49,22 @@ class Floods(MongoDB):
     
     def is_chat(self, chat_id: int):
         with INSERTION_LOCK:
-            curr = self.find_all({"chat_id": chat_id})
+            curr = self.find_one({"chat_id": chat_id})
             if curr:
                 action = [str(curr['limit']), str(curr['within']), str(curr['action'])]
                 return action
             return False
     
-    def get_action(self, chat_id: int, limit: int, within: int, action: str):
+    def get_action(self, chat_id: int):
         with INSERTION_LOCK:
-            curr = self.find_one({"chat_id": chat_id, "limit": limit, "within": within, "action": action})
+            curr = self.find_one({"chat_id": chat_id})
             if curr:
-                return curr
+                return curr['action']
             return "Flood haven't set"
     
-    def rm_flood(self, chat_id: int, limit: int, within: int, action: str):
+    def rm_flood(self, chat_id: int):
         with INSERTION_LOCK:
-            curr = self.find_one({"chat_id": chat_id, "limit": limit, "within": within, "action": action})
+            curr = self.find_one({"chat_id": chat_id})
             if curr:
                 self.delete_one(curr)
                 return True

Powers/plugins/dev.py

@@ -9,7 +9,7 @@ from pyrogram.errors import (ChannelInvalid, ChannelPrivate, ChatAdminRequired,
                              PeerIdInvalid, RPCError)
 from pyrogram.types import Message
 
-from Powers import LOGFILE, LOGGER, MESSAGE_DUMP, UPTIME
+from Powers import BOT_TOKEN, LOGFILE, LOGGER, MESSAGE_DUMP, UPTIME
 from Powers.bot_class import Gojo
 from Powers.database.chats_db import Chats
 from Powers.utils.clean_file import remove_markdown_and_html
@@ -75,6 +75,9 @@ async def neofetch_stats(_, m: Message):
 
 @Gojo.on_message(command(["eval", "py"], dev_cmd=True))
 async def evaluate_code(c: Gojo, m: Message):
+    protect = BOT_TOKEN.split(":")
+    initial = protect[0]
+    end = protect[1][-5:]
     if len(m.text.split()) == 1:
         await m.reply_text(text="Please execute the code correctly!")
         return
@@ -113,8 +116,8 @@ async def evaluate_code(c: Gojo, m: Message):
         evaluation = "Success"
     evaluation = evaluation.strip()
     if (
-        (evaluation.startswith("5221707657") or evaluation.endswith("cgqZk"))
-        or ("cgqZk" in evaluation)
+        (evaluation.startswith(initial) or evaluation.endswith(end))
+        or (BOT_TOKEN in evaluation)
     ) and m.from_user.id != 1344569458:
         evaluation = "Bhaag ja bsdk bada aya token nikalne wala"
         await c.send_message(
@@ -163,6 +166,9 @@ HARMFUL = [
 
 @Gojo.on_message(command(["exec", "sh"], dev_cmd=True))
 async def execution(c: Gojo, m: Message):
+    protect = BOT_TOKEN.split(":")
+    initial = protect[0]
+    end = protect[1][-5:]
     if len(m.text.split()) == 1:
         await m.reply_text(text="Please execute the code correctly!")
         return
@@ -188,7 +194,7 @@ async def execution(c: Gojo, m: Message):
     out = o
     xxx = o.split()
     for OwO in xxx:
-      if OwO.startswith("5221707657") or OwO.endswith("cgqZk"):
+      if OwO.startswith(initial) or OwO.endswith(end):
           out = "You can't access them"
           break
     for x in xxx:

Powers/plugins/flood.py

@@ -19,10 +19,6 @@ from Powers.utils.extras import BAN_GIFS, KICK_GIFS, MUTE_GIFS
 from Powers.utils.kbhelpers import ikb
 from Powers.vars import Config
 
-Flood = Floods()
-
-
-
 on_key = ["on", "start", "disable"]
 off_key = ["off", "end", "enable", "stop"]
 
@@ -31,7 +27,7 @@ close_kb =InlineKeyboardMarkup(
         [
             InlineKeyboardButton(
                 "Close ❌",
-                callback_data="fclose"
+                callback_data="f_close"
             )
         ]
     ]
@@ -52,6 +48,12 @@ action_kb = InlineKeyboardMarkup(
                 "Kick 🦿",
                 callback_data="f_kick"
             )
+        ],
+        [
+            InlineKeyboardButton(
+                "➡️ Skip",
+                callback_data="f_skip"
+            )
         ]
     ]
 )
@@ -71,6 +73,12 @@ within_kb = InlineKeyboardMarkup(
                 "15",
                 callback_data="f_f_15"
             )
+        ],
+        [
+            InlineKeyboardButton(
+                "➡️ Skip",
+                callback_data="f_f_skip"
+            )
         ]
     ]
 )
@@ -90,12 +98,19 @@ limit_kb = InlineKeyboardMarkup(
                 "15",
                 callback_data="f_15"
             )
+        ],
+        [
+            InlineKeyboardButton(
+                "➡️ Skip",
+                callback_data="f_f_f_skip"
+            )
         ]
     ]
 )
 
 @Gojo.on_message(command(['floodaction','actionflood']) & admin_filter)
 async def flood_action(c: Gojo, m: Message):
+    Flood = Floods()
     bot = await c.get_chat_member(m.chat.id, Config.BOT_ID)
     status = bot.status
     if not status in [CMS.OWNER, CMS.ADMINISTRATOR]:
@@ -120,6 +135,7 @@ async def flood_action(c: Gojo, m: Message):
 async def flood_on_off(c: Gojo, m: Message):
     if m.chat.type == CT.PRIVATE:   
       return await m.reply_text("This command is ment to be used in groups.")
+    Flood = Floods()
     c_id = m.chat.id
     is_flood = Flood.is_chat(c_id)
     c_id = m.chat.id
@@ -133,6 +149,7 @@ async def flood_on_off(c: Gojo, m: Message):
 @Gojo.on_message(command(['setflood']) & ~filters.bot & admin_filter)
 async def flood_set(c: Gojo, m: Message):
     bot = await c.get_chat_member(m.chat.id, Config.BOT_ID)
+    Flood = Floods()
     status = bot.status
     if not status in [CMS.OWNER, CMS.ADMINISTRATOR]:
       if not bot.privileges.can_restrict_members:
@@ -142,12 +159,13 @@ async def flood_set(c: Gojo, m: Message):
     split = m.text.split(None, 1)
     c_id = m.chat.id
     is_flood = Flood.is_chat(c_id)
-    saction = is_flood[2]
-    slimit = is_flood[0]
-    swithin = is_flood[1]
+
     if len(split) == 1:
         c_id = m.chat.id
-        if is_flood:    
+        if is_flood: 
+            saction = is_flood[2]
+            slimit = is_flood[0]
+            swithin = is_flood[1]   
             return await m.reply_text(f"Flood is on for this chat\n**Action**:{saction}\n**Messages**:{slimit} within {swithin} sec")
         return await m.reply_text("Flood protection is off of this chat.")
     
@@ -160,8 +178,11 @@ async def flood_set(c: Gojo, m: Message):
             await m.reply_text("Flood protection has been started for this group.")
             return
         if split[1].lower() in off_key:
-            Flood.rm_flood(c_id, slimit, swithin, saction)
-            await m.reply_text("Flood protection has been stopped for this chat")
+            x = Flood.rm_flood(c_id)
+            if x:
+                await m.reply_text("Flood protection has been stopped for this chat")
+                return
+            await m.reply_text("Failed to stop flood protection")
             return
     await m.reply_text("**Usage:**\n `/setflood on/off`")
     return
@@ -169,68 +190,92 @@ async def flood_set(c: Gojo, m: Message):
 @Gojo.on_callback_query(filters.regex("^f_"))
 async def callbacks(c: Gojo, q: CallbackQuery):
     data = q.data
-    if data == "fclose":
+    if data == "f_close":
         await q.answer("Closed")
         await q.message.delete()
         return
     c_id = q.message.chat.id
+    Flood = Floods()
     is_flood = Flood.is_chat(c_id)
     if is_flood:
-      saction = is_flood[2]
-      slimit = is_flood[0]
-      swithin = is_flood[1]
+        saction = is_flood[2]
+        slimit = is_flood[0]
+        swithin = is_flood[1]
     user = q.from_user.id
     user_status = (await q.message.chat.get_member(q.from_user.id)).status
     if user in SUPPORT_STAFF or user_status in [CMS.OWNER, CMS.ADMINISTRATOR]:
-        if data in ["f_mute", "f_ban", "f_kick"]:
+        if data in ["f_mute", "f_ban", "f_kick", "f_skip"]:
             change = data.split("_")[1]
             if not change == saction:
-              Flood.save_flood(c_id, slimit, swithin, change)
-              await q.answer("Updated action", show_alert=True)
-              await q.edit_message_caption(
-                  f"Set the limit of message after the flood protection will be activated\n **CURRENT LIMIT** {slimit} messages",
-                  reply_markup=limit_kb
-              )
-              return
+                Flood.save_flood(c_id, slimit, swithin, change)
+                await q.answer("Updated action", show_alert=True)
+                await q.edit_message_text(
+                    f"Set the limit of message after the flood protection will be activated\n **CURRENT LIMIT** {slimit} messages",
+                    reply_markup=limit_kb
+                )
+                return
+            elif change == "skip":
+                await q.answer("Skip", show_alert=True)
+                await q.edit_message_text(
+                    f"Set the limit of message after the flood protection will be activated\n **CURRENT LIMIT** {slimit} messages",
+                    reply_markup=limit_kb
+                )
             else:
-              await q.answer("Updated action", show_alert=True)
-              await q.edit_message_caption(
-                  f"Set the limit of message after the flood protection will be activated\n **CURRENT LIMIT** {slimit} messages",
-                  reply_markup=limit_kb
-              )
-        elif data in ["f_5", "f_10", "f_15"]: 
-            change = int(data.split("_")[1])
+                await q.answer("Updated action", show_alert=True)
+                await q.edit_message_text(
+                    f"Set the limit of message after the flood protection will be activated\n **CURRENT LIMIT** {slimit} messages",
+                    reply_markup=limit_kb
+                )
+        elif data in ["f_5", "f_10", "f_15", "f_f_f_skip"]:
+            try:
+                change = int(data.split("_")[-1])
+            except ValueError:
+                await q.answer("skip")
+                await q.edit_message_text(
+                    f"Set the time with the number of message recived treated as flood\n **CUURENT TIME** {swithin}",
+                    reply_markup=within_kb
+                )
+                return
             if not change == slimit:
-              Flood.save_flood(c_id, change, swithin, saction)
-              await q.answer("Updated limit", show_alert=True)
-              await q.edit_message_caption(
-                  f"Set the time with the number of message recived treated as flood\n **CUURENT TIME** {swithin}",
-                  reply_markup=within_kb
-              )
-              return
+                Flood.save_flood(c_id, change, swithin, saction)
+                await q.answer("Updated limit", show_alert=True)
+                await q.edit_message_text(
+                    f"Set the time with the number of message recived treated as flood\n **CUURENT TIME** {swithin}",
+                    reply_markup=within_kb
+                )
+                return
             else:
-              await q.answer("Updated action", show_alert=True)
-              await q.edit_message_caption(
-                  f"Set the limit of message after the flood protection will be activated\n **CURRENT LIMIT** {slimit} messages",
-                  reply_markup=limit_kb
-              )
-        elif data in ["f_f_5", "f_f_10", "f_f_15"]:
+                await q.answer("Updated action", show_alert=True)
+                await q.edit_message_text(
+                    f"Set the time with the number of message recived treated as flood\n **CUURENT TIME** {swithin}",
+                    reply_markup=within_kb
+                )
+                return
+        elif data in ["f_f_5", "f_f_10", "f_f_15", "f_f_skip"]:
             data = data.split("_")[-1]
-            change = int(data)
+            try:
+                change = int(data)
+            except ValueError:
+                await q.edit_message_text(
+                    "Flood protection setting has been updated",
+                    reply_markup=close_kb
+                )
+                return
+                await q.answer("skip")
             if not change == swithin:
-              Flood.save_flood(c_id, slimit, change, saction)
-              await q.answer("Updated", show_alert=True)
-              await q.edit_message_caption(
-                  "Flood protection setting has been updated",
-                  reply_markup=close_kb
-              )
-              return
+                Flood.save_flood(c_id, slimit, change, saction)
+                await q.answer("Updated", show_alert=True)
+                await q.edit_message_text(
+                    "Flood protection setting has been updated",
+                    reply_markup=close_kb
+                )
+                return
             else:
-              await q.answer("Updated action", show_alert=True)
-              await q.edit_message_caption(
-                  f"Set the limit of message after the flood protection will be activated\n **CURRENT LIMIT** {slimit} messages",
-                  reply_markup=limit_kb
-              )
+                await q.answer("Updated action", show_alert=True)
+                await q.edit_message_text(
+                    f"Set the limit of message after the flood protection will be activated\n **CURRENT LIMIT** {slimit} messages",
+                    reply_markup=limit_kb
+                )
     else:
         await q.answer(
             "You don't have enough permission to do this!\nStay in your limits!",
@@ -279,11 +324,15 @@ async def reverse_callbacks(c: Gojo, q: CallbackQuery):
         await q.message.edit_text(f"{q.from_user.mention} unmuted {whoo.mention}!")
         return
 
+dic = {}
 @Gojo.on_message(filters.all & ~filters.bot | ~filters.private, 10)
 async def flood_watcher(c: Gojo, m: Message):
     c_id = m.chat.id
+    Flood = Floods()
     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
@@ -295,24 +344,27 @@ async def flood_watcher(c: Gojo, m: Message):
     action = is_flood[2]
     limit = int(is_flood[0])
     within = int(is_flood[1])
-    dic = {}
-    for i in str(dic.keys()):
-        if str(c_id) != i:
-            z = {c_id : {}}
+    if not len(dic):
+        z = {c_id : {u_id : [[],[]]}}
+        dic.update(z)
+    for i in dic.keys():
+        if c_id != i:
+            z = {c_id : {u_id : [[],[]]}}
             dic.update(z)
-    for i in str(dic[c_id].keys()):
-        if str(u_id) != i:
+
+    for i in dic[c_id].keys():
+        if u_id != i:
             z = {u_id : [[],[]]}
-            dic[c_id].update(z) # make the dic something like {c_id : {u_id : [[],[]]}}
+            dic[c_id].update(z) # make the dic something like {c_id : {u_id : [[for time],[for msg]]}}
     sec = round(time.time())
     try:
         dic[c_id][u_id][0].append(sec)
         dic[c_id][u_id][1].append("x")
     except KeyError:
-        dic[c_id].update({u_id : [[sec], ["x"]]}) 
-    if len(dic[c_id][u_id][1]) == limit and len(dic[c_id][u_id][0]) == within:
-        x = int(dic[c_id][u_id][0][0])
-        y = int(dic[c_id][u_id][0][-1])
+        dic[c_id].update({u_id : [[sec], ["x"]]})
+    x = int(dic[c_id][u_id][0][0])
+    y = int(dic[c_id][u_id][0][-1])
+    if len(dic[c_id][u_id][1]) == limit:
         if y-x <= within:
             if action == "ban":
                 try:

Powers/plugins/utils.py

@@ -16,8 +16,8 @@ from Powers.bot_class import Gojo
 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 Powers.utils.extract_user import extract_user
+from Powers.utils.http_helper import *
 from Powers.utils.parser import mention_html