Rubka 7.1.18__tar.gz → 7.2.2__tar.gz

{rubka-7.1.18 → rubka-7.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Rubka
-Version: 7.1.18
+Version: 7.2.2
 Summary: Rubika: A Python library for interacting with the Rubika Bot API. This library provides an easy-to-use interface to send messages, polls, stickers, media files, manage groups and channels, handle inline keyboards, and implement advanced bot features like subscription management, user authentication, and message handling. Ideal for developers looking to automate and extend their Rubika bots with Python.
 Home-page: https://github.com/Mahdy-Ahmadi/Rubka
 Download-URL: https://github.com/Mahdy-Ahmadi/rubka/archive/refs/tags/v6.6.4.zip

{rubka-7.1.18 → rubka-7.2.2}/Rubka.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Rubka
-Version: 7.1.18
+Version: 7.2.2
 Summary: Rubika: A Python library for interacting with the Rubika Bot API. This library provides an easy-to-use interface to send messages, polls, stickers, media files, manage groups and channels, handle inline keyboards, and implement advanced bot features like subscription management, user authentication, and message handling. Ideal for developers looking to automate and extend their Rubika bots with Python.
 Home-page: https://github.com/Mahdy-Ahmadi/Rubka
 Download-URL: https://github.com/Mahdy-Ahmadi/rubka/archive/refs/tags/v6.6.4.zip

{rubka-7.1.18 → rubka-7.2.2}/rubka/__init__.py

@@ -66,8 +66,7 @@ Sync = simple, step-by-step, blocking.
 Async = scalable, concurrent, non-blocking.
 """
 
-from .api import Robot
-from .rubino import Bot
+from .api import Robot,Bot,robot,bot
 from .exceptions import APIRequestError
 from .rubino import Bot as rubino
 from .tv import TV as TvRubika

{rubka-7.1.18 → rubka-7.2.2}/rubka/asynco.py

@@ -280,6 +280,7 @@ max_cache_size and max_msg_age help manage duplicate message processing efficien
         self.proxy = proxy
         self.max_msg_age = max_msg_age
         self.retries = retries
+        self.middleware_data = []
         
         self.retry_delay = retry_delay
         self.raise_errors = raise_errors
@@ -541,6 +542,11 @@ max_cache_size and max_msg_age help manage duplicate message processing efficien
 
 #decorator#
 
+    def middleware(self):
+        def decorator(func: Callable[[Any, Union[Message, InlineMessage]], None]):
+            self.middleware_data.append(func)
+            return func
+        return decorator
     def on_message_private(
         self,
         chat_id: Optional[Union[str, List[str]]] = None,   
@@ -1842,20 +1848,23 @@ max_cache_size and max_msg_age help manage duplicate message processing efficien
         reply_to_message_id: Optional[str] = None,
         chat_keypad_type: Optional[Literal["New", "Remove"]] = None,
         delete_after: Optional[int] = None,
-        parse_mode: Optional[Literal["HTML", "Markdown"]] = None
+        parse_mode: Optional[Literal["HTML", "Markdown"]] = None,
+        meta_data:Optional[dict] = None
     ) -> Dict[str, Any]:
-
         payload = {
             "chat_id": chat_id,
             "text": text,
             "disable_notification": disable_notification,
         }
-        parse_mode_to_use = parse_mode or self.parse_mode
-        if text:
-            text, metadata = self._parse_text_metadata(text, parse_mode_to_use)
-            payload["text"] = text
-            if metadata:
-                payload["metadata"] = metadata
+        if not meta_data:
+            parse_mode_to_use = parse_mode or self.parse_mode
+            if text:
+                text, metadata = self._parse_text_metadata(text, parse_mode_to_use)
+                payload["text"] = text
+                if metadata:
+                    payload["metadata"] = metadata
+        else :
+            payload["metadata"] = meta_data
         if chat_keypad:
             payload["chat_keypad"] = chat_keypad
             payload["chat_keypad_type"] = chat_keypad_type or "New"
@@ -2017,7 +2026,7 @@ max_cache_size and max_msg_age help manage duplicate message processing efficien
         if reply_to_message_id: payload["reply_to_message_id"] = reply_to_message_id
         if chat_keypad_type: payload["chat_keypad_type"] = chat_keypad_type
         return await self._post("sendLocation", {k: v for k, v in payload.items() if v is not None})
-    async def upload_media_file(self, upload_url: str, name: str, path: Union[str, Path]) -> str:
+    async def upload_media_file(self, upload_url: str, name: str, path: Union[str, Path, bytes]) -> str:
         session = await self._get_session()
         is_temp_file = False
         if isinstance(path, str) and path.startswith("http"):
@@ -2029,12 +2038,17 @@ max_cache_size and max_msg_age help manage duplicate message processing efficien
                     tmp.write(content)
                     path = tmp.name
                     is_temp_file = True
+        elif isinstance(path, bytes):
+            with tempfile.NamedTemporaryFile(delete=False) as tmp:
+                tmp.write(path)
+                path = tmp.name
+                is_temp_file = True
 
         file_size = os.path.getsize(path)
         chunk_size = self.chunk_size
 
         progress_bar = tqdm(total=file_size, unit='B', unit_scale=True, unit_divisor=1024,
-                            desc=f'Uploading: {name}', colour='cyan', disable=not getattr(self, 'show_progress', True))
+                            desc=f'Upload : {name}', colour='blue', disable=not getattr(self, 'show_progress', True))
 
         async def file_generator(file_path):
             async with aiofiles.open(file_path, 'rb') as f:
@@ -2044,7 +2058,6 @@ max_cache_size and max_msg_age help manage duplicate message processing efficien
 
         form = aiohttp.FormData()
         form.add_field('file', file_generator(path), filename=name, content_type='application/octet-stream')
-
         try:
             async with session.post(upload_url, data=form, timeout=aiohttp.ClientTimeout(total=None)) as response:
                 progress_bar.close()
@@ -2053,7 +2066,7 @@ max_cache_size and max_msg_age help manage duplicate message processing efficien
                     raise Exception(f"Upload failed ({response.status}): {text}")
                 return (await response.json()).get('data', {}).get('file_id')
         except Exception as e:
-            raise FeatureNotAvailableError(f"File upload not supported: {e}")
+            raise FeatureNotAvailableError(f"File upload not supported : {e}")
         finally:
             if is_temp_file:
                 os.remove(path)
@@ -2142,16 +2155,20 @@ max_cache_size and max_msg_age help manage duplicate message processing efficien
             raise ValueError(f"Invalid media type. Must be one of {allowed}")
         result = await self._post("requestSendFile", {"type": media_type})
         return result.get("data", {}).get("upload_url")
-    async def _send_uploaded_file(self, chat_id: str, file_id: str,type_file : str = "file",text: Optional[str] = None, chat_keypad: Optional[Dict[str, Any]] = None, inline_keypad: Optional[Dict[str, Any]] = None, disable_notification: bool = False, reply_to_message_id: Optional[str] = None, chat_keypad_type: Optional[Literal["New", "Remove", "None"]] = "None",parse_mode: Optional[Literal["HTML", "Markdown"]] = None) -> Dict[str, Any]:
+    async def _send_uploaded_file(self, chat_id: str, file_id: str,type_file : str = "file",text: Optional[str] = None, chat_keypad: Optional[Dict[str, Any]] = None, inline_keypad: Optional[Dict[str, Any]] = None, disable_notification: bool = False, reply_to_message_id: Optional[str] = None, chat_keypad_type: Optional[Literal["New", "Remove", "None"]] = "None",parse_mode: Optional[Literal["HTML", "Markdown"]] = None,meta_data:Optional[dict] = None) -> Dict[str, Any]:
         payload = {"chat_id": chat_id, "file_id": file_id, "text": text, "disable_notification": disable_notification, "chat_keypad_type": chat_keypad_type}
         if chat_keypad: payload["chat_keypad"] = chat_keypad
         if inline_keypad: payload["inline_keypad"] = inline_keypad
         if reply_to_message_id: payload["reply_to_message_id"] = str(reply_to_message_id)
-        parse_mode_to_use = parse_mode or self.parse_mode
-        if text:
-            text, metadata = self._parse_text_metadata(text, parse_mode_to_use)
-            payload["text"] = text
-            if metadata:payload["metadata"] = metadata
+        if not meta_data:
+            parse_mode_to_use = parse_mode or self.parse_mode
+            if text:
+                text, metadata = self._parse_text_metadata(text, parse_mode_to_use)
+                payload["text"] = text
+                if metadata:
+                    payload["metadata"] = metadata
+        else :
+            payload["metadata"] = meta_data
         payload["time"] = "10"
         resp = await self._post("sendFile", payload)
         message_id_put = resp["data"]["message_id"]
@@ -2171,26 +2188,26 @@ max_cache_size and max_msg_age help manage duplicate message processing efficien
             "chat_keypad_type":chat_keypad_type
         }
         return AttrDict(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,parse_mode: Optional[Literal["HTML", "Markdown"]] = None):
+    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,parse_mode: Optional[Literal["HTML", "Markdown"]] = None,meta_data:Optional[dict] = None):
         if path:
             file_name = file_name or Path(path).name
             upload_url = await self.get_upload_url(media_type)
             file_id = await self.upload_media_file(upload_url, file_name, path)
         if not file_id:
             raise ValueError("Either path or file_id must be provided.")
-        return await self._send_uploaded_file(chat_id=chat_id, file_id=file_id, text=text, inline_keypad=inline_keypad, chat_keypad=chat_keypad, reply_to_message_id=reply_to_message_id, disable_notification=disable_notification, chat_keypad_type=chat_keypad_type,type_file=media_type,parse_mode=parse_mode)
-    async def send_document(self, chat_id: str, path: Optional[Union[str, Path]] = None, file_id: Optional[str] = None, text: Optional[str] = None, file_name: Optional[str] = None, inline_keypad: Optional[Dict[str, Any]] = None, chat_keypad: Optional[Dict[str, Any]] = None, reply_to_message_id: Optional[str] = None, disable_notification: bool = False, chat_keypad_type: Optional[Literal["New", "Remove", "None"]] = "None",parse_mode: Optional[Literal["HTML", "Markdown"]] = None) -> Dict[str, Any]:
-        return await self._send_file_generic("File", chat_id, path, file_id, text, file_name, inline_keypad, chat_keypad, reply_to_message_id, disable_notification, chat_keypad_type,parse_mode=parse_mode)
-    async def send_file(self, chat_id: str, path: Optional[Union[str, Path]] = None, file_id: Optional[str] = None, caption: Optional[str] = None, file_name: Optional[str] = None, inline_keypad: Optional[Dict[str, Any]] = None, chat_keypad: Optional[Dict[str, Any]] = None, reply_to_message_id: Optional[str] = None, disable_notification: bool = False, chat_keypad_type: Optional[Literal["New", "Remove", "None"]] = "None",parse_mode: Optional[Literal["HTML", "Markdown"]] = None) -> Dict[str, Any]:
-        return await self._send_file_generic("File", chat_id, path, file_id, caption, file_name, inline_keypad, chat_keypad, reply_to_message_id, disable_notification, chat_keypad_type,parse_mode=parse_mode)
-    async def re_send(self, chat_id: str, path: Optional[Union[str, Path]] = None, file_id: Optional[str] = None, caption: Optional[str] = None, file_name: Optional[str] = None, inline_keypad: Optional[Dict[str, Any]] = None, chat_keypad: Optional[Dict[str, Any]] = None, reply_to_message_id: Optional[str] = None, disable_notification: bool = False, chat_keypad_type: Optional[Literal["New", "Remove", "None"]] = "None",parse_mode: Optional[Literal["HTML", "Markdown"]] = None) -> Dict[str, Any]:
-        return await self._send_file_generic("File", chat_id, path, file_id, caption, file_name, inline_keypad, chat_keypad, reply_to_message_id, disable_notification, chat_keypad_type,parse_mode=parse_mode)  
-    async def send_video(self, chat_id: str, path: Optional[Union[str, Path]] = None, file_id: Optional[str] = None, text: Optional[str] = None, file_name: Optional[str] = None, inline_keypad: Optional[Dict[str, Any]] = None, chat_keypad: Optional[Dict[str, Any]] = None, reply_to_message_id: Optional[str] = None, disable_notification: bool = False, chat_keypad_type: Optional[Literal["New", "Remove", "None"]] = "None",parse_mode: Optional[Literal["HTML", "Markdown"]] = None) -> Dict[str, Any]:
-        return await self._send_file_generic("Video", chat_id, path, file_id, text, file_name, inline_keypad, chat_keypad, reply_to_message_id, disable_notification, chat_keypad_type,parse_mode=parse_mode)
-    async def send_voice(self, chat_id: str, path: Optional[Union[str, Path]] = None, file_id: Optional[str] = None, text: Optional[str] = None, file_name: Optional[str] = None, inline_keypad: Optional[Dict[str, Any]] = None, chat_keypad: Optional[Dict[str, Any]] = None, reply_to_message_id: Optional[str] = None, disable_notification: bool = False, chat_keypad_type: Optional[Literal["New", "Remove", "None"]] = "None",parse_mode: Optional[Literal["HTML", "Markdown"]] = None) -> Dict[str, Any]:
-        return await self._send_file_generic("voice", chat_id, path, file_id, text, file_name, inline_keypad, chat_keypad, reply_to_message_id, disable_notification, chat_keypad_type,parse_mode=parse_mode)
-    async def send_image(self, chat_id: str, path: Optional[Union[str, Path]] = None, file_id: Optional[str] = None, text: Optional[str] = None, file_name: Optional[str] = None, inline_keypad: Optional[Dict[str, Any]] = None, chat_keypad: Optional[Dict[str, Any]] = None, reply_to_message_id: Optional[str] = None, disable_notification: bool = False, chat_keypad_type: Optional[Literal["New", "Remove", "None"]] = "None",parse_mode: Optional[Literal["HTML", "Markdown"]] = None) -> Dict[str, Any]:
-        return await self._send_file_generic("Image", chat_id, path, file_id, text, file_name, inline_keypad, chat_keypad, reply_to_message_id, disable_notification, chat_keypad_type,parse_mode=parse_mode)
+        return await self._send_uploaded_file(chat_id=chat_id, file_id=file_id, text=text, inline_keypad=inline_keypad, chat_keypad=chat_keypad, reply_to_message_id=reply_to_message_id, disable_notification=disable_notification, chat_keypad_type=chat_keypad_type,type_file=media_type,parse_mode=parse_mode,meta_data=meta_data)
+    async def send_document(self, chat_id: str, path: Optional[Union[str, Path]] = None, file_id: Optional[str] = None, text: Optional[str] = None, file_name: Optional[str] = None, inline_keypad: Optional[Dict[str, Any]] = None, chat_keypad: Optional[Dict[str, Any]] = None, reply_to_message_id: Optional[str] = None, disable_notification: bool = False, chat_keypad_type: Optional[Literal["New", "Remove", "None"]] = "None",parse_mode: Optional[Literal["HTML", "Markdown"]] = None,meta_data:Optional[dict] = None) -> Dict[str, Any]:
+        return await self._send_file_generic("File", chat_id, path, file_id, text, file_name, inline_keypad, chat_keypad, reply_to_message_id, disable_notification, chat_keypad_type,parse_mode=parse_mode,meta_data=meta_data)
+    async def send_file(self, chat_id: str, path: Optional[Union[str, Path]] = None, file_id: Optional[str] = None, caption: Optional[str] = None, file_name: Optional[str] = None, inline_keypad: Optional[Dict[str, Any]] = None, chat_keypad: Optional[Dict[str, Any]] = None, reply_to_message_id: Optional[str] = None, disable_notification: bool = False, chat_keypad_type: Optional[Literal["New", "Remove", "None"]] = "None",parse_mode: Optional[Literal["HTML", "Markdown"]] = None,meta_data:Optional[dict] = None) -> Dict[str, Any]:
+        return await self._send_file_generic("File", chat_id, path, file_id, caption, file_name, inline_keypad, chat_keypad, reply_to_message_id, disable_notification, chat_keypad_type,parse_mode=parse_mode,meta_data=meta_data)
+    async def re_send(self, chat_id: str, path: Optional[Union[str, Path]] = None, file_id: Optional[str] = None, caption: Optional[str] = None, file_name: Optional[str] = None, inline_keypad: Optional[Dict[str, Any]] = None, chat_keypad: Optional[Dict[str, Any]] = None, reply_to_message_id: Optional[str] = None, disable_notification: bool = False, chat_keypad_type: Optional[Literal["New", "Remove", "None"]] = "None",parse_mode: Optional[Literal["HTML", "Markdown"]] = None,meta_data:Optional[dict] = None) -> Dict[str, Any]:
+        return await self._send_file_generic("File", chat_id, path, file_id, caption, file_name, inline_keypad, chat_keypad, reply_to_message_id, disable_notification, chat_keypad_type,parse_mode=parse_mode,meta_data=meta_data)  
+    async def send_video(self, chat_id: str, path: Optional[Union[str, Path]] = None, file_id: Optional[str] = None, text: Optional[str] = None, file_name: Optional[str] = None, inline_keypad: Optional[Dict[str, Any]] = None, chat_keypad: Optional[Dict[str, Any]] = None, reply_to_message_id: Optional[str] = None, disable_notification: bool = False, chat_keypad_type: Optional[Literal["New", "Remove", "None"]] = "None",parse_mode: Optional[Literal["HTML", "Markdown"]] = None,meta_data:Optional[dict] = None) -> Dict[str, Any]:
+        return await self._send_file_generic("Video", chat_id, path, file_id, text, file_name, inline_keypad, chat_keypad, reply_to_message_id, disable_notification, chat_keypad_type,parse_mode=parse_mode,meta_data=meta_data)
+    async def send_voice(self, chat_id: str, path: Optional[Union[str, Path]] = None, file_id: Optional[str] = None, text: Optional[str] = None, file_name: Optional[str] = None, inline_keypad: Optional[Dict[str, Any]] = None, chat_keypad: Optional[Dict[str, Any]] = None, reply_to_message_id: Optional[str] = None, disable_notification: bool = False, chat_keypad_type: Optional[Literal["New", "Remove", "None"]] = "None",parse_mode: Optional[Literal["HTML", "Markdown"]] = None,meta_data:Optional[dict] = None) -> Dict[str, Any]:
+        return await self._send_file_generic("voice", chat_id, path, file_id, text, file_name, inline_keypad, chat_keypad, reply_to_message_id, disable_notification, chat_keypad_type,parse_mode=parse_mode,meta_data=meta_data)
+    async def send_image(self, chat_id: str, path: Optional[Union[str, Path]] = None, file_id: Optional[str] = None, text: Optional[str] = None, file_name: Optional[str] = None, inline_keypad: Optional[Dict[str, Any]] = None, chat_keypad: Optional[Dict[str, Any]] = None, reply_to_message_id: Optional[str] = None, disable_notification: bool = False, chat_keypad_type: Optional[Literal["New", "Remove", "None"]] = "None",parse_mode: Optional[Literal["HTML", "Markdown"]] = None,meta_data:Optional[dict] = None) -> Dict[str, Any]:
+        return await self._send_file_generic("Image", chat_id, path, file_id, text, file_name, inline_keypad, chat_keypad, reply_to_message_id, disable_notification, chat_keypad_type,parse_mode=parse_mode,meta_data=meta_data)
     async def send_music(
     self,
     chat_id: str,
@@ -2203,7 +2220,8 @@ max_cache_size and max_msg_age help manage duplicate message processing efficien
     reply_to_message_id: Optional[str] = None,
     disable_notification: bool = False,
     chat_keypad_type: Optional[Literal["New", "Remove", "None"]] = "None",
-    parse_mode: Optional[Literal["HTML", "Markdown"]] = None
+    parse_mode: Optional[Literal["HTML", "Markdown"]] = None,
+    meta_data:Optional[dict] = None
     ) -> Dict[str, Any]:
         valid_extensions = {"ogg", "oga", "opus", "flac"}
         extension = "flac"
@@ -2236,7 +2254,8 @@ max_cache_size and max_msg_age help manage duplicate message processing efficien
             reply_to_message_id,
             disable_notification,
             chat_keypad_type,
-            parse_mode=parse_mode
+            parse_mode=parse_mode,
+            meta_data=meta_data
         )
     async def send_gif(
     self,
@@ -2250,7 +2269,8 @@ max_cache_size and max_msg_age help manage duplicate message processing efficien
     reply_to_message_id: Optional[str] = None,
     disable_notification: bool = False,
     chat_keypad_type: Optional[Literal["New", "Remove", "None"]] = "None",
-    parse_mode: Optional[Literal["HTML", "Markdown"]] = None
+    parse_mode: Optional[Literal["HTML", "Markdown"]] = None,
+    meta_data:Optional[dict] = None
     ) -> Dict[str, Any]:
         valid_extensions = {"gif"}
         extension = "gif"
@@ -2283,7 +2303,7 @@ max_cache_size and max_msg_age help manage duplicate message processing efficien
             reply_to_message_id,
             disable_notification,
             chat_keypad_type,
-            parse_mode=parse_mode
+            parse_mode=parse_mode,meta_data=meta_data
         )
 
     async def get_avatar_me(self, save_as: str = None) -> str:
@@ -2427,18 +2447,21 @@ max_cache_size and max_msg_age help manage duplicate message processing efficien
         return await self._post("leaveChat", {"chat_id": chat_id})
     async def forward_message(self, from_chat_id: str, message_id: str, to_chat_id: str, disable_notification: bool = False) -> Dict[str, Any]:
         return await self._post("forwardMessage", {"from_chat_id": from_chat_id, "message_id": message_id, "to_chat_id": to_chat_id, "disable_notification": disable_notification})
-    async def edit_message_text(self, chat_id: str, message_id: str, text: str, parse_mode: Optional[Literal["HTML", "Markdown"]] = None) -> Dict[str, Any]:
+    async def edit_message_text(self, chat_id: str, message_id: str, text: str, parse_mode: Optional[Literal["HTML", "Markdown"]] = None,meta_data:Optional[dict] = None) -> Dict[str, Any]:
         payload = {
             "chat_id": chat_id,
             "message_id": message_id,
             "text": text,
         }
-        parse_mode_to_use = parse_mode or self.parse_mode
-        if text:
-            text, metadata = self._parse_text_metadata(text, parse_mode_to_use)
-            payload["text"] = text
-            if metadata:
-                payload["metadata"] = metadata
+        if not meta_data:
+            parse_mode_to_use = parse_mode or self.parse_mode
+            if text:
+                text, metadata = self._parse_text_metadata(text, parse_mode_to_use)
+                payload["text"] = text
+                if metadata:
+                    payload["metadata"] = metadata
+        else :
+            payload["metadata"] = meta_data
         return await self._post("editMessageText", payload)
     async def edit_inline_keypad(self,chat_id: str,message_id: str,inline_keypad: Dict[str, Any],text: str = None) -> Dict[str, Any]:
         if text is not None:await self._post("editMessageText", {"chat_id": chat_id,"message_id": message_id,"text": text})
@@ -2511,4 +2534,11 @@ max_cache_size and max_msg_age help manage duplicate message processing efficien
                 result = await asyncio.to_thread(self.get_all_member, channel_guid, search_text=first_name)
                 members = result.get('in_chat_members', [])
                 return any(m.get('first_name') == first_name for m in members)
-        return False
+        return False
+
+class Bot(Robot):
+    pass
+class bot(Robot):
+    pass
+class robot(Robot):
+    pass

{rubka-7.1.18 → rubka-7.2.2}/rubka/context.py

@@ -288,6 +288,7 @@ class Message:
         self.is_audio = None
         self.is_voice = None
         self.is_document = None
+        self.is_music = None
         self.is_archive = None
         self.is_executable = None
         self.is_font = None
@@ -356,6 +357,7 @@ class Message:
             self.is_photo = name.endswith((".jpg", ".jpeg", ".png", ".gif", ".webp"))
             self.is_video = name.endswith((".mp4", ".mov", ".avi", ".mkv", ".webm"))
             self.is_audio = name.endswith((".mp3", ".wav", ".ogg", ".m4a", ".flac"))
+            self.is_music = name.endswith((".mp3", ".wav", ".ogg", ".m4a", ".flac"))
             self.is_voice = name.endswith((".ogg", ".m4a"))
             self.is_document = name.endswith((".pdf", ".doc", ".docx", ".txt", ".xls", ".xlsx", ".ppt", ".pptx"))
             self.is_archive = name.endswith((".zip", ".rar", ".7z", ".tar", ".gz"))
@@ -437,8 +439,32 @@ class Message:
             reply_to_message_id=self.message_id,
             **kwargs
         )
-    
-
+    async def copy(self, to_chat_id: Optional[str], message_id: Optional[str] = None):await self.copy_message(to_chat_id, message_id)
+    async def copy_message(self, to_chat_id: Optional[str], message_id: Optional[str] = None):
+        try:
+            send_func = None
+            kwargs = {
+                "chat_id": to_chat_id,
+                "reply_to_message_id": message_id,
+                "meta_data": self.metadata
+            }
+            if getattr(self, "is_photo", False):
+                send_func = self.bot.send_image
+            elif getattr(self, "is_video", False):
+                send_func = self.bot.send_video
+            elif getattr(self, "is_document", False):
+                send_func = self.bot.send_document
+            elif getattr(self, "is_text", False):
+                send_func = self.bot.send_message
+                kwargs["text"] = self.text
+            if send_func:
+                if hasattr(self, "file") and self.file:
+                    kwargs["path"] = await self.bot.get_url_file(self.file.file_id)
+                return await send_func(**kwargs)
+            else:
+                raise Exception("Unsupported message type.")
+        except Exception as e:
+            raise Exception(f"Error: {e}")
     def reply_poll(
         self,
         question: str,

{rubka-7.1.18 → rubka-7.2.2}/rubka/filters.py

@@ -1,4 +1,4 @@
-from typing import Callable
+from typing import Callable,Union
 import re
 class TextFilter:
     def __call__(self, keyword=None):
@@ -244,9 +244,18 @@ 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_id_is(sender_id: str):
+    return Filter(lambda m: getattr(m, "chat_id", None) == sender_id)
+def sender_id_is(sender_id: str):
+    return Filter(lambda m: getattr(m, "sender_id", None) == sender_id)
+def senders_id(sender_ids: Union[str, list]):
+    if isinstance(sender_ids, list):
+        return Filter(lambda m: getattr(m, "sender_id", None) in sender_ids)
+    return Filter(lambda m: getattr(m, "sender_id", None) == sender_ids)
+def chat_ids(sender_ids: Union[str, list]):
+    if isinstance(sender_ids, list):
+        return Filter(lambda m: getattr(m, "chat_id", None) in sender_ids)
+    return Filter(lambda m: getattr(m, "chat_id", None) == sender_ids)
 def chat_member_count(min_count: int = 0, max_count: int = None):
     
     def _filter(m):

{rubka-7.1.18 → rubka-7.2.2}/rubka/rubino.py

@@ -1228,4 +1228,44 @@ class Bot():
             "limit": limit,
             "sort": sort
         }
-        return self._reuests_post("getNewFollowRequests", data=payload)
+        return self._reuests_post("getNewFollowRequests", data=payload)
+    def get_myprofile_posts(
+        self,
+        profile_id: Optional[str] = None ,
+        limit: int = 20,
+        sort: str = "FromMax"
+    ) -> Dict[str, Any]:
+        payload = {
+            "profile_id": profile_id,
+            "limit": limit,
+            "sort": sort
+        }
+        return self._reuests_post("getMyProfilePosts", data=payload)
+    def get_recent_following_posts(
+        self,
+        profile_id: Optional[str] = None ,
+        limit: int = 20,
+        sort: str = "FromMax"
+    ) -> Dict[str, Any]:
+        payload = {
+            "profile_id": profile_id,
+            "limit": limit,
+            "sort": sort
+        }
+        return self._reuests_post("getRecentFollowingPosts", data=payload)
+    def get_explore_post_topics(
+        self,
+        profile_id: Optional[str] = None ,
+    ) -> Dict[str, Any]:
+        payload = {
+            "profile_id": profile_id,
+        }
+        return self._reuests_post("getExplorePostTopics", data=payload)
+    def get_profiles_stories(
+        self,
+        profile_id: Optional[str] = None ,
+    ) -> Dict[str, Any]:
+        payload = {
+            "profile_id": profile_id,
+        }
+        return self._reuests_post("getProfilesStories", data=payload)

{rubka-7.1.18 → rubka-7.2.2}/setup.py

@@ -13,7 +13,7 @@ with open("README.md", "r", encoding="utf-8") as f:
 
 setup(
     name='Rubka',
-    version='7.1.18',
+    version='7.2.2',
     description=(
     "Rubika: A Python library for interacting with the Rubika Bot API. "
     "This library provides an easy-to-use interface to send messages, polls, "