maxapi-python 1.1.14__tar.gz → 1.1.15__tar.gz

{maxapi_python-1.1.14 → maxapi_python-1.1.15}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: maxapi-python
-Version: 1.1.14
+Version: 1.1.15
 Summary: Python wrapper для API мессенджера Max
 Project-URL: Homepage, https://github.com/ink-developer/PyMax
 Project-URL: Repository, https://github.com/ink-developer/PyMax
@@ -145,7 +145,7 @@ if __name__ == "__main__":
 
 ## Документация
 
-[WIP](https://ink-developer.github.io/)
+[WIP](https://ink-developer.github.io/PyMax)
 
 ## Лицензия
 

{maxapi_python-1.1.14 → maxapi_python-1.1.15}/README.md

@@ -123,7 +123,7 @@ if __name__ == "__main__":
 
 ## Документация
 
-[WIP](https://ink-developer.github.io/)
+[WIP](https://ink-developer.github.io/PyMax)
 
 ## Лицензия
 

{maxapi_python-1.1.14 → maxapi_python-1.1.15}/examples/example.py

@@ -1,6 +1,8 @@
 import asyncio
+import datetime
 
 from pymax import MaxClient, Message
+from pymax.files import File
 from pymax.filters import Filter
 from pymax.static.enum import AttachType
 
@@ -27,14 +29,24 @@ async def handle_deleted_message(message: Message) -> None:
 
 @client.on_start
 async def handle_start() -> None:
-    print("Client started successfully!")
-    history = await client.fetch_history(chat_id=0)
-    if history:
-        for message in history:
-            if message.attaches:
-                for attach in message.attaches:
-                    if attach.type == AttachType.STICKER:
-                        print(attach.lottie_url)
+    print(f"Client started successfully at {datetime.datetime.now()}!")
+    file_path = "ruff.toml"
+    file = File(path=file_path)
+    msg = await client.send_message(
+        text="Here is the file you requested.",
+        chat_id=0,
+        attachment=file,
+        notify=True,
+    )
+    if msg:
+        print(f"File sent successfully in message ID: {msg.id}")
+    # history = await client.fetch_history(chat_id=0)
+    # if history:
+    #     for message in history:
+    #         if message.attaches:
+    #             for attach in message.attaches:
+    #                 if attach.type == AttachType.STICKER:
+    #                     print(attach.lottie_url)
     # chat = await client.rework_invite_link(chat_id=0)
     # print(chat.link)
     # text = """

{maxapi_python-1.1.14 → maxapi_python-1.1.15}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "maxapi-python"
-version = "1.1.14"
+version = "1.1.15"
 description = "Python wrapper для API мессенджера Max"
 readme = "README.md"
 requires-python = ">=3.10"

{maxapi_python-1.1.14 → maxapi_python-1.1.15}/src/pymax/core.py

@@ -4,6 +4,7 @@ import socket
 import ssl
 import time
 from pathlib import Path
+from typing import Literal
 
 from typing_extensions import override
 
@@ -36,6 +37,12 @@ class MaxClient(ApiMixin, WebSocketMixin):
             процесс логина по номеру телефона.
         host (str, optional): Хост API сервера. По умолчанию Constants.HOST.value.
         port (int, optional): Порт API сервера. По умолчанию Constants.PORT.value.
+        registration (bool, optional): Флаг регистрации нового пользователя. По умолчанию False.
+        first_name (str, optional): Имя пользователя для регистрации. Требуется, если registration=True.
+        last_name (str | None, optional): Фамилия пользователя для регистрации.
+        send_fake_telemetry (bool, optional): Флаг отправки фейковой телеметрии. По умолчанию True.
+        proxy (str | Literal[True] | None, optional): Прокси для подключения к WebSocket.
+            (См. https://websockets.readthedocs.io/en/stable/topics/proxies.html).
 
     Raises:
         InvalidPhoneError: Если формат номера телефона неверный.
@@ -50,7 +57,11 @@ class MaxClient(ApiMixin, WebSocketMixin):
         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,
         logger: logging.Logger | None = None,
     ) -> None:
         logger = logger or logging.getLogger(f"{__name__}.MaxClient")
@@ -62,12 +73,22 @@ class MaxClient(ApiMixin, WebSocketMixin):
             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._work_dir: str = work_dir
         self._database_path: Path = Path(work_dir) / "session.db"
         self._database_path.parent.mkdir(parents=True, exist_ok=True)
         self._database_path.touch(exist_ok=True)
         self._database = Database(self._work_dir)
+        self._outgoing: asyncio.Queue[dict[str, Any]] | None = None
+        self._outgoing_task: asyncio.Task[Any] | None = None
+        self._error_count: int = 0
+        self._circuit_breaker: bool = False
+        self._last_error_time: float = 0.0
         self._device_id = 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
         self.user_agent = headers
         self._send_fake_telemetry: bool = send_fake_telemetry
@@ -111,6 +132,12 @@ class MaxClient(ApiMixin, WebSocketMixin):
                     await self._recv_task
                 except asyncio.CancelledError:
                     self.logger.debug("recv_task cancelled")
+            if self._outgoing_task:
+                self._outgoing_task.cancel()
+                try:
+                    await self._outgoing_task
+                except asyncio.CancelledError:
+                    self.logger.debug("outgoing_task cancelled")
             if self._ws:
                 await self._ws.close()
             self.is_connected = False
@@ -127,6 +154,11 @@ class MaxClient(ApiMixin, WebSocketMixin):
             self.logger.info("Client starting")
             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)
 

{maxapi_python-1.1.14 → maxapi_python-1.1.15}/src/pymax/files.py

@@ -9,9 +9,7 @@ from typing_extensions import override
 
 
 class BaseFile(ABC):
-    def __init__(
-        self, url: str | None = None, path: str | None = None
-    ) -> None:
+    def __init__(self, url: str | None = None, path: str | None = None) -> None:
         self.url = url
         self.path = path
 
@@ -47,9 +45,7 @@ class Photo(BaseFile):
         ".bmp",
     }  # FIXME: костыль ✅
 
-    def __init__(
-        self, url: str | None = None, path: str | None = None
-    ) -> None:
+    def __init__(self, url: str | None = None, path: str | None = None) -> None:
         super().__init__(url, path)
 
     def validate_photo(self) -> tuple[str, str] | None:
@@ -71,9 +67,7 @@ class Photo(BaseFile):
             mime_type = mimetypes.guess_type(self.url)[0]
 
             if not mime_type or not mime_type.startswith("image/"):
-                raise ValueError(
-                    f"URL does not appear to be an image: {self.url}"
-                )
+                raise ValueError(f"URL does not appear to be an image: {self.url}")
 
             return (extension[1:], mime_type)
         return None
@@ -90,6 +84,18 @@ class Video(BaseFile):
 
 
 class File(BaseFile):
+    def __init__(self, url: str | None = None, path: str | None = None) -> None:
+        self.file_name: str = ""
+        if path:
+            self.file_name = Path(path).name
+        elif url:
+            self.file_name = Path(url).name
+
+        if not self.file_name:
+            raise ValueError("Either url or path must be provided.")
+
+        super().__init__(url, path)
+
     @override
     async def read(self) -> bytes:
         return await super().read()

{maxapi_python-1.1.14 → maxapi_python-1.1.15}/src/pymax/interfaces.py

@@ -5,10 +5,12 @@ from abc import ABC, abstractmethod
 from collections.abc import Awaitable, Callable
 from logging import Logger
 from pathlib import Path
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING, Any, Literal
 
 import websockets
 
+from pymax.static.constant import DEFAULT_USER_AGENT
+
 from .filters import Filter
 from .payloads import UserAgentPayload
 from .static.constant import DEFAULT_TIMEOUT
@@ -37,6 +39,10 @@ class ClientProtocol(ABC):
         self.me: Me | None = None
         self.host: str
         self.port: int
+        self.proxy: str | Literal[True] | None
+        self.registration: bool
+        self.first_name: str
+        self.last_name: str | None
         self._work_dir: str
         self._database_path: Path
         self._ws: websockets.ClientConnection | None = None
@@ -44,7 +50,14 @@ class ClientProtocol(ABC):
         self._pending: dict[int, asyncio.Future[dict[str, Any]]] = {}
         self._recv_task: asyncio.Task[Any] | None = None
         self._incoming: asyncio.Queue[dict[str, Any]] | None = None
+        self._file_upload_waiters: dict[int, asyncio.Future[dict[str, Any]]] = {}
         self.user_agent = UserAgentPayload()
+        self._outgoing: asyncio.Queue[dict[str, Any]] | None = None
+        self._outgoing_task: asyncio.Task[Any] | None = None
+        self._error_count: int = 0
+        self._circuit_breaker: bool = False
+        self._last_error_time: float = 0.0
+        self.user_agent = DEFAULT_USER_AGENT
         self._session_id: int
         self._action_id: int = 0
         self._current_screen: str = "chats_list_tab"
@@ -57,9 +70,7 @@ class ClientProtocol(ABC):
         self._on_message_delete_handlers: list[
             tuple[Callable[[Message], Any], Filter | None]
         ] = []
-        self._on_start_handler: Callable[[], Any | Awaitable[Any]] | None = (
-            None
-        )
+        self._on_start_handler: Callable[[], Any | Awaitable[Any]] | None = None
         self._background_tasks: set[asyncio.Task[Any]] = set()
         self._ssl_context: ssl.SSLContext
         self._socket: socket.socket | None = None
@@ -77,3 +88,14 @@ class ClientProtocol(ABC):
     @abstractmethod
     async def _get_chat(self, chat_id: int) -> Chat | None:
         pass
+
+    @abstractmethod
+    async def _queue_message(
+        self,
+        opcode: int,
+        payload: dict[str, Any],
+        cmd: int = 0,
+        timeout: float = DEFAULT_TIMEOUT,
+        max_retries: int = 3,
+    ) -> Message | None:
+        pass

{maxapi_python-1.1.14 → maxapi_python-1.1.15}/src/pymax/mixins/auth.py

@@ -1,15 +1,15 @@
 import asyncio
 import re
+import sys
 from typing import Any
 
 from pymax.interfaces import ClientProtocol
-from pymax.payloads import RequestCodePayload, SendCodePayload
+from pymax.payloads import RegisterPayload, RequestCodePayload, SendCodePayload
 from pymax.static.constant import PHONE_REGEX
 from pymax.static.enum import AuthType, Opcode
 
 
 class AuthMixin(ClientProtocol):
-
     def __init__(self, token: str | None = None, *args, **kwargs) -> None:
         super().__init__(*args, **kwargs)
         self._token = token
@@ -55,9 +55,7 @@ class AuthMixin(ClientProtocol):
                 auth_token_type=AuthType.CHECK_CODE,
             ).model_dump(by_alias=True)
 
-            data = await self._send_and_wait(
-                opcode=Opcode.AUTH, payload=payload
-            )
+            data = await self._send_and_wait(opcode=Opcode.AUTH, payload=payload)
             self.logger.debug(
                 "Send code response opcode=%s seq=%s",
                 data.get("opcode"),
@@ -75,13 +73,15 @@ class AuthMixin(ClientProtocol):
 
     async def _login(self) -> None:
         self.logger.info("Starting login flow")
+
         request_code_payload = await self._request_code(self.phone)
         temp_token = request_code_payload.get("token")
         if not temp_token or not isinstance(temp_token, str):
             self.logger.critical("Failed to request code: token missing")
             raise ValueError("Failed to request code")
 
-        code = await asyncio.to_thread(input, "Введите код: ")
+        print("Введите код: ", end="", flush=True)
+        code = await asyncio.to_thread(lambda: sys.stdin.readline().strip())
         if len(code) != 6 or not code.isdigit():
             self.logger.error("Invalid code format entered")
             raise ValueError("Invalid code format")
@@ -97,3 +97,66 @@ class AuthMixin(ClientProtocol):
         self._token = token
         self._database.update_auth_token(self._device_id, self._token)
         self.logger.info("Login successful, token saved to database")
+
+    async def _submit_reg_info(
+        self, first_name: str, last_name: str | None, token: str
+    ) -> dict[str, Any]:
+        try:
+            self.logger.info("Submitting registration info")
+
+            payload = RegisterPayload(
+                first_name=first_name,
+                last_name=last_name,
+                token=token,
+            ).model_dump(by_alias=True)
+
+            data = await self._send_and_wait(
+                opcode=Opcode.AUTH_CONFIRM, payload=payload
+            )
+            self.logger.debug(
+                "Registration info response opcode=%s seq=%s",
+                data.get("opcode"),
+                data.get("seq"),
+            )
+            payload_data = data.get("payload")
+            if isinstance(payload_data, dict):
+                return payload_data
+            else:
+                self.logger.error("Invalid payload data received")
+                raise ValueError("Invalid payload data received")
+        except Exception:
+            self.logger.error("Submit registration info failed", exc_info=True)
+            raise RuntimeError("Submit registration info failed")
+
+    async def _register(self, first_name: str, last_name: str | None = None) -> None:
+        self.logger.info("Starting registration flow")
+
+        request_code_payload = await self._request_code(self.phone)
+        temp_token = request_code_payload.get("token")
+
+        if not temp_token or not isinstance(temp_token, str):
+            self.logger.critical("Failed to request code: token missing")
+            raise ValueError("Failed to request code")
+
+        print("Введите код: ", end="", flush=True)
+        code = await asyncio.to_thread(lambda: sys.stdin.readline().strip())
+        if len(code) != 6 or not code.isdigit():
+            self.logger.error("Invalid code format entered")
+            raise ValueError("Invalid code format")
+
+        registration_response = await self._send_code(code, temp_token)
+        token: str | None = (
+            registration_response.get("tokenAttrs", {}).get("REGISTER", {}).get("token")
+        )
+        if not token:
+            self.logger.critical("Failed to register, token not received")
+            raise ValueError("Failed to register, token not received")
+
+        data = await self._submit_reg_info(first_name, last_name, token)
+        self._token = data.get("token")
+        if not self._token:
+            self.logger.critical("Failed to register, token not received")
+            raise ValueError("Failed to register, token not received")
+
+        self._database.update_auth_token(self._device_id, self._token)
+        self.logger.info("Registration successful, token saved to database")