fix: Correctly resize and save small artwork

backend/endpoints/collections.py

@@ -1,7 +1,8 @@
 import json
+from io import BytesIO
 from shutil import rmtree
 
-from anyio import open_file
+from anyio import Path
 from config import RESOURCES_BASE_PATH
 from decorators.auth import protected_route
 from endpoints.responses import MessageResponse
@@ -17,6 +18,7 @@
 from handler.filesystem.base_handler import CoverSize
 from logger.logger import log
 from models.collection import Collection
+from PIL import Image
 from sqlalchemy.inspection import inspect
 from utils.router import APIRouter
 
@@ -62,15 +64,14 @@ async def add_collection(
             artwork_path,
         ) = await fs_resource_handler.build_artwork_path(_added_collection, file_ext)
 
-        artwork_file = artwork.file.read()
-        file_location_s = f"{artwork_path}/small.{file_ext}"
-        async with await open_file(file_location_s, "wb+") as artwork_s:
-            await artwork_s.write(artwork_file)
-            fs_resource_handler.resize_cover_to_small(file_location_s)
-
-        file_location_l = f"{artwork_path}/big.{file_ext}"
-        async with await open_file(file_location_l, "wb+") as artwork_l:
-            await artwork_l.write(artwork_file)
+        artwork_content = BytesIO(await artwork.read())
+        file_location_small = Path(f"{artwork_path}/small.{file_ext}")
+        file_location_large = Path(f"{artwork_path}/big.{file_ext}")
+        with Image.open(artwork_content) as img:
+            img.save(file_location_large)
+            fs_resource_handler.resize_cover_to_small(
+                img, save_path=file_location_small
+            )
     else:
         path_cover_s, path_cover_l = await fs_resource_handler.get_cover(
             overwrite=True,
@@ -183,15 +184,15 @@ async def update_collection(
             cleaned_data["path_cover_l"] = path_cover_l
             cleaned_data["path_cover_s"] = path_cover_s
 
-            artwork_file = artwork.file.read()
-            file_location_s = f"{artwork_path}/small.{file_ext}"
-            async with await open_file(file_location_s, "wb+") as artwork_s:
-                await artwork_s.write(artwork_file)
-                fs_resource_handler.resize_cover_to_small(file_location_s)
+            artwork_content = BytesIO(await artwork.read())
+            file_location_small = Path(f"{artwork_path}/small.{file_ext}")
+            file_location_large = Path(f"{artwork_path}/big.{file_ext}")
+            with Image.open(artwork_content) as img:
+                img.save(file_location_large)
+                fs_resource_handler.resize_cover_to_small(
+                    img, save_path=file_location_small
+                )
 
-            file_location_l = f"{artwork_path}/big.{file_ext}"
-            async with await open_file(file_location_l, "wb+") as artwork_l:
-                await artwork_l.write(artwork_file)
             cleaned_data.update({"url_cover": ""})
         else:
             if data.get("url_cover", "") != collection.url_cover or not (

backend/endpoints/rom.py

@@ -1,10 +1,11 @@
 import binascii
 from base64 import b64encode
+from io import BytesIO
 from shutil import rmtree
 from typing import Annotated
 from urllib.parse import quote
 
-from anyio import Path, open_file
+from anyio import Path
 from config import (
     DEV_MODE,
     DISABLE_DOWNLOAD_ENDPOINT_AUTH,
@@ -23,6 +24,7 @@
 from handler.filesystem.base_handler import CoverSize
 from handler.metadata import meta_igdb_handler, meta_moby_handler
 from logger.logger import log
+from PIL import Image
 from starlette.requests import ClientDisconnect
 from starlette.responses import FileResponse
 from streaming_form_data import StreamingFormDataParser
@@ -433,15 +435,15 @@ async def update_rom(
                 {"path_cover_s": path_cover_s, "path_cover_l": path_cover_l}
             )
 
-            artwork_file = artwork.file.read()
-            file_location_s = f"{artwork_path}/small.{file_ext}"
-            async with await open_file(file_location_s, "wb+") as artwork_s:
-                await artwork_s.write(artwork_file)
-                fs_resource_handler.resize_cover_to_small(file_location_s)
+            artwork_content = BytesIO(await artwork.read())
+            file_location_small = Path(f"{artwork_path}/small.{file_ext}")
+            file_location_large = Path(f"{artwork_path}/big.{file_ext}")
+            with Image.open(artwork_content) as img:
+                img.save(file_location_large)
+                fs_resource_handler.resize_cover_to_small(
+                    img, save_path=file_location_small
+                )
 
-            file_location_l = f"{artwork_path}/big.{file_ext}"
-            async with await open_file(file_location_l, "wb+") as artwork_l:
-                await artwork_l.write(artwork_file)
             cleaned_data.update({"url_cover": ""})
         else:
             if data.get("url_cover", "") != rom.url_cover or not (

backend/handler/filesystem/resources_handler.py

@@ -7,7 +7,7 @@
 from logger.logger import log
 from models.collection import Collection
 from models.rom import Rom
-from PIL import Image
+from PIL import Image, ImageFile
 from utils.context import ctx_httpx_client
 
 from .base_handler import CoverSize, FSHandler
@@ -33,9 +33,8 @@ async def cover_exists(entity: Rom | Collection, size: CoverSize) -> bool:
         return False
 
     @staticmethod
-    def resize_cover_to_small(cover_path: str) -> None:
-        """Path of the cover image to resize"""
-        cover = Image.open(cover_path)
+    def resize_cover_to_small(cover: ImageFile.ImageFile, save_path: Path) -> None:
+        """Resize cover to small size, and save it to filesystem."""
         if cover.height >= 1000:
             ratio = 0.2
         else:
@@ -44,7 +43,7 @@ def resize_cover_to_small(cover_path: str) -> None:
         small_height = int(cover.height * ratio)
         small_size = (small_width, small_height)
         small_img = cover.resize(small_size)
-        small_img.save(cover_path)
+        small_img.save(save_path)
 
     async def _store_cover(
         self, entity: Rom | Collection, url_cover: str, size: CoverSize
@@ -57,15 +56,15 @@ async def _store_cover(
             url_cover: url to get the cover
             size: size of the cover
         """
-        cover_file = f"{size.value}.png"
-        cover_path = f"{RESOURCES_BASE_PATH}/{entity.fs_resources_path}/cover"
+        cover_path = Path(f"{RESOURCES_BASE_PATH}/{entity.fs_resources_path}/cover")
+        cover_file = cover_path / Path(f"{size.value}.png")
 
         httpx_client = ctx_httpx_client.get()
         try:
             async with httpx_client.stream("GET", url_cover, timeout=120) as response:
                 if response.status_code == 200:
-                    await Path(cover_path).mkdir(parents=True, exist_ok=True)
-                    async with await open_file(f"{cover_path}/{cover_file}", "wb") as f:
+                    await cover_path.mkdir(parents=True, exist_ok=True)
+                    async with await cover_file.open("wb") as f:
                         async for chunk in response.aiter_raw():
                             await f.write(chunk)
         except httpx.NetworkError as exc:
@@ -77,7 +76,8 @@ async def _store_cover(
             log.warning(f"Failure writing cover {url_cover} to file (ProtocolError)")
 
         if size == CoverSize.SMALL:
-            self.resize_cover_to_small(f"{cover_path}/{cover_file}")
+            with Image.open(cover_file) as img:
+                self.resize_cover_to_small(img, save_path=cover_file)
 
     @staticmethod
     async def _get_cover_path(entity: Rom | Collection, size: CoverSize) -> str: