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

rubigram/handler.py

@@ -0,0 +1,24 @@
+from typing import Callable, Optional
+import rubigram
+
+
+class Handler:
+    def __init__(
+        self,
+        func: Callable,
+        filters: Optional[str] = None,  # Filter Class
+        group: Optional[int] = 1
+    ):
+        self.func = func
+        self.filters = filters
+        self.group = group
+
+    async def runner(
+        self,
+        client,
+        update: "rubigram.types.Update"
+    ):
+        if self.filters is None or await self.filters(update):
+            await self.func(client, update)
+            return True
+        return False

rubigram/http.py

@@ -0,0 +1,32 @@
+from aiohttp import ClientSession, TCPConnector, ClientTimeout
+from typing import Optional
+import logging
+
+
+logger = logging.getLogger(__name__)
+
+
+class Http:
+    def __init__(self, timeout: Optional[float] = 30):
+        self.timeout = timeout
+        self.session: Optional[ClientSession] = None
+
+    async def connect(self):
+        connector = TCPConnector(limit=100)
+        timeout = ClientTimeout(total=self.timeout)
+        if self.session is None:
+            self.session = ClientSession(connector=connector, timeout=timeout)
+            logger.info("[<] Open HTTP session")
+
+    async def disconnect(self):
+        if self.session:
+            await self.session.close()
+            self.session = None
+            logger.info("[<] Close HTTP session")
+
+    async def __aenter__(self):
+        await self.connect()
+        return self
+
+    async def __aexit__(self, *args):
+        await self.disconnect()

rubigram/logger.py

@@ -0,0 +1,20 @@
+import logging
+import sys
+
+
+class RubigramFormatter(logging.Formatter):
+    def format(self, record):
+        module_name = record.name
+        log_time = self.formatTime(record, "%Y-%m-%d %H:%M:%S")
+        level = record.levelname.upper().ljust(5)
+        message = record.getMessage()
+        return f"{log_time} | {level} | {module_name} | {message}"
+
+
+logger = logging.getLogger("rubigram")
+logger.setLevel(logging.DEBUG)
+
+if not logger.handlers:
+    handler = logging.StreamHandler(sys.stdout)
+    handler.setFormatter(RubigramFormatter())
+    logger.addHandler(handler)

rubigram/method/__init__.py

@@ -0,0 +1,18 @@
+from .chat import Chat
+from .file import File
+from .setting import Setting
+from .network import Network
+from .messages import Message
+from .decorator import Decorator
+from .utilities import Utilities
+
+class Method(
+    Chat,
+    File,
+    Setting,
+    Network,
+    Message,
+    Decorator,
+    Utilities
+):
+    pass

rubigram/method/chat/__init__.py

@@ -0,0 +1,10 @@
+from .get_me import GetMe
+from .get_chat import GetChat
+from .get_update import GetUpdates
+
+class Chat(
+    GetMe,
+    GetChat,
+    GetUpdates
+):
+    pass

rubigram/method/chat/get_chat.py

@@ -0,0 +1,26 @@
+import rubigram
+
+
+class GetChat:
+    async def get_chat(
+        self: "rubigram.Client",
+        chat_id: str
+    ) -> "rubigram.types.Chat":
+        """Get information about a chat.
+
+        Args:
+            self (rubigram.Client): The active Rubigram client instance.
+            chat_id (str): Unique identifier of the chat to get information about.
+
+        Returns:
+            rubigram.types.Chat: An object containing chat information.
+
+        Example:
+            >>> chat = await client.get_chat("u0f1a2b3c4d5e6")
+            >>> print(chat.chat_id, chat.title)
+        """
+        data = {
+            "chat_id": chat_id
+        }
+        response = await self.request("getChat", data)
+        return rubigram.types.Chat.parse(response["chat"])

rubigram/method/chat/get_me.py

