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

codex/librarian/importer/cache.py

@@ -1,171 +1,84 @@
 """Update Groups timestamp for cover cache busting."""
 
-import os
-
 from django.db.models.aggregates import Count
 from django.db.models.functions.datetime import Now
 from django.db.models.query import Q
 
 from codex.librarian.importer.init import InitImporter
 from codex.librarian.importer.status import ImportStatusTypes
-from codex.models import Comic, Folder, Imprint, Publisher, Series, StoryArc, Volume
+from codex.models import StoryArc, Volume
 from codex.status import Status
+from codex.views.const import GROUP_MODELS
 
-_FIRST_COVER_MODEL_UPDATE_ORDER = (Volume, Series, Imprint, Publisher, Folder, StoryArc)
-_UPDATE_FIELDS = ("first_comic", "updated_at")
+_UPDATE_FIELDS = ("updated_at",)
 
 
 class CacheUpdateImporter(InitImporter):
     """Update Groups timestamp for cover cache busting."""
 
     @staticmethod
-    def _get_folder_batches(model_qs):
-        """Create batches of folders by folder depth level."""
-        # Collect all related folders
-        folder_pks = model_qs.values_list("pk", flat=True)
-        all_folders = (
-            Folder.objects.filter(Q(folder__pk__in=folder_pks) | Q(pk__in=folder_pks))
-            .select_related("first_comic")
-            .only("path", *_UPDATE_FIELDS)
-        )
-
-        # Create a map of each folder by path depth level
-        batch_map = {}
-        for folder in all_folders:
-            depth = folder.path.count(os.sep)
-            if depth not in batch_map:
-                batch_map[depth] = set()
-            batch_map[depth].add(folder)
-
-        # Order batches by reverse depth level to update bottom up.
-        batches = []
-        for _, folders in sorted(batch_map.items(), reverse=True):
-            batches.append(folders)
-
-        return tuple(batches)
+    def _get_update_filter(model, start_time, force_update_group_map):
+        # Get groups with comics updated during this import
+        rel = "storyarcnumber__" if model == StoryArc else ""
+        updated_at_rel = rel + "comic__updated_at__gt"
+        updated_filter = {updated_at_rel: start_time}
+        update_filter = Q(**updated_filter)
 
-    @staticmethod
-    def _update_first_cover_volume(obj):
-        qs = Comic.objects.filter(volume=obj)
-        qs = qs.order_by("issue_number", "issue_suffix", "sort_name").only("pk")
-        obj.first_comic = qs.first()
+        # Get groups with custom covers updated during this import
+        if model != Volume:
+            update_filter |= Q(custom_cover__updated_at__gt=start_time)
 
-    @staticmethod
-    def _update_first_cover_group(obj, model, field):
-        qs = model.objects.filter(**{field: obj})
-        order_by = "name" if model == Volume else "sort_name"
-        qs = qs.select_related("first_comic").order_by(order_by).only("first_comic")
-        obj.first_comic = qs.first().first_comic
+        # Get groups to be force updated (usually those with deleted children)
+        if pks := force_update_group_map.get(model):
+            update_filter |= Q(pk__in=pks)
 
-    @staticmethod
-    def _update_first_cover_story_arc(obj):
-        qs = Comic.objects.filter(story_arc_numbers__story_arc=obj)
-        qs = qs.order_by("story_arc_numbers__number", "date").only("pk")
-        obj.first_comic = qs.first()
+        return update_filter
 
     @staticmethod
-    def _update_first_cover_folder(obj):
-        first_comic = (
-            Comic.objects.filter(parent_folder=obj)
-            .order_by("path")
-            .only("path")
-            .first()
-        )
-        first_folder = (
-            Folder.objects.filter(parent_folder=obj)
-            .select_related("first_comic")
-            .order_by("path")
-            .only("first_comic", "path")
-            .first()
-        )
-        if first_comic and not first_folder:
-            obj.first_comic = first_comic
-        elif first_folder and not first_comic:
-            obj.first_comic = first_folder.first_comic
-        elif first_folder and first_comic:
-            if first_comic and first_comic.path < first_folder.path:
-                obj.first_comic = first_comic
-            else:
-                obj.first_comic = first_folder.first_comic
-
-    @classmethod
-    def _update_first_cover(cls, model, obj):
-        if model == Volume:
-            cls._update_first_cover_volume(obj)
-        elif model == Series:
-            cls._update_first_cover_group(obj, Volume, "series")
-        elif model == Imprint:
-            cls._update_first_cover_group(obj, Series, "imprint")
-        elif model == Publisher:
-            cls._update_first_cover_group(obj, Imprint, "publisher")
-        elif model == StoryArc:
-            cls._update_first_cover_story_arc(obj)
-        elif model == Folder:
-            cls._update_first_cover_folder(obj)
+    def _add_child_count_filter(qs, model):
+        """Filter out groups with no comics."""
+        rel_prefix = "storyarcnumber__" if model == StoryArc else ""
+        rel_prefix += "comic"
+        qs = qs.alias(child_count=Count(f"{rel_prefix}__pk", distinct=True))
+        return qs.filter(child_count__gt=0)
 
     @classmethod
