Rubka 6.7.1__tar.gz → 6.8.5__tar.gz

{rubka-6.7.1 → rubka-6.8.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Rubka
-Version: 6.7.1
+Version: 6.8.5
 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.7.1 → rubka-6.8.5}/Rubka.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Rubka
-Version: 6.7.1
+Version: 6.8.5
 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.7.1 → rubka-6.8.5}/rubka/asynco.py

@@ -145,7 +145,7 @@ 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 = 1000,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):
         self.token = token
         self._inline_query_handlers: List[dict] = []
         self.timeout = timeout
@@ -167,10 +167,7 @@ max_cache_size and max_msg_age help manage duplicate message processing efficien
         self.sessions: Dict[str, Dict[str, Any]] = {}
         self._callback_handler = None
         self._processed_message_ids = OrderedDict()
-        self._max_cache_size = max_cache_size
-
-        self._connector = aiohttp.TCPConnector(limit=100, ssl=False)
-        
+        self._max_cache_size = max_cache_size        
         self._callback_handlers: List[dict] = []
         self._edited_message_handlers = []
         self._message_handlers: List[dict] = []
@@ -183,8 +180,9 @@ max_cache_size and max_msg_age help manage duplicate message processing efficien
             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()
+        if self._aiohttp_session and not self._aiohttp_session.closed:
+            await self._aiohttp_session.close()
+            logger.debug("aiohttp session closed successfully.")
         
     async def _initialize_webhook(self):
         """Initializes and sets the webhook endpoint if provided."""
@@ -1363,7 +1361,13 @@ max_cache_size and max_msg_age help manage duplicate message processing efficien
                                     msg_time = int(msg_data.get("time", 0))
                                 elif "message_id" in update:
                                     message_id = update.get("message_id")
+                                else:
+                                    msg_time = time.time()
+                                    msg_data = update.get("updated_message", {})
+                                    message_id = msg_data.get("message_id")
+                                    text_content = msg_data.get("text", "")
                                 now = int(time.time())
+                            
                                 if msg_time and (now - msg_time > self.max_msg_age):
                                     continue
                                 dup_ok = True
@@ -1372,15 +1376,10 @@ max_cache_size and max_msg_age help manage duplicate message processing efficien
                                     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.005)
-                        else:
-                            await asyncio.sleep(sleep_time)
-                        if not loop_forever and max_runtime is None:
-                            break
+                        if pause_on_idle and sleep_time == 0:await asyncio.sleep(0.005)
+                        else:await asyncio.sleep(sleep_time)
+                        if not loop_forever and max_runtime is None:break
                         continue
 
                     
