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

codex/views/browser/title.py

@@ -1,48 +0,0 @@
-"""Browser title."""
-
-from codex.models import BrowserGroupModel, 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"
-            raise ValueError(reason)
-        plural = self.model._meta.verbose_name_plural
-        if not plural:
-            reason = f"No plural name for {self.model}"
-            raise ValueError(reason)
-        return plural.capitalize(), 0
-
-    def _get_group_name(self):
-        group_count = 0
-        if gi := self.group_instance:
-            if isinstance(gi, Volume):
-                group_count = gi.series.volume_count
-            elif isinstance(gi, Comic):
-                group_count = gi.volume.issue_count
-            group_name = gi.name
-        else:
-            group_name = ""
-        return group_name, group_count
-
-    def get_browser_page_title(self):
-        """Get the proper title for this browse level."""
-        pks = self.kwargs.get("pks")
-        if not pks:
-            group_name, group_count = self._get_root_group_name()
-        else:
-            group_name, group_count = self._get_group_name()
-
-        return {
-            "group_name": group_name,
-            "group_count": group_count,
-        }

codex/views/browser/validate.py

@@ -1,161 +0,0 @@
-"""Browser Settings and URL Validation."""
-
-from copy import deepcopy
-from types import MappingProxyType
-
-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.views.const import (
-    COMIC_GROUP,
-    FOLDER_GROUP,
-    ROOT_GROUP,
-    STORY_ARC_GROUP,
-)
-
-LOG = get_logger(__name__)
-_NO_TOP_GROUP_VALIDATE = frozenset({"metadata"})
-
-
-class BrowserValidateView(BrowserBaseView):
-    """Browser Settings and URL Validation."""
-
-    DEFAULT_ROUTE = MappingProxyType(
-        {
-            "name": "browser",
-            "params": deepcopy(DEFAULTS["breadcrumbs"][0]),
-        }
-    )
-
-    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))
-        if route_mask:
-            route["params"].update(route_mask)  # type: ignore
-        settings = deepcopy(dict(self.params))
-        if settings_mask:
-            settings.update(settings_mask)
-        detail = {"route": route, "settings": settings, "reason": reason}
-        raise SeeOtherRedirectError(detail=detail)
-
-    def _get_valid_browse_top_groups(self):
-        """Get valid top groups for the current settings.
-
-        Valid top groups are determined by the Browser Settings.
-        """
-        valid_top_groups = []
-
-        show = self.params["show"]
-        for nav_group, allowed in show.items():
-            if allowed:
-                valid_top_groups.append(nav_group)
-        # Issues is always a valid top group
-        valid_top_groups += [COMIC_GROUP]
-
-        return valid_top_groups
-
-    def _validate_top_group(self, valid_top_groups):
-        # if self.TARGET in _NO_TOP_GROUP_VALIDATE:
-        #    return
-        nav_group = self.kwargs.get("group")
-        top_group = self.params.get("top_group")
-        if top_group not in valid_top_groups:
-            reason = f"top_group {top_group} not in valid nav groups, changed to "
-            if nav_group in valid_top_groups:
-                valid_top_group = nav_group
-                reason += "nav group: "
-            else:
-                valid_top_group = valid_top_groups[0]
-                reason += "first valid top group "
-            reason += valid_top_group
-            pks = self.kwargs.get("pks", ())
-            page = self.kwargs["page"]
-            route = {"group": nav_group, "pks": pks, "page": page}
-            settings_mask = {"top_group": valid_top_group}
-            self.raise_redirect(reason, route, settings_mask)
-
-    def set_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
-        enabled in browser settings.
-
-        May always navigate to root 'r' nav group.
-        """
-        top_group = self.params["top_group"]
-        nav_group = self.kwargs["group"]
-        valid_nav_groups = [ROOT_GROUP]
-
-        for possible_index, possible_nav_group in enumerate(valid_top_groups):
-            if top_group == possible_nav_group:
-                # all the nav groups past this point,
-                # 'c' is obscured by the web reader url, but valid for opds
-                tail_top_groups = valid_top_groups[possible_index:]
-                valid_nav_groups += tail_top_groups
-
-                if nav_group not in valid_nav_groups:
-                    reason = (
-                        f"Nav group {nav_group} unavailable, "
-                        f"redirect to {ROOT_GROUP}"
-                    )
-                    self.raise_redirect(reason)
-                break
-        self.valid_nav_groups = tuple(valid_nav_groups)
-
-    def _validate_folder_settings(self):
-        """Check that all the view variables for folder mode are set right."""
-        # Check folder view admin flag
-        if not self.admin_flags["folder_view"]:
-            reason = "folder view disabled"
-            valid_top_groups = self._get_valid_browse_top_groups()
-            settings_mask = {"top_group": valid_top_groups[0]}
-            self.raise_redirect(reason, settings_mask=settings_mask)
-
-        valid_top_groups = (FOLDER_GROUP,)
-        self._validate_top_group(valid_top_groups)
-        self.valid_nav_groups = valid_top_groups
-
-    def _validate_browser_group_settings(self):
-        """Check that all the view variables for browser mode are set right."""
-        # Validate Browser top_group
-        # Change top_group if its not in the valid top groups
-        valid_top_groups = self._get_valid_browse_top_groups()
-        self._validate_top_group(valid_top_groups)
-
-        # Validate pks
-        nav_group = self.kwargs["group"]
-        pks = self.kwargs["pks"]
-        if nav_group == ROOT_GROUP and (pks and 0 not in pks):
-            # r never has pks
-            reason = f"Redirect r with {pks=} to pks 0"
-            self.raise_redirect(reason)
-
-        # Validate Browser nav_group
-        # Redirect if nav group is wrong
-        self.set_valid_browse_nav_groups(valid_top_groups)
-
-    def _validate_story_arc_settings(self):
-        """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)

