RubigramClient 1.7.17__py3-none-any.whl

rubigram/methods/decorators/on_update_message.py

@@ -0,0 +1,70 @@
+#  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, Callable
+from rubigram.filters import Filter
+import rubigram
+
+
+class OnUpdateMessage:
+    def on_update_message(
+        self: "rubigram.Client",
+        filters: Optional["Filter"] = None
+    ):
+        """
+        **Decorator for handling edited messages.**
+            `@client.on_edit_message(filters.text)`
+
+        This decorator registers a function to handle message edit events
+        that match the specified filters. If no filters are provided,
+        all message edits will be handled.
+
+        Args:
+            filters (`Optional[Filter]`):
+                Filter to determine which message edits should be handled.
+                If None, all message edits will be processed.
+
+        Returns:
+            Callable: The decorator function.
+
+        Example:
+        .. code-block:: python
+
+            # Handle text message edits
+            @client.on_edit_message(filters.text)
+            async def handle_text_edit(client, update):
+                old_text = update.updated_message.text
+                await client.send_message(
+                    update.chat_id, 
+                    f"Message was edited to: {old_text}"
+                )
+
+            # Handle edits in specific chats only
+            @client.on_edit_message(filters.chat("g0123456789"))
+            async def handle_group_edits(client, update):
+                print(f"Message edited in group: {update.updated_message.text}")
+
+            # Handle all message edits (no filter)
+            @client.on_edit_message()
+            async def handle_all_edits(client, update):
+                print(f"Message {update.updated_message.message_id} was edited")
+
+        Note:
+            This handler only triggers for messages that have been edited,
+            not for new messages. The edited message is available in `update.updated_message`.
+        """
+        def decorator(func: Callable) -> Callable:
+            async def wrapper(
+                client: "rubigram.Client",
+                update: "rubigram.types.Update"
+            ):
+                if filters is None or await filters(client, update):
+                    await func(client, update)
+                    return True
+                return False
+
+            self.update_message_handlers.append(wrapper)
+            return func
+        return decorator

rubigram/methods/files/__init__.py

@@ -0,0 +1,32 @@
+#  RubigramClient - Rubika API library for python
+#  Copyright (C) 2025-present Javad <https://github.com/DevJavad>
+#  Github - https://github.com/DevJavad/rubigram
+
+
+from .get_file import GetFile
+from .upload_file import UploadFile
+from .get_file_name import GetFileName
+from .send_file import SendFile
+from .send_gif import SendGif
+from .send_music import SendMusic
+from .send_photo import SendPhoto
+from .send_video import SendVideo
+from .send_voice import SendVoice
+from .download_file import DownloadFile
+from .request_send_file import RequestSendFile
+
+
+class Files(
+    GetFile,
+    UploadFile,
+    GetFileName,
+    RequestSendFile,
+    SendFile,
+    SendGif,
+    SendMusic,
+    SendPhoto,
+    SendVideo,
+    SendVoice,
+    DownloadFile
+):
+    pass

rubigram/methods/files/download_file.py

