RubigramClient 1.7.17__py3-none-any.whl

rubigram/http_session.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 aiohttp import ClientSession, TCPConnector, ClientTimeout
+from typing import Optional
+import logging
+
+
+logger = logging.getLogger(__name__)
+
+
+class HttpSession:
+    """
+    Asynchronous HTTP session manager based on aiohttp.
+
+    This class manages the lifecycle of a shared aiohttp ClientSession,
+    providing configurable timeouts and connection pooling. It is intended
+    to be used as the low-level HTTP transport layer for Rubigram.
+
+    Parameters:
+        timeout (float):
+            Total timeout (in seconds) for a single HTTP request, including
+            connection, redirects, and response reading.
+
+        connect_timeout (float):
+            Maximum time (in seconds) allowed to establish a connection
+            to the remote server.
+
+        read_timeout (float):
+            Maximum time (in seconds) to wait for data to be read from
+            the socket after the connection is established.
+
+        max_connections (int):
+            Maximum number of simultaneous connections allowed in the
+            connection pool.
+
+    Example:
+    .. code-block:: python
+        async with HttpSession(timeout=30, max_connections=100) as http:
+            session = http.get_session()
+            await session.get("https://example.com")
+    """
+
+    def __init__(
+        self,
+        timeout: float = 30.0,
+        connect_timeout: float = 10.0,
+        read_timeout: float = 20.0,
+        max_connections: int = 100
+    ):
+        self.timeout = ClientTimeout(
+            total=timeout,
+            connect=connect_timeout,
+            sock_read=read_timeout
+        )
+        self.max_connections = max_connections
+        self.session: Optional[ClientSession] = None
+
+    async def connect(self) -> None:
+        if not self.is_connected:
+            connector = TCPConnector(
+                limit=self.max_connections, enable_cleanup_closed=True
+            )
+            self.session = ClientSession(
+                connector=connector, timeout=self.timeout
+            )
+            logger.info(
+                "Connect to HTTP session, timeout=%s, connections=%s",
+                self.timeout.total, self.max_connections
+            )
+        else:
+            logger.debug("HTTP session already connected")
+
+    async def disconnect(self) -> None:
+        if self.is_connected:
+            await self.session.close()
+            logger.info("HTTP session closed")
+        self.session = None
+
+    @property
+    def is_connected(self) -> bool:
+        return self.session is not None and not self.session.closed
+
+    def get_session(self) -> "ClientSession":
+        if not self.is_connected:
+            raise RuntimeError("HTTP session is not connected")
+        return self.session
+
+    async def __aenter__(self) -> "HttpSession":
+        await self.connect()
+        return self
+
+    async def __aexit__(self, *args) -> None:
+        await self.disconnect()

rubigram/methods/__init__.py

@@ -0,0 +1,26 @@
+#  RubigramClient - Rubika API library for python
+#  Copyright (C) 2025-present Javad <https://github.com/DevJavad>
+#  Github - https://github.com/DevJavad/rubigram
+
+
+from .decorators import Decorators
+from .utilities import Utilities
+from .messages import Messages
+from .settings import Settings
+from .updates import Updates
+from .network import Network
+from .chats import Chats
+from .files import Files
+
+
+class Methods(
+    Decorators,
+    Utilities,
+    Messages,
+    Network,
+    Settings,
+    Updates,
+    Chats,
+    Files
+):
+    pass

rubigram/methods/chats/__init__.py

@@ -0,0 +1,10 @@
+#  RubigramClient - Rubika API library for python
+#  Copyright (C) 2025-present Javad <https://github.com/DevJavad>
+#  Github - https://github.com/DevJavad/rubigram
+
+
+from .get_chat import GetChat
+
+
+class Chats(GetChat):
+    pass

rubigram/methods/chats/get_chat.py

