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

{maxapi_python-1.1.15 → maxapi_python-1.1.17}/.gitignore

@@ -103,6 +103,7 @@ Thumbs.db
 session.db
 *.bak
 *.swp
+*.bin
 
 # Environment / secrets
 .env
@@ -114,6 +115,7 @@ cache/
 
 # Keep lockfiles and important configs tracked? If you want to track specific lockfiles,
 # remove them from this .gitignore (for example: remove poetry.lock or uv.lock).
+tests2/
 tests/
 
 

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: maxapi-python
-Version: 1.1.15
+Version: 1.1.17
 Summary: Python wrapper для API мессенджера Max
 Project-URL: Homepage, https://github.com/ink-developer/PyMax
 Project-URL: Repository, https://github.com/ink-developer/PyMax
@@ -155,10 +155,14 @@ if __name__ == "__main__":
 
 [Telegram](https://t.me/pymax_news)
 
-## Авторы
+## Star History
+
+[![Star History Chart](https://api.star-history.com/svg?repos=ink-developer/PyMax&type=date&legend=top-left)](https://www.star-history.com/#ink-developer/PyMax&type=date&legend=top-left)
 
-- **[ink-developer](https://github.com/ink-developer)** — Оригинальный автор проекта
+## Авторы
 - **[ink](https://github.com/ink-developer)** — Главный разработчик, исследование API и его документация
+- **[noxzion](https://github.com/noxzion)** — Оригинальный автор проекта
+
 
 ## Контрибьюторы
 

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

@@ -133,10 +133,14 @@ if __name__ == "__main__":
 
 [Telegram](https://t.me/pymax_news)
 
-## Авторы
+## Star History
+
+[![Star History Chart](https://api.star-history.com/svg?repos=ink-developer/PyMax&type=date&legend=top-left)](https://www.star-history.com/#ink-developer/PyMax&type=date&legend=top-left)
 
-- **[ink-developer](https://github.com/ink-developer)** — Оригинальный автор проекта
+## Авторы
 - **[ink](https://github.com/ink-developer)** — Главный разработчик, исследование API и его документация
+- **[noxzion](https://github.com/noxzion)** — Оригинальный автор проекта
+
 
 ## Контрибьюторы
 

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

@@ -30,23 +30,30 @@ async def handle_deleted_message(message: Message) -> None:
 @client.on_start
 async def handle_start() -> None:
     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)
+    print(client.me.id)
+
+    # await client.send_message(
+    #     "Hello, this is a test message sent upon client start!",
+    #     chat_id=23424,
+    #     notify=True,
+    # )
+    # 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.AUDIO:
+                        print(attach.url)
     # chat = await client.rework_invite_link(chat_id=0)
     # print(chat.link)
     # text = """

{maxapi_python-1.1.15 → maxapi_python-1.1.17}/examples/telegram_bridge.py

@@ -75,14 +75,17 @@ async def handle_message(message: Message) -> None:
                         async with session.get(video.url) as response:
                             response.raise_for_status()  # Проверка на ошибки HTTP
                             video_bytes = BytesIO(await response.read())
-                            video_bytes.name = response.headers.get("X-File-Name")
+                            video_bytes.name = response.headers.get(
+                                "X-File-Name"
+                            )
 
                         # Отправляем видео через телеграм бота
                         await telegram_bot.send_video(
                             chat_id=tg_id,
                             caption=f"{sender.names[0].name}: {message.text}",
                             video=types.BufferedInputFile(
-                                video_bytes.getvalue(), filename=video_bytes.name
+                                video_bytes.getvalue(),
+                                filename=video_bytes.name,
                             ),
                         )
 
@@ -102,14 +105,17 @@ async def handle_message(message: Message) -> None:
                         async with session.get(attach.base_url) as response:
                             response.raise_for_status()  # Проверка на ошибки HTTP
                             photo_bytes = BytesIO(await response.read())
-                            photo_bytes.name = response.headers.get("X-File-Name")
+                            photo_bytes.name = response.headers.get(
+                                "X-File-Name"
+                            )
 
                         # Отправляем фото через телеграм бота
                         await telegram_bot.send_photo(
                             chat_id=tg_id,
                             caption=f"{sender.names[0].name}: {message.text}",
                             photo=types.BufferedInputFile(
-                                photo_bytes.getvalue(), filename=photo_bytes.name
+                                photo_bytes.getvalue(),
+                                filename=photo_bytes.name,
                             ),
                         )
 
@@ -136,7 +142,9 @@ async def handle_message(message: Message) -> None:
                         async with session.get(file.url) as response:
                             response.raise_for_status()  # Проверка на ошибки HTTP
                             file_bytes = BytesIO(await response.read())
-                            file_bytes.name = response.headers.get("X-File-Name")
+                            file_bytes.name = response.headers.get(
+                                "X-File-Name"
+                            )
 
                         # Отправляем файл через телеграм бота
                         await telegram_bot.send_document(

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

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

{maxapi_python-1.1.15 → maxapi_python-1.1.17}/src/pymax/__init__.py

@@ -9,14 +9,26 @@ from .core import (
 from .exceptions import (
     InvalidPhoneError,
     LoginError,
+    ResponseError,
+    ResponseStructureError,
+    SocketNotConnectedError,
+    SocketSendError,
     WebSocketNotConnectedError,
 )
+from .files import (
+    File,
+    Photo,
+)
 from .static.enum import (
     AccessType,
+    AttachType,
     AuthType,
     ChatType,
+    ContactAction,
     DeviceType,
     ElementType,
+    FormattingType,
+    MarkupType,
     MessageStatus,
     MessageType,
     Opcode,
@@ -24,10 +36,26 @@ from .static.enum import (
 from .types import (
     Channel,
     Chat,
+    Contact,
+    ControlAttach,
     Dialog,
     Element,
+    FileAttach,
+    FileRequest,
+    Me,
+    Member,
     Message,
+    MessageLink,
+    Name,
+    Names,
+    PhotoAttach,
+    Presence,
+    ReactionCounter,
+    ReactionInfo,
+    Session,
     User,
+    VideoAttach,
+    VideoRequest,
 )
 
 __author__ = "ink-developer"
@@ -35,25 +63,51 @@ __author__ = "ink-developer"
 __all__ = [
     # Перечисления и константы
     "AccessType",
+    "AttachType",
     "AuthType",
     # Типы данных
     "Channel",
     "Chat",
     "ChatType",
+    "Contact",
+    "ContactAction",
+    "ControlAttach",
     "DeviceType",
     "Dialog",
     "Element",
     "ElementType",
+    "File",
+    "FileAttach",
+    "FileRequest",
+    "FormattingType",
     # Исключения
     "InvalidPhoneError",
     "LoginError",
-    "WebSocketNotConnectedError",
+    "MarkupType",
     # Клиент
     "MaxClient",
+    "Me",
+    "Member",
     "Message",
+    "MessageLink",
     "MessageStatus",
     "MessageType",
+    "Name",
+    "Names",
     "Opcode",
+    "Photo",
+    "PhotoAttach",
+    "Presence",
+    "ReactionCounter",
+    "ReactionInfo",
+    "ResponseError",
+    "ResponseStructureError",
+    "Session",
     "SocketMaxClient",
+    "SocketNotConnectedError",
+    "SocketSendError",
     "User",
+    "VideoAttach",
+    "VideoRequest",
+    "WebSocketNotConnectedError",
 ]

maxapi_python-1.1.17/src/pymax/core.py

@@ -0,0 +1,342 @@
+import asyncio
+import contextlib
+import logging
+import socket
+import ssl
+import time
+import traceback
+from collections.abc import Awaitable
+from pathlib import Path
+from typing import TYPE_CHECKING, Any, Literal
+
+from typing_extensions import override
+
+from .crud import Database
+from .exceptions import InvalidPhoneError, WebSocketNotConnectedError
+from .formatter import ColoredFormatter
+from .mixins import ApiMixin, SocketMixin, WebSocketMixin
+from .payloads import UserAgentPayload
+from .static.constant import (
+    HOST,
+    PORT,
+    WEBSOCKET_URI,
+)
+
+if TYPE_CHECKING:
+    from collections.abc import Awaitable, Callable
+    from typing import Any
+
+    import websockets
+
+    from .filters import Filter
+    from .types import Channel, Chat, Dialog, Me, Message, User
+
+
+logger = logging.getLogger(__name__)
+
+
+class MaxClient(ApiMixin, WebSocketMixin):
+    """
+    Основной клиент для работы с WebSocket API сервиса Max.
+
+
+    Args:
+        phone (str): Номер телефона для авторизации.
+        uri (str, optional): URI WebSocket сервера. По умолчанию Constants.WEBSOCKET_URI.value.
+        work_dir (str, optional): Рабочая директория для хранения базы данных. По умолчанию ".".
+        logger (logging.Logger | None): Пользовательский логгер. Если не передан — используется
+            логгер модуля с именем f"{__name__}.MaxClient".
+        headers (UserAgentPayload): Заголовки для подключения к WebSocket.
+        token (str | None, optional): Токен авторизации. Если не передан, будет выполнен
+            процесс логина по номеру телефона.
+        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).
+        reconnect (bool, optional): Флаг автоматического переподключения при потере соединения. По умолчанию True.
+
+
+    Raises:
+        InvalidPhoneError: Если формат номера телефона неверный.
+    """
+
+    def __init__(
+        self,
+        phone: str,
+        uri: str = WEBSOCKET_URI,
+        headers: UserAgentPayload = UserAgentPayload(),
+        token: str | None = None,
+        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,
+        reconnect: bool = True,
+        reconnect_delay: float = 1.0,
+    ) -> None:
+        self.logger = logger or logging.getLogger(f"{__name__}")
+        self.uri: str = uri
+        self.phone: str = phone
+        if not self._check_phone():
+            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.reconnect: bool = reconnect
+        self.reconnect_delay: float = reconnect_delay
+
+        self.is_connected: bool = False
+
+        self.chats: list[Chat] = []
+        self.dialogs: list[Dialog] = []
+        self.channels: list[Channel] = []
+        self.me: Me | None = None
+        self._users: dict[int, User] = {}
+
+        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._incoming: asyncio.Queue[dict[str, Any]] | None = None
+        self._outgoing: asyncio.Queue[dict[str, Any]] | None = None
+        self._recv_task: asyncio.Task[Any] | None = None
+        self._outgoing_task: asyncio.Task[Any] | None = None
+        self._pending: dict[int, asyncio.Future[dict[str, Any]]] = {}
+        self._file_upload_waiters: dict[int, asyncio.Future[dict[str, Any]]] = {}
+        self._background_tasks: set[asyncio.Task[Any]] = set()
+
+        self._seq: int = 0
+        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
+        self._session_id: int = int(time.time() * 1000)
+        self._action_id: int = 1
+        self._current_screen: str = "chats_list_tab"
+
+        self._on_message_handlers: list[
+            tuple[Callable[[Message], Any], Filter | None]
+        ] = []
+        self._on_message_edit_handlers: list[
+            tuple[Callable[[Message], Any], Filter | None]
+        ] = []
+        self._on_message_delete_handlers: list[
+            tuple[Callable[[Message], Any], Filter | None]
+        ] = []
+        self._on_start_handler: Callable[[], Any | Awaitable[Any]] | None = None
+
+        self._ssl_context = ssl.create_default_context()
+        self._ssl_context.set_ciphers("DEFAULT")
+        self._ssl_context.check_hostname = True
+        self._ssl_context.verify_mode = ssl.CERT_REQUIRED
+        self._ssl_context.minimum_version = ssl.TLSVersion.TLSv1_2
+        self._ssl_context.load_default_certs()
+        self._socket: socket.socket | None = None
+        self._ws: websockets.ClientConnection | None = None
+
+        self._setup_logger()
+        self.logger.debug(
+            "Initialized MaxClient uri=%s work_dir=%s",
+            self.uri,
+            self._work_dir,
+        )
+
+    def _setup_logger(self) -> None:
+        if not self.logger.handlers:
+            if not self.logger.level:
+                self.logger.setLevel(logging.INFO)
+            handler = logging.StreamHandler()
+            formatter = ColoredFormatter(
+                "%(asctime)s [%(levelname)s] %(name)s: %(message)s",
+                datefmt="%Y-%m-%d %H:%M:%S",
+            )
+            handler.setFormatter(formatter)
+            self.logger.addHandler(handler)
+
+    async def _wait_forever(self):
+        try:
+            await self.ws.wait_closed()
+        except asyncio.CancelledError:
+            self.logger.debug("wait_closed cancelled")
+
+    async def _safe_execute(self, coro, *, context: str = "unknown"):
+        """
+        Безопасно выполняет пользовательскую корутину.
+        Логирует traceback, но не роняет event loop.
+        """
+        try:
+            return await coro
+        except Exception as e:
+            self.logger.error(
+                f"Unhandled exception in {context}: {e}\n{traceback.format_exc()}"
+            )
+
+    async def close(self) -> None:
+        try:
+            self.logger.info("Closing client")
+            if self._recv_task:
+                self._recv_task.cancel()
+                try:
+                    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
+            self.logger.info("Client closed")
+        except Exception:
+            self.logger.exception("Error closing client")
+
+    @override
+    def _create_safe_task(
+        self, coro: Awaitable[Any], *, name: str | None = None
+    ) -> asyncio.Task[Any | None]:
+        async def runner():
+            try:
+                return await coro
+            except asyncio.CancelledError:
+                raise
+            except Exception as e:
+                self.logger.exception(
+                    f"Unhandled exception in task {name or coro}: {e}",
+                    exc_info=e,
+                )
+                return None
+
+        task = asyncio.create_task(runner(), name=name)
+        self._background_tasks.add(task)
+        return task
+
+    async def start(self) -> None:
+        """
+        Запускает клиент, подключается к WebSocket, авторизует
+        пользователя (если нужно) и запускает фоновый цикл.
+        Теперь включает безопасный reconnect-loop, если self.reconnect=True.
+        """
+
+        while True:
+            try:
+                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)
+
+                if self._token is None:
+                    await self._login()
+                else:
+                    await self._sync()
+
+                if self._on_start_handler:
+                    self.logger.debug("Calling on_start handler")
+                    result = self._on_start_handler()
+                    if asyncio.iscoroutine(result):
+                        await self._safe_execute(result, context="on_start handler")
+
+                ping_task = asyncio.create_task(self._send_interactive_ping())
+                ping_task.add_done_callback(self._log_task_exception)
+                self._background_tasks.add(ping_task)
+
+                if self._send_fake_telemetry:
+                    telemetry_task = asyncio.create_task(self._start())
+                    telemetry_task.add_done_callback(self._log_task_exception)
+                    self._background_tasks.add(telemetry_task)
+
+                await self._wait_forever()
+                self.logger.info("WebSocket closed (wait_forever exited)")
+
+            except Exception:
+                self.logger.exception("Client start iteration failed")
+
+            finally:
+                self.logger.debug("Cleaning up background tasks and pending futures")
+
+                for task in list(self._background_tasks):
+                    task.cancel()
+                    try:
+                        await task
+                    except asyncio.CancelledError:
+                        pass
+                    except Exception:
+                        self.logger.debug(
+                            "Background task raised during cancellation", exc_info=True
+                        )
+                    self._background_tasks.discard(task)
+
+                if self._recv_task:
+                    self._recv_task.cancel()
+                    with contextlib.suppress(asyncio.CancelledError):
+                        await self._recv_task
+                    self._recv_task = None
+
+                if self._outgoing_task:
+                    self._outgoing_task.cancel()
+                    with contextlib.suppress(asyncio.CancelledError):
+                        await self._outgoing_task
+                    self._outgoing_task = None
+
+                for fut in self._pending.values():
+                    if not fut.done():
+                        fut.set_exception(WebSocketNotConnectedError)
+                self._pending.clear()
+
+                if self._ws:
+                    try:
+                        await self._ws.close()
+                    except Exception:
+                        self.logger.debug(
+                            "Error closing ws during cleanup", exc_info=True
+                        )
+                    self._ws = None
+
+                self.is_connected = False
+                self.logger.info("Client start() cleaned up")
+
+            if not self.reconnect:
+                self.logger.info("Reconnect disabled — exiting start()")
+                return
+
+            self.logger.info("Reconnect enabled — restarting client")
+            await asyncio.sleep(self.reconnect_delay)
+
+
+class SocketMaxClient(SocketMixin, MaxClient):
+    @override
+    async def _wait_forever(self):
+        if self._recv_task:
+            try:
+                await self._recv_task
+            except asyncio.CancelledError:
+                self.logger.debug("Socket recv_task cancelled")
+            except Exception as e:
+                self.logger.exception("Socket recv_task failed: %s", e)

{maxapi_python-1.1.15 → maxapi_python-1.1.17}/src/pymax/exceptions.py

@@ -39,15 +39,6 @@ class SocketSendError(Exception):
         super().__init__("Send and wait failed (socket)")
 
 
-class LoginError(Exception):
-    """
-    Исключение, вызываемое при ошибке авторизации.
-    """
-
-    def __init__(self, message: str) -> None:
-        super().__init__(f"Login error: {message}")
-
-
 class ResponseError(Exception):
     """
     Исключение, вызываемое при ошибке в ответе от сервера.
@@ -64,3 +55,54 @@ class ResponseStructureError(Exception):
 
     def __init__(self, message: str) -> None:
         super().__init__(f"Response structure error: {message}")
+
+
+class Error(Exception):
+    """
+    Базовое исключение для ошибок PyMax.
+    """
+
+    def __init__(
+        self,
+        error: str,
+        message: str,
+        title: str,
+        localized_message: str | None = None,
+    ) -> None:
+        self.error = error
+        self.message = message
+        self.title = title
+        self.localized_message = localized_message
+
+        parts = []
+        if localized_message:
+            parts.append(localized_message)
+        if message:
+            parts.append(message)
+        if title:
+            parts.append(f"({title})")
+        parts.append(f"[{error}]")
+
+        super().__init__("PyMax Error: " + " ".join(parts))
+
+
+class RateLimitError(Error):
+    """
+    Исключение, вызываемое при превышении лимита запросов.
+    """
+
+    def __init__(
+        self, error: str, message: str, title: str, localized_message: str | None = None
+    ) -> None:
+        super().__init__(error, message, title, localized_message)
+
+
+class LoginError(Error):
+    """
+    Исключение, вызываемое при ошибке авторизации.
+    """
+
+    def __init__(
+        self, error: str, message: str, title: str, localized_message: str | None = None
+    ) -> None:
+        super().__init__(error, message, title, localized_message)