codex 1.7.0a0__py3-none-any.whl → 1.7.0a1__py3-none-any.whl

codex/views/browser/annotations.py

@@ -1,339 +0,0 @@
-"""Base view for metadata annotations."""
-
-from os import sep
-from types import MappingProxyType
-
-from django.db.models import (
-    Avg,
-    Case,
-    F,
-    FilteredRelation,
-    Min,
-    OuterRef,
-    Q,
-    Sum,
-    Value,
-    When,
-)
-from django.db.models.expressions import Subquery
-from django.db.models.fields import CharField, PositiveSmallIntegerField
-from django.db.models.functions import Least, Reverse, Right, StrIndex
-from django.db.models.functions.comparison import Coalesce
-
-from codex.logger.logging import get_logger
-from codex.models import (
-    BrowserGroupModel,
-    Comic,
-    Folder,
-    StoryArc,
-    Volume,
-)
-from codex.models.functions import ComicFTSRank, JsonGroupArray
-from codex.models.groups import Imprint, Publisher, Series
-from codex.views.browser.order_by import (
-    BrowserOrderByView,
-)
-from codex.views.const import (
-    NONE_DATETIMEFIELD,
-    NONE_INTEGERFIELD,
-    STORY_ARC_GROUP,
-)
-from codex.views.mixins import SharedAnnotationsMixin
-
-_ORDER_AGGREGATE_FUNCS = MappingProxyType(
-    # These are annotated to order_value because 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",
-    }
-)
-_GROUP_BY: MappingProxyType[type[BrowserGroupModel], str] = MappingProxyType(
-    {Publisher: "sort_name", Imprint: "sort_name", Series: "sort_name", Volume: "name"}
-)
-
-LOG = get_logger(__name__)
-
-
-class BrowserAnnotationsView(BrowserOrderByView, SharedAnnotationsMixin):
-    """Base class for views that need special metadata annotations."""
-
-    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 add_group_by(self, qs, model=None):
-        """Get the group by for the model."""
-        if model is None:
-            model = self.model
-        if group_by := _GROUP_BY.get(model):  # type: ignore
-            qs = qs.group_by(group_by)
-        return qs
-
-    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
-
-    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:
-            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)
-
-    def _alias_story_arc_number(self, qs):
-        if self.order_key != "story_arc_number":
-            return qs
-
-        # Get story_arc__pk
-        group = self.kwargs["group"]
-        pks = self.kwargs["pks"]
-        if group == STORY_ARC_GROUP and pks:
-            story_arc_pks = pks
-        else:
-            story_arc_pks = self.params.get("filters", {}).get(  # type: ignore
-                "story_arcs", ()
-            )
-
-        # 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 = 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."""
-        # Used for sorting and progress
-        if model == Comic:
-            return qs
-
-        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:
-            qs = qs.annotate(page_count=page_count_sum)
-        return qs
-
-    def _annotate_bookmark_updated_at(self, qs, model):
-        if not self.is_opds_1_acquisition and self.order_key != "bookmark_updated_at":
-            return qs
-        bm_rel, bm_filter = self.get_bookmark_rel_and_filter(model)
-        bm_updated_at_rel = f"{bm_rel}__updated_at"
-        bmua_agg = self.order_agg_func(
-            bm_updated_at_rel, default=NONE_DATETIMEFIELD, filter=bm_filter
-        )
-        return qs.annotate(bookmark_updated_at=bmua_agg)
-
-    def _annotate_order_value(self, qs, model):
-        """Annotate a main key for sorting and browser card display."""
-        # Determine order func
-        if self.TARGET == "metadata":
-            return qs
-        if model == Folder and self.order_key == "filename":
-            order_value = F("name")
-        elif model == Comic or self.order_key in _ANNOTATED_ORDER_FIELDS:
-            # These are annotated in browser_annotaions
-            order_value = F(self.order_key)
-        else:
-            agg_func = _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 self.TARGET == "browser":
-            qs = qs.annotate(order_value=order_value)
-        else:
-            qs = qs.alias(order_value=order_value)
-        return qs
-
-    def _annotate_search_scores(self, qs):
-        """Annotate Search Scores."""
-        if (
-            self.TARGET not in frozenset({"browser", "cover"})
-            or self.order_key != "search_score"  # type: ignore
-        ):
-            return qs
-        return qs.annotate(search_score=ComicFTSRank())
-
-    def annotate_order_aggregates(self, qs, model):
-        """Annotate common aggregates between browser and metadata."""
-        self.set_order_key()
-        qs = qs.annotate(ids=JsonGroupArray("id", distinct=True))
-        qs = self._annotate_search_scores(qs)
-        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_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)))
-
-    @staticmethod
-    def _get_bookmark_page_and_finished_counts(
-        bm_filter, page_rel, finished_rel, page_count
-    ):
-        bookmark_page_case = Case(
-            # When(**{bm_rel: None}, then=0),
-            When(**{finished_rel: True}, then=page_count),
-            default=page_rel,
-            output_field=PositiveSmallIntegerField(),
-        )
-
-        bookmark_page = Sum(
-            bookmark_page_case,
-            default=0,
-            filter=bm_filter,
-            output_field=PositiveSmallIntegerField(),
-            distinct=True,
-        )
-
-        finished_count = Sum(
-            finished_rel,
-            default=0,
-            filter=bm_filter,
-            output_field=PositiveSmallIntegerField(),
-            distinct=True,
-        )
-        finished_aggregate = Q(child_count=finished_count)
-
-        return bookmark_page, finished_aggregate
-
-    def _annotate_group_bookmarks(self):
-        """Aggregate bookmark and finished states for groups using subqueries to not break with the FTS match filter."""
-        # Using these subqueries is faster even though it's not neccissary for non-fts queries.
-        if not self.model:
-            return 0, 0
-
-        comic_qs = self.get_filtered_queryset(Comic)
-        # Must group by the outer ref or it only does aggregates for one comic.
-        group_rel = (
-            "parent_folder"
-            if self.model == Folder
-            else "story_arc_numbers__story_arc"
-            if self.model == StoryArc
-            else self.model.__name__.lower()
-        )
-        group_rel_suffix = "name" if self.model == Volume else "sort_name"
-        group_rel += "__" + group_rel_suffix
-        comic_qs = comic_qs.filter(**{group_rel: OuterRef("pk")}).values(group_rel)
-
-        bm_rel, bm_filter = self.get_bookmark_rel_and_filter(Comic)
-        page_rel = f"{bm_rel}__page"
-        finished_rel = f"{bm_rel}__finished"
-        page_count = "page_count"
-        bookmark_page, finished_aggregate = self._get_bookmark_page_and_finished_counts(
-            bm_filter, page_rel, finished_rel, page_count
-        )
-
-        comic_qs = comic_qs.annotate(page=bookmark_page, finished=finished_aggregate)
-        bookmark_page = Subquery(comic_qs.values("page"))
-        finished_aggregate = Subquery(comic_qs.values("finished"))
-
-        return bookmark_page, finished_aggregate
-
-    def _annotate_bookmarks(self, qs, model):
-        """Hoist up bookmark annotations."""
-        # XXX These are slow for large groups.
-        bm_rel, _bm_filter = self.get_bookmark_rel_and_filter(model)
-        page_rel = f"{bm_rel}__page"
-        finished_rel = f"{bm_rel}__finished"
-
-        if model == Comic:
-            # Hoist comic bookmark and finished states
-            bookmark_page = F(page_rel)
-            finished_aggregate = F(finished_rel)
-        else:
-            # FTS mode is faster?
-            # Aggregate bookmark and finished states for groups using subqueries to
-            # not break with FTS match filter.
-            bookmark_page, finished_aggregate = self._annotate_group_bookmarks()
-
-        if (
-            self.is_opds_1_acquisition
-            or (self.is_model_comic and self.TARGET == "browser")
-            or self.TARGET in frozenset({"metadata", "browser"})
-        ):
-            qs = qs.annotate(page=bookmark_page)
-
-        if self.TARGET in frozenset({"metadata", "browser"}):
-            qs = qs.annotate(finished=finished_aggregate)
-
-        return qs
-
-    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
-        # Page counts can be null with metadata turned off.
-        # Least guard is for rare instances when bookmarks are set to
-        # invalid high values
-        progress = Least(Coalesce(F("page"), 0) * 100.0 / F("page_count"), Value(100.0))
-        return qs.annotate(progress=progress)
-
-    def annotate_card_aggregates(self, qs, model):
-        """Annotate aggregates that appear the browser card."""
-        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)
-        qs = self._annotate_progress(qs)
-        return qs.annotate(updated_ats=JsonGroupArray("updated_at", distinct=True))

