pymaxgram 4.0.0__tar.gz

pymaxgram-4.0.0/.gitignore

@@ -0,0 +1,9 @@
+__pycache__/
+*.py[cod]
+*$py.class
+*.egg-info/
+dist/
+build/
+.eggs/
+*.egg
+.venv/

pymaxgram-4.0.0/PKG-INFO

@@ -0,0 +1,61 @@
+Metadata-Version: 2.4
+Name: pymaxgram
+Version: 4.0.0
+Summary: Async framework for MAX Messenger Bot API
+Project-URL: Repository, https://github.com/daeeros/pymaxgram
+License-Expression: MIT
+Classifier: Development Status :: 4 - Beta
+Classifier: Framework :: AsyncIO
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+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: Typing :: Typed
+Requires-Python: >=3.10
+Requires-Dist: aiofiles<26.0,>=23.2.1
+Requires-Dist: aiohttp<3.14,>=3.9.0
+Requires-Dist: certifi>=2023.7.22
+Requires-Dist: magic-filter<1.1,>=1.0.12
+Requires-Dist: pydantic<2.13,>=2.4.1
+Requires-Dist: typing-extensions<=5.0,>=4.7.0
+Description-Content-Type: text/markdown
+
+# pymaxgram
+
+Async framework for MAX Messenger Bot API.
+
+## Installation
+
+```bash
+pip install pymaxgram
+```
+
+## Quick Start
+
+```python
+import asyncio
+from maxgram import Bot, Dispatcher, Router
+
+bot = Bot(token="YOUR_BOT_TOKEN")
+dp = Dispatcher()
+router = Router()
+
+
+@router.message()
+async def on_message(message, bot):
+    await message.answer("Hello!")
+
+
+dp.include_router(router)
+
+
+async def main():
+    await dp.start_polling(bot)
+
+
+asyncio.run(main())
+```

pymaxgram-4.0.0/README.md

@@ -0,0 +1,35 @@
+# pymaxgram
+
+Async framework for MAX Messenger Bot API.
+
+## Installation
+
+```bash
+pip install pymaxgram
+```
+
+## Quick Start
+
+```python
+import asyncio
+from maxgram import Bot, Dispatcher, Router
+
+bot = Bot(token="YOUR_BOT_TOKEN")
+dp = Dispatcher()
+router = Router()
+
+
+@router.message()
+async def on_message(message, bot):
+    await message.answer("Hello!")
+
+
+dp.include_router(router)
+
+
+async def main():
+    await dp.start_polling(bot)
+
+
+asyncio.run(main())
+```

pymaxgram-4.0.0/maxgram/__init__.py

@@ -0,0 +1,30 @@
+from maxgram.dispatcher.flags import FlagGenerator
+
+from . import enums, methods, types
+from .__meta__ import __api_version__, __version__
+from .client.bot import Bot
+from .dispatcher.dispatcher import Dispatcher
+from .dispatcher.middlewares.base import BaseMiddleware
+from .dispatcher.router import Router
+from .utils.magic_filter import MagicFilter
+from .utils.text_decorations import html_decoration as html
+from .utils.text_decorations import markdown_decoration as md
+
+F = MagicFilter()
+flags = FlagGenerator()
+
+__all__ = (
+    "BaseMiddleware",
+    "Bot",
+    "Dispatcher",
+    "F",
+    "Router",
+    "__api_version__",
+    "__version__",
+    "enums",
+    "flags",
+    "html",
+    "md",
+    "methods",
+    "types",
+)

pymaxgram-4.0.0/maxgram/__meta__.py

@@ -0,0 +1,2 @@
+__version__ = "4.0.0"
+__api_version__ = "1.0"

pymaxgram-4.0.0/maxgram/client/__init__.py

@@ -0,0 +1,5 @@
+from .default import DefaultBotProperties
+
+__all__ = [
+    "DefaultBotProperties",
+]

pymaxgram-4.0.0/maxgram/client/bot.py

