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

pymax/filters/filters.py

@@ -0,0 +1,211 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, TypeVar
+
+from .base import ClientT, Filter, PathResolver
+
+if TYPE_CHECKING:
+    pass
+
+EventT = TypeVar("EventT")
+
+
+class ContainsFilter(Filter[EventT, ClientT], PathResolver):
+    def __init__(
+        self,
+        path: list[str],
+        expected_type: type[EventT],
+        text: str,
+        ignore_case: bool,
+    ) -> None:
+        self.path = path
+        self.expected_type = expected_type
+        self.text = text
+        self.ignore_case = ignore_case
+
+    def __call__(self, event: EventT, _: ClientT) -> bool:
+        if not isinstance(event, self.expected_type):
+            return False
+
+        value = self.resolve_path(event)
+
+        if not isinstance(value, str):
+            return False
+
+        if self.ignore_case:
+            return self.text.casefold() in value.casefold()
+
+        return self.text in value
+
+
+class StartsWithFilter(Filter[EventT, ClientT], PathResolver):
+    def __init__(
+        self,
+        path: list[str],
+        expected_type: type[EventT],
+        text: str,
+        ignore_case: bool,
+    ) -> None:
+        self.path = path
+        self.expected_type = expected_type
+        self.text = text
+        self.ignore_case = ignore_case
+
+    def __call__(self, event: EventT, _: ClientT) -> bool:
+        if not isinstance(event, self.expected_type):
+            return False
+
+        value = self.resolve_path(event)
+
+        if not isinstance(value, str):
+            return False
+
+        if self.ignore_case:
+            return value.casefold().startswith(self.text.casefold())
+
+        return value.startswith(self.text)
+
+
+class EndsWithFilter(Filter[EventT, ClientT], PathResolver):
+    def __init__(
+        self,
+        path: list[str],
+        expected_type: type[EventT],
+        text: str,
+        ignore_case: bool,
+    ) -> None:
+        self.path = path
+        self.expected_type = expected_type
+        self.text = text
+        self.ignore_case = ignore_case
+
+    def __call__(self, event: EventT, _: ClientT) -> bool:
+        if not isinstance(event, self.expected_type):
+            return False
+
+        value = self.resolve_path(event)
+
+        if not isinstance(value, str):
+            return False
+
+        if self.ignore_case:
+            return value.casefold().endswith(self.text.casefold())
+
+        return value.endswith(self.text)
+
+
+class LessThanFilter(Filter[EventT, ClientT], PathResolver):
+    def __init__(
+        self,
+        path: list[str],
+        expected_type: type[EventT],
+        expected: float,
+    ) -> None:
+        self.path = path
+        self.expected_type = expected_type
+        self.expected = expected
+
+    def __call__(self, event: EventT, _: ClientT) -> bool:
+        if not isinstance(event, self.expected_type):
+            return False
+
+        value = self.resolve_path(event)
+
+        if not isinstance(value, int | float) or isinstance(value, bool):
+            return False
+
+        return value < self.expected
+
+
+class LessThanOrEqualFilter(Filter[EventT, ClientT], PathResolver):
+    def __init__(
+        self,
+        path: list[str],
+        expected_type: type[EventT],
+        expected: float,
+    ) -> None:
+        self.path = path
+        self.expected_type = expected_type
+        self.expected = expected
+
+    def __call__(self, event: EventT, _: ClientT) -> bool:
+        if not isinstance(event, self.expected_type):
+            return False
+
+        value = self.resolve_path(event)
+
+        if not isinstance(value, int | float) or isinstance(value, bool):
+            return False
+
+        return value <= self.expected
+
+
+class GreaterThanFilter(Filter[EventT, ClientT], PathResolver):
+    def __init__(
+        self,
+        path: list[str],
+        expected_type: type[EventT],
+        expected: float,
+    ) -> None:
+        self.path = path
+        self.expected_type = expected_type
+        self.expected = expected
+
+    def __call__(self, event: EventT, _: ClientT) -> bool:
+        if not isinstance(event, self.expected_type):
+            return False
+
+        value = self.resolve_path(event)
+
+        if not isinstance(value, int | float) or isinstance(value, bool):
+            return False
+
+        return value > self.expected
+
+
+class GreaterThanOrEqualFilter(Filter[EventT, ClientT], PathResolver):
+    def __init__(
+        self,
+        path: list[str],
+        expected_type: type[EventT],
+        expected: float,
+    ) -> None:
+        self.path = path
+        self.expected_type = expected_type
+        self.expected = expected
+
+    def __call__(self, event: EventT, _: ClientT) -> bool:
+        if not isinstance(event, self.expected_type):
+            return False
+
+        value = self.resolve_path(event)
+
+        if not isinstance(value, int | float) or isinstance(value, bool):
+            return False
+
+        return value >= self.expected
+
+
+class BetweenFilter(Filter[EventT, ClientT], PathResolver):
+    def __init__(
+        self,
+        path: list[str],
+        expected_type: type[EventT],
+        minimum: float,
+        maximum: float,
+    ) -> None:
+        self.path = path
+        self.expected_type = expected_type
+        self.minimum = minimum
+        self.maximum = maximum
+
+    def __call__(self, event: EventT, _: ClientT) -> bool:
+        if not isinstance(event, self.expected_type):
+            return False
+
+        value = self.resolve_path(event)
+
+        if not isinstance(value, int | float) or isinstance(value, bool):
+            return False
+
+        return self.minimum <= value <= self.maximum

