Rubka 6.6.2__py3-none-any.whl → 7.1.17__py3-none-any.whl

rubka/button.py

@@ -371,7 +371,7 @@ class InlineBuilder:
 
     def build(self) -> Dict:
         return {"rows": self.rows}
-class ChatKeypadBuilder:
+class ChatKeypadBuilder(InlineBuilder):
     def __init__(self):
         self.rows: List[Dict[str, List[Dict[str, str]]]] = []
 

rubka/context.py

@@ -1,5 +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")
@@ -184,9 +247,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
 
+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
@@ -196,6 +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 = 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)
@@ -226,19 +351,85 @@ class Message:
         self.is_contact = self.contact_message is not None
         self.has_any_media = any([self.file, self.sticker, self.poll, self.location, self.live_location])
         self.edited_text = self.raw_data.get("edited_text") if self.is_edited else None
-        self.info = {attr: value for attr, value in vars(self).items()}
+        if self.file and self.file.file_name:
+            name = self.file.file_name.lower()
+            self.is_photo = name.endswith((".jpg", ".jpeg", ".png", ".gif", ".webp"))
+            self.is_video = name.endswith((".mp4", ".mov", ".avi", ".mkv", ".webm"))
+            self.is_audio = name.endswith((".mp3", ".wav", ".ogg", ".m4a", ".flac"))
+            self.is_voice = name.endswith((".ogg", ".m4a"))
+            self.is_document = name.endswith((".pdf", ".doc", ".docx", ".txt", ".xls", ".xlsx", ".ppt", ".pptx"))
+            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"))
     @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,parse_mode : Optional[Literal["HTML", "Markdown"]] = 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,
+                    parse_mode=parse_mode,
+                    **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,
@@ -246,15 +437,42 @@ 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", {
+    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(
@@ -457,6 +675,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")
@@ -467,37 +693,346 @@ class InlineMessage:
     def __init__(self, bot, raw_data: dict):
         self.bot = bot
         self.raw_data = raw_data
-        
+        chat_id : str = raw_data.get("chat_id")
+        sender_id : str = raw_data.get("sender_id")
         self.chat_id: str = raw_data.get("chat_id")
         self.message_id: str = raw_data.get("message_id")
         self.sender_id: str = raw_data.get("sender_id")
         self.text: str = raw_data.get("text")
         self.aux_data = AuxData(raw_data.get("aux_data", {})) if "aux_data" in raw_data else None
+        self.bot = bot
+        self.raw_data = raw_data or {}
+        self.object_guid = chat_id
+        self.author_guid  = self.raw_data.get("sender_id", sender_id)
+        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.text))
+        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)
+        self.sender_type: str = self.raw_data.get("sender_type")
+        self.args = []
+        self.is_command = bool(self.text and self.text.startswith("/"))
+        self.is_user = self.chat_id.startswith("b")
+        self.is_private = self.chat_id.startswith("b")
+        self.is_group = self.chat_id.startswith("g")
+        self.is_channel = self.chat_id.startswith("c")
+        self.reply_to_message_id: Optional[str] = self.raw_data.get("reply_to_message_id")
+        self.forwarded_from = ForwardedFrom(self.raw_data["forwarded_from"]) if "forwarded_from" in self.raw_data else None
+        self.file = File(self.raw_data["file"]) if "file" in self.raw_data else None
+        self.sticker = Sticker(self.raw_data["sticker"]) if "sticker" in self.raw_data else None
+        self.contact_message = ContactMessage(self.raw_data["contact_message"]) if "contact_message" in self.raw_data else None
+        self.aux_data = AuxData(self.raw_data["aux_data"]) if "aux_data" in self.raw_data else None
+        self.is_reply = self.reply_to_message_id is not None
+        self.has_media = any([self.file, self.sticker])
+        self.is_forwarded = self.forwarded_from is not None
+        self.is_text = bool(self.text and not self.has_media)
+        self.is_media = self.has_media
+        self.is_contact = self.contact_message is not None
+        self.has_any_media = any([self.file, self.sticker,])
+        self.edited_text = self.raw_data.get("edited_text") if self.is_edited else None
+        if self.file and self.file.file_name:
+            name = self.file.file_name.lower()
+            self.is_photo = name.endswith((".jpg", ".jpeg", ".png", ".gif", ".webp"))
+            self.is_video = name.endswith((".mp4", ".mov", ".avi", ".mkv", ".webm"))
+            self.is_audio = name.endswith((".mp3", ".wav", ".ogg", ".m4a", ".flac"))
+            self.is_voice = name.endswith((".ogg", ".m4a"))
+            self.is_document = name.endswith((".pdf", ".doc", ".docx", ".txt", ".xls", ".xlsx", ".ppt", ".pptx"))
+            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"))
+        
 
