codex 1.7.14__py3-none-any.whl → 1.8.0a2__py3-none-any.whl

codex/__init__.py

@@ -6,7 +6,12 @@ from django import setup
 
 from codex.signals.django_signals import connect_signals
 
+if environ.get("PYTHONDEVMODE"):
+    from icecream import install
+
+    install()
+
 # This all happens before anything else to make django safe to use.
-environ.setdefault("DJANGO_SETTINGS_MODULE", "codex.settings.settings")
+environ.setdefault("DJANGO_SETTINGS_MODULE", "codex.settings")
 setup()
 connect_signals()

codex/applications/lifespan.py

@@ -3,33 +3,36 @@
 import asyncio
 from contextlib import suppress
 
-from codex.logger_base import LoggerBaseMixin
+from loguru import logger
+
 from codex.signals.os_signals import bind_signals_to_loop
+from codex.startup.logger_init import init_logging
 from codex.websockets.listener import BroadcastListener
 
 
-class LifespanApplication(LoggerBaseMixin):
+class LifespanApplication:
     """Lifespan AGSI App."""
 
     SCOPE_TYPE = "lifespan"
 
-    def __init__(self, log_queue, broadcast_queue):
+    def __init__(self, broadcast_queue):
         """Create logger and librarian."""
-        self.init_logger(log_queue)
+        init_logging()
         self.broadcast_queue = broadcast_queue
-        self.broadcast_listener = BroadcastListener(broadcast_queue, log_queue)
+        self.broadcast_listener = BroadcastListener(logger, broadcast_queue)
+        self.broadcast_listener_task = None
 
     async def _event(self, event, send):
         """Process a lifespan event."""
         try:
-            self.log.debug(f"Lifespan {event} started.")
+            logger.debug(f"Lifespan {event} started.")
             func = getattr(self, "_" + event)
             await func()
             await send({"type": f"lifespan.{event}.complete"})
-            self.log.debug(f"Lifespan {event} complete.")
+            logger.debug(f"Lifespan {event} complete.")
         except Exception:
             await send({"type": f"lifespan.{event}.failed"})
-            self.log.exception(f"Lifespan {event} failed.")
+            logger.exception(f"Lifespan {event} failed.")
             raise
 
     async def _startup(self):
@@ -44,13 +47,14 @@ class LifespanApplication(LoggerBaseMixin):
         with suppress(ValueError):
             # Depending on timing this can be closed already
             self.broadcast_queue.put(None)
-        await self.broadcast_listener_task
+        if self.broadcast_listener_task:
+            await self.broadcast_listener_task
 
     async def __call__(self, scope, receive, send):
         """Lifespan application."""
         if scope["type"] != self.SCOPE_TYPE:
             return
-        self.log.debug("Lifespan application started.")
+        logger.debug("Lifespan application started.")
         while True:
             try:
                 message = await receive()
@@ -60,5 +64,5 @@ class LifespanApplication(LoggerBaseMixin):
                     await self._event("shutdown", send)
                     break
             except Exception:
-                self.log.exception("Lifespan application")
-        self.log.debug("Lifespan application stopped.")
+                logger.exception("Lifespan application")
+        logger.debug("Lifespan application stopped.")

codex/asgi.py

@@ -12,13 +12,12 @@ from django.core.asgi import get_asgi_application
 
 from codex.applications.lifespan import LifespanApplication
 from codex.applications.websocket import WEBSOCKET_APPLICATION
-from codex.logger.mp_queue import LOG_QUEUE
 from codex.websockets.aio_queue import BROADCAST_QUEUE
 
 application = ProtocolTypeRouter(
     {
         "http": get_asgi_application(),
         "websocket": WEBSOCKET_APPLICATION,
-        "lifespan": LifespanApplication(LOG_QUEUE, BROADCAST_QUEUE),
+        "lifespan": LifespanApplication(BROADCAST_QUEUE),
     }
 )

codex/choices/admin.py

@@ -2,47 +2,45 @@
 
 from types import MappingProxyType
 
-from bidict import frozenbidict
+from django.db.models.enums import TextChoices
+
+
+class AdminFlagChoices(TextChoices):
+    """Choices for Admin Flags."""
+
+    AUTO_UPDATE = "AU"
+    BANNER_TEXT = "BT"
+    FOLDER_VIEW = "FV"
+    IMPORT_METADATA = "IM"
+    LAZY_IMPORT_METADATA = "LI"
+    NON_USERS = "NU"
+    REGISTRATION = "RG"
+    SEND_TELEMETRY = "ST"
 
