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

codex/exceptions.py

@@ -9,6 +9,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,13 +21,21 @@ class SeeOtherRedirectError(APIException):
     default_code = "redirect"
     default_detail = "redirect to a valid route"
 
+    def _coerce_pks_to_string(self, detail):
+        """Coerce pks to valid string."""
+        params = detail.get("route", {}).get("params", DEFAULTS["breadcrumbs"][0])
+        serializer = RouteSerializer(params)
+        detail["route"]["params"] = serializer.data
+
     def __init__(self, detail):
         """Create a response to pass to the exception handler."""
-        LOG.debug(f"redirect {detail.get('reason')}")
+        self._coerce_pks_to_string(detail)
         serializer = BrowserRedirectSerializer(detail)
         self.detail: dict = serializer.data  # type: ignore
-        # super().__init__ converts every type into strings!
-        # do not use it.
+        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."""
@@ -44,8 +53,8 @@ class SeeOtherRedirectError(APIException):
         """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"])
+        params = route.get("params", DEFAULTS["breadcrumbs"][0])
         url = reverse(url_name, kwargs=params)
         url = self._add_query_params(url)
 
-        return redirect(url)
+        return redirect(url, permanent=False)

codex/librarian/covers/create.py

@@ -77,7 +77,8 @@ 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):
         """Create bulk comic covers."""

codex/librarian/covers/path.py

@@ -4,7 +4,7 @@ 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
 
 
@@ -12,7 +12,6 @@ class CoverPathMixin(QueuedThread):
     """Path methods for covers."""
 
     COVER_ROOT = ROOT_CACHE_PATH / "covers"
-    MISSING_COVER_PATH = CODEX_PATH / "img" / "missing-cover.webp"
     _HEX_FILL = 8
     _PATH_STEP = 2
     _ZFILL = 12

codex/librarian/importer/const.py

@@ -27,7 +27,6 @@ _NUMBER_FIELD_NAME = "number"
 IDENTIFIERS_FIELD_NAME = "identifiers"
 _IDENTIFIER_TYPE_FIELD_NAME = "identifier_type"
 _IDENTIFIER_CODE_FIELD_NAME = "nss"
-_IDENTIFIER_URL_FIELD_NAME = "url"
 
 # AGGREGATE
 DICT_MODEL_AGG_MAP = MappingProxyType(
@@ -50,15 +49,20 @@ DICT_MODEL_CLASS_FIELDS_MAP = MappingProxyType(
         Identifier: frozenset({_IDENTIFIER_TYPE_FIELD_NAME}),
     }
 )
