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

pymax/config.py

@@ -0,0 +1,215 @@
+from random import choice, randint
+from uuid import uuid4
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from pymax.api.session.enums import DeviceType
+from pymax.api.session.payloads import (
+    DEFAULT_WEB_HEADER_USER_AGENT,
+    MobileUserAgentPayload,
+)
+from pymax.session import SessionStore, StoreProtocol
+from pymax.types.domain.sync import SyncOverrides
+
+APP_VERSIONS: tuple[tuple[str, int], ...] = (
+    ("26.14.1", 6686),
+    ("26.14.0", 6685),
+    ("26.13.0", 6683),
+    ("26.12.2", 6681),
+    ("26.12.1", 6679),
+    ("26.12.0", 6678),
+    ("26.11.3", 6680),
+    ("26.11.2", 6669),
+    ("26.11.1", 6665),
+    ("26.11.0", 6661),
+)
+ANDROID_DEVICES: tuple[tuple[str, str, str, str], ...] = (
+    ("Samsung SM-A525F", "Android 13", "405dpi 405dpi 1080x2400", "arm64-v8a"),
+    ("Samsung SM-A536B", "Android 14", "405dpi 405dpi 1080x2400", "arm64-v8a"),
+    ("Samsung SM-A546E", "Android 14", "405dpi 405dpi 1080x2340", "arm64-v8a"),
+    ("Samsung SM-G991B", "Android 14", "421dpi 421dpi 1080x2400", "arm64-v8a"),
+    ("Samsung SM-G998B", "Android 13", "515dpi 515dpi 1440x3200", "arm64-v8a"),
+    ("Samsung SM-S901B", "Android 14", "425dpi 425dpi 1080x2340", "arm64-v8a"),
+    ("Samsung SM-S911B", "Android 14", "425dpi 425dpi 1080x2340", "arm64-v8a"),
+    ("Xiaomi 2109119DG", "Android 13", "395dpi 395dpi 1080x2400", "arm64-v8a"),
+    ("Xiaomi 2201117TG", "Android 13", "395dpi 395dpi 1080x2400", "arm64-v8a"),
+    ("Xiaomi 2201123G", "Android 14", "526dpi 526dpi 1440x3200", "arm64-v8a"),
+    ("Xiaomi 2210132G", "Android 14", "446dpi 446dpi 1220x2712", "arm64-v8a"),
+    ("Xiaomi 23049PCD8G", "Android 14", "446dpi 446dpi 1220x2712", "arm64-v8a"),
+    ("Redmi 2201116TG", "Android 13", "395dpi 395dpi 1080x2400", "arm64-v8a"),
+    ("Redmi 22101316G", "Android 13", "395dpi 395dpi 1080x2400", "arm64-v8a"),
+    ("Redmi 23021RAA2Y", "Android 14", "395dpi 395dpi 1080x2400", "arm64-v8a"),
+    ("POCO 22011211G", "Android 13", "395dpi 395dpi 1080x2400", "arm64-v8a"),
+    ("POCO 23049PCD8G", "Android 14", "446dpi 446dpi 1220x2712", "arm64-v8a"),
+    ("Pixel 6", "Android 14", "411dpi 411dpi 1080x2400", "arm64-v8a"),
+    ("Pixel 6a", "Android 14", "429dpi 429dpi 1080x2400", "arm64-v8a"),
+    ("Pixel 7", "Android 14", "416dpi 416dpi 1080x2400", "arm64-v8a"),
+    ("Pixel 7 Pro", "Android 14", "512dpi 512dpi 1440x3120", "arm64-v8a"),
+    ("Pixel 8", "Android 14", "428dpi 428dpi 1080x2400", "arm64-v8a"),
+    ("OnePlus NE2213", "Android 14", "525dpi 525dpi 1440x3216", "arm64-v8a"),
+    ("OnePlus CPH2449", "Android 14", "451dpi 451dpi 1240x2772", "arm64-v8a"),
+    ("realme RMX3085", "Android 13", "409dpi 409dpi 1080x2400", "arm64-v8a"),
+    ("realme RMX3370", "Android 13", "409dpi 409dpi 1080x2400", "arm64-v8a"),
+    ("realme RMX3630", "Android 13", "400dpi 400dpi 1080x2412", "arm64-v8a"),
+    ("HUAWEI ELS-NX9", "Android 12", "441dpi 441dpi 1080x2340", "arm64-v8a"),
+    ("HUAWEI VOG-L29", "Android 12", "398dpi 398dpi 1080x2340", "arm64-v8a"),
+    ("HONOR RMO-NX1", "Android 13", "391dpi 391dpi 1080x2388", "arm64-v8a"),
+    ("HONOR REA-NX9", "Android 13", "435dpi 435dpi 1200x2664", "arm64-v8a"),
+)
+LOCALE_TIMEZONES: tuple[tuple[str, str], ...] = (
+    ("ru", "Europe/Moscow"),
+    ("ru", "Europe/Kaliningrad"),
+    ("ru", "Europe/Samara"),
+    ("ru", "Asia/Yekaterinburg"),
+    ("ru", "Asia/Omsk"),
+    ("ru", "Asia/Novosibirsk"),
+    ("ru", "Asia/Krasnoyarsk"),
+    ("ru", "Asia/Irkutsk"),
+    ("ru", "Asia/Yakutsk"),
+    ("ru", "Asia/Vladivostok"),
+)
+WEB_APP_VERSION = "26.5.5"
+WEB_SCREEN = "1080x1920 1.0x"
+
+
+class DeviceConfig(BaseModel):
+    mt_instance_id: str
+    user_agent: MobileUserAgentPayload
+    device_id: str = Field(default_factory=lambda: str(uuid4()))
+    client_session_id: int = Field(default_factory=lambda: randint(1, 70))
+
+
+class ClientConfig(BaseModel):
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    phone: str | None = None
+    work_dir: str = "."
+    session_name: str = "session.db"
+    device: DeviceConfig
+    token: str | None = None
+
+    host: str = "api.oneme.ru"
+    port: int = 443
+    use_ssl: bool = True
+
+    protocol_version: int = 10
+    request_timeout: float = 30.0
+    log_level: str = "INFO"
+    telemetry: bool = False
+
+    store: StoreProtocol | None = None
+
+    sync: SyncOverrides = Field(default_factory=SyncOverrides)
+
+    def ensure_config(self) -> None:
+        if not self.phone:
+            raise ValueError("Phone must be provided when no saved session exists.")
+
+
+class ExtraConfig(BaseModel):
+    """Дополнительные настройки ``Client`` и ``WebClient``.
+
+    Используйте ``ExtraConfig`` для token-логина, debug-логов, reconnect,
+    пользовательского device/user-agent и переопределения sync-state.
+
+    Args:
+        token: Готовый token для создания сессии без SMS/QR.
+        host: TCP host Max API.
+        port: TCP port Max API.
+        url: WebSocket URL для ``WebClient``.
+        use_ssl: Использовать TLS для TCP.
+        proxy: Proxy URL для TCP- или WebSocket-транспорта.
+        reconnect: Переподключаться после сетевых ошибок.
+        reconnect_delay: Пауза перед reconnect.
+        device_id: Явный device ID. Если не передан, генерируется UUID.
+        device_type: Тип устройства для mobile user-agent.
+        user_agent: Полностью заданный user-agent payload.
+        mt_instance_id: Instance ID устройства.
+        request_timeout: Timeout API-запросов в секундах.
+        log_level: Уровень логов ``pymax``.
+        telemetry: Отправлять telemetry-события Max.
+        sync: Переопределения sync-маркеров для login.
+
+    Example:
+        .. code-block:: python
+
+           from pymax import Client, ExtraConfig, SyncOverrides
+
+           client = Client(
+               phone="+79990000000",
+               extra_config=ExtraConfig(
+                   log_level="DEBUG",
+                   reconnect=False,
+                   sync=SyncOverrides(chats_sync=-1),
+               ),
+           )
+    """
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    token: str | None = None
+
+    host: str = "api.oneme.ru"
+    port: int = 443
+    url: str = "wss://ws-api.oneme.ru/websocket"
+    use_ssl: bool = True
+    proxy: str | None = None
+    reconnect: bool = True
+    reconnect_delay: float = 1.0
+
+    device_id: str | None = None
+    device_type: DeviceType = DeviceType.ANDROID
+    user_agent: MobileUserAgentPayload | None = None
+    mt_instance_id: str = Field(default_factory=lambda: str(uuid4()))
+
+    request_timeout: float = 30.0
+    log_level: str = "INFO"
+    telemetry: bool = True
+
+    store: StoreProtocol | None = None
+
+    sync: SyncOverrides = Field(default_factory=SyncOverrides)
+
+    def generate_user_agent(self) -> MobileUserAgentPayload:
+        """Создает mobile user-agent payload для TCP-клиента.
+
+        Returns:
+            Случайная, но правдоподобная конфигурация Android-клиента Max.
+        """
+        app_version, build_number = choice(APP_VERSIONS)
+        device_name, os_version, screen, arch = choice(ANDROID_DEVICES)
+        locale, timezone = choice(LOCALE_TIMEZONES)
+
+        return MobileUserAgentPayload(
+            device_type=self.device_type,
+            app_version=app_version,
+            os_version=os_version,
+            timezone=timezone,
+            screen=screen,
+            push_device_type="GCM",
+            arch=arch,
+            locale=locale,
+            build_number=build_number,
+            device_name=device_name,
+            device_locale=locale,
+        )
+
+    def generate_web_user_agent(self) -> MobileUserAgentPayload:
+        """Создает web user-agent payload для ``WebClient``.
+
+        Returns:
+            Конфигурация web-клиента Max с ``DeviceType.WEB``.
+        """
+        locale, timezone = choice(LOCALE_TIMEZONES)
+
+        return MobileUserAgentPayload(
+            device_type=DeviceType.WEB,
+            app_version=WEB_APP_VERSION,
+            os_version="Linux",
+            timezone=timezone,
+            screen=WEB_SCREEN,
+            locale=locale,
+            device_name="Chrome",
+            device_locale=locale,
+            header_user_agent=DEFAULT_WEB_HEADER_USER_AGENT,
+        )

