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

pymax/protocol/tcp/payload.py

@@ -0,0 +1,127 @@
+from enum import Enum
+from typing import Any
+
+import msgpack
+
+from pymax.logging import get_logger
+
+from .compression import Lz4BlockCompression
+
+
+logger = get_logger(__name__)
+
+
+class MsgpackPayloadCodec:
+    def _to_msgpack_value(self, value: Any) -> Any:
+        if isinstance(value, Enum):
+            return value.value
+        if isinstance(value, dict):
+            return {
+                self._to_msgpack_value(k): self._to_msgpack_value(v)
+                for k, v in value.items()
+            }
+        if isinstance(value, list):
+            return [self._to_msgpack_value(item) for item in value]
+        if isinstance(value, tuple):
+            return tuple(self._to_msgpack_value(item) for item in value)
+        return value
+
+    def encode(self, payload: object) -> bytes:
+        if payload is None:
+            return b""
+        return (
+            msgpack.packb(self._to_msgpack_value(payload), use_bin_type=True)
+            or b""
+        )
+
+    def _unpack_stream(self, payload_bytes: bytes, *, raw: bool) -> list[Any]:
+        unpacker = msgpack.Unpacker(raw=raw, strict_map_key=False)
+        unpacker.feed(payload_bytes)
+        return list(unpacker)
+
+    def decode(self, payload_bytes: bytes) -> dict[Any, Any]:
+        if not payload_bytes:
+            return {}
+
+        try:
+            return msgpack.unpackb(payload_bytes, raw=False, strict_map_key=False)
+        except msgpack.exceptions.ExtraData as e:
+            if isinstance(e.unpacked, dict):
+                logger.debug(
+                    "msgpack payload has trailing data unpacked_type=%s extra_bytes=%s extra_head=%s",
+                    type(e.unpacked).__name__,
+                    len(e.extra),
+                    e.extra[:16].hex(),
+                )
+                return e.unpacked
+
+            try:
+                values = self._unpack_stream(payload_bytes, raw=False)
+            except UnicodeDecodeError:
+                values = self._unpack_stream(payload_bytes, raw=True)
+            logger.debug(
+                "msgpack payload has extra data objects=%s extra_bytes=%s",
+                [type(value).__name__ for value in values],
+                len(e.extra),
+            )
+            for value in values:
+                if isinstance(value, dict):
+                    return value
+            raise
+        except UnicodeDecodeError:
+            values = self._unpack_stream(payload_bytes, raw=True)
+            logger.debug(
+                "msgpack payload decoded with raw bytes objects=%s",
+                [type(value).__name__ for value in values],
+            )
+            for value in values:
+                if isinstance(value, dict):
+                    return value
+            raise
+
+
+class TcpPayloadDecoder:
+    def __init__(
+        self,
+        *,
+        serializer: MsgpackPayloadCodec,
+        compression: Lz4BlockCompression | None = None,
+    ) -> None:
+        self.serializer = serializer
+        self.compression = compression
+
+    def _normalize_keys(self, obj: Any) -> Any:
+        if isinstance(obj, dict):
+            return {
+                self._normalize_key(k): self._normalize_keys(v)
+                for k, v in obj.items()
+            }
+        if isinstance(obj, list):
+            return [self._normalize_keys(item) for item in obj]
+        if isinstance(obj, tuple):
+            return tuple(self._normalize_keys(item) for item in obj)
+        return obj
+
+    def _normalize_key(self, key: Any) -> Any:
+        if isinstance(key, int):
+            return str(key)
+        if isinstance(key, bytes):
+            try:
+                return key.decode("utf-8")
+            except UnicodeDecodeError:
+                return key.hex()
+        return key
+
+    def decode(self, payload_bytes: bytes, flags: int = 0) -> dict[str, Any]:
+        if not payload_bytes:
+            return {}
+
+        if flags & 0x03 and self.compression:
+            try:
+                payload_bytes = self.compression.decompress(payload_bytes)
+                logger.debug("tcp payload decompressed flags=%s", flags)
+            except ValueError:
+                logger.debug("tcp payload decompress skipped flags=%s", flags)
+
+        result = self.serializer.decode(payload_bytes)
+        return self._normalize_keys(result)

