maxapi-python 0.1.3__py3-none-any.whl → 1.1.1__py3-none-any.whl

pymax/crud.py

@@ -1,99 +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()
+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

@@ -1,20 +1,29 @@
-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")
+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")
+
+
+class LoginError(Exception):
+    """
+    Исключение, вызываемое при ошибке авторизации.
+    """
+
+    def __init__(self, message: str) -> None:
+        super().__init__(f"Login error: {message}")

pymax/files.py

@@ -1,86 +1,86 @@
-import mimetypes
-from abc import ABC, abstractmethod
-from pathlib import Path
-from typing import ClassVar
-
-from aiofiles import open as aio_open
-from aiohttp import ClientSession
-from typing_extensions import override
-
-
-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()
+import mimetypes
+from abc import ABC, abstractmethod
+from pathlib import Path
+from typing import ClassVar
+
+from aiofiles import open as aio_open
+from aiohttp import ClientSession
+from typing_extensions import override
+
+
+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

@@ -1,38 +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
+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

@@ -1,67 +1,79 @@
-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
+import asyncio
+import logging
+import socket
+import ssl
+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.host: str
+        self.port: int
+        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._session_id: int
+        self._action_id: int = 0
+        self._current_screen: str = "chats_list_tab"
+
+        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._ssl_context: ssl.SSLContext
+        self._socket: socket.socket | None = None
+
+    @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