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

codex/views/browser/metadata/copy_intersections.py

@@ -1,90 +0,0 @@
-"""Copy Intersections Into Comic Fields."""
-
-from codex.logger.logging import get_logger
-from codex.models.comic import Comic
-from codex.serializers.browser.metadata import PREFETCH_PREFIX
-from codex.views.browser.metadata.query_intersections import (
-    MetadataQueryIntersectionsView,
-)
-
-LOG = get_logger(__name__)
-_COMIC_VALUE_FIELDS_CONFLICTING = frozenset(
-    {
-        "created_at",
-        "name",
-        "path",
-        "updated_at",
-    }
-)
-_COMIC_VALUE_FIELDS_CONFLICTING_PREFIX = "conflict_"
-_PATH_GROUPS = frozenset({"c", "f"})
-
-
-class MetadataCopyIntersectionsView(MetadataQueryIntersectionsView):
-    """Copy Intersections Into Comic Fields."""
-
-    def _path_security(self, obj):
-        """Secure filesystem information for acl situation."""
-        group = self.kwargs["group"]
-        is_path_group = group in _PATH_GROUPS
-        if is_path_group:
-            if self.is_admin:
-                return
-            if self.admin_flags["folder_view"]:
-                obj.path = obj.search_path()
-        else:
-            obj.path = ""
-
-    def _highlight_current_group(self, obj):
-        """Values for highlighting the current group."""
-        if self.model and self.model is not Comic:
-            # move the name of the group to the correct field
-            field = self.model.__name__.lower() + "_list"
-            group_list = self.model.objects.filter(pk__in=obj.ids).values("name")
-            setattr(obj, field, group_list)
-            obj.name = None
-
-    @classmethod
-    def _copy_m2m_intersections(cls, obj, m2m_intersections):
-        """Copy the m2m intersections into the object."""
-        # XXX It might even be faster to copy everything to a dict and not use the obj.
-        for key, qs in m2m_intersections.items():
-            serializer_key = (
-                f"{PREFETCH_PREFIX}{key}"
-                if key in ("identifiers", "contributors", "story_arc_numbers")
-                else key
-            )
-            if hasattr(obj, serializer_key):
-                # real db fields need to use their special set method.
-                field = getattr(obj, serializer_key)
-                field.set(
-                    qs,
-                    clear=True,
-                )
-            else:
-                # fake db field is just a queryset attached.
-                setattr(obj, serializer_key, qs)
-
-    @staticmethod
-    def _copy_groups(obj, groups):
-        for field, group_qs in groups.items():
-            setattr(obj, field + "_list", group_qs)
-
-    @staticmethod
-    def _copy_conflicting_simple_fields(obj):
-        for field in _COMIC_VALUE_FIELDS_CONFLICTING:
-            """Copy conflicting fields over naturral fields."""
-            conflict_field = _COMIC_VALUE_FIELDS_CONFLICTING_PREFIX + field
-            val = getattr(obj, conflict_field)
-            setattr(obj, field, val)
-
-    def copy_intersections_into_comic_fields(self, obj, groups, m2m_intersections):
-        """Copy a bunch of values that i couldn't fit cleanly in the main queryset."""
-        self._path_security(obj)
-        self._highlight_current_group(obj)
-        self._copy_groups(obj, groups)
-        self._copy_m2m_intersections(obj, m2m_intersections)
-        if self.model is not Comic:
-            self._copy_conflicting_simple_fields(obj)
-
-        return obj

codex/views/browser/metadata/metadata.py

