maxapi-python 1.2.4__py3-none-any.whl → 2.0.0__py3-none-any.whl

pymax/types/events/message.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from pydantic import PrivateAttr
+
+from pymax.types.domain import Chat
+from pymax.types.domain.base import CamelModel
+
+if TYPE_CHECKING:
+    from pymax.api.messages import MessageService
+
+
+class MessageDeleteEvent(CamelModel):
+    """Событие удаления сообщений.
+
+    Handler ``on_message_delete`` получает этот объект, когда Max сообщает об
+    удалении одного или нескольких сообщений в чате.
+
+    :ivar chat: Чат, в котором удалены сообщения.
+    :vartype chat: Chat
+    :ivar message_ids: ID удаленных сообщений.
+    :vartype message_ids: list[int]
+    :ivar ttl: Признак удаления из-за TTL, если Max его прислал.
+    :vartype ttl: bool
+    """
+
+    chat: Chat
+    message_ids: list[int]
+    ttl: bool = False
+
+    _actions: MessageService | None = PrivateAttr(default=None)
+
+    def bind(self, actions: MessageService) -> MessageDeleteEvent:
+        """Привязывает сервис сообщений к событию удаления."""
+        self._actions = actions
+        return self

pymax/types/events/video.py

@@ -0,0 +1,5 @@
+from pymax.types.domain.base import CamelModel
+
+
+class VideoUploadSignal(CamelModel):
+    video_id: int

maxapi_python-1.2.4.dist-info/METADATA

