Rubka 6.7.11__tar.gz → 7.1.1__tar.gz

{rubka-6.7.11 → rubka-7.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Rubka
-Version: 6.7.11
+Version: 7.1.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
@@ -31,6 +31,7 @@ Requires-Dist: Pillow
 Requires-Dist: websocket-client
 Requires-Dist: pycryptodome
 Requires-Dist: aiohttp
+Requires-Dist: httpx
 Requires-Dist: tqdm
 Requires-Dist: mutagen
 Requires-Dist: filetype

{rubka-6.7.11 → rubka-7.1.1}/Rubka.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Rubka
-Version: 6.7.11
+Version: 7.1.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
@@ -31,6 +31,7 @@ Requires-Dist: Pillow
 Requires-Dist: websocket-client
 Requires-Dist: pycryptodome
 Requires-Dist: aiohttp
+Requires-Dist: httpx
 Requires-Dist: tqdm
 Requires-Dist: mutagen
 Requires-Dist: filetype

{rubka-6.7.11 → rubka-7.1.1}/Rubka.egg-info/requires.txt

@@ -3,6 +3,7 @@ Pillow
 websocket-client
 pycryptodome
 aiohttp
+httpx
 tqdm
 mutagen
 filetype

{rubka-6.7.11 → rubka-7.1.1}/rubka/api.py

@@ -1016,7 +1016,8 @@ class Robot:
         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 = None
     ) -> Dict[str, Any]:
         """
         Send a text message to a chat.

{rubka-6.7.11 → rubka-7.1.1}/rubka/asynco.py

@@ -1,4 +1,4 @@
-import asyncio,aiohttp,aiofiles,time,datetime,json,tempfile,os,sys,subprocess,mimetypes,time, hashlib
+import asyncio,aiohttp,aiofiles,time,datetime,json,tempfile,os,sys,subprocess,mimetypes,time, hashlib,sqlite3
 from typing import List, Optional, Dict, Any, Literal, Callable, Union,Set
 from collections import OrderedDict
 from .exceptions import APIRequestError,raise_for_status,InvalidAccessError,InvalidInputError,TooRequestError,InvalidTokenError
@@ -19,7 +19,6 @@ from tqdm import tqdm
 API_URL = "https://botapi.rubika.ir/v3"
 
 def install_package(package_name: str) -> bool:
-    """Installs a package using pip."""
     try:
         subprocess.check_call([sys.executable, "-m", "pip", "install", package_name], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
         return True
@@ -27,7 +26,6 @@ def install_package(package_name: str) -> bool:
         return False
 
 def get_importlib_metadata():
-    """Dynamically imports and returns metadata functions from importlib."""
     try:
         from importlib.metadata import version, PackageNotFoundError
         return version, PackageNotFoundError
@@ -43,7 +41,6 @@ def get_importlib_metadata():
 version, PackageNotFoundError = get_importlib_metadata()
 
 def get_installed_version(package_name: str) -> Optional[str]:
-    """Gets the installed version of a package."""
     if version is None:
         return "unknown"
     try:
@@ -52,7 +49,6 @@ def get_installed_version(package_name: str) -> Optional[str]:
         return None
 
 async def get_latest_version(package_name: str) -> Optional[str]:
-    """Fetches the latest version of a package from PyPI asynchronously."""
     url = f"https://pypi.org/pypi/{package_name}/json"
     try:
         async with aiohttp.ClientSession() as session:
@@ -64,7 +60,6 @@ async def get_latest_version(package_name: str) -> Optional[str]:
         return None
 
 async def check_rubka_version():
-    """Checks for outdated 'rubka' package and warns the user."""
     package_name = "rubka"
     installed_version = get_installed_version(package_name)
     if installed_version is None:
@@ -87,7 +82,6 @@ async def check_rubka_version():
 
 
 def show_last_six_words(text: str) -> str:
-    """Returns the last 6 characters of a stripped string."""
     text = text.strip()
     return text[-6:]
 class AttrDict(dict):
@@ -145,7 +139,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
@@ -170,18 +164,23 @@ max_cache_size and max_msg_age help manage duplicate message processing efficien
         self._max_cache_size = max_cache_size        
         self._callback_handlers: List[dict] = []
         self._edited_message_handlers = []
+        self._message_saver_enabled = False
+        self._max_messages = None
+        self._db_path = os.path.join(os.getcwd(), "RubkaSaveMessage.db")
+        self._ensure_db()
         self._message_handlers: List[dict] = []
 
         logger.info(f"Initialized RubikaBot with token: {token[:8]}***")
     async def _get_session(self) -> aiohttp.ClientSession:
         if self._aiohttp_session is None or self._aiohttp_session.closed:
-            connector = aiohttp.TCPConnector(limit=100, ssl=False)  # limit اتصالات همزمان
+            connector = aiohttp.TCPConnector(limit=100, ssl=False)
             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()
+        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."""
@@ -250,15 +249,157 @@ max_cache_size and max_msg_age help manage duplicate message processing efficien
         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", {})
     async def geteToken(self):
