codex 1.5.19__py3-none-any.whl → 1.6.0__py3-none-any.whl

codex/exceptions.py

@@ -1,5 +1,9 @@
 """Special Redirect Error."""
 
+from collections.abc import Mapping
+from copy import deepcopy
+from pprint import pformat
+
 from django.shortcuts import redirect
 from django.urls import reverse
 from django.utils.http import urlencode
@@ -8,7 +12,7 @@ from rest_framework.status import HTTP_303_SEE_OTHER
 
 from codex.logger.logging import get_logger
 from codex.serializers.choices import DEFAULTS
-from codex.serializers.redirect import BrowserRedirectSerializer
+from codex.serializers.route import RouteSerializer
 
 LOG = get_logger(__name__)
 
@@ -20,18 +24,29 @@ class SeeOtherRedirectError(APIException):
     default_code = "redirect"
     default_detail = "redirect to a valid route"
 
-    def __init__(self, detail):
+    def __init__(self, detail: Mapping[str, str | dict]):
         """Create a response to pass to the exception handler."""
-        LOG.debug(f"redirect {detail.get('reason')}")
-        serializer = BrowserRedirectSerializer(detail)
-        self.detail: dict = serializer.data  # type: ignore
-        # super().__init__ converts every type into strings!
-        # do not use it.
+        detail = dict(detail)
+        route: dict = detail.get("route", {})  # type: ignore
+        params: dict = route.get("params", DEFAULTS["breadcrumbs"][0])
+        # Save route in server format for redirect reverse
+        params.pop("name", None)
+        self.route_kwargs = params
+        # Serialize route for detail
+        serializer = RouteSerializer(params)
+        route = deepcopy(route)
+        route["params"] = serializer.data
+        detail["route"] = route
+        # Pop uneccissary breadcrumbs.
+        detail.get("settings", {}).pop("breadcrumbs", None)  # type: ignore
+        self.detail: Mapping[str, str | Mapping] = detail  # type: ignore
+        LOG.debug(f"redirect {pformat(detail)}")
+        # super().__init__ converts every type into strings! do not use it.
 
     def _add_query_params(self, url):
         """Change OPDS settings like the frontend does with error.detail."""
         query_params = {}
-        settings = self.detail.get("settings", {})
+        settings: Mapping = self.detail.get("settings", {})  # type: ignore
         if top_group := settings.get("top_group"):
             query_params["top_group"] = top_group
         if order_by := settings.get("order_by"):
@@ -43,9 +58,7 @@ class SeeOtherRedirectError(APIException):
     def get_response(self, url_name):
         """Return a Django Redirect Response."""
         # only used in codex_exception_handler for opds stuff
-        route = self.detail.get("route", {})
-        params = route.get("params", DEFAULTS["route"])
-        url = reverse(url_name, kwargs=params)
+        url = reverse(url_name, kwargs=self.route_kwargs)
         url = self._add_query_params(url)
 
-        return redirect(url)
+        return redirect(url, permanent=False)

codex/integrity.py

@@ -12,12 +12,14 @@ from django.db import DEFAULT_DB_ALIAS, connection, connections
 from django.db.migrations.executor import MigrationExecutor
 from django.db.migrations.recorder import MigrationRecorder
 from django.db.models.functions import Now
+from django.db.models.query import Q
 from django.db.utils import OperationalError
 
 from codex.logger.logging import get_logger
 from codex.settings.settings import (
     CODEX_PATH,
     CONFIG_PATH,
+    CUSTOM_COVERS_DIR,
     DB_PATH,
     SKIP_INTEGRITY_CHECK,
 )
@@ -34,6 +36,7 @@ MIGRATION_0011 = "0010_library_groups_and_metadata_changes"
 MIGRATION_0018 = "0018_rename_userbookmark_bookmark"
 MIGRATION_0025 = "0025_add_story_arc_number"
 MIGRATION_0026 = "0026_comicbox_1"
