RubigramClient 1.7.17__py3-none-any.whl

rubigram/methods/files/send_photo.py

@@ -0,0 +1,95 @@
+#  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, BinaryIO
+import rubigram
+
+class SendPhoto:
+    """
+    Photo sender for Rubika API.
+
+    This class provides an asynchronous method to send photos/images
+    to a chat. It is a specialized wrapper around `send_file` that
+    automatically sets the file type to Image and supports captions,
+    keypads, notifications, replies, and auto-deletion.
+    """
+
+    __slots__ = ()
+
+    async def send_photo(
+        self: rubigram.Client,
+        chat_id: str,
+        photo: Union[str, bytes, BinaryIO],
+        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: 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 photo/image to a chat on Rubika.
+
+        Parameters:
+            chat_id (str):
+                Unique identifier of the target chat.
+            photo (Union[str, bytes, BinaryIO]):
+                Photo source. Can be a local file path, URL, bytes,
+                file-like object, or an existing File ID.
+            caption (Optional[str], default=None):
+                Caption or text to send with the photo.
+            filename (Optional[str], default=None):
+                Custom filename for the uploaded photo.
+            chat_keypad (Optional[rubigram.types.Keypad], default=None):
+                Custom chat keypad to attach to the message.
+            inline_keypad (Optional[rubigram.types.Keypad], default=None):
+                Inline keypad to attach to the message.
+            chat_keypad_type (Optional[rubigram.enums.ChatKeypadType], default=None):
+                Type of chat keypad.
+            disable_notification (bool, default=False):
+                If True, sends the message silently.
+            reply_to_message_id (Optional[str], default=None):
+                Message ID to reply to.
+            auto_delete (Optional[int], default=None):
+                Time in seconds after which the message will be
+                automatically deleted.
+
+        Returns:
+            rubigram.types.UMessage:
+                The sent photo message object.
+
+        Example:
+        .. code-block:: python
+            # Send a local photo
+            message = await client.send_photo(chat_id="chat_id", photo="image.jpg")
+
+            # Send a photo from URL
+            message = await client.send_photo(chat_id="chat_id", photo="https://example.com/image.png")
+
+            # Send an existing photo by File ID
+            message = await client.send_photo(chat_id="chat_id", photo="file_id")
+
+            # Send photo bytes
+            message = await client.send_photo(chat_id="chat_id", photo=b"binary data")
+        """
+        return await self.send_file(
+            chat_id,
+            photo,
+            caption,
+            filename,
+            rubigram.enums.FileType.IMAGE,
+            chat_keypad,
+            inline_keypad,
+            chat_keypad_type,
+            disable_notification,
+            reply_to_message_id,
+            parse_mode,
+            auto_delete
+        )

rubigram/methods/files/send_video.py

@@ -0,0 +1,96 @@
+#  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, BinaryIO
+import rubigram
+
+
+class SendVideo:
+    """
+    Video sender for Rubika API.
+
+    This class provides an asynchronous method to send video files
+    to a chat. It is a specialized wrapper around `send_file` that
+    automatically sets the file type to Video and supports captions,
+    keypads, notifications, replies, and auto-deletion.
+    """
+
+    __slots__ = ()
+
+    async def send_video(
+        self: rubigram.Client,
+        chat_id: str,
+        video: Union[str, bytes, BinaryIO],
+        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: 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 video to a chat on Rubika.
+
+        Parameters:
+            chat_id (str):
+                Unique identifier of the target chat.
+            video (Union[str, bytes, BinaryIO]):
+                Video source. Can be a local file path, URL, bytes,
+                file-like object, or an existing File ID.
+            caption (Optional[str], default=None):
+                Caption or text to send with the video.
+            filename (Optional[str], default=None):
+                Custom filename for the uploaded video.
+            chat_keypad (Optional[rubigram.types.Keypad], default=None):
+                Custom chat keypad to attach to the message.
+            inline_keypad (Optional[rubigram.types.Keypad], default=None):
+                Inline keypad to attach to the message.
+            chat_keypad_type (Optional[rubigram.enums.ChatKeypadType], default=None):
+                Type of chat keypad.
+            disable_notification (bool, default=False):
+                If True, sends the message silently.
+            reply_to_message_id (Optional[str], default=None):
+                Message ID to reply to.
+            auto_delete (Optional[int], default=None):
+                Time in seconds after which the message will be
+                automatically deleted.
+
+        Returns:
+            rubigram.types.UMessage:
+                The sent video message object.
+
+        Example:
+        .. code-block:: python
+            # Send a local video
+            message = await client.send_video(chat_id="chat_id", video="video.mp4")
+
+            # Send a video from URL
+            message = await client.send_video(chat_id="chat_id", video="https://example.com/video.mp4")
+
+            # Send an existing video by File ID
+            message = await client.send_video(chat_id="chat_id", video="file_id")
+
+            # Send video bytes
+            message = await client.send_video(chat_id="chat_id", video=b"binary data")
+        """
+        return await self.send_file(
+            chat_id,
+            video,
+            caption,
+            filename,
+            rubigram.enums.FileType.VIDEO,
+            chat_keypad,
+            inline_keypad,
+            chat_keypad_type,
+            disable_notification,
+            reply_to_message_id,
+            parse_mode,
+            auto_delete
+        )

rubigram/methods/files/send_voice.py

@@ -0,0 +1,96 @@
+#  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, BinaryIO
+import rubigram
+
+
+class SendVoice:
+    """
+    Voice message sender for Rubika API.
+
+    This class provides an asynchronous method to send voice/audio
+    messages to a chat. It is a specialized wrapper around `send_file`
+    that automatically sets the file type to Voice and supports
+    captions, keypads, notifications, replies, and auto-deletion.
+    """
+
+    __slots__ = ()
+
+    async def send_voice(
+        self: rubigram.Client,
+        chat_id: str,
+        voice: Union[str, bytes, BinaryIO],
+        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: 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 voice message to a chat on Rubika.
+
+        Parameters:
+            chat_id (str):
+                Unique identifier of the target chat.
+            voice (Union[str, bytes, BinaryIO]):
+                Voice source. Can be a local file path, URL, bytes,
+                file-like object, or an existing File ID.
+            caption (Optional[str], default=None):
+                Caption or text to send with the voice message.
+            filename (Optional[str], default=None):
+                Custom filename for the uploaded voice file.
+            chat_keypad (Optional[rubigram.types.Keypad], default=None):
+                Custom chat keypad to attach to the message.
+            inline_keypad (Optional[rubigram.types.Keypad], default=None):
+                Inline keypad to attach to the message.
+            chat_keypad_type (Optional[rubigram.enums.ChatKeypadType], default=None):
+                Type of chat keypad.
+            disable_notification (Optional[bool], default=False):
+                If True, sends the message silently.
+            reply_to_message_id (Optional[str], default=None):
+                Message ID to reply to.
+            auto_delete (Optional[int], default=None):
+                Time in seconds after which the message will be
+                automatically deleted.
+
+        Returns:
+            rubigram.types.UMessage:
+                The sent voice message object.
+
+        Example:
+        .. code-block:: python
+            # Send a local voice file
+            message = await client.send_voice(chat_id="chat_id", voice="voice.ogg")
+
+            # Send a voice message from URL
+            message = await client.send_voice(chat_id="chat_id", voice="https://example.com/voice.ogg")
+
+            # Send an existing voice by File ID
+            message = await client.send_voice(chat_id="chat_id", voice="file_id")
+
+            # Send voice bytes
+            message = await client.send_voice(chat_id="chat_id", voice=b"binary data")
+        """
+        return await self.send_file(
+            chat_id,
+            voice,
+            caption,
+            filename,
+            rubigram.enums.FileType.VOICE,
+            chat_keypad,
+            inline_keypad,
+            chat_keypad_type,
+            disable_notification,
+            reply_to_message_id,
+            parse_mode,
+            auto_delete
+        )

rubigram/methods/files/upload_file.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 aiohttp import FormData, ClientError
+from aiohttp import FormData, ClientError, payload
+from typing import Union, Optional, BinaryIO
+from pathlib import Path
+from aiohttp import FormData
+import asyncio
+import rubigram
+import logging
+
+
+logger = logging.getLogger(__name__)
+
+
+class UploadFile:
+    """
+    File uploader for Rubika API.
+
+    This class provides an asynchronous method to upload files to a
+    temporary Rubika upload URL. It supports local file paths, remote
+    URLs, bytes, and file-like objects, and handles network and timeout
+    errors.
+    """
+
+    __slots__ = ()
+
+    async def upload_file(
+        self: "rubigram.Client",
+        upload_url: str,
+        file: Union[str, bytes, BinaryIO],
+        name: Optional[str] = None,
+    ) -> Union[str, None]:
+        """
+        Upload a file to a temporary Rubika upload URL.
+
+        Parameters:
+            upload_url (str):
+                The temporary URL obtained from `request_send_file`.
+            file (Union[str, bytes, BinaryIO]):
+                File path, remote URL, bytes, or file-like object to upload.
+            name (Optional[str], default=None):
+                Custom name for the uploaded file. If None, the name
+                is inferred from the file path or URL, or defaults to "file".
+
+        Returns:
+            Union(str, None):
+                The file_id returned by Rubika after a successful upload,
+                or None if the server response does not contain a file_id.
+
+        Raises:
+            TimeoutError:
+                If the upload times out.
+            ConnectionError:
+                If a network error occurs during upload.
+
+        Example:
+        .. code-block:: python
+            # Upload a local file
+            file_id = await client.upload_file(upload_url, "example.jpg")
+
+            # Upload from URL
+            file_id = await client.upload_file(upload_url, "https://example.com/file.png")
+
+            # Upload from bytes
+            file_id = await client.upload_file(upload_url, b"binary data")
+        """
+        if isinstance(file, str):
+            if file.startswith(("http://", "https://")):
+                async with self.http.session.get(file) as response:
+                    response.raise_for_status()
+                    data = await response.read()
+                    if not name:
+                        if response.content_type == "application/octet-stream":
+                            ext = "ogg"
+                        else:
+                            ext = f"{str(response.content_type).split("/")[1]}"
+                        name = await self.get_file_name(file) or f"rubigram.{ext}"
+            else:
+                data = Path(file).read_bytes()
+                name = name or Path(file).name
+        else:
+            data = file.read() if hasattr(file, "read") else file
+            name = file.name if hasattr(file, "name") else "file.bin"
+
+        form = FormData()
+        form.add_field(
+            "file", payload.BytesPayload(data), filename=name
+        )
+
+        try:
+            async with self.http.session.post(upload_url, data=form) as response:
+                result: dict = await response.json()
+                if result.get("status") == "OK":
+                    logger.debug("Upload file, name=%s", name)
+                    return result.get("data", {}).get("file_id")
+
+                elif result.get("status") == "INVALID_INPUT":
+                    raise rubigram.errors.InvalidInput(result)
+
+                elif result.get("status") == "INVALID_ACCESS":
+                    raise rubigram.errors.InvalidAccess(result)
+
+                else:
+                    raise Exception(str(result))
+
+        except asyncio.TimeoutError as error:
+            raise TimeoutError(str(error))
+
+        except ClientError as error:
+            raise ConnectionError(str(error))

rubigram/methods/messages/__init__.py

@@ -0,0 +1,34 @@
+#  RubigramClient - Rubika API library for python
+#  Copyright (C) 2025-present Javad <https://github.com/DevJavad>
+#  Github - https://github.com/DevJavad/rubigram
+
+
+from .delete_messages import DeleteMessage
+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
+from .remove_chat_keypad import RemoveChatKeypad
+from .send_contact import SendContact
+from .send_location import SendLocation
+from .send_message import SendMessage
+from .send_poll import SendPoll
+from .send_sticker import SendSticker
+
+
+class Messages(
+    DeleteMessage,
+    EditChatKeypad,
+    EditMessageKeypad,
+    EditMessageText,
+    EditMessage,
+    ForwardMessage,
+    RemoveChatKeypad,
+    SendContact,
+    SendLocation,
+    SendMessage,
+    SendPoll,
+    SendSticker
+):
+    pass

rubigram/methods/messages/delete_messages.py

@@ -0,0 +1,84 @@
+#  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 Union
+import asyncio
+import rubigram
+
+
+class DeleteMessage:
+    async def delete_messages(
+        self: rubigram.Client,
+        chat_id: str,
+        message_ids: Union[str, int, list[Union[str, int]]]
+    ) -> dict:
+        """
+        **Delete one or multiple messages from a chat.**
+            `await client.delete_message(chat_id, message_id)`
+
+        This method can delete a single message or multiple messages in bulk.
+        When deleting multiple messages, it uses asyncio.gather for efficient
+        parallel execution.
+
+        Args:
+            chat_id (`str`):
+                The ID of the chat where the message(s) are located.
+
+            message_ids (`Union[str, int, list[Union[str, int]]]`):
+                Single message ID or list of message IDs to delete.
+
+        Returns:
+            dict: A dictionary containing deletion results with the following keys:
+                - success (int): Number of successfully deleted messages
+                - failed (int): Number of messages that failed to delete
+                - details (list): List of individual deletion responses
+
+        Example:
+        .. code-block:: python
+
+            # Delete a single message
+            result = await client.delete_message(
+                chat_id=chat_id,
+                message_ids=message_id
+            )
+
+            # Delete multiple messages
+            message_ids = ["12345", "12346", "12347"]
+            result = await client.delete_message(
+                chat_id=chat_id,
+                message_ids=message_ids
+            )
+            print(f"Success: {result['success']}, Failed: {result['failed']}")
+
+        Note:
+            When deleting multiple messages, the operation continues even if
+            some deletions fail. Check the 'failed' count and 'details' for
+            individual results.
+        """
+        if isinstance(message_ids, (str, int)):
+            return await self.request("deleteMessage", {"chat_id": chat_id, "message_id": str(message_ids)})
+
+        elif isinstance(message_ids, list):
+            ids = [str(i) for i in message_ids]
+
+        tasks = [
+            self.request(
+                "deleteMessage",
+                {"chat_id": chat_id, "message_id": id}
+            )
+            for id in ids
+        ]
+
+        responses = await asyncio.gather(*tasks, return_exceptions=True)
+        success = sum(1 for r in responses if not isinstance(r, Exception))
+        failed = len(responses) - success
+
+        return {
+            "success": success,
+            "failed": failed,
+            "details": responses
+        }

rubigram/methods/messages/edit_chat_keypad.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
+
+import rubigram
+
+
+class EditChatKeypad:
+    async def edit_chat_keypad(
+        self: rubigram.Client,
+        chat_id: str,
+        chat_keypad: rubigram.types.Keypad
+    ):
+        """
+        **Edit the chat keypad for a specific chat.**
+            `await client.edit_chat_keypad(chat_id, chat_keypad)`
+
+        This method updates the custom keyboard (keypad) for the specified chat.
+        The new keypad will be displayed to all users in the chat.
+
+        Args:
+            chat_id (`str`):
+                The ID of the chat where the keypad should be updated.
+
+            chat_keypad (`rubigram.types.Keypad`):
+                The new keypad object containing rows of buttons and display settings.
+
+        Returns:
+            dict: The API response from Rubigram.
+
+        Example:
+        .. code-block:: python
+
+            from rubigram.types import Keypad, KeypadRow, Button
+
+            # Create a new keypad
+            keypad = Keypad(
+                rows=[
+                    KeypadRow(buttons=[
+                        Button(button_text="Option 1", id="btn1"),
+                        Button(button_text="Option 2", id="btn2")
+                    ])
+                ],
+                resize_keyboard=True
+            )
+
+            # Update the chat keypad
+            await client.edit_chat_keypad(
+                chat_id=chat_id,
+                chat_keypad=keypad
+            )
+
+        Note:
+            This method sets the keypad type to "New" by default, replacing
+            any existing keypad in the chat.
+        """
+
+        return await self.request(
+            "editChatKeypad",
+            {
+                "chat_id": chat_id,
+                "chat_keypad_type": "New",
+                "chat_keypad": chat_keypad.as_dict()
+            }
+        )

rubigram/methods/messages/edit_message.py

@@ -0,0 +1,82 @@
+#  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
+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,
+        parse_mode: Optional[Union[str, rubigram.enums.ParseMode]] = None
+    ):
+        """
+        **Edit various components of a message or chat.**
+            `await client.edit_message(chat_id, message_id, text=text, inline_keypad=keypad)`
+
+        This method provides a unified way to update message text, chat keypads,
+        and inline keyboards in a single call. You can update one or more
+        components simultaneously.
+
+        Args:
+            chat_id (`str`):
+                The ID of the chat where the edits should be applied.
+
+            message_id (`Optional[str]`):
+                The ID of the message to edit (required for text and inline keyboard edits).
+
+            text (`Optional[str]`):
+                New text content for the message. If provided, updates the message text.
+
+            chat_keypad (`Optional[rubigram.types.Keypad]`):
+                New chat keypad to set for the chat. Updates the keyboard for all users.
+
+            inline_keypad (`Optional[rubigram.types.Keypad]`):
+                New inline keyboard to attach to the message. Updates buttons below the message.
+
+        Returns:
+            None: This method doesn't return a value as it may perform multiple operations.
+
+        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")
+                ])
+            ])
+
+            # Edit message text and inline keyboard
+            await client.edit_message(
+                chat_id=chat_id,
+                message_id=message_id,
+                text=text,
+                inline_keypad=inline_keypad
+            )
+
+        Note:
+            - At least one of `text`, `chat_keypad`, or `inline_keypad` must be provided
+            - `message_id` is required when editing text or inline keyboards
+            - Chat keypad updates affect the entire chat, not just a specific message
+        """
+        if text:
+            return await self.edit_message_text(chat_id, message_id, text, parse_mode)
+
+        if chat_keypad:
+            return await self.edit_chat_keypad(chat_id, chat_keypad)
+
+        if inline_keypad:
+            return await self.edit_message_keypad(chat_id, message_id, inline_keypad)