codex 1.7.15__py3-none-any.whl → 1.8.0__py3-none-any.whl

codex/settings/__init__.py

@@ -1 +1,423 @@
-"""Settings functions for the settings file."""
+"""
+Django settings for codex project.
+
+Generated by 'django-admin startproject' using Django 3.0.3.
+
+For more information on this file, see
+https://docs.djangoproject.com/en/dev/topics/settings/
+
+For the full list of settings and their values, see
+https://docs.djangoproject.com/en/dev/ref/settings/
+"""
+
+from os import environ
+from pathlib import Path
+from types import MappingProxyType
+
+from comicbox.config import get_config
+from loguru import logger
+
+from codex.settings.hypercorn import load_hypercorn_config
+from codex.settings.secret_key import get_secret_key
+from codex.settings.timezone import get_time_zone
+from codex.settings.whitenoise import immutable_file_test
+
+######################################
+# Undocumented Environment Variables #
+######################################
+# SECURITY WARNING: don't run with debug turned on in production!
+FALSY = {None, "", "false", "0", False}
+
+
+def not_falsy_env(name):
+    """Return a boolean environment envs mindful of falsy values."""
+    return bool(environ.get(name, "").lower() not in FALSY)
+
+
+DEBUG = not_falsy_env("DEBUG")
+BUILD = not_falsy_env("BUILD")
+# Slow query middleware
+# limit in seconds
+SLOW_QUERY_LIMIT = float(environ.get("CODEX_SLOW_QUERY_LIMIT", "0.5"))
+LOG_RESPONSE_TIME = not_falsy_env("CODEX_LOG_RESPONSE_TIME")
+# Search indexing memory controls
+MMAP_RATIO = int(environ.get("CODEX_MMAP_RATIO", "240"))
+WRITER_MEMORY_PERCENT = float(environ.get("CODEX_WRITER_MEMORY_PERCENT", "0.6"))
+CPU_MULTIPLIER = float(environ.get("CODEX_CPU_MULTIPLIER", "1.25"))
+CHUNK_PER_GB = int(environ.get("CODEX_CHUNK_PER_GB", "250"))
+MAX_CHUNK_SIZE = int(environ.get("CODEX_MAX_CHUNK_SIZE", "1000"))
+# sqlite parser breaks with more than 1000 variables in a query and
+# django only fixes this in the bulk_create & bulk_update functions.
+# So for complicated queries I gotta batch them myself. These batch sizes
+# are only a proxy for query terms, but it works.
+# FILTER_BATCH_SIZE of 990 errors sometimes.
+FILTER_BATCH_SIZE = int(environ.get("CODEX_FILTER_BATCH_SIZE", "900"))
+LINK_FK_BATCH_SIZE = int(environ.get("CODEX_LINK_FK_BATCH_SIZE", "20000"))
+LINK_M2M_BATCH_SIZE = int(environ.get("CODEX_LINK_M2M_BATCH_SIZE", "20000"))
+VITE_HOST = environ.get("VITE_HOST")
+SEARCH_INDEX_BATCH_SIZE = int(environ.get("CODEX_SEARCH_INDEX_BATCH_SIZE", "10000"))
+LOG_RETENTION = environ.get("LOG_RETENTION", "6 months")
+MAX_OBJ_PER_PAGE = int(environ.get("CODEX_BROWSER_MAX_OBJ_PER_PAGE", "100"))
+
+
+####################################
+# Documented Environment Variables #
+####################################
+LOGLEVEL = environ.get("LOGLEVEL", "TRACE" if DEBUG else "INFO")
+TZ = environ.get("TIMEZONE", environ.get("TZ"))
+CONFIG_PATH = Path(environ.get("CODEX_CONFIG_DIR", Path.cwd() / "config"))
+RESET_ADMIN = not_falsy_env("CODEX_RESET_ADMIN")
+LOG_DIR = Path(environ.get("CODEX_LOG_DIR", CONFIG_PATH / "logs"))
+LOG_TO_CONSOLE = environ.get("CODEX_LOG_TO_CONSOLE") != "0"
+LOG_TO_FILE = environ.get("CODEX_LOG_TO_FILE") != "0"
+THROTTLE_ANON = int(environ.get("CODEX_THROTTLE_ANON", "0"))
+THROTTLE_USER = int(environ.get("CODEX_THROTTLE_USER", "0"))
+THROTTLE_OPDS = int(environ.get("CODEX_THROTTLE_OPDS", "0"))
+THROTTLE_OPENSEARCH = int(environ.get("CODEX_THROTTLE_OPENSEARCH", "0"))
+FIX_FOREIGN_KEYS = not_falsy_env("CODEX_FIX_FOREIGN_KEYS")
+INTEGRITY_CHECK = not_falsy_env("CODEX_INTEGRITY_CHECK")
+FTS_INTEGRITY_CHECK = not_falsy_env("CODEX_FTS_INTEGRITY_CHECK")
+FTS_REBUILD = not_falsy_env("CODEX_FTS_REBUILD")
+
+# Base paths
+BASE_DIR = Path(__file__).resolve().parent.parent.parent
+CODEX_PATH = BASE_DIR / "codex"
+CUSTOM_COVERS_SUBDIR = "custom-covers"
+CUSTOM_COVERS_DIR = CONFIG_PATH / CUSTOM_COVERS_SUBDIR
+CUSTOM_COVERS_GROUP_DIRS = ("publishers", "imprints", "series", "volumes", "story-arcs")
+for group_dir in CUSTOM_COVERS_GROUP_DIRS:
+    custom_cover_group_dir = CUSTOM_COVERS_DIR / group_dir
+    custom_cover_group_dir.mkdir(exist_ok=True, parents=True)
+
+# SECURITY WARNING: keep the secret key used in production secret!
+SECRET_KEY = get_secret_key(CONFIG_PATH)
+
+
+def _get_logging():
+    loggers = {}
+    if LOGLEVEL != "TRACE":
+        loggers.update(
+            {
+                "asyncio": {
+                    "level": "INFO",
+                },
+            }
+        )
+    if not DEBUG:
+        loggers.update(
+            {
+                "urllib3.connectionpool": {"level": "INFO"},
+                "watchdog": {
+                    "level": "INFO",
+                },
+                "PIL": {
+                    "level": "INFO",
+                },
+            }
+        )
+    return {"version": 1, "loggers": loggers}
+
+
+LOG_PATH = LOG_DIR / "codex.log"
+LOG_ROTATION = "10 MB"
+LOGGING = _get_logging()
+
+ALLOWED_HOSTS = ["*"]
+
+
+# Application definition
+def _get_installed_apps():
+    installed_apps = [
+        "django.contrib.auth",
+        "django.contrib.contenttypes",
+        "django.contrib.sessions",
+        "django.contrib.messages",
+    ]
+
+    if DEBUG:
+        # comes before static apps
+        installed_apps += ["nplusone.ext.django", "schema_graph"]
+
+    installed_apps += [
+        "whitenoise.runserver_nostatic",
+        "django.contrib.staticfiles",
+        "rest_framework",
+        "rest_registration",
+        "corsheaders",
+    ]
+    if not BUILD:
+        installed_apps += [
+            "django_vite",
+        ]
+    installed_apps += [
+        "codex",
+        "cachalot",
+        "drf_spectacular",
+    ]
+    return tuple(installed_apps)
+
+
+INSTALLED_APPS = _get_installed_apps()
+
+
+def _get_middleware():
+    middleware = [
+        "corsheaders.middleware.CorsMiddleware",
+        "django.middleware.security.SecurityMiddleware",
+        "whitenoise.middleware.WhiteNoiseMiddleware",
+        "django.contrib.sessions.middleware.SessionMiddleware",
+        "django.middleware.common.CommonMiddleware",
+        "django.middleware.csrf.CsrfViewMiddleware",
+        "django.contrib.auth.middleware.AuthenticationMiddleware",
+        "django.contrib.messages.middleware.MessageMiddleware",
+        "django.middleware.clickjacking.XFrameOptionsMiddleware",
+        "codex.middleware.TimezoneMiddleware",
+    ]
+    if DEBUG:
+        middleware += [
+            "nplusone.ext.django.NPlusOneMiddleware",
+        ]
+
+    if LOG_RESPONSE_TIME:
+        middleware += [
+            "codex.middleware.LogResponseTimeMiddleware",
+        ]
+    return tuple(middleware)
+
+
+MIDDLEWARE = _get_middleware()
+
+if DEBUG:
+    NPLUSONE_LOGGER = logger
+    NPLUSONE_LOG_LEVEL = "WARNING"
+
+ROOT_URLCONF = "codex.urls.root"
+
+CODEX_TEMPLATES = CODEX_PATH / "templates"
+TEMPLATES = [
+    {
+        "BACKEND": "django.template.backends.django.DjangoTemplates",
+        "DIRS": [CODEX_TEMPLATES],
+        "APP_DIRS": True,
+        "OPTIONS": {
+            "context_processors": [
+                "django.template.context_processors.debug",
+                "django.template.context_processors.request",
+                "django.contrib.auth.context_processors.auth",
+                "django.contrib.messages.context_processors.messages",
+            ],
+        },
+    },
+]
+
+WSGI_APPLICATION = "codex.wsgi.application"
+
+
+# Database
+# https://docs.djangoproject.com/en/dev/ref/settings/#databases
+
+DB_PATH = CONFIG_PATH / "codex.sqlite3"
+
+# Move old DB_PATH
+OLD_DB_PATH = CONFIG_PATH / "db.sqlite3"
+if not DB_PATH.exists() and OLD_DB_PATH.exists():
+    OLD_DB_PATH.rename(DB_PATH)
+
+BACKUP_DB_DIR = CONFIG_PATH / "backups"
+BACKUP_DB_PATH = (BACKUP_DB_DIR / DB_PATH.stem).with_suffix(DB_PATH.suffix + ".bak")
+
+DATABASES = {
+    "default": {
+        "ENGINE": "django.db.backends.sqlite3",
+        "NAME": DB_PATH,
+        "CONN_MAX_AGE": 600,
+        "OPTIONS": {
+            "init_command": "PRAGMA journal_mode=wal;",
+            "timeout": 120,
+        },
+    },
+}
+SESSION_ENGINE = "django.contrib.sessions.backends.cached_db"
+# The new DEFAULT_AUTO_FIELD in Django 3.2 is BigAutoField (64 bit),
+#   but it can't be auto migrated. Automigration has been punted to
+#   Django 4.0 at the earliest:
+#   https://code.djangoproject.com/ticket/32674
+DEFAULT_AUTO_FIELD = "django.db.models.AutoField"
+
+
+# Password validation
+# https://docs.djangoproject.com/en/3.0/ref/settings/#auth-password-validators
+
+AUTH_PASSWORD_VALIDATORS = [
+    {
+        "NAME": (
+            "django.contrib.auth.password_validation.UserAttributeSimilarityValidator"
+        )
+    },
+    {
+        "NAME": "django.contrib.auth.password_validation.MinimumLengthValidator",
+        "OPTIONS": {"min_length": 4},
+    },
+]
+
+
+# Internationalization
+# https://docs.djangoproject.com/en/dev/topics/i18n/
+LANGUAGE_CODE = "en-us"
+USE_I18N = True
+TIME_ZONE = get_time_zone(TZ)
+
+# Hypercorn
+HYPERCORN_CONFIG_TOML = CONFIG_PATH / "hypercorn.toml"
+HYPERCORN_CONFIG_TOML_DEFAULT = CODEX_PATH / "settings/hypercorn.toml.default"
+HYPERCORN_CONFIG = load_hypercorn_config(
+    HYPERCORN_CONFIG_TOML, HYPERCORN_CONFIG_TOML_DEFAULT, DEBUG
+)
+PORT = int(HYPERCORN_CONFIG.bind[0].split(":")[1])
+
+
+# Static files (CSS, JavaScript, Images)
+# https://docs.djangoproject.com/en/dev/howto/static-files/
+# WHITENOISE_KEEP_ONLY_HASHED_FILES is still not usable with vite chunking
+WHITENOISE_STATIC_PREFIX = "static/"
+WHITENOISE_IMMUTABLE_FILE_TEST = immutable_file_test
+STATIC_ROOT = CODEX_PATH / "static_root"
+ROOT_PATH = HYPERCORN_CONFIG.root_path
+STATIC_URL = (
+    ROOT_PATH + "/" + WHITENOISE_STATIC_PREFIX
+    if ROOT_PATH
+    else WHITENOISE_STATIC_PREFIX
+)
+STORAGES = {
+    "staticfiles": {
+        "BACKEND": "whitenoise.storage.CompressedManifestStaticFilesStorage"
+    }
+}
+STATICFILES_DIRS = (
+    [CODEX_PATH / "static_src", CODEX_PATH / "static_build"] if (DEBUG or BUILD) else []
+)
+for path in STATICFILES_DIRS:
+    path.mkdir(exist_ok=True, parents=True)
+
+SESSION_COOKIE_AGE = 60 * 60 * 24 * 60  # 60 days
+
+# Setup support for proxy headers
+USE_X_FORWARDED_HOST = True
+SECURE_PROXY_SSL_HEADER = ("HTTP_X_FORWARDED_PROTO", "https")
+
+_THROTTLE_MAP = MappingProxyType(
+    {
+        "anon": ("rest_framework.throttling.AnonRateThrottle", THROTTLE_ANON),
+        "user": ("rest_framework.throttling.UserRateThrottle", THROTTLE_USER),
+        "opds": ("rest_framework.throttling.ScopedRateThrottle", THROTTLE_OPDS),
+        "opensearch": (
+            "rest_framework.throttling.ScopedRateThrottle",
+            THROTTLE_OPENSEARCH,
+        ),
+    }
+)
+_THROTTLE_CLASSES = set()
+_THROTTLE_RATES = {}
+for scope, value in _THROTTLE_MAP.items():
+    classname, rate_value = value
+    if rate_value or classname == "rest_framework.throttling.ScopedRateThrottle":
+        _THROTTLE_CLASSES.add(classname)
+        rate = f"{rate_value}/min" if value[1] else None
+        _THROTTLE_RATES[scope] = rate
+
+REST_FRAMEWORK = {
+    "DEFAULT_AUTHENTICATION_CLASSES": (
+        "rest_framework.authentication.SessionAuthentication",
+    ),
+    "DEFAULT_RENDERER_CLASSES": (
+        "djangorestframework_camel_case.render.CamelCaseJSONRenderer",
+        "djangorestframework_camel_case.render.CamelCaseBrowsableAPIRenderer",
+    ),
+    "DEFAULT_PARSER_CLASSES": (
+        "djangorestframework_camel_case.parser.CamelCaseJSONParser",
+        # "djangorestframework_camel_case.parser.CamelCaseFormParser",
+        # "djangorestframework_camel_case.parser.CamelCaseMultiPartParser",
+    ),
+    "DEFAULT_SCHEMA_CLASS": "drf_spectacular.openapi.AutoSchema",
+    "EXCEPTION_HANDLER": "codex.views.error.codex_exception_handler",
+    "DEFAULT_THROTTLE_CLASSES": tuple(_THROTTLE_CLASSES),
+    "DEFAULT_THROTTLE_RATES": _THROTTLE_RATES,
+}
+
+REST_REGISTRATION = {
+    "REGISTER_VERIFICATION_ENABLED": False,
+    "REGISTER_EMAIL_VERIFICATION_ENABLED": False,
+    "RESET_PASSWORD_VERIFICATION_ENABLED": False,
+    "USER_HIDDEN_FIELDS": (
+        # DEFAULT
+        "last_login",
+        "is_active",
+        "user_permissions",
+        "groups",
+        "date_joined",
+        # SHOWN
+        # "is_staff", "is_superuser",
+        # HIDDEN
+        "email",
+        "first_name",
+        "last_name",
+    ),
+}
+
+
+SPECTACULAR_SETTINGS = {
+    "TITLE": "Codex API",
+    "DESCRIPTION": "Comic Library Browser and Reader",
+    "OAS_VERSION": "3.1.0",
+    "VERSION": "3.0.0",
+    "CONTACT": {
+        "name": "Support",
+        "url": "https://github.com/ajslater/codex?tab=readme-ov-file#-support",
+    },
+    "PREPROCESSING_HOOKS": ["codex.urls.spectacular.allow_list"],
+    "SERVE_PERMISSIONS": ["rest_framework.permissions.IsAdminUser"],
+    "EXTERNAL_DOCS": {
+        "url": "https://github.com/ajslater/codex/",
+        "description": "Codex Docs",
+    },
+}
+
+CORS_ALLOW_CREDENTIALS = True
+
+ROOT_CACHE_PATH = CONFIG_PATH / "cache"
+DEFAULT_CACHE_PATH = ROOT_CACHE_PATH / "default"
+DEFAULT_CACHE_PATH.mkdir(exist_ok=True, parents=True)
+CACHES = {
+    "default": {
+        "BACKEND": "django.core.cache.backends.filebased.FileBasedCache",
+        "LOCATION": str(DEFAULT_CACHE_PATH),
+    },
+}
+
+INTERNAL_IPS = ("127.0.0.1",)
+
+CHANNEL_LAYERS = {
+    "default": {"BACKEND": "channels.layers.InMemoryChannelLayer"},
+}
+
+if DEBUG and not BUILD:
+    import socket
+
+    DEV_SERVER_HOST = VITE_HOST if VITE_HOST else socket.gethostname()
+    DJANGO_VITE = {
+        "default": {
+            "dev_mode": DEBUG,
+            "dev_server_host": DEV_SERVER_HOST,
+        }
+    }
+
+CACHALOT_UNCACHABLE_TABLES = frozenset(
+    {"django_migrations", "django_session", "codex_useractive"}
+)
+
+COMICBOX_CONFIG = get_config(
+    {
+        "loglevel": LOGLEVEL,
+        "delete_keys": frozenset({"pages", "reprints"}),
+    }
+)

