codex 1.6.0a6__py3-none-any.whl → 1.6.0a8__py3-none-any.whl

codex/views/browser/browser_breadcrumbs.py

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

codex/views/browser/const.py

@@ -1,3 +0,0 @@
-"""Browser constants."""
-
-MAX_OBJ_PER_PAGE = 100

codex/views/cover.py

@@ -1,78 +0,0 @@
-"""Comic cover thumbnail view."""
-
-from typing import ClassVar
-
-from django.http import HttpResponse
-from drf_spectacular.types import OpenApiTypes
-from drf_spectacular.utils import extend_schema
-from rest_framework.renderers import BaseRenderer
-from rest_framework.views import APIView
-
-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.views.auth import GroupACLMixin, IsAuthenticatedOrEnabledNonUsers
-from codex.views.const import MISSING_COVER_FN, MISSING_COVER_NAME_MAP, STATIC_IMG_PATH
-
-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(APIView, GroupACLMixin):
-    """ComicCover View."""
-
-    permission_classes: ClassVar[list] = [IsAuthenticatedOrEnabledNonUsers]  # type: ignore
-    renderer_classes = (WEBPRenderer,)
-    content_type = "image/webp"
-
-    def _get_missing_cover_path(self):
-        # Get the missing cover, which is a default svg if fetched for a group.
-        data = self.request.GET
-        group: str = data.get("group", "c")  # type: ignore
-        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
-
-    @extend_schema(responses={(200, content_type): OpenApiTypes.BINARY})
-    def get(self, *_args, **_kwargs):
-        """Get comic cover."""
-        thumb_image_data = None
-        content_type = "image/webp"
-
-        custom: bool = self.request.GET.get("custom") == "1"
-        pk = self.kwargs.get("pk")
-        cover_path = CoverPathMixin.get_cover_path(pk, custom)
-        if not cover_path.exists():
-            thumb_image_data = CoverCreateMixin.create_cover_from_path(
-                pk, cover_path, LOG, LIBRARIAN_QUEUE, custom
-            )
-            if not thumb_image_data:
-                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()
-
-        if not thumb_image_data:
-            # if not thumb_image_data:
-            with cover_path.open("rb") as f:
-                thumb_image_data = f.read()
-
-        return HttpResponse(thumb_image_data, content_type=content_type)