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

codex/views/browser/breadcrumbs.py

@@ -1,202 +0,0 @@
-"""Browser breadcrumbs calculations."""
-
-from contextlib import suppress
-from types import MappingProxyType
-
-from codex.logger.logging import get_logger
-from codex.views.browser.paginate import BrowserPaginateView
-from codex.views.const import FOLDER_GROUP, GROUP_NAME_MAP, GROUP_ORDER, STORY_ARC_GROUP
-from codex.views.util import Route
-
-LOG = get_logger(__name__)
-
-
-class BrowserBreadcrumbsView(BrowserPaginateView):
-    """Browser breadcrumbs calculations."""
-
-    def _init_breadcrumbs(self, valid_groups):
-        """Load breadcrumbs and determine if they should be searched for a graft."""
-        breadcrumbs: list[Route] = list(self.params.get("breadcrumbs", []))
-        old_breadcrumbs = [Route(**crumb) for crumb in breadcrumbs]
-        invalid = not old_breadcrumbs or old_breadcrumbs[-1].group not in valid_groups
-        if invalid:
-            old_breadcrumbs = []
-        return old_breadcrumbs, invalid
-
-    def _breadcrumbs_save(self, breadcrumbs):
-        """Save the breadcrumbs to params."""
-        params = dict(self.params)
-        params["breadcrumbs"] = tuple(crumb.dict() for crumb in breadcrumbs)
-        self.params = MappingProxyType(params)
-
-    def _breadcrumbs_graft_or_create_story_arc(self) -> tuple[tuple[Route, ...], bool]:
-        """Graft or create story_arc breadcrumbs."""
-        old_breadcrumbs, changed = self._init_breadcrumbs(STORY_ARC_GROUP)
-
-        pks = self.kwargs["pks"]
-        page = self.kwargs["page"]
-        gi = self.group_instance  # type: ignore
-        name = gi.name if gi else ""
-        group_crumb = Route(STORY_ARC_GROUP, pks, page, name)
-
-        if old_breadcrumbs and old_breadcrumbs[-1] & group_crumb:
-            # Graft. Hurray
-            breadcrumbs = old_breadcrumbs
-        else:
-            # Create
-            new_breadcrumbs = [group_crumb]
-            if group_crumb.pks and 0 not in group_crumb.pks:
-                # Add head.
-                new_breadcrumbs = [Route(STORY_ARC_GROUP, ()), *new_breadcrumbs]
-            changed = True
-            breadcrumbs = new_breadcrumbs
-
-        return tuple(breadcrumbs), changed
-
-    @staticmethod
-    def _breadcrumb_find_branch(reverse_breadcrumbs, crumb) -> list[Route] | None:
-        """Find a graftable breadcrumb branch."""
-        for index, breadcrumb in enumerate(reverse_breadcrumbs):
-            if breadcrumb & crumb:
-                return list(reversed(reverse_breadcrumbs[index:]))
-        return None
-
-    def _breadcrumbs_graft_or_create_folder(self) -> tuple[tuple[Route, ...], bool]:
-        """Graft or create folder breadcrumbs."""
-        old_breadcrumbs, changed = self._init_breadcrumbs(FOLDER_GROUP)
-
-        reversed_breadcrumbs = list(reversed(old_breadcrumbs))
-
-        pks = self.kwargs["pks"]
-        page = self.kwargs["page"]
-        folder = self.group_instance  # type: ignore
-        name = folder.name if folder and pks else ""
-        group_crumb = Route(FOLDER_GROUP, pks, page, name)
-        new_breadcrumbs = []
-
-        while True:
-            branch = self._breadcrumb_find_branch(reversed_breadcrumbs, group_crumb)
-            if branch and not branch[0].pks:
-                # Branch must have the top as a head.
-                # Graft. Hurray.
-                new_breadcrumbs = branch + new_breadcrumbs
-                break
-
-            # Add head
-            new_breadcrumbs = [group_crumb, *new_breadcrumbs]
-            changed = True
-            if not group_crumb.pks:
-                break
-
-            # parent next
-            if not folder:
-                break
-            folder = folder.parent_folder
-            if folder:
-                group_crumb = Route(FOLDER_GROUP, (folder.pk,), 1, name=folder.name)
-            else:
-                group_crumb = Route(FOLDER_GROUP, (), 1, name="")
-
-        breadcrumbs = new_breadcrumbs
-
-        return tuple(breadcrumbs), changed
-
-    def _get_breadcrumbs_group_crumb(self, group):
-        """Create the crumb for this group."""
-        gi = self.group_instance  # type: ignore
-        if not gi:
-            pks = ()
-            page = 1
-            name = ""
-        if group == self.kwargs["group"]:
-            # create self crumb
-            pks = self.kwargs["pks"]
-            page = self.kwargs["page"]
-            name = gi.name if gi else ""
-        else:
-            page = 1
-            if (attr := GROUP_NAME_MAP.get(group)) and (
-                parent_group := getattr(gi, attr, None)
-            ):
-                pks = (parent_group.pk,)
-                name = parent_group.name
-            else:
-                pks = ()
-                name = ""
-
-        return Route(group, pks, page, name)
-
-    def _breadcrumbs_graft_or_create_group_crumb(
-        self, group, old_breadcrumbs, new_breadcrumbs, changed
-    ) -> tuple[bool, bool]:
-        """Graft or create one browse group breadcrumb."""
-        group_crumb = self._get_breadcrumbs_group_crumb(group)
-
-        if old_breadcrumbs and (
-            (group_crumb == old_breadcrumbs[-1])
-            or (changed and (group_crumb & old_breadcrumbs[-1]))
-            and not old_breadcrumbs[0].pks
-        ):
-            # Graft. Hurray
-            new_breadcrumbs[0:0] = old_breadcrumbs
-            done = True
-        else:
-            # Insert the new node
-            new_breadcrumbs.insert(0, group_crumb)
-            changed = True
-            done = False
-        return done, changed
-
-    def _breadcrumbs_graft_or_create_group(self) -> tuple[tuple[Route, ...], bool]:
-        """Graft or create browse group breadcrumbs."""
-        old_breadcrumbs, changed = self._init_breadcrumbs(GROUP_ORDER)
-
-        vng = self.valid_nav_groups  # type: ignore
-        test_groups = tuple(reversed(vng[:-1]))
-        new_breadcrumbs = []
-        level = done = False
-        try:
-            browser_group_index = GROUP_ORDER.index(self.kwargs["group"])
-        except ValueError:
-            browser_group_index = -1
-
-        for group in test_groups:
-            try:
-                with suppress(ValueError):
-                    level = level or GROUP_ORDER.index(group) <= browser_group_index
-                if level:
-                    done, changed = self._breadcrumbs_graft_or_create_group_crumb(
-                        group, old_breadcrumbs, new_breadcrumbs, changed
-                    )
-                try:
-                    if old_breadcrumbs and GROUP_ORDER.index(
-                        old_breadcrumbs[-1].group
-                    ) >= GROUP_ORDER.index(group):
-                        # Trim old_breadcrumbs to match to group
-                        old_breadcrumbs.pop(-1)
-                except ValueError:
-                    old_breadcrumbs = []
-
-                if done:
-                    break
-            except Exception:
-                LOG.exception("group loop")
-
-        return tuple(new_breadcrumbs), changed
-
-    def get_breadcrumbs(
-        self,
-    ) -> tuple[Route, ...]:
-        """Graft or create breadcrumbs by browser mode."""
-        group = self.kwargs["group"]
-        if group == FOLDER_GROUP:
-            breadcrumbs, changed = self._breadcrumbs_graft_or_create_folder()
-        elif group == STORY_ARC_GROUP:
-            breadcrumbs, changed = self._breadcrumbs_graft_or_create_story_arc()
-        else:
-            breadcrumbs, changed = self._breadcrumbs_graft_or_create_group()
-
-        if changed:
-            self._breadcrumbs_save(breadcrumbs)
-
-        return breadcrumbs

