codex 1.7.3a1__py3-none-any.whl → 1.7.4__py3-none-any.whl

codex/serializers/browser/filters.py

@@ -1,68 +1,40 @@
 """Browser Settings Filter Serializers."""
 
-from rest_framework.serializers import BooleanField, ListField, Serializer
+from rest_framework.serializers import ListField, Serializer
 
 from codex.serializers.fields import (
-    BookmarkFilterField,
     VuetifyBooleanField,
-    VuetifyCharField,
     VuetifyDecadeField,
     VuetifyFloatField,
     VuetifyIntegerField,
 )
+from codex.serializers.fields.browser import BookmarkFilterField
 
 
-class BrowserFilterChoicesSerializer(Serializer):
-    """All dynamic filters."""
-
-    age_rating = BooleanField(read_only=True)
-    community_rating = BooleanField(read_only=True)
-    characters = BooleanField(read_only=True)
-    country = BooleanField(read_only=True)
-    critical_rating = BooleanField(read_only=True)
-    contributors = BooleanField(read_only=True)
-    decade = BooleanField(read_only=True)
-    genres = BooleanField(read_only=True)
-    file_type = BooleanField(read_only=True)
-    identifier_type = BooleanField(read_only=True)
-    monochrome = BooleanField(read_only=True)
-    language = BooleanField(read_only=True)
-    locations = BooleanField(read_only=True)
-    original_format = BooleanField(read_only=True)
-    reading_direction = BooleanField(read_only=True)
-    series_groups = BooleanField(read_only=True)
-    stories = BooleanField(read_only=True)
-    story_arcs = BooleanField(read_only=True)
-    tagger = BooleanField(read_only=True)
-    tags = BooleanField(read_only=True)
-    teams = BooleanField(read_only=True)
-    year = BooleanField(read_only=True)
-
-
-class BrowserSettingsFilterSerializer(Serializer):
+class BrowserSettingsFilterInputSerializer(Serializer):
     """Filter values for settings."""
 
     bookmark = BookmarkFilterField(required=False)
     # Dynamic filters
-    age_rating = ListField(child=VuetifyCharField(), required=False)
+    age_rating = ListField(child=VuetifyIntegerField(), 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)
+    file_type = ListField(child=VuetifyIntegerField(), required=False)
     genres = ListField(child=VuetifyIntegerField(), required=False)
