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

pymax/telemetry/payloads.py

@@ -0,0 +1,142 @@
+from __future__ import annotations
+
+import time
+from random import Random
+from typing import Any
+
+from pydantic import Field
+
+from pymax.api.models import CamelModel
+
+
+class TelemetryEvent(CamelModel):
+    time: int
+    user_id: int
+    type: str
+    event: str
+    params: dict[str, Any] = Field(default_factory=dict)
+    session_id: int
+
+
+class TelemetryPayload(CamelModel):
+    events: list[TelemetryEvent]
+
+
+class TelemetryPayloadBuilder:
+    def __init__(self, rng: Random) -> None:
+        self.rng = rng
+
+    def login(self, user_id: int, session_id: int) -> TelemetryEvent:
+        return TelemetryEvent(
+            time=now_ms(),
+            user_id=user_id,
+            type="PERF",
+            event="login",
+            params={
+                "properties": {
+                    "connection_type": 2,
+                    "vpn": 0,
+                    "class": 2,
+                    "background": 1,
+                    "warm_start": 1,
+                },
+                "errorType": 100,
+            },
+            session_id=session_id,
+        )
+
+    def navigation(
+        self,
+        *,
+        user_id: int,
+        session_id: int,
+        screen_from: int,
+        screen_to: int,
+        prev_time: int,
+        action_id: int,
+        extra_params: dict[str, int],
+    ) -> TelemetryEvent:
+        params: dict[str, Any] = {
+            "prev_time": prev_time,
+            "screen_to": screen_to,
+            "action_id": action_id,
+            "screen_from": screen_from,
+        }
+        params.update(extra_params)
+        return TelemetryEvent(
+            time=now_ms(),
+            user_id=user_id,
+            type="NAV",
+            event="GO",
+            params=params,
+            session_id=session_id,
+        )
+
+    def open_chat(self, user_id: int, session_id: int) -> TelemetryEvent:
+        messages = self.rng.randint(60, 240)
+        render = self.rng.randint(50, 260)
+        duration = messages + render
+        return TelemetryEvent(
+            time=now_ms(),
+            user_id=user_id,
+            type="PERF",
+            event="open_chat_to_render",
+            params={
+                "spans": [
+                    {
+                        "duration": duration,
+                        "name": "open_chat_to_render",
+                    },
+                    {
+                        "duration": messages,
+                        "name": "messages_list_created",
+                    },
+                    {
+                        "duration": render,
+                        "name": "messages_render",
+                    },
+                ],
+                "properties": {
+                    "class": 2,
+                    "warm": 1,
+                    "flow": 1,
+                },
+            },
+            session_id=session_id,
+        )
+
+    def open_chats(self, user_id: int, session_id: int) -> TelemetryEvent:
+        created = self.rng.randint(50, 230)
+        rendered = self.rng.randint(180, 650)
+        duration = created + rendered
+        return TelemetryEvent(
+            time=now_ms(),
+            user_id=user_id,
+            type="PERF",
+            event="open_chats_to_render",
+            params={
+                "spans": [
+                    {
+                        "duration": duration,
+                        "name": "open_chats_to_render",
+                    },
+                    {
+                        "duration": created,
+                        "name": "chats_tab_created",
+                    },
+                    {
+                        "duration": rendered,
+                        "name": "chat_list_render",
+                    },
+                ],
+                "properties": {"class": 2},
+            },
+            session_id=session_id,
+        )
+
+    def to_payload(self, events: list[TelemetryEvent]) -> dict:
+        return TelemetryPayload(events=events).to_payload()
+
+
+def now_ms() -> int:
+    return int(time.time() * 1000)

pymax/telemetry/service.py