pymax/protocol/tcp/protocol.py

@@ -0,0 +1,68 @@
+from pymax.logging import get_logger
+from pymax.protocol import InboundFrame, OutboundFrame
+from pymax.protocol.base import BaseProtocol
+
+from .framing import TcpPacketFramer
+from .payload import Lz4BlockCompression, MsgpackPayloadCodec, TcpPayloadDecoder
+
+logger = get_logger(__name__)
+
+
+class TcpProtocol(BaseProtocol):
+    version = 10
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.framer = TcpPacketFramer()
+        self.serializer = MsgpackPayloadCodec()
+        self.compression = Lz4BlockCompression()
+        self.payload_decoder = TcpPayloadDecoder(
+            serializer=self.serializer, compression=self.compression
+        )
+
+    def encode(self, frame: OutboundFrame) -> bytes:
+        payload_bytes = self.serializer.encode(frame.payload) if frame.payload is not None else b""
+
+        flags = 0
+
+        # if frame.compress and payload_bytes:
+        #     payload_bytes = self.compression.compress(payload_bytes)
+        #     flags = 0x01
+
+        return self.framer.pack(
+            ver=self.version,
+            cmd=frame.cmd,
+            seq=frame.seq,
+            opcode=frame.opcode,
+            flags=flags,
+            payload_bytes=payload_bytes,
+        )
+
+    def decode(self, raw: bytes | str) -> InboundFrame:
+        if isinstance(raw, str):
+            raw = raw.encode("utf-8")
+
+        packed_packet = self.framer.unpack(raw)
+        if not packed_packet:
+            return InboundFrame(opcode=0, cmd=0, seq=None, payload=None, raw=None)
+
+        logger.debug(
+            "tcp frame decoded header ver=%s cmd=%s seq=%s opcode=%s flags=%s payload_len=%s",
+            packed_packet.header.ver,
+            packed_packet.header.cmd,
+            packed_packet.header.seq,
+            packed_packet.header.opcode,
+            packed_packet.header.flags,
+            packed_packet.header.payload_len,
+        )
+        payload = self.payload_decoder.decode(
+            packed_packet.payload_bytes, flags=packed_packet.header.flags
+        )
+
+        return InboundFrame(
+            opcode=packed_packet.header.opcode,
+            cmd=packed_packet.header.cmd,
+            seq=packed_packet.header.seq,
+            payload=payload,
+            raw=payload,
+        )

pymax/protocol/ws/__init__.py

@@ -0,0 +1 @@
+from .protocol import WsProtocol

pymax/protocol/ws/protocol.py

@@ -0,0 +1,27 @@
+import json
+
+from pydantic import ValidationError
+
+from pymax.logging import get_logger
+from pymax.protocol import InboundFrame, OutboundFrame
+from pymax.protocol.base import BaseProtocol
+
+logger = get_logger(__name__)
+
+
+class WsProtocol(BaseProtocol):
+    version = 11
+
+    def encode(self, frame: OutboundFrame) -> str:
+        return frame.model_dump_json()
+
+    def decode(self, raw: bytes | str) -> InboundFrame:
+        try:
+            data = json.loads(raw)
+            return InboundFrame.model_validate(data)
+        except json.JSONDecodeError:
+            logger.debug("failed to decode websocket frame json", exc_info=True)
+            return InboundFrame(opcode=0, cmd=0, seq=None, payload=None, raw=None)
+        except ValidationError:
+            logger.debug("failed to validate websocket frame", exc_info=True)
+            return InboundFrame(opcode=0, cmd=0, seq=None, payload=None, raw=None)

pymax/routers.py