codex/views/opds/auth.py

@@ -1,17 +0,0 @@
-"""OPDS Authentican mixin."""
-
-from rest_framework.authentication import BasicAuthentication, SessionAuthentication
-
-from codex.views.auth import IsAuthenticatedOrEnabledNonUsers
-from codex.views.template import CodexXMLTemplateView
-
-
-class OPDSAuthMixin:
-    """Add Basic Auth."""
-
-    authentication_classes = (SessionAuthentication, BasicAuthentication)
-    permission_classes = (IsAuthenticatedOrEnabledNonUsers,)
-
-
-class OPDSTemplateView(OPDSAuthMixin, CodexXMLTemplateView):
-    """XML Template view with OPDSAuth."""

codex/views/public.py

@@ -1,36 +0,0 @@
-"""Public non-authenticated views."""
-
-from rest_framework.generics import GenericAPIView
-from rest_framework.mixins import RetrieveModelMixin
-
-from codex.logger.logging import get_logger
-from codex.models import AdminFlag
-from codex.serializers.auth import AuthAdminFlagsSerializer
-from codex.serializers.choices import CHOICES
-
-LOG = get_logger(__name__)
-_ADMIN_FLAG_KEYS = frozenset(
-    {
-        AdminFlag.FlagChoices.NON_USERS.value,
-        AdminFlag.FlagChoices.REGISTRATION.value,
-    }
-)
-
-
-class AdminFlagsView(GenericAPIView, RetrieveModelMixin):
-    """Get admin flags relevant to auth."""
-
-    serializer_class = AuthAdminFlagsSerializer
-    queryset = AdminFlag.objects.filter(key__in=_ADMIN_FLAG_KEYS).only("key", "on")
-
-    def get_object(self):
-        """Get admin flags."""
-        flags = {}
-        for obj in self.get_queryset():  # type: ignore
-            name = CHOICES["admin"]["adminFlags"][obj.key].lower().replace(" ", "_")
-            flags[name] = obj.on
-        return flags
-
-    def get(self, request, *args, **kwargs):
-        """Get admin flags relevant to auth."""
-        return self.retrieve(request, *args, **kwargs)

codex/views/reader/arcs.py

