codex 1.7.3a2__py3-none-any.whl → 1.7.5__py3-none-any.whl

codex/asgi.py

@@ -1,4 +1,5 @@
-"""ASGI config for codex project.
+"""
+ASGI config for codex project.
 
 It exposes the ASGI callable as a module-level variable named ``DJANGO_APPLICATION``.
 

codex/choices/__init__.py

@@ -0,0 +1 @@
+"""Enums and Choices for models and Seralizers."""

codex/{choices.py → choices/admin.py}

@@ -1,114 +1,7 @@
-"""Frontend Choices, Defaults and Messages."""
+"""Admin Choices."""
 
 from types import MappingProxyType
 
-BROWSER_BOOKMARK_FILTER_CHOICES = MappingProxyType(
-    {
-        "": "All",
-        "IN_PROGRESS": "In Progress",
-        "READ": "Read",
-        "UNREAD": "Unread",
-    },
-)
-BROWSER_ORDER_BY_CHOICES = MappingProxyType(
-    {
-        "created_at": "Added Time",
-        "age_rating": "Age Rating",
-        "child_count": "Child Count",
-        "community_rating": "Community Rating",
-        "critical_rating": "Critical Rating",
-        "filename": "Filename",
-        "size": "File Size",
-        "bookmark_updated_at": "Last Read",
-        "sort_name": "Name",
-        "page_count": "Page Count",
-        "date": "Publish Date",
-        "search_score": "Search Score",
-        "story_arc_number": "Story Arc Number",
-        "updated_at": "Updated Time",
-    }
-)
-_GROUP_NAMES = {
-    "p": "Publishers",
-    "i": "Imprints",
-    "s": "Series",
-    "v": "Volumes",
-}
-BROWSER_TOP_GROUP_CHOICES = MappingProxyType(
-    {
-        **_GROUP_NAMES,
-        "c": "Issues",
-        "f": "Folders",
-        "a": "Story Arcs",
-    },
-)
-VUETIFY_NULL_CODE = -1
-BROWSER_CHOICES = MappingProxyType(
-    {
-        "bookmark_filter": BROWSER_BOOKMARK_FILTER_CHOICES,
-        "order_by": BROWSER_ORDER_BY_CHOICES,
-        "top_group": BROWSER_TOP_GROUP_CHOICES,
-        "vuetify_null_code": VUETIFY_NULL_CODE,
-        "settings_group": {**_GROUP_NAMES},
-        "identifier_types": {
-            "comicvine": "Comic Vine",
-            "comixology": "Comixology",
-            "asin": "Amazon",
-            "gtin": "GTIN",
-            "isbn": "ISBN",
-            "upc": "UPC",
-        },
-    }
-)
-
-READER_CHOICES = MappingProxyType(
-    {
-        "fit_to": MappingProxyType(
-            {
-                "H": "Fit to Height",
-                "O": "Original Size",
-                "S": "Fit to Screen",
-                "W": "Fit to Width",
-            }
-        ),
-        "reading_direction": MappingProxyType(
-            {
-                "btt": "Bottom to Top",
-                "ltr": "Left to Right",
-                "rtl": "Right to Left",
-                "ttb": "Top to Bottom",
-            }
-        ),
-    }
-)
-DEFAULT_BROWSER_ROUTE = MappingProxyType({"group": "r", "pks": (0,), "page": 1})
-_DEFAULT_BROWSER_BREADCRUMBS = (DEFAULT_BROWSER_ROUTE,)
-_DEFAULT_SHOW = MappingProxyType({"i": False, "p": True, "s": True, "v": False})
-BROWSER_DEFAULTS = MappingProxyType(
-    {
-        "bookmark_filter": "",
-        "breadcrumbs": _DEFAULT_BROWSER_BREADCRUMBS,
-        "custom_covers": True,
-        "dynamic_covers": True,
-        "order_by": "sort_name",
-        "order_reverse": False,
-        "q": "",
-        # "search_results_limit": 100,
-        "show": _DEFAULT_SHOW,
-        "top_group": "p",
-        "twenty_four_hour_time": False,
-    }
-)
-READER_DEFAULTS = MappingProxyType(
-    {
-        "finish_on_last_page": True,
-        "fit_to": "S",
-        "reading_direction": "ltr",
-        "read_rtl_in_reverse": False,
-        "two_pages": False,
-    }
-)
-
 ADMIN_FLAG_CHOICES = MappingProxyType(
     {
         "AU": "Auto Update",
@@ -323,21 +216,6 @@ ADMIN_TASK_GROUPS = MappingProxyType(
                     },
                 ],
             },