@@ -0,0 +1,362 @@
+from __future__ import annotations
+
+import io
+import pathlib
+from collections.abc import AsyncGenerator
+from contextlib import asynccontextmanager
+from types import TracebackType
+from typing import (
+    Any,
+    BinaryIO,
+    TypeVar,
+    cast,
+)
+
+from ..methods import (
+    AddMembers,
+    AnswerCallback,
+    AssignAdmins,
+    CreateSubscription,
+    DeleteChat,
+    DeleteMessage,
+    DeleteSubscription,
+    EditChat,
+    EditMessage,
+    GetAdmins,
+    GetChat,
+    GetChats,
+    GetMe,
+    GetMembers,
+    GetMessageById,
+    GetMessages,
+    GetMyMembership,
+    GetPinnedMessage,
+    GetSubscriptions,
+    GetUpdates,
+    GetUploadUrl,
+    GetVideoInfo,
+    LeaveChat,
+    MaxMethod,
+    PinMessage,
+    RemoveAdmin,
+    RemoveMember,
+    SendAction,
+    SendMessage,
+    UnpinMessage,
+)
+from ..methods.base import MaxType
+from ..types import (
+    BotInfo,
+    Chat,
+    ChatMember,
+    Message,
+    Subscription,
+    Update,
+    UploadInfo,
+    User,
+    VideoInfo,
+)
+from .context_controller import BotContextController
+from .default import DefaultBotProperties
+
+T = TypeVar("T")
+
+
+class Bot:
+    """MAX Bot API client."""
+
+    def __init__(
+        self,
+        token: str,
+        session: Any | None = None,
+        default: DefaultBotProperties | None = None,
+    ) -> None:
+        if not token:
+            raise ValueError("Token must not be empty")
+
+        self.__token = token
+        self.session = session or self._create_default_session()
+        self.default = default or DefaultBotProperties()
+        self._me: BotInfo | None = None
+
+    @staticmethod
+    def _create_default_session() -> Any:
+        from .session.aiohttp import AiohttpSession
+        return AiohttpSession()
+
+    @property
+    def token(self) -> str:
+        return self.__token
+
+    @property
+    def id(self) -> int | None:
+        """Bot ID. Available after calling get_me()."""
+        if self._me:
+            return self._me.user_id
+        return None
+
+    async def me(self) -> BotInfo:
+        """Get bot info (cached)."""
+        if self._me is None:
+            self._me = await self.get_me()
+        return self._me
+
+    async def __call__(
+        self,
+        method: MaxMethod[MaxType],
+        **kwargs: Any,
+    ) -> MaxType:
+        """Execute an API method."""
+        return await self.session(self, method, **kwargs)
+
+    def __hash__(self) -> int:
+        return hash(self.__token)
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, Bot):
+            return NotImplemented
+        return self.__token == other.__token
+
+    async def __aenter__(self) -> Bot:
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
+    ) -> None:
+        await self.session.close()
+
+    # ==================== Bot Info ====================
+
+    async def get_me(self) -> BotInfo:
+        return await self(GetMe())
+
+    # ==================== Chats ====================
+
+    async def get_chats(
+        self,
+        count: int | None = None,
+        marker: int | None = None,
+    ) -> list[Chat]:
+        return await self(GetChats(count=count, marker=marker))
+
+    async def get_chat(self, chat_id: int) -> Chat:
+        return await self(GetChat(chat_id=chat_id))
+
+    async def edit_chat(
+        self,
+        chat_id: int,
+        title: str | None = None,
+        icon: dict[str, Any] | None = None,
+        pin: str | None = None,
+        notify: bool | None = None,
+    ) -> Chat:
+        return await self(EditChat(
+            chat_id=chat_id, title=title, icon=icon, pin=pin, notify=notify,
+        ))
+
+    async def delete_chat(self, chat_id: int) -> bool:
+        return await self(DeleteChat(chat_id=chat_id))
+
+    # ==================== Chat Actions ====================
+
+    async def send_action(self, chat_id: int, action: str) -> bool:
+        return await self(SendAction(chat_id=chat_id, action=action))
+
+    # ==================== Pinned Messages ====================
+
+    async def get_pinned_message(self, chat_id: int) -> Message | None:
+        return await self(GetPinnedMessage(chat_id=chat_id))
+
+    async def pin_message(
+        self,
+        chat_id: int,
+        message_id: str,
+        notify: bool | None = None,
+    ) -> bool:
+        return await self(PinMessage(chat_id=chat_id, message_id=message_id, notify=notify))
+
+    async def unpin_message(self, chat_id: int) -> bool:
+        return await self(UnpinMessage(chat_id=chat_id))
+
+    # ==================== Members ====================
+
+    async def get_my_membership(self, chat_id: int) -> ChatMember:
+        return await self(GetMyMembership(chat_id=chat_id))
+
+    async def leave_chat(self, chat_id: int) -> bool:
+        return await self(LeaveChat(chat_id=chat_id))
+
+    async def get_admins(
+        self,
+        chat_id: int,
+        marker: int | None = None,
+    ) -> list[ChatMember]:
+        return await self(GetAdmins(chat_id=chat_id, marker=marker))
+
+    async def assign_admins(
+        self,
+        chat_id: int,
+        admins: list[dict[str, Any]],
+    ) -> bool:
+        return await self(AssignAdmins(chat_id=chat_id, admins=admins))
+
+    async def remove_admin(self, chat_id: int, user_id: int) -> bool:
+        return await self(RemoveAdmin(chat_id=chat_id, user_id=user_id))
+
+    async def get_members(
+        self,
+        chat_id: int,
+        user_ids: list[int] | None = None,
+        marker: int | None = None,
+        count: int | None = None,
+    ) -> list[ChatMember]:
+        return await self(GetMembers(
+            chat_id=chat_id, user_ids=user_ids, marker=marker, count=count,
+        ))
+
+    async def add_members(self, chat_id: int, user_ids: list[int]) -> bool:
+        return await self(AddMembers(chat_id=chat_id, user_ids=user_ids))
+
+    async def remove_member(
+        self,
+        chat_id: int,
+        user_id: int,
+        block: bool | None = None,
+    ) -> bool:
+        return await self(RemoveMember(chat_id=chat_id, user_id=user_id, block=block))
+
+    # ==================== Subscriptions (Webhooks) ====================
+
+    async def get_subscriptions(self) -> list[Subscription]:
+        return await self(GetSubscriptions())
+
+    async def create_subscription(
+        self,
+        url: str,
+        update_types: list[str] | None = None,
+        secret: str | None = None,
+    ) -> bool:
+        return await self(CreateSubscription(
+            url=url, update_types=update_types, secret=secret,
+        ))
+
+    async def delete_subscription(self, url: str) -> bool:
+        return await self(DeleteSubscription(url=url))
+
+    # ==================== Updates ====================
+
+    async def get_updates(
+        self,
+        limit: int | None = None,
+        timeout: int | None = None,
+        marker: int | None = None,
+        types: list[str] | None = None,
+    ) -> list[Update]:
+        return await self(GetUpdates(
+            limit=limit, timeout=timeout, marker=marker, types=types,
+        ))
+
+    # ==================== Messages ====================
+
+    async def send_message(
+        self,
+        chat_id: int | None = None,
+        user_id: int | None = None,
+        text: str | None = None,
+        attachments: list[Any] | None = None,
+        link: Any | None = None,
+        notify: bool | None = None,
+        format: str | None = None,
+        disable_link_preview: bool | None = None,
+    ) -> Message:
+        return await self(SendMessage(
+            chat_id=chat_id,
+            user_id=user_id,
+            text=text,
+            attachments=attachments,
+            link=link,
+            notify=notify,
+            format=format,
+            disable_link_preview=disable_link_preview,
+        ))
+
+    async def edit_message(
+        self,
+        message_id: str,
+        text: str | None = None,
+        attachments: list[Any] | None = None,
+        notify: bool | None = None,
+        format: str | None = None,
+    ) -> bool:
+        return await self(EditMessage(
+            message_id=message_id,
+            text=text,
+            attachments=attachments,
+            notify=notify,
+            format=format,
+        ))
+
+    async def delete_message(self, message_id: str) -> bool:
+        return await self(DeleteMessage(message_id=message_id))
+
+    async def get_messages(
+        self,
+        chat_id: int | None = None,
+        message_ids: list[str] | None = None,
+        count: int | None = None,
+    ) -> list[Message]:
+        return await self(GetMessages(
+            chat_id=chat_id, message_ids=message_ids, count=count,
+        ))
+
+    async def get_message_by_id(self, message_id: str) -> Message:
+        return await self(GetMessageById(message_id=message_id))
+
+    # ==================== Uploads ====================
+
+    async def get_upload_url(self, type: str) -> UploadInfo:
+        return await self(GetUploadUrl(type=type))
+
+    async def upload_file(
+        self,
+        file_type: str,
+        file_data: bytes,
+        filename: str = "file",
+    ) -> str:
+        """Two-stage file upload. Returns token for use in attachments."""
+        upload_info = await self.get_upload_url(type=file_type)
+        result = await self.session.upload_file(
+            bot=self,
+            upload_url=upload_info.url,
+            file_data=file_data,
+            filename=filename,
+        )
+        return result.get("token", upload_info.token or "")
+
+    # ==================== Video ====================
+
+    async def get_video_info(self, video_token: str) -> VideoInfo:
+        return await self(GetVideoInfo(video_token=video_token))
+
+    # ==================== Callbacks ====================
+
+    async def answer_callback(
+        self,
+        callback_id: str,
+        text: str | None = None,
+        attachments: list[Any] | None = None,
+        notification: str | None = None,
+        notify: bool | None = None,
+        format: str | None = None,
+    ) -> bool:
+        return await self(AnswerCallback(
+            callback_id=callback_id,
+            text=text,
+            attachments=attachments,
+            notification=notification,
+            notify=notify,
+            format=format,
+        ))

