RubigramClient 1.7.17__py3-none-any.whl

rubigram/methods/messages/edit_message_keypad.py

@@ -0,0 +1,72 @@
+#  RubigramClient - Rubika API library for python
+#  Copyright (C) 2025-present Javad <https://github.com/DevJavad>
+#  Github - https://github.com/DevJavad/rubigram
+
+
+from __future__ import annotations
+
+import rubigram
+
+
+class EditMessageKeypad:
+    async def edit_message_keypad(
+        self: rubigram.Client,
+        chat_id: str,
+        message_id: str,
+        inline_keypad: rubigram.types.Keypad
+    ):
+        """
+        **Edit the inline keyboard of a specific message.**
+            `await client.edit_message_keypad(chat_id, message_id, inline_keypad)`
+
+        This method updates the inline keyboard attached to an existing message.
+        The inline keyboard appears below the message content and provides
+        interactive buttons for users.
+
+        Args:
+            chat_id (`str`):
+                The ID of the chat where the message is located.
+
+            message_id (`str`):
+                The ID of the message to update.
+
+            inline_keypad (`rubigram.types.Keypad`):
+                The new inline keyboard object containing rows of interactive buttons.
+
+        Returns:
+            dict: The API response from Rubigram.
+
+        Example:
+        .. code-block:: python
+
+            from rubigram.types import Keypad, KeypadRow, Button
+
+            # Create an inline keyboard
+            inline_keypad = Keypad(
+                rows=[
+                    KeypadRow(buttons=[
+                        Button(button_text="Like", id="like_btn"),
+                        Button(button_text="Share", id="share_btn")
+                    ])
+                ]
+            )
+
+            # Update the message's inline keyboard
+            await client.edit_message_keypad(
+                chat_id=message_id,
+                message_id=message_id,
+                inline_keypad=inline_keypad
+            )
+
+        Note:
+            This method only affects the inline keyboard of the specified message
+            and does not modify the message text or other content.
+        """
+        return await self.request(
+            "editMessageKeypad",
+            {
+                "chat_id": chat_id,
+                "message_id": message_id,
+                "inline_keypad": inline_keypad.as_dict()
+            }
+        )

rubigram/methods/messages/edit_message_text.py

@@ -0,0 +1,68 @@
+#  RubigramClient - Rubika API library for python
+#  Copyright (C) 2025-present Javad <https://github.com/DevJavad>
+#  Github - https://github.com/DevJavad/rubigram
+
+from __future__ import annotations
+
+from typing import Optional, Union
+from rubigram.utils import Parser
+import rubigram
+
+
+class EditMessageText:
+    async def edit_message_text(
+        self: rubigram.Client,
+        chat_id: str,
+        message_id: str,
+        text: str,
+        parse_mode: Optional[Union[str, rubigram.enums.ParseMode]] = None
+    ):
+        """
+        **Edit the text content of an existing message.**
+            `await client.edit_message_text(chat_id, message_id, text)`
+
+        This method updates the text content of a previously sent message
+        while preserving other message components like inline keyboards
+        and attachments.
+
+        Args:
+            chat_id (`str`):
+                The ID of the chat where the message is located.
+
+            message_id (`str`):
+                The ID of the message to update.
+
+            text (`str`):
+                The new text content for the message.
+
+        Returns:
+            dict: The API response from Rubigram containing the updated message data.
+
+        Example:
+        .. code-block:: python
+
+            # Edit a message's text content
+            await client.edit_message_text(
+                chat_id=chat_id
+                message_id=message_id,
+                text=text
+            )
+
+        Note:
+            This method only modifies the text content of the message.
+            Other message elements like inline keyboards, files, or media
+            remain unchanged.
+        """
+        data = {
+            "chat_id": chat_id,
+            "message_id": message_id,
+            "text": text
+        }
+
+        parse = Parser.parser(text, parse_mode or self.parse_mode)
+
+        if "metadata" in parse:
+            data["text"] = parse["text"]
+            data["metadata"] = parse["metadata"]
+
+        return await self.request("editMessageText", data)

rubigram/methods/messages/forward_message.py