@@ -1,92 +0,0 @@
-"""Reader get Arcs methods."""
-
-from types import MappingProxyType
-
-from codex.models import AdminFlag
-from codex.util import max_none
-from codex.views.const import FOLDER_GROUP, STORY_ARC_GROUP
-from codex.views.reader.books import ReaderBooksView
-
-
-class ReaderArcsView(ReaderBooksView):
-    """Reader get Arcs methods."""
-
-    def __init__(self, *args, **kwargs):
-        """Initialize instance vars."""
-        super().__init__(*args, **kwargs)
-        self.params: MappingProxyType = MappingProxyType({})
-
-    def _get_group_arc(self, book, attr):
-        """Create the volume arc."""
-        group = getattr(book, attr, None)
-        if not group:
-            return None
-
-        _, arc_pks = self.get_group_pks_from_breadcrumbs([group])
-        if group.pk not in arc_pks:
-            arc_pks = (group.pk,)
-        return {
-            "group": attr[0],
-            "pks": arc_pks,
-            "name": group.name,
-            "mtime": group.updated_at,
-        }
-
-    def _get_folder_arc(self, book):
-        """Create the folder arc."""
-        efv_flag = (
-            AdminFlag.objects.only("on")
-            .get(key=AdminFlag.FlagChoices.FOLDER_VIEW.value)
-            .on
-        )
-        if not efv_flag:
-            return None
-
-        folder = book.parent_folder
-        return {
-            "group": FOLDER_GROUP,
-            "pks": (folder.pk,),
-            "name": folder.name,
-            "mtime": folder.updated_at,
-        }
-
-    def _get_story_arcs(self, book):
-        """Create story arcs."""
-        sas = []
-        for san in book.story_arc_numbers.all():
-            sa = san.story_arc
-            arc = {
-                "group": "a",
-                "pks": (sa.pk,),
-                "name": sa.name,
-                "mtime": sa.updated_at,
-            }
-            sas.append(arc)
-        return sorted(sas, key=lambda x: x["name"])
-
-    def get_arcs(self, book):
-        """Get all series/folder/story arcs."""
-        # create top arcs
-        arcs = []
-        top_group = self.params.get("top_group")
-        arc = None
-        if series_arc := self._get_group_arc(book, "series"):
-            arcs.append(series_arc)
-            arc = series_arc
-        if volume_arc := self._get_group_arc(book, "volume"):
-            arcs.append(volume_arc)
-            if not arc:
-                arc = volume_arc
-        if folder_arc := self._get_folder_arc(book):
-            arcs.append(folder_arc)
-            if top_group == FOLDER_GROUP:
-                arc = folder_arc
-        if story_arcs := self._get_story_arcs(book):
-            arcs = [*arcs, *story_arcs]
-            if top_group == STORY_ARC_GROUP:
-                arc = story_arcs[0]
-
-        max_mtime = None
-        for arc in arcs:
-            max_mtime = max_none(max_mtime, arc["mtime"])
-        return arcs, max_mtime

codex/views/reader/books.py

