Merge pull request #232 from pSpitzner/filemeta_cleanup

Restyling of asis candidate in inbox view

Author: pSpitzner

CHANGELOG.md

@@ -21,6 +21,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Import Bootleg Button now works as expected [#218](https://github.com/pSpitzner/beets-flask/issues/218)
 - Startup script was not executed correctly if placed in `/config/beets-flask/startup.sh` [#227](https://github.com/pSpitzner/beets-flask/pull/227)
 - Another state-related bug around Searching for Candidates [#225](https://github.com/pSpitzner/beets-flask/issues/225). We now no longer require a certaint type of state before allowing to add candidates.
+- Asis candidates have been restyled to be more consistent with other candidate types. They now also include a cover art preview if available.
 - Fixed a typo in our opiniated beets config [#235](https://github.com/pSpitzner/beets-flask/issues/235)
 
 ### Added
@@ -35,6 +36,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Fixed typing issues in `./tests` folder and enabled mypy check for it.
 - Ruff now has the F401 (imported but unused) check enabled.
 - Ruff now had the UP checks enabled to enforce modern python syntax.
+- Unified coverart components in the frontend, we now use common styling for external and internal coverart.
+- Moved inbox metadata fetching into the library api routes.
 
 ### Dependencies
 

backend/beets_flask/server/app.py

@@ -3,7 +3,7 @@
 import json
 import os
 from dataclasses import asdict, is_dataclass
-from datetime import datetime
+from datetime import date, datetime
 from typing import TYPE_CHECKING, Any
 
 from quart import Quart
@@ -72,7 +72,7 @@ def default(self, o):
             # Might yield strange results for other byte objects
             return o.decode("utf-8")
 
-        if isinstance(o, datetime):
+        if isinstance(o, (datetime, date)):
             return o.isoformat()
 
         # Dataclasses are not serializable by default

backend/beets_flask/server/routes/inbox.py

@@ -1,15 +1,12 @@
 import os
 import shutil
 from datetime import datetime
-from io import BytesIO
 from pathlib import Path
-from typing import TypedDict, cast
+from typing import TypedDict
 
 from cachetools import Cache
-from mediafile import Image, MediaFile  # comes with the beets install
 from quart import Blueprint, jsonify, request
 from sqlalchemy import func, select
-from tinytag import TinyTag
 
 from beets_flask.database import db_session_factory
 from beets_flask.database.models.states import FolderInDb, SessionStateInDb
@@ -24,10 +21,8 @@
 from beets_flask.importer.progress import Progress
 from beets_flask.logger import log
 from beets_flask.server.exceptions import InvalidUsageException, NotFoundException
-from beets_flask.server.routes.library.artwork import send_image
 from beets_flask.server.utility import (
     pop_folder_params,
-    pop_paths_param,
 )
 from beets_flask.server.websocket.status import (
     trigger_clear_cache,
@@ -208,70 +203,6 @@ async def delete():
     )
 
 
-@inbox_bp.route("/metadata", methods=["POST"])
-async def get_multiple_filemeta():
-    params = await request.get_json()
-
-    file_paths = pop_paths_param(params, "file_paths", default=[])
-
-    if len(file_paths) == 0:
-        raise InvalidUsageException("No file paths provided", status_code=400)
-
-    tags = []
-
-    for p in file_paths:
-        if not p.is_file():
-            raise InvalidUsageException(f"Invalid file path: {p}", status_code=400)
-
-        tag = _get_filemeta(p)
-        tags.append(tag)
-
-    return jsonify(tags)
-
-
-def _get_filemeta(path: str | Path):
-    """Get the file metadata for a given audio file."""
-
-    tag = TinyTag.get(path).as_dict()
-    for k, v in tag.items():
-        # TODO: we cant just omit if there are multiple values...
-        if isinstance(v, list):
-            tag[k] = v[0]
-
-    if "filename" in tag:
-        tag["filename"] = str(tag["filename"]).split("/")[-1]
-
-    return tag
-
-
-# TODO: consolidate with the file artwork route from artwork.py
-@inbox_bp.route("/metadata_art/<path:query>", methods=["GET"])
-async def file_art(query: str):
-    """Get the cover art for a given audio file.
-
-    Parameters
-    ----------
-    query : str
-        The path to the file to get the cover art for.
-    """
-    path = Path("/" + query)
-    if not path.is_file():
-        raise NotFoundException(f"File not found: '{path}'.")
-
-    return await send_image(_file_art(path))
-
-
-def _file_art(path: Path):
-    """Get the cover art for a given audio file."""
-
-    mediafile = MediaFile(path)
-    if not mediafile.images or len(mediafile.images) < 1:
-        raise NotFoundException(f"File has no cover art: '{path}'.")
-
-    im: Image = cast(Image, mediafile.images[0])
-    return BytesIO(im.data)
-
-
 # ------------------------------------------------------------------------------------ #
 #                                         Stats                                        #
 # ------------------------------------------------------------------------------------ #

backend/beets_flask/server/routes/library/__init__.py

@@ -11,6 +11,7 @@
 from .artists import artists_bp
 from .artwork import artwork_pb
 from .audio import audio_bp
+from .metadata import metadata_bp
 from .resources import resource_bp
 from .stats import stats_bp
 
@@ -20,7 +21,7 @@
 library_bp.register_blueprint(resource_bp)
 library_bp.register_blueprint(stats_bp)
 library_bp.register_blueprint(artists_bp)
-
+library_bp.register_blueprint(metadata_bp)
 
 from typing import TYPE_CHECKING
 

backend/beets_flask/server/routes/library/artwork.py

@@ -1,7 +1,6 @@
 import os
 from io import BytesIO
 from typing import TYPE_CHECKING, cast
-from urllib.parse import unquote_plus
 
 from beets import util as beets_util
 from mediafile import Image, MediaFile  # comes with the beets install
@@ -54,6 +53,42 @@ def parse_size(size_key: str) -> tuple[int, int] | None:
     return preset
 
 
+def parse_art_params() -> tuple[int, tuple[int, int] | None]:
+    """Parse common artwork parameters from request."""
+    idx = int(request.args.get("index", 0))
+    size_key = request.args.get("size", "small")
+    try:
+        size = parse_size(size_key)
+    except KeyError:
+        raise InvalidUsageException(
+            f"Invalid size key '{size_key}' provided. Supported keys: {', '.join(SIZE_PRESETS.keys())}"
+        )
+    return idx, size
+
+
+def get_image_data_from_file(filepath: str, index: int = 0) -> BytesIO:
+    """Get image data from a file path."""
+    if not os.path.exists(filepath):
+        raise IntegrityException(f"File '{filepath}' does not exist.")
+
+    mediafile = MediaFile(filepath)
+    images = mediafile.images
+    if not images or len(images) <= index:
+        raise NotFoundException(
+            f"File has no cover art at index {index}: '{filepath}'."
+        )
+
+    im: Image = cast(Image, images[index])
+    return BytesIO(im.data)
+
+
+def get_image_count_from_file(filepath: str) -> int:
+    """Get number of images from a file path."""
+    mediafile = MediaFile(filepath)
+    images = mediafile.images
+    return len(images) if images else 0
+
+
 async def send_image(img_data: BytesIO, size: tuple[int, int] | None = None):
     # Resize if preset provided
     if size:
@@ -63,90 +98,51 @@ async def send_image(img_data: BytesIO, size: tuple[int, int] | None = None):
     return response
 
 
+# -------------------------------- Item Routes ------------------------------- #
+
+
 @artwork_pb.route("/item/<int:item_id>/nArtworks", methods=["GET"])
 async def item_art_idx(item_id: int):
-    """Get the number of images for an item.
-
-    This is a HEAD request to check the number of images available for an item.
-    """
+    """Get the number of images for an item."""
     log.debug(f"Item art index query for id:'{item_id}'")
 
-    # Item from beets library
     item = g.lib.get_item(item_id)
     if not item:
         raise NotFoundException(
             f"Item with beets_id:'{item_id}' not found in beets db."
         )
 
-    # File
     item_path = beets_util.syspath(item.path)
-    if not os.path.exists(item_path):
-        raise IntegrityException(
-            f"Item file '{item_path}' does not exist for item beets_id:'{item_id}'."
-        )
-
-    # Get image with mediafile library (comes with beets)
-    mediafile = MediaFile(item_path)
-    images = mediafile.images
-    if not images or len(images) < 1:
-        return jsonify({"count": 0}), 200
-
-    return jsonify({"count": len(images)}), 200
+    count = get_image_count_from_file(item_path)
+    return jsonify({"count": count}), 200
 
 
 @artwork_pb.route("/item/<int:item_id>/art", methods=["GET"])
 async def item_art(item_id: int):
     log.debug(f"Item art query for id:'{item_id}'")
 
-    # Allow selecting image index and size via query params
-    idx = int(request.args.get("index", 0))
-    size_key = request.args.get("size", "small")
-    try:
-        size = parse_size(size_key)
-    except KeyError:
-        raise InvalidUsageException(
-            f"Invalid size key '{size_key}' provided. Supported keys: {', '.join(SIZE_PRESETS.keys())}"
-        )
+    idx, size = parse_art_params()
 
-    # Item from beets library
     item = g.lib.get_item(item_id)
     if not item:
         raise NotFoundException(
             f"Item with beets_id:'{item_id}' not found in beets db."
         )
 
-    # File
     item_path = beets_util.syspath(item.path)
-    if not os.path.exists(item_path):
-        raise IntegrityException(
-            f"Item file '{item_path}' does not exist for item beets_id:'{item_id}'."
-        )
+    img_data = get_image_data_from_file(item_path, idx)
+    return await send_image(img_data, size)
 
-    # Get image with mediafile library (comes with beets)
-    mediafile = MediaFile(item_path)
-    images = mediafile.images
-    if not images or len(images) < 1:
-        raise NotFoundException(f"Item has no cover art: '{item_id}'.")
 
-    im: Image = cast(Image, images[idx])
-    return await send_image(BytesIO(im.data), size)
+# ------------------------------- Album Routes ------------------------------- #
 
 
 @artwork_pb.route("/album/<int:album_id>/art", methods=["GET"])
 async def album_art(album_id: int):
     log.debug(f"Album art query for id:'{album_id}'")
 
-    # Allow selecting image index and size via query params
-    idx = int(request.args.get("index", 0))
-    size_key = request.args.get("size", "small")
-    try:
-        size = parse_size(size_key)
-    except KeyError:
-        raise InvalidUsageException(
-            f"Invalid size key '{size_key}' provided. Supported keys: {', '.join(SIZE_PRESETS.keys())}"
-        )
+    idx, size = parse_art_params()
 
-    # Album from beets library
     album = g.lib.get_album(album_id)
     if not album:
         raise NotFoundException(
@@ -172,37 +168,28 @@ async def album_art(album_id: int):
             ".item_art",
             item_id=items[0].id,
             index=idx,
-            size=size_key,
+            size=request.args.get("size", "small"),
         )
     )
 
 
-@artwork_pb.route("/file/<string:filepath>/art", methods=["GET"])
-async def file_art(filepath: str):
-    # Decode url encoded filepath
-    filepath = unquote_plus(filepath)
-    filepath = beets_util.syspath(filepath)
+# -------------------------------- File Routes ------------------------------- #
 
-    # Allow selecting image index and size via query params
-    idx = int(request.args.get("index", 0))
-    size_key = request.args.get("size", "small")
-    try:
-        size = parse_size(size_key)
-    except KeyError:
-        raise InvalidUsageException(
-            f"Invalid size key '{size_key}' provided. Supported keys: {', '.join(SIZE_PRESETS.keys())}"
-        )
 
-    if not os.path.exists(filepath):
-        raise IntegrityException(f"File '{filepath}' does not exist.")
+@artwork_pb.route("/files/<string:filepath>/nArtworks", methods=["GET"])
+async def file_art_idx(filepath: str):
+    """Get the number of images for a file."""
+    filepath = bytes.fromhex(filepath).decode("utf-8")
+    count = get_image_count_from_file(filepath)
+    return jsonify({"count": count}), 200
 
-    mediafile = MediaFile(filepath)
-    images = mediafile.images
-    if not images or len(images) <= idx:
-        raise NotFoundException(f"File has no cover art at index {idx}: '{filepath}'.")
 
-    im: Image = cast(Image, images[idx])
-    return await send_image(BytesIO(im.data), size)
+@artwork_pb.route("/file/<string:filepath>/art", methods=["GET"])
+async def file_art(filepath: str):
+    filepath = bytes.fromhex(filepath).decode("utf-8")
+    idx, size = parse_art_params()
+    img_data = get_image_data_from_file(filepath, idx)
+    return await send_image(img_data, size)
 
 
 # ---------------------------------- Utils ----------------------------------- #