Rubka 4.5.0__py3-none-any.whl → 4.5.11__py3-none-any.whl

rubka/api.py

@@ -13,6 +13,8 @@ import tempfile
 from tqdm import tqdm
 import os
 API_URL = "https://botapi.rubika.ir/v3"
+import mimetypes
+import re
 import sys
 import subprocess
 def install_package(package_name):
@@ -109,14 +111,16 @@ class Robot:
         self.Key = Key
         self.platform = platform
         self.web_hook = web_hook
+        self.hook = web_hook
         self._offset_id = None
         self.session = requests.Session()
         self.sessions: Dict[str, Dict[str, Any]] = {}
         self._callback_handler = None
         self._message_handler = None
         self._inline_query_handler = None
+        self._message_handlers: List[dict] = []
         self._callback_handlers = None
-        self._callback_handlers = []  # ✅ این خط مهمه
+        self._callback_handlers = []
         if web_hook:
             try:
                 json_url = requests.get(web_hook, timeout=self.timeout).json().get('url', web_hook)
@@ -132,7 +136,7 @@ class Robot:
             except Exception as e:
                 logger.error(f"Failed to set webhook from {web_hook}: {e}")
         else:
-            self.web_hook = None
+            self.web_hook = self.hook
 
 
 
@@ -161,11 +165,11 @@ class Robot:
         return self._post("getMe", {})
     def on_message(self, filters: Optional[Callable[[Message], bool]] = None, commands: Optional[List[str]] = None):
         def decorator(func: Callable[[Any, Message], None]):
-            self._message_handler = {
+            self._message_handlers.append({
                 "func": func,
                 "filters": filters,
                 "commands": commands
-            }
+            })
             return func
         return decorator
 
@@ -200,64 +204,52 @@ class Robot:
 
     
     def _process_update(self, update: dict):
-        import threading, time
+        import threading
 
-        # هندل پیام inline (معمولاً type = ReceiveQuery)
         if update.get("type") == "ReceiveQuery":
             msg = update.get("inline_message", {})
-            if update.get("type") == "ReceiveQuery":
-                msg = update.get("inline_message", {})
-                context = InlineMessage(bot=self, raw_data=msg)
-                threading.Thread(target=self._handle_inline_query, args=(context,), daemon=True).start()
-                return
+            context = InlineMessage(bot=self, raw_data=msg)
+            threading.Thread(target=self._handle_inline_query, args=(context,), daemon=True).start()
+            return
 
-        # هندل پیام جدید متنی
         if update.get("type") == "NewMessage":
             msg = update.get("new_message", {})
-            chat_id = update.get("chat_id")
-            message_id = msg.get("message_id")
-            sender_id = msg.get("sender_id")
-            text = msg.get("text")
-
-            # فیلتر زمان پیام (مثلاً پیام‌های خیلی قدیمی)
             try:
                 if msg.get("time") and (time.time() - float(msg["time"])) > 20:
                     return
             except Exception:
                 return
 
-            # ساخت context پیام
-            context = Message(bot=self, chat_id=chat_id, message_id=message_id, sender_id=sender_id, text=text, raw_data=msg)
+            context = Message(bot=self, 
+                              chat_id=update.get("chat_id"), 
+                              message_id=msg.get("message_id"), 
+                              sender_id=msg.get("sender_id"), 
+                              text=msg.get("text"), 
+                              raw_data=msg)
 
-            # هندل callback ها (دکمه‌ها)
-            if context.aux_data and hasattr(self, "_callback_handlers"):
+            if context.aux_data and self._callback_handlers:
                 for handler in self._callback_handlers:
                     if not handler["button_id"] or context.aux_data.button_id == handler["button_id"]:
                         threading.Thread(target=handler["func"], args=(self, context), daemon=True).start()
-                        return  # فقط یک callback اجرا شود
-
-            # هندل پیام‌های متنی معمولی
-            if hasattr(self, "_message_handler") and self._message_handler:
-                handler = self._message_handler
-
-                if handler["commands"]:
-                    if not context.text or not context.text.startswith("/"):
-                        return
-                    parts = context.text.split()
-                    cmd = parts[0][1:]
-                    if cmd not in handler["commands"]:
                         return
