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

codex/models/query.py

@@ -6,6 +6,7 @@ from django.db.models import Manager
 from django.db.models.query import QuerySet
 from django.db.models.sql.compiler import SQLCompiler
 from django.db.models.sql.query import Query
+from typing_extensions import override
 
 
 class GroupBySQLCompiler(SQLCompiler):
@@ -22,6 +23,7 @@ class GroupBySQLCompiler(SQLCompiler):
         self.force_group_by_table = table
         self.force_group_by_fields = fields
 
+    @override
     def get_group_by(self, *args, **kwargs):
         """If force group_by set, force it."""
         if self.force_group_by_table and self.force_group_by_fields:
@@ -45,7 +47,8 @@ class GroupByQuery(Query):
         self.force_group_by_table = ""
         self.force_group_by_fields = ()
 
-    def get_compiler(self, using=None, connection=None, elide_empty=True):  # noqa: FBT002
+    @override
+    def get_compiler(self, using=None, connection=None, elide_empty=True):
         """Use the custom compiler instead of SQLCompiler."""
         if self.compiler == "SQLCompiler":
             if using is None and connection is None:
@@ -58,11 +61,10 @@ class GroupByQuery(Query):
                 self.force_group_by_table, self.force_group_by_fields
             )
         else:
-            # Normal super() operation.
             compiler = super().get_compiler(
                 using=using,
                 connection=connection,
-                elide_empty=elide_empty,  # type: ignore[reportCallIssue]
+                elide_empty=elide_empty,  # pyright: ignore[reportCallIssue]
             )
 
         return compiler
@@ -86,13 +88,13 @@ class GroupByQuerySet(QuerySet):
 
     def group_by(self, *fields, model=None):
         """Force group_by operator."""
-        obj = self._chain()  # type: ignore[reportAttributeAccessIssue]
+        obj = self._chain()  # pyright: ignore[reportAttributeAccessIssue]
         obj.query.set_force_group_by(fields, model=model)
         return obj
 
     def demote_joins(self, tables):
         """Force INNER JOINS."""
-        obj = self._chain()  # type: ignore[reportAttributeAccessIssue]
+        obj = self._chain()  # pyright: ignore[reportAttributeAccessIssue]
         obj.query.demote_joins(tables)
         return obj
 

codex/run.py

@@ -2,30 +2,26 @@
 """The main runnable for codex. Sets up codex and runs hypercorn."""
 
 import asyncio
-import logging
 from os import execv
 
 from django.db import connection
 from hypercorn.asyncio import serve
+from loguru import logger
 
 from codex.asgi import application
 from codex.librarian.librariand import LibrarianDaemon
 from codex.librarian.mp_queue import LIBRARIAN_QUEUE
-from codex.logger.logger import get_logger
-from codex.logger.loggerd import CodexLogQueueListener
-from codex.logger.mp_queue import LOG_QUEUE
-from codex.settings.settings import HYPERCORN_CONFIG
+from codex.settings import HYPERCORN_CONFIG
 from codex.signals.os_signals import RESTART_EVENT, SHUTDOWN_EVENT
 from codex.startup import codex_init
+from codex.startup.logger_init import init_logging
 from codex.version import VERSION
 from codex.websockets.aio_queue import BROADCAST_QUEUE
 
-LOG = get_logger(__name__)
-
 
 def codex_startup():
     """Start up codex."""
-    LOG.info(f"Starting Codex v{VERSION}")
+    logger.info(f"Starting Codex v{VERSION}")
     return codex_init()
 
 
@@ -33,7 +29,7 @@ def _database_checkpoint():
     """Write wal to disk and truncate it."""
     with connection.cursor() as cursor:
         cursor.execute("PRAGMA wal_checkpoint(TRUNCATE);")
-    LOG.debug("checkpointed and truncated database wal")
+    logger.debug("checkpointed and truncated database wal")
 
 
 def restart():
@@ -44,20 +40,19 @@ def restart():
     execv(__file__, argv)  # noqa: S606
 
 
-def codex_shutdown(loggerd):
+def codex_shutdown():
     """Shutdown for codex."""
     _database_checkpoint()
-    LOG.info("Goodbye.")
-    logging.shutdown()
-    loggerd.stop()
+    logger.success("Goodbye.")
+    logger.complete()
     if RESTART_EVENT.is_set():
         restart()
 
 
 def run():
     """Run Codex."""
-    LOG.info(f"Running Codex v{VERSION}")
-    librarian = LibrarianDaemon(LIBRARIAN_QUEUE, LOG_QUEUE, BROADCAST_QUEUE)
+    logger.success(f"Running Codex v{VERSION}")
+    librarian = LibrarianDaemon(logger, LIBRARIAN_QUEUE, BROADCAST_QUEUE)
     librarian.start()
     asyncio.run(
         serve(
@@ -71,11 +66,10 @@ def run():
 
 def main():
     """Set up and run Codex."""
-    loggerd = CodexLogQueueListener(LOG_QUEUE)
-    loggerd.start()
+    init_logging()
     if codex_startup():
         run()
-    codex_shutdown(loggerd)
+    codex_shutdown()
 
 
 if __name__ == "__main__":

codex/serializers/admin/groups.py

@@ -4,6 +4,7 @@ from django.contrib.auth.models import Group
 from rest_framework.serializers import (
     BooleanField,
 )
+from typing_extensions import override
 
 from codex.models.admin import GroupAuth
 from codex.serializers.models.base import BaseModelSerializer
@@ -21,6 +22,7 @@ class GroupSerializer(BaseModelSerializer):
         fields = ("pk", "name", "library_set", "user_set", "exclude")
         read_only_fields = ("pk",)
 
+    @override
     def update(self, instance, validated_data):
         """Update with nested GroupAuth."""
         exclude = validated_data.pop("groupauth", {}).get("exclude")
@@ -30,6 +32,7 @@ class GroupSerializer(BaseModelSerializer):
             groupauth.save()
         return super().update(instance, validated_data)
 
+    @override
     def create(self, validated_data):
         """Create with nested GroupAuth."""
         exclude = validated_data.pop("groupauth", {}).get("exclude", False)

codex/serializers/admin/libraries.py

@@ -5,6 +5,7 @@ from pathlib import Path
 from rest_framework.serializers import (
     BooleanField,
     CharField,
+    IntegerField,
     ListField,
     Serializer,
     ValidationError,
@@ -17,6 +18,9 @@ from codex.serializers.models.base import BaseModelSerializer
 class LibrarySerializer(BaseModelSerializer):
     """Library Serializer."""
 
+    comic_count = IntegerField(read_only=True)
+    failed_count = IntegerField(read_only=True)
+
     class Meta(BaseModelSerializer.Meta):
         """Specify Model."""
 
@@ -30,8 +34,16 @@ class LibrarySerializer(BaseModelSerializer):
             "poll_every",
             "groups",
             "covers_only",
+            "comic_count",
+            "failed_count",
+        )
+        read_only_fields = (
+            "last_poll",
+            "pk",
+            "covers_only",
+            "comic_count",
+            "failed_count",
         )
-        read_only_fields = ("last_poll", "pk", "covers_only")
 
     def validate_path(self, path):
         """Validate new library paths."""

codex/serializers/admin/stats.py

@@ -73,13 +73,13 @@ class StatsComicMetadataSerializer(Serializer):
 
     age_rating_count = IntegerField(required=False, read_only=True)
     character_count = IntegerField(required=False, read_only=True)
-    contributor_count = IntegerField(required=False, read_only=True)
-    contributor_person_count = IntegerField(required=False, read_only=True)
-    contributor_role_count = IntegerField(required=False, read_only=True)
+    credit_count = IntegerField(required=False, read_only=True)
+    credit_person_count = IntegerField(required=False, read_only=True)
+    credit_role_count = IntegerField(required=False, read_only=True)
     country_count = IntegerField(required=False, read_only=True)
     genre_count = IntegerField(required=False, read_only=True)
     identifier_count = IntegerField(required=False, read_only=True)
-    identifier_type_count = IntegerField(required=False, read_only=True)
+    identifier_source_count = IntegerField(required=False, read_only=True)
     language_count = IntegerField(required=False, read_only=True)
     location_count = IntegerField(required=False, read_only=True)
     original_format_count = IntegerField(required=False, read_only=True)
@@ -90,6 +90,7 @@ class StatsComicMetadataSerializer(Serializer):
     tag_count = IntegerField(required=False, read_only=True)
     tagger_count = IntegerField(required=False, read_only=True)
     team_count = IntegerField(required=False, read_only=True)
+    universe_count = IntegerField(required=False, read_only=True)
 
 
 class StatsSerializer(Serializer):

codex/serializers/admin/tasks.py

@@ -10,11 +10,9 @@ from codex.choices.admin import ADMIN_TASK_GROUPS
 
 _ADMIN_TASK_CHOICES = tuple(
     sorted(
-        [
-            item["value"]
-            for group in ADMIN_TASK_GROUPS["tasks"]
-            for item in group["tasks"]
-        ]
+        item["value"]  # pyright: ignore[reportArgumentType], #ty: ignore[call-non-callable]
+        for group in ADMIN_TASK_GROUPS["tasks"]
+        for item in group["tasks"]
     )
 )
 

codex/serializers/admin/users.py

@@ -5,20 +5,26 @@ from rest_framework.serializers import (
     CharField,
     DateTimeField,
     Serializer,
+    SerializerMetaclass,
 )
 
 from codex.serializers.models.base import BaseModelSerializer
 
 
-class UserChangePasswordSerializer(Serializer):
-    """Special User Change Password Serializer."""
+class PasswordSerializerMixin(metaclass=SerializerMetaclass):
+    """Password Serializer Mixin."""
 
     password = CharField(write_only=True)
 
 
-class UserSerializer(BaseModelSerializer, UserChangePasswordSerializer):
+class UserChangePasswordSerializer(Serializer, PasswordSerializerMixin):
+    """Special User Change Password Serializer."""
+
+
+class UserSerializer(BaseModelSerializer, PasswordSerializerMixin):
     """User Serializer."""
 
+    password = CharField(write_only=True)
     last_active = DateTimeField(
         read_only=True, source="useractive.updated_at", allow_null=True
     )

codex/serializers/auth.py

@@ -4,10 +4,12 @@ from django.contrib.auth.models import User
 from rest_framework.fields import BooleanField, CharField
 from rest_framework.serializers import (
     Serializer,
+    SerializerMetaclass,
     SerializerMethodField,
 )
 
-from codex.models import AdminFlag
+from codex.choices.admin import AdminFlagChoices
+from codex.models.admin import AdminFlag
 from codex.serializers.fields.auth import TimezoneField
 from codex.serializers.fields.sanitized import SanitizedCharField
 from codex.serializers.models.base import BaseModelSerializer
@@ -17,8 +19,8 @@ class UserSerializer(BaseModelSerializer):
     """Serialize User model for UI."""
 
     _ADMIN_FLAG_KEYS = (
-        AdminFlag.FlagChoices.NON_USERS.value,
-        AdminFlag.FlagChoices.REGISTRATION.value,
+        AdminFlagChoices.NON_USERS.value,
+        AdminFlagChoices.REGISTRATION.value,
     )
 
     admin_flags = SerializerMethodField()
@@ -48,13 +50,17 @@ class UserSerializer(BaseModelSerializer):
         read_only_fields = fields
 
 
-class TimezoneSerializer(Serializer):
+class TimezoneSerializerMixin(metaclass=SerializerMetaclass):
     """Serialize Timezone submission from front end."""
 
     timezone = TimezoneField(write_only=True)
 
 
-class UserCreateSerializer(BaseModelSerializer, TimezoneSerializer):
+class TimezoneSerializer(TimezoneSerializerMixin, Serializer):
+    """Serialize Timezone submission from front end."""
+
+
+class UserCreateSerializer(BaseModelSerializer, TimezoneSerializerMixin):
     """Serialize registration input for creating users."""
 
     class Meta(BaseModelSerializer.Meta):
@@ -78,6 +84,7 @@ class UserLoginSerializer(UserCreateSerializer):
 class AuthAdminFlagsSerializer(Serializer):
     """Admin flags related to auth."""
 
+    banner_text = CharField(read_only=True)
+    lazy_import_metadata = BooleanField(read_only=True)
     non_users = BooleanField(read_only=True)
     registration = BooleanField(read_only=True)
-    banner_text = CharField(read_only=True)

codex/serializers/browser/choices.py

@@ -14,10 +14,14 @@ from codex.serializers.fields import (
     VuetifyBooleanField,
     VuetifyCharField,
     VuetifyDecadeField,
-    VuetifyFloatField,
+    VuetifyDecimalField,
     VuetifyIntegerField,
 )
 from codex.serializers.fields.browser import BookmarkFilterField
+from codex.serializers.fields.vuetify import (
+    VuetifyFileTypeChoiceField,
+    VuetifyReadingDirectionChoiceField,
+)
 from codex.serializers.models.pycountry import CountrySerializer, LanguageSerializer
 
 
@@ -25,15 +29,14 @@ 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)
+    credits = 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)
+    identifier_source = BooleanField(read_only=True)
     monochrome = BooleanField(read_only=True)
     language = BooleanField(read_only=True)
     locations = BooleanField(read_only=True)
@@ -45,6 +48,7 @@ class BrowserFilterChoicesSerializer(Serializer):
     tagger = BooleanField(read_only=True)
     tags = BooleanField(read_only=True)
     teams = BooleanField(read_only=True)
+    universes = BooleanField(read_only=True)
     year = BooleanField(read_only=True)
 
 
@@ -55,20 +59,19 @@ class BrowserSettingsFilterSerializer(Serializer):
     # Dynamic filters
     age_rating = ListField(child=VuetifyCharField(), required=False, read_only=True)
     characters = ListField(child=VuetifyIntegerField(), required=False, read_only=True)
-    community_rating = ListField(
-        child=VuetifyFloatField(), required=False, read_only=True
-    )
     country = ListField(child=VuetifyIntegerField(), required=False, read_only=True)
-    contributors = ListField(
-        child=VuetifyIntegerField(), required=False, read_only=True
-    )
+    credits = ListField(child=VuetifyIntegerField(), required=False, read_only=True)
     critical_rating = ListField(
-        child=VuetifyFloatField(), required=False, read_only=True
+        child=VuetifyDecimalField(max_digits=5, decimal_places=2),
+        required=False,
+        read_only=True,
     )
     decade = ListField(child=VuetifyDecadeField(), required=False, read_only=True)
