d4rktg 0.5.3__tar.gz → 0.5.5__tar.gz

{d4rktg-0.5.3 → d4rktg-0.5.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: d4rktg
-Version: 0.5.3
+Version: 0.5.5
 Summary: A module for create with easy and fast
 Author: D4rkShell
 Author-email: premiumqtrst@gmail.com

d4rktg-0.5.5/VERSION.txt

@@ -0,0 +1 @@
+0.5.5

{d4rktg-0.5.3 → d4rktg-0.5.5}/d4rk/Handlers/_bot.py

@@ -51,8 +51,6 @@ class BotManager(Client):
         if self._loop:asyncio.run_coroutine_threadsafe(coro_func(), self._loop)
         else:logger.error("Event loop is not set for _safe_async")
 
-    
-
     async def powerup(self,appname):
         if hasattr(self, "db"):
             self.font = self.db.Settings.get(key="font",datatype=str)

{d4rktg-0.5.3 → d4rktg-0.5.5}/d4rk/Models/_commands.py

@@ -30,7 +30,7 @@ def reorder_command_registry():
 def get_commands():
     return command_registry
 
-def command(command: Union[str, list], description: str):
+def command(command: Union[str, list], description: str,Custom_filter=None):
     def decorator(func):
         command_registry.append({
             "command": command,
@@ -38,7 +38,11 @@ def command(command: Union[str, list], description: str):
             "handler": func
         })
         logger.info(f"Registered command: {command} - {description}")
-        @Client.on_message(filters.command(command))
+        if Custom_filter:
+            filter = filters.command(command) & Custom_filter
+        else:
+            filter = filters.command(command)
+        @Client.on_message(filter)
         @wraps(func)
         async def wrapper(client, message):
             return await func(client, message)

{d4rktg-0.5.3 → d4rktg-0.5.5}/d4rk/Utils/__init__.py

@@ -5,4 +5,4 @@ from ._delete import delete
 from ._ractions import Reacts
 from ._fonts import FontMessageMixin , get_font , web_app_data
 from ._movie_parser import parser
-from ._round import round_robin
+from ._round import round_robin , round

d4rktg-0.5.5/d4rk/Utils/_decorators.py

@@ -0,0 +1,72 @@
+import os
+import asyncio
+import functools
+
+from typing import Union
+from pyrogram import Client , filters
+from d4rk.Logs import setup_logger
+from pyrogram.types import Message , CallbackQuery , ChatPrivileges
+
+from ._delete import delete
+from ._ractions import Reacts
+from dotenv import load_dotenv
+load_dotenv()
+
+logger = setup_logger(__name__)
+
+OWNER = int(os.getenv("OWNER", 7859877609))
+
+
+def authorize(
+    sudo=True,
+    admin=False,
+    permission=None,
+    owner_id: int = None
+):
+    async def func(flt, client: Client, message: Union[Message, CallbackQuery]):
+        try:
+            user = message.from_user
+            if not user:
+                logger.warning(f"Unauthorized access attempt from non-user message: {message}")
+                return False
+
+            me = await client.get_me()
+            is_admin = False
+
+            if admin:
+                if message.chat.type.name.lower() in ["group", "supergroup"]:
+                    role = await client.get_chat_member(message.chat.id, user.id)
+                    myrole = await client.get_chat_member(message.chat.id, me.id)
+
+                    role_status = getattr(role.status, "name", role.status).lower()
+                    myrole_status = getattr(myrole.status, "name", myrole.status).lower()
+
+                    if role_status in ["creator", "administrator"] and \
+                       myrole_status in ["creator", "administrator"]:
+
+                        if permission:
+                            privileges = getattr(role, "privileges", None)
+                            myprivileges = getattr(myrole, "privileges", None)
+                            if privileges and myprivileges:
+                                has_permission = getattr(privileges, permission, False)
+                                has_my_permission = getattr(myprivileges, permission, False)
+                                if has_permission and has_my_permission:
+                                    is_admin = True
+                                else:
+                                    return False
+                        else:
+                            is_admin = True
+                else:
+                    return False
+
+            authorized = (
+                (owner_id and user.id == owner_id)
+                or (sudo and user.id in getattr(client, "sudo_users", []))
+                or is_admin
+            )
+            return bool(authorized)
+        except Exception as e:
+            logger.error(f"Error in authorize filter: {e}")
+            return bool(owner_id and user.id == user.id)
+
+    return filters.create(func, name="AuthorizeFilter")

{d4rktg-0.5.3 → d4rktg-0.5.5}/d4rk/Utils/_round.py

@@ -11,6 +11,39 @@ responded_messages = {}
 # Lock per chat to prevent race conditions
 chat_locks = {}
 
+def round():
+    async def func(flt, client: Client, message: Union[Message, CallbackQuery]):
+        chat_id = message.chat.id
+        msg_id = message.id
+
+        if message.chat.type.name.lower() == "private":
+            return True
+
+        if chat_id not in bot_order_per_chat:
+            bot_order_per_chat[chat_id] = [client.me.id]
+            last_index_per_chat[chat_id] = 0
+            responded_messages[chat_id] = set()
+            chat_locks[chat_id] = asyncio.Lock()
+        
+        if client.me.id not in bot_order_per_chat[chat_id]:
+            bot_order_per_chat[chat_id].append(client.me.id)
+        
+        async with chat_locks[chat_id]:
+            # Skip if message already responded
+            if msg_id in responded_messages[chat_id]:
+                return False
+
+            # Decide which bot should respond
+            current_index = last_index_per_chat[chat_id]
+            selected_bot_id = bot_order_per_chat[chat_id][current_index]
+
+            if client.me.id == selected_bot_id:
+                # Mark message as responded
+                responded_messages[chat_id].add(msg_id)
+                # Rotate for next message
+                last_index_per_chat[chat_id] = (current_index + 1) % len(bot_order_per_chat[chat_id])
+                return True
+
 def round_robin():
     def decorator(func):
         @wraps(func)

{d4rktg-0.5.3 → d4rktg-0.5.5}/d4rktg.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: d4rktg
-Version: 0.5.3
+Version: 0.5.5
 Summary: A module for create with easy and fast
 Author: D4rkShell
 Author-email: premiumqtrst@gmail.com

d4rktg-0.5.3/VERSION.txt

@@ -1 +0,0 @@
-0.5.3

d4rktg-0.5.3/d4rk/Utils/_decorators.py

@@ -1,78 +0,0 @@
-import os
-import asyncio
-import functools
-
-from typing import Union
-from pyrogram import Client 
-from d4rk.Logs import setup_logger
-from pyrogram.types import Message , CallbackQuery , ChatPrivileges
-
-from ._delete import delete
-from ._ractions import Reacts
-from dotenv import load_dotenv
-load_dotenv()
-
-logger = setup_logger(__name__)
-
-OWNER = int(os.getenv("OWNER", 7859877609))
-
-def authorize(sudo=True,admin=False,delete_command=True, react=True,react_emoji:Reacts=Reacts.fire,alert=True,permission=None):
-    def decorator(func):
-        @functools.wraps(func)
-        async def wrapper(client: Client, message: Union[Message,CallbackQuery]):
-            try:
-                user = message.from_user
-                if not user:
-                    logger.warning(f"Unauthorized access attempt from non-user message: {message}")
-                me = await client.get_me()
-                is_admin = False
-                if admin:
-                    if message.chat.type.name.lower() in ["group","supergroup"]:
-                        role = await client.get_chat_member(message.chat.id, user.id)
-                        myrole = await client.get_chat_member(message.chat.id, me.id)
-                        if (user_admin:= role.status.name.lower() in ["creator", "administrator","owner"]) and (i_am_admin:=myrole.status.name.lower() in ["creator", "administrator","owner"]):
-                            if permission:
-                                privileges = getattr(role, "privileges", None)
-                                myprivileges = getattr(myrole, "privileges", None)
-                                if privileges and myprivileges:
-                                    has_permission = getattr(privileges, permission, False)
-                                    has_my_permission = getattr(myprivileges, permission, False)
-                                    if has_permission and has_my_permission:
-                                        is_admin = True
-                                    else:
-                                        msg = ""
-                                        if not has_permission and not has_my_permission:msg = f"❌ Neither you nor I "
-                                        elif not has_permission:msg = f"❌ You don't"
-                                        elif not has_my_permission:msg = f"❌ I don't"
-                                        msg += f" have the required permission: `{permission}`."
-                                        return await client.send_alert(message=message,text=msg)
-                            else:is_admin = True
-                    else:
-                        if alert:
-                            return await client.send_alert(message=message,text="❌ This command can only be used in groups.")
-                        
-                authorized = user.id == OWNER or (sudo and user.id in client.sudo_users) or is_admin
-                if react and isinstance(message, Message):
-                    try:await message.react(react_emoji)
-                    except:pass
-                
-                if not authorized:
-                    logger.warning(f"Unauthorized {func.__name__} request from user {user.id} @{user.username}")
-                    if alert:
-                        m = await client.send_alert(message=message,text="❌ Unauthorized access.")
-                        if react and isinstance(message, Message):
-                            await message.react(Reacts.shit)
-                            if m:await delete(client, message.chat.id, m.id, timeout=5)
-                
-                else:
-                    logger.info(f"Authorized user {user.id} executing {func.__name__}")
-                    await func(client, message)
-                if delete_command:
-                    try:await delete(client, message.chat.id, message.id, timeout=5)
-                    except:pass
-            except Exception as e:
-                logger.error(f"Error in {func.__name__}: {e}")
-            return
-        return wrapper
-    return decorator
-