@@ -0,0 +1,22 @@
+import rubigram
+
+
+class GetMe:
+    async def get_me(self: "rubigram.Client") -> "rubigram.types.Bot":
+        """Get information about the current bot.
+
+        Sends a `getMe` request to the Rubigram API and retrieves
+        detailed information about the bot associated with the current token.
+
+        Returns:
+            rubigram.types.Bot: The bot information object containing attributes
+            such as bot ID, name, username, and creation date.
+
+        Example:
+            >>> bot = await client.get_me()
+            >>> print(bot.id)
+            >>> print(bot.name)
+            >>> print(bot.username)
+        """
+        response = await self.request("getMe")
+        return rubigram.types.Bot(response["bot"])

rubigram/method/chat/get_update.py

@@ -0,0 +1,32 @@
+from typing import Optional
+import rubigram
+
+
+class GetUpdates:
+    async def get_updates(
+        self: "rubigram.Client",
+        limit: Optional[int] = 1,
+        offset_id: Optional[str] = None
+    ) -> "rubigram.types.Updates":
+        """Get new updates for the bot (messages, events, etc.).
+
+        Args:
+            self (rubigram.Client): The active Rubigram client instance.
+            limit (Optional[int], optional): Maximum number of updates to retrieve. Defaults to 1.
+            offset_id (Optional[str], optional): Identifier of the last processed update to skip older ones. Defaults to None.
+
+        Returns:
+            rubigram.types.Updates: A parsed object containing a list of updates received from the server.
+
+        Example:
+            >>> updates = await client.get_updates(limit=5)
+            >>> for update in updates.updates:
+            >>>     print(update.new_message.text)
+        """
+        data = {
+            "limit": limit,
+            "offset_id": offset_id
+        }
+
+        response = await self.request("getUpdates", data)
+        return rubigram.types.Updates.parse(response)

rubigram/method/decorator/__init__.py

@@ -0,0 +1,8 @@
+from .register import Register
+from .on_message import OnMessage
+
+class Decorator(
+    Register,
+    OnMessage
+):
+    pass

rubigram/method/decorator/on_delete_message.py

@@ -0,0 +1,37 @@
+from typing import Optional
+from rubigram.filters import Filter
+import rubigram
+
+
+class OnDeleteMessage:
+    def on_delete_message(
+        self: "rubigram.Client",
+        filters: Optional["Filter"] = None,
+        group: int = 0
+    ):
+        """Register a handler for deleted messages.
+
+        This decorator allows you to handle events where a message has been removed
+        from a chat (either by the sender, admin, or system). The handler function
+        will be called whenever a `RemovedMessage` update is received.
+
+        Args:
+            self (rubigram.Client): The active Rubigram client instance.
+            filters (Optional[Filter], optional): A filter or combined filters to restrict
+                which deleted messages trigger the handler. Defaults to None.
+            group (int, optional): Execution priority for this handler. Handlers with
+                lower group values are executed first. Defaults to 0.
+
+        Returns:
+            Callable: A decorator that registers the function as a delete-message handler.
+
+        Example:
+            >>> @app.on_delete_message()
+            >>> async def on_delete(client, update):
+            >>>     print(f"Message deleted in chat: {update.chat_id}")
+        """
+        return self.register_handler(
+            self.handlers["delete"],
+            filters,
+            group
+        )

rubigram/method/decorator/on_edit_message.py

@@ -0,0 +1,37 @@
+from typing import Optional
+from rubigram.filters import Filter
+import rubigram
+
+
+class OnEditMessage:
+    def on_edit_message(
+        self: "rubigram.Client",
+        filters: Optional["Filter"] = None,
+        group: int = 0
+    ):
+        """Register a handler for edited messages.
+
+        This decorator allows you to handle updates where an existing message
+        in a chat has been edited. The handler function will be triggered whenever
+        an `UpdatedMessage` event is received.
+
+        Args:
+            self (rubigram.Client): The active Rubigram client instance.
+            filters (Optional[Filter], optional): A filter or combination of filters to limit
+                which edited messages should trigger the handler. Defaults to None.
+            group (int, optional): Execution priority for this handler. Handlers with
+                smaller group values run first. Defaults to 0.
+
+        Returns:
+            Callable: A decorator that registers the function as an edit-message handler.
+
+        Example:
+            >>> @app.on_edit_message()
+            >>> async def on_edit(client, update):
+            >>>     await client.send_message(update.chat_id, "A message was edited!")
+        """
+        return self.register_handler(
+            self.handlers["edit"],
+            filters,
+            group
+        )

