maxapi-lite 0.2.0__py3-none-any.whl

maxapi_lite/__init__.py

@@ -0,0 +1,42 @@
+"""
+maxapi_lite - легковесный асинхронный клиент MAX Bot API, совместимый с aiohttp 3.8.
+
+Позволяет использовать MAX API в проектах, привязанных к старому aiohttp
+(например, aiogram 2.x требует aiohttp<3.9, а официальный maxapi - aiohttp>=3.12).
+"""
+
+from .bot import Bot
+from .enums import ChatPermission, ParseMode
+from .exceptions import InvalidToken, MaxApiError
+from .types import (
+    Attachment,
+    ButtonsPayload,
+    CallbackButton,
+    InputMedia,
+    LinkButton,
+    MessageButton,
+    RequestContactButton,
+    RequestGeoLocationButton,
+)
+
+__version__ = "0.2.0"
+
+__all__ = [
+    # Main class
+    "Bot",
+    # Types
+    "Attachment",
+    "ButtonsPayload",
+    "CallbackButton",
+    "LinkButton",
+    "MessageButton",
+    "RequestContactButton",
+    "RequestGeoLocationButton",
+    "InputMedia",
+    # Enums
+    "ParseMode",
+    "ChatPermission",
+    # Exceptions
+    "MaxApiError",
+    "InvalidToken",
+]

maxapi_lite/bot.py

