Rubka 5.2.0__py3-none-any.whl → 6.4.4__py3-none-any.whl

rubka/asynco.py

@@ -190,6 +190,324 @@ class Robot:
         """Check if the bot token is valid."""
         if (await self.get_me())['status'] != "OK":
             raise InvalidTokenError("The provided bot token is invalid or expired.")
+    from typing import Callable, Any, Optional, List
+
+    def on_message_private(
+        self,
+        chat_id: Optional[Union[str, List[str]]] = None,   
+        commands: Optional[List[str]] = None,              
+        filters: Optional[Callable[[Message], bool]] = None, 
+        sender_id: Optional[Union[str, List[str]]] = None, 
+        sender_type: Optional[str] = None,                 
+        allow_forwarded: bool = True,                      
+        allow_files: bool = True,                          
+        allow_stickers: bool = True,                       
+        allow_polls: bool = True,                          
+        allow_contacts: bool = True,                       
+        allow_locations: bool = True,                      
+        min_text_length: Optional[int] = None,             
+        max_text_length: Optional[int] = None,             
+        contains: Optional[str] = None,                    
+        startswith: Optional[str] = None,                  
+        endswith: Optional[str] = None,                    
+        case_sensitive: bool = False                       
+    ):
+        """
+        Advanced decorator for handling only private messages with extended filters.
+        """
+
+        def decorator(func: Callable[[Any, Message], None]):
+            async def wrapper(bot, message: Message):
+                
+                if not message.is_private:
+                    return
+
+                
+                if chat_id:
+                    if isinstance(chat_id, str) and message.chat_id != chat_id:
+                        return
+                    if isinstance(chat_id, list) and message.chat_id not in chat_id:
+                        return
+
+                
+                if sender_id:
+                    if isinstance(sender_id, str) and message.sender_id != sender_id:
+                        return
+                    if isinstance(sender_id, list) and message.sender_id not in sender_id:
+                        return
+
+                
+                if sender_type and message.sender_type != sender_type:
+                    return
+
+                
+                if not allow_forwarded and message.forwarded_from:
+                    return
+
+                
+                if not allow_files and message.file:
+                    return
+                if not allow_stickers and message.sticker:
+                    return
+                if not allow_polls and message.poll:
+                    return
+                if not allow_contacts and message.contact_message:
+                    return
+                if not allow_locations and (message.location or message.live_location):
+                    return
+
+                
+                if message.text:
+                    text = message.text if case_sensitive else message.text.lower()
+                    if min_text_length and len(message.text) < min_text_length:
+                        return
+                    if max_text_length and len(message.text) > max_text_length:
+                        return
+                    if contains and (contains if case_sensitive else contains.lower()) not in text:
+                        return
+                    if startswith and not text.startswith(startswith if case_sensitive else startswith.lower()):
+                        return
+                    if endswith and not text.endswith(endswith if case_sensitive else endswith.lower()):
+                        return
+
+                
+                if commands:
+                    if not message.text:
+                        return
+                    parts = message.text.strip().split()
+                    cmd = parts[0].lstrip("/")
+                    if cmd not in commands:
+                        return
+                    message.args = parts[1:]  
+
+                
+                if filters and not filters(message):
+                    return
+
+                return await func(bot, message)
+
+            self._message_handlers.append({
+                "func": wrapper,
+                "filters": filters,
+                "commands": commands,
+                "chat_id": chat_id,
+                "private_only": True,
+                "sender_id": sender_id,
+                "sender_type": sender_type
+            })
+            return wrapper
+        return decorator
+    def on_message_channel(
+        self,
+        chat_id: Optional[Union[str, List[str]]] = None,   
+        commands: Optional[List[str]] = None,              
+        filters: Optional[Callable[[Message], bool]] = None, 
+        sender_id: Optional[Union[str, List[str]]] = None, 
+        sender_type: Optional[str] = None,                 
+        allow_forwarded: bool = True,                      
+        allow_files: bool = True,                          
+        allow_stickers: bool = True,                       
+        allow_polls: bool = True,                          
+        allow_contacts: bool = True,                       
+        allow_locations: bool = True,                      
+        min_text_length: Optional[int] = None,             
+        max_text_length: Optional[int] = None,             
+        contains: Optional[str] = None,                    
+        startswith: Optional[str] = None,                  
+        endswith: Optional[str] = None,                    
+        case_sensitive: bool = False                       
+    ):
+        """
+        Advanced decorator for handling only channel messages with extended filters.
+        """
+
+        def decorator(func: Callable[[Any, Message], None]):
+            async def wrapper(bot, message: Message):
+                
+                if not message.is_channel:
+                    return
+
+                
+                if chat_id:
+                    if isinstance(chat_id, str) and message.chat_id != chat_id:
+                        return
+                    if isinstance(chat_id, list) and message.chat_id not in chat_id:
+                        return
+
+                
+                if sender_id:
+                    if isinstance(sender_id, str) and message.sender_id != sender_id:
+                        return
+                    if isinstance(sender_id, list) and message.sender_id not in sender_id:
+                        return
+
+                
+                if sender_type and message.sender_type != sender_type:
+                    return
+
+                
+                if not allow_forwarded and message.forwarded_from:
+                    return
+
+                
+                if not allow_files and message.file:
+                    return
+                if not allow_stickers and message.sticker:
+                    return
+                if not allow_polls and message.poll:
+                    return
+                if not allow_contacts and message.contact_message:
+                    return
+                if not allow_locations and (message.location or message.live_location):
+                    return
+
+                
+                if message.text:
+                    text = message.text if case_sensitive else message.text.lower()
+                    if min_text_length and len(message.text) < min_text_length:
+                        return
+                    if max_text_length and len(message.text) > max_text_length:
+                        return
+                    if contains and (contains if case_sensitive else contains.lower()) not in text:
+                        return
+                    if startswith and not text.startswith(startswith if case_sensitive else startswith.lower()):
+                        return
+                    if endswith and not text.endswith(endswith if case_sensitive else endswith.lower()):
+                        return
+
+                
+                if commands:
+                    if not message.text:
+                        return
+                    parts = message.text.strip().split()
+                    cmd = parts[0].lstrip("/")
+                    if cmd not in commands:
+                        return
+                    message.args = parts[1:]  
+
+                
+                if filters and not filters(message):
+                    return
+
+                return await func(bot, message)
+
+            self._message_handlers.append({
+                "func": wrapper,
+                "filters": filters,
+                "commands": commands,
+                "chat_id": chat_id,
+                "group_only": True,
+                "sender_id": sender_id,
+                "sender_type": sender_type
+            })
+            return wrapper
+        return decorator
+    def on_message_group(
+        self,
+        chat_id: Optional[Union[str, List[str]]] = None,   
+        commands: Optional[List[str]] = None,
+        filters: Optional[Callable[[Message], bool]] = None, 
+        sender_id: Optional[Union[str, List[str]]] = None, 
+        sender_type: Optional[str] = None,                 
+        allow_forwarded: bool = True,                      
+        allow_files: bool = True,                          
+        allow_stickers: bool = True,                       
+        allow_polls: bool = True,                          
+        allow_contacts: bool = True,                       
+        allow_locations: bool = True,                      
+        min_text_length: Optional[int] = None,             
+        max_text_length: Optional[int] = None,             
+        contains: Optional[str] = None,                    
+        startswith: Optional[str] = None,                  
+        endswith: Optional[str] = None,                    
+        case_sensitive: bool = False                       
+    ):
+        """
+        Advanced decorator for handling only group messages with extended filters.
+        """
+
+        def decorator(func: Callable[[Any, Message], None]):
+            async def wrapper(bot, message: Message):
+                
+                if not message.is_group:
+                    return
+
+                
+                if chat_id:
+                    if isinstance(chat_id, str) and message.chat_id != chat_id:
+                        return
+                    if isinstance(chat_id, list) and message.chat_id not in chat_id:
+                        return
+
+                
+                if sender_id:
+                    if isinstance(sender_id, str) and message.sender_id != sender_id:
+                        return
+                    if isinstance(sender_id, list) and message.sender_id not in sender_id:
+                        return
+
+                
+                if sender_type and message.sender_type != sender_type:
+                    return
+
+                
+                if not allow_forwarded and message.forwarded_from:
+                    return
+
+                
+                if not allow_files and message.file:
+                    return
+                if not allow_stickers and message.sticker:
+                    return
+                if not allow_polls and message.poll:
+                    return
+                if not allow_contacts and message.contact_message:
+                    return
+                if not allow_locations and (message.location or message.live_location):
+                    return
+
+                
+                if message.text:
+                    text = message.text if case_sensitive else message.text.lower()
+                    if min_text_length and len(message.text) < min_text_length:
+                        return
+                    if max_text_length and len(message.text) > max_text_length:
+                        return
+                    if contains and (contains if case_sensitive else contains.lower()) not in text:
+                        return
+                    if startswith and not text.startswith(startswith if case_sensitive else startswith.lower()):
+                        return
+                    if endswith and not text.endswith(endswith if case_sensitive else endswith.lower()):
+                        return
+
+                
+                if commands:
+                    if not message.text:
+                        return
+                    parts = message.text.strip().split()
+                    cmd = parts[0].lstrip("/")
+                    if cmd not in commands:
+                        return
+                    message.args = parts[1:]  
+
+                
+                if filters and not filters(message):
+                    return
+
+                return await func(bot, message)
+
+            self._message_handlers.append({
+                "func": wrapper,
+                "filters": filters,
+                "commands": commands,
+                "chat_id": chat_id,
+                "group_only": True,
+                "sender_id": sender_id,
+                "sender_type": sender_type
+            })
+            return wrapper
+        return decorator
+
     def on_message(self, filters: Optional[Callable[[Message], bool]] = None, commands: Optional[List[str]] = None):
         def decorator(func: Callable[[Any, Message], None]):
             self._message_handlers.append({
@@ -219,6 +537,16 @@ class Robot:
             })
             return func
         return decorator