codex/views/browser/cover.py

@@ -1,165 +0,0 @@
-"""Comic cover thumbnail view."""
-
-from django.db.models.query import Q
-from django.http.response import StreamingHttpResponse
-from drf_spectacular.types import OpenApiTypes
-from drf_spectacular.utils import extend_schema
-from rest_framework.renderers import BaseRenderer
-
-from codex.librarian.covers.create import CoverCreateMixin
-from codex.librarian.covers.path import CoverPathMixin
-from codex.librarian.mp_queue import LIBRARIAN_QUEUE
-from codex.logger.logging import get_logger
-from codex.models import Comic, Volume
-from codex.models.groups import Folder
-from codex.models.paths import CustomCover
-from codex.serializers.browser.settings import BrowserCoverInputSerializer
-from codex.views.browser.annotations import BrowserAnnotationsView
-from codex.views.const import (
-    CUSTOM_COVER_GROUP_RELATION,
-    GROUP_RELATION,
-    MISSING_COVER_FN,
-    MISSING_COVER_NAME_MAP,
-    STATIC_IMG_PATH,
-)
-from codex.views.util import chunker
-
-LOG = get_logger(__name__)
-
-
-class WEBPRenderer(BaseRenderer):
-    """Render WEBP images."""
-
-    media_type = "image/webp"
-    format = "webp"
-    charset = None
-    render_style = "binary"
-
-    def render(self, data, *_args, **_kwargs):
-        """Return raw data."""
-        return data
-
-
-class CoverView(BrowserAnnotationsView):
-    """ComicCover View."""
-
-    input_serializer_class = BrowserCoverInputSerializer
-    renderer_classes = (WEBPRenderer,)
-    content_type = "image/webp"
-    TARGET = "cover"
-    REPARSE_JSON_FIELDS = frozenset(
-        BrowserAnnotationsView.REPARSE_JSON_FIELDS | {"parent"}
-    )
-
-    def get_group_filter(self, group=None, pks=None, page_mtime=False):
-        """Get group filter for First Cover View."""
-        if self.params.get("dynamic_covers") or self.model in (Volume, Folder):
-            return super().get_group_filter(group=group, pks=pks, page_mtime=page_mtime)
-
-        # First cover group filter relies on sort names to look outside the browser supplied pks
-        # For multi_groups not in the browser query.
-        pks = self.kwargs["pks"]
-        qs = self.model.objects.filter(pk__in=pks)  # type: ignore
-        sort_names = qs.values_list("sort_name", flat=True).distinct()
-        model_rel = GROUP_RELATION[self.model_group]
-        group_filter = {f"{model_rel}__sort_name__in": sort_names}
-
-        parent = self.params.get("parent", {})
-        if parent_pks := parent.get("pks"):
-            parent_rel = GROUP_RELATION[parent["group"]]
-            group_filter[f"{parent_rel}__pk__in"] = parent_pks
-        return Q(**group_filter)
-
-    def get_model_group(self):
-        """Return the url group."""
-        return self.kwargs["group"]
-
-    def init_request(self):
-        """Initialize request."""
-        self.parse_params()
-        self.set_model()
-
-    def _get_comic_cover(self):
-        pks = self.kwargs["pks"]
-        return pks[0], False
-
-    def _get_custom_cover(self):
-        """Get Custom Cover."""
-        if self.model == Volume or not self.params.get("custom_covers"):
-            return None
-        group = self.kwargs["group"]
-        group_rel = CUSTOM_COVER_GROUP_RELATION[group]
-        pks = self.kwargs["pks"]
-        comic_filter = {f"{group_rel}__in": pks}
-        qs = CustomCover.objects.filter(**comic_filter)
-        qs = qs.only("pk")
-        return qs.first()
-
-    def _get_dynamic_cover(self):
-        """Get dynamic cover."""
-        self.set_order_key()
-        comic_qs = self.get_filtered_queryset(Comic)
-        comic_qs = self.annotate_order_aggregates(comic_qs, Comic)
-        comic_qs = self.add_order_by(comic_qs, Comic)
-        comic_qs = comic_qs.only("pk")
-        group_by = self.get_group_by(Comic)
-        comic_qs.group_by(group_by)
-        comic = comic_qs.first()
-        cover_pk = comic.pk if comic else 0
-        return cover_pk, False
-
-    def _get_cover_pk(self) -> tuple[int, bool]:
-        """Get Cover Pk queryset for comic queryset."""
-        if self.model == Comic:
-            cover_pk, custom = self._get_comic_cover()
-        elif custom_cover := self._get_custom_cover():
-            cover_pk = custom_cover.pk
-            custom = True
-        else:
-            cover_pk, custom = self._get_dynamic_cover()
-        return cover_pk, custom
-
-    def _get_missing_cover_path(self):
-        """Get the missing cover, which is a default svg if fetched for a group."""
-        group: str = self.kwargs["group"]
-        cover_name = MISSING_COVER_NAME_MAP.get(group)
-        if cover_name:
-            cover_fn = cover_name + ".svg"
-            content_type = "image/svg+xml"
-        else:
-            cover_fn = MISSING_COVER_FN
-            content_type = "image/webp"
-        cover_path = STATIC_IMG_PATH / cover_fn
-        return cover_path, content_type
-
-    def _get_cover_data(self, pk, custom):
-        thumb_buffer = None
-        content_type = "image/webp"
-
-        cover_path = CoverPathMixin.get_cover_path(pk, custom)
-        if not cover_path.exists():
-            thumb_buffer = CoverCreateMixin.create_cover_from_path(
-                pk, cover_path, LOG, LIBRARIAN_QUEUE, custom
-            )
-            if not thumb_buffer:
-                cover_path, content_type = self._get_missing_cover_path()
-        elif cover_path.stat().st_size == 0:
-            cover_path, content_type = self._get_missing_cover_path()
-
-        cover_file = thumb_buffer if thumb_buffer else cover_path.open("rb")
-        return cover_file, content_type
-
-    @extend_schema(
-        parameters=[BrowserAnnotationsView.input_serializer_class],
-        responses={(200, content_type): OpenApiTypes.BINARY},
-    )
-    def get(self, *args, **kwargs):  # type: ignore
-        """Get comic cover."""
-        try:
-            self.init_request()
-            pk, custom = self._get_cover_pk()
-            cover_file, content_type = self._get_cover_data(pk, custom)
-
-            return StreamingHttpResponse(chunker(cover_file), content_type=content_type)
-        except Exception:
-            LOG.exception("get")