-    file_type = ListField(child=VuetifyCharField(), required=False, read_only=True)
+    file_type = ListField(
+        child=VuetifyFileTypeChoiceField(), required=False, read_only=True
+    )
     genres = ListField(child=VuetifyIntegerField(), required=False, read_only=True)
-    identifier_type = ListField(
+    identifier_source = ListField(
         child=VuetifyCharField(), required=False, read_only=True
     )
     language = ListField(child=VuetifyIntegerField(), required=False, read_only=True)
@@ -78,7 +81,7 @@ class BrowserSettingsFilterSerializer(Serializer):
         child=VuetifyCharField(), required=False, read_only=True
     )
     reading_direction = ListField(
-        child=VuetifyCharField(), required=False, read_only=True
+        child=VuetifyReadingDirectionChoiceField(), required=False, read_only=True
     )
     series_groups = ListField(
         child=VuetifyIntegerField(), required=False, read_only=True
@@ -88,6 +91,7 @@ class BrowserSettingsFilterSerializer(Serializer):
     tagger = ListField(child=VuetifyCharField(), required=False, read_only=True)
     tags = ListField(child=VuetifyIntegerField(), required=False, read_only=True)
     teams = ListField(child=VuetifyIntegerField(), required=False, read_only=True)
+    universes = ListField(child=VuetifyIntegerField(), required=False, read_only=True)
     year = ListField(child=VuetifyIntegerField(), required=False, read_only=True)
 
 
@@ -98,17 +102,32 @@ class BrowserChoicesIntegerPkSerializer(Serializer):
     name = CharField(read_only=True)
 
 
+class BrowserChoicesUniversePkSerializer(Serializer):
+    """Universes Only."""
+
+    designation = CharField(read_only=True)
+
+
 class BrowserChoicesCharPkSerializer(BrowserChoicesIntegerPkSerializer):
     """Named Model Serailizer with pk = char hack for languages & countries."""
 
     pk = VuetifyCharField(read_only=True)
 
 
+class BrowserChoicesDecimalPkSerializer(BrowserChoicesIntegerPkSerializer):
+    """Named Model Serailizer with pk = char hack for languages & countries."""
+
+    pk = VuetifyDecimalField(max_digits=5, decimal_places=2, read_only=True)
+
+
 _CHOICES_NAME_SERIALIZER_MAP = MappingProxyType(
     {
         "bookmark": BrowserChoicesCharPkSerializer,
         "country": CountrySerializer,
+        "critical_rating": BrowserChoicesDecimalPkSerializer,
+        "file_type": BrowserChoicesCharPkSerializer,
         "language": LanguageSerializer,
+        "universe": BrowserChoicesUniversePkSerializer,
     }
 )
 _LIST_FIELDS = frozenset({"decade", "monochrome", "reading_direction", "year"})
@@ -128,10 +147,8 @@ class BrowserChoicesFilterSerializer(Serializer):
         if serializer_class:
             value = serializer_class(choices, many=True).data
         elif not serializer_class and field_name in _LIST_FIELDS:
-            field: ListField = (  # type: ignore[reportAssignmentType]
-                BrowserSettingsFilterSerializer().get_fields().get(field_name)
-            )
-            value = field.to_representation(choices)
+            field = BrowserSettingsFilterSerializer().get_fields().get(field_name)
+            value = field.to_representation(choices)  #  pyright: ignore[reportOptionalMemberAccess], #ty: ignore[possibly-unbound-attribute]
         else:
             value = BrowserChoicesIntegerPkSerializer(choices, many=True).data
         return value

codex/serializers/browser/filters.py

@@ -5,7 +5,7 @@ from rest_framework.serializers import ListField, Serializer
 from codex.serializers.fields import (
     VuetifyBooleanField,
     VuetifyDecadeField,
-    VuetifyFloatField,
+    VuetifyDecimalField,
     VuetifyIntegerField,
 )
 from codex.serializers.fields.browser import BookmarkFilterField
@@ -18,14 +18,15 @@ class BrowserSettingsFilterInputSerializer(Serializer):
     # Dynamic filters
     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)
