maxapi-python 2.4.1__py3-none-any.whl → 2.5.0__py3-none-any.whl

pymax/filters/refs.py

@@ -0,0 +1,56 @@
+from __future__ import annotations
+
+from typing import TypeVar
+
+from .base import MISSING, ClientT, FieldRef
+from .filters import (
+    BetweenFilter,
+    ContainsFilter,
+    EndsWithFilter,
+    GreaterThanFilter,
+    GreaterThanOrEqualFilter,
+    LessThanFilter,
+    LessThanOrEqualFilter,
+    StartsWithFilter,
+)
+
+EventT = TypeVar("EventT")
+
+
+class TextFieldRef(FieldRef[EventT, ClientT]):
+    def contains(self, text: str, *, ignore_case: bool = False) -> ContainsFilter:
+        return ContainsFilter(self.path, self.expected_type, text, ignore_case)
+
+    def startswith(self, text: str, *, ignore_case: bool = False) -> StartsWithFilter:
+        return StartsWithFilter(self.path, self.expected_type, text, ignore_case)
+
+    def endswith(self, text: str, *, ignore_case: bool = False) -> EndsWithFilter:
+        return EndsWithFilter(self.path, self.expected_type, text, ignore_case)
+
+    def __call__(self, event: EventT, _: ClientT) -> bool:
+        if not isinstance(event, self.expected_type):
+            return False
+
+        value = self.resolve_path(event)
+
+        if value is MISSING:
+            return False
+
+        return bool(value)
+
+
+class NumberFieldRef(FieldRef[EventT, ClientT]):
+    def __lt__(self, value: float) -> LessThanFilter:
+        return LessThanFilter(self.path, self.expected_type, value)
+
+    def __le__(self, value: float) -> LessThanOrEqualFilter:
+        return LessThanOrEqualFilter(self.path, self.expected_type, value)
+
+    def __gt__(self, value: float) -> GreaterThanFilter:
+        return GreaterThanFilter(self.path, self.expected_type, value)
+
+    def __ge__(self, value: float) -> GreaterThanOrEqualFilter:
+        return GreaterThanOrEqualFilter(self.path, self.expected_type, value)
+
+    def between(self, minimum: float, maximum: float) -> BetweenFilter:
+        return BetweenFilter(self.path, self.expected_type, minimum, maximum)

pymax/formatting/markdown.py

@@ -51,6 +51,29 @@ class Formatter:
 
         return label, url, url_end + 1
 
+    @staticmethod
+    def _is_intraword_single_marker(text: str, i: int, marker: str) -> bool:
+        if marker != "_":
+            return False
+        if i == 0 or i + 1 >= len(text):
+            return False
+        return text[i - 1].isalnum() and text[i + 1].isalnum()
+
+    @staticmethod
+    def _find_closing_marker(
+        text: str,
+        marker: str,
+        start: int,
+        end: int | None = None,
+    ) -> int:
+        while True:
+            closing_index = text.find(marker, start, len(text) if end is None else end)
+            if closing_index == -1:
+                return -1
+            if not Formatter._is_intraword_single_marker(text, closing_index, marker):
+                return closing_index
+            start = closing_index + len(marker)
+
     @staticmethod
     def format_markdown(text: str) -> tuple[str, list[Element]]:
         clean_text = ""
@@ -65,6 +88,34 @@ class Formatter:
         while i < len(text):
             handled = False
 
+            for marker in ("```", "`"):
+                if marker not in active:
+                    continue
+
+                closing_index = text.find(marker, i)
+                content = text[i:closing_index]
+                clean_text += content
+                clean_pos += Formatter._code_units_len(content)
+
+                start = active.pop(marker)
+                length = clean_pos - start
+                if length > 0:
+                    entities.append(
+                        Element(
+                            type=Formatter.MARKERS[marker],
+                            from_=start,
+                            length=length,
+                        )
+                    )
+
+                i = closing_index + len(marker)
+                handled = True
+                break
+
+            if handled:
+                line_start = False
+                continue
+
             # LINK: [text](url)
             parsed_link = Formatter._parse_link(text, i, clean_pos)
 
@@ -155,6 +206,8 @@ class Formatter:
             for marker in Formatter.MARKER_ORDER:
                 if not text.startswith(marker, i):
                     continue
+                if Formatter._is_intraword_single_marker(text, i, marker):
+                    continue
 
                 marker_len = len(marker)
 
@@ -180,7 +233,8 @@ class Formatter:
                         break
 
                     end = text.find("\n", i + marker_len)
