RubigramClient 1.7.0__py3-none-any.whl → 1.7.2__py3-none-any.whl

rubigram/method/messages/edit_message.py

@@ -0,0 +1,41 @@
+from typing import Optional
+import rubigram
+
+
+class EditMessage:
+    async def edit_message(
+        self: "rubigram.Client",
+        chat_id: str,
+        message_id: Optional[str] = None,
+        text: Optional[str] = None,
+        chat_keypad: Optional["rubigram.types.Keypad"] = None,
+        inline_keypad: Optional["rubigram.types.Keypad"] = None
+    ):
+        """Edit various properties of a message.
+
+        This method allows updating a message's text, chat keypad, or inline keypad.
+
+        Args:
+            self (rubigram.Client): The active Rubigram client instance.
+            chat_id (str): The unique identifier of the chat containing the message.
+            message_id (Optional[str], optional): The unique identifier of the message to edit.
+            text (Optional[str], optional): The new message text.
+            chat_keypad (Optional[rubigram.types.Keypad], optional): A new chat keypad layout.
+            inline_keypad (Optional[rubigram.types.Keypad], optional): A new inline keypad layout.
+
+        Returns:
+            None: This method does not return a response directly.
+
+        Example:
+            >>> from rubigram.types import Keypad, KeypadRow, Button
+            >>> button = Button(id="101", button_text="rubigram")
+            >>> row = KeypadRow(buttons=[button])
+            >>> keypad = Keypad(rows=[row])
+            >>> await client.edit_message("chat123", "msg456", text="Updated!", inline_keypad=keypad)
+        """
+        if text:
+            await self.edit_message_text(chat_id, message_id, text)
+        if chat_keypad:
+            await self.edit_chat_keypad(chat_id, chat_keypad)
+        if inline_keypad:
+            await self.edit_message_keypad(chat_id, message_id, inline_keypad)

rubigram/method/messages/edit_message_keypad.py

