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

codex/exceptions.py

@@ -30,6 +30,7 @@ class SeeOtherRedirectError(APIException):
         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)

codex/librarian/covers/purge.py

@@ -7,7 +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, Timestamp
+from codex.models import Comic
 from codex.models.paths import CustomCover
 from codex.status import Status
 
@@ -69,7 +69,6 @@ class CoverPurgeMixin(CoverPathMixin):
             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):

codex/librarian/importer/aggregate_metadata.py

@@ -28,6 +28,7 @@ from codex.librarian.importer.status import ImportStatusTypes, status_notify
 from codex.models import Imprint, Publisher, Series, Volume
 from codex.models.admin import AdminFlag
 from codex.status import Status
+from codex.util import max_none
 
 
 class AggregateMetadataMixin(CleanMetadataMixin):
@@ -182,22 +183,13 @@ class AggregateMetadataMixin(CleanMetadataMixin):
                 all_fks[field] = set()
             all_fks[field].add(name)
 
-    @staticmethod
-    def _none_max(a, b):
-        """None aware math.max."""
-        if a is not None and b is not None:
-            return max(a, b)
-        if a is None:
-            return b
-        return a
-
     @classmethod
     def _set_max_group_count(cls, common_args, group_class, index, count_key):
         """Assign the maximum group count number."""
         all_fks, group_tree, group_md = common_args
         group_name = group_tree[0:index]
         try:
-            count = cls._none_max(
+            count = max_none(
                 all_fks[GROUP_TREES][Series].get(group_name),
                 group_md.get(count_key),
             )

codex/librarian/importer/cache.py

@@ -0,0 +1,47 @@
+"""Update Groups timestamp for cover cache busting."""
+
+from django.db.models.functions import Now
+from django.db.models.query import Q
+
+from codex.models import StoryArc
+
+
+class CacheMixin:
+    """Update Groups timestamp for cover cache busting."""
+
+    def update_groups_with_changed_comics(self, start_time, deleted_comic_groups):
+        """Update timestamps for each group for cover cache busting."""
+        total_count = 0
+        now = Now()
+
+        log_list = []
+        for model, pks in deleted_comic_groups.items():
+            rel = "story_arc_number__" if model == StoryArc else ""
+            updated_at_rel = rel + "comic__updated_at__gt"
+            updated_filter = {updated_at_rel: start_time}
+            model_qs = (
+                model.objects.filter(Q(**updated_filter) | Q(pk__in=pks))
+                .distinct()
+                .only("updated_at")
+            )
+
+            updated = []
+            for obj in model_qs:
+                obj.updated_at = now
+                updated.append(obj)
+
+            count = len(updated)
+            if count:
+                model.objects.bulk_update(updated, ["updated_at"])
+                log_list.append(f"{count} {model.__name__}s.")
+                total_count += count
+        if total_count:
+            groups_log = ", ".join(log_list)
+            self.log.debug(  # type: ignore
+                f"Updated {groups_log} timestamps for browser cache busting."
+            )
+            self.log.info(  # type: ignore
+                f"Updated {total_count} group timestamps for browser cache busting."
+            )
+
+        return total_count

codex/librarian/importer/const.py

@@ -219,3 +219,11 @@ COMIC_M2M_FIELD_NAMES = frozenset(
     for field in Comic._meta.get_fields()
     if field.many_to_many and field.name != "folders"
 )
+COMIC_GROUP_FIELD_NAMES = (
+    "publisher",
+    "imprint",
+    "series",
+    "volume",
+    "story_arc_numbers",
+    "folders",
+)

codex/librarian/importer/deleted.py

@@ -1,9 +1,11 @@
 """Clean up the database after moves or imports."""
 
 from codex.librarian.covers.tasks import CoverRemoveTask
+from codex.librarian.importer.const import COMIC_GROUP_FIELD_NAMES
 from codex.librarian.importer.status import ImportStatusTypes, status_notify
-from codex.models import Comic, Folder
+from codex.models import Comic, Folder, StoryArc
 from codex.models.paths import CustomCover
+from codex.settings.settings import MAX_CHUNK_SIZE
 from codex.threads import QueuedThread
 
 
@@ -37,14 +39,47 @@ class DeletedMixin(QueuedThread):
             )
         return count
 