codex/signals/django_signals.py

@@ -1,42 +1,9 @@
 """Django signal actions."""
 
-from time import time
-
-from django.core.cache import cache
-from django.db.models.signals import m2m_changed
-
-from codex.librarian.mp_queue import LIBRARIAN_QUEUE
-from codex.librarian.notifier.tasks import LIBRARIAN_STATUS_TASK
-from codex.librarian.tasks import DelayedTasks
-from codex.logger.logger import get_logger
-
-GROUP_CHANGE_MODEL_NAMES = frozenset(("User", "Library"))
-GROUP_CHANGE_ACTIONS = frozenset(
-    {
-        "post_add",
-        "post_remove",
-        "post_clear",
-    }
-)
-LOG = get_logger(__name__)
-
-
-def _user_group_change(**kwargs):
-    """Clear cache and send update signals when groups change."""
-    model = kwargs["model"]
-    action = kwargs["action"]
-    if (
-        model.__name__ not in GROUP_CHANGE_MODEL_NAMES
-        or action not in GROUP_CHANGE_ACTIONS
-    ):
-        return
-    cache.clear()
-    tasks = (LIBRARIAN_STATUS_TASK,)
-    task = DelayedTasks(time() + 2, tasks)
-    LIBRARIAN_QUEUE.put(task)
+# from django.db.models.signals import m2m_changed unused
 
 
 def connect_signals():
     """Connect actions to signals."""
     # connection_created.connect(_db_connect) unused atm