@@ -0,0 +1,8 @@
+from typing import TypeAlias
+
+from pymax.client import Client
+from pymax.client_web import WebClient
+from pymax.dispatch.router import Router
+
+ClientRouter: TypeAlias = Router[Client]
+WebRouter: TypeAlias = Router[WebClient]

pymax/session/__init__.py

@@ -0,0 +1,3 @@
+from .models import SessionInfo
+from .protocol import StoreProtocol
+from .store import SessionStore

pymax/session/models.py

@@ -0,0 +1,11 @@
+from pydantic import BaseModel, Field
+
+from pymax.types.domain.sync import SyncState
+
+
+class SessionInfo(BaseModel):
+    token: str
+    device_id: str
+    phone: str
+    mt_instance_id: str = ""
+    sync: SyncState = Field(default_factory=SyncState)

pymax/session/protocol.py

@@ -0,0 +1,14 @@
+from typing import Protocol, runtime_checkable
+
+from .models import SessionInfo
+
+
+@runtime_checkable
+class StoreProtocol(Protocol):
+    async def save_session(self, session_info: SessionInfo) -> None: ...
+    async def update_token(self, old_token: str, new_token: str) -> None: ...
+    async def load_session(self) -> SessionInfo | None: ...
+    async def load_session_by_device_id(self, device_id: str) -> SessionInfo | None: ...
+    async def load_session_by_phone(self, phone: str) -> SessionInfo | None: ...
+    async def delete_session(self, token: str) -> None: ...
+    async def close(self) -> None: ...

pymax/session/store.py

