RubigramClient 1.7.17__py3-none-any.whl

rubigram/methods/messages/send_poll.py

@@ -0,0 +1,104 @@
+#  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
+from rubigram.utils import AutoDelete
+import rubigram
+
+
+class SendPoll:
+    async def send_poll(
+        self: rubigram.Client,
+        chat_id: str,
+        question: str,
+        options: list[str],
+        chat_keypad: Optional[rubigram.types.Keypad] = None,
+        inline_keypad: Optional[rubigram.types.Keypad] = None,
+        chat_keypad_type: Optional[Union[str, rubigram.enums.ChatKeypadType]] = None,
+        disable_notification: bool = False,
+        reply_to_message_id: Optional[str] = None,
+        auto_delete: Optional[int] = None
+    ) -> rubigram.types.UMessage:
+        """
+        **Send a poll to a chat.**
+            `await client.send_poll(chat_id, question, options)`
+
+        This method sends an interactive poll to the specified chat.
+        Users can vote on the provided options and see real-time results.
+
+        Args:
+            chat_id (`str`):
+                The ID of the chat where the poll will be sent.
+
+            question (`str`):
+                The poll question text.
+
+            options (`list[str]`):
+                List of answer options for the poll (minimum 2 options).
+
+            chat_keypad (`Optional[rubigram.types.Keypad]`):
+                Custom keyboard to show in the chat. Defaults to None.
+
+            inline_keypad (`Optional[rubigram.types.Keypad]`):
+                Inline keyboard to attach below the poll. Defaults to None.
+
+            chat_keypad_type (`Optional[rubigram.enums.ChatKeypadType]`):
+                Type of chat keypad (New, Remove). Defaults to None.
+
+            disable_notification (`Optional[bool]`):
+                If True, disables notification for the poll. Defaults to False.
+
+            reply_to_message_id (`Optional[str]`):
+                ID of the message to reply to. Defaults to None.
+
+            auto_delete (`Optional[int]`):
+                If set, the message will be automatically deleted after the specified number of seconds.
+
+        Returns:
+            rubigram.types.UMessage: The sent poll message object with client binding.
+
+        Example:
+        .. code-block:: python
+
+            # Send a poll with multiple options
+            await client.send_poll(
+                chat_id=chat_id,
+                question="What's your favorite programming language?",
+                options=["Python", "JavaScript", "Java", "C++"],
+                disable_notification=True
+            )
+
+        Note:
+            - Polls must have at least 2 options
+            - Users can only vote once per poll
+            - Poll results are visible to all participants in real-time
+        """
+        data = {
+            "chat_id": chat_id,
+            "question": question,
+            "options": options
+        }
+
+        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("sendPoll", data)
+        message = rubigram.types.UMessage.parse(response, self)
+        message.chat_id = chat_id
+
+        if auto_delete and auto_delete > 0:
+            AutoDelete.run(self, message, auto_delete)
+
+        return message

rubigram/methods/messages/send_sticker.py

@@ -0,0 +1,98 @@
+#  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
+from rubigram.utils import AutoDelete
+import rubigram
+
+
+class SendSticker:
+    async def send_sticker(
+        self: rubigram.Client,
+        chat_id: str,
+        sticker_id: str,
+        chat_keypad: Optional[rubigram.types.Keypad] = None,
+        inline_keypad: Optional[rubigram.types.Keypad] = None,
+        chat_keypad_type: Optional[Union[str, rubigram.enums.ChatKeypadType]] = None,
+        disable_notification: bool = False,
+        reply_to_message_id: Optional[str] = None,
+        auto_delete: Optional[int] = None
+    ) -> rubigram.types.UMessage:
+        """
+        **Send a sticker to a chat.**
+            `await client.send_sticker(chat_id, sticker_id)`
+
+        This method sends a sticker to the specified chat using its unique identifier.
+        Stickers are graphical elements that can express emotions, reactions, or concepts.
+
+        Args:
+            chat_id (`str`):
+                The ID of the chat where the sticker will be sent.
+
+            sticker_id (`str`):
+                The unique identifier of the sticker to send.
+
+            chat_keypad (`Optional[rubigram.types.Keypad]`):
+                Custom keyboard to show in the chat. Defaults to None.
+
+            inline_keypad (`Optional[rubigram.types.Keypad]`):
+                Inline keyboard to attach below the sticker. Defaults to None.
+
+            chat_keypad_type (`Optional[rubigram.enums.ChatKeypadType]`):
+                Type of chat keypad (New, Remove). Defaults to None.
+
+            disable_notification (`Optional[bool]`):
+                If True, disables notification for the sticker. Defaults to False.
+
+            reply_to_message_id (`Optional[str]`):
+                ID of the message to reply to. Defaults to None.
+
+            auto_delete (`Optional[int]`):
+                If set, the message will be automatically deleted after the specified number of seconds.
+
+        Returns:
+            rubigram.types.UMessage: The sent sticker message object with client binding.
+
+        Example:
+        .. code-block:: python
+
+            # Send a sticker to a chat
+            await client.send_sticker(
+                chat_id=chat_id,
+                sticker_id=sticker_id,
+                disable_notification=True
+            )
+
+        Note:
+            - Sticker IDs are unique identifiers for each sticker in Rubigram's sticker pack
+            - Stickers are displayed as large, animated or static images
+            - Users can tap on stickers to see them in full size
+        """
+        data = {
+            "chat_id": chat_id,
+            "sticker_id": sticker_id
+        }
+
+        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("sendSticker", data)
+        message = rubigram.types.UMessage.parse(response, self)
+        message.chat_id = chat_id
+
+        if auto_delete and auto_delete > 0:
+            AutoDelete.run(self, message, auto_delete)
+
+        return message