-                    context.args = parts[1:]
 
-                if handler["filters"] and not handler["filters"](context):
+            if self._message_handlers:
+                for handler in self._message_handlers:
+                    if handler["commands"]:
+                        if not context.text or not context.text.startswith("/"):
+                            continue
+                        parts = context.text.split()
+                        cmd = parts[0][1:]
+                        if cmd not in handler["commands"]:
+                            continue
+                        context.args = parts[1:]
+
+                    if handler["filters"] and not handler["filters"](context):
+                        continue
+
+                    threading.Thread(target=handler["func"], args=(self, context), daemon=True).start()
                     return
 
-                threading.Thread(target=handler["func"], args=(self, context), daemon=True).start()
-
-
-
-
-
     def get_updates(
         self,
         offset_id: Optional[str] = None,
@@ -284,12 +276,10 @@ class Robot:
     def _is_duplicate(self, message_id: str, max_age_sec: int = 300) -> bool:
         now = time.time()
 
-        # حذف پیام‌های قدیمی‌تر از max_age_sec
         expired = [mid for mid, ts in self._processed_message_ids.items() if now - ts > max_age_sec]
         for mid in expired:
             del self._processed_message_ids[mid]
 
-        # بررسی تکراری بودن پیام
         if message_id in self._processed_message_ids:
             return True
 
@@ -303,7 +293,6 @@ class Robot:
     def run(self):
         print("Bot started running...")
         self._processed_message_ids: Dict[str, float] = {}
-        # self._offset_id می‌تواند قبلاً مقداردهی شده باشد
 
         while True:
             try:
@@ -314,12 +303,11 @@ class Robot:
                         for item in updates:
                             data = item.get("data", {})
 
-                            # بررسی زمان دریافت پیام و رد کردن پیام‌های قدیمی (بیش از 20 ثانیه)
                             received_at_str = item.get("received_at")
                             if received_at_str:
                                 received_at_ts = datetime.datetime.strptime(received_at_str, "%Y-%m-%d %H:%M:%S").timestamp()
                                 if time.time() - received_at_ts > 20:
-                                    continue  # رد کردن پیام قدیمی
+                                    continue
 
                             update = None
                             if "update" in data:
@@ -348,7 +336,6 @@ class Robot:
 
                             self._process_update(update)
 
-                            # ثبت پیام به عنوان پردازش شده
                             if message_id:
                                 self._processed_message_ids[message_id] = time.time()
 
@@ -436,6 +423,10 @@ class Robot:
 
         return False
 
+    def get_url_file(self,file_id):
+        data = self._post("getFile", {'file_id': file_id})
+        return data.get("data").get("download_url")
+    
 
     def get_all_member(
         self,
@@ -484,7 +475,6 @@ class Robot:
             "reply_to_message_id": reply_to_message_id,
             "chat_keypad_type": chat_keypad_type
         }
-        # Remove None values
         payload = {k: v for k, v in payload.items() if v is not None}
         return self._post("sendLocation", payload)
 
@@ -504,7 +494,63 @@ class Robot:
             "last_name": last_name,
             "phone_number": phone_number
         })