@@ -1,181 +0,0 @@
-"""Get Books methods."""
-
-from typing import TYPE_CHECKING
-
-from django.db.models import F
-
-from codex.models import Bookmark, Comic
-from codex.views.bookmark import BookmarkBaseView
-from codex.views.const import FOLDER_GROUP, NONE_INTEGERFIELD
-from codex.views.mixins import SharedAnnotationsMixin
-from codex.views.reader.init import ReaderInitView
-
-if TYPE_CHECKING:
-    from collections.abc import Mapping
-
-_SETTINGS_ATTRS = ("fit_to", "two_pages", "reading_direction")
-_COMIC_FIELDS = (
-    "file_type",
-    "issue_number",
-    "issue_suffix",
-    "page_count",
-    "series",
-    "volume",
-    "reading_direction",
-    "updated_at",
-)
-
-
-class ReaderBooksView(BookmarkBaseView, ReaderInitView, SharedAnnotationsMixin):
-    """Get Books methods."""
-
-    def _get_reader_arc_pks(  # noqa: PLR0913
-        self, arc, arc_pk_select_related, prefetch_related, arc_pk_rel, arc_group
-    ):
-        """Get the nav filter."""
-        if arc_pks := arc.get("pks", ()):
-            return arc_pks
-
-        comic_pk = self.kwargs["pk"]
-        try:
-            arc_pk_qs = Comic.objects.filter(pk=comic_pk)
-            arc_pk_qs = arc_pk_qs.select_related(*arc_pk_select_related)
-            arc_pk_qs = arc_pk_qs.prefetch_related(*prefetch_related)
-            arc_pk_qs = arc_pk_qs.values_list(arc_pk_rel, flat=True)
-            arc_pk = arc_pk_qs.first()
-        except IndexError:
-            arc_pk = 0
-
-        _, multi_arc_pks = self.get_group_pks_from_breadcrumbs([arc_group])
-        if not arc_pk or arc_pk in multi_arc_pks:
-            arc_pks = multi_arc_pks
-
-        if not arc_pks:
-            arc_pks = (arc_pk,)
-
-        return arc_pks
-
-    def _get_comics_list(self):
-        """Get the reader naviation group filter."""
-        select_related = ("series", "volume")
-        prefetch_related = ()
-
-        arc: Mapping = self.params.get("arc", {})  # type: ignore
-
-        arc_group = arc.get("group", "s")
-        if arc_group == "a":
-            # for story arcs
-            rel = "story_arc_numbers__story_arc"
-            fields = _COMIC_FIELDS
-            arc_pk_rel = "story_arc_numbers__story_arc__pk"
-            prefetch_related = (*prefetch_related, "story_arc_numbers__story_arc")
-            arc_index = F("story_arc_numbers__number")
-            ordering = ("arc_index", "date", "pk")
-            arc_pk_select_related = ()
-        elif arc_group == FOLDER_GROUP:
-            # folder mode
-            rel = "parent_folder"
-            fields = (*_COMIC_FIELDS, "parent_folder")
-            arc_pk_rel = "parent_folder__pk"
-            arc_index = NONE_INTEGERFIELD
-            ordering = ("path", "pk")
-            arc_pk_select_related = ("parent_folder",)
-        elif arc_group == "v":
-            # volume
-            rel = "volume"
-            fields = _COMIC_FIELDS
-            arc_pk_rel = "volume__pk"
-            arc_index = NONE_INTEGERFIELD
-            ordering = ()
-            arc_pk_select_related = ("volume",)
-        else:
-            # series
-            rel = "series"
-            fields = _COMIC_FIELDS
-            arc_pk_rel = "series__pk"
-            arc_index = NONE_INTEGERFIELD
-            ordering = ()
-            arc_pk_select_related = ("series",)
-
-        arc_pks = self._get_reader_arc_pks(
-            arc, arc_pk_select_related, prefetch_related, arc_pk_rel, arc_group
-        )
-        nav_filter = {f"{rel}__in": arc_pks}
-        group_acl_filter = self.get_group_acl_filter(Comic)
-
-        qs = (
-            Comic.objects.filter(group_acl_filter)
-            .filter(**nav_filter)
-            .select_related(*select_related)
-            .prefetch_related(*prefetch_related)
-            .only(*fields)
-            .annotate(
-                issue_count=F("volume__issue_count"),
-            )
-            .annotate(
-                arc_pk=F(arc_pk_rel),
-                arc_index=arc_index,
-            )
-            .annotate(mtime=F("updated_at"))
-        )
-        qs = self.annotate_group_names(qs, Comic)
-        if arc_group in ("v", "s"):
-            show = self.params["show"]
-            model_group = "i" if arc_group == "s" else "s"
-            qs, comic_sort_names = self.alias_sort_names(
-                qs, Comic, pks=arc_pks, model_group=model_group, show=show
-            )
-            ordering = (
-                *comic_sort_names,
-                "issue_number",
-                "issue_suffix",
-                "sort_name",
-            )
-        qs = qs.order_by(*ordering)
-        return qs, arc_group
-
-    def _append_with_settings(self, book, bookmark_filter):
-        """Append bookmark to book list."""
-        book.settings = (
-            Bookmark.objects.filter(**bookmark_filter, comic=book)
-            .only(*_SETTINGS_ATTRS)
-            .first()
-        )
-        return book
-
-    def get_book_collection(self):
-        """Get the -1, +1 window around the current issue.
-
-        Uses iteration in python. There are some complicated ways of
-        doing this with __gt[0] & __lt[0] in the db, but I think they
-        might be even more expensive.
-
-        Yields 1 to 3 books
-        """
-        comics, arc_group = self._get_comics_list()
-        bookmark_filter = self.get_bookmark_search_kwargs()
-        books = {}
-        prev_book = None
-        pk = self.kwargs.get("pk")
-        for index, book in enumerate(comics):
-            if books:
-                # after match set next comic and break
-                books["next"] = self._append_with_settings(book, bookmark_filter)
-                break
-            if book.pk == pk:
-                # first match. set previous and current comic
-                if prev_book:
-                    books["prev"] = self._append_with_settings(
-                        prev_book, bookmark_filter
-                    )
-                # create extra current book attrs:
-                if book.arc_index is None:
-                    book.arc_index = index + 1
-                book.filename = book.get_filename()
-                book.arc_group = arc_group
-                book.arc_count = comics.count()
-                books["current"] = self._append_with_settings(book, bookmark_filter)
-            else:
-                # Haven't matched yet, so set the previous comic
-                prev_book = book
-        return books

codex/views/reader/init.py