@@ -0,0 +1,225 @@
+from __future__ import annotations
+
+import asyncio
+from contextlib import suppress
+from random import Random
+from typing import TYPE_CHECKING
+
+from pydantic import BaseModel
+
+from pymax.logging import get_logger
+from pymax.protocol import Opcode
+
+from .navigation import (
+    MAIN_TAB_PARAMS,
+    NavigationPlanner,
+    RouteProfile,
+    Screen,
+)
+from .payloads import TelemetryEvent, TelemetryPayloadBuilder, now_ms
+
+if TYPE_CHECKING:
+    from pymax.app import App
+    from pymax.types.domain import Chat
+
+
+logger = get_logger(__name__)
+
+
+class TelemetryTiming(BaseModel):
+    model_config = {"frozen": True}
+
+    startup_delay: tuple[float, float] = (15.0, 90.0)
+    session_idle_delay: tuple[float, float] = (900.0, 2700.0)
+    render_delay: tuple[float, float] = (0.15, 1.2)
+    return_delay: tuple[float, float] = (12.0, 45.0)
+    return_to_background_chance: float = 0.40
+    open_chats_render_chance: float = 0.20
+
+
+DEFAULT_TIMING = TelemetryTiming()
+
+
+class TelemetryService:
+    def __init__(self, app: App) -> None:
+        self.app = app
+        self._rng = Random()
+        self._timing = DEFAULT_TIMING
+        self._planner = NavigationPlanner(self._rng)
+        self._payloads = TelemetryPayloadBuilder(self._rng)
+        self._task: asyncio.Task[None] | None = None
+        self._action_id = 0
+        self._session_id = app.config.device.client_session_id
+        self._last_nav_time = now_ms()
+
+    def start(self) -> None:
+        if self._task and not self._task.done():
+            logger.debug("telemetry start skipped: already running")
+            return
+
+        if not self._ready:
+            logger.debug("telemetry start skipped: app is not ready")
+            return
+
+        self._task = asyncio.create_task(
+            self._run(),
+            name="pymax.telemetry",
+        )
+        logger.debug("telemetry started")
+
+    async def stop(self) -> None:
+        if not self._task:
+            return
+
+        task = self._task
+        self._task = None
+        if not task.done():
+            task.cancel()
+        with suppress(asyncio.CancelledError):
+            await task
+        logger.debug("telemetry stopped")
+
+    async def _run(self) -> None:
+        try:
+            await asyncio.sleep(self._between(self._timing.startup_delay))
+            await self._send_events(
+                [self._payloads.login(self._user_id, self._session_id)]
+            )
+
+            while True:
+                self._session_id += 1
+                events = await self._collect_session_events(self._planner.new_profile())
+                await self._send_events(events)
+                self._planner.reset_to_background()
+                await asyncio.sleep(self._between(self._timing.session_idle_delay))
+
+        except asyncio.CancelledError:
+            raise
+        except Exception:
+            logger.debug("telemetry loop stopped by error", exc_info=True)
+        finally:
+            self._task = None
+
+    async def _collect_session_events(
+        self,
+        profile: RouteProfile,
+    ) -> list[TelemetryEvent]:
+        events: list[TelemetryEvent] = []
+
+        for _ in range(profile.steps):
+            await asyncio.sleep(profile.pause(self._rng))
+            if not self._ready:
+                return events
+
+            screen_from = self._planner.current_screen
+            screen_to = self._planner.next_screen(profile)
+            events.append(self._nav_event(screen_from, screen_to))
+
+            render_events = await self._render_events(screen_to)
+            events.extend(render_events)
+
+        if (
+            self._planner.current_screen != Screen.BACKGROUND
+            and self._rng.random() < self._timing.return_to_background_chance
+        ):
+            await asyncio.sleep(self._between(self._timing.return_delay))
+            screen_from = self._planner.current_screen
+            self._planner.reset_to_background()
+            events.append(self._nav_event(screen_from, Screen.BACKGROUND))
+
+        return events
+
+    async def _render_events(self, screen_to: Screen) -> list[TelemetryEvent]:
+        if screen_to == Screen.CHAT:
+            await asyncio.sleep(self._between(self._timing.render_delay))
+            return [self._payloads.open_chat(self._user_id, self._session_id)]
+
+        if (
+            screen_to == Screen.CHATS
+            and self._rng.random() < self._timing.open_chats_render_chance
+        ):
+            await asyncio.sleep(self._between(self._timing.render_delay))
+            return [self._payloads.open_chats(self._user_id, self._session_id)]
+
+        return []
+
+    async def _send_events(self, events: list[TelemetryEvent]) -> None:
+        if not events or not self._ready:
+            return
+
+        try:
+            await self.app.invoke(
+                Opcode.LOG,
+                self._payloads.to_payload(events),
+                timeout=self.app.config.request_timeout,
+            )
+            logger.debug("telemetry sent events=%s", len(events))
+        except asyncio.CancelledError:
+            raise
+        except Exception:
+            logger.debug("telemetry send failed", exc_info=True)
+
+    def _nav_event(self, screen_from: Screen, screen_to: Screen) -> TelemetryEvent:
+        event = self._payloads.navigation(
+            user_id=self._user_id,
+            session_id=self._session_id,
+            screen_from=int(screen_from),
+            screen_to=int(screen_to),
+            prev_time=self._last_nav_time,
+            action_id=self._next_action_id(),
+            extra_params=self._source_params(screen_to),
+        )
+        self._last_nav_time = event.time
+        return event
+
+    def _source_params(self, screen_to: Screen) -> dict[str, int]:
+        if screen_to == Screen.CHATS:
+            return dict(MAIN_TAB_PARAMS)
+
+        if screen_to != Screen.CHAT:
+            return {}
+
+        chat = self._pick_chat()
+        if chat is None:
+            return {
+                "source_type": 1,
+                "source_id": self._user_id,
+            }
+
+        return {
+            "source_type": _chat_source_type(chat),
+            "source_id": chat.id,
+        }
+
+    def _pick_chat(self) -> Chat | None:
+        chats = self.app.chats or []
+        if not chats:
+            return None
+        return self._rng.choice(chats)
+
+    def _next_action_id(self) -> int:
+        self._action_id = (self._action_id + 1) % 0xFFFFFFFF
+        return self._action_id
+
+    def _between(self, value: tuple[float, float]) -> float:
+        return self._rng.uniform(*value)
+
+    @property
+    def _ready(self) -> bool:
+        return (
+            self.app.started
+            and self.app.me is not None
+            and self.app.connection.is_open
+        )
+
+    @property
+    def _user_id(self) -> int:
+        if self.app.me is None:
+            raise RuntimeError("Telemetry requires authenticated profile")
+        return self.app.me.contact.id
+
+
+def _chat_source_type(chat: Chat) -> int:
+    if str(chat.type) == "ChatType.DIALOG" or chat.type == "DIALOG":
+        return 1
+    return 2

