Рефакторинг обработки ошибок и структуры кода в миксинах: добавлен MixinsUtils, обновлена обработка ошибок, упрощено логирование, переименован JoinGroupPayload в JoinChatPayload, Enum для типобезопасности, удалён utils.py, улучшено логирование.

Author: ink-developer

.gitignore

@@ -103,6 +103,7 @@ Thumbs.db
 session.db
 *.bak
 *.swp
+*.bin
 
 # Environment / secrets
 .env
@@ -114,6 +115,7 @@ cache/
 
 # Keep lockfiles and important configs tracked? If you want to track specific lockfiles,
 # remove them from this .gitignore (for example: remove poetry.lock or uv.lock).
+tests2/
 tests/
 
 

examples/example.py

@@ -30,16 +30,23 @@ async def handle_deleted_message(message: Message) -> None:
 @client.on_start
 async def handle_start() -> None:
     print(f"Client started successfully at {datetime.datetime.now()}!")
-    file_path = "ruff.toml"
-    file = File(path=file_path)
-    msg = await client.send_message(
-        text="Here is the file you requested.",
-        chat_id=0,
-        attachment=file,
-        notify=True,
-    )
-    if msg:
-        print(f"File sent successfully in message ID: {msg.id}")
+    print(client.me.id)
+
+    # await client.send_message(
+    #     "Hello, this is a test message sent upon client start!",
+    #     chat_id=23424,
+    #     notify=True,
+    # )
+    # file_path = "ruff.toml"
+    # file = File(path=file_path)
+    # msg = await client.send_message(
+    #     text="Here is the file you requested.",
+    #     chat_id=0,
+    #     attachment=file,
+    #     notify=True,
+    # )
+    # if msg:
+    #     print(f"File sent successfully in message ID: {msg.id}")
     # history = await client.fetch_history(chat_id=0)
     # if history:
     #     for message in history:

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "maxapi-python"
-version = "1.1.15"
+version = "1.1.16"
 description = "Python wrapper для API мессенджера Max"
 readme = "README.md"
 requires-python = ">=3.10"

src/pymax/core.py

@@ -3,13 +3,16 @@
 import socket
 import ssl
 import time
+import traceback
+from collections.abc import Awaitable
 from pathlib import Path
-from typing import Any, Literal
+from typing import TYPE_CHECKING, Any, Literal
 
 from typing_extensions import override
 
 from .crud import Database
 from .exceptions import InvalidPhoneError
+from .formatter import ColoredFormatter
 from .mixins import ApiMixin, SocketMixin, WebSocketMixin
 from .payloads import UserAgentPayload
 from .static.constant import (
@@ -18,6 +21,16 @@
     WEBSOCKET_URI,
 )
 
+if TYPE_CHECKING:
+    from collections.abc import Awaitable, Callable
+    from typing import Any
+
+    import websockets
+
+    from .filters import Filter
+    from .types import Channel, Chat, Dialog, Me, Message, User
+
+
 logger = logging.getLogger(__name__)
 
 
@@ -64,9 +77,7 @@ def __init__(
         last_name: str | None = None,
         logger: logging.Logger | None = None,
     ) -> None:
-        logger = logger or logging.getLogger(f"{__name__}.MaxClient")
-        ApiMixin.__init__(self, token=token, logger=logger)
-        WebSocketMixin.__init__(self, token=token, logger=logger)
+        self.logger = logger or logging.getLogger(f"{__name__}")
         self.uri: str = uri
         self.phone: str = phone
         if not self._check_phone():