rubigram/methods/network/__init__.py

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

rubigram/methods/network/request.py

@@ -0,0 +1,129 @@
+#  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
+from aiohttp import ClientError
+import asyncio
+import rubigram
+import logging
+
+
+logger = logging.getLogger(__name__)
+
+
+class Request:
+    """
+    HTTP request handler with retry logic for Rubika API.
+
+    This class provides an asynchronous method to send POST requests
+    to the Rubika Bot API with configurable retries, delays, backoff,
+    and optional proxy support. It handles HTTP errors and validates
+    the API response, raising appropriate exceptions if the request
+    fails.
+    """
+
+    __slots__ = ()
+
+    async def request(
+        self: rubigram.Client,
+        endpoint: str,
+        payload: dict,
+        *,
+        headers: Optional[dict] = None,
+        proxy: Optional[str] = None,
+        retries: Optional[int] = None,
+        delay: Optional[float] = None,
+        backoff: Optional[float] = None,
+        max_delay: float = 5.0
+    ) -> dict:
+        """
+        Send an HTTP request to the specified endpoint with the
+        provided JSON payload.
+
+        Parameters:
+            endpoint (str):
+                API endpoint name (e.g., "sendMessage").
+            payload (dict):
+                JSON-serializable data to send in the request body.
+            headers (Optional[dict], default=None):
+                Custom HTTP headers.
+            proxy (Optional[str], default=None):
+                Proxy URL for the request. Uses client's proxy if None.
+            retries (Optional[int], default=None):
+                Number of retry attempts. Uses client's default if None.
+            delay (Optional[float], default=None):
+                Initial delay between retries in seconds.
+            backoff (Optional[float], default=None):
+                Multiplier to increase delay after each retry.
+            max_delay (float, default=5.0):
+                Maximum delay allowed between retries.
+
+        Returns:
+            dict: The "data" field from the API response if status is "OK".
+
+        Raises:
+            rubigram.errors.InvalidInput:
+                If the API response status is "INVALID_INPUT".
+            rubigram.errors.InvalidInput:
+                If the API response status is not "INVALID_ACCESS".
+            aiohttp.ClientError:
+                For network or HTTP errors.
+            RuntimeError:
+                If maximum retries are exceeded.
+
+        Example:
+        .. code-block:: python
+            # Assuming `client` is an instance of Rubigram.Client
+            response = await client.request(
+                endpoint="sendMessage",
+                payload={"chat_id": "chat_id", "text": "text"},
+                retries=5,
+                delay=1.0,
+                backoff=2.0
+            )
+        """
+        proxy = self.proxy if proxy is None else proxy
+        retries = self.retries if retries is None else retries
+        delay = self.delay if delay is None else delay
+        backoff = self.backoff if backoff is None else backoff
+        max_delay = self.max_delay if max_delay is None else max_delay
+
+        last_error = None
+
+        for attempt in range(1, retries + 1):
+            try:
+                async with self.http.session.post(
+                    self.api + endpoint,
+                    json=payload,
+                    headers=headers,
+                    proxy=proxy
+                ) as response:
+                    response.raise_for_status()
+                    data: dict = await response.json()
+
+                    if data.get("status") == "OK":
+                        logger.debug(data.get("data"))
+                        return data.get("data")
+
+                    if data.get("status") == "INVALID_INPUT":
+                        raise rubigram.errors.InvalidInput(data)
+
+                    elif data.get("status") == "INVALID_ACCESS":
+                        raise rubigram.errors.InvalidAccess(data)
+                    
+                    else:
+                        raise Exception(str(data))
+
+            except ClientError as error:
+                last_error = error
+                if attempt == retries:
+                    raise error
+
+                await asyncio.sleep(min(delay, max_delay))
+                delay *= backoff
+
+        raise last_error or RuntimeError("Max retries exceeded")

rubigram/methods/settings/__init__.py