@@ -0,0 +1,118 @@
+#  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 os
+import asyncio
+import rubigram
+from io import BytesIO
+from aiohttp import ClientError
+from typing import Optional, Union
+import aiofiles
+
+
+class DownloadFile:
+    """
+    File download manager for Rubika API.
+
+    This class provides an asynchronous method to download files from
+    the Rubika server by file ID, supporting saving to disk or loading
+    directly into memory. It handles HTTP errors, timeouts, and
+    filesystem exceptions.
+    """
+    __slots__ = ()
+
+    async def download_file(
+        self: "rubigram.Client",
+        file_id: str,
+        file_name: Optional[str] = None,
+        directory: Optional[str] = None,
+        chunk_size: int = 64 * 1024,
+        in_memory: bool = False,
+    ) -> Union[str, BytesIO]:
+        """
+        Download a file from Rubika by file ID.
+
+        Parameters:
+            file_id (str):
+                Unique identifier of the file to download.
+            file_name (Optional[str], default=None):
+                Custom name for the downloaded file. If not provided,
+                the name is inferred from the file URL.
+            directory (Optional[str], default=None):
+                Directory path to save the file. If None, saves to
+                the current working directory.
+            chunk_size (int, default=64*1024):
+                Size (in bytes) of each chunk to read during download.
+            in_memory (bool, default=False):
+                If True, the file will be loaded into a BytesIO buffer
+                instead of being written to disk.
+
+        Returns:
+            Union[str, BytesIO]:
+                Path to the saved file on disk, or a BytesIO buffer
+                if in_memory is True.
+
+        Raises:
+            ValueError:
+                If the file_id is invalid or the URL cannot be obtained.
+            RuntimeError:
+                If file name cannot be determined or a filesystem error occurs.
+            TimeoutError:
+                If the download times out.
+            ConnectionError:
+                If a network error occurs during download.
+
+        Example:
+        .. code-block:: python
+            # Save file to disk
+            path = await client.download_file(file_id="file_id", directory="downloads")
+
+            # Load file into memory
+            buffer = await client.download_file(file_id="file_id", in_memory=True)
+        """
+        print(file_name)
+        url = await self.get_file(file_id)
+        if url is None:
+            raise ValueError(f"Invalid file_id: {file_id}")
+
+        name = file_name or await self.get_file_name(url)
+        if name is None:
+            raise RuntimeError("Could not determine file name")
+
+        if directory:
+            os.makedirs(directory, exist_ok=True)
+            path = os.path.join(directory, name)
+        else:
+            path = name
+
+        try:
+            async with self.http.session.get(url, allow_redirects=True) as response:
+                response.raise_for_status()
+
+                if in_memory:
+                    buf = BytesIO()
+                    buf.name = name
+
+                    async for chunk in response.content.iter_chunked(chunk_size):
+                        buf.write(chunk)
+
+                    buf.seek(0)
+                    return buf
+
+                async with aiofiles.open(path, "wb") as f:
+                    async for chunk in response.content.iter_chunked(chunk_size):
+                        await f.write(chunk)
+
+                return path
+
+        except asyncio.TimeoutError as error:
+            raise TimeoutError(str(error))
+
+        except ClientError as error:
+            raise ConnectionError(str(error))
+
+        except OSError as error:
+            raise RuntimeError(str(error))

rubigram/methods/files/get_file.py

@@ -0,0 +1,41 @@
+#  RubigramClient - Rubika API library for python
+#  Copyright (C) 2025-present Javad <https://github.com/DevJavad>
+#  Github - https://github.com/DevJavad/rubigram
+
+
+from typing import Union
+import rubigram
+
+
+class GetFile:
+    """
+    File retrieval utility for Rubika API.
+
+    This class provides an asynchronous method to obtain the download
+    URL of a file stored on the Rubika server using its file ID. It
+    interacts with the Rubika API and returns a URL that can be used
+    to download the file.
+    """
+    __slots__ = ()
+
+    async def get_file(
+        self: "rubigram.Client",
+        file_id: str
+    ) -> Union[str, None]:
+        """
+        Retrieve the download URL of a file by its ID.
+
+        Parameters:
+            file_id (str):
+                Unique identifier of the file on the Rubika server.
+
+        Returns:
+            Union[str, None]:
+                The download URL of the file if found, otherwise None.
+
+        Example:
+        .. code-block:: python
+            url = await client.get_file(file_id="file_id")
+        """
+        response = await self.request("getFile", {"file_id": file_id})
+        return response.get("download_url")

rubigram/methods/files/get_file_name.py