-    def reply(self, text: str, **kwargs):
+    @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, 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,
+            text,
+            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", {
+            "chat_id": self.chat_id,
+            "question": question,
+            "options": options,
+            "reply_to_message_id": self.message_id,
+            **kwargs
+        })
+    
+
+    def reply_document(
+        self,
+        path: Optional[Union[str, Path]] = None,
+        file_id: Optional[str] = None,
+        text: Optional[str] = None,
+        chat_keypad: Optional[Dict[str, Any]] = None,
+        inline_keypad: Optional[Dict[str, Any]] = None,
+        chat_keypad_type: Optional[str] = "None",
+        disable_notification: bool = False
+    ):
+        if chat_keypad and chat_keypad_type == "none":chat_keypad_type == "New"
+        return self.bot.send_document(
+            chat_id=self.chat_id,
+            path=path,
+            file_id=file_id,
+            text=text,
+            chat_keypad=chat_keypad,
+            inline_keypad=inline_keypad,
+            chat_keypad_type=chat_keypad_type,
+            disable_notification=disable_notification,
+            reply_to_message_id=self.message_id
+        )
+    def reply_file(
+        self,
+        path: Optional[Union[str, Path]] = None,
+        file_id: Optional[str] = None,
+        text: Optional[str] = None,
+        chat_keypad: Optional[Dict[str, Any]] = None,
+        inline_keypad: Optional[Dict[str, Any]] = None,
+        chat_keypad_type: Optional[str] = "None",
+        disable_notification: bool = False
+    ):
+        if chat_keypad and chat_keypad_type == "none":
+            chat_keypad_type == "New"
+
+        return self.bot.send_document(
             chat_id=self.chat_id,
+            path=path,
+            file_id=file_id,
             text=text,
+            chat_keypad=chat_keypad,
+            inline_keypad=inline_keypad,
+            chat_keypad_type=chat_keypad_type,
+            disable_notification=disable_notification,
+            reply_to_message_id=self.message_id
+        )
+
+    def reply_image(
+        self,
+        path: Optional[Union[str, Path]] = None,
+        file_id: Optional[str] = None,
+        text: Optional[str] = None,
+        chat_keypad: Optional[Dict[str, Any]] = None,
+        inline_keypad: Optional[Dict[str, Any]] = None,
+        chat_keypad_type: Optional[str] = "None",
+        disable_notification: bool = False
+    ):
+        if chat_keypad and chat_keypad_type == "none":
+            chat_keypad_type == "New"
+        return self.bot.send_image(
+            chat_id=self.chat_id,
+            path=path,
+            file_id=file_id,
+            text=text,
+            chat_keypad=chat_keypad,
+            inline_keypad=inline_keypad,
+            chat_keypad_type=chat_keypad_type,
+            disable_notification=disable_notification,
+            reply_to_message_id=self.message_id
+        )
+
+    def reply_music(
+        self,
+        path: Optional[Union[str, Path]] = None,
+        file_id: Optional[str] = None,
+        text: Optional[str] = None,
+        chat_keypad: Optional[Dict[str, Any]] = None,
+        inline_keypad: Optional[Dict[str, Any]] = None,
+        chat_keypad_type: Optional[str] = "None",
+        disable_notification: bool = False
+    ):
+        if chat_keypad and chat_keypad_type == "none":
+            chat_keypad_type == "New"
+        return self.bot.send_music(
+            chat_id=self.chat_id,
+            path=path,
+            file_id=file_id,
+            text=text,
+            chat_keypad=chat_keypad,
+            inline_keypad=inline_keypad,
+            chat_keypad_type=chat_keypad_type,
+            disable_notification=disable_notification,
+            reply_to_message_id=self.message_id
+        )
+
+    def reply_voice(
+        self,
+        path: Optional[Union[str, Path]] = None,
+        file_id: Optional[str] = None,
+        text: Optional[str] = None,
+        chat_keypad: Optional[Dict[str, Any]] = None,
+        inline_keypad: Optional[Dict[str, Any]] = None,
+        chat_keypad_type: Optional[str] = "None",
+        disable_notification: bool = False
+    ):
+        if chat_keypad and chat_keypad_type == "none":
+            chat_keypad_type == "New"
+        return self.bot.send_voice(
+            chat_id=self.chat_id,
+            path=path,
+            file_id=file_id,
+            text=text,
+            chat_keypad=chat_keypad,
+            inline_keypad=inline_keypad,
+            chat_keypad_type=chat_keypad_type,
+            disable_notification=disable_notification,
+            reply_to_message_id=self.message_id
+        )
+
+    def reply_gif(
+        self,
+        path: Optional[Union[str, Path]] = None,
+        file_id: Optional[str] = None,
+        text: Optional[str] = None,
+        chat_keypad: Optional[Dict[str, Any]] = None,
+        inline_keypad: Optional[Dict[str, Any]] = None,
+        chat_keypad_type: Optional[str] = "None",
+        disable_notification: bool = False
+    ):
+        if chat_keypad and chat_keypad_type == "none":chat_keypad_type == "New"
+        return self.bot.send_gif(
+            chat_id=self.chat_id,
+            path=path,
+            file_id=file_id,
+            text=text,
+            chat_keypad=chat_keypad,
+            inline_keypad=inline_keypad,
+            chat_keypad_type=chat_keypad_type,
+            disable_notification=disable_notification,
+            reply_to_message_id=self.message_id
+        )
+
+    def reply_location(self, latitude: str, longitude: str, **kwargs) -> Dict[str, Any]:
+        return self.bot.send_location(
+            chat_id=self.chat_id,
+            latitude=latitude,
+            longitude=longitude,
             reply_to_message_id=self.message_id,
             **kwargs
         )