@@ -0,0 +1,232 @@
+from pathlib import Path
+
+import aiosqlite
+
+from pymax.logging import get_logger
+from pymax.types.domain.sync import DEFAULT_CONFIG_HASH, SyncState
+
+from .models import SessionInfo
+
+logger = get_logger(__name__)
+
+SESSION_COLUMNS = """
+    token,
+    device_id,
+    phone,
+    mt_instance_id,
+    chats_sync,
+    contacts_sync,
+    drafts_sync,
+    presence_sync,
+    config_hash
+"""
+
+
+class SessionStore:
+    def __init__(self, work_dir: str, db_name: str = "session.db") -> None:
+        self.work_dir = Path(work_dir)
+        self.work_dir.mkdir(parents=True, exist_ok=True)
+        self.db_path = str(self.work_dir / db_name)
+        self.conn: aiosqlite.Connection | None = None
+        logger.debug("session store initialized db=%s", self.db_path)
+
+    async def _get_connection(self) -> aiosqlite.Connection:
+        if self.conn is None:
+            logger.debug("opening session database db=%s", self.db_path)
+            self.conn = await aiosqlite.connect(self.db_path)
+            self.conn.row_factory = aiosqlite.Row
+            await self._initialize_db(self.conn)
+        return self.conn
+
+    async def _initialize_db(self, conn: aiosqlite.Connection) -> None:
+        logger.debug("initializing session database")
+        await conn.execute(
+            """
+            CREATE TABLE IF NOT EXISTS sessions (
+                token TEXT NOT NULL PRIMARY KEY,
+                device_id TEXT NOT NULL,
+                phone TEXT NOT NULL,
+                mt_instance_id TEXT NOT NULL DEFAULT '',
+                chats_sync INTEGER NOT NULL DEFAULT -1,
+                contacts_sync INTEGER NOT NULL DEFAULT -1,
+                drafts_sync INTEGER NOT NULL DEFAULT -1,
+                presence_sync INTEGER NOT NULL DEFAULT -1,
+                config_hash TEXT NOT NULL DEFAULT ''
+            )
+            """
+        )
+        await self._ensure_column(conn, "mt_instance_id", "TEXT NOT NULL DEFAULT ''")
+        await self._ensure_column(conn, "chats_sync", "INTEGER NOT NULL DEFAULT -1")
+        await self._ensure_column(conn, "contacts_sync", "INTEGER NOT NULL DEFAULT -1")
+        await self._ensure_column(conn, "drafts_sync", "INTEGER NOT NULL DEFAULT -1")
+        await self._ensure_column(conn, "presence_sync", "INTEGER NOT NULL DEFAULT -1")
+        await self._ensure_column(conn, "config_hash", "TEXT NOT NULL DEFAULT ''")
+        await conn.execute(
+            """
+            UPDATE sessions
+            SET config_hash = ?
+            WHERE config_hash = ''
+            """,
+            (DEFAULT_CONFIG_HASH,),
+        )
+        await conn.commit()
+
+    async def _ensure_column(
+        self,
+        conn: aiosqlite.Connection,
+        name: str,
+        definition: str,
+    ) -> None:
+        async with conn.execute("PRAGMA table_info(sessions)") as cursor:
+            columns = {row["name"] for row in await cursor.fetchall()}
+
+        if name not in columns:
+            await conn.execute(f"ALTER TABLE sessions ADD COLUMN {name} {definition}")
+
+    async def save_session(self, session_info: SessionInfo) -> None:
+        conn = await self._get_connection()
+        logger.debug(
+            "saving session device_id=%s phone_set=%s mt_instance_id_set=%s",
+            session_info.device_id,
+            bool(session_info.phone),
+            bool(session_info.mt_instance_id),
+        )
+        await conn.execute(
+            """
+            INSERT OR REPLACE INTO sessions (
+                token,
+                device_id,
+                phone,
+                mt_instance_id,
+                chats_sync,
+                contacts_sync,
+                drafts_sync,
+                presence_sync,
+                config_hash
+            )
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+            """,
+            (
+                session_info.token,
+                session_info.device_id,
+                session_info.phone,
+                session_info.mt_instance_id,
+                session_info.sync.chats_sync,
+                session_info.sync.contacts_sync,
+                session_info.sync.drafts_sync,
+                session_info.sync.presence_sync,
+                session_info.sync.config_hash,
+            ),
+        )
+        await conn.commit()
+        logger.info("session saved")
+
+    async def load_session(self) -> SessionInfo | None:
+        conn = await self._get_connection()
+        logger.debug("loading first session")
+        async with conn.execute(
+            f"""
+            SELECT {SESSION_COLUMNS}
+            FROM sessions
+            LIMIT 1
+            """,
+        ) as cursor:
+            row = await cursor.fetchone()
+
+        if row is None:
+            logger.debug("session not found")
+            return None
+
+        logger.debug(
+            "session loaded device_id=%s phone_set=%s",
+            row["device_id"],
+            bool(row["phone"]),
+        )
+        return self._row_to_session(row)
+
+    async def load_session_by_device_id(self, device_id: str) -> SessionInfo | None:
+        conn = await self._get_connection()
+        logger.debug("loading session by device_id=%s", device_id)
+        async with conn.execute(
+            f"""
+            SELECT {SESSION_COLUMNS}
+            FROM sessions
+            WHERE device_id = ?
+            """,
+            (device_id,),
+        ) as cursor:
+            row = await cursor.fetchone()
+
+        if row is None:
+            logger.debug("session not found by device_id=%s", device_id)
+            return None
+
+        return self._row_to_session(row)
+
+    async def load_session_by_phone(self, phone: str) -> SessionInfo | None:
+        conn = await self._get_connection()
+        logger.debug("loading session by phone_set=%s", bool(phone))
+        async with conn.execute(
+            f"""
+            SELECT {SESSION_COLUMNS}
+            FROM sessions
+            WHERE phone = ?
+            """,
+            (phone,),
+        ) as cursor:
+            row = await cursor.fetchone()
+
+        if row is None:
+            logger.debug("session not found by phone_set=%s", bool(phone))
+            return None
+
+        return self._row_to_session(row)
+
+    async def delete_session(self, token: str) -> None:
+        conn = await self._get_connection()
+        logger.warning("deleting session token_set=%s", bool(token))
+        await conn.execute(
+            """
+            DELETE FROM sessions WHERE token = ?
+            """,
+            (token,),
+        )
+        await conn.commit()
+        logger.info("session deleted")
+
+    async def update_token(self, old_token: str, new_token: str) -> None:
+        conn = await self._get_connection()
+        logger.debug(
+            "updating session token old_token_set=%s new_token_set=%s",
+            bool(old_token),
+            bool(new_token),
+        )
+        await conn.execute(
+            """
+            UPDATE sessions SET token = ? WHERE token = ?
+            """,
+            (new_token, old_token),
+        )
+        await conn.commit()
+        logger.info("session token updated")
+
+    async def close(self) -> None:
+        if self.conn is not None:
+            logger.debug("closing session database")
+            await self.conn.close()
+            self.conn = None
+
+    def _row_to_session(self, row: aiosqlite.Row) -> SessionInfo:
+        return SessionInfo(
+            token=row["token"],
+            device_id=row["device_id"],
+            phone=row["phone"],
+            mt_instance_id=row["mt_instance_id"] or "",
+            sync=SyncState(
+                chats_sync=row["chats_sync"],
+                contacts_sync=row["contacts_sync"],
+                drafts_sync=row["drafts_sync"],
+                presence_sync=row["presence_sync"],
+                config_hash=row["config_hash"] or DEFAULT_CONFIG_HASH,
+            ),
+        )

