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

codex/views/browser/filters/search/field/parse.py

@@ -1,6 +1,7 @@
 """Parse field boolean expressions into Django ORM Queries."""
 
 import re
+from abc import ABC, abstractmethod
 from typing import TYPE_CHECKING
 
 from django.db.models import Q
@@ -13,6 +14,7 @@ from pyparsing import (
     infix_notation,
     printables,
 )
+from typing_extensions import override
 
 from codex.models.base import MAX_NAME_LEN
 from codex.models.comic import Comic
@@ -32,14 +34,28 @@ _IMPLICIT_AND_RE = re.compile(_IMPLICIT_AND_REXP, flags=re.IGNORECASE)
 ParserElement.enablePackrat()
 
 
-class BoolOperand:
+class BoolOperandBase(ABC):
+    """Hold context."""
+
+    def __init__(self, context):
+        """Initialize context."""
+        self.context = context
+
+    @abstractmethod
+    def to_query(self) -> Q:
+        """Construct a django ORM Query."""
+        raise NotImplementedError
+
+
+class BoolOperand(BoolOperandBase):
     """Hacky Base for injecting rel."""
 
     def __init__(self, tokens, context):
         """Initialize value from first token."""
+        super().__init__(context)
         self.value = tokens[0]
-        self.context = context
 
+    @override
     def __repr__(self) -> str:
         """Represent as string."""
         return str(self.value)
@@ -59,6 +75,7 @@ class BoolOperand:
             prefixed_q_dict[prefixed_rel] = value
         return prefixed_q_dict
 
+    @override
     def to_query(self) -> Q:
         """Construct Django ORM Query from rel & value."""
         rel = self.context[0]
@@ -72,39 +89,43 @@ class BoolOperand:
         return Q(**prefixed_q_dict)
 
 
-class BoolNot(BoolOperand):
+class BoolNot(BoolOperandBase):
     """NOT Operand."""
 
     def __init__(self, tokens, context):
         """Initialize args from first token."""
+        super().__init__(context)
         self.arg = tokens[0][1]
-        self.context = context
 
+    @override
     def __repr__(self) -> str:
         """Represent as string."""
         return f"NOT {self.arg}"
 
+    @override
     def to_query(self) -> Q:
         """Negate argument query."""
         q = self.arg.to_query()
         return ~q
 
 
-class BoolBinaryOperand:
+class BoolBinaryOperand(BoolOperandBase):
     """Boolean Binary Operand."""
 
     OP: str = ""
 
     def __init__(self, tokens, context):
         """Initialize args from first two tokens."""
+        super().__init__(context)
         self.args = tokens[0][0::2]
-        self.context = context
 
+    @override
     def __repr__(self) -> str:
         """Represent as string."""
         sep = f" {self.OP} "
         return f"({sep.join(map(str, self.args))})"
 
+    @override
     def to_query(self) -> Q:
         """Construct Django ORM Query from args."""
         q = Q()
@@ -183,5 +204,5 @@ def get_field_query(rel, rel_class, exp, model, many_to_many):
     bool_expr = _create_context_expression(context)
 
     parsed_result = bool_expr.parse_string(exp)
-    root_bool_operand: BoolOperand = parsed_result[0]  # type:ignore[reportAssignmentType]
+    root_bool_operand: BoolOperandBase = parsed_result[0]  # pyright:ignore[reportAssignmentType]
     return root_bool_operand.to_query()

codex/views/browser/filters/search/fts.py

@@ -1,9 +1,8 @@
 """Search Filters Methods."""
 
-from codex.logger.logger import get_logger
-from codex.views.browser.filters.search.field.filter import BrowserFieldQueryFilter
+from loguru import logger
 
-LOG = get_logger(__name__)
+from codex.views.browser.filters.search.field.filter import BrowserFieldQueryFilter
 
 
 class BrowserFTSFilter(BrowserFieldQueryFilter):
@@ -19,6 +18,6 @@ class BrowserFTSFilter(BrowserFieldQueryFilter):
                 rel += "comicfts__match"
                 fts_filter[rel] = text
         except Exception:
-            LOG.exception("Getting Full Text Search Filter.")
+            logger.exception("Getting Full Text Search Filter.")
             self.search_error = "Error creating full text search filter"
         return fts_filter

codex/views/browser/filters/search/parse.py

@@ -4,15 +4,15 @@ import re
 from types import MappingProxyType
 
 from django.db.models.query import Q
