maxapi-python 1.1.20__py3-none-any.whl → 1.2.1__py3-none-any.whl

pymax/filters.py

@@ -1,47 +1,164 @@
-from .static.enum import MessageStatus, MessageType
-from .types import Message
-
-
-class Filter:
-    def __init__(
-        self,
-        chat_id: int | None = None,
-        user_id: int | None = None,
-        text: list[str] | None = None,
-        status: MessageStatus | str | None = None,
-        type: MessageType | str | None = None,
-        text_contains: str | None = None,
-        reaction_info: bool | None = None,
-    ) -> None:
+from __future__ import annotations
+
+import re
+from abc import ABC, abstractmethod
+from typing import Generic, TypeVar
+
+from pymax.static.enum import AttachType, ChatType, MessageStatus
+from pymax.types import Message
+
+T_co = TypeVar("T_co")
+
+
+class BaseFilter(ABC, Generic[T_co]):
+    event_type: type[T_co]
+
+    @abstractmethod
+    def __call__(self, event: T_co) -> bool: ...
+
+    def __and__(self, other: BaseFilter[T_co]) -> BaseFilter[T_co]:
+        return AndFilter(self, other)
+
+    def __or__(self, other: BaseFilter[T_co]) -> BaseFilter[T_co]:
+        return OrFilter(self, other)
+
+    def __invert__(self) -> BaseFilter[T_co]:
+        return NotFilter(self)
+
+
+class AndFilter(BaseFilter[T_co]):
+    def __init__(self, *filters: BaseFilter[T_co]) -> None:
+        self.filters = filters
+        self.event_type = filters[0].event_type
+
+    def __call__(self, event: T_co) -> bool:
+        return all(f(event) for f in self.filters)
+
+
+class OrFilter(BaseFilter[T_co]):
+    def __init__(self, *filters: BaseFilter[T_co]) -> None:
+        self.filters = filters
+        self.event_type = filters[0].event_type
+
+    def __call__(self, event: T_co) -> bool:
+        return any(f(event) for f in self.filters)
+
+
+class NotFilter(BaseFilter[T_co]):
+    def __init__(self, base_filter: BaseFilter[T_co]) -> None:
+        self.base_filter = base_filter
+        self.event_type = base_filter.event_type
+
+    def __call__(self, event: T_co) -> bool:
+        return not self.base_filter(event)
+
+
+class ChatFilter(BaseFilter[Message]):
+    event_type = Message
+
+    def __init__(self, chat_id: int) -> None:
         self.chat_id = chat_id
-        self.user_id = user_id
+
+    def __call__(self, message: Message) -> bool:
+        return message.chat_id == self.chat_id
+
+
+class TextFilter(BaseFilter[Message]):
+    event_type = Message
+
+    def __init__(self, text: str) -> None:
         self.text = text
+
+    def __call__(self, message: Message) -> bool:
+        return self.text in message.text
+
+
+class SenderFilter(BaseFilter[Message]):
+    event_type = Message
+
+    def __init__(self, user_id: int) -> None:
+        self.user_id = user_id
+
+    def __call__(self, message: Message) -> bool:
+        return message.sender == self.user_id
+
+
+class StatusFilter(BaseFilter[Message]):
+    event_type = Message
+
+    def __init__(self, status: MessageStatus) -> None:
         self.status = status
-        self.type = type
-        self.reaction_info = reaction_info
-        self.text_contains = text_contains
 
-    def match(self, message: Message) -> bool:
-        if self.chat_id is not None and message.chat_id != self.chat_id:
-            return False
-        if self.user_id is not None and message.sender != self.user_id:
-            return False
-        if self.text is not None and any(
-            text not in message.text for text in self.text
-        ):
-            return False
-        if (
-            self.text_contains is not None
-            and self.text_contains not in message.text
-        ):
-            return False
-        if self.status is not None and message.status != self.status:
-            return False
-        if self.type is not None and message.type != self.type:
-            return False
-        if (
-            self.reaction_info is not None and message.reactionInfo is None
-        ):  # noqa: SIM103
+    def __call__(self, message: Message) -> bool:
+        return message.status == self.status
+
+
+class TextContainsFilter(BaseFilter[Message]):
+    event_type = Message
+
+    def __init__(self, substring: str) -> None:
+        self.substring = substring
+
+    def __call__(self, message: Message) -> bool:
+        return self.substring in message.text
+
+
+class RegexTextFilter(BaseFilter[Message]):
+    event_type = Message
+
+    def __init__(self, pattern: str) -> None:
+        self.pattern = pattern
+        self.regex = re.compile(pattern)
+
+    def __call__(self, message: Message) -> bool:
+        return bool(self.regex.search(message.text))
+
+
+class MediaFilter(BaseFilter[Message]):
+    event_type = Message
+
+    def __call__(self, message: Message) -> bool:
+        return message.attaches is not None and len(message.attaches) > 0
+
+
+class FileFilter(BaseFilter[Message]):
+    event_type = Message
+
+    def __call__(self, message: Message) -> bool:
+        if message.attaches is None:
             return False
