codex 1.7.15__py3-none-any.whl → 1.8.0__py3-none-any.whl

codex/serializers/browser/settings.py

@@ -7,12 +7,16 @@ from rest_framework.serializers import (
     IntegerField,
     Serializer,
 )
+from typing_extensions import override
 
 from codex.choices.browser import BROWSER_ORDER_BY_CHOICES
 from codex.serializers.browser.filters import BrowserSettingsFilterInputSerializer
 from codex.serializers.fields import TimestampField
-from codex.serializers.fields.browser import BreadcrumbsField, TopGroupField
+from codex.serializers.fields.browser import BreadcrumbsField
+from codex.serializers.fields.group import BrowseGroupField, BrowserRouteGroupField
+from codex.serializers.mixins import JSONFieldSerializer
 from codex.serializers.route import SimpleRouteSerializer
+from codex.serializers.settings import SettingsInputSerializer
 
 
 class BrowserSettingsShowGroupFlagsSerializer(Serializer):
@@ -24,17 +28,21 @@ class BrowserSettingsShowGroupFlagsSerializer(Serializer):
     v = BooleanField()
 
 
-class BrowserFilterChoicesInputSerilalizer(Serializer):
+class BrowserFilterChoicesInputSerializer(JSONFieldSerializer):
     """Browser Settings for the filter choices response."""
 
+    JSON_FIELDS: frozenset[str] = frozenset({"filters"})
+
     filters = BrowserSettingsFilterInputSerializer(required=False)
     # NOT Sanitized because so complex.
     q = CharField(allow_blank=True, required=False)
 
 
-class BrowserCoverInputSerializerBase(BrowserFilterChoicesInputSerilalizer):
+class BrowserCoverInputSerializerBase(BrowserFilterChoicesInputSerializer):
     """Base Serializer for Cover and Settings."""
 