+    def download(self,file_id: str, save_as: str = None, chunk_size: int = 1024 * 512, timeout_sec: int = 60, verbose: bool = False):
+        """
+        Download a file from server using its file_id with chunked transfer,
+        progress bar, file extension detection, custom filename, and timeout.
+
+        If save_as is not provided, filename will be extracted from
+        Content-Disposition header or Content-Type header extension.
 
+        Parameters:
+            file_id (str): The file ID to fetch the download URL.
+            save_as (str, optional): Custom filename to save. If None, automatically detected.
+            chunk_size (int, optional): Size of each chunk in bytes. Default 512KB.
+            timeout_sec (int, optional): HTTP timeout in seconds. Default 60.
+            verbose (bool, optional): Show progress messages. Default True.
+
+        Returns:
+            bool: True if success, raises exceptions otherwise.
+        """
+        try:
+            url = self.get_url_file(file_id)
+            if not url:
+                raise ValueError("Download URL not found in response.")
+        except Exception as e:
+            raise ValueError(f"Failed to get download URL: {e}")
+
+        try:
+            with requests.get(url, stream=True, timeout=timeout_sec) as resp:
+                if resp.status_code != 200:
+                    raise requests.HTTPError(f"Failed to download file. Status code: {resp.status_code}")
+
+                if not save_as:
+                    content_disp = resp.headers.get("Content-Disposition", "")
+                    match = re.search(r'filename="?([^\";]+)"?', content_disp)
+                    if match:
+                        save_as = match.group(1)
+                    else:
+                        content_type = resp.headers.get("Content-Type", "").split(";")[0]
+                        extension = mimetypes.guess_extension(content_type) or ".bin"
+                        save_as = f"{file_id}{extension}"
+
+                total_size = int(resp.headers.get("Content-Length", 0))
+                progress = tqdm(total=total_size, unit="B", unit_scale=True)
+
+                with open(save_as, "wb") as f:
+                    for chunk in resp.iter_content(chunk_size=chunk_size):
+                        if chunk:
+                            f.write(chunk)
+                            progress.update(len(chunk))
+
+                progress.close()
+                if verbose:
+                    print(f"File saved as: {save_as}")
+
+                return True
+
+        except Exception as e:
+            raise RuntimeError(f"Download failed: {e}")
     def get_chat(self, chat_id: str) -> Dict[str, Any]:
         """Get chat info."""
         return self._post("getChat", {"chat_id": chat_id})
@@ -605,7 +651,64 @@ class Robot:
             payload["reply_to_message_id"] = str(reply_to_message_id)
 
         return self._post("sendFile", payload)
-
+    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", "Removed", "None"]] = "None"
+    ) -> Dict[str, Any]:
+        if path:
+            file_name = file_name or Path(path).name
+            upload_url = self.get_upload_url("File")
+            file_id = self.upload_media_file(upload_url, file_name, path)
+        if not file_id:
+            raise ValueError("Either path or file_id must be provided.")
+        return self._send_uploaded_file(
+            chat_id=chat_id,
+            file_id=file_id,
+            text=caption,
+            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
+        )
+    def re_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", "Removed", "None"]] = "None"
+    ) -> Dict[str, Any]:
+        if path:
+            file_name = file_name or Path(path).name
+            upload_url = self.get_upload_url("File")
+            file_id = self.upload_media_file(upload_url, file_name, path)
+        if not file_id:
+            raise ValueError("Either path or file_id must be provided.")
+        return self._send_uploaded_file(
+            chat_id=chat_id,
+            file_id=file_id,
+            text=caption,
+            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
+        )
     def send_document(
         self,
         chat_id: str,
@@ -617,7 +720,7 @@ class Robot:
         chat_keypad: Optional[Dict[str, Any]] = None,
         reply_to_message_id: Optional[str] = None,
         disable_notification: bool = False,
-        chat_keypad_type: Optional[Literal["New", "Removed", "None"]] = "New"
+        chat_keypad_type: Optional[Literal["New", "Removed", "None"]] = "None"
     ) -> Dict[str, Any]:
         if path:
             file_name = file_name or Path(path).name
@@ -646,7 +749,7 @@ class Robot:
         chat_keypad: Optional[Dict[str, Any]] = None,
         reply_to_message_id: Optional[str] = None,
         disable_notification: bool = False,
-        chat_keypad_type: Optional[Literal["New", "Removed", "None"]] = "New"
+        chat_keypad_type: Optional[Literal["New", "Removed", "None"]] = "None"
     ) -> Dict[str, Any]:
         if path:
             file_name = file_name or Path(path).name
