r-tg-bot 0.1.0__tar.gz

r_tg_bot-0.1.0/PKG-INFO

@@ -0,0 +1,10 @@
+Metadata-Version: 2.4
+Name: r-tg-bot
+Version: 0.1.0
+Summary: An asynchronous Python library for the Telegram Bot API
+Author-email: Rixa <mrereyoshiki12@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/rixa8/r-tg-bot
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: aiohttp>=3.8.0

r_tg_bot-0.1.0/pyproject.toml

@@ -0,0 +1,20 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "r-tg-bot"
+version = "0.1.0"
+description = "An asynchronous Python library for the Telegram Bot API"
+authors = [
+    {name = "Rixa", email = "mrereyoshiki12@gmail.com"}
+]
+license = {text = "MIT"}
+readme = "README.md"
+requires-python = ">=3.8"
+dependencies = [
+    "aiohttp>=3.8.0"
+]
+
+[project.urls]
+Homepage = "https://github.com/rixa8/r-tg-bot"

r_tg_bot-0.1.0/r_tg_bot/__init__.py

@@ -0,0 +1,27 @@
+"""r-tg-bot: Asynchronous Python library for the Telegram Bot API."""
+
+from .client import Bot
+from .exceptions import (
+    TelegramAPIError,
+    InvalidTokenError,
+    NetworkError,
+    TimeoutError,
+)
+from .types import (
+    Message,
+    Update,
+    User,
+    Chat,
+)
+
+__all__ = [
+    "Bot",
+    "TelegramAPIError",
+    "InvalidTokenError",
+    "NetworkError",
+    "TimeoutError",
+    "Message",
+    "Update",
+    "User",
+    "Chat",
+]

r_tg_bot-0.1.0/r_tg_bot/client.py

@@ -0,0 +1,175 @@
+"""Asynchronous Telegram Bot client."""
+
+import asyncio
+import json
+from typing import Any, Callable, Coroutine, Optional
+
+import aiohttp
+from aiohttp import ClientTimeout
+
+from .exceptions import InvalidTokenError, NetworkError, TelegramAPIError, TimeoutError
+from .types import Update
+
+
+class Bot:
+    """Main client for interacting with the Telegram Bot API."""
+
+    BASE_URL = "https://api.telegram.org/bot{token}"
+
+    def __init__(self, token: str, session: Optional[aiohttp.ClientSession] = None):
+        """
+        Initialize the Bot client.
+
+        :param token: Bot token from BotFather.
+        :param session: Optional aiohttp session (reused if provided).
+        """
+        self.token = token
+        self._session = session
+        self._owned_session = session is None
+        self._offset = 0
+
+    async def _get_session(self) -> aiohttp.ClientSession:
+        """Return existing session or create a new one."""
+        if self._session is None or self._session.closed:
+            self._session = aiohttp.ClientSession()
+            self._owned_session = True
+        return self._session
+
+    async def _request(
+        self,
+        method: str,
+        params: Optional[dict] = None,
+        timeout: int = 30,
+    ) -> dict[str, Any]:
+        """
+        Make an asynchronous request to the Telegram Bot API.
+
+        :param method: API method name (e.g., 'getMe').
+        :param params: Optional query or JSON parameters.
+        :param timeout: Request timeout in seconds.
+        :return: Parsed JSON response.
+        :raises TelegramAPIError: If the API returns an error.
+        """
+        url = self.BASE_URL.format(token=self.token) + f"/{method}"
+        session = await self._get_session()
+
+        try:
+            async with session.post(
+                url,
+                json=params,
+                timeout=ClientTimeout(total=timeout),
+            ) as response:
+                data = await response.json()
+        except aiohttp.ClientConnectionError as e:
+            raise NetworkError(f"Network error: {e}") from e
+        except asyncio.TimeoutError as e:
+            raise TimeoutError(f"Request timed out after {timeout}s") from e
+
+        if not data.get("ok"):
+            error_msg = data.get("description", "Unknown error")
+            status_code = response.status if "response" in locals() else None
+            if status_code == 401:
+                raise InvalidTokenError(error_msg, status_code)
+            raise TelegramAPIError(error_msg, status_code)
+
+        return data["result"]
+
+    async def get_me(self) -> dict[str, Any]:
+        """
+        Get basic information about the bot.
+
+        :return: Bot user information as dictionary.
+        """
+        return await self._request("getMe")
+
+    async def send_message(
+        self,
+        chat_id: int | str,
+        text: str,
+        parse_mode: Optional[str] = None,
+        disable_web_page_preview: bool = False,
+        reply_to_message_id: Optional[int] = None,
+    ) -> dict[str, Any]:
+        """
+        Send a text message.
+
+        :param chat_id: Unique identifier for the target chat.
+        :param text: Text of the message.
+        :param parse_mode: 'HTML' or 'MarkdownV2'.
+        :param disable_web_page_preview: Disables link previews.
+        :param reply_to_message_id: Message ID to reply to.
+        :return: API response containing sent Message.
+        """
+        payload = {
+            "chat_id": chat_id,
+            "text": text,
+            "disable_web_page_preview": disable_web_page_preview,
+        }
+        if parse_mode:
+            payload["parse_mode"] = parse_mode
+        if reply_to_message_id:
+            payload["reply_to_message_id"] = reply_to_message_id
+
+        return await self._request("sendMessage", payload)
+
+    async def get_updates(
+        self,
+        offset: Optional[int] = None,
+        limit: int = 100,
+        timeout: int = 0,
+    ) -> list[Update]:
+        """
+        Get incoming updates using long polling.
+
+        :param offset: Identifier of the first update to be returned.
+        :param limit: Maximum number of updates to be fetched (1-100).
+        :param timeout: Long polling timeout in seconds.
+        :return: List of Update objects.
+        """
+        params = {
+            "offset": offset if offset is not None else self._offset,
+            "limit": limit,
+            "timeout": timeout,
+        }
+        result = await self._request("getUpdates", params, timeout=timeout + 5)
+        updates = [Update.from_dict(item) for item in result]
+        if updates:
+            self._offset = updates[-1].update_id + 1
+        return updates
+
+    async def start_polling(
+        self,
+        update_handler: Callable[[Update], Coroutine[Any, Any, None]],
+        interval: float = 0.0,
+        timeout: int = 30,
+    ) -> None:
+        """
+        Start long polling to receive updates continuously.
+
+        :param update_handler: Async function that takes an Update and processes it.
+        :param interval: Sleep interval between polling cycles (seconds).
+        :param timeout: Long polling timeout for getUpdates.
+        """
+        while True:
+            try:
+                updates = await self.get_updates(timeout=timeout)
+                for update in updates:
+                    await update_handler(update)
+            except TelegramAPIError as e:
+                # Log error but continue polling
+                print(f"Polling error: {e}")
+            except Exception as e:
+                print(f"Unexpected error: {e}")
+            if interval > 0:
+                await asyncio.sleep(interval)
+
+    async def close(self) -> None:
+        """Close the aiohttp session if owned by this client."""
+        if self._session and self._owned_session:
+            await self._session.close()
+
+    async def __aenter__(self) -> "Bot":
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb) -> None:
+        await self.close()

