feat: support deleting multiple messages

Author: New-dev0

docs/docs/api_reference/methods/delete_message.md

@@ -1,12 +1,12 @@
-# delete_message
+# delete_messages
 
-Deletes a message.
+Delete messages.
 
 Usually you will call this method using the `delete` method of the message object itself.
 
 ## Signature
 
-`async def delete_message(message: int | Message) -> bool`
+`async def delete_messages(message_ids: List[int | Message]) -> bool`
 
 ## Parameters
 

swibots/api/chat/controllers/media_controller.py

@@ -1,18 +1,33 @@
-import asyncio, aiofiles
-import os, tempfile
-import json, mimetypes, re
-from datetime import datetime
-import logging, base64, random
-from io import BytesIO
-import json, mimetypes
-import logging, hashlib
-from uuid import uuid1
+import asyncio
+import aiofiles
+import base64
+import hashlib
 import httpx
-from typing import Union
-from io import BytesIO
+import json
+import logging
+import mimetypes
+import os
+import random
+import re
+import tempfile
 import uuid
+from urllib.parse import urlparse
+from datetime import datetime
 from httpx import AsyncClient
+from io import BytesIO
+from typing import TYPE_CHECKING, Optional, Union
 from typing import TYPE_CHECKING, Optional
+from swibots.api.common.models import Media
+from swibots.config import APP_CONFIG
+from swibots.errors import UnknownBackBlazeError, FileTooLarge
+from swibots.types import MAX_FILE_SIZE
+
+from swibots.utils.types import (
+    DownloadProgressCallback,
+    IOClient,
+    UploadProgress,
+    UploadProgressCallback,
+)
 
 from swibots.errors import UnknownBackBlazeError, FileTooLarge
 from swibots.utils.types import (
@@ -157,14 +172,18 @@ async def file_to_response(
     async def generate_from_ffmpeg(self, path: str, hw: int):
         log.debug("checking for ffmpeg")
         ffmpeg_path = os.getenv("FFMPEG_PATH") or "ffmpeg"
-        proc = await asyncio.create_subprocess_exec(
-            ffmpeg_path, stderr=asyncio.subprocess.PIPE
-        )
-        await proc.wait()
+        try:
+            proc = await asyncio.create_subprocess_exec(
+                ffmpeg_path, stderr=asyncio.subprocess.PIPE
+            )
+            await proc.wait()
+        except Exception as er:
+            logger.error(er)
+            return
         if b"ffmpeg version" not in (er := await proc.stderr.read()):
             log.info(f"ffmpeg is not installed, {er}")
             return
-        name = os.path.join(tempfile.gettempdir(), f"{uuid1()}.png")
+        name = os.path.join(tempfile.gettempdir(), f"{uuid.uuid1()}.png")
         log.info(f"generating thumb for '{path}'")
         cmd = [
             ffmpeg_path,
@@ -192,6 +211,13 @@ async def get_thumb_url(
     ) -> str:
         if not path:
             return
+
+        if path and isinstance(path, str):
+            # check for valid urls
+            parse = urlparse(path)
+            if parse.scheme and parse.netloc:
+                return path
+
         __remove = False
         mime_type = (
             mimetypes.guess_type(path.name if isinstance(path, BytesIO) else path)[0]
@@ -332,8 +358,12 @@ async def upload_media(
             )
         else:
             path, file_response = await self.file_to_response(
-                path, mime_type, file_name, callback=callback, file_size=size,
-                callback_args=callback_args
+                path,
+                mime_type,
+                file_name,
+                callback=callback,
+                file_size=size,
+                callback_args=callback_args,
             )
         if not file_response.get("fileName"):
             raise UnknownBackBlazeError(file_response)
@@ -357,7 +387,7 @@ async def upload_media(
             "sourceUri": file_response["fileId"],
             "checksum": file_response["contentSha1"],
             "ownerId": self.client.app.user.id,
-            "premium": premium
+            "premium": premium,
         }
         return self.client.build_object(Media, media)
 

swibots/api/chat/controllers/message_controller.py

@@ -192,7 +192,6 @@ async def _upload_media(media):
                     premium=premium,
                     for_document=kwargs.get("is_document")
                     or (kwargs.get("media_type", 0) == MediaType.DOCUMENT.value),
-                    
                 )
             elif not media:
                 raise ValueError("'media' or 'document' must be provided!")
@@ -321,7 +320,7 @@ async def edit_message(
         response = await self.client.put(f"{BASE_PATH}?id={message_id}", data=data)
         return self.client.build_object(Message, response.data["message"])
 
-    async def delete_message(self, message: int | Message) -> bool:
+    async def delete_messages(self, message_ids: List[Union[int, Message]]) -> bool:
         """Delete a message
 
         Parameters:
@@ -333,12 +332,15 @@ async def delete_message(self, message: int | Message) -> bool:
         Raises:
             ``~switch.error.SwitchError``: If the message could not be deleted
         """
-        if isinstance(message, Message):
-            id = message.id
-        else:
-            id = message
-        log.debug("Deleting message %s", id)
-        response = await self.client.delete(f"{BASE_PATH}/{id}")
+        message_ids = ",".join(
+            [
+                message.id if isinstance(message, Message) else message
+                for message in message_ids
+            ]
+        )
+        log.debug(f"Deleting message {message_ids}")
+        response = await self.client.delete(f"{BASE_PATH}/{message_ids}")
+        log.debug(response)
         return True
 
     async def delete_messages_from_user(
@@ -430,14 +432,16 @@ async def forward_message(
         q = []
         if group_channel is not None:
             q.append(f"groupChannelId={group_channel}")
-        if user_id is not None:
+        if user_id:
             q.append(f"receiverId={user_id}")
 
         strQuery = "&".join(q)
 
         log.debug("Forwarding message %s", id)
         response = await self.client.put(f"{BASE_PATH}/forward/{message_id}?{strQuery}")
-        message = self.client.build_list(Message, [data.get("message") for data in response.data])
+        message = self.client.build_list(
+            Message, [data.get("message") for data in response.data]
+        )
         if message_id_list:
             return message
         return message[0] if message else None
@@ -752,7 +756,9 @@ async def get_user(self, user_id: int | str = None, username: str = None) -> Use
         if username and user_id:
             raise ValueError("'username' and 'user_id' both were provided!")
         elif user_id:
-            response = await self.client.app.auth_service.get(f"/api/users/getUserById?userid={user_id}")
+            response = await self.client.app.auth_service.get(
+                f"/api/users/getUserById?userid={user_id}"
+            )
         elif username:
             if username.startswith("@"):
                 username = username[1:]

swibots/api/chat/methods/delete_message.py

@@ -1,4 +1,5 @@
-from typing import Type, TypeVar
+import logging
+from typing import Type, TypeVar, List, Union
 import swibots
 from swibots.api.chat.models import Message
 
@@ -18,4 +19,31 @@ async def delete_message(self: "swibots.ApiClient", message: int | Message) -> b
 
         This method does the same as :meth:`~switch.api.chat.controllers.MessageController.delete_message`.
         """
-        return await self.chat_service.messages.delete_message(message)
+        logging.warning("This method is deprecated and is going to be removed in the future! Use client.delete_messages to achieve same results!")
+        return await self.chat_service.messages.delete_messages([message])
+
+    async def delete_messages(self: "swibots.ApiClient", message_ids: List[Union[int, Message]]) -> bool:
+            """Delete one or more messages.
+
+            This method allows you to delete one or more messages from a chat.
+
+            Parameters:
+                message_ids (List[Union[int, Message]]): A list of message IDs or Message objects to delete.
+
+            Returns:
+                bool: True if the messages were deleted successfully, False otherwise.
+
+            Raises:
+                SwitchError: If the messages could not be deleted.
+
+            Note:
+                This method internally calls the :meth:`~switch.api.chat.controllers.MessageController.delete_message` method.
+
+            Example:
+                >>> client = Client(...)
+                >>> message_ids = [1, 2, 3]
+                >>> result = await client.delete_messages(message_ids)
+                >>> print(result)
+                True
+            """
+            return await self.chat_service.messages.delete_messages(message_ids=message_ids)