codex 1.6.0a10__py3-none-any.whl → 1.6.0a12__py3-none-any.whl

codex/librarian/covers/create.py

@@ -26,17 +26,17 @@ class CoverCreateMixin(CoverPathMixin):
     @classmethod
     def _create_cover_thumbnail(cls, cover_image_data):
         """Isolate the save thumbnail function for leak detection."""
-        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()
+        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
 
     @classmethod
     def _get_comic_cover_image(cls, comic_path):
@@ -71,15 +71,18 @@ class CoverCreateMixin(CoverPathMixin):
                 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)
+            thumb_buffer = cls._create_cover_thumbnail(cover_image)
+            thumb_bytes = thumb_buffer.getvalue()
+            thumb_buffer.seek(0)
         except Exception as exc:
-            data = b""
+            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}")
 
-        task = CoverSaveToCache(cover_path, data)
+        task = CoverSaveToCache(cover_path, thumb_bytes)
         librarian_queue.put(task)
-        return data
+        return thumb_buffer
 
     def save_cover_to_cache(self, cover_path, data):
         """Save cover thumb image to the disk cache."""
@@ -110,9 +113,11 @@ class CoverCreateMixin(CoverPathMixin):
                     status.decrement_total()
                 else:
                     # bulk contributor creates covers inline
-                    self.create_cover_from_path(
+                    data = 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)
 

codex/serializers/browser/choices.py

@@ -4,66 +4,40 @@ from types import MappingProxyType
 
 from rest_framework.fields import SerializerMethodField
 from rest_framework.serializers import (
-    BooleanField,
     CharField,
-    ChoiceField,
-    FloatField,
-    IntegerField,
     Serializer,
 )
 from rest_framework.utils.serializer_helpers import ReturnList
 
 from codex.serializers.browser.filters import BrowserSettingsFilterSerializer
 from codex.serializers.fields import (
-    BooleanListField,
-    CharListField,
-    DecadeListField,
-    FloatListField,
-    IntListField,
+    VuetifyCharField,
+    VuetifyIntegerField,
 )
+from codex.serializers.models.pycountry import CountrySerializer, LanguageSerializer
 
 
 class BrowserChoicesCharPkSerializer(Serializer):
-    """Named Model Serailizer with pk = char hack for languages & countries."""
+    """Named Model Serializer."""
 
-    pk = CharField(read_only=True)
+    pk = VuetifyCharField(read_only=True)
     name = CharField(read_only=True)
 
 
-class BrowserChoicesBoolPkSerializer(BrowserChoicesCharPkSerializer):
-    """Named Model Serailizer with pk = char hack for languages & countries."""
-
-    pk = BooleanField(read_only=True)
-
-
-class BrowserChoicesIntPkSerializer(BrowserChoicesCharPkSerializer):
-    """Named Model Serailizer with pk = char hack for languages & countries."""
-
-    pk = IntegerField(read_only=True)
-
-
-class BrowserChoicesFloatPkSerializer(BrowserChoicesCharPkSerializer):
+class BrowserChoicesIntegerPkSerializer(BrowserChoicesCharPkSerializer):
     """Named Model Serailizer with pk = char hack for languages & countries."""
 