+    @staticmethod
+    def _populate_deleted_comic_groups(delete_qs, deleted_comic_groups):
+        """Populate changed groups for cover timestamp updater."""
+        comics_deleted_qs = delete_qs.only(*COMIC_GROUP_FIELD_NAMES).prefetch_related(
+            "story_arc_numbers__story_arc"
+        )
+        for comic in comics_deleted_qs.iterator(chunk_size=MAX_CHUNK_SIZE):
+            for field_name in COMIC_GROUP_FIELD_NAMES:
+                if field_name == "story_arc_numbers":
+                    for san in comic.story_arc_numbers.select_related("story_arc").only(
+                        "story_arc"
+                    ):
+                        deleted_comic_groups[StoryArc].add(san.story_arc.pk)
+                elif field_name == "folders":
+                    for folder in comic.folders.only("pk"):
+                        deleted_comic_groups[Folder].add(folder.pk)
+                else:
+                    related_model = comic._meta.get_field(field_name).related_model
+                    related_id = getattr(comic, field_name).pk
+                    deleted_comic_groups[related_model].add(related_id)
+
+    @staticmethod
+    def _init_deleted_comic_groups(deleted_comic_groups):
+        """Init deleted_comic_groups, used later even if no deletes."""
+        for field_name in COMIC_GROUP_FIELD_NAMES:
+            related_model = Comic._meta.get_field(field_name).related_model
+            deleted_comic_groups[related_model] = set()
+
     @status_notify(status_type=ImportStatusTypes.FILES_DELETED, updates=False)
-    def _bulk_comics_deleted(self, delete_comic_paths, library, **kwargs):
+    def _bulk_comics_deleted(
+        self, delete_comic_paths, library, deleted_comic_groups, **kwargs
+    ):
         """Bulk delete comics found missing from the filesystem."""
         if not delete_comic_paths:
             return 0
-        comics = Comic.objects.filter(library=library, path__in=delete_comic_paths)
-        delete_comic_pks = frozenset(comics.values_list("pk", flat=True))
-        comics.delete()
+        delete_qs = Comic.objects.filter(library=library, path__in=delete_comic_paths)
+
+        self._populate_deleted_comic_groups(delete_qs, deleted_comic_groups)
+
+        delete_comic_pks = frozenset(delete_qs.values_list("pk", flat=True))
+        delete_qs.delete()
 
         self._remove_covers(delete_comic_pks)
 
@@ -73,12 +108,15 @@ class DeletedMixin(QueuedThread):
 
         return count
 
-    def delete(self, library, task):
+    def delete(self, library, task, deleted_comic_groups):
         """Delete files and folders."""
         count = self._bulk_folders_deleted(task.dirs_deleted, library)
         task.dirs_deleted = None
 
-        count += self._bulk_comics_deleted(task.files_deleted, library)
+        self._init_deleted_comic_groups(deleted_comic_groups)
+        count += self._bulk_comics_deleted(
+            task.files_deleted, library, deleted_comic_groups
+        )
         task.files_deleted = None
 
         count += self._bulk_covers_deleted(task.covers_deleted, library)

codex/librarian/importer/importerd.py

@@ -5,9 +5,11 @@ from pathlib import Path
 from time import sleep, time
 
 from django.core.cache import cache
+from django.utils.timezone import now
 from humanize import naturaldelta
 
 from codex.librarian.importer.aggregate_metadata import AggregateMetadataMixin
+from codex.librarian.importer.cache import CacheMixin
 from codex.librarian.importer.const import FIS, FKS, M2M_MDS, MDS
 from codex.librarian.importer.deleted import DeletedMixin
 from codex.librarian.importer.failed_imports import FailedImportsMixin
@@ -35,6 +37,7 @@ class ComicImporterThread(
     UpdateComicsMixin,
     FailedImportsMixin,
     MovedMixin,
+    CacheMixin,
 ):
     """A worker to handle all bulk database updates."""
 