-            {
-                "title": "Notify",
-                "tasks": [
-                    {
-                        "value": "notify_library_changed",
-                        "title": "Notify Library Changed ",
-                        "desc": "Signal all clients that the libraries have changed and the browser should fetch new data.",
-                    },
-                    {
-                        "value": "notify_librarian_status",
-                        "title": "Notify Librarian Status",
-                        "desc": "Signal Admin clients to fetch librarian status.",
-                    },
-                ],
-            },
             {
                 "title": "Cleanup",
                 "tasks": [
@@ -384,28 +262,51 @@ ADMIN_TASK_GROUPS = MappingProxyType(
                     },
                 ],
             },
-        )
-    }
-)
-
-
-def _group_task_values(groups):
-    """Extract values into sorted tuple."""
-    values = []
-    for group in groups["tasks"]:
-        for item in group["tasks"]:
-            values.append(item["value"])
-    return tuple(sorted(values))
-
-
-ADMIN_TASKS = _group_task_values(ADMIN_TASK_GROUPS)
-WEBSOCKET_MESSAGES = MappingProxyType(
-    {
-        "messages": {
-            "FAILED_IMPORTS": "FAILED_IMPORTS",
-            "LIBRARY_CHANGED": "LIBRARY_CHANGED",
-            "LIBRARIAN_STATUS": "LIBRARIAN_STATUS",
-        }
+            {
+                "title": "Notify",
+                "tasks": [
+                    {
+                        "value": "notify_admin_flags_changed",
+                        "title": "Notify Admin Flags Changed",
+                        "desc": "Notify all users that admin flags have changed.",
+                    },
+                    {
+                        "value": "notify_bookmark_changed",
+                        "title": "Notify Bookmark Changed",
+                        "desc": "Notify only your user that a bookmark changed.",
+                    },
+                    {
+                        "value": "notify_covers_changed",
+                        "title": "Notify Covers Changed",
+                        "desc": "Notify all users that covers have changed.",
+                    },
+                    {
+                        "value": "notify_failed_imports_changed",
+                        "title": "Notify Failed Imports Changed",
+                        "desc": "Notify admin users that failed imports have changed",
+                    },
+                    {
+                        "value": "notify_groups_changed",
+                        "title": "Notify Groups Changed",
+                        "desc": "Notify all users that ACL groups have changed.",
+                    },
+                    {
+                        "value": "notify_library_changed",
+                        "title": "Notify Library Changed ",
+                        "desc": "Notify all users libraries have changed.",
+                    },
+                    {
+                        "value": "notify_librarian_status",
+                        "title": "Notify Librarian Status",
+                        "desc": "Notify admin users that a librarian job status changed..",
+                    },
+                    {
+                        "value": "notify_users_changed",
+                        "title": "Notify Users Changed",
+                        "desc": "Notify one user that their users changed or all users if a user was deleted.",
+                    },
+                ],
+            },
+        ),
     }
 )
-DUMMY_NULL_NAME = "_none_"

codex/choices/browser.py