codex/views/browser/base.py

@@ -1,139 +0,0 @@
-"""Views for browsing comic library."""
-
-from types import MappingProxyType
-from typing import TYPE_CHECKING, Any
-
-from django.contrib.auth.models import User
-from django.db.models.aggregates import Max, Min
-from rest_framework.exceptions import NotFound
-
-from codex.logger.logging import get_logger
-from codex.models import (
-    AdminFlag,
-    Comic,
-)
-from codex.serializers.browser.settings import BrowserSettingsSerializer
-from codex.views.browser.filters.search.parse import SearchFilterView
-from codex.views.const import FOLDER_GROUP, GROUP_MODEL_MAP, ROOT_GROUP, STORY_ARC_GROUP
-from codex.views.util import reparse_json_query_params
-
-LOG = get_logger(__name__)
-
-if TYPE_CHECKING:
-    from codex.models.groups import BrowserGroupModel
-
-
-class BrowserBaseView(SearchFilterView):
-    """Browse comics with a variety of filters and sorts."""
-
-    input_serializer_class = BrowserSettingsSerializer
-
-    ADMIN_FLAG_VALUE_KEY_MAP = MappingProxyType({})
-    REPARSE_JSON_FIELDS = frozenset({"breadcrumbs", "filters", "show"})
-
-    def __init__(self, *args, **kwargs):
-        """Set params for the type checker."""
-        super().__init__(*args, **kwargs)
-        self._is_admin: bool = False
-        self.params: MappingProxyType[str, Any] = MappingProxyType({})
-        self.rel_prefix: str = ""
-        self.model: type[BrowserGroupModel] | None = None
-        self.group_class: type[BrowserGroupModel] | None = None
-        self.model_group: str = ""
-        self.is_model_comic: bool = False
-        self.admin_flags: MappingProxyType[str, bool] = MappingProxyType({})
-        self.order_agg_func: type[Min | Max] = Min
-        self.order_key: str = ""
-
-    def is_admin(self):
-        """Is the current user an admin."""
-        if self._is_admin is None:
-            user = self.request.user
-            self._is_admin = user and isinstance(user, User) and user.is_staff
-        return self._is_admin
-
-    def set_admin_flags(self):
-        """Set browser relevant admin flags."""
-        admin_pairs = AdminFlag.objects.filter(
-            key__in=self.ADMIN_FLAG_VALUE_KEY_MAP.keys()
-        ).values_list("key", "on")
-        admin_flags = {}
-        for key, on in admin_pairs:
-            export_key = self.ADMIN_FLAG_VALUE_KEY_MAP[key]
-            admin_flags[export_key] = on
-        self.admin_flags = MappingProxyType(admin_flags)
-
-    def get_model_group(self):
-        """Determine model group for set_browse_model()."""
-        group = self.kwargs["group"]
-        if group == ROOT_GROUP:
-            group = self.params["top_group"]
-        return group
-
-    def _parse_query_params(self):
-        """Parse GET query parameters: filter object & snake case."""
-        query_params = reparse_json_query_params(
-            self.request.GET, self.REPARSE_JSON_FIELDS
-        )
-        if "q" not in query_params and (query := query_params.get("query")):
-            # parse query param for opds v2
-            query_params["q"] = query
-        return query_params
-
-    def parse_params(self):
-        """Validate sbmitted settings and apply them over the session settings."""
-        data = self._parse_query_params()
-        serializer = self.input_serializer_class(data=data)
-        serializer.is_valid(raise_exception=True)
-
-        params: dict[str, Any] = {}
-        defaults = self.SESSION_DEFAULTS[self.SESSION_KEY]
-        params.update(defaults)
-        group = self.kwargs.get("group")
-        if group:
-            # order_by has a dynamic group based default
-            order_defaults = {
-                "order_by": "filename"
-                if group == FOLDER_GROUP
-                else "story_arc_number"
-                if group == STORY_ARC_GROUP
-                else "sort_name"
-            }
-            params.update(order_defaults)
-        validated_data = serializer.validated_data
-
-        if validated_data:
-            params.update(validated_data)  # type: ignore
-        self.params = MappingProxyType(params)
-        self.is_bookmark_filtered = bool(self.params.get("filters", {}).get("bookmark"))
-
-    def set_order_key(self):
-        """Unused until browser."""
-
-    def validate_settings(self):
-        """Unused until browser."""
-
-    def set_model(self):
-        """Set the model for the browse list."""
-        group = self.kwargs["group"]
-        self.group_class = GROUP_MODEL_MAP[group]
-
-        self.model_group = self.get_model_group()
-        self.model = GROUP_MODEL_MAP.get(self.model_group)
-        if self.model is None:
-            detail = f"Cannot browse {group=}"
-            LOG.debug(detail)
-            raise NotFound(detail=detail)
-        self.is_model_comic = self.model == Comic
-
-    def set_rel_prefix(self):
-        """Set the relation prefix for most fields."""
-        self.rel_prefix = self.get_rel_prefix(self.model)
-
-    def init_request(self):
-        """Initialize request."""
-        self.set_admin_flags()
-        self.parse_params()
-        self.validate_settings()
-        self.set_model()
-        self.set_rel_prefix()