@@ -0,0 +1,78 @@
+#  RubigramClient - Rubika API library for python
+#  Copyright (C) 2025-present Javad <https://github.com/DevJavad>
+#  Github - https://github.com/DevJavad/rubigram
+
+
+from typing import Optional
+from rubigram.utils import AutoDelete
+import rubigram
+
+
+class ForwardMessage:
+    async def forward_message(
+        self: rubigram.Client,
+        from_chat_id: str,
+        message_id: str,
+        to_chat_id: str,
+        disable_notification: bool = False,
+        auto_delete: Optional[int] = None
+    ) -> rubigram.types.UMessage:
+        """
+        **Forward a message from one chat to another.**
+            `await client.forward_message(from_chat_id, message_id, to_chat_id)`
+
+        This method forwards an existing message from a source chat to a
+        destination chat while preserving all message content, attachments,
+        and metadata.
+
+        Args:
+            from_chat_id (`str`):
+                The ID of the chat where the original message is located.
+
+            message_id (`str`):
+                The ID of the message to forward.
+
+            to_chat_id (`str`):
+                The ID of the destination chat where the message will be forwarded.
+
+            disable_notification (`Optional[bool]`):
+                If True, disables notification for the forwarded message.
+                Defaults to False.
+                
+            auto_delete (`Optional[int]`):
+                If set, the message will be automatically deleted after the specified number of seconds.
+
+        Returns:
+            rubigram.types.UMessage: The forwarded message object with client binding.
+
+        Example:
+        .. code-block:: python
+
+            # Forward a message from one chat to another
+            forwarded_message = await client.forward_message(
+                from_chat_id=from_chat_id,
+                message_id=message_id,
+                to_chat_id=to_chat_id,
+                disable_notification=True
+            )
+
+        Note:
+            The original message remains unchanged in the source chat.
+            The forwarded message includes all original content and attachments.
+        """
+        response = await self.request(
+            "forwardMessage",
+            {
+                "from_chat_id": from_chat_id,
+                "message_id": message_id,
+                "to_chat_id": to_chat_id,
+                "disable_notification": disable_notification
+            }
+        )
+        message = rubigram.types.UMessage.parse(response, self)
+        message.chat_id = to_chat_id
+        
+        if auto_delete and auto_delete > 0:
+            AutoDelete.run(self, message, auto_delete)
+            
+        return message

rubigram/methods/messages/remove_chat_keypad.py

@@ -0,0 +1,46 @@
+#  RubigramClient - Rubika API library for python
+#  Copyright (C) 2025-present Javad <https://github.com/DevJavad>
+#  Github - https://github.com/DevJavad/rubigram
+
+
+from __future__ import annotations
+
+import rubigram
+
+
+class RemoveChatKeypad:
+    async def remove_chat_keypad(
+        self: rubigram.Client,
+        chat_id: str
+    ):
+        """
+        **Remove the custom keypad from a chat.**
+            `await client.remove_chat_keypad(chat_id)`
+
+        This method removes any custom keyboard (keypad) from the specified chat,
+        restoring the default keyboard interface for all users in the chat.
+
+        Args:
+            chat_id (`str`):
+                The ID of the chat where the keypad should be removed.
+
+        Returns:
+            dict: The API response from Rubigram.
+
+        Example:
+        .. code-block:: python
+
+            # Remove custom keypad from a chat
+            await client.remove_chat_keypad(chat_id=chat_id)
+
+        Note:
+            This action affects all users in the chat and cannot be undone
+            without setting a new keypad.
+        """
+        return await self.request(
+            "editChatKeypad",
+            {
+                "chat_id": chat_id,
+                "chat_keypad_type": "Remove"
+            }
+        )

rubigram/methods/messages/send_contact.py

