codex 1.5.19__py3-none-any.whl → 1.6.0a0__py3-none-any.whl

codex/views/browser/browser_annotations.py

@@ -1,91 +1,137 @@
 """Base view for metadata annotations."""
 
-from os.path import sep
+from os import sep
+from types import MappingProxyType
 
 from django.db.models import (
+    Avg,
     BooleanField,
     Case,
-    CharField,
-    Count,
     DateTimeField,
     F,
     FilteredRelation,
     Max,
     Min,
-    OuterRef,
     Q,
-    Subquery,
     Sum,
     Value,
     When,
 )
-from django.db.models.fields import PositiveSmallIntegerField
-from django.db.models.functions import Least, Lower, Reverse, Right, StrIndex, Substr
+from django.db.models.fields import CharField, PositiveSmallIntegerField
+from django.db.models.functions import Least, Reverse, Right, StrIndex
 
-from codex.models import Comic
-from codex.views.browser.browser_order_by import BrowserOrderByView
+from codex.models import BrowserGroupModel, Comic, Folder, StoryArc, Volume
+from codex.models.functions import JsonGroupArray
+from codex.views.browser.browser_order_by import (
+    BrowserOrderByView,
+)
+from codex.views.mixins import SharedAnnotationsMixin
 
 
-class BrowserAnnotationsView(BrowserOrderByView):
+class BrowserAnnotationsView(BrowserOrderByView, SharedAnnotationsMixin):
     """Base class for views that need special metadata annotations."""
 
-    _ONE_INTEGERFIELD = Value(1, PositiveSmallIntegerField())
     _NONE_INTEGERFIELD = Value(None, PositiveSmallIntegerField())
     _NONE_DATETIMEFIELD = Value(None, DateTimeField())