@@ -0,0 +1,53 @@
+#  RubigramClient - Rubika API library for python
+#  Copyright (C) 2025-present Javad <https://github.com/DevJavad>
+#  Github - https://github.com/DevJavad/rubigram
+
+
+import rubigram
+
+
+class GetChat:
+    async def get_chat(
+        self: "rubigram.Client",
+        chat_id: str
+    ) -> "rubigram.types.Chat":
+        """
+        **Get information about a specific chat.**
+            `await client.get_chat(chat_id)`
+
+        This method retrieves detailed information about a chat, including
+        its type, title, user information (for private chats), and other
+        metadata.
+
+        Args:
+            chat_id (`str`):
+                The unique identifier of the chat to retrieve information for.
+
+        Returns:
+            rubigram.types.Chat: A Chat object containing the chat information.
+
+        Example:
+        .. code-block:: python
+
+            # Get information about a chat
+            chat = await client.get_chat(chat_id=chat_id)
+            print(f"Chat title: {chat.title}")
+            print(f"Chat type: {chat.chat_type}")
+            print(f"Username: {chat.username}")
+
+            # For private chats, access user information
+            if chat.chat_type == rubigram.enums.ChatType.USER:
+                print(f"User full name: {chat.full_name}")
+
+        Note:
+            - Works for all chat types (private, group, supergroup, channel)
+            - For private chats, returns user information
+            - For groups/channels, returns group metadata and settings
+        """
+        response = await self.request(
+            "getChat",
+            {
+                "chat_id": chat_id
+            }
+        )
+        return rubigram.types.Chat.parse(response["chat"])

rubigram/methods/decorators/__init__.py

@@ -0,0 +1,25 @@
+#  RubigramClient - Rubika API library for python
+#  Copyright (C) 2025-present Javad <https://github.com/DevJavad>
+#  Github - https://github.com/DevJavad/rubigram
+
+
+from .on_stop import OnStop
+from .on_start import OnStart
+from .on_message import OnMessage
+from .on_stopped_bot import OnStoppedBot
+from .on_started_bot import OnStartedBot
+from .on_inline_message import OnInlineMessage
+from .on_remove_message import OnRemoveMessage
+from .on_update_message import OnUpdateMessage
+
+class Decorators(
+    OnStop,
+    OnStart,
+    OnMessage,
+    OnStoppedBot,
+    OnStartedBot,
+    OnInlineMessage,
+    OnRemoveMessage,
+    OnUpdateMessage
+):
+    pass

rubigram/methods/decorators/on_inline_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 OnInlineMessage:
+    def on_inline_message(
+        self: "rubigram.Client",
+        filters: Optional["Filter"] = None
+    ):
+        """
+        **Decorator for handling inline messages.**
+            `@client.on_inline_message(filters.button("my_button"))`
+
+        This decorator registers a function to handle inline message events
+        that match the specified filters. If no filters are provided,
+        all inline messages will be handled.
+
+        Args:
+            filters (`Optional[Filter]`):
+                Filter to determine which inline messages should be handled.
+                If None, all inline messages will be processed.
+
+        Returns:
+            Callable: The decorator function.
+
+        Example:
+        .. code-block:: python
+
+            # Handle specific button clicks
+            @client.on_inline_message(filters.button("start_btn"))
+            async def handle_start_button(client, update):
+                await client.send_message(
+                    update.chat_id, 
+                    "Start button was clicked!"
+                )
+
+            # Handle inline messages with text
+            @client.on_inline_message(filters.text)
+            async def handle_inline_text(client, update):
+                print(f"Inline message text: {update.text}")
+
+            # Handle all inline messages (no filter)
+            @client.on_inline_message()
+            async def handle_all_inline(client, update):
+                print(f"Inline message received from: {update.sender_id}")
+
+        Note:
+            Inline messages are typically generated by button clicks in
+            inline keyboards or other interactive elements. The button ID
+            can be accessed via `update.aux_data.button_id`.
+        """
+        def decorator(func: Callable) -> Callable:
+            async def wrapper(
+                client: "rubigram.Client",
+                update: "rubigram.types.InlineMessage"
+            ):
+                if filters is None or await filters(client, update):
+                    await func(client, update)
+                    return True
+                return False
+
+            self.inline_message_handlers.append(wrapper)
+            return func
+        return decorator

rubigram/methods/decorators/on_message.py

@@ -0,0 +1,62 @@
+#  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 OnMessage:
+    def on_message(
+        self: "rubigram.Client",
+        filters: Optional["Filter"] = None
+    ):
+        """
+        **Decorator for handling incoming messages.**
+            `@client.on_message(filters.text)`
+
+        This decorator registers a function to handle incoming messages
+        that match the specified filters. If no filters are provided,
+        all messages will be handled.
+
+        Args:
+            filters (`Optional[Filter]`):
+                Filter to determine which messages should be handled.
+                If None, all messages will be processed.
+
+        Returns:
+            Callable: The decorator function.
+
+        Example:
+        .. code-block:: python
+
+            # Handle all text messages
+            @client.on_message(filters.text)
+            async def handle_text(client, update):
+                await client.send_message(update.chat_id, "Text message received!")
+
+            # Handle commands
+            @client.on_message(filters.command("start"))
+            async def handle_start(client, update):
+                await client.send_message(update.chat_id, "Bot started!")
+
+            # Handle all messages (no filter)
+            @client.on_message()
+            async def handle_all(client, update):
+                print(f"Received message: {update.new_message.text}")
+        """
+        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.new_message_handlers.append(wrapper)
+            return func
+        return decorator