-from codex.librarian.covers.status import CoverStatusTypes
-from codex.librarian.importer.status import ImportStatusTypes
-from codex.librarian.janitor.status import JanitorStatusTypes
-from codex.librarian.search.status import SearchIndexStatusTypes
-from codex.librarian.watchdog.status import WatchdogStatusTypes
 
 ADMIN_FLAG_CHOICES = MappingProxyType(
     {
-        "AU": "Auto Update",
-        "FV": "Folder View",
-        "IM": "Import Metadata on Library Scan",
-        "NU": "Non Users",
-        "RG": "Registration",
-        "ST": "Send Stats",
-        "BT": "Banner Text",
+        AdminFlagChoices.AUTO_UPDATE.value: "Auto Update",
+        AdminFlagChoices.BANNER_TEXT.value: "Banner Text",
+        AdminFlagChoices.FOLDER_VIEW.value: "Folder View",
+        AdminFlagChoices.IMPORT_METADATA.value: "Import Metadata on Library Scan",
+        AdminFlagChoices.LAZY_IMPORT_METADATA.value: "Import Metadata on Demand",
+        AdminFlagChoices.NON_USERS.value: "Non Users",
+        AdminFlagChoices.REGISTRATION.value: "Registration",
+        AdminFlagChoices.SEND_TELEMETRY.value: "Send Stats",
     }
 )
 
-ADMIN_STATUS_TITLES = frozenbidict(
-    sorted(
-        (key, val)
-        for status_types in (
-            CoverStatusTypes,
-            ImportStatusTypes,
-            JanitorStatusTypes,
-            SearchIndexStatusTypes,
-            WatchdogStatusTypes,
-        )
-        for key, val in status_types.choices
-    )
-)
 
 # Easier to store in vuetify format