pymax/transport/base.py

@@ -0,0 +1,14 @@
+from typing import Protocol, overload
+
+
+class Transport(Protocol):
+    async def connect(self) -> None: ...
+    async def close(self) -> None: ...
+    async def send(self, data: bytes | str) -> None: ...
+    @overload
+    async def recv(self) -> bytes | str: ...
+    @overload
+    async def recv(self, n: int) -> bytes | str: ...
+    async def recv(self, n: int | None = None) -> bytes | str: ...
+    @property
+    def connected(self) -> bool: ...

pymax/transport/tcp.py

@@ -0,0 +1,93 @@
+import asyncio
+
+from python_socks.async_.asyncio import Proxy
+
+from pymax.logging import get_logger
+
+from .base import Transport
+
+logger = get_logger(__name__)
+
+
+class TCPTransport(Transport):
+    def __init__(self, host: str, port: int, proxy: str | None, use_ssl: bool = True) -> None:
+        self._host = host
+        self._port = port
+        self._proxy = proxy
+        self._use_ssl = use_ssl
+        self._reader = None
+        self._writer = None
+
+    async def connect(self) -> None:
+        logger.debug(
+            "tcp connect host=%s port=%s ssl=%s",
+            self._host,
+            self._port,
+            self._use_ssl,
+        )
+        if self._proxy:
+            logger.debug("tcp connecting via proxy %s", self._proxy)
+            proxy = Proxy.from_url(self._proxy)
+            sock = await proxy.connect(
+                dest_host=self._host,
+                dest_port=self._port,
+                ssl=self._use_ssl,
+            )
+            self._reader, self._writer = await asyncio.open_connection(
+                sock=sock, ssl=self._use_ssl
+            )
+            logger.info(
+                "tcp connected via proxy %s host=%s port=%s ssl=%s",
+                self._proxy,
+                self._host,
+                self._port,
+                self._use_ssl,
+            )
+        else:
+            self._reader, self._writer = await asyncio.open_connection(
+                self._host,
+                self._port,
+                ssl=self._use_ssl,
+            )
+        logger.info(
+            "tcp connected host=%s port=%s ssl=%s",
+            self._host,
+            self._port,
+            self._use_ssl,
+        )
+
+    async def close(self) -> None:
+        if self._writer:
+            logger.debug("tcp close")
+            self._writer.close()
+            await self._writer.wait_closed()
+            logger.debug("tcp closed")
+
+    async def send(self, data: bytes | str) -> None:
+        if isinstance(data, str):
+            data = data.encode()
+
+        if self._writer is None or not self.connected:
+            logger.warning("tcp send failed: transport is not connected")
+            raise ConnectionError("Not connected to the server")
+
+        logger.debug("tcp send bytes=%s", len(data))
+        self._writer.write(data)
+        await self._writer.drain()
+
+    async def recv(self, n: int | None = None) -> bytes:
+        if self._reader is None or not self.connected:
+            logger.warning("tcp recv failed: transport is not connected")
+            raise ConnectionError("Not connected to the server")
+
+        if n is None:
+            data = await self._reader.readexactly(1024)
+        else:
+            data = await self._reader.readexactly(n)
+
+        logger.debug("tcp recv bytes=%s requested=%s", len(data), n)
+        return data
+
+    @property
+    def connected(self) -> bool:
+        return bool(self._reader and not self._reader.at_eof())