-    identifier_type = ListField(child=VuetifyCharField(), required=False)
+    identifier_type = ListField(child=VuetifyIntegerField(), 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)
+    original_format = ListField(child=VuetifyIntegerField(), required=False)
+    reading_direction = ListField(child=VuetifyIntegerField(), 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)
+    tagger = ListField(child=VuetifyIntegerField(), 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

@@ -1,6 +1,7 @@
 """Codex Serializers for the metadata box."""
 
-from rest_framework.serializers import CharField, IntegerField, ListField, Serializer
+from rest_framework.fields import CharField
+from rest_framework.serializers import IntegerField, ListField, Serializer
 
 from codex.serializers.browser.mixins import BrowserAggregateSerializerMixin
 from codex.serializers.models.comic import ComicSerializer

codex/serializers/browser/mixins.py

@@ -5,7 +5,6 @@ from itertools import chain
 
 from rest_framework.serializers import (
     BooleanField,
-    CharField,
     DecimalField,
     IntegerField,
     ListField,
@@ -14,6 +13,7 @@ from rest_framework.serializers import (
 )
 
 from codex.logger.logging import get_logger
+from codex.serializers.fields.browser import TopGroupField
 from codex.util import max_none
 from codex.views.const import EPOCH_START
 
@@ -23,7 +23,7 @@ LOG = get_logger(__name__)
 class BrowserAggregateSerializerMixin(Serializer):
     """Mixin for browser, opds & metadata serializers."""
 
-    group = CharField(read_only=True, max_length=1)
+    group = TopGroupField(read_only=True)
     ids = ListField(child=IntegerField(), read_only=True)
 
     # Aggregate Annotations
@@ -64,5 +64,9 @@ class BrowserAggregateSerializerMixin(Serializer):
         )
         mtime = self._get_max_updated_at(EPOCH_START, updated_ats)
         if obj.bmua_is_max:
-            mtime: datetime = max_none(mtime, obj.bookmark_updated_at, EPOCH_START)  # type: ignore
+            mtime: datetime | None = max_none(
+                mtime, obj.bookmark_updated_at, EPOCH_START
+            )
+        if mtime is None:
+            return 0
         return int(mtime.timestamp() * 1000)

codex/serializers/browser/mtime.py

@@ -1,17 +1,15 @@
 """Group Mtimes."""
 
-from rest_framework.serializers import CharField, Serializer
+from rest_framework.serializers import Serializer
 
-from codex.serializers.browser.settings import BrowserSettingsFilterSerializer
+from codex.serializers.browser.settings import BrowserFilterChoicesInputSerilalizer
 from codex.serializers.fields import TimestampField
 from codex.serializers.route import SimpleRouteSerializer
 
 
-class GroupsMtimeSerializer(Serializer):
+class GroupsMtimeSerializer(BrowserFilterChoicesInputSerilalizer):
     """Groups Mtimes."""
 
-    filters = BrowserSettingsFilterSerializer(required=False)
-    q = CharField(allow_blank=True, required=False)
     groups = SimpleRouteSerializer(many=True, required=True)
 
 

codex/serializers/browser/page.py

@@ -1,17 +1,18 @@
 """Browser Page Serializer."""
 
-from rest_framework.serializers import (
+from rest_framework.fields import (
     BooleanField,
     CharField,
     DecimalField,
     IntegerField,
-    Serializer,
 )
+from rest_framework.serializers import Serializer
 
 from codex.serializers.browser.mixins import (
     BrowserAggregateSerializerMixin,
 )
-from codex.serializers.fields import BreadcrumbsField, TimestampField
+from codex.serializers.fields import TimestampField
+from codex.serializers.fields.browser import BreadcrumbsField, TopGroupField
 
 
 class BrowserCardSerializer(BrowserAggregateSerializerMixin):
@@ -57,7 +58,7 @@ class BrowserPageSerializer(Serializer):
     title = BrowserTitleSerializer(read_only=True)
     zero_pad = IntegerField(read_only=True)
     libraries_exist = BooleanField(read_only=True)
-    model_group = CharField(read_only=True)
+    model_group = TopGroupField(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)

codex/serializers/browser/settings.py

@@ -9,8 +9,9 @@ from rest_framework.serializers import (
 )
 
 from codex.choices import BROWSER_ORDER_BY_CHOICES
-from codex.serializers.browser.filters import BrowserSettingsFilterSerializer
-from codex.serializers.fields import BreadcrumbsField, TimestampField, TopGroupField
+from codex.serializers.browser.filters import BrowserSettingsFilterInputSerializer
+from codex.serializers.fields import TimestampField
+from codex.serializers.fields.browser import BreadcrumbsField, TopGroupField
 from codex.serializers.route import SimpleRouteSerializer
 
 
@@ -26,7 +27,8 @@ class BrowserSettingsShowGroupFlagsSerializer(Serializer):
 class BrowserFilterChoicesInputSerilalizer(Serializer):
     """Browser Settings for the filter choices response."""
 
-    filters = BrowserSettingsFilterSerializer(required=False)
+    filters = BrowserSettingsFilterInputSerializer(required=False)
+    # NOT Sanitized because so complex.
     q = CharField(allow_blank=True, required=False)
 
 
@@ -51,7 +53,6 @@ class BrowserCoverInputSerializer(BrowserCoverInputSerializerBase):
 class BrowserSettingsSerializerBase(BrowserCoverInputSerializerBase):
     """Base Serializer for Browser & OPDS Settings."""
 
-    # search_results_limit = IntegerField(required=False)
     top_group = TopGroupField(required=False)
 
 
@@ -64,7 +65,8 @@ class OPDSSettingsSerializer(BrowserSettingsSerializerBase):
 
 
 class BrowserSettingsSerializer(BrowserSettingsSerializerBase):
-    """Browser Settings that the user can change.
+    """
+    Browser Settings that the user can change.
 
     This is the only browse serializer that's submitted.
     """

codex/serializers/fields/__init__.py

@@ -0,0 +1,37 @@
+"""Custom Serializer Fields."""
+
+from codex.serializers.fields.auth import TimestampField, TimezoneField
+from codex.serializers.fields.group import BrowseGroupField
+from codex.serializers.fields.reader import FitToField, ReadingDirectionField
+from codex.serializers.fields.sanitized import SanitizedCharField
+from codex.serializers.fields.session import SessionKeyField
+from codex.serializers.fields.stats import (
+    CountDictField,
+    SerializerChoicesField,
+    StringListMultipleChoiceField,
+)
+from codex.serializers.fields.vuetify import (
+    VuetifyBooleanField,
+    VuetifyCharField,
+    VuetifyDecadeField,
+    VuetifyFloatField,
+    VuetifyIntegerField,
+)
+
+__all__ = (
+    "TimestampField",
+    "TimezoneField",
+    "BrowseGroupField",
+    "SanitizedCharField",
+    "StringListMultipleChoiceField",
+    "SerializerChoicesField",
+    "CountDictField",
+    "VuetifyFloatField",
+    "VuetifyIntegerField",
+    "VuetifyCharField",
+    "VuetifyBooleanField",
+    "VuetifyDecadeField",
+    "FitToField",
+    "ReadingDirectionField",
+    "SessionKeyField",
+)

codex/serializers/fields/auth.py

@@ -0,0 +1,45 @@
+"""Custom fields."""
+
+from datetime import datetime, timezone
+from zoneinfo import ZoneInfo, ZoneInfoNotFoundError
+
+from rest_framework.exceptions import ValidationError
+from rest_framework.serializers import (
+    CharField,
+    IntegerField,
+)
+
+from codex.logger.logging import get_logger
+
+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[reportIncompatibleMethodOverride]
+        """Convert from castable, likely string to datetime."""
+        return datetime.fromtimestamp(float(data) / 1000, tz=timezone.utc)
+
+
+def validate_timezone(data):
+    """Validate Timezone."""
+    try:
+        ZoneInfo(data)
+    except ZoneInfoNotFoundError as exc:
+        raise ValidationError from exc
+    return data
+
+
+class TimezoneField(CharField):
+    """Timezone field."""
+
+    def __init__(self, *args, **kwargs):
+        """Call Charfield with defaults."""
+        super().__init__(*args, min_length=2, validators=[validate_timezone], **kwargs)

codex/serializers/fields/browser.py

@@ -0,0 +1,85 @@
+"""Custom fields."""
+
+from abc import ABC
+
+import pycountry
+from rest_framework.serializers import (
+    ChoiceField,
+    ListField,
+)
+
+from codex.choices import (
+    BROWSER_BOOKMARK_FILTER_CHOICES,
+    BROWSER_TOP_GROUP_CHOICES,
+    DUMMY_NULL_NAME,
+)
+from codex.logger.logging import get_logger
+from codex.serializers.fields.sanitized import SanitizedCharField
+from codex.serializers.route import RouteSerializer
+
+LOG = get_logger(__name__)
+
+
+class TopGroupField(ChoiceField):
+    """Valid Top Groups Only."""
+
+    class_choices = tuple(BROWSER_TOP_GROUP_CHOICES.keys())
+
+    def __init__(self, *args, **kwargs):
+        """Initialize with choices."""
+        super().__init__(*args, choices=self.class_choices, **kwargs)
+
+
+class BookmarkFilterField(ChoiceField):
+    """Bookmark Choice Field."""
+
+    def __init__(self, *args, **kwargs):
+        """Use bookmark filter choices."""
+        super().__init__(
+            *args, choices=tuple(BROWSER_BOOKMARK_FILTER_CHOICES.keys()), **kwargs
+        )
+
+
+class PyCountryField(SanitizedCharField, 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
+
+
+class BreadcrumbsField(ListField):
+    """And Array of Routes."""
+
+    child = RouteSerializer()

codex/serializers/fields/group.py

@@ -0,0 +1,13 @@
+"""Browser Group Field."""
+
+from rest_framework.fields import ChoiceField
+
+from codex.choices import BROWSER_GROUP_CHOICES
+
+
+class BrowseGroupField(ChoiceField):
+    """BrowseGroup Field."""
+
+    def __init__(self, *args, **kwargs):
+        """Add choices."""
+        super().__init__(*args, choices=tuple(BROWSER_GROUP_CHOICES.keys()), **kwargs)

codex/serializers/fields/reader.py

@@ -0,0 +1,22 @@
+"""Reader Fields."""
+
+from rest_framework.serializers import ChoiceField
+
+from codex.models import Bookmark
+from codex.models.comic import ReadingDirection
+
+
+class FitToField(ChoiceField):
+    """Bookmark FitTo Fieild."""
+
+    def __init__(self, *args, **kwargs):
+        """Add Choices."""
+        super().__init__(*args, choices=Bookmark.FitTo.values, **kwargs)
+
+
+class ReadingDirectionField(ChoiceField):
+    """Reading Direction Field."""
+
+    def __init__(self, *args, **kwargs):
+        """Add Choices."""
+        super().__init__(*args, choices=ReadingDirection.values, **kwargs)

codex/serializers/fields/sanitized.py

@@ -0,0 +1,13 @@
+"""Sanitied Fields."""
+
+from nh3 import clean
+from rest_framework.fields import CharField
+
+
+class SanitizedCharField(CharField):
+    """Sanitize CharField using NH3."""
+
+    def to_internal_value(self, data):
+        """Sanitize CharField using NH3."""
+        sanitized_data = clean(data)
+        return super().to_internal_value(sanitized_data)

codex/serializers/fields/session.py

@@ -0,0 +1,15 @@
+"""Session Custom Fields."""
+
+from rest_framework.fields import ChoiceField
+
+from codex.choices import BROWSER_DEFAULTS, READER_DEFAULTS
+
+_SESSION_KEYS = (*READER_DEFAULTS.keys(), *BROWSER_DEFAULTS.keys(), "filters")
+
+
+class SessionKeyField(ChoiceField):
+    """Session Key Field."""
+
+    def __init__(self, *args, **kwargs):
+        """Add choices."""
+        super().__init__(*args, choices=_SESSION_KEYS, **kwargs)

codex/serializers/fields/stats.py

@@ -0,0 +1,36 @@
+"""Custom Vuetify fields."""
+
+from rest_framework.fields import DictField, IntegerField
+from rest_framework.serializers import MultipleChoiceField
+
+from codex.logger.logging import get_logger
+
+LOG = get_logger(__name__)
+
+
+class StringListMultipleChoiceField(MultipleChoiceField):
+    """A Multiple Choice Field expressed as as a comma delimited string."""
+
+    def to_internal_value(self, data):
+        """Convert comma delimited strings to sets."""
+        if isinstance(data, str):
+            data = frozenset(data.split(","))
+        return super().to_internal_value(data)  # type: ignore[reportIncompatibleMethodOverride]
+
+
+class SerializerChoicesField(StringListMultipleChoiceField):
+    """A String List Multiple Choice Field limited to a specified serializer's fields."""
+
+    def __init__(self, *args, serializer=None, **kwargs):
+        """Limit choices to fields from serializers."""
+        if not serializer:
+            reason = "serializer required for this field."
+            raise ValueError(reason)
+        choices = serializer().get_fields().keys()
+        super().__init__(*args, choices=choices, **kwargs)
+
+
+class CountDictField(DictField):
+    """Dict for counting things."""
+
+    child = IntegerField(read_only=True)

codex/serializers/fields/vuetify.py

@@ -0,0 +1,62 @@
+"""Custom Vuetify fields."""
+
+from django.utils.translation import gettext_lazy as _
+from rest_framework.exceptions import ValidationError
+from rest_framework.serializers import (
+    BooleanField,
+    CharField,
+    FloatField,
+    IntegerField,
+)
+
+from codex.choices import VUETIFY_NULL_CODE
+from codex.logger.logging import get_logger
+
+LOG = get_logger(__name__)
+
+
+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[reportIncompatibleMethodOverride]
+    """Float Field with null code conversion."""
+
+
+class VuetifyIntegerField(VuetifyNullCodeFieldMixin, IntegerField):  # type: ignore[reportIncompatibleMethodOverride]
+    """Integer Field with null code conversion."""
+
+
+class VuetifyCharField(VuetifyNullCodeFieldMixin, CharField):  # type: ignore[reportIncompatibleMethodOverride]
+    """Char Field with null code conversion."""
+
+    NULL_CODE = str(VUETIFY_NULL_CODE)
+
+
+class VuetifyBooleanField(VuetifyNullCodeFieldMixin, BooleanField):  # type: ignore[reportIncompatibleMethodOverride]
+    """Boolean Field with null code conversion."""
+
+
+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(_("Invalid decade: ") + f"{decade}")
+    return True
+
+
+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)

codex/serializers/models/base.py

@@ -6,7 +6,7 @@ from rest_framework.serializers import ModelSerializer, SerializerMetaclass
 class BaseModelSerializer(ModelSerializer):
     """BaseModel Serializer for inheritance."""
 
-    class Meta(SerializerMetaclass):  # type: ignore
+    class Meta(SerializerMetaclass):  # type: ignore[reportIncompatibleVariableOverride]
         """Use explicit metaclass instead of python 3 method."""
 
         abstract = True

codex/serializers/models/comic.py

@@ -38,8 +38,8 @@ class ComicSerializer(BaseModelSerializer):
     pk = IntegerField(source="id")
 
     # Annotations
-    # issue_count = IntegerField(allow_null=True)
-    # volume_count = IntegerField(allow_null=True)
+    # issue_count = IntegerField(allow_null=True) could be 1
+    # volume_count = IntegerField(allow_null=True) could be 1
 
     # Group FKs
     publisher = PublisherSerializer(allow_null=True)

codex/serializers/models/groups.py

@@ -43,7 +43,6 @@ class SeriesSerializer(GroupModelSerializer):
         """Configure model."""
 
         model = Series
-        # fields = (*NamedModelMeta.fields, "volume_count")
 
 
 class VolumeSerializer(GroupModelSerializer):
@@ -53,4 +52,3 @@ class VolumeSerializer(GroupModelSerializer):
         """Configure model."""
 
         model = Volume
-        # fields = (*NamedModelMeta.fields, "issue_count")

codex/serializers/models/named.py

@@ -1,6 +1,6 @@
 """Named model Serializers."""
 
-from rest_framework.serializers import CharField
+from rest_framework.fields import CharField
 
 from codex.models import (
     AgeRating,

codex/serializers/models/pycountry.py

@@ -5,7 +5,7 @@ from codex.models import (
     Country,
     Language,
 )
-from codex.serializers.fields import CountryField, LanguageField
+from codex.serializers.fields.browser import CountryField, LanguageField
 from codex.serializers.models.named import NamedModelSerializer
 
 LOG = get_logger(__name__)

codex/serializers/opds/authentication.py

@@ -1,9 +1,11 @@
-"""OPDS Authentication 1.0 Serializer.
+"""
+OPDS Authentication 1.0 Serializer.
 
 https://drafts.opds.io/schema/authentication.schema.json
 """
 
-from rest_framework.serializers import CharField, IntegerField, Serializer
+from rest_framework.fields import CharField
+from rest_framework.serializers import IntegerField, Serializer
 
 
 class OPDSAuth1LinksSerializer(Serializer):

codex/serializers/opds/urls.py

@@ -1,6 +1,7 @@
 """OPDS URLs."""
 
-from rest_framework.serializers import CharField, Serializer
+from rest_framework.fields import CharField
+from rest_framework.serializers import Serializer
 
 
 class OPDSURLsSerializer(Serializer):

codex/serializers/opds/v1.py

@@ -2,16 +2,17 @@
 
 from zoneinfo import ZoneInfo
 
-from rest_framework.serializers import (
+from rest_framework.fields import (
     BooleanField,
     CharField,
     DateField,
     DateTimeField,
     DictField,
     IntegerField,
-    Serializer,
 )
+from rest_framework.serializers import Serializer
 
+from codex.serializers.fields.browser import TopGroupField
 from codex.serializers.models.pycountry import LanguageSerializer
 
 UTC_TZ = ZoneInfo("UTC")
@@ -25,7 +26,7 @@ class OPDS1TemplateLinkSerializer(Serializer):
     mime_type = CharField(read_only=True)
     title = CharField(read_only=True, required=False)
     length = IntegerField(read_only=True, required=False)
-    facet_group = CharField(read_only=True, required=False)
+    facet_group = TopGroupField(read_only=True, required=False)
     facet_active = BooleanField(read_only=True, required=False)
     thr_count = IntegerField(read_only=True, required=False)
     pse_count = IntegerField(read_only=True, required=False)