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

codex/exceptions.py

@@ -1,9 +1,5 @@
 """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
@@ -12,6 +8,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__)
@@ -24,29 +21,26 @@ class SeeOtherRedirectError(APIException):
     default_code = "redirect"
     default_detail = "redirect to a valid route"
 
-    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
-        params.pop("name", None)
-        self.route_kwargs = params
-        # Serialize route for detail
+    def _coerce_pks_to_string(self, detail):
+        """Coerce pks to valid string."""
+        params = detail.get("route", {}).get("params", DEFAULTS["breadcrumbs"][0])
         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)}")
+        detail["route"]["params"] = serializer.data
+
+    def __init__(self, detail):
+        """Create a response to pass to the exception handler."""
+        self._coerce_pks_to_string(detail)
+        serializer = BrowserRedirectSerializer(detail)
+        self.detail: dict = serializer.data  # type: ignore
+        LOG.debug(
+            f"redirect {self.detail.get('reason')} to {self.detail.get('route')} {self.detail.get('settings')}"
+        )
         # 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: Mapping = self.detail.get("settings", {})  # type: ignore
+        settings = self.detail.get("settings", {})
         if top_group := settings.get("top_group"):
             query_params["top_group"] = top_group
         if order_by := settings.get("order_by"):
@@ -58,7 +52,9 @@ class SeeOtherRedirectError(APIException):
     def get_response(self, url_name):
         """Return a Django Redirect Response."""
         # only used in codex_exception_handler for opds stuff
-        url = reverse(url_name, kwargs=self.route_kwargs)
+        route = self.detail.get("route", {})
+        params = route.get("params", DEFAULTS["breadcrumbs"][0])
+        url = reverse(url_name, kwargs=params)
         url = self._add_query_params(url)
 
         return redirect(url, permanent=False)

codex/integrity.py

@@ -12,14 +12,12 @@ 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,
 )
@@ -36,7 +34,6 @@ 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",
@@ -54,7 +51,7 @@ SKIP_M2M_CHECKS = MappingProxyType(
     {"Contributor": MIGRATION_0026, "StoryArcNumber": MIGRATION_0025}
 )
 NULL_SET = frozenset({None})
-HAVE_LIBRARY_FKS = ("FailedImport", "Folder", "Comic", "CustomCover")
+HAVE_LIBRARY_FKS = ("FailedImport", "Folder", "Comic")
 GROUP_HOSTS = MappingProxyType(
     {
         "Imprint": ("Publisher",),
@@ -63,6 +60,7 @@ GROUP_HOSTS = MappingProxyType(
         "Comic": ("Publisher", "Imprint", "Series", "Volume"),
     }
 )
+
 COMIC_FK_FIELDS = MappingProxyType(
     {
         "AgeRating": "age_rating",
@@ -73,6 +71,7 @@ COMIC_FK_FIELDS = MappingProxyType(
         "Tagger": "tagger",
     }
 )
+
 WATCHED_PATHS = ("Comic", "Folder")
 CONTRIBUTOR_FIELDS = MappingProxyType(
     {"ContributorRole": "role", "ContributorPerson": "person"}
@@ -93,9 +92,6 @@ 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__)
 
@@ -307,67 +303,9 @@ 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:
@@ -440,7 +378,6 @@ 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 CoverThread(CoverCreateMixin, CoverPurgeMixin):
+class CoverContributorThread(CoverCreateMixin, CoverPurgeMixin):
     """Create comic covers in it's own thread."""
 
     def process_item(self, item):
@@ -22,7 +22,7 @@ class CoverThread(CoverCreateMixin, CoverPurgeMixin):
         elif isinstance(task, CoverRemoveAllTask):
             self.purge_all_comic_covers(self.librarian_queue)
         elif isinstance(task, CoverRemoveTask):
-            self.purge_comic_covers(task.pks, task.custom)
+            self.purge_comic_covers(task.comic_pks)
         elif isinstance(task, CoverRemoveOrphansTask):
             self.cleanup_orphan_covers()
         elif isinstance(task, CoverCreateAllTask):

codex/librarian/covers/create.py

@@ -1,7 +1,6 @@
 """Create comic cover paths."""
 
 from io import BytesIO
-from pathlib import Path
 from time import time
 
 from comicbox.box import Comicbox
@@ -11,7 +10,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, CustomCover
+from codex.models import Comic
 from codex.status import Status
 
 
@@ -26,17 +25,17 @@ class CoverCreateMixin(CoverPathMixin):
     @classmethod
     def _create_cover_thumbnail(cls, cover_image_data):
         """Isolate the save thumbnail function for leak detection."""
-        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
+        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()
 
     @classmethod
     def _get_comic_cover_image(cls, comic_path):
@@ -52,37 +51,24 @@ class CoverCreateMixin(CoverPathMixin):
         return image_data
 
     @classmethod
-    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
+    def create_cover_from_path(cls, pk, cover_path, log, librarian_queue):
         """Create cover for path.
 
         Called from views/cover.
         """
-        db_path = None
+        comic_path = None
         try:
-            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)
+            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)
         except Exception as 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}")