pymax/transport/websocket.py

@@ -0,0 +1,50 @@
+import asyncio
+
+from websockets import ClientConnection, Origin
+from websockets.asyncio import client
+
+from pymax.logging import get_logger
+
+from .base import Transport
+
+logger = get_logger(__name__)
+
+
+class WebSocketTransport(Transport):
+    def __init__(self, url: str, proxy: str | None) -> None:
+        self.url = url
+        self.proxy = proxy
+        self.ws: ClientConnection | None = None
+
+    async def connect(self) -> None:
+        if self.proxy:
+            self.ws = await client.connect(
+                self.url, origin=Origin("https://web.max.ru"), proxy=self.proxy
+            )
+        else:
+            self.ws = await client.connect(
+                self.url, origin=Origin("https://web.max.ru")
+            )  # TODO: origin should be configurable
+
+    async def close(self) -> None:
+        if self.ws:
+            ws = self.ws
+            await ws.close()
+            await ws.wait_closed()
+            self.ws = None
+
+    async def send(self, data: bytes | str) -> None:
+        if self.ws is None or not self.connected:
+            raise ConnectionError("Not connected to the server")
+        logger.debug("sending %s", data)
+        await self.ws.send(data)
+
+    async def recv(self, n: int | None = None) -> bytes | str:
+        if self.ws is None or not self.connected:
+            raise ConnectionError("Not connected to the server")
+
+        return await self.ws.recv(decode=True)
+
+    @property
+    def connected(self) -> bool:
+        return bool(self.ws and self.ws.close_code is None)

pymax/types/__init__.py

@@ -0,0 +1,2 @@
+from .domain import *
+from .events import *

pymax/types/domain/__init__.py

@@ -0,0 +1,11 @@
+from .attachments import *
+from .chat import Chat
+from .error import MaxApiError
+from .folder import Folder, FolderList, FolderUpdate
+from .login import LoginResponse
+from .message import Message, ReactionCounter, ReactionInfo, ReadState
+from .name import Name
+from .profile import Profile
+from .session import Session
+from .sync import SyncOverrides, SyncState
+from .user import User

pymax/types/domain/attachments/__init__.py

