Rubka 4.5.2__py3-none-any.whl → 4.6.0__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,6 +111,7 @@ 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]] = {}
@@ -117,7 +120,7 @@ class Robot:
         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)
@@ -133,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
 
 
 
@@ -202,14 +205,13 @@ class Robot:
     
     def _process_update(self, update: dict):
         import threading
-        # هندل پیام inline (بدون تغییر)
+
         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
 
-        # هندل پیام جدید متنی
         if update.get("type") == "NewMessage":
             msg = update.get("new_message", {})
             try:
@@ -225,17 +227,14 @@ class Robot:
                               text=msg.get("text"), 
                               raw_data=msg)
 
-            # هندل callback ها (دکمه‌ها) - بدون تغییر
             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
 
-            # هندل پیام‌های متنی با حلقه روی تمام هندلرها
             if self._message_handlers:
                 for handler in self._message_handlers:
-                    # بررسی شرط دستورات (commands)
                     if handler["commands"]:
                         if not context.text or not context.text.startswith("/"):
                             continue
@@ -245,11 +244,9 @@ class Robot:
                             continue
                         context.args = parts[1:]
 
-                    # بررسی شرط فیلترها (filters)
                     if handler["filters"] and not handler["filters"](context):
                         continue
 
-                    # اگر شرایط بالا برقرار بود یا هندلر عمومی بود، اجرا کن و خارج شو
                     threading.Thread(target=handler["func"], args=(self, context), daemon=True).start()
                     return
 
@@ -279,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
 
@@ -298,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:
@@ -309,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:
@@ -338,12 +331,11 @@ class Robot:
                             if message_id is not None:
                                 message_id = str(message_id)
 
-                            if message_id and self._is_duplicate(message_id):
+                            if message_id and self._is_duplicate(received_at_str):
                                 continue
 
                             self._process_update(update)
 
-                            # ثبت پیام به عنوان پردازش شده
                             if message_id:
                                 self._processed_message_ids[message_id] = time.time()
 
@@ -431,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,
@@ -479,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)
 
@@ -499,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})
@@ -600,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,
@@ -612,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
@@ -641,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
@@ -670,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
@@ -699,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
@@ -728,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
@@ -757,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
@@ -86,8 +90,8 @@ async def check_rubka_version():
         print("Not updating may lead to malfunctions or incompatibility.")
         print("To see new methods : @rubka_library\n\n")
 
-# To run the check at startup in an async context
-# asyncio.run(check_rubka_version())
+
+
 
 def show_last_six_words(text: str) -> str:
     """Returns the last 6 characters of a stripped string."""
@@ -222,7 +226,39 @@ class Robot:
             })
             return func
         return decorator
+    def on_inline_query_prefix(self, prefix: str, button_id: Optional[str] = None):
+        if not prefix.startswith('/'):
+            prefix = '/' + prefix
+
+        def decorator(func: Callable[[Any, InlineMessage], None]):
+            
+            async def handler_wrapper(bot_instance, inline_message: InlineMessage):
+                
+                if not inline_message.raw_data or 'text' not in inline_message.raw_data:
+                    return
+
+                query_text = inline_message.raw_data['text']
 
+                
+                if query_text.startswith(prefix):
+                    
+                    
+                    
+                    try:
+                        await func(bot_instance, inline_message)
+                    except Exception as e:
+                        print(f"Error in inline query prefix handler '{prefix}': {e}")
+            
+            
+            self._inline_query_handlers.append({
+                "func": handler_wrapper,
+                "button_id": button_id 
+                                        
+                                        
+                                        
+            })
+            return func 
+        return decorator
     async def _process_update(self, update: dict):
         if update.get("type") == "ReceiveQuery":
             msg = update.get("inline_message", {})
@@ -245,40 +281,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_handlers:
                 for handler_info in self._message_handlers:
-                    # بررسی شرط دستورات (commands)
+                    
                     if handler_info["commands"]:
                         if not context.text or not context.text.startswith("/"):
-                            continue  # اگر پیام کامند نبود، این هندلر را رد کن
+                            continue  
                         parts = context.text.split()
                         cmd = parts[0][1:]
                         if cmd not in handler_info["commands"]:
-                            continue  # اگر کامند مطابقت نداشت، این هندلر را رد کن
+                            continue  
                         context.args = parts[1:]
                     
-                    # بررسی شرط فیلترها (filters)
+                    
                     if handler_info["filters"]:
                         if not handler_info["filters"](context):
-                            continue # اگر فیلتر برقرار نبود، این هندلر را رد کن
+                            continue 
+                    
                     
-                    # اگر هندلری برای همه پیام‌ها باشد (بدون کامند و فیلتر)
                     if not handler_info["commands"] and not handler_info["filters"]:
                         asyncio.create_task(handler_info["func"](self, context))