@@ -675,7 +778,7 @@ class Robot:
         chat_keypad: Optional[Dict[str, Any]] = None,
         reply_to_message_id: Optional[str] = None,
         disable_notification: bool = False,
-        chat_keypad_type: Optional[Literal["New", "Removed", "None"]] = "New"
+        chat_keypad_type: Optional[Literal["New", "Removed", "None"]] = "None"
     ) -> Dict[str, Any]:
         if path:
             file_name = file_name or Path(path).name
@@ -704,7 +807,7 @@ class Robot:
         chat_keypad: Optional[Dict[str, Any]] = None,
         reply_to_message_id: Optional[str] = None,
         disable_notification: bool = False,
-        chat_keypad_type: Optional[Literal["New", "Removed", "None"]] = "New"
+        chat_keypad_type: Optional[Literal["New", "Removed", "None"]] = "None"
     ) -> Dict[str, Any]:
         if path:
             file_name = file_name or Path(path).name
@@ -733,7 +836,7 @@ class Robot:
         chat_keypad: Optional[Dict[str, Any]] = None,
         reply_to_message_id: Optional[str] = None,
         disable_notification: bool = False,
-        chat_keypad_type: Optional[Literal["New", "Removed", "None"]] = "New"
+        chat_keypad_type: Optional[Literal["New", "Removed", "None"]] = "None"
     ) -> Dict[str, Any]:
         if path:
             file_name = file_name or Path(path).name
@@ -762,7 +865,7 @@ class Robot:
         chat_keypad: Optional[Dict[str, Any]] = None,
         reply_to_message_id: Optional[str] = None,
         disable_notification: bool = False,
-        chat_keypad_type: Optional[Literal["New", "Removed", "None"]] = "New"
+        chat_keypad_type: Optional[Literal["New", "Removed", "None"]] = "None"
     ) -> Dict[str, Any]:
         if path:
             file_name = file_name or Path(path).name

rubka/asynco.py

@@ -8,8 +8,12 @@ from .logger import logger
 try:
     from .context import Message, InlineMessage
 except (ImportError, ModuleNotFoundError):
-    # اگر به صورت مستقیم اجرا شود، از این حالت استفاده می‌کند
     from context import Message, InlineMessage
+
+from tqdm.asyncio import tqdm
+from urllib.parse import urlparse, parse_qs
+
+import mimetypes
 from pathlib import Path
 import time
 import datetime
@@ -119,6 +123,7 @@ class Robot:
         self._inline_query_handler = None
         self._callback_handlers: List[dict] = []
         self._processed_message_ids: Dict[str, float] = {}
+        self._message_handlers: List[dict] = [] 
 
         logger.info(f"Initialized RubikaBot with token: {token[:8]}***")
         
@@ -184,11 +189,11 @@ class Robot:
 
     def on_message(self, filters: Optional[Callable[[Message], bool]] = None, commands: Optional[List[str]] = None):
         def decorator(func: Callable[[Any, Message], None]):
-            self._message_handler = {
+            self._message_handlers.append({
                 "func": func,
                 "filters": filters,
                 "commands": commands
-            }
+            })
             return func
         return decorator
 
@@ -244,27 +249,40 @@ class Robot:
                               text=msg.get("text"), 
                               raw_data=msg)
             
+            # پردازش دکمه‌های شیشه‌ای (بدون تغییر)
             if context.aux_data and self._callback_handlers:
                 for handler in self._callback_handlers:
                     if not handler["button_id"] or context.aux_data.button_id == handler["button_id"]:
                         asyncio.create_task(handler["func"](self, context))
                         return
 
