pyrobale 0.2.9.4.1__py3-none-any.whl → 0.3.5__py3-none-any.whl

pyrobale/objects/message.py

@@ -0,0 +1,368 @@
+from typing import TYPE_CHECKING
+from typing import Optional, Union
+
+if TYPE_CHECKING:
+    from .utils import build_api_url
+    from ..objects.user import User
+    from ..objects.chat import Chat
+    from ..objects.chatphoto import ChatPhoto
+    from ..objects.animation import Animation
+    from ..objects.audio import Audio
+    from ..objects.document import Document
+    from ..objects.photosize import PhotoSize
+    from ..objects.sticker import Sticker
+    from ..objects.video import Video
+    from ..objects.voice import Voice
+    from ..objects.contact import Contact
+    from ..objects.location import Location
+    from ..objects.invoice import Invoice
+    from ..objects.successfulpayment import SuccessfulPayment
+    from ..objects.webappdata import WebAppData
+    from ..objects.webappinfo import WebAppInfo
+    from ..objects.inlinekeyboardmarkup import InlineKeyboardMarkup
+    from ..objects.replykeyboardmarkup import ReplyKeyboardMarkup
+    from ..client import Client
+from ..objects.chat import Chat
+from ..objects.user import User
+import asyncio
+import aiohttp
+
+
+class Message:
+    """This class represents a Message object in Telegram.
+
+    A message can contain various types of content like text, media, location, etc.
+    It also provides methods to reply, edit, delete, and forward messages.
+
+    Attributes:
+        id (int): Unique message identifier
+        user (User): Sender of the message
+        date (int): Date the message was sent in Unix time
+        chat (Chat): Conversation the message belongs to
+        text (str): Text content of the message
+        forward_from (User): Original sender of a forwarded message
+        forward_from_chat (Chat): Original chat of a forwarded message
+        forward_from_message_id (int): Message ID in the original chat
+        forward_date (int): Date when message was forwarded
+        edite_date (int): Date when message was last edited
+        animation (Animation): Message is an animation
+        audio (Audio): Message is an audio file
+        document (Document): Message is a general file
+        photo (list[PhotoSize]): Message is a photo
+        sticker (Sticker): Message is a sticker
+        video (Video): Message is a video
+        voice (Voice): Message is a voice message
+        caption (str): Caption for media messages
+        contact (Contact): Message is a shared contact
+        location (Location): Message is a shared location
+        new_chat_members (list[User]): New members added to the chat
+        left_chat_member (User): Member removed from the chat
+        invoice (Invoice): Message is an invoice for payment
+        successful_payment (SuccessfulPayment): Message is a service message about successful payment
+        web_app_data (WebAppData): Data from a Web App
+        reply_markup (InlineKeyboardMarkup): Inline keyboard attached to the message
+        client (Client): Client instance associated with this message
+    """
+
+    def __init__(
+        self,
+        message_id: Optional[int] = None,
+        from_user: Optional["User"] = None,
+        date: Optional[int] = None,
+        chat: Optional["Chat"] = None,
+        text: Optional[str] = None,
+        forward_from: Optional["User"] = None,
+        forward_from_chat: Optional["Chat"] = None,
+        forward_from_message_id: Optional[int] = None,
+        forward_date: Optional[int] = None,
+        edite_date: Optional[int] = None,
+        animation: Optional["Animation"] = None,
+        audio: Optional["Audio"] = None,
+        document: Optional["Document"] = None,
+        photo: Optional[list["PhotoSize"]] = None,
+        sticker: Optional["Sticker"] = None,
+        video: Optional["Video"] = None,
+        voice: Optional["Voice"] = None,
+        caption: Optional[str] = None,
+        contact: Optional["Contact"] = None,
+        location: Optional["Location"] = None,
+        new_chat_members: Optional[list["User"]] = None,
+        left_chat_member: Optional["User"] = None,
+        invoice: Optional["Invoice"] = None,
+        successful_payment: Optional["SuccessfulPayment"] = None,
+        web_app_data: Optional["WebAppData"] = None,
+        reply_markup: Optional["InlineKeyboardMarkup"] = None,
+        **kwargs
+    ):
+        """Initialize a Message object with the provided attributes.
+
+        Args:
+            message_id: Unique message identifier
+            from_user: Sender of the message
+            date: Date the message was sent
+            chat: Conversation the message belongs to
+            text: Text content of the message
+            forward_from: Original sender of a forwarded message
+            forward_from_chat: Original chat of a forwarded message
+            forward_from_message_id: Message ID in the original chat
+            forward_date: Date when message was forwarded
+            edite_date: Date when message was last edited
+            animation: Animation content
+            audio: Audio content
+            document: Document content
+            photo: Photo content
+            sticker: Sticker content
+            video: Video content
+            voice: Voice message content
+            caption: Caption for media messages
+            contact: Contact content
+            location: Location content
+            new_chat_members: New members added to the chat
+            left_chat_member: Member removed from the chat
+            invoice: Invoice content
+            successful_payment: Successful payment information
+            web_app_data: Web App data
+            reply_markup: Inline keyboard markup
+            **kwargs: Additional keyword arguments
+        """
+        self.id: int = message_id
+        self.user: "User" = User(**from_user) if from_user else None
+        self.date: int = date
+        self.chat: Optional["Chat"] = (
+            chat if isinstance(chat, Chat) else Chat(**chat) if chat else None
+        )
+        self.forward_from: Optional["User"] = forward_from
+        self.forward_from_chat: Optional["Chat"] = forward_from_chat
+        self.forward_from_message_id: Optional[int] = forward_from_message_id
+        self.forward_date: Optional[int] = forward_date
+        self.edite_date: Optional[int] = edite_date
+        self.text: Optional[str] = text
+        self.animation: Optional["Animation"] = animation
+        self.audio: Optional["Audio"] = audio
+        self.document: Optional["Document"] = document
+        self.photo: Optional[list["PhotoSize"]] = photo
+        self.sticker: Optional["Sticker"] = sticker
+        self.video: Optional["Video"] = video
+        self.voice: Optional["Voice"] = voice
+        self.caption: Optional[str] = caption
+        self.contact: Optional["Contact"] = contact
+        self.location: Optional["Location"] = location
+        self.new_chat_members: Optional[list["User"]] = new_chat_members
+        self.left_chat_member: Optional["User"] = left_chat_member
+        self.invoice: Optional["Invoice"] = invoice
+        self.successful_payment: Optional["SuccessfulPayment"] = successful_payment
+        self.web_app_data: Optional["WebAppData"] = web_app_data
+        self.reply_markup: Optional["InlineKeyboardMarkup"] = reply_markup
+        self.client: Client = kwargs.get("kwargs", {}).get("client")
+
+    async def reply(
+        self,
+        text: str,
+        reply_markup: Union["ReplyKeyboardMarkup", "InlineKeyboardMarkup"] = None,
+    ):
+        """Reply to the current message with text.
+
+        Args:
+            text: The text to send
+            reply_markup: Optional keyboard markup for the message
+        """
+        if self.chat and self.chat.id:
+            await self.client.send_message(
+                self.chat.id, text, reply_markup=reply_markup
+            )
+
+    async def edit(
+        self,
+        text: str,
+        reply_markup: Union["ReplyKeyboardMarkup", "InlineKeyboardMarkup"] = None,
+    ):
+        """Edit the current message text.
+
+        Args:
+            text: The new text
+            reply_markup: Optional new keyboard markup
+        """
+        if self.chat and self.chat.id and self.id:
+            await self.client.edit_message(
+                self.chat.id, self.id, text, reply_markup=reply_markup
+            )
+
+    async def delete(self):
+        """Delete the current message."""
+        if self.chat and self.chat.id and self.id:
+            await self.client.delete(self.chat.id, self.id)
+
+    async def forward(self, chat_id: int):
+        """Forward the current message to another chat.
+
+        Args:
+            chat_id: Destination chat ID
+        """
+        if self.chat and self.chat.id and self.id:
+            await self.client.forward(self.chat.id, chat_id, self.id)
+
+    async def reply_photo(
+        self,
+        photo: str,
+        caption: Optional[str] = None,
+        reply_markup: Union["ReplyKeyboardMarkup", "InlineKeyboardMarkup"] = None,
+    ):
+        """Reply with a photo to the current message.
+
+        Args:
+            photo: Photo to send (file_id or URL)
+            caption: Optional caption for the photo
+            reply_markup: Optional keyboard markup
+        """
+        if self.chat and self.chat.id:
+            await self.client.send_photo(
+                self.chat.id, photo=photo, caption=caption, reply_markup=reply_markup
+            )
+
+    async def reply_video(
+        self,
+        video: str,
+        caption: Optional[str] = None,
+        reply_markup: Union["ReplyKeyboardMarkup", "InlineKeyboardMarkup"] = None,
+    ):
+        """Reply with a video to the current message.
+
+        Args:
+            video: Video to send (file_id or URL)
+            caption: Optional caption for the video
+            reply_markup: Optional keyboard markup
+        """
+        if self.chat and self.chat.id:
+            await self.client.send_video(
+                self.chat.id, video=video, caption=caption, reply_markup=reply_markup
+            )
+
+    async def reply_audio(
+        self,
+        audio: str,
+        caption: Optional[str] = None,
+        reply_markup: Union["ReplyKeyboardMarkup", "InlineKeyboardMarkup"] = None,
+    ):
+        """Reply with an audio file to the current message.
+
+        Args:
+            audio: Audio to send (file_id or URL)
+            caption: Optional caption for the audio
+            reply_markup: Optional keyboard markup
+        """
+        if self.chat and self.chat.id:
+            await self.client.send_audio(
+                self.chat.id, audio=audio, caption=caption, reply_markup=reply_markup
+            )
+
+    async def reply_document(
+        self,
+        document: str,
+        caption: Optional[str] = None,
+        reply_markup: Union["ReplyKeyboardMarkup", "InlineKeyboardMarkup"] = None,
+    ):
+        """Reply with a document to the current message.
+
+        Args:
+            document: Document to send (file_id or URL)
+            caption: Optional caption for the document
+            reply_markup: Optional keyboard markup
+        """
+        if self.chat and self.chat.id:
+            await self.client.send_document(
+                self.chat.id,
+                document=document,
+                caption=caption,
+                reply_markup=reply_markup,
+            )
+
+    async def reply_sticker(
+        self,
+        sticker: str,
+        reply_markup: Union["ReplyKeyboardMarkup", "InlineKeyboardMarkup"] = None,
+    ):
+        """Reply with a sticker to the current message.
+
+        Args:
+            sticker: Sticker to send (file_id or URL)
+            reply_markup: Optional keyboard markup
+        """
+        if self.chat and self.chat.id:
+            await self.client.send_sticker(
+                self.chat.id, sticker=sticker, reply_markup=reply_markup
+            )
+
+    async def reply_location(
+        self,
+        latitude: float,
+        longitude: float,
+        reply_markup: Union["ReplyKeyboardMarkup", "InlineKeyboardMarkup"] = None,
+    ):
+        """Reply with a location to the current message.
+
+        Args:
+            latitude: Latitude of the location
+            longitude: Longitude of the location
+            reply_markup: Optional keyboard markup
+        """
+        if self.chat and self.chat.id:
+            await self.client.send_location(
+                self.chat.id,
+                latitude=latitude,
+                longitude=longitude,
+                reply_markup=reply_markup,
+            )
+
+    async def reply_contact(
+        self,
+        phone_number: str,
+        first_name: str,
+        reply_markup: Union["ReplyKeyboardMarkup", "InlineKeyboardMarkup"] = None,
+    ):
+        """Reply with a contact to the current message.
+
+        Args:
+            phone_number: Contact's phone number
+            first_name: Contact's first name
+            reply_markup: Optional keyboard markup
+        """
+        if self.chat and self.chat.id:
+            await self.client.send_contact(
+                self.chat.id,
+                phone_number=phone_number,
+                first_name=first_name,
+                reply_markup=reply_markup,
+            )
+
+    async def reply_invoice(
+        self,
+        title: str,
+        description: str,
+        payload: str,
+        provider_token: str,
+        currency: str,
+        prices: list,
+        reply_markup: Union["ReplyKeyboardMarkup", "InlineKeyboardMarkup"] = None,
+    ):
+        """Reply with an invoice to the current message.
+
+        Args:
+            title: Product name
+            description: Product description
+            payload: Bot-defined invoice payload
+            provider_token: Payment provider token
+            currency: Three-letter ISO 4217 currency code
+            prices: Price breakdown (amount in smallest units)
+            reply_markup: Optional keyboard markup
+        """
+        if self.chat and self.chat.id:
+            await self.client.send_invoice(
+                self.chat.id,
+                title=title,
+                description=description,
+                payload=payload,
+                provider_token=provider_token,
+                currency=currency,
+                prices=prices,
+                reply_markup=reply_markup,
+            )