+from loguru import logger
 
-from codex.logger.logger import get_logger
+from codex.choices.admin import AdminFlagChoices
+from codex.choices.search import FIELDMAP
 from codex.models import AdminFlag
 from codex.models.comic import ComicFTS
-from codex.settings.settings import MAX_OBJ_PER_PAGE
-from codex.views.browser.filters.search.aliases import ALIAS_FIELD_MAP
+from codex.settings import MAX_OBJ_PER_PAGE
 from codex.views.browser.filters.search.fts import BrowserFTSFilter
 
-LOG = get_logger(__name__)
 _FTS_COLUMNS = frozenset(
     {field.name for field in ComicFTS._meta.get_fields()}
     - {"comic", "updated_at", "created_at"}
@@ -20,6 +20,7 @@ _FTS_COLUMNS = frozenset(
 _NON_FTS_COLUMNS = frozenset(
     {
         "volume",
+        "volume_to",
         "created_at",
         "updated_at",
         "issue_number",
@@ -27,16 +28,13 @@ _NON_FTS_COLUMNS = frozenset(
         "year",
         "month",
         "day",
-        "community_rating",
-        "criticial_rating",
+        "critical_rating",
         "page_count",
         "monochrome",
         "date",
         "decade",
         "size",
         "path",
-        "identifier",
-        "identifier_type",
     }
 )
 _VALID_COLUMNS = frozenset(_FTS_COLUMNS | _NON_FTS_COLUMNS)
@@ -55,16 +53,15 @@ _COL_REXP = rf"({_MULTI_COL_REXP}|{_SINGLE_COL_REXP}):{_EXP_REXP}"
 _TOKEN_PRE_OP_REXP = r"(?:(?P<preop>and|or|not)\s+)?"  # noqa: S105
 _TOKEN_REXP = rf"(?P<token>{_TOKEN_PRE_OP_REXP}{_COL_REXP}|\S+)"
 _TOKEN_RE = re.compile(_TOKEN_REXP, flags=re.IGNORECASE)
+_ALIAS_FIELD_MAP = MappingProxyType(
+    {value: key for key, values in FIELDMAP.items() for value in values}
+)
 
 
 class SearchFilterView(BrowserFTSFilter):
     """Search Query Parser."""
 
-    ADMIN_FLAG_VALUE_KEY_MAP = MappingProxyType(
-        {
-            AdminFlag.FlagChoices.FOLDER_VIEW.value: "folder_view",
-        }
-    )
+    ADMIN_FLAGS: tuple[AdminFlagChoices, ...] = (AdminFlagChoices.FOLDER_VIEW,)
 
     def __init__(self, *args, **kwargs):
         """Initialize search variables."""
@@ -78,15 +75,15 @@ class SearchFilterView(BrowserFTSFilter):
     def admin_flags(self) -> MappingProxyType[str, bool]:
         """Set browser relevant admin flags."""
         if self._admin_flags is None:
-            if self.ADMIN_FLAG_VALUE_KEY_MAP:
+            if self.ADMIN_FLAGS:
                 admin_pairs = AdminFlag.objects.filter(
-                    key__in=self.ADMIN_FLAG_VALUE_KEY_MAP.keys()
+                    key__in=(enum.value for enum in self.ADMIN_FLAGS)
                 ).values_list("key", "on")
             else:
                 admin_pairs = ()
             admin_flags = {}
             for key, on in admin_pairs:
-                export_key = self.ADMIN_FLAG_VALUE_KEY_MAP[key]
+                export_key = AdminFlagChoices(key).name.lower()
                 admin_flags[export_key] = on
             self._admin_flags = MappingProxyType(admin_flags)
         return self._admin_flags
@@ -104,7 +101,7 @@ class SearchFilterView(BrowserFTSFilter):
         return False
 
     def _parse_column_match(self, preop, col, exp, field_tokens):  # , fts_tokens):
-        col = ALIAS_FIELD_MAP.get(col, col)
+        col = _ALIAS_FIELD_MAP.get(col.lower(), col)
         if col not in _VALID_COLUMNS:
             return True
         if col == "path" and not self._is_path_column_allowed():
@@ -114,20 +111,24 @@ class SearchFilterView(BrowserFTSFilter):
                 preop = "and"
             if preop not in field_tokens:
                 field_tokens[preop] = set()
-            field_tokens[preop].add((col, exp))
+            field_token = (col, exp)
+            field_tokens[preop].add(field_token)
             return True
-
         return False
 
     @staticmethod
     def _add_fts_token(fts_tokens, token):
         token = _FTS_OPERATOR_RE.sub(lambda op: op.group("operator").upper(), token)
-        if (
-            token.lower() not in _FTS_OPERATORS
-            and not (token.startswith('"') and token.endswith('"'))
-            and ":" not in token
+
+        if ":" in token:
+            col, value = token.split(":")
+            col = _ALIAS_FIELD_MAP.get(col.lower(), col)
+            token = f"{col}:{value}"
+        elif token.lower() not in _FTS_OPERATORS and not (
+            token.startswith('"') and token.endswith('"')
         ):
             token = f'"{token}"'
+
         fts_tokens.append(token)
 
     def _preparse_search_query_token(self, match, field_tokens, fts_tokens):
@@ -160,10 +161,9 @@ class SearchFilterView(BrowserFTSFilter):
                 self._preparse_search_query_token(match, field_tokens, fts_tokens)
             except Exception as exc:
                 tok = match.group(0) if match else "<unmatched>"
-                LOG.debug(f"Error preparsing search query token {tok}: {exc}")
+                logger.debug(f"Error preparsing search query token {tok}: {exc}")
                 self.search_error = "Syntax error"
         text = " ".join(fts_tokens)
-
         return field_tokens, text
 
     def _create_search_filters(self, model):
@@ -221,7 +221,7 @@ class SearchFilterView(BrowserFTSFilter):
 
         except Exception as exc:
             msg = "Creating search filters"
-            LOG.exception(msg)
+            logger.exception(msg)
             msg = f"{msg} - {exc}"
             self.search_error = msg
 

codex/views/browser/group_mtime.py

@@ -1,18 +1,20 @@
 """Group Mtime Function."""
 
-from logging import DEBUG, WARNING
+from typing import TYPE_CHECKING
 
 from django.db.models.aggregates import Aggregate, Max
 from django.db.models.functions import Greatest
 from django.db.utils import OperationalError
+from loguru import logger
 
-from codex.logger.logger import get_logger
 from codex.models.functions import JsonGroupArray
 from codex.views.browser.filters.filter import BrowserFilterView
 from codex.views.const import EPOCH_START, EPOCH_START_DATETIMEFIELD, NONE_DATETIMEFIELD
 
+if TYPE_CHECKING:
+    from django.db.models import Q, Value
+
 _FTS5_PREFIX = "fts5: "
-LOG = get_logger(__name__)
 
 
 class BrowserGroupMtimeView(BrowserFilterView):
@@ -35,12 +37,13 @@ class BrowserGroupMtimeView(BrowserFilterView):
     def _handle_operational_error(self, err):
         msg = err.args[0] if err.args else ""
         if msg.startswith(_FTS5_PREFIX):
-            level = DEBUG
+            level = "DEBUG"
             self.search_error = msg.removeprefix(_FTS5_PREFIX)
         else:
-            level = WARNING
+            level = "WARNING"
             msg = str(err)
-        LOG.log(level, f"Query Error: {msg}")
+        logger.log(level, f"Query Error: {msg}")
+        # logger.exception(f"Query Error: {msg}") debug
 
     def get_max_bookmark_updated_at_aggregate(
         self, model, agg_func: type[Aggregate] = Max, default=NONE_DATETIMEFIELD
@@ -49,12 +52,12 @@ class BrowserGroupMtimeView(BrowserFilterView):
         bm_rel = self.get_bm_rel(model)
         bm_filter = self.get_my_bookmark_filter(bm_rel)
         bmua_rel = f"{bm_rel}__updated_at"
-        args = {"default": default, "filter": bm_filter}
+        kwargs: dict[str, bool | Value | Q] = {"default": default, "filter": bm_filter}
         if agg_func is JsonGroupArray:
-            args["distinct"] = True
-        return agg_func(bmua_rel, **args)
+            kwargs["distinct"] = True
+        return agg_func(bmua_rel, **kwargs)  # pyright: ignore[reportArgumentType]
 
-    def get_group_mtime(self, model, group=None, pks=None, page_mtime=False):  # noqa: FBT002
+    def get_group_mtime(self, model, group=None, pks=None, *, page_mtime=False):
         """Get a filtered mtime for browser pages and mtime checker."""
         qs = self.get_filtered_queryset(
             model,

codex/views/browser/metadata/__init__.py

@@ -1 +1,90 @@
-"""Metadata View."""
+"""Aggregate Group and Comic Metadata View."""
+
+from django.db.models import QuerySet
+from drf_spectacular.utils import extend_schema
+from loguru import logger
+from rest_framework.exceptions import NotFound
+from rest_framework.response import Response
+from rest_framework.serializers import BaseSerializer
+from typing_extensions import override
+
+from codex.choices.admin import AdminFlagChoices
+from codex.serializers.browser.metadata import MetadataSerializer
+from codex.serializers.browser.settings import BrowserFilterChoicesInputSerializer
+from codex.views.browser.metadata.copy_intersections import (
+    MetadataCopyIntersectionsView,
+)
+
+
+class MetadataView(MetadataCopyIntersectionsView):
+    """Aggregate Group and Comic Metadata View."""
+
+    serializer_class: type[BaseSerializer] | None = MetadataSerializer
+    input_serializer_class: type[BrowserFilterChoicesInputSerializer] = (  # pyright: ignore[reportIncompatibleVariableOverride]
+        BrowserFilterChoicesInputSerializer
+    )
+    TARGET: str = "metadata"
+    ADMIN_FLAGS = (AdminFlagChoices.FOLDER_VIEW,)
+
+    @override
+    def _get_valid_browse_nav_groups(self, valid_top_groups):
+        """Limited allowed nav groups for metadata."""
+        # Overrides method in browser.validate
+        group = self.kwargs["group"]
+        return (group,)
+
+    def _raise_not_found(self, exc=None):
+        """Raise an exception if the object is not found."""
+        pks = self.kwargs["pks"]
+        group = self.kwargs["group"]
+        detail = f"Filtered metadata for {group}/{pks} not found"
+        raise NotFound(detail=detail) from exc
+
+    def _get_first_object(self, qs: QuerySet):
+        obj = qs[0]
+        if not obj:
+            reason = "Empty obj"
+            raise ValueError(reason)
+        return obj
+
+    @override
+    def get_object(self):
+        """Create a comic-like object from the current browser group."""
+        # Comic model goes through the same code path as groups because
+        # values dicts don't copy relations to the serializer. The values
+        # dict is necessary because of the folders view union in browser.py.
+
+        qs = self.get_filtered_queryset(self.model)
+        filtered_qs = qs
+
+        # Annotate
+        qs = self.annotate_order_aggregates(qs)
+        qs = self.annotate_card_aggregates(qs)
+        qs = self.annotate_values_and_fks(qs, filtered_qs)
+        qs = self.add_group_by(qs)
+        qs = self.force_inner_joins(qs)
+
+        # Get Object
+        try:
+            obj = self._get_first_object(qs)
+        except (IndexError, ValueError) as exc:
+            return self._raise_not_found(exc)
+
+        # Hacks to add to object after query
+        groups, fk_intersections, m2m_intersections = self.query_intersections(
+            filtered_qs
+        )
+        return self.copy_intersections_into_comic_fields(
+            obj, groups, fk_intersections, m2m_intersections
+        )
+
+    @extend_schema(parameters=[input_serializer_class])
+    def get(self, *_args, **_kwargs):
+        """Get metadata for a filtered browse group."""
+        # Init
+        try:
+            obj = self.get_object()
+            serializer = self.get_serializer(obj)
+            return Response(serializer.data)
+        except Exception:
+            logger.exception(f"Getting metadata {self.kwargs}")

codex/views/browser/metadata/annotate.py

@@ -4,29 +4,15 @@ from django.db.models import Count, IntegerField, Sum, Value
 
 from codex.models import Comic
 from codex.views.browser.annotate.card import BrowserAnnotateCardView
-
-COMIC_VALUE_FIELDS_CONFLICTING = frozenset(
-    {
-        "created_at",
-        "name",
-        "path",
-        "updated_at",
-    }
-)
-COMIC_VALUE_FIELDS_CONFLICTING_PREFIX = "conflict_"
-PATH_GROUPS = frozenset({"c", "f"})
-_ADMIN_OR_FILE_VIEW_ENABLED_COMIC_VALUE_FIELDS = frozenset({"path"})
-_DISABLED_VALUE_FIELD_NAMES = frozenset(
-    {"id", "pk", "sort_name", "stat"} | COMIC_VALUE_FIELDS_CONFLICTING
-)
-_COMIC_VALUE_FIELD_NAMES = frozenset(
-    # contains path
-    field.name
-    for field in Comic._meta.get_fields()
-    if not field.is_relation and field.name not in _DISABLED_VALUE_FIELD_NAMES
+from codex.views.browser.metadata.const import (
+    ADMIN_OR_FILE_VIEW_ENABLED_COMIC_VALUE_FIELDS,
+    COMIC_RELATED_VALUE_FIELDS,
+    COMIC_VALUE_FIELD_NAMES,
+    COMIC_VALUE_FIELDS_CONFLICTING,
+    COMIC_VALUE_FIELDS_CONFLICTING_PREFIX,
+    PATH_GROUPS,
+    SUM_FIELDS,
 )
-_COMIC_RELATED_VALUE_FIELDS = frozenset({"series__volume_count", "volume__issue_count"})
-_SUM_FIELDS = frozenset({"page_count", "size"})
 
 
 class MetadataAnnotateView(BrowserAnnotateCardView):
@@ -34,13 +20,13 @@ class MetadataAnnotateView(BrowserAnnotateCardView):
 
     def _get_comic_value_fields(self):
         """Include the path field for staff."""
-        fields = set(_COMIC_VALUE_FIELD_NAMES)
+        fields = set(COMIC_VALUE_FIELD_NAMES)
         group = self.kwargs["group"]
         if (
             not (self.is_admin and self.admin_flags["folder_view"])
             or group not in PATH_GROUPS
         ):
-            fields -= _ADMIN_OR_FILE_VIEW_ENABLED_COMIC_VALUE_FIELDS
+            fields -= ADMIN_OR_FILE_VIEW_ENABLED_COMIC_VALUE_FIELDS
         return tuple(fields)
 
     def _intersection_annotate(
@@ -60,7 +46,7 @@ class MetadataAnnotateView(BrowserAnnotateCardView):
 
             full_field = self.rel_prefix + field
 
-            if field in _SUM_FIELDS:
+            if field in SUM_FIELDS:
                 val = Sum(full_field)
             else:
                 # group_by makes the filter work, but prevents its
@@ -79,7 +65,7 @@ class MetadataAnnotateView(BrowserAnnotateCardView):
                 if field.endswith("count"):
                     output_field = IntegerField()
                 else:
-                    output_field = Comic._meta.get_field(field).__class__()
+                    output_field = Comic._meta.get_field(field)
                 val = Value(val, output_field)
             qs = qs.annotate(**{ann_field: val})
 
@@ -103,6 +89,6 @@ class MetadataAnnotateView(BrowserAnnotateCardView):
         # Foreign Keys with special count values
         _, qs = self._intersection_annotate(
             querysets,
-            _COMIC_RELATED_VALUE_FIELDS,
+            COMIC_RELATED_VALUE_FIELDS,
         )
         return qs

codex/views/browser/metadata/const.py

@@ -0,0 +1,83 @@
+"""Metadata view consts."""
+
+from types import MappingProxyType
+
+from codex.models import Comic
+from codex.models.groups import Folder, Imprint, Publisher, Series, Volume
+from codex.models.identifier import Identifier
+from codex.models.named import Credit, SeriesGroup, StoryArcNumber, Universe
+
+############
+# Annotate #
+############
+COMIC_VALUE_FIELDS_CONFLICTING = frozenset(
+    {
+        "created_at",
+        "name",
+        "path",
+        "updated_at",
+    }
+)
+COMIC_VALUE_FIELDS_CONFLICTING_PREFIX = "conflict_"
+PATH_GROUPS = frozenset({"c", "f"})
+ADMIN_OR_FILE_VIEW_ENABLED_COMIC_VALUE_FIELDS = frozenset({"path"})
+_DISABLED_VALUE_FIELD_NAMES = frozenset(
+    {"id", "pk", "sort_name", "stat"} | COMIC_VALUE_FIELDS_CONFLICTING
+)
+COMIC_VALUE_FIELD_NAMES = frozenset(
+    # contains path
+    field.name
+    for field in Comic._meta.get_fields()
+    if not field.is_relation and field.name not in _DISABLED_VALUE_FIELD_NAMES
+)
+COMIC_RELATED_VALUE_FIELDS = frozenset({"series__volume_count", "volume__issue_count"})
+SUM_FIELDS = frozenset({"page_count", "size"})
+
+#########
+# Query #
+#########
+_CREDIT_ONLY = ("role", "person")
+_CREDIT_PREFETCH = (*_CREDIT_ONLY, "role__identifier", "person__identifier")
+GROUP_MODELS = MappingProxyType(
+    {
+        "i": (Publisher,),
+        "s": (Publisher, Imprint),
+        "v": (Publisher, Imprint, Series),
+        "c": (Publisher, Imprint, Series, Volume),
+        "f": (Publisher, Imprint, Series, Volume),
+        "a": (Publisher, Imprint, Series, Volume),
+    }
+)
+M2M_QUERY_OPTIMIZERS = MappingProxyType(
+    {
+        Credit: {
+            "prefetch": _CREDIT_PREFETCH,
+            "select": (),
+            "only": _CREDIT_ONLY,
+        },
+        StoryArcNumber: {
+            "prefetch": ("story_arc", "story_arc__identifier"),
+            "select": (),
+            "only": ("story_arc", "number"),
+        },
+        Identifier: {
+            "select": ("source",),
+            "only": ("source", "key", "url"),
+        },
+        Universe: {"only": ("name", "designation", "identifier")},
+        SeriesGroup: {
+            "select": (),
+            "only": ("name",),
+        },
+        Folder: {
+            "select": (),
+            "only": ("path",),
+        },
+    }
+)
+COMIC_MAIN_FIELD_NAME_BACK_REL_MAP = MappingProxyType(
+    {
+        "main_character": "main_character_in_comics",
+        "main_team": "main_team_in_comics",
+    }
+)

codex/views/browser/metadata/copy_intersections.py

@@ -2,7 +2,7 @@
 
 from codex.models.comic import Comic
 from codex.serializers.browser.metadata import PREFETCH_PREFIX
-from codex.views.browser.metadata.annotate import (
+from codex.views.browser.metadata.const import (
     COMIC_VALUE_FIELDS_CONFLICTING,
     COMIC_VALUE_FIELDS_CONFLICTING_PREFIX,
     PATH_GROUPS,
@@ -11,6 +11,8 @@ from codex.views.browser.metadata.query_intersections import (
     MetadataQueryIntersectionsView,
 )
 
+_PREFETCH_DICT_FIELDS = frozenset({"identifiers", "credits", "story_arc_numbers"})
+
 
 class MetadataCopyIntersectionsView(MetadataQueryIntersectionsView):
     """Copy Intersections Into Comic Fields."""
@@ -42,17 +44,12 @@ class MetadataCopyIntersectionsView(MetadataQueryIntersectionsView):
         # It might even be faster to copy everything to a dict and not use the obj.
         for key, qs in m2m_intersections.items():
             serializer_key = (
-                f"{PREFETCH_PREFIX}{key}"
-                if key in ("identifiers", "contributors", "story_arc_numbers")
-                else key
+                f"{PREFETCH_PREFIX}{key}" if key in _PREFETCH_DICT_FIELDS else key
             )
             if hasattr(obj, serializer_key):
                 # real db fields need to use their special set method.
                 field = getattr(obj, serializer_key)
-                field.set(
-                    qs,
-                    clear=True,
-                )
+                field.set(qs, clear=True)
             else:
                 # fake db field is just a queryset attached.
                 setattr(obj, serializer_key, qs)
@@ -62,6 +59,11 @@ class MetadataCopyIntersectionsView(MetadataQueryIntersectionsView):
         for field, group_qs in groups.items():
             setattr(obj, field + "_list", group_qs)
 
+    @staticmethod
+    def _copy_fks(obj, fks):
+        for field, fk_qs in fks.items():
+            setattr(obj, field, fk_qs.first())
+
     @staticmethod
     def _copy_conflicting_simple_fields(obj):
         for field in COMIC_VALUE_FIELDS_CONFLICTING:
@@ -70,11 +72,14 @@ class MetadataCopyIntersectionsView(MetadataQueryIntersectionsView):
             val = getattr(obj, conflict_field, None)
             setattr(obj, field, val)
 
-    def copy_intersections_into_comic_fields(self, obj, groups, m2m_intersections):
+    def copy_intersections_into_comic_fields(
+        self, obj, groups, fk_intersections, m2m_intersections
+    ):
         """Copy a bunch of values that i couldn't fit cleanly in the main queryset."""
         self._path_security(obj)
         self._highlight_current_group(obj)
         self._copy_groups(obj, groups)
+        self._copy_fks(obj, fk_intersections)
         self._copy_m2m_intersections(obj, m2m_intersections)
         if self.model is not Comic:
             self._copy_conflicting_simple_fields(obj)