@@ -0,0 +1,85 @@
+"""Browser Choices."""
+
+from types import MappingProxyType
+
+BROWSER_BOOKMARK_FILTER_CHOICES = MappingProxyType(
+    {
+        "": "All",
+        "IN_PROGRESS": "In Progress",
+        "READ": "Read",
+        "UNREAD": "Unread",
+    },
+)
+BROWSER_ORDER_BY_CHOICES = MappingProxyType(
+    {
+        "created_at": "Added Time",
+        "age_rating": "Age Rating",
+        "child_count": "Child Count",
+        "community_rating": "Community Rating",
+        "critical_rating": "Critical Rating",
+        "filename": "Filename",
+        "size": "File Size",
+        "bookmark_updated_at": "Last Read",
+        "sort_name": "Name",
+        "page_count": "Page Count",
+        "date": "Publish Date",
+        "search_score": "Search Score",
+        "story_arc_number": "Story Arc Number",
+        "updated_at": "Updated Time",
+    }
+)
+_GROUP_NAMES = MappingProxyType(
+    {
+        "p": "Publishers",
+        "i": "Imprints",
+        "s": "Series",
+        "v": "Volumes",
+    }
+)
+BROWSER_TOP_GROUP_CHOICES = MappingProxyType(
+    {
+        **_GROUP_NAMES,
+        "c": "Issues",
+        "f": "Folders",
+        "a": "Story Arcs",
+    },
+)
+BROWSER_GROUP_CHOICES = MappingProxyType({**BROWSER_TOP_GROUP_CHOICES, "r": "Root"})
+VUETIFY_NULL_CODE = -1
+BROWSER_CHOICES = MappingProxyType(
+    {
+        "bookmark_filter": BROWSER_BOOKMARK_FILTER_CHOICES,
+        "order_by": BROWSER_ORDER_BY_CHOICES,
+        "top_group": BROWSER_TOP_GROUP_CHOICES,
+        "vuetify_null_code": VUETIFY_NULL_CODE,
+        "settings_group": {**_GROUP_NAMES},
+        "identifier_types": {
+            "comicvine": "Comic Vine",
+            "comixology": "Comixology",
+            "asin": "Amazon",
+            "gtin": "GTIN",
+            "isbn": "ISBN",
+            "upc": "UPC",
+        },
+    }
+)
+
+DEFAULT_BROWSER_ROUTE = MappingProxyType({"group": "r", "pks": (0,), "page": 1})
+_DEFAULT_BROWSER_BREADCRUMBS = (DEFAULT_BROWSER_ROUTE,)
+_DEFAULT_SHOW = MappingProxyType({"i": False, "p": True, "s": True, "v": False})
+BROWSER_DEFAULTS = MappingProxyType(
+    {
+        "bookmark_filter": "",
+        "breadcrumbs": _DEFAULT_BROWSER_BREADCRUMBS,
+        "custom_covers": True,
+        "dynamic_covers": True,
+        "order_by": "sort_name",
+        "order_reverse": False,
+        "q": "",
+        "show": _DEFAULT_SHOW,
+        "top_group": "p",
+        "twenty_four_hour_time": False,
+    }
+)
+
+DUMMY_NULL_NAME = "_none_"

codex/{choices_to_json.py → choices/choices_to_json.py}

@@ -8,16 +8,15 @@ from types import MappingProxyType
 
 from caseconverter import camelcase
 