+        return any(attach.type == AttachType.FILE for attach in message.attaches)
+
+
+class Filters:
+    @staticmethod
+    def chat(chat_id: int) -> BaseFilter[Message]:
+        return ChatFilter(chat_id)
+
+    @staticmethod
+    def text(text: str) -> BaseFilter[Message]:
+        return TextFilter(text)
+
+    @staticmethod
+    def sender(user_id: int) -> BaseFilter[Message]:
+        return SenderFilter(user_id)
+
+    @staticmethod
+    def status(status: MessageStatus) -> BaseFilter[Message]:
+        return StatusFilter(status)
+
+    @staticmethod
+    def text_contains(substring: str) -> BaseFilter[Message]:
+        return TextContainsFilter(substring)
+
+    @staticmethod
+    def text_matches(pattern: str) -> BaseFilter[Message]:
+        return RegexTextFilter(pattern)
+
+    @staticmethod
+    def has_media() -> BaseFilter[Message]:
+        return MediaFilter()
 
-        return True
+    @staticmethod
+    def has_file() -> BaseFilter[Message]:
+        return FileFilter()

pymax/formatter.py

@@ -27,4 +27,5 @@ class ColoredFormatter(logging.Formatter):
             f"{name_color}{record.name}{self.RESET}: "
             f"{message_color}{record.getMessage()}{self.RESET}"
         )
+
         return log

pymax/formatting.py

@@ -46,14 +46,12 @@ class Formatting:
 
             if inner_text is not None and fmt_type is not None:
                 next_pos = match.end()
-                has_newline = (
-                    next_pos < len(text) and text[next_pos] == "\n"
-                ) or (next_pos == len(text))
+                has_newline = (next_pos < len(text) and text[next_pos] == "\n") or (
+                    next_pos == len(text)
+                )
 
                 length = len(inner_text) + (1 if has_newline else 0)
-                elements.append(
-                    Element(type=fmt_type, from_=current_pos, length=length)
-                )
+                elements.append(Element(type=fmt_type, from_=current_pos, length=length))
 
                 clean_parts.append(inner_text)
                 if has_newline:

pymax/interfaces.py

@@ -1,11 +1,19 @@
 import asyncio
+import contextlib
+import logging
 import socket
 import ssl
+import traceback
 from abc import ABC, abstractmethod
 from collections.abc import Awaitable, Callable
 from logging import Logger
 from typing import TYPE_CHECKING, Any, Literal
 
+from typing_extensions import Self
+
+from pymax.exceptions import WebSocketNotConnectedError
+from pymax.formatter import ColoredFormatter
+
 from .payloads import UserAgentPayload
 from .static.constant import DEFAULT_TIMEOUT
 from .static.enum import Opcode
@@ -21,7 +29,7 @@ if TYPE_CHECKING:
     from pymax.types import ReactionInfo
 
     from .crud import Database
-    from .filters import Filter
+    from .filters import BaseFilter
 
 
 class ClientProtocol(ABC):
@@ -67,18 +75,18 @@ class ClientProtocol(ABC):
         self._action_id: int = 0
         self._current_screen: str = "chats_list_tab"
         self._on_message_handlers: list[
-            tuple[Callable[[Message], Any], Filter | None]
+            tuple[Callable[[Message], Any], BaseFilter[Message] | None]
         ] = []
         self._on_message_edit_handlers: list[
-            tuple[Callable[[Message], Any], Filter | None]
+            tuple[Callable[[Message], Any], BaseFilter[Message] | None]
         ] = []
         self._on_message_delete_handlers: list[
-            tuple[Callable[[Message], Any], Filter | None]
-        ] = []
-        self._on_reaction_change_handlers: list[
-            tuple[Callable[[str, int, ReactionInfo], Any]]
+            tuple[Callable[[Message], Any], BaseFilter[Message] | None]
         ] = []
-        self._on_chat_update_handlers: list[tuple[Callable[[Chat], Any]]] = []
+        self._on_reaction_change_handlers: list[Callable[[str, int, ReactionInfo], Any]] = []
+        self._on_chat_update_handlers: list[Callable[[Chat], Any | Awaitable[Any]]] = []
+        self._on_raw_receive_handlers: list[Callable[[dict[str, Any]], Any | Awaitable[Any]]] = []
+        self._scheduled_tasks: list[tuple[Callable[[], Any | Awaitable[Any]], float]] = []
         self._on_start_handler: Callable[[], Any | Awaitable[Any]] | None = None
         self._background_tasks: set[asyncio.Task[Any]] = set()
         self._ssl_context: ssl.SSLContext
@@ -114,3 +122,135 @@ class ClientProtocol(ABC):
         self, coro: Awaitable[Any], name: str | None = None
     ) -> asyncio.Task[Any]:
         pass