-ADMIN_TASK_GROUPS = MappingProxyType(
+ADMIN_TASK_GROUPS: MappingProxyType[
+    str, tuple[dict[str, str | tuple[dict[str, str], ...]], ...]
+] = MappingProxyType(
     {
         "tasks": (
             {
                 "title": "Libraries",
-                "tasks": [
+                "tasks": (
                     {
                         "value": "poll",
                         "title": "Poll All Libraries",
@@ -65,11 +63,16 @@ ADMIN_TASK_GROUPS = MappingProxyType(
                         "title": "Sync Watchdog with DB",
                         "desc": "Ensure the Watchdog file watcher is enabled per database preferences for each library",
                     },
-                ],
+                    {
+                        "value": "import_abort",
+                        "title": "Abort Running Import",
+                        "desc": "Abort the current running import after the current import subtask is complete",
+                    },
+                ),
             },
             {
                 "title": "Covers",
-                "tasks": [
+                "tasks": (
                     {
                         "value": "purge_comic_covers",
                         "title": "Remove Comic Covers",
@@ -87,36 +90,20 @@ ADMIN_TASK_GROUPS = MappingProxyType(
                         "title": "Update Group Timestamps",
                         "desc": "Force the update of group timestamps. Will bust the browser cache for browser views and covers.",
                     },
-                ],
+                ),
             },
             {
                 "title": "Search Index",
-                "tasks": [
-                    {
-                        "value": "search_index_update",
-                        "title": "Update Search Index",
-                        "desc": "with recently changed comics",
-                    },
+                "tasks": (
                     {
                         "value": "search_index_optimize",
                         "title": "Optimize Search Index",
                         "desc": "Merge Search Index for optimal lookup time. Runs nightly.",
                     },
-                    {
-                        "value": "search_index_rebuild",
-                        "title": "Rebuild Search Index",
-                        "desc": "Delete and rebuild the search index from scratch",
-                        "confirm": "This can take a long time",
-                    },
                     {
                         "value": "search_index_remove_stale",
-                        "title": "Remove Stale Index Entries",
-                        "desc": "Remove search index entries that are no longer in the library.",
-                    },
-                    {
-                        "value": "search_index_abort",
-                        "title": "Abort Search Indexing",
-                        "desc": "Aborts search index update and remove tasks.",
+                        "title": "Clean Stale Index Entries",
+                        "desc": "Clean search index entries that are no longer in the library.",
                     },
                     {
                         "value": "search_index_clear",
@@ -133,11 +120,28 @@ ADMIN_TASK_GROUPS = MappingProxyType(
                         "title": "Repair Search Index",
                         "desc": "Probably faster than Rebuild if integrity check fails.",
                     },
-                ],
+                    {
+                        "value": "search_index_abort",
+                        "title": "Abort Legacy Search Index Sync",
+                        "desc": "Aborts search index sync tasks.",
+                    },
+                    {
+                        "value": "search_index_update",
+                        "title": "Sync Search Index",
+                        "desc": "with recently changed comics. This should not need to be run.",
+                        "confirm": "This can take a long time",
+                    },
+                    {
+                        "value": "search_index_rebuild",
+                        "title": "Rebuild Search Index Using Sync.",
+                        "desc": "Delete and rebuild the search index from scratch using the legacy syncer. This should not need to be run.",
+                        "confirm": "This can take a long time",
+                    },
+                ),
             },
             {
                 "title": "Database",
-                "tasks": [
+                "tasks": (
                     {
                         "value": "db_vacuum",
                         "title": "Optimize & Compact Database",
@@ -159,11 +163,11 @@ ADMIN_TASK_GROUPS = MappingProxyType(
                         "desc": "Check logs for results. Runs nightly.",
                         "confirm": "Can take a while on large databases, Are you sure?",
                     },
-                ],
+                ),
             },
             {
                 "title": "Codex Software",
-                "tasks": [
+                "tasks": (
                     {
                         "value": "codex_latest_version",
                         "title": "Check for Codex Latest Version",
@@ -187,11 +191,11 @@ ADMIN_TASK_GROUPS = MappingProxyType(
                         "desc": "Immediately",
                         "confirm": "Are you sure?",
                     },
-                ],
+                ),
             },
             {
                 "title": "Cleanup",
-                "tasks": [
+                "tasks": (
                     {
                         "value": "cleanup_fks",
                         "title": "Remove Orphan Tags",
@@ -233,11 +237,11 @@ ADMIN_TASK_GROUPS = MappingProxyType(
                         "desc": "Runs several tasks above that also run nightly.",
                         "confirm": "Launches several tasks that run nightly anyway.",
                     },
-                ],
+                ),
             },
             {
                 "title": "Notify",
-                "tasks": [
+                "tasks": (
                     {
                         "value": "notify_admin_flags_changed",
                         "title": "Notify Admin Flags Changed",
@@ -278,7 +282,7 @@ ADMIN_TASK_GROUPS = MappingProxyType(
                         "title": "Notify Users Changed",
                         "desc": "Notify one user that their users changed or all users if a user was deleted.",
                     },
-                ],
+                ),
             },
         ),
     }

codex/choices/browser.py

@@ -2,6 +2,8 @@
 
 from types import MappingProxyType
 
+from comicbox.enums.maps.identifiers import ID_SOURCE_NAME_MAP
+
 BROWSER_BOOKMARK_FILTER_CHOICES = MappingProxyType(
     {
         "": "All",
@@ -15,7 +17,6 @@ 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",
@@ -44,8 +45,11 @@ BROWSER_TOP_GROUP_CHOICES = MappingProxyType(
         "a": "Story Arcs",
     },
 )
-BROWSER_GROUP_CHOICES = MappingProxyType({**BROWSER_TOP_GROUP_CHOICES, "r": "Root"})
+BROWSER_ROUTE_CHOICES = MappingProxyType({**BROWSER_TOP_GROUP_CHOICES, "r": "Root"})
 VUETIFY_NULL_CODE = -1
+_IDENTIFIER_SOURCES = MappingProxyType(
+    {key.value: value for key, value in ID_SOURCE_NAME_MAP.items()}
+)
 BROWSER_CHOICES = MappingProxyType(
     {
         "bookmark_filter": BROWSER_BOOKMARK_FILTER_CHOICES,
@@ -53,14 +57,7 @@ BROWSER_CHOICES = MappingProxyType(
         "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",
-        },
+        "identifier_sources": _IDENTIFIER_SOURCES,
     }
 )
 

codex/choices/choices_to_json.py

@@ -10,12 +10,13 @@ from caseconverter import camelcase
 
 from codex.choices.admin import (
     ADMIN_FLAG_CHOICES,
-    ADMIN_STATUS_TITLES,
     ADMIN_TASK_GROUPS,
 )
 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.choices.search import SEARCH_FIELDS
+from codex.choices.statii import ADMIN_STATUS_TITLES
 from codex.serializers.route import RouteSerializer
 
 _DEFAULTS = MappingProxyType(
@@ -37,6 +38,7 @@ _MAP_DUMPS = MappingProxyType(
         "browser-defaults.json": BROWSER_DEFAULTS,
         "browser-map.json": BROWSER_CHOICES,
         "reader-map.json": READER_CHOICES,
+        "search-map.json": SEARCH_FIELDS,
     }
 )
 
@@ -61,16 +63,17 @@ def _json_key(key: str):
     return key if key.upper() == key else camelcase(key)
 
 
-def _make_json_serializable(data):
+def _make_json_serializable(data, *, jsonize_keys: bool = True):
     """Convert nested Mapping objects to dicts."""
     if isinstance(data, Mapping):
         json_dict = {}
         for key, value in data.items():
             if key == "breadcrumbs":
-                json_value = tuple(RouteSerializer(dict(route)).data for route in value)
+                json_value = tuple(RouteSerializer(dict(route)).data for route in value)  #  pyright: ignore[reportGeneralTypeIssues]
             else:
                 json_value = _make_json_serializable(value)
-            json_dict[_json_key(key)] = json_value
+            json_key = _json_key(key) if jsonize_keys else key
+            json_dict[json_key] = json_value
         return json_dict
     if isinstance(data, list | tuple | frozenset | set):
         return [_make_json_serializable(item) for item in data]
@@ -90,10 +93,12 @@ def _to_vuetify_dict(fn: str, data):
     return vuetify_data
 
 
-def _dump(parent_path: Path, fn: str, data, vuetify: bool):
+def _dump(parent_path: Path, fn: str, data, *, vuetify: bool, jsonize_keys: bool):
     """Dump data to json file."""
     vuetify_data = (
-        _to_vuetify_dict(fn, data) if vuetify else _make_json_serializable(data)
+        _to_vuetify_dict(fn, data)
+        if vuetify
+        else _make_json_serializable(data, jsonize_keys=jsonize_keys)
     )
     path = parent_path / fn
     with path.open("w") as json_file:
@@ -115,13 +120,20 @@ def main():
     parent_path = Path(parent_path)
     parent_path.mkdir(exist_ok=True)
     for fn, data in _DUMPS.items():
-        _dump(parent_path, fn, data, vuetify=True)
+        _dump(parent_path, fn, data, vuetify=True, jsonize_keys=True)
 
     for fn, data in _MAP_DUMPS.items():
-        _dump(parent_path, fn, data, vuetify=False)
+        jsonize_keys = fn != "search-map.json"
+        _dump(parent_path, fn, data, vuetify=False, jsonize_keys=jsonize_keys)
 
     ws_messages = _make_websocket_messages()
-    _dump(parent_path, "websocket-messages.json", ws_messages, vuetify=False)
+    _dump(
+        parent_path,
+        "websocket-messages.json",
+        ws_messages,
+        vuetify=False,
+        jsonize_keys=True,
+    )
 
 
 if __name__ == "__main__":

codex/choices/search.py

@@ -0,0 +1,133 @@
+"""Create the search field alias help map."""
+
+from types import MappingProxyType
+
+_REVERSE_TYPE_MAP = MappingProxyType(
+    {
+        "Boolean": ["monochrome"],
+        "Date": ["date"],
+        "DateTime": ["create_at", "updated_at"],
+        "Decimal": ["critical_rating", "issue_number"],
+        "Integer": [
+            "day",
+            "month",
+            "year",
+            "page_count",
+            "size",
+            "decade",
+            "volume",
+            "volume_to",
+        ],
+    }
+)
+_TYPE_MAP = MappingProxyType(
+    {
+        field: field_type
+        for field_type, fields in _REVERSE_TYPE_MAP.items()
+        for field in fields
+    }
+)
+
+
+def gen_multipart_field_aliases(field):
+    """Generate aliases for fields made of snake_case words."""
+    bits = field.split("_")
+    aliases = set({field})
+
+    # Singular from plural
+    if field.endswith("s"):
+        singular = field[:-1]
+        if not singular.endswith("ie"):
+            aliases.add(singular)
+
+    # Alternate delimiters
+    for connector in ("", "-"):
+        joined = connector.join(bits)
+        aliases.add(joined)
+
+    return frozenset(aliases)
+
+
+def _get_fieldmap_values(*args):
+    values = set()
+    for val in args:
+        values |= gen_multipart_field_aliases(val)
+    return tuple(sorted(values))
+
+
+FIELDMAP = MappingProxyType(
+    {
+        "age_rating": ("age",),
+        "characters": _get_fieldmap_values("category", "categories", "characters"),
+        "collection_title": ("collection",),
+        "country": (),
+        "credits": _get_fieldmap_values(
+            "authors",
+            "contributors",
+            "creators",
+            "credits",
+            "people",
+            "persons",
+        ),
+        "created_at": ("created",),
+        "critical_rating": _get_fieldmap_values("critical_rating"),
+        "day": (),
+        "date": (),
+        "decade": (),
+        "file_type": (
+            "filetype",
+            "type",
+        ),
+        "genres": ("genre",),
+        "identifiers": _get_fieldmap_values("id", "id_key", "identifier"),
+        "imprint": (),
+        "issue": (),
+        "issue_number": ("number",),
+        "issue_suffix": (),
+        "locations": ("location", "loc"),
+        "language": ("lang"),
+        "month": (),
+        "monochrome": _get_fieldmap_values("black_and_white"),
+        "name": ("title",),
+        "notes": (),
+        "original_format": ("format",),
+        "publisher": (),
+        "page_count": ("pages",),
+        "path": _get_fieldmap_values(
+            "filename",
+            "folders",
+        ),
+        "reading_direction": ("direction", "rd"),
+        "review": (),
+        "scan_info": ("scan",),
+        "series": (),
+        "series_groups": _get_fieldmap_values("series_groups"),
+        "size": (),
+        "sources": _get_fieldmap_values("sources", "id_sources"),
+        "stories": ("story",),
+        "story_arcs": _get_fieldmap_values("story_arcs", "arcs", "arc"),
+        "summary": _get_fieldmap_values("desc", "description", "comments"),
+        "tags": ("tag",),
+        "tagger": (),
+        "teams": ("team",),
+        "updated_at": ("updated",),
+        "universes": ("universe", "designation"),
+        "volume": ("volume_from",),
+        "volume_to": (),
+        "year": (),
+    }
+)
+
+
+def create_search_field_map():
+    """Create the search field alias help map."""
+    result = {}
+    for key, values in FIELDMAP.items():
+        result[key] = {
+            "type": _TYPE_MAP.get(key, "String"),
+            "aliases": tuple(sorted({*values} - {key})),
+        }
+    return result
+
+
+SEARCH_FIELDS = create_search_field_map()

codex/choices/statii.py

@@ -0,0 +1,40 @@
+"""Status code to title map."""
+
+from itertools import chain
+
+from bidict import frozenbidict
+
+from codex.librarian.covers.status import COVERS_STATII
+from codex.librarian.restarter.status import RESTARTER_STATII
+from codex.librarian.scribe.importer.statii.create import CREATE_STATII
+from codex.librarian.scribe.importer.statii.delete import REMOVE_STATII
+from codex.librarian.scribe.importer.statii.link import LINK_STATII
+from codex.librarian.scribe.importer.statii.query import QUERY_STATII
+from codex.librarian.scribe.importer.statii.read import READ_STATII
+from codex.librarian.scribe.importer.statii.search import IMPORTER_SEARCH_INDEX_STATII
+from codex.librarian.scribe.importer.status import FAILED_IMPORTS_STATII
+from codex.librarian.scribe.janitor.status import JANITOR_STATII
+from codex.librarian.scribe.search.status import SEARCH_INDEX_STATII
+from codex.librarian.scribe.status import SCRIBE_STATII
+from codex.librarian.watchdog.status import WATCHDOG_STATII
+
+_STATII = (
+    RESTARTER_STATII,
+    COVERS_STATII,
+    WATCHDOG_STATII,
+    JANITOR_STATII,
+    SEARCH_INDEX_STATII,
+    SCRIBE_STATII,
+    CREATE_STATII,
+    REMOVE_STATII,
+    LINK_STATII,
+    QUERY_STATII,
+    READ_STATII,
+    IMPORTER_SEARCH_INDEX_STATII,
+    FAILED_IMPORTS_STATII,
+)
+
+
+ADMIN_STATUS_TITLES = frozenbidict(
+    sorted((status.CODE, status.title()) for status in chain.from_iterable(_STATII))
+)