-    def answer(self, text: str, **kwargs):
+
+    def reply_contact(self, first_name: str, last_name: str, phone_number: str, **kwargs) -> Dict[str, Any]:
+        return self.bot.send_contact(
+            chat_id=self.chat_id,
+            first_name=first_name,
+            last_name=last_name,
+            phone_number=phone_number,
+            reply_to_message_id=self.message_id,
+            **kwargs
+        )
+
+    def reply_keypad(self, text: str, keypad: Dict[str, Any], **kwargs) -> Dict[str, Any]:
         return self.bot.send_message(
-            self.chat_id,
-            text,
+            chat_id=self.chat_id,
+            text=text,
+            chat_keypad_type="New",
+            chat_keypad=keypad,
+            reply_to_message_id=self.message_id,
+            **kwargs
+        )
+
+    def reply_inline(self, text: str, inline_keypad: Dict[str, Any], **kwargs) -> Dict[str, Any]:
+        return self.bot.send_message(
+            chat_id=self.chat_id,
+            text=text,
+            inline_keypad=inline_keypad,
             reply_to_message_id=self.message_id,
             **kwargs
         )
 
-    def edit(self, new_text: str):
+    def reply_sticker(self, sticker_id: str, **kwargs) -> Dict[str, Any]:
+        return self.bot._post("sendSticker", {
+            "chat_id": self.chat_id,
+            "sticker_id": sticker_id,
+            "reply_to_message_id": self.message_id,
+            **kwargs
+        })
+
+    def edit(self, new_text: str) -> Dict[str, Any]:
         return self.bot.edit_message_text(
             chat_id=self.chat_id,
             message_id=self.message_id,
             text=new_text
         )
 
-    def delete(self):
+    def delete(self) -> Dict[str, Any]:
         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)