-            if self._message_handler:
-                handler_info = self._message_handler
-                if handler_info["commands"]:
-                    if not context.text or not context.text.startswith("/"):
-                        return
-                    parts = context.text.split()
-                    cmd = parts[0][1:]
-                    if cmd not in handler_info["commands"]:
-                        return
-                    context.args = parts[1:]
-                
-                if handler_info["filters"] and not handler_info["filters"](context):
-                    return
-
-                asyncio.create_task(handler_info["func"](self, context))
+            # پردازش پیام‌های متنی با حلقه روی تمام هندلرها
+            if self._message_handlers:
+                for handler_info in self._message_handlers:
+                    # بررسی شرط دستورات (commands)
+                    if handler_info["commands"]:
+                        if not context.text or not context.text.startswith("/"):
+                            continue  # اگر پیام کامند نبود، این هندلر را رد کن
+                        parts = context.text.split()
+                        cmd = parts[0][1:]
+                        if cmd not in handler_info["commands"]:
+                            continue  # اگر کامند مطابقت نداشت، این هندلر را رد کن
+                        context.args = parts[1:]
+                    
+                    # بررسی شرط فیلترها (filters)
+                    if handler_info["filters"]:
+                        if not handler_info["filters"](context):
+                            continue # اگر فیلتر برقرار نبود، این هندلر را رد کن
+                    
+                    # اگر هندلری برای همه پیام‌ها باشد (بدون کامند و فیلتر)
+                    if not handler_info["commands"] and not handler_info["filters"]:
+                        asyncio.create_task(handler_info["func"](self, context))
+                        return # بعد از یافتن هندلر مناسب، از حلقه خارج شو
+                    
+                    # اگر شرایط کامند یا فیلتر برقرار بود
+                    if handler_info["commands"] or handler_info["filters"]:
+                        asyncio.create_task(handler_info["func"](self, context))
+                        return # بعد از یافتن هندلر مناسب، از حلقه خارج شو
 
     async def get_updates(self, offset_id: Optional[str] = None, limit: Optional[int] = None) -> Dict[str, Any]:
         data = {}
@@ -293,6 +311,7 @@ class Robot:
 
         self._processed_message_ids[message_id] = now
         return False
