codex 1.6.0a4__py3-none-any.whl → 1.6.0a5__py3-none-any.whl

codex/exceptions.py

@@ -1,6 +1,8 @@
 """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
@@ -10,6 +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.route import RouteSerializer
 
 LOG = get_logger(__name__)
 
@@ -23,10 +26,20 @@ class SeeOtherRedirectError(APIException):
 
     def __init__(self, detail: Mapping[str, str | dict]):
         """Create a response to pass to the exception handler."""
+        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
+        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 {self.detail.get('reason')} to {self.detail.get('route')} {self.detail.get('settings')}"
-        )
+        LOG.debug(f"redirect {pformat(detail)}")
         # super().__init__ converts every type into strings! do not use it.
 
     def _add_query_params(self, url):
@@ -44,9 +57,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: Mapping = self.detail.get("route", {})  # type: ignore
-        params: dict = route.get("params", DEFAULTS["breadcrumbs"][0])
-        url = reverse(url_name, kwargs=params)
+        url = reverse(url_name, kwargs=self.route_kwargs)
         url = self._add_query_params(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_0028 = "0028_custom_covers"  # TODO merge with 27
 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,68 @@ def _repair_library_groups(apps):
     bad_relations.delete()
 
 
+def _delete_extra_custom_cover_libraries(apps):
+    if not has_applied_migration(MIGRATION_0028):
+        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_0028):
+        return
+    custom_cover_model = apps.get_model("codex", "customcover")
+    now = Now()
+    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_0028
+        ):
+            continue
         _delete_fk_integrity_errors(apps, host_model_name, "Library", "library")
 
     for host_model_name in WATCHED_PATHS:
@@ -378,6 +441,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
 
 
@@ -51,20 +52,30 @@ 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)
+            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)
             data = cls._create_cover_thumbnail(cover_image)
         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}")
+            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)
         librarian_queue.put(task)
@@ -80,9 +91,9 @@ class CoverCreateMixin(CoverPathMixin):
             # 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)
@@ -92,9 +103,9 @@ 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:
@@ -106,12 +117,17 @@ class CoverCreateMixin(CoverPathMixin):
                 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

@@ -11,7 +11,8 @@ from codex.threads import QueuedThread
 class CoverPathMixin(QueuedThread):
     """Path methods for covers."""
 
-    COVER_ROOT = ROOT_CACHE_PATH / "covers"
+    COVERS_ROOT = ROOT_CACHE_PATH / "covers"
+    CUSTOM_COVERS_ROOT = ROOT_CACHE_PATH / "custom-covers"
     _HEX_FILL = 8
     _PATH_STEP = 2
     _ZFILL = 12
@@ -27,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

@@ -8,6 +8,7 @@ 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.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,41 @@ 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 +90,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

codex/librarian/importer/aggregate_metadata.py

@@ -87,7 +87,7 @@ class AggregateMetadataMixin(CleanMetadataMixin):
         return m2m_md
 
     def _get_path_metadata(self, path, import_metadata):
-        """Get the metatada from comicbox and munge it a little."""
+        """Get the metadata from comicbox and munge it a little."""
         md = {}
         fk_md = {}
         group_tree_md = {}
@@ -251,7 +251,7 @@ class AggregateMetadataMixin(CleanMetadataMixin):
         force_import_metadata,
         status=None,
     ):
-        """Get aggregated metatada for the paths given."""
+        """Get aggregated metadata for the paths given."""
         total_paths = len(all_paths)
         if not total_paths:
             return 0

codex/librarian/importer/const.py

@@ -2,17 +2,22 @@
 
 from types import MappingProxyType
 
+from bidict import bidict
+
 from codex.models import (
     Comic,
     Contributor,
+    Folder,
     Imprint,
     Publisher,
     Series,
+    StoryArc,
     StoryArcNumber,
     Volume,
 )
 from codex.models.groups import BrowserGroupModel
 from codex.models.named import Identifier
+from codex.models.paths import CustomCover
 
 #################
 # DICT METADATA #
@@ -139,9 +144,15 @@ BULK_UPDATE_COMIC_FIELDS_WITH_VALUES = tuple(
         - frozenset(BULK_UPDATE_FOLDER_MODIFIED_FIELDS)
     )
 )
-MOVED_BULK_COMIC_UPDATE_FIELDS = ("path", "parent_folder")
-MOVED_BULK_FOLDER_UPDATE_FIELDS = ("path", "parent_folder", *GROUP_BASE_FIELDS)
-
+MOVED_BULK_COMIC_UPDATE_FIELDS = ("path", "parent_folder", "stat", "updated_at")
+MOVED_BULK_FOLDER_UPDATE_FIELDS = (
+    "path",
+    "parent_folder",
+    *GROUP_BASE_FIELDS,
+    "stat",
+    "updated_at",
+)
+CUSTOM_COVER_UPDATE_FIELDS = ("path", "stat", "updated_at", "sort_name", "group")
 
 #########
 # OTHER #
@@ -184,6 +195,15 @@ GROUP_COMPARE_FIELDS = MappingProxyType(
         Volume: ("publisher__name", "imprint__name", "series__name", "name"),
     }
 )
+CLASS_CUSTOM_COVER_GROUP_MAP = bidict(
+    {
+        Publisher: CustomCover.GroupChoice.P.value,
+        Imprint: CustomCover.GroupChoice.I.value,
+        Series: CustomCover.GroupChoice.S.value,
+        StoryArc: CustomCover.GroupChoice.A.value,
+        Folder: CustomCover.GroupChoice.F.value,
+    }
+)
 
 COMIC_FK_FIELD_NAMES = frozenset(
     field.name