Rubka 6.4.6__tar.gz → 6.5.2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Rubka
-Version: 6.4.6
+Version: 6.5.2
 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.5.2}/Rubka.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Rubka
-Version: 6.4.6
+Version: 6.5.2
 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.5.2}/Rubka.egg-info/SOURCES.txt

@@ -13,6 +13,7 @@ rubka/config.py
 rubka/context.py
 rubka/decorators.py
 rubka/exceptions.py
+rubka/filters.py
 rubka/jobs.py
 rubka/keyboards.py
 rubka/keypad.py

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

@@ -3,6 +3,7 @@ from typing import List, Optional, Dict, Any, Literal
 from .exceptions import APIRequestError
 from .adaptorrubka import Client as Client_get
 from .logger import logger
+from . import filters
 from typing import Callable
 from .context import Message,InlineMessage
 from typing import Optional, Union, Literal, Dict, Any
@@ -489,15 +490,191 @@ class Robot:
 
         return decorator
 
-    def on_message(self, filters: Optional[Callable[[Message], bool]] = None, commands: Optional[List[str]] = None):
+    def on_message(
+        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 filters and not filters(message):
+                    return
+                if commands:
+                    if not getattr(message, "is_command", False):
+                        return
+                    cmd = message.text.split()[0].lstrip("/") if message.text else ""
+                    if cmd not in commands:
+                        return
+                return func(bot, message)
             self._message_handlers.append({
-                "func": func,
+                "func": wrapper,
                 "filters": filters,
                 "commands": commands
             })
-            return func
+            return wrapper
+        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.5.2}/rubka/asynco.py

@@ -5,6 +5,7 @@ from typing import List, Optional, Dict, Any, Literal, Callable, Union
 from .exceptions import APIRequestError
 from .adaptorrubka import Client as Client_get
 from .logger import logger
+from . import filters
 try:
     from .context import Message, InlineMessage
 except (ImportError, ModuleNotFoundError):
@@ -218,6 +219,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 +251,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:
@@ -534,14 +528,162 @@ class Robot:
             return wrapper
         return decorator
 
-    def on_message(self, filters: Optional[Callable[[Message], bool]] = None, commands: Optional[List[str]] = None):
+    def on_message(
+    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 filters and not filters(message):return
+                if commands:
+                    if not message.is_command:return
+                    cmd = message.text.split()[0].lstrip("/")
+                    if cmd not in commands:return
+                return await func(bot, message)
             self._message_handlers.append({
-                "func": func,
+                "func": wrapper,
                 "filters": filters,
                 "commands": commands
             })
-            return func
+            return wrapper
+        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]):
@@ -1516,7 +1658,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 +1783,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 +1843,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.5.2}/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.5.2/rubka/filters.py

