codex 1.6.19__py3-none-any.whl → 1.7.0__py3-none-any.whl

codex/views/browser/paginate.py

@@ -5,152 +5,61 @@ from math import ceil
 from django.core.paginator import EmptyPage, Paginator
 
 from codex.logger.logging import get_logger
-from codex.models import (
-    Comic,
-    Folder,
-)
-from codex.views.browser.annotations import BrowserAnnotationsView
-from codex.views.const import (
-    MAX_OBJ_PER_PAGE,
-)
-from codex.views.util import Route
+from codex.views.browser.page_in_bounds import BrowserPageInBoundsView
+from codex.views.const import MAX_OBJ_PER_PAGE
 
 LOG = get_logger(__name__)
 
 
-class BrowserPaginateView(BrowserAnnotationsView):
-    """Browser pagination."""
+class BrowserPaginateView(BrowserPageInBoundsView):
+    """Paginate Groups and Books."""
 
-    def _get_back_one_page_route(self, num_pages):
-        """Get max page if oob or 1."""
-        LOG.debug("Redirect back one page.")
-        group = self.kwargs.get("group")
-        pks = self.kwargs.get("pks")
-        page = self.kwargs.get("page", 1)
-        new_page = num_pages if num_pages and page > num_pages else 1
-        pks = pks if pks else "0"
-        return {"group": group, "pks": pks, "page": new_page}
-
-    def _get_up_breadcrumbs(self):
-        """Walk up the breadcrumbs to get the next level up."""
-        breadcrumbs = self.params.get("breadcrumbs", [])
-        new_breadcrumbs = []
-        level = False
-        group = self.kwargs.get("group")
-        pks = self.kwargs.get("pks")
-        page = self.kwargs.get("page", 1)
-        current_route = Route(group=group, pks=pks, page=page)
-        for crumb in reversed(breadcrumbs):
-            if not level:
-                crumb_route = Route(**crumb)
-                level = current_route & crumb_route
-                continue
-            new_breadcrumbs = [crumb, *new_breadcrumbs]
-
-        if not new_breadcrumbs:
-            if group not in ("f", "a"):
-                group = "r"
-            top_route = {"group": group, "pks": (), "page": 1}
-            new_breadcrumbs = [top_route]
-        return new_breadcrumbs
-
-    def _get_up_page_redirect(self):
-        """Walk up the breadcrumbs."""
-        try:
-            up_breadcrumbs = self._get_up_breadcrumbs()
-            route_mask = up_breadcrumbs[-1]
-            settings_mask = {"breadcrumbs": up_breadcrumbs}
-            LOG.debug("Redirect up a level.")
-        except IndexError:
-            group = self.kwargs.get("group")
-            pks = "0"
-            new_page = 1
-            route_mask = {"group": group, "pks": pks, "page": new_page}
-            settings_mask = {"breadcrumbs": [route_mask]}
-            LOG.debug("Redirect to all at current group.")
-        return route_mask, settings_mask
-
-    def _check_page_in_bounds(self, total_count):
-        """Redirect page out of bounds."""
-        pks = self.kwargs.get("pks")
-        page = self.kwargs.get("page", 1)
-        num_pages = ceil(total_count / MAX_OBJ_PER_PAGE)
-        if page == 1 or (page >= 1 and page <= num_pages):
-            # Don't redirect if on the root page for the group.
-            # Or page within valid range.
-            return num_pages
-
-        group = self.kwargs.get("group")
-        reason = f"{group=} {pks=} {page=} does not exist."
-
-        # Adjust route mask for redirect
-        if num_pages and page > 1:
-            route_mask = self._get_back_one_page_route(num_pages)
-            settings_mask = None
-        else:
-            # This now only occurs when page < 1
-            route_mask, settings_mask = self._get_up_page_redirect()
-
-        return self.raise_redirect(
-            reason, route_mask=route_mask, settings_mask=settings_mask
-        )
-
-    def _paginate_section(self, model, qs, page):
+    def _paginate_section(self, qs, page):
         """Paginate a group or Comic section."""
         orphans = 0 if self.model_group == "f" or self.params.get("q") else 5
         paginator = Paginator(qs, MAX_OBJ_PER_PAGE, orphans=orphans)
         try:
