Rubka 7.1.9__tar.gz → 7.1.11__tar.gz

{rubka-7.1.9 → rubka-7.1.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Rubka
-Version: 7.1.9
+Version: 7.1.11
 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

{rubka-7.1.9 → rubka-7.1.11}/Rubka.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Rubka
-Version: 7.1.9
+Version: 7.1.11
 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

{rubka-7.1.9 → rubka-7.1.11}/Rubka.egg-info/SOURCES.txt

@@ -21,6 +21,7 @@ rubka/jobs.py
 rubka/keyboards.py
 rubka/keypad.py
 rubka/logger.py
+rubka/metadata.py
 rubka/rubino.py
 rubka/tv.py
 rubka/update.py

{rubka-7.1.9 → rubka-7.1.11}/rubka/api.py

@@ -1011,7 +1011,8 @@ class Robot:
         disable_notification: bool = False,
         reply_to_message_id: Optional[str] = None,
         chat_keypad_type: Optional[Literal["New", "Removed"]] = None,
-        delete_after = None
+        delete_after = None,
+        parse_mode = None
     ) -> Dict[str, Any]:
         """
         Send a text message to a chat.

{rubka-7.1.9 → rubka-7.1.11}/rubka/asynco.py

@@ -1,9 +1,10 @@
-import asyncio,aiohttp,aiofiles,time,datetime,json,tempfile,os,sys,subprocess,mimetypes,time, hashlib,sqlite3
+import asyncio,aiohttp,aiofiles,time,datetime,json,tempfile,os,sys,subprocess,mimetypes,time, hashlib,sqlite3,re
 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
 from .adaptorrubka import Client as Client_get
 from .logger import logger
+from .metadata import Track_parsed as GlyphWeaver
 from .rubino import Bot as Rubino
 from . import filters
 try:from .context import Message, InlineMessage
@@ -27,6 +28,127 @@ def install_package(package_name: str) -> bool:
     except Exception:
         return False
 
+def metadata_CallBack(text: str, mode: str) -> Dict[str, Any]:
+    meta_data_parts = []
+    if mode == "Markdown":
+        for match in re.finditer(r"\*\*(.*?)\*\*", text):
+            meta_data_parts.append({
+                "type": "Bold",
+                "from_index": match.start(1),
+                "length": len(match.group(1))
+            })
+        for match in re.finditer(r"(?<!\*)\*(?!\*)(.*?)\*(?!\*)", text):
+            meta_data_parts.append({
+                "type": "Italic",
+                "from_index": match.start(1),
+                "length": len(match.group(1))
+            })
+        for match in re.finditer(r"~~(.*?)~~", text):
+            meta_data_parts.append({
+                "type": "Strike",
+                "from_index": match.start(1),
+                "length": len(match.group(1))
+            })
+        for match in re.finditer(r"__(.*?)__", text):
+            meta_data_parts.append({
+                "type": "Underline",
+                "from_index": match.start(1),
+                "length": len(match.group(1))
+            })
+        for match in re.finditer(r"^> (.*)$", text, re.MULTILINE):
+            meta_data_parts.append({
+                "type": "Quote",
+                "from_index": match.start(1),
+                "length": len(match.group(1))
+            })
+        for match in re.finditer(r"\|\|(.*?)\|\|", text):
+            meta_data_parts.append({
+                "type": "Spoiler",
+                "from_index": match.start(1),
+                "length": len(match.group(1))
+            })
+        for match in re.finditer(r"`(.*?)`", text):
+            meta_data_parts.append({
+                "type": "Mono",
+                "from_index": match.start(1),
+                "length": len(match.group(1))
+            })
+
+        for match in re.finditer(r"```(.*?)```", text, re.DOTALL):
+            meta_data_parts.append({
+                "type": "Pre",
+                "from_index": match.start(1),
+                "length": len(match.group(1))
+            })
+        for match in re.finditer(r"\[(.*?)\]\((.*?)\)", text):
+            meta_data_parts.append({
+                "type": "Link",
+                "from_index": match.start(1),
+                "length": len(match.group(1)),
+                "link_url": match.group(2)
+            })
+
+    elif mode == "HTML":
+        for match in re.finditer(r"<b>(.*?)</b>", text):
+            meta_data_parts.append({
+                "type": "Bold",
+                "from_index": match.start(1),
+                "length": len(match.group(1))
+            })
+        for match in re.finditer(r"<i>(.*?)</i>", text):
+            meta_data_parts.append({
+                "type": "Italic",
+                "from_index": match.start(1),
+                "length": len(match.group(1))
+            })
+        for match in re.finditer(r"<u>(.*?)</u>", text):
+            meta_data_parts.append({
+                "type": "Underline",
+                "from_index": match.start(1),
+                "length": len(match.group(1))
+            })
+        for match in re.finditer(r"<s>(.*?)</s>|<strike>(.*?)</strike>", text):
+            inner = match.group(1) or match.group(2)
+            meta_data_parts.append({
+                "type": "Strike",
+                "from_index": match.start(),
+                "length": len(inner)
+            })
+        for match in re.finditer(r"<blockquote>(.*?)</blockquote>", text, re.DOTALL):
+            meta_data_parts.append({
+                "type": "Quote",
+                "from_index": match.start(1),
+                "length": len(match.group(1))
+            })
+        for match in re.finditer(r'<span class="spoiler">(.*?)</span>', text):
+            meta_data_parts.append({
+                "type": "Spoiler",
+                "from_index": match.start(1),
+                "length": len(match.group(1))
+            })
+        for match in re.finditer(r"<code>(.*?)</code>", text):
+            meta_data_parts.append({
+                "type": "Pre",
+                "from_index": match.start(1),
+                "length": len(match.group(1))
+            })
+
+        for match in re.finditer(r"<pre>(.*?)</pre>", text, re.DOTALL):
+            meta_data_parts.append({
+                "type": "Pre",
+                "from_index": match.start(1),
+                "length": len(match.group(1))
+            })
+        for match in re.finditer(r'<a href="(.*?)">(.*?)</a>', text):
+            meta_data_parts.append({
+                "type": "Link",
+                "from_index": match.start(2),
+                "length": len(match.group(2)),
+                "link_url": match.group(1)
+            })
+
+    return {"meta_data_parts": meta_data_parts} if meta_data_parts else {}
+
 def get_importlib_metadata():
     try:
         from importlib.metadata import version, PackageNotFoundError
@@ -143,7 +265,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 = 2000,max_msg_age : int = 60,chunk_size : int = 64 * 1024):
+    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,parse_mode: Optional[Literal["HTML", "Markdown"]] = "Markdown"):
         self.token = token
         self._inline_query_handlers: List[dict] = []
         self.timeout = timeout
@@ -161,6 +283,7 @@ max_cache_size and max_msg_age help manage duplicate message processing efficien
         self.Key = Key
         self.platform = platform
         self.web_hook = web_hook
+        self.parse_mode = parse_mode
         self._offset_id: Optional[str] = None
         self._aiohttp_session: aiohttp.ClientSession = None
         self.sessions: Dict[str, Dict[str, Any]] = {}
@@ -1692,23 +1815,35 @@ max_cache_size and max_msg_age help manage duplicate message processing efficien
 
         task = loop.create_task(_task())
         return task
+    def _parse_text_metadata(self, text: str, parse_mode: str):
+        formatter = GlyphWeaver()
+        parsed = formatter.parse(text, parse_mode)
+        return parsed.get("text"), parsed.get("metadata")
 
     async def send_message(
-    self,
-    chat_id: str,
-    text: str,
-    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,
-    delete_after : int = None
-) -> Dict[str, Any]:
+        self,
+        chat_id: str,
+        text: str,
+        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,
+        delete_after: Optional[int] = None,
+        parse_mode: Optional[Literal["HTML", "Markdown"]] = None
+    ) -> Dict[str, Any]:
+
         payload = {
             "chat_id": chat_id,
             "text": text,
             "disable_notification": disable_notification,
         }
+        parse_mode_to_use = parse_mode or self.parse_mode
+        if text:
+            text, metadata = self._parse_text_metadata(text, parse_mode_to_use)
+            payload["text"] = text
+            if metadata:
+                payload["metadata"] = metadata
         if chat_keypad:
             payload["chat_keypad"] = chat_keypad
             payload["chat_keypad_type"] = chat_keypad_type or "New"
@@ -1716,19 +1851,18 @@ max_cache_size and max_msg_age help manage duplicate message processing efficien
             payload["inline_keypad"] = inline_keypad
         if reply_to_message_id:
             payload["reply_to_message_id"] = reply_to_message_id
-        if self.safeSendMode and reply_to_message_id:
-            try:
-                state = await self._post("sendMessage", payload)
-            except Exception:
+        try:
+            state = await self._post("sendMessage", payload)
+        except Exception:
+            if self.safeSendMode and reply_to_message_id:
                 payload.pop("reply_to_message_id", None)
                 state = await self._post("sendMessage", payload)
-        else:
-            state = await self._post("sendMessage", payload)
+            else:
+                raise
         if delete_after:
             await self.delete_after(chat_id, state.message_id, delete_after)
-            return state
         return state
-    
+
 
     async def send_sticker(
         self,
@@ -1996,11 +2130,16 @@ 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", "Remove", "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",parse_mode: Optional[Literal["HTML", "Markdown"]] = 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
         if reply_to_message_id: payload["reply_to_message_id"] = str(reply_to_message_id)
+        parse_mode_to_use = parse_mode or self.parse_mode
+        if text:
+            text, metadata = self._parse_text_metadata(text, parse_mode_to_use)
+            payload["text"] = text
+            if metadata:payload["metadata"] = metadata
         payload["time"] = "10"
         resp = await self._post("sendFile", payload)
         message_id_put = resp["data"]["message_id"]
@@ -2020,20 +2159,26 @@ max_cache_size and max_msg_age help manage duplicate message processing efficien
             "chat_keypad_type":chat_keypad_type
         }
         return AttrDict(result)
-    async def _send_file_generic(self, media_type, chat_id, path, file_id, text, file_name, inline_keypad, chat_keypad, reply_to_message_id, disable_notification, chat_keypad_type):
+    async def _send_file_generic(self, media_type, chat_id, path, file_id, text, file_name, inline_keypad, chat_keypad, reply_to_message_id, disable_notification, chat_keypad_type,parse_mode: Optional[Literal["HTML", "Markdown"]] = None):
         if path:
             file_name = file_name or Path(path).name
             upload_url = await self.get_upload_url(media_type)
             file_id = await self.upload_media_file(upload_url, file_name, path)
         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", "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", "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", "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)  
+        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,parse_mode=parse_mode)
+    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",parse_mode: Optional[Literal["HTML", "Markdown"]] = 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,parse_mode=parse_mode)
+    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",parse_mode: Optional[Literal["HTML", "Markdown"]] = 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,parse_mode=parse_mode)
+    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",parse_mode: Optional[Literal["HTML", "Markdown"]] = 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,parse_mode=parse_mode)  
+    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",parse_mode: Optional[Literal["HTML", "Markdown"]] = 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,parse_mode=parse_mode)
+    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",parse_mode: Optional[Literal["HTML", "Markdown"]] = 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,parse_mode=parse_mode)
+    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",parse_mode: Optional[Literal["HTML", "Markdown"]] = 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,parse_mode=parse_mode)
     async def send_music(
     self,
     chat_id: str,
@@ -2045,7 +2190,8 @@ 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", "Remove", "None"]] = "None"
+    chat_keypad_type: Optional[Literal["New", "Remove", "None"]] = "None",
+    parse_mode: Optional[Literal["HTML", "Markdown"]] = None
     ) -> Dict[str, Any]:
         valid_extensions = {"ogg", "oga", "opus", "flac"}
         extension = "flac"
@@ -2077,7 +2223,8 @@ max_cache_size and max_msg_age help manage duplicate message processing efficien
             chat_keypad,
             reply_to_message_id,
             disable_notification,
-            chat_keypad_type
+            chat_keypad_type,
+            parse_mode=parse_mode
         )
     async def send_gif(
     self,
@@ -2090,7 +2237,8 @@ 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", "Remove", "None"]] = "None"
+    chat_keypad_type: Optional[Literal["New", "Remove", "None"]] = "None",
+    parse_mode: Optional[Literal["HTML", "Markdown"]] = None
     ) -> Dict[str, Any]:
         valid_extensions = {"gif"}
         extension = "gif"
@@ -2122,7 +2270,8 @@ max_cache_size and max_msg_age help manage duplicate message processing efficien
             chat_keypad,
             reply_to_message_id,
             disable_notification,
-            chat_keypad_type
+            chat_keypad_type,
+            parse_mode=parse_mode
         )
 
     async def get_avatar_me(self, save_as: str = None) -> str:
@@ -2285,12 +2434,7 @@ max_cache_size and max_msg_age help manage duplicate message processing efficien
         return await self._post("sendContact", {"chat_id": chat_id, "first_name": first_name, "last_name": last_name, "phone_number": phone_number,"inline_keypad": inline_keypad,"chat_keypad": chat_keypad,"chat_keypad_type": chat_keypad_type})
     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", "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", "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", "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)

{rubka-7.1.9 → rubka-7.1.11}/rubka/context.py

@@ -291,6 +291,36 @@ class Message:
         self.is_archive = None
         self.is_executable = None
         self.is_font = None
+        self.metadata = self.raw_data.get("metadata", {})
+        self.is_metadata = self.metadata
+        self.meta_parts = self.metadata.get("meta_data_parts", [])
+        self.has_metadata = bool(self.meta_parts)
+        self.meta_types = [part.get("type") for part in self.meta_parts] if self.has_metadata else []
+        self.is_bold = "Bold" in self.meta_types
+        self.is_italic = "Italic" in self.meta_types
+        self.is_strike = "Strike" in self.meta_types
+        self.is_underline = "Underline" in self.meta_types
+        self.is_quote = "Quote" in self.meta_types
+        self.is_spoiler = "Spoiler" in self.meta_types
+        self.is_pre = "Pre" in self.meta_types
+        self.is_mono = "Mono" in self.meta_types
+        self.is_link_meta = "Link" in self.meta_types
+        self.meta_links = [part.get("link_url") for part in self.meta_parts if part.get("type") == "Link"]
+        self.meta_link_positions = [
+            {"from": part.get("from_index"), "length": part.get("length"), "url": part.get("link_url")}
+            for part in self.meta_parts if part.get("type") == "Link"
+        ]
+        self.has_link = contains_link_or_mention(self.text) or self.is_link_meta
+        self.is_formatted = any([
+            self.is_bold,
+            self.is_italic,
+            self.is_strike,
+            self.is_underline,
+            self.is_quote,
+            self.is_spoiler,
+            self.is_pre,
+            self.is_mono
+        ])
         self.sender_id: str = self.raw_data.get("sender_id", sender_id)
         self.time: str = self.raw_data.get("time")
         self.is_edited: bool = self.raw_data.get("is_edited", False)
@@ -337,7 +367,7 @@ class Message:
             self.bot.sessions[self.chat_id] = {}
         return self.bot.sessions[self.chat_id]
     
-    def reply(self, text: str, delete_after: int = None, **kwargs):
+    def reply(self, text: str, delete_after: int = None,parse_mode : Optional[Literal["HTML", "Markdown"]] = None , **kwargs):
         async def _reply_async():
             send_func = self.bot.send_message
             if inspect.iscoroutinefunction(send_func):
@@ -346,6 +376,7 @@ class Message:
                     text,
                     reply_to_message_id=self.message_id,
                     delete_after=delete_after,
+                    parse_mode=parse_mode,
                     **kwargs
                 )
             else:

rubka-7.1.11/rubka/metadata.py

@@ -0,0 +1,92 @@
+import re
+from typing import Any, Dict, List
+import markdownify
+class Track_parsed:
+    _PATT = re.compile(
+        r"(?P<pre>```(?P<pre_c>[\s\S]*?)```)"
+        r"|(?P<bold>\*\*(?P<bold_c>.*?)\*\*)"
+        r"|(?P<mono>`(?P<mono_c>.*?)`)"
+        r"|(?P<italic>__(?P<italic_c>.*?)__)"
+        r"|(?P<underline>--(?P<underline_c>.*?)--)"
+        r"|(?P<strike>~~(?P<strike_c>.*?)~~)"
+        r"|(?P<spoiler>\|\|(?P<spoiler_c>.*?)\|\|)"
+        r"|(?P<link>\[(?P<link_text>.*?)\]\((?P<link_url>\S+?)\))",
+        flags=re.DOTALL,
+    )
+    _TYPE_MAP = {
+        "pre": "Pre",
+        "bold": "Bold",
+        "mono": "Mono",
+        "italic": "Italic",
+        "underline": "Underline",
+        "strike": "Strike",
+        "spoiler": "Spoiler",
+        "link": "Link",
+    }
+
+    @staticmethod
+    def _utf16_len_java_style(s: str) -> int:
+        return len(s.encode("utf-16-be")) // 2
+
+    @staticmethod
+    def _html2md(src: str) -> str:
+        src = re.sub(r'<i>(.*?)</i>', r'||\1||', src, flags=re.DOTALL)
+        src = re.sub(r'<span class="spoiler">(.*?)</span>', r'||\1||', src, flags=re.DOTALL)
+        src = markdownify.markdownify(html=src).strip()
+        src = src.replace("@@SPOILER@@", "||")
+        return src
+
+    def transcribe(self, src: str, mode: str = "MARKDOWN") -> Dict[str, Any]:
+        if mode and mode.upper() == "HTML":src = self._html2md(src)
+
+        payload_parts: List[Dict[str, Any]] = []
+
+        normalized_text = src
+        byte_offset = 0
+        char_offset = 0
+
+        matches = list(self._PATT.finditer(src))
+        for m in matches:
+            whole = m.group(0)
+            start, end = m.span()
+            adj_from = self._utf16_len_java_style(src[:start]) - byte_offset
+            adj_char_from = start - char_offset
+
+            gname = m.lastgroup
+            if not gname:
+                continue
+            if gname == "link":
+                inner = m.group("link_text") or ""
+                link_href = m.group("link_url")
+            else:
+                inner = m.group(f"{gname}_c") or ""
+                link_href = None
+
+            if inner == "":
+                continue
+
+            content_utf16_len = self._utf16_len_java_style(inner)
+
+            part: Dict[str, Any] = {
+                "type": self._TYPE_MAP.get(gname, "Unknown"),
+                "from_index": adj_from,
+                "length": content_utf16_len,
+            }
+            if link_href:
+                part["link_url"] = link_href
+            payload_parts.append(part)
+            normalized_text = (
+                normalized_text[:adj_char_from] + inner + normalized_text[end - char_offset :]
+            )
+            byte_offset += self._utf16_len_java_style(whole) - content_utf16_len
+            char_offset += (end - start) - len(inner)
+
+        result: Dict[str, Any] = {"text": normalized_text.strip()}
+        if payload_parts:
+            result["metadata"] = {"meta_data_parts": payload_parts}
+
+        return result
+
+
+    def parse(self, text: str, parse_mode: str = "MARKDOWN") -> Dict[str, Any]:
+        return self.transcribe(text, mode=parse_mode)

{rubka-7.1.9 → rubka-7.1.11}/rubka/update.py

@@ -1,8 +1,68 @@
-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
+_EMOJI_PATTERN = re.compile(
+    "["
+    "\U0001F300-\U0001F5FF"
+    "\U0001F600-\U0001F64F"
+    "\U0001F680-\U0001F6FF"
+    "\U0001F700-\U0001F77F"
+    "\U0001F780-\U0001F7FF"
+    "\U0001F800-\U0001F8FF"
+    "\U0001F900-\U0001F9FF"
+    "\U0001FA00-\U0001FA6F"
+    "\U0001FA70-\U0001FAFF"
+    "\U00002700-\U000027BF"
+    "\U00002600-\U000026FF"
+    "\U00002000-\U000023FF" 
+    "]+", 
+    flags=re.UNICODE
+)
+
+def contains_emoji(text: str) -> bool:
+    if not text:return False
+    return bool(_EMOJI_PATTERN.search(text))
+
+def count_emojis(text: str) -> int:
+    if not text:return 0
+    return len(_EMOJI_PATTERN.findall(text))
+def contains_link_or_mention(text: str) -> bool:
+    if not text:return False
+    pattern = re.compile(
+        r"(?i)\b("
+        r"https?://[^\s]+"
+        r"|www\.[^\s]+"
+        r"|[a-zA-Z0-9.-]+\.(com|net|org|ir|edu|gov|info|biz|io|me|co|xyz|in|us|uk|ru|tv|cc|app|dev|site|store|cloud|shop)"
+        r"|t\.me/[^\s]+"
+        r"|telegram\.me/[^\s]+"
+        r"|rubika\.(ir|app)/[^\s]+"
+        r"|whatsapp\.com/[^\s]+"
+        r"|wa\.me/[^\s]+"
+        r"|instagram\.com/[^\s]+"
+        r"|instagr\.am/[^\s]+"
+        r"|youtube\.com/[^\s]+"
+        r"|youtu\.be/[^\s]+"
+        r"|aparat\.com/[^\s]+"
+        r"|discord\.gg/[^\s]+"
+        r"|discord\.com/[^\s]+"
+        r"|splus\.ir/[^\s]+"
+        r"|eitaa\.com/[^\s]+"
+        r"|ble\.ir/[^\s]+"
+        r"|gap\.im/[^\s]+"
+        r"|rubino\.ir/[^\s]+"
+        r"|pin\.it/[^\s]+"
+        r"|twitter\.com/[^\s]+"
+        r"|x\.com/[^\s]+"
+        r"|facebook\.com/[^\s]+"
+        r"|threads\.net/[^\s]+"
+        r"|@\w+"
+        r"|\b\d{1,3}(?:\.\d{1,3}){3}\b" 
+        r"|\[?[A-F0-9:]{2,39}\]?"
+        r")\b"
+    )
+    return bool(pattern.search(text))
 class File:
     def __init__(self, data: dict):
         self.file_id: str = data.get("file_id")
@@ -215,10 +275,52 @@ class Message:
         self.author_guid  = self.raw_data.get("sender_id", sender_id)
         self.message_id: str = self.raw_data.get("message_id", message_id)
         self.text: str = self.raw_data.get("text", text)
-        self.has_link = bool(re.search(
-    r"(https?://[^\s]+|www\.[^\s]+|[a-zA-Z0-9.-]+\.(com|net|org|ir|edu|gov|info|biz|io|me|co)|t\.me/[^\s]+|telegram\.me/[^\s]+|@\w+|\b\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\b)",
-    self.raw_data.get("text", text) or ""
-))
+        self.has_link = contains_link_or_mention(self.raw_data.get("text", text))
+        self.is_link = self.has_link
+        self.is_mention = bool(re.search(r"@\w+", self.raw_data.get("text", text) or ""))
+        self.is_hashtag = bool(re.search(r"#\w+", text or ""))
+        self.is_number = bool(re.search(r"\d+", text or ""))
+        self.is_emoji = contains_emoji(self.raw_data.get("text", text))
+        self.emoji_count = count_emojis(self.raw_data.get("text", text))
+        self.is_pure_emoji = bool(self.is_emoji and self.emoji_count == len(self.text))
+        self.is_photo = None
+        self.is_video = None
+        self.is_audio = None
+        self.is_voice = None
+        self.is_document = None
+        self.is_archive = None
+        self.is_executable = None
+        self.is_font = None
+        self.metadata = self.raw_data.get("metadata", {})
+        self.is_metadata = self.metadata
+        self.meta_parts = self.metadata.get("meta_data_parts", [])
+        self.has_metadata = bool(self.meta_parts)
+        self.meta_types = [part.get("type") for part in self.meta_parts] if self.has_metadata else []
+        self.is_bold = "Bold" in self.meta_types
+        self.is_italic = "Italic" in self.meta_types
+        self.is_strike = "Strike" in self.meta_types
+        self.is_underline = "Underline" in self.meta_types
+        self.is_quote = "Quote" in self.meta_types
+        self.is_spoiler = "Spoiler" in self.meta_types
+        self.is_pre = "Pre" in self.meta_types
+        self.is_mono = "Mono" in self.meta_types
+        self.is_link_meta = "Link" in self.meta_types
+        self.meta_links = [part.get("link_url") for part in self.meta_parts if part.get("type") == "Link"]
+        self.meta_link_positions = [
+            {"from": part.get("from_index"), "length": part.get("length"), "url": part.get("link_url")}
+            for part in self.meta_parts if part.get("type") == "Link"
+        ]
+        self.has_link = contains_link_or_mention(self.text) or self.is_link_meta
+        self.is_formatted = any([
+            self.is_bold,
+            self.is_italic,
+            self.is_strike,
+            self.is_underline,
+            self.is_quote,
+            self.is_spoiler,
+            self.is_pre,
+            self.is_mono
+        ])
         self.sender_id: str = self.raw_data.get("sender_id", sender_id)
         self.time: str = self.raw_data.get("time")
         self.is_edited: bool = self.raw_data.get("is_edited", False)
@@ -265,7 +367,7 @@ class Message:
             self.bot.sessions[self.chat_id] = {}
         return self.bot.sessions[self.chat_id]
     
-    def reply(self, text: str, delete_after: int = None, **kwargs):
+    def reply(self, text: str, delete_after: int = None,parse_mode : Optional[Literal["HTML", "Markdown"]] = None , **kwargs):
         async def _reply_async():
             send_func = self.bot.send_message
             if inspect.iscoroutinefunction(send_func):
@@ -274,6 +376,7 @@ class Message:
                     text,
                     reply_to_message_id=self.message_id,
                     delete_after=delete_after,
+                    parse_mode=parse_mode,
                     **kwargs
                 )
             else:
@@ -336,14 +439,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 +746,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 +816,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 +1027,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.9 → rubka-7.1.11}/setup.py

@@ -13,7 +13,7 @@ with open("README.md", "r", encoding="utf-8") as f:
 
 setup(
     name='Rubka',
-    version='7.1.9',
+    version='7.1.11',
     description=(
     "Rubika: A Python library for interacting with the Rubika Bot API. "
     "This library provides an easy-to-use interface to send messages, polls, "