-                    closing_index = text.find(
+                    closing_index = Formatter._find_closing_marker(
+                        text,
                         marker,
                         i + marker_len,
                         None if end == -1 else end,

pymax/fsm/__init__.py

@@ -0,0 +1,3 @@
+from .context import FSMContext
+from .state import FsmGroup, State
+from .storage import InMemoryFSM, InMemoryFSMStorage

pymax/fsm/context.py

@@ -0,0 +1,30 @@
+from dataclasses import dataclass
+
+from .protocol import FSMStorage
+
+
+@dataclass(frozen=True, slots=True)
+class FSMKey:
+    client_id: int
+    user_id: int
+    chat_id: int
+
+
+class FSMContext:
+    """Контекст состояния пользователя в текущем чате.
+
+    PyMax передает его в обязательный параметр обработчика сообщения
+    с аннотацией ``FSMContext``. Состояние и данные доступны через ``storage``.
+
+    Attributes:
+        storage: Хранилище состояния и данных текущего контекста.
+        key: Ключ контекста для текущих клиента, пользователя и чата.
+    """
+
+    def __init__(
+        self,
+        storage: FSMStorage,
+        key: FSMKey,
+    ) -> None:
+        self.storage = storage
+        self.key = key

pymax/fsm/protocol.py

@@ -0,0 +1,14 @@
+from typing import Any, Protocol
+
+from .state import State
+
+
+class FSMStorage(Protocol):
+    async def get_state(self) -> str | None: ...
+    async def set_state(self, state: str | State | None, ttl: int | None = None) -> None: ...
+
+    async def get_data(self) -> dict[str, Any]: ...
+    async def set_data(self, key: str, value: Any) -> None: ...
+    async def update_data(self, **data: Any) -> None: ...
+
+    async def clear(self) -> None: ...

pymax/fsm/state.py

@@ -0,0 +1,70 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from pymax.base import BaseClient
+
+from pymax.filters import Filter
+from pymax.types import Message
+
+
+class State(Filter[Message, "BaseClient"]):
+    """Состояние FSM и фильтр сообщений по этому состоянию.
+
+    Объявляйте экземпляры атрибутами ``FsmGroup``. Один и тот же экземпляр
+    можно передать в ``ctx.storage.set_state()`` и ``router.on_message()``.
+    """
+
+    owner: type
+    name: str
+
+    def __set_name__(self, owner: type, name: str) -> None:
+        self.owner = owner
+        self.name = name
+
+    @property
+    def full_name(self) -> str:
+        """Возвращает полное имя состояния из имени модуля, группы и атрибута."""
+        return f"{self.owner.__module__}.{self.owner.__qualname__}:{self.name}"
+
+    def __str__(self) -> str:
+        return self.full_name
+
+    async def __call__(
+        self,
+        event: Message,
+        client: BaseClient,
+    ) -> bool:
+        if event.chat_id is None or event.sender is None:
+            return False
+
+        fsm_key = client._app.fsm_storage.resolve_key(client, event)
+
+        if not fsm_key:
+            return False
+
+        record = client._app.fsm_storage.records.get(fsm_key)
+
+        if record is None:
+            return False
+
+        return await record.get_state() == self.full_name
+
+
+class FsmGroup:
+    """Группа состояний, объявленных атрибутами класса через ``State()``."""
+
+    __states__: dict[str, State] = {}
+
+    def __init_subclass__(cls) -> None:
+        super().__init_subclass__()
+
+        inherited: dict[str, State] = {}
+
+        for base in cls.__bases__:
+            inherited.update(getattr(base, "__states__", {}))
+
+        own = {name: value for name, value in vars(cls).items() if isinstance(value, State)}
+
+        cls.__states__ = inherited | own

pymax/fsm/storage.py

@@ -0,0 +1,151 @@
+from __future__ import annotations
+
+import asyncio
+from contextlib import asynccontextmanager
+from dataclasses import dataclass
+from datetime import datetime
+from typing import TYPE_CHECKING, Any, AsyncGenerator
+
+from pymax.fsm.context import FSMContext, FSMKey
+from pymax.types.domain.message import Message
+
+from .protocol import FSMStorage
+from .state import State
+
+if TYPE_CHECKING:
+    from pymax.base import BaseClient
+    from pymax.dispatch import DispatchEvent
+
+
+class InMemoryFSMStorage:
+    def __init__(self) -> None:
+        self.records: dict[FSMKey, InMemoryFSM] = {}
+        self.locks: dict[FSMKey, asyncio.Lock] = {}
+
+    def resolve_key(
+        self,
+        client: BaseClient,
+        event: DispatchEvent,
+    ) -> FSMKey | None:
+        if not isinstance(event, Message):
+            return None
+
+        if event.chat_id is None or event.sender is None:
+            return None
+
+        return FSMKey(
+            client_id=hash(client),
+            user_id=event.sender,
+            chat_id=event.chat_id,
+        )
+
+    def get_context(
+        self,
+        client: BaseClient,
+        event: Message,
+    ) -> FSMContext | None:
+        if not event.chat_id or not event.sender:
+            return None
+
+        key = self.resolve_key(client, event)
+
+        if not key:
+            return None
+
+        record = self.records.get(key)
+        if record is None:
+            record = InMemoryFSM()
+            self.records[key] = record
+
+        return FSMContext(storage=record, key=key)
+
+    @asynccontextmanager
+    async def isolate(
+        self,
+        client: BaseClient,
+        event: DispatchEvent,
+    ) -> AsyncGenerator[None]:
+        key = self.resolve_key(client, event)
+
+        if key is None:
+            yield
+            return
+
+        lock = self.locks.setdefault(key, asyncio.Lock())
+
+        async with lock:
+            yield
+
+
+@dataclass
+class FsmState:
+    value: str | None = None
+    created_at: datetime = datetime.now()
+    ttl: int | None = None
+
+
+class InMemoryFSM(FSMStorage):
+    """Состояние и данные одного FSM-контекста в памяти процесса.
+
+    В обработчике это хранилище доступно как ``ctx.storage``.
+    """
+
+    def __init__(self) -> None:
+        self.state: FsmState = FsmState()
+        self.data: dict[str, Any] = {}
+        self.lock = asyncio.Lock()
+
+    async def get_state(self) -> str | None:
+        """Возвращает имя состояния или ``None``, если оно не задано или истек TTL.
+
+        Истечение TTL сбрасывает только состояние, сохраняя данные контекста.
+        """
+        async with self.lock:
+            if self.state.ttl is None:
+                return self.state.value
+
+            expires_at = self.state.created_at.timestamp() + self.state.ttl
+
+            if datetime.now().timestamp() >= expires_at:
+                self.state = FsmState()
+                return None
+
+            return self.state.value
+
+    async def set_state(self, state: str | State | None, ttl: int | None = None) -> None:
+        """Устанавливает состояние, сохраняя данные контекста.
+
+        Args:
+            state: Состояние, его строковое имя или ``None`` для сброса.
+            ttl: Срок действия в секундах с момента установки.
+                ``None`` означает отсутствие срока действия.
+        """
+        async with self.lock:
+            if state is None:
+                self.state = FsmState()
+                return
+
+            self.state.value = str(state)
+            self.state.ttl = ttl
+            self.state.created_at = datetime.now()
+
+    async def get_data(self) -> dict[str, Any]:
+        """Возвращает поверхностную копию словаря данных контекста."""
+        async with self.lock:
+            return self.data.copy()
+
+    async def set_data(self, key: str, value: Any) -> None:
+        """Записывает одно значение, сохраняя остальные ключи данных."""
+        async with self.lock:
+            self.data[key] = value
+
+    async def update_data(self, **data: Any) -> None:
+        """Добавляет или перезаписывает переданные ключи данных."""
+        async with self.lock:
+            self.data.update(data)
+
+    async def clear(self) -> None:
+        """Сбрасывает состояние и удаляет все данные текущего контекста."""
+        async with self.lock:
+            self.state = FsmState()
+            self.data.clear()

pymax/infra/base.py

@@ -3,6 +3,7 @@ from .bots import BotsMixin
 from .chat import ChatMixin
 from .message import MessageMixin
 from .self import SelfMixin
+from .stories import StoriesMixin
 from .user import UserMixin
 
 
@@ -13,5 +14,6 @@ class BaseMixin(
     MessageMixin,
     BotsMixin,
     AuthMixin,
+    StoriesMixin,
 ):
     """Собирает публичные API-методы клиента."""

pymax/infra/bots.py

@@ -1,3 +1,4 @@
+from pymax.types import ButtonType, CallbackResponse
 from pymax.types.domain import InitData
 
 from .protocol import IClientProtocol
@@ -31,3 +32,22 @@ class BotsMixin(IClientProtocol):
             chat_id=chat_id,
             start_param=start_param,
         )
+
+    async def send_callback(
+        self,
+        callback_id: str,
+        type: ButtonType,
+        payload: str | None = None,
+    ) -> CallbackResponse:
+        """Передает нажатие inline-кнопки бота.
+
+        Args:
+            callback_id: ID из ``InlineKeyboardAttachment.callback_id``.
+            type: Тип нажатой кнопки.
+            payload: Данные кнопки, если они есть.
+
+        Returns:
+            Результат нажатия. ``message`` и ``chat`` содержатся в нем,
+            только если Max вернул эти объекты.
+        """
+        return await self._app.api.bots.send_callback(callback_id, type, payload)

pymax/infra/chat.py

@@ -414,3 +414,31 @@ class ChatMixin(IClientProtocol):
             permissions: Непустой список прав администратора.
         """
         return await self._app.api.chats.add_admin(chat_id, user_id, permissions)
+
+    async def set_channel_comments(self, chat_id: int, enabled: bool) -> None:
+        """Включает или выключает комментарии канала."""
+        return await self._app.api.chats.set_channel_comments(
+            chat_id=chat_id,
+            enabled=enabled,
+        )
+
+    async def block_comment_author(
+        self,
+        chat_id: int,
+        post_id: int,
+        user_ids: list[int],
+        message_id: int,
+        clean_msg_period: int = 0,
+    ) -> bool:
+        """Блокирует авторов в комментариях.
+
+        ``message_id`` — ID комментария для модерации.
+        ``clean_msg_period=0`` сохраняет комментарии, ``-1`` также удаляет их.
+        """
+        return await self._app.api.chats.block_comment_author(
+            chat_id=chat_id,
+            post_id=post_id,
+            user_ids=user_ids,
+            message_id=message_id,
+            clean_msg_period=clean_msg_period,
+        )