@@ -1497,7 +1496,53 @@ 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")
-      
+    async def _delete_after_task(self, chat_id: str, message_id: str, delay: int):
+        try:
+            await asyncio.sleep(delay)
+            await self.delete_message(chat_id=chat_id, message_id=message_id)
+        except Exception:
+            return False
+    async def _edit_after_task(self, chat_id: str, message_id: str, text:str, delay: int):
+        try:
+            await asyncio.sleep(delay)
+            await self.edit_message_text(chat_id=chat_id, message_id=message_id,text=text)
+        except Exception:
+            return False
+        
+    async def delete_after(self, chat_id: str, message_id: str, delay: int = 30) -> asyncio.Task:
+        async def _task():
+            await asyncio.sleep(delay)
+            try:
+                await self.delete_message(chat_id, message_id)
+            except Exception:
+                pass
+
+        try:
+            loop = asyncio.get_running_loop()
+        except RuntimeError:
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+
+        task = loop.create_task(_task())
+        return task
+
+    async def edit_after(self, chat_id: str, message_id: str, text : str, delay: int = 30) -> asyncio.Task:
+        async def _task():
+            await asyncio.sleep(delay)
+            try:
+                await self.edit_message_text(chat_id, message_id,text)
+            except Exception:
+                pass
+
+        try:
+            loop = asyncio.get_running_loop()
+        except RuntimeError:
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+
+        task = loop.create_task(_task())
+        return task
+
     async def send_message(
     self,
     chat_id: str,
@@ -1506,7 +1551,8 @@ 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", "Removed"]] = None,
+    delete_after : int = None
 ) -> Dict[str, Any]:
         payload = {
             "chat_id": chat_id,
@@ -1522,12 +1568,16 @@ max_cache_size and max_msg_age help manage duplicate message processing efficien
             payload["reply_to_message_id"] = reply_to_message_id
         if self.safeSendMode and reply_to_message_id:
             try:
-                return await self._post("sendMessage", payload)
+                state = await self._post("sendMessage", payload)
             except Exception:
                 payload.pop("reply_to_message_id", None)
-                return await self._post("sendMessage", payload)
+                state = await self._post("sendMessage", payload)
         else:
-            return await self._post("sendMessage", payload)
+            state = await self._post("sendMessage", payload)
+        if delete_after:
+            await self.delete_after(chat_id, state.message_id, delete_after)
+            return state
+        return state
     
 
     async def send_sticker(
@@ -1920,33 +1970,35 @@ max_cache_size and max_msg_age help manage duplicate message processing efficien
             disable_notification,
             chat_keypad_type
         )
-    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.
-        """
+
+    async def get_avatar_me(self, save_as: str = None) -> str:
+        session = None
         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)
+                return "null"
+
+            file_info = await self.get_url_file(file_id)
+            url = file_info.get("download_url") if isinstance(file_info, dict) else file_info
+
             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)
+                session = aiohttp.ClientSession()
+                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
+        except Exception as e:
+            print(f"[get_avatar_me] Error: {e}")
+            return "null"
+        finally:
+            if session and not session.closed:
+                await session.close()
+
     async def get_name(self, chat_id: str) -> str:
         try:
             chat = await self.get_chat(chat_id)

{rubka-6.7.1 → rubka-6.8.5}/rubka/context.py

@@ -1,5 +1,8 @@
 from typing import Any, Dict, List,Optional
-
+from typing import Union
+from pathlib import Path
+import re
+import asyncio
 class File:
     def __init__(self, data: dict):
         self.file_id: str = data.get("file_id")
@@ -184,9 +187,25 @@ class Bot:
         self.username: str = data.get("username")
         self.start_message: str = data.get("start_message")
         self.share_url: str = data.get("share_url")
-from typing import Union
-from pathlib import Path
-import re
+
+class hybrid_property:
+    def __init__(self, func):
+        self.func = func
+
+    def __get__(self, instance, owner):
+        if instance is None:
+            return self
+        coro = self.func(instance)
+        try:
+            loop = asyncio.get_running_loop()
+            return coro
+        except RuntimeError:
+            try:
+                loop = asyncio.get_event_loop()
+            except RuntimeError:
+                loop = asyncio.new_event_loop()
+                asyncio.set_event_loop(loop)
+            return loop.run_until_complete(coro)
 class Message:
     def __init__(self, bot, chat_id, message_id, sender_id, text=None, raw_data=None):
         self.bot = bot
@@ -240,19 +259,30 @@ class Message:
             self.is_archive = name.endswith((".zip", ".rar", ".7z", ".tar", ".gz"))
             self.is_executable = name.endswith((".exe", ".msi", ".bat", ".sh"))
             self.is_font = name.endswith((".ttf", ".otf", ".woff", ".woff2"))
-        self.info = {attr: value for attr, value in vars(self).items()}
     @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(
+    
+    async def reply(self, text: str, delete_after: int = None, **kwargs):
+        msg = await self.bot.send_message(
             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
+            async def edit(self, new_text):
+                await self.bot.edit_message_text(self.chat_id, self.message_id, new_text)
+            async def delete(self):
+                await self.bot.delete_message(self.chat_id, self.message_id)
+        return pick(self.bot, msg.chat_id, msg.message_id)
     def answer(self, text: str, **kwargs):
         return self.bot.send_message(
             self.chat_id,
@@ -260,6 +290,7 @@ class Message:
             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", {
@@ -471,6 +502,14 @@ class 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)
 class AuxData:
     def __init__(self, data: dict):
         self.start_id = data.get("start_id")

{rubka-6.7.1 → rubka-6.8.5}/rubka/update.py

@@ -1,5 +1,8 @@
 from typing import Any, Dict, List,Optional
-
+from typing import Union
+from pathlib import Path
+import re
+import asyncio
 class File:
     def __init__(self, data: dict):
         self.file_id: str = data.get("file_id")
@@ -184,9 +187,25 @@ class Bot:
         self.username: str = data.get("username")
         self.start_message: str = data.get("start_message")
         self.share_url: str = data.get("share_url")
-from typing import Union
-from pathlib import Path
-import re
+
+class hybrid_property:
+    def __init__(self, func):
+        self.func = func
+
+    def __get__(self, instance, owner):
+        if instance is None:
+            return self
+        coro = self.func(instance)
+        try:
+            loop = asyncio.get_running_loop()
+            return coro
+        except RuntimeError:
+            try:
+                loop = asyncio.get_event_loop()
+            except RuntimeError:
+                loop = asyncio.new_event_loop()
+                asyncio.set_event_loop(loop)
+            return loop.run_until_complete(coro)
 class Message:
     def __init__(self, bot, chat_id, message_id, sender_id, text=None, raw_data=None):
         self.bot = bot
@@ -246,11 +265,12 @@ class Message:
         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):
+    def reply(self, text: str,delete_after :int = None, **kwargs):
         return self.bot.send_message(
             self.chat_id,
             text,
             reply_to_message_id=self.message_id,
+            delete_after=delete_after,
             **kwargs
         )
     def answer(self, text: str, **kwargs):
@@ -260,6 +280,7 @@ class Message:
             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", {
@@ -471,6 +492,14 @@ class 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)
 class AuxData:
     def __init__(self, data: dict):
         self.start_id = data.get("start_id")

{rubka-6.7.1 → rubka-6.8.5}/setup.py

@@ -13,7 +13,7 @@ with open("README.md", "r", encoding="utf-8") as f:
 
 setup(
     name='Rubka',
-    version='6.7.1',
+    version='6.8.5',
     description='rubika A Python library for interacting with Rubika Bot API.',
     long_description=long_description,
     long_description_content_type='text/markdown',