+MIGRATION_0027 = "0027_import_order_and_covers"
 M2M_NAMES = MappingProxyType(
     {
         "Character": "characters",
@@ -51,7 +54,7 @@ SKIP_M2M_CHECKS = MappingProxyType(
     {"Contributor": MIGRATION_0026, "StoryArcNumber": MIGRATION_0025}
 )
 NULL_SET = frozenset({None})
-HAVE_LIBRARY_FKS = ("FailedImport", "Folder", "Comic")
+HAVE_LIBRARY_FKS = ("FailedImport", "Folder", "Comic", "CustomCover")
 GROUP_HOSTS = MappingProxyType(
     {
         "Imprint": ("Publisher",),
@@ -60,7 +63,6 @@ GROUP_HOSTS = MappingProxyType(
         "Comic": ("Publisher", "Imprint", "Series", "Volume"),
     }
 )
-
 COMIC_FK_FIELDS = MappingProxyType(
     {
         "AgeRating": "age_rating",
@@ -71,7 +73,6 @@ COMIC_FK_FIELDS = MappingProxyType(
         "Tagger": "tagger",
     }
 )
-
 WATCHED_PATHS = ("Comic", "Folder")
 CONTRIBUTOR_FIELDS = MappingProxyType(
     {"ContributorRole": "role", "ContributorPerson": "person"}
@@ -92,6 +93,9 @@ DELETE_BAD_COMIC_FOLDER_RELATIONS_SQL = (
     'IN (SELECT "codex_folder"."id" FROM "codex_folder")))'
 )
 MIGRATION_DIR = CODEX_PATH / "migrations"
+CUSTOM_COVER_MODEL_NAMES = MappingProxyType(
+    {"publisher": "p", "imprint": "i", "series": "s", "storyarc": "a", "folder": "f"}
+)
 
 LOG = get_logger(__name__)
 
@@ -303,9 +307,67 @@ def _repair_library_groups(apps):
     bad_relations.delete()
 
 
+def _delete_extra_custom_cover_libraries(apps):
+    if not has_applied_migration(MIGRATION_0027):
+        return
+    library_model = apps.get_model("codex", "library")
+    custom_cover_libraries = library_model.objects.filter(covers_only=True)
+    if custom_cover_libraries.count() <= 1:
+        return
+
+    # Attempt to remove the bad ones, probably futile
+    bad_lib_pks = []
+    for library in custom_cover_libraries:
+        if library.path != CUSTOM_COVERS_DIR:
+            bad_lib_pks.append(library.pk)
+    delete_libs = library_model.object.filter(pk__in=bad_lib_pks)
+    count = delete_libs.count()
+    if count:
+        delete_libs.delete()
+        LOG.warn(
+            f"Removed {count} duplicate custom cover libraries pointing to unused custom cover dirs."
+        )
+
+    custom_cover_libraries = library_model.object.filter(covers_only=True)
+    count = custom_cover_libraries.count()
+    if count <= 1:
+        return
+    custom_cover_libraries.delete()
+    LOG.warn(
+        f"Removed all ({count}) custom cover libraries, Unable to determine valid one. Will recreate upon startup."
+    )
+
+
+def _repair_groups_with_custom_covers(apps):
+    if not has_applied_migration(MIGRATION_0027):
+        return
+    custom_cover_model = apps.get_model("codex", "customcover")
+    for model_name, group_letter in CUSTOM_COVER_MODEL_NAMES.items():
+        valid_covers = custom_cover_model.objects.filter(group=group_letter)
+        group_model = apps.get_model("codex", model_name)
+        objs = group_model.objects.exclude(
+            Q(custom_cover__isnull=True) | Q(custom_cover__in=valid_covers)
+        )
+        update_groups = []
+        for group in objs:
+            group.custom_cover = None
+            group.updated_at = Now()
+            update_groups.append(group)
+        group_model.objects.bulk_update(update_groups, ["custom_cover"])
+        count = len(update_groups)
+        if count:
+            LOG.warn(f"Removed illegal custom cover links from {count} {model_name}s")
+
+
 def _delete_errors():
     """DELETE things we can't fix."""
+    _delete_extra_custom_cover_libraries(apps)
+
     for host_model_name in HAVE_LIBRARY_FKS:
+        if host_model_name == "CustomCover" and not has_applied_migration(
+            MIGRATION_0027
+        ):
+            continue
         _delete_fk_integrity_errors(apps, host_model_name, "Library", "library")
 
     for host_model_name in WATCHED_PATHS:
@@ -378,6 +440,7 @@ def _repair_integrity():
     _mark_comics_with_bad_rels_for_update(comic_model, bad_comic_ids)
 
     _repair_library_groups(apps)
+    _repair_groups_with_custom_covers(apps)
 
 
 def repair_db():

codex/librarian/covers/coverd.py

@@ -11,7 +11,7 @@ from codex.librarian.covers.tasks import (
 )
 
 
-class CoverContributorThread(CoverCreateMixin, CoverPurgeMixin):
+class CoverThread(CoverCreateMixin, CoverPurgeMixin):
     """Create comic covers in it's own thread."""
 
     def process_item(self, item):
@@ -22,7 +22,7 @@ class CoverContributorThread(CoverCreateMixin, CoverPurgeMixin):
         elif isinstance(task, CoverRemoveAllTask):
             self.purge_all_comic_covers(self.librarian_queue)
         elif isinstance(task, CoverRemoveTask):
-            self.purge_comic_covers(task.comic_pks)
+            self.purge_comic_covers(task.pks, task.custom)
         elif isinstance(task, CoverRemoveOrphansTask):
             self.cleanup_orphan_covers()
         elif isinstance(task, CoverCreateAllTask):

codex/librarian/covers/create.py

@@ -1,6 +1,7 @@
 """Create comic cover paths."""
 
 from io import BytesIO
+from pathlib import Path
 from time import time
 
 from comicbox.box import Comicbox
@@ -10,7 +11,7 @@ from PIL import Image
 from codex.librarian.covers.path import CoverPathMixin
 from codex.librarian.covers.status import CoverStatusTypes
 from codex.librarian.covers.tasks import CoverSaveToCache
-from codex.models import Comic
+from codex.models import Comic, CustomCover
 from codex.status import Status
 
 
@@ -25,17 +26,17 @@ class CoverCreateMixin(CoverPathMixin):
     @classmethod
     def _create_cover_thumbnail(cls, cover_image_data):
         """Isolate the save thumbnail function for leak detection."""
-        with BytesIO() as cover_thumb_buffer:
-            with BytesIO(cover_image_data) as image_io:
-                with Image.open(image_io) as cover_image:
-                    cover_image.thumbnail(
-                        cls._THUMBNAIL_SIZE,
-                        Image.Resampling.LANCZOS,  # type: ignore
-                        reducing_gap=3.0,
-                    )
-                    cover_image.save(cover_thumb_buffer, "WEBP", method=6)
-                cover_image.close()  # extra close for animated sequences
-            return cover_thumb_buffer.getvalue()
+        cover_thumb_buffer = BytesIO()
+        with BytesIO(cover_image_data) as image_io:
+            with Image.open(image_io) as cover_image:
+                cover_image.thumbnail(
+                    cls._THUMBNAIL_SIZE,
+                    Image.Resampling.LANCZOS,  # type: ignore
+                    reducing_gap=3.0,
+                )
+                cover_image.save(cover_thumb_buffer, "WEBP", method=6)
+            cover_image.close()  # extra close for animated sequences
+        return cover_thumb_buffer
 
     @classmethod
     def _get_comic_cover_image(cls, comic_path):
@@ -51,24 +52,37 @@ class CoverCreateMixin(CoverPathMixin):
         return image_data
 
     @classmethod
-    def create_cover_from_path(cls, pk, cover_path, log, librarian_queue):
+    def _get_custom_cover_image(cls, cover_path):
+        """Get cover image from image file."""
+        with Path(cover_path).open("rb") as f:
+            return f.read()
+
+    @classmethod
+    def create_cover_from_path(cls, pk, cover_path, log, librarian_queue, custom=False):  # noqa: PLR0913
         """Create cover for path.
 
         Called from views/cover.
         """
-        comic_path = None
+        db_path = None
         try:
-            comic_path = Comic.objects.only("path").get(pk=pk).path
-            cover_image = cls._get_comic_cover_image(comic_path)
-            data = cls._create_cover_thumbnail(cover_image)
+            model = CustomCover if custom else Comic
+            db_path = model.objects.only("path").get(pk=pk).path
+            if custom:
+                cover_image = cls._get_custom_cover_image(db_path)
+            else:
+                cover_image = cls._get_comic_cover_image(db_path)
+            thumb_buffer = cls._create_cover_thumbnail(cover_image)
+            thumb_bytes = thumb_buffer.getvalue()
+            thumb_buffer.seek(0)
         except Exception as exc:
-            data = b""
-            comic_str = comic_path if comic_path else f"{pk=}"
-            log.warning(f"Could not create cover thumbnail for {comic_str}: {exc}")
+            thumb_bytes = b""
+            thumb_buffer = None
+            cover_str = db_path if db_path else f"{pk=}"
+            log.warning(f"Could not create cover thumbnail for {cover_str}: {exc}")
 
-        task = CoverSaveToCache(cover_path, data)
+        task = CoverSaveToCache(cover_path, thumb_bytes)
         librarian_queue.put(task)
-        return data
+        return thumb_buffer
 
     def save_cover_to_cache(self, cover_path, data):
         """Save cover thumb image to the disk cache."""
@@ -77,11 +91,12 @@ class CoverCreateMixin(CoverPathMixin):
             with cover_path.open("wb") as cover_file:
                 cover_file.write(data)
         elif not cover_path.exists():
-            cover_path.symlink_to(self.MISSING_COVER_PATH)
+            # zero length file is code for missing.
+            cover_path.touch()
 
-    def _bulk_create_comic_covers(self, comic_pks):
+    def _bulk_create_comic_covers(self, pks, custom=False):
         """Create bulk comic covers."""
-        num_comics = len(comic_pks)
+        num_comics = len(pks)
         if not num_comics:
             return None
         status = Status(CoverStatusTypes.CREATE_COVERS, 0, num_comics)
@@ -91,26 +106,33 @@ class CoverCreateMixin(CoverPathMixin):
             self.status_controller.start(status)
 
             # Get comic objects
-            for pk in comic_pks:
+            for pk in pks:
                 # Create all covers.
-                cover_path = self.get_cover_path(pk)
+                cover_path = self.get_cover_path(pk, custom)
                 if cover_path.exists():
                     status.decrement_total()
                 else:
                     # bulk contributor creates covers inline
-                    self.create_cover_from_path(
+                    data = self.create_cover_from_path(
                         pk, cover_path, self.log, self.librarian_queue
                     )
+                    if data:
+                        data.close()
                     status.increment_complete()
                 self.status_controller.update(status)
 
             total_elapsed = naturaldelta(time() - start_time)
-            self.log.info(f"Created {status.complete} comic covers in {total_elapsed}.")
+            desc = "custom" if custom else "comic"
+            self.log.info(
+                f"Created {status.complete} {desc} covers in {total_elapsed}."
+            )
         finally:
             self.status_controller.finish(status)
         return status.complete
 
     def create_all_covers(self):
         """Create all covers for all libraries."""
+        pks = CustomCover.objects.values_list("pk", flat=True)
+        self._bulk_create_comic_covers(pks, True)
         pks = Comic.objects.values_list("pk", flat=True)
-        self._bulk_create_comic_covers(pks)
+        self._bulk_create_comic_covers(pks, False)

codex/librarian/covers/path.py

@@ -4,15 +4,15 @@ from pathlib import Path
 
 from fnvhash import fnv1a_32
 
-from codex.settings.settings import CODEX_PATH, ROOT_CACHE_PATH
+from codex.settings.settings import ROOT_CACHE_PATH
 from codex.threads import QueuedThread
 
 
 class CoverPathMixin(QueuedThread):
     """Path methods for covers."""
 
-    COVER_ROOT = ROOT_CACHE_PATH / "covers"
-    MISSING_COVER_PATH = CODEX_PATH / "img" / "missing-cover.webp"
+    COVERS_ROOT = ROOT_CACHE_PATH / "covers"
+    CUSTOM_COVERS_ROOT = ROOT_CACHE_PATH / "custom-covers"
     _HEX_FILL = 8
     _PATH_STEP = 2
     _ZFILL = 12
@@ -28,16 +28,17 @@ class CoverPathMixin(QueuedThread):
         return Path("/".join(parts))
 
     @classmethod
-    def get_cover_path(cls, pk):
+    def get_cover_path(cls, pk, custom=False):
         """Get cover path for comic pk."""
         cover_path = cls._hex_path(pk)
-        return cls.COVER_ROOT / cover_path.with_suffix(".webp")
+        root = cls.CUSTOM_COVERS_ROOT if custom else cls.COVERS_ROOT
+        return root / cover_path.with_suffix(".webp")
 
     @classmethod
-    def get_cover_paths(cls, comic_pks):
+    def get_cover_paths(cls, pks, custom=False):
         """Get cover paths for many comic pks."""
         cover_paths = set()
-        for comic_pk in comic_pks:
-            cover_path = cls.get_cover_path(comic_pk)
+        for pk in pks:
+            cover_path = cls.get_cover_path(pk, custom)
             cover_paths.add(cover_path)
         return cover_paths

codex/librarian/covers/purge.py

@@ -7,7 +7,8 @@ from pathlib import Path
 from codex.librarian.covers.path import CoverPathMixin
 from codex.librarian.covers.status import CoverStatusTypes
 from codex.librarian.notifier.tasks import LIBRARY_CHANGED_TASK
-from codex.models import Comic, Timestamp
+from codex.models import Comic
+from codex.models.paths import CustomCover
 from codex.status import Status
 
 
@@ -20,17 +21,17 @@ class CoverPurgeMixin(CoverPathMixin):
     )
 
     @classmethod
-    def _cleanup_cover_dirs(cls, path):
+    def _cleanup_cover_dirs(cls, path, cover_root):
         """Recursively remove empty cover directories."""
-        if not path or cls.COVER_ROOT not in path.parents:
+        if not path or cover_root not in path.parents:
             return
         try:
             path.rmdir()
-            cls._cleanup_cover_dirs(path.parent)
+            cls._cleanup_cover_dirs(path.parent, cover_root)
         except OSError:
             pass
 
-    def purge_cover_paths(self, cover_paths):
+    def purge_cover_paths(self, cover_paths, cover_root):
         """Purge a set a cover paths."""
         self.log.debug(f"Removing {len(cover_paths)} possible cover thumbnails...")
         status = Status(CoverStatusTypes.PURGE_COVERS, 0, len(cover_paths))
@@ -46,38 +47,40 @@ class CoverPurgeMixin(CoverPathMixin):
                 cover_dirs.add(cover_path.parent)
                 self.status_controller.update(status)
             for cover_dir in cover_dirs:
-                self._cleanup_cover_dirs(cover_dir)
+                self._cleanup_cover_dirs(cover_dir, cover_root)
             self.log.info(f"Removed {status.complete} cover thumbnails.")
         finally:
             self.status_controller.finish(status)
         return status.complete
 
-    def purge_comic_covers(self, comic_pks):
+    def purge_comic_covers(self, pks: frozenset[int], custom: bool):
         """Purge a set a cover paths."""
-        cover_paths = self.get_cover_paths(comic_pks)
-        return self.purge_cover_paths(cover_paths)
+        cover_paths = self.get_cover_paths(pks, custom)
+        cover_root = self.CUSTOM_COVERS_ROOT if custom else self.COVERS_ROOT
+        return self.purge_cover_paths(cover_paths, cover_root)
 
     def purge_all_comic_covers(self, librarian_queue):
         """Purge every comic cover."""
         self.log.debug("Removing entire comic cover cache.")
         try:
-            shutil.rmtree(self.COVER_ROOT)
+            shutil.rmtree(self.COVERS_ROOT)
             self.log.info("Removed entire comic cover cache.")
+            shutil.rmtree(self.CUSTOM_COVERS_ROOT)
+            self.log.info("Removed entire custom cover cache.")
         except Exception as exc:
             self.log.warning(exc)
-        Timestamp.touch(Timestamp.TimestampChoices.COVERS)
         librarian_queue.put(LIBRARY_CHANGED_TASK)
 
-    def cleanup_orphan_covers(self):
+    def _cleanup_orphan_covers(self, cover_class, cover_root, name):
         """Remove all orphan cover thumbs."""
         try:
-            self.log.debug("Removing covers from missing comics.")
+            self.log.debug(f"Removing covers from missing {name}.")
             self.status_controller.start_many(self._CLEANUP_STATUS_MAP)
-            comic_pks = Comic.objects.all().values_list("pk", flat=True)
-            db_cover_paths = self.get_cover_paths(comic_pks)
+            pks = cover_class.objects.all().values_list("pk", flat=True)
+            db_cover_paths = self.get_cover_paths(pks)
 
             orphan_cover_paths = set()
-            for root, _, filenames in os.walk(self.COVER_ROOT):
+            for root, _, filenames in os.walk(cover_root):
                 root_path = Path(root)
                 for fn in filenames:
                     fs_cover_path = root_path / fn
@@ -86,6 +89,13 @@ class CoverPurgeMixin(CoverPathMixin):
         finally:
             self.status_controller.finish(CoverStatusTypes.FIND_ORPHAN)
 
-        count = self.purge_cover_paths(orphan_cover_paths)
-        self.log.info(f"Removed {count} covers for missing comics.")
+        count = self.purge_cover_paths(orphan_cover_paths, cover_root)
+        self.log.info(f"Removed {count} covers for missing {name}.")
         return count
+
+    def cleanup_orphan_covers(self):
+        """Cleanup both comic and custom covers."""
+        self._cleanup_orphan_covers(Comic, self.COVERS_ROOT, "comics")
+        self._cleanup_orphan_covers(
+            CustomCover, self.CUSTOM_COVERS_ROOT, "custom covers"
+        )

codex/librarian/covers/tasks.py

@@ -5,7 +5,7 @@ from dataclasses import dataclass
 
 @dataclass
 class CoverTask:
-    """Handle with the CoverContributor."""
+    """Handle with the CoverThread."""
 
 
 @dataclass
@@ -29,7 +29,8 @@ class LibrariesTask:
 class CoverRemoveTask(CoverTask):
     """Purge a set of comic covers."""
 
-    comic_pks: frozenset
+    pks: frozenset
+    custom: bool
 
 
 @dataclass