codex/views/browser/mtime.py

@@ -1,61 +0,0 @@
-"""Get the mtimes for the submitted groups."""
-
-from drf_spectacular.utils import extend_schema
-from rest_framework.response import Response
-
-from codex.logger.logging import get_logger
-from codex.models.groups import Publisher
-from codex.serializers.browser.mtime import GroupsMtimeSerializer, MtimeSerializer
-from codex.util import max_none
-from codex.views.browser.filters.annotations import BrowserAnnotationsFilterView
-from codex.views.const import GROUP_MODEL_MAP
-
-LOG = get_logger(__name__)
-
-
-class MtimeView(BrowserAnnotationsFilterView):
-    """Get the mtimes for the submitted groups."""
-
-    input_serializer_class = GroupsMtimeSerializer
-    serializer_class = MtimeSerializer
-
-    REPARSE_JSON_FIELDS = frozenset({"groups", "filters"})
-    TARGET = "mtime"
-
-    def __init__(self, *args, **kwargs) -> None:
-        """Initialize."""
-        super().__init__(*args, **kwargs)
-        self.init_bookmark_data()
-
-    def _get_group_mtime(self, item):
-        """Get one group's mtimes."""
-        group = item["group"]
-        pks = item["pks"]
-
-        model = GROUP_MODEL_MAP[group]
-        if not model:
-            model = Publisher
-
-        return self.get_group_mtime(model, group, pks)
-
-    def get_max_groups_mtime(self):
-        """Get max mtime for all groups."""
-        max_mtime = None
-
-        for item in self.params["groups"]:  # type: ignore
-            mtime = self._get_group_mtime(item)
-            max_mtime = max_none(max_mtime, mtime)
-        return max_mtime
-
-    @extend_schema(parameters=[GroupsMtimeSerializer])
-    def get(self, *args, **kwargs):
-        """Get the mtimes for the submitted groups."""
-        # Parse Request
-        self.parse_params()
-
-        max_mtime = self.get_max_groups_mtime()
-
-        # Serialize Response
-        result = {"max_mtime": max_mtime}
-        serializer = self.get_serializer(result)
-        return Response(serializer.data)