pymaxgram-4.0.0/maxgram/client/context_controller.py

@@ -0,0 +1,35 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from pydantic import BaseModel, PrivateAttr
+from typing_extensions import Self
+
+if TYPE_CHECKING:
+    from maxgram.client.bot import Bot
+
+
+class BotContextController(BaseModel):
+    _bot: Bot | None = PrivateAttr()
+
+    def model_post_init(self, __context: Any) -> None:  # noqa: PYI063
+        self._bot = __context.get("bot") if __context else None
+
+    def as_(self, bot: Bot | None) -> Self:
+        """
+        Bind object to a bot instance.
+
+        :param bot: Bot instance
+        :return: self
+        """
+        self._bot = bot
+        return self
+
+    @property
+    def bot(self) -> Bot | None:
+        """
+        Get bot instance.
+
+        :return: Bot instance
+        """
+        return self._bot

pymaxgram-4.0.0/maxgram/client/default.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+from maxgram.utils.dataclass import dataclass_kwargs
+
+
+@dataclass(**dataclass_kwargs(slots=True, kw_only=True))
+class DefaultBotProperties:
+    """Default bot properties for MAX API."""
+
+    parse_mode: str | None = None
+    """Default parse mode for messages (markdown or html)."""
+    disable_link_preview: bool | None = None
+    """Disable link preview in messages."""
+    notify: bool | None = None
+    """Default notification setting."""
+
+    def __getitem__(self, item: str) -> Any:
+        return getattr(self, item, None)

pymaxgram-4.0.0/maxgram/client/max_api.py

@@ -0,0 +1,22 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class MaxAPIServer:
+    """MAX API server configuration."""
+
+    base: str = "https://platform-api.max.ru"
+
+    def api_url(self, path: str) -> str:
+        """Build full API URL from path."""
+        return f"{self.base}{path}"
+
+    @classmethod
+    def from_base(cls, base: str) -> MaxAPIServer:
+        base = base.rstrip("/")
+        return cls(base=base)
+
+
+PRODUCTION = MaxAPIServer()