+    credits = ListField(child=VuetifyIntegerField(), required=False)
+    critical_rating = ListField(
+        child=VuetifyDecimalField(max_digits=5, decimal_places=2), required=False
+    )
     decade = ListField(child=VuetifyDecadeField(), required=False)
     file_type = ListField(child=VuetifyIntegerField(), required=False)
     genres = ListField(child=VuetifyIntegerField(), required=False)
-    identifier_type = ListField(child=VuetifyIntegerField(), required=False)
+    identifier_source = ListField(child=VuetifyIntegerField(), required=False)
     language = ListField(child=VuetifyIntegerField(), required=False)
     locations = ListField(child=VuetifyIntegerField(), required=False)
     monochrome = ListField(child=VuetifyBooleanField(), required=False)
@@ -37,4 +38,5 @@ class BrowserSettingsFilterInputSerializer(Serializer):
     tagger = ListField(child=VuetifyIntegerField(), required=False)
     tags = ListField(child=VuetifyIntegerField(), required=False)
     teams = ListField(child=VuetifyIntegerField(), required=False)
+    universes = ListField(child=VuetifyIntegerField(), required=False)
     year = ListField(child=VuetifyIntegerField(), required=False)

codex/serializers/browser/metadata.py

@@ -1,12 +1,12 @@
 """Codex Serializers for the metadata box."""
 
 from rest_framework.fields import CharField
-from rest_framework.serializers import IntegerField, ListField, Serializer
+from rest_framework.serializers import IntegerField, ListField, Serializer, URLField
 
 from codex.serializers.browser.mixins import BrowserAggregateSerializerMixin
 from codex.serializers.models.comic import ComicSerializer
 from codex.serializers.models.named import (
-    ContributorSerializer,
+    CreditSerializer,
     IdentifierSeralizer,
     StoryArcNumberSerializer,
 )
@@ -19,6 +19,8 @@ class GroupSerializer(Serializer):
 
     ids = ListField(child=IntegerField(), read_only=True)
     name = CharField(read_only=True)
+    number_to = CharField(read_only=True)
+    url = URLField(read_only=True)
 
 
 class MetadataSerializer(BrowserAggregateSerializerMixin, ComicSerializer):
@@ -35,17 +37,17 @@ class MetadataSerializer(BrowserAggregateSerializerMixin, ComicSerializer):
     volume_list = GroupSerializer(many=True, required=False)
     folder_list = GroupSerializer(many=True, required=False)
     story_arc_list = GroupSerializer(many=True, required=False)
-    publisher = None
-    imprint = None
-    series = None
-    volume = None
+    publisher = None  # pyright: ignore[reportIncompatibleUnannotatedOverride]
+    imprint = None  # pyright: ignore[reportIncompatibleUnannotatedOverride]
+    series = None  # pyright: ignore[reportIncompatibleUnannotatedOverride]
+    volume = None  # pyright: ignore[reportIncompatibleUnannotatedOverride]
 
+    credits = CreditSerializer(
+        source=f"{PREFETCH_PREFIX}credits", many=True, allow_null=True
+    )
     identifiers = IdentifierSeralizer(
         source=f"{PREFETCH_PREFIX}identifiers", many=True, allow_null=True
     )
-    contributors = ContributorSerializer(
-        source=f"{PREFETCH_PREFIX}contributors", many=True, allow_null=True
-    )
     story_arc_numbers = StoryArcNumberSerializer(
         source=f"{PREFETCH_PREFIX}story_arc_numbers", many=True, allow_null=True
     )