@@ -322,6 +325,7 @@ class ComicImporterThread(
         library = Library.objects.get(pk=task.library_id)
         try:
             self._init_apply(library, task)
+            import_start_time = now()
 
             changed: int = 0
             link_cover_pks: set[int] = set()
@@ -379,7 +383,13 @@ class ComicImporterThread(
                 library, fis, bool(task.files_deleted)
             )
 
-            changed += self.delete(library, task)
+            deleted_comic_groups = {}
+            changed += self.delete(library, task, deleted_comic_groups)
+
+            self.update_groups_with_changed_comics(
+                import_start_time, deleted_comic_groups
+            )
+
             if changed:
                 cache.clear()
         finally:

codex/librarian/importer/update_comics.py

@@ -11,7 +11,6 @@ from codex.librarian.importer.link_comics import LinkComicsMixin
 from codex.librarian.importer.status import ImportStatusTypes, status_notify
 from codex.models import (
     Comic,
-    Timestamp,
 )
 
 
@@ -74,7 +73,6 @@ class UpdateComicsMixin(LinkComicsMixin):
         self.log.debug(f"Bulk updating {len(update_comics)} comics.")
         try:
             Comic.objects.bulk_update(update_comics, BULK_UPDATE_COMIC_FIELDS)
-            Timestamp.touch(Timestamp.TimestampChoices.COVERS)
             count = len(update_comics)
 
             self._remove_covers(comic_pks, False)  # type: ignore

codex/librarian/janitor/janitor.py

@@ -76,7 +76,7 @@ class Janitor(CleanupMixin, UpdateMixin, VacuumMixin, UpdateFailedImportsMixin):
         except Exception:
             self.log.exception(f"In {self.__class__.__name__}")
 
-    def run(self, task):
+    def run(self, task):  # noqa: PLR0912,C901
         """Run Janitor tasks as the librarian process directly."""
         try:
             match task:

codex/librarian/librariand.py

@@ -77,7 +77,7 @@ class LibrarianDaemon(Process, LoggerBaseMixin):
             self.queue.put(task)
         self.search_indexer_abort_event = Manager().Event()
 
-    def _process_task(self, task):
+    def _process_task(self, task):  # noqa: PLR0912,C901
         """Process an individual task popped off the queue."""
         match task:
             case CoverTask():

codex/migrations/0029_choices_adminflag_and_timestamp.py

@@ -0,0 +1,44 @@
+"""Generated by Django 5.0.6 on 2024-05-25 21:19."""
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+    """Migrate db."""
+
+    dependencies = [
+        ("codex", "0028_custom_covers"),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name="adminflag",
+            name="key",
+            field=models.CharField(
+                choices=[
+                    ("FV", "Folder View"),
+                    ("RG", "Registration"),
+                    ("NU", "Non Users"),
+                    ("AU", "Auto Update"),
+                    ("SO", "Search Index Optimize"),
+                    ("IM", "Import Metadata"),
+                ],
+                db_index=True,
+                max_length=2,
+            ),
+        ),
+        migrations.AlterField(
+            model_name="timestamp",
+            name="key",
+            field=models.CharField(
+                choices=[
+                    ("JA", "Janitor"),
+                    ("VR", "Codex Version"),
+                    ("SI", "Search Index UUID"),
+                    ("AP", "API Key"),
+                ],
+                db_index=True,
+                max_length=2,
+            ),
+        ),
+    ]

codex/models/admin.py

@@ -82,7 +82,6 @@ class Timestamp(BaseModel):
     class TimestampChoices(TextChoices):
         """Choices for Timestamps."""
 
-        COVERS = "CV", _("Covers")
         JANITOR = "JA", _("Janitor")
         CODEX_VERSION = "VR", _("Codex Version")
         SEARCH_INDEX_UUID = "SI", _("Search Index UUID")

codex/permissions.py

@@ -8,7 +8,7 @@ from codex.models import Timestamp
 class HasAPIKeyOrIsAdminUser(BasePermission):
     """Does the request have the current api key."""
 