-    m2m_changed.connect(_user_group_change)
+    # m2m_changed.connect(_user_group_change) unused

codex/signals/os_signals.py

@@ -4,9 +4,8 @@ import asyncio
 import signal
 from asyncio import Event
 
-from codex.logger.logger import get_logger
+from loguru import logger
 
-LOG = get_logger(__name__)
 STOP_SIGNAL_NAMES = (
     "SIGABRT",
     "SIGBREAK",
@@ -27,7 +26,7 @@ def _shutdown_signal_handler(*_args):
     """Initiate Codex Shutdown."""
     if SHUTDOWN_EVENT.is_set():
         return
-    LOG.info("Asking hypercorn to shut down gracefully. Could take 10 seconds...")
+    logger.info("Asking hypercorn to shut down gracefully. Could take 10 seconds...")
     SHUTDOWN_EVENT.set()
 
 
@@ -35,7 +34,7 @@ def _restart_signal_handler(*_args):
     """Initiate Codex Restart."""
     if RESTART_EVENT.is_set():
         return
-    LOG.info("Restart signal received.")
+    logger.info("Restart signal received.")
     RESTART_EVENT.set()
     _shutdown_signal_handler()
 
@@ -49,4 +48,4 @@ def bind_signals_to_loop():
                 loop.add_signal_handler(sig, _shutdown_signal_handler)
         loop.add_signal_handler(signal.SIGUSR1, _restart_signal_handler)
     except NotImplementedError:
-        LOG.info("Shutdown and restart signal handling not implemented on windows.")
+        logger.info("Shutdown and restart signal handling not implemented on windows.")

codex/startup/__init__.py

@@ -0,0 +1,180 @@
+"""Initialize Codex Dataabse before running."""
+
+from pathlib import Path
+
+from django.contrib.auth.models import User
+from django.core.cache import cache
+from django.db.models import F, Q
+from django.db.models.functions import Now
+from loguru import logger
+
+from codex.choices.admin import AdminFlagChoices
+from codex.librarian.status_controller import STATUS_DEFAULTS
+from codex.models import AdminFlag, CustomCover, LibrarianStatus, Library, Timestamp
+from codex.settings import (
+    CUSTOM_COVERS_DIR,
+    CUSTOM_COVERS_SUBDIR,
+    HYPERCORN_CONFIG,
+    HYPERCORN_CONFIG_TOML,
+    RESET_ADMIN,
+)
+from codex.startup.db import ensure_db_schema
+from codex.startup.registration import patch_registration_setting
+
+
+def ensure_superuser():
+    """Ensure there is a valid superuser."""
+    if RESET_ADMIN or not User.objects.filter(is_superuser=True).exists():
+        admin_user, created = User.objects.update_or_create(
+            username="admin",
+            defaults={"is_staff": True, "is_superuser": True, "is_active": True},
+        )
+        admin_user.set_password("admin")
+        admin_user.save()
+        prefix = "Cre" if created else "Upd"
+        logger.success(f"{prefix}ated admin user.")
+
+
+def _delete_orphans(model, field, names):
+    """Delete orphans for declared models."""
+    params = {f"{field}__in": names}
+    query = model.objects.filter(~Q(**params))
+    count, _ = query.delete()
+    if count:
+        logger.info(f"Deleted {count} orphan {model._meta.verbose_name_plural}.")
+
+
+def init_admin_flags():
+    """Init admin flag rows."""
+    _delete_orphans(AdminFlag, "key", AdminFlagChoices.values)
+
+    for key, title in AdminFlagChoices.choices:
+        defaults = {"key": key, "on": key not in AdminFlag.FALSE_DEFAULTS}
+        flag, created = AdminFlag.objects.get_or_create(defaults=defaults, key=key)
+        if created:
+            logger.info(f"Created AdminFlag: {title} = {flag.on}")
+
+
+def init_timestamps():
+    """Init timestamps."""
+    _delete_orphans(Timestamp, "key", Timestamp.Choices.values)
+
+    for enum in Timestamp.Choices:
+        key = enum.value
+        ts, created = Timestamp.objects.get_or_create(key=key)
+        if enum == Timestamp.Choices.API_KEY and not ts.version:
+            ts.save_uuid_version()
+        if created:
+            label = Timestamp.Choices(ts.key).label
+            logger.debug(f"Created {label} timestamp.")
+
+
+def init_librarian_statuses():
+    """Init librarian statuses."""
+    _delete_orphans(LibrarianStatus, "status_type", LibrarianStatus.CHOICES.values)  # ty: ignore[possibly-unbound-attribute]
+
+    for status_type, title in LibrarianStatus.CHOICES.choices:  # ty: ignore[possibly-unbound-attribute]
+        _, created = LibrarianStatus.objects.update_or_create(
+            defaults=STATUS_DEFAULTS, status_type=status_type
+        )
+        if created:
+            logger.debug(f"Created {title} LibrarianStatus.")
+
+
+def clear_library_status():
+    """Unset the update_in_progress flag for all libraries."""
+    count = Library.objects.filter(update_in_progress=True).update(
+        update_in_progress=False, updated_at=Now()
+    )
+    if count:
+        logger.debug(f"Reset {count} Libraries' update_in_progress flag")
+
+
+def init_custom_cover_dir():
+    """Initialize the Custom Cover Dir singleton row."""
+    defaults = dict(**Library.CUSTOM_COVERS_DIR_DEFAULTS, path=CUSTOM_COVERS_DIR)
+    covers_library, created = Library.objects.get_or_create(
+        defaults=defaults, covers_only=True
+    )
+    if created:
+        logger.info("Created Custom Covers Dir settings in the db.")
+
+    old_path = covers_library.path
+    if Path(old_path) != CUSTOM_COVERS_DIR:
+        Library.objects.filter(covers_only=True).update(path=str(CUSTOM_COVERS_DIR))
+        logger.info(
+            f"Updated Custom Group Covers Dir path from {old_path} to {CUSTOM_COVERS_DIR}."
+        )
+
+
+def update_custom_covers_for_config_dir():
+    """Update custom covers if the config dir changes."""
+    # This is okay, but I wouldn't need to do it if paths were constructed from
+    # parent_folder and library.path
+    # Fast lookup without relations seems better though, paths shouldn't change too much.
+
+    # Determine which covers need re-pathing
+    update_covers = []
+    delete_cover_pks = []
+    update_fields = ("path", "updated_at")
+    group_covers = (
+        CustomCover.objects.filter(library__covers_only=True)
+        .exclude(path__startswith=F("library__path"))
+        .only(*update_fields)
+    )
+    logger.debug(f"Checking that group custom covers are under {CUSTOM_COVERS_DIR}")
+    for cover in group_covers.iterator():
+        old_path = cover.path
+        parts = old_path.rsplit(f"/{CUSTOM_COVERS_SUBDIR}/")
+        if len(parts) < 2:  # noqa: PLR2004
+            delete_cover_pks.append(cover.pk)
+            continue
+        new_path = CUSTOM_COVERS_DIR / parts[1]
+        if new_path.exists():
+            cover.path = str(new_path)
+            update_covers.append(cover)
+        else:
+            delete_cover_pks.append(cover.pk)
+    update_count = len(update_covers)
+    logger.debug(
+        f"Found {update_count} custom covers to update, {len(delete_cover_pks)} to delete."
+    )
+
+    # Update covers
+    if update_count:
+        CustomCover.objects.bulk_update(update_covers, update_fields)
+        logger.info(
+            f"Updated {update_count} CustomCovers sources to point to new config dir"
+        )
+
+    # Delete covers we can't reliably update.
+    if delete_cover_pks:
+        delete_qs = CustomCover.objects.filter(pk__in=delete_cover_pks)
+        delete_count, _ = delete_qs.delete()
+        logger.warning(
+            f"Delete {delete_count} CustomCovers that could not be re-sourced after config dir change."
+        )
+
+
+def ensure_db_rows():
+    """Ensure database content is good."""
+    ensure_superuser()
+    init_admin_flags()
+    init_timestamps()
+    init_librarian_statuses()
+    clear_library_status()
+    init_custom_cover_dir()
+    update_custom_covers_for_config_dir()
+
+
+def codex_init():
+    """Initialize the database and start the daemons."""
+    if not ensure_db_schema():
+        return False
+    ensure_db_rows()
+    patch_registration_setting()
+    cache.clear()
+    logger.info(f"root_path: {HYPERCORN_CONFIG.root_path}")
+    if HYPERCORN_CONFIG.use_reloader:
+        logger.info(f"Will reload hypercorn if {HYPERCORN_CONFIG_TOML} changes")
+    return True