@@ -0,0 +1,41 @@
+#  RubigramClient - Rubika API library for python
+#  Copyright (C) 2025-present Javad <https://github.com/DevJavad>
+#  Github - https://github.com/DevJavad/rubigram
+
+
+from urllib.parse import urlparse
+import os
+import rubigram
+
+
+class GetFileName:
+    """
+    Utility to extract the file name from a URL.
+
+    This class provides a simple asynchronous method to parse a
+    given file URL and return its base name. It is intended to be
+    used internally by Rubigram for file management operations.
+    """
+    __slots__ = ()
+
+    async def get_file_name(
+        self: "rubigram.Client",
+        url: str
+    ) -> str:
+        """
+        Extract the base name of a file from its URL.
+
+        Parameters:
+            url (str):
+                The full URL of the file.
+
+        Returns:
+            str: The base name of the file (e.g., "file.jpg").
+
+        Example:
+        .. code-block:: python
+            name = await client.get_file_name("https://example.com/path/to/file.png")
+            print(name)  # Output: "file.png"
+        """
+        parser = urlparse(url)
+        return os.path.basename(parser.path)

rubigram/methods/files/request_send_file.py

@@ -0,0 +1,49 @@
+#  RubigramClient - Rubika API library for python
+#  Copyright (C) 2025-present Javad <https://github.com/DevJavad>
+#  Github - https://github.com/DevJavad/rubigram
+
+
+from typing import Union
+import rubigram
+
+
+class RequestSendFile:
+    """
+    File upload URL request utility for Rubika API.
+
+    This class provides an asynchronous method to request a temporary
+    upload URL from the Rubika server. The URL can then be used to
+    upload files of a specified type.
+    """
+    __slots__ = ()
+
+    async def request_send_file(
+        self: "rubigram.Client",
+        type: Union[str, "rubigram.enums.FileType"] = "File"
+    ) -> str:
+        """
+        Request a temporary file upload URL from the Rubika server.
+
+        Parameters:
+            type (Union[str, rubigram.enums.FileType], default="File"):
+                Type of the file to upload. Can be a string or a
+                FileType enum member.
+
+        Returns:
+            str: Temporary URL for uploading the file.
+
+
+        Example:
+        .. code-block:: python
+            # Using enum
+            from rubigram.enums import FileType
+            upload_url = await client.request_send_file(type=FileType.Image)
+
+            # Using string
+            upload_url = await client.request_send_file(type="File")
+        """
+        type = type.value if isinstance(
+            type, rubigram.enums.FileType
+        ) else type
+        response = await self.request("requestSendFile", {"type": type})
+        return response["upload_url"]

rubigram/methods/files/send_file.py

