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

codex/views/reader/{init.py → params.py}

@@ -1,8 +1,9 @@
 """Views for reading comic books."""
 
-from copy import deepcopy
 from types import MappingProxyType
+from typing import Any
 
+from codex.choices import mapping_to_dict
 from codex.logger.logging import get_logger
 from codex.models import Comic
 from codex.serializers.reader import (
@@ -25,7 +26,7 @@ _DEFAULT_PARAMS = {
 }
 
 
-class ReaderInitView(SessionView):
+class ReaderParamsView(SessionView):
     """Reader initialization."""
 
     input_serializer_class = ReaderViewInputSerializer
@@ -33,9 +34,10 @@ class ReaderInitView(SessionView):
     def __init__(self, *args, **kwargs):
         """Initialize instance vars."""
         super().__init__(*args, **kwargs)
-        self.group_pks: dict[str, tuple[int, ...]] = {}
+        self._group_pks: dict[str, tuple[int, ...]] = {}
+        self._params: MappingProxyType[str, Any] | None = None
 
-    def _set_group_pks_from_breadcrumbs(self, groups, breadcrumbs):
+    def _get_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
@@ -44,29 +46,29 @@ class ReaderInitView(SessionView):
             crumb_group = crumb.get("group")
             if crumb_group in groups:
                 pks = crumb.get("pks", ())
-                self.group_pks[crumb_group] = pks
+                self._group_pks[crumb_group] = pks
                 break
             index -= 1
         else:
             crumb_group = ""
             pks = ()
             for group in groups:
-                self.group_pks[group] = pks
+                self._group_pks[group] = pks
         return crumb_group, pks
 
-    def get_group_pks_from_breadcrumbs(self, groups):
+    def get_group_pks_from_breadcrumbs(self, groups, params=None):
         """Get Multi-Group pks from the breadcrumbs."""
         # Return cached values
         for group in groups:
-            if pks := self.group_pks.get(group):
+            pks = self._group_pks.get(group)
+            if pks is not None:
                 return group, pks
 
-        # Validate input
-        breadcrumbs: tuple = self.params.get("breadcrumbs")  # type: ignore
-        if not breadcrumbs:
-            return "", ()
+        if params is None:
+            params = self.params
+        breadcrumbs: tuple = params.get("breadcrumbs", ())
 
-        return self._set_group_pks_from_breadcrumbs(groups, breadcrumbs)
+        return self._get_group_pks_from_breadcrumbs(groups, breadcrumbs)
 
     def _ensure_arc_contains_comic(self, params):
         """Arc sanity check."""
@@ -99,7 +101,7 @@ class ReaderInitView(SessionView):
             else:
                 search_groups = "vsip"
 
-            group, pks = self.get_group_pks_from_breadcrumbs(search_groups)
+            group, pks = self.get_group_pks_from_breadcrumbs(search_groups, params)
             if not group:
                 group = "s"
 
@@ -109,20 +111,24 @@ class ReaderInitView(SessionView):
 
         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
+    @property
+    def params(self):
+        """Memoized params property."""
+        if self._params is None:
+            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: dict = mapping_to_dict(_DEFAULT_PARAMS)  # type: ignore
+                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
+        return self._params

codex/views/reader/reader.py

@@ -58,7 +58,7 @@ class ReaderView(ReaderArcsView):
             task = LazyImportComicsTask(frozenset(import_pks))
             LIBRARIAN_QUEUE.put(task)
 
-    def get_object(self):
+    def get_object(self):  # type: ignore
         """Get the previous and next comics in a group or story arc."""
         # Books
         books = self.get_book_collection()
@@ -101,7 +101,6 @@ class ReaderView(ReaderArcsView):
     @extend_schema(parameters=[ReaderViewInputSerializer])
     def get(self, *args, **kwargs):
         """Get the book info."""
-        self._parse_params()
         obj = self.get_object()
         serializer = self.get_serializer(obj)
         return Response(serializer.data)

codex/views/session.py

@@ -4,77 +4,63 @@ from abc import ABC
 from copy import deepcopy
 from types import MappingProxyType
 
+from codex.choices import BROWSER_DEFAULTS, READER_DEFAULTS, mapping_to_dict
 from codex.logger.logging import get_logger
-from codex.serializers.choices import DEFAULTS
 from codex.views.auth import AuthFilterGenericAPIView
 from codex.views.util import pop_name
 
 LOG = get_logger(__name__)
 
+CONTRIBUTOR_PERSON_UI_FIELD = "contributors"
+STORY_ARC_UI_FIELD = "story_arcs"
+IDENTIFIER_TYPE_UI_FIELD = "identifier_type"
+
+_DYNAMIC_FILTER_DEFAULTS = MappingProxyType(
+    {
+        "age_rating": [],
+        "characters": [],
+        "country": [],
+        CONTRIBUTOR_PERSON_UI_FIELD: [],
+        "community_rating": [],
+        "critical_rating": [],
+        "decade": [],
+        "file_type": [],
+        "genres": [],
+        IDENTIFIER_TYPE_UI_FIELD: [],
+        "language": [],
+        "locations": [],
+        "monochrome": [],
+        "original_format": [],
+        "reading_direction": [],
+        "series_groups": [],
+        "stories": [],
+        STORY_ARC_UI_FIELD: [],
+        "tagger": [],
+        "tags": [],
+        "teams": [],
+        "year": [],
+    }
+)
+
 
 class SessionView(AuthFilterGenericAPIView, ABC):
     """Generic Session View."""
 
-    # Must override both of these
+    # Must override this
     SESSION_KEY = ""
-
-    CONTRIBUTOR_PERSON_UI_FIELD = "contributors"
-    STORY_ARC_UI_FIELD = "story_arcs"
-    IDENTIFIER_TYPE_UI_FIELD = "identifier_type"
-    _DYNAMIC_FILTER_DEFAULTS = MappingProxyType(
-        {
-            "age_rating": [],
-            "characters": [],
-            "country": [],
-            CONTRIBUTOR_PERSON_UI_FIELD: [],
-            "community_rating": [],
-            "critical_rating": [],
-            "decade": [],
-            "file_type": [],
-            "genres": [],
-            IDENTIFIER_TYPE_UI_FIELD: [],
-            "language": [],
-            "locations": [],
-            "monochrome": [],
-            "original_format": [],
-            "reading_direction": [],
-            "series_groups": [],
-            "stories": [],
-            STORY_ARC_UI_FIELD: [],
-            "tagger": [],
-            "tags": [],
-            "teams": [],
-            "year": [],
-        }
-    )
     FILTER_ATTRIBUTES = frozenset(_DYNAMIC_FILTER_DEFAULTS.keys())
     BROWSER_SESSION_KEY = "browser"
     READER_SESSION_KEY = "reader"
     SESSION_DEFAULTS = MappingProxyType(
         {
             BROWSER_SESSION_KEY: {
-                "breadcrumbs": DEFAULTS["breadcrumbs"],
+                **BROWSER_DEFAULTS,
                 "filters": {
-                    "bookmark": DEFAULTS["bookmarkFilter"],
+                    "bookmark": BROWSER_DEFAULTS["bookmark_filter"],
                     **_DYNAMIC_FILTER_DEFAULTS,
                 },
-                "order_by": DEFAULTS["orderBy"],
-                "order_reverse": DEFAULTS["orderReverse"],
-                "q": DEFAULTS["q"],
-                "search_results_limit": DEFAULTS["searchResultsLimit"],
-                "show": DEFAULTS["show"],
-                "dynamic_covers": DEFAULTS["dynamicCovers"],
-                "custom_covers": DEFAULTS["customCovers"],
-                "twenty_four_hour_time": DEFAULTS["twentyFourHourTime"],
-                "top_group": DEFAULTS["topGroup"],
-            },
-            READER_SESSION_KEY: {
-                "finish_on_last_page": DEFAULTS["finishOnLastPage"],
-                "fit_to": DEFAULTS["fitTo"],
-                "two_pages": DEFAULTS["twoPages"],
-                "read_rtl_in_reverse": DEFAULTS["readRtlInReverse"],
-                "reading_direction": DEFAULTS["readingDirection"],
             },
+            READER_SESSION_KEY: READER_DEFAULTS,
         }
     )
 
@@ -97,7 +83,8 @@ class SessionView(AuthFilterGenericAPIView, ABC):
             "breadcrumbs", session_key=self.BROWSER_SESSION_KEY
         )
         if not breadcrumbs:
-            breadcrumbs = DEFAULTS["breadcrumbs"]
+            default_breadcrumbs: tuple[dict] = BROWSER_DEFAULTS["breadcrumbs"]  # type: ignore
+            breadcrumbs = default_breadcrumbs
         last_route = breadcrumbs[-1]
         if not name:
             last_route = pop_name(last_route)
@@ -127,9 +114,11 @@ class SessionView(AuthFilterGenericAPIView, ABC):
             defaults = {}
             for key in only:
                 if key:
-                    defaults[key] = self.SESSION_DEFAULTS[session_key][key]
+                    defaults[key] = mapping_to_dict(
+                        self.SESSION_DEFAULTS[session_key][key]
+                    )
         else:
-            defaults = self.SESSION_DEFAULTS[session_key]
+            defaults = mapping_to_dict(self.SESSION_DEFAULTS[session_key])
 
         session = self.request.session.get(session_key, defaults)
         return self._get_source_values_or_set_defaults(defaults, session, {})
@@ -139,7 +128,7 @@ class SessionView(AuthFilterGenericAPIView, ABC):
         try:
             # Deepcopy this so serializing the values later later for http response doesn't alter them
             params = deepcopy(dict(params))
-            defaults = self.SESSION_DEFAULTS[self.SESSION_KEY]
+            defaults = mapping_to_dict(self.SESSION_DEFAULTS[self.SESSION_KEY])
             data = self._get_source_values_or_set_defaults(defaults, params, {})
             self.request.session[self.SESSION_KEY] = data
             self.request.session.save()

codex/views/timezone.py

@@ -0,0 +1,54 @@
+"""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)

codex/views/version.py

@@ -15,7 +15,7 @@ class VersionView(AuthGenericAPIView):
 
     serializer_class = VersionsSerializer
 
-    def get_object(self):
+    def get_object(self) -> dict[str, str]:  # type: ignore
         """Get the versions."""
         ts = Timestamp.objects.get(key=Timestamp.TimestampChoices.CODEX_VERSION.value)
         if ts.version:

{codex-1.7.0a0.dist-info → codex-1.7.0a1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: codex
-Version: 1.7.0a0
+Version: 1.7.0a1
 Summary: A comic archive web server.
 Home-page: https://github.com/ajslater/codex
 License: GPL-3.0-only