Rubka 7.1.3__tar.gz → 7.1.5__tar.gz

{rubka-7.1.3 → rubka-7.1.5}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: Rubka
-Version: 7.1.3
-Summary: rubika A Python library for interacting with Rubika Bot API.
+Version: 7.1.5
+Summary: Rubika: A Python library for interacting with the Rubika Bot API. This library provides an easy-to-use interface to send messages, polls, stickers, media files, manage groups and channels, handle inline keyboards, and implement advanced bot features like subscription management, user authentication, and message handling. Ideal for developers looking to automate and extend their Rubika bots with Python.
 Home-page: https://github.com/Mahdy-Ahmadi/Rubka
 Download-URL: https://github.com/Mahdy-Ahmadi/rubka/archive/refs/tags/v6.6.4.zip
 Author: Mahdi Ahmadi
@@ -12,7 +12,7 @@ License: MIT
 Project-URL: Bug Tracker, https://t.me/Bprogrammer
 Project-URL: Documentation, https://github.com/Mahdy-Ahmadi/rubka/blob/main/README.md
 Project-URL: Source Code, https://github.com/Mahdy-Ahmadi/Rubka
-Keywords: rubika bot api library chat messaging rubpy pyrubi rubigram
+Keywords: rubika bot api library chat messaging rubpy pyrubi rubigram rubika_bot rubika_api fast_rub
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
 Classifier: Programming Language :: Python :: 3

{rubka-7.1.3 → rubka-7.1.5}/Rubka.egg-info/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: Rubka
-Version: 7.1.3
-Summary: rubika A Python library for interacting with Rubika Bot API.
+Version: 7.1.5
+Summary: Rubika: A Python library for interacting with the Rubika Bot API. This library provides an easy-to-use interface to send messages, polls, stickers, media files, manage groups and channels, handle inline keyboards, and implement advanced bot features like subscription management, user authentication, and message handling. Ideal for developers looking to automate and extend their Rubika bots with Python.
 Home-page: https://github.com/Mahdy-Ahmadi/Rubka
 Download-URL: https://github.com/Mahdy-Ahmadi/rubka/archive/refs/tags/v6.6.4.zip
 Author: Mahdi Ahmadi
@@ -12,7 +12,7 @@ License: MIT
 Project-URL: Bug Tracker, https://t.me/Bprogrammer
 Project-URL: Documentation, https://github.com/Mahdy-Ahmadi/rubka/blob/main/README.md
 Project-URL: Source Code, https://github.com/Mahdy-Ahmadi/Rubka
-Keywords: rubika bot api library chat messaging rubpy pyrubi rubigram
+Keywords: rubika bot api library chat messaging rubpy pyrubi rubigram rubika_bot rubika_api fast_rub
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
 Classifier: Programming Language :: Python :: 3

{rubka-7.1.3 → rubka-7.1.5}/rubka/api.py

@@ -61,13 +61,7 @@ def check_rubka_version():
     latest_version = get_latest_version(package_name)
     if latest_version is None:return
     if installed_version != latest_version:
-        print(f"\n\nWARNING: Your installed version of '{package_name}' is OUTDATED and may cause errors or security risks!")
-        print(f"Installed version : {installed_version}")
-        print(f"Latest available version : {latest_version}")
-        print(f"Please update IMMEDIATELY by running:")
         print(f"\npip install {package_name}=={latest_version}\n")
-        print(f"Not updating may lead to malfunctions or incompatibility.")
-        print(f"To see new methods : @rubka_library\n\n")
 
 check_rubka_version()
 def show_last_six_words(text):

{rubka-7.1.3 → rubka-7.1.5}/rubka/asynco.py

@@ -72,14 +72,16 @@ async def check_rubka_version():
         return
     
     if installed_version != latest_version:
-        print(f"\n\nWARNING: Your installed version of '{package_name}' is OUTDATED and may cause errors or security risks!")
-        print(f"Installed version : {installed_version}")
-        print(f"Latest available version : {latest_version}")
-        print(f"Please update IMMEDIATELY by running:")
-        print(f"\npip install {package_name}=={latest_version}\n")
-        print("Not updating may lead to malfunctions or incompatibility.")
-        print("To see new methods : @rubka_library\n\n")
-
+        print(f"CRITICAL WARNING: Your installed version of '{package_name}' is outdated.")
+        print("This poses a serious risk to stability, security, and compatibility with current features.")
+        print(f"- Installed version : {installed_version}")
+        print(f"- Latest version    : {latest_version}")
+        print("\nImmediate action is required.")
+        print(f"Run the following command to update safely:")
+        print(f"\n    pip install {package_name}=={latest_version}\n")
+        print("Delaying this update may result in unexpected crashes, data loss, or broken functionality.")
+        print("Stay up-to-date to ensure full support and access to the latest improvements.")
+        print("For new methods and updates, visit: @rubka_library\n")
 
 
 
@@ -141,11 +143,12 @@ safeSendMode ensures reliable message sending even if replying by message_id fai
 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 = 2000,max_msg_age : int = 60):
+    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 = 2000,max_msg_age : int = 60,chunk_size : int = 64 * 1024):
         self.token = token
         self._inline_query_handlers: List[dict] = []
         self.timeout = timeout
         self.auth = auth
+        self.chunk_size = chunk_size
         self.safeSendMode = safeSendMode 
         self.user_agent = user_agent
         self.proxy = proxy
@@ -194,9 +197,8 @@ max_cache_size and max_msg_age help manage duplicate message processing efficien
             async with session.get(self.web_hook, timeout=self.timeout) as response:
                 response.raise_for_status()
                 data = await response.json()
-                print(data)
+                if data:print(f"[INFO] Retrieving WebHook URL information...")
                 json_url = data.get('url', self.web_hook)
-                print(self.web_hook)
             for endpoint_type in [
                     "ReceiveUpdate",
                     "ReceiveInlineMessage",
@@ -205,7 +207,8 @@ max_cache_size and max_msg_age help manage duplicate message processing efficien
                     "SearchSelectionItems"
                 ]:
                 result = await self.update_bot_endpoint(self.web_hook, endpoint_type)
-                print(result)
+                if result['status'] =="OK":print(f"✔ Set endpoint type to '{endpoint_type}' — Operation succeeded with status: {result['status']}")
+                else:print(f"[ERROR] Failed to set endpoint type '{endpoint_type}': Status code {result['status']}")
             self.web_hook = json_url
         except Exception as e:
             logger.error(f"Failed to set webhook from {self.web_hook}: {e}")
@@ -1693,7 +1696,7 @@ max_cache_size and max_msg_age help manage duplicate message processing efficien
     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,
+    chat_keypad_type: Optional[Literal["New", "Remove"]] = None,
     delete_after : int = None
 ) -> Dict[str, Any]:
         payload = {
@@ -1857,48 +1860,52 @@ max_cache_size and max_msg_age help manage duplicate message processing efficien
 
     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]:
+    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", "Remove"]] = 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 upload_media_file(self, upload_url: str, name: str, path: Union[str, Path]) -> str:
-        is_temp_file = False
         session = await self._get_session()
+        is_temp_file = False
         if isinstance(path, str) and path.startswith("http"):
             async with session.get(path) as response:
                 if response.status != 200:
                     raise Exception(f"Failed to download file from URL ({response.status})")
                 content = await response.read()
-                with tempfile.NamedTemporaryFile(delete=False) as temp_file:
-                    temp_file.write(content)
-                    path = temp_file.name
+                with tempfile.NamedTemporaryFile(delete=False) as tmp:
+                    tmp.write(content)
+                    path = tmp.name
                     is_temp_file = True
+
         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)
-        async def file_progress_generator(file_path, chunk_size=8192):
+        chunk_size = self.chunk_size
+
+        progress_bar = tqdm(total=file_size, unit='B', unit_scale=True, unit_divisor=1024,
+                            desc=f'Uploading: {name}', colour='cyan', disable=not getattr(self, 'show_progress', True))
+
+        async def file_generator(file_path):
             async with aiofiles.open(file_path, 'rb') as f:
-                while True:
-                    chunk = await f.read(chunk_size)
-                    if not chunk:
-                        break
+                while chunk := await f.read(chunk_size):
                     progress_bar.update(len(chunk))
                     yield chunk
-        data = aiohttp.FormData()
-        data.add_field('file', file_progress_generator(path), filename=name, content_type='application/octet-stream')
+
+        form = aiohttp.FormData()
+        form.add_field('file', file_generator(path), filename=name, content_type='application/octet-stream')
+
         try:
-            async with session.post(upload_url, data=data) as response:
+            async with session.post(upload_url, data=form, timeout=aiohttp.ClientTimeout(total=None)) as response:
                 progress_bar.close()
                 if response.status != 200:
-                    raise Exception(f"Upload failed ({response.status}): {await response.text()}")
-                
-                json_data = await response.json()
-                if is_temp_file:
-                    os.remove(path)
-                return json_data.get('data', {}).get('file_id')
-        except :
-            raise FeatureNotAvailableError(f"files is not currently supported by the server.")
+                    text = await response.text()
+                    raise Exception(f"Upload failed ({response.status}): {text}")
+                return (await response.json()).get('data', {}).get('file_id')
+        except Exception as e:
+            raise FeatureNotAvailableError(f"File upload not supported: {e}")
+        finally:
+            if is_temp_file:
+                os.remove(path)
     def get_extension(content_type: str) -> str:
         ext = mimetypes.guess_extension(content_type)
         return ext if ext else ''
@@ -1984,7 +1991,7 @@ max_cache_size and max_msg_age help manage duplicate message processing efficien
             raise ValueError(f"Invalid media type. Must be one of {allowed}")
         result = await self._post("requestSendFile", {"type": media_type})
         return result.get("data", {}).get("upload_url")
-    async def _send_uploaded_file(self, chat_id: str, file_id: str,type_file : str = "file",text: Optional[str] = None, chat_keypad: Optional[Dict[str, Any]] = None, inline_keypad: Optional[Dict[str, Any]] = None, disable_notification: bool = False, reply_to_message_id: Optional[str] = None, chat_keypad_type: Optional[Literal["New", "Removed", "None"]] = "None") -> Dict[str, Any]:
+    async def _send_uploaded_file(self, chat_id: str, file_id: str,type_file : str = "file",text: Optional[str] = None, chat_keypad: Optional[Dict[str, Any]] = None, inline_keypad: Optional[Dict[str, Any]] = None, disable_notification: bool = False, reply_to_message_id: Optional[str] = None, chat_keypad_type: Optional[Literal["New", "Remove", "None"]] = "None") -> Dict[str, Any]:
         payload = {"chat_id": chat_id, "file_id": file_id, "text": text, "disable_notification": disable_notification, "chat_keypad_type": chat_keypad_type}
         if chat_keypad: payload["chat_keypad"] = chat_keypad
         if inline_keypad: payload["inline_keypad"] = inline_keypad
@@ -2016,11 +2023,11 @@ max_cache_size and max_msg_age help manage duplicate message processing efficien
         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]:
+    async def send_document(self, chat_id: str, path: Optional[Union[str, Path]] = None, file_id: Optional[str] = None, text: Optional[str] = None, file_name: Optional[str] = None, inline_keypad: Optional[Dict[str, Any]] = None, chat_keypad: Optional[Dict[str, Any]] = None, reply_to_message_id: Optional[str] = None, disable_notification: bool = False, chat_keypad_type: Optional[Literal["New", "Remove", "None"]] = "None") -> 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]:
+    async def send_file(self, chat_id: str, path: Optional[Union[str, Path]] = None, file_id: Optional[str] = None, caption: Optional[str] = None, file_name: Optional[str] = None, inline_keypad: Optional[Dict[str, Any]] = None, chat_keypad: Optional[Dict[str, Any]] = None, reply_to_message_id: Optional[str] = None, disable_notification: bool = False, chat_keypad_type: Optional[Literal["New", "Remove", "None"]] = "None") -> 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]:
+    async def re_send(self, chat_id: str, path: Optional[Union[str, Path]] = None, file_id: Optional[str] = None, caption: Optional[str] = None, file_name: Optional[str] = None, inline_keypad: Optional[Dict[str, Any]] = None, chat_keypad: Optional[Dict[str, Any]] = None, reply_to_message_id: Optional[str] = None, disable_notification: bool = False, chat_keypad_type: Optional[Literal["New", "Remove", "None"]] = "None") -> 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,
@@ -2033,7 +2040,7 @@ max_cache_size and max_msg_age help manage duplicate message processing efficien
     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"