-    pk = FloatField(read_only=True)
+    pk = VuetifyIntegerField(read_only=True)
 
 
-_CHOICES_TYPE_SERIALIZER_MAP = MappingProxyType(
-    {
-        BooleanListField: BrowserChoicesBoolPkSerializer,
-        CharListField: BrowserChoicesCharPkSerializer,
-        ChoiceField: BrowserChoicesCharPkSerializer,
-        DecadeListField: BrowserChoicesIntPkSerializer,
-        FloatListField: BrowserChoicesFloatPkSerializer,
-        IntListField: BrowserChoicesIntPkSerializer,
-    }
-)
-_CHOICES_SERIALIZER_CLASS_MAP = MappingProxyType(
+_CHOICES_NAME_SERIALIZER_MAP = MappingProxyType(
     {
-        name: _CHOICES_TYPE_SERIALIZER_MAP[field.__class__]
-        for name, field in BrowserSettingsFilterSerializer().fields.items()  # type: ignore
+        "bookmark": BrowserChoicesCharPkSerializer,
+        "country": CountrySerializer,
+        "language": LanguageSerializer,
     }
 )
+_LIST_FIELDS = frozenset({"decade", "monochrome", "reading_direction", "year"})
 
 
 class BrowserChoicesFilterSerializer(Serializer):
@@ -73,10 +47,15 @@ class BrowserChoicesFilterSerializer(Serializer):
 
     def get_choices(self, obj) -> ReturnList:
         """Dynamic Serializer response by field type."""
-        key = obj.get("field_name", "")
+        field_name = obj.get("field_name", "")
         choices = obj.get("choices", [])
-        serializer_class = _CHOICES_SERIALIZER_CLASS_MAP.get(
-            key, BrowserChoicesCharPkSerializer
-        )
-        serializer = serializer_class(choices, many=True)
-        return serializer.data  # type: ignore
+        serializer_class = _CHOICES_NAME_SERIALIZER_MAP.get(field_name)
+        value: ReturnList
+        if serializer_class:
+            value = serializer_class(choices, many=True).data  # type: ignore
+        elif not serializer_class and field_name in _LIST_FIELDS:
+            field = BrowserSettingsFilterSerializer().get_fields().get(field_name)  # type: ignore
+            value = field.to_representation(choices)
+        else:
+            value = BrowserChoicesIntegerPkSerializer(choices, many=True).data  # type: ignore
+        return value

codex/serializers/browser/filters.py

@@ -1,18 +1,14 @@
 """Browser Settings Filter Serializers."""
 
-from rest_framework.serializers import (
-    BooleanField,
-    ChoiceField,
-    Serializer,
-)
+from rest_framework.serializers import BooleanField, ListField, Serializer
 
-from codex.serializers.choices import CHOICES
 from codex.serializers.fields import (
-    BooleanListField,
-    CharListField,
-    DecadeListField,
-    FloatListField,
-    IntListField,
+    BookmarkFilterField,
+    VuetifyBooleanField,
+    VuetifyCharField,
+    VuetifyDecadeField,
+    VuetifyFloatField,
+    VuetifyIntegerField,
 )
 
 
@@ -46,29 +42,27 @@ class BrowserFilterChoicesSerializer(Serializer):
 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/mixins.py

@@ -1,27 +1,33 @@
 """Serializer mixins."""
 
+from datetime import datetime, timezone
+
 from rest_framework.serializers import (
     BooleanField,
     CharField,
     DateTimeField,
     DecimalField,
     IntegerField,
+    ListField,
     Serializer,
+    SerializerMethodField,
 )
 
-from codex.serializers.browser.filters import IntListField
-from codex.serializers.fields import TimestampField
+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 = IntListField(read_only=True)
+    ids = ListField(child=IntegerField(), read_only=True)
 
     # Aggregate Annotations
     child_count = IntegerField(read_only=True)
-    mtime = TimestampField(read_only=True)
+    mtime = SerializerMethodField(read_only=True)
 
     # Bookmark annotations
     page = IntegerField(read_only=True)
@@ -30,3 +36,30 @@ class BrowserAggregateSerializerMixin(Serializer):
     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/settings.py

@@ -11,6 +11,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 BreadcrumbsField, TimestampField, TopGroupField
+from codex.serializers.route import SimpleRouteSerializer
 
 VUETIFY_NULL_CODE_STR = str(VUETIFY_NULL_CODE)
 
@@ -31,8 +32,8 @@ class BrowserFilterChoicesInputSerilalizer(Serializer):
     q = CharField(allow_blank=True, required=False)
 
 
-class BrowserCoverInputSerializer(BrowserFilterChoicesInputSerilalizer):
-    """Browser Settings for the cover response."""
+class BrowserCoverInputSerializerBase(BrowserFilterChoicesInputSerilalizer):
+    """Base Serializer for Cover and Settings."""
 
     custom_covers = BooleanField(required=False)
     dynamic_covers = BooleanField(required=False)
@@ -41,7 +42,13 @@ class BrowserCoverInputSerializer(BrowserFilterChoicesInputSerilalizer):
     show = BrowserSettingsShowGroupFlagsSerializer(required=False)
 
 
-class BrowserSettingsSerializerBase(BrowserCoverInputSerializer):
+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)

codex/serializers/choices.py

@@ -53,10 +53,13 @@ _SINGLE_VALUE_KEYS = frozenset(
     {
         "customCovers",
         "dynamicCovers",
+        "finishOnLastPage",
         "orderReverse",
         "q",
+        "readRtlInReverse",
         "searchResultsLimit",
         "twentyFourHourTime",
+        "twoPages",
     }
 )
 
@@ -65,6 +68,7 @@ CHOICES = {}
 DEFAULTS = {}
 WEBSOCKET_MESSAGES = {}
 VUETIFY_NULL_CODE = -1
+DUMMY_NULL_NAME = "_none_"
 
 
 def _find_filename_regex(js_root, module_name):

codex/serializers/fields.py

@@ -3,9 +3,9 @@
 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.fields import Field
 from rest_framework.serializers import (
     BooleanField,
     CharField,
@@ -15,10 +15,12 @@ from rest_framework.serializers import (
     ListField,
 )
 
-from codex.serializers.choices import CHOICES, VUETIFY_NULL_CODE
+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):
@@ -35,93 +37,61 @@ class TimestampField(IntegerField):
         return datetime.fromtimestamp(float(data) / 1000, tz=timezone.utc)
 
 
-def validate_decades(decades):
+def validate_decade(decade):
     """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}"))
+    if decade is not None and decade % 10 != 0:
+        raise ValidationError(_(f"Invalid decade: {decade}"))
+    return True
 
 
-def validate_int_null(values):
-    """Use a special code for null.
+class VuetifyNullCodeFieldMixin:
+    """Convert Vuetify null codes to None."""
 
