maxapi-python 0.1.1__py3-none-any.whl → 0.1.2__py3-none-any.whl

{maxapi_python-0.1.1.dist-info → maxapi_python-0.1.2.dist-info}/METADATA

@@ -1,17 +1,21 @@
 Metadata-Version: 2.4
 Name: maxapi-python
-Version: 0.1.1
+Version: 0.1.2
 Summary: Python wrapper для API мессенджера Max
 Project-URL: Homepage, https://github.com/noxzion/PyMax
 Project-URL: Repository, https://github.com/noxzion/PyMax
 Project-URL: Issues, https://github.com/noxzion/PyMax/issues
-Author-email: noxzion <negroid2281488ilikrilex@gmail.com>
+Author-email: noxzion <mail@gmail.com>
 License-Expression: MIT
 License-File: LICENSE
 Keywords: api,max,messenger,websocket,wrapper
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
 Requires-Python: >=3.10
+Requires-Dist: aiofiles>=24.1.0
+Requires-Dist: aiohttp>=3.12.15
+Requires-Dist: lz4>=4.4.4
+Requires-Dist: msgpack>=1.1.1
 Requires-Dist: sqlmodel>=0.0.24
 Requires-Dist: websockets>=11.0
 Description-Content-Type: text/markdown
@@ -31,6 +35,14 @@ Description-Content-Type: text/markdown
     <img src="https://img.shields.io/badge/packaging-uv-D7FF64.svg" alt="Packaging">
 </p>
 
+---
+> ⚠️ **Дисклеймер**
+> 
+> *   Это **неофициальная** библиотека для работы с внутренним API Max.
+> *   Использование может **нарушать условия предоставления услуг** сервиса.
+> *   **Вы используете её исключительно на свой страх и риск.**
+> *   **Разработчики и контрибьюторы не несут никакой ответственности** за любые последствия использования этого пакета, включая, но не ограничиваясь: блокировку аккаунтов, утерю данных, юридические риски и любые другие проблемы.
+> *   API может быть изменен в любой момент без предупреждения.
 ---
 
 ## Описание
@@ -74,7 +86,7 @@ phone = "+1234567890"
 client = MaxClient(phone=phone, work_dir="cache")
 
 # Обработчик входящих сообщений
-@client.on_message
+@client.on_message()
 async def handle_message(message: Message) -> None:
     print(f"{message.sender}: {message.text}")
 
@@ -133,12 +145,16 @@ if __name__ == "__main__":
 
 ## Документация
 