pyrobale/objects/messageid.py

@@ -0,0 +1,3 @@
+class MessageId:
+    def __init__(self, message_id: int):
+        self.message_id = message_id

pyrobale/objects/photosize.py

@@ -0,0 +1,9 @@
+class PhotoSize:
+    def __init__(
+        self, file_id: str, file_unique_id: str, width: int, height: int, file_size: int
+    ):
+        self.file_id = file_id
+        self.file_unique_id = file_unique_id
+        self.width = width
+        self.height = height
+        self.file_size = file_size

pyrobale/objects/precheckoutquery.py

@@ -0,0 +1,21 @@
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from .user import User
+
+
+class PreCheckoutQuery:
+    def __init__(
+        self,
+        id: str,
+        from_user: "User",
+        currency: str,
+        total_amount: int,
+        invoice_payload: str,
+        **kwargs
+    ) -> None:
+        self.id = id
+        self.from_user = from_user
+        self.currency = currency
+        self.total_amount = total_amount
+        self.invoice_payload = invoice_payload

pyrobale/objects/replykeyboardmarkup.py

@@ -0,0 +1,54 @@
+from typing import TYPE_CHECKING, Union
+
+if TYPE_CHECKING:
+    from .webappinfo import WebAppInfo
+    from .copytextbutton import CopyTextButton
+
+
+class ReplyKeyboardMarkup:
+    """
+    Represents a reply keyboard.
+    Attributes:
+        Each dictionary contains the following keys:
+            - keyboard (list): A list of lists of dictionaries representing the buttons in the keyboard.
+            - text (str): The text of the button.
+            - request_contact (bool, optional): If True, the user's phone number will be sent.
+            - request_location (bool, optional): If True, the user's location will be sent.
+            - web_app (WebApp, optional): The web app associated with the button.
+    """
+
+    def __init__(self):
+        self.keyboard = []
+
+    def add_button(
+        self,
+        text: str,
+        request_contact: bool = None,
+        request_location: bool = None,
+        web_app: Union["WebAppInfo", str] = None,
+    ):
+        """Add a button to the current row."""
+        button = {"text": text}
+        if request_contact:
+            button["request_contact"] = request_contact
+        if request_location:
+            button["request_location"] = request_location
+        if web_app:
+            button["web_app"] = web_app
+
+        if not self.keyboard:
+            self.keyboard.append([])
+        self.keyboard[-1].append(button)
+        return self
+
+    def add_row(self):
+        """Add a new row for buttons."""
+        self.keyboard.append([])
+        return self
+
+    @property
+    def json(self):
+        return {"keyboard": self.keyboard}
+
+    def __str__(self):
+        return str(self.json)