@@ -77,32 +88,64 @@ def __init__(
         self.first_name: str = first_name
         self.last_name: str | None = last_name
         self.proxy: str | Literal[True] | None = proxy
+
+        self.is_connected: bool = False
+
+        self.chats: list[Chat] = []
+        self.dialogs: list[Dialog] = []
+        self.channels: list[Channel] = []
+        self.me: Me | None = None
+        self._users: dict[int, User] = {}
+
         self._work_dir: str = work_dir
         self._database_path: Path = Path(work_dir) / "session.db"
         self._database_path.parent.mkdir(parents=True, exist_ok=True)
         self._database_path.touch(exist_ok=True)
         self._database = Database(self._work_dir)
+
+        self._incoming: asyncio.Queue[dict[str, Any]] | None = None
         self._outgoing: asyncio.Queue[dict[str, Any]] | None = None
+        self._recv_task: asyncio.Task[Any] | None = None
         self._outgoing_task: asyncio.Task[Any] | None = None
+        self._pending: dict[int, asyncio.Future[dict[str, Any]]] = {}
+        self._file_upload_waiters: dict[int, asyncio.Future[dict[str, Any]]] = {}
+        self._background_tasks: set[asyncio.Task[Any]] = set()
+
+        self._seq: int = 0
         self._error_count: int = 0
         self._circuit_breaker: bool = False
         self._last_error_time: float = 0.0
+
         self._device_id = self._database.get_device_id()
-        self._file_upload_waiters: dict[
-            int, asyncio.Future[dict[str, Any]]
-        ] = {}
+        self._file_upload_waiters: dict[int, asyncio.Future[dict[str, Any]]] = {}
+
         self._token = self._database.get_auth_token() or token
         self.user_agent = headers
         self._send_fake_telemetry: bool = send_fake_telemetry
         self._session_id: int = int(time.time() * 1000)
         self._action_id: int = 1
+        self._current_screen: str = "chats_list_tab"
+
+        self._on_message_handlers: list[
+            tuple[Callable[[Message], Any], Filter | None]
+        ] = []
+        self._on_message_edit_handlers: list[
+            tuple[Callable[[Message], Any], Filter | None]
+        ] = []
+        self._on_message_delete_handlers: list[
+            tuple[Callable[[Message], Any], Filter | None]
+        ] = []
+        self._on_start_handler: Callable[[], Any | Awaitable[Any]] | None = None
+
         self._ssl_context = ssl.create_default_context()
         self._ssl_context.set_ciphers("DEFAULT")
         self._ssl_context.check_hostname = True
         self._ssl_context.verify_mode = ssl.CERT_REQUIRED
         self._ssl_context.minimum_version = ssl.TLSVersion.TLSv1_2
         self._ssl_context.load_default_certs()
         self._socket: socket.socket | None = None
+        self._ws: websockets.ClientConnection | None = None
+
         self._setup_logger()
         self.logger.debug(
             "Initialized MaxClient uri=%s work_dir=%s",
@@ -111,20 +154,35 @@ def __init__(
         )
 
     def _setup_logger(self) -> None:
-        if not logger.handlers:
+        if not self.logger.handlers:
+            if not self.logger.level:
+                self.logger.setLevel(logging.INFO)
             handler = logging.StreamHandler()
-            formatter = logging.Formatter(
-                "%(asctime)s [%(levelname)s] %(name)s: %(message)s"
+            formatter = ColoredFormatter(
+                "%(asctime)s [%(levelname)s] %(name)s: %(message)s",
+                datefmt="%Y-%m-%d %H:%M:%S",
             )
             handler.setFormatter(formatter)
-            logger.addHandler(handler)
+            self.logger.addHandler(handler)
 
     async def _wait_forever(self):
         try:
             await self.ws.wait_closed()
         except asyncio.CancelledError:
             self.logger.debug("wait_closed cancelled")
 
+    async def _safe_execute(self, coro, *, context: str = "unknown"):
+        """
+        Безопасно выполняет пользовательскую корутину.
+        Логирует traceback, но не роняет event loop.
+        """
+        try:
+            return await coro
+        except Exception as e:
+            self.logger.error(
+                f"Unhandled exception in {context}: {e}\n{traceback.format_exc()}"
+            )
+
     async def close(self) -> None:
         try:
             self.logger.info("Closing client")
@@ -147,6 +205,23 @@ async def close(self) -> None:
         except Exception:
             self.logger.exception("Error closing client")
 
+    def _create_safe_task(self, coro: Awaitable[Any], *, name: str | None = None):
+        async def runner():
+            try:
+                return await coro
+            except asyncio.CancelledError:
+                raise
+            except Exception as e:
+                self.logger.error(
+                    f"Unhandled exception in task {name or coro}: {e}",
+                    exc_info=e,
+                )
+                return None
+
+        task = asyncio.create_task(runner(), name=name)
+        self._background_tasks.add(task)
+        return task
+
     async def start(self) -> None:
         """
         Запускает клиент, подключается к WebSocket, авторизует
@@ -173,7 +248,7 @@ async def start(self) -> None:
                 self.logger.debug("Calling on_start handler")
                 result = self._on_start_handler()
                 if asyncio.iscoroutine(result):
-                    await result
+                    await self._safe_execute(result, context="on_start handler")
 
             ping_task = asyncio.create_task(self._send_interactive_ping())
             ping_task.add_done_callback(self._log_task_exception)

src/pymax/exceptions.py

@@ -39,15 +39,6 @@ def __init__(self) -> None:
         super().__init__("Send and wait failed (socket)")
 
 
-class LoginError(Exception):
-    """
-    Исключение, вызываемое при ошибке авторизации.
-    """
-
-    def __init__(self, message: str) -> None:
-        super().__init__(f"Login error: {message}")
-
-
 class ResponseError(Exception):
     """
     Исключение, вызываемое при ошибке в ответе от сервера.
@@ -64,3 +55,54 @@ class ResponseStructureError(Exception):
 
     def __init__(self, message: str) -> None:
         super().__init__(f"Response structure error: {message}")
+
+
+class Error(Exception):
+    """
+    Базовое исключение для ошибок PyMax.
+    """
+
+    def __init__(
+        self,
+        error: str,
+        message: str,
+        title: str,
+        localized_message: str | None = None,
+    ) -> None:
+        self.error = error
+        self.message = message
+        self.title = title
+        self.localized_message = localized_message
+
+        parts = []
+        if localized_message:
+            parts.append(localized_message)
+        if message:
+            parts.append(message)
+        if title:
+            parts.append(f"({title})")
+        parts.append(f"[{error}]")
+
+        super().__init__("PyMax Error: " + " ".join(parts))
+
+
+class RateLimitError(Error):
+    """
+    Исключение, вызываемое при превышении лимита запросов.
+    """
+
+    def __init__(
+        self, error: str, message: str, title: str, localized_message: str | None = None
+    ) -> None:
+        super().__init__(error, message, title, localized_message)
+
+
+class LoginError(Error):
+    """
+    Исключение, вызываемое при ошибке авторизации.
+    """
+
+    def __init__(
+        self, error: str, message: str, title: str, localized_message: str | None = None
+    ) -> None:
+        super().__init__(error, message, title, localized_message)

src/pymax/formatter.py

@@ -0,0 +1,30 @@
+import logging
+from typing import ClassVar
+
+
+class ColoredFormatter(logging.Formatter):
+    COLORS: ClassVar = {
+        "DEBUG": "\033[37m",
+        "INFO": "\033[36m",
+        "WARNING": "\033[33m",
+        "ERROR": "\033[31m",
+        "CRITICAL": "\033[41m",
+    }
+
+    RESET = "\033[0m"
+    DIM = "\033[2m"
+    BOLD = "\033[1m"
+
+    def format(self, record: logging.LogRecord) -> str:
+        level_color = self.COLORS.get(record.levelname, self.RESET)
+        time_color = self.DIM
+        name_color = "\033[35m"
+        message_color = self.RESET
+
+        log = (
+            f"{time_color}{self.formatTime(record, '%H:%M:%S')}{self.RESET} "
+            f"[{level_color}{record.levelname}{self.RESET}] "
+            f"{name_color}{record.name}{self.RESET}: "
+            f"{message_color}{record.getMessage()}{self.RESET}"
+        )
+        return log

src/pymax/interfaces.py

@@ -41,6 +41,7 @@ def __init__(self, logger: Logger) -> None:
         self.registration: bool
         self.first_name: str
         self.last_name: str | None
+        self._token: str | None
         self._work_dir: str
         self._database_path: Path
         self._ws: websockets.ClientConnection | None = None
@@ -100,3 +101,9 @@ async def _queue_message(
         max_retries: int = 3,
     ) -> Message | None:
         pass
+
+    @abstractmethod
+    def _create_safe_task(
+        self, coro: Awaitable[Any], name: str | None = None
+    ) -> asyncio.Task[Any]:
+        pass