-WIP
+[WIP](https://noxzion.github.io/)
 
 ## Лицензия
 
 Этот проект распространяется под лицензией MIT. См. файл [LICENSE](LICENSE) для получения информации.
 
+## Новости
+
+[Telegram](https://t.me/pymax_news)
+
 ## Авторы
 
 - **[noxzion](https://github.com/noxzion)** — оригинальный автор проекта

maxapi_python-0.1.2.dist-info/RECORD

@@ -0,0 +1,25 @@
+pymax/__init__.py,sha256=I-ZUVKBfHN-MPkLUbLPxflsvnHSFsyXdW3TmbN2_zz0,950
+pymax/core.py,sha256=DjwhOXmMoPl2pT9k18lrZLjlyvzPqkby6hIbPEYlctM,6001
+pymax/crud.py,sha256=_V88YErPKE4k0jPjGn8Op9FDGGVuNwRjuKN-4iIVdgM,3306
+pymax/exceptions.py,sha256=tiD_JD-MYSb4qFyKov-KWOm0zlD1p_gG6nf1fV-0-SY,702
+pymax/files.py,sha256=Bdvzb8xzMCstRHClldj6bh6TE-AplHG3hInjOnGU6f8,2712
+pymax/filters.py,sha256=EKNDzB3jjxlfjMGs3HivFvuQ1HSuYn-xKCxvmRFmq6c,1344
+pymax/interfaces.py,sha256=xAlzVgS4RLChlChZ6WbKLWGezO_b0fHC_2NBePMtyVI,2179
+pymax/models.py,sha256=7sWAmVuJjM7SPnDkpYEi8CARbTpUKbXqtWKMQdwd0w0,209
+pymax/payloads.py,sha256=Pp4vc3BwKzqqWpIce_NhlNw9FA7i6Jhd-hRPg1Ld8Xg,3702
+pymax/static.py,sha256=LQBXSWpiA3a4IWGqC84jTt7LBHSKEqnLDlvgSiMrX_M,4891
+pymax/types.py,sha256=Fsf7_8rkUnCZ7zG_A9P4WJG8wfY8YxZcc-mRLEL3kU0,14140
+pymax/utils.py,sha256=2QnhUb1o-vAIthtodtfrxty9v-qd96OtMd2GMG0n5h4,1402
+pymax/mixins/__init__.py,sha256=yFhB18-PMhn5yIbvIh_XBCTIdkf87M1hmsmMwL9ved0,371
+pymax/mixins/auth.py,sha256=eIlJ5YY7ez99nQuICTu97XWoeKgcjk3ZVhb73qbAsMw,3160
+pymax/mixins/channel.py,sha256=juLIojxsmTXstYfE9pVc98gZ9VSVZJy-chLSDOxay0A,848
+pymax/mixins/group.py,sha256=5MH2S78Q0JxcECEopGPi80QjcTO5bQNOwYLgRx3Gkt4,8040
+pymax/mixins/handler.py,sha256=S6zGnm6U9yNY7LU1MV0TsYQj3MXkeOhiuUGlXyM2kTw,2164
+pymax/mixins/message.py,sha256=pm4YFRmmYdldnk3G4rfjwAbodY-TfeIIvFHez6Xse_o,10542
+pymax/mixins/self.py,sha256=Z1FiWFXJf3Qu9mKTQGrobe01bx4opa-uH5p6wedRWbI,1207
+pymax/mixins/user.py,sha256=V8HLhLMopxItWfc4BF9P3eFjF8ksGAepkqaXrJ1e0ZE,3127
+pymax/mixins/websocket.py,sha256=o7ITyScJNcoBP93dg9itLfGWl1oHmJy31K42j5sUTJQ,9736
+maxapi_python-0.1.2.dist-info/METADATA,sha256=jWYrhQ_-auSt6H_q5vS5OrH6QeQvQ_heeIu-sGSBsas,5930
+maxapi_python-0.1.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+maxapi_python-0.1.2.dist-info/licenses/LICENSE,sha256=Ud-0SKeXO_yA02Bb1nMDnEaSGwz2OqNlfGQbk0IzqPI,1085
+maxapi_python-0.1.2.dist-info/RECORD,,

pymax/__init__.py

@@ -0,0 +1,55 @@
+"""
+Python wrapper для API мессенджера Max
+"""
+
+from .core import (
+    InvalidPhoneError,
+    MaxClient,
+    WebSocketNotConnectedError,
+)
+from .static import (
+    AccessType,
+    AuthType,
+    ChatType,
+    Constants,
+    DeviceType,
+    ElementType,
+    MessageStatus,
+    MessageType,
+    Opcode,
+)
+from .types import (
+    Channel,
+    Chat,
+    Dialog,
+    Element,
+    Message,
+    User,
+)
+
+__author__ = "noxzion"
+
+__all__ = [
+    # Перечисления и константы
+    "AccessType",
+    "AuthType",
+    # Типы данных
+    "Channel",
+    "Chat",
+    "ChatType",
+    "Constants",
+    "DeviceType",
+    "Dialog",
+    "Element",
+    "ElementType",
+    # Исключения
+    "InvalidPhoneError",
+    # Клиент
+    "MaxClient",
+    "Message",
+    "MessageStatus",
+    "MessageType",
+    "Opcode",
+    "User",
+    "WebSocketNotConnectedError",
+]

pymax/core.py

@@ -0,0 +1,156 @@
+import asyncio
+import json
+import logging
+import re
+import time
+from collections.abc import Awaitable, Callable
+from pathlib import Path
+from typing import TYPE_CHECKING, Any
+
+import websockets
+
+from .crud import Database
+from .exceptions import InvalidPhoneError, WebSocketNotConnectedError
+from .mixins import ApiMixin, WebSocketMixin
+from .payloads import (
+    BaseWebSocketMessage,
+    SyncPayload,
+)
+from .static import ChatType, Constants, Opcode
+from .types import Channel, Chat, Dialog, Me, Message, User, override
+
+if TYPE_CHECKING:
+    from .filters import Filter
+
+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".
+
+    Raises:
+        InvalidPhoneError: Если формат номера телефона неверный.
+    """
+
+    def __init__(
+        self,
+        phone: str,
+        uri: str = Constants.WEBSOCKET_URI.value,
+        headers: dict[str, Any] | None = Constants.DEFAULT_USER_AGENT.value,
+        token: str | None = None,
+        work_dir: str = ".",
+        logger: logging.Logger | None = None,
+    ) -> None:
+        self.uri: str = uri
+        self.is_connected: bool = False
+        self.phone: str = phone
+        self.chats: list[Chat] = []
+        self.dialogs: list[Dialog] = []
+        self.channels: list[Channel] = []
+        self.me: Me | None = None
+        self._users: dict[int, User] = {}
+        if not self._check_phone():
+            raise InvalidPhoneError(self.phone)
+        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._ws: websockets.ClientConnection | None = None
+        self._seq: int = 0
+        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._device_id = self._database.get_device_id()
+        self._token = self._database.get_auth_token() or token
+        self.user_agent = headers
+        self._on_message_handlers: list[
+            tuple[Callable[[Message], Any], Filter | None]
+        ] = []
+        self._on_start_handler: Callable[[], Any | Awaitable[Any]] | None = None
+        self._background_tasks: set[asyncio.Task[Any]] = set()
+        self.logger = logger or logging.getLogger(f"{__name__}.MaxClient")
+        self._setup_logger()
+
+        self.logger.debug(
+            "Initialized MaxClient uri=%s work_dir=%s", self.uri, self._work_dir
+        )
+
+    def _setup_logger(self) -> None:
+        self.logger.setLevel(logging.INFO)
+
+        if not logger.handlers:
+            handler = logging.StreamHandler()
+            formatter = logging.Formatter(
+                "%(asctime)s [%(levelname)s] %(name)s: %(message)s"
+            )
+            handler.setFormatter(formatter)
+            logger.addHandler(handler)
+
+    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._ws:
+                await self._ws.close()
+            self.is_connected = False
+            self.logger.info("Client closed")
+        except Exception:
+            self.logger.exception("Error closing client")
+
+    async def start(self) -> None:
+        """
+        Запускает клиент, подключается к WebSocket, авторизует
+        пользователя (если нужно) и запускает фоновый цикл.
+        """
+        try:
+            self.logger.info("Client starting")
+            await self._connect(self.user_agent)
+
+            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 result
+
+            if self._ws:
+                ping_task = asyncio.create_task(self._send_interactive_ping())
+                self._background_tasks.add(ping_task)
+                ping_task.add_done_callback(
+                    lambda t: self._background_tasks.discard(t)
+                    or self._log_task_exception(t)
+                )
+
+                try:
+                    await self._ws.wait_closed()
+                except asyncio.CancelledError:
+                    self.logger.debug("wait_closed cancelled")
+        except Exception:
+            self.logger.exception("Client start failed")
+
+
+class SocketMaxClient:
+    pass  # нокс займись
+    # нет не займусь 

pymax/crud.py

@@ -0,0 +1,99 @@
+from uuid import UUID
+
+from sqlalchemy.engine.base import Engine
+from sqlmodel import Session, SQLModel, create_engine, select
+
+from .models import Auth
+from .static import DeviceType
+
+
+class Database:
+    def __init__(self, workdir: str) -> None:
+        self.workdir = workdir
+        self.engine = self.get_engine(workdir)
+        self.create_all()
+        self._ensure_single_auth()
+
+        self.workdir = workdir
+        self.engine = self.get_engine(workdir)
+        self.create_all()
+        self._ensure_single_auth()
+
+    def create_all(self) -> None:
+        SQLModel.metadata.create_all(self.engine)
+
+    def get_engine(self, workdir: str) -> Engine:
+        return create_engine(f"sqlite:///{workdir}/session.db")
+
+    def get_session(self) -> Session:
+        return Session(bind=self.engine)
+
+    def get_auth_token(self) -> str | None:
+        with self.get_session() as session:
+            return session.exec(select(Auth.token)).first()
+
+    def get_device_id(self) -> UUID:
+        with self.get_session() as session:
+            device_id = session.exec(select(Auth.device_id)).first()
+            if device_id is None:
+                auth = Auth()
+                session.add(auth)
+                session.commit()
+                session.refresh(auth)
+                return auth.device_id
+            return device_id
+
+    def insert_auth(self, auth: Auth) -> Auth:
+        with self.get_session() as session:
+            session.add(auth)
+            session.commit()
+            session.refresh(auth)
+            return auth
+
+    def update_auth_token(self, device_id: UUID, token: str) -> None:
+        with self.get_session() as session:
+            auth = session.exec(select(Auth).where(Auth.device_id == device_id)).first()
+            if auth:
+                auth.token = token
+                session.add(auth)
+                session.commit()
+                session.refresh(auth)
+                return
+
+            existing = session.exec(select(Auth)).first()
+            if existing:
+                existing.device_id = device_id
+                existing.token = token
+                session.add(existing)
+                session.commit()
+                session.refresh(existing)
+                return
+
+            new_auth = Auth(device_id=device_id, token=token)
+            session.add(new_auth)
+            session.commit()
+            session.refresh(new_auth)
+
+    def update(self, auth: Auth) -> Auth:
+        with self.get_session() as session:
+            session.add(auth)
+            session.commit()
+            session.refresh(auth)
+            return auth
+
+    def _ensure_single_auth(self) -> None:
+        with self.get_session() as session:
+            rows = session.exec(select(Auth)).all()
+            if not rows:
+                # Create default Auth with device type from enum
+                auth = Auth(device_type=DeviceType.WEB.value)
+                session.add(auth)
+                session.commit()
+                session.refresh(auth)
+                return
+
+            if len(rows) > 1:
+                _ = rows[0]
+                for extra in rows[1:]:
+                    session.delete(extra)
+                session.commit()

pymax/exceptions.py

@@ -0,0 +1,20 @@
+class InvalidPhoneError(Exception):
+    """
+    Исключение, вызываемое при неверном формате номера телефона.
+
+    Args:
+        phone (str): Некорректный номер телефона.
+    """
+
+    def __init__(self, phone: str) -> None:
+        super().__init__(f"Invalid phone number format: {phone}")
+
+
+class WebSocketNotConnectedError(Exception):
+    """
+    Исключение, вызываемое при попытке обращения к WebSocket,
+    если соединение не установлено.
+    """
+
+    def __init__(self) -> None:
+        super().__init__("WebSocket is not connected")

pymax/files.py

@@ -0,0 +1,85 @@
+import mimetypes
+from abc import ABC, abstractmethod
+from pathlib import Path
+from typing import ClassVar, override
+
+from aiofiles import open as aio_open
+from aiohttp import ClientSession
+
+
+class BaseFile(ABC):
+    def __init__(self, url: str | None = None, path: str | None = None) -> None:
+        self.url = url
+        self.path = path
+
+        if self.url is None and self.path is None:
+            raise ValueError("Either url or path must be provided.")
+
+        if self.url and self.path:
+            raise ValueError("Only one of url or path must be provided.")
+
+    @abstractmethod
+    async def read(self) -> bytes:
+        if self.url:
+            async with ClientSession() as session, session.get(self.url) as response:
+                response.raise_for_status()
+                return await response.read()
+        elif self.path:
+            async with aio_open(self.path, "rb") as f:
+                return await f.read()
+        else:
+            raise ValueError("Either url or path must be provided.")
+
+
+class Photo(BaseFile):
+    ALLOWED_EXTENSIONS: ClassVar[set[str]] = {
+        ".jpg",
+        ".jpeg",
+        ".png",
+        ".gif",
+        ".webp",
+        ".bmp",
+    }  # FIXME: костыль ✅
+
+    def __init__(self, url: str | None = None, path: str | None = None) -> None:
+        super().__init__(url, path)
+
+    def validate_photo(self) -> tuple[str, str] | None:
+        if self.path:
+            extension = Path(self.path).suffix.lower()
+            if extension not in self.ALLOWED_EXTENSIONS:
+                raise ValueError(
+                    f"Invalid photo extension: {extension}. Allowed: {self.ALLOWED_EXTENSIONS}"
+                )
+
+            return (extension[1:], ("image/" + extension[1:]).lower())
+        elif self.url:
+            extension = Path(self.url).suffix.lower()
+            if extension in self.ALLOWED_EXTENSIONS:
+                raise ValueError(
+                    f"Invalid photo extension in URL: {extension}. Allowed: {self.ALLOWED_EXTENSIONS}"
+                )
+
+            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}")
+
+            return (extension[1:], mime_type)
+        return None
+
+    @override
+    async def read(self) -> bytes:
+        return await super().read()
+
+
+class Video(BaseFile):
+    @override
+    async def read(self) -> bytes:
+        return await super().read()
+
+
+class File(BaseFile):
+    @override
+    async def read(self) -> bytes:
+        return await super().read()

pymax/filters.py

@@ -0,0 +1,38 @@
+from .static import MessageStatus, MessageType
+from .types import Message
+
+
+class Filter:
+    def __init__(
+        self,
+        user_id: int | None = None,
+        text: list[str] | None = None,
+        status: MessageStatus | str | None = None,
+        type: MessageType | str | None = None,
+        text_contains: str | None = None,
+        reaction_info: bool | None = None,
+    ) -> None:
+        self.user_id = user_id
+        self.text = text
+        self.status = status
+        self.type = type
+        self.reaction_info = reaction_info
+        self.text_contains = text_contains
+
+    def match(self, message: Message) -> bool:
+        if self.user_id is not None and message.sender != self.user_id:
+            return False
+        if self.text is not None and any(
+            text not in message.text for text in self.text
+        ):
+            return False
+        if self.text_contains is not None and self.text_contains not in message.text:
+            return False
+        if self.status is not None and message.status != self.status:
+            return False
+        if self.type is not None and message.type != self.type:
+            return False
+        if self.reaction_info is not None and message.reactionInfo is None:  # noqa: SIM103
+            return False
+
+        return True

pymax/interfaces.py

@@ -0,0 +1,67 @@
+import asyncio
+import logging
+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
+
+import websockets
+
+from .filters import Filter
+from .static import Constants
+from .types import Channel, Chat, Dialog, Me, Message, User
+
+if TYPE_CHECKING:
+    from uuid import UUID
+
+    from .crud import Database
+
+
+class ClientProtocol(ABC):
+    def __init__(self, logger: Logger) -> None:
+        super().__init__()
+        self.logger = logger
+        self._users: dict[int, User] = {}
+        self.chats: list[Chat] = []
+        self.phone: str = ""
+        self._database: Database
+        self._device_id: UUID
+        self._on_message_handlers: list[
+            tuple[Callable[[Message], Any], Filter | None]
+        ] = []
+        self.uri: str
+        self.is_connected: bool = False
+        self.phone: str
+        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
+        self._database_path: Path
+        self._ws: websockets.ClientConnection | None = None
+        self._seq: int = 0
+        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.user_agent = Constants.DEFAULT_USER_AGENT.value
+        self._on_message_handlers: list[
+            tuple[Callable[[Message], Any], Filter | None]
+        ] = []
+        self._on_start_handler: Callable[[], Any | Awaitable[Any]] | None = None
+        self._background_tasks: set[asyncio.Task[Any]] = set()
+
+    @abstractmethod
+    async def _send_and_wait(
+        self,
+        opcode: int,
+        payload: dict[str, Any],
+        cmd: int = 0,
+        timeout: float = Constants.DEFAULT_TIMEOUT.value,
+    ) -> dict[str, Any]:
+        pass
+
+    @abstractmethod
+    async def _get_chat(self, chat_id: int) -> Chat | None:
+        pass

pymax/mixins/__init__.py

@@ -0,0 +1,18 @@
+from .auth import AuthMixin
+from .channel import ChannelMixin
+from .handler import HandlerMixin
+from .message import MessageMixin
+from .self import SelfMixin
+from .user import UserMixin
+from .websocket import WebSocketMixin
+
+
+class ApiMixin(
+    AuthMixin,
+    HandlerMixin,
+    UserMixin,
+    ChannelMixin,
+    SelfMixin,
+    MessageMixin,
+):
+    pass