rubigram/methods/decorators/on_remove_message.py

@@ -0,0 +1,65 @@
+#  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 OnRemoveMessage:
+    def on_remove_message(
+        self: "rubigram.Client",
+        filters: Optional["Filter"] = None
+    ):
+        """
+        **Decorator for handling deleted messages.**
+            `@client.on_delete_message(filters.private)`
+
+        This decorator registers a function to handle message deletion events
+        that match the specified filters. If no filters are provided,
+        all message deletions will be handled.
+
+        Args:
+            filters (`Optional[Filter]`):
+                Filter to determine which message deletions should be handled.
+                If None, all message deletions will be processed.
+
+        Returns:
+            Callable: The decorator function.
+
+        Example:
+        .. code-block:: python
+
+            # Handle all message deletions in private chats
+            @client.on_delete_message(filters.private)
+            async def handle_private_deletion(client, update):
+                await client.send_message(
+                    update.chat_id, 
+                    "A message was deleted in this private chat!"
+                )
+
+            # Handle message deletions in specific chats
+            @client.on_delete_message(filters.chat(["g0123456789", "g0987654321"]))
+            async def handle_group_deletions(client, update):
+                print(f"Message deleted in group: {update.chat_id}")
+
+            # Handle all message deletions (no filter)
+            @client.on_delete_message()
+            async def handle_all_deletions(client, update):
+                print(f"Message {update.removed_message_id} was deleted in {update.chat_id}")
+        """
+        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.remove_message_handlers.append(wrapper)
+            return func
+        return decorator

rubigram/methods/decorators/on_start.py

@@ -0,0 +1,65 @@
+#  RubigramClient - Rubika API library for python
+#  Copyright (C) 2025-present Javad <https://github.com/DevJavad>
+#  Github - https://github.com/DevJavad/rubigram
+
+
+from typing import Callable
+import rubigram
+
+
+class OnStart:
+    def on_start(self: "rubigram.Client"):
+        """
+        **Decorator for handling application startup events.**
+            `@client.on_start()`
+
+        This decorator registers a function to be executed when the
+        Rubigram client starts up and connects to the server. This is
+        useful for initialization tasks, setting up webhooks, or
+        performing any setup required before the bot starts processing updates.
+
+        Returns:
+            Callable: The decorator function.
+
+        Example:
+        .. code-block:: python
+
+            # Initialize bot on startup
+            @client.on_start()
+            async def initialize_bot(client):
+                await client.set_commands([
+                    rubigram.types.BotCommand(command="start", description="Start the bot"),
+                    rubigram.types.BotCommand(command="help", description="Get help")
+                ])
+                print("Bot started and commands registered!")
+
+            # Set up webhook on startup
+            @client.on_start()
+            async def setup_webhook(client):
+                await client.update_bot_endpoints(
+                    url="https://api.example.com/webhook",
+                    type="ReceiveUpdate"
+                )
+                print("Webhook configured successfully!")
+
+            # Perform database initialization
+            @client.on_start()
+            async def init_database(client):
+                # Initialize database connections
+                # Create necessary tables
+                # Load initial data
+                print("Database initialized!")
+
+        Note:
+            - This handler runs only once when the client starts
+            - Multiple startup handlers can be registered
+            - All startup handlers run before the client begins processing updates
+            - The client parameter provides access to all bot methods
+        """
+        def decorator(func: Callable) -> Callable:
+            async def wrapper(client):
+                return await func(client)
+
+            self.start_handlers.append(wrapper)
+            return func
+        return decorator