@@ -0,0 +1,16 @@
+#  RubigramClient - Rubika API library for python
+#  Copyright (C) 2025-present Javad <https://github.com/DevJavad>
+#  Github - https://github.com/DevJavad/rubigram
+
+
+from .set_command import SetCommands
+from .setup_endpoints import SetupEndpoints
+from .update_bot_endpoint import UpdateBotEndpoints
+
+
+class Settings(
+    SetCommands,
+    SetupEndpoints,
+    UpdateBotEndpoints
+):
+    pass

rubigram/methods/settings/set_command.py

@@ -0,0 +1,50 @@
+#  RubigramClient - Rubika API library for python
+#  Copyright (C) 2025-present Javad <https://github.com/DevJavad>
+#  Github - https://github.com/DevJavad/rubigram
+
+
+import rubigram
+
+
+class SetCommands:
+    async def set_commands(
+        self: "rubigram.Client",
+        commands: list["rubigram.types.BotCommand"]
+    ) -> dict:
+        """
+        **Set bot commands for the Rubigram bot.**
+            `await client.set_commands(commands)`
+
+        This method registers a list of bot commands that will be displayed
+        in the chat interface and accessible to users through the bot menu.
+
+        Args:
+            commands (`list[rubigram.types.BotCommand]`):
+                List of BotCommand objects to register for the bot.
+
+        Returns:
+            dict: The API response from Rubigram.
+
+        Example:
+        .. code-block:: python
+
+            from rubigram.types import BotCommand
+
+            # Define bot commands
+            commands = [
+                BotCommand(command="start", description="Start the bot"),
+                BotCommand(command="help", description="Get help"),
+                BotCommand(command="settings", description="Change settings")
+            ]
+
+            # Register commands with Rubigram
+            result = await client.set_commands(commands)
+
+        Note:
+            - Commands will appear in the bot's menu in user chats
+            - Each command should have a unique command string
+            - Descriptions should be clear and concise for users
+        """
+        data = {"bot_commands": [command.as_dict() for command in commands]}
+        response = await self.request("setCommands", data)
+        return response

rubigram/methods/settings/setup_endpoints.py

@@ -0,0 +1,48 @@
+#  RubigramClient - Rubika API library for python
+#  Copyright (C) 2025-present Javad <https://github.com/DevJavad>
+#  Github - https://github.com/DevJavad/rubigram
+
+
+import rubigram
+import logging
+
+
+logger = logging.getLogger(__name__)
+
+
+class SetupEndpoints:
+    async def setup_endpoints(self: "rubigram.Client"):
+        """
+        **Set up webhook endpoints for all update types.**
+            `await client.setup_endpoints()`
+
+        This method automatically configures webhook endpoints for all
+        available update types in Rubigram. Each endpoint type will be
+        registered with the base webhook URL followed by the endpoint type.
+
+        Example:
+        .. code-block:: python
+
+            # Set up all webhook endpoints
+            await client.setup_endpoints()
+
+            # Example of configured endpoints:
+            # - https://api.example.com/webhook/ReceiveUpdate
+            # - https://api.example.com/webhook/ReceiveInlineMessage  
+            # - https://api.example.com/webhook/ReceiveQuery
+            # - https://api.example.com/webhook/GetSelectionItem
+            # - https://api.example.com/webhook/SearchSelectionItems
+
+        Note:
+            - Requires `webhook_url` to be set in the client instance
+            - Configures endpoints for all UpdateEndpointType enum values
+            - Logs the status of each endpoint setup operation
+            - Each endpoint type gets its own unique URL path
+        """
+        for i in rubigram.enums.UpdateEndpointType:
+            type = i.value
+            url = f"{self.webhook}/{type}"
+            set_endpoint = await self.update_bot_endpoints(url, type)
+            logger.info(
+                "ENDPOINT SET(type=%s, status=%s)", type, set_endpoint["status"]
+            )