@@ -1,125 +0,0 @@
-"""Views for reading comic books."""
-
-from copy import deepcopy
-from types import MappingProxyType
-
-from codex.logger.logging import get_logger
-from codex.models import Comic
-from codex.serializers.reader import (
-    ReaderViewInputSerializer,
-)
-from codex.views.const import FOLDER_GROUP, GROUP_RELATION, STORY_ARC_GROUP
-from codex.views.session import SessionView
-from codex.views.util import reparse_json_query_params
-
-LOG = get_logger(__name__)
-VALID_ARC_GROUPS = frozenset({"s", "v", "f", "a"})
-_JSON_KEYS = frozenset({"arc", "breadcrumbs", "show"})
-_BROWSER_SESSION_DEFAULTS = SessionView.SESSION_DEFAULTS[
-    SessionView.BROWSER_SESSION_KEY
-]
-_DEFAULT_PARAMS = {
-    "breadcrumbs": _BROWSER_SESSION_DEFAULTS["breadcrumbs"],
-    "show": _BROWSER_SESSION_DEFAULTS["show"],
-    "top_group": _BROWSER_SESSION_DEFAULTS["top_group"],
-}
-
-
-class ReaderInitView(SessionView):
-    """Reader initialization."""
-
-    input_serializer_class = ReaderViewInputSerializer
-
-    def __init__(self, *args, **kwargs):
-        """Initialize instance vars."""
-        super().__init__(*args, **kwargs)
-        self.group_pks: dict[str, tuple[int, ...]] = {}
-
-    def _set_group_pks_from_breadcrumbs(self, groups, breadcrumbs):
-        """Set Multi-Group pks from breadcrumbs to the cache."""
-        index = len(breadcrumbs) - 1
-        min_index = max(index - 1, 0) if FOLDER_GROUP in groups else 0
-        while index > min_index:
-            crumb = breadcrumbs[index]
-            crumb_group = crumb.get("group")
-            if crumb_group in groups:
-                pks = crumb.get("pks", ())
-                self.group_pks[crumb_group] = pks
-                break
-            index -= 1
-        else:
-            crumb_group = ""
-            pks = ()
-            for group in groups:
-                self.group_pks[group] = pks
-        return crumb_group, pks
-
-    def get_group_pks_from_breadcrumbs(self, groups):
-        """Get Multi-Group pks from the breadcrumbs."""
-        # Return cached values
-        for group in groups:
-            if pks := self.group_pks.get(group):
-                return group, pks
-
-        # Validate input
-        breadcrumbs: tuple = self.params.get("breadcrumbs")  # type: ignore
-        if not breadcrumbs:
-            return "", ()
-
-        return self._set_group_pks_from_breadcrumbs(groups, breadcrumbs)
-
-    def _ensure_arc_contains_comic(self, params):
-        """Arc sanity check."""
-        arc = params.get("arc")
-        if not arc:
-            return
-        pk = self.kwargs["pk"]
-        arc_group = arc.get("group")
-        arc_pks = arc.get("pks")
-        valid = False
-        if rel := GROUP_RELATION.get(arc_group):
-            arc_filter = {rel: arc_pks}
-            valid = Comic.objects.filter(pk=pk, **arc_filter).exists()
-        if not valid:
-            LOG.warning(f"Invalid arc {arc} submitted to reader for comic {pk}.")
-            params.pop("arc", None)
-
-    def _ensure_arc(self, params):
-        """arc.group validation."""
-        # Can't be in the serializer
-        arc = params.get("arc", {})
-
-        if arc.get("group") not in VALID_ARC_GROUPS:
-            top_group = params["top_group"]
-            if top_group in (FOLDER_GROUP, STORY_ARC_GROUP):
-                search_groups = (top_group,)
-            else:
-                search_groups = ("v", "s")
-
-            group, pks = self.get_group_pks_from_breadcrumbs(search_groups)
-            if not group:
-                group = "s"
-
-            arc["group"] = group
-            if pks:
-                arc["pks"] = pks
-
-        params["arc"] = arc
-
-    def _parse_params(self):
-        try:
-            data = self.request.GET
-            data = reparse_json_query_params(self.request.GET, _JSON_KEYS)
-            serializer = self.input_serializer_class(data=data)
-            serializer.is_valid(raise_exception=True)
-
-            params = deepcopy(_DEFAULT_PARAMS)
-            if serializer.validated_data:
-                params.update(serializer.validated_data)  # type: ignore
-            self._ensure_arc_contains_comic(params)
-            self._ensure_arc(params)
-
-            self.params = MappingProxyType(params)
-        except Exception:
-            LOG.exception("validate")
-            raise