maxapi-python 2.0.1__py3-none-any.whl → 2.1.1__py3-none-any.whl

pymax/api/uploads/service.py

@@ -38,16 +38,26 @@ logger = get_logger(__name__)
 class UploadService:
     def __init__(self, app: App) -> None:
         self.app = app
-        self.video_upload_waiters: dict[int, asyncio.Future[VideoUploadSignal]] = {}
-        self.file_upload_waiters: dict[int, asyncio.Future[FileUploadSignal]] = {}
-        self.app.dispatcher.on_internal(EventType.VIDEO_READY)(self.on_video_attach)
-        self.app.dispatcher.on_internal(EventType.FILE_READY)(self.on_file_attach)
+        self.video_upload_waiters: dict[
+            int, asyncio.Future[VideoUploadSignal]
+        ] = {}
+        self.file_upload_waiters: dict[
+            int, asyncio.Future[FileUploadSignal]
+        ] = {}
+        self.app.dispatcher.on_internal(EventType.VIDEO_READY)(
+            self.on_video_attach
+        )
+        self.app.dispatcher.on_internal(EventType.FILE_READY)(
+            self.on_file_attach
+        )
 
-    async def upload_photo(self, photo: Photo) -> AttachPhotoPayload:
+    async def upload_photo(
+        self, photo: Photo, profile: bool = False
+    ) -> AttachPhotoPayload:
         logger.info("Uploading photo")
         logger.debug("Preparing photo upload payload")
 