-            qs = paginator.page(page).object_list
+            paginator_page = paginator.page(page)
+            qs = paginator_page.object_list
         except EmptyPage:
-            if model != Folder:
-                model_name = self.model.__name__ if self.model else "NO_MODEL"
+            if self.model_group != "f":
+                model_name = qs.model.__name__ if qs.model else "UnknownGroup"
                 LOG.warning(f"No {model_name}s on page {page}")
-            qs = model.objects.none()
+            qs = qs.model.objects.none()
 
         return qs
 
-    def _paginate_groups(self, group_qs, total_group_count):
+    def _paginate_groups(self, group_qs):
         """Paginate the group object list before books."""
-        if total_group_count:
-            page = self.kwargs.get("page", 1)
-            page_group_qs = self._paginate_section(self.model, group_qs, page)
-        else:
-            page_group_qs = self.model.objects.none()  # type: ignore
-        return page_group_qs
+        page = self.kwargs.get("page", 1)
+        return self._paginate_section(group_qs, page)
 
-    def _paginate_books(self, book_qs, total_group_count, page_obj_count):
+    def _paginate_books(self, book_qs, total_group_count, page_group_count):
         """Paginate the book object list based on how many group/folders are showing."""
-        if page_obj_count >= MAX_OBJ_PER_PAGE:
-            # No books for this page
-            page_book_qs = Comic.objects.none()
+        group_remainder = total_group_count % MAX_OBJ_PER_PAGE
+        num_books_on_mixed_page = MAX_OBJ_PER_PAGE - group_remainder
+        if page_group_count:
+            # There are books after the groups on the same page
+            # Add remainder books without the paginator
+            page_book_qs = book_qs[:num_books_on_mixed_page]
         else:
-            group_remainder = total_group_count % MAX_OBJ_PER_PAGE
-            if page_obj_count:
-                # There are books after the groups on the same page
-                # Manually add books without the paginator
-                book_limit = MAX_OBJ_PER_PAGE - group_remainder
-                page_book_qs = book_qs[:book_limit]
-            else:
-                # There are books after the groups on a new page
-                if group_remainder:
-                    book_offset = MAX_OBJ_PER_PAGE - group_remainder
-                    page_book_qs = book_qs[book_offset:]
-                else:
-                    page_book_qs = book_qs
+            # There are books after the groups on a new page
+            book_offset = 0 if not group_remainder else num_books_on_mixed_page
+            page_book_qs = book_qs[book_offset:]
+
+            # Which book page are we on after groups?
+            page = self.kwargs.get("page", 1)
+            num_group_and_mixed_pages = ceil(total_group_count / MAX_OBJ_PER_PAGE)
+            book_only_page = page - num_group_and_mixed_pages
 
-                num_group_and_mixed_pages = ceil(total_group_count / MAX_OBJ_PER_PAGE)
-                book_only_page = self.kwargs.get("page", 1) - num_group_and_mixed_pages
-                page_book_qs = self._paginate_section(
-                    Comic, page_book_qs, book_only_page
-                )
+            page_book_qs = self._paginate_section(page_book_qs, book_only_page)
         return page_book_qs
 
-    def paginate(self, group_qs, book_qs, group_count, book_count):
+    def paginate(self, group_qs, book_qs, group_count):
         """Paginate the queryset into a group and book object lists."""
-        num_pages = self._check_page_in_bounds(group_count + book_count)
-        page_group_qs = self._paginate_groups(group_qs, group_count)
+        page_group_qs = self._paginate_groups(group_qs)
         page_group_count = page_group_qs.count()
         page_book_qs = self._paginate_books(book_qs, group_count, page_group_count)
         page_book_count = page_book_qs.count()
 