-from codex.choices import (
+from codex.choices.admin import (
     ADMIN_FLAG_CHOICES,
     ADMIN_STATUS_TITLES,
     ADMIN_TASK_GROUPS,
-    BROWSER_CHOICES,
-    BROWSER_DEFAULTS,
-    READER_CHOICES,
-    READER_DEFAULTS,
-    WEBSOCKET_MESSAGES,
 )
+from codex.choices.browser import BROWSER_CHOICES, BROWSER_DEFAULTS
+from codex.choices.notifications import Notifications
+from codex.choices.reader import READER_CHOICES, READER_DEFAULTS
+from codex.serializers.route import RouteSerializer
 
 _DEFAULTS = MappingProxyType(
     {"browser-choices.json": BROWSER_DEFAULTS, "reader-choices.json": READER_DEFAULTS}
@@ -38,12 +37,11 @@ _MAP_DUMPS = MappingProxyType(
         "browser-defaults.json": BROWSER_DEFAULTS,
         "browser-map.json": BROWSER_CHOICES,
         "reader-map.json": READER_CHOICES,
-        "websocket-messages.json": WEBSOCKET_MESSAGES,
     }
 )
 
 
-def _to_vuetify_choices(defaults, key, obj_map):
+def _to_vuetify_choices(defaults, key: str, obj_map):
     """Transform a dict into a list of vuetify choices."""
     default = defaults.get(key)
     vuetify_list = []
@@ -58,7 +56,7 @@ def _to_vuetify_choices(defaults, key, obj_map):
     return vuetify_list
 
 
-def _json_key(key):
+def _json_key(key: str):
     """Transform key to json version."""
     return key if key.upper() == key else camelcase(key)
 
@@ -68,19 +66,18 @@ def _make_json_serializable(data):
     if isinstance(data, Mapping):
         json_dict = {}
         for key, value in data.items():
-            if key == "pks":
-                # Special route serializer
-                # XXX possibly should use actual route serializer for route not just pks
-                json_dict[key] = ",".join(str(pk) for pk in sorted(value))
+            if key == "breadcrumbs":
+                json_value = tuple(RouteSerializer(dict(route)).data for route in value)
             else:
-                json_dict[_json_key(key)] = _make_json_serializable(value)
+                json_value = _make_json_serializable(value)
+            json_dict[_json_key(key)] = json_value
         return json_dict
     if isinstance(data, list | tuple | frozenset | set):
         return [_make_json_serializable(item) for item in data]
     return data
 
 
-def _to_vuetify_dict(fn, data):
+def _to_vuetify_dict(fn: str, data):
     """Convert mappings to vuetify dict list."""
     vuetify_data = {}
     defaults = _DEFAULTS.get(fn) or {}
@@ -93,17 +90,23 @@ def _to_vuetify_dict(fn, data):
     return vuetify_data
 
 
-def _dump(parent_path, fn, data, vuetify=True):
+def _dump(parent_path: Path, fn: str, data, vuetify: bool):
     """Dump data to json file."""
     vuetify_data = (
         _to_vuetify_dict(fn, data) if vuetify else _make_json_serializable(data)
     )
-    path = parent_path / Path(fn)
+    path = parent_path / fn
     with path.open("w") as json_file:
         json.dump(vuetify_data, json_file, indent=2)
         json_file.write("\n")
 
 
+def _make_websocket_messages():
+    return MappingProxyType(
+        {"messages": {msg.name: msg.value for msg in Notifications}}
+    )
+
+
 def main():
     """Dump all files."""
     import sys
@@ -112,10 +115,13 @@ def main():
     parent_path = Path(parent_path)
     parent_path.mkdir(exist_ok=True)
     for fn, data in _DUMPS.items():
-        _dump(parent_path, fn, data)
+        _dump(parent_path, fn, data, vuetify=True)
 
     for fn, data in _MAP_DUMPS.items():
-        _dump(parent_path, fn, data, False)
+        _dump(parent_path, fn, data, vuetify=False)
+
+    ws_messages = _make_websocket_messages()
+    _dump(parent_path, "websocket-messages.json", ws_messages, vuetify=False)
 
 
 if __name__ == "__main__":

codex/choices/notifications.py

@@ -0,0 +1,16 @@
+"""Notification messages."""
+
+from enum import Enum
+
+
+class Notifications(Enum):
+    """Websocket Notifications."""
+
+    ADMIN_FLAGS = "ADMIN_FLAGS_CHANGED"
+    BOOKMARK = "BOOKMARK_CHANGED"
+    COVERS = "COVERS_CHANGED"
+    FAILED_IMPORTS = "FAILED_IMPORTS"
+    GROUPS = "GROUPS_CHANGED"
+    LIBRARY = "LIBRARY_CHANGED"
+    LIBRARIAN_STATUS = "LIBRARIAN_STATUS"
+    USERS = "USERS_CHANGED"

codex/choices/reader.py

@@ -0,0 +1,33 @@
+"""Frontend Choices, Defaults and Messages."""
+
+from types import MappingProxyType
+
+READER_CHOICES = MappingProxyType(
+    {
+        "fit_to": MappingProxyType(
+            {
+                "H": "Fit to Height",
+                "O": "Original Size",
+                "S": "Fit to Screen",
+                "W": "Fit to Width",
+            }
+        ),
+        "reading_direction": MappingProxyType(
+            {
+                "btt": "Bottom to Top",
+                "ltr": "Left to Right",
+                "rtl": "Right to Left",
+                "ttb": "Top to Bottom",
+            }
+        ),
+    }
+)
+READER_DEFAULTS = MappingProxyType(
+    {
+        "finish_on_last_page": True,
+        "fit_to": "S",
+        "reading_direction": "ltr",
+        "read_rtl_in_reverse": False,
+        "two_pages": False,
+    }
+)

codex/db.py

@@ -62,7 +62,7 @@ def _backup_db_before_migration():
     """If there are migrations to do, backup the db."""
     backup_path = _get_backup_db_path(f"before-v{VERSION}")
     janitor = Janitor(LOG_QUEUE, LIBRARIAN_QUEUE)
-    janitor.backup_db(backup_path, show_status=False)
+    janitor.backup_db(show_status=False, backup_path=backup_path)
     LOG.info("Backed up database before migrations")
 
 
@@ -71,7 +71,7 @@ def _repair_db():
     if FIX_FOREIGN_KEYS:
         fix_foreign_keys()
     if INTEGRITY_CHECK:
-        integrity_check()
+        integrity_check(long=True)
     success = fts_integrity_check() if FTS_INTEGRITY_CHECK else True
     if FTS_REBUILD or not success:
         fts_rebuild()

codex/exceptions.py

@@ -1,8 +1,8 @@
 """Special Redirect Error."""
 
+from collections.abc import Mapping
 from copy import deepcopy
 from pprint import pformat
-from typing import TYPE_CHECKING
 
 from django.core.validators import EMPTY_VALUES
 from django.shortcuts import redirect
@@ -11,16 +11,12 @@ from django.utils.http import urlencode
 from rest_framework.exceptions import APIException
 from rest_framework.status import HTTP_303_SEE_OTHER
 
-from codex.choices import DEFAULT_BROWSER_ROUTE
+from codex.choices.browser import DEFAULT_BROWSER_ROUTE
 from codex.logger.logging import get_logger
-from codex.serializers.fields import BreadcrumbsField
+from codex.serializers.fields.browser import BreadcrumbsField
 from codex.serializers.route import RouteSerializer
 from codex.views.util import pop_name
 
-if TYPE_CHECKING:
-    from collections.abc import Mapping
-
-
 LOG = get_logger(__name__)
 _OPDS_REDIRECT_SETTINGS_KEYS = ("order_by", "top_group")
 _REDIRECT_SETTINGS_KEYS = ("breadcrumbs", *_OPDS_REDIRECT_SETTINGS_KEYS)
@@ -71,7 +67,10 @@ class SeeOtherRedirectError(APIException):
     def _add_query_params(self, url):
         """Change OPDS settings like the frontend does with error.detail."""
         query_params = {}
-        settings: Mapping = self.detail.get("settings", {})  # type: ignore
+        if isinstance(self.detail, Mapping):
+            settings = self.detail.get("settings", {})
+        else:
+            settings = {}
         for key in _OPDS_REDIRECT_SETTINGS_KEYS:
             value = settings.get(key)
             if value not in EMPTY_VALUES:

codex/librarian/bookmark/bookmarkd.py

@@ -21,15 +21,19 @@ class BookmarkThread(AggregateMessageQueuedThread, BookmarkUpdate):
         else:
             self.log.warning(f"Unknown Bookmark task {item}")
 
+    def _send_item(self, filters, updates):
+        """Process one item."""
+        auth_filter, comic_pks = filters
+        auth_filter = dict(auth_filter)
+        self.update_bookmarks(auth_filter, comic_pks, updates, self.log)
+        self.log.debug(f"updated {auth_filter} pk__in={comic_pks}")
+
     def send_all_items(self):
         """Run the task method."""
         cleanup = set()
         for filters, updates in self.cache.items():
             try:
-                auth_filter, comic_pks = filters
-                auth_filter = dict(auth_filter)
-                self.update_bookmarks(auth_filter, comic_pks, updates, self.log)
-                self.log.debug(f"updated {auth_filter} pk__in={comic_pks}")
+                self._send_item(filters, updates)
                 cleanup.add(filters)
             except Exception:
                 self.log.exception("Updating bookmarks")