-    def _update_group_first_comic(
-        cls, force_update_group_map, model, start_time, log_list
-    ):
-        rel = "storyarcnumber__" if model == StoryArc else ""
-        updated_at_rel = rel + "comic__updated_at__gt"
-        updated_filter = {updated_at_rel: start_time}
-        filter_query = (
-            Q(**updated_filter)
-            | Q(first_comic__isnull=True)
-            | Q(updated_at__gt=start_time)
+    def _update_group_model(cls, force_update_group_map, model, start_time, log_list):
+        """Update a single group model."""
+        update_filter = cls._get_update_filter(
+            model, start_time, force_update_group_map
         )
-        if model != Volume:
-            filter_query |= Q(custom_cover__updated_at__gt=start_time)
-        pks = force_update_group_map.get(model)
-        if pks:
-            filter_query |= Q(pk__in=pks)
-        model_qs = model.objects.filter(filter_query)
+        qs = model.objects.filter(update_filter)
+        qs = cls._add_child_count_filter(qs, model)
 
-        # only update those with comics
-        rel_prefix = "storyarcnumber__" if model == StoryArc else ""
-        rel_prefix += "comic"
-        model_qs = model_qs.alias(child_count=Count(f"{rel_prefix}__pk", distinct=True))
-        model_qs = model_qs.filter(child_count__gt=0)
-        model_qs = model_qs.distinct()
-        if model == Folder:
-            batches = cls._get_folder_batches(model_qs)
-        else:
-            model_qs.select_related("first_comic").only(*_UPDATE_FIELDS)
-            batches = (model_qs,)
+        qs = qs.distinct()
+        qs = qs.only(*_UPDATE_FIELDS)
 
-        total_count = 0
-        for model_qs in batches:
-            updated = []
-            for obj in model_qs:
-                cls._update_first_cover(model, obj)
-                obj.updated_at = Now()
-                updated.append(obj)
-
-            count = len(updated)
-            if count:
-                model.objects.bulk_update(updated, _UPDATE_FIELDS)
-                total_count += count
-        if total_count:
-            log_list.append(f"{total_count} {model.__name__}s")
-        return total_count
+        updated = []
+        for obj in qs:
+            obj.updated_at = Now()
+            updated.append(obj)
+
+        count = len(updated)
+        if count:
+            model.objects.bulk_update(updated, _UPDATE_FIELDS)
+            log_list.append(f"{count} {model.__name__}s")
+        return count
 
-    def update_all_groups_first_comics(self, force_update_group_map, start_time):
+    def update_all_groups(self, force_update_group_map, start_time):
         """Update timestamps for each group for cover cache busting."""
         total_count = 0
         status = Status(ImportStatusTypes.GROUP_UPDATE)
         self.status_controller.start(status)
         try:
             log_list = []
-            for model in _FIRST_COVER_MODEL_UPDATE_ORDER:
-                # self.log.debug(f"Updating first covers for {model.__name__}s...")
-                count = self._update_group_first_comic(
+            for model in GROUP_MODELS:
+                # self.log.debug(f"Updating timestamps for {model.__name__}s...")
+                count = self._update_group_model(
                     force_update_group_map, model, start_time, log_list
                 )
                 if count:
-                    self.log.debug(
-                        f"Updated {count} first covers for {model.__name__}s"
-                    )
+                    self.log.debug(f"Updated {count} {model.__name__}s timestamps.")
                 status.add_complete(count)
                 self.status_controller.update(status, notify=False)
                 total_count += count
@@ -173,7 +86,7 @@ class CacheUpdateImporter(InitImporter):
             if total_count:
                 groups_log = ", ".join(log_list)
                 self.log.info(  # type: ignore
-                    f"Updated first covers for {groups_log}."
+                    f"Updated timestamps for {groups_log}."
                 )
                 self.changed += total_count
         finally:

codex/librarian/importer/create_fks.py

@@ -211,8 +211,10 @@ class CreateForeignKeysImporter(CreateCoversImporter):
             folder_path_dict[path_length].add(path)
 
         # create each depth level first to ensure we can assign parents
-        for paths in sorted(folder_path_dict.values()):
+        for depth_level in sorted(folder_path_dict):
+            paths = sorted(folder_path_dict[depth_level])
             count += self._bulk_folders_create_depth_level(paths, status)
+            self.log.debug(f"Created {count} Folders at depth level {depth_level}")
 
         if count:
             self.log.info(f"Created {count} Folders.")

codex/librarian/importer/importer.py

@@ -88,7 +88,7 @@ class ComicImporter(MovedImporter):
 
             deleted_comic_groups = self.delete()
 
-            self.update_all_groups_first_comics(deleted_comic_groups, self.start_time)
+            self.update_all_groups(deleted_comic_groups, self.start_time)
 
         finally:
             self._finish_apply_status()

codex/librarian/importer/importerd.py

@@ -8,7 +8,7 @@ from codex.librarian.importer.tasks import (
     AdoptOrphanFoldersTask,
     ImportDBDiffTask,
     LazyImportComicsTask,
-    UpdateGroupsFirstComic,
+    UpdateGroupsTask,
 )
 from codex.librarian.notifier.tasks import LIBRARY_CHANGED_TASK
 from codex.models import Comic, Folder, Library
@@ -89,13 +89,13 @@ class ComicImporterThread(QueuedThread):
 
         self.status_controller.finish_many((moved_status, status))
 
-    def _update_groups_first_comic(self, task):
+    def _update_groups(self, task):
         pks = Library.objects.filter(covers_only=False).values_list("pk", flat=True)
         start_time = task.start_time if task.start_time else timezone.now()
         for pk in pks:
             task = ImportDBDiffTask(library_id=pk)
             importer = self._create_importer(task)
-            importer.update_all_groups_first_comics({}, start_time)
+            importer.update_all_groups({}, start_time)
         self.librarian_queue.put(LIBRARY_CHANGED_TASK)
 
     def process_item(self, item):
@@ -107,7 +107,7 @@ class ComicImporterThread(QueuedThread):
             self._lazy_import_metadata(task)
         elif isinstance(task, AdoptOrphanFoldersTask):
             self._adopt_orphan_folders()
-        elif isinstance(task, UpdateGroupsFirstComic):
-            self._update_groups_first_comic(task)
+        elif isinstance(task, UpdateGroupsTask):
+            self._update_groups(task)
         else:
             self.log.warning(f"Bad task sent to library updater {task}")

codex/librarian/importer/tasks.py

@@ -47,7 +47,7 @@ class AdoptOrphanFoldersTask(ImportTask):
 
 
 @dataclass
-class UpdateGroupsFirstComic(ImportTask):
-    """Force the update of the first comics."""
+class UpdateGroupsTask(ImportTask):
+    """Force the update of group timestamp."""
 
     start_time: datetime | None = None

codex/librarian/janitor/janitor.py

@@ -5,7 +5,6 @@ from codex.librarian.covers.tasks import CoverRemoveOrphansTask
 from codex.librarian.importer.status import ImportStatusTypes
 from codex.librarian.importer.tasks import (
     AdoptOrphanFoldersTask,
-    UpdateGroupsFirstComic,
 )
 from codex.librarian.janitor.cleanup import TOTAL_NUM_FK_CLASSES, CleanupMixin
 from codex.librarian.janitor.failed_imports import UpdateFailedImportsMixin
@@ -41,7 +40,6 @@ _JANITOR_STATII = (
     Status(JanitorStatusTypes.DB_OPTIMIZE),
     Status(JanitorStatusTypes.DB_BACKUP),
     Status(JanitorStatusTypes.CODEX_UPDATE),
-    Status(ImportStatusTypes.GROUP_UPDATE),
     Status(CoverStatusTypes.FIND_ORPHAN),
     Status(CoverStatusTypes.PURGE_COVERS),
     Status(ImportStatusTypes.ADOPT_FOLDERS),
@@ -75,7 +73,6 @@ class Janitor(CleanupMixin, UpdateMixin, VacuumMixin, UpdateFailedImportsMixin):
                 JanitorBackupTask(),
                 JanitorUpdateTask(force=False),
                 AdoptOrphanFoldersTask(),
-                UpdateGroupsFirstComic(),
                 CoverRemoveOrphansTask(),
                 SearchIndexUpdateTask(False),
                 SearchIndexMergeTask(optimize),

codex/librarian/librariand.py

@@ -14,7 +14,6 @@ from codex.librarian.importer.importerd import ComicImporterThread
 from codex.librarian.importer.tasks import (
     AdoptOrphanFoldersTask,
     ImportTask,
-    UpdateGroupsFirstComic,
 )
 from codex.librarian.janitor.janitor import Janitor
 from codex.librarian.janitor.janitord import JanitorThread
@@ -74,7 +73,6 @@ class LibrarianDaemon(Process, LoggerBaseMixin):
         self.broadcast_queue = broadcast_queue
         startup_tasks = (
             AdoptOrphanFoldersTask(),
-            UpdateGroupsFirstComic(),
             WatchdogSyncTask(),
             SearchIndexRebuildIfDBChangedTask(),
         )

codex/librarian/notifier/notifierd.py

@@ -22,7 +22,7 @@ class NotifierThread(AggregateMessageQueuedThread):
         and do a group_send with it's message.
         """
         item = {
-            "group": task.group.name,
+            "group": task.group,
             "message": {
                 "type": "send_text",
                 "text": task.text,

codex/librarian/notifier/tasks.py

@@ -10,9 +10,9 @@ class NotifierTask:
     """Handle with the Notifier."""
 
     text: str
-    group: ChannelGroups
+    group: str
 
 
-LIBRARY_CHANGED_TASK = NotifierTask("LIBRARY_CHANGED", ChannelGroups.ALL)
-LIBRARIAN_STATUS_TASK = NotifierTask("LIBRARIAN_STATUS", ChannelGroups.ADMIN)
-FAILED_IMPORTS_TASK = NotifierTask("FAILED_IMPORTS", ChannelGroups.ADMIN)
+LIBRARY_CHANGED_TASK = NotifierTask("LIBRARY_CHANGED", ChannelGroups.ALL.name)
+LIBRARIAN_STATUS_TASK = NotifierTask("LIBRARIAN_STATUS", ChannelGroups.ADMIN.name)
+FAILED_IMPORTS_TASK = NotifierTask("FAILED_IMPORTS", ChannelGroups.ADMIN.name)

codex/middleware.py

@@ -22,8 +22,7 @@ class TimezoneMiddleware:
 
     def __call__(self, request):
         """Fix timeszone from the django session."""
-        tzname = request.session.get("django_timezone")
-        if tzname:
+        if tzname := request.session.get("django_timezone"):
             timezone.activate(tzname)
         else:
             timezone.deactivate()

codex/migrations/0027_import_order_and_covers.py

@@ -71,33 +71,11 @@ class Migration(migrations.Migration):
             name="sort_name",
             field=models.CharField(db_index=True, default="", max_length=128),
         ),
-        migrations.AddField(
-            model_name="folder",
-            name="first_comic",
-            field=models.ForeignKey(
-                default=None,
-                null=True,
-                on_delete=django.db.models.deletion.SET_DEFAULT,
-                related_name="+",
-                to="codex.comic",
-            ),
-        ),
         migrations.AddField(
             model_name="folder",
             name="sort_name",
             field=models.CharField(db_index=True, default="", max_length=128),
         ),
-        migrations.AddField(
-            model_name="imprint",
-            name="first_comic",
-            field=models.ForeignKey(
-                default=None,
-                null=True,
-                on_delete=django.db.models.deletion.SET_DEFAULT,
-                related_name="+",
-                to="codex.comic",
-            ),
-        ),
         migrations.AddField(
             model_name="imprint",
             name="sort_name",
@@ -108,65 +86,21 @@ class Migration(migrations.Migration):
             name="covers_only",
             field=models.BooleanField(db_index=True, default=False),
         ),
-        migrations.AddField(
-            model_name="publisher",
-            name="first_comic",
-            field=models.ForeignKey(
-                default=None,
-                null=True,
-                on_delete=django.db.models.deletion.SET_DEFAULT,
-                related_name="+",
-                to="codex.comic",
-            ),
-        ),
         migrations.AddField(
             model_name="publisher",
             name="sort_name",
             field=models.CharField(db_index=True, default="", max_length=128),
         ),
-        migrations.AddField(
-            model_name="series",
-            name="first_comic",
-            field=models.ForeignKey(
-                default=None,
-                null=True,
-                on_delete=django.db.models.deletion.SET_DEFAULT,
-                related_name="+",
-                to="codex.comic",
-            ),
-        ),
         migrations.AddField(
             model_name="series",
             name="sort_name",
             field=models.CharField(db_index=True, default="", max_length=128),
         ),
-        migrations.AddField(
-            model_name="storyarc",
-            name="first_comic",
-            field=models.ForeignKey(
-                default=None,
-                null=True,
-                on_delete=django.db.models.deletion.SET_DEFAULT,
-                related_name="+",
-                to="codex.comic",
-            ),
-        ),
         migrations.AddField(
             model_name="storyarc",
             name="sort_name",
             field=models.CharField(db_index=True, default="", max_length=128),
         ),
-        migrations.AddField(
-            model_name="volume",
-            name="first_comic",
-            field=models.ForeignKey(
-                default=None,
-                null=True,
-                on_delete=django.db.models.deletion.SET_DEFAULT,
-                related_name="+",
-                to="codex.comic",
-            ),
-        ),
         migrations.AlterField(
             model_name="adminflag",
             name="key",
@@ -211,6 +145,7 @@ class Migration(migrations.Migration):
                     ("ICD", "Covers Deleted"),
                     ("ICL", "Covers Link"),
                     ("IGU", "Group Update"),
+                    ("IAF", "Adopt Folders"),
                     ("JTD", "Cleanup Fk"),
                     ("JCU", "Codex Update"),
                     ("JCR", "Codex Restart"),

codex/models/comic.py

@@ -176,7 +176,6 @@ class Comic(WatchedPathBrowserGroup):
 
     # Not useful
     custom_cover = None
-    first_comic = None
 
     class Meta(WatchedPathBrowserGroup.Meta):
         """Constraints."""

codex/models/groups.py

@@ -25,9 +25,6 @@ class BrowserGroupModel(BaseModel):
     custom_cover = ForeignKey(
         CustomCover, on_delete=SET_DEFAULT, null=True, default=None
     )
-    first_comic = ForeignKey(
-        "Comic", on_delete=SET_DEFAULT, null=True, default=None, related_name="+"
-    )
 
     def set_sort_name(self):
         """Create sort_name for model."""

codex/serializers/admin.py

@@ -181,67 +181,68 @@ class AdminGroupSerializer(Serializer):
     """Group Counts."""
 
     publishers_count = IntegerField(required=False, read_only=True)
-    imprints_count = IntegerField(required=False)
-    series_count = IntegerField(required=False)
-    volumes_count = IntegerField(required=False)
-    issues_count = IntegerField(required=False)
-    folders_count = IntegerField(required=False)
+    imprints_count = IntegerField(required=False, read_only=True)
+    series_count = IntegerField(required=False, read_only=True)
+    volumes_count = IntegerField(required=False, read_only=True)
+    issues_count = IntegerField(required=False, read_only=True)
+    folders_count = IntegerField(required=False, read_only=True)
+    story_arcs_count = IntegerField(required=False, read_only=True)
 
 
 class AdminFileTypeSerializer(Serializer):
     """File Type Counts."""
 
-    pdf_count = IntegerField(required=False)
-    cbz_count = IntegerField(required=False)
-    cbr_count = IntegerField(required=False)
-    cbt_count = IntegerField(required=False)
-    unknown_count = IntegerField(required=False)
+    pdf_count = IntegerField(required=False, read_only=True)
+    cbz_count = IntegerField(required=False, read_only=True)
+    cbr_count = IntegerField(required=False, read_only=True)
+    cbt_count = IntegerField(required=False, read_only=True)
+    unknown_count = IntegerField(required=False, read_only=True)
 
 
 class AdminComicMetadataSerializer(Serializer):
     """Metadata Counts."""
 
-    age_ratings_count = IntegerField(required=False)
-    characters_count = IntegerField(required=False)
-    contributors_count = IntegerField(required=False)
-    contributor_persons_count = IntegerField(required=False)
-    contributor_roles_count = IntegerField(required=False)
-    countries_count = IntegerField(required=False)
-    genres_count = IntegerField(required=False)
-    identifiers_count = IntegerField(required=False)
-    identifier_types_count = IntegerField(required=False)
-    languages_count = IntegerField(required=False)
-    locations_count = IntegerField(required=False)
-    original_formats_count = IntegerField(required=False)
-    series_groups_count = IntegerField(required=False)
-    scan_infos_count = IntegerField(required=False)
+    age_ratings_count = IntegerField(required=False, read_only=True)
+    characters_count = IntegerField(required=False, read_only=True)
+    contributors_count = IntegerField(required=False, read_only=True)
+    contributor_persons_count = IntegerField(required=False, read_only=True)
+    contributor_roles_count = IntegerField(required=False, read_only=True)
+    countries_count = IntegerField(required=False, read_only=True)
+    genres_count = IntegerField(required=False, read_only=True)
+    identifiers_count = IntegerField(required=False, read_only=True)
+    identifier_types_count = IntegerField(required=False, read_only=True)
+    languages_count = IntegerField(required=False, read_only=True)
+    locations_count = IntegerField(required=False, read_only=True)
+    original_formats_count = IntegerField(required=False, read_only=True)
+    series_groups_count = IntegerField(required=False, read_only=True)
+    scan_infos_count = IntegerField(required=False, read_only=True)
     story_arcs_count = IntegerField(required=False)
-    story_arc_numbers_count = IntegerField(required=False)
-    tags_count = IntegerField(required=False)
-    taggers_count = IntegerField(required=False)
-    teams_count = IntegerField(required=False)
+    story_arc_numbers_count = IntegerField(required=False, read_only=True)
+    tags_count = IntegerField(required=False, read_only=True)
+    taggers_count = IntegerField(required=False, read_only=True)
+    teams_count = IntegerField(required=False, read_only=True)
 
 
 class AdminConfigSerializer(Serializer):
     """Config Information."""
 
-    api_key = CharField(required=False)
-    groups_count = IntegerField(required=False)
-    libraries_count = IntegerField(required=False)
-    sessions_anon_count = IntegerField(required=False)
-    sessions_count = IntegerField(required=False)
-    users_count = IntegerField(required=False)
+    api_key = CharField(required=False, read_only=True)
+    groups_count = IntegerField(required=False, read_only=True)
+    libraries_count = IntegerField(required=False, read_only=True)
+    sessions_anon_count = IntegerField(required=False, read_only=True)
+    sessions_count = IntegerField(required=False, read_only=True)
+    users_count = IntegerField(required=False, read_only=True)
 
 
 class AdminPlatformSerializer(Serializer):
     """Platform Information."""
 
-    docker = BooleanField()
-    machine = CharField()
-    system = CharField()
-    system_release = CharField()
-    python = CharField()
-    codex = CharField()
+    docker = BooleanField(read_only=True)
+    machine = CharField(read_only=True)
+    system = CharField(read_only=True)
+    system_release = CharField(read_only=True)
+    python = CharField(read_only=True)
+    codex = CharField(read_only=True)
 
 
 class AdminStatsSerializer(Serializer):

codex/serializers/browser/choices.py

@@ -2,6 +2,7 @@
 
 from types import MappingProxyType
 
+from rest_framework.fields import SerializerMethodField
 from rest_framework.serializers import (
     BooleanField,
     CharField,
@@ -10,10 +11,11 @@ from rest_framework.serializers import (
     IntegerField,
     Serializer,
 )
+from rest_framework.utils.serializer_helpers import ReturnList
 
-from codex.serializers.browser.filters import (
+from codex.serializers.browser.filters import BrowserSettingsFilterSerializer
+from codex.serializers.fields import (
     BooleanListField,
-    BrowserSettingsFilterSerializer,
     CharListField,
     DecadeListField,
     FloatListField,
@@ -56,11 +58,25 @@ _CHOICES_TYPE_SERIALIZER_MAP = MappingProxyType(
         IntListField: BrowserChoicesIntPkSerializer,
     }
 )
-
-_BSFS = BrowserSettingsFilterSerializer
-CHOICES_SERIALIZER_CLASS_MAP = MappingProxyType(
+_CHOICES_SERIALIZER_CLASS_MAP = MappingProxyType(
     {
         name: _CHOICES_TYPE_SERIALIZER_MAP[field.__class__]
-        for name, field in _BSFS().fields.items()  # type: ignore
+        for name, field in BrowserSettingsFilterSerializer().fields.items()  # type: ignore
     }
 )
+
+
+class BrowserChoicesFilterSerializer(Serializer):
+    """Dynamic Serializer response by field type."""
+
+    choices = SerializerMethodField(read_only=True)
+
+    def get_choices(self, obj) -> ReturnList:
+        """Dynamic Serializer response by field type."""
+        key = obj.get("field_name", "")
+        choices = obj.get("choices", [])
+        serializer_class = _CHOICES_SERIALIZER_CLASS_MAP.get(
+            key, BrowserChoicesCharPkSerializer
+        )
+        serializer = serializer_class(choices, many=True)
+        return serializer.data  # type: ignore