Rubka 6.4.6__tar.gz → 6.4.8__tar.gz

{rubka-6.4.6 → rubka-6.4.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Rubka
-Version: 6.4.6
+Version: 6.4.8
 Summary: A Python library for interacting with Rubika Bot API.
 Home-page: https://github.com/Mahdy-Ahmadi/Rubka
 Download-URL: https://github.com/Mahdy-Ahmadi/rubka/blob/main/project_library.zip

{rubka-6.4.6 → rubka-6.4.8}/Rubka.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Rubka
-Version: 6.4.6
+Version: 6.4.8
 Summary: A Python library for interacting with Rubika Bot API.
 Home-page: https://github.com/Mahdy-Ahmadi/Rubka
 Download-URL: https://github.com/Mahdy-Ahmadi/rubka/blob/main/project_library.zip

{rubka-6.4.6 → rubka-6.4.8}/rubka/api.py

@@ -498,6 +498,168 @@ class Robot:
             })
             return func
         return decorator
+    def on_message_file(self, filters: Optional[Callable[[Message], bool]] = None, commands: Optional[List[str]] = None):
+        def decorator(func: Callable[[Any, Message], None]):
+            def wrapper(bot, message: Message):
+                if not message.file:
+                    return
+                if filters and not filters(message):
+                    return
+                return func(bot, message)
+
+            self._message_handlers.append({
+                "func": wrapper,
+                "filters": filters,
+                "file_only": True,
+                "commands":commands
+            })
+            return wrapper
+        return decorator
+
+    def on_message_forwarded(self, filters: Optional[Callable[[Message], bool]] = None, commands: Optional[List[str]] = None):
+        def decorator(func: Callable[[Any, Message], None]):
+            def wrapper(bot, message: Message):
+                if not message.is_forwarded:
+                    return
+                if filters and not filters(message):
+                    return
+                return func(bot, message)
+
+            self._message_handlers.append({
+                "func": wrapper,
+                "filters": filters,
+                "forwarded_only": True,
+                "commands":commands
+            })
+            return wrapper
+        return decorator
+
+    def on_message_reply(self, filters: Optional[Callable[[Message], bool]] = None, commands: Optional[List[str]] = None):
+        def decorator(func: Callable[[Any, Message], None]):
+            def wrapper(bot, message: Message):
+                if not message.is_reply:
+                    return
+                if filters and not filters(message):
+                    return
+                return func(bot, message)
+
+            self._message_handlers.append({
+                "func": wrapper,
+                "filters": filters,
+                "reply_only": True,
+                "commands":commands
+            })
+            return wrapper
+        return decorator
+
+    def on_message_text(self, filters: Optional[Callable[[Message], bool]] = None, commands: Optional[List[str]] = None):
+        def decorator(func: Callable[[Any, Message], None]):
+            def wrapper(bot, message: Message):
+                if not message.text:
+                    return
+                if filters and not filters(message):
+                    return
+                return func(bot, message)
+
+            self._message_handlers.append({
+                "func": wrapper,
+                "filters": filters,
+                "text_only": True,
+                "commands":commands
+            })
+            return wrapper
+        return decorator
+
+    def on_message_media(self, filters: Optional[Callable[[Message], bool]] = None, commands: Optional[List[str]] = None):
+        def decorator(func: Callable[[Any, Message], None]):
+            def wrapper(bot, message: Message):
+                if not message.is_media:
+                    return
+                if filters and not filters(message):
+                    return
+                return func(bot, message)
+
+            self._message_handlers.append({
+                "func": wrapper,
+                "filters": filters,
+                "media_only": True,
+                "commands":commands
+            })
+            return wrapper
+        return decorator
+
+    def on_message_sticker(self, filters: Optional[Callable[[Message], bool]] = None, commands: Optional[List[str]] = None):
+        def decorator(func: Callable[[Any, Message], None]):
+            def wrapper(bot, message: Message):
+                if not message.sticker:
+                    return
+                if filters and not filters(message):
+                    return
+                return func(bot, message)
+
+            self._message_handlers.append({
+                "func": wrapper,
+                "filters": filters,
+                "sticker_only": True,
+                "commands":commands
+            })
+            return wrapper
+        return decorator
+
+    def on_message_contact(self, filters: Optional[Callable[[Message], bool]] = None, commands: Optional[List[str]] = None):
+        def decorator(func: Callable[[Any, Message], None]):
+            def wrapper(bot, message: Message):
+                if not message.is_contact:
+                    return
+                if filters and not filters(message):
+                    return
+                return func(bot, message)
+
+            self._message_handlers.append({
+                "func": wrapper,
+                "filters": filters,
+                "contact_only": True,
+                "commands":commands
+            })
+            return wrapper
+        return decorator
+
+    def on_message_location(self, filters: Optional[Callable[[Message], bool]] = None, commands: Optional[List[str]] = None):
+        def decorator(func: Callable[[Any, Message], None]):
+            def wrapper(bot, message: Message):
+                if not message.is_location:
+                    return
+                if filters and not filters(message):
+                    return
+                return func(bot, message)
+
+            self._message_handlers.append({
+                "func": wrapper,
+                "filters": filters,
+                "location_only": True,
+                "commands":commands
+            })
+            return wrapper
+        return decorator
+
+    def on_message_poll(self, filters: Optional[Callable[[Message], bool]] = None, commands: Optional[List[str]] = None):
+        def decorator(func: Callable[[Any, Message], None]):
+            def wrapper(bot, message: Message):
+                if not message.is_poll:
+                    return
+                if filters and not filters(message):
+                    return
+                return func(bot, message)
+
+            self._message_handlers.append({
+                "func": wrapper,
+                "filters": filters,
+                "poll_only": True,
+                "commands":commands
+            })
+            return wrapper
+        return decorator
+
     def message_handler(self, filters: Optional[Callable[[Message], bool]] = None, commands: Optional[List[str]] = None):
         def decorator(func: Callable[[Any, Message], None]):
             self._message_handlers.append({

{rubka-6.4.6 → rubka-6.4.8}/rubka/asynco.py

@@ -218,6 +218,9 @@ class Robot:
             raise InvalidTokenError("The provided bot token is invalid or expired.")
     from typing import Callable, Any, Optional, List
 
+
+#decorator#
+
     def on_message_private(
         self,
         chat_id: Optional[Union[str, List[str]]] = None,   
@@ -247,30 +250,20 @@ class Robot:
                 
                 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:
@@ -543,6 +536,142 @@ class Robot:
             })
             return func
         return decorator
+    
+    def on_message_file(self, filters: Optional[Callable[[Message], bool]] = None, commands: Optional[List[str]] = None):
+        def decorator(func: Callable[[Any, Message], None]):
+            async def wrapper(bot, message: Message):
+                if not message.file:return
+                if filters and not filters(message):return
+                return await func(bot, message)
+
+            self._message_handlers.append({
+                "func": wrapper,
+                "filters": filters,
+                "file_only": True,
+                "commands": commands
+            })
+            return wrapper
+        return decorator
+    def on_message_forwarded(self, filters: Optional[Callable[[Message], bool]] = None, commands: Optional[List[str]] = None):
+        def decorator(func: Callable[[Any, Message], None]):
+            async def wrapper(bot, message: Message):
+                if not message.is_forwarded:return
+                if filters and not filters(message):return
+                return await func(bot, message)
+
+            self._message_handlers.append({
+                "func": wrapper,
+                "filters": filters,
+                "forwarded_only": True,
+                "commands": commands
+            })
+            return wrapper
+        return decorator
+    def on_message_reply(self, filters: Optional[Callable[[Message], bool]] = None, commands: Optional[List[str]] = None):
+        def decorator(func: Callable[[Any, Message], None]):
+            async def wrapper(bot, message: Message):
+                if not message.is_reply:return
+                if filters and not filters(message):return
+                return await func(bot, message)
+
+            self._message_handlers.append({
+                "func": wrapper,
+                "filters": filters,
+                "reply_only": True,
+                "commands": commands
+            })
+            return wrapper
+        return decorator
+    def on_message_text(self, filters: Optional[Callable[[Message], bool]] = None, commands: Optional[List[str]] = None):
+        def decorator(func: Callable[[Any, Message], None]):
+            async def wrapper(bot, message: Message):
+                if not message.text:return
+                if filters and not filters(message):return
+                return await func(bot, message)
+
+            self._message_handlers.append({
+                "func": wrapper,
+                "filters": filters,
+                "text_only": True,
+                "commands": commands
+            })
+            return wrapper
+        return decorator
+    def on_message_media(self, filters: Optional[Callable[[Message], bool]] = None, commands: Optional[List[str]] = None):
+        def decorator(func: Callable[[Any, Message], None]):
+            async def wrapper(bot, message: Message):
+                if not message.is_media:return
+                if filters and not filters(message):return
+                return await func(bot, message)
+
+            self._message_handlers.append({
+                "func": wrapper,
+                "filters": filters,
+                "media_only": True,
+                "commands": commands
+            })
+            return wrapper
+        return decorator
+    def on_message_sticker(self, filters: Optional[Callable[[Message], bool]] = None, commands: Optional[List[str]] = None):
+        def decorator(func: Callable[[Any, Message], None]):
+            async def wrapper(bot, message: Message):
+                if not message.sticker:return
+                if filters and not filters(message):return
+                return await func(bot, message)
+
+            self._message_handlers.append({
+                "func": wrapper,
+                "filters": filters,
+                "sticker_only": True,
+                "commands": commands
+            })
+            return wrapper
+        return decorator
+    def on_message_contact(self, filters: Optional[Callable[[Message], bool]] = None, commands: Optional[List[str]] = None):
+        def decorator(func: Callable[[Any, Message], None]):
+            async def wrapper(bot, message: Message):
+                if not message.is_contact:return
+                if filters and not filters(message):return
+                return await func(bot, message)
+
+            self._message_handlers.append({
+                "func": wrapper,
+                "filters": filters,
+                "contact_only": True,
+                "commands": commands
+            })
+            return wrapper
+        return decorator
+    def on_message_location(self, filters: Optional[Callable[[Message], bool]] = None, commands: Optional[List[str]] = None):
+        def decorator(func: Callable[[Any, Message], None]):
+            async def wrapper(bot, message: Message):
+                if not message.is_location:return
+                if filters and not filters(message):return
+                return await func(bot, message)
+
+            self._message_handlers.append({
+                "func": wrapper,
+                "filters": filters,
+                "location_only": True,
+                "commands": commands
+            })
+            return wrapper
+        return decorator
+    def on_message_poll(self, filters: Optional[Callable[[Message], bool]] = None, commands: Optional[List[str]] = None):
+        def decorator(func: Callable[[Any, Message], None]):
+            async def wrapper(bot, message: Message):
+                if not message.is_poll:return
+                if filters and not filters(message):return
+                return await func(bot, message)
+
+            self._message_handlers.append({
+                "func": wrapper,
+                "filters": filters,
+                "poll_only": True,
+                "commands": commands
+            })
+            return wrapper
+        return decorator
     def on_update(self, filters: Optional[Callable[[Message], bool]] = None, commands: Optional[List[str]] = None):
         def decorator(func: Callable[[Any, Message], None]):
             self._message_handlers.append({
@@ -1516,7 +1645,6 @@ class Robot:
                 json_data = await response.json()
                 if is_temp_file:
                     os.remove(path)
-                print(json_data)
                 return json_data.get('data', {}).get('file_id')
         except :
             raise FeatureNotAvailableError(f"files is not currently supported by the server.")
@@ -1642,7 +1770,7 @@ class Robot:
             "inline_keypad":inline_keypad,
             "chat_keypad_type":chat_keypad_type
         }
-        return json.dumps(result, ensure_ascii=False, indent=4)
+        return result
 
     async def _send_file_generic(self, media_type, chat_id, path, file_id, text, file_name, inline_keypad, chat_keypad, reply_to_message_id, disable_notification, chat_keypad_type):
         if path:
@@ -1702,13 +1830,19 @@ class Robot:
         try:
             chat = await self.get_chat(chat_id)
             chat_info = chat.get("data", {}).get("chat", {})
-            first_name = chat_info.get("first_name", "")
-            last_name = chat_info.get("last_name", "")
-            
-            full_name = f"{first_name} {last_name}".strip()
-            return full_name if full_name else "Unknown"
-        except Exception:
-            return "Unknown"
+            chat_type = chat_info.get("chat_type", "").lower()
+            if chat_type == "user":
+                first_name = chat_info.get("first_name", "")
+                last_name = chat_info.get("last_name", "")
+                full_name = f"{first_name} {last_name}".strip()
+                return full_name if full_name else "null"
+            elif chat_type in ["group", "channel"]:
+                title = chat_info.get("title", "")
+                return title if title else "null"
+            else:return "null"
+        except Exception:return "null"
+
+    
 
     async def get_username(self, chat_id: str) -> str:
         chat_info = await self.get_chat(chat_id)

{rubka-6.4.6 → rubka-6.4.8}/rubka/context.py

@@ -190,8 +190,10 @@ from pathlib import Path
 class Message:
     def __init__(self, bot, chat_id, message_id, sender_id, text=None, raw_data=None):
         self.bot = bot
-        self.chat_id = chat_id
         self.raw_data = raw_data or {}
+        self.chat_id = chat_id
+        self.object_guid = chat_id
+        self.author_guid  = self.raw_data.get("sender_id", sender_id)
         self.message_id: str = self.raw_data.get("message_id", message_id)
         self.text: str = self.raw_data.get("text", text)
         self.sender_id: str = self.raw_data.get("sender_id", sender_id)
@@ -199,6 +201,7 @@ 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_command = bool(self.text and self.text.startswith("/"))
         self.is_user = self.chat_id.startswith("b")
         self.is_private = self.chat_id.startswith("b")
         self.is_group = self.chat_id.startswith("g")
@@ -212,7 +215,18 @@ class Message:
         self.location = Location(self.raw_data["location"]) if "location" in self.raw_data else None
         self.live_location = LiveLocation(self.raw_data["live_location"]) if "live_location" in self.raw_data else None
         self.aux_data = AuxData(self.raw_data["aux_data"]) if "aux_data" in self.raw_data else None
-
+        self.is_reply = self.reply_to_message_id is not None
+        self.has_media = any([self.file, self.sticker, self.poll, self.location, self.live_location])
+        self.is_forwarded = self.forwarded_from is not None
+        self.is_text = bool(self.text and not self.has_media)
+        self.is_media = self.has_media
+        self.is_poll = self.poll is not None
+        self.is_location = self.location is not None
+        self.is_live_location = self.live_location is not None
+        self.is_contact = self.contact_message is not None
+        self.has_any_media = any([self.file, self.sticker, self.poll, self.location, self.live_location])
+        self.edited_text = self.raw_data.get("edited_text") if self.is_edited else None
+        self.info = {attr: value for attr, value in vars(self).items()}
     @property
     def session(self):
         if self.chat_id not in self.bot.sessions:

{rubka-6.4.6 → rubka-6.4.8}/rubka/update.py

@@ -190,8 +190,10 @@ from pathlib import Path
 class Message:
     def __init__(self, bot, chat_id, message_id, sender_id, text=None, raw_data=None):
         self.bot = bot
-        self.chat_id = chat_id
         self.raw_data = raw_data or {}
+        self.chat_id = chat_id
+        self.object_guid = chat_id
+        self.author_guid  = self.raw_data.get("sender_id", sender_id)
         self.message_id: str = self.raw_data.get("message_id", message_id)
         self.text: str = self.raw_data.get("text", text)
         self.sender_id: str = self.raw_data.get("sender_id", sender_id)
@@ -199,6 +201,7 @@ 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_command = bool(self.text and self.text.startswith("/"))
         self.is_user = self.chat_id.startswith("b")
         self.is_private = self.chat_id.startswith("b")
         self.is_group = self.chat_id.startswith("g")
@@ -212,7 +215,18 @@ class Message:
         self.location = Location(self.raw_data["location"]) if "location" in self.raw_data else None
         self.live_location = LiveLocation(self.raw_data["live_location"]) if "live_location" in self.raw_data else None
         self.aux_data = AuxData(self.raw_data["aux_data"]) if "aux_data" in self.raw_data else None
-
+        self.is_reply = self.reply_to_message_id is not None
+        self.has_media = any([self.file, self.sticker, self.poll, self.location, self.live_location])
+        self.is_forwarded = self.forwarded_from is not None
+        self.is_text = bool(self.text and not self.has_media)
+        self.is_media = self.has_media
+        self.is_poll = self.poll is not None
+        self.is_location = self.location is not None
+        self.is_live_location = self.live_location is not None
+        self.is_contact = self.contact_message is not None
+        self.has_any_media = any([self.file, self.sticker, self.poll, self.location, self.live_location])
+        self.edited_text = self.raw_data.get("edited_text") if self.is_edited else None
+        self.info = {attr: value for attr, value in vars(self).items()}
     @property
     def session(self):
         if self.chat_id not in self.bot.sessions:

{rubka-6.4.6 → rubka-6.4.8}/setup.py

@@ -8,7 +8,7 @@ except FileNotFoundError:
 
 setup(
     name='Rubka',
-    version='6.4.6',
+    version='6.4.8',
     description='A Python library for interacting with Rubika Bot API.',
     long_description=long_description,
     long_description_content_type='text/markdown',