Rubka 7.1.10__tar.gz → 7.1.12__tar.gz

{rubka-7.1.10 → rubka-7.1.12}/PKG-INFO

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Rubka
-Version: 7.1.10
+Version: 7.1.12
 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.10 → rubka-7.1.12}/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.10 → rubka-7.1.12}/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.10 → rubka-7.1.12}/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.10 → rubka-7.1.12}/rubka/context.py

@@ -367,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):
@@ -376,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.12/rubka/metadata.py

@@ -0,0 +1,102 @@
+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<link>\[(?P<link_text>.*?)\]\((?P<link_url>\S+?)\))"
+    r"|(?P<quote>\$(?P<quote_c>[\s\S]*?)\$)"
+    r"|(?P<strike>~~(?P<strike_c>.*?)~~)"
+    r"|(?P<spoiler>\|\|(?P<spoiler_c>.*?)\|\|)",
+    flags=re.DOTALL,
+)
+
+
+    
+    _TYPE_MAP = {
+        "pre": "Pre",
+        "bold": "Bold",
+        "mono": "Mono",
+        "italic": "Italic",
+        "underline": "Underline",
+        "strike": "Strike",
+        "spoiler": "Spoiler",
+        "quote": "Quote",
+        "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 gname == "quote":
+                inner_metadata = self.transcribe(inner, mode="MARKDOWN")
+                inner = inner_metadata["text"]
+                if "metadata" in inner_metadata:
+                    for part in inner_metadata["metadata"]["meta_data_parts"]:
+                        part["from_index"] += adj_from
+                        payload_parts.append(part)
+            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.10 → rubka-7.1.12}/rubka/update.py

@@ -292,6 +292,7 @@ class Message:
         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 []
@@ -366,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):
@@ -375,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.10 → rubka-7.1.12}/setup.py

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