-    _ARTICLES = frozenset(
-        ("a", "an", "the")  # en    # noqa RUF005
-        + ("un", "unos", "unas", "el", "los", "la", "las")  # es
-        + ("un", "une", "le", "les", "la", "les", "l'")  # fr
-        + ("o", "a", "os")  # pt
-        # pt "as" conflicts with English
-        + ("der", "dem", "des", "das")  # de
-        # de: "den & die conflict with English
-        + ("il", "lo", "gli", "la", "le", "l'")  # it
-        # it: "i" conflicts with English
-        + ("de", "het", "een")  # nl
-        + ("en", "ett")  # sw
-        + ("en", "ei", "et")  # no
-        + ("en", "et")  # da
-        + ("el", "la", "els", "les", "un", "una", "uns", "unes", "na")  # ct
+    _ORDER_AGGREGATE_FUNCS = MappingProxyType(
+        # These are annotated to order_value becauase they're simple relations
+        {
+            "age_rating": Avg,
+            "community_rating": Avg,
+            "created_at": Min,
+            "critical_rating": Avg,
+            "date": Min,
+            "page_count": Sum,
+            "size": Sum,
+            "updated_at": Min,
+        }
+    )
+    _ANNOTATED_ORDER_FIELDS = frozenset(
+        # These are annotated with their own functions
+        {
+            "filename",
+            "sort_name",
+            "search_score",
+            "bookmark_updated_at",
+            "story_arc_number",
+        }
+    )
+    _ALTERNATE_GROUP_BY: MappingProxyType[type[BrowserGroupModel], str] = (
+        MappingProxyType({Comic: "id", Volume: "name"})
     )
 
-    is_opds_1_acquisition = False
-
-    def _annotate_search_score(self, queryset, search_scores, model):
-        """Annotate the search score for ordering by search score.
+    def __init__(self, *args, **kwargs):
+        """Set params for the type checker."""
+        super().__init__(*args, **kwargs)
+        self.is_opds_1_acquisition = False
+        self.comic_sort_names = ()
+        self.bm_annotataion_data: dict[BrowserGroupModel, tuple[str, dict]] = {}
+
+    def get_group_by(self, model=None):
+        """Get the group by for the model."""
+        if model is None:
+            model = self.model
+        return self._ALTERNATE_GROUP_BY.get(model, "sort_name")  # type: ignore
+
+    def _alias_sort_names(self, qs, model):
+        """Annotate sort_name."""
+        if self.order_key != "sort_name" and not (
+            model == StoryArc and self.order_key == "story_arc_number"
+        ):
+            return qs
+        pks = self.kwargs.get("pks")
+        model_group = self.model_group  # type: ignore
+        show = MappingProxyType(self.params["show"])  # type: ignore
+        qs, self.comic_sort_names = self.alias_sort_names(
+            qs, model, pks, model_group, show
+        )
+        return qs
 
-        Choose the maximum matching score for the group.
-        """
-        if self.order_key != "search_score":
-            return queryset
-        if search_scores:
-            whens = []
-            prefix = "" if model == Comic else self.rel_prefix
-            for pk, score in search_scores.items():
-                when = {prefix + "pk": pk, "then": score}
-                whens.append(When(**when))
-            search_score = Max(Case(*whens, default=0.0))
+    def _alias_filename(self, qs, model):
+        """Calculate filename from path in the db."""
+        if self.order_key != "filename":
+            return qs
+        if model == Folder:
+            filename = F("name")
         else:
-            search_score = Value(0.0)
+            prefix = "" if model == Comic else self.rel_prefix
+            path_rel = prefix + "path"
+            filename = self.order_agg_func(
+                Right(
+                    path_rel,
+                    StrIndex(Reverse(F(path_rel)), Value(sep)) - 1,  # type: ignore
+                    output_field=CharField(),
+                )
+            )
+        return qs.alias(filename=filename)
 
-        return queryset.annotate(search_score=search_score)
+    def _alias_story_arc_number(self, qs):
+        if self.order_key != "story_arc_number":
+            return qs
 
-    def _annotate_cover_pk(self, qs, model):
-        """Annotate the query set for the coverpath for the sort."""
-        # Select comics for the children by an outer ref for annotation
-        # Order the descendant comics by the sort argumentst
-        if model == Comic:
-            cover_pk = F("pk")
+        # Get story_arc__pk
+        group = self.kwargs["group"]
+        pks = self.kwargs["pks"]
+        if group == self.STORY_ARC_GROUP and pks:
+            story_arc_pks = pks
         else:
-            # I wish I could figure out how to get a cover for each group
-            # without a subquery.
-            cover_qs = qs.filter(pk=OuterRef("pk"))
-            cover_qs = self.add_order_by(cover_qs, model, True)
-            cover_qs = cover_qs.values(self.rel_prefix + "pk")
-            cover_qs = cover_qs[:1]
-            cover_pk = Subquery(cover_qs)
+            story_arc_pks = self.params.get("filters", {}).get(  # type: ignore
+                "story_arcs", ()
+            )
 
-        return qs.annotate(cover_pk=cover_pk)
+        # If we have one annotate it.
+        if story_arc_pks:
+            san_rel = self.rel_prefix + "story_arc_numbers"
+            rel = f"{san_rel}"
+            condition = Q(**{f"{san_rel}__story_arc__in": story_arc_pks})
+            qs = qs.alias(
+                selected_story_arc_number=FilteredRelation(rel, condition=condition),
+            )
+            story_arc_number = self.order_agg_func("selected_story_arc_number__number")
+        else:
+            story_arc_number = self._NONE_INTEGERFIELD
+
+        return qs.alias(story_arc_number=story_arc_number)
 
     def _annotate_page_count(self, qs, model):
         """Hoist up total page_count of children."""
@@ -93,126 +139,91 @@ class BrowserAnnotationsView(BrowserOrderByView):
         if model == Comic:
             return qs
 
-        page_count_sum = Sum(self.rel_prefix + "page_count", distinct=True)
-        return qs.annotate(page_count=page_count_sum)
-
-    def _annotate_child_count(self, qs, model):
-        """Annotate Child Count."""
-        if model == Comic:
-            child_count_sum = self._ONE_INTEGERFIELD
+        rel = self.rel_prefix + "page_count"
+        page_count_sum = Sum(rel, distinct=True)
+        if self.TARGET == "browser":
+            qs = qs.alias(page_count=page_count_sum)
         else:
-            child_count_sum = Count(self.rel_prefix + "pk", distinct=True)
-        qs = qs.annotate(child_count=child_count_sum)
-        if model != Comic:
-            # XXX Extra filter for empty groups
-            qs = qs.filter(child_count__gt=0)
+            qs = qs.annotate(page_count=page_count_sum)
         return qs
 
     def _annotate_bookmark_updated_at(self, qs, model):
-        """Annotate bookmark_updated_at."""
-        bm_rel = self.get_bm_rel(model)
-        bm_filter = self._get_my_bookmark_filter(bm_rel)
-
         if self.is_opds_1_acquisition or self.order_key == "bookmark_updated_at":
+            bm_rel = self.get_bm_rel(model)
+            bm_filter = self._get_my_bookmark_filter(bm_rel)
+            self.bm_annotation_data[model] = bm_rel, bm_filter  # type: ignore
+
             updated_at_rel = f"{bm_rel}__updated_at"
-            bookmark_updated_at_aggregate = Min(
+            bookmark_updated_at_aggregate = self.order_agg_func(
                 updated_at_rel,
                 default=self._NONE_DATETIMEFIELD,
                 filter=bm_filter,
             )
-            qs = qs.annotate(bookmark_updated_at=bookmark_updated_at_aggregate)
-
-        bm_annotation_data = bm_rel, bm_filter
-        return qs, bm_annotation_data
-
-    def _annotate_sort_name(self, queryset, model):
-        """Sort groups by name ignoring articles."""
-        # TODO move this into the database on import.
-        if self.order_key != "sort_name":
-            return queryset
-
-        if self.kwargs.get("group") == self.FOLDER_GROUP and model == Comic:
-            # File View Filename
-            return queryset.annotate(
-                sort_name=Right(
-                    "path",
-                    StrIndex(Reverse(F("path")), Value(sep)) - 1,  # type: ignore
-                    output_field=CharField(),
-                )
-            )
-
-        ##################################################
-        # Otherwise Remove articles from the browse name #
-        ##################################################
-
-        # first_space_index
-        first_field = model.ORDERING[0]
-        queryset = queryset.annotate(
-            first_space_index=StrIndex(first_field, Value(" "))
-        )
-
-        # lowercase_first_word
-        lowercase_first_word = Lower(
-            Substr(first_field, 1, length=(F("first_space_index") - 1))  # type: ignore
-        )
-        queryset = queryset.annotate(
-            lowercase_first_word=Case(
-                When(Q(first_space_index__gt=0), then=lowercase_first_word)
-            ),
-            default=Value(""),
-        )
-
-        # sort_name
-        return queryset.annotate(
-            sort_name=Case(
-                When(
-                    lowercase_first_word__in=self._ARTICLES,
-                    then=Substr(
-                        first_field,
-                        F("first_space_index") + 1,  # type: ignore
-                    ),
-                ),
-                default=first_field,
-            )
-        )
-
-    def _annotate_story_arc_number(self, qs):
-        if self.order_key != "story_arc_number":
-            return qs
+            if self.TARGET == "opds1":
+                qs = qs.annotate(bookmark_updated_at=bookmark_updated_at_aggregate)
+            else:
+                qs = qs.alias(bookmark_updated_at=bookmark_updated_at_aggregate)
+        return qs
 
-        # Get story_arc__pk
-        group = self.kwargs["group"]
-        pk = self.kwargs["pk"]
-        if group == self.STORY_ARC_GROUP and pk:
-            story_arc_pk = pk
-        elif story_arc_pks := self.params.get("filters", {}).get(  # type: ignore
-            "story_arcs", []
-        ):
-            story_arc_pk = story_arc_pks[0]
+    def _annotate_order_value(self, qs, model):
+        """Annotate a main key for sorting and browser card display."""
+        # Determine order func
+        if model == Folder and self.order_key == "filename":
+            order_value = F("name")
+        elif model == Comic or self.order_key in self._ANNOTATED_ORDER_FIELDS:
+            # These are annotated in browser_annotaions
+            order_value = F(self.order_key)
         else:
-            story_arc_pk = None
+            agg_func = self._ORDER_AGGREGATE_FUNCS[self.order_key]
+            agg_func = self.order_agg_func if agg_func == Min else agg_func
+            field = self.rel_prefix + self.order_key
+            order_value = agg_func(field)
 
-        # If we have one annotate it.
-        if story_arc_pk:
-            san_rel = self.rel_prefix + "story_arc_numbers"
-            rel = f"{san_rel}"
-            condition = Q(**{f"{san_rel}__story_arc": story_arc_pk})
-            qs = qs.annotate(
-                selected_story_arc_number=FilteredRelation(rel, condition=condition),
-                story_arc_number=F("selected_story_arc_number__number"),
-            )
+        if self.TARGET == "browser":
+            qs = qs.annotate(order_value=order_value)
         else:
-            qs = qs.annotate(story_arc_number=self._NONE_INTEGERFIELD)
+            qs = qs.alias(order_value=order_value)
         return qs
 
-    def _annotate_order_value(self, qs, model):
-        """Annotate a main key for sorting."""
-        order_func = self.get_order_value(model)
-        return qs.annotate(order_value=order_func)
+    def annotate_order_aggregates(self, qs, model):
+        """Annotate common aggregates between browser and metadata."""
+        # ids coming first or before cover_qs works.
+        qs = qs.annotate(ids=JsonGroupArray("id", distinct=True))
+        qs = self._alias_sort_names(qs, model)
+        qs = self._alias_filename(qs, model)
+        qs = self._alias_story_arc_number(qs)
+        qs = self._annotate_page_count(qs, model)
+        qs = self._annotate_bookmark_updated_at(qs, model)
+        if model != Comic:
+            # comic orders on indexed fields when it can
+            qs = self._annotate_order_value(qs, model)
+        return qs
 
-    def _annotate_bookmarks(self, qs, model, bm_annotation_data):
+    def _annotate_cover_pk(self, qs, model):
+        """Annotate the query set for the coverpath for the sort."""
+        # Select comics for the children by an outer ref for annotation
+        # Order the descendant comics by the sort argumentst
+        if model == Comic:
+            qs = qs.annotate(cover_pk=F("pk"))
+            qs = qs.annotate(cover_mtime=F("updated_at"))
+        elif self.admin_flags["dynamic_group_covers"]:
+            # At this point it's only been filtered.
+            qs = qs.annotate(cover_pk=F(self.rel_prefix + "pk"))
+            qs = qs.annotate(cover_pks=JsonGroupArray("cover_pk", distinct=True))
+        return qs
+
+    def _annotate_group(self, qs, model):
+        """Annotate Group."""
+        value = "c" if model == Comic else self.model_group  # type: ignore
+        return qs.annotate(group=Value(value, CharField(max_length=1)))
+
+    def _annotate_bookmarks(self, qs, model):
         """Hoist up bookmark annotations."""
-        bm_rel, bm_filter = bm_annotation_data
+        if model in self.bm_annotation_data:  # type: ignore
+            bm_rel, bm_filter = self.bm_annotation_data[model]  # type: ignore
+        else:
+            bm_rel = self.get_bm_rel(model)
+            bm_filter = self._get_my_bookmark_filter(bm_rel)
 
         page_rel = f"{bm_rel}__page"
         finished_rel = f"{bm_rel}__finished"
@@ -253,46 +264,84 @@ class BrowserAnnotationsView(BrowserOrderByView):
                 output_field=PositiveSmallIntegerField(),
                 distinct=True,
             )
-            qs = qs.annotate(finished_count=finished_count)
+            qs = qs.alias(finished_count=finished_count)
             finished_aggregate = Case(
-                When(
-                    Q(finished_count=F("child_count")) | Q(page=F("page_count")),
-                    then=True,
-                ),
-                When(page=0, then=False),
+                When(finished_count=F("child_count"), then=True),
+                When(finished_count=0, then=False),
                 default=None,
                 output_field=BooleanField(),
             )
 
-        qs = qs.annotate(page=bookmark_page)
-        return qs.annotate(finished=finished_aggregate)
+        if self.is_opds_1_acquisition:
+            qs = qs.annotate(page=bookmark_page)
+        else:
+            qs = qs.alias(page=bookmark_page)
+
+        if self.TARGET in frozenset({"metadata", "browser"}):
+            qs.annotate(finished=finished_aggregate)
+        else:
+            # Only used for progress
+            qs.alias(finished=finished_aggregate)
+        return qs
 
-    @staticmethod
-    def _annotate_progress(queryset):
-        """Compute progress for each member of a queryset."""
+    def _annotate_progress(self, qs):
+        """Compute progress for each member of a qs."""
+        if self.TARGET not in frozenset({"metadata", "browser"}):
+            return qs
         # Requires bookmark and annotation hoisted from bookmarks.
         # Requires page_count native to comic or aggregated
         # Least guard is for rare instances when bookmarks are set to
         # invalid high values
         then = Least(F("page") * 100.0 / F("page_count"), Value(100.0))
         progress = Case(When(page_count__gt=0, then=then), default=0.0)
-        return queryset.annotate(progress=progress)
-
-    @staticmethod
-    def _annotate_mtime(queryset):
-        return queryset.annotate(mtime=Max("updated_at"))
+        return qs.annotate(progress=progress)
 
-    def annotate_common_aggregates(self, qs, model, search_scores):
-        """Annotate common aggregates between browser and metadata."""
-        qs = self._annotate_search_score(qs, search_scores, model)
-        qs = self._annotate_child_count(qs, model)
-        qs = self._annotate_page_count(qs, model)
-        qs, bm_annotation_data = self._annotate_bookmark_updated_at(qs, model)
-        qs = self._annotate_sort_name(qs, model)
-        qs = self._annotate_story_arc_number(qs)
-        # cover annotation depends on order_value, in metadata too.
-        qs = self._annotate_order_value(qs, model)
+    def annotate_card_aggregates(self, qs, model):
+        """Annotate aggregates that appear the browser card."""
         qs = self._annotate_cover_pk(qs, model)
-        qs = self._annotate_bookmarks(qs, model, bm_annotation_data)
-        qs = self._annotate_mtime(qs)
+        if model == Comic:
+            # comic adds order_value for cards late
+            qs = self._annotate_order_value(qs, model)
+        qs = self._annotate_group(qs, model)
+        qs = self.annotate_group_names(qs, model)
+        qs = self._annotate_bookmarks(qs, model)
         return self._annotate_progress(qs)
+
+    def annotate_for_metadata(self, qs, _model):
+        """Annotations only for metadata."""
+        return qs.annotate(mtime=Max("updated_at"))
+
+    def _get_cover_pk_query(self, cover_pks):
+        """Get Cover Pk queryset for comic queryset."""
+        comic_qs = Comic.objects.filter(pk__in=cover_pks)
+        comic_qs = self.annotate_search_score(
+            comic_qs, Comic, self.cover_search_score_pairs
+        )
+        comic_qs = self.annotate_order_aggregates(comic_qs, Comic)
+        comic_qs = self.add_order_by(comic_qs, Comic)  # type: ignore
+        comic_qs = comic_qs.group_by("id")
+        return comic_qs.only("pk", "updated_at")
+
+    def re_cover_multi_groups(self, group_qs):
+        """Python hack to re-cover groups collapsed with group_by."""
+        # This would be better in the main query but OuterRef can't access annotations.
+        # So cover_pks aggregates all covers from multi groups like ids does.
+        if self.is_model_comic or not self.admin_flags["dynamic_group_covers"]:  # type: ignore
+            return group_qs
+        recovered_group_list = []
+        for group in group_qs:
+            cover_pks = group.cover_pks
+            if len(cover_pks) == 1:
+                cover_pk = cover_pks[0]
+                cover_updated_at = group.updated_at
+            else:
+                comic_qs = self._get_cover_pk_query(cover_pks)
+                # print(comic_qs.explain())
+                # print(comic_qs.query)
+                cover = comic_qs[0]
+                cover_pk = cover.pk
+                cover_updated_at = cover.updated_at
+            group.cover_pk = cover_pk
+            group.cover_mtime = cover_updated_at
+            recovered_group_list.append(group)
+        return recovered_group_list

codex/views/browser/browser_breadcrumbs.py

@@ -0,0 +1,175 @@
+"""Browser breadcrumbs calculations."""
+
+from types import MappingProxyType
+from typing import TYPE_CHECKING
+
+from codex.views.browser.browser_annotations import BrowserAnnotationsView
+from codex.views.const import GROUP_NAME_MAP
+
+if TYPE_CHECKING:
+    from codex.models.paths import Folder
+
+
+class BrowserBreadcrumbsView(BrowserAnnotationsView):
+    """Browser breadcrumbs calculations."""
+
+    def _is_breadcrumbs_child_folder(self, is_child, group, up_group, up_pks) -> bool:
+        """Is this page a child of the folder breadcrumbs."""
+        if group != up_group or not self.group_instance:  # type: ignore
+            return is_child
+        parent_folder: Folder | None = self.group_instance.parent_folder  # type: ignore
+        parent_pk = parent_folder.pk if parent_folder else 0
+        return parent_pk in up_pks or (not up_pks and not parent_pk)
+
+    def _is_breadcrumbs_child_groups(self, is_child, group, up_group, up_pks):
+        """Is this page a child of the group breadcrumbs."""
+        show = self.params["show"]
+        test_parent = False
+        parent_group = None
+        for show_group, enabled in reversed(show.items()):
+            if not test_parent:
+                if show_group == group:
+                    test_parent = True
+                continue
+            if not enabled:
+                continue
+            group_name = GROUP_NAME_MAP[show_group]
+            parent_group = getattr(self.group_instance, group_name, None)  # type: ignore
+            is_child = bool(parent_group) and (parent_group.pk in up_pks)
+            break
+        if up_group == "r" and not parent_group:
+            is_child = True
+        return is_child
+
+    def _is_breadcrumbs_child(self, breadcrumbs) -> bool:
+        """Is the current route a child of the stored breadcrumbs."""
+        is_child = False
+        if not breadcrumbs:
+            return is_child
+        group = self.kwargs["group"]
+        pks = self.kwargs["pks"]
+        up_route = breadcrumbs[-1]
+        up_group = up_route["group"]
+        up_pks = up_route["pks"]
+        if group == self.STORY_ARC_GROUP:
+            is_child = group == up_group and pks
+        elif group == self.FOLDER_GROUP:
+            is_child = self._is_breadcrumbs_child_folder(
+                is_child, group, up_group, up_pks
+            )
+        else:
+            is_child = self._is_breadcrumbs_child_groups(
+                is_child, group, up_group, up_pks
+            )
+
+        return is_child
+
+    def _create_breadcrumbs_story_arc(self):
+        """Create the only story_arc parent."""
+        return [
+            {
+                "group": self.STORY_ARC_GROUP,
+                "pks": (),
+                "page": 1,
+                "name": "",
+            }
+        ]
+
+    def _create_breadcrumbs_folder(self):
+        """Create folder parents."""
+        breadcrumbs = []
+        folder: Folder | None = self.group_instance  # type: ignore
+        while folder:
+            folder = folder.parent_folder  # type: ignore
+            pks = (folder.pk,) if folder else ()
+            name = folder.name if folder else ""
+            parent_route = {
+                "group": self.FOLDER_GROUP,
+                "pks": pks,
+                "page": 1,
+                "name": name,
+            }
+            breadcrumbs = [parent_route, *breadcrumbs]
+        return breadcrumbs
+
+    def _create_breadcrumbs_group(self):
+        """Create browse group parents."""
+        breadcrumbs = [{"group": self.ROOT_GROUP, "pks": (), "page": 1, "name": ""}]
+        show = self.params["show"]
+        for show_group, enabled in show.items():
+            if not enabled or show_group not in self.valid_nav_groups:  # type: ignore
+                continue
+            attr = GROUP_NAME_MAP[show_group]  # + "_id"
+            parent_group = getattr(self.group_instance, attr, None)  # type: ignore
+            if parent_group:
+                pks = (parent_group.pk,)
+                name = parent_group.name
+                parent_group_route = {
+                    "group": show_group,
+                    "pks": pks,
+                    "page": 1,
+                    "name": name,
+                }
+                breadcrumbs += [parent_group_route]
+        return breadcrumbs
+
+    def _create_breadcrumbs(self):
+        """Create breadcrumbs from scratch."""
+        pks = self.kwargs["pks"]
+        if not pks:
+            return []
+        group = self.kwargs["group"]
+        if group == self.STORY_ARC_GROUP:
+            breadcrumbs = self._create_breadcrumbs_story_arc()
+        elif group == self.FOLDER_GROUP:
+            breadcrumbs = self._create_breadcrumbs_folder()
+        else:
+            breadcrumbs = self._create_breadcrumbs_group()
+        return breadcrumbs
+
+    def _is_breadcrumbs_identical(self, breadcrumbs):
+        if not breadcrumbs:
+            return False
+
+        up_route = breadcrumbs[-1]
+        if not up_route:
+            return False
+
+        group = self.kwargs["group"]
+        if up_route["group"] != group:
+            return False
+
+        pks = self.kwargs["pks"]
+        if set(up_route["pks"]) != set(pks):
+            return False
+
+        return True
+
+    def get_parent_breadcrumbs(
+        self,
+    ) -> tuple[dict[str, str | tuple[int, ...] | int], ...]:
+        """Get the breadcrumbs."""
+        breadcrumbs: list[dict[str, str | tuple[int, ...] | int]] = list(
+            self.get_from_session("breadcrumbs")
+        )
+
+        if not self._is_breadcrumbs_identical(breadcrumbs):
+            if not self._is_breadcrumbs_child(breadcrumbs):
+                breadcrumbs = self._create_breadcrumbs()
+
+            # Add current route to crumbs
+            group = self.kwargs["group"]
+            pks = self.kwargs["pks"]
+            name = self.group_instance.name if self.group_instance else ""  # type: ignore
+            page = self.kwargs["page"]
+            route = {"group": group, "pks": pks, "page": page, "name": name}
+            breadcrumbs += [route]
+
+            # Save params
+            params = dict(self.params)
+            params["breadcrumbs"] = breadcrumbs
+            self.params = MappingProxyType(params)
+
+        parent_breadcrumbs = breadcrumbs[:-1] if breadcrumbs else ()
+
+        return tuple(parent_breadcrumbs)