@@ -53,7 +55,7 @@ class MetadataSerializer(BrowserAggregateSerializerMixin, ComicSerializer):
     class Meta(ComicSerializer.Meta):
         """Configure the model."""
 
-        exclude = (
+        exclude = (  # pyright: ignore[reportIncompatibleUnannotatedOverride]
             *ComicSerializer.Meta.exclude,
             "publisher",
             "imprint",

codex/serializers/browser/mixins.py

@@ -3,27 +3,25 @@
 from datetime import datetime, timezone
 from itertools import chain
 
+from loguru import logger
 from rest_framework.serializers import (
     BooleanField,
     DecimalField,
     IntegerField,
     ListField,
-    Serializer,
+    SerializerMetaclass,
     SerializerMethodField,
 )
 
-from codex.logger.logger import get_logger
-from codex.serializers.fields.browser import TopGroupField
+from codex.serializers.fields.group import BrowseGroupField
 from codex.util import max_none
 from codex.views.const import EPOCH_START
 
-LOG = get_logger(__name__)
 
-
-class BrowserAggregateSerializerMixin(Serializer):
+class BrowserAggregateSerializerMixin(metaclass=SerializerMetaclass):
     """Mixin for browser, opds & metadata serializers."""
 
-    group = TopGroupField(read_only=True)
+    group = BrowseGroupField(read_only=True)
     ids = ListField(child=IntegerField(), read_only=True)
 
     # Aggregate Annotations
@@ -48,7 +46,7 @@ class BrowserAggregateSerializerMixin(Serializer):
                     tzinfo=timezone.utc
                 )
             except ValueError:
-                LOG.warning(
+                logger.warning(
                     f"computing group mtime: {dt_str} is not a valid datetime string."
                 )
                 continue

codex/serializers/browser/mtime.py

@@ -2,14 +2,18 @@
 
 from rest_framework.serializers import Serializer
 
-from codex.serializers.browser.settings import BrowserFilterChoicesInputSerilalizer
+from codex.serializers.browser.settings import BrowserFilterChoicesInputSerializer
 from codex.serializers.fields import TimestampField
 from codex.serializers.route import SimpleRouteSerializer
 
 
-class GroupsMtimeSerializer(BrowserFilterChoicesInputSerilalizer):
+class GroupsMtimeSerializer(BrowserFilterChoicesInputSerializer):
     """Groups Mtimes."""
 
+    JSON_FIELDS = frozenset(
+        BrowserFilterChoicesInputSerializer.JSON_FIELDS | {"groups"}
+    )
+
     groups = SimpleRouteSerializer(many=True, required=True)
 
 

codex/serializers/browser/page.py

@@ -12,18 +12,21 @@ from codex.serializers.browser.mixins import (
     BrowserAggregateSerializerMixin,
 )
 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
 
 
-class BrowserCardSerializer(BrowserAggregateSerializerMixin):
+class BrowserCardSerializer(BrowserAggregateSerializerMixin, Serializer):
     """Browse card displayed in the browser."""
 
     pk = IntegerField(read_only=True)
     publisher_name = CharField(read_only=True)
     series_name = CharField(read_only=True)
     volume_name = CharField(read_only=True)
+    volume_number_to = CharField(read_only=True)
     file_name = CharField(read_only=True)
     name = CharField(read_only=True)
+    number_to = CharField(read_only=True)
     issue_number = DecimalField(
         max_digits=16,
         decimal_places=3,
@@ -34,6 +37,7 @@ class BrowserCardSerializer(BrowserAggregateSerializerMixin):
     order_value = CharField(read_only=True)
     page_count = IntegerField(read_only=True)
     reading_direction = CharField(read_only=True)
+    has_metadata = BooleanField(read_only=True)
 
 
 class BrowserAdminFlagsSerializer(Serializer):
@@ -47,6 +51,7 @@ class BrowserTitleSerializer(Serializer):
     """Elements for constructing the browse title."""
 
     group_name = CharField(read_only=True)
+    group_number_to = CharField(read_only=True)
     group_count = IntegerField(read_only=True, allow_null=True)
 
 
@@ -58,7 +63,7 @@ class BrowserPageSerializer(Serializer):
     title = BrowserTitleSerializer(read_only=True)
     zero_pad = IntegerField(read_only=True)
     libraries_exist = BooleanField(read_only=True)
-    model_group = TopGroupField(read_only=True)
+    model_group = BrowseGroupField(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)