pyrobale/objects/sticker.py

@@ -0,0 +1,16 @@
+class Sticker:
+    def __init__(
+        self,
+        file_id: str,
+        file_unique_id: str,
+        type: str,
+        width: int,
+        height: int,
+        file_size: int,
+    ):
+        self.file_id = file_id
+        self.file_unique_id = file_unique_id
+        self.type = type
+        self.width = width
+        self.height = height
+        self.file_size = file_size

pyrobale/objects/stickerset.py

@@ -0,0 +1,12 @@
+from typing import List, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from .sticker import Sticker
+    from .photosize import PhotoSize
+
+
+class StickerSet:
+    def __init__(
+        self, name: str, title: str, stickers: List["Sticker"], thumb: "PhotoSize"
+    ):
+        pass

pyrobale/objects/successfulpayment.py

@@ -0,0 +1,15 @@
+class SuccessfulPayment:
+    def __init__(
+        self,
+        currency: str,
+        total_amount: int,
+        invoice_payload: str,
+        telegram_payment_charge_id: str,
+        provider_payment_charge_id: str,
+        **kwargs
+    ):
+        self.currency = currency
+        self.total_amount = total_amount
+        self.invoice_payload = invoice_payload
+        self.telegram_payment_charge_id = telegram_payment_charge_id
+        self.provider_payment_charge_id = provider_payment_charge_id