rubigram/method/decorator/on_inline_message.py

@@ -0,0 +1,40 @@
+from typing import Optional
+from rubigram.filters import Filter
+import rubigram
+
+
+class OnInlineMessage:
+    def on_inline_message(
+        self: "rubigram.Client",
+        filters: Optional["Filter"] = None,
+        group: int = 0
+    ):
+        """Register a handler for inline message updates.
+
+        This decorator registers a callback function that will be called
+        whenever an inline message update is received by the client.
+
+        Args:
+            self (rubigram.Client): The Rubigram client instance.
+            filters (Optional[Filter], optional): Filter(s) to restrict which updates
+                should trigger the callback. Defaults to None.
+            group (int, optional): Determines the order in which multiple handlers
+                are executed. Lower numbers are executed first. Defaults to 0.
+
+        Returns:
+            Callable: A decorator that registers the provided function as a handler.
+
+        Example:
+            >>> from rubigram import Client, filters
+            >>>
+            >>> app = Client("TOKEN")
+            >>>
+            >>> @app.on_inline_message(filters.button("click_me"))
+            >>> async def handle_inline(client, inline):
+            >>>     await client.send_message(inline.chat_id, "Button clicked!")
+        """
+        return self.register_handler(
+            self.handlers["inline"],
+            filters,
+            group
+        )

rubigram/method/decorator/on_message.py

@@ -0,0 +1,38 @@
+from typing import Optional
+from rubigram.filters import Filter
+import rubigram
+
+
+class OnMessage:
+    def on_message(
+        self: "rubigram.Client",
+        filters: Optional["Filter"] = None,
+        group: int = 0
+    ):
+        """Register a handler for new incoming messages.
+
+        This decorator allows you to listen for new message updates that match
+        the provided filters. Handlers are executed in order based on their group priority.
+
+        Args:
+            self (rubigram.Client): The Rubigram client instance.
+            filters (Optional[Filter], optional): A filter or combination of filters
+                that determine which messages trigger this handler. Defaults to None.
+            group (int, optional): The handler execution priority.
+                Lower values run first. Defaults to 0.
+
+        Returns:
+            Callable: A decorator used to register the function as a message handler.
+
+        Example:
+            >>> from rubigram import filters
+            >>>
+            >>> @app.on_message(filters.text)
+            >>> async def handle_text(client, update):
+            >>>     await client.send_message(update.chat_id, "Received a text message!")
+        """
+        return self.register_handler(
+            self.handlers["message"],
+            filters,
+            group
+        )

rubigram/method/decorator/on_start.py

@@ -0,0 +1,30 @@
+from typing import Callable
+import rubigram
+
+
+class OnStart:
+    def on_start(
+        self: "rubigram.Client",
+        func: Callable[["rubigram.Client"], None]
+    ):
+        """Register a startup handler.
+
+        This decorator registers a function that will be called when the
+        client starts. It is typically used for initializing resources,
+        database connections, or performing setup tasks before the bot begins
+        processing updates.
+
+        Args:
+            self (rubigram.Client): The active Rubigram client instance.
+            func (Callable[[rubigram.Client], None]): The async function to be executed on startup.
+
+        Returns:
+            Callable: The function itself, after being registered.
+
+        Example:
+            >>> @app.on_start
+            >>> async def on_start(client):
+            >>>     print("Bot started and ready!")
+        """
+        self.on_start_app.append(func)
+        return func