+    def on_callback_query(self, button_id: Optional[str] = None):
+        def decorator(func: Callable[[Any, Union[Message, InlineMessage]], None]):
+            if not hasattr(self, "_callback_handlers"):
+                self._callback_handlers = []
+            self._callback_handlers.append({
+                "func": func,
+                "button_id": button_id
+            })
+            return func
+        return decorator
     def callback_query_handler(self, button_id: Optional[str] = None):
         def decorator(func: Callable[[Any, Message], None]):
             if not hasattr(self, "_callback_handlers"):
@@ -349,12 +677,12 @@ class Robot:
                     
                     if not handler_info["commands"] and not handler_info["filters"]:
                         asyncio.create_task(handler_info["func"](self, context))
-                        return 
+                        continue 
                     
                     
                     if handler_info["commands"] or handler_info["filters"]:
-                        asyncio.create_task(handler_info["func"](self, context))
-                        return 
+                        asyncio.create_task(handler_info["func"](self, context))#jaq
+                        continue 
 
     async def get_updates(self, offset_id: Optional[str] = None, limit: Optional[int] = None) -> Dict[str, Any]:
         data = {}
@@ -1014,49 +1342,90 @@ class Robot:
                 return user_id in member_guids
         return False
     async def send_button_join(
-        self, 
-        chat_id, 
-        title_button,
-        username, 
-        text,
-        reply_to_message_id=None, 
-        id="None"):
+    self, 
+    chat_id, 
+    title_button : Union[str, list],
+    username :  Union[str, list], 
+    text,
+    reply_to_message_id=None, 
+    id="None"):
         from .button import InlineBuilder