pyrobale/objects/update.py

@@ -0,0 +1,23 @@
+from typing import TYPE_CHECKING, Optional
+
+if TYPE_CHECKING:
+    from .message import Message
+    from .callbackquery import CallbackQuery
+    from .precheckoutquery import PreCheckoutQuery
+
+
+class Update:
+    def __init__(
+        self,
+        update_id: int,
+        message: Optional["Message"] = None,
+        edited_message: Optional["Message"] = None,
+        callback_query: Optional["CallbackQuery"] = None,
+        pre_checkout_query: Optional["PreCheckoutQuery"] = None,
+        **kwargs
+    ):
+        self.update_id = update_id
+        self.message = message
+        self.edited_message = edited_message
+        self.callback_query = callback_query
+        self.pre_checkout_query = pre_checkout_query

pyrobale/objects/user.py

@@ -0,0 +1,20 @@
+from typing import Optional, Union
+from .utils import build_api_url
+import asyncio
+import aiohttp
+
+
+class User:
+    def __init__(
+        self,
+        id: int,
+        is_bot: bool,
+        first_name: str,
+        last_name: Optional[str],
+        username: Optional[str],
+    ):
+        self.id = id
+        self.is_bot = is_bot
+        self.first_name = first_name
+        self.last_name = last_name
+        self.username = username