@@ -1,83 +0,0 @@
-"""Aggregate Group and Comic Metadata View."""
-
-from types import MappingProxyType
-
-from drf_spectacular.utils import extend_schema
-from rest_framework.exceptions import NotFound
-from rest_framework.response import Response
-
-from codex.logger.logging import get_logger
-from codex.models import AdminFlag
-from codex.serializers.browser.metadata import MetadataSerializer
-from codex.serializers.browser.settings import BrowserFilterChoicesInputSerilalizer
-from codex.views.browser.metadata.copy_intersections import (
-    MetadataCopyIntersectionsView,
-)
-
-LOG = get_logger(__name__)
-
-
-class MetadataView(MetadataCopyIntersectionsView):
-    """Aggregate Group and Comic Metadata View."""
-
-    serializer_class = MetadataSerializer
-    input_serializer_class = BrowserFilterChoicesInputSerilalizer
-    TARGET = "metadata"
-    ADMIN_FLAG_VALUE_KEY_MAP = MappingProxyType(
-        {
-            AdminFlag.FlagChoices.FOLDER_VIEW.value: "folder_view",
-        }
-    )
-
-    def _get_valid_browse_nav_groups(self, valid_top_groups):  # noqa: ARG002
-        """Limited allowed nav groups for metadata."""
-        # Overrides method in browser.validate
-        group = self.kwargs["group"]
-        return (group,)
-
-    def _raise_not_found(self, exc=None):
-        """Raise an exception if the object is not found."""
-        pks = self.kwargs["pks"]
-        group = self.kwargs["group"]
-        detail = f"Filtered metadata for {group}/{pks} not found"
-        raise NotFound(detail=detail) from exc
-
-    def get_object(self):
-        """Create a comic-like object from the current browser group."""
-        # Comic model goes through the same code path as groups because
-        # values dicts don't copy relations to the serializer. The values
-        # dict is necessary because of the folders view union in browser.py.
-
-        qs = self.get_filtered_queryset(self.model)
-        filtered_qs = qs
-
-        # Annotate
-        qs = self.annotate_order_aggregates(qs)
-        qs = self.annotate_card_aggregates(qs)
-        qs = self._annotate_values_and_fks(qs, filtered_qs)
-        qs = self.add_group_by(qs)
-        qs = self.force_inner_joins(qs)
-
-        # Get Object
-        try:
-            obj = qs[0]
-            if not obj:
-                reason = "Empty obj"
-                raise ValueError(reason)  # noqa TRY301
-        except (IndexError, ValueError) as exc:
-            return self._raise_not_found(exc)
-
-        # Hacks to add to object after query
-        groups, m2m_intersections = self.query_intersections(filtered_qs)
-        return self.copy_intersections_into_comic_fields(obj, groups, m2m_intersections)
-
-    @extend_schema(parameters=[input_serializer_class])
-    def get(self, *_args, **_kwargs):
-        """Get metadata for a filtered browse group."""
-        # Init
-        try:
-            obj = self.get_object()
-            serializer = self.get_serializer(obj)
-            return Response(serializer.data)
-        except Exception:
-            LOG.exception(f"Getting metadata {self.kwargs}")

codex/views/browser/metadata/query_intersections.py