@@ -0,0 +1,11 @@
+from .audio import AudioAttachment
+from .call import CallAttachment
+from .contact import ContactAttachment
+from .control import ControlAttachment
+from .enums import AttachmentType
+from .file import FileAttachment, FileRequest
+from .keyboards import InlineKeyboardAttachment
+from .photo import PhotoAttachment
+from .share import ShareAttachment
+from .sticker import StickerAttachment
+from .video import VideoAttachment, VideoRequest

pymax/types/domain/attachments/audio.py

@@ -0,0 +1,35 @@
+from typing import Literal
+
+from pydantic import Field
+
+from pymax.types.domain.base import CamelModel
+
+from .enums import AttachmentType, TranscriptionStatus
+
+
+class AudioAttachment(CamelModel):
+    """Аудио-вложение сообщения.
+
+    :ivar duration: Длительность аудио.
+    :vartype duration: int
+    :ivar audio_id: ID аудио.
+    :vartype audio_id: int
+    :ivar wave: Данные waveform.
+    :vartype wave: str | None
+    :ivar transcription_status: Статус транскрибации.
+    :vartype transcription_status: TranscriptionStatus | None
+    :ivar url: URL аудио.
+    :vartype url: str | None
+    :ivar type: Тип вложения.
+    :vartype type: Literal[AttachmentType.AUDIO]
+    :ivar token: Токен аудио.
+    :vartype token: str | None
+    """
+
+    duration: int
+    audio_id: int
+    wave: str | None = None
+    transcription_status: TranscriptionStatus | None = None
+    url: str | None = None
+    type: Literal[AttachmentType.AUDIO] = Field(alias="_type")
+    token: str | None = None

pymax/types/domain/attachments/call.py

@@ -0,0 +1,26 @@
+from typing import Literal
+
+from pydantic import Field
+
+from pymax.types.domain.base import CamelModel
+
+from .enums import AttachmentType
+
+
+class CallAttachment(CamelModel):
+    """Вложение звонка.
+
+    :ivar type: Тип вложения.
+    :vartype type: Literal[AttachmentType.CALL]
+    :ivar duration: Длительность звонка.
+    :vartype duration: int | None
+    :ivar conversation_id: ID звонка или конференции.
+    :vartype conversation_id: str | int | None
+    :ivar contact_ids: ID участников звонка.
+    :vartype contact_ids: list[int]
+    """
+
+    type: Literal[AttachmentType.CALL] = Field(alias="_type")
+    duration: int | None = None
+    conversation_id: str | int | None = None
+    contact_ids: list[int] = Field(default_factory=list)

pymax/types/domain/attachments/contact.py

@@ -0,0 +1,32 @@
+from typing import Literal
+
+from pydantic import Field
+
+from pymax.types.domain.base import CamelModel
+
+from .enums import AttachmentType
+
+
+class ContactAttachment(CamelModel):
+    """Контактное вложение сообщения.
+
+    :ivar contact_id: ID контакта.
+    :vartype contact_id: int
+    :ivar first_name: Имя контакта.
+    :vartype first_name: str | None
+    :ivar last_name: Фамилия контакта.
+    :vartype last_name: str | None
+    :ivar name: Отображаемое имя контакта.
+    :vartype name: str | None
+    :ivar photo_url: URL фотографии контакта.
+    :vartype photo_url: str | None
+    :ivar type: Тип вложения.
+    :vartype type: Literal[AttachmentType.CONTACT]
+    """
+
+    contact_id: int
+    first_name: str | None = None
+    last_name: str | None = None
+    name: str | None = None
+    photo_url: str | None = None
+    type: Literal[AttachmentType.CONTACT] = Field(alias="_type")

pymax/types/domain/attachments/control.py

@@ -0,0 +1,20 @@
+from typing import Literal
+
+from pydantic import Field
+
+from pymax.types.domain.base import CamelModel
+
+from .enums import AttachmentType
+
+
+class ControlAttachment(CamelModel):
+    """Служебное вложение управления.
+
+    :ivar type: Тип вложения.
+    :vartype type: Literal[AttachmentType.CONTROL]
+    :ivar event: Событие управления.
+    :vartype event: str
+    """
+
+    type: Literal[AttachmentType.CONTROL] = Field(alias="_type")
+    event: str