rubigram/method/decorator/on_stop.py

@@ -0,0 +1,29 @@
+from typing import Callable
+import rubigram
+
+
+class OnStop:
+    def on_stop(
+        self: "rubigram.Client",
+        func: Callable[["rubigram.Client"], None]
+    ):
+        """Register a shutdown handler.
+
+        This decorator registers a function that will be called when the
+        client stops. It is typically used for cleaning up resources,
+        saving data, or closing database connections before shutdown.
+
+        Args:
+            self (rubigram.Client): The active Rubigram client instance.
+            func (Callable[[rubigram.Client], None]): The async function to be executed on shutdown.
+
+        Returns:
+            Callable: The function itself, after being registered.
+
+        Example:
+            >>> @app.on_stop
+            >>> async def on_stop(client):
+            >>>     print("Bot stopped gracefully.")
+        """
+        self.on_stop_app.append(func)
+        return func

rubigram/method/decorator/register.py

@@ -0,0 +1,43 @@
+from typing import Optional, Callable
+from rubigram.filters import Filter
+from ...handler import Handler
+import rubigram
+
+
+class Register:
+    def register_handler(
+        self: "rubigram.Client",
+        handlers: list["Handler"],
+        filters: Optional["Filter"] = None,
+        group: int = 0
+    ) -> Callable:
+        """Register an event handler with optional filters and group priority.
+
+        This method is used internally by decorators such as
+        `on_message`, `on_inline`, and similar ones to attach a function
+        as an event handler. It wraps the given function inside a `Handler`
+        object and stores it in the appropriate handler list.
+
+        Args:
+            self (rubigram.Client): The active Rubigram client instance.
+            handlers (List[Handler]): The list where the handler should be registered.
+            filters (Optional[Filter], optional): A filter or filter group to
+                restrict which updates trigger the handler. Defaults to None.
+            group (int, optional): The handler's execution priority.
+                Lower values are executed first. Defaults to 0.
+
+        Returns:
+            Callable: A decorator that registers the provided function as a handler.
+
+        Example:
+            >>> @app.on_message(filters.text)
+            >>> async def handle_text(client, update):
+            >>>     await client.send_message(update.chat_id, "Received text!")
+        """
+        def decorator(func: Callable):
+            handler = Handler(func, filters, group)
+            handlers.append(handler)
+            handlers.sort(key=lambda x: x.group)
+            return func
+
+        return decorator

rubigram/method/file/__init__.py

@@ -0,0 +1,32 @@
+from .send_gif import SendGif
+from .get_file import GetFile
+from .get_bytes import GetBytes
+from .send_file import SendFile
+from .send_photo import SendPhoto
+from .send_video import SendVideo
+from .send_music import SendMusic
+from .send_voice import SendVoice
+from .get_file_name import GetFileName
+from .send_document import SendDocument
+from .download_file import DownloadFile
+from .request_send_file import RequestSendFile
+from .request_upload_file import RequestUploadFile
+from .request_download_file import RequestDownloadFile
+
+class File(
+    SendGif,
+    GetFile,
+    GetBytes,
+    SendFile,
+    SendPhoto,
+    SendVideo,
+    SendMusic,
+    SendVoice,
+    GetFileName,
+    SendDocument,
+    DownloadFile,
+    RequestSendFile,
+    RequestUploadFile,
+    RequestDownloadFile
+):
+    pass

rubigram/method/file/download_file.py

@@ -0,0 +1,34 @@
+from typing import Optional
+import rubigram
+
+
+class DownloadFile:
+    async def download_file(
+        self: "rubigram.Client",
+        file_id: str,
+        save_as: Optional[str] = None
+    ) -> str:
+        """Download a file by its file ID.
+
+        Retrieves the file download URL from the server using the file ID,
+        downloads the file, and saves it locally.
+
+        Args:
+            self (rubigram.Client): The active Rubigram client instance.
+            file_id (str): The unique identifier of the file to download.
+            save_as (Optional[str], optional): Custom filename or path to save the file as.
+                If not provided, the original filename will be used. Defaults to None.
+
+        Returns:
+            str: The local path where the file was saved.
+
+        Example:
+            >>> path = await client.download_file(
+            >>>     file_id="1234567890abcdef",
+            >>>     save_as="downloads/photo.png"
+            >>> )
+            >>> print(f"File saved at: {path}")
+        """
+        download_url = await self.get_file(file_id)
+        response = await self.request_download_file(download_url, save_as)
+        return response