@@ -1,112 +0,0 @@
-"""Metadata query fk & m2m intersections."""
-
-from types import MappingProxyType
-
-from django.db.models import Count
-
-from codex.librarian.importer.const import COMIC_M2M_FIELD_NAMES
-from codex.logger.logging import get_logger
-from codex.models import Comic
-from codex.models.functions import JsonGroupArray
-from codex.views.browser.metadata.annotate import MetadataAnnotateView
-from codex.views.const import METADATA_GROUP_RELATION
-
-LOG = get_logger(__name__)
-_CONTRIBUTOR_RELATIONS = ("role", "person")
-_GROUP_RELS = MappingProxyType(
-    {
-        "i": ("publisher",),
-        "s": (
-            "publisher",
-            "imprint",
-        ),
-        "v": (
-            "publisher",
-            "imprint",
-            "series",
-        ),
-        "c": ("publisher", "imprint", "series", "volume"),
-    }
-)
-
-
-class MetadataQueryIntersectionsView(MetadataAnnotateView):
-    """Metadata query fk & m2m intersections."""
-
-    def _query_groups(self):
-        """Query the through models to show group lists."""
-        groups = {}
-        if not self.model:
-            return groups
-        group = self.kwargs["group"]
-        rel = METADATA_GROUP_RELATION.get(group)
-        if not rel:
-            return groups
-        rel = rel + "__in"
-        pks = self.kwargs["pks"]
-        group_filter = {rel: pks}
-
-        for field_name in _GROUP_RELS.get(group, ()):
-            field = self.model._meta.get_field(field_name)
-            model = field.related_model
-            if not model:
-                continue
-
-            qs = model.objects.filter(**group_filter)
-            qs = qs.only("name").distinct()
-            qs = qs.group_by("name")
-            qs = qs.annotate(ids=JsonGroupArray("id", distinct=True))
-            qs = qs.values("ids", "name")
-            groups[field_name] = qs
-        return groups
-
-    @staticmethod
-    def _get_optimized_m2m_query(key, qs):
-        if key == "contributors":
-            qs = qs.prefetch_related(*_CONTRIBUTOR_RELATIONS)
-            qs = qs.only(*_CONTRIBUTOR_RELATIONS)
-        elif key == "story_arc_numbers":
-            qs = qs.select_related("story_arc")
-            qs = qs.only("story_arc", "number")
-        elif key == "identifiers":
-            qs = qs.select_related("identifier_type")
-            qs = qs.only("identifier_type", "nss", "url")
-        else:
-            qs = qs.only("name")
-        return qs
-
-    def _get_m2m_intersection_query(self, field_name, comic_pks, comic_pks_count):
-        """Get intersection query for one field."""
-        model = Comic._meta.get_field(field_name).related_model
-        if not model:
-            reason = f"No model found for comic field: {field_name}"
-            raise ValueError(reason)
-
-        intersection_qs = model.objects.filter(comic__pk__in=comic_pks)
-        intersection_qs = intersection_qs.alias(count=Count("comic")).filter(
-            count=comic_pks_count
-        )
-        return self._get_optimized_m2m_query(field_name, intersection_qs)
-
-    def _query_m2m_intersections(self, filtered_qs):
-        """Query the through models to figure out m2m intersections."""
-        # Speed ok, but still does a query per m2m model
-        m2m_intersections = {}
-        pk_field = self.rel_prefix + "pk"
-        comic_pks = filtered_qs.distinct().values_list(pk_field, flat=True)
-        # In fts mode the join doesn't work for the query.
-        # Evaluating it now is probably faster than running the filter for every m2m anyway.
-        comic_pks = set(comic_pks)
-        comic_pks_count = len(comic_pks)
-
-        for field_name in COMIC_M2M_FIELD_NAMES:
-            m2m_intersections[field_name] = self._get_m2m_intersection_query(
-                field_name, comic_pks, comic_pks_count
-            )
-        return m2m_intersections
-
-    def query_intersections(self, filtered_qs):
-        """Query complex intersections."""
-        groups = self._query_groups()
-        m2m_intersections = self._query_m2m_intersections(filtered_qs)
-        return groups, m2m_intersections

codex/views/browser/params.py

@@ -1,64 +0,0 @@
-"""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/timezone.py

@@ -1,54 +0,0 @@
-"""Set timezone from browser endpoint."""
-
-from drf_spectacular.utils import extend_schema
-from rest_framework.response import Response
-
-from codex.logger.logging import get_logger
-from codex.models import UserActive
-from codex.serializers.auth import TimezoneSerializer
-from codex.serializers.mixins import OKSerializer
-from codex.views.auth import AuthGenericAPIView
-
-LOG = get_logger(__name__)
-
-
-class TimezoneView(AuthGenericAPIView):
-    """User info."""
-
-    input_serializer_class = TimezoneSerializer
-    serializer_class = OKSerializer
-
-    def _save_timezone(self, django_timezone):
-        """Save django timezone in session."""
-        if not django_timezone:
-            return
-        session = self.request.session
-        session["django_timezone"] = django_timezone
-        session.save()
-
-    def _update_user_active(self):
-        """Update user activity."""
-        user = self.request.user
-        if user and user.is_authenticated:
-            UserActive.objects.update_or_create(user=user)
-
-    @extend_schema(request=input_serializer_class)
-    def put(self, *args, **kwargs):
-        """Get the user info for the current user."""
-        data = self.request.data  # type: ignore
-        serializer = self.input_serializer_class(data=data)
-        serializer.is_valid(raise_exception=True)
-        try:
-            self._save_timezone(serializer.validated_data.get("timezone"))  # type: ignore
-        except Exception as exc:
-            reason = f"update user timezone {exc}"
-            LOG.warning(reason)
-
-        try:
-            self._update_user_active()
-        except Exception as exc:
-            reason = f"update user activity {exc}"
-            LOG.warning(reason)
-
-        serializer = self.get_serializer()
-        return Response(serializer.data)