@@ -1,205 +0,0 @@
-Metadata-Version: 2.4
-Name: maxapi-python
-Version: 1.2.4
-Summary: Python wrapper для API мессенджера Max
-Project-URL: Homepage, https://github.com/MaxApiTeam/PyMax
-Project-URL: Repository, https://github.com/MaxApiTeam/PyMax
-Project-URL: Issues, https://github.com/MaxApiTeam/PyMax/issues
-Author-email: ink <mail@gmail.com>
-License-Expression: MIT
-License-File: LICENSE
-Keywords: api,max,messenger,websocket,wrapper
-Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python :: 3
-Requires-Python: >=3.10
-Requires-Dist: aiofiles>=24.1.0
-Requires-Dist: aiohttp>=3.12.15
-Requires-Dist: lz4>=4.4.4
-Requires-Dist: msgpack>=1.1.1
-Requires-Dist: qrcode>=8.2
-Requires-Dist: sqlmodel>=0.0.24
-Requires-Dist: ua-generator>=2.0.19
-Requires-Dist: websockets>=15.0
-Provides-Extra: test
-Requires-Dist: flake8; extra == 'test'
-Requires-Dist: mypy; extra == 'test'
-Requires-Dist: pytest-asyncio>=0.24.0; extra == 'test'
-Requires-Dist: pytest-cov>=5.0.0; extra == 'test'
-Requires-Dist: pytest-timeout>=2.1.0; extra == 'test'
-Requires-Dist: pytest>=8.0.0; extra == 'test'
-Description-Content-Type: text/markdown
-
-<p align="center">
-    <img src="assets/logo.svg" alt="PyMax" width="400">
-</p>
-
-<p align="center">
-    <strong>Python wrapper для API мессенджера Max</strong>
-</p>
-
-> [!IMPORTANT]
-> (29.12.2025) Снова неожиданное изменение апи, теперь `MaxClient` с `device_type` любым кроме `WEB` не работает, для вохда по номеру телефона используйте `SocketMaxClient`
-
-
-<p align="center">
-    <img src="https://img.shields.io/badge/python-3.10+-3776AB.svg" alt="Python 3.11+">
-    <img src="https://img.shields.io/badge/License-MIT-2f9872.svg" alt="License: MIT">
-    <img src="https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json" alt="Ruff">
-    <img src="https://img.shields.io/badge/packaging-uv-D7FF64.svg" alt="Packaging">
-</p>
-
-
----
-> ⚠️ **Дисклеймер**
->
-> *   Это **неофициальная** библиотека для работы с внутренним API Max.
-> *   Использование может **нарушать условия предоставления услуг** сервиса.
-> *   **Вы используете её исключительно на свой страх и риск.**
-> *   **Разработчики и контрибьюторы не несут никакой ответственности** за любые последствия использования этого пакета, включая, но не ограничиваясь: блокировку аккаунтов, утерю данных, юридические риски и любые другие проблемы.
-> *   API может быть изменен в любой момент без предупреждения.
----
-
-## Описание
-
-**`pymax`** — асинхронная Python библиотека для работы с API мессенджера Max. Предоставляет интерфейс для отправки сообщений, управления чатами, каналами и диалогами через WebSocket соединение.
-
-### Основные возможности
-
-- Вход по номеру телефона
-- Отправка, редактирование и удаление сообщений
-- Работа с чатами и каналами
-- История сообщений
-
-## Установка
-
-> [!IMPORTANT]
-> Для работы библиотеки требуется Python 3.10 или выше
-
-### Установка через pip
-
-```bash
-pip install -U maxapi-python
-```
-
-### Установка через uv
-
-```bash
-uv add -U maxapi-python
-```
-
-## Быстрый старт
-
-### Аутентификация (`device_type`)
-
-> [!IMPORTANT]
-> Параметр `device_type` в `UserAgentPayload` **критически важен** для выбора способа авторизации:
-
-**Вход по номеру телефона (DESKTOP):**
-
-```python
-from pymax import SocketMaxClient
-from pymax.payloads import UserAgentPayload
-
-ua = UserAgentPayload(device_type="DESKTOP", app_version="25.12.13")
-
-client = SocketMaxClient(
-    phone="+79111111111",
-    work_dir="cache",
-    headers=ua,
-)
-```
-
-**Вход через QR-код (WEB)** — токен совместим с веб-версией Max:
-
-```python
-from pymax import MaxClient
-from pymax.payloads import UserAgentPayload
-
-ua = UserAgentPayload(device_type="WEB", app_version="25.12.13")
-
-client = MaxClient(
-    phone="+7911111111",
-    work_dir="cache",
-    headers=ua,
-)
-```
-
-### Базовый пример использования
-
-```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}")
-
-    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_start
-async def on_start() -> None:
-    print(f"Клиент запущен. Ваш ID: {client.me.id}")
-
-    # Получение истории
-    history = await client.fetch_history(chat_id=0)
-    print("Последние сообщения из чата 0:")
-    for m in history:
-        print(f"- {m.text}")
-
-
-async def main():
-    await client.start()  # подключение и авторизация
-
-
-if __name__ == "__main__":
-    asyncio.run(main())
-```
-
-## Документация
-
-[GitHub Pages](https://maxapiteam.github.io/PyMax/)
-[DeepWiki](https://deepwiki.com/MaxApiTeam/PyMax)
-
-## Лицензия
-
-Этот проект распространяется под лицензией MIT. См. файл [LICENSE](LICENSE) для получения информации.
-
-## Новости
-
-[Telegram](https://t.me/pymax_news)
-
-## Star History
-
-[![Star History Chart](https://api.star-history.com/svg?repos=ink-developer/PyMax&type=date&legend=top-left)](https://www.star-history.com/#ink-developer/PyMax&type=date&legend=top-left)
-
-## Авторы
-- **[ink](https://github.com/ink-developer)** — Главный разработчик, исследование API и его документация
-- **[noxzion](https://github.com/noxzion)** — Оригинальный автор проекта
-
-
-## Контрибьюторы
-
-Спасибо всем за помощь в разработке!
-
-<a href="https://github.com/MaxApiTeam/PyMax/graphs/contributors">
-  <img src="https://contrib.rocks/image?repo=ink-developer/PyMax" />
-</a>

maxapi_python-1.2.4.dist-info/RECORD

@@ -1,33 +0,0 @@
-pymax/__init__.py,sha256=6wUKKwsyxFpWG3b7kwptOvHd-w78C-ygw42iCDBYQvc,1915
-pymax/core.py,sha256=oJEgLVWHjtTPqDd8I7mdHgYxw-Z567FZx-su-iIhVK8,15904
-pymax/crud.py,sha256=YC92TyhA2mr1tJCcfd-tvh8umtXKgqJfgiLo7nXUl3Q,3076
-pymax/exceptions.py,sha256=nDUNx7bM-Yjugj-qfIllcrnwLg9JpZroYqfXapjYbMQ,3178
-pymax/files.py,sha256=nx7oZfIJ8ZvO-TuG5LzSmk8esbBtNrkKdFQgTQVbUA8,4063
-pymax/filters.py,sha256=gSHPJ1Vi37HKPxf0jRRv9Q3iGwhiQjw1MGrCaouqHzs,4325
-pymax/formatter.py,sha256=RJ_5VbY7Li8UM3xL1AvcXo8v1iYnY8GvDDkreaFqtnY,860
-pymax/formatting.py,sha256=XRtuXJGweuNZevJFdPxksDftIrfuMGEA-AOUc_v6IhQ,2484
-pymax/interfaces.py,sha256=ZFmgZ9sK5j3jG8z7DuVovBkXIvPrN4H4rI0UBb2g4BY,19543
-pymax/models.py,sha256=PsPGbOkERxesZZltjNrmqhOfRcO44Is2ThbEToREcB8,201
-pymax/navigation.py,sha256=4ia6RGY2pXMArboNhHkbWlWX7LtcYK1VGVXorPX0Pb4,5747
-pymax/payloads.py,sha256=m0Fn0eEOo6hrdLB6ACh27ioT3SkYIMDMfLKaPbs2vdo,8147
-pymax/protocols.py,sha256=PoNvri9jFH6WBXGwugrkU6lwtwJEw0DO2s13HOH8_KI,4025
-pymax/types.py,sha256=z1HXNl8CP_X3jTUlENlF9_vzZKdb7gF5PHG5d4rG3BY,37209
-pymax/utils.py,sha256=HK6E6UYyjtUoJ2KXWeDycyiXm_9j5shZme6VFA2ixeM,2960
-pymax/mixins/__init__.py,sha256=5sXJME34S1EssuDETaN4DLRH7vhMw_Q3Jmay9myAIZM,775
-pymax/mixins/auth.py,sha256=nA1fX2ERzk6_WBSrbtBhvwkA5aUXgUdgweytqhZSAJU,14708
-pymax/mixins/channel.py,sha256=Qi5ujw5X7QYx4Lq1XnvlJ3BYjmTFmYDfu7_jRcx4Mx8,5335
-pymax/mixins/group.py,sha256=6bsWSx0ULZonDM_dJSC0EkqpZWd6tv9lmmKWj_gEaaw,15903
-pymax/mixins/handler.py,sha256=duL3Q5Bvv8tjUhOKaDr_k7w09BeCwjVdws2ga7v_zNE,12432
-pymax/mixins/message.py,sha256=MpUED92iWONkJRjb0f7lwPj9gYJhDuv0KKzbveOEaAk,33397
-pymax/mixins/scheduler.py,sha256=K4HB9IfksnXPujJnkipIS5um9nuzC8EjbtQn65RtbfI,963
-pymax/mixins/self.py,sha256=Wn9l3zDF5VzFzzisryOQknf3Ngl81Q98_9jqqbE9ZAw,9174
-pymax/mixins/socket.py,sha256=00uO4-8xer94i6Z6NDTUzzEQbs3NVMH1DB-KoPY6shU,10525
-pymax/mixins/telemetry.py,sha256=EAbGyk8EB6QxijaFQ16vUmFPe6l-gEraCxXnAfhA3kY,3594
-pymax/mixins/user.py,sha256=Xwb2fWM8RCq0SbVhlRyr1RBQGyjlaImtp0lT2PbgEqE,9420
-pymax/mixins/websocket.py,sha256=XZ7lE8rKiNd3MXQRlS7Waz8TuoVWms9ldjCOF12pNTw,4891
-pymax/static/constant.py,sha256=Gu1j4ibpaZL3tI6fUayS_jkyYOYNe9K-QlTUCOGviwQ,2260
-pymax/static/enum.py,sha256=Scyi1pAUaaQlec1YQsU_nvlfxTiQZ6p7gntOJhWfBk4,4773
-maxapi_python-1.2.4.dist-info/METADATA,sha256=hVzJYUCzdYWHmbcvAVlNYrEmvLRoWSVxwSbeNCL0Rqc,7069
-maxapi_python-1.2.4.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-maxapi_python-1.2.4.dist-info/licenses/LICENSE,sha256=hOR249ItqMdcly1A0amqEWRNRTq4Gv5NJtmQ3A5qK4E,1070
-maxapi_python-1.2.4.dist-info/RECORD,,

pymax/core.py

@@ -1,390 +0,0 @@
-from __future__ import annotations
-
-import asyncio
-import contextlib
-import logging
-import socket
-import ssl
-import time
-from collections.abc import Awaitable
-from pathlib import Path
-from typing import TYPE_CHECKING, Any, Literal
-from uuid import UUID
-
-from typing_extensions import override
-
-from .crud import Database
-from .exceptions import (
-    InvalidPhoneError,
-    SocketNotConnectedError,
-    WebSocketNotConnectedError,
-)
-from .interfaces import BaseClient
-from .mixins import ApiMixin, SocketMixin, WebSocketMixin
-from .payloads import UserAgentPayload
-from .static.constant import HOST, PORT, SESSION_STORAGE_DB, WEBSOCKET_URI
-
-if TYPE_CHECKING:
-    from collections.abc import Callable
-
-    import websockets
-
-    from pymax.filters import BaseFilter
-
-    from .types import Channel, Chat, Dialog, Me, Message, ReactionInfo, User
-
-
-logger = logging.getLogger(__name__)
-
-
-class MaxClient(ApiMixin, WebSocketMixin, BaseClient):
-    allowed_device_types: set[str] = {"WEB"}
-    """
-    Основной клиент для работы с WebSocket API сервиса Max.
-
-    :param phone: Номер телефона для авторизации.
-    :type phone: str
-    :param uri: URI WebSocket сервера.
-    :type uri: str, optional
-    :param session_name: Название сессии для хранения базы данных.
-    :type session_name: 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__(
-        self,
-        phone: str,
-        uri: str = WEBSOCKET_URI,
-        session_name: str = SESSION_STORAGE_DB,
-        headers: UserAgentPayload | None = None,
-        token: str | None = None,
-        send_fake_telemetry: bool = True,
-        host: str = HOST,
-        port: int = PORT,
-        proxy: str | Literal[True] | None = None,
-        work_dir: str = ".",
-        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,
-    ) -> None:
-        self.logger = logger or logging.getLogger(f"{__name__}")
-        self.uri: str = uri
-        self.phone: str = phone
-        if not self._check_phone():
-            raise InvalidPhoneError(self.phone)
-        self.host: str = host
-        self.port: int = port
-        self.registration: bool = registration
-        self.first_name: str = first_name
-        self.last_name: str | None = last_name
-        self.proxy: str | Literal[True] | None = proxy
-        self.reconnect: bool = reconnect
-        self.reconnect_delay: float = reconnect_delay
-
-        self.is_connected: bool = False
-
-        self.chats: list[Chat] = []
-        self.dialogs: list[Dialog] = []
-        self.channels: list[Channel] = []
-        self.me: Me | None = None
-        self.contacts: list[User] = []
-        self._users: dict[int, User] = {}
-
-        self._work_dir: str = work_dir
-        self._database_path: Path = Path(work_dir) / session_name
-        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._stop_event = asyncio.Event()
-
-        self._seq: int = 0
-        self._error_count: int = 0
-        self._circuit_breaker: bool = False
-        self._last_error_time: float = 0.0
-
-        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
-        if headers is None:
-            headers = self._default_headers()
-        self.user_agent = headers
-        self._validate_device_type()
-        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], BaseFilter[Message] | None]
-        ] = []
-        self._on_message_edit_handlers: list[
-            tuple[Callable[[Message], Any], BaseFilter[Message] | None]
-        ] = []
-        self._on_message_delete_handlers: list[
-            tuple[Callable[[Message], Any], BaseFilter[Message] | None]
-        ] = []
-        self._on_start_handler: Callable[[], Any | Awaitable[Any]] | None = None
-        self._on_stop_handler: Callable[[], Any | Awaitable[Any]] | None = None
-        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._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",
-            self.uri,
-            self._work_dir,
-        )
-
-    @staticmethod
-    def _default_headers() -> UserAgentPayload:
-        return UserAgentPayload(device_type="WEB")
-
-    def _validate_device_type(self) -> None:
-        if self.user_agent.device_type not in self.allowed_device_types:
-            raise ValueError(
-                f"{self.__class__.__name__} does not support "
-                f"device_type={self.user_agent.device_type}"
-            )
-
-    async def _wait_forever(self) -> None:
-        try:
-            await self.ws.wait_closed()
-        except asyncio.CancelledError:
-            self.logger.debug("wait_closed cancelled")
-        except WebSocketNotConnectedError:
-            self.logger.info("WebSocket not connected, exiting wait_forever")
-
-    async def close(self) -> None:
-        """
-        Закрывает клиент и освобождает ресурсы.
-
-        :return: None
-        """
-        try:
-            self.logger.info("Closing client")
-            self._stop_event.set()
-        except Exception:
-            self.logger.exception("Error closing client")
-
-    async def _post_login_tasks(self, sync: bool = True) -> None:
-        if sync:
-            await self._sync()
-
-        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 login_with_code(self, temp_token: str, code: str, start: bool = False) -> None:
-        """
-        Завершает кастомный login flow: отправляет код, сохраняет токен и запускает пост-логин задачи.
-
-        :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)
-        if start:
-            while True:
-                try:
-                    await self._post_login_tasks()
-                    await self._wait_forever()
-                except Exception:
-                    self.logger.exception("Error during post-login tasks")
-                finally:
-                    await self._cleanup_client()
-
-                self.logger.info("Reconnecting after post-login tasks failure")
-                await asyncio.sleep(self.reconnect_delay)
-        else:
-            self.logger.info("Login successful, token saved to database, exiting...")
-
-    async def start(self) -> None:
-        """
-        Запускает клиент, подключается к WebSocket, авторизует
-        пользователя (если нужно) и запускает фоновый цикл.
-        Теперь включает безопасный reconnect-loop, если self.reconnect=True.
-
-        :return: None
-        :rtype: None
-        """
-        self.logger.info("Client starting")
-        while not self._stop_event.is_set():
-            try:
-                await self.connect(self.user_agent)
-
-                if self.registration:
-                    if not self.first_name:
-                        raise ValueError("First name is required for registration")
-                    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)
-
-                if self._token is None:
-                    await self._login()
-
-                await self._sync(self.user_agent)
-                await self._post_login_tasks(sync=False)
-
-                wait_task = asyncio.create_task(self._wait_forever())
-                stop_task = asyncio.create_task(self._stop_event.wait())
-
-                done, pending = await asyncio.wait(
-                    [wait_task, stop_task], return_when=asyncio.FIRST_COMPLETED
-                )
-
-                for task in pending:
-                    task.cancel()
-                    with contextlib.suppress(asyncio.CancelledError):
-                        await task
-
-            except asyncio.CancelledError:
-                self.logger.info("Client task cancelled, stopping")
-                break
-            except Exception as e:
-                self.logger.exception("Client start iteration failed")
-            finally:
-                await self._cleanup_client()
-
-            if not self.reconnect or self._stop_event.is_set():
-                self.logger.info("Reconnect disabled or stop requested — exiting start()")
-                break
-
-            self.logger.info("Reconnect enabled — restarting client")
-            await asyncio.sleep(self.reconnect_delay)
-
-        self.logger.info("Client exited cleanly")
-
-
-class SocketMaxClient(SocketMixin, MaxClient):
-    allowed_device_types = {"ANDROID", "IOS", "DESKTOP"}
-
-    @staticmethod
-    def _default_headers() -> UserAgentPayload:
-        return UserAgentPayload(device_type="DESKTOP")
-
-    @override
-    async def _wait_forever(self):
-        if self._recv_task:
-            try:
-                await self._recv_task
-            except asyncio.CancelledError:
-                self.logger.debug("Socket recv_task cancelled")
-            except Exception as e:
-                self.logger.exception("Socket recv_task failed: %s", e)
-
-    @override
-    async def _cleanup_client(self):
-        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 (socket)",
-                    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(SocketNotConnectedError())
-        self._pending.clear()
-
-        if self._socket:
-            try:
-                self._socket.close()
-            except Exception:
-                self.logger.debug("Error closing socket during cleanup", exc_info=True)
-            self._socket = None
-
-        self.is_connected = False
-        self.logger.info("Client start() cleaned up (socket)")