@@ -0,0 +1,453 @@
+"""
+Max API Lite - легковесный клиент для Max API
+Совместим с aiohttp 3.8.4
+"""
+
+import mimetypes
+import os
+from typing import Any, Dict, List, Optional, Union
+
+import aiohttp
+
+from .client import MaxApiClient
+from .enums import ParseMode
+from .exceptions import MaxApiError
+from .types import Attachment
+
+
+class Bot:
+    """
+    Основной класс бота для работы с Max API
+    Реализует только необходимые методы для совместимости с aiohttp 3.8.4
+    """
+
+    def __init__(self, token: Optional[str] = None, parse_mode: Optional[ParseMode] = None):
+        """
+        Инициализация бота
+
+        Args:
+            token: Токен бота Max API
+            parse_mode: Режим парсинга по умолчанию (HTML/MARKDOWN)
+        """
+        if token is None:
+            token = os.environ.get("MAX_BOT_TOKEN")
+            if token is None:
+                raise ValueError("Token must be provided or set in MAX_BOT_TOKEN environment variable")
+
+        self.client = MaxApiClient(token)
+        self.parse_mode = parse_mode
+        self._me: Optional[Dict[str, Any]] = None
+
+    async def close_session(self):
+        """Закрыть HTTP сессию"""
+        await self.client.close()
+
+    async def get_me(self) -> Dict[str, Any]:
+        """
+        Получить информацию о текущем боте
+
+        Returns:
+            Dict с информацией о боте (user_id, name, username, etc)
+        """
+        if self._me is None:
+            self._me = await self.client.request("GET", "/me")
+        return self._me
+
+    async def get_updates(self, limit: int = 100, timeout: int = 30, marker: Optional[int] = None) -> Dict[str, Any]:
+        """
+        Получить обновления бота (long polling)
+
+        Args:
+            limit: Максимальное количество обновлений
+            timeout: Таймаут ожидания новых обновлений
+            marker: Маркер последнего обработанного обновления
+
+        Returns:
+            Dict с полем "updates" - список обновлений
+        """
+        params = {"limit": limit, "timeout": timeout}
+        if marker is not None:
+            params["marker"] = marker
+
+        return await self.client.request("GET", "/updates", params=params)
+
+    @staticmethod
+    def _serialize_attachments(
+        attachments: Optional[List[Union[Attachment, Dict[str, Any]]]],
+    ) -> Optional[List[Dict[str, Any]]]:
+        if attachments is None:
+            return None
+        result: List[Dict[str, Any]] = []
+        for att in attachments:
+            if hasattr(att, "model_dump"):
+                result.append(att.model_dump())
+            elif isinstance(att, dict):
+                result.append(att)
+            else:
+                result.append(att)
+        return result
+
+    @staticmethod
+    def extract_message_id(response: Optional[Dict[str, Any]]) -> Optional[str]:
+        if not isinstance(response, dict):
+            return None
+        message = response.get("message") or {}
+        body = message.get("body") or {}
+        mid = body.get("mid")
+        if not mid:
+            return None
+        return str(mid)
+
+    @staticmethod
+    def build_link_button_attachment(text: str, url: str) -> Dict[str, Any]:
+        return {
+            "type": "inline_keyboard",
+            "payload": {
+                "buttons": [
+                    [
+                        {
+                            "type": "link",
+                            "text": text,
+                            "url": url,
+                        }
+                    ]
+                ]
+            },
+        }
+
+    @staticmethod
+    def _media_mapping(media_type: str) -> tuple[str, str]:
+        return {
+            "photo": ("image", "image"),
+            "animation": ("image", "image"),
+            "video": ("video", "video"),
+            "document": ("file", "file"),
+            "file": ("file", "file"),
+            "image": ("image", "image"),
+        }.get(media_type, ("file", "file"))
+
+    async def upload_file(self, file_path: str, upload_type: str) -> Dict[str, Any]:
+        if not file_path or not os.path.isfile(file_path):
+            raise MaxApiError(f"File not found: {file_path}", 400)
+
+        init_resp = await self.client.request("POST", "/uploads", params={"type": upload_type})
+        upload_url = init_resp.get("url")
+        if not upload_url:
+            raise MaxApiError(f"MAX upload init response has no url: {init_resp}", 500)
+
+        content_type = mimetypes.guess_type(file_path)[0] or "application/octet-stream"
+        async with aiohttp.ClientSession() as session:
+            with open(file_path, "rb") as media_file:
+                form = aiohttp.FormData()
+                form.add_field(
+                    "data",
+                    media_file,
+                    filename=os.path.basename(file_path),
+                    content_type=content_type,
+                )
+                async with session.post(upload_url, data=form) as response:
+                    if response.status >= 400:
+                        text = await response.text()
+                        raise MaxApiError(f"MAX upload failed [{response.status}]: {text}", response.status)
+                    try:
+                        return await response.json()
+                    except Exception:
+                        return {}
+
+    async def create_media_attachment(
+        self,
+        media_type: str,
+        *,
+        file_path: Optional[str] = None,
+        url: Optional[str] = None,
+    ) -> Optional[Dict[str, Any]]:
+        upload_type, attachment_type = self._media_mapping(media_type)
+        if url:
+            return {"type": attachment_type, "payload": {"url": url}}
+        if not file_path:
+            return None
+
+        upload_resp = await self.upload_file(file_path, upload_type)
+        if upload_type == "image":
+            photos = upload_resp.get("photos") or {}
+            first_photo = next(iter(photos.values()), None) if isinstance(photos, dict) else None
+            if not isinstance(first_photo, dict):
+                raise MaxApiError(f"MAX image upload payload is invalid: {upload_resp}", 500)
+            payload = first_photo
+        else:
+            payload = upload_resp if isinstance(upload_resp, dict) else {}
+            if not payload.get("token"):
+                raise MaxApiError(f"MAX upload payload is invalid: {upload_resp}", 500)
+        return {"type": attachment_type, "payload": payload}
+
+    async def send_message(
+        self,
+        chat_id: Optional[int] = None,
+        user_id: Optional[int] = None,
+        text: Optional[str] = None,
+        attachments: Optional[List[Union[Attachment, Dict[str, Any]]]] = None,
+        format: Optional[str] = None,
+        notify: Optional[bool] = None,
+        **kwargs,
+    ) -> Dict[str, Any]:
+        """
+        Отправить сообщение
+
+        Args:
+            chat_id: ID чата (для групповых чатов)
+            user_id: ID пользователя (для личных сообщений)
+            text: Текст сообщения
+            attachments: Вложения (кнопки, медиа)
+            format: Формат текста (html/markdown)
+            notify: Отправлять уведомление
+
+        Returns:
+            Dict с отправленным сообщением
+        """
+        # Формируем тело запроса
+        body: Dict[str, Any] = {}
+        params: Dict[str, Any] = {}
+
+        if chat_id is not None:
+            params["chat_id"] = chat_id
+        elif user_id is not None:
+            params["user_id"] = user_id
+        else:
+            raise ValueError("Either chat_id or user_id must be provided")
+
+        if text:
+            body["text"] = text
+
+        serialized_attachments = self._serialize_attachments(attachments)
+        if serialized_attachments is not None:
+            body["attachments"] = serialized_attachments
+
+        # Используем format или parse_mode
+        if format:
+            body["format"] = format
+        elif self.parse_mode:
+            body["format"] = self.parse_mode.value
+
+        if notify is not None:
+            body["notify"] = notify
+
+        return await self.client.request("POST", "/messages", params=params, json=body)
+
+    async def send_message_with_media(
+        self,
+        *,
+        chat_id: int,
+        text: Optional[str] = None,
+        media_type: Optional[str] = None,
+        file_path: Optional[str] = None,
+        media_url: Optional[str] = None,
+        attachments: Optional[List[Union[Attachment, Dict[str, Any]]]] = None,
+        format: Optional[str] = None,
+        notify: Optional[bool] = None,
+    ) -> Dict[str, Any]:
+        send_attachments: List[Union[Attachment, Dict[str, Any]]] = []
+        if attachments:
+            send_attachments.extend(attachments)
+        if media_type and (file_path or media_url):
+            media_attachment = await self.create_media_attachment(media_type, file_path=file_path, url=media_url)
+            if media_attachment:
+                send_attachments.append(media_attachment)
+        return await self.send_message(
+            chat_id=chat_id,
+            text=text,
+            attachments=send_attachments or None,
+            format=format,
+            notify=notify,
+        )
+
+    async def edit_message(
+        self,
+        message_id: str,
+        text: Optional[str] = None,
+        attachments: Optional[List[Union[Attachment, Dict[str, Any]]]] = None,
+        format: Optional[str] = None,
+        **kwargs,
+    ) -> Dict[str, Any]:
+        """
+        Редактировать сообщение
+
+        Args:
+            message_id: ID сообщения для редактирования
+            text: Новый текст
+            attachments: Новые вложения
+
+        Returns:
+            Dict с отредактированным сообщением
+        """
+        body: Dict[str, Any] = {}
+        params: Dict[str, Any] = {"message_id": message_id}
+
+        if text is not None:
+            body["text"] = text
+
+        serialized_attachments = self._serialize_attachments(attachments)
+        if serialized_attachments is not None:
+            body["attachments"] = serialized_attachments
+
+        # Preserve text formatting on edits the same way as in send_message.
+        # Format only applies to text, so attachment-only edits leave the text untouched.
+        if text is not None:
+            if format:
+                body["format"] = format
+            elif self.parse_mode:
+                body["format"] = self.parse_mode.value
+
+        return await self.client.request("PUT", "/messages", params=params, json=body)
+
+    async def edit_message_with_media(
+        self,
+        *,
+        message_id: str,
+        text: Optional[str] = None,
+        media_type: Optional[str] = None,
+        file_path: Optional[str] = None,
+        media_url: Optional[str] = None,
+        attachments: Optional[List[Union[Attachment, Dict[str, Any]]]] = None,
+        format: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        edit_attachments: List[Union[Attachment, Dict[str, Any]]] = []
+        if attachments:
+            edit_attachments.extend(attachments)
+        if media_type and (file_path or media_url):
+            media_attachment = await self.create_media_attachment(media_type, file_path=file_path, url=media_url)
+            if media_attachment:
+                edit_attachments.append(media_attachment)
+        return await self.edit_message(
+            message_id=message_id,
+            text=text,
+            attachments=edit_attachments or [],
+            format=format,
+        )
+
+    async def pin_chat_message(self, chat_id: int, message_id: str, notify: bool = True) -> Dict[str, Any]:
+        """
+        Закрепить сообщение в чате/канале.
+
+        Args:
+            chat_id: ID чата
+            message_id: ID сообщения (mid.*)
+            notify: Показывать уведомление участникам
+        """
+        body: Dict[str, Any] = {"message_id": message_id}
+        if notify is not None:
+            body["notify"] = notify
+        return await self.client.request("PUT", f"/chats/{chat_id}/pin", json=body)
+
+    async def pin_from_response(
+        self, chat_id: int, response: Dict[str, Any], notify: bool = True
+    ) -> Optional[Dict[str, Any]]:
+        message_id = self.extract_message_id(response)
+        if not message_id:
+            return None
+        return await self.pin_chat_message(chat_id=chat_id, message_id=message_id, notify=notify)
+
+    async def get_message(self, message_id: str) -> Dict[str, Any]:
+        """Получить сообщение (текст и вложения) по ID."""
+        return await self.client.request("GET", f"/messages/{message_id}")
+
+    async def unpin_chat_message(self, chat_id: int) -> Dict[str, Any]:
+        """Remove the pinned message or channel post from a MAX chat."""
+        return await self.client.request("DELETE", f"/chats/{chat_id}/pin")
+
+    async def delete_message(self, message_id: str) -> Dict[str, Any]:
+        """
+        Удалить сообщение
+
+        Args:
+            message_id: ID сообщения
+
+        Returns:
+            Dict с результатом удаления
+        """
+        return await self.client.request("DELETE", f"/messages/{message_id}")
+
+    async def send_callback(self, callback_id: str, notification: Optional[str] = None) -> Dict[str, Any]:
+        """
+        Ответить на callback query
+
+        Args:
+            callback_id: ID callback query
+            notification: Текст уведомления для пользователя
+
+        Returns:
+            Dict с результатом
+        """
+        body: Dict[str, Any] = {"callback_id": callback_id}
+
+        if notification:
+            body["notification"] = notification
+
+        return await self.client.request("POST", "/answers", json=body)
+
+    async def get_chat_by_id(self, id: int) -> Dict[str, Any]:
+        """
+        Получить информацию о чате
+
+        Args:
+            id: ID чата
+
+        Returns:
+            Dict с информацией о чате
+        """
+        return await self.client.request("GET", f"/chats/{id}")
+
+    async def get_chat_member(self, chat_id: int, user_id: int) -> Optional[Dict[str, Any]]:
+        """
+        Получить информацию об участнике чата с его правами
+
+        Args:
+            chat_id: ID чата
+            user_id: ID пользователя
+
+        Returns:
+            Dict с информацией об участнике (включая permissions) или None
+        """
+        # Max API возвращает список участников
+        result = await self.client.request("GET", f"/chats/{chat_id}/members", params={"user_ids": [user_id]})
+
+        members = result.get("members", [])
+        if members:
+            return members[0]
+
+        return None
+
+    async def get_list_admin_chat(self, chat_id: int) -> Dict[str, Any]:
+        """
+        Получить список администраторов чата
+
+        Args:
+            chat_id: ID чата
+
+        Returns:
+            Dict со списком администраторов в поле "members"
+        """
+        return await self.client.request("GET", f"/chats/{chat_id}/members/admins")
+
+    async def get_chat_members_batch(self, chat_id: int, user_ids: list[int]) -> list[int]:
+        """
+        Проверить список пользователей на членство в чате.
+        Возвращает список user_id которые состоят в чате.
+
+        Args:
+            chat_id: ID чата
+            user_ids: Список ID пользователей для проверки (максимум 100 за раз)
+
+        Returns:
+            List с user_id участников чата
+        """
+        if not user_ids:
+            return []
+
+        ids_str = ','.join(str(uid) for uid in user_ids)
+        result = await self.client.request(
+            "GET",
+            f"/chats/{chat_id}/members",
+            params={"user_ids": ids_str}
+        )
+        members = result.get("members", [])
+        return [m.get("user_id") for m in members if m.get("user_id")]

maxapi_lite/client.py

@@ -0,0 +1,90 @@
+"""
+HTTP клиент для Max API Lite
+"""
+
+import aiohttp
+from typing import Optional, Dict, Any
+from .exceptions import MaxApiError, InvalidToken
+
+
+class MaxApiClient:
+    """Легковесный HTTP клиент для Max API, совместимый с aiohttp 3.8.4"""
+
+    BASE_URL = "https://platform-api.max.ru"
+
+    def __init__(self, token: str):
+        """
+        Инициализация клиента
+
+        Args:
+            token: Токен бота Max API
+        """
+        if not token:
+            raise InvalidToken("Token cannot be empty")
+
+        self.token = token
+        self.headers = {"Authorization": token}
+        self._session: Optional[aiohttp.ClientSession] = None
+
+    async def _get_session(self) -> aiohttp.ClientSession:
+        """Получить или создать aiohttp сессию"""
+        if self._session is None or self._session.closed:
+            self._session = aiohttp.ClientSession(headers=self.headers)
+        return self._session
+
+    async def close(self):
+        """Закрыть HTTP сессию"""
+        if self._session and not self._session.closed:
+            await self._session.close()
+            self._session = None
+
+    async def request(
+        self,
+        method: str,
+        endpoint: str,
+        params: Optional[Dict[str, Any]] = None,
+        json: Optional[Dict[str, Any]] = None,
+        **kwargs,
+    ) -> Dict[str, Any]:
+        """
+        Выполнить HTTP запрос к Max API
+
+        Args:
+            method: HTTP метод (GET, POST, PUT, DELETE)
+            endpoint: API endpoint (начинается с /)
+            params: Query параметры
+            json: JSON body запроса
+            **kwargs: Дополнительные параметры для aiohttp
+
+        Returns:
+            Dict с ответом API
+
+        Raises:
+            InvalidToken: При ошибке авторизации (401)
+            MaxApiError: При других ошибках API
+        """
+        session = await self._get_session()
+        url = f"{self.BASE_URL}{endpoint}"
+
+        try:
+            async with session.request(method=method, url=url, params=params, json=json, **kwargs) as response:
+                # Читаем ответ
+                try:
+                    data = await response.json()
+                except Exception:
+                    # Если не JSON, читаем как текст
+                    text = await response.text()
+                    data = {"error": text}
+
+                # Проверяем статус
+                if response.status == 401:
+                    raise InvalidToken("Invalid or expired token")
+
+                if response.status >= 400:
+                    error_message = data.get("error", data.get("message", "Unknown error"))
+                    raise MaxApiError(error_message, response.status)
+
+                return data
+
+        except aiohttp.ClientError as e:
+            raise MaxApiError(f"Connection error: {e}", 500)

maxapi_lite/enums.py

@@ -0,0 +1,23 @@
+"""
+Enums для Max API Lite
+"""
+
+from enum import Enum
+
+
+class ParseMode(str, Enum):
+    """Режим парсинга текста"""
+
+    HTML = "html"
+    MARKDOWN = "markdown"
+
+
+class ChatPermission(str, Enum):
+    """Права участника чата"""
+
+    # Основные права из Max API
+    READ_ALL_MESSAGES = "read_all_messages"
+    WRITE = "write"
+    ADD_REMOVE_MEMBERS = "add_remove_members"
+    ADD_ADMINS = "add_admins"
+    CHANGE_CHAT_INFO = "change_chat_info"

maxapi_lite/exceptions.py

@@ -0,0 +1,19 @@
+"""
+Исключения для Max API Lite
+"""
+
+
+class MaxApiError(Exception):
+    """Базовое исключение Max API"""
+
+    def __init__(self, message: str = "Unknown error", code: int = 500):
+        self.message = message
+        self.code = code
+        super().__init__(f"[{code}] {message}")
+
+
+class InvalidToken(MaxApiError):
+    """Неверный токен авторизации"""
+
+    def __init__(self, message: str = "Invalid token"):
+        super().__init__(message, 401)

maxapi_lite/types.py

@@ -0,0 +1,64 @@
+"""
+Типы данных для Max API Lite
+"""
+
+from pydantic import BaseModel
+from typing import Optional, List, Any, Union, Dict
+
+
+# Кнопки
+class CallbackButton(BaseModel):
+    """Кнопка с callback"""
+
+    text: str
+    payload: str
+
+
+class LinkButton(BaseModel):
+    """Кнопка со ссылкой"""
+
+    text: str
+    url: str
+
+
+class MessageButton(BaseModel):
+    """Кнопка с текстовым сообщением"""
+
+    text: str
+
+
+class RequestContactButton(BaseModel):
+    """Кнопка запроса контакта"""
+
+    text: str
+
+
+class RequestGeoLocationButton(BaseModel):
+    """Кнопка запроса геолокации"""
+
+    text: str
+
+
+ButtonType = Union[CallbackButton, LinkButton, MessageButton, RequestContactButton, RequestGeoLocationButton]
+
+
+class ButtonsPayload(BaseModel):
+    """Payload для кнопок"""
+
+    buttons: List[List[ButtonType]]
+
+
+class Attachment(BaseModel):
+    """Вложение к сообщению"""
+
+    type: str
+    payload: Union[ButtonsPayload, Dict[str, Any], Any]
+
+
+class InputMedia(BaseModel):
+    """Медиа для загрузки"""
+
+    type: str = "photo"
+    url: Optional[str] = None
+    token: Optional[str] = None
+    file_path: Optional[str] = None

maxapi_lite-0.2.0.dist-info/METADATA

@@ -0,0 +1,144 @@
+Metadata-Version: 2.5
+Name: maxapi-lite
+Version: 0.2.0
+Summary: Lightweight async client for the MAX messenger Bot API, compatible with aiohttp 3.8
+Project-URL: Homepage, https://github.com/kiriyk/maxapi-lite
+Project-URL: Source, https://github.com/kiriyk/maxapi-lite
+Project-URL: Issues, https://github.com/kiriyk/maxapi-lite/issues
+Project-URL: Changelog, https://github.com/kiriyk/maxapi-lite/blob/main/CHANGELOG.md
+Author: Kirill
+License-Expression: MIT
+License-File: LICENSE
+Keywords: aiohttp,asyncio,bot,bot-api,max,max.ru,messenger
+Classifier: Development Status :: 4 - Beta
+Classifier: Framework :: AsyncIO
+Classifier: Intended Audience :: Developers
+Classifier: Natural Language :: Russian
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Communications :: Chat
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Requires-Dist: aiohttp>=3.8
+Requires-Dist: pydantic>=2
+Provides-Extra: test
+Requires-Dist: pytest-asyncio>=0.21; extra == 'test'
+Requires-Dist: pytest>=7; extra == 'test'
+Description-Content-Type: text/markdown
+
+# maxapi-lite
+
+[![PyPI](https://img.shields.io/pypi/v/maxapi-lite.svg)](https://pypi.org/project/maxapi-lite/)
+[![Python](https://img.shields.io/pypi/pyversions/maxapi-lite.svg)](https://pypi.org/project/maxapi-lite/)
+[![CI](https://github.com/kiriyk/maxapi-lite/actions/workflows/ci.yml/badge.svg)](https://github.com/kiriyk/maxapi-lite/actions/workflows/ci.yml)
+
+Легковесный асинхронный клиент [MAX Bot API](https://dev.max.ru/docs-api), совместимый с `aiohttp 3.8.x`.
+
+Пакет нужен, когда в проекте уже зафиксирован старый `aiohttp` — например, рядом живёт
+`aiogram 2.x` (`aiohttp<3.9`), а официальный клиент `maxapi` требует `aiohttp>=3.12`.
+Зависимости — только `aiohttp>=3.8` и `pydantic>=2`.
+
+*Lightweight async client for the MAX messenger Bot API that works with aiohttp 3.8,
+so it can share an environment with aiogram 2.x.*
+
+## Установка
+
+```bash
+pip install maxapi-lite
+```
+
+## Быстрый старт
+
+```python
+import asyncio
+from maxapi_lite import Bot, ParseMode
+
+
+async def main():
+    bot = Bot(token="YOUR_MAX_TOKEN", parse_mode=ParseMode.HTML)  # или переменная окружения MAX_BOT_TOKEN
+
+    # Кнопка-ссылка
+    kb_attachment = bot.build_link_button_attachment(
+        text="Открыть MiniApp",
+        url="https://example.com/app?startapp=123",
+    )
+
+    # Отправка фото + кнопки
+    result = await bot.send_message_with_media(
+        chat_id=-70893181482276,
+        text="<b>Розыгрыш</b>",
+        media_type="photo",
+        file_path="banner.jpg",  # или media_url="https://..."
+        attachments=[kb_attachment],
+    )
+
+    # Извлечение mid и закрепление
+    mid = bot.extract_message_id(result)
+    if mid:
+        await bot.pin_chat_message(chat_id=-70893181482276, message_id=mid)
+
+    await bot.close_session()
+
+
+asyncio.run(main())
+```
+
+### Long polling
+
+```python
+marker = None
+while True:
+    data = await bot.get_updates(timeout=30, marker=marker)
+    for update in data.get("updates", []):
+        ...
+    marker = data.get("marker", marker)
+```
+
+## Методы `Bot`
+
+| Группа | Методы |
+| --- | --- |
+| Бот и обновления | `get_me`, `get_updates` |
+| Сообщения | `send_message`, `edit_message`, `delete_message`, `get_message` |
+| Медиа | `upload_file`, `create_media_attachment`, `send_message_with_media`, `edit_message_with_media` |
+| Закрепление | `pin_chat_message`, `pin_from_response`, `unpin_chat_message` |
+| Чаты | `get_chat_by_id`, `get_chat_member`, `get_chat_members_batch`, `get_list_admin_chat` |
+| Callback | `send_callback` |
+| Утилиты | `extract_message_id`, `build_link_button_attachment` |
+
+Методы возвращают «сырые» `dict` из ответа API. Ошибки API поднимаются как `MaxApiError`
+(с полем `code`), ошибка авторизации — как `InvalidToken`.
+
+## Поддерживаемые `media_type`
+
+- `photo`, `animation`, `image` → загрузка как `image`
+- `video`
+- `document`, `file`
+
+## Примечания
+
+- `chat_id` / `user_id` передаются query-параметрами, как требует MAX API.
+- `edit_message(..., attachments=[])` явно очищает вложения; `attachments=None` оставляет их как есть.
+- Формат (`parse_mode`) применяется к редактированию только если передан `text`.
+- Для upload используется multipart-поле `data`.
+
+## Разработка
+
+```bash
+pip install -e ".[test]"
+pytest
+```
+
+Релиз: поднять `__version__` в `src/maxapi_lite/__init__.py`, дополнить `CHANGELOG.md`,
+создать GitHub Release с тегом `vX.Y.Z` — workflow `publish.yml` соберёт пакет и опубликует его на PyPI.
+
+## Лицензия
+
+MIT

maxapi_lite-0.2.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+maxapi_lite/__init__.py,sha256=a_qc31x08vLA3zWuESUrdaqPV7uacVKdbzKly28ll9o,1033
+maxapi_lite/bot.py,sha256=wyHmt6QcvvjIYxrCa4kwNXhxLIY8AgXPEAV0g2Ho3VI,16773
+maxapi_lite/client.py,sha256=SUROnI6SY292A9k03OZ3ZLyGqNObarXx6eeM_Z1phwU,3060
+maxapi_lite/enums.py,sha256=bdsyuE5hQN_jd24MMob2R1sI9lChKveEJuUj6_xcLiY,497
+maxapi_lite/exceptions.py,sha256=EjcUCpEOxYbQ2GTddelrR9ZMCkB2lxt4cK3aL_bNAcM,505
+maxapi_lite/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+maxapi_lite/types.py,sha256=dPTi4INNRu6oS0PJ9U-K3tqGLeTeblrXG5P_F_mXe3k,1270
+maxapi_lite-0.2.0.dist-info/METADATA,sha256=od-1KG-WO5FrKPEPR2xabsiN7TKdkvDdLTezmDsJMNw,5546
+maxapi_lite-0.2.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+maxapi_lite-0.2.0.dist-info/licenses/LICENSE,sha256=FrhT0HHTK2qCPqAUkuZpq3h62GxeU5ZxJMn3UcRl2-g,1063
+maxapi_lite-0.2.0.dist-info/RECORD,,

maxapi_lite-0.2.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.4
+Root-Is-Purelib: true
+Tag: py3-none-any

maxapi_lite-0.2.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 kiriyk
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.