@@ -0,0 +1,133 @@
+#  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
+from rubigram.utils import AutoDelete, Parser
+from pathlib import Path
+import rubigram
+
+
+class SendFile:
+    """
+    File sender for Rubika API.
+
+    This class provides an asynchronous method to send files to a
+    chat. Supports sending local files, remote URLs, bytes, file-like
+    objects, or existing File IDs. Handles uploading, metadata parsing,
+    keypads, notifications, replies, and optional auto-deletion.
+    """
+    __slots__ = ()
+
+    async def send_file(
+        self: rubigram.Client,
+        chat_id: str,
+        file: Union[str, bytes, BinaryIO],
+        caption: Optional[str] = None,
+        filename: Optional[str] = None,
+        type: Union[str, rubigram.enums.FileType] = 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: 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 file to a chat on Rubika.
+
+        Parameters:
+            chat_id (str):
+                Unique identifier of the chat to send the file to.
+            file (Union[str, bytes, BinaryIO]):
+                File path, URL, bytes, file-like object, or existing File ID.
+            caption (Optional[str], default=None):
+                Caption or text to send with the file.
+            filename (Optional[str], default=None):
+                Custom file name for uploads. Inferred if not provided.
+            type (Union[str, rubigram.enums.FileType], default="File"):
+                Type of the file to send (e.g., File, Image, 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 (e.g., persistent, one-time).
+            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 deleted automatically.
+
+        Returns:
+            rubigram.types.UMessage:
+                The sent message object.
+
+        Example:
+        .. code-block:: python
+            # Send a local file
+            message = await client.send_file(chat_id="chat_id", file="example.jpg")
+
+            # Send a file from URL
+            message = await client.send_file(chat_id="chat_id", file="https://example.com/file.png")
+
+            # Send an existing file by File ID
+            message = await client.send_file(chat_id="chat_id", file="file_id")
+
+            # Send bytes
+            message = await client.send_file(chat_id="chat_id", file=b"binary data")
+        """
+        type = type if isinstance(type, str) else type.value
+        upload_url = await self.request_send_file(type)
+
+        if isinstance(file, str):
+            if file.startswith(("http://", "https://")) or Path(file).exists():
+                file_id = await self.upload_file(upload_url, file, filename)
+            else:
+                download_url = await self.get_file(file)
+                if not download_url:
+                    raise ValueError(f"Invalid file_id: {file}")
+                file_id = await self.upload_file(upload_url, download_url, filename)
+        else:
+            file_id = await self.upload_file(upload_url, file, filename)
+
+        if not file_id:
+            raise RuntimeError("Upload succeeded but file_id is missing")
+
+        data = {"chat_id": chat_id, "file_id": file_id, "text": caption}
+        if caption:
+            parse = Parser.parser(caption, 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("sendFile", data)
+        message = rubigram.types.UMessage.parse(response, self)
+        message.chat_id = chat_id
+        message.file_id = file_id
+
+        if auto_delete and auto_delete > 0:
+            AutoDelete.run(self, message, auto_delete)
+
+        return message

rubigram/methods/files/send_gif.py

@@ -0,0 +1,51 @@
+#  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 SendGif:
+    """
+    Gif sender for Rubika API.
+
+    This class provides an asynchronous method to send Gif
+    files to a chat. It is a specialized wrapper around `send_gif`
+    that automatically sets the file type to Gif and supports
+    captions, keypads, notifications, replies, and auto-deletion.
+    """
+
+    __slots__ = ()
+
+    async def send_gif(
+        self: rubigram.Client,
+        chat_id: str,
+        gif: 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:
+        return await self.send_file(
+            chat_id,
+            gif,
+            caption,
+            filename,
+            rubigram.enums.FileType.GIF,
+            chat_keypad,
+            inline_keypad,
+            chat_keypad_type,
+            disable_notification,
+            reply_to_message_id,
+            parse_mode,
+            auto_delete
+        )

rubigram/methods/files/send_music.py

@@ -0,0 +1,97 @@
+#  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 SendMusic:
+    """
+    Music sender for Rubika API.
+
+    This class provides an asynchronous method to send music/audio
+    files to a chat. It is a specialized wrapper around `send_file`
+    that automatically sets the file type to Music and supports
+    captions, keypads, notifications, replies, and auto-deletion.
+    """
+
+    __slots__ = ()
+
+    async def send_music(
+        self: rubigram.Client,
+        chat_id: str,
+        music: 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 music/audio file to a chat on Rubika.
+
+        Parameters:
+            chat_id (str):
+                Unique identifier of the target chat.
+            music (Union[str, bytes, BinaryIO]):
+                Music source. Can be a local file path, URL, bytes,
+                file-like object, or an existing File ID.
+            caption (Optional[str], default=None):
+                Caption or description for the music.
+            filename (Optional[str], default=None):
+                Custom filename for the uploaded music.
+            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 music message object.
+
+        Example:
+        .. code-block:: python
+            # Send a local file
+            message = await client.send_music(chat_id="chat_id", music="example.mp3")
+
+            # Send a file from URL
+            message = await client.send_music(chat_id="chat_id", music="https://example.com/file.mp3")
+
+            # Send an existing file by File ID
+            message = await client.send_music(chat_id="chat_id", music="file_id")
+
+            # Send bytes
+            message = await client.send_music(chat_id="chat_id", music=b"binary data")
+            )
+        """
+        return await self.send_file(
+            chat_id,
+            music,
+            caption,
+            filename,
+            rubigram.enums.FileType.MUSIC,
+            chat_keypad,
+            inline_keypad,
+            chat_keypad_type,
+            disable_notification,
+            reply_to_message_id,
+            parse_mode,
+            auto_delete
+        )