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

rubigram/method/file/request_send_file.py

@@ -0,0 +1,28 @@
+from typing import Optional
+import rubigram
+
+
+class RequestSendFile:
+    async def request_send_file(
+        self: "rubigram.Client",
+        type: Optional[str] = "File"
+    ) -> str:
+        """Request a file upload URL from the server.
+
+        This method asks the server to generate an upload URL for sending
+        a file. The type of file can be specified.
+
+        Args:
+            self (rubigram.Client): The active Rubigram client instance.
+            type (Optional[str], optional): Type of file. Defaults to "File".
+
+        Returns:
+            str: The upload URL to send the file.
+
+        Example:
+            >>> upload_url = await client.request_send_file()
+            >>> print(upload_url)
+        """
+        data = {"type": type}
+        response = await self.request("requestSendFile", data)
+        return response["upload_url"]

rubigram/method/file/request_upload_file.py

@@ -0,0 +1,62 @@
+from typing import Union, Optional
+from pathlib import Path
+from aiohttp import FormData
+import rubigram
+
+
+class RequestUploadFile:
+    async def request_upload_file(
+        self: "rubigram.Client",
+        upload_url: str,
+        file: Union[str, bytes],
+        name: Optional[str] = None
+    ) -> str:
+        """Upload a file and return its file ID.
+
+        Supports local file paths, URLs, or raw bytes. If sending raw bytes,
+        the `name` argument must be provided.
+
+        Args:
+            self (rubigram.Client): The active Rubigram client instance.
+            upload_url (str): The URL to upload the file to (from `request_send_file`).
+            file (Union[str, bytes]): File path, URL, or raw bytes.
+            name (Optional[str], optional): File name for raw bytes or to override the default.
+
+        Returns:
+            str: The uploaded file's ID.
+
+        Example:
+            >>> file_id = await client.request_upload(
+            >>>     upload_url="https://upload.rubigram.com",
+            >>>     file="path/to/file.png"
+            >>> )
+            >>> print(file_id)
+        """
+        if isinstance(file, str):
+            path = Path(file)
+            if path.is_file():
+                data, filename = path.read_bytes(), name or path.name
+            elif file.startswith("http"):
+                data = await self.get_bytes(file)
+                filename = name or await self.get_file_name(file)
+            else:
+                raise FileNotFoundError("File not found : {}".format(file))
+        elif isinstance(file, bytes):
+            if not name:
+                raise ValueError("A name must be provided for bytes file")
+            data, filename = file, name
+        else:
+            raise TypeError("`file` must be a string path, URL, or bytes")
+
+        form = FormData()
+        form.add_field(
+            "file",
+            data,
+            filename=filename,
+            content_type="application/octet-stream"
+        )
+
+        async with self.http.session.post(upload_url, data=form) as response:
+            response.raise_for_status()
+            result = await response.json()
+            return result.get("data", {}).get("file_id")

rubigram/method/file/send_document.py