@@ -0,0 +1,38 @@
+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 keypad (buttons) of a message.
+
+        This method updates the inline keypad of a specific message
+        in a chat with a new button layout.
+
+        Args:
+            self (rubigram.Client): The active Rubigram client instance.
+            chat_id (str): The unique identifier of the chat containing the message.
+            message_id (str): The unique identifier of the message to update.
+            inline_keypad (rubigram.types.Keypad): A `Keypad` object defining the new inline buttons.
+
+        Returns:
+            dict: The response returned by the server.
+
+        Example:
+            >>> from rubigram.types import Keypad, KeypadRow, Button
+            >>> button = Button(id="101", button_text="rubigram")
+            >>> row = KeypadRow(buttons=[button])
+            >>> keypad = Keypad(rows=[row])
+            >>> response = await client.edit_message_keypad("chat_id", "message_id", keypad)
+            >>> print(response)
+        """
+        data = {
+            "chat_id": chat_id,
+            "message_id": message_id,
+            "inline_keypad": inline_keypad.asdict()
+        }
+        return await self.request("editMessageKeypad", data)

rubigram/method/messages/edit_message_text.py

@@ -0,0 +1,34 @@
+import rubigram
+
+
+class EditMessageText:
+    async def edit_message_text(
+        self: "rubigram.Client",
+        chat_id: str,
+        message_id: str,
+        text: str
+    ):
+        """Edit the text content of a message.
+
+        This method changes the text of an existing message
+        in a specific chat.
+
+        Args:
+            self (rubigram.Client): The active Rubigram client instance.
+            chat_id (str): The unique identifier of the chat containing the message.
+            message_id (str): The unique identifier of the message to edit.
+            text (str): The new text to replace the current message content.
+
+        Returns:
+            dict: The response returned by the server.
+
+        Example:
+            >>> response = await client.edit_message_text("chat_id", "message_id", "New message text")
+            >>> print(response)
+        """
+        data = {
+            "chat_id": chat_id,
+            "message_id": message_id,
+            "text": text
+        }
+        return await self.request("editMessageText", data)

rubigram/method/messages/forward_message.py

@@ -0,0 +1,43 @@
+from typing import Optional
+import rubigram
+
+
+class ForwardMessage:
+    async def forward_message(
+        self: "rubigram.Client",
+        from_chat_id: str,
+        message_id: str,
+        to_chat_id: str,
+        disable_notification: Optional[bool] = False
+    ) -> "rubigram.types.UMessage":
+        """Forward a message from one chat to another.
+
+        This method forwards a specific message from a source chat
+        to a target chat, optionally disabling notifications.
+
+        Args:
+            self (rubigram.Client): The active Rubigram client instance.
+            from_chat_id (str): The unique identifier of the chat to forward the message from.
+            message_id (str): The unique identifier of the message to forward.
+            to_chat_id (str): The unique identifier of the chat to forward the message to.
+            disable_notification (Optional[bool], optional): Whether to disable notifications for the forwarded message. Defaults to False.
+
+        Returns:
+            rubigram.types.UMessage: The forwarded message object.
+
+        Example:
+            >>> message = await client.forward_message("from_chat_id", "message_id", "to_chat_id")
+            >>> print(message.message_id)
+        """
+        data = {
+            "from_chat_id": from_chat_id,
+            "message_id": message_id,
+            "to_chat_id": to_chat_id,
+            "disable_notification": disable_notification
+        }
+        
+        response = await self.request("forwardMessage", data)
+        message = rubigram.types.UMessage.parse(response)
+        message.chat_id = to_chat_id
+        message.client = self
+        return message

rubigram/method/messages/remove_chat_keypad.py

@@ -0,0 +1,28 @@
+import rubigram
+
+
+class RemoveChatKeypad:
+    async def remove_chat_keypad(
+        self: "rubigram.Client",
+        chat_id: str
+    ) -> dict:
+        """Remove the chat keypad from a chat.
+
+        This method removes the custom chat keypad from a specific chat.
+
+        Args:
+            self (rubigram.Client): The active Rubigram client instance.
+            chat_id (str): The unique identifier of the chat.
+
+        Returns:
+            dict: The response returned by the server.
+
+        Example:
+            >>> response = await client.remove_chat_keypad("chat_id")
+            >>> print(response)
+        """
+        data = {
+            "chat_id": chat_id,
+            "chat_keypad_type": "Remove"
+        }
+        return await self.request("editChatKeypad", data)

rubigram/method/messages/send_contact.py

@@ -0,0 +1,74 @@
+from typing import Optional
+import rubigram
+
+
+class SendContact:
+    async def send_contact(
+        self: "rubigram.Client",
+        chat_id: str,
+        first_name: str,
+        last_name: str,
+        phone_number: str,
+        chat_keypad: Optional["rubigram.types.Keypad"] = None,
+        inline_keypad: Optional["rubigram.types.Keypad"] = None,
+        chat_keypad_type: Optional["rubigram.enums.ChatKeypadType"] = None,
+        disable_notification: Optional[bool] = False,
+        reply_to_message_id: Optional[str] = None
+    ) -> "rubigram.types.UMessage":
+        """Send a contact to a chat.
+
+        This method sends a contact with first name, last name, and phone number
+        to a specified chat. Optional chat or inline keypads can be included.
+
+        Args:
+            self (rubigram.Client): The active Rubigram client instance.
+            chat_id (str): The unique identifier of the target chat.
+            first_name (str): Contact's first name.
+            last_name (str): Contact's last name.
+            phone_number (str): Contact's phone number.
+            chat_keypad (Optional[rubigram.types.Keypad], optional): Custom chat keypad. Defaults to None.
+            inline_keypad (Optional[rubigram.types.Keypad], optional): Inline keypad. Defaults to None.
+            chat_keypad_type (Optional[rubigram.enums.ChatKeypadType], optional): Type of chat keypad. Defaults to None.
+            disable_notification (Optional[bool], optional): Whether to disable notifications. Defaults to False.
+            reply_to_message_id (Optional[str], optional): Reply to a specific message ID. Defaults to None.
+
+        Returns:
+            rubigram.types.UMessage: The sent message object.
+
+        Example:
+            >>> from rubigram.types import Keypad, KeypadRow, Button
+            >>> button = Button(id="101", button_text="rubigram")
+            >>> row = KeypadRow(buttons=[button])
+            >>> keypad = Keypad(rows=[row])
+            >>> message = await client.send_contact(
+            ...     "chat_id",
+            ...     "John",
+            ...     "Doe",
+            ...     "+123456789",
+            ...     inline_keypad=keypad
+            ... )
+            >>> print(message.message_id)
+        """
+        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.asdict()
+        if inline_keypad:
+            data["inline_keypad"] = inline_keypad.asdict()
+        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)
+        message.chat_id = chat_id
+        message.client = self
+        return message

rubigram/method/messages/send_location.py

@@ -0,0 +1,70 @@
+from typing import Optional
+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["rubigram.enums.ChatKeypadType"] = None,
+        disable_notification: Optional[bool] = False,
+        reply_to_message_id: Optional[str] = None
+    ) -> "rubigram.types.UMessage":
+        """Send a location to a chat.
+
+        This method sends geographic coordinates to a specific chat,
+        with optional chat or inline keypads and notification settings.
+
+        Args:
+            self (rubigram.Client): The active Rubigram client instance.
+            chat_id (str): The unique identifier of the target chat.
+            latitude (str): Latitude of the location.
+            longitude (str): Longitude of the location.
+            chat_keypad (Optional[rubigram.types.Keypad], optional): Custom chat keypad. Defaults to None.
+            inline_keypad (Optional[rubigram.types.Keypad], optional): Inline keypad. Defaults to None.
+            chat_keypad_type (Optional[rubigram.enums.ChatKeypadType], optional): Type of chat keypad. Defaults to None.
+            disable_notification (Optional[bool], optional): Whether to disable notifications. Defaults to False.
+            reply_to_message_id (Optional[str], optional): Reply to a specific message ID. Defaults to None.
+
+        Returns:
+            rubigram.types.UMessage: The sent message object.
+
+        Example:
+            >>> from rubigram.types import Keypad, KeypadRow, Button
+            >>> button = Button(id="101", button_text="rubigram")
+            >>> row = KeypadRow(buttons=[button])
+            >>> keypad = Keypad(rows=[row])
+            >>> message = await client.send_location(
+            ...     "chat_id",
+            ...     "35.6895",
+            ...     "139.6917",
+            ...     inline_keypad=keypad
+            ... )
+            >>> print(message.message_id)
+        """
+        data = {
+            "chat_id": chat_id,
+            "latitude": latitude,
+            "longitude": longitude
+        }
+
+        if chat_keypad:
+            data["chat_keypad"] = chat_keypad.asdict()
+        if inline_keypad:
+            data["inline_keypad"] = inline_keypad.asdict()
+        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)
+        message.chat_id = chat_id
+        message.client = self
+        return message

rubigram/method/messages/send_message.py

@@ -0,0 +1,67 @@
+from typing import Optional
+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["rubigram.enums.ChatKeypadType"] = None,
+        disable_notification: Optional[bool] = False,
+        reply_to_message_id: Optional[str] = None
+    ) -> "rubigram.types.UMessage":
+        """Send a text message to a chat.
+
+        This method sends a text message to a specific chat with optional
+        chat or inline keypads, notification settings, and reply options.
+
+        Args:
+            self (rubigram.Client): The active Rubigram client instance.
+            chat_id (str): The unique identifier of the target chat.
+            text (str): The text content of the message.
+            chat_keypad (Optional[rubigram.types.Keypad], optional): Custom chat keypad. Defaults to None.
+            inline_keypad (Optional[rubigram.types.Keypad], optional): Inline keypad. Defaults to None.
+            chat_keypad_type (Optional[rubigram.enums.ChatKeypadType], optional): Type of chat keypad. Defaults to None.
+            disable_notification (Optional[bool], optional): Whether to disable notifications. Defaults to False.
+            reply_to_message_id (Optional[str], optional): Reply to a specific message ID. Defaults to None.
+
+        Returns:
+            rubigram.types.UMessage: The sent message object.
+
+        Example:
+            >>> from rubigram.types import Keypad, KeypadRow, Button
+            >>> button = Button(id="101", button_text="rubigram")
+            >>> row = KeypadRow(buttons=[button])
+            >>> keypad = Keypad(rows=[row])
+            >>> message = await client.send_message(
+            ...     "chat_id",
+            ...     "Hello, world!",
+            ...     inline_keypad=keypad,
+            ...     disable_notification=True
+            ... )
+            >>> print(message.message_id)
+        """
+        data = {
+            "chat_id": chat_id,
+            "text": text
+        }
+
+        if chat_keypad:
+            data["chat_keypad"] = chat_keypad.asdict()
+        if inline_keypad:
+            data["inline_keypad"] = inline_keypad.asdict()
+        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)
+        message.chat_id = chat_id
+        message.client = self
+        return message

rubigram/method/messages/send_poll.py

@@ -0,0 +1,71 @@
+from typing import Optional
+import rubigram
+
+
+class SendPoll:
+    async def send_poll(
+        self: "rubigram.Client",
+        chat_id: str,
+        question: str,
+        options: list[str],
+        chat_keypad: Optional["rubigram.types.Keypad"] = None,
+        inline_keypad: Optional["rubigram.types.Keypad"] = None,
+        chat_keypad_type: Optional["rubigram.enums.ChatKeypadType"] = None,
+        disable_notification: Optional[bool] = False,
+        reply_to_message_id: Optional[str] = None
+    ) -> "rubigram.types.UMessage":
+        """Send a poll to a chat.
+
+        This method sends a poll with a question and a list of options
+        to a specific chat. Optional chat or inline keypads, notification
+        settings, and reply options can be provided.
+
+        Args:
+            self (rubigram.Client): The active Rubigram client instance.
+            chat_id (str): The unique identifier of the target chat.
+            question (str): The poll question.
+            options (list[str]): List of possible answers.
+            chat_keypad (Optional[rubigram.types.Keypad], optional): Custom chat keypad. Defaults to None.
+            inline_keypad (Optional[rubigram.types.Keypad], optional): Inline keypad. Defaults to None.
+            chat_keypad_type (Optional[rubigram.enums.ChatKeypadType], optional): Type of chat keypad. Defaults to None.
+            disable_notification (Optional[bool], optional): Whether to disable notifications. Defaults to False.
+            reply_to_message_id (Optional[str], optional): Reply to a specific message ID. Defaults to None.
+
+        Returns:
+            rubigram.types.UMessage: The sent poll message object.
+
+        Example:
+            >>> from rubigram.types import Keypad, KeypadRow, Button
+            >>> button = Button(id="101", button_text="Vote")
+            >>> row = KeypadRow(buttons=[button])
+            >>> keypad = Keypad(rows=[row])
+            >>> message = await client.send_poll(
+            ...     "chat_id",
+            ...     "What's your favorite color?",
+            ...     ["Red", "Blue", "Green"],
+            ...     inline_keypad=keypad
+            ... )
+            >>> print(message.message_id)
+        """
+        data = {
+            "chat_id": chat_id,
+            "question": question,
+            "options": options
+        }
+
+        if chat_keypad:
+            data["chat_keypad"] = chat_keypad.asdict()
+        if inline_keypad:
+            data["inline_keypad"] = inline_keypad.asdict()
+        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("sendPoll", data)
+        message = rubigram.types.UMessage.parse(response)
+        message.chat_id = chat_id
+        message.client = self
+        return message

rubigram/method/messages/send_sticker.py

@@ -0,0 +1,66 @@
+from typing import Optional
+import rubigram
+
+
+class SendSticker:
+    async def send_sticker(
+        self: "rubigram.Client",
+        chat_id: str,
+        sticker_id: str,
+        chat_keypad: Optional["rubigram.types.Keypad"] = None,
+        inline_keypad: Optional["rubigram.types.Keypad"] = None,
+        chat_keypad_type: Optional["rubigram.enums.ChatKeypadType"] = None,
+        disable_notification: Optional[bool] = False,
+        reply_to_message_id: Optional[str] = None
+    ) -> "rubigram.types.UMessage":
+        """Send a sticker to a chat.
+
+        This method sends a sticker to a specific chat with optional
+        chat or inline keypads, notification settings, and reply options.
+
+        Args:
+            self (rubigram.Client): The active Rubigram client instance.
+            chat_id (str): The unique identifier of the target chat.
+            sticker_id (str): The ID of the sticker to send.
+            chat_keypad (Optional[rubigram.types.Keypad], optional): Custom chat keypad. Defaults to None.
+            inline_keypad (Optional[rubigram.types.Keypad], optional): Inline keypad. Defaults to None.
+            chat_keypad_type (Optional[rubigram.enums.ChatKeypadType], optional): Type of chat keypad. Defaults to None.
+            disable_notification (Optional[bool], optional): Whether to disable notifications. Defaults to False.
+            reply_to_message_id (Optional[str], optional): Reply to a specific message ID. Defaults to None.
+
+        Returns:
+            rubigram.types.UMessage: The sent sticker message object.
+
+        Example:
+            >>> from rubigram.types import Keypad, KeypadRow, Button
+            >>> button = Button(id="101", button_text="Sticker!")
+            >>> row = KeypadRow(buttons=[button])
+            >>> keypad = Keypad(rows=[row])
+            >>> message = await client.send_sticker(
+            ...     "chat_id",
+            ...     "sticker_id",
+            ...     inline_keypad=keypad
+            ... )
+            >>> print(message.message_id)
+        """
+        data = {
+            "chat_id": chat_id,
+            "sticker_id": sticker_id
+        }
+
+        if chat_keypad:
+            data["chat_keypad"] = chat_keypad.asdict()
+        if inline_keypad:
+            data["inline_keypad"] = inline_keypad.asdict()
+        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("sendSticker", data)
+        message = rubigram.types.UMessage.parse(response)
+        message.chat_id = chat_id
+        message.client = self
+        return message

rubigram/method/network/__init__.py

@@ -0,0 +1,7 @@
+from .request import Request
+
+
+class Network(
+    Request
+):
+    pass

rubigram/method/network/request.py

@@ -0,0 +1,20 @@
+from typing import Optional
+import rubigram
+
+
+class Request:
+    def __init__(self, client: "rubigram.Client"):
+        self.client = client
+        self.api: str = f"https://botapi.rubika.ir/v3/{client.token}/"
+
+    async def request(
+        self,
+        method: str,
+        data: Optional[dict] = {}
+    ) -> dict:
+
+        url = self.api + method
+        async with self.client.http.session.post(url, json=data) as response:
+            response.raise_for_status()
+            res: dict = await response.json()
+            return res.get("data")

rubigram/method/setting/__init__.py

@@ -0,0 +1,9 @@
+from .set_command import SetCommands
+from .update_bot_endpoint import UpdateBotEndpoints
+
+
+class Setting(
+    SetCommands,
+    UpdateBotEndpoints
+):
+    pass

rubigram/method/setting/set_command.py

@@ -0,0 +1,32 @@
+import rubigram
+
+
+class SetCommands:
+    async def set_commands(
+        self: "rubigram.Client",
+        commands: list["rubigram.types.BotCommand"]
+    ) -> dict:
+        """Set the command for bot.
+
+        Args:
+            self (rubigram.Client): ...
+            commands (list[rubigram.types.BotCommand]): ...
+
+        Returns:
+            dict: response server
+
+        Example:
+            >>> commands = [
+            >>>     rubigram.types.BotCommand(command="start", description="Start the bot"),
+            >>>     rubigram.types.BotCommand(command="help", description="Show help")
+            >>> ]
+            >>> response = await client.set_commands(commands)
+            >>> print(response)
+        """
+
+        data = {
+            "bot_commands": [command.asdict() for command in commands]
+        }
+
+        response = await self.request("setCommands", data)
+        return response

rubigram/method/setting/update_bot_endpoint.py

@@ -0,0 +1,31 @@
+from typing import Optional, Union
+import rubigram
+
+
+class UpdateBotEndpoints:
+    async def update_bot_endpoints(
+        self: "rubigram.Client",
+        url: str,
+        type: Optional[Union[str, "rubigram.enums.UpdateEndpointType"]] = "ReceiveUpdate"
+    ) -> dict:
+        """ Set the endpoint URL for receiving updates.
+
+        Args:
+            self (rubigram.Client): ...
+            url (str): your endpoint url
+            type (Optional[Union[str, rubigram.enums.UpdateEndpointType]], optional):
+            type of endpoint Defaults to "ReceiveUpdate".
+
+        Returns:
+            dict: response server
+
+        Example:
+            >>> response = await client.update_bot_endpoints("https://rubigram.bot.com")
+            >>> print(response)
+        """
+        data = {
+            "url": url,
+            "type": type
+        }
+        response = await self.client.request("updateBotEndpoints", data)
+        return response

rubigram/method/utilities/__init__.py

@@ -0,0 +1,11 @@
+from .updater import Updater
+from .dispatch import Dispatch
+from .setup_endpoint import SetupEndpoints
+
+
+class Utilities(
+    Updater,
+    Dispatch,
+    SetupEndpoints
+):
+    pass