Rubka 6.6.13__py3-none-any.whl → 6.7.1__py3-none-any.whl

rubka/asynco.py

@@ -1,6 +1,7 @@
-import asyncio,aiohttp,aiofiles,time,datetime,json,tempfile,os,sys,subprocess,mimetypes
+import asyncio,aiohttp,aiofiles,time,datetime,json,tempfile,os,sys,subprocess,mimetypes,time, hashlib
 from typing import List, Optional, Dict, Any, Literal, Callable, Union,Set
-from .exceptions import APIRequestError
+from collections import OrderedDict
+from .exceptions import APIRequestError,raise_for_status,InvalidAccessError,InvalidInputError,TooRequestError,InvalidTokenError
 from .adaptorrubka import Client as Client_get
 from .logger import logger
 from .rubino import Bot as Rubino
@@ -12,7 +13,7 @@ class FeatureNotAvailableError(Exception):
 
 from tqdm.asyncio import tqdm
 from urllib.parse import urlparse, parse_qs
-class InvalidTokenError(Exception):pass
+
 from pathlib import Path
 from tqdm import tqdm
 API_URL = "https://botapi.rubika.ir/v3"
@@ -98,38 +99,64 @@ class AttrDict(dict):
 
 class Robot:
     """
-    Main asynchronous class to interact with the Rubika Bot API.
-
-    This class handles sending and receiving messages, inline queries, callbacks,
-    and manages sessions and API interactions. It is initialized with a bot token
-    and provides multiple optional parameters for configuration.
-
-    Attributes:
-        token (str): Bot token used for authentication with Rubika Bot API.
-        session_name (str | None): Optional session name for storing session data.
-        auth (str | None): Optional authentication string for advanced features.
-        Key (str | None): Optional key for additional authorization if required.
-        platform (str): Platform type, default is 'web'.
-        web_hook (str | None): Optional webhook URL for receiving updates.
-        timeout (int): Timeout for API requests in seconds (default 10).
-        show_progress (bool): Whether to show progress for long operations (default False).
-    Example:
-    ```python
-        import asyncio
-        from rubka.asynco import Robot,filters,Message
-        bot = Robot(token="YOUR_BOT_TOKEN")
-        @bot.on_message(filters.is_command.start)
-        async def start_command(bot: Robot, message: Message):
-            await message.reply("Hello!")
-        asyncio.run(bot.run())
-        
-    """
-
-    def __init__(self, token: str, session_name: str = None, auth: str = None, Key: str = None, platform: str = "web", web_hook: str = None, timeout: int = 10, show_progress: bool = False):
+Main asynchronous class to interact with the Rubika Bot API.
+
+This class handles sending and receiving messages, inline queries, callbacks,
+and manages sessions and API interactions. It is initialized with a bot token
+and provides multiple optional parameters for configuration.
+
+Attributes:
+    token (str): Bot token used for authentication with Rubika Bot API.
+    session_name (str | None): Optional session name for storing session data.
+    auth (str | None): Optional authentication string for advanced features related to account key.
+    Key (str | None): Optional account key for additional authorization if required.
+    platform (str): Platform type, default is 'web'.
+    web_hook (str | None): Optional webhook URL for receiving updates.
+    timeout (int): Timeout for API requests in seconds (default 10).
+    show_progress (bool): Whether to show progress for long operations (default False).
+    raise_errors (bool): Whether to raise exceptions on API errors (default True).
+    proxy (str | None): Optional proxy URL to route requests through.
+    retries (int): Number of times to retry a failed API request (default 2).
+    retry_delay (float): Delay between retries in seconds (default 0.5).
+    user_agent (str | None): Custom User-Agent header for requests.
+    safeSendMode (bool): If True, messages are sent safely. If reply fails using message_id, sends without message_id (default False).
+    max_cache_size (int): Maximum number of processed messages stored to prevent duplicates (default 1000).
+    max_msg_age (int): Maximum age of messages in seconds to consider for processing (default 20).
+
+Example:
+```python
+import asyncio
+from rubka.asynco import Robot, filters, Message
+
+bot = Robot(token="YOUR_BOT_TOKEN", safeSendMode=False, max_cache_size=1000)
+
+@bot.on_message(filters.is_command.start)
+async def start_command(bot: Robot, message: Message):
+    await message.reply("Hello!")
+
+asyncio.run(bot.run())
+```
+Notes:
+
+token is mandatory, all other parameters are optional.
+
+safeSendMode ensures reliable message sending even if replying by message_id fails.
+
+max_cache_size and max_msg_age help manage duplicate message processing efficiently.
+"""
+
+    def __init__(self, token: str, session_name: str = None, auth: str = None, Key: str = None, platform: str = "web", web_hook: str = None, timeout: int = 10, show_progress: bool = False, raise_errors: bool = True,proxy: str = None,retries: int = 2,retry_delay: float = 0.5,user_agent: str = None,safeSendMode = False,max_cache_size: int = 1000,max_msg_age : int = 60):
         self.token = token
         self._inline_query_handlers: List[dict] = []
         self.timeout = timeout
         self.auth = auth
+        self.safeSendMode = safeSendMode 
+        self.user_agent = user_agent
+        self.proxy = proxy
+        self.max_msg_age = max_msg_age
+        self.retries = retries
+        self.retry_delay = retry_delay
+        self.raise_errors = raise_errors
         self.show_progress = show_progress
         self.session_name = session_name
         self.Key = Key
@@ -139,20 +166,25 @@ class Robot:
         self._aiohttp_session: aiohttp.ClientSession = None
         self.sessions: Dict[str, Dict[str, Any]] = {}
         self._callback_handler = None
-        self._message_handler = None
-        self._inline_query_handler = None
+        self._processed_message_ids = OrderedDict()
+        self._max_cache_size = max_cache_size
+
+        self._connector = aiohttp.TCPConnector(limit=100, ssl=False)
         
         self._callback_handlers: List[dict] = []
         self._edited_message_handlers = []
-        self._processed_message_ids: Dict[str, float] = {}
         self._message_handlers: List[dict] = []
 
         logger.info(f"Initialized RubikaBot with token: {token[:8]}***")
     async def _get_session(self) -> aiohttp.ClientSession:
-        """Lazily creates and returns the aiohttp session."""
         if self._aiohttp_session is None or self._aiohttp_session.closed:
-            self._aiohttp_session = aiohttp.ClientSession(timeout=aiohttp.ClientTimeout(total=self.timeout))
+            connector = aiohttp.TCPConnector(limit=100, ssl=False)  # limit اتصالات همزمان
+            timeout = aiohttp.ClientTimeout(total=self.timeout)
+            self._aiohttp_session = aiohttp.ClientSession(connector=connector, timeout=timeout)
         return self._aiohttp_session
+    async def close(self):
+        if self._session and not self._session.closed:
+            await self._session.close()
         
     async def _initialize_webhook(self):
         """Initializes and sets the webhook endpoint if provided."""
@@ -183,22 +215,43 @@ class Robot:
     async def _post(self, method: str, data: Dict[str, Any]) -> Dict[str, Any]:
         url = f"{API_URL}/{self.token}/{method}"
         session = await self._get_session()
-        try:
-            async with session.post(url, json=data) as response:
-                response.raise_for_status()
-                try:
-                    json_resp = await response.json()
-                except aiohttp.ContentTypeError:
-                    text_resp = await response.text()
-                    logger.error(f"Invalid JSON response from {method}: {text_resp}")
-                    raise APIRequestError(f"Invalid JSON response: {text_resp}")
-                if method != "getUpdates":
-                    logger.debug(f"API Response from {method}: {json_resp}")
-                return AttrDict(json_resp)
-        except aiohttp.ClientError as e:
-            logger.error(f"API request failed: {e}")
-            raise APIRequestError(f"API request failed: {e}") from e
+        for attempt in range(1, self.retries + 1):
+            try:
+                headers = {}
+                if self.user_agent:headers["User-Agent"] = self.user_agent
+                async with session.post(url, json=data, proxy=self.proxy,headers=headers) as response:
+                    if response.status in (429, 500, 502, 503, 504):
+                        logger.warning(f"[{method}] Got status {response.status}, retry {attempt}/{self.retries}...")
+                        if attempt < self.retries:
+                            await asyncio.sleep(self.retry_delay)
+                            continue
+                        response.raise_for_status()
 
+                    response.raise_for_status()
+                    try:
+                        json_resp = await response.json(content_type=None)
+                    except Exception:
+                        text_resp = await response.text()
+                        logger.error(f"[{method}] Invalid JSON response: {text_resp}")
+                        raise APIRequestError(f"Invalid JSON response: {text_resp}")
+
+                    status = json_resp.get("status")
+                    if status in {"INVALID_ACCESS", "INVALID_INPUT", "TOO_REQUESTS"}:
+                        if self.raise_errors:
+                            raise_for_status(json_resp)
+                        return AttrDict(json_resp)
+                    return AttrDict({**json_resp, **data,"message_id":json_resp.get("data").get("message_id")})
+
+            except (aiohttp.ClientError, asyncio.TimeoutError) as e:
+                logger.warning(f"[{method}] Attempt {attempt}/{self.retries} failed: {e}")
+                if attempt < self.retries:
+                    await asyncio.sleep(self.retry_delay)
+                    continue
+                logger.error(f"[{method}] API request failed after {self.retries} retries: {e}")
+                raise APIRequestError(f"API request failed: {e}") from e
+    def _make_dup_key(self, message_id: str, update_type: str, msg_data: dict) -> str:
+        raw = f"{message_id}:{update_type}:{msg_data.get('text','')}:{msg_data.get('author_guid','')}"
+        return hashlib.sha1(raw.encode()).hexdigest()
     async def get_me(self) -> Dict[str, Any]:
         """Get info about the bot itself."""
         return await self._post("getMe", {})
@@ -504,25 +557,34 @@ class Robot:
             return wrapper
         return decorator
     def on_message(
-    self, 
-    filters: Optional[Callable[[Message], bool]] = None, 
-    commands: Optional[List[str]] = None
-    ):
-        def decorator(func: Callable[[Any, Message], None]):
-            async def wrapper(bot, message: Message):
-                if filters and not filters(message):return
-                if commands:
-                    if not message.is_command:return
-                    cmd = message.text.split()[0].lstrip("/")
-                    if cmd not in commands:return
-                return await func(bot, message)
-            self._message_handlers.append({
-                "func": wrapper,
-                "filters": filters,
-                "commands": commands
-            })
-            return wrapper
-        return decorator
+    self,
+    filters: Optional[Callable[[Message], bool]] = None,
+    commands: Optional[List[str]] = None):
+            def decorator(func: Callable[[Any, Message], None]):
+                async def wrapper(bot, message: Message):
+                    if filters and not filters(message):
+                        return
+                    if commands:
+                        if not message.is_command:
+                            return
+                        cmd = message.text.split()[0].lstrip("/")
+                        if cmd not in commands:
+                            return
+
+                    return await func(bot, message)
+                self._message_handlers.append({
+                    "func": wrapper,
+                    "filters": filters,
+                    "commands": commands
+                })
+                self._edited_message_handlers.append({
+                    "func": wrapper,
+                    "filters": filters,
+                    "commands": commands
+                })
+
+                return wrapper
+            return decorator
 
     
     def on_message_file(self, filters: Optional[Callable[[Message], bool]] = None, commands: Optional[List[str]] = None):
@@ -837,14 +899,17 @@ class Robot:
             response.raise_for_status() 
             return await response.json()
 
-    def _is_duplicate(self, message_id: str, max_age_sec: int = 300) -> bool:
+    def _is_duplicate(self, key: str, max_age_sec: int = 300) -> bool:
         now = time.time()
         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
-        self._processed_message_ids[message_id] = now
+        for mid in expired:
+            del self._processed_message_ids[mid]
+        if key in self._processed_message_ids:
+            return True
+        self._processed_message_ids[key] = now
+        if len(self._processed_message_ids) > self._max_cache_size:
+            self._processed_message_ids.popitem(last=False)
         return False
-    
 
     async def run(
     self,
@@ -1282,24 +1347,36 @@ class Robot:
                             for update in updates:
                                 message_id = None
                                 if update.get("type") == "NewMessage":
-                                    message_id = update.get("new_message", {}).get("message_id")
+                                    msg_data = update.get("new_message", {})
+                                    message_id = msg_data.get("message_id")
+                                    text_content = msg_data.get("text", "")
+                                    msg_time = int(msg_data.get("time", 0))
                                 elif update.get("type") == "ReceiveQuery":
-                                    message_id = update.get("inline_message", {}).get("message_id")
+                                    msg_data = update.get("inline_message", {})
+                                    message_id = msg_data.get("message_id")
+                                    text_content = msg_data.get("text", "")
+                                    msg_time = int(msg_data.get("time", 0))
                                 elif update.get("type") == "UpdatedMessage":
-                                    message_id = update.get("updated_message", {}).get("message_id")
+                                    msg_data = update.get("updated_message", {})
+                                    message_id = msg_data.get("message_id")
+                                    text_content = msg_data.get("text", "")
+                                    msg_time = int(msg_data.get("time", 0))
                                 elif "message_id" in update:
                                     message_id = update.get("message_id")
-
+                                now = int(time.time())
+                                if msg_time and (now - msg_time > self.max_msg_age):
+                                    continue
                                 dup_ok = True
-                                if ignore_duplicate_messages:
-                                    dup_ok = (not self._is_duplicate(str(message_id))) if message_id else True
+                                if ignore_duplicate_messages and message_id:
+                                    dup_key = self._make_dup_key(message_id, update.get("type", ""), msg_data)
+                                    dup_ok = not self._is_duplicate(dup_key)
                                 if message_id and dup_ok:
                                     received_updates.append(update)
 
                     
                     if not received_updates:
                         if pause_on_idle and sleep_time == 0:
-                            await asyncio.sleep(0.05)
+                            await asyncio.sleep(0.005)
                         else:
                             await asyncio.sleep(sleep_time)
                         if not loop_forever and max_runtime is None:
@@ -1430,7 +1507,7 @@ class Robot:
     disable_notification: bool = False,
     reply_to_message_id: Optional[str] = None,
     chat_keypad_type: Optional[Literal["New", "Removed"]] = None
-    ) -> Dict[str, Any]:
+) -> Dict[str, Any]:
         payload = {
             "chat_id": chat_id,
             "text": text,
@@ -1443,9 +1520,15 @@ class Robot:
             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)
+        if self.safeSendMode and reply_to_message_id:
+            try:
+                return await self._post("sendMessage", payload)
+            except Exception:
+                payload.pop("reply_to_message_id", None)
+                return await self._post("sendMessage", payload)
+        else:
+            return await self._post("sendMessage", payload)
     
-    from typing import Optional, Dict, Any, Literal
 
     async def send_sticker(
         self,
@@ -1494,22 +1577,6 @@ class Robot:
             return Client_get(self.session_name, self.auth, self.Key, self.platform)
         else:
             return Client_get(show_last_six_words(self.token), self.auth, self.Key, self.platform)
-            
-    async def check_join(self, channel_guid: str, chat_id: str = None) -> Union[bool, list[str]]:
-        client = self._get_client()
-        if chat_id:
-            chat_info_data = await self.get_chat(chat_id)
-            chat_info = chat_info_data.get('data', {}).get('chat', {})
-            username = chat_info.get('username')
-            user_id = chat_info.get('user_id')
-            if username:
-                result = await asyncio.to_thread(self.get_all_member, channel_guid, search_text=username)
-                members = result.get('in_chat_members', [])
-                return any(m.get('username') == username for m in members)
-            elif user_id:
-                member_guids = await asyncio.to_thread(client.get_all_members, channel_guid, just_get_guids=True)
-                return user_id in member_guids
-        return False
     async def send_button_join(
     self, 
     chat_id, 
@@ -1595,21 +1662,15 @@ class Robot:
             inline_keypad=builder.build(),
             reply_to_message_id=reply_to_message_id
         )
-    def get_all_member(self, channel_guid: str, search_text: str = None, start_id: str = None, just_get_guids: bool = False):
-        client = self._get_client()
-        return client.get_all_members(channel_guid, search_text, start_id, just_get_guids)
-    async def send_poll(self, chat_id: str, question: str, options: List[str]) -> Dict[str, Any]:
-        return await self._post("sendPoll", {"chat_id": chat_id, "question": question, "options": options})
+
+    async def close_poll(self, chat_id: str, message_id: str) -> Dict[str, Any]:
+        return await self._post("closePoll", {"chat_id": chat_id, "message_id": message_id})
     async def send_location(self, chat_id: str, latitude: str, longitude: str, disable_notification: bool = False, inline_keypad: Optional[Dict[str, Any]] = None, reply_to_message_id: Optional[str] = None, chat_keypad_type: Optional[Literal["New", "Removed"]] = None) -> Dict[str, Any]:
         payload = {"chat_id": chat_id, "latitude": latitude, "longitude": longitude, "disable_notification": disable_notification}
         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
         return await self._post("sendLocation", {k: v for k, v in payload.items() if v is not None})
-    async def send_contact(self, chat_id: str, first_name: str, last_name: str, phone_number: str) -> Dict[str, Any]:
-        return await self._post("sendContact", {"chat_id": chat_id, "first_name": first_name, "last_name": last_name, "phone_number": phone_number})
-    async def get_chat(self, chat_id: str) -> Dict[str, Any]:
-        return await self._post("getChat", {"chat_id": chat_id})
     async def upload_media_file(self, upload_url: str, name: str, path: Union[str, Path]) -> str:
         is_temp_file = False
         session = await self._get_session()
@@ -1725,14 +1786,12 @@ class Robot:
             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:
             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", "Removed", "None"]] = "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
@@ -1757,7 +1816,6 @@ class Robot:
             "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):
         if path:
             file_name = file_name or Path(path).name
@@ -1766,14 +1824,12 @@ class Robot:
         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)
-
     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_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,
@@ -1819,12 +1875,6 @@ class Robot:
             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"]] = "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"]] = "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"]] = "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,
@@ -1870,23 +1920,33 @@ class Robot:
             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]:
-        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) -> Dict[str, Any]:
-        return await self._post("editMessageText", {"chat_id": chat_id, "message_id": message_id, "text": text})
-    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})
-        return await self._post("editMessageKeypad", {"chat_id": chat_id,"message_id": message_id,"inline_keypad": inline_keypad})
-    async def delete_message(self, chat_id: str, message_id: str) -> Dict[str, Any]:
-        return await self._post("deleteMessage", {"chat_id": chat_id, "message_id": message_id})
-    async def set_commands(self, bot_commands: List[Dict[str, str]]) -> Dict[str, Any]:
-        return await self._post("setCommands", {"bot_commands": bot_commands})
-    async def update_bot_endpoint(self, url: str, type: str) -> Dict[str, Any]:
-        return await self._post("updateBotEndpoints", {"url": url, "type": type})
-    async def remove_keypad(self, chat_id: str) -> Dict[str, Any]:
-        return await self._post("editChatKeypad", {"chat_id": chat_id, "chat_keypad_type": "Removed"})
-    async def edit_chat_keypad(self, chat_id: str, chat_keypad: Dict[str, Any]) -> Dict[str, Any]:
-        return await self._post("editChatKeypad", {"chat_id": chat_id, "chat_keypad_type": "New", "chat_keypad": chat_keypad})
+    async def get_avatar_me(
+    self,
+    save_as: str = None) -> str:
+        """
+        Get the bot's profile photo URL and optionally save it locally.
+        Args:
+            save_as (str, optional): File name to save the avatar locally.
+        Returns:
+            str: Download URL of the bot's avatar, or "null" if not available.
+        """
+        try:
+            me_info = await self.get_me()
+            avatar = me_info.get('data', {}).get('bot', {}).get('avatar', {})
+            file_id = avatar.get('file_id')
+            if not file_id:
+                return None
+            url = await self.get_url_file(file_id)
+            if save_as:
+                async with aiohttp.ClientSession() as session:
+                    async with session.get(url) as resp:
+                        if resp.status == 200:
+                            content = await resp.read()
+                            with open(save_as, "wb") as f:
+                                f.write(content)
+            return url
+        except Exception:
+            return None
     async def get_name(self, chat_id: str) -> str:
         try:
             chat = await self.get_chat(chat_id)
@@ -1904,4 +1964,99 @@ class Robot:
         except Exception:return "null"
     async def get_username(self, chat_id: str) -> str:
         chat_info = await self.get_chat(chat_id)
-        return chat_info.get("data", {}).get("chat", {}).get("username", "None")
+        return chat_info.get("data", {}).get("chat", {}).get("username", "None")
+    async def get_chat_admins(self, chat_id: str) -> Dict[str, Any]:
+        return await self._post("getChatAdmins", {"chat_id": chat_id})
+    async def get_chat_members(self, chat_id: str, start_id: str = "") -> Dict[str, Any]:
+        return await self._post("getChatMembers", {"chat_id": chat_id, "start_id": start_id})
+    async def get_chat_info(self, chat_id: str) -> Dict[str, Any]:
+        return await self._post("getChatInfo", {"chat_id": chat_id})
+    async def set_chat_title(self, chat_id: str, title: str) -> Dict[str, Any]:
+        return await self._post("editChatTitle", {"chat_id": chat_id, "title": title})
+    async def set_chat_description(self, chat_id: str, description: str) -> Dict[str, Any]:
+        return await self._post("editChatDescription", {"chat_id": chat_id, "description": description})
+    async def set_chat_photo(self, chat_id: str, file_id: str) -> Dict[str, Any]:
+        return await self._post("editChatPhoto", {"chat_id": chat_id, "file_id": file_id})
+    async def remove_chat_photo(self, chat_id: str) -> Dict[str, Any]:
+        return await self._post("editChatPhoto", {"chat_id": chat_id, "file_id": "Removed"})
+    async def add_member_chat(self, chat_id: str, user_ids: list[str]) -> Dict[str, Any]:
+        return await self._post("addChatMembers", {"chat_id": chat_id, "member_ids": user_ids})
+    async def ban_member_chat(self, chat_id: str, user_id: str) -> Dict[str, Any]:
+        return await self._post("banChatMember", {"chat_id": chat_id, "member_id": user_id})
+    async def unban_chat_member(self, chat_id: str, user_id: str) -> Dict[str, Any]:
+        return await self._post("unbanChatMember", {"chat_id": chat_id, "member_id": user_id})
+    async def restrict_chat_member(self, chat_id: str, user_id: str, until: int = 0) -> Dict[str, Any]:
+        return await self._post("restrictChatMember", {"chat_id": chat_id, "member_id": user_id, "until_date": until})
+    async def get_chat_member(self, chat_id: str, user_id: str):
+        return await self._post("getChatMember", {"chat_id": chat_id, "user_id": user_id})
+    async def get_admin_chat(self, chat_id: str):
+        return await self._post("getChatAdministrators", {"chat_id": chat_id})
+    async def get_chat_member_count(self, chat_id: str):
+        return await self._post("getChatMemberCount", {"chat_id": chat_id})
+    async def ban_chat_member(self, chat_id: str, user_id: str):
+        return await self._post("banChatMember", {"chat_id": chat_id, "user_id": user_id})
+    async def promote_chat_member(self, chat_id: str, user_id: str, rights: dict) -> Dict[str, Any]:
+        return await self._post("promoteChatMember", {"chat_id": chat_id, "member_id": user_id, "rights": rights})
+    async def demote_chat_member(self, chat_id: str, user_id: str) -> Dict[str, Any]:
+        return await self._post("promoteChatMember", {"chat_id": chat_id, "member_id": user_id, "rights": {}})
+    async def pin_chat_message(self, chat_id: str, message_id: str) -> Dict[str, Any]:
+        return await self._post("pinChatMessage", {"chat_id": chat_id, "message_id": message_id})
+    async def unpin_chat_message(self, chat_id: str, message_id: str = "") -> Dict[str, Any]:
+        return await self._post("unpinChatMessage", {"chat_id": chat_id, "message_id": message_id})
+    async def export_chat_invite_link(self, chat_id: str) -> Dict[str, Any]:
+        return await self._post("exportChatInviteLink", {"chat_id": chat_id})
+    async def revoke_chat_invite_link(self, chat_id: str, link: str) -> Dict[str, Any]:
+        return await self._post("revokeChatInviteLink", {"chat_id": chat_id, "invite_link": link})
+    async def create_group(self, title: str, user_ids: list[str]) -> Dict[str, Any]:
+        return await self._post("createGroup", {"title": title, "user_ids": user_ids})
+    async def create_channel(self, title: str, description: str = "") -> Dict[str, Any]:
+        return await self._post("createChannel", {"title": title, "description": description})
+    async def leave_chat(self, chat_id: str) -> Dict[str, Any]:
+        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) -> Dict[str, Any]:
+        return await self._post("editMessageText", {"chat_id": chat_id, "message_id": message_id, "text": text})
+    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})
+        return await self._post("editMessageKeypad", {"chat_id": chat_id,"message_id": message_id,"inline_keypad": inline_keypad})
+    async def delete_message(self, chat_id: str, message_id: str) -> Dict[str, Any]:
+        return await self._post("deleteMessage", {"chat_id": chat_id, "message_id": message_id})
+    async def set_commands(self, bot_commands: List[Dict[str, str]]) -> Dict[str, Any]:
+        return await self._post("setCommands", {"bot_commands": bot_commands})
+    async def update_bot_endpoint(self, url: str, type: str) -> Dict[str, Any]:
+        return await self._post("updateBotEndpoints", {"url": url, "type": type})
+    async def remove_keypad(self, chat_id: str) -> Dict[str, Any]:
+        return await self._post("editChatKeypad", {"chat_id": chat_id, "chat_keypad_type": "Removed"})
+    async def edit_chat_keypad(self, chat_id: str, chat_keypad: Dict[str, Any]) -> Dict[str, Any]:
+        return await self._post("editChatKeypad", {"chat_id": chat_id, "chat_keypad_type": "New", "chat_keypad": chat_keypad})
+    async def send_contact(self, chat_id: str, first_name: str, last_name: str, phone_number: str) -> Dict[str, Any]:
+        return await self._post("sendContact", {"chat_id": chat_id, "first_name": first_name, "last_name": last_name, "phone_number": phone_number})
+    async def get_chat(self, chat_id: str) -> Dict[str, Any]:
+        return await self._post("getChat", {"chat_id": chat_id})
+    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"]] = "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"]] = "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)
+    def get_all_member(self, channel_guid: str, search_text: str = None, start_id: str = None, just_get_guids: bool = False):
+        client = self._get_client()
+        return client.get_all_members(channel_guid, search_text, start_id, just_get_guids)
+    async def send_poll(self, chat_id: str, question: str, options: List[str]) -> Dict[str, Any]:
+        return await self._post("sendPoll", {"chat_id": chat_id, "question": question, "options": options})
+    async def check_join(self, channel_guid: str, chat_id: str = None) -> Union[bool, list[str]]:
+        client = self._get_client()
+        if chat_id:
+            chat_info_data = await self.get_chat(chat_id)
+            chat_info = chat_info_data.get('data', {}).get('chat', {})
+            username = chat_info.get('username')
+            user_id = chat_info.get('user_id')
+            if username:
+                result = await asyncio.to_thread(self.get_all_member, channel_guid, search_text=username)
+                members = result.get('in_chat_members', [])
+                return any(m.get('username') == username for m in members)
+            elif user_id:
+                member_guids = await asyncio.to_thread(client.get_all_members, channel_guid, just_get_guids=True)
+                return user_id in member_guids
+        return False

rubka/context.py

@@ -508,20 +508,14 @@ class InlineMessage:
         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.is_reply = self.reply_to_message_id is not None
-        self.has_media = any([self.file, self.sticker, self.poll, self.location, self.live_location])
+        self.has_media = any([self.file, self.sticker])
         self.is_forwarded = self.forwarded_from is not None
         self.is_text = bool(self.text and not self.has_media)
         self.is_media = self.has_media
-        self.is_poll = self.poll is not None
-        self.is_location = self.location is not None
-        self.is_live_location = self.live_location is not None
         self.is_contact = self.contact_message is not None
-        self.has_any_media = any([self.file, self.sticker, self.poll, self.location, self.live_location])
+        self.has_any_media = any([self.file, self.sticker,])
         self.edited_text = self.raw_data.get("edited_text") if self.is_edited else None
         if self.file and self.file.file_name:
             name = self.file.file_name.lower()
@@ -535,10 +529,15 @@ class InlineMessage:
             self.is_font = name.endswith((".ttf", ".otf", ".woff", ".woff2"))
         
 
+    @property
+    def session(self):
+        if self.chat_id not in self.bot.sessions:
+            self.bot.sessions[self.chat_id] = {}
+        return self.bot.sessions[self.chat_id]
     def reply(self, text: str, **kwargs):
         return self.bot.send_message(
-            chat_id=self.chat_id,
-            text=text,
+            self.chat_id,
+            text,
             reply_to_message_id=self.message_id,
             **kwargs
         )
@@ -550,14 +549,212 @@ class InlineMessage:
             **kwargs
         )
 
-    def edit(self, new_text: str):
+    def reply_poll(self, question: str, options: List[str], **kwargs) -> Dict[str, Any]:
+        return self.bot._post("sendPoll", {
+            "chat_id": self.chat_id,
+            "question": question,
+            "options": options,
+            "reply_to_message_id": self.message_id,
+            **kwargs
+        })
+    
+
+    def reply_document(
+        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,
+            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,
+            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_image(
+        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_image(
+            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_music(
+        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_music(
+            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_voice(
+        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_voice(
+            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_gif(
+        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_gif(
+            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_location(self, latitude: str, longitude: str, **kwargs) -> Dict[str, Any]:
+        return self.bot.send_location(
+            chat_id=self.chat_id,
+            latitude=latitude,
+            longitude=longitude,
+            reply_to_message_id=self.message_id,
+            **kwargs
+        )
+
+    def reply_contact(self, first_name: str, last_name: str, phone_number: str, **kwargs) -> Dict[str, Any]:
+        return self.bot.send_contact(
+            chat_id=self.chat_id,
+            first_name=first_name,
+            last_name=last_name,
+            phone_number=phone_number,
+            reply_to_message_id=self.message_id,
+            **kwargs
+        )
+
+    def reply_keypad(self, text: str, keypad: Dict[str, Any], **kwargs) -> Dict[str, Any]:
+        return self.bot.send_message(
+            chat_id=self.chat_id,
+            text=text,
+            chat_keypad_type="New",
+            chat_keypad=keypad,
+            reply_to_message_id=self.message_id,
+            **kwargs
+        )
+
+    def reply_inline(self, text: str, inline_keypad: Dict[str, Any], **kwargs) -> Dict[str, Any]:
+        return self.bot.send_message(
+            chat_id=self.chat_id,
+            text=text,
+            inline_keypad=inline_keypad,
+            reply_to_message_id=self.message_id,
+            **kwargs
+        )
+
+    def reply_sticker(self, sticker_id: str, **kwargs) -> Dict[str, Any]:
+        return self.bot._post("sendSticker", {
+            "chat_id": self.chat_id,
+            "sticker_id": sticker_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,
             message_id=self.message_id,
             text=new_text
         )
 
-    def delete(self):
+    def delete(self) -> Dict[str, Any]:
         return self.bot.delete_message(
             chat_id=self.chat_id,
             message_id=self.message_id

rubka/exceptions.py

@@ -1,3 +1,37 @@
 class APIRequestError(Exception):
-    """Raised when an API request fails."""
+    """Base class for all API request errors."""
+    def __init__(self, status: str, dev_message: str = None):
+        self.status = status
+        self.dev_message = dev_message
+        msg = f"{self.__class__.__name__}: {status}"
+        if dev_message:
+            msg += f" | Message : {dev_message}"
+        super().__init__(msg)
+
+
+class InvalidAccessError(APIRequestError):
+    """Raised when access is invalid."""
+
+class InvalidTokenError(Exception):
     pass
+
+class InvalidInputError(APIRequestError):
+    """Raised when input is invalid."""
+
+
+class TooRequestError(APIRequestError):
+    """Raised when too many requests are made."""
+
+
+def raise_for_status(response: dict):
+    status = response.get("status")
+    dev_message = response.get("dev_message")
+
+    if status == "INVALID_ACCESS":
+        raise InvalidAccessError(status, dev_message)
+    elif status == "INVALID_INPUT":
+        raise InvalidInputError(status, dev_message)
+    elif status == "TOO_REQUEST":
+        raise TooRequestError(status, dev_message)
+    elif status != "OK":
+        raise APIRequestError(status, dev_message)

rubka/update.py

@@ -508,20 +508,14 @@ class InlineMessage:
         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.is_reply = self.reply_to_message_id is not None
-        self.has_media = any([self.file, self.sticker, self.poll, self.location, self.live_location])
+        self.has_media = any([self.file, self.sticker])
         self.is_forwarded = self.forwarded_from is not None
         self.is_text = bool(self.text and not self.has_media)
         self.is_media = self.has_media
-        self.is_poll = self.poll is not None
-        self.is_location = self.location is not None
-        self.is_live_location = self.live_location is not None
         self.is_contact = self.contact_message is not None
-        self.has_any_media = any([self.file, self.sticker, self.poll, self.location, self.live_location])
+        self.has_any_media = any([self.file, self.sticker,])
         self.edited_text = self.raw_data.get("edited_text") if self.is_edited else None
         if self.file and self.file.file_name:
             name = self.file.file_name.lower()
@@ -535,10 +529,15 @@ class InlineMessage:
             self.is_font = name.endswith((".ttf", ".otf", ".woff", ".woff2"))
         
 
+    @property
+    def session(self):
+        if self.chat_id not in self.bot.sessions:
+            self.bot.sessions[self.chat_id] = {}
+        return self.bot.sessions[self.chat_id]
     def reply(self, text: str, **kwargs):
         return self.bot.send_message(
-            chat_id=self.chat_id,
-            text=text,
+            self.chat_id,
+            text,
             reply_to_message_id=self.message_id,
             **kwargs
         )
@@ -550,14 +549,212 @@ class InlineMessage:
             **kwargs
         )
 
-    def edit(self, new_text: str):
+    def reply_poll(self, question: str, options: List[str], **kwargs) -> Dict[str, Any]:
+        return self.bot._post("sendPoll", {
+            "chat_id": self.chat_id,
+            "question": question,
+            "options": options,
+            "reply_to_message_id": self.message_id,
+            **kwargs
+        })
+    
+
+    def reply_document(
+        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,
+            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,
+            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_image(
+        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_image(
+            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_music(
+        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_music(
+            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_voice(
+        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_voice(
+            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_gif(
+        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_gif(
+            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_location(self, latitude: str, longitude: str, **kwargs) -> Dict[str, Any]:
+        return self.bot.send_location(
+            chat_id=self.chat_id,
+            latitude=latitude,
+            longitude=longitude,
+            reply_to_message_id=self.message_id,
+            **kwargs
+        )
+
+    def reply_contact(self, first_name: str, last_name: str, phone_number: str, **kwargs) -> Dict[str, Any]:
+        return self.bot.send_contact(
+            chat_id=self.chat_id,
+            first_name=first_name,
+            last_name=last_name,
+            phone_number=phone_number,
+            reply_to_message_id=self.message_id,
+            **kwargs
+        )
+
+    def reply_keypad(self, text: str, keypad: Dict[str, Any], **kwargs) -> Dict[str, Any]:
+        return self.bot.send_message(
+            chat_id=self.chat_id,
+            text=text,
+            chat_keypad_type="New",
+            chat_keypad=keypad,
+            reply_to_message_id=self.message_id,
+            **kwargs
+        )
+
+    def reply_inline(self, text: str, inline_keypad: Dict[str, Any], **kwargs) -> Dict[str, Any]:
+        return self.bot.send_message(
+            chat_id=self.chat_id,
+            text=text,
+            inline_keypad=inline_keypad,
+            reply_to_message_id=self.message_id,
+            **kwargs
+        )
+
+    def reply_sticker(self, sticker_id: str, **kwargs) -> Dict[str, Any]:
+        return self.bot._post("sendSticker", {
+            "chat_id": self.chat_id,
+            "sticker_id": sticker_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,
             message_id=self.message_id,
             text=new_text
         )
 
-    def delete(self):
+    def delete(self) -> Dict[str, Any]:
         return self.bot.delete_message(
             chat_id=self.chat_id,
             message_id=self.message_id

{rubka-6.6.13.dist-info → rubka-6.7.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Rubka
-Version: 6.6.13
+Version: 6.7.1
 Summary: rubika 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/archive/refs/tags/v6.6.4.zip

{rubka-6.6.13.dist-info → rubka-6.7.1.dist-info}/RECORD

@@ -1,11 +1,11 @@
 rubka/__init__.py,sha256=P6IBiORfp-GqKHe5LZ-5lldWyG7tnrUYUcAQDUgwXmY,1973
 rubka/api.py,sha256=1S8JIcYN_Zxb7JT73eQl9me-qDDDTDzcSk6_qawAfkA,68861
-rubka/asynco.py,sha256=9GdEzmOk9_n5MV7FxEJ4fWdZtuedPAsqJUj2Upnm9Gc,90044
+rubka/asynco.py,sha256=QRieOUl4w81zP-a2FtbLmI9DuExy9d6m1jDR4RUhuo4,100228
 rubka/button.py,sha256=vU9OvWXCD4MRrTJ8Xmivd4L471-06zrD2qpZBTw5vjY,13305
 rubka/config.py,sha256=Bck59xkOiqioLv0GkQ1qPGnBXVctz1hKk6LT4h2EPx0,78
-rubka/context.py,sha256=OcYY0G0IFQa29zpw6YRm873RwJOf568qxJplm1UdeAM,23936
+rubka/context.py,sha256=kYLsGq4cQhmMX16WrzH_kxYzGGyvulZyxazoN_5tul4,30768
 rubka/decorators.py,sha256=hGwUoE4q2ImrunJIGJ_kzGYYxQf1ueE0isadqraKEts,1157
-rubka/exceptions.py,sha256=tujZt1XrhWaw-lmdeVadVceUptpw4XzNgE44sAAY0gs,90
+rubka/exceptions.py,sha256=DDOGIHEMoliHNW5E7C_s38WZgqqMBv9812fcJGvj7TY,1173
 rubka/filters.py,sha256=DY1bdkpRKIiLtVcy6X3hOnlGPcVOK4HFb3QgmaPx6Oo,12116
 rubka/helpers.py,sha256=QvK5lg4QDmycImxJia4m8HDpfacYzbKKZiOk536mafc,65161
 rubka/jobs.py,sha256=GvLMLsVhcSEzRTgkvnPISPEBN71suW2xXI0hUaUZPTo,378
@@ -14,7 +14,7 @@ rubka/keypad.py,sha256=yGsNt8W5HtUFBzVF1m_p7GySlu1hwIcSvXZ4BTdrlvg,9558
 rubka/logger.py,sha256=J2I6NiK1z32lrAzC4H1Et6WPMBXxXGCVUsW4jgcAofs,289
 rubka/rubino.py,sha256=GuXnEUTTSZUw68FMTQBYsB2zG_3rzdDa-krsrl4ib8w,58755
 rubka/tv.py,sha256=o7CW-6EKLhmM--rzcHcKPcXfzOixcL_B4j037R3mHts,5399
-rubka/update.py,sha256=OcYY0G0IFQa29zpw6YRm873RwJOf568qxJplm1UdeAM,23936
+rubka/update.py,sha256=kYLsGq4cQhmMX16WrzH_kxYzGGyvulZyxazoN_5tul4,30768
 rubka/utils.py,sha256=XUQUZxQt9J2f0X5hmAH_MH1kibTAfdT1T4AaBkBhBBs,148
 rubka/adaptorrubka/__init__.py,sha256=6o2tCXnVeES7nx-LjnzsuMqjKcWIm9qwKficLE54s-U,83
 rubka/adaptorrubka/enums.py,sha256=cyiakExmZi-QQpYuf_A93HQvfZVmyG_0uVuvTTNT5To,1053
@@ -37,8 +37,8 @@ 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-6.6.13.dist-info/METADATA,sha256=-UinFermTRpXMLTPl4D6Whjgun6xhXdsrfqqoobw-gY,34270
-rubka-6.6.13.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-rubka-6.6.13.dist-info/entry_points.txt,sha256=4aESuUmuUOALMUy7Kucv_Gb5YlqhsJmTmdXLlZU9sJ0,46
-rubka-6.6.13.dist-info/top_level.txt,sha256=vy2A4lot11cRMdQS-F4HDCIXL3JK8RKfu7HMDkezJW4,6
-rubka-6.6.13.dist-info/RECORD,,
+rubka-6.7.1.dist-info/METADATA,sha256=EWh4ebJjsnf3NgzY03qEjhZbuQhQ54GfljbLr7WNTnM,34269
+rubka-6.7.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+rubka-6.7.1.dist-info/entry_points.txt,sha256=4aESuUmuUOALMUy7Kucv_Gb5YlqhsJmTmdXLlZU9sJ0,46
+rubka-6.7.1.dist-info/top_level.txt,sha256=vy2A4lot11cRMdQS-F4HDCIXL3JK8RKfu7HMDkezJW4,6
+rubka-6.7.1.dist-info/RECORD,,