codex/views/browser/order_by.py

@@ -1,65 +0,0 @@
-"""Base view for ordering the query."""
-
-from django.db.models.aggregates import Max, Min
-
-from codex.models import Comic
-from codex.views.browser.filters.annotations import (
-    BrowserAnnotationsFilterView,
-)
-
-
-class BrowserOrderByView(BrowserAnnotationsFilterView):
-    """Base class for views that need ordering."""
-
-    def set_order_key(self):
-        """Get the default order key for the view."""
-        self.order_key: str = self.params["order_by"]
-        order_reverse = self.params.get("order_reverse")
-        self.order_agg_func = Max if order_reverse else Min
-
-    def _add_comic_order_by(self, order_key, comic_sort_names):
-        """Order by for comics (and covers)."""
-        if not order_key:
-            order_key = self.order_key
-        if order_key == "sort_name":
-            if not comic_sort_names:
-                comic_sort_names = self.comic_sort_names  # type: ignore
-            order_fields_head = [
-                *comic_sort_names,
-                "issue_number",
-                "issue_suffix",
-                "sort_name",
-            ]
-        else:
-            # Comic orders on indexed fields directly
-            # Which is allegedly faster than using tmp b-trees (annotations)
-            # And since that's every cover sort, it's worth it.
-            order_fields_head = [order_key]
-            # Comic order micro optimizations
-            if order_key == "story_arc_number":
-                order_fields_head += ["date"]
-            elif order_key == "bookmark_updated_at":
-                order_fields_head += ["updated_at"]
-        return order_fields_head
-
-    def add_order_by(  # noqa: PLR0913
-        self, qs, model, order_key="", do_reverse=True, comic_sort_names=None
-    ):
-        """Create the order_by list."""
-        order_fields_head = ()
-        if model == Comic:
-            order_fields_head = self._add_comic_order_by(order_key, comic_sort_names)
-        else:
-            order_fields_head = ["order_value"]
-
-        order_fields = (*order_fields_head, "pk")
-
-        prefix = "-" if do_reverse and self.params.get("order_reverse") else ""
-        order_by = []
-        if prefix:
-            for field in order_fields:
-                order_by.append(prefix + field)
-        else:
-            order_by = order_fields
-
-        return qs.order_by(*order_by)

