maxapi-python 1.1.20__py3-none-any.whl → 1.2.1__py3-none-any.whl

pymax/mixins/message.py

@@ -1,9 +1,11 @@
 import asyncio
 import time
 from http import HTTPStatus
+from pathlib import Path
 
 import aiohttp
-from aiohttp import ClientSession
+from aiofiles import open as aio_open
+from aiohttp import ClientSession, TCPConnector
 
 from pymax.exceptions import Error
 from pymax.files import File, Photo, Video
@@ -37,15 +39,17 @@ from pymax.types import (
     FileRequest,
     Message,
     ReactionInfo,
-    VideoAttach,
     VideoRequest,
 )
 
 
 class MessageMixin(ClientProtocol):
+    CHUNK_SIZE = 6 * 1024 * 1024
+
     async def _upload_file(self, file: File) -> None | Attach:
         try:
             self.logger.info("Uploading file")
+
             payload = UploadPayload().model_dump(by_alias=True)
             data = await self._send_and_wait(
                 opcode=Opcode.FILE_UPLOAD,
@@ -60,46 +64,118 @@ class MessageMixin(ClientProtocol):
                 self.logger.error("No upload URL or file ID received")
                 return None
 
-            file_bytes = await file.read()
+            self.logger.debug("Got upload URL and file_id=%s", file_id)
+
+            if file.path:
+                file_size = Path(file.path).stat().st_size
+                self.logger.info(
+                    "File size from path: %.2f MB", file_size / (1024 * 1024)
+                )
+            else:
+                file_bytes = await file.read()
+                file_size = len(file_bytes)
+                self.logger.info(
+                    "File size from URL: %.2f MB", file_size / (1024 * 1024)
+                )
+
+            connector = TCPConnector(limit=0)
+            timeout = aiohttp.ClientTimeout(total=None, sock_read=None, sock_connect=30)
 
             headers = {
                 "Content-Disposition": f"attachment; filename={file.file_name}",
-                "Content-Range": f"0-{len(file_bytes) - 1}/{len(file_bytes)}",
+                "Content-Length": str(file_size),
+                "Content-Range": f"0-{file_size - 1}/{file_size}",
             }
 
             loop = asyncio.get_running_loop()
             fut: asyncio.Future[dict] = loop.create_future()
-            try:
-                self._file_upload_waiters[int(file_id)] = fut
-            except Exception:
-                self.logger.exception("Failed to register file upload waiter")
+            self._file_upload_waiters[int(file_id)] = fut
+
+            async def file_generator():
+                bytes_sent = 0
+                chunk_num = 0
+                self.logger.debug("Starting file streaming from: %s", file.path)
+                async with aio_open(file.path, "rb") as f:
+                    while True:
+                        chunk = await f.read(self.CHUNK_SIZE)
+                        if not chunk:
+                            self.logger.info(
+                                "File streaming complete: %d bytes in %d chunks",
+                                bytes_sent,
+                                chunk_num,
+                            )
+                            break
+
+                        yield chunk
+
+                        bytes_sent += len(chunk)
+                        chunk_num += 1
+                        if chunk_num % 10 == 0:
+                            self.logger.info(
+                                "Upload progress: %.1f MB in %d chunks",
+                                bytes_sent / (1024 * 1024),
+                                chunk_num,
+                            )
+                        if chunk_num % 4 == 0:
+                            await asyncio.sleep(0)
+
+            async def bytes_generator(b: bytes):
+                bytes_sent = 0
+                chunk_num = 0
+                for i in range(0, len(b), self.CHUNK_SIZE):
+                    chunk = b[i : i + self.CHUNK_SIZE]
+                    yield chunk
+                    bytes_sent += len(chunk)
+                    chunk_num += 1
+                    if chunk_num % 10 == 0:
+                        self.logger.info(
+                            "Upload progress: %.1f MB in %d chunks",
+                            bytes_sent / (1024 * 1024),
+                            chunk_num,
+                        )
+                    if chunk_num % 4 == 0:
+                        await asyncio.sleep(0)
+
+            if file.path:
+                data_to_send = file_generator()
+            else:
+                data_to_send = bytes_generator(file_bytes)
+
+            self.logger.info("Starting file upload: %s", file.file_name)
 
             async with (
-                ClientSession() as session,
-                session.post(
-                    url=url,
-                    headers=headers,
-                    data=file_bytes,
-                ) as response,
+                ClientSession(connector=connector, timeout=timeout) as session,
+                session.post(url=url, headers=headers, data=data_to_send) as response,
             ):
+                self.logger.debug("Server response status: %d", response.status)
                 if response.status != HTTPStatus.OK:
-                    self.logger.error(f"Upload failed with status {response.status}")
+                    self.logger.error("Upload failed with status %s", response.status)
                     self._file_upload_waiters.pop(int(file_id), None)
                     return None
 
+                self.logger.debug(
+                    "File sent successfully. Waiting for server confirmation "
+                    "(timeout=%d seconds, fileId=%s)",
+                    DEFAULT_TIMEOUT,
+                    file_id,
+                )
                 try:
                     await asyncio.wait_for(fut, timeout=DEFAULT_TIMEOUT)
+                    self.logger.info(
+                        "File upload completed successfully (fileId=%s)", file_id
+                    )
                     return Attach(_type=AttachType.FILE, file_id=file_id)
                 except asyncio.TimeoutError:
-                    self.logger.error(
+                    self.logger.warning(
                         "Timed out waiting for file processing notification for fileId=%s",
                         file_id,
                     )
                     self._file_upload_waiters.pop(int(file_id), None)
                     return None
-        except Exception as e:
-            self.logger.exception("Upload file failed: %s", str(e))
-            raise e
+
+        except Exception:
+            self.logger.exception("Upload file failed")
+            raise
 
     async def _upload_video(self, video: Video) -> None | Attach:
         try:
@@ -127,10 +203,19 @@ class MessageMixin(ClientProtocol):
                 return None
 
             file_bytes = await video.read()
+            file_size = len(file_bytes)
+
+            # Настройки для ClientSession
+            connector = TCPConnector(limit=0)
+            timeout = aiohttp.ClientTimeout(
+                total=900, sock_read=60
+            )  # 15 минут на видео
 
             headers = {
                 "Content-Disposition": f"attachment; filename={video.file_name}",
-                "Content-Range": f"0-{len(file_bytes) - 1}/{len(file_bytes)}",
+                "Content-Range": f"0-{file_size - 1}/{file_size}",
+                "Content-Length": str(file_size),
+                "Connection": "keep-alive",
             }
 
             loop = asyncio.get_running_loop()
@@ -140,35 +225,45 @@ class MessageMixin(ClientProtocol):
             except Exception:
                 self.logger.exception("Failed to register file upload waiter")
 
-            async with (
-                ClientSession() as session,
-                session.post(
-                    url=url,
-                    headers=headers,
-                    data=file_bytes,
-                ) as response,
-            ):
-                if response.status != HTTPStatus.OK:
-                    self.logger.error(f"Upload failed with status {response.status}")
-                    self._file_upload_waiters.pop(int(video_id), None)
-                    return None
-
-                try:
-                    await asyncio.wait_for(fut, timeout=DEFAULT_TIMEOUT)
-                    return Attach(
-                        _type=AttachType.VIDEO, video_id=video_id, token=token
-                    )
-                except asyncio.TimeoutError:
-                    self.logger.error(
-                        "Timed out waiting for video processing notification for videoId=%s",
-                        video_id,
+            try:
+                async with ClientSession(
+                    connector=connector, timeout=timeout
+                ) as session:
+                    async with session.post(
+                        url=url,
+                        headers=headers,
+                        data=file_bytes,
+                    ) as response:
+                        if response.status != HTTPStatus.OK:
+                            self.logger.error(
+                                "Upload failed with status %s", response.status
+                            )
+                            self._file_upload_waiters.pop(int(video_id), None)
+                            return None
+
+                        try:
+                            await asyncio.wait_for(fut, timeout=DEFAULT_TIMEOUT)
+                            return Attach(
+                                _type=AttachType.VIDEO, video_id=video_id, token=token
+                            )
+                        except asyncio.TimeoutError:
+                            self.logger.warning(
+                                "Timed out waiting for video processing notification for videoId=%s",
+                                video_id,
+                            )
+                            self._file_upload_waiters.pop(int(video_id), None)
+                            return None
+            except OSError as e:
+                if "malloc failure" in str(e) or "BUF" in str(e):
+                    self.logger.exception(
+                        "Memory error during video upload. File too large or insufficient memory. Try uploading smaller files or free up memory."
                     )
                     self._file_upload_waiters.pop(int(video_id), None)
-                    return None
+                raise
 
-        except Exception as e:
-            self.logger.exception("Upload video failed: %s", str(e))
-            raise e
+        except Exception:
+            self.logger.exception("Upload video failed")
+            raise
 
     async def _upload_photo(self, photo: Photo) -> None | Attach:
         try:
@@ -265,7 +360,25 @@ class MessageMixin(ClientProtocol):
         use_queue: bool = False,
     ) -> Message | None:
         """
-        Отправляет сообщение в чат.
+        Отправляет текстовое сообщение в чат с опциональными вложениями.
+
+        :param text: Текст сообщения.
+        :type text: str
+        :param chat_id: Идентификатор чата, в который отправляется сообщение.
+        :type chat_id: int
+        :param notify: Флаг оповещения о новом сообщении. По умолчанию True.
+        :type notify: bool
+        :param attachment: Одно вложение (фото, файл или видео).
+        :type attachment: Photo | File | Video | None
+        :param attachments: Список множественных вложений.
+        :type attachments: list[Photo | File | Video] | None
+        :param reply_to: Идентификатор сообщения для ответа.
+        :type reply_to: int | None
+        :param use_queue: Использовать очередь для отправки. По умолчанию False.
+        :type use_queue: bool
+        :return: Объект сообщения или None, если используется очередь.
+        :rtype: Message | None
+        :raises Error: Если загрузка вложения или отправка сообщения не удалась.
         """
 
         self.logger.info("Sending message to chat_id=%s notify=%s", chat_id, notify)
@@ -301,9 +414,9 @@ class MessageMixin(ClientProtocol):
 
         elements = []
         clean_text = None
-        raw_elements = Formatting.get_elements_from_markdown(text)[0]
+        raw_elements, parsed_text = Formatting.get_elements_from_markdown(text)
         if raw_elements:
-            clean_text = Formatting.get_elements_from_markdown(text)[1]
+            clean_text = parsed_text
         elements = [
             MessageElement(type=e.type, length=e.length, from_=e.from_)
             for e in raw_elements
@@ -349,6 +462,25 @@ class MessageMixin(ClientProtocol):
         attachments: list[Photo | Video | File] | None = None,
         use_queue: bool = False,
     ) -> Message | None:
+        """
+        Редактирует текст и/или вложения существующего сообщения.
+
+        :param chat_id: Идентификатор чата.
+        :type chat_id: int
+        :param message_id: Идентификатор сообщения для редактирования.
+        :type message_id: int
+        :param text: Новый текст сообщения.
+        :type text: str
+        :param attachment: Новое вложение (фото, файл или видео).
+        :type attachment: Photo | File | Video | None
+        :param attachments: Список новых множественных вложений.
+        :type attachments: list[Photo | Video | File] | None
+        :param use_queue: Использовать очередь для отправки.
+        :type use_queue: bool
+        :return: Отредактированное сообщение или None.
+        :rtype: Message | None
+        :raises Error: Если редактирование не удалось.
+        """
         self.logger.info(
             "Editing message chat_id=%s message_id=%s", chat_id, message_id
         )
@@ -428,7 +560,18 @@ class MessageMixin(ClientProtocol):
         use_queue: bool = False,
     ) -> bool:
         """
-        Удаляет сообщения.
+        Удаляет одно или несколько сообщений.
+
+        :param chat_id: Идентификатор чата.
+        :type chat_id: int
+        :param message_ids: Список идентификаторов сообщений для удаления.
+        :type message_ids: list[int]
+        :param for_me: Удалить только для себя (не видимо другим).
+        :type for_me: bool
+        :param use_queue: Использовать очередь для отправки.
+        :type use_queue: bool
+        :return: True, если сообщения успешно удалены.
+        :rtype: bool
         """
         self.logger.info(
             "Deleting messages chat_id=%s ids=%s for_me=%s",
@@ -458,15 +601,16 @@ class MessageMixin(ClientProtocol):
         self, chat_id: int, message_id: int, notify_pin: bool
     ) -> bool:
         """
-        Закрепляет сообщение.
-
-        Args:
-            chat_id (int): ID чата
-            message_id (int): ID сообщения
-            notify_pin (bool): Оповещать о закреплении
-
-        Returns:
-            bool: True, если сообщение закреплено
+        Закрепляет сообщение в чате.
+
+        :param chat_id: Идентификатор чата.
+        :type chat_id: int
+        :param message_id: Идентификатор сообщения.
+        :type message_id: int
+        :param notify_pin: Отправить уведомление о закреплении.
+        :type notify_pin: bool
+        :return: True, если сообщение успешно закреплено.
+        :rtype: bool
         """
         payload = PinMessagePayload(
             chat_id=chat_id,
@@ -490,7 +634,18 @@ class MessageMixin(ClientProtocol):
         backward: int = 200,
     ) -> list[Message] | None:
         """
-        Получает историю сообщений чата.
+        Получает историю сообщений из чата.
+
+        :param chat_id: Идентификатор чата.
+        :type chat_id: int
+        :param from_time: Временная метка для начала выборки.
+        :type from_time: int | None
+        :param forward: Кол-во сообщений вперед от from_time.
+        :type forward: int
+        :param backward: Кол-во сообщений назад от from_time.
+        :type backward: int
+        :return: Список сообщений или None.
+        :rtype: list[Message] | None
         """
         if from_time is None:
             from_time = int(time.time() * 1000)
@@ -534,15 +689,14 @@ class MessageMixin(ClientProtocol):
         """
         Получает видео
 
-        Args:
-            chat_id (int): ID чата
-            message_id (int): ID сообщения
-            video_id (int): ID видео
-
-        Returns:
-            external (str): Странная ссылка из апи
-            cache (bool): True, если видео кэшировано
-            url (str): Ссылка на видео
+        :param chat_id: ID чата
+        :type chat_id: int
+        :param message_id: ID сообщения
+        :type message_id: int
+        :param video_id: ID видео
+        :type video_id: int
+        :return: Объект VideoRequest или None
+        :rtype: VideoRequest | None
         """
         self.logger.info("Getting video_id=%s message_id=%s", video_id, message_id)
 
@@ -578,14 +732,14 @@ class MessageMixin(ClientProtocol):
         """
         Получает файл
 
-        Args:
-            chat_id (int): ID чата
-            message_id (int): ID сообщения
-            file_id (int): ID видео
-
-        Returns:
-            unsafe (bool): Проверка файла на безопасность максом
-            url (str): Ссылка на скачивание файла
+        :param chat_id: ID чата
+        :type chat_id: int
+        :param message_id: ID сообщения
+        :type message_id: int
+        :param file_id: ID файла
+        :type file_id: int
+        :return: Объект FileRequest или None
+        :rtype: FileRequest | None
         """
         self.logger.info("Getting file_id=%s message_id=%s", file_id, message_id)
         if self.is_connected and self._socket is not None:
@@ -620,13 +774,14 @@ class MessageMixin(ClientProtocol):
         """
         Добавляет реакцию к сообщению.
 
-        Args:
-            chat_id (int): ID чата
-            message_id (int): ID сообщения
-            reaction (str): Реакция (эмодзи)
-
-        Returns:
-            ReactionInfo | None: Информация о реакции или None при ошибке.
+        :param chat_id: ID чата
+        :type chat_id: int
+        :param message_id: ID сообщения
+        :type message_id: str
+        :param reaction: Реакция для добавления
+        :type reaction: str (emoji)
+        :return: Объект ReactionInfo или None
+        :rtype: ReactionInfo | None
         """
         try:
             self.logger.info(
@@ -665,13 +820,12 @@ class MessageMixin(ClientProtocol):
         """
         Получает реакции на сообщения.
 
-        Args:
-            chat_id (int): ID чата
-            message_ids (list[str]): Список ID сообщений
-
-        Returns:
-            dict[str, ReactionInfo] | None: Словарь с ID сообщений и информацией
-            о реакциях или None при ошибке.
+        :param chat_id: ID чата
+        :type chat_id: int
+        :param message_ids: Список ID сообщений
+        :type message_ids: list[str]
+        :return: Словарь с ID сообщений и соответствующими реакциями
+        :rtype: dict[str, ReactionInfo] | None
         """
         self.logger.info(
             "Getting reactions for messages chat_id=%s message_ids=%s",
@@ -707,12 +861,12 @@ class MessageMixin(ClientProtocol):
         """
         Удаляет реакцию с сообщения.
 
-        Args:
-            chat_id (int): ID чата
-            message_id (str): ID сообщения
-
-        Returns:
-            ReactionInfo | None: Информация о реакции или None при ошибке.
+        :param chat_id: ID чата
+        :type chat_id: int
+        :param message_id: ID сообщения
+        :type message_id: str
+        :return: Объект ReactionInfo или None
+        :rtype: ReactionInfo | None
         """
         self.logger.info(
             "Removing reaction from message chat_id=%s message_id=%s",

pymax/mixins/scheduler.py

@@ -0,0 +1,28 @@
+import asyncio
+import traceback
+from collections.abc import Awaitable, Callable
+from typing import Any
+
+from pymax.interfaces import ClientProtocol
+
+
+class SchedulerMixin(ClientProtocol):
+    async def _run_periodic(
+        self, func: Callable[[], Any | Awaitable[Any]], interval: float
+    ) -> None:
+        while True:
+            try:
+                result = func()
+                if asyncio.iscoroutine(result):
+                    await result
+            except Exception as e:
+                tb = traceback.format_exc()
+                self.logger.error(f"Error in scheduled task {func}: {e}")
+                raise
+            await asyncio.sleep(interval)
+
+    async def _start_scheduled_tasks(self) -> None:
+        for func, interval in self._scheduled_tasks:
+            task = asyncio.create_task(self._run_periodic(func, interval))
+            self._background_tasks.add(task)
+            task.add_done_callback(self._background_tasks.discard)