pymax/connection/__init__.py

@@ -0,0 +1 @@
+from .connection import ConnectionManager

pymax/connection/connection.py

@@ -0,0 +1,205 @@
+import asyncio
+from collections.abc import Awaitable, Callable
+from contextlib import suppress
+
+from pymax.logging import get_logger
+from pymax.protocol import Command, InboundFrame, OutboundFrame
+from pymax.protocol.base import BaseProtocol
+from pymax.transport.base import Transport
+
+from .pending import PendingRequests
+from .readers.base import BaseReader
+
+logger = get_logger(__name__)
+
+
+class ConnectionManager:
+    def __init__(
+        self,
+        reader: BaseReader,
+        transport: Transport,
+        protocol: BaseProtocol,
+        on_event: Callable[[InboundFrame], Awaitable[None]] | None = None,
+    ) -> None:
+        self.reader = reader
+        self.transport = transport
+        self.protocol = protocol
+        self.on_event = on_event
+
+        self.requests = PendingRequests()
+
+        self._is_open = False
+        self._connection_lost = False
+        self._seq = -1
+
+        self._recv_task: asyncio.Task[None] | None = None
+        self._event_tasks: set[asyncio.Task[None]] = set()
+
+    async def open(self) -> None:
+        if self._is_open:
+            logger.debug("connection open skipped: already open")
+            return
+
+        logger.info("opening connection")
+        await self.transport.connect()
+        self._is_open = True
+        self._connection_lost = False
+
+        self._recv_task = asyncio.create_task(self._recv_loop())
+        logger.debug("receive loop started")
+
+    async def close(self) -> None:
+        if not self._is_open and not self._recv_task:
+            logger.debug("connection close skipped: already closed")
+            return
+
+        logger.info("closing connection")
+        if self._recv_task:
+            if not self._recv_task.done():
+                self._recv_task.cancel()
+            with suppress(asyncio.CancelledError, Exception):
+                await self._recv_task
+            logger.debug("receive loop stopped")
+            self._recv_task = None
+
+        for task in tuple(self._event_tasks):
+            if not task.done():
+                task.cancel()
+        for task in tuple(self._event_tasks):
+            with suppress(asyncio.CancelledError, Exception):
+                await task
+        self._event_tasks.clear()
+
+        self.requests.cancel_all()
+        await self.transport.close()
+        self._is_open = False
+        logger.info("connection closed")
+
+    async def fail(self, exc: Exception | None = None) -> None:
+        logger.warning("marking connection as failed")
+        self._connection_lost = True
+        self.requests.cancel_all(exc=exc)
+        await self.transport.close()
+
+    async def send(self, frame: OutboundFrame) -> None:
+        if not self._is_open:
+            logger.warning("send requested while connection is closed")
+            raise ConnectionError("Connection is not open")
+
+        data = self.protocol.encode(frame)
+        logger.debug(
+            "sending frame opcode=%s cmd=%s seq=%s bytes=%s",
+            frame.opcode,
+            frame.cmd,
+            frame.seq,
+            len(data),
+        )
+        await self.transport.send(data)
+
+    async def request(
+        self,
+        frame: OutboundFrame,
+        *,
+        timeout: float | None = None,
+    ) -> InboundFrame:
+        future = self.requests.create(frame.seq)
+        try:
+            raw = self.protocol.encode(frame)
+            logger.debug(
+                "sending request opcode=%s cmd=%s seq=%s bytes=%s timeout=%s",
+                frame.opcode,
+                frame.cmd,
+                frame.seq,
+                len(raw),
+                timeout,
+            )
+            await self.transport.send(raw)
+            return await asyncio.wait_for(future, timeout)
+        except Exception as e:
+            logger.exception(
+                "request failed seq=%s opcode=%s",
+                frame.seq,
+                frame.opcode,
+            )
+            self.requests.reject(frame.seq, e)
+            raise
+
+    async def wait_closed(self) -> None:
+        if not self._recv_task:
+            return
+
+        await self._recv_task
+        if self._connection_lost:
+            raise ConnectionError("Connection lost")
+
+    async def _recv_loop(self) -> None:
+        logger.debug("receive loop entered")
+        try:
+            while True:
+                frame = await self.reader.read()
+                if frame is None:
+                    logger.warning("reader returned empty frame")
+                    continue
+
+                logger.debug("received raw frame bytes=%s", len(frame))
+                model = self.protocol.decode(frame)
+                await self._handle_inbound(model)
+
+        except EOFError as e:
+            logger.warning("connection closed by server")
+            self.requests.cancel_all(exc=ConnectionError("Connection closed by the server"))
+            self._connection_lost = True
+        except TimeoutError as e:
+            logger.exception("connection timed out")
+            self.requests.cancel_all(exc=ConnectionError("Connection timed out"))
+            self._connection_lost = True
+            raise e
+        except Exception as e:
+            logger.exception("connection receive loop failed")
+            self.requests.cancel_all(exc=ConnectionError(f"Connection error: {e}"))
+            self._connection_lost = True
+            raise e
+
+    async def _handle_inbound(self, frame: InboundFrame) -> None:
+        logger.debug(
+            "inbound frame opcode=%s cmd=%s seq=%s",
+            frame.opcode,
+            frame.cmd,
+            frame.seq,
+        )
+
+        if (
+            frame.cmd in (Command.RESPONSE, Command.ERROR)
+            and frame.seq is not None
+            and self.requests.resolve(frame.seq, frame)
+        ):
+            logger.debug("resolved pending request seq=%s", frame.seq)
+
+        if self.on_event:
+            task = asyncio.create_task(self._dispatch_event(frame))
+            self._event_tasks.add(task)
+            task.add_done_callback(self._event_tasks.discard)
+        else:
+            logger.debug("inbound event dropped: no event handler")
+
+    async def _dispatch_event(self, frame: InboundFrame) -> None:
+        if not self.on_event:
+            return
+
+        try:
+            await self.on_event(frame)
+        except Exception:
+            logger.exception(
+                "inbound event handler failed opcode=%s cmd=%s seq=%s",
+                frame.opcode,
+                frame.cmd,
+                frame.seq,
+            )
+
+    def next_seq(self) -> int:
+        self._seq = (self._seq + 1) % 0xFFFFFFFF
+        return self._seq
+
+    @property
+    def is_open(self) -> bool:
+        return self._is_open