+    chat_keypad_type: Optional[Literal["New", "Remove", "None"]] = "None"
     ) -> Dict[str, Any]:
         valid_extensions = {"ogg", "oga", "opus", "flac"}
         extension = "flac"
@@ -2078,7 +2085,7 @@ max_cache_size and max_msg_age help manage duplicate message processing efficien
     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"
+    chat_keypad_type: Optional[Literal["New", "Remove", "None"]] = "None"
     ) -> Dict[str, Any]:
         valid_extensions = {"gif"}
         extension = "gif"
@@ -2172,7 +2179,7 @@ max_cache_size and max_msg_age help manage duplicate message processing efficien
     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"})
+        return await self._post("editChatPhoto", {"chat_id": chat_id, "file_id": "Remove"})
     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]:
@@ -2221,24 +2228,58 @@ max_cache_size and max_msg_age help manage duplicate message processing efficien
     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"})
+        return await self._post("editChatKeypad", {"chat_id": chat_id, "chat_keypad_type": "Remove"})
     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]:
+    async def send_video(self, chat_id: str, path: Optional[Union[str, Path]] = None, file_id: Optional[str] = None, text: Optional[str] = None, file_name: Optional[str] = None, inline_keypad: Optional[Dict[str, Any]] = None, chat_keypad: Optional[Dict[str, Any]] = None, reply_to_message_id: Optional[str] = None, disable_notification: bool = False, chat_keypad_type: Optional[Literal["New", "Remove", "None"]] = "None") -> 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]:
+    async def send_voice(self, chat_id: str, path: Optional[Union[str, Path]] = None, file_id: Optional[str] = None, text: Optional[str] = None, file_name: Optional[str] = None, inline_keypad: Optional[Dict[str, Any]] = None, chat_keypad: Optional[Dict[str, Any]] = None, reply_to_message_id: Optional[str] = None, disable_notification: bool = False, chat_keypad_type: Optional[Literal["New", "Remove", "None"]] = "None") -> 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]:
+    async def send_image(self, chat_id: str, path: Optional[Union[str, Path]] = None, file_id: Optional[str] = None, text: Optional[str] = None, file_name: Optional[str] = None, inline_keypad: Optional[Dict[str, Any]] = None, chat_keypad: Optional[Dict[str, Any]] = None, reply_to_message_id: Optional[str] = None, disable_notification: bool = False, chat_keypad_type: Optional[Literal["New", "Remove", "None"]] = "None") -> 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 send_poll(
+        self,
+        chat_id: str,
+        question: str,
+        options: List[str],
+        type: Literal["Regular", "Quiz"] = "Regular",
+        allows_multiple_answers: bool = False,
+        is_anonymous: bool = True,
+        correct_option_index: Optional[int] = None,
+        hint: Optional[str] = None,
+        reply_to_message_id: Optional[str] = None,
+        disable_notification: bool = False,
+        show_results : bool = False,
+        inline_keypad : Optional[Dict[str, Any]] = None,
+        chat_keypad: Optional[Dict[str, Any]] = None,
+        chat_keypad_type: Optional[Literal["New", "Remove", "None"]] = None,
+
+    ) -> AttrDict:
+        return await self._post(
+            "sendPoll", {
+                "chat_id": chat_id,
+                "question": question,
+                "options": options,
+                "type": type,
+                "allows_multiple_answers": allows_multiple_answers,
+                "is_anonymous": is_anonymous,
+                "correct_option_index": correct_option_index,
+                "explanation": hint,
+                "show_results":show_results,
+                "reply_to_message_id": reply_to_message_id,
+                "disable_notification": disable_notification,
+                "chat_keypad": chat_keypad,
+                "inline_keypad":inline_keypad,
+                "chat_keypad_type": chat_keypad_type,
+            }
+        )
     async def check_join(self, channel_guid: str, chat_id: str = None) -> Union[bool, list[str]]:
         client = self._get_client()
         if chat_id:

{rubka-7.1.3 → rubka-7.1.5}/rubka/context.py

@@ -1,6 +1,6 @@
-from typing import Any, Dict, List,Optional
 from typing import Union
 from pathlib import Path
+from typing import List, Optional, Dict, Any, Literal, Callable, Union,Set
 import re,inspect
 import asyncio
 class File:
@@ -336,14 +336,40 @@ class Message:
         )
     
 
-    def reply_poll(self, question: str, options: List[str], **kwargs) -> Dict[str, Any]:
-        return self.bot._post("sendPoll", {
+    def reply_poll(
+        self,
+        question: str,
+        options: List[str],
+        type: Literal['Regular', 'Quiz'] = "Regular",
+        allows_multiple_answers: bool = False,
+        is_anonymous: bool = True,
+        correct_option_index: Optional[int] = None,
+        hint: Optional[str] = None,
+        reply_to_message_id: Optional[str] = None,
+        disable_notification: bool = False,
+        show_results: bool = False,
+        inline_keypad: Optional[Dict[str, Any]] = None,
+        chat_keypad: Optional[Dict[str, Any]] = None,
+        chat_keypad_type: Optional[Literal['New', 'Remove', 'None']] = None,
+        **kwargs
+    ) -> dict:
+        payload = {
             "chat_id": self.chat_id,
             "question": question,
             "options": options,
-            "reply_to_message_id": self.message_id,
-            **kwargs
-        })
+            "type": type,
+            "allows_multiple_answers": allows_multiple_answers,
+            "is_anonymous": is_anonymous,
+            "correct_option_index": correct_option_index,
+            "hint": hint,
+            "reply_to_message_id": self.message_id if not reply_to_message_id else reply_to_message_id,
+            "disable_notification": disable_notification,
+            "show_results": show_results,
+            "inline_keypad": inline_keypad,
+            "chat_keypad": chat_keypad,
+            "chat_keypad_type": chat_keypad_type,
+        }
+        return self.bot._post("sendPoll", {key: value for key, value in payload.items() if value is not None}, **kwargs)
     
 
     def reply_document(
@@ -617,13 +643,69 @@ class InlineMessage:
         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(
-            self.chat_id,
-            text,
-            reply_to_message_id=self.message_id,
-            **kwargs
-        )
+    
+    def reply(self, text: str, delete_after: int = None, **kwargs):
+        async def _reply_async():
+            send_func = self.bot.send_message
+            if inspect.iscoroutinefunction(send_func):
+                msg = await send_func(
+                    self.chat_id,
+                    text,
+                    reply_to_message_id=self.message_id,
+                    delete_after=delete_after,
+                    **kwargs
+                )
+            else:
+                msg = send_func(
+                    self.chat_id,
+                    text,
+                    reply_to_message_id=self.message_id,
+                    delete_after=delete_after,
+                    **kwargs
+                )
+            class Pick:
+                def __init__(self, bot, chat_id, message_id):
+                    self.bot = bot
+                    self.chat_id = chat_id
+                    self.message_id = message_id
+
+                def edit(self, new_text):
+                    async def _edit():
+                        func = self.bot.edit_message_text
+                        if inspect.iscoroutinefunction(func):
+                            await func(self.chat_id, self.message_id, new_text)
+                        else:
+                            func(self.chat_id, self.message_id, new_text)
+
+                    try:
+                        loop = asyncio.get_running_loop()
+                        if loop.is_running():
+                            return asyncio.create_task(_edit())
+                    except RuntimeError:
+                        return asyncio.run(_edit())
+
+                def delete(self):
+                    async def _delete():
+                        func = self.bot.delete_message
+                        if inspect.iscoroutinefunction(func):
+                            await func(self.chat_id, self.message_id)
+                        else:
+                            func(self.chat_id, self.message_id)
+                    try:
+                        loop = asyncio.get_running_loop()
+                        if loop.is_running():
+                            return asyncio.create_task(_delete())
+                    except RuntimeError:
+                        return asyncio.run(_delete())
+            chat_id = msg.get("chat_id") if isinstance(msg, dict) else getattr(msg, "chat_id", self.chat_id)
+            message_id = msg.get("message_id") if isinstance(msg, dict) else getattr(msg, "message_id", self.message_id)
+            return Pick(self.bot, chat_id, message_id)
+        try:
+            loop = asyncio.get_running_loop()
+            if loop.is_running():
+                return asyncio.create_task(_reply_async())
+        except RuntimeError:
+            return asyncio.run(_reply_async())
     def answer(self, text: str, **kwargs):
         return self.bot.send_message(
             self.chat_id,
@@ -631,6 +713,7 @@ class InlineMessage:
             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", {
@@ -841,4 +924,12 @@ class InlineMessage:
         return self.bot.delete_message(
             chat_id=self.chat_id,
             message_id=self.message_id
-        )
+        )
+    @hybrid_property
+    async def author_name(self):return await self.bot.get_name(self.chat_id)
+    @hybrid_property
+    async def name(self):return await self.bot.get_name(self.chat_id)
+    @hybrid_property
+    async def username(self):return await self.bot.get_username(self.chat_id)
+    @hybrid_property
+    async def author_info(self):return await self.bot.get_chat(self.chat_id)

{rubka-7.1.3 → rubka-7.1.5}/rubka/rubino.py

@@ -1177,4 +1177,16 @@ class Bot():
             "post_id": post_id,
             "post_profile_id": post_profile_id,
             "profile_id": profile_id
-        },methode="addPostViewTime")['data']
+        },methode="addPostViewTime")['data']
+    def get_Profile_Posts(self,target_profile_id:str,max_id:str,sort:str="FromMax",limit:str=10):
+        return self._reuests_post(data={
+            "limit": limit,
+            "max_id": max_id,
+            "sort":sort,
+            "target_profile_id": target_profile_id,
+        },methode="getProfilePosts")['data']
+    def get_info_Post(self,url_post:str,profile_id:str=None):
+        return self._reuests_post(data={
+            "share_string": url_post,
+            "profile_id": profile_id,
+        },methode="getPostByShareLink")['data']