+    
 
     async def run(self):
         """
@@ -370,14 +389,40 @@ class Robot:
                 await self._aiohttp_session.close()
             print("Bot stopped and session closed.")
             
-    async def send_message(self, chat_id: str, text: str, 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", "Removed"]] = None) -> Dict[str, Any]:
-        payload = {"chat_id": chat_id, "text": text, "disable_notification": disable_notification}
-        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"] = reply_to_message_id
-        if chat_keypad_type: payload["chat_keypad_type"] = chat_keypad_type
+    async def send_message(
+    self,
+    chat_id: str,
+    text: str,
+    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", "Removed"]] = None
+) -> Dict[str, Any]:
+        payload = {
+            "chat_id": chat_id,
+            "text": text,
+            "disable_notification": disable_notification,
+        }
+
+        if chat_keypad:
+            payload["chat_keypad"] = chat_keypad
+            payload["chat_keypad_type"] = chat_keypad_type or "New"
+
+        if inline_keypad:
+            payload["inline_keypad"] = inline_keypad
+
+        if reply_to_message_id:
+            payload["reply_to_message_id"] = reply_to_message_id
+
         return await self._post("sendMessage", payload)
 
+
+    
+    async def get_url_file(self,file_id):
+        data = await self._post("getFile", {'file_id': file_id})
+        return data.get("data").get("download_url")
+
     def _get_client(self) -> Client_get:
         if self.session_name:
             return Client_get(self.session_name, self.auth, self.Key, self.platform)
@@ -440,7 +485,7 @@ class Robot:
                     path = temp_file.name
                     is_temp_file = True
 
-        file_size = os.path.getsize(path) # Note: os.path.getsize is sync, but fast enough for most cases. aiofiles can be used for async alternative if needed on huge file lists.
+        file_size = os.path.getsize(path)
 
         progress_bar = tqdm(total=file_size, unit='B', unit_scale=True, unit_divisor=1024, desc=f'Uploading : {name}', bar_format='{l_bar}{bar:100}{r_bar}', colour='cyan', disable=not self.show_progress)
 
@@ -464,9 +509,100 @@ 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')
 
+
+    def get_extension(content_type: str) -> str:
+        ext = mimetypes.guess_extension(content_type)
+        return ext if ext else ''
+
+    async def download(self, file_id: str, save_as: str = None, chunk_size: int = 1024 * 512,timeout_sec: int = 60, verbose: bool = False):
+        """
+        Download a file from server using its file_id with chunked transfer,
+        progress bar, file extension detection, custom filename, and timeout.
+
+        If save_as is not provided, filename will be extracted from
+        Content-Disposition header or Content-Type header extension.
+
+        Parameters:
+            file_id (str): The file ID to fetch the download URL.
+            save_as (str, optional): Custom filename to save. If None, automatically detected.
+            chunk_size (int, optional): Size of each chunk in bytes. Default 512KB.
+            timeout_sec (int, optional): HTTP timeout in seconds. Default 60.
+            verbose (bool, optional): Show progress messages. Default True.
+
+        Returns:
+            bool: True if success, raises exceptions otherwise.
+        """
+
+        try:
+            url = await self.get_url_file(file_id)
+            if not url:
+                raise ValueError("Download URL not found in response.")
+        except Exception as e:
+            raise ValueError(f"Failed to get download URL: {e}")
+
+        timeout = aiohttp.ClientTimeout(total=timeout_sec)
+
+        try:
+            async with aiohttp.ClientSession(timeout=timeout) as session:
+                async with session.get(url) as resp:
+                    if resp.status != 200:
+                        raise aiohttp.ClientResponseError(
+                            request_info=resp.request_info,
+                            history=resp.history,
+                            status=resp.status,
+                            message="Failed to download file.",
+                            headers=resp.headers
+                        )
+
+                    if not save_as:
+                        content_disp = resp.headers.get("Content-Disposition", "")
+                        import re
+                        match = re.search(r'filename="?([^\";]+)"?', content_disp)
+                        if match:
+                            save_as = match.group(1)
+                        else:
+                            content_type = resp.headers.get("Content-Type", "").split(";")[0]
+                            extension = mimetypes.guess_extension(content_type) or ".bin"
+                            save_as = f"{file_id}{extension}"
+
+                    total_size = int(resp.headers.get("Content-Length", 0))
+                    progress = tqdm(total=total_size, unit="B", unit_scale=True, disable=not verbose)
+
+                    async with aiofiles.open(save_as, "wb") as f:
+                        async for chunk in resp.content.iter_chunked(chunk_size):
+                            await f.write(chunk)
+                            progress.update(len(chunk))
+
+                    progress.close()
+                    if verbose:
+                        print(f"✅ File saved as: {save_as}")
+
+                    return True
+
+        except aiohttp.ClientError as e:
+            raise aiohttp.ClientError(f"HTTP error occurred: {e}")
+        except asyncio.TimeoutError:
+            raise asyncio.TimeoutError("Download timed out.")
+        except Exception as e:
+            raise Exception(f"Error downloading file: {e}")
+
+        except aiohttp.ClientError as e:
+            raise aiohttp.ClientError(f"HTTP error occurred: {e}")
+        except asyncio.TimeoutError:
+            raise asyncio.TimeoutError("The download operation timed out.")
+        except Exception as e:
+            raise Exception(f"An error occurred while downloading the file: {e}")
+
+        except aiohttp.ClientError as e:
+            raise aiohttp.ClientError(f"HTTP error occurred: {e}")
+        except asyncio.TimeoutError:
+            raise asyncio.TimeoutError("The download operation timed out.")
+        except Exception as e:
+            raise Exception(f"An error occurred while downloading the file: {e}")
+
     async def get_upload_url(self, media_type: Literal['File', 'Image', 'Voice', 'Music', 'Gif', 'Video']) -> str:
         allowed = ['File', 'Image', 'Voice', 'Music', 'Gif', 'Video']
         if media_type not in allowed:
@@ -490,22 +626,25 @@ class Robot:
             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)
 
-    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", "Removed", "None"]] = "New") -> Dict[str, Any]:
+    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", "Removed", "None"]] = "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)
-        
-    async def send_music(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", "Removed", "None"]] = "New") -> Dict[str, Any]:
+    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", "Removed", "None"]] = "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)
+    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", "Removed", "None"]] = "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)  
+    async def send_music(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", "Removed", "None"]] = "None") -> Dict[str, Any]:
         return await self._send_file_generic("Music", chat_id, path, file_id, text, file_name, inline_keypad, chat_keypad, reply_to_message_id, disable_notification, chat_keypad_type)
 
-    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", "Removed", "None"]] = "New") -> Dict[str, Any]:
+    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", "Removed", "None"]] = "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)
 
-    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", "Removed", "None"]] = "New") -> Dict[str, Any]:
+    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", "Removed", "None"]] = "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)
 
-    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", "Removed", "None"]] = "New") -> Dict[str, Any]:
+    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", "Removed", "None"]] = "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)
         
-    async def send_gif(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", "Removed", "None"]] = "New") -> Dict[str, Any]:
+    async def send_gif(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", "Removed", "None"]] = "None") -> Dict[str, Any]:
         return await self._send_file_generic("Gif", chat_id, path, file_id, text, file_name, inline_keypad, chat_keypad, reply_to_message_id, disable_notification, chat_keypad_type)
 
     async def forward_message(self, from_chat_id: str, message_id: str, to_chat_id: str, disable_notification: bool = False) -> Dict[str, Any]:

rubka/context.py

@@ -242,6 +242,31 @@ class Message:
         chat_keypad_type: Optional[str] = "None",
         disable_notification: bool = False
     ):
+        if chat_keypad and chat_keypad_type == "none":chat_keypad_type == "New"
+        return self.bot.send_document(
+            chat_id=self.chat_id,
+            path=path,
+            file_id=file_id,
+            text=text,
+            chat_keypad=chat_keypad,
+            inline_keypad=inline_keypad,
+            chat_keypad_type=chat_keypad_type,
+            disable_notification=disable_notification,
+            reply_to_message_id=self.message_id
+        )
+    def reply_file(
+        self,
+        path: Optional[Union[str, Path]] = None,
+        file_id: Optional[str] = None,
+        text: Optional[str] = None,
+        chat_keypad: Optional[Dict[str, Any]] = None,
+        inline_keypad: Optional[Dict[str, Any]] = None,
+        chat_keypad_type: Optional[str] = "None",
+        disable_notification: bool = False
+    ):
+        if chat_keypad and chat_keypad_type == "none":
+            chat_keypad_type == "New"
+
         return self.bot.send_document(
             chat_id=self.chat_id,
             path=path,
@@ -264,6 +289,8 @@ class Message:
         chat_keypad_type: Optional[str] = "None",
         disable_notification: bool = False
     ):
+        if chat_keypad and chat_keypad_type == "none":
+            chat_keypad_type == "New"
         return self.bot.send_image(
             chat_id=self.chat_id,
             path=path,
@@ -286,6 +313,8 @@ class Message:
         chat_keypad_type: Optional[str] = "None",
         disable_notification: bool = False
     ):
+        if chat_keypad and chat_keypad_type == "none":
+            chat_keypad_type == "New"
         return self.bot.send_music(
             chat_id=self.chat_id,
             path=path,
@@ -308,6 +337,8 @@ class Message:
         chat_keypad_type: Optional[str] = "None",
         disable_notification: bool = False
     ):
+        if chat_keypad and chat_keypad_type == "none":
+            chat_keypad_type == "New"
         return self.bot.send_voice(
             chat_id=self.chat_id,
             path=path,
@@ -330,6 +361,7 @@ class Message:
         chat_keypad_type: Optional[str] = "None",
         disable_notification: bool = False
     ):
+        if chat_keypad and chat_keypad_type == "none":chat_keypad_type == "New"
         return self.bot.send_gif(
             chat_id=self.chat_id,
             path=path,
@@ -388,14 +420,6 @@ class Message:
             **kwargs
         })
 
-    def reply_file(self, file_id: str, **kwargs) -> Dict[str, Any]:
-        return self.bot._post("sendFile", {
-            "chat_id": self.chat_id,
-            "file_id": file_id,
-            "reply_to_message_id": self.message_id,
-            **kwargs
-        })
-
     def edit(self, new_text: str) -> Dict[str, Any]:
         return self.bot.edit_message_text(
             chat_id=self.chat_id,

{rubka-4.5.0.dist-info → rubka-4.5.11.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Rubka
-Version: 4.5.0
+Version: 4.5.11
 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-4.5.0.dist-info → rubka-4.5.11.dist-info}/RECORD

@@ -1,9 +1,9 @@
 rubka/__init__.py,sha256=TR1DABU5Maz2eO62ZEFiwOqNU0dH6l6HZfqRUxeo4eY,194
-rubka/api.py,sha256=KGcbBPJh7RaoYPuJTcpzAfhbgZ1PerSA5wn_tzelDq0,35045
-rubka/asynco.py,sha256=osfR2hKKEOT1Pqp0Meq3Iu-_Oox_SjwEesKJzv_Jqgo,30581
+rubka/api.py,sha256=0gj52uxIGmLCVRUxnvjIHF6MVBiXnVBdVr_SRXp2I4M,39416
+rubka/asynco.py,sha256=DDAeES9qDQ9vegHT-7X7RL72G510YObFN7qqJ948NEQ,37647
 rubka/button.py,sha256=4fMSZR7vUADxSmw1R3_pZ4dw5uMLZX5sOkwPPyNTBDE,8437
 rubka/config.py,sha256=Bck59xkOiqioLv0GkQ1qPGnBXVctz1hKk6LT4h2EPx0,78
-rubka/context.py,sha256=j1scXTy_wBY52MmMixfZyIQnB0sdYjRwx17-8ZZmyB4,17017
+rubka/context.py,sha256=KXfDqn3vir6oIupF7piKD89Sqj1MjWoSerS4WyyHXBw,18062
 rubka/decorators.py,sha256=hGwUoE4q2ImrunJIGJ_kzGYYxQf1ueE0isadqraKEts,1157
 rubka/exceptions.py,sha256=tujZt1XrhWaw-lmdeVadVceUptpw4XzNgE44sAAY0gs,90
 rubka/jobs.py,sha256=GvLMLsVhcSEzRTgkvnPISPEBN71suW2xXI0hUaUZPTo,378
@@ -33,7 +33,7 @@ rubka/adaptorrubka/types/socket/message.py,sha256=0WgLMZh4eow8Zn7AiSX4C3GZjQTkIg
 rubka/adaptorrubka/utils/__init__.py,sha256=OgCFkXdNFh379quNwIVOAWY2NP5cIOxU5gDRRALTk4o,54
 rubka/adaptorrubka/utils/configs.py,sha256=nMUEOJh1NqDJsf9W9PurkN_DLYjO6kKPMm923i4Jj_A,492
 rubka/adaptorrubka/utils/utils.py,sha256=5-LioLNYX_TIbQGDeT50j7Sg9nAWH2LJUUs-iEXpsUY,8816
-rubka-4.5.0.dist-info/METADATA,sha256=3xURNUuDQNQR2PrKrMgqOn11urYLW82eYtHEmGyMoOw,33216
-rubka-4.5.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-rubka-4.5.0.dist-info/top_level.txt,sha256=vy2A4lot11cRMdQS-F4HDCIXL3JK8RKfu7HMDkezJW4,6
-rubka-4.5.0.dist-info/RECORD,,
+rubka-4.5.11.dist-info/METADATA,sha256=_9gtchOWeb6ROIeF58OO4Egk7uDSL6Rc-xvcvAasyKg,33217
+rubka-4.5.11.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+rubka-4.5.11.dist-info/top_level.txt,sha256=vy2A4lot11cRMdQS-F4HDCIXL3JK8RKfu7HMDkezJW4,6
+rubka-4.5.11.dist-info/RECORD,,