pymax/telemetry/__init__.py

@@ -0,0 +1,3 @@
+from .service import TelemetryService
+
+__all__ = ("TelemetryService",)

pymax/telemetry/navigation.py

@@ -0,0 +1,181 @@
+from __future__ import annotations
+
+from enum import IntEnum
+from random import Random
+
+from pydantic import BaseModel
+
+
+class Screen(IntEnum):
+    BACKGROUND = 1
+    CONTACTS = 100
+    CHATS = 150
+    SEARCH = 151
+    CALLS = 300
+    CHAT = 350
+    SETTINGS = 450
+    MINIAPP = 500
+
+
+MAIN_TAB_PARAMS = {
+    "source_type": 5,
+    "source_id": 1,
+    "tab_config": 2,
+}
+
+
+class ScreenTransition(BaseModel):
+    model_config = {"frozen": True}
+
+    screen: Screen
+    weight: int
+
+
+class RouteProfile(BaseModel):
+    model_config = {"frozen": True}
+
+    steps: int
+    min_pause: float
+    max_pause: float
+    long_pause_chance: float
+    min_long_pause: float
+    max_long_pause: float
+    back_chance: float
+
+    def pause(self, rng: Random) -> float:
+        if rng.random() < self.long_pause_chance:
+            return rng.uniform(self.min_long_pause, self.max_long_pause)
+        return rng.uniform(self.min_pause, self.max_pause)
+
+
+class NavigationRules(BaseModel):
+    model_config = {"frozen": True}
+
+    profiles: dict[str, RouteProfile]
+    graph: dict[Screen, tuple[ScreenTransition, ...]]
+
+    def choose_profile(self, rng: Random) -> RouteProfile:
+        name = rng.choice(tuple(self.profiles))
+        return self.profiles[name]
+
+
+DEFAULT_RULES = NavigationRules(
+    profiles={
+        "quick": RouteProfile(
+            steps=2,
+            min_pause=35.0,
+            max_pause=95.0,
+            long_pause_chance=0.05,
+            min_long_pause=180.0,
+            max_long_pause=420.0,
+            back_chance=0.30,
+        ),
+        "browse": RouteProfile(
+            steps=4,
+            min_pause=70.0,
+            max_pause=210.0,
+            long_pause_chance=0.12,
+            min_long_pause=240.0,
+            max_long_pause=720.0,
+            back_chance=0.22,
+        ),
+        "read": RouteProfile(
+            steps=3,
+            min_pause=140.0,
+            max_pause=360.0,
+            long_pause_chance=0.25,
+            min_long_pause=420.0,
+            max_long_pause=1200.0,
+            back_chance=0.18,
+        ),
+    },
+    graph={
+        Screen.BACKGROUND: (
+            ScreenTransition(screen=Screen.CHATS, weight=10),
+            ScreenTransition(screen=Screen.SETTINGS, weight=1),
+        ),
+        Screen.CHATS: (
+            ScreenTransition(screen=Screen.CHAT, weight=7),
+            ScreenTransition(screen=Screen.CONTACTS, weight=2),
+            ScreenTransition(screen=Screen.SEARCH, weight=2),
+            ScreenTransition(screen=Screen.CALLS, weight=1),
+            ScreenTransition(screen=Screen.SETTINGS, weight=1),
+            ScreenTransition(screen=Screen.CHATS, weight=2),
+        ),
+        Screen.CHAT: (
+            ScreenTransition(screen=Screen.CHATS, weight=8),
+            ScreenTransition(screen=Screen.CHAT, weight=2),
+            ScreenTransition(screen=Screen.SETTINGS, weight=1),
+        ),
+        Screen.CONTACTS: (
+            ScreenTransition(screen=Screen.CHATS, weight=6),
+            ScreenTransition(screen=Screen.CHAT, weight=2),
+            ScreenTransition(screen=Screen.SEARCH, weight=1),
+        ),
+        Screen.SEARCH: (
+            ScreenTransition(screen=Screen.CHATS, weight=5),
+            ScreenTransition(screen=Screen.CHAT, weight=3),
+            ScreenTransition(screen=Screen.CONTACTS, weight=1),
+        ),
+        Screen.CALLS: (
+            ScreenTransition(screen=Screen.CHATS, weight=5),
+            ScreenTransition(screen=Screen.CONTACTS, weight=2),
+            ScreenTransition(screen=Screen.SETTINGS, weight=2),
+        ),
+        Screen.SETTINGS: (
+            ScreenTransition(screen=Screen.CHATS, weight=7),
+            ScreenTransition(screen=Screen.CONTACTS, weight=2),
+            ScreenTransition(screen=Screen.CALLS, weight=2),
+            ScreenTransition(screen=Screen.MINIAPP, weight=1),
+        ),
+        Screen.MINIAPP: (
+            ScreenTransition(screen=Screen.SETTINGS, weight=3),
+            ScreenTransition(screen=Screen.CHATS, weight=6),
+        ),
+    },
+)
+
+
+class NavigationPlanner:
+    def __init__(
+        self,
+        rng: Random,
+        rules: NavigationRules = DEFAULT_RULES,
+    ) -> None:
+        self.rng = rng
+        self.rules = rules
+        self.current_screen = Screen.BACKGROUND
+        self.history: list[Screen] = []
+
+    def new_profile(self) -> RouteProfile:
+        return self.rules.choose_profile(self.rng)
+
+    def next_screen(self, profile: RouteProfile) -> Screen:
+        if self.history and self.rng.random() < profile.back_chance:
+            self.current_screen = self.history.pop()
+            return self.current_screen
+
+        next_screen = self._weighted_choice(self.rules.graph[self.current_screen])
+        if next_screen != self.current_screen:
+            self.history.append(self.current_screen)
+            if len(self.history) > 4:
+                del self.history[0]
+        self.current_screen = next_screen
+        return next_screen
+
+    def reset_to_background(self) -> None:
+        self.current_screen = Screen.BACKGROUND
+        self.history.clear()
+
+    def _weighted_choice(
+        self,
+        transitions: tuple[ScreenTransition, ...],
+    ) -> Screen:
+        total = sum(item.weight for item in transitions)
+        point = self.rng.randint(1, total)
+        current = 0
+        for item in transitions:
+            current += item.weight
+            if point <= current:
+                return item.screen
+        return transitions[-1].screen