-    def has_permission(self, request, view):
+    def has_permission(self, request, view):  # type: ignore
         """Test the request api key against the database."""
         data = request.GET if request.method == "GET" else request.POST
         api_key = data.get("apiKey")

codex/serializers/admin.py

@@ -173,8 +173,7 @@ class AdminFolderSerializer(Serializer):
     def validate_show_hidden(self, show_hidden):
         """Snakecase the showHidden field."""
         return (
-            show_hidden == "true"
-            or self.initial_data.get("showHidden", False) == "true"
+            show_hidden == "true" or self.initial_data.get("showHidden") == "true"  # type: ignore
         )
 
 

codex/serializers/browser/filters.py

@@ -1,23 +1,19 @@
 """Browser Settings Filter Serializers."""
 
-from abc import ABC
-
-from django.core.exceptions import ValidationError
-from django.utils.translation import gettext_lazy as _
-from rest_framework.fields import Field
 from rest_framework.serializers import (
     BooleanField,
-    CharField,
     ChoiceField,
-    FloatField,
-    IntegerField,
-    ListField,
     Serializer,
 )
 
-from codex.serializers.choices import CHOICES, VUETIFY_NULL_CODE
-
-VUETIFY_NULL_CODE_STR = str(VUETIFY_NULL_CODE)
+from codex.serializers.choices import CHOICES
+from codex.serializers.fields import (
+    BooleanListField,
+    CharListField,
+    DecadeListField,
+    FloatListField,
+    IntListField,
+)
 
 
 class BrowserFilterChoicesSerializer(Serializer):
@@ -47,95 +43,6 @@ class BrowserFilterChoicesSerializer(Serializer):
     year = BooleanField(read_only=True)
 
 
-def validate_decades(decades):
-    """Validate decades."""
-    if not decades:
-        return
-    # * We don't need a whole db call just to be perfectly accurate
-    # * -1s are decoded back into None before validation
-    exists = False
-    for decade in decades:
-        if decade is None or decade % 10 == 0:
-            exists = True
-            break
-    if not exists:
-        raise ValidationError(_(f"Invalid decade in: {decades}"))
-
-
-def validate_int_null(values):
-    """Use a special code for null.
-
-    Because if a vuetify component has a null key it changes it to the
-    array index.
-    """
-    for index, value in enumerate(values):
-        if value == VUETIFY_NULL_CODE:
-            values[index] = None
-    return values
-
-
-def validate_str_null(values):
-    """Use a special code for null.
-
-    Because if a vuetify component has a null key it changes it to the
-    array index. This is the version for CharFields.
-    """
-    for index, value in enumerate(values):
-        if value == VUETIFY_NULL_CODE_STR:
-            values[index] = None
-    return values
-
-
-class FilterListField(ListField, ABC):
-    """Filter List field with custom arguments."""
-
-    CHILD_CLASS = Field
-    VALIDATORS = ()
-
-    def __init__(self, *args, **kwargs):
-        """Apply the subclass's arguments."""
-        super().__init__(
-            *args,
-            child=self.CHILD_CLASS(allow_null=True, **kwargs),
-            required=False,
-            validators=self.VALIDATORS,
-        )
-
-
-class FloatListField(FilterListField):
-    """Decimal List Field with validation."""
-
-    CHILD_CLASS = FloatField  # type: ignore
-    VALIDATORS = (validate_int_null,)
-
-
-class IntListField(FilterListField):
-    """Integer List Field with validation."""
-
-    CHILD_CLASS = IntegerField  # type: ignore
-    VALIDATORS = (validate_int_null,)
-
-
-class DecadeListField(IntListField):
-    """Integer List Field with validation for decades."""
-
-    VALIDATORS = (validate_int_null, validate_decades)
-
-
-class CharListField(FilterListField):
-    """Char List Field with validation."""
-
-    CHILD_CLASS = CharField  # type: ignore
-    VALIDATORS = (validate_str_null,)
-
-
-class BooleanListField(FilterListField):
-    """Bool List Field with validation."""
-
-    CHILD_CLASS = BooleanField  # type: ignore
-    VALIDATORS = (validate_int_null,)
-
-
 class BrowserSettingsFilterSerializer(Serializer):
     """Filter values for settings."""
 