codex/views/browser/paginate.py

@@ -1,106 +0,0 @@
-"""Browser pagination."""
-
-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,
-)
-
-LOG = get_logger(__name__)
-
-
-class BrowserPaginateView(BrowserAnnotationsView):
-    """Browser pagination."""
-
-    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 (not pks and 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
-
-        # Adjust route mask for redirect
-        group = self.kwargs.get("group")
-        if num_pages and page > 1:
-            # Try page 1 first.
-            new_page = num_pages if num_pages and page > num_pages else 1
-            pks = pks if pks else "0"
-        else:
-            # Redirect to root for the group.
-            pks = "0"
-            new_page = 1
-
-        reason = f"{page=} does not exist!"
-        route_changes = {"group": group, "pks": pks, "page": new_page}
-        return self.raise_redirect(reason, route_mask=route_changes)
-
-    def _paginate_section(self, model, 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
-        except EmptyPage:
-            if model != Folder:
-                model_name = self.model.__name__ if self.model else "NO_MODEL"
-                LOG.warning(f"No {model_name}s on page {page}")
-            qs = model.objects.none()
-
-        return qs
-
-    def _paginate_groups(self, group_qs, total_group_count):
-        """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
-
-    def _paginate_books(self, book_qs, total_group_count, page_obj_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()
-        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
-
-                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
-                )
-        return page_book_qs
-
-    def paginate(self, group_qs, book_qs, group_count, book_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_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

codex/views/browser/settings.py

@@ -1,66 +0,0 @@
-"""Browser session view."""
-
-from codex.serializers.browser.settings import BrowserSettingsSerializer
-from codex.views.const import GROUP_ORDER
-from codex.views.settings import SettingsView
-
-
-class BrowserSettingsView(SettingsView):
-    """Get Browser Settings."""
-
-    # Put Browser Settings is normally done through BrowserView.get()
-    serializer_class = BrowserSettingsSerializer  # type: ignore
-
-    SESSION_KEY = SettingsView.BROWSER_SESSION_KEY
-
-    @staticmethod
-    def _strip_breadcrumb_names(params):
-        """Remove names from breadcrumbs."""
-        breadcrumbs = params.get("breadcrumbs")
-        if not breadcrumbs:
-            return params
-        nameless_breadcrumbs = []
-        for crumb in breadcrumbs:
-            crumb.pop("name", None)
-            nameless_breadcrumbs.append(crumb)
-        params["breadcrumbs"] = nameless_breadcrumbs
-        return params
-
-    @staticmethod
-    def _validate_browse_top_group(params, group, top_group):
-        """Validate top group for browse groups."""
-        show = params["show"]
-        if group == "r" or (
-            show.get(top_group)
-            and GROUP_ORDER.index(top_group) < GROUP_ORDER.index(group)
-        ):
-            return
-
-        for show_group, on in show.items():
-            if on:
-                params["top_group"] = show_group
-                break
-        else:
-            params["top_group"] = "c"
-
-    @classmethod
-    def _validate_top_group(cls, params, group, top_group):
-        """Validate top group."""
-        if group == top_group:
-            return
-
-        if group in ("f", "a"):
-            params["top_group"] = group
-        else:
-            cls._validate_browse_top_group(params, group, top_group)
-
-    def validate_settings_get(self, validated_data, params):
-        """Change bad settings."""
-        top_group = params["top_group"]
-        group = validated_data.get("group", "r") if validated_data else "r"
-        self._validate_top_group(params, group, top_group)
-
-        if not validated_data.get("breadcrumb_names", True):
-            params = self._strip_breadcrumb_names(params)
-
-        return params