pymax/connection/pending.py

@@ -0,0 +1,46 @@
+import asyncio
+from asyncio import Future
+
+from pymax.protocol import InboundFrame
+
+
+class PendingRequests:
+    def __init__(self) -> None:
+        self._pending: dict[int, Future[InboundFrame]] = {}
+
+    def create(self, seq: int) -> Future[InboundFrame]:
+        future = asyncio.get_running_loop().create_future()
+        self._pending[seq] = future
+        return future
+
+    def resolve(self, seq: int, frame: InboundFrame) -> bool:
+        future = self._pending.pop(seq, None)
+        if future is None:
+            return False
+
+        if not future.done():
+            future.set_result(frame)
+        return True
+
+    def reject(self, seq: int, exc: Exception) -> bool:
+        future = self._pending.pop(seq, None)
+        if future is None:
+            return False
+
+        if not future.done():
+            future.set_exception(exc)
+        return True
+
+    def discard(self, seq: int) -> None:
+        future = self._pending.pop(seq, None)
+        if future and not future.done():
+            future.cancel()
+
+    def cancel_all(self, exc: Exception | None = None) -> None:
+        for future in self._pending.values():
+            if not future.done():
+                if exc:
+                    future.set_exception(exc)
+                else:
+                    future.cancel()
+        self._pending.clear()