rubigram/methods/settings/update_bot_endpoint.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 Union
+import rubigram
+
+
+class UpdateBotEndpoints:
+    async def update_bot_endpoints(
+        self: "rubigram.Client",
+        url: str,
+        type: Union[str, "rubigram.enums.UpdateEndpointType"] = "ReceiveUpdate"
+    ) -> dict:
+        """
+        **Update webhook endpoints for receiving bot updates.**
+            `await client.update_bot_endpoints(url, type)`
+
+        This method sets or updates the webhook URL where Rubigram will send
+        bot updates. Different endpoint types can be configured for various
+        types of interactions.
+
+        Args:
+            url (`str`):
+                The webhook URL where updates will be sent.
+
+            type (`Optional[Union[str, rubigram.enums.UpdateEndpointType]]`):
+                The type of endpoint to update. Defaults to "ReceiveUpdate".
+                Available types:
+                - "ReceiveUpdate": General updates
+                - "ReceiveInlineMessage": Inline message updates
+                - "ReceiveQuery": Callback query updates
+                - "GetSelectionItem": Selection item retrieval
+                - "SearchSelectionItems": Selection item search
+
+        Returns:
+            dict: The API response from Rubigram.
+
+        Example:
+        .. code-block:: python
+
+            # Set webhook for general updates
+            result = await client.update_bot_endpoints(
+                url="https://api.example.com/webhook",
+                type="ReceiveUpdate"
+            )
+
+            # Set webhook for inline messages
+            from rubigram.enums import UpdateEndpointType
+            result = await client.update_bot_endpoints(
+                url="https://api.example.com/inline",
+                type=UpdateEndpointType.ReceiveInlineMessage
+            )
+
+        Note:
+            - The URL must be HTTPS for security reasons
+            - Each endpoint type requires a separate configuration
+            - Make sure your webhook server can handle POST requests with JSON payloads
+        """
+        response = await self.request("updateBotEndpoints", {"url": url, "type": type})
+        return response

rubigram/methods/updates/__init__.py

@@ -0,0 +1,14 @@
+#  RubigramClient - Rubika API library for python
+#  Copyright (C) 2025-present Javad <https://github.com/DevJavad>
+#  Github - https://github.com/DevJavad/rubigram
+
+
+from .get_update import GetUpdates
+from .get_me import GetMe
+
+
+class Updates(
+    GetUpdates,
+    GetMe
+):
+    pass

rubigram/methods/updates/get_me.py

@@ -0,0 +1,35 @@
+#  RubigramClient - Rubika API library for python
+#  Copyright (C) 2025-present Javad <https://github.com/DevJavad>
+#  Github - https://github.com/DevJavad/rubigram
+
+
+import rubigram
+
+
+class GetMe:
+    async def get_me(self: "rubigram.Client") -> "rubigram.types.Bot":
+        """
+        **Get information about the current bot.**
+            `await client.get_me()`
+
+        This method retrieves the current bot's information, including
+        the bot's ID, username, and other relevant details.
+
+        Returns:
+            rubigram.types.Bot: A Bot object containing the bot's information.
+
+        Example:
+        .. code-block:: python
+
+            # Get bot information
+            bot = await client.get_me()
+            print(f"Bot ID: {bot.bot_id}")
+            print(f"Bot username: {bot.username}")
+            print(f"Bot title : {bot.bot_title }")
+
+        Note:
+            This method is useful for verifying that the bot token is valid
+            and for accessing the bot's own profile information.
+        """
+        response = await self.request("getMe", None)
+        return rubigram.types.Bot(response["bot"])

rubigram/methods/updates/get_update.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
+import rubigram
+
+
+class GetUpdates:
+    async def get_updates(
+        self: "rubigram.Client",
+        limit: Optional[int] = 1,
+        offset_id: Optional[str] = None
+    ) -> "rubigram.types.Updates":
+        """
+        **Retrieve incoming updates from Rubigram.**
+            `await client.get_updates(limit=10, offset_id="12345")`
+
+        This method fetches updates (new messages, edits, deletions, etc.)
+        from the Rubigram server. It supports pagination through the offset_id
+        parameter for efficient update retrieval.
+
+        Args:
+            limit (`Optional[int]`):
+                Maximum number of updates to retrieve. Defaults to 1.
+
+            offset_id (`Optional[str]`):
+                ID of the last received update. Updates with higher IDs
+                will be returned. Defaults to None.
+
+        Returns:
+            rubigram.types.Updates: A collection of update objects with next_offset_id.
+
+        Example:
+        .. code-block:: python
+
+            # Get the latest 10 updates
+            updates = await client.get_updates(limit=10)
+            for update in updates.updates:
+                print(f"New update type: {update.type}")
+
+            # Get updates after a specific ID
+            updates = await client.get_updates(
+                limit=5,
+                offset_id="12345"
+            )
+            print(f"Next offset: {updates.next_offset_id}")
+
+        Note:
+            - Use the returned next_offset_id for subsequent calls to avoid missing updates
+            - Updates are automatically marked as received by the server
+            - Consider using a reasonable limit to avoid overwhelming the client
+        """
+        response = await self.request(
+            "getUpdates",
+            {
+                "limit": limit,
+                "offset_id": offset_id
+            }
+        )
+        return rubigram.types.Updates.parse(response)

rubigram/methods/utilities/__init__.py

@@ -0,0 +1,14 @@
+#  RubigramClient - Rubika API library for python
+#  Copyright (C) 2025-present Javad <https://github.com/DevJavad>
+#  Github - https://github.com/DevJavad/rubigram
+
+
+from .dispatcher import Dispatcher
+from .run import Run
+
+
+class Utilities(
+    Run,
+    Dispatcher
+):
+    pass