@@ -0,0 +1,114 @@
+#  RubigramClient - Rubika API library for python
+#  Copyright (C) 2025-present Javad <https://github.com/DevJavad>
+#  Github - https://github.com/DevJavad/rubigram
+
+
+from __future__ import annotations
+
+from typing import Optional, Union
+from rubigram.utils import AutoDelete
+import rubigram
+
+
+class SendContact:
+    async def send_contact(
+        self: rubigram.Client,
+        chat_id: str,
+        phone_number: str,
+        first_name: str,
+        last_name: Optional[str] = None,
+        chat_keypad: Optional[rubigram.types.Keypad] = None,
+        inline_keypad: Optional[rubigram.types.Keypad] = None,
+        chat_keypad_type: Optional[Union[str, rubigram.enums.ChatKeypadType]] = None,
+        disable_notification: bool = False,
+        reply_to_message_id: Optional[str] = None,
+        auto_delete: Optional[int] = None
+    ) -> rubigram.types.UMessage:
+        """
+        **Send a contact to a chat.**
+            `await client.send_contact(chat_id, phone_number, first_name, last_name)`
+
+        This method sends a contact card with phone number and name information
+        to the specified chat. The contact can be saved directly to the user's
+        device contacts.
+
+        Args:
+            chat_id (`str`):
+                The ID of the chat where the contact will be sent.
+
+            phone_number (`str`):
+                The contact's phone number.
+
+            first_name (`str`):
+                The contact's first name.
+
+            last_name (`Optional[str]`):
+                The contact's last name. Defaults to None.
+
+            chat_keypad (`Optional[rubigram.types.Keypad]`):
+                Custom keyboard to show in the chat. Defaults to None.
+
+            inline_keypad (`Optional[rubigram.types.Keypad]`):
+                Inline keyboard to attach to the message. Defaults to None.
+
+            chat_keypad_type (`Optional[rubigram.enums.ChatKeypadType]`):
+                Type of chat keypad. Defaults to None.
+
+            disable_notification (`Optional[bool]`):
+                If True, disables notification for the message. Defaults to False.
+
+            reply_to_message_id (`Optional[str]`):
+                ID of the message to reply to. Defaults to None.
+
+            auto_delete (`Optional[int]`):
+                If set, the message will be automatically deleted after the specified number of seconds.
+
+        Returns:
+            rubigram.types.UMessage: The sent contact message object.
+
+        Example:
+        .. code-block:: python
+
+            # Send a contact with full details
+            await client.send_contact(
+                chat_id=chat_id,
+                phone_number="+1234567890",
+                first_name="John",
+                last_name="Doe",
+                disable_notification=True
+            )
+
+        Note:
+            The contact information will be displayed as a clickable card
+            that users can save to their device contacts.
+        """
+        data = {
+            "chat_id": chat_id,
+            "first_name": first_name,
+            "last_name": last_name,
+            "phone_number": phone_number
+        }
+
+        if chat_keypad:
+            data["chat_keypad"] = chat_keypad.as_dict()
+
+        if inline_keypad:
+            data["inline_keypad"] = inline_keypad.as_dict()
+
+        if chat_keypad_type:
+            data["chat_keypad_type"] = chat_keypad_type
+
+        if disable_notification:
+            data["disable_notification"] = disable_notification
+
+        if reply_to_message_id:
+            data["reply_to_message_id"] = reply_to_message_id
+
+        response = await self.request("sendContact", data)
+        message = rubigram.types.UMessage.parse(response, self)
+        message.client = self
+
+        if auto_delete and auto_delete > 0:
+            AutoDelete.run(self, message, auto_delete)
+
+        return message

rubigram/methods/messages/send_location.py

@@ -0,0 +1,108 @@
+#  RubigramClient - Rubika API library for python
+#  Copyright (C) 2025-present Javad <https://github.com/DevJavad>
+#  Github - https://github.com/DevJavad/rubigram
+
+
+from __future__ import annotations
+
+from typing import Optional, Union
+from rubigram.utils import AutoDelete
+import rubigram
+
+
+class SendLocation:
+    async def send_location(
+        self: rubigram.Client,
+        chat_id: str,
+        latitude: str,
+        longitude: str,
+        chat_keypad: Optional[rubigram.types.Keypad] = None,
+        inline_keypad: Optional[rubigram.types.Keypad] = None,
+        chat_keypad_type: Optional[Union[str, rubigram.enums.ChatKeypadType]] = None,
+        disable_notification: bool = False,
+        reply_to_message_id: Optional[str] = None,
+        auto_delete: Optional[int] = None
+    ) -> rubigram.types.UMessage:
+        """
+        **Send a location to a chat.**
+            `await client.send_location(chat_id, latitude, longitude)`
+
+        This method sends a geographical location to the specified chat.
+        The location appears as an interactive map that users can tap to
+        open in their maps application.
+
+        Args:
+            chat_id (`str`):
+                The ID of the chat where the location will be sent.
+
+            latitude (`str`):
+                The latitude coordinate of the location.
+
+            longitude (`str`):
+                The longitude coordinate of the location.
+
+            chat_keypad (`Optional[rubigram.types.Keypad]`):
+                Custom keyboard to show in the chat. Defaults to None.
+
+            inline_keypad (`Optional[rubigram.types.Keypad]`):
+                Inline keyboard to attach to the message. Defaults to None.
+
+            chat_keypad_type (`Optional[rubigram.enums.ChatKeypadType]`):
+                Type of chat keypad. Defaults to None.
+
+            disable_notification (`Optional[bool]`):
+                If True, disables notification for the message. Defaults to False.
+
+            reply_to_message_id (`Optional[str]`):
+                ID of the message to reply to. Defaults to None.
+
+            auto_delete (`Optional[int]`):
+                If set, the message will be automatically deleted after the specified number of seconds.
+
+        Returns:
+            rubigram.types.UMessage: The sent location message object.
+
+        Example:
+        .. code-block:: python
+
+            # Send a location (Tokyo coordinates)
+            await client.send_location(
+                chat_id=chat_id,
+                latitude="35.6895",
+                longitude="139.6917",
+                disable_notification=True
+            )
+
+        Note:
+            The location will be displayed as an interactive map preview
+            that users can tap to open in their preferred maps application.
+        """
+        data = {
+            "chat_id": chat_id,
+            "latitude": latitude,
+            "longitude": longitude
+        }
+
+        if chat_keypad:
+            data["chat_keypad"] = chat_keypad.as_dict()
+
+        if inline_keypad:
+            data["inline_keypad"] = inline_keypad.as_dict()
+
+        if chat_keypad_type:
+            data["chat_keypad_type"] = chat_keypad_type
+
+        if disable_notification:
+            data["disable_notification"] = disable_notification
+
+        if reply_to_message_id:
+            data["reply_to_message_id"] = reply_to_message_id
+
+        response = await self.request("sendLocation", data)
+        message = rubigram.types.UMessage.parse(response, self)
+        message.chat_id = chat_id
+
+        if auto_delete and auto_delete > 0:
+            AutoDelete.run(self, message, auto_delete)
+
+        return message