@@ -0,0 +1,58 @@
+from typing import Optional, Union
+import rubigram
+
+
+class SendDocument:
+    async def send_document(
+        self: "rubigram.Client",
+        chat_id: str,
+        document: Union[str, bytes],
+        caption: Optional[str] = None,
+        filename: Optional[str] = None,
+        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 document to a chat.
+
+        This is a wrapper around `send_file` to explicitly indicate
+        that the file is a document. It supports local files, URLs, or raw bytes.
+
+        Args:
+            self (rubigram.Client): The active Rubigram client instance.
+            chat_id (str): The ID of the chat to send the document to.
+            document (Union[str, bytes]): Local path, URL, or raw bytes of the document.
+            caption (Optional[str], optional): Text caption for the document. Defaults to None.
+            filename (Optional[str], optional): Filename to use for raw bytes. Defaults to None.
+            chat_keypad (Optional[rubigram.types.Keypad], optional): Chat keypad to include. Defaults to None.
+            inline_keypad (Optional[rubigram.types.Keypad], optional): Inline keypad to include. Defaults to None.
+            chat_keypad_type (Optional[rubigram.enums.ChatKeypadType], optional): Chat keypad type. Defaults to None.
+            disable_notification (Optional[bool], optional): Whether to disable notifications. Defaults to False.
+            reply_to_message_id (Optional[str], optional): ID of message to reply to. Defaults to None.
+
+        Returns:
+            rubigram.types.UMessage: The sent message object containing message ID, file ID, and chat ID.
+
+        Example:
+            >>> message = await client.send_document(
+            >>>     chat_id="chat_id",
+            >>>     document="path/to/file.pdf",
+            >>>     caption="Here is the document"
+            >>> )
+            >>> print(message.message_id)
+            >>> print(message.file_id)
+        """
+        return await self.send_file(
+            chat_id=chat_id,
+            file=document,
+            caption=caption,
+            filename=filename,
+            type="File",
+            chat_keypad=chat_keypad,
+            inline_keypad=inline_keypad,
+            chat_keypad_type=chat_keypad_type,
+            disable_notification=disable_notification,
+            reply_to_message_id=reply_to_message_id
+        )

rubigram/method/file/send_file.py

@@ -0,0 +1,78 @@
+from typing import Optional, Union
+import rubigram
+
+
+class SendFile:
+    async def send_file(
+        self: "rubigram.Client",
+        chat_id: str,
+        file: Union[str, bytes],
+        caption: Optional[str] = None,
+        filename: Optional[str] = None,
+        type: Optional[Union[str, "rubigram.enums.FileType"]] = "File",
+        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 file to a chat.
+
+        Uploads a file (local path, URL, or raw bytes) and sends it to the specified chat,
+        optionally with caption, keypads, or as a reply.
+
+        Args:
+            self (rubigram.Client): The active Rubigram client instance.
+            chat_id (str): The ID of the chat to send the file to.
+            file (Union[str, bytes]): File path, URL, or raw bytes to send.
+            caption (Optional[str], optional): Text caption for the file. Defaults to None.
+            filename (Optional[str], optional): Filename to use for raw bytes. Defaults to None.
+            type (Optional[Union[str, rubigram.enums.FileType]], optional): Type of file. Defaults to "File".
+            chat_keypad (Optional[rubigram.types.Keypad], optional): Chat keypad to include. Defaults to None.
+            inline_keypad (Optional[rubigram.types.Keypad], optional): Inline keypad to include. Defaults to None.
+            chat_keypad_type (Optional[rubigram.enums.ChatKeypadType], optional): Chat keypad type. Defaults to None.
+            disable_notification (Optional[bool], optional): Whether to disable notifications. Defaults to False.
+            reply_to_message_id (Optional[str], optional): ID of message to reply to. Defaults to None.
+
+        Returns:
+            rubigram.types.UMessage: The sent message object containing message ID, file ID, and chat ID.
+
+        Example:
+            >>> message = await client.send_file(
+            >>>     chat_id="chat_id",
+            >>>     file="path/to/file.png",
+            >>>     caption="Hello!",
+            >>> )
+            >>> print(message.message_id)
+            >>> print(message.file_id)
+        """
+        upload_url = await self.request_send_file(type)
+        file_id = await self.request_upload_file(upload_url, file, filename)
+
+        data = {
+            "chat_id": chat_id,
+            "file_id": file_id,
+            "text": caption
+        }
+
+        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("sendFile", data)
+        message = rubigram.types.UMessage.parse(response)
+        message.chat_id = chat_id
+        message.file_id = file_id
+        message.client = self
+        return message

rubigram/method/file/send_gif.py

@@ -0,0 +1,58 @@
+from typing import Optional, Union
+import rubigram
+
+
+class SendGif:
+    async def send_gif(
+        self: "rubigram.Client",
+        chat_id: str,
+        document: Union[str, bytes],
+        caption: Optional[str] = None,
+        filename: Optional[str] = None,
+        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 GIF file to a chat.
+
+        This is a wrapper around `send_file` to specifically send GIFs.
+        Supports local files, URLs, or raw bytes.
+
+        Args:
+            self (rubigram.Client): The active Rubigram client instance.
+            chat_id (str): The ID of the chat to send the GIF to.
+            document (Union[str, bytes]): Local path, URL, or raw bytes of the GIF.
+            caption (Optional[str], optional): Text caption for the GIF. Defaults to None.
+            filename (Optional[str], optional): Filename to use for raw bytes. Defaults to None.
+            chat_keypad (Optional[rubigram.types.Keypad], optional): Chat keypad to include. Defaults to None.
+            inline_keypad (Optional[rubigram.types.Keypad], optional): Inline keypad to include. Defaults to None.
+            chat_keypad_type (Optional[rubigram.enums.ChatKeypadType], optional): Chat keypad type. Defaults to None.
+            disable_notification (Optional[bool], optional): Whether to disable notifications. Defaults to False.
+            reply_to_message_id (Optional[str], optional): ID of message to reply to. Defaults to None.
+
+        Returns:
+            rubigram.types.UMessage: The sent message object containing message ID, file ID, and chat ID.
+
+        Example:
+            >>> message = await client.send_gif(
+            >>>     chat_id="chat_id",
+            >>>     document="path/to/animation.gif",
+            >>>     caption="Funny GIF"
+            >>> )
+            >>> print(message.message_id)
+            >>> print(message.file_id)
+        """
+        return await self.send_file(
+            chat_id=chat_id,
+            file=document,
+            caption=caption,
+            filename=filename,
+            type="Gif",
+            chat_keypad=chat_keypad,
+            inline_keypad=inline_keypad,
+            chat_keypad_type=chat_keypad_type,
+            disable_notification=disable_notification,
+            reply_to_message_id=reply_to_message_id
+        )

rubigram/method/file/send_music.py

@@ -0,0 +1,58 @@
+from typing import Optional, Union
+import rubigram
+
+
+class SendMusic:
+    async def send_music(
+        self: "rubigram.Client",
+        chat_id: str,
+        document: Union[str, bytes],
+        caption: Optional[str] = None,
+        filename: Optional[str] = None,
+        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 music file to a chat.
+
+        This is a wrapper around `send_file` to specifically send audio/music files.
+        Supports local files, URLs, or raw bytes.
+
+        Args:
+            self (rubigram.Client): The active Rubigram client instance.
+            chat_id (str): The ID of the chat to send the music to.
+            document (Union[str, bytes]): Local path, URL, or raw bytes of the music file.
+            caption (Optional[str], optional): Text caption for the music. Defaults to None.
+            filename (Optional[str], optional): Filename to use for raw bytes. Defaults to None.
+            chat_keypad (Optional[rubigram.types.Keypad], optional): Chat keypad to include. Defaults to None.
+            inline_keypad (Optional[rubigram.types.Keypad], optional): Inline keypad to include. Defaults to None.
+            chat_keypad_type (Optional[rubigram.enums.ChatKeypadType], optional): Chat keypad type. Defaults to None.
+            disable_notification (Optional[bool], optional): Whether to disable notifications. Defaults to False.
+            reply_to_message_id (Optional[str], optional): ID of message to reply to. Defaults to None.
+
+        Returns:
+            rubigram.types.UMessage: The sent message object containing message ID, file ID, and chat ID.
+
+        Example:
+            >>> message = await client.send_music(
+            >>>     chat_id="chat_id",
+            >>>     document="path/to/song.mp3",
+            >>>     caption="My favorite song"
+            >>> )
+            >>> print(message.message_id)
+            >>> print(message.file_id)
+        """
+        return await self.send_file(
+            chat_id=chat_id,
+            file=document,
+            caption=caption,
+            filename=filename,
+            type="Music",
+            chat_keypad=chat_keypad,
+            inline_keypad=inline_keypad,
+            chat_keypad_type=chat_keypad_type,
+            disable_notification=disable_notification,
+            reply_to_message_id=reply_to_message_id
+        )

rubigram/method/file/send_photo.py

@@ -0,0 +1,58 @@
+from typing import Optional, Union
+import rubigram
+
+
+class SendPhoto:
+    async def send_photo(
+        self: "rubigram.Client",
+        chat_id: str,
+        document: Union[str, bytes],
+        caption: Optional[str] = None,
+        filename: Optional[str] = None,
+        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 photo to a chat.
+
+        This method allows sending an image file from a local path, URL, or raw bytes.
+        You can also attach chat or inline keypads and set notification options.
+
+        Args:
+            self (rubigram.Client): The active Rubigram client instance.
+            chat_id (str): The ID of the chat to send the photo to.
+            document (Union[str, bytes]): Local path, URL, or raw bytes of the photo.
+            caption (Optional[str], optional): Caption text for the photo. Defaults to None.
+            filename (Optional[str], optional): Filename to use for raw bytes. Defaults to None.
+            chat_keypad (Optional[rubigram.types.Keypad], optional): Chat keypad to include. Defaults to None.
+            inline_keypad (Optional[rubigram.types.Keypad], optional): Inline keypad to include. Defaults to None.
+            chat_keypad_type (Optional[rubigram.enums.ChatKeypadType], optional): Chat keypad type. Defaults to None.
+            disable_notification (Optional[bool], optional): Disable notification for this message. Defaults to False.
+            reply_to_message_id (Optional[str], optional): ID of message to reply to. Defaults to None.
+
+        Returns:
+            rubigram.types.UMessage: The sent message object containing message ID, file ID, and chat ID.
+
+        Example:
+            >>> message = await client.send_photo(
+            >>>     chat_id="chat_id",
+            >>>     document="path/to/photo.jpg",
+            >>>     caption="Check this out!"
+            >>> )
+            >>> print(message.message_id)
+            >>> print(message.file_id)
+        """
+        return await self.send_file(
+            chat_id=chat_id,
+            file=document,
+            caption=caption,
+            filename=filename,
+            type="Image",
+            chat_keypad=chat_keypad,
+            inline_keypad=inline_keypad,
+            chat_keypad_type=chat_keypad_type,
+            disable_notification=disable_notification,
+            reply_to_message_id=reply_to_message_id
+        )

rubigram/method/file/send_video.py

@@ -0,0 +1,58 @@
+from typing import Optional, Union
+import rubigram
+
+
+class SendVideo:
+    async def send_video(
+        self: "rubigram.Client",
+        chat_id: str,
+        document: Union[str, bytes],
+        caption: Optional[str] = None,
+        filename: Optional[str] = None,
+        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 video to a chat.
+
+        This method allows sending a video file from a local path, URL, or raw bytes.
+        You can also attach chat or inline keypads and set notification options.
+
+        Args:
+            self (rubigram.Client): The active Rubigram client instance.
+            chat_id (str): The ID of the chat to send the video to.
+            document (Union[str, bytes]): Local path, URL, or raw bytes of the video.
+            caption (Optional[str], optional): Caption text for the video. Defaults to None.
+            filename (Optional[str], optional): Filename to use for raw bytes. Defaults to None.
+            chat_keypad (Optional[rubigram.types.Keypad], optional): Chat keypad to include. Defaults to None.
+            inline_keypad (Optional[rubigram.types.Keypad], optional): Inline keypad to include. Defaults to None.
+            chat_keypad_type (Optional[rubigram.enums.ChatKeypadType], optional): Chat keypad type. Defaults to None.
+            disable_notification (Optional[bool], optional): Disable notification for this message. Defaults to False.
+            reply_to_message_id (Optional[str], optional): ID of message to reply to. Defaults to None.
+
+        Returns:
+            rubigram.types.UMessage: The sent message object containing message ID, file ID, and chat ID.
+
+        Example:
+            >>> message = await client.send_video(
+            >>>     chat_id="chat_id",
+            >>>     document="path/to/video.mp4",
+            >>>     caption="Watch this!"
+            >>> )
+            >>> print(message.message_id)
+            >>> print(message.file_id)
+        """
+        return await self.send_file(
+            chat_id=chat_id,
+            file=document,
+            caption=caption,
+            filename=filename,
+            type="Video",
+            chat_keypad=chat_keypad,
+            inline_keypad=inline_keypad,
+            chat_keypad_type=chat_keypad_type,
+            disable_notification=disable_notification,
+            reply_to_message_id=reply_to_message_id
+        )

rubigram/method/file/send_voice.py

@@ -0,0 +1,55 @@
+from typing import Optional, Union
+import rubigram
+
+
+class SendVoice:
+    async def send_voice(
+        self: "rubigram.Client",
+        chat_id: str,
+        document: Union[str, bytes],
+        caption: Optional[str] = None,
+        filename: Optional[str] = None,
+        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 voice message to a chat.
+
+        Args:
+            self (rubigram.Client): The active Rubigram client instance.
+            chat_id (str): The ID of the chat to send the voice message to.
+            document (Union[str, bytes]): Local path, URL, or raw bytes of the voice file.
+            caption (Optional[str], optional): Caption text. Defaults to None.
+            filename (Optional[str], optional): Filename for raw bytes. Defaults to None.
+            chat_keypad (Optional[rubigram.types.Keypad], optional): Chat keypad to include. Defaults to None.
+            inline_keypad (Optional[rubigram.types.Keypad], optional): Inline keypad to include. Defaults to None.
+            chat_keypad_type (Optional[rubigram.enums.ChatKeypadType], optional): Chat keypad type. Defaults to None.
+            disable_notification (Optional[bool], optional): Disable notification for this message. Defaults to False.
+            reply_to_message_id (Optional[str], optional): ID of message to reply to. Defaults to None.
+
+        Returns:
+            rubigram.types.UMessage: The sent message object with message ID, file ID, and chat ID.
+
+        Example:
+            >>> message = await client.send_voice(
+            >>>     chat_id="chat_id",
+            >>>     document="path/to/voice.ogg",
+            >>>     caption="Listen!"
+            >>> )
+            >>> print(message.message_id)
+            >>> print(message.file_id)
+        """
+        return await self.send_file(
+            chat_id=chat_id,
+            file=document,
+            caption=caption,
+            filename=filename,
+            type="Voice",
+            chat_keypad=chat_keypad,
+            inline_keypad=inline_keypad,
+            chat_keypad_type=chat_keypad_type,
+            disable_notification=disable_notification,
+            reply_to_message_id=reply_to_message_id
+        )

rubigram/method/messages/__init__.py

@@ -0,0 +1,29 @@
+from .send_message import SendMessage
+from .send_poll import SendPoll
+from .send_location import SendLocation
+from .send_contact import SendContact
+from .send_sticker import SendSticker
+from .delete_message import DeleteMessage
+from .remove_chat_keypad import RemoveChatKeypad
+from .edit_chat_keypad import EditChatKeypad
+from .edit_message_keypad import EditMessageKeypad
+from .edit_message_text import EditMessageText
+from .edit_message import EditMessage
+from .forward_message import ForwardMessage
+
+
+class Message(
+    SendMessage,
+    SendPoll,
+    SendLocation,
+    SendContact,
+    SendSticker,
+    DeleteMessage,
+    RemoveChatKeypad,
+    EditChatKeypad,
+    EditMessageKeypad,
+    EditMessageText,
+    EditMessage,
+    ForwardMessage
+):
+    pass

rubigram/method/messages/delete_message.py

@@ -0,0 +1,50 @@
+from typing import Union
+import asyncio
+import rubigram
+
+
+class DeleteMessage:
+    async def delete_message(
+        self: "rubigram.Client",
+        chat_id: str,
+        message_id: Union[str, list[str]]
+    ):
+        """Delete one or more messages from a chat.
+
+        This method deletes a single message or multiple messages
+        from a specific chat.
+
+        Args:
+            self (rubigram.Client): The active Rubigram client instance.
+            chat_id (str): The unique identifier of the chat.
+            message_id (Union[str, list[str]]): A message ID or list of message IDs to delete.
+
+        Returns:
+            Any: API response for a single message, or the number of deletions for multiple messages.
+
+        Example:
+            >>> await client.delete_message("chat_id", "msg_id")
+            >>> await client.delete_message("chat_id", ["msg1", "msg2"])
+        """
+        if isinstance(message_id, str):
+            return await self.request(
+                "deleteMessage",
+                {
+                    "chat_id": chat_id,
+                    "message_id": message_id
+                }
+            )
+
+        tasks = [
+            self.request(
+                "deleteMessage",
+                {
+                    "chat_id": chat_id,
+                    "message_id": i
+                }
+            )
+            for i in message_id
+        ]
+
+        responses = await asyncio.gather(*tasks, return_exceptions=True)
+        return len(responses)

rubigram/method/messages/edit_chat_keypad.py

@@ -0,0 +1,34 @@
+import rubigram
+
+
+class EditChatKeypad:
+    async def edit_chat_keypad(
+        self: "rubigram.Client",
+        chat_id: str,
+        chat_keypad: "rubigram.types.Keypad"
+    ):
+        """
+        Edit the keypad (custom button layout) of a chat.
+
+        This method updates or replaces the current chat keypad
+        (custom buttons) with a new layout.
+
+        Args:
+            chat_id (str): The unique identifier of the chat where the keypad should be updated.
+            chat_keypad (rubigram.bot.types.Keypad): A `Keypad` object defining the new button layout.
+
+        Returns:
+            Any: The API response returned by the server.
+
+        Example:
+            >>> from rubigram.bot.types import Keypad, Button
+            >>> keypad = Keypad(rows=[[Button(text="Menu"), Button(text="Help")]])
+            >>> await client.edit_chat_keypad("chat123", keypad)
+        """
+        data = {
+            "chat_id": chat_id,
+            "chat_keypad_type": "New",
+            "chat_keypad": chat_keypad.asdict()
+        }
+
+        return await self.request("editChatKeypad", data)