-        payload = UploadPayload().model_dump()
+        payload = UploadPayload(profile=profile).model_dump()
 
         try:
             data = await self.app.invoke(
@@ -62,7 +72,9 @@ class UploadService:
             url = payload_item(data, "url", str)  # TODO: ENUM!!!!
         except Exception as e:
             logger.exception("Failed to parse photo upload URL from response")
-            raise UploadError("Failed to parse photo upload URL from response") from e
+            raise UploadError(
+                "Failed to parse photo upload URL from response"
+            ) from e
 
         if not url:
             logger.error("No upload URL received")
@@ -80,11 +92,15 @@ class UploadService:
         except (KeyError, IndexError) as e:
             logger.exception("Photo upload URL does not contain photoIds")
             logger.debug("Invalid photo upload URL=%s", url)
-            raise UploadError("Photo upload URL does not contain photoIds") from e
+            raise UploadError(
+                "Photo upload URL does not contain photoIds"
+            ) from e
         except Exception as e:
             logger.exception("Failed to parse photo id from upload URL")
             logger.debug("Invalid photo upload URL=%s", url)
-            raise UploadError("Failed to parse photo id from upload URL") from e
+            raise UploadError(
+                "Failed to parse photo id from upload URL"
+            ) from e
 
         logger.debug("Photo upload id parsed photo_id=%s", photo_id)
 
@@ -122,23 +138,33 @@ class UploadService:
 
         try:
             async with (
-                aiohttp.ClientSession() as session,
+                aiohttp.ClientSession(proxy=self.app.config.proxy) as session,
                 session.post(
                     url=url,
                     data=form,
                 ) as response,
             ):
-                logger.debug("Photo upload HTTP response status=%s", response.status)
+                logger.debug(
+                    "Photo upload HTTP response status=%s", response.status
+                )
 
                 if response.status != HTTPStatus.OK:
-                    logger.error("Photo upload failed with status %s", response.status)
-                    raise UploadError(f"Photo upload failed with status {response.status}")
+                    logger.error(
+                        "Photo upload failed with status %s", response.status
+                    )
+                    raise UploadError(
+                        f"Photo upload failed with status {response.status}"
+                    )
 
                 try:
                     result = await response.json()
                 except Exception as e:
-                    logger.exception("Failed to decode photo upload response JSON")
-                    raise UploadError("Failed to decode photo upload response JSON") from e
+                    logger.exception(
+                        "Failed to decode photo upload response JSON"
+                    )
+                    raise UploadError(
+                        "Failed to decode photo upload response JSON"
+                    ) from e
 
         except UploadError:
             raise
@@ -251,8 +277,12 @@ class UploadService:
         logger.debug("Video upload waiter registered video_id=%s", video_id)
 
         try:
-            async with aiohttp.ClientSession(timeout=timeout) as session:
-                logger.debug("Starting video upload HTTP request video_id=%s", video_id)
+            async with aiohttp.ClientSession(
+                timeout=timeout, proxy=self.app.config.proxy
+            ) as session:
+                logger.debug(
+                    "Starting video upload HTTP request video_id=%s", video_id
+                )
 
                 async with session.post(
                     url=upload_info.url,
@@ -297,14 +327,26 @@ class UploadService:
         except UploadError:
             raise
         except aiohttp.ClientError as e:
-            logger.exception("HTTP error during video upload video_id=%s", video_id)
-            raise UploadError(f"HTTP error during video upload video_id={video_id}") from e
+            logger.exception(
+                "HTTP error during video upload video_id=%s", video_id
+            )
+            raise UploadError(
+                f"HTTP error during video upload video_id={video_id}"
+            ) from e
         except asyncio.TimeoutError as e:
-            logger.exception("Timed out during video upload video_id=%s", video_id)
-            raise UploadError(f"Timed out during video upload video_id={video_id}") from e
+            logger.exception(
+                "Timed out during video upload video_id=%s", video_id
+            )
+            raise UploadError(
+                f"Timed out during video upload video_id={video_id}"
+            ) from e
         except Exception as e:
-            logger.exception("Unexpected error during video upload video_id=%s", video_id)
-            raise UploadError(f"Unexpected error during video upload video_id={video_id}") from e
+            logger.exception(
+                "Unexpected error during video upload video_id=%s", video_id
+            )
+            raise UploadError(
+                f"Unexpected error during video upload video_id={video_id}"
+            ) from e
         finally:
             self.video_upload_waiters.pop(video_id, None)
             logger.debug("Video upload waiter removed video_id=%s", video_id)
@@ -371,7 +413,9 @@ class UploadService:
         logger.debug("File upload waiter registered file_id=%s", file_id)
 
         try:
-            async with aiohttp.ClientSession() as session:
+            async with aiohttp.ClientSession(
+                proxy=self.app.config.proxy,
+            ) as session:
                 async with session.post(
                     url=upload_info.url,
                     headers=headers,
@@ -414,44 +458,70 @@ class UploadService:
         except UploadError:
             raise
         except aiohttp.ClientError as e:
-            logger.exception("HTTP error during file upload file_id=%s", file_id)
-            raise UploadError(f"HTTP error during file upload file_id={file_id}") from e
+            logger.exception(
+                "HTTP error during file upload file_id=%s", file_id
+            )
+            raise UploadError(
+                f"HTTP error during file upload file_id={file_id}"
+            ) from e
         except asyncio.TimeoutError as e:
-            logger.exception("Timed out during file upload file_id=%s", file_id)
-            raise UploadError(f"Timed out during file upload file_id={file_id}") from e
+            logger.exception(
+                "Timed out during file upload file_id=%s", file_id
+            )
+            raise UploadError(
+                f"Timed out during file upload file_id={file_id}"
+            ) from e
         except Exception as e:
-            logger.exception("Unexpected error during file upload file_id=%s", file_id)
-            raise UploadError(f"Unexpected error during file upload file_id={file_id}") from e
+            logger.exception(
+                "Unexpected error during file upload file_id=%s", file_id
+            )
+            raise UploadError(
+                f"Unexpected error during file upload file_id={file_id}"
+            ) from e
         finally:
             self.file_upload_waiters.pop(file_id, None)
             logger.debug("File upload waiter removed file=%s", file_id)
 
-    async def on_video_attach(self, attach: VideoUploadSignal, _: Client) -> None:
+    async def on_video_attach(
+        self, attach: VideoUploadSignal, _: Client
+    ) -> None:
         logger.debug("Received attach event video_id=%s", attach.video_id)
 
         future = self.video_upload_waiters.pop(attach.video_id, None)
 
         if not future:
-            logger.debug("No video upload waiter found video_id=%s", attach.video_id)
+            logger.debug(
+                "No video upload waiter found video_id=%s", attach.video_id
+            )
             return
 
         if future.done():
-            logger.debug("Video upload waiter already done video_id=%s", attach.video_id)
+            logger.debug(
+                "Video upload waiter already done video_id=%s", attach.video_id
+            )
             return
 
         future.set_result(attach)
-        logger.debug("Video upload waiter resolved video_id=%s", attach.video_id)
+        logger.debug(
+            "Video upload waiter resolved video_id=%s", attach.video_id
+        )
 
-    async def on_file_attach(self, attach: FileUploadSignal, _: Client) -> None:
+    async def on_file_attach(
+        self, attach: FileUploadSignal, _: Client
+    ) -> None:
         logger.debug("Received attach event file_id=%s", attach.file_id)
         future = self.file_upload_waiters.pop(attach.file_id, None)
 
         if not future:
-            logger.debug("No file upload waiter found file_id=%s", attach.file_id)
+            logger.debug(
+                "No file upload waiter found file_id=%s", attach.file_id
+            )
             return
 
         if future.done():
-            logger.debug("File upload waiter already done file_id=%s", attach.file_id)
+            logger.debug(
+                "File upload waiter already done file_id=%s", attach.file_id
+            )
             return
 
         future.set_result(attach)

pymax/api/users/service.py

@@ -44,7 +44,9 @@ class UserService:
             for user_id in user_ids
             if (user := self.get_cached_user(user_id)) is not None
         }
-        missing_ids = [user_id for user_id in user_ids if user_id not in cached]
+        missing_ids = [
+            user_id for user_id in user_ids if user_id not in cached
+        ]
 
         if missing_ids:
             for user in await self.fetch_users(missing_ids):
@@ -62,11 +64,15 @@ class UserService:
     async def fetch_users(self, user_ids: list[int]) -> list[User]:
         logger.info("fetching users count=%s", len(user_ids))
         frame = FetchContactsPayload(contact_ids=user_ids)
-        response = await self.app.invoke(Opcode.CONTACT_INFO, frame.to_payload())
+        response = await self.app.invoke(
+            Opcode.CONTACT_INFO, frame.to_payload()
+        )
 
         users = [
             self._cache_user(user)
-            for user in parse_payload_list(response, UserPayloadKey.CONTACTS, User)
+            for user in parse_payload_list(
+                response, UserPayloadKey.CONTACTS, User
+            )
         ]
         logger.debug("fetched users count=%s", len(users))
         return users
@@ -91,8 +97,12 @@ class UserService:
         response = await self.app.invoke(Opcode.SESSIONS_INFO, {})
         return parse_payload_list(response, UserPayloadKey.SESSIONS, Session)
 
-    async def _contact_action(self, payload: ContactActionPayload) -> InboundFrame:
-        response = await self.app.invoke(Opcode.CONTACT_UPDATE, payload.to_payload())
+    async def _contact_action(
+        self, payload: ContactActionPayload
+    ) -> InboundFrame:
+        response = await self.app.invoke(
+            Opcode.CONTACT_UPDATE, payload.to_payload()
+        )
         require_payload_dict(response)
         return response
 

pymax/app.py

@@ -33,7 +33,9 @@ class App(Generic[ClientT]):
         self.dispatcher: Dispatcher[ClientT] = Dispatcher(self, root_router)
         self.api = ApiFacade(self)
         self.config = config
-        self.store = self.config.store or SessionStore(config.work_dir, config.session_name)
+        self.store = self.config.store or SessionStore(
+            config.work_dir, config.session_name
+        )
         self.auth_flow = auth_flow
 
         self.me: Profile | None = None
@@ -74,14 +76,18 @@ class App(Generic[ClientT]):
             await self.connection.open()
 
             handshake_device_id = (
-                session_data.device_id if session_data else self.config.device.device_id
+                session_data.device_id
+                if session_data
+                else self.config.device.device_id
             )
             logger.debug("running handshake")
             await self.handshake(handshake_device_id)
         except (ConnectionError, EOFError, OSError, TimeoutError) as e:
             logger.exception("failed to connect or handshake")
             await self.connection.close()
-            raise ConnectionError(f"Failed to connect and handshake: {e}") from e
+            raise ConnectionError(
+                f"Failed to connect and handshake: {e}"
+            ) from e
 
         self._ping_task = asyncio.create_task(self._ping_loop())
 
@@ -102,7 +108,9 @@ class App(Generic[ClientT]):
 
                 if not auth_result.token:
                     logger.error("authentication finished without token")
-                    raise RuntimeError("Authentication failed: no token received")
+                    raise RuntimeError(
+                        "Authentication failed: no token received"
+                    )
 
                 await self.store.save_session(
                     session_data := SessionInfo(
@@ -127,6 +135,10 @@ class App(Generic[ClientT]):
             self.config.device.user_agent,
         )
 
+        if response.token != self.session.token:
+            await self.store.update_token(self.session.token, response.token)
+            self.session.token = response.token
+
         self.me = response.profile
         self.chats = response.chats
         self.users[self.me.contact.id] = self.me.contact
@@ -200,7 +212,9 @@ class App(Generic[ClientT]):
         )
         logger.debug("Request data=%s", frame.model_dump())
         response = await self.connection.request(frame, timeout=timeout)
-        response_keys = sorted(response.payload.keys()) if response.payload else []
+        response_keys = (
+            sorted(response.payload.keys()) if response.payload else []
+        )
         logger.debug(
             "response opcode=%s cmd=%s seq=%s payload_keys=%s",
             response.opcode,

pymax/auth/qr.py

@@ -4,8 +4,7 @@ import asyncio
 import time
 from typing import TYPE_CHECKING
 
-import qrcode
-
+from pymax.auth.base import AuthFlow
 from pymax.exceptions import ApiError
 from pymax.logging import get_logger
 
@@ -20,7 +19,7 @@ if TYPE_CHECKING:
 logger = get_logger(__name__)
 
 
-class QrAuthFlow:
+class QrAuthFlow(AuthFlow):
     """Стандартная QR-авторизация ``WebClient``.
 
     Flow получает QR-ссылку, передает ее в ``QrHandler``, ждет подтверждения и
@@ -119,17 +118,23 @@ class QrAuthFlow:
                 continue
 
             try:
-                response = await app.api.auth.check_password(track_id, password)
+                response = await app.api.auth.check_password(
+                    track_id, password
+                )
             except ApiError as e:
                 logger.error("2fa password check failed: %s", e)
                 continue
 
             if response.error:
-                logger.error("2fa password check failed error=%s", response.error)
+                logger.error(
+                    "2fa password check failed error=%s", response.error
+                )
                 continue
 
             if response.login_token:
                 logger.info("2fa password authentication completed")
                 return response.login_token
 
-            logger.error("2fa password response did not contain login token; retrying")
+            logger.error(
+                "2fa password response did not contain login token; retrying"
+            )

pymax/auth/sms.py

@@ -2,11 +2,16 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING
 
+from pymax.auth.base import AuthFlow
 from pymax.exceptions import ApiError
 from pymax.logging import get_logger
 
 from .models import AuthResult
-from .providers import ConsolePasswordProvider, PasswordProvider, SmsCodeProvider
+from .providers import (
+    ConsolePasswordProvider,
+    PasswordProvider,
+    SmsCodeProvider,
+)
 
 if TYPE_CHECKING:
     from pymax.app import App
@@ -15,7 +20,7 @@ if TYPE_CHECKING:
 logger = get_logger(__name__)
 
 
-class SmsAuthFlow:
+class SmsAuthFlow(AuthFlow):
     """Стандартная SMS-авторизация ``Client``.
 
     Flow запрашивает SMS-код, отправляет его в Max, при необходимости проходит
@@ -104,13 +109,17 @@ class SmsAuthFlow:
                 continue
 
             try:
-                response = await app.api.auth.check_password(track_id, password)
+                response = await app.api.auth.check_password(
+                    track_id, password
+                )
             except ApiError as e:
                 logger.error("2fa password check failed: %s", e)
                 continue
 
             if response.error:
-                logger.error("2fa password check failed error=%s", response.error)
+                logger.error(
+                    "2fa password check failed error=%s", response.error
+                )
                 continue
 
             if response.login_token:

pymax/base.py

@@ -82,6 +82,7 @@ class BaseClient(BaseMixin, ABC, Generic[ClientT]):
             telemetry=self.extra_config.telemetry,
             sync=self.extra_config.sync,
             store=self.extra_config.store,
+            proxy=self.extra_config.proxy,
             device=DeviceConfig(
                 mt_instance_id=self.extra_config.mt_instance_id,
                 device_id=self.extra_config.device_id or str(uuid4()),

pymax/client.py

@@ -66,7 +66,10 @@ class Client(BaseClient["Client"]):
 
         self._config = self._build_config(
             phone=phone,
-            user_agent=(self.extra_config.user_agent or self.extra_config.generate_user_agent()),
+            user_agent=(
+                self.extra_config.user_agent
+                or self.extra_config.generate_user_agent()
+            ),
         )
 
         if auth_flow is None:

pymax/client_web.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+from pymax.auth.base import AuthFlow
 from pymax.auth.providers import ConsoleQrHandler, QrHandler
 from pymax.auth.qr import QrAuthFlow
 from pymax.connection import ConnectionManager
@@ -34,7 +35,7 @@ class WebClient(BaseClient["WebClient"]):
         session_name: str = "session.db",
         work_dir: str = ".",
         extra_config: ExtraConfig | None = None,
-        auth_flow: QrAuthFlow | None = None,
+        auth_flow: AuthFlow | None = None,
         qr_provider: QrHandler | None = None,
     ) -> None:
         self.extra_config = extra_config or ExtraConfig()
@@ -53,7 +54,8 @@ class WebClient(BaseClient["WebClient"]):
         self._config = self._build_config(
             phone=None,
             user_agent=(
-                self.extra_config.user_agent or self.extra_config.generate_web_user_agent()
+                self.extra_config.user_agent
+                or self.extra_config.generate_web_user_agent()
             ),
         )
 

pymax/config.py

@@ -8,7 +8,7 @@ from pymax.api.session.payloads import (
     DEFAULT_WEB_HEADER_USER_AGENT,
     MobileUserAgentPayload,
 )
-from pymax.session import SessionStore, StoreProtocol
+from pymax.session import StoreProtocol
 from pymax.types.domain.sync import SyncOverrides
 
 APP_VERSIONS: tuple[tuple[str, int], ...] = (
@@ -35,7 +35,12 @@ ANDROID_DEVICES: tuple[tuple[str, str, str, str], ...] = (
     ("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"),
+    (
+        "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"),
@@ -87,6 +92,7 @@ class ClientConfig(BaseModel):
     session_name: str = "session.db"
     device: DeviceConfig
     token: str | None = None
+    proxy: str | None = None
 
     host: str = "api.oneme.ru"
     port: int = 443
@@ -103,7 +109,9 @@ class ClientConfig(BaseModel):
 
     def ensure_config(self) -> None:
         if not self.phone:
-            raise ValueError("Phone must be provided when no saved session exists.")
+            raise ValueError(
+                "Phone must be provided when no saved session exists."
+            )
 
 
 class ExtraConfig(BaseModel):

pymax/connection/connection.py

@@ -80,6 +80,7 @@ class ConnectionManager:
         self._connection_lost = True
         self.requests.cancel_all(exc=exc)
         await self.transport.close()
+        self._is_open = False
 
     async def send(self, frame: OutboundFrame) -> None:
         if not self._is_open:
@@ -145,19 +146,28 @@ class ConnectionManager:
                 model = self.protocol.decode(frame)
                 await self._handle_inbound(model)
 
-        except EOFError as e:
+        except EOFError:
             logger.warning("connection closed by server")
-            self.requests.cancel_all(exc=ConnectionError("Connection closed by the server"))
+            self.requests.cancel_all(
+                exc=ConnectionError("Connection closed by the server")
+            )
             self._connection_lost = True
+            self._is_open = False
         except TimeoutError as e:
             logger.exception("connection timed out")
-            self.requests.cancel_all(exc=ConnectionError("Connection timed out"))
+            self.requests.cancel_all(
+                exc=ConnectionError("Connection timed out")
+            )
             self._connection_lost = True
+            self._is_open = False
             raise e
         except Exception as e:
             logger.exception("connection receive loop failed")
-            self.requests.cancel_all(exc=ConnectionError(f"Connection error: {e}"))
+            self.requests.cancel_all(
+                exc=ConnectionError(f"Connection error: {e}")
+            )
             self._connection_lost = True
+            self._is_open = False
             raise e
 
     async def _handle_inbound(self, frame: InboundFrame) -> None:
@@ -197,7 +207,7 @@ class ConnectionManager:
             )
 
     def next_seq(self) -> int:
-        self._seq = (self._seq + 1) % 0xFFFFFFFF
+        self._seq = (self._seq + 1) % 0x10000
         return self._seq
 
     @property

pymax/connection/readers/tcp.py

@@ -8,13 +8,15 @@ logger = get_logger(__name__)
 
 
 class TCPReader(BaseReader):
-    def __init__(self, transport: TCPTransport, framer: TcpPacketFramer) -> None:
+    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)
+        header_bytes = await self.transport.recv(self.framer.HEADER_SIZE)
         payload_len = self.framer.unpack_header(header_bytes)
         if payload_len is None:
             logger.warning(