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

codex/integrity.py

@@ -342,7 +342,6 @@ def _repair_groups_with_custom_covers(apps):
     if not has_applied_migration(MIGRATION_0027):
         return
     custom_cover_model = apps.get_model("codex", "customcover")
-    now = Now()
     for model_name, group_letter in CUSTOM_COVER_MODEL_NAMES.items():
         valid_covers = custom_cover_model.objects.filter(group=group_letter)
         group_model = apps.get_model("codex", model_name)
@@ -352,7 +351,7 @@ def _repair_groups_with_custom_covers(apps):
         update_groups = []
         for group in objs:
             group.custom_cover = None
-            group.updated_at = now
+            group.updated_at = Now()
             update_groups.append(group)
         group_model.objects.bulk_update(update_groups, ["custom_cover"])
         count = len(update_groups)

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_comics.py

@@ -20,7 +20,7 @@ from codex.status import Status
 class CreateComicsImporter(LinkComicsImporter):
     """Create comics methods."""
 
-    def _bulk_update_comics_add_comic(self, now, comic, results):
+    def _bulk_update_comics_add_comic(self, comic, results):
         """Add one comic and stats to the bulk update list."""
         try:
             md = self.metadata[MDS].pop(comic.path)
@@ -33,7 +33,7 @@ class CreateComicsImporter(LinkComicsImporter):
                         value = default_value
                 setattr(comic, field_name, value)
             comic.presave()
-            comic.updated_at = now
+            comic.updated_at = Now()
             update_comics, comic_pks, comic_update_paths = results
             update_comics.append(comic)
             comic_pks.append(comic.pk)
@@ -59,12 +59,11 @@ class CreateComicsImporter(LinkComicsImporter):
 
         # set attributes for each comic
         update_comics = []
-        now = Now()
         comic_pks = []
         comic_update_paths = set()
         results = update_comics, comic_pks, comic_update_paths
         for comic in comics.iterator():
-            self._bulk_update_comics_add_comic(now, comic, results)
+            self._bulk_update_comics_add_comic(comic, results)
 
         converted_create_paths = frozenset(
             set(self.task.files_modified) - comic_update_paths

codex/librarian/importer/create_covers.py

@@ -30,11 +30,9 @@ class CreateCoversImporter(CreateComicsImporter):
         status = Status(ImportStatusTypes.COVERS_MODIFIED, 0, update_covers_count)
         self.status_controller.start(status)
 
-        now = Now()
-
         update_covers = []
         for cover in update_covers_qs.only(*CUSTOM_COVER_UPDATE_FIELDS):
-            cover.updated_at = now
+            cover.updated_at = Now()
             cover.presave()
             update_covers.append(cover)
 

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/failed_imports.py

@@ -84,13 +84,12 @@ class FailedImportsImporter(DeletedImporter):
         ).only(*_BULK_UPDATE_FAILED_IMPORT_FIELDS)
         if not update_failed_import_objs:
             return
-        now = Now()
         for fi in update_failed_import_objs:
             try:
                 exc = update_failed_imports.pop(fi.path)
                 fi.set_reason(exc)
                 fi.presave()
-                fi.updated_at = now
+                fi.updated_at = Now()
             except Exception as exc:
                 self.log.exception(
                     f"Error preparing failed import update for {fi.path}"

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

@@ -1,6 +1,6 @@
 """Bulk import and move comics and folders."""
 
-from django.utils.timezone import datetime
+from django.utils import timezone
 
 from codex.librarian.importer.importer import ComicImporter
 from codex.librarian.importer.status import ImportStatusTypes
@@ -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 datetime.now()
+        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/moved.py

@@ -42,7 +42,6 @@ class MovedImporter(AggregateMetadataImporter):
         ).only("pk", "path", PARENT_FOLDER, FOLDERS_FIELD)
 
         folder_m2m_links = {}
-        now = Now()
         updated_comics = []
         for comic in comics.iterator():
             try:
@@ -52,7 +51,7 @@ class MovedImporter(AggregateMetadataImporter):
                 comic.parent_folder = Folder.objects.get(  # type: ignore
                     path=new_path.parent
                 )
-                comic.updated_at = now
+                comic.updated_at = Now()
                 comic.presave()
                 folder_m2m_links[comic.pk] = Folder.objects.filter(
                     path__in=new_path.parents
@@ -83,7 +82,6 @@ class MovedImporter(AggregateMetadataImporter):
         if status:
             status.total = covers.count()
 
-        now = Now()
         moved_covers = []
         unlink_pks = set()
         for cover in covers.iterator():
@@ -91,7 +89,7 @@ class MovedImporter(AggregateMetadataImporter):
                 new_path = self.task.covers_moved[cover.path]
                 cover.path = new_path
                 new_path = Path(new_path)
-                cover.updated_at = now
+                cover.updated_at = Now()
                 cover.presave()
                 moved_covers.append(cover)
                 unlink_pks.add(cover.pk)
@@ -186,7 +184,6 @@ class MovedImporter(AggregateMetadataImporter):
         ).order_by("path")
 
         update_folders = []
-        now = Now()
         for folder in folders_to_move.iterator():
             new_path = self.task.dirs_moved[folder.path]
             folder.name = Path(new_path).name
@@ -194,7 +191,7 @@ class MovedImporter(AggregateMetadataImporter):
             parent_path_str = str(Path(new_path).parent)
             folder.parent_folder = dest_parent_folders.get(parent_path_str)
             folder.presave()
-            folder.updated_at = now  # type: ignore
+            folder.updated_at = Now()
             update_folders.append(folder)
         self.task.dirs_moved = {}
 
@@ -220,10 +217,9 @@ class MovedImporter(AggregateMetadataImporter):
         ).only("stat", "updated_at")
         self.task.dirs_modified = frozenset()
         update_folders = []
-        now = Now()
         for folder in folders.iterator():
             if Path(folder.path).exists():
-                folder.updated_at = now
+                folder.updated_at = Now()
                 folder.presave()
                 update_folders.append(folder)
         Folder.objects.bulk_update(

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."""