+DICT_MODEL_FIELD_MODEL_MAP = MappingProxyType(
+    {
+        CONTRIBUTORS_FIELD_NAME: Contributor,
+        STORY_ARCS_METADATA_KEY: StoryArcNumber,
+        IDENTIFIERS_FIELD_NAME: Identifier,
+    }
+)
 DICT_MODEL_REL_MAP = MappingProxyType(
     {
         CONTRIBUTORS_FIELD_NAME: (
-            Contributor,
             f"{_CONTRIBUTOR_ROLE_FIELD_NAME}__name",
             f"{_CONTRIBUTOR_PERSON_FIELD_NAME}__name",
         ),
         STORY_ARCS_METADATA_KEY: (
-            StoryArcNumber,
             f"{_STORY_ARC_FIELD_NAME}__name",
             _NUMBER_FIELD_NAME,
         ),
@@ -67,11 +71,9 @@ DICT_MODEL_REL_MAP = MappingProxyType(
 IDENTIFIERS_MODEL_REL_MAP = MappingProxyType(
     {
         IDENTIFIERS_FIELD_NAME: (
-            Identifier,
             f"{_IDENTIFIER_TYPE_FIELD_NAME}__name",
             {
                 "nss": _IDENTIFIER_CODE_FIELD_NAME,
-                "url": _IDENTIFIER_URL_FIELD_NAME,
             },
         ),
     }
@@ -118,6 +120,7 @@ _EXCLUDEBULK_UPDATE_COMIC_FIELDS = {
     "id",
     "bookmark",
 }
+GROUP_BASE_FIELDS = ("name", "sort_name")
 BULK_UPDATE_COMIC_FIELDS = tuple(
     sorted(
         field.name
@@ -126,6 +129,13 @@ BULK_UPDATE_COMIC_FIELDS = tuple(
         and (field.name not in _EXCLUDEBULK_UPDATE_COMIC_FIELDS)
     )
 )
+BULK_UPDATE_FOLDER_FIELDS = (
+    *GROUP_BASE_FIELDS,
+    "stat",
+    "updated_at",
+    "path",
+    "parent_folder",
+)
 BULK_UPDATE_FOLDER_MODIFIED_FIELDS = ("stat", "updated_at")
 BULK_UPDATE_COMIC_FIELDS_WITH_VALUES = tuple(
     sorted(
@@ -133,6 +143,9 @@ 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)
+
 
 #########
 # OTHER #
@@ -140,14 +153,22 @@ BULK_UPDATE_COMIC_FIELDS_WITH_VALUES = tuple(
 VOLUME_COUNT = "volume_count"
 ISSUE_COUNT = "issue_count"
 COUNT_FIELDS = {Series: VOLUME_COUNT, Volume: ISSUE_COUNT}
-GROUP_UPDATE_FIELDS = MappingProxyType(
-    {
-        Publisher: ("name",),
-        Imprint: ("name", "publisher"),
-        Series: ("name", "imprint"),
-        Volume: ("name", "publisher", "imprint", "series"),
-    }
-)
+_GROUP_CLASSES = (Publisher, Imprint, Series, Volume)
+
+
+def _create_group_update_fields():
+    guf = {}
+    fields = GROUP_BASE_FIELDS
+    for cls in _GROUP_CLASSES:
+        if cls == Volume:
+            guf[cls] = tuple({*fields} - {"sort_name"})
+        else:
+            guf[cls] = fields
+        fields = (*fields, cls.__name__.lower())
+    return MappingProxyType(guf)
+
+
+GROUP_UPDATE_FIELDS = _create_group_update_fields()
 NAMED_MODEL_UPDATE_FIELDS = ("name",)
 FOLDERS_FIELD = "folders"
 GROUP_TREES = "group_trees"

codex/librarian/importer/create_comics.py

@@ -29,7 +29,6 @@ class CreateComicsMixin(LinkComicsMixin):
                 self.get_comic_fk_links(md, library, path)
                 comic = Comic(**md)
                 comic.presave()
-                comic.set_stat()
                 create_comics.append(comic)
             except KeyError:
                 self.log.warning(f"No comic metadata for {path}")

codex/librarian/importer/create_fks.py

@@ -7,9 +7,10 @@ from itertools import chain
 from pathlib import Path
 
 from codex.librarian.importer.const import (
-    BULK_UPDATE_FOLDER_MODIFIED_FIELDS,
+    BULK_UPDATE_FOLDER_FIELDS,
     COUNT_FIELDS,
     CREATE_DICT_UPDATE_FIELDS,
+    GROUP_BASE_FIELDS,
     GROUP_UPDATE_FIELDS,
     IMPRINT,
     ISSUE_COUNT,
@@ -61,7 +62,9 @@ class CreateForeignKeysMixin(QueuedThread):
             )
             defaults[ISSUE_COUNT] = group_count
 
-        return group_class(**defaults)
+        obj = group_class(**defaults)
+        obj.presave()
+        return obj
 
     @staticmethod
     def _update_group_obj(group_class, group_param_tuple, group_count):
@@ -153,7 +156,7 @@ class CreateForeignKeysMixin(QueuedThread):
             name=path.name,
             parent_folder=parent,
         )
-        folder.set_stat()
+        folder.presave()
         create_folders.append(folder)
 
     def _bulk_folders_create_depth_level(self, library, paths, status):
@@ -164,7 +167,7 @@ class CreateForeignKeysMixin(QueuedThread):
         Folder.objects.bulk_create(
             create_folders,
             update_conflicts=True,
-            update_fields=BULK_UPDATE_FOLDER_MODIFIED_FIELDS,
+            update_fields=BULK_UPDATE_FOLDER_FIELDS,
             unique_fields=Folder._meta.unique_together[0],  # type: ignore
         )
         count = len(create_folders)
@@ -204,14 +207,21 @@ class CreateForeignKeysMixin(QueuedThread):
         if not count:
             return count
         create_named_objs = []
+        is_story_arc = named_class == StoryArc
         for name in names:
             named_obj = named_class(name=name)
+            if is_story_arc:
+                named_obj.presave()
             create_named_objs.append(named_obj)
 
+        update_fields = NAMED_MODEL_UPDATE_FIELDS
+        if is_story_arc:
+            update_fields += GROUP_BASE_FIELDS
+
         named_class.objects.bulk_create(
             create_named_objs,
             update_conflicts=True,
-            update_fields=NAMED_MODEL_UPDATE_FIELDS,
+            update_fields=update_fields,
             unique_fields=named_class._meta.unique_together[0],
         )
         if count:
@@ -224,32 +234,36 @@ class CreateForeignKeysMixin(QueuedThread):
         return count
 
     @staticmethod
-    def _create_contributor(role_name, person_name):
-        role = ContributorRole.objects.get(name=role_name) if role_name else None
-        person = ContributorPerson.objects.get(name=person_name)
-        return Contributor(role=role, person=person)
+    def _create_contributor_args(values):
+        return {
+            "role": ContributorRole.objects.get(name=values[0]) if values[0] else None,
+            "person": ContributorPerson.objects.get(name=values[1]),
+        }
 
     @staticmethod
-    def _create_story_arc_number(name, number):
-        story_arc = StoryArc.objects.get(name=name)
-        return StoryArcNumber(story_arc=story_arc, number=number)
+    def _create_story_arc_number_args(values):
+        return {"story_arc": StoryArc.objects.get(name=values[0]), "number": values[1]}
 
     @staticmethod
-    def _create_identifier(name, values):
-        identifier_type = IdentifierType.objects.get(name=name)
-        return Identifier(identifier_type=identifier_type, **dict(values))
+    def _create_identifier_args(values):
+        return {
+            "identifier_type": IdentifierType.objects.get(name=values[0]),
+            "nss": values[1],
+            "url": values[2],
+        }
 
     @status_notify()
     def _bulk_create_dict_models(
-        self, create_tuples, create_method, model, status=None
+        self, create_tuples, create_args_method, model, status=None
     ):
         """Bulk create a dict type m2m model."""
         if not create_tuples:
             return 0
 
         create_objs = []
-        for key, value in create_tuples:
-            obj = create_method(key, value)
+        for values_tuple in create_tuples:
+            args = create_args_method(values_tuple)
+            obj = model(**args)
             create_objs.append(obj)
 
         model.objects.bulk_create(
@@ -341,13 +355,13 @@ class CreateForeignKeysMixin(QueuedThread):
 
             # These all depend on bulk_create_named_models running first
             create_dict_data = (
-                (Contributor, create_contributors, self._create_contributor),
+                (Contributor, create_contributors, self._create_contributor_args),
                 (
                     StoryArcNumber,
                     create_story_arc_numbers,
-                    self._create_story_arc_number,
+                    self._create_story_arc_number_args,
                 ),
-                (Identifier, create_identifiers, self._create_identifier),
+                (Identifier, create_identifiers, self._create_identifier_args),
             )
             for model, create_objs, func in create_dict_data:
                 count = self._bulk_create_dict_models(

codex/librarian/importer/failed_imports.py

@@ -94,7 +94,7 @@ class FailedImportsMixin(QueuedThread):
             try:
                 exc = update_failed_imports.pop(fi.path)
                 fi.set_reason(exc)
-                fi.set_stat()
+                fi.presave()
                 fi.updated_at = now
             except Exception as exc:
                 self.log.exception(
@@ -119,7 +119,7 @@ class FailedImportsMixin(QueuedThread):
             try:
                 fi = FailedImport(library=library, path=path, parent_folder=None)
                 fi.set_reason(exc)
-                fi.set_stat()
+                fi.presave()
                 create_objs.append(fi)
             except Exception as exc:
                 self.log.exception(f"Error preparing failed import create for {path}")

codex/librarian/importer/moved.py

@@ -4,19 +4,21 @@ from pathlib import Path
 
 from django.db.models.functions import Now
 
-from codex.librarian.importer.const import FOLDERS_FIELD, PARENT_FOLDER
+from codex.librarian.importer.const import (
+    BULK_UPDATE_FOLDER_MODIFIED_FIELDS,
+    FOLDERS_FIELD,
+    MOVED_BULK_COMIC_UPDATE_FIELDS,
+    MOVED_BULK_FOLDER_UPDATE_FIELDS,
+    PARENT_FOLDER,
+)
 from codex.librarian.importer.create_comics import CreateComicsMixin
 from codex.librarian.importer.create_fks import (
-    BULK_UPDATE_FOLDER_MODIFIED_FIELDS,
     CreateForeignKeysMixin,
 )
 from codex.librarian.importer.query_fks import QueryForeignKeysMixin
 from codex.librarian.importer.status import ImportStatusTypes, status_notify
 from codex.models import Comic, Folder, Library
 
-_MOVED_BULK_COMIC_UPDATE_FIELDS = ("path", "parent_folder")
-_MOVED_BULK_FOLDER_UPDATE_FIELDS = ("path", "parent_folder", "name")
-
 
 class MovedMixin(CreateComicsMixin, CreateForeignKeysMixin, QueryForeignKeysMixin):
     """Methods for moving comics and folders."""
@@ -52,7 +54,7 @@ class MovedMixin(CreateComicsMixin, CreateForeignKeysMixin, QueryForeignKeysMixi
                     path=new_path.parent
                 )
                 comic.updated_at = now
-                comic.set_stat()
+                comic.presave()
                 folder_m2m_links[comic.pk] = Folder.objects.filter(
                     path__in=new_path.parents
                 ).values_list("pk", flat=True)
@@ -60,7 +62,7 @@ class MovedMixin(CreateComicsMixin, CreateForeignKeysMixin, QueryForeignKeysMixi
             except Exception:
                 self.log.exception(f"moving {comic.path}")
 
-        Comic.objects.bulk_update(updated_comics, _MOVED_BULK_COMIC_UPDATE_FIELDS)
+        Comic.objects.bulk_update(updated_comics, MOVED_BULK_COMIC_UPDATE_FIELDS)
 
         # Update m2m field
         if folder_m2m_links:
@@ -123,13 +125,13 @@ class MovedMixin(CreateComicsMixin, CreateForeignKeysMixin, QueryForeignKeysMixi
             folder.path = new_path
             parent_path_str = str(Path(new_path).parent)
             folder.parent_folder = dest_parent_folders.get(parent_path_str)
-            folder.set_stat()
+            folder.presave()
             folder.updated_at = now  # type: ignore
             update_folders.append(folder)
 
         update_folders = sorted(update_folders, key=lambda x: len(Path(x.path).parts))
 
-        Folder.objects.bulk_update(update_folders, _MOVED_BULK_FOLDER_UPDATE_FIELDS)
+        Folder.objects.bulk_update(update_folders, MOVED_BULK_FOLDER_UPDATE_FIELDS)
         count = len(update_folders)
         if count:
             self.log.info(f"Moved {count} folders.")
@@ -148,8 +150,8 @@ class MovedMixin(CreateComicsMixin, CreateForeignKeysMixin, QueryForeignKeysMixi
         now = Now()
         for folder in folders.iterator():
             if Path(folder.path).exists():
-                folder.set_stat()
                 folder.updated_at = now
+                folder.presave()
                 update_folders.append(folder)
         Folder.objects.bulk_update(
             update_folders, fields=BULK_UPDATE_FOLDER_MODIFIED_FIELDS