r_tg_bot-0.1.0/r_tg_bot/exceptions.py

@@ -0,0 +1,27 @@
+"""Custom exceptions for the r-tg-bot library."""
+
+
+class TelegramAPIError(Exception):
+    """Base exception for Telegram API related errors."""
+
+    def __init__(self, message: str, status_code: int | None = None):
+        self.status_code = status_code
+        super().__init__(message)
+
+
+class InvalidTokenError(TelegramAPIError):
+    """Raised when the provided bot token is invalid."""
+
+    pass
+
+
+class NetworkError(TelegramAPIError):
+    """Raised when a network-related error occurs."""
+
+    pass
+
+
+class TimeoutError(TelegramAPIError):
+    """Raised when a request times out."""
+
+    pass

r_tg_bot-0.1.0/r_tg_bot/types.py

@@ -0,0 +1,90 @@
+"""Data types representing Telegram API objects."""
+
+from dataclasses import dataclass
+from typing import Any, Optional
+
+
+@dataclass
+class User:
+    """Telegram User object."""
+
+    id: int
+    is_bot: bool
+    first_name: str
+    last_name: Optional[str] = None
+    username: Optional[str] = None
+    language_code: Optional[str] = None
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> "User":
+        """Create User from API dictionary."""
+        return cls(
+            id=data["id"],
+            is_bot=data["is_bot"],
+            first_name=data["first_name"],
+            last_name=data.get("last_name"),
+            username=data.get("username"),
+            language_code=data.get("language_code"),
+        )
+
+
+@dataclass
+class Chat:
+    """Telegram Chat object."""
+
+    id: int
+    type: str
+    title: Optional[str] = None
+    username: Optional[str] = None
+    first_name: Optional[str] = None
+    last_name: Optional[str] = None
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> "Chat":
+        """Create Chat from API dictionary."""
+        return cls(
+            id=data["id"],
+            type=data["type"],
+            title=data.get("title"),
+            username=data.get("username"),
+            first_name=data.get("first_name"),
+            last_name=data.get("last_name"),
+        )
+
+
+@dataclass
+class Message:
+    """Telegram Message object."""
+
+    message_id: int
+    date: int
+    text: Optional[str] = None
+    chat: Optional[Chat] = None
+    from_user: Optional[User] = None
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> "Message":
+        """Create Message from API dictionary."""
+        chat = Chat.from_dict(data["chat"]) if "chat" in data else None
+        from_user = User.from_dict(data["from"]) if "from" in data else None
+        return cls(
+            message_id=data["message_id"],
+            date=data["date"],
+            text=data.get("text"),
+            chat=chat,
+            from_user=from_user,
+        )
+
+
+@dataclass
+class Update:
+    """Telegram Update object."""
+
+    update_id: int
+    message: Optional[Message] = None
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> "Update":
+        """Create Update from API dictionary."""
+        message = Message.from_dict(data["message"]) if "message" in data else None
+        return cls(update_id=data["update_id"], message=message)

r_tg_bot-0.1.0/r_tg_bot.egg-info/PKG-INFO

@@ -0,0 +1,10 @@
+Metadata-Version: 2.4
+Name: r-tg-bot
+Version: 0.1.0
+Summary: An asynchronous Python library for the Telegram Bot API
+Author-email: Rixa <mrereyoshiki12@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/rixa8/r-tg-bot
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: aiohttp>=3.8.0

r_tg_bot-0.1.0/r_tg_bot.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+pyproject.toml
+r_tg_bot/__init__.py
+r_tg_bot/client.py
+r_tg_bot/exceptions.py
+r_tg_bot/types.py
+r_tg_bot.egg-info/PKG-INFO
+r_tg_bot.egg-info/SOURCES.txt
+r_tg_bot.egg-info/dependency_links.txt
+r_tg_bot.egg-info/requires.txt
+r_tg_bot.egg-info/top_level.txt

r_tg_bot-0.1.0/r_tg_bot.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

r_tg_bot-0.1.0/r_tg_bot.egg-info/requires.txt

@@ -0,0 +1 @@
+aiohttp>=3.8.0

r_tg_bot-0.1.0/r_tg_bot.egg-info/top_level.txt

@@ -0,0 +1 @@
+r_tg_bot

r_tg_bot-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+