-        return await self.send_message(
-            chat_id=chat_id,
-            text=text,
-            inline_keypad=InlineBuilder()
-            .row(
-                InlineBuilder()
-                .button_join_channel(
+        builder = InlineBuilder()
+
+        if isinstance(username, (list, tuple)) and isinstance(title_button, (list, tuple)):
+            for t, u in zip(title_button, username):
+                builder = builder.row(
+                    InlineBuilder().button_join_channel(
+                        text=t,
+                        id=id,
+                        username=u
+                    )
+                ) 
+        elif isinstance(username, (list, tuple)) and isinstance(title_button, str):
+            for u in username:
+                builder = builder.row(
+                    InlineBuilder().button_join_channel(
+                        text=title_button,  
+                        id=id,
+                        username=u
+                    )
+                )
+        else:
+            builder = builder.row(
+                InlineBuilder().button_join_channel(
                     text=title_button,
                     id=id,
                     username=username
                 )
-            ).build(),
+            )
+        return await self.send_message(
+            chat_id=chat_id,
+            text=text,
+            inline_keypad=builder.build(),
             reply_to_message_id=reply_to_message_id
         )
     async def send_button_link(
-        self, 
-        chat_id, 
-        title_button,
-        url, 
-        text,
-        reply_to_message_id=None, 
-        id="None"):
+    self, 
+    chat_id, 
+    title_button: Union[str, list],
+    url: Union[str, list], 
+    text,
+    reply_to_message_id=None, 
+    id="None"
+    ):
         from .button import InlineBuilder
-        return await self.send_message(
-            chat_id=chat_id,
-            text=text,
-            inline_keypad=InlineBuilder()
-            .row(
-                InlineBuilder()
-                .button_url_link(
+        builder = InlineBuilder()
+        if isinstance(url, (list, tuple)) and isinstance(title_button, (list, tuple)):
+            for t, u in zip(title_button, url):
+                builder = builder.row(
+                    InlineBuilder().button_url_link(
+                        text=t,
+                        id=id,
+                        url=u
+                    )
+                )
+        elif isinstance(url, (list, tuple)) and isinstance(title_button, str):
+            for u in url:
+                builder = builder.row(
+                    InlineBuilder().button_url_link(
+                        text=title_button,
+                        id=id,
+                        url=u
+                    )
+                )
+        else:
+            builder = builder.row(
+                InlineBuilder().button_url_link(
                     text=title_button,
                     id=id,
                     url=url
                 )
-            ).build(),
+            )
+
+        return await self.send_message(
+            chat_id=chat_id,
+            text=text,
+            inline_keypad=builder.build(),
             reply_to_message_id=reply_to_message_id
         )
 

rubka/button.py

@@ -370,4 +370,35 @@ class InlineBuilder:
         }
 
     def build(self) -> Dict:
-        return {"rows": self.rows}
+        return {"rows": self.rows}
+class ChatKeypadBuilder:
+    def __init__(self):
+        self.rows: List[Dict[str, List[Dict[str, str]]]] = []
+
+    def row(self, *buttons: Dict[str, str]) -> "ChatKeypadBuilder":
+        """
+        یک ردیف دکمه به کی‌پد اضافه می‌کند.
+        ورودی: چند دیکشنری که نماینده دکمه‌ها هستند.
+        """
+        self.rows.append({"buttons": list(buttons)})
+        return self
+
+    def button(self, id: str, text: str, type: str = "Simple") -> Dict[str, str]:
+        """
+        دیکشنری یک دکمه می‌سازد.
+        """
+        return {"id": id, "type": type, "button_text": text}
+
+    def build(
+        self,
+        resize_keyboard: bool = True,
+        on_time_keyboard: bool = False
+    ) -> Dict[str, object]:
+        """
+        ساختار نهایی chat_keypad را می‌سازد.
+        """
+        return {
+            "rows": self.rows,
+            "resize_keyboard": resize_keyboard,
+            "on_time_keyboard": on_time_keyboard
+        }

rubka/context.py

@@ -199,6 +199,10 @@ class Message:
         self.is_edited: bool = self.raw_data.get("is_edited", False)
         self.sender_type: str = self.raw_data.get("sender_type")
         self.args = []
+        self.is_user = self.chat_id.startswith("b")
+        self.is_private = self.chat_id.startswith("b")
+        self.is_group = self.chat_id.startswith("g")
+        self.is_channel = self.chat_id.startswith("c")
         self.reply_to_message_id: Optional[str] = self.raw_data.get("reply_to_message_id")
         self.forwarded_from = ForwardedFrom(self.raw_data["forwarded_from"]) if "forwarded_from" in self.raw_data else None
         self.file = File(self.raw_data["file"]) if "file" in self.raw_data else None