codex/serializers/browser/mixins.py

@@ -10,6 +10,15 @@ from rest_framework.serializers import (
 )
 
 from codex.serializers.browser.filters import IntListField
+from codex.serializers.fields import TimestampField
+
+
+class BrowserCover(Serializer):
+    """Browser Cover."""
+
+    custom = BooleanField(read_only=True, default=False)
+    pk = IntegerField(read_only=True, default=0)
+    mtime = TimestampField(read_only=True, default=0)
 
 
 class BrowserAggregateSerializerMixin(Serializer):
@@ -20,9 +29,8 @@ class BrowserAggregateSerializerMixin(Serializer):
 
     # Aggregate Annotations
     child_count = IntegerField(read_only=True)
-    cover_pk = IntegerField(read_only=True)
-    cover_mtime = DateTimeField(format="%s", read_only=True)
-    cover_custom = BooleanField(read_only=True)
+    mtime = TimestampField(read_only=True)
+    cover = BrowserCover(read_only=True)
 
     # Bookmark annotations
     page = IntegerField(read_only=True)
@@ -31,3 +39,12 @@ class BrowserAggregateSerializerMixin(Serializer):
     progress = DecimalField(
         max_digits=5, decimal_places=2, read_only=True, coerce_to_string=False
     )
+
+    def to_representation(self, instance):
+        """Nest Cover Object."""
+        instance.cover = {
+            "custom": instance.cover_custom,
+            "pk": instance.cover_pk,
+            "mtime": instance.cover_mtime,
+        }
+        return super().to_representation(instance)

codex/serializers/browser/page.py

@@ -3,7 +3,6 @@
 from rest_framework.serializers import (
     BooleanField,
     CharField,
-    DateTimeField,
     DecimalField,
     IntegerField,
     ListSerializer,
@@ -13,6 +12,7 @@ from rest_framework.serializers import (
 from codex.serializers.browser.mixins import (
     BrowserAggregateSerializerMixin,
 )
+from codex.serializers.fields import TimestampField
 from codex.serializers.route import RouteSerializer
 
 
@@ -34,7 +34,6 @@ class BrowserCardSerializer(BrowserAggregateSerializerMixin):
     order_value = CharField(read_only=True)
     page_count = IntegerField(read_only=True)
     reading_direction = CharField(read_only=True)
-    mtime = DateTimeField(format="%s", read_only=True)
 
 
 class BrowserAdminFlagsSerializer(Serializer):
@@ -57,10 +56,10 @@ class BrowserPageSerializer(Serializer):
     admin_flags = BrowserAdminFlagsSerializer(read_only=True)
     breadcrumbs = ListSerializer(child=RouteSerializer())
     title = BrowserTitleSerializer(read_only=True)
-    covers_timestamp = IntegerField(read_only=True)
     zero_pad = IntegerField(read_only=True)
     libraries_exist = BooleanField(read_only=True)
     model_group = CharField(read_only=True)
     num_pages = IntegerField(read_only=True)
     groups = BrowserCardSerializer(allow_empty=True, read_only=True, many=True)
     books = BrowserCardSerializer(allow_empty=True, read_only=True, many=True)
+    mtime = TimestampField(read_only=True)

codex/serializers/browser/settings.py

@@ -10,6 +10,7 @@ from rest_framework.serializers import (
 
 from codex.serializers.browser.filters import BrowserSettingsFilterSerializer
 from codex.serializers.choices import CHOICES, VUETIFY_NULL_CODE
+from codex.serializers.fields import TimestampField
 
 VUETIFY_NULL_CODE_STR = str(VUETIFY_NULL_CODE)
 
@@ -44,3 +45,4 @@ class BrowserSettingsSerializer(Serializer):
     top_group = ChoiceField(choices=tuple(CHOICES["topGroup"].keys()), required=False)
     opds_metadata = BooleanField(required=False)
     limit = IntegerField(required=False)
+    mtime = TimestampField(read_only=True)