-                        return # بعد از یافتن هندلر مناسب، از حلقه خارج شو
+                        return 
+                    
                     
-                    # اگر شرایط کامند یا فیلتر برقرار بود
                     if handler_info["commands"] or handler_info["filters"]:
                         asyncio.create_task(handler_info["func"](self, context))
-                        return # بعد از یافتن هندلر مناسب، از حلقه خارج شو
+                        return 
 
     async def get_updates(self, offset_id: Optional[str] = None, limit: Optional[int] = None) -> Dict[str, Any]:
         data = {}
@@ -293,7 +329,7 @@ class Robot:
         if limit: params['limit'] = limit
         async with session.get(self.web_hook, params=params) as response:
             response.raise_for_status()
-            # وب‌هوک باید لیستی از رویدادها را برگرداند
+            
             return await response.json()
 
     def _is_duplicate(self, message_id: str, max_age_sec: int = 300) -> bool:
@@ -307,6 +343,7 @@ class Robot:
 
         self._processed_message_ids[message_id] = now
         return False
+    
 
     async def run(self):
         """
@@ -321,8 +358,8 @@ class Robot:
             while True:
                 try:
                     if self.web_hook:
-                        # ----- منطق وب‌هوک (اصلاح شده) -----
-                        # آپدیت‌ها مستقیما از وب‌هوک گرفته و پردازش می‌شوند
+                        
+                        
                         webhook_data = await self.update_webhook()
                         if isinstance(webhook_data, list):
                             for item in webhook_data:
@@ -335,7 +372,7 @@ class Robot:
                                         if time.time() - received_at_ts > 20:
                                             continue
                                     except (ValueError, TypeError):
-                                        pass  # رد شدن در صورت فرمت اشتباه زمان
+                                        pass  
 
                                 update = None
                                 if "update" in data:
@@ -353,11 +390,11 @@ class Robot:
                                 elif "message_id" in update:
                                     message_id = update.get("message_id")
                                 
-                                if message_id and not self._is_duplicate(str(message_id)):
+                                if message_id and not self._is_duplicate(str(received_at_str)):
                                     await self._process_update(update)
 
                     else:
-                        # ----- منطق Polling (بدون تغییر) -----
+                        
                         get_updates_response = await self.get_updates(offset_id=self._offset_id, limit=100)
                         if get_updates_response and get_updates_response.get("data"):
                             updates = get_updates_response["data"].get("updates", [])
@@ -375,23 +412,49 @@ class Robot:
                                 if message_id and not self._is_duplicate(str(message_id)):
                                     await self._process_update(update)
 
-                    await asyncio.sleep(0.1) # وقفه کوتاه برای جلوگیری از مصرف CPU
+                    await asyncio.sleep(0) 
                 except Exception as e:
                     print(f"❌ Error in run loop: {e}")
-                    await asyncio.sleep(5) # وقفه طولانی‌تر در صورت بروز خطا
+                    await asyncio.sleep(5) 
         finally:
             if self._aiohttp_session:
                 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)
@@ -407,7 +470,7 @@ class Robot:
             username = chat_info.get('username')
             user_id = chat_info.get('user_id')
             
-            # Since client methods are sync, run them in a thread pool
+            
             if username:
                 result = await asyncio.to_thread(self.get_all_member, channel_guid, search_text=username)
                 members = result.get('in_chat_members', [])
@@ -418,7 +481,7 @@ class Robot:
         return False
 
     def get_all_member(self, channel_guid: str, search_text: str = None, start_id: str = None, just_get_guids: bool = False):
-        # This is a sync method that will be called with asyncio.to_thread
+        
         client = self._get_client()
         return client.get_all_members(channel_guid, search_text, start_id, just_get_guids)
 
@@ -454,7 +517,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)
 
@@ -478,9 +541,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:
@@ -504,22 +658,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]:
-        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_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("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_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

@@ -14,9 +14,9 @@ class Sticker:
         self.file = File(data.get("file", {}))
 
 
-# =========================
-# Poll
-# =========================
+
+
+
 class PollStatus:
     def __init__(self, data: dict):
         self.state: str = data.get("state")
@@ -33,9 +33,9 @@ class Poll:
         self.poll_status = PollStatus(data.get("poll_status", {}))
 
 
-# =========================
-# Location & Contact & ForwardedFrom
-# =========================
+
+
+
 class Location:
     def __init__(self, data: dict):
         self.latitude: str = data.get("latitude")
@@ -67,18 +67,18 @@ class ForwardedFrom:
         self.from_sender_id: str = data.get("from_sender_id")
 
 
-# =========================
-# AuxData
-# =========================
+
+
+
 class AuxData:
     def __init__(self, data: dict):
         self.start_id: str = data.get("start_id")
         self.button_id: str = data.get("button_id")
 
 
-# =========================
-# Button Models
-# =========================
+
+
+
 class ButtonTextbox:
     def __init__(self, data: dict):
         self.type_line: str = data.get("type_line")
@@ -221,6 +221,13 @@ class Message:
             reply_to_message_id=self.message_id,
             **kwargs
         )
+    def answer(self, text: str, **kwargs):
+        return self.bot.send_message(
+            self.chat_id,
+            text,
+            reply_to_message_id=self.message_id,
+            **kwargs
+        )
 
     def reply_poll(self, question: str, options: List[str], **kwargs) -> Dict[str, Any]:
         return self.bot._post("sendPoll", {
@@ -242,6 +249,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 +296,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 +320,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 +344,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 +368,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 +427,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,
@@ -413,12 +444,25 @@ class AuxData:
         self.start_id = data.get("start_id")
         self.button_id = data.get("button_id")
 
-# نمونه کلاس InlineMessage با ویژگی aux_data که شامل دکمه است
+
 class InlineMessage:
     def __init__(self, bot, raw_data: dict):
         self.bot = bot
         self.raw_data = raw_data
-
+        self.chat_id = self.raw_data.get("chat_id")
+        self.time: str = self.raw_data.get("time")
+        self.is_edited: bool = self.raw_data.get("is_edited", False)
+        self.sender_type: str = self.raw_data.get("sender_type")
+        self.args = []
+        self.reply_to_message_id: Optional[str] = self.raw_data.get("reply_to_message_id")
+        self.forwarded_from = ForwardedFrom(self.raw_data["forwarded_from"]) if "forwarded_from" in self.raw_data else None
+        self.file = File(self.raw_data["file"]) if "file" in self.raw_data else None
+        self.sticker = Sticker(self.raw_data["sticker"]) if "sticker" in self.raw_data else None
+        self.contact_message = ContactMessage(self.raw_data["contact_message"]) if "contact_message" in self.raw_data else None
+        self.poll = Poll(self.raw_data["poll"]) if "poll" in self.raw_data else None
+        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.chat_id: str = raw_data.get("chat_id")
         self.message_id: str = raw_data.get("message_id")
         self.sender_id: str = raw_data.get("sender_id")
@@ -432,6 +476,13 @@ class InlineMessage:
             reply_to_message_id=self.message_id,
             **kwargs
         )
+    def answer(self, text: str, **kwargs):
+        return self.bot.send_message(
+            self.chat_id,
+            text,
+            reply_to_message_id=self.message_id,
+            **kwargs
+        )
 
     def edit(self, new_text: str):
         return self.bot.edit_message_text(

{rubka-4.5.2.dist-info → rubka-4.6.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Rubka
-Version: 4.5.2
+Version: 4.6.0
 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
@@ -19,6 +19,11 @@ Requires-Dist: requests
 Requires-Dist: Pillow
 Requires-Dist: websocket-client
 Requires-Dist: pycryptodome
+Requires-Dist: aiohttp
+Requires-Dist: tqdm
+Requires-Dist: mutagen
+Requires-Dist: filetype
+Requires-Dist: aiofiles
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier

{rubka-4.5.2.dist-info → rubka-4.6.0.dist-info}/RECORD

@@ -1,9 +1,9 @@
 rubka/__init__.py,sha256=TR1DABU5Maz2eO62ZEFiwOqNU0dH6l6HZfqRUxeo4eY,194
-rubka/api.py,sha256=gzaH2nfZjpxlMwzNsgA4FFBR38bAfQK2-2oTPs555Xw,35160
-rubka/asynco.py,sha256=m3WztgmkzK6Jvrko8HxqLlIigWTbtJkdbDdQq3NtbMo,31994
+rubka/api.py,sha256=-ayu17rFI35hU1O7ePxLQNTK-upj2uJxOflA0JUdWdI,39421
+rubka/asynco.py,sha256=f2OH2JDdB98x7T4c6B1n-dTWpCe8R5KkkHUdwr9IP9g,37433
 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=jtdMYf2slFxK2kmkVO6MMSTl-yu5NH52UvzAOyB79hw,19317
 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.2.dist-info/METADATA,sha256=xgwDJfrcrmaI2Hr9YEugIt8_3OzJiAXBHx2sldoW7ZU,33216
-rubka-4.5.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-rubka-4.5.2.dist-info/top_level.txt,sha256=vy2A4lot11cRMdQS-F4HDCIXL3JK8RKfu7HMDkezJW4,6
-rubka-4.5.2.dist-info/RECORD,,
+rubka-4.6.0.dist-info/METADATA,sha256=ZSH799BnofV3TFaXKdi_unkoru9Yki1Sbv3L1upObMI,33335
+rubka-4.6.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+rubka-4.6.0.dist-info/top_level.txt,sha256=vy2A4lot11cRMdQS-F4HDCIXL3JK8RKfu7HMDkezJW4,6
+rubka-4.6.0.dist-info/RECORD,,