-        return page_group_qs, page_book_qs, num_pages, page_group_count, page_book_count
+        return page_group_qs, page_book_qs, page_group_count, page_book_count

codex/views/browser/params.py

@@ -0,0 +1,64 @@
+"""Parse browser params."""
+
+from types import MappingProxyType
+from typing import Any
+
+from codex.serializers.browser.settings import BrowserSettingsSerializer
+from codex.views.const import FOLDER_GROUP, STORY_ARC_GROUP
+from codex.views.session import SessionView
+from codex.views.util import reparse_json_query_params
+
+
+class BrowserParamsView(SessionView):
+    """Browser Params Parsing."""
+
+    input_serializer_class = BrowserSettingsSerializer
+    REPARSE_JSON_FIELDS = frozenset({"breadcrumbs", "filters", "show"})
+
+    def __init__(self, *args, **kwargs):
+        """Initialize properties."""
+        super().__init__(*args, **kwargs)
+        self._params: MappingProxyType[str, Any] | None = None
+
+    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 validate_settings(self):
+        """Not used until browser/validate.py."""
+
+    @property
+    def params(self):
+        """Validate sbmitted settings and apply them over the session settings."""
+        if self._params is None:
+            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.validate_settings()
+        return self._params

codex/views/browser/title.py

@@ -1,17 +1,12 @@
 """Browser title."""
 
-from codex.models import BrowserGroupModel, Comic, Volume
+from codex.models import Comic, Volume
 from codex.views.browser.breadcrumbs import BrowserBreadcrumbsView
 
 
 class BrowserTitleView(BrowserBreadcrumbsView):
     """Browser title methods."""
 
-    def __init__(self, *args, **kwargs):
-        """Set params for the type checker."""
-        super().__init__(*args, **kwargs)
-        self.group_instance: BrowserGroupModel | None = None
-
     def _get_root_group_name(self):
         if not self.model:
             reason = "No model set in browser"

codex/views/browser/validate.py

@@ -3,13 +3,17 @@
 from copy import deepcopy
 from types import MappingProxyType
 
+from rest_framework.exceptions import NotFound
+
+from codex.choices import DEFAULT_BROWSER_ROUTE, mapping_to_dict
 from codex.exceptions import SeeOtherRedirectError
 from codex.logger.logging import get_logger
-from codex.serializers.choices import DEFAULTS
-from codex.views.browser.base import BrowserBaseView
+from codex.models.groups import BrowserGroupModel
+from codex.views.browser.filters.search.parse import SearchFilterView
 from codex.views.const import (
     COMIC_GROUP,
     FOLDER_GROUP,
+    GROUP_MODEL_MAP,
     ROOT_GROUP,
     STORY_ARC_GROUP,
 )
