Rubka 7.1.4__py3-none-any.whl → 7.1.6__py3-none-any.whl

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/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
@@ -1051,7 +1054,7 @@ max_cache_size and max_msg_age help manage duplicate message processing efficien
             self._processed_message_ids.popitem(last=False)
         return False
 
-    async def run(
+    async def run_progelry(
     self,
     debug: bool = False,
     sleep_time: float = 0.1,
@@ -1411,7 +1414,7 @@ max_cache_size and max_msg_age help manage duplicate message processing efficien
         await check_rubka_version()
         await self._initialize_webhook()
         await self.geteToken()
-        _log("Bot started running...", "info")
+        _log("Bot is up and running...", "info")
 
         try:
             while True:
@@ -1638,6 +1641,11 @@ max_cache_size and max_msg_age help manage duplicate message processing efficien
             
             
             _log("Auto-restart requested. You can call run(...) again as needed.", "warning")
+    def run(self, sleep_time : float = 0.1 ,*args, **kwargs):
+        print("Connecting to the server...")
+        loop = asyncio.get_event_loop()
+        if loop.is_running():return loop.create_task(self.run_progelry(sleep_time=sleep_time,*args, **kwargs))
+        else:return asyncio.run(self.run_progelry(sleep_time=sleep_time,*args, **kwargs))
     async def _delete_after_task(self, chat_id: str, message_id: str, delay: int):
         try:
             await asyncio.sleep(delay)
@@ -1864,41 +1872,45 @@ max_cache_size and max_msg_age help manage duplicate message processing efficien
         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 ''
@@ -2237,8 +2249,42 @@ max_cache_size and max_msg_age help manage duplicate message processing efficien
     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/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/rubino.py

@@ -5,6 +5,10 @@ from tempfile import NamedTemporaryFile
 from os import system, chmod, remove
 from base64 import b64encode
 from io import BytesIO
+class InvalidInputError(Exception):
+    def __init__(self, message="Invalid input provided"):
+        self.message = message
+        super().__init__(self.message)
 class confing():
     headers= {
         "User-Agent": "okhttp/3.12.1",
@@ -192,9 +196,15 @@ class req:
             except:
                 continue
             else:
-                if 'data_enc' in  response.json():
-                    return loads(self.enc.decrypt(response.json()['data_enc']))
-                return response.json()
+                
+                response_data = response.json()
+
+                if 'data_enc' in response_data:
+                    return loads(self.enc.decrypt(response_data['data_enc']))
+                if response_data.get('status') != "OK":
+                    raise InvalidInputError(f"Error : {response_data.get('status_det', 'Unknown error')}")
+                return response_data
+
         
     def requestUploadFile(self,file_name:str,size:str,file_type:str,profile_id:str=None):
         return self.send_request({
@@ -203,6 +213,7 @@ class req:
             "file_type": file_type,
             "profile_id": profile_id
         },"requestUploadFile")
+    
 
     def upload(self, post_file, post_type: str, profile_id: str = None):
         file_byte_code = post_file if isinstance(post_file, bytes) else open(post_file, "rb").read()
@@ -476,11 +487,12 @@ class Bot():
         if response.status == 200:
             response_data = json.loads(response.data.decode('utf-8'))
             if 'data' in response_data:
-                    return response_data['data']
+                return response_data['data']
             else:
-                return response_data['status_det']
-        else :
-            raise Exception("Request Error Server")
+                raise Exception(f"Error: {response_data.get('status_det', 'Unknown error')}")
+        else:
+            raise Exception(f"Request Error Server - Status Code: {response.status}")
+
     def edit_info_page(
         self,
         username_me:str,

{rubka-7.1.4.dist-info → rubka-7.1.6.dist-info}/METADATA

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: Rubka
-Version: 7.1.4
-Summary: rubika A Python library for interacting with Rubika Bot API.
+Version: 7.1.6
+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.4.dist-info → rubka-7.1.6.dist-info}/RECORD

@@ -1,9 +1,9 @@
 rubka/__init__.py,sha256=P6IBiORfp-GqKHe5LZ-5lldWyG7tnrUYUcAQDUgwXmY,1973
-rubka/api.py,sha256=fo4X9MH_HqQmLkRNhjJcJJZOHp5lkFZqitCXs2qL_kc,68891
-rubka/asynco.py,sha256=QIwWgfhmKqNeqkO0VxpoLCmNBKVM58GP8JdpuvgCzL8,108338
+rubka/api.py,sha256=wa1gQj7NDc7QEbmNNRz-TIOdVqfMWFC362tndRKdqig,68449
+rubka/asynco.py,sha256=WMQQSX7rjqKn4aGphgC7BQvSqR0DDfe9uEXnmb8ZNHo,110233
 rubka/button.py,sha256=woSzZVd5MtTqOrP-YgkH5b0GS9y4DuKBsFSc9-KuLnk,13320
 rubka/config.py,sha256=Bck59xkOiqioLv0GkQ1qPGnBXVctz1hKk6LT4h2EPx0,78
-rubka/context.py,sha256=-oC9h7U_H3CrtqUCDCnFXAvC7zdSmwxlc0CNwL1XLxM,34314
+rubka/context.py,sha256=OowmsvqkThzB1NDhK5629Jm4ExdaWcjUo4rsBjpTtjA,38536
 rubka/decorators.py,sha256=hGwUoE4q2ImrunJIGJ_kzGYYxQf1ueE0isadqraKEts,1157
 rubka/exceptions.py,sha256=DDOGIHEMoliHNW5E7C_s38WZgqqMBv9812fcJGvj7TY,1173
 rubka/filters.py,sha256=DY1bdkpRKIiLtVcy6X3hOnlGPcVOK4HFb3QgmaPx6Oo,12116
@@ -12,7 +12,7 @@ rubka/jobs.py,sha256=GvLMLsVhcSEzRTgkvnPISPEBN71suW2xXI0hUaUZPTo,378
 rubka/keyboards.py,sha256=7nr-dT2bQJVQnQ6RMWPTSjML6EEk6dsBx-4d8pab8xk,488
 rubka/keypad.py,sha256=yGsNt8W5HtUFBzVF1m_p7GySlu1hwIcSvXZ4BTdrlvg,9558
 rubka/logger.py,sha256=J2I6NiK1z32lrAzC4H1Et6WPMBXxXGCVUsW4jgcAofs,289
-rubka/rubino.py,sha256=d_j32FVra8HLsZ-QJC-clChJZK6VFLqgLFAFSr-jRFk,60651
+rubka/rubino.py,sha256=hejkavxd9lmQMI_f8cNjGpGEHSobCzfTLHousWEHjA8,61128
 rubka/tv.py,sha256=rBoyCadCH3I3YqQGrQYv_dLtTg1I63AzVf1orn-hbko,5724
 rubka/update.py,sha256=-oC9h7U_H3CrtqUCDCnFXAvC7zdSmwxlc0CNwL1XLxM,34314
 rubka/utils.py,sha256=XUQUZxQt9J2f0X5hmAH_MH1kibTAfdT1T4AaBkBhBBs,148
@@ -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-7.1.4.dist-info/METADATA,sha256=mkANXgvGnSdKVFOHBJ7cXCVEs7W5aoOZopYA4RmiU5A,34291
-rubka-7.1.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-rubka-7.1.4.dist-info/entry_points.txt,sha256=4aESuUmuUOALMUy7Kucv_Gb5YlqhsJmTmdXLlZU9sJ0,46
-rubka-7.1.4.dist-info/top_level.txt,sha256=vy2A4lot11cRMdQS-F4HDCIXL3JK8RKfu7HMDkezJW4,6
-rubka-7.1.4.dist-info/RECORD,,
+rubka-7.1.6.dist-info/METADATA,sha256=ot_eijQARS-ukqO0VI3JaQOGWuSZIEyDWjSDfUrcnq0,34667
+rubka-7.1.6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+rubka-7.1.6.dist-info/entry_points.txt,sha256=4aESuUmuUOALMUy7Kucv_Gb5YlqhsJmTmdXLlZU9sJ0,46
+rubka-7.1.6.dist-info/top_level.txt,sha256=vy2A4lot11cRMdQS-F4HDCIXL3JK8RKfu7HMDkezJW4,6
+rubka-7.1.6.dist-info/RECORD,,