-    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
+    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
 
-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 VuetifyFloatField(VuetifyNullCodeFieldMixin, FloatField):  # type: ignore
+    """Float Field with null code conversion."""
 
 
-class FilterListField(ListField, ABC):
-    """Filter List field with custom arguments."""
+class VuetifyIntegerField(VuetifyNullCodeFieldMixin, IntegerField):  # type: ignore
+    """Integer Field with null code conversion."""
 
-    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 VuetifyCharField(VuetifyNullCodeFieldMixin, CharField):  # type: ignore
+    """Char Field with null code conversion."""
 
+    NULL_CODE = VUETIFY_NULL_CODE_STR
 
-class IntListField(FilterListField):
-    """Integer List Field with validation."""
 
-    CHILD_CLASS = IntegerField  # type: ignore
-    VALIDATORS = (validate_int_null,)
+class VuetifyBooleanField(VuetifyNullCodeFieldMixin, BooleanField):  # type: ignore
+    """Boolean Field with null code conversion."""
 
 
-class DecadeListField(IntListField):
-    """Integer List Field with validation for decades."""
+class BookmarkFilterField(ChoiceField):
+    """Bookmark Choice Field."""
 
-    VALIDATORS = (validate_int_null, validate_decades)
-
-
-class CharListField(FilterListField):
-    """Char List Field with validation."""
+    def __init__(self, *args, **kwargs):
+        """Use bookmark filter choices."""
+        super().__init__(
+            *args, choices=tuple(CHOICES["bookmarkFilter"].keys()), **kwargs
+        )
 
-    CHILD_CLASS = CharField  # type: ignore
-    VALIDATORS = (validate_str_null,)
 
+class VuetifyDecadeField(VuetifyIntegerField):
+    """Integer field with null code conversion and decade validation."""
 
-class BooleanListField(FilterListField):
-    """Bool List Field with validation."""
+    VALIDATORS = (validate_decade,)
 
-    CHILD_CLASS = BooleanField  # type: ignore
-    VALIDATORS = (validate_int_null,)
+    def __init__(self, *args, **kwargs):
+        """Use decade validator."""
+        super().__init__(*args, validators=self.VALIDATORS, **kwargs)
 
 
 class BreadcrumbsField(ListField):
@@ -138,3 +108,42 @@ class TopGroupField(ChoiceField):
     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

codex/serializers/models/pycountry.py

@@ -1,73 +1,33 @@
 """Pycountry Model Serializers."""
 
-import pycountry
-from drf_spectacular.types import OpenApiTypes
-from drf_spectacular.utils import extend_schema_field
-from rest_framework.serializers import (
-    SerializerMethodField,
-)
-
+from codex.logger.logging import get_logger
 from codex.models import (
     Country,
     Language,
 )
+from codex.serializers.fields import CountryField, LanguageField
 from codex.serializers.models.named import NamedModelSerializer
 
+LOG = get_logger(__name__)
 
-class PyCountrySerializer(NamedModelSerializer):
-    """PyCountry tag serializer to include long names.
 
-    Takes a single string value and serializes the value to
-    a pk attribute and a pycountry long name lookup of that value to
-    the name.
-    """
-
-    LOOKUP_MODULE = pycountry.countries
-    _ALPHA_2_LEN = 2
+class CountrySerializer(NamedModelSerializer):
+    """Pycountry serializer for country field."""
 
-    name = SerializerMethodField()
+    name = CountryField(read_only=True)
 
     class Meta(NamedModelSerializer.Meta):
-        """Abstract class."""
-
-        abstract = True
-
-    @classmethod
-    def lookup_name(cls, lookup_module, obj):
-        """Lookup the name with pycountry, just copy the key on fail."""
-        name = obj.name
-        if not name:
-            return ""
-        # fix for https://github.com/flyingcircusio/pycountry/issues/41
-        lookup_obj = (
-            lookup_module.get(alpha_2=name)
-            if len(name) == cls._ALPHA_2_LEN
-            else lookup_module.lookup(name)
-        )
-        # If lookup fails, return the key as the name
-        return lookup_obj.name if lookup_obj else name
+        """Configure model."""
 
-    @extend_schema_field(OpenApiTypes.STR)
-    def get_name(self, obj):
-        """Lookup the name with pycountry, just copy the key on fail."""
-        return self.lookup_name(self.LOOKUP_MODULE, obj)
+        model = Country
 
 
-class LanguageSerializer(PyCountrySerializer):
+class LanguageSerializer(NamedModelSerializer):
     """Pycountry serializer for language field."""
 
-    LOOKUP_MODULE = pycountry.languages
+    name = LanguageField(read_only=True)
 
-    class Meta(PyCountrySerializer.Meta):
+    class Meta(NamedModelSerializer.Meta):
         """Configure model."""
 
         model = Language
-
-
-class CountrySerializer(PyCountrySerializer):
-    """Pycountry serializer for country field."""
-
-    class Meta(PyCountrySerializer.Meta):
-        """Configure model."""
-
-        model = Country