@@ -17,19 +21,55 @@ from codex.views.const import (
 LOG = get_logger(__name__)
 
 
-class BrowserValidateView(BrowserBaseView):
+class BrowserValidateView(SearchFilterView):
     """Browser Settings and URL Validation."""
 
     DEFAULT_ROUTE = MappingProxyType(
-        {
-            "name": "browser",
-            "params": deepcopy(DEFAULTS["breadcrumbs"][0]),
-        }
+        {"name": "browser", "params": DEFAULT_BROWSER_ROUTE}
     )
 
+    def __init__(self, *args, **kwargs):
+        """Initialize properties."""
+        super().__init__(*args, **kwargs)
+        self._is_admin: bool | None = None
+        self._model_group: str = ""
+        self._model: type[BrowserGroupModel] | None = None
+        self._rel_prefix: str | None = None
+        self._valid_nav_groups: tuple[str, ...] | None = None
+
+    @property
+    def model_group(self):
+        """Memoize the model group."""
+        if not self._model_group:
+            group = self.kwargs["group"]
+            if group == ROOT_GROUP:
+                group = self.params["top_group"]
+            self._model_group = group
+        return self._model_group
+
+    @property
+    def model(self) -> type[BrowserGroupModel] | None:
+        """Memoize the model for the browse list."""
+        if not self._model:
+            model = GROUP_MODEL_MAP.get(self.model_group)
+            if model is None:
+                group = self.kwargs["group"]
+                detail = f"Cannot browse {group=}"
+                LOG.debug(detail)
+                raise NotFound(detail=detail)
+            self._model = model
+        return self._model
+
+    @property
+    def rel_prefix(self):
+        """Memoize model rel prefix."""
+        if self._rel_prefix is None:
+            self._rel_prefix = self.get_rel_prefix(self.model)
+        return self._rel_prefix
+
     def raise_redirect(self, reason, route_mask=None, settings_mask=None):
         """Redirect the client to a valid group url."""
-        route = deepcopy(dict(self.DEFAULT_ROUTE))
+        route = mapping_to_dict(self.DEFAULT_ROUTE)
         if route_mask:
             route["params"].update(route_mask)  # type: ignore
         settings = deepcopy(dict(self.params))
@@ -73,7 +113,7 @@ class BrowserValidateView(BrowserBaseView):
             settings_mask = {"top_group": valid_top_group, "breadcrumbs": breadcrumbs}
             self.raise_redirect(reason, route, settings_mask)
 
-    def set_valid_browse_nav_groups(self, valid_top_groups):
+    def _get_valid_browse_nav_groups(self, valid_top_groups):
         """Get valid nav groups for the current settings.
 
         Valid nav groups are the top group and below that are also
@@ -96,7 +136,7 @@ class BrowserValidateView(BrowserBaseView):
             reason = f"Nav group {nav_group} unavailable, redirect to {ROOT_GROUP}"
             self.raise_redirect(reason)
 
-        self.valid_nav_groups = tuple(valid_nav_groups)
+        return tuple(valid_nav_groups)
 
     def _validate_folder_settings(self):
         """Check that all the view variables for folder mode are set right."""
@@ -113,7 +153,7 @@ class BrowserValidateView(BrowserBaseView):
 
         valid_top_groups = (FOLDER_GROUP,)
         self._validate_top_group(valid_top_groups)
-        self.valid_nav_groups = valid_top_groups
+        return valid_top_groups
 
     def _validate_browser_group_settings(self):
         """Check that all the view variables for browser mode are set right."""
@@ -132,29 +172,24 @@ class BrowserValidateView(BrowserBaseView):
 
         # Validate Browser nav_group
         # Redirect if nav group is wrong
-        self.set_valid_browse_nav_groups(valid_top_groups)
+        return self._get_valid_browse_nav_groups(valid_top_groups)
 
-    def _validate_story_arc_settings(self):
+    def _validate_story_arc_settings(self) -> tuple[str, ...]:
         """Validate story arc settings."""
         valid_top_groups = (STORY_ARC_GROUP,)
         self._validate_top_group(valid_top_groups)
-        self.valid_nav_groups = valid_top_groups
-
-    def validate_settings(self):
-        """Validate group and top group settings."""
-        group = self.kwargs["group"]
-        if group == FOLDER_GROUP:
-            self._validate_folder_settings()
-        elif group == STORY_ARC_GROUP:
-            self._validate_story_arc_settings()
-        else:
-            self._validate_browser_group_settings()
-
-        # Validate order
-        if self.order_key == "filename" and not self.admin_flags["folder_view"]:
-            pks = self.kwargs["pks"]
-            page = self.kwargs["page"]
-            route_changes = {"group": group, "pks": pks, "page": page}
-            reason = "order by filename not allowed by admin flag."
-            settings_mask = {"order_by": "sort_name"}
-            self.raise_redirect(reason, route_changes, settings_mask)
+        return valid_top_groups
+
+    @property
+    def valid_nav_groups(self) -> tuple[str, ...]:
+        """Memoize valid nav groups."""
+        if self._valid_nav_groups is None:
+            group = self.kwargs["group"]
+            if group == FOLDER_GROUP:
+                vng = self._validate_folder_settings()
+            elif group == STORY_ARC_GROUP:
+                vng = self._validate_story_arc_settings()
+            else:
+                vng = self._validate_browser_group_settings()
+            self._valid_nav_groups = vng
+        return self._valid_nav_groups

codex/views/const.py

@@ -39,7 +39,6 @@ from codex.models import (
 )
 from codex.settings.settings import CODEX_PATH
 
-FALSY = {None, "", "false", "0", False}
 GROUP_NAME_MAP = MappingProxyType(
     {"p": "publisher", "i": "imprint", "s": "series", "v": "volume"}
 )

codex/views/download.py

@@ -22,7 +22,7 @@ class DownloadView(AuthFilterAPIView):
         """Download a comic archive."""
         pk = kwargs.get("pk")
         try:
-            group_acl_filter = self.get_group_acl_filter(Comic)
+            group_acl_filter = self.get_group_acl_filter(Comic, self.request.user)
             comic = (
                 Comic.objects.filter(group_acl_filter)
                 .only("path", "file_type")

codex/views/mixins.py

@@ -12,7 +12,7 @@ class SharedAnnotationsMixin:
     """Cross view annotation methods."""
 
     @staticmethod
-    def _get_order_groups(pks, model_group):
+    def _get_order_groups(model_group, pks):
         """Annotate sort_name."""
         if not pks or len(pks) > 1:
             order_groups = _SHOW_GROUPS
@@ -28,12 +28,11 @@ class SharedAnnotationsMixin:
         return order_groups
 
     @classmethod
-    def alias_sort_names(cls, qs, model, pks, model_group, show=None):
+    def get_sort_name_annotations(cls, model, model_group, pks, show):
         """Annotate sort names for browser subclasses and reader."""
         sort_name_annotations = {}
-        comic_sort_names = []
-        if model == Comic:
-            order_groups = cls._get_order_groups(pks, model_group)
+        if model is Comic:
+            order_groups = cls._get_order_groups(model_group, pks)
             for order_group in order_groups:
                 if show and not show.get(order_group):
                     continue
@@ -42,23 +41,19 @@ class SharedAnnotationsMixin:
                 name_field = "name" if group_name == "volume" else "sort_name"
                 sort_name = F(f"{group_name}__{name_field}")
                 sort_name_annotations[ann_name] = sort_name
-                comic_sort_names.append(ann_name)
-        elif model == Volume:
+        elif model is Volume:
             sort_name_annotations["sort_name"] = F("name")
-
-        if sort_name_annotations:
-            qs = qs.alias(**sort_name_annotations)
-        return qs, comic_sort_names
+        return sort_name_annotations
 
     @classmethod
-    def annotate_group_names(cls, qs, model):
+    def annotate_group_names(cls, qs):
         """Annotate name fields by hoisting them up."""
         # Optimized to only lookup what is used on the frontend
         target = cls.TARGET  # type: ignore
         if target not in frozenset({"browser", "opds1", "opds2", "reader"}):
             return qs
         group_names = {}
-        if model == Comic:
+        if qs.model is Comic:
             if target != "reader":
                 group_names["publisher_name"] = F("publisher__name")
                 if target == "opds2":
@@ -69,8 +64,25 @@ class SharedAnnotationsMixin:
                     "volume_name": F("volume__name"),
                 }
             )
-        elif model == Volume:
+        elif qs.model is Volume:
             group_names["series_name"] = F("series__name")
-        elif model == Imprint:
+        elif qs.model is Imprint:
             group_names["publisher_name"] = F("publisher__name")
         return qs.annotate(**group_names)
+
+
+class BookmarkSearchMixin:
+    """Create Bookmark Search kwargs."""
+
+    @staticmethod
+    def get_bookmark_search_kwargs(auth_filter, comic_filter=None):
+        """Get the search kwargs for a user's authentication state."""
+        # search kwargs are relative to the bookmark object.
+        search_kwargs = {}
+        search_kwargs.update(auth_filter)
+
+        if comic_filter:
+            for key, value in comic_filter.items():
+                search_kwargs[f"comic__{key}"] = value
+
+        return search_kwargs

codex/views/opds/const.py

@@ -1,6 +1,5 @@
 """OPDS Common consts."""
 
-from collections.abc import Mapping
 from types import MappingProxyType
 
 from codex.models import (
@@ -63,7 +62,7 @@ class MimeType:
     HTML = "text/html"
     AUTH_BASIC = "http://opds-spec.org/auth/basic"
     COOKIE = "cookie"
-    FILE_TYPE_MAP: Mapping[str, str] = MappingProxyType(
+    FILE_TYPE_MAP: MappingProxyType[str, str] = MappingProxyType(
         {
             "CBZ": "application/vnd.comicbook+zip",
             "CBR": "application/vnd.comicbook+rar",
@@ -71,7 +70,7 @@ class MimeType:
             "PDF": "application/pdf",
         }
     )
-    SIMPLE_FILE_TYPE_MAP: Mapping[str, str] = MappingProxyType(
+    SIMPLE_FILE_TYPE_MAP: MappingProxyType[str, str] = MappingProxyType(
         {
             # PocketBooks needs app/zip
             "CBZ": "application/zip",

codex/views/opds/urls.py

@@ -3,7 +3,7 @@
 from django.urls import reverse
 from rest_framework.response import Response
 
-from codex.serializers.choices import DEFAULTS
+from codex.choices import DEFAULT_BROWSER_ROUTE
 from codex.serializers.opds.urls import OPDSURLsSerializer
 from codex.views.auth import AuthGenericAPIView
 from codex.views.util import pop_name
@@ -19,7 +19,7 @@ class OPDSURLsView(AuthGenericAPIView):
     def get(self, *args, **kwargs):
         """Resolve the urls."""
         obj = {}
-        route = DEFAULTS["breadcrumbs"][0]
+        route = DEFAULT_BROWSER_ROUTE
         route = pop_name(route)
         for version in _OPDS_VERSIONS:
             key = f"v{version}"

codex/views/opds/util.py

@@ -5,11 +5,11 @@ from django.http.response import HttpResponseRedirect
 from django.urls import reverse
 from django.utils.http import urlencode
 
+from codex.choices import DEFAULT_BROWSER_ROUTE
 from codex.models import (
     Contributor,
     ContributorPerson,
 )
-from codex.serializers.choices import DEFAULTS
 from codex.views.auth import GroupACLMixin
 from codex.views.opds.const import OPDS_M2M_MODELS
 
@@ -71,8 +71,7 @@ def full_redirect_view(url_name):
 
     def func(request):
         """Redirect to view, forwarding query strings and auth."""
-        kwargs = DEFAULTS["breadcrumbs"][0]
-        kwargs.pop("name", None)
+        kwargs = dict(DEFAULT_BROWSER_ROUTE)
         url = reverse(url_name, kwargs=kwargs)
 
         # Forward the query string.

codex/views/opds/v1/entry/links.py

@@ -82,7 +82,9 @@ class OPDS1EntryLinksMixin:
         else:
             mime_type = MimeType.NAV
 
-        thr_count = 0 if self.fake else self.obj.child_count
+        thr_count = (
+            0 if self.fake else 1 if self.obj.group == "c" else self.obj.child_count
+        )
         rel = Rel.ALTERNATE if metadata else "subsection"
 
         return OPDS1Link(rel, href, mime_type, thr_count=thr_count)