rubigram/method/file/get_bytes.py

@@ -0,0 +1,25 @@
+import rubigram
+
+class GetBytes:
+    async def get_bytes(
+        self: "rubigram.Client",
+        url: str
+    ) -> bytes:
+        """Fetch raw bytes from a given URL.
+
+        Performs an HTTP GET request and returns the response content as bytes.
+
+        Args:
+            self (rubigram.Client): The active Rubigram client instance.
+            url (str): The URL to fetch.
+
+        Returns:
+            bytes: The raw content of the response.
+
+        Example:
+            >>> data = await client.get_bytes("https://rubigram.com/file.png")
+            >>> print(len(data))
+        """
+        async with self.http.session.get(url) as response:
+            response.raise_for_status()
+            return await response.read()

rubigram/method/file/get_file.py

@@ -0,0 +1,27 @@
+import rubigram
+
+
+class GetFile:
+    async def get_file(
+        self: "rubigram.Client",
+        file_id: str
+    ) -> str:
+        """Get the download URL of a file.
+
+        This method retrieves the direct download URL of a file
+        previously uploaded or sent via Rubigram.
+
+        Args:
+            self (rubigram.Client): The active Rubigram client instance.
+            file_id (str): The unique identifier of the file.
+
+        Returns:
+            str: The download URL of the file.
+
+        Example:
+            >>> download_url = await client.get_file("file_id")
+            >>> print(download_url)
+        """
+        data = {"file_id": file_id}
+        response = await self.request("getFile", data)
+        return response["download_url"]

rubigram/method/file/get_file_name.py

@@ -0,0 +1,29 @@
+import os
+from urllib.parse import urlparse
+import rubigram
+
+
+class GetFileName:
+    async def get_file_name(
+        self: "rubigram.Client",
+        url: str
+    ) -> str:
+        """Extract the file name from a given URL.
+
+        This method parses the URL and returns the last path component,
+        which usually corresponds to the file name.
+
+        Args:
+            self (rubigram.Client): The active Rubigram client instance.
+            url (str): The URL to parse.
+
+        Returns:
+            str: The file name extracted from the URL.
+
+        Example:
+            >>> file_name = await client.get_file_name("https://example.com/path/to/file.png")
+            >>> print(file_name)
+            file.png
+        """
+        parser = urlparse(url)
+        return os.path.basename(parser.path)

rubigram/method/file/request_download_file.py

@@ -0,0 +1,35 @@
+from typing import Optional
+import aiofiles
+import rubigram
+
+class RequestDownloadFile:
+    async def request_download_file(
+        self: "rubigram.Client",
+        url: str,
+        filename: Optional[str] = None
+    ) -> str:
+        """Download a file from a URL and save it locally.
+
+        If `filename` is not provided, the name is extracted from the URL.
+
+        Args:
+            self (rubigram.Client): The active Rubigram client instance.
+            url (str): The URL of the file to download.
+            filename (Optional[str], optional): Local file name to save as.
+
+        Returns:
+            str: The path of the saved file.
+
+        Example:
+            >>> saved_file = await client.request_download(
+            >>>     "https://example.com/file.png"
+            >>> )
+            >>> print(saved_file)
+        """
+        file_bytes = await self.get_bytes(url)
+        file_name = filename or await self.get_file_name(url)
+
+        async with aiofiles.open(file_name, "wb") as f:
+            await f.write(file_bytes)
+
+        return file_name