{rubka-7.1.3 → rubka-7.1.5}/setup.py

@@ -13,8 +13,16 @@ with open("README.md", "r", encoding="utf-8") as f:
 
 setup(
     name='Rubka',
-    version='7.1.3',
-    description='rubika A Python library for interacting with Rubika Bot API.',
+    version='7.1.5',
+    description=(
+    "Rubika: A Python library for interacting with the Rubika Bot API. "
+    "This library provides an easy-to-use interface to send messages, polls, "
+    "stickers, media files, manage groups and channels, handle inline keyboards, "
+    "and implement advanced bot features like subscription management, "
+    "user authentication, and message handling. "
+    "Ideal for developers looking to automate and extend their Rubika bots with Python."
+),
+
     long_description=long_description,
     long_description_content_type='text/markdown',
     author='Mahdi Ahmadi',
@@ -56,7 +64,7 @@ setup(
             "rubka=rubka.__main__:main",
         ],
     },
-    keywords="rubika bot api library chat messaging rubpy pyrubi rubigram",
+    keywords="rubika bot api library chat messaging rubpy pyrubi rubigram rubika_bot rubika_api fast_rub",
     project_urls={
         "Bug Tracker": "https://t.me/Bprogrammer",
         "Documentation": "https://github.com/Mahdy-Ahmadi/rubka/blob/main/README.md",