@@ -0,0 +1,317 @@
+from typing import Callable
+import re
+
+class Filter:
+    def __init__(self, func: Callable):
+        self.func = func
+
+    def __call__(self, message):
+        return self.func(message)
+
+    def __and__(self, other):
+        return Filter(lambda m: self(m) and other(m))
+
+    def __or__(self, other):
+        return Filter(lambda m: self(m) or other(m))
+
+    def __invert__(self):
+        return Filter(lambda m: not self(m))
+
+    def __xor__(self, other):
+        return Filter(lambda m: self(m) != other(m))
+
+    def __eq__(self, other):
+        return Filter(lambda m: self(m) == other)
+
+    def __ne__(self, other):
+        return Filter(lambda m: self(m) != other)
+
+    def __lt__(self, other):
+        return Filter(lambda m: self(m) < other)
+
+    def __le__(self, other):
+        return Filter(lambda m: self(m) <= other)
+
+    def __gt__(self, other):
+        return Filter(lambda m: self(m) > other)
+
+    def __ge__(self, other):
+        return Filter(lambda m: self(m) >= other)
+
+    def __add__(self, other):
+        return Filter(lambda m: self(m) + (other(m) if callable(other) else other))
+
+    def __sub__(self, other):
+        return Filter(lambda m: self(m) - (other(m) if callable(other) else other))
+
+    def __mul__(self, other):
+        return Filter(lambda m: self(m) * (other(m) if callable(other) else other))
+
+    def __truediv__(self, other):
+        return Filter(lambda m: self(m) / (other(m) if callable(other) else other))
+
+is_text = Filter(lambda m: getattr(m, "is_text", False))
+is_file = Filter(lambda m: getattr(m, "file", None) is not None)
+is_sticker = Filter(lambda m: getattr(m, "sticker", None) is not None)
+is_contact = Filter(lambda m: getattr(m, "contact_message", None) is not None)
+is_poll = Filter(lambda m: getattr(m, "poll", None) is not None)
+is_location = Filter(lambda m: getattr(m, "location", None) is not None)
+is_live_location = Filter(lambda m: getattr(m, "live_location", None) is not None)
+has_any_media = Filter(lambda m: getattr(m, "has_any_media", False))
+has_media = Filter(lambda m: getattr(m, "has_media", False))
+is_command = Filter(lambda m: getattr(m, "is_command", False))
+is_user = Filter(lambda m: getattr(m, "is_user", False))
+is_private = Filter(lambda m: getattr(m, "is_private", False))
+is_group = Filter(lambda m: getattr(m, "is_group", False))
+is_channel = Filter(lambda m: getattr(m, "is_channel", False))
+is_reply = Filter(lambda m: getattr(m, "is_reply", False))
+is_forwarded = Filter(lambda m: getattr(m, "is_forwarded", False))
+is_edited = Filter(lambda m: getattr(m, "is_edited", False))
+
+
+
+
+def text(keyword: str):
+    return Filter(lambda m: getattr(m, "text", "") and keyword in m.text)
+
+def text_length(min_len: int = 0, max_len: int = None):
+    def _filter(m):
+        t = getattr(m, "text", "")
+        if not t: return False
+        if len(t) < min_len: return False
+        if max_len is not None and len(t) > max_len: return False
+        return True
+    return Filter(_filter)
+
+def text_regex(pattern: str):
+    regex = re.compile(pattern)
+    return Filter(lambda m: getattr(m, "text", "") and regex.search(m.text))
+
+def text_startswith(prefix: str):
+    return Filter(lambda m: getattr(m, "text", "").startswith(prefix) if getattr(m, "text", None) else False)
+
+def text_endswith(suffix: str):
+    return Filter(lambda m: getattr(m, "text", "").endswith(suffix) if getattr(m, "text", None) else False)
+
+def text_upper():
+    return Filter(lambda m: getattr(m, "text", "").isupper() if getattr(m, "text", None) else False)
+
+def text_lower():
+    return Filter(lambda m: getattr(m, "text", "").islower() if getattr(m, "text", None) else False)
+
+def text_digit():
+    return Filter(lambda m: getattr(m, "text", "").isdigit() if getattr(m, "text", None) else False)
+
+def text_word_count(min_words: int = 1, max_words: int = None):
+    def _filter(m):
+        t = getattr(m, "text", "")
+        if not t: return False
+        wc = len(t.split())
+        if wc < min_words: return False
+        if max_words is not None and wc > max_words: return False
+        return True
+    return Filter(_filter)
+
+def text_contains_any(keywords: list):
+    return Filter(lambda m: getattr(m, "text", "") and any(k in m.text for k in keywords))
+
+def text_equals(value: str):
+    return Filter(lambda m: getattr(m, "text", None) == value)
+
+def text_not_equals(value: str):
+    return Filter(lambda m: getattr(m, "text", None) != value)
+
+
+
+
+def file_size_gt(size: int):
+    return Filter(lambda m: m.file and getattr(m.file, "size", 0) > size)
+
+def file_size_lt(size: int):
+    return Filter(lambda m: m.file and getattr(m.file, "size", 0) < size)
+
+def file_name_contains(substring: str):
+    return Filter(lambda m: m.file and substring in getattr(m.file, "file_name", ""))
+
+def file_extension(ext: str):
+    return Filter(lambda m: m.file and getattr(m.file, "file_name", "").endswith(ext))
+
+def file_id_is(file_id: str):
+    return Filter(lambda m: m.file and getattr(m.file, "file_id", None) == file_id)
+
+
+
+
+def sticker_id_is(sid: str):
+    return Filter(lambda m: m.sticker and getattr(m.sticker, "sticker_id", None) == sid)
+
+def sticker_emoji_is(emoji: str):
+    return Filter(lambda m: m.sticker and getattr(m.sticker, "emoji", None) == emoji)
+
+
+
+
+def poll_question_contains(keyword: str):
+    return Filter(lambda m: m.poll and keyword in getattr(m.poll, "question", ""))
+
+def poll_option_count(min_options: int = 1, max_options: int = None):
+    def _filter(m):
+        if not getattr(m, "poll", None): return False
+        options = getattr(m.poll, "options", [])
+        if len(options) < min_options: return False
+        if max_options is not None and len(options) > max_options: return False
+        return True
+    return Filter(_filter)
+
+
+
+
+def location_within(lat_min, lat_max, long_min, long_max):
+    def _filter(m):
+        loc = getattr(m, "location", None)
+        if not loc: return False
+        return lat_min <= getattr(loc, "lat", 0) <= lat_max and long_min <= getattr(loc, "long", 0) <= long_max
+    return Filter(_filter)
+
+def live_location_within(lat_min, lat_max, long_min, long_max):
+    def _filter(m):
+        loc = getattr(m, "live_location", None)
+        if not loc: return False
+        return lat_min <= getattr(loc, "lat", 0) <= lat_max and long_min <= getattr(loc, "long", 0) <= long_max
+    return Filter(_filter)
+
+
+
+
+def has_media_types(types: list):
+    return Filter(lambda m: any(getattr(m, t, None) for t in types))
+
+def message_id_is(mid: str):
+    return Filter(lambda m: getattr(m, "message_id", None) == mid)
+
+def is_reply_to_user(user_id: str):
+    return Filter(lambda m: getattr(m, "reply_to_message_id", None) == user_id)
+
+def is_forwarded_from(user_id: str):
+    return Filter(lambda m: getattr(m.forwarded_from, "sender_id", None) == user_id if getattr(m, "forwarded_from", None) else False)
+
+def edited_text_contains(keyword: str):
+    return Filter(lambda m: getattr(m, "edited_text", "") and keyword in m.edited_text)
+
+def aux_data_contains(key: str, value):
+    return Filter(lambda m: getattr(m.aux_data, key, None) == value if getattr(m, "aux_data", None) else False)
+
+
+
+
+def file_attr(attr_name):
+    return Filter(lambda m: m.file and getattr(m.file, attr_name, None))
+
+def sticker_attr(attr_name):
+    return Filter(lambda m: m.sticker and getattr(m.sticker, attr_name, None))
+
+def poll_attr(attr_name):
+    return Filter(lambda m: m.poll and getattr(m.poll, attr_name, None))
+
+def location_attr(attr_name):
+    return Filter(lambda m: m.location and getattr(m.location, attr_name, None))
+
+def live_location_attr(attr_name):
+    return Filter(lambda m: m.live_location and getattr(m.live_location, attr_name, None))
+
+
+
+
+file_size = file_attr("size")
+file_name = file_attr("file_name")
+sticker_id = sticker_attr("sticker_id")
+poll_question = poll_attr("question")
+location_lat = location_attr("lat")
+location_long = location_attr("long")
+live_location_lat = live_location_attr("lat")
+live_location_long = live_location_attr("long")
+
+_custom_filters = {}
+def chat_title_contains(keyword: str):
+    
+    return Filter(lambda m: getattr(m, "chat", None) and keyword in getattr(m.chat, "title", ""))
+
+def chat_title_equals(value: str):
+    
+    return Filter(lambda m: getattr(m, "chat", None) and getattr(m.chat, "title", "") == value)
+
+def chat_id_is(cid: str):
+    return Filter(lambda m: getattr(m, "chat", None) and getattr(m.chat, "id", None) == cid)
+
+def chat_member_count(min_count: int = 0, max_count: int = None):
+    
+    def _filter(m):
+        c = getattr(m, "chat", None)
+        if not c: return False
+        count = getattr(c, "member_count", 0)
+        if count < min_count: return False
+        if max_count is not None and count > max_count: return False
+        return True
+    return Filter(_filter)
+
+def chat_type_is(chat_type: str):
+    
+    return Filter(lambda m: getattr(m, "chat", None) and getattr(m.chat, "type", None) == chat_type)
+
+def chat_username_contains(keyword: str):
+    
+    return Filter(lambda m: getattr(m, "chat", None) and keyword in getattr(m.chat, "username", ""))
+
+def chat_username_equals(value: str):
+    
+    return Filter(lambda m: getattr(m, "chat", None) and getattr(m.chat, "username", "") == value)
+
+def chat_has_link():
+    
+    return Filter(lambda m: getattr(m, "chat", None) and getattr(m.chat, "invite_link", None) is not None)
+
+def chat_is_private():
+    
+    return Filter(lambda m: getattr(m, "chat", None) and getattr(m.chat, "type", None) in ["group", "channel"])
+
+def chat_member_count_gt(count: int):
+    
+    return Filter(lambda m: getattr(m, "chat", None) and getattr(m.chat, "member_count", 0) > count)
+
+def chat_member_count_lt(count: int):
+    
+    return Filter(lambda m: getattr(m, "chat", None) and getattr(m.chat, "member_count", 0) < count)
+
+def chat_has_username():
+    
+    return Filter(lambda m: getattr(m, "chat", None) and getattr(m.chat, "username", None) is not None)
+
+def chat_type_in(types: list):
+    
+    return Filter(lambda m: getattr(m, "chat", None) and getattr(m.chat, "type", None) in types)
+
+
+def chat_title_regex(pattern: str):
+    regex = re.compile(pattern)
+    return Filter(lambda m: getattr(m, "chat", None) and regex.search(getattr(m.chat, "title", "")))
+
+def chat_username_regex(pattern: str):
+    regex = re.compile(pattern)
+    return Filter(lambda m: getattr(m, "chat", None) and regex.search(getattr(m.chat, "username", "")))
+def custom(name):
+    def wrapper(func):
+        _custom_filters[name] = Filter(func)
+        return _custom_filters[name]
+    return wrapper
+
+def get_custom(name):
+    return _custom_filters.get(name)
+
+def and_(*filters):
+    return Filter(lambda m: all(f(m) for f in filters))
+
+def or_(*filters):
+    return Filter(lambda m: any(f(m) for f in filters))
+
+def not_(filter_):
+    return Filter(lambda m: not filter_(m))

{rubka-6.4.6 → rubka-6.5.2}/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.5.2}/setup.py

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