+            data = b""
+            comic_str = comic_path if comic_path else f"{pk=}"
+            log.warning(f"Could not create cover thumbnail for {comic_str}: {exc}")
 
-        task = CoverSaveToCache(cover_path, thumb_bytes)
+        task = CoverSaveToCache(cover_path, data)
         librarian_queue.put(task)
-        return thumb_buffer
+        return data
 
     def save_cover_to_cache(self, cover_path, data):
         """Save cover thumb image to the disk cache."""
@@ -94,9 +80,9 @@ class CoverCreateMixin(CoverPathMixin):
             # zero length file is code for missing.
             cover_path.touch()
 
-    def _bulk_create_comic_covers(self, pks, custom=False):
+    def _bulk_create_comic_covers(self, comic_pks):
         """Create bulk comic covers."""
-        num_comics = len(pks)
+        num_comics = len(comic_pks)
         if not num_comics:
             return None
         status = Status(CoverStatusTypes.CREATE_COVERS, 0, num_comics)
@@ -106,33 +92,26 @@ class CoverCreateMixin(CoverPathMixin):
             self.status_controller.start(status)
 
             # Get comic objects
-            for pk in pks:
+            for pk in comic_pks:
                 # Create all covers.
-                cover_path = self.get_cover_path(pk, custom)
+                cover_path = self.get_cover_path(pk)
                 if cover_path.exists():
                     status.decrement_total()
                 else:
                     # bulk contributor creates covers inline
-                    data = self.create_cover_from_path(
+                    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)
-            desc = "custom" if custom else "comic"
-            self.log.info(
-                f"Created {status.complete} {desc} covers in {total_elapsed}."
-            )
+            self.log.info(f"Created {status.complete} comic 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, False)
+        self._bulk_create_comic_covers(pks)

codex/librarian/covers/path.py

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

codex/librarian/covers/purge.py

@@ -7,8 +7,7 @@ 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
-from codex.models.paths import CustomCover
+from codex.models import Comic, Timestamp
 from codex.status import Status
 
 
@@ -21,17 +20,17 @@ class CoverPurgeMixin(CoverPathMixin):
     )
 
     @classmethod
-    def _cleanup_cover_dirs(cls, path, cover_root):
+    def _cleanup_cover_dirs(cls, path):
         """Recursively remove empty cover directories."""
-        if not path or cover_root not in path.parents:
+        if not path or cls.COVER_ROOT not in path.parents:
             return
         try:
             path.rmdir()
-            cls._cleanup_cover_dirs(path.parent, cover_root)
+            cls._cleanup_cover_dirs(path.parent)
         except OSError:
             pass
 
-    def purge_cover_paths(self, cover_paths, cover_root):
+    def purge_cover_paths(self, cover_paths):
         """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))
@@ -47,40 +46,38 @@ 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, cover_root)
+                self._cleanup_cover_dirs(cover_dir)
             self.log.info(f"Removed {status.complete} cover thumbnails.")
         finally:
             self.status_controller.finish(status)
         return status.complete
 
-    def purge_comic_covers(self, pks: frozenset[int], custom: bool):
+    def purge_comic_covers(self, comic_pks):
         """Purge a set a 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)
+        cover_paths = self.get_cover_paths(comic_pks)
+        return self.purge_cover_paths(cover_paths)
 
     def purge_all_comic_covers(self, librarian_queue):
         """Purge every comic cover."""
         self.log.debug("Removing entire comic cover cache.")
         try:
-            shutil.rmtree(self.COVERS_ROOT)
+            shutil.rmtree(self.COVER_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, cover_class, cover_root, name):
+    def cleanup_orphan_covers(self):
         """Remove all orphan cover thumbs."""
         try:
-            self.log.debug(f"Removing covers from missing {name}.")
+            self.log.debug("Removing covers from missing comics.")
             self.status_controller.start_many(self._CLEANUP_STATUS_MAP)
-            pks = cover_class.objects.all().values_list("pk", flat=True)
-            db_cover_paths = self.get_cover_paths(pks)
+            comic_pks = Comic.objects.all().values_list("pk", flat=True)
+            db_cover_paths = self.get_cover_paths(comic_pks)
 
             orphan_cover_paths = set()
-            for root, _, filenames in os.walk(cover_root):
+            for root, _, filenames in os.walk(self.COVER_ROOT):
                 root_path = Path(root)
                 for fn in filenames:
                     fs_cover_path = root_path / fn
@@ -89,13 +86,6 @@ class CoverPurgeMixin(CoverPathMixin):
         finally:
             self.status_controller.finish(CoverStatusTypes.FIND_ORPHAN)
 
-        count = self.purge_cover_paths(orphan_cover_paths, cover_root)
-        self.log.info(f"Removed {count} covers for missing {name}.")
+        count = self.purge_cover_paths(orphan_cover_paths)
+        self.log.info(f"Removed {count} covers for missing comics.")
         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 CoverThread."""
+    """Handle with the CoverContributor."""
 
 
 @dataclass
@@ -29,8 +29,7 @@ class LibrariesTask:
 class CoverRemoveTask(CoverTask):
     """Purge a set of comic covers."""
 
-    pks: frozenset
-    custom: bool
+    comic_pks: frozenset
 
 
 @dataclass