rubigram/methods/messages/send_message.py

@@ -0,0 +1,115 @@
+#  RubigramClient - Rubika API library for python
+#  Copyright (C) 2025-present Javad <https://github.com/DevJavad>
+#  Github - https://github.com/DevJavad/rubigram
+
+
+from __future__ import annotations
+
+from typing import Optional, Union
+from rubigram.utils import AutoDelete, Parser
+import rubigram
+
+    
+
+class SendMessage:
+    async def send_message(
+        self: rubigram.Client,
+        chat_id: str,
+        text: str,
+        chat_keypad: Optional[rubigram.types.Keypad] = None,
+        inline_keypad: Optional[rubigram.types.Keypad] = None,
+        chat_keypad_type: Optional[Union[str, rubigram.enums.ChatKeypadType]] = None,
+        disable_notification: bool = False,
+        reply_to_message_id: Optional[str] = None,
+        parse_mode: Optional[Union[str, rubigram.enums.ParseMode]] = None,
+        auto_delete: Optional[int] = None
+    ) -> rubigram.types.UMessage:
+        """
+        **Send a text message to a chat.**
+            `await client.send_message(chat_id, text)`
+
+        This method sends a text message to the specified chat with optional
+        keyboards, notification settings, and reply functionality.
+
+        Args:
+            chat_id (`str`):
+                The ID of the chat where the message will be sent.
+
+            text (`str`):
+                The text content of the message.
+
+            chat_keypad (`Optional[rubigram.types.Keypad]`):
+                Custom keyboard to show in the chat. Defaults to None.
+
+            inline_keypad (`Optional[rubigram.types.Keypad]`):
+                Inline keyboard to attach below the message. Defaults to None.
+
+            chat_keypad_type (`Optional[rubigram.enums.ChatKeypadType]`):
+                Type of chat keypad (New, Remove). Defaults to None.
+
+            disable_notification (`Optional[bool]`):
+                If True, disables notification for the message. Defaults to False.
+
+            reply_to_message_id (`Optional[str]`):
+                ID of the message to reply to. Defaults to None.
+            
+            auto_delete (`Optional[int]`):
+                If set, the message will be automatically deleted after the specified number of seconds.
+
+        Returns:
+            rubigram.types.UMessage: The sent message object with client binding.
+
+        Example:
+        .. code-block:: python
+
+            from rubigram.types import Keypad, KeypadRow, Button
+
+            # Create an inline keyboard
+            inline_keypad = Keypad(rows=[
+                KeypadRow(buttons=[
+                    Button(button_text="Option 1", id="btn1"),
+                    Button(button_text="Option 2", id="btn2")
+                ])
+            ])
+
+            # Send a message with inline keyboard
+            await client.send_message(
+                chat_id=chat_id,
+                text=text,
+                inline_keypad=inline_keypad,
+                disable_notification=True
+            )
+
+        Note:
+            The returned UMessage object includes methods for editing,
+            deleting, and forwarding the message.
+        """
+        
+        data = {"chat_id": chat_id, "text": text}
+        
+        parse = Parser.parser(text, parse_mode or self.parse_mode)
+        
+        if "metadata" in parse:
+            data["text"] = parse["text"]
+            data["metadata"] = parse["metadata"]
+
+        if chat_keypad:
+            data["chat_keypad"] = chat_keypad.as_dict()
+        if inline_keypad:
+            data["inline_keypad"] = inline_keypad.as_dict()
+        if chat_keypad_type:
+            data["chat_keypad_type"] = chat_keypad_type
+        if disable_notification:
+            data["disable_notification"] = disable_notification
+        if reply_to_message_id:
+            data["reply_to_message_id"] = reply_to_message_id
+
+        
+        response = await self.request("sendMessage", data)
+        message = rubigram.types.UMessage.parse(response, self)
+        message.chat_id = chat_id
+        
+        if auto_delete and auto_delete > 0:
+            AutoDelete.run(self, message, auto_delete)
+            
+        return message