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

codex/serializers/browser/filters.py

@@ -1,23 +1,16 @@
 """Browser Settings Filter Serializers."""
 
-from abc import ABC, abstractmethod
-
-from django.core.exceptions import ValidationError
-from django.utils.translation import gettext_lazy as _
-from rest_framework.serializers import (
-    BooleanField,
-    CharField,
-    ChoiceField,
-    FloatField,
-    IntegerField,
-    ListField,
-    Serializer,
+from rest_framework.serializers import BooleanField, ListField, Serializer
+
+from codex.serializers.fields import (
+    BookmarkFilterField,
+    VuetifyBooleanField,
+    VuetifyCharField,
+    VuetifyDecadeField,
+    VuetifyFloatField,
+    VuetifyIntegerField,
 )
 
-from codex.serializers.choices import CHOICES, VUETIFY_NULL_CODE
-
-VUETIFY_NULL_CODE_STR = str(VUETIFY_NULL_CODE)
-
 
 class BrowserFilterChoicesSerializer(Serializer):
     """All dynamic filters."""
@@ -46,127 +39,30 @@ 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."""
-
-    @property
-    @classmethod
-    @abstractmethod
-    def CHILD_CLASS(cls):  # noqa: N802
-        """Child field class."""
-        raise NotImplementedError
-
-    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."""
 
-    bookmark = ChoiceField(
-        choices=tuple(CHOICES["bookmarkFilter"].keys()), required=False
-    )
+    bookmark = BookmarkFilterField(required=False)
     # Dynamic filters
-    age_rating = CharListField(allow_blank=True, required=False)
-    characters = IntListField(required=False)
-    community_rating = FloatListField(required=False)
-    country = CharListField(allow_blank=True, required=False)
-    contributors = IntListField(required=False)
-    critical_rating = FloatListField(required=False)
-    decade = DecadeListField(required=False)
-    file_type = CharListField(allow_blank=True, required=False)
-    genres = IntListField(required=False)
-    identifier_type = CharListField(allow_blank=True, required=False)
-    language = CharListField(allow_blank=True, required=False)
-    locations = IntListField()
-    monochrome = BooleanListField(required=False)
-    original_format = CharListField(required=False, allow_blank=True)
-    reading_direction = CharListField(required=False)
-    series_groups = IntListField(required=False)
-    stories = IntListField(required=False)
-    story_arcs = IntListField(required=False)
-    tagger = CharListField(required=False)
-    tags = IntListField(required=False)
-    teams = IntListField(required=False)
-    year = IntListField(required=False)
+    age_rating = ListField(child=VuetifyCharField(), required=False)
+    characters = ListField(child=VuetifyIntegerField(), required=False)
+    community_rating = ListField(child=VuetifyFloatField(), required=False)
+    country = ListField(child=VuetifyIntegerField(), required=False)
+    contributors = ListField(child=VuetifyIntegerField(), required=False)
+    critical_rating = ListField(child=VuetifyFloatField(), required=False)
+    decade = ListField(child=VuetifyDecadeField(), required=False)
+    file_type = ListField(child=VuetifyCharField(), required=False)
+    genres = ListField(child=VuetifyIntegerField(), required=False)
+    identifier_type = ListField(child=VuetifyCharField(), required=False)
+    language = ListField(child=VuetifyIntegerField(), required=False)
+    locations = ListField(child=VuetifyIntegerField(), required=False)
+    monochrome = ListField(child=VuetifyBooleanField(), required=False)
+    original_format = ListField(child=VuetifyCharField(), required=False)
+    reading_direction = ListField(child=VuetifyCharField(), required=False)
+    series_groups = ListField(child=VuetifyIntegerField(), required=False)
+    stories = ListField(child=VuetifyIntegerField(), required=False)
+    story_arcs = ListField(child=VuetifyIntegerField(), required=False)
+    tagger = ListField(child=VuetifyCharField(), required=False)
+    tags = ListField(child=VuetifyIntegerField(), required=False)
+    teams = ListField(child=VuetifyIntegerField(), required=False)
+    year = ListField(child=VuetifyIntegerField(), required=False)

codex/serializers/browser/metadata.py

@@ -0,0 +1,59 @@
+"""Codex Serializers for the metadata box."""
+
+from rest_framework.serializers import CharField, IntegerField, ListField, Serializer
+
+from codex.serializers.browser.mixins import BrowserAggregateSerializerMixin
+from codex.serializers.models.comic import ComicSerializer
+from codex.serializers.models.named import (
+    ContributorSerializer,
+    IdentifierSeralizer,
+    StoryArcNumberSerializer,
+)
+
+PREFETCH_PREFIX = "attached_"
+
+
+class GroupSerializer(Serializer):
+    """Serialize a group pk and name."""
+
+    ids = ListField(child=IntegerField(), read_only=True)
+    name = CharField(read_only=True)
+
+
+class MetadataSerializer(BrowserAggregateSerializerMixin, ComicSerializer):
+    """Aggregate stats for the comics selected in the metadata dialog."""
+
+    filename = CharField(read_only=True)
+    parent_folder_id = IntegerField(read_only=True, required=False)
+    series_volume_count = IntegerField(read_only=True)
+    volume_issue_count = IntegerField(read_only=True)
+
+    publisher_list = GroupSerializer(many=True, required=False)
+    imprint_list = GroupSerializer(many=True, required=False)
+    series_list = GroupSerializer(many=True, required=False)
+    volume_list = GroupSerializer(many=True, required=False)
+    publisher = None
+    imprint = None
+    series = None
+    volume = None
+
+    identifiers = IdentifierSeralizer(
+        source=f"{PREFETCH_PREFIX}identifiers", many=True, allow_null=True
+    )
+    contributors = ContributorSerializer(
+        source=f"{PREFETCH_PREFIX}contributors", many=True, allow_null=True
+    )
+    stroy_arc_numbers = StoryArcNumberSerializer(
+        source=f"{PREFETCH_PREFIX}story_arc_numbers", many=True, allow_null=True
+    )
+
+    class Meta(ComicSerializer.Meta):
+        """Configure the model."""
+
+        exclude = (
+            *ComicSerializer.Meta.exclude,
+            "publisher",
+            "imprint",
+            "series",
+            "volume",
+        )

codex/serializers/browser/mixins.py

@@ -0,0 +1,65 @@
+"""Serializer mixins."""
+
+from datetime import datetime, timezone
+
+from rest_framework.serializers import (
+    BooleanField,
+    CharField,
+    DateTimeField,
+    DecimalField,
+    IntegerField,
+    ListField,
+    Serializer,
+    SerializerMethodField,
+)
+
+from codex.logger.logging import get_logger
+from codex.views.const import COMIC_GROUP, EPOCH_START
+
+LOG = get_logger(__name__)
+
+
+class BrowserAggregateSerializerMixin(Serializer):
+    """Mixin for browser, opds & metadata serializers."""
+
+    group = CharField(read_only=True, max_length=1)
+    ids = ListField(child=IntegerField(), read_only=True)
+
+    # Aggregate Annotations
+    child_count = IntegerField(read_only=True)
+    mtime = SerializerMethodField(read_only=True)
+
+    # Bookmark annotations
+    page = IntegerField(read_only=True)
+    bookmark_updated_at = DateTimeField(read_only=True, allow_null=True)
+    finished = BooleanField(read_only=True)
+    progress = DecimalField(
+        max_digits=5, decimal_places=2, read_only=True, coerce_to_string=False
+    )
+
+    def get_mtime(self, obj) -> int:
+        """Compute mtime from json array aggregates."""
+        mtime = EPOCH_START
+        for dt_str in obj.updated_ats:
+            if not dt_str:
+                continue
+            try:
+                dt = datetime.strptime(dt_str, "%Y-%m-%d %H:%M:%S.%f").replace(
+                    tzinfo=timezone.utc
+                )
+            except ValueError:
+                LOG.warning(
+                    f"computing group mtime: {dt_str} is not a valid datetime string."
+                )
+                continue
+
+            if dt > mtime:
+                mtime = dt
+
+        if obj.group != COMIC_GROUP and (
+            mbua := getattr(obj, "max_bookmark_updated_at", None)
+        ):
+            mtime = max(mtime, mbua)
+
+        # print(obj.group, obj.pk, obj.name, obj.updated_ats, obj.max_bookmark_updated_at, "max:", mtime)
+        return int(mtime.timestamp() * 1000)

codex/serializers/browser/mtime.py

@@ -0,0 +1,21 @@
+"""Group Mtimes."""
+
+from rest_framework.serializers import CharField, Serializer
+
+from codex.serializers.browser.settings import BrowserSettingsFilterSerializer
+from codex.serializers.fields import TimestampField
+from codex.serializers.route import SimpleRouteSerializer
+
+
+class GroupsMtimeSerializer(Serializer):
+    """Groups Mtimes."""
+
+    filters = BrowserSettingsFilterSerializer(required=False)
+    q = CharField(allow_blank=True, required=False)
+    groups = SimpleRouteSerializer(many=True, required=True)
+
+
+class MtimeSerializer(Serializer):
+    """Max mtime for all submitted groups."""
+
+    max_mtime = TimestampField(read_only=True)

codex/serializers/browser/page.py

@@ -3,15 +3,15 @@
 from rest_framework.serializers import (
     BooleanField,
     CharField,
-    DateTimeField,
     DecimalField,
     IntegerField,
     Serializer,
 )
 
-from codex.serializers.mixins import (
+from codex.serializers.browser.mixins import (
     BrowserAggregateSerializerMixin,
 )
+from codex.serializers.fields import BreadcrumbsField, TimestampField
 
 
 class BrowserCardSerializer(BrowserAggregateSerializerMixin):
@@ -32,15 +32,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 BrowserRouteSerializer(Serializer):
-    """A vue route for the browser."""
-
-    group = CharField(read_only=True)
-    pk = IntegerField(read_only=True)
-    page = IntegerField(read_only=True)
 
 
 class BrowserAdminFlagsSerializer(Serializer):
@@ -53,7 +44,6 @@ class BrowserAdminFlagsSerializer(Serializer):
 class BrowserTitleSerializer(Serializer):
     """Elements for constructing the browse title."""
 
-    parent_name = CharField(read_only=True)
     group_name = CharField(read_only=True)
     group_count = IntegerField(read_only=True, allow_null=True)
 
@@ -62,17 +52,12 @@ class BrowserPageSerializer(Serializer):
     """The main browse list."""
 
     admin_flags = BrowserAdminFlagsSerializer(read_only=True)
-    browser_title = BrowserTitleSerializer(read_only=True)
-    covers_timestamp = IntegerField(read_only=True)
-    issue_number_max = DecimalField(
-        max_digits=16,
-        decimal_places=3,
-        read_only=True,
-        coerce_to_string=False,
-    )
+    breadcrumbs = BreadcrumbsField(read_only=True)
+    title = BrowserTitleSerializer(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)
-    up_route = BrowserRouteSerializer(allow_null=True, read_only=True)
+    mtime = TimestampField(read_only=True)

codex/serializers/browser/settings.py

@@ -10,6 +10,8 @@ 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 BreadcrumbsField, TimestampField, TopGroupField
+from codex.serializers.route import SimpleRouteSerializer
 
 VUETIFY_NULL_CODE_STR = str(VUETIFY_NULL_CODE)
 
@@ -23,20 +25,50 @@ class BrowserSettingsShowGroupFlagsSerializer(Serializer):
     v = BooleanField()
 
 
-class BrowserSettingsSerializer(Serializer):
-    """Browser Settings that the user can change.
-
-    This is the only browse serializer that's submitted.
-    It is also sent to the browser as part of BrowserOpenedSerializer.
-    """
+class BrowserFilterChoicesInputSerilalizer(Serializer):
+    """Browser Settings for the filter choices response."""
 
     filters = BrowserSettingsFilterSerializer(required=False)
+    q = CharField(allow_blank=True, required=False)
+
+
+class BrowserCoverInputSerializerBase(BrowserFilterChoicesInputSerilalizer):
+    """Base Serializer for Cover and Settings."""
+
+    custom_covers = BooleanField(required=False)
+    dynamic_covers = BooleanField(required=False)
     order_by = ChoiceField(choices=tuple(CHOICES["orderBy"].keys()), required=False)
     order_reverse = BooleanField(required=False)
-    q = CharField(allow_blank=True, required=False)
-    query = CharField(allow_blank=True, required=False)  # OPDS 2.0
     show = BrowserSettingsShowGroupFlagsSerializer(required=False)
-    twenty_four_hour_time = BooleanField(required=False)
-    top_group = ChoiceField(choices=tuple(CHOICES["topGroup"].keys()), required=False)
-    opds_metadata = BooleanField(required=False)
+
+
+class BrowserCoverInputSerializer(BrowserCoverInputSerializerBase):
+    """Browser Settings for the cover response."""
+
+    parent = SimpleRouteSerializer(required=False)
+
+
+class BrowserSettingsSerializerBase(BrowserCoverInputSerializerBase):
+    """Base Serializer for Browser & OPDS Settings."""
+
+    # search_results_limit = IntegerField(required=False)
+    top_group = TopGroupField(required=False)
+
+
+class OPDSSettingsSerializer(BrowserSettingsSerializerBase):
+    """Browser Settings for the OPDS."""
+
     limit = IntegerField(required=False)
+    opds_metadata = BooleanField(required=False)
+    query = CharField(allow_blank=True, required=False)  # OPDS 2.0
+
+
+class BrowserSettingsSerializer(BrowserSettingsSerializerBase):
+    """Browser Settings that the user can change.
+
+    This is the only browse serializer that's submitted.
+    """
+
+    breadcrumbs = BreadcrumbsField(required=False)
+    mtime = TimestampField(read_only=True)
+    twenty_four_hour_time = BooleanField(required=False)

codex/serializers/choices.py

@@ -11,6 +11,7 @@ import re
 from pathlib import Path
 
 from codex.logger.logging import get_logger
+from codex.serializers.route import RouteSerializer
 from codex.settings.settings import BUILD, DEBUG, STATIC_ROOT
 
 LOG = get_logger(__name__)
@@ -48,13 +49,26 @@ _CHOICES_FN_RE = {
     _CHOICES_MODULE_NAME: create_choices_fn_regexes(_CHOICES_MODULE_NAME),
     _ADMIN_CHOICES_MODULE_NAME: create_choices_fn_regexes(_ADMIN_CHOICES_MODULE_NAME),
 }
-_SINGLE_VALUE_KEYS = frozenset({"q", "route"})
+_SINGLE_VALUE_KEYS = frozenset(
+    {
+        "customCovers",
+        "dynamicCovers",
+        "finishOnLastPage",
+        "orderReverse",
+        "q",
+        "readRtlInReverse",
+        "searchResultsLimit",
+        "twentyFourHourTime",
+        "twoPages",
+    }
+)
 
 # Exports
 CHOICES = {}
 DEFAULTS = {}
 WEBSOCKET_MESSAGES = {}
 VUETIFY_NULL_CODE = -1
+DUMMY_NULL_NAME = "_none_"
 
 
 def _find_filename_regex(js_root, module_name):
@@ -122,17 +136,26 @@ def _build_choices_and_defaults(data_dict):
     """Transform the vuetify choice formatted data to key:value dicts."""
     global VUETIFY_NULL_CODE  # noqa PLW0603
     for vuetify_key, value in data_dict.items():
-        if vuetify_key in ("identifierTypes", "groupNames"):
-            continue
-        if vuetify_key in _SINGLE_VALUE_KEYS:
-            DEFAULTS[vuetify_key] = value
-            continue
-        if vuetify_key == "settingsGroup":
-            DEFAULTS["show"] = _build_show_defaults(value)
-            continue
-        if vuetify_key == "vuetifyNullCode":
-            VUETIFY_NULL_CODE = value
-            continue
+        match vuetify_key:
+            case x if x in ("identifierTypes", "groupNames"):
+                continue
+            case x if x in _SINGLE_VALUE_KEYS:
+                DEFAULTS[vuetify_key] = value
+                continue
+            case "settingsGroup":
+                DEFAULTS["show"] = _build_show_defaults(value)
+                continue
+            case "vuetifyNullCode":
+                VUETIFY_NULL_CODE = value
+                continue
+            case "breadcrumbs":
+                deserialized = []
+                for crumb in value:
+                    serializer = RouteSerializer(data=crumb)
+                    serializer.is_valid()
+                    deserialized.append(serializer.validated_data)
+                DEFAULTS[vuetify_key] = tuple(deserialized)
+                continue
 
         CHOICES[vuetify_key] = _parse_choices_to_dict(vuetify_key, value)
 

codex/serializers/fields.py

@@ -0,0 +1,149 @@
+"""Custom fields."""
+
+from abc import ABC
+from datetime import datetime, timezone
+
+import pycountry
+from django.core.exceptions import ValidationError
+from django.utils.translation import gettext_lazy as _
+from rest_framework.serializers import (
+    BooleanField,
+    CharField,
+    ChoiceField,
+    FloatField,
+    IntegerField,
+    ListField,
+)
+
+from codex.logger.logging import get_logger
+from codex.serializers.choices import CHOICES, DUMMY_NULL_NAME, VUETIFY_NULL_CODE
+from codex.serializers.route import RouteSerializer
+
+VUETIFY_NULL_CODE_STR = str(VUETIFY_NULL_CODE)
+LOG = get_logger(__name__)
+
+
+class TimestampField(IntegerField):
+    """IntegerTimestampField."""
+
+    def to_representation(self, value) -> int:
+        """Convert to Jascript millisecond int timestamp from datetime, or castable."""
+        if isinstance(value, datetime):
+            value = value.timestamp()
+        return int(float(value) * 1000)
+
+    def to_internal_value(self, data) -> datetime:  # type: ignore
+        """Convert from castable, likely string to datetime."""
+        return datetime.fromtimestamp(float(data) / 1000, tz=timezone.utc)
+
+
+def validate_decade(decade):
+    """Validate decades."""
+    # * We don't need a whole db call just to be perfectly accurate
+    # * -1s are decoded back into None before validation
+    if decade is not None and decade % 10 != 0:
+        raise ValidationError(_(f"Invalid decade: {decade}"))
+    return True
+
+
+class VuetifyNullCodeFieldMixin:
+    """Convert Vuetify null codes to None."""
+
+    NULL_CODE = VUETIFY_NULL_CODE
+
+    def to_internal_value(self, data):
+        """Convert numeric null code to None."""
+        return None if data == self.NULL_CODE else data
+
+
+class VuetifyFloatField(VuetifyNullCodeFieldMixin, FloatField):  # type: ignore
+    """Float Field with null code conversion."""
+
+
+class VuetifyIntegerField(VuetifyNullCodeFieldMixin, IntegerField):  # type: ignore
+    """Integer Field with null code conversion."""
+
+
+class VuetifyCharField(VuetifyNullCodeFieldMixin, CharField):  # type: ignore
+    """Char Field with null code conversion."""
+
+    NULL_CODE = VUETIFY_NULL_CODE_STR
+
+
+class VuetifyBooleanField(VuetifyNullCodeFieldMixin, BooleanField):  # type: ignore
+    """Boolean Field with null code conversion."""
+
+
+class BookmarkFilterField(ChoiceField):
+    """Bookmark Choice Field."""
+
+    def __init__(self, *args, **kwargs):
+        """Use bookmark filter choices."""
+        super().__init__(
+            *args, choices=tuple(CHOICES["bookmarkFilter"].keys()), **kwargs
+        )
+
+
+class VuetifyDecadeField(VuetifyIntegerField):
+    """Integer field with null code conversion and decade validation."""
+
+    VALIDATORS = (validate_decade,)
+
+    def __init__(self, *args, **kwargs):
+        """Use decade validator."""
+        super().__init__(*args, validators=self.VALIDATORS, **kwargs)
+
+
+class BreadcrumbsField(ListField):
+    """And Array of Routes."""
+
+    child = RouteSerializer()
+
+
+class TopGroupField(ChoiceField):
+    """Valid Top Groups Only."""
+
+    class_choices = tuple(CHOICES["topGroup"].keys())
+
+    def __init__(self, *args, **kwargs):
+        """Initialize with choices."""
+        super().__init__(*args, choices=self.class_choices, **kwargs)
+
+
+class PyCountryField(CharField, ABC):
+    """Serialize to a long pycountry name."""
+
+    LOOKUP_MODULE = pycountry.countries
+    _ALPHA_2_LEN = 2
+
+    def to_representation(self, value):
+        """Lookup the name with pycountry, just copy the value on fail."""
+        if not value:
+            return ""
+        if value == DUMMY_NULL_NAME:
+            return value
+        try:
+            # fix for https://github.com/flyingcircusio/pycountry/issues/41
+            lookup_obj = (
+                self.LOOKUP_MODULE.get(alpha_2=value)
+                if len(value) == self._ALPHA_2_LEN
+                else self.LOOKUP_MODULE.lookup(value)
+            )
+            # If lookup fails, return the key as the name
+        except Exception:
+            LOG.warning(f"Could not serialize name with pycountry {value}")
+            return value
+        else:
+            return lookup_obj.name if lookup_obj else value
+
+
+class CountryField(PyCountryField):
+    """Serializer to long country name."""
+
+    LOOKUP_MODULE = pycountry.countries
+
+
+class LanguageField(PyCountryField):
+    """Serializer to long language name."""
+
+    LOOKUP_MODULE = pycountry.languages