codex/views/browser/filters/annotations.py

@@ -1,125 +0,0 @@
-"""Annotations used by a filter."""
-
-from logging import DEBUG, WARNING
-
-from django.db.models.aggregates import Count, Max
-from django.db.models.functions import Coalesce, Greatest
-from django.db.utils import OperationalError
-
-from codex.logger.logging import get_logger
-from codex.models.comic import Comic
-from codex.views.browser.filters.bookmark import BookmarkFilterMixin
-from codex.views.browser.validate import BrowserValidateView
-from codex.views.const import (
-    EPOCH_START_DATETIMEFIELD,
-    ONE_INTEGERFIELD,
-)
-
-_CHILD_COUNT = "child_count"
-_FTS5_PREFIX = "fts5: "
-LOG = get_logger(__name__)
-
-
-class BrowserAnnotationsFilterView(BrowserValidateView, BookmarkFilterMixin):
-    """Annotations that also filter."""
-
-    TARGET = ""
-
-    def __init__(self, *args, **kwargs) -> None:
-        """Initialize."""
-        super().__init__(*args, **kwargs)
-        self.init_bookmark_data()
-
-    def _get_query_filters(  # noqa: PLR0913
-        self, model, group, pks, bookmark_filter, page_mtime=False, group_filter=True
-    ):
-        """Return all the filters except the group filter."""
-        # XXX all these ifs and flags are awful
-        object_filter = self.get_group_acl_filter(model)
-        if group_filter:
-            object_filter &= self.get_group_filter(group, pks, page_mtime=page_mtime)
-        object_filter &= self.get_comic_field_filter(model)
-        if bookmark_filter:
-            # not needed when used by outerrefl OuterRef is applied next
-            object_filter &= self.get_bookmark_filter(model)
-        return object_filter
-
-    def _filter_by_child_count(self, qs, model):
-        """Filter group by child count."""
-        rel = self.rel_prefix + "pk"
-        count_func = ONE_INTEGERFIELD if model == Comic else Count(rel, distinct=True)
-        ann = {_CHILD_COUNT: count_func}
-        if self.TARGET == "opds2":
-            if model != Comic:
-                qs = qs.alias(**ann)
-        else:
-            qs = qs.annotate(**ann)
-        if model != Comic:
-            qs = qs.filter(**{f"{_CHILD_COUNT}__gt": 0})
-        return qs
-
-    def get_filtered_queryset(  # noqa: PLR0913
-        self,
-        model,
-        group=None,
-        pks=None,
-        bookmark_filter=True,
-        page_mtime=False,
-        group_filter=True,
-    ):
-        """Get a filtered queryset for the model."""
-        object_filter = self._get_query_filters(
-            model,
-            group,
-            pks,
-            bookmark_filter,
-            page_mtime=page_mtime,
-            group_filter=group_filter,
-        )
-        qs = model.objects.filter(object_filter)
-        qs = self.apply_search_filter(qs, model)
-        return self._filter_by_child_count(qs, model)
-
-    def _handle_operational_error(self, err):
-        msg = err.args[0] if err.args else ""
-        if msg.startswith(_FTS5_PREFIX):
-            level = DEBUG
-            self.search_error = msg.removeprefix(_FTS5_PREFIX)
-        else:
-            level = WARNING
-            msg = str(err)
-        LOG.log(level, f"Query Error: {msg}")
-
-    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,
-            group=group,
-            pks=pks,
-            bookmark_filter=self.is_bookmark_filtered,
-            page_mtime=page_mtime,
-        )
-        qs = qs.annotate(max_updated_at=Max("updated_at"))
-
-        if self.is_bookmark_filtered:
-            bm_rel, bm_filter = self.get_bookmark_rel_and_filter(model)
-            qs = qs.filter(bm_filter)
-            ua_rel = bm_rel + "__updated_at"
-            mbua = Max(ua_rel)
-        else:
-            mbua = EPOCH_START_DATETIMEFIELD
-        qs = qs.annotate(max_bookmark_updated_at=mbua)
-
-        try:
-            mtime = qs.aggregate(
-                max=Greatest(
-                    Coalesce("max_bookmark_updated_at", EPOCH_START_DATETIMEFIELD),
-                    "max_updated_at",
-                )
-            )["max"]
-        except OperationalError as exc:
-            self._handle_operational_error(exc)
-            mtime = None
-        if mtime == NotImplemented:
-            mtime = None
-        return mtime