+    JSON_FIELDS = frozenset(BrowserFilterChoicesInputSerializer.JSON_FIELDS | {"show"})
+
     custom_covers = BooleanField(required=False)
     dynamic_covers = BooleanField(required=False)
     order_by = ChoiceField(
@@ -47,13 +55,24 @@ class BrowserCoverInputSerializerBase(BrowserFilterChoicesInputSerilalizer):
 class BrowserCoverInputSerializer(BrowserCoverInputSerializerBase):
     """Browser Settings for the cover response."""
 
-    parent = SimpleRouteSerializer(required=False)
+    JSON_FIELDS = frozenset(
+        BrowserCoverInputSerializerBase.JSON_FIELDS | {"parent_route"}
+    )
+
+    parent_route = SimpleRouteSerializer(required=False)
 
 
 class BrowserSettingsSerializerBase(BrowserCoverInputSerializerBase):
     """Base Serializer for Browser & OPDS Settings."""
 
-    top_group = TopGroupField(required=False)
+    top_group = BrowseGroupField(required=False)
+
+    @override
+    def to_internal_value(self, data):
+        if "q" not in data and (query := data.get("query")):
+            # parse query param for opds v2
+            data["q"] = query
+        return super().to_internal_value(data)
 
 
 class OPDSSettingsSerializer(BrowserSettingsSerializerBase):
@@ -71,7 +90,18 @@ class BrowserSettingsSerializer(BrowserSettingsSerializerBase):
     This is the only browse serializer that's submitted.
     """
 
+    JSON_FIELDS: frozenset[str] = frozenset(
+        BrowserSettingsSerializerBase.JSON_FIELDS | {"breadcrumbs"}
+    )
+
     breadcrumbs = BreadcrumbsField(required=False)
     mtime = TimestampField(read_only=True)
     twenty_four_hour_time = BooleanField(required=False)
     always_show_filename = BooleanField(required=False)
+
+
+class BrowserSettingsInputSerializer(SettingsInputSerializer):
+    """Browser Set Settings Input Serializer."""
+
+    group = BrowserRouteGroupField(required=False)
+    breadcrumb_names = BooleanField(required=False, default=True)

codex/serializers/fields/__init__.py

@@ -14,7 +14,7 @@ from codex.serializers.fields.vuetify import (
     VuetifyBooleanField,
     VuetifyCharField,
     VuetifyDecadeField,
-    VuetifyFloatField,
+    VuetifyDecimalField,
     VuetifyIntegerField,
 )
 
@@ -32,6 +32,6 @@ __all__ = (
     "VuetifyBooleanField",
     "VuetifyCharField",
     "VuetifyDecadeField",
-    "VuetifyFloatField",
+    "VuetifyDecimalField",
     "VuetifyIntegerField",
 )

codex/serializers/fields/auth.py

@@ -8,22 +8,21 @@ from rest_framework.serializers import (
     CharField,
     IntegerField,
 )
-
-from codex.logger.logger import get_logger
-
-LOG = get_logger(__name__)
+from typing_extensions import override
 
 
 class TimestampField(IntegerField):
     """IntegerTimestampField."""
 
+    @override
     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]
+    @override
+    def to_internal_value(self, data) -> datetime:  # pyright: ignore[reportIncompatibleMethodOverride]
         """Convert from castable, likely string to datetime."""
         return datetime.fromtimestamp(float(data) / 1000, tz=timezone.utc)
 

codex/serializers/fields/base.py

@@ -0,0 +1,16 @@
+"""Base Fields."""
+
+from abc import ABC
+from collections.abc import Sequence
+
+from rest_framework.fields import ChoiceField
+
+
+class CodexChoiceField(ChoiceField, ABC):
+    """Valid class choices."""
+
+    class_choices: Sequence[str] = ()
+
+    def __init__(self, *args, **kwargs):
+        """Initialize with choices."""
+        super().__init__(*args, choices=self.class_choices, **kwargs)

codex/serializers/fields/browser.py

@@ -3,49 +3,33 @@
 from abc import ABC
 
 import pycountry
-from rest_framework.serializers import (
-    ChoiceField,
-    ListField,
-)
+from loguru import logger
+from pycountry.db import Database
+from rest_framework.serializers import ListField
+from typing_extensions import override
 
 from codex.choices.browser import (
     BROWSER_BOOKMARK_FILTER_CHOICES,
-    BROWSER_TOP_GROUP_CHOICES,
     DUMMY_NULL_NAME,
 )
-from codex.logger.logger import get_logger
+from codex.serializers.fields.base import CodexChoiceField
 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):
+class BookmarkFilterField(CodexChoiceField):
     """Bookmark Choice Field."""
 
-    def __init__(self, *args, **kwargs):
-        """Use bookmark filter choices."""
-        super().__init__(
-            *args, choices=tuple(BROWSER_BOOKMARK_FILTER_CHOICES.keys()), **kwargs
-        )
+    class_choices = tuple(BROWSER_BOOKMARK_FILTER_CHOICES.keys())
 
 
 class PyCountryField(SanitizedCharField, ABC):
     """Serialize to a long pycountry name."""
 
-    LOOKUP_MODULE = pycountry.countries
+    DB: Database = pycountry.countries
     _ALPHA_2_LEN = 2
 
+    @override
     def to_representation(self, value):
         """Lookup the name with pycountry, just copy the value on fail."""
         if not value:
@@ -55,13 +39,13 @@ class PyCountryField(SanitizedCharField, ABC):
         try:
             # fix for https://github.com/flyingcircusio/pycountry/issues/41
             lookup_obj = (
-                self.LOOKUP_MODULE.get(alpha_2=value)
+                self.DB.get(alpha_2=value)
                 if len(value) == self._ALPHA_2_LEN
-                else self.LOOKUP_MODULE.lookup(value)
+                else self.DB.lookup(value)
             )
             # If lookup fails, return the key as the name
         except Exception:
-            LOG.warning(f"Could not serialize name with pycountry {value}")
+            logger.warning(f"Could not serialize name with pycountry {value}")
             return value
         else:
             return lookup_obj.name if lookup_obj else value
@@ -70,16 +54,16 @@ class PyCountryField(SanitizedCharField, ABC):
 class CountryField(PyCountryField):
     """Serializer to long country name."""
 
-    LOOKUP_MODULE = pycountry.countries
+    DB: Database = pycountry.countries
 
 
 class LanguageField(PyCountryField):
     """Serializer to long language name."""
 
-    LOOKUP_MODULE = pycountry.languages
+    DB: Database = pycountry.languages
 
 
 class BreadcrumbsField(ListField):
-    """And Array of Routes."""
+    """An Array of Routes."""
 
     child = RouteSerializer()

codex/serializers/fields/group.py

@@ -1,13 +1,16 @@
-"""Browser Group Field."""
+"""Browse Group Field."""
 
-from rest_framework.fields import ChoiceField
+from codex.choices.browser import BROWSER_ROUTE_CHOICES, BROWSER_TOP_GROUP_CHOICES
+from codex.serializers.fields.base import CodexChoiceField
 
-from codex.choices.browser import BROWSER_GROUP_CHOICES
 
+class BrowseGroupField(CodexChoiceField):
+    """Valid Top Groups Only."""
 
-class BrowseGroupField(ChoiceField):
-    """BrowseGroup Field."""
+    class_choices = tuple(BROWSER_TOP_GROUP_CHOICES.keys())
 
-    def __init__(self, *args, **kwargs):
-        """Add choices."""
-        super().__init__(*args, choices=tuple(BROWSER_GROUP_CHOICES.keys()), **kwargs)
+
+class BrowserRouteGroupField(CodexChoiceField):
+    """Valid Top Groups Only."""
+
+    class_choices = tuple(BROWSER_ROUTE_CHOICES.keys())

codex/serializers/fields/reader.py

@@ -1,22 +1,26 @@
 """Reader Fields."""
 
-from rest_framework.serializers import ChoiceField
-
 from codex.models import Bookmark
 from codex.models.comic import ReadingDirection
+from codex.serializers.fields.base import CodexChoiceField
+from codex.views.const import FOLDER_GROUP, STORY_ARC_GROUP
+
+VALID_ARC_GROUPS = ("s", "v", FOLDER_GROUP, STORY_ARC_GROUP)
 
 
-class FitToField(ChoiceField):
+class FitToField(CodexChoiceField):
     """Bookmark FitTo Fieild."""
 
-    def __init__(self, *args, **kwargs):
-        """Add Choices."""
-        super().__init__(*args, choices=Bookmark.FitTo.values, **kwargs)
+    class_choices = Bookmark.FitTo.values
 
 
-class ReadingDirectionField(ChoiceField):
+class ReadingDirectionField(CodexChoiceField):
     """Reading Direction Field."""
 
-    def __init__(self, *args, **kwargs):
-        """Add Choices."""
-        super().__init__(*args, choices=ReadingDirection.values, **kwargs)
+    class_choices = ReadingDirection.values
+
+
+class ArcGroupField(CodexChoiceField):
+    """Arc Group Field."""
+
+    class_choices = VALID_ARC_GROUPS

codex/serializers/fields/sanitized.py

@@ -2,11 +2,13 @@
 
 from nh3 import clean
 from rest_framework.fields import CharField
+from typing_extensions import override
 
 
 class SanitizedCharField(CharField):
     """Sanitize CharField using NH3."""
 
+    @override
     def to_internal_value(self, data):
         """Sanitize CharField using NH3."""
         sanitized_data = clean(data)

codex/serializers/fields/session.py

@@ -1,16 +1,11 @@
 """Session Custom Fields."""
 
-from rest_framework.fields import ChoiceField
-
 from codex.choices.browser import BROWSER_DEFAULTS
 from codex.choices.reader import READER_DEFAULTS
-
-_SESSION_KEYS = (*READER_DEFAULTS.keys(), *BROWSER_DEFAULTS.keys(), "filters")
+from codex.serializers.fields.base import CodexChoiceField
 
 
-class SessionKeyField(ChoiceField):
+class SessionKeyField(CodexChoiceField):
     """Session Key Field."""
 
-    def __init__(self, *args, **kwargs):
-        """Add choices."""
-        super().__init__(*args, choices=_SESSION_KEYS, **kwargs)
+    class_choices = (*READER_DEFAULTS.keys(), *BROWSER_DEFAULTS.keys(), "filters")

codex/serializers/fields/stats.py

@@ -2,20 +2,18 @@
 
 from rest_framework.fields import DictField, IntegerField
 from rest_framework.serializers import MultipleChoiceField
-
-from codex.logger.logger import get_logger
-
-LOG = get_logger(__name__)
+from typing_extensions import override
 
 
 class StringListMultipleChoiceField(MultipleChoiceField):
     """A Multiple Choice Field expressed as as a comma delimited string."""
 
+    @override
     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]
+        return super().to_internal_value(data)  # pyright: ignore[reportArgumentType]
 
 
 class SerializerChoicesField(StringListMultipleChoiceField):

codex/serializers/fields/vuetify.py

@@ -5,41 +5,52 @@ from rest_framework.exceptions import ValidationError
 from rest_framework.serializers import (
     BooleanField,
     CharField,
-    FloatField,
+    DecimalField,
     IntegerField,
 )
 
 from codex.choices.browser import VUETIFY_NULL_CODE
-from codex.logger.logger import get_logger
-
-LOG = get_logger(__name__)
+from codex.models.comic import FileType, ReadingDirection
+from codex.serializers.fields.base import CodexChoiceField
 
 
 class VuetifyNullCodeFieldMixin:
     """Convert Vuetify null codes to None."""
 
-    NULL_CODE = VUETIFY_NULL_CODE
+    NULL_CODE: int = 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]
+class VuetifyFileTypeChoiceField(VuetifyNullCodeFieldMixin, CodexChoiceField):  # pyright: ignore[reportIncompatibleMethodOverride]
+    """File Type Choice Field."""
+
+    class_choices = FileType.values
+
+
+class VuetifyReadingDirectionChoiceField(VuetifyNullCodeFieldMixin, CodexChoiceField):  # pyright: ignore[reportIncompatibleMethodOverride]
+    """Reading Direction Choice Field."""
+
+    class_choices = ReadingDirection.values
+
+
+class VuetifyDecimalField(VuetifyNullCodeFieldMixin, DecimalField):  # pyright: ignore[reportIncompatibleMethodOverride]
     """Float Field with null code conversion."""
 
 
-class VuetifyIntegerField(VuetifyNullCodeFieldMixin, IntegerField):  # type: ignore[reportIncompatibleMethodOverride]
+class VuetifyIntegerField(VuetifyNullCodeFieldMixin, IntegerField):  # pyright: ignore[reportIncompatibleMethodOverride]
     """Integer Field with null code conversion."""
 
 
-class VuetifyCharField(VuetifyNullCodeFieldMixin, CharField):  # type: ignore[reportIncompatibleMethodOverride]
+class VuetifyCharField(VuetifyNullCodeFieldMixin, CharField):  # pyright: ignore[reportIncompatibleMethodOverride]
     """Char Field with null code conversion."""
 
-    NULL_CODE = str(VUETIFY_NULL_CODE)
+    NULL_CODE: str = str(VUETIFY_NULL_CODE)  # pyright: ignore[reportIncompatibleVariableOverride]
 
 
-class VuetifyBooleanField(VuetifyNullCodeFieldMixin, BooleanField):  # type: ignore[reportIncompatibleMethodOverride]
+class VuetifyBooleanField(VuetifyNullCodeFieldMixin, BooleanField):  # pyright: ignore[reportIncompatibleMethodOverride]
     """Boolean Field with null code conversion."""
 
 

codex/serializers/mixins.py

@@ -1,12 +1,54 @@
 """Serializer mixins."""
 
+import json
+from contextlib import suppress
+from json.decoder import JSONDecodeError
+from typing import Any
+from urllib.parse import unquote_plus
+
+from djangorestframework_camel_case.settings import api_settings
+from djangorestframework_camel_case.util import underscoreize
+from loguru import logger
 from rest_framework.serializers import (
     BooleanField,
     Serializer,
 )
+from typing_extensions import override
 
 
 class OKSerializer(Serializer):
     """Default serializer for views without much response."""
 
     ok = BooleanField(default=True)
+
+
+class JSONFieldSerializer(Serializer):
+    """Reparse JSON encoded query_params."""
+
+    JSON_FIELDS: frozenset[str] = frozenset()
+
+    @staticmethod
+    def _parse_json_field(key, value):
+        try:
+            parsed_value = unquote_plus(value)
+            with suppress(JSONDecodeError):
+                parsed_value = json.loads(parsed_value)
+        except Exception:
+            reason = f"parsing as json: {key}:{value}"
+            logger.exception(reason)
+            parsed_value = None
+        return parsed_value
+
+    @override
+    def to_internal_value(self, data):
+        """Reparse JSON encoded query_params."""
+        # It is an unbelievable amount of trouble to try to parse axios native bracket
+        # encoded complex objects in python
+        parsed_dict: dict[str, Any] = {
+            key: self._parse_json_field(key, value)
+            if key in self.JSON_FIELDS
+            else value
+            for key, value in data.items()
+        }
+        data = dict(underscoreize(parsed_dict, **api_settings.JSON_UNDERSCOREIZE))  # pyright: ignore[reportArgumentType,reportCallIssue]
+        return super().to_internal_value(data)

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[reportIncompatibleVariableOverride]
+    class Meta(SerializerMetaclass):  # pyright: ignore[reportIncompatibleVariableOverride]
         """Use explicit metaclass instead of python 3 method."""
 
         abstract = True

codex/serializers/models/comic.py

@@ -15,7 +15,7 @@ from codex.serializers.models.groups import (
 from codex.serializers.models.named import (
     AgeRatingSerializer,
     CharacterSerializer,
-    ContributorSerializer,
+    CreditSerializer,
     GenreSerializer,
     IdentifierSeralizer,
     LocationSerializer,
@@ -27,6 +27,7 @@ from codex.serializers.models.named import (
     TaggerSerializer,
     TagSerializer,
     TeamSerializer,
+    UniverseSerializer,
 )
 from codex.serializers.models.pycountry import CountrySerializer, LanguageSerializer
 
@@ -56,9 +57,12 @@ class ComicSerializer(BaseModelSerializer):
     original_format = OriginalFormatSerializer(allow_null=True)
     scan_info = ScanInfoSerializer(allow_null=True)
     tagger = TaggerSerializer(allow_null=True)
+    main_character = CharacterSerializer(allow_null=True)
+    main_team = TeamSerializer(allow_null=True)
 
     # ManyToMany
     characters = CharacterSerializer(many=True, allow_null=True)
+    credits = CreditSerializer(many=True, allow_null=True)
     genres = GenreSerializer(many=True, allow_null=True)
     identifiers = IdentifierSeralizer(many=True, allow_null=True)
     locations = LocationSerializer(many=True, allow_null=True)
@@ -70,7 +74,7 @@ class ComicSerializer(BaseModelSerializer):
     )
     tags = TagSerializer(many=True, allow_null=True)
     teams = TeamSerializer(many=True, allow_null=True)
-    contributors = ContributorSerializer(many=True, allow_null=True)
+    universes = UniverseSerializer(many=True, allow_null=True)
 
     class Meta(BaseModelSerializer.Meta):
         """Configure the model."""