rubigram/methods/decorators/on_started_bot.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 OnStartedBot:
+    def on_started_bot(
+        self: "rubigram.Client",
+        filters: Optional["Filter"] = None
+    ):
+        """
+        **Decorator for handling bot start events.**
+            `@client.on_start_bot(filters.private)`
+
+        This decorator registers a function to handle bot start events
+        that match the specified filters. If no filters are provided,
+        all bot start events will be handled.
+
+        Args:
+            filters (`Optional[Filter]`):
+                Filter to determine which bot start events should be handled.
+                If None, all bot start events will be processed.
+
+        Returns:
+            Callable: The decorator function.
+
+        Example:
+        .. code-block:: python
+
+            # Handle bot starts in private chats only
+            @client.on_start_bot(filters.private)
+            async def handle_private_start(client, update):
+                await client.send_message(
+                    update.chat_id, 
+                    "Welcome to the bot! Use /help for commands."
+                )
+
+            # Handle bot starts from specific users
+            @client.on_start_bot(filters.chat(["b0123456789", "b0987654321"]))
+            async def handle_specific_users(client, update):
+                print(f"Bot started by user: {update.chat_id}")
+
+            # Handle all bot start events (no filter)
+            @client.on_start_bot()
+            async def handle_all_starts(client, update):
+                print(f"Bot started in chat: {update.chat_id}")
+
+        Note:
+            This handler triggers when the bot is started by a user,
+            typically when they first interact with the bot or use a /start command.
+            The chat ID is available in `update.chat_id`.
+        """
+        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.started_bot_handlers.append(wrapper)
+            return func
+        return decorator

rubigram/methods/decorators/on_stop.py

@@ -0,0 +1,65 @@
+#  RubigramClient - Rubika API library for python
+#  Copyright (C) 2025-present Javad <https://github.com/DevJavad>
+#  Github - https://github.com/DevJavad/rubigram
+
+
+from typing import Callable
+import rubigram
+
+
+class OnStop:
+    def on_stop(self: "rubigram.Client"):
+        """
+        **Decorator for handling application shutdown events.**
+            `@client.on_stop()`
+
+        This decorator registers a function to be executed when the
+        Rubigram client is shutting down. This is useful for cleanup tasks,
+        closing database connections, saving state, or performing any
+        cleanup required before the bot stops completely.
+
+        Returns:
+            Callable: The decorator function.
+
+        Example:
+        .. code-block:: python
+
+            # Cleanup resources on shutdown
+            @client.on_stop()
+            async def cleanup_resources(client):
+                # Close database connections
+                # Save bot state
+                # Clean up temporary files
+                print("Resources cleaned up successfully!")
+
+            # Send shutdown notification
+            @client.on_stop()
+            async def send_shutdown_notification(client):
+                await client.send_message(
+                    "b0ADMIN_USER_ID",
+                    "Bot is shutting down for maintenance."
+                )
+                print("Shutdown notification sent!")
+
+            # Backup data before shutdown
+            @client.on_stop()
+            async def backup_data(client):
+                # Backup user data
+                # Save logs
+                # Export statistics
+                print("Data backup completed!")
+
+        Note:
+            - This handler runs only once when the client is shutting down
+            - Multiple shutdown handlers can be registered
+            - All shutdown handlers run before the client completely stops
+            - The client parameter provides access to all bot methods until shutdown completes
+            - Useful for graceful shutdown and resource cleanup
+        """
+        def decorator(func: Callable) -> Callable:
+            async def wrapper(client):
+                return await func(client)
+
+            self.stop_handlers.append(wrapper)
+            return func
+        return decorator

rubigram/methods/decorators/on_stopped_bot.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 OnStoppedBot:
+    def on_stopped_bot(
+        self: "rubigram.Client",
+        filters: Optional["Filter"] = None
+    ):
+        """
+        **Decorator for handling bot stop events.**
+            `@client.on_stop_bot(filters.private)`
+
+        This decorator registers a function to handle bot stop events
+        that match the specified filters. If no filters are provided,
+        all bot stop events will be handled.
+
+        Args:
+            filters (`Optional[Filter]`):
+                Filter to determine which bot stop events should be handled.
+                If None, all bot stop events will be processed.
+
+        Returns:
+            Callable: The decorator function.
+
+        Example:
+        .. code-block:: python
+
+            # Handle bot stops in private chats only
+            @client.on_stop_bot(filters.private)
+            async def handle_private_stop(client, update):
+                await client.send_message(
+                    update.chat_id, 
+                    "Sorry to see you go! You can always start me again with /start."
+                )
+
+            # Handle bot stops from specific users
+            @client.on_stop_bot(filters.chat(["b0123456789", "b0987654321"]))
+            async def handle_specific_users_stop(client, update):
+                print(f"Bot stopped by user: {update.chat_id}")
+
+            # Handle all bot stop events (no filter)
+            @client.on_stop_bot()
+            async def handle_all_stops(client, update):
+                print(f"Bot stopped in chat: {update.chat_id}")
+
+        Note:
+            This handler triggers when the bot is stopped by a user,
+            typically when they block the bot or use a /stop command.
+            The chat ID is available in `update.chat_id`.
+        """
+        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.stopped_bot_handlers.append(wrapper)
+            return func
+        return decorator