+
+
+class BaseClient(ClientProtocol):
+    def _setup_logger(self) -> None:
+        if not self.logger.handlers:
+            if not self.logger.level:
+                self.logger.setLevel(logging.INFO)
+            handler = logging.StreamHandler()
+            formatter = ColoredFormatter(
+                "%(asctime)s [%(levelname)s] %(name)s: %(message)s",
+                datefmt="%Y-%m-%d %H:%M:%S",
+            )
+            handler.setFormatter(formatter)
+            self.logger.addHandler(handler)
+
+    async def _safe_execute(self, coro, *, context: str = "unknown") -> Any:
+        try:
+            return await coro
+        except Exception as e:
+            self.logger.error(f"Unhandled exception in {context}: {e}\n{traceback.format_exc()}")
+
+    def _create_safe_task(
+        self, coro: Awaitable[Any], name: str | None = None
+    ) -> asyncio.Task[Any | None]:
+        async def runner():
+            try:
+                return await coro
+            except asyncio.CancelledError:
+                raise
+            except Exception as e:
+                tb = traceback.format_exc()
+                self.logger.error(f"Unhandled exception in task {name or coro}: {e}\n{tb}")
+                raise
+
+        task = asyncio.create_task(runner(), name=name)
+        self._background_tasks.add(task)
+        return task
+
+    async def _cleanup_client(self) -> None:
+        for task in list(self._background_tasks):
+            task.cancel()
+            try:
+                await task
+            except asyncio.CancelledError:
+                pass
+            except Exception:
+                self.logger.debug("Background task raised during cancellation", exc_info=True)
+            self._background_tasks.discard(task)
+
+        if self._recv_task:
+            self._recv_task.cancel()
+            with contextlib.suppress(asyncio.CancelledError):
+                await self._recv_task
+            self._recv_task = None
+
+        if self._outgoing_task:
+            self._outgoing_task.cancel()
+            with contextlib.suppress(asyncio.CancelledError):
+                await self._outgoing_task
+            self._outgoing_task = None
+
+        for fut in self._pending.values():
+            if not fut.done():
+                fut.set_exception(WebSocketNotConnectedError())
+        self._pending.clear()
+
+        if self._ws:
+            try:
+                await self._ws.close()
+            except Exception:
+                self.logger.debug("Error closing ws during cleanup", exc_info=True)
+            self._ws = None
+
+        self.is_connected = False
+        self.logger.info("Client start() cleaned up")
+
+    async def idle(self):
+        """
+        Поддерживает клиента в «ожидающем» состоянии до закрытия клиента или иного прерывающего события.
+
+        :return: Никогда не возвращает значение; функция блокирует выполнение.
+        :rtype: None
+        """
+        await asyncio.Event().wait()
+
+    def inspect(self) -> None:
+        """
+        Выводит в лог текущий статус клиента для отладки.
+        """
+        self.logger.info("Pymax")
+        self.logger.info("---------")
+        self.logger.info(f"Connected: {self.is_connected}")
+        if self.me is not None:
+            self.logger.info(f"Me: {self.me.names[0].first_name} ({self.me.id})")
+        else:
+            self.logger.info("Me: N/A")
+        self.logger.info(f"Dialogs: {len(self.dialogs)}")
+        self.logger.info(f"Chats: {len(self.chats)}")
+        self.logger.info(f"Channels: {len(self.channels)}")
+        self.logger.info(f"Users cached: {len(self._users)}")
+        self.logger.info(f"Background tasks: {len(self._background_tasks)}")
+        self.logger.info(f"Scheduled tasks: {len(self._scheduled_tasks)}")
+        self.logger.info("---------")
+
+    async def __aenter__(self) -> Self:
+        self._create_safe_task(self.start(), name="start")
+        while not self.is_connected:
+            await asyncio.sleep(0.05)
+        return self
+
+    async def __aexit__(self, exc_type, exc, tb) -> None:
+        await self.close()
+
+    @abstractmethod
+    async def login_with_code(self, temp_token: str, code: str, start: bool = False) -> None:
+        pass
+
+    @abstractmethod
+    async def _post_login_tasks(self, sync: bool = True) -> None:
+        pass
+
+    @abstractmethod
+    async def _wait_forever(self) -> None:
+        pass
+
+    @abstractmethod
+    async def start(self) -> None:
+        pass
+
+    @abstractmethod
+    async def close(self) -> None:
+        pass

pymax/mixins/__init__.py

@@ -3,6 +3,7 @@ from .channel import ChannelMixin
 from .group import GroupMixin
 from .handler import HandlerMixin
 from .message import MessageMixin
+from .scheduler import SchedulerMixin
 from .self import SelfMixin
 from .socket import SocketMixin
 from .telemetry import TelemetryMixin
@@ -19,6 +20,7 @@ class ApiMixin(
     MessageMixin,
     TelemetryMixin,
     GroupMixin,
+    SchedulerMixin,
 ):
     pass
 
@@ -29,6 +31,7 @@ __all__ = [
     "ChannelMixin",
     "HandlerMixin",
     "MessageMixin",
+    "SchedulerMixin",
     "SelfMixin",
     "SocketMixin",
     "TelemetryMixin",