-        """Check if the bot token is valid."""
         if (await self.get_me())['status'] != "OK":
             raise InvalidTokenError("The provided bot token is invalid or expired.")
     from typing import Callable, Any, Optional, List
 
 
+#save message database __________________________
+
+    def _ensure_db(self):
+        conn = sqlite3.connect(self._db_path)
+        cur = conn.cursor()
+        cur.execute("""
+        CREATE TABLE IF NOT EXISTS messages (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            chat_id TEXT NOT NULL,
+            message_id TEXT NOT NULL,
+            sender_id TEXT,
+            text TEXT,
+            raw_data TEXT,
+            time TEXT,
+            saved_at INTEGER
+        );
+        """)
+        cur.execute("CREATE UNIQUE INDEX IF NOT EXISTS idx_chat_message ON messages(chat_id, message_id);")
+        conn.commit()
+        conn.close()
+
+    def _insert_message(self, record: dict):
+        conn = sqlite3.connect(self._db_path)
+        cur = conn.cursor()
+        cur.execute("""
+        INSERT OR IGNORE INTO messages
+        (chat_id, message_id, sender_id, text, raw_data, time, saved_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?)
+        """, (
+            record.get("chat_id"),
+            record.get("message_id"),
+            record.get("sender_id"),
+            record.get("text"),
+            json.dumps(record.get("raw_data") or {}, ensure_ascii=False),
+            record.get("time"),
+            int(time.time())
+        ))
+        conn.commit()
+        if getattr(self, "_max_messages", None) is not None:
+            cur.execute("SELECT COUNT(*) FROM messages")
+            total = cur.fetchone()[0]
+            if total > self._max_messages:
+                remove_count = total - self._max_messages
+                cur.execute(
+                    "DELETE FROM messages WHERE id IN (SELECT id FROM messages ORDER BY saved_at ASC LIMIT ?)",
+                    (remove_count,)
+                )
+                conn.commit()
+
+        conn.close()
+
+    def _fetch_message(self, chat_id: str, message_id: str):
+        conn = sqlite3.connect(self._db_path)
+        cur = conn.cursor()
+        cur.execute(
+            "SELECT chat_id, message_id, sender_id, text, raw_data, time, saved_at FROM messages WHERE chat_id=? AND message_id=?",
+            (chat_id, message_id)
+        )
+        row = cur.fetchone()
+        conn.close()
+        if not row:
+            return None
+        chat_id, message_id, sender_id, text, raw_data_json, time_val, saved_at = row
+        try:
+            raw = json.loads(raw_data_json)
+        except:
+            raw = {}
+        return {
+            "chat_id": chat_id,
+            "message_id": message_id,
+            "sender_id": sender_id,
+            "text": text,
+            "raw_data": raw,
+            "time": time_val,
+            "saved_at": saved_at
+        }
+    async def save_message(self, message: Message):
+        try:
+            record = {
+                "chat_id": getattr(message, "chat_id", None),
+                "message_id": getattr(message, "message_id", None),
+                "sender_id": getattr(message, "author_guid", None),
+                "text": getattr(message, "text", None),
+                "raw_data": getattr(message, "raw_data", {}),
+                "time": getattr(message, "time", None),
+            }
+            await asyncio.to_thread(self._insert_message, record)
+        except Exception as e:
+            print(f"[DB] Error saving message: {e}")
+
+    async def get_message(self, chat_id: str, message_id: str):
+        return await asyncio.to_thread(self._fetch_message, chat_id, message_id)
+
+    def start_save_message(self, max_messages: int = 1000):
+        if self._message_saver_enabled:
+            return
+        self._message_saver_enabled = True
+        self._max_messages = max_messages
+        decorators = [
+            "on_message", "on_edited_message", "on_message_file", "on_message_forwarded",
+            "on_message_reply", "on_message_text", "on_update", "on_callback",
+            "on_callback_query", "callback_query_handler", "callback_query",
+            "on_inline_query", "on_inline_query_prefix", "on_message_private", "on_message_group"
+        ]
+
+        for decorator_name in decorators:
+            if hasattr(self, decorator_name):
+                original_decorator = getattr(self, decorator_name)
+
+                def make_wrapper(orig_decorator):
+                    def wrapper(*args, **kwargs):
+                        decorator = orig_decorator(*args, **kwargs)
+                        def inner_wrapper(func):
+                            async def inner(bot, message, *a, **kw):
+                                try:
+                                    await bot.save_message(message)
+                                    if getattr(self, "_max_messages", None) is not None:
+                                        await asyncio.to_thread(self._prune_old_messages)
+                                except Exception as e:
+                                    print(f"[DB] Save error: {e}")
+                                return await func(bot, message, *a, **kw)
+                            return decorator(inner)
+                        return inner_wrapper
+                    return wrapper
+
+                setattr(self, decorator_name, make_wrapper(original_decorator))
+    def _prune_old_messages(self):
+        if not hasattr(self, "_max_messages") or self._max_messages is None:
+            return
+        conn = sqlite3.connect(self._db_path)
+        cur = conn.cursor()
+        cur.execute("SELECT COUNT(*) FROM messages")
+        total = cur.fetchone()[0]
+        if total > self._max_messages:
+            remove_count = total - self._max_messages
+            cur.execute(
+                "DELETE FROM messages WHERE id IN (SELECT id FROM messages ORDER BY saved_at ASC LIMIT ?)",
+                (remove_count,)
+            )
+            conn.commit()
+        conn.close()
+
+#save message database __________________________ end
+
 #decorator#
 
     def on_message_private(
@@ -851,7 +992,7 @@ max_cache_size and max_msg_age help manage duplicate message processing efficien
                         asyncio.create_task(handler_info["func"](self, context))
                         continue 
                     if handler_info["commands"] or handler_info["filters"]:
-                        asyncio.create_task(handler_info["func"](self, context))#jaq
+                        asyncio.create_task(handler_info["func"](self, context))#kir baba kir
                         continue 
         elif update.get("type") == "UpdatedMessage":
             msg = update.get("updated_message", {})
@@ -911,7 +1052,7 @@ max_cache_size and max_msg_age help manage duplicate message processing efficien
     async def run(
     self,
     debug: bool = False,
-    sleep_time: float = 0.2,
+    sleep_time: float = 0.1,
     webhook_timeout: int = 20,
     update_limit: int = 100,
     retry_delay: float = 5.0,
@@ -1360,7 +1501,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
@@ -1369,15 +1516,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
 
                     
@@ -1494,7 +1636,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,
@@ -1503,7 +1691,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,
@@ -1519,12 +1708,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(
@@ -1917,33 +2110,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.11 → rubka-7.1.1}/rubka/context.py

@@ -1,5 +1,8 @@
 from typing import Any, Dict, List,Optional
-
+from typing import Union
+from pathlib import Path
+import re,inspect
+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,74 @@ 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(
-            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,
@@ -260,6 +334,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 +546,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.11 → rubka-7.1.1}/rubka/update.py

@@ -1,5 +1,8 @@
 from typing import Any, Dict, List,Optional
-
+from typing import Union
+from pathlib import Path
+import re,inspect
+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,74 @@ 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(
-            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,
@@ -260,6 +334,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 +546,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.11 → rubka-7.1.1}/setup.py

@@ -13,7 +13,7 @@ with open("README.md", "r", encoding="utf-8") as f:
 
 setup(
     name='Rubka',
-    version='6.7.11',
+    version='7.1.1',
     description='rubika A Python library for interacting with Rubika Bot API.',
     long_description=long_description,
     long_description_content_type='text/markdown',
@@ -45,6 +45,7 @@ setup(
         "websocket-client",
         'pycryptodome',
         'aiohttp',
+        'httpx',
         'tqdm',
         'mutagen',
         'filetype',