pymax/filters/magic.py

@@ -0,0 +1,13 @@
+from pymax.types import Chat, Message
+
+from .containers import ChatContainer, MessageContainer
+
+
+class MagicFilter:
+    @property
+    def message(self) -> MessageContainer:
+        return MessageContainer(Message)
+
+    @property
+    def chat(self) -> ChatContainer:
+        return ChatContainer(Chat)

pymax/filters/presets.py

@@ -0,0 +1,88 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from pymax.types import LinkType, Message
+
+from .base import Filter
+
+if TYPE_CHECKING:
+    from pymax.base import BaseClient
+    from pymax.types.domain.message import Attachment
+
+
+class Command(Filter[Message, "BaseClient"]):
+    """Проверяет команду в первом слове текста сообщения.
+
+    Args:
+        command: Имя команды, например ``"start"`` для ``/start``.
+        prefix: Префикс команды или кортеж допустимых префиксов.
+
+    Аргументы после команды не влияют на совпадение.
+    """
+
+    def __init__(self, command: str, prefix: str | tuple[str, ...] = "/") -> None:
+        self.prefixes = (prefix,) if isinstance(prefix, str) else prefix
+
+        for prefix_ in self.prefixes:
+            self.command = command.removeprefix(prefix_)
+
+    def __call__(self, message: Message, _: BaseClient) -> bool:
+        if not message.text:
+            return False
+
+        parts = message.text.split(maxsplit=1)
+        if not parts:
+            return False
+
+        dirty_command = parts[0]
+
+        for prefix in self.prefixes:
+            if message.text.startswith(prefix) and dirty_command[len(prefix) :] == self.command:
+                return True
+
+        return False
+
+
+class Reply(Filter[Message, "BaseClient"]):
+    """Проверяет, является ли сообщение ответом на другое сообщение."""
+
+    def __call__(self, message: Message, _: BaseClient) -> bool:
+        if not message.link:
+            return False
+
+        return message.link.type == LinkType.REPLY
+
+
+class Forwarded(Filter[Message, "BaseClient"]):
+    """Проверяет, является ли сообщение пересланным."""
+
+    def __call__(self, message: Message, _: BaseClient) -> bool:
+        if not message.link:
+            return False
+
+        return message.link.type == LinkType.FORWARD
+
+
+class FromMe(Filter[Message, "BaseClient"]):
+    """Проверяет, отправлено ли сообщение текущим пользователем клиента."""
+
+    def __call__(self, message: Message, client: BaseClient) -> bool:
+        if not message.sender or not client.me:
+            return False
+
+        return message.sender == client.me.contact.id
+
+
+class HasAttachment(Filter[Message, "BaseClient"]):
+    """Проверяет наличие хотя бы одного вложения указанных типов.
+
+    Передавайте классы входящих вложений из ``pymax.types``, например
+    ``PhotoAttachment``, а не классы файлов для отправки.
+    """
+
+    def __init__(self, *attachment_types: type[Attachment]) -> None:
+        self.expected_types = attachment_types
+
+    def __call__(self, message: Message, _: BaseClient) -> bool:
+        return any(isinstance(attach, self.expected_types) for attach in message.attaches)

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/fingerprint/fingerprint.py

@@ -1,47 +1,30 @@
 import hashlib
-import json
 import struct
-from importlib import resources
-from typing import Any
 
 from .models import ApkBuildFingerprint
 
 
 class FingerprintGenerator:
-    def __init__(
-        self,
-    ) -> None:
-        self.path = resources.files("pymax._data") / "apk_fingerprints.json"
-        self.data = self.load_fingerprints()
-
-    def load_fingerprints(self) -> Any:
-        with self.path.open("r", encoding="utf-8") as f:
-            return json.load(f)
+    def __init__(self, version_data: ApkBuildFingerprint) -> None:
+        self.data = version_data
 
     def generate_fingerprint(
         self,
-        version: str,
         device_id: str,
         calls_seed: int,
         arch: str = "arm64-v8a",
     ) -> bytes | None:
-        data = self.data.get(version)
-        if not data:
-            return None
-
-        model = ApkBuildFingerprint.model_validate(data)
-
         seed_bytes = struct.pack(">q", calls_seed)
         device_bytes = device_id.encode("utf-8")
 
         h1 = hashlib.sha256(
-            bytes.fromhex(model.certificate_meta_sha256) + seed_bytes + device_bytes
+            bytes.fromhex(self.data.certificate_meta_sha256) + seed_bytes + device_bytes
         ).digest()
         h2 = hashlib.sha256(
-            bytes.fromhex(model.dex_meta_sha256) + seed_bytes + device_bytes
+            bytes.fromhex(self.data.dex_meta_sha256) + seed_bytes + device_bytes
         ).digest()
         h3 = hashlib.sha256(
-            bytes.fromhex(model.so_meta_sha256[arch]) + seed_bytes + device_bytes
+            bytes.fromhex(self.data.so_meta_sha256[arch]) + seed_bytes + device_bytes
         ).digest()
 
         return h1 + h2 + h3

pymax/fingerprint/models.py

@@ -7,5 +7,6 @@ class ApkBuildFingerprint(BaseModel):
     certificate_meta_sha256: str
     certificate_sha256: list[str]
     dex_meta_sha256: str
+    so_meta_sha256_arm64_v8a: str
     so_meta_sha256: dict[str, str]
     build_number: int

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