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

{maxapi_python-1.1.20.dist-info → maxapi_python-1.1.21.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: maxapi-python
-Version: 1.1.20
+Version: 1.1.21
 Summary: Python wrapper для API мессенджера Max
 Project-URL: Homepage, https://github.com/ink-developer/PyMax
 Project-URL: Repository, https://github.com/ink-developer/PyMax
@@ -79,65 +79,47 @@ uv add -U maxapi-python
 
 ```python
 import asyncio
+
 from pymax import MaxClient, Message
+from pymax.filters import Filters
+
+client = MaxClient(
+    phone="+1234567890",
+    work_dir="cache",  # директория для сессий
+)
+
+
+# Обработка входящих сообщений
+@client.on_message(Filters.chat(0))  # фильтр по ID чата
+async def on_message(msg: Message) -> None:
+    print(f"[{msg.sender}] {msg.text}")
 
-# Инициализация клиента
-phone = "+1234567890"
-client = MaxClient(phone=phone, work_dir="cache")
+    await client.send_message(
+        chat_id=msg.chat_id,
+        text="Привет, я бот на PyMax!",
+    )
+
+    await client.add_reaction(
+        chat_id=msg.chat_id,
+        message_id=str(msg.id),
+        reaction="👍",
+    )
 
-# Обработчик входящих сообщений
-@client.on_message()
-async def handle_message(message: Message) -> None:
-    print(f"{message.sender}: {message.text}")
 
-# Обработчик запуска клиента
 @client.on_start
-async def handle_start() -> None:
-    print("Клиент запущен")
+async def on_start() -> None:
+    print(f"Клиент запущен. Ваш ID: {client.me.id}")
 
-    # Получение истории сообщений
+    # Получение истории
     history = await client.fetch_history(chat_id=0)
-    if history:
-        for message in history:
-            user = await client.get_user(message.sender)
-            if user:
-                print(f"{user.names[0].name}: {message.text}")
-
-async def main() -> None:
-    await client.start()
-
-    # Работа с чатами
-    for chat in client.chats:
-        print(f"Чат: {chat.title}")
-
-        # Отправка сообщения
-        message = await client.send_message(
-            "Привет от PyMax!",
-            chat.id,
-            notify=True
-        )
-
-        # Редактирование сообщения
-        await asyncio.sleep(2)
-        await client.edit_message(
-            chat.id,
-            message.id,
-            "Привет от PyMax! (отредактировано)"
-        )
-
-        # Удаление сообщения
-        await asyncio.sleep(2)
-        await client.delete_message(chat.id, [message.id], for_me=False)
-
-    # Работа с диалогами
-    for dialog in client.dialogs:
-        print(f"Диалог: {dialog.last_message.text}")
-
-    # Работа с каналами
-    for channel in client.channels:
-        print(f"Канал: {channel.title}")
-
-    await client.close()
+    print("Последние сообщения из чата 0:")
+    for m in history:
+        print(f"- {m.text}")
+
+
+async def main():
+    await client.start()  # подключение и авторизация
+
 
 if __name__ == "__main__":
     asyncio.run(main())
@@ -145,7 +127,8 @@ if __name__ == "__main__":
 
 ## Документация
 
-[WIP](https://ink-developer.github.io/PyMax)
+[GitHub Pages](https://maxapiteam.github.io/PyMax/)
+[DeepWiki](https://deepwiki.com/MaxApiTeam/PyMax)
 
 ## Лицензия
 

maxapi_python-1.1.21.dist-info/RECORD

@@ -0,0 +1,32 @@
+pymax/__init__.py,sha256=6wUKKwsyxFpWG3b7kwptOvHd-w78C-ygw42iCDBYQvc,1915
+pymax/core.py,sha256=aF-nGQG92KV9ZBIXWTxl2mpyfXgmZ2OQq2-OnouB2O4,19720
+pymax/crud.py,sha256=uphxDTCj1tGCrQ1lE2osLIZY7WLWbS-pkG46i2pU8Z0,3075
+pymax/exceptions.py,sha256=nDUNx7bM-Yjugj-qfIllcrnwLg9JpZroYqfXapjYbMQ,3178
+pymax/files.py,sha256=AvFIr34Desq2p4CNWXIngRqeyTBKMT98VmcnI-zvUU0,3462
+pymax/filters.py,sha256=gSHPJ1Vi37HKPxf0jRRv9Q3iGwhiQjw1MGrCaouqHzs,4325
+pymax/formatter.py,sha256=RJ_5VbY7Li8UM3xL1AvcXo8v1iYnY8GvDDkreaFqtnY,860
+pymax/formatting.py,sha256=hhtmakfcQDzQRsAckPunnJOCKY2lFdLeIp8Yw53yY8s,2522
+pymax/interfaces.py,sha256=2wdS5BfguU9zH3yLSGBWtSq0_SWwcSVLHSd1Z4ZIS2g,4003
+pymax/models.py,sha256=PsPGbOkERxesZZltjNrmqhOfRcO44Is2ThbEToREcB8,201
+pymax/navigation.py,sha256=4ia6RGY2pXMArboNhHkbWlWX7LtcYK1VGVXorPX0Pb4,5747
+pymax/payloads.py,sha256=-GEJVXXlmJiFSTX4ToVNzmSZSrvSRe-BLOwYyRxGkWY,7280
+pymax/types.py,sha256=_ARcVXLGHyiGAJKYPd6EU9QDKzz4VwS6kjTu3YEH_u4,35523
+pymax/mixins/__init__.py,sha256=5sXJME34S1EssuDETaN4DLRH7vhMw_Q3Jmay9myAIZM,775
+pymax/mixins/auth.py,sha256=zErX2vItVwHV8rAKWXX74dEEYSlECr2oYmnzEzw86eM,9661
+pymax/mixins/channel.py,sha256=W52YnBay1sUYXxF9oAWsz44ZUh_s45jSvKmAyjTbULM,5357
+pymax/mixins/group.py,sha256=LqI1QHmZlmtuQ0-4H1MrNeBV-O9SMDMfHT9f4B_2poE,15189
+pymax/mixins/handler.py,sha256=ETnI8fA386LYJGjWtUhhWzQHREUA78di1aO1oWwtscA,12523
+pymax/mixins/message.py,sha256=AznKKmTMxdzsYl8IecT43RjWpGvlQM85GzSNGFbI8BA,33279
+pymax/mixins/scheduler.py,sha256=rcMfgfZnzu5V6MkcCg6uRgbi-jkc7UyqOjemulydWbc,964
+pymax/mixins/self.py,sha256=Be5L64eNYylGM-NmoxFpQZv1ohsC1Dx_Cs3Om__V96s,6976
+pymax/mixins/socket.py,sha256=9_TtTzB1mXH2U-odtwvOEXViUOCzPXBgTEXbMckhiq4,23122
+pymax/mixins/telemetry.py,sha256=LWr68DNQkPhAjGRDYQ5lORXxC3Yw6M9E8sF0TCNISTE,3609
+pymax/mixins/user.py,sha256=RSZd4t-aq8P2k3cVzNVWBkUf-_xTWILrBzwxLRgk1pw,9450
+pymax/mixins/utils.py,sha256=s3FUf3i_wjn2Gbg5YY1rWZB-90ZEGrrcUuND_MqqSTE,853
+pymax/mixins/websocket.py,sha256=m2swhSHIcFG6iABAik_oWxIpHfr0sxZ74I6VRU-iVO8,17809
+pymax/static/constant.py,sha256=BjSb2G6CTN6Idpo5GeLa-07YodnLNycYDmI7nOk0YGs,1111
+pymax/static/enum.py,sha256=Lf_qHbA2e2oK7X2uuiXInvaV1ql6hX-4wypFnokaazM,4584
+maxapi_python-1.1.21.dist-info/METADATA,sha256=_VPALryggwzxWHAcYKsKSb4rP094y1PmLEFKIOFolRs,5560
+maxapi_python-1.1.21.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+maxapi_python-1.1.21.dist-info/licenses/LICENSE,sha256=hOR249ItqMdcly1A0amqEWRNRTq4Gv5NJtmQ3A5qK4E,1070
+maxapi_python-1.1.21.dist-info/RECORD,,

pymax/core.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import asyncio
 import contextlib
 import logging
@@ -8,6 +10,7 @@ import traceback
 from collections.abc import Awaitable
 from pathlib import Path
 from typing import TYPE_CHECKING, Any, Literal
+from uuid import UUID
 
 from typing_extensions import Self, override
 
@@ -27,12 +30,13 @@ from .static.constant import (
 )
 
 if TYPE_CHECKING:
-    from collections.abc import Awaitable, Callable
-    from typing import Any
+    from collections.abc import Callable
 
     import websockets
 
-    from .filters import Filter
+    from pymax.filters import BaseFilter
+
+    from .filters import Filters
     from .types import Channel, Chat, Dialog, Me, Message, ReactionInfo, User
 
 
@@ -43,29 +47,36 @@ class MaxClient(ApiMixin, WebSocketMixin):
     """
     Основной клиент для работы с WebSocket API сервиса Max.
 
-
-    Args:
-        phone (str): Номер телефона для авторизации.
-        uri (str, optional): URI WebSocket сервера. По умолчанию Constants.WEBSOCKET_URI.value.
-        work_dir (str, optional): Рабочая директория для хранения базы данных. По умолчанию ".".
-        logger (logging.Logger | None): Пользовательский логгер. Если не передан — используется
-            логгер модуля с именем f"{__name__}.MaxClient".
-        headers (UserAgentPayload): Заголовки для подключения к WebSocket.
-        token (str | None, optional): Токен авторизации. Если не передан, будет выполнен
-            процесс логина по номеру телефона.
-        host (str, optional): Хост API сервера. По умолчанию Constants.HOST.value.
-        port (int, optional): Порт API сервера. По умолчанию Constants.PORT.value.
-        registration (bool, optional): Флаг регистрации нового пользователя. По умолчанию False.
-        first_name (str, optional): Имя пользователя для регистрации. Требуется, если registration=True.
-        last_name (str | None, optional): Фамилия пользователя для регистрации.
-        send_fake_telemetry (bool, optional): Флаг отправки фейковой телеметрии. По умолчанию True.
-        proxy (str | Literal[True] | None, optional): Прокси для подключения к WebSocket.
-            (См. https://websockets.readthedocs.io/en/stable/topics/proxies.html).
-        reconnect (bool, optional): Флаг автоматического переподключения при потере соединения. По умолчанию True.
-
-
-    Raises:
-        InvalidPhoneError: Если формат номера телефона неверный.
+    :param phone: Номер телефона для авторизации.
+    :type phone: str
+    :param uri: URI WebSocket сервера.
+    :type uri: str, optional
+    :param work_dir: Рабочая директория для хранения базы данных.
+    :type work_dir: str, optional
+    :param logger: Пользовательский логгер. Если не передан, используется логгер модуля с именем f"{__name__}.MaxClient".
+    :type logger: logging.Logger | None
+    :param headers: Заголовки для подключения к WebSocket.
+    :type headers: UserAgentPayload
+    :param token: Токен авторизации. Если не передан, будет выполнен процесс логина по номеру телефона.
+    :type token: str | None, optional
+    :param host: Хост API сервера.
+    :type host: str, optional
+    :param port: Порт API сервера.
+    :type port: int, optional
+    :param registration: Флаг регистрации нового пользователя.
+    :type registration: bool, optional
+    :param first_name: Имя пользователя для регистрации. Требуется, если registration=True.
+    :type first_name: str, optional
+    :param last_name: Фамилия пользователя для регистрации.
+    :type last_name: str | None, optional
+    :param send_fake_telemetry: Флаг отправки фейковой телеметрии.
+    :type send_fake_telemetry: bool, optional
+    :param proxy: Прокси для подключения к WebSocket (см. https://websockets.readthedocs.io/en/stable/topics/proxies.html).
+    :type proxy: str | Literal[True] | None, optional
+    :param reconnect: Флаг автоматического переподключения при потере соединения.
+    :type reconnect: bool, optional
+
+    :raises InvalidPhoneError: Если формат номера телефона неверный.
     """
 
     def __init__(
@@ -82,6 +93,7 @@ class MaxClient(ApiMixin, WebSocketMixin):
         registration: bool = False,
         first_name: str = "",
         last_name: str | None = None,
+        device_id: UUID | None = None,
         logger: logging.Logger | None = None,
         reconnect: bool = True,
         reconnect_delay: float = 1.0,
@@ -127,7 +139,9 @@ class MaxClient(ApiMixin, WebSocketMixin):
         self._circuit_breaker: bool = False
         self._last_error_time: float = 0.0
 
-        self._device_id = self._database.get_device_id()
+        self._device_id = (
+            device_id if device_id is not None else self._database.get_device_id()
+        )
         self._file_upload_waiters: dict[int, asyncio.Future[dict[str, Any]]] = {}
 
         self._token = self._database.get_auth_token() or token
@@ -138,19 +152,25 @@ class MaxClient(ApiMixin, WebSocketMixin):
         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]
+            tuple[Callable[[Message], Any], BaseFilter[Message] | None]
         ] = []
         self._on_start_handler: Callable[[], Any | Awaitable[Any]] | None = None
         self._on_reaction_change_handlers: list[
             tuple[Callable[[str, int, ReactionInfo], Any]]
         ] = []
         self._on_chat_update_handlers: list[tuple[Callable[[Chat], 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._ssl_context = ssl.create_default_context()
         self._ssl_context.set_ciphers("DEFAULT")
@@ -199,6 +219,11 @@ class MaxClient(ApiMixin, WebSocketMixin):
             )
 
     async def close(self) -> None:
+        """
+        Закрывает клиент и освобождает ресурсы.
+
+        :return: None
+        """
         try:
             self.logger.info("Closing client")
             if self._recv_task:
@@ -230,11 +255,11 @@ class MaxClient(ApiMixin, WebSocketMixin):
             except asyncio.CancelledError:
                 raise
             except Exception as e:
-                self.logger.exception(
-                    f"Unhandled exception in task {name or coro}: {e}",
-                    exc_info=e,
+                tb = traceback.format_exc()
+                self.logger.error(
+                    f"Unhandled exception in task {name or coro}: {e}\n{tb}"
                 )
-                return None
+                raise
 
         task = asyncio.create_task(runner(), name=name)
         self._background_tasks.add(task)
@@ -244,21 +269,25 @@ class MaxClient(ApiMixin, WebSocketMixin):
         if sync:
             await self._sync()
 
-        if self._on_start_handler:
-            self.logger.debug("Calling on_start handler")
-            result = self._on_start_handler()
-            if asyncio.iscoroutine(result):
-                await self._safe_execute(result, context="on_start handler")
-
+        self.logger.debug("is_connected=%s before starting ping", self.is_connected)
         ping_task = asyncio.create_task(self._send_interactive_ping())
         ping_task.add_done_callback(self._log_task_exception)
         self._background_tasks.add(ping_task)
 
+        start_scheduled_task = asyncio.create_task(self._start_scheduled_tasks())
+        start_scheduled_task.add_done_callback(self._log_task_exception)
+
         if self._send_fake_telemetry:
             telemetry_task = asyncio.create_task(self._start())
             telemetry_task.add_done_callback(self._log_task_exception)
             self._background_tasks.add(telemetry_task)
 
+        if self._on_start_handler:
+            self.logger.debug("Calling on_start handler")
+            result = self._on_start_handler()
+            if asyncio.iscoroutine(result):
+                await self._safe_execute(result, context="on_start handler")
+
     async def _cleanup_client(self) -> None:
         for task in list(self._background_tasks):
             task.cancel()
@@ -305,17 +334,21 @@ class MaxClient(ApiMixin, WebSocketMixin):
         """
         Завершает кастомный login flow: отправляет код, сохраняет токен и запускает пост-логин задачи.
 
-        Args:
-            temp_token (str): Временный токен, полученный из request_code()
-            code (str): Код, введённый пользователем
-
-        Returns:
-            str: Токен для входа
+        :param temp_token: Временный токен, полученный из request_code.
+        :type temp_token: str
+        :param code: Код верификации (6 цифр).
+        :type code: str
+        :param start: Флаг запуска пост-логин задач и ожидания навсегда. Если False, только сохраняет токен.
+        :type start: bool, optional
+        :return: None
+        :rtype: None
         """
         resp = await self._send_code(code, temp_token)
         token = resp.get("tokenAttrs", {}).get("LOGIN", {}).get("token")
+        if not token:
+            raise ValueError("Login response did not contain tokenAttrs.LOGIN.token")
         self._token = token
-        self._database.update_auth_token(self._device_id, token)
+        self._database.update_auth_token(str(self._device_id), token)
         if start:
             while True:
                 try:
@@ -336,6 +369,9 @@ class MaxClient(ApiMixin, WebSocketMixin):
         Запускает клиент, подключается к WebSocket, авторизует
         пользователя (если нужно) и запускает фоновый цикл.
         Теперь включает безопасный reconnect-loop, если self.reconnect=True.
+
+        :return: None
+        :rtype: None
         """
 
         while True:
@@ -349,7 +385,7 @@ class MaxClient(ApiMixin, WebSocketMixin):
                     await self._register(self.first_name, self.last_name)
 
                 if self._token and self._database.get_auth_token() is None:
-                    self._database.update_auth_token(self._device_id, self._token)
+                    self._database.update_auth_token(str(self._device_id), self._token)
 
                 if self._token is None:
                     await self._login()
@@ -377,8 +413,33 @@ class MaxClient(ApiMixin, WebSocketMixin):
             await asyncio.sleep(self.reconnect_delay)
 
     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:

pymax/crud.py

@@ -31,9 +31,8 @@ class Database:
 
     def get_device_id(self) -> UUID:
         with self.get_session() as session:
-            device_id = cast(
-                UUID | None, session.exec(select(Auth.device_id)).first()
-            )
+            device_id = session.exec(select(Auth.device_id)).first()
+
             if device_id is None:
                 auth = Auth()
                 session.add(auth)
@@ -49,11 +48,9 @@ class Database:
             session.refresh(auth)
             return auth
 
-    def update_auth_token(self, device_id: UUID, token: str) -> None:
+    def update_auth_token(self, device_id: str, token: str) -> None:
         with self.get_session() as session:
-            auth = session.exec(
-                select(Auth).where(Auth.device_id == device_id)
-            ).first()
+            auth = session.exec(select(Auth).where(Auth.device_id == device_id)).first()
             if auth:
                 auth.token = token
                 session.add(auth)
@@ -86,7 +83,6 @@ class Database:
         with self.get_session() as session:
             rows = session.exec(select(Auth)).all()
             if not rows:
-                # Create default Auth with device type from enum
                 auth = Auth(device_type=DeviceType.WEB.value)
                 session.add(auth)
                 session.commit()

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