pymax/connection/readers/__init__.py

@@ -0,0 +1,2 @@
+from .tcp import TCPReader
+from .ws import WSReader

pymax/connection/readers/base.py

@@ -0,0 +1,6 @@
+from abc import ABC, abstractmethod
+
+
+class BaseReader(ABC):
+    @abstractmethod
+    async def read(self) -> bytes | str: ...

pymax/connection/readers/tcp.py

@@ -0,0 +1,29 @@
+from pymax.logging import get_logger
+from pymax.protocol.tcp.framing import TcpPacketFramer
+from pymax.transport.tcp import TCPTransport
+
+from .base import BaseReader
+
+logger = get_logger(__name__)
+
+
+class TCPReader(BaseReader):
+    def __init__(self, transport: TCPTransport, framer: TcpPacketFramer) -> None:
+        super().__init__()
+        self.transport = transport
+        self.framer = framer
+
+    async def read(self) -> bytes:
+        header_bytes = await self.transport.recv(10)
+        payload_len = self.framer.unpack_header(header_bytes)
+        if payload_len is None:
+            logger.warning(
+                "failed to unpack tcp packet header bytes=%s",
+                len(header_bytes),
+            )
+            raise ValueError("Failed to unpack TCP packet header")
+
+        logger.debug("tcp packet header read payload_len=%s", payload_len)
+        payload_bytes = await self.transport.recv(payload_len)
+        logger.debug("tcp packet payload read bytes=%s", len(payload_bytes))
+        return header_bytes + payload_bytes

pymax/connection/readers/ws.py

@@ -0,0 +1,14 @@
+from pymax.logging import get_logger
+from pymax.transport.websocket import WebSocketTransport
+
+from .base import BaseReader
+
+logger = get_logger(__name__)
+
+
+class WSReader(BaseReader):
+    def __init__(self, transport: WebSocketTransport) -> None:
+        self.transport = transport
+
+    async def read(self) -> bytes | str:
+        return await self.transport.recv()

pymax/dispatch/__init__.py

@@ -0,0 +1,10 @@
+from .dispatcher import Dispatcher
+from .enums import EventType
+from .router import ClientRouter, Router
+
+__all__ = (
+    "ClientRouter",
+    "Dispatcher",
+    "EventType",
+    "Router",
+)