pyrobale/objects/utils.py

@@ -0,0 +1,28 @@
+import asyncio
+import aiohttp
+
+
+def build_api_url(base: str, endpoint: str) -> str:
+    return f"{base}/{endpoint}"
+
+
+async def make_post(url: str, data: dict = None, headers: dict = None) -> dict:
+    async with aiohttp.ClientSession() as session:
+        async with session.post(url, json=data, headers=headers) as response:
+            return await response.json()
+
+
+async def make_get(url: str, headers: dict = None) -> dict:
+    async with aiohttp.ClientSession() as session:
+        async with session.get(url, headers=headers) as response:
+            return await response.json()
+
+
+def pythonize(dictionary: dict) -> dict:
+    """Converts a dictionary with keys in snake_case to camelCase."""
+    result = {}
+    for key, value in dictionary.items():
+        if key == "from":
+            key = "from_user"
+        result[key] = value
+    return result

pyrobale/objects/video.py

@@ -0,0 +1,20 @@
+class Video:
+    def __init__(
+        self,
+        file_id: str,
+        file_unique_id: str,
+        width: int,
+        height: int,
+        duration: int,
+        file_name: str,
+        mime_type: str,
+        file_size: int,
+    ):
+        self.file_id = file_id
+        self.file_unique_id = file_unique_id
+        self.width = width
+        self.height = height
+        self.duration = duration
+        self.file_name = file_name
+        self.mime_type = mime_type
+        self.file_size = file_size

pyrobale/objects/voice.py

@@ -0,0 +1,4 @@
+class Voice:
+    def __init__(self, file_id: str, file_unique_id: str):
+        self.file_id = file_id
+        self.file_unique_id = file_unique_id

pyrobale/objects/webappdata.py

@@ -0,0 +1,3 @@
+class WebAppData:
+    def __init__(self, data: str):
+        self.data = data

pyrobale/objects/webappinfo.py

@@ -0,0 +1,3 @@
+class WebAppInfo:
+    def __init__(self, url: str):
+        self.url = url