codex 1.7.2__py3-none-any.whl → 1.7.3a0__py3-none-any.whl

codex/choices.py

@@ -12,17 +12,18 @@ BROWSER_BOOKMARK_FILTER_CHOICES = MappingProxyType(
 )
 BROWSER_ORDER_BY_CHOICES = MappingProxyType(
     {
+        "created_at": "Added Time",
         "age_rating": "Age Rating",
-        "bookmark_updated_at": "Last Read",
+        "child_count": "Child Count",
         "community_rating": "Community Rating",
-        "created_at": "Added Time",
         "critical_rating": "Critical Rating",
-        "date": "Publish Date",
         "filename": "Filename",
-        "page_count": "Page Count",
-        "search_score": "Search Score",
         "size": "File Size",
+        "bookmark_updated_at": "Last Read",
         "sort_name": "Name",
+        "page_count": "Page Count",
+        "date": "Publish Date",
+        "search_score": "Search Score",
         "story_arc_number": "Story Arc Number",
         "updated_at": "Updated Time",
     }
@@ -116,6 +117,7 @@ ADMIN_FLAG_CHOICES = MappingProxyType(
         "NU": "Non Users",
         "RG": "Registration",
         "ST": "Send Stats",
+        "BT": "Banner Text",
     }
 )
 
@@ -159,6 +161,7 @@ ADMIN_STATUS_TITLES = MappingProxyType(
         "JLV": "Check Codex Latest Version",
         "JSD": "Cleanup Expired Sessions",
         "JTD": "Cleanup Stale Tags",
+        "JCL": "Compress Logs",
         "SIC": "Search Index Create",
         "SID": "Search Index Remove Stale Records",
         "SIO": "Search Index Optimize",
@@ -374,6 +377,11 @@ ADMIN_TASK_GROUPS = MappingProxyType(
                         "title": "Clear Librarian Statuses",
                         "desc": "Mark all Librarian tasks finished.",
                     },
+                    {
+                        "value": "compress_logs",
+                        "title": "Compress Old Logs",
+                        "desc": "Compress old Codex logs. Runs nightly.",
+                    },
                     {
                         "value": "janitor_nightly",
                         "title": "Run Nightly Maintenance",

codex/librarian/bookmark/bookmarkd.py

@@ -14,7 +14,7 @@ class BookmarkThread(AggregateMessageQueuedThread, BookmarkUpdate):
     def aggregate_items(self, item):
         """Aggregate bookmark updates."""
         if isinstance(item, BookmarkUpdateTask):
-            key = (tuple(item.auth_filter.items()), tuple(item.comic_filter.items()))
+            key = (tuple(item.auth_filter.items()), item.comic_pks)
             if key not in self.cache:
                 self.cache[key] = {}
             self.cache[key].update(item.updates)
@@ -26,11 +26,10 @@ class BookmarkThread(AggregateMessageQueuedThread, BookmarkUpdate):
         cleanup = set()
         for filters, updates in self.cache.items():
             try:
-                auth_filter, comic_filter = filters
+                auth_filter, comic_pks = filters
                 auth_filter = dict(auth_filter)
-                comic_filter = dict(comic_filter)
-                self.update_bookmarks(auth_filter, comic_filter, updates, self.log)
-                self.log.debug(f"updated {auth_filter | comic_filter}")
+                self.update_bookmarks(auth_filter, comic_pks, updates, self.log)
+                self.log.debug(f"updated {auth_filter} pk__in={comic_pks}")
                 cleanup.add(filters)
             except Exception:
                 self.log.exception("Updating bookmarks")

codex/librarian/bookmark/tasks.py

@@ -15,5 +15,5 @@ class BookmarkUpdateTask(BookmarkTask):
     """Bookmark a page."""
 
     auth_filter: Mapping[str, int | str]
-    comic_filter: Mapping[str, Any]
+    comic_pks: tuple[int]
     updates: Mapping[str, Any]

codex/librarian/bookmark/update.py

@@ -10,9 +10,8 @@ from codex.librarian.notifier.tasks import NotifierTask
 from codex.models import Bookmark, Comic
 from codex.models.admin import UserActive
 from codex.views.auth import GroupACLMixin
-from codex.views.mixins import BookmarkSearchMixin
 
-VERTICAL_READING_DIRECTIONS = frozenset({"ttb", "btt"})
+_VERTICAL_READING_DIRECTIONS = frozenset({"ttb", "btt"})
 _BOOKMARK_UPDATE_FIELDS = frozenset(
     {
         "page",
@@ -22,10 +21,9 @@ _BOOKMARK_UPDATE_FIELDS = frozenset(
         "reading_direction",
     }
 )
-_COMIC_ONLY_FIELDS = ("pk", "page_count")
 
 
-class BookmarkUpdate(GroupACLMixin, BookmarkSearchMixin):
+class BookmarkUpdate(GroupACLMixin):
     """Update Bookmarks."""
 
     # Used by Bookmarkd and view.bookmark.
@@ -47,10 +45,8 @@ class BookmarkUpdate(GroupACLMixin, BookmarkSearchMixin):
     def _update_bookmarks_validate_two_pages(bm, updates):
         """Force vertical view to not use two pages."""
         rd = updates.get("reading_direction")
-        if (
-            bm.two_pages
-            and rd in VERTICAL_READING_DIRECTIONS
-            or bm.reading_direction in VERTICAL_READING_DIRECTIONS
+        if bm.two_pages and bool(
+            {rd, bm.reading_direction}.intersection(_VERTICAL_READING_DIRECTIONS)
         ):
             updates["two_pages"] = None
 
@@ -62,13 +58,13 @@ class BookmarkUpdate(GroupACLMixin, BookmarkSearchMixin):
         LIBRARIAN_QUEUE.put(task)
 
     @classmethod
-    def _update_bookmarks(cls, search_kwargs, updates, user) -> int:
+    def _update_bookmarks(cls, auth_filter, comic_pks, updates, user) -> int:
         """Update existing bookmarks."""
         count = 0
         if not updates:
             return count
         group_acl_filter = cls.get_group_acl_filter(Bookmark, user)
-        query_filter = group_acl_filter & Q(**search_kwargs)
+        query_filter = group_acl_filter & Q(**auth_filter) & Q(comic__in=comic_pks)
         existing_bookmarks = Bookmark.objects.filter(query_filter)
         if updates.get("page") is not None:
             existing_bookmarks = existing_bookmarks.annotate(
@@ -98,12 +94,12 @@ class BookmarkUpdate(GroupACLMixin, BookmarkSearchMixin):
         """Force vertical view to not use two pages."""
         if (
             updates.get("two_pages")
-            and updates.get("reading_direction") in VERTICAL_READING_DIRECTIONS
+            and updates.get("reading_direction") in _VERTICAL_READING_DIRECTIONS
         ):
             updates.pop("two_pages", None)
 
     @classmethod
-    def _create_bookmarks(cls, comic_filter, search_kwargs, updates, user) -> int:
+    def _create_bookmarks(cls, auth_filter, comic_pks, updates, user) -> int:
         """Create new bookmarks for comics that don't exist yet."""
         count = 0
         cls._create_bookmarks_validate_two_pages(updates)
@@ -112,20 +108,12 @@ class BookmarkUpdate(GroupACLMixin, BookmarkSearchMixin):
         create_bookmarks = []
         group_acl_filter = cls.get_group_acl_filter(Comic, user)
         exclude = {}
-        for key, value in search_kwargs.items():
+        for key, value in auth_filter.items():
             exclude["bookmark__" + key] = value
-        query_filter = group_acl_filter & Q(**comic_filter) & ~Q(**exclude)
-        create_bookmark_comics = Comic.objects.filter(query_filter).only(
-            *_COMIC_ONLY_FIELDS
-        )
+        query_filter = group_acl_filter & Q(pk__in=comic_pks) & ~Q(**exclude)
+        create_bookmark_comics = Comic.objects.filter(query_filter).only("pk")
         for comic in create_bookmark_comics:
-            defaults = {"comic": comic}
-            defaults.update(updates)
-            for key, value in search_kwargs.items():
-                if not key.startswith("comic"):
-                    defaults[key] = value
-
-            bm = Bookmark(**defaults)
+            bm = Bookmark(comic=comic, **auth_filter, **updates)
             create_bookmarks.append(bm)
         count = len(create_bookmarks)
         if count:
@@ -147,18 +135,16 @@ class BookmarkUpdate(GroupACLMixin, BookmarkSearchMixin):
             log.warning(reason)
 
     @classmethod
-    def update_bookmarks(cls, auth_filter, comic_filter, updates, log):
+    def update_bookmarks(cls, auth_filter, comic_pks, updates, log):
         """Update a user bookmark."""
-        search_kwargs = cls.get_bookmark_search_kwargs(auth_filter, comic_filter)
-
         user = None
         for key, value in auth_filter.items():
             if key == "user":
                 user = User.objects.get(pk=value)
             break
 
-        count = cls._update_bookmarks(search_kwargs, updates, user)
-        count += cls._create_bookmarks(comic_filter, search_kwargs, updates, user)
+        count = cls._update_bookmarks(auth_filter, comic_pks, updates, user)
+        count += cls._create_bookmarks(auth_filter, comic_pks, updates, user)
         if user:
             cls._update_user_active(user, log)
         if count:

codex/librarian/cron/crond.py

@@ -28,7 +28,7 @@ class CronThread(NamedThread):
         self._stop_event = Event()
         self._cond = Condition()
         self._task_times = ()
-        super().__init__(*args, name=self.__class__.__name__, daemon=True, **kwargs)
+        super().__init__(*args, daemon=True, **kwargs)
 
     def _create_task_times(self):
         task_times = {}

codex/librarian/importer/query_fks.py

@@ -96,7 +96,7 @@ class QueryForeignKeysImporter(QueryCustomCoversImporter):
         if extra_fields:
             fields += extra_fields
         flat = len(fields) == 1 and fk_cls != Publisher
-        qs = fk_cls.objects.filter(fk_filter).values_list(*fields, flat=flat)
+        qs = fk_cls.objects.filter(fk_filter).distinct().values_list(*fields, flat=flat)
         return frozenset(qs)
 
     def _query_create_metadata(  # noqa: PLR0913
@@ -449,7 +449,7 @@ class QueryForeignKeysImporter(QueryCustomCoversImporter):
 
         # Build combined query object from the value_filter
         model = DICT_MODEL_FIELD_MODEL_MAP[field_name]
-        if model == Identifier:
+        if model in (Identifier, Contributor):
             for filter_and_prefix, value_filter in query_filter_map.items():
                 self._query_create_metadata(
                     model,

codex/librarian/janitor/janitor.py

@@ -10,6 +10,7 @@ from codex.librarian.janitor.cleanup import TOTAL_NUM_FK_CLASSES, CleanupMixin
 from codex.librarian.janitor.failed_imports import UpdateFailedImportsMixin
 from codex.librarian.janitor.integrity import IntegrityMixin
 from codex.librarian.janitor.latest_version import LatestVersionMixin
+from codex.librarian.janitor.log_compress import LogCompressMixin
 from codex.librarian.janitor.status import JanitorStatusTypes
 from codex.librarian.janitor.tasks import (
     ForceUpdateAllFailedImportsTask,
@@ -20,6 +21,7 @@ from codex.librarian.janitor.tasks import (
     JanitorCleanupBookmarksTask,
     JanitorCleanupSessionsTask,
     JanitorClearStatusTask,
+    JanitorCompressOldLogs,
     JanitorForeignKeyCheck,
     JanitorFTSIntegrityCheck,
     JanitorFTSRebuildTask,
@@ -61,6 +63,7 @@ _JANITOR_STATII = (
     Status(SearchIndexStatusTypes.SEARCH_INDEX_UPDATE),
     Status(SearchIndexStatusTypes.SEARCH_INDEX_REMOVE),
     Status(SearchIndexStatusTypes.SEARCH_INDEX_OPTIMIZE),
+    Status(JanitorStatusTypes.COMPRESS_LOGS),
 )
 
 
@@ -71,6 +74,7 @@ class Janitor(
     UpdateFailedImportsMixin,
     VacuumMixin,
     IntegrityMixin,
+    LogCompressMixin,
 ):
     """Janitor inline task runner."""
 
@@ -149,9 +153,15 @@ class Janitor(
                     for next_task in next_tasks:
                         self.librarian_queue.put(next_task)
                 case JanitorSearchOptimizeFinishedTask():
-                    next_tasks = (JanitorVacuumTask(), JanitorBackupTask())
+                    next_tasks = (
+                        JanitorVacuumTask(),
+                        JanitorBackupTask(),
+                        JanitorCompressOldLogs(),
+                    )
                     for next_task in next_tasks:
                         self.librarian_queue.put(next_task)
+                case JanitorCompressOldLogs():
+                    self.log_compress()
                 case _:
                     self.log.warning(f"Janitor received unknown task {task}")
         except Exception:

codex/librarian/janitor/log_compress.py

@@ -0,0 +1,77 @@
+"""Rotate logs."""
+
+from dataclasses import dataclass
+from lzma import LZMAFile
+from pathlib import Path
+
+from humanize import naturalsize
+
+from codex.librarian.janitor.status import JanitorStatusTypes
+from codex.settings.settings import LOG_DIR
+from codex.status import Status
+from codex.worker_base import WorkerBaseMixin
+
+_LOG_GLOB = "codex.log.*"
+
+
+@dataclass
+class LogStats:
+    """Collect stats for compressed logs."""
+
+    count = 0
+    old_size = 0
+    new_size = 0
+
+
+class LogCompressMixin(WorkerBaseMixin):
+    """Rotate logs with janitor."""
+
+    @staticmethod
+    def _get_old_log_paths():
+        """Get old log paths to compress and sort them by reverse age."""
+        old_log_paths = {}
+        for path_str in LOG_DIR.glob(_LOG_GLOB):
+            old_path = Path(path_str)
+            try:
+                log_number = int(old_path.suffix[1:])
+                if log_number == 1:
+                    continue
+            except ValueError:
+                continue
+            old_log_paths[log_number] = old_path
+        return dict(sorted(old_log_paths.items(), reverse=True)).values()
+
+    @staticmethod
+    def _rotate_log(old_path, stats):
+        """Rotate one log file."""
+        new_path = Path(str(old_path) + ".xz")
+        if new_path.exists():
+            return
+        with (
+            LZMAFile(new_path, mode="w", preset=9) as log_archive,
+            old_path.open("r") as log_file,
+        ):
+            data = log_file.read()
+            log_archive.write(data.encode())
+        stats.count += 1
+        stats.old_size += old_path.stat().st_size
+        stats.new_size += new_path.stat().st_size
+        if new_path.exists():
+            old_path.unlink(missing_ok=True)
+
+    def log_compress(self):
+        """Compress old log files and report on savings."""
+        status = Status(JanitorStatusTypes.COMPRESS_LOGS)
+        try:
+            self.status_controller.start(status)
+            old_log_paths = self._get_old_log_paths()
+            stats = LogStats()
+            for old_path in old_log_paths:
+                self._rotate_log(old_path, stats)
+            if stats.count:
+                saved = naturalsize(stats.old_size - stats.new_size)
+                self.log.info(f"Compressed logs. Saved {saved}.")
+            else:
+                self.log.debug("No logs compressed.")
+        finally:
+            self.status_controller.finish(status)

codex/librarian/janitor/status.py

@@ -20,3 +20,4 @@ class JanitorStatusTypes(Choices):
     INTEGRITY_CHECK = "JIC"
     FTS_INTEGRITY_CHECK = "JFC"
     FTS_REBUILD = "JFR"
+    COMPRESS_LOGS = "JCL"

codex/librarian/janitor/tasks.py

@@ -107,3 +107,8 @@ class JanitorAdoptOrphanFoldersFinishedTask(JanitorTask):
 @dataclass
 class JanitorSearchOptimizeFinishedTask(JanitorTask):
     """Signals to the Janitor that the Search Optimize task is finished."""
+
+
+@dataclass
+class JanitorCompressOldLogs(JanitorTask):
+    """Compress old logs."""

codex/librarian/librariand.py

@@ -42,6 +42,7 @@ from codex.librarian.watchdog.tasks import (
     WatchdogSyncTask,
 )
 from codex.logger_base import LoggerBaseMixin
+from codex.settings.settings import SET_PROC_TITLE
 
 
 class LibrarianDaemon(Process, LoggerBaseMixin):
@@ -121,7 +122,7 @@ class LibrarianDaemon(Process, LoggerBaseMixin):
             case DelayedTasks():
                 self._threads.delayed_tasks_thread.queue.put(task)
             case LibrarianShutdownTask():
-                self.log.info(f"Shutting down {self.__class__.__name__}...")
+                self.log.info(f"Shutting down {self.name}...")
                 self.run_loop = False
             case _:
                 self.log.warning(f"Unhandled Librarian task: {task}")
@@ -150,34 +151,38 @@ class LibrarianDaemon(Process, LoggerBaseMixin):
 
     def _start_threads(self):
         """Start all librarian's threads."""
-        self.log.debug(f"{self.__class__.__name__} starting all threads.")
+        self.log.debug(f"{self.name} starting all threads.")
         for thread in self._threads:
             thread.start()
-        self.log.info(f"{self.__class__.__name__} started all threads.")
+        self.log.info(f"{self.name} started all threads.")
 
     def _startup(self):
         """Initialize threads."""
+        if SET_PROC_TITLE:
+            from setproctitle import setproctitle
+
+            setproctitle("Codex" + self.name)
         self.init_logger(self.log_queue)
-        self.log.debug(f"Started {self.__class__.__name__}.")
+        self.log.debug(f"Started {self.name}.")
         self.janitor = Janitor(self.log_queue, self.queue)
         self._create_threads()  # can't do this in init.
         self._start_threads()
         self.run_loop = True
-        self.log.info(f"{self.__class__.__name__} ready for tasks.")
+        self.log.info(f"{self.name} ready for tasks.")
 
     def _stop_threads(self):
         """Stop all librarian's threads."""
-        self.log.debug(f"{self.__class__.__name__} stopping all threads...")
+        self.log.debug(f"{self.name} stopping all threads...")
         for thread in self._reversed_threads:
             thread.stop()
-        self.log.debug(f"{self.__class__.__name__} stopped all threads.")
+        self.log.debug(f"{self.name} stopped all threads.")
 
     def _join_threads(self):
         """Join all librarian threads."""
-        self.log.debug(f"{self.__class__.__name__} joining all threads...")
+        self.log.debug(f"{self.name} joining all threads...")
         for thread in self._reversed_threads:
             thread.join()
-        self.log.info(f"{self.__class__.__name__} joined all threads.")
+        self.log.info(f"{self.name} joined all threads.")
 
     def _shutdown(self):
         """Shutdown threads and queues."""
@@ -188,7 +193,7 @@ class LibrarianDaemon(Process, LoggerBaseMixin):
             self.queue.get_nowait()
         self.queue.close()
         self.queue.join_thread()
-        self.log.info(f"{self.__class__.__name__} finished.")
+        self.log.info(f"{self.name} finished.")
         self.log_queue.close()
         self.log_queue.join_thread()
 
@@ -205,11 +210,11 @@ class LibrarianDaemon(Process, LoggerBaseMixin):
                     task = self.queue.get()
                     self._process_task(task)
                 except Exception:
-                    self.log.exception(f"In {self.__class__.__name__} loop")
+                    self.log.exception(f"In {self.name} loop")
         except Exception:
-            self.log.exception(f"{self.__class__.__name__} crashed.")
+            self.log.exception(f"{self.name} crashed.")
         except KeyboardInterrupt:
-            self.log.debug(f"{self.__class__.__name__} Keyboard interrupt")
+            self.log.debug(f"{self.name} Keyboard interrupt")
         finally:
             self._shutdown()
 

codex/librarian/search/update.py

@@ -114,7 +114,7 @@ class FTSUpdateMixin(RemoveMixin):
             return ""
         return ",".join((iso_code, field_instance.to_representation(iso_code)))
 
-    def _get_comicts_fts_list(
+    def _get_comics_fts_list(
         self, comics, country_field, language_field, obj_list, create
     ):
         """Prepare a batch of search entries."""
@@ -157,6 +157,7 @@ class FTSUpdateMixin(RemoveMixin):
             if create:
                 comicfts.created_at = now
             obj_list.append(comicfts)
+            self.log.debug(f"{len(obj_list)}/{comics.count()} entries prepped.")
 
     def _get_comicfts_list(self, comics, create=False):
         """Create a ComicFTS object for bulk_create or bulk_update."""
@@ -164,7 +165,7 @@ class FTSUpdateMixin(RemoveMixin):
         language_field = LanguageField()
         obj_list = []
         comics = self._annotate_fts_query(comics)
-        self._get_comicts_fts_list(
+        self._get_comics_fts_list(
             comics, country_field, language_field, obj_list, create
         )
         return obj_list
@@ -205,11 +206,14 @@ class FTSUpdateMixin(RemoveMixin):
                 batch_start = time()
                 batch_to = batch_from + SEARCH_INDEX_BATCH_SIZE
                 comics_batch = comics_qs[batch_from:batch_to]
-
+                self.log.debug(
+                    f"Checking {comics_batch.count()}/{count} comics for search index operations..."
+                )
                 if self.abort_event.is_set():
                     break
                 operate_comicfts = self._get_comicfts_list(comics_batch, create)
                 operate_comicfts_count = len(operate_comicfts)
+                self.log.debug(f"{verb}ing {operate_comicfts_count} search entries...")
                 if self.abort_event.is_set():
                     break
                 if create:
@@ -223,7 +227,7 @@ class FTSUpdateMixin(RemoveMixin):
                 batch_time = time() - batch_start
                 eps = round(count / batch_time)
                 self.log.debug(
-                    f"{verb} {count}/{operate_comicfts_count} search entries in {batch_time}, {eps} per second."
+                    f"{verb} {operate_comicfts_count}/{count} search entries in {batch_time}, {eps} per second."
                 )
                 batch_from = batch_to
         finally:

codex/migrations/0031_adminflag_banner.py

@@ -0,0 +1,50 @@
+"""Generated by Django 5.1.2 on 2024-10-22 03:09."""
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+    """Migrate db."""
+
+    dependencies = [
+        ("codex", "0030_nocase_collation_day_month_indexes_status_types"),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="adminflag",
+            name="value",
+            field=models.CharField(blank=True, default="", max_length=32),
+        ),
+        migrations.AlterField(
+            model_name="adminflag",
+            name="key",
+            field=models.CharField(
+                choices=[
+                    ("FV", "Folder View"),
+                    ("RG", "Registration"),
+                    ("NU", "Non Users"),
+                    ("AU", "Auto Update"),
+                    ("IM", "Import Metadata"),
+                    ("ST", "Send Telemetry"),
+                    ("BT", "Banner Text"),
+                ],
+                db_index=True,
+                max_length=2,
+            ),
+        ),
+        migrations.AlterField(
+            model_name="timestamp",
+            name="key",
+            field=models.CharField(
+                choices=[
+                    ("AP", "API Key"),
+                    ("VR", "Codex Version"),
+                    ("JA", "Janitor"),
+                    ("TS", "Telemeter Sent"),
+                ],
+                db_index=True,
+                max_length=2,
+            ),
+        ),
+    ]

codex/models/admin.py

@@ -39,6 +39,7 @@ class AdminFlag(BaseModel):
         AUTO_UPDATE = "AU"
         IMPORT_METADATA = "IM"
         SEND_TELEMETRY = "ST"
+        BANNER_TEXT = "BT"
 
     FALSE_DEFAULTS = frozenset({FlagChoices.AUTO_UPDATE})
 
@@ -48,6 +49,7 @@ class AdminFlag(BaseModel):
         choices=FlagChoices.choices,
     )
     on = BooleanField(default=True)
+    value = CharField(max_length=32, default="", blank=True)
 
     class Meta(BaseModel.Meta):
         """Constraints."""
@@ -88,10 +90,9 @@ class Timestamp(BaseModel):
     class TimestampChoices(TextChoices):
         """Choices for Timestamps."""
 
-        JANITOR = "JA", _("Janitor")
-        CODEX_VERSION = "VR", _("Codex Version")
-        SEARCH_INDEX_UUID = "SI", _("Search Index UUID")
         API_KEY = "AP", _("API Key")
+        CODEX_VERSION = "VR", _("Codex Version")
+        JANITOR = "JA", _("Janitor")
         TELEMETER_SENT = "TS", _("Telemeter Sent")
 
     key = CharField(

codex/serializers/admin/flags.py

@@ -11,5 +11,5 @@ class AdminFlagSerializer(BaseModelSerializer):
         """Specify Model."""
 
         model = AdminFlag
-        fields = ("key", "on")
+        fields = ("key", "on", "value")
         read_only_fields = ("key",)

codex/serializers/auth.py

@@ -78,3 +78,4 @@ class AuthAdminFlagsSerializer(Serializer):
 
     non_users = BooleanField(read_only=True)
     registration = BooleanField(read_only=True)
+    banner_text = CharField(read_only=True)

codex/serializers/opds/v2/__init__.py

@@ -0,0 +1 @@
+"""OPDS v2.0 Serializers."""

codex/serializers/opds/v2/facet.py

@@ -0,0 +1,13 @@
+"""OPDS v2.0 Facet Serializer."""
+
+from rest_framework.serializers import Serializer
+
+from codex.serializers.opds.v2.links import OPDS2LinkListField
+from codex.serializers.opds.v2.metadata import OPDS2MetadataSerializer
+
+
+class OPDS2FacetSerializer(Serializer):
+    """Facets."""
+
+    metadata = OPDS2MetadataSerializer(read_only=True)
+    links = OPDS2LinkListField(read_only=True)

codex/serializers/opds/v2/feed.py

@@ -0,0 +1,35 @@
+"""OPDS v2.0 Feed Serializer."""
+
+from rest_framework.fields import (
+    ListField,
+)
+from rest_framework.serializers import Serializer
+
+from codex.serializers.opds.v2.facet import OPDS2FacetSerializer
+from codex.serializers.opds.v2.links import OPDS2LinkListField
+from codex.serializers.opds.v2.publication import (
+    OPDS2MetadataSerializer,
+    OPDS2PublicationSerializer,
+)
+
+
+class OPDS2GroupSerializer(Serializer):
+    """Group."""
+
+    metadata = OPDS2MetadataSerializer(read_only=True)
+    links = OPDS2LinkListField(read_only=True, required=False)
+    publications = ListField(
+        child=OPDS2PublicationSerializer(), read_only=True, required=False
+    )
+    navigation = OPDS2LinkListField(read_only=True, required=False)
+
+
+class OPDS2FeedSerializer(OPDS2GroupSerializer):
+    """Feed.
+
+    https://drafts.opds.io/schema/feed.schema.json
+    https://readium.org/webpub-manifest/schema/subcollection.schema.json
+    """
+
+    facets = ListField(child=OPDS2FacetSerializer(), read_only=True, required=False)
+    groups = ListField(child=OPDS2GroupSerializer(), read_only=True, required=False)