Enables prek workspace mode and moves hooks to specific locations as possible, moving to mdformat instead of prettier

.editorconfig

@@ -39,6 +39,3 @@ max_line_length = off
 
 [Dockerfile*]
 indent_style = space
-
-[*.toml]
-indent_style = space

.pre-commit-config.yaml

@@ -1,9 +1,4 @@
-# This file configures pre-commit hooks.
-# See https://pre-commit.com/ for general information
-# See https://pre-commit.com/hooks.html for a listing of possible hooks
-# We actually run via https://github.com/j178/prek which is compatible
 repos:
-  # General hooks
   - repo: https://github.com/pre-commit/pre-commit-hooks
     rev: v6.0.0
     hooks:
@@ -11,21 +6,16 @@ repos:
       - id: check-json
         exclude: "tsconfig.*json"
       - id: check-yaml
-        args:
-          - "--unsafe"
+        args: ["--unsafe"]
       - id: check-toml
       - id: check-executables-have-shebangs
       - id: end-of-file-fixer
-        exclude_types:
-          - svg
-          - pofile
+        exclude_types: [svg, pofile]
         exclude: "(^LICENSE$|^src/documents/static/bootstrap.min.css$)"
       - id: mixed-line-ending
-        args:
-          - "--fix=lf"
+        args: ["--fix=lf"]
       - id: trailing-whitespace
-        exclude_types:
-          - svg
+        exclude_types: [svg]
       - id: check-case-conflict
       - id: detect-private-key
   - repo: https://github.com/codespell-project/codespell
@@ -33,53 +23,29 @@ repos:
     hooks:
       - id: codespell
         additional_dependencies: [tomli]
-        exclude_types:
-          - pofile
-          - json
-  # See https://github.com/prettier/prettier/issues/15742 for the fork reason
-  - repo: https://github.com/rbubley/mirrors-prettier
-    rev: 'v3.8.1'
+        exclude_types: [pofile, json]
+  - repo: https://github.com/google/yamlfmt
+    rev: v0.21.0
     hooks:
-      - id: prettier
-        types_or:
-          - javascript
-          - ts
-          - markdown
-        additional_dependencies:
-          - prettier@3.3.3
-          - 'prettier-plugin-organize-imports@4.1.0'
-  # Python hooks
-  - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.15.0
-    hooks:
-      - id: ruff-check
-      - id: ruff-format
-  - repo: https://github.com/tox-dev/pyproject-fmt
-    rev: "v2.12.1"
-    hooks:
-      - id: pyproject-fmt
-  # Dockerfile hooks
+      - id: yamlfmt
+        exclude: "^src-ui/pnpm-lock.yaml"
+        types: [yaml]
   - repo: https://github.com/AleksaC/hadolint-py
     rev: v2.14.0
     hooks:
       - id: hadolint
-  # Shell script hooks
   - repo: https://github.com/lovesegfault/beautysh
     rev: v6.4.2
     hooks:
       - id: beautysh
         types: [file]
         files: (\.sh$|/run$|/finish$)
-        args:
-          - "--tab"
+        args: ["--tab"]
   - repo: https://github.com/shellcheck-py/shellcheck-py
     rev: "v0.11.0.1"
     hooks:
       - id: shellcheck
-  - repo: https://github.com/google/yamlfmt
-    rev: v0.21.0
+  - repo: https://github.com/tox-dev/pyproject-fmt
+    rev: "v2.16.2"
     hooks:
-      - id: yamlfmt
-        exclude: "^src-ui/pnpm-lock.yaml"
-        types:
-          - yaml
+      - id: pyproject-fmt

docker/.pre-commit-config.yaml

@@ -0,0 +1,6 @@
+repos:
+  - repo: https://github.com/astral-sh/ruff-pre-commit
+    rev: v0.15.4
+    hooks:
+      - id: ruff-check
+      - id: ruff-format

docs/.markdownlint.yaml

@@ -0,0 +1,6 @@
+default: true
+MD013: false # line length -- mdformat handles this
+MD033: false # inline HTML -- MkDocs uses it
+MD041: false # first line heading -- not always true in MkDocs
+MD046: # code block style
+  style: fenced

docs/.pre-commit-config.yaml

@@ -0,0 +1,13 @@
+repos:
+  - repo: https://github.com/executablebooks/mdformat
+    rev: 1.0.0
+    hooks:
+      - id: mdformat
+        additional_dependencies:
+          - mdformat-mkdocs
+          - mdformat-ruff
+  - repo: https://github.com/DavidAnson/markdownlint-cli2
+    rev: v0.21.0
+    hooks:
+      - id: markdownlint-cli2
+        args: ["--config", ".markdownlint.yaml"]

docs/administration.md

@@ -62,10 +62,6 @@ copies you created in the steps above.
 
 ## Updating Paperless {#updating}
 
-!!! warning
-
-    Please review the [migration instructions](migration-v3.md) before upgrading Paperless-ngx to v3.0, it includes some breaking changes that require manual intervention before upgrading.
-
 ### Docker Route {#docker-updating}
 
 If a new release of paperless-ngx is available, upgrading depends on how

docs/configuration.md

@@ -51,172 +51,137 @@ matcher.
 ### Database
 
 By default, Paperless uses **SQLite** with a database stored at `data/db.sqlite3`.
-For multi-user or higher-throughput deployments, **PostgreSQL** (recommended) or
-**MariaDB** can be used instead by setting [`PAPERLESS_DBENGINE`](#PAPERLESS_DBENGINE)
-and the relevant connection variables.
-
-#### [`PAPERLESS_DBENGINE=<engine>`](#PAPERLESS_DBENGINE) {#PAPERLESS_DBENGINE}
-
-: Specifies the database engine to use. Accepted values are `sqlite`, `postgresql`,
-and `mariadb`.
-
-    Defaults to `sqlite` if not set.
-
-    PostgreSQL and MariaDB both require [`PAPERLESS_DBHOST`](#PAPERLESS_DBHOST) to be
-    set. SQLite does not use any other connection variables; the database file is always
-    located at `<PAPERLESS_DATA_DIR>/db.sqlite3`.
-
-    !!! warning
-        Using MariaDB comes with some caveats.
-        See [MySQL Caveats](advanced_usage.md#mysql-caveats).
+To switch to **PostgreSQL** or **MariaDB**, set [`PAPERLESS_DBHOST`](#PAPERLESS_DBHOST) and optionally configure other
+database-related environment variables.
 
 #### [`PAPERLESS_DBHOST=<hostname>`](#PAPERLESS_DBHOST) {#PAPERLESS_DBHOST}
 
-: Hostname of the PostgreSQL or MariaDB database server. Required when
-`PAPERLESS_DBENGINE` is `postgresql` or `mariadb`.
+: If unset, Paperless uses **SQLite** by default.
+
+    Set `PAPERLESS_DBHOST` to switch to PostgreSQL or MariaDB instead.
+
+#### [`PAPERLESS_DBENGINE=<engine_name>`](#PAPERLESS_DBENGINE) {#PAPERLESS_DBENGINE}
+
+: Optional. Specifies the database engine to use when connecting to a remote database.
+Available options are `postgresql` and `mariadb`.
+
+    Defaults to `postgresql` if `PAPERLESS_DBHOST` is set.
+
+    !!! warning
+
+        Using MariaDB comes with some caveats. See [MySQL Caveats](advanced_usage.md#mysql-caveats).
 
 #### [`PAPERLESS_DBPORT=<port>`](#PAPERLESS_DBPORT) {#PAPERLESS_DBPORT}
 
 : Port to use when connecting to PostgreSQL or MariaDB.
 
-    Defaults to `5432` for PostgreSQL and `3306` for MariaDB.
+    Default is `5432` for PostgreSQL and `3306` for MariaDB.
 
 #### [`PAPERLESS_DBNAME=<name>`](#PAPERLESS_DBNAME) {#PAPERLESS_DBNAME}
 
-: Name of the PostgreSQL or MariaDB database to connect to.
+: Name of the database to connect to when using PostgreSQL or MariaDB.
 
-    Defaults to `paperless`.
+    Defaults to "paperless".
 
-#### [`PAPERLESS_DBUSER=<user>`](#PAPERLESS_DBUSER) {#PAPERLESS_DBUSER}
+#### [`PAPERLESS_DBUSER=<name>`](#PAPERLESS_DBUSER) {#PAPERLESS_DBUSER}
 
 : Username for authenticating with the PostgreSQL or MariaDB database.
 
-    Defaults to `paperless`.
+    Defaults to "paperless".
 
 #### [`PAPERLESS_DBPASS=<password>`](#PAPERLESS_DBPASS) {#PAPERLESS_DBPASS}
 
 : Password for the PostgreSQL or MariaDB database user.
 
-    Defaults to `paperless`.
+    Defaults to "paperless".
 
-#### [`PAPERLESS_DB_OPTIONS=<options>`](#PAPERLESS_DB_OPTIONS) {#PAPERLESS_DB_OPTIONS}
+#### [`PAPERLESS_DBSSLMODE=<mode>`](#PAPERLESS_DBSSLMODE) {#PAPERLESS_DBSSLMODE}
 
-: Advanced database connection options as a semicolon-delimited key-value string.
-Keys and values are separated by `=`. Dot-notation produces nested option
-dictionaries; for example, `pool.max_size=20` sets
-`OPTIONS["pool"]["max_size"] = 20`.
+: SSL mode to use when connecting to PostgreSQL or MariaDB.
 
-    Options specified here are merged over the engine defaults. Unrecognised keys
-    are passed through to the underlying database driver without validation, so a
-    typo will be silently ignored rather than producing an error.
+    See [the official documentation about
+    sslmode for PostgreSQL](https://www.postgresql.org/docs/current/libpq-ssl.html).
 
-    Refer to your database driver's documentation for the full set of accepted keys:
+    See [the official documentation about
+    sslmode for MySQL and MariaDB](https://dev.mysql.com/doc/refman/8.0/en/connection-options.html#option_general_ssl-mode).
 
-    - PostgreSQL: [libpq connection parameters](https://www.postgresql.org/docs/current/libpq-connect.html#LIBPQ-PARAMKEYWORDS)
-    - MariaDB: [MariaDB Connector/Python](https://mariadb.com/kb/en/mariadb-connector-python/)
-    - SQLite: [SQLite PRAGMA statements](https://www.sqlite.org/pragma.html)
+    *Note*: SSL mode values differ between PostgreSQL and MariaDB.
 
-    !!! note "PostgreSQL connection pooling"
+    Default is `prefer` for PostgreSQL and `PREFERRED` for MariaDB.
 
-        Pool size is controlled via `pool.min_size` and `pool.max_size`. When
-        configuring pooling, ensure your PostgreSQL `max_connections` is large enough
-        to handle all pool connections across all workers:
-        `(web_workers + celery_workers) * pool.max_size + safety_margin`.
+#### [`PAPERLESS_DBSSLROOTCERT=<ca-path>`](#PAPERLESS_DBSSLROOTCERT) {#PAPERLESS_DBSSLROOTCERT}
 
-    **Examples:**
+: Path to the SSL root certificate used to verify the database server.
 
-    ```bash title="PostgreSQL: require SSL, set a custom CA certificate, and limit the pool size"
-    PAPERLESS_DB_OPTIONS="sslmode=require;sslrootcert=/certs/ca.pem;pool.max_size=5"
-    ```
+    See [the official documentation about
+    sslmode for PostgreSQL](https://www.postgresql.org/docs/current/libpq-ssl.html).
+    Changes the location of `root.crt`.
 
-    ```bash title="MariaDB: require SSL with a custom CA certificate"
-    PAPERLESS_DB_OPTIONS="ssl_mode=REQUIRED;ssl.ca=/certs/ca.pem"
-    ```
+    See [the official documentation about
+    sslmode for MySQL and MariaDB](https://dev.mysql.com/doc/refman/8.0/en/connection-options.html#option_general_ssl-ca).
 
-    ```bash title="SQLite: set a busy timeout of 30 seconds"
-    # PostgreSQL: set a connection timeout
-    PAPERLESS_DB_OPTIONS="connect_timeout=10"
-    ```
+    Defaults to unset, using the standard location in the home directory.
 
-#### ~~[`PAPERLESS_DBSSLMODE`](#PAPERLESS_DBSSLMODE)~~ {#PAPERLESS_DBSSLMODE}
+#### [`PAPERLESS_DBSSLCERT=<client-cert-path>`](#PAPERLESS_DBSSLCERT) {#PAPERLESS_DBSSLCERT}
 
-!!! failure "Removed in v3"
+: Path to the client SSL certificate used when connecting securely.
 
-    Use [`PAPERLESS_DB_OPTIONS`](#PAPERLESS_DB_OPTIONS) instead.
+    See [the official documentation about
+    sslmode for PostgreSQL](https://www.postgresql.org/docs/current/libpq-ssl.html).
 
-    ```bash title="PostgreSQL"
-    PAPERLESS_DB_OPTIONS="sslmode=require"
-    ```
+    See [the official documentation about
+    sslmode for MySQL and MariaDB](https://dev.mysql.com/doc/refman/8.0/en/connection-options.html#option_general_ssl-cert).
 
-    ```bash title="MariaDB"
-    PAPERLESS_DB_OPTIONS="ssl_mode=REQUIRED"
-    ```
+    Changes the location of `postgresql.crt`.
 
-#### ~~[`PAPERLESS_DBSSLROOTCERT`](#PAPERLESS_DBSSLROOTCERT)~~ {#PAPERLESS_DBSSLROOTCERT}
+    Defaults to unset, using the standard location in the home directory.
 
-!!! failure "Removed in v3"
+#### [`PAPERLESS_DBSSLKEY=<client-cert-key>`](#PAPERLESS_DBSSLKEY) {#PAPERLESS_DBSSLKEY}
 
-    Use [`PAPERLESS_DB_OPTIONS`](#PAPERLESS_DB_OPTIONS) instead.
+: Path to the client SSL private key used when connecting securely.
 
-    ```bash title="PostgreSQL"
-    PAPERLESS_DB_OPTIONS="sslrootcert=/path/to/ca.pem"
-    ```
+    See [the official documentation about
+    sslmode for PostgreSQL](https://www.postgresql.org/docs/current/libpq-ssl.html).
 
-    ```bash title="MariaDB"
-    PAPERLESS_DB_OPTIONS="ssl.ca=/path/to/ca.pem"
-    ```
+    See [the official documentation about
+    sslmode for MySQL and MariaDB](https://dev.mysql.com/doc/refman/8.0/en/connection-options.html#option_general_ssl-key).
 
-#### ~~[`PAPERLESS_DBSSLCERT`](#PAPERLESS_DBSSLCERT)~~ {#PAPERLESS_DBSSLCERT}
+    Changes the location of `postgresql.key`.
 
-!!! failure "Removed in v3"
+    Defaults to unset, using the standard location in the home directory.
 
-    Use [`PAPERLESS_DB_OPTIONS`](#PAPERLESS_DB_OPTIONS) instead.
+#### [`PAPERLESS_DB_TIMEOUT=<int>`](#PAPERLESS_DB_TIMEOUT) {#PAPERLESS_DB_TIMEOUT}
 
-    ```bash title="PostgreSQL"
-    PAPERLESS_DB_OPTIONS="sslcert=/path/to/client.crt"
-    ```
+: Sets how long a database connection should wait before timing out.
 
-    ```bash title="MariaDB"
-    PAPERLESS_DB_OPTIONS="ssl.cert=/path/to/client.crt"
-    ```
+    For SQLite, this sets how long to wait if the database is locked.
+    For PostgreSQL or MariaDB, this sets the connection timeout.
 
-#### ~~[`PAPERLESS_DBSSLKEY`](#PAPERLESS_DBSSLKEY)~~ {#PAPERLESS_DBSSLKEY}
+    Defaults to unset, which uses Django’s built-in defaults.
 
-!!! failure "Removed in v3"
+#### [`PAPERLESS_DB_POOLSIZE=<int>`](#PAPERLESS_DB_POOLSIZE) {#PAPERLESS_DB_POOLSIZE}
 
-    Use [`PAPERLESS_DB_OPTIONS`](#PAPERLESS_DB_OPTIONS) instead.
+: Defines the maximum number of database connections to keep in the pool.
 
-    ```bash title="PostgreSQL"
-    PAPERLESS_DB_OPTIONS="sslkey=/path/to/client.key"
-    ```
+    Only applies to PostgreSQL. This setting is ignored for other database engines.
 
-    ```bash title="MariaDB"
-    PAPERLESS_DB_OPTIONS="ssl.key=/path/to/client.key"
-    ```
+    The value must be greater than or equal to 1 to be used.
+    Defaults to unset, which disables connection pooling.
 
-#### ~~[`PAPERLESS_DB_TIMEOUT`](#PAPERLESS_DB_TIMEOUT)~~ {#PAPERLESS_DB_TIMEOUT}
+    !!! note
 
-!!! failure "Removed in v3"
+        A pool of 8-10 connections per worker is typically sufficient.
+        If you encounter error messages such as `couldn't get a connection`
+        or database connection timeouts, you probably need to increase the pool size.
 
-    Use [`PAPERLESS_DB_OPTIONS`](#PAPERLESS_DB_OPTIONS) instead.
+    !!! warning
+        Make sure your PostgreSQL `max_connections` setting is large enough to handle the connection pools:
+        `(NB_PAPERLESS_WORKERS + NB_CELERY_WORKERS) × POOL_SIZE + SAFETY_MARGIN`. For example, with
+        4 Paperless workers and 2 Celery workers, and a pool size of 8:``(4 + 2) × 8 + 10 = 58`,
+        so `max_connections = 60` (or even more) is appropriate.
 
-    ```bash title="SQLite"
-    PAPERLESS_DB_OPTIONS="timeout=30"
-    ```
-
-    ```bash title="PostgreSQL or MariaDB"
-    PAPERLESS_DB_OPTIONS="connect_timeout=30"
-    ```
-
-#### ~~[`PAPERLESS_DB_POOLSIZE`](#PAPERLESS_DB_POOLSIZE)~~ {#PAPERLESS_DB_POOLSIZE}
-
-!!! failure "Removed in v3"
-
-    Use [`PAPERLESS_DB_OPTIONS`](#PAPERLESS_DB_OPTIONS) instead.
-
-    ```bash
-    PAPERLESS_DB_OPTIONS="pool.max_size=10"
-    ```
+        This assumes only Paperless-ngx connects to your PostgreSQL instance. If you have other applications,
+        you should increase `max_connections` accordingly.
 
 #### [`PAPERLESS_DB_READ_CACHE_ENABLED=<bool>`](#PAPERLESS_DB_READ_CACHE_ENABLED) {#PAPERLESS_DB_READ_CACHE_ENABLED}
 

docs/migration.md

@@ -48,58 +48,3 @@ The `CONSUMER_BARCODE_SCANNER` setting has been removed. zxing-cpp is now the on
     reliability.
 -   The `libzbar0` / `libzbar-dev` system packages are no longer required and can be removed from any custom Docker
     images or host installations.
-
-## Database Engine
-
-`PAPERLESS_DBENGINE` is now required to use PostgreSQL or MariaDB. Previously, the
-engine was inferred from the presence of `PAPERLESS_DBHOST`, with `PAPERLESS_DBENGINE`
-only needed to select MariaDB over PostgreSQL.
-
-SQLite users require no changes, though they may explicitly set their engine if desired.
-
-#### Action Required
-
-PostgreSQL and MariaDB users must add `PAPERLESS_DBENGINE` to their environment:
-
-```yaml
-# v2 (PostgreSQL inferred from PAPERLESS_DBHOST)
-PAPERLESS_DBHOST: postgres
-
-# v3 (engine must be explicit)
-PAPERLESS_DBENGINE: postgresql
-PAPERLESS_DBHOST: postgres
-```
-
-See [`PAPERLESS_DBENGINE`](configuration.md#PAPERLESS_DBENGINE) for accepted values.
-
-## Database Advanced Options
-
-The individual SSL, timeout, and pooling variables have been removed in favor of a
-single [`PAPERLESS_DB_OPTIONS`](configuration.md#PAPERLESS_DB_OPTIONS) string. This
-consolidates a growing set of engine-specific variables into one place, and allows
-any option supported by the underlying database driver to be set without requiring a
-dedicated environment variable for each.
-
-The removed variables and their replacements are:
-
-| Removed Variable          | Replacement in `PAPERLESS_DB_OPTIONS`                                        |
-| ------------------------- | ---------------------------------------------------------------------------- |
-| `PAPERLESS_DBSSLMODE`     | `sslmode=<value>` (PostgreSQL) or `ssl_mode=<value>` (MariaDB)               |
-| `PAPERLESS_DBSSLROOTCERT` | `sslrootcert=<path>` (PostgreSQL) or `ssl.ca=<path>` (MariaDB)               |
-| `PAPERLESS_DBSSLCERT`     | `sslcert=<path>` (PostgreSQL) or `ssl.cert=<path>` (MariaDB)                 |
-| `PAPERLESS_DBSSLKEY`      | `sslkey=<path>` (PostgreSQL) or `ssl.key=<path>` (MariaDB)                   |
-| `PAPERLESS_DB_POOLSIZE`   | `pool.max_size=<value>` (PostgreSQL only)                                    |
-| `PAPERLESS_DB_TIMEOUT`    | `timeout=<value>` (SQLite) or `connect_timeout=<value>` (PostgreSQL/MariaDB) |
-
-The deprecated variables will continue to function for now but will be removed in a
-future release. A deprecation warning is logged at startup for each deprecated variable
-that is still set.
-
-#### Action Required
-
-Users with any of the deprecated variables set should migrate to `PAPERLESS_DB_OPTIONS`.
-Multiple options are combined in a single value:
-
-```bash
-PAPERLESS_DB_OPTIONS="sslmode=require;sslrootcert=/certs/ca.pem;pool.max_size=10"
-```

docs/setup.md

@@ -504,7 +504,8 @@ installation. Keep these points in mind:
 -   Read the [changelog](changelog.md) and
     take note of breaking changes.
 -   Decide whether to stay on SQLite or migrate to PostgreSQL.
-    Both work fine with
+    See [documentation](#sqlite_to_psql) for details on moving data
+    from SQLite to PostgreSQL. Both work fine with
     Paperless. However, if you already have a database server running
     for other services, you might as well use it for Paperless as well.
 -   The task scheduler of Paperless, which is used to execute periodic

pyproject.toml

@@ -37,7 +37,6 @@ dependencies = [
   "django-filter~=25.1",
   "django-guardian~=3.3.0",
   "django-multiselectfield~=1.0.1",
-  "django-rich~=2.2.0",
   "django-soft-delete~=1.0.18",
   "django-treenode>=0.23.2",
   "djangorestframework~=3.16",
@@ -77,6 +76,7 @@ dependencies = [
   "setproctitle~=1.3.4",
   "tika-client~=0.10.0",
   "torch~=2.10.0",
+  "tqdm~=4.67.1",
   "watchfiles>=1.1.1",
   "whitenoise~=6.11",
   "whoosh-reloaded>=2.7.5",
@@ -149,6 +149,7 @@ typing = [
   "types-pytz",
   "types-redis",
   "types-setuptools",
+  "types-tqdm",
 ]
 
 [tool.uv]
@@ -303,7 +304,6 @@ markers = [
   "tika: Tests requiring Tika service",
   "greenmail: Tests requiring Greenmail service",
   "date_parsing: Tests which cover date parsing from content or filename",
-  "management: Tests which cover management commands/functionality",
 ]
 
 [tool.pytest_env]

src-ui/.pre-commit-config.yaml

@@ -0,0 +1,9 @@
+repos:
+  - repo: https://github.com/rbubley/mirrors-prettier
+    rev: 'v3.8.1'
+    hooks:
+      - id: prettier
+        types_or: [javascript, ts]
+        additional_dependencies:
+          - prettier@3.3.3
+          - 'prettier-plugin-organize-imports@4.1.0'

src-ui/src/app/components/document-detail/document-version-dropdown/document-version-dropdown.component.html

@@ -57,7 +57,7 @@
       }
     </div>
     @for (version of versions; track version.id) {
-      <div class="dropdown-item border-top px-0" [class.pe-3]="versions.length === 1">
+      <div class="dropdown-item border-top px-0">
         <div class="d-flex align-items-center w-100 py-2 version-item">
           <div class="btn btn-link link-underline link-underline-opacity-0 d-flex align-items-center small text-start p-0 version-link"
             (click)="selectVersion(version.id)"
@@ -88,7 +88,7 @@
                     @if (version.version_label) {
                       {{ version.version_label }}
                     } @else {
-                      <ng-container i18n>Version</ng-container>&nbsp;{{ versions.length - $index }}&nbsp;<span class="text-muted small">(#{{ version.id }})</span>
+                      <span i18n>Version</span>&nbsp;#{{ version.id }}
                     }
                   </span>
                 }

src/.pre-commit-config.yaml

@@ -0,0 +1,10 @@
+orphan: true
+
+repos:
+  - repo: https://github.com/astral-sh/ruff-pre-commit
+    rev: v0.15.4
+    hooks:
+      - id: ruff-check
+      - id: ruff-format
+
+

src/documents/management/commands/base.py

@@ -1,320 +0,0 @@
-"""
-Base command class for Paperless-ngx management commands.
-
-Provides automatic progress bar and multiprocessing support with minimal boilerplate.
-"""
-
-from __future__ import annotations
-
-import os
-from collections.abc import Iterable
-from collections.abc import Sized
-from concurrent.futures import ProcessPoolExecutor
-from concurrent.futures import as_completed
-from dataclasses import dataclass
-from typing import TYPE_CHECKING
-from typing import Any
-from typing import ClassVar
-from typing import Generic
-from typing import TypeVar
-
-from django import db
-from django.core.management import CommandError
-from django.db.models import QuerySet
-from django_rich.management import RichCommand
-from rich.console import Console
-from rich.progress import BarColumn
-from rich.progress import MofNCompleteColumn
-from rich.progress import Progress
-from rich.progress import SpinnerColumn
-from rich.progress import TextColumn
-from rich.progress import TimeElapsedColumn
-from rich.progress import TimeRemainingColumn
-
-if TYPE_CHECKING:
-    from collections.abc import Callable
-    from collections.abc import Generator
-    from collections.abc import Iterable
-    from collections.abc import Sequence
-
-    from django.core.management import CommandParser
-
-T = TypeVar("T")
-R = TypeVar("R")
-
-
-@dataclass(frozen=True, slots=True)
-class ProcessResult(Generic[T, R]):
-    """
-    Result of processing a single item in parallel.
-
-    Attributes:
-        item: The input item that was processed.
-        result: The return value from the processing function, or None if an error occurred.
-        error: The exception if processing failed, or None on success.
-    """
-
-    item: T
-    result: R | None
-    error: BaseException | None
-
-    @property
-    def success(self) -> bool:
-        """Return True if the item was processed successfully."""
-        return self.error is None
-
-
-class PaperlessCommand(RichCommand):
-    """
-    Base command class with automatic progress bar and multiprocessing support.
-
-    Features are opt-in via class attributes:
-        supports_progress_bar: Adds --no-progress-bar argument (default: True)
-        supports_multiprocessing: Adds --processes argument (default: False)
-
-    Example usage:
-
-        class Command(PaperlessCommand):
-            help = "Process all documents"
-
-            def handle(self, *args, **options):
-                documents = Document.objects.all()
-                for doc in self.track(documents, description="Processing..."):
-                    process_document(doc)
-
-        class Command(PaperlessCommand):
-            help = "Regenerate thumbnails"
-            supports_multiprocessing = True
-
-            def handle(self, *args, **options):
-                ids = list(Document.objects.values_list("id", flat=True))
-                for result in self.process_parallel(process_doc, ids):
-                    if result.error:
-                        self.console.print(f"[red]Failed: {result.error}[/red]")
-    """
-
-    supports_progress_bar: ClassVar[bool] = True
-    supports_multiprocessing: ClassVar[bool] = False
-
-    # Instance attributes set by execute() before handle() runs
-    no_progress_bar: bool
-    process_count: int
-
-    def add_arguments(self, parser: CommandParser) -> None:
-        """Add arguments based on supported features."""
-        super().add_arguments(parser)
-
-        if self.supports_progress_bar:
-            parser.add_argument(
-                "--no-progress-bar",
-                default=False,
-                action="store_true",
-                help="Disable the progress bar",
-            )
-
-        if self.supports_multiprocessing:
-            default_processes = max(1, (os.cpu_count() or 1) // 4)
-            parser.add_argument(
-                "--processes",
-                default=default_processes,
-                type=int,
-                help=f"Number of processes to use (default: {default_processes})",
-            )
-
-    def execute(self, *args: Any, **options: Any) -> str | None:
-        """
-        Set up instance state before handle() is called.
-
-        This is called by Django's command infrastructure after argument parsing
-        but before handle(). We use it to set instance attributes from options.
-        """
-        # Set progress bar state
-        if self.supports_progress_bar:
-            self.no_progress_bar = options.get("no_progress_bar", False)
-        else:
-            self.no_progress_bar = True
-
-        # Set multiprocessing state
-        if self.supports_multiprocessing:
-            self.process_count = options.get("processes", 1)
-            if self.process_count < 1:
-                raise CommandError("--processes must be at least 1")
-        else:
-            self.process_count = 1
-
-        return super().execute(*args, **options)
-
-    def _create_progress(self, description: str) -> Progress:
-        """
-        Create a configured Progress instance.
-
-        Progress output is directed to stderr to match the convention that
-        progress bars are transient UI feedback, not command output. This
-        mirrors tqdm's default behavior and prevents progress bar rendering
-        from interfering with stdout-based assertions in tests or piped
-        command output.
-
-        Args:
-            description: Text to display alongside the progress bar.
-
-        Returns:
-            A Progress instance configured with appropriate columns.
-        """
-        return Progress(
-            SpinnerColumn(),
-            TextColumn("[progress.description]{task.description}"),
-            BarColumn(),
-            MofNCompleteColumn(),
-            TimeElapsedColumn(),
-            TimeRemainingColumn(),
-            console=Console(stderr=True),
-            transient=False,
-        )
-
-    def _get_iterable_length(self, iterable: Iterable[object]) -> int | None:
-        """
-        Attempt to determine the length of an iterable without consuming it.
-
-        Tries .count() first (for Django querysets - executes SELECT COUNT(*)),
-        then falls back to len() for sequences.
-
-        Args:
-            iterable: The iterable to measure.
-
-        Returns:
-            The length if determinable, None otherwise.
-        """
-        if isinstance(iterable, QuerySet):
-            return iterable.count()
-
-        if isinstance(iterable, Sized):
-            return len(iterable)
-
-        return None
-
-    def track(
-        self,
-        iterable: Iterable[T],
-        *,
-        description: str = "Processing...",
-        total: int | None = None,
-    ) -> Generator[T, None, None]:
-        """
-        Iterate over items with an optional progress bar.
-
-        Respects --no-progress-bar flag. When disabled, simply yields items
-        without any progress display.
-
-        Args:
-            iterable: The items to iterate over.
-            description: Text to display alongside the progress bar.
-            total: Total number of items. If None, attempts to determine
-                automatically via .count() (for querysets) or len().
-
-        Yields:
-            Items from the iterable.
-
-        Example:
-            for doc in self.track(documents, description="Renaming..."):
-                process(doc)
-        """
-        if self.no_progress_bar:
-            yield from iterable
-            return
-
-        # Attempt to determine total if not provided
-        if total is None:
-            total = self._get_iterable_length(iterable)
-
-        with self._create_progress(description) as progress:
-            task_id = progress.add_task(description, total=total)
-            for item in iterable:
-                yield item
-                progress.advance(task_id)
-
-    def process_parallel(
-        self,
-        fn: Callable[[T], R],
-        items: Sequence[T],
-        *,
-        description: str = "Processing...",
-    ) -> Generator[ProcessResult[T, R], None, None]:
-        """
-        Process items in parallel with progress tracking.
-
-        When --processes=1, runs sequentially in the main process without
-        spawning subprocesses. This is critical for testing, as multiprocessing
-        breaks fixtures, mocks, and database transactions.
-
-        When --processes > 1, uses ProcessPoolExecutor and automatically closes
-        database connections before spawning workers (required for PostgreSQL).
-
-        Args:
-            fn: Function to apply to each item. Must be picklable for parallel
-                execution (i.e., defined at module level, not a lambda or closure).
-            items: Sequence of items to process.
-            description: Text to display alongside the progress bar.
-
-        Yields:
-            ProcessResult for each item, containing the item, result, and any error.
-
-        Example:
-            def regenerate_thumbnail(doc_id: int) -> Path:
-                ...
-
-            for result in self.process_parallel(regenerate_thumbnail, doc_ids):
-                if result.error:
-                    self.console.print(f"[red]Failed {result.item}[/red]")
-        """
-        total = len(items)
-
-        if self.process_count == 1:
-            # Sequential execution in main process - critical for testing
-            yield from self._process_sequential(fn, items, description, total)
-        else:
-            # Parallel execution with ProcessPoolExecutor
-            yield from self._process_parallel(fn, items, description, total)
-
-    def _process_sequential(
-        self,
-        fn: Callable[[T], R],
-        items: Sequence[T],
-        description: str,
-        total: int,
-    ) -> Generator[ProcessResult[T, R], None, None]:
-        """Process items sequentially in the main process."""
-        for item in self.track(items, description=description, total=total):
-            try:
-                result = fn(item)
-                yield ProcessResult(item=item, result=result, error=None)
-            except Exception as e:
-                yield ProcessResult(item=item, result=None, error=e)
-
-    def _process_parallel(
-        self,
-        fn: Callable[[T], R],
-        items: Sequence[T],
-        description: str,
-        total: int,
-    ) -> Generator[ProcessResult[T, R], None, None]:
-        """Process items in parallel using ProcessPoolExecutor."""
-        # Close database connections before forking - required for PostgreSQL
-        db.connections.close_all()
-
-        with self._create_progress(description) as progress:
-            task_id = progress.add_task(description, total=total)
-
-            with ProcessPoolExecutor(max_workers=self.process_count) as executor:
-                # Submit all tasks and map futures back to items
-                future_to_item = {executor.submit(fn, item): item for item in items}
-
-                # Yield results as they complete
-                for future in as_completed(future_to_item):
-                    item = future_to_item[future]
-                    try:
-                        result = future.result()
-                        yield ProcessResult(item=item, result=result, error=None)
-                    except Exception as e:
-                        yield ProcessResult(item=item, result=None, error=e)
-                    finally:
-                        progress.advance(task_id)

src/documents/management/commands/document_archiver.py

@@ -1,15 +1,20 @@
 import logging
+import multiprocessing
 
+import tqdm
+from django import db
 from django.conf import settings
+from django.core.management.base import BaseCommand
 
-from documents.management.commands.base import PaperlessCommand
+from documents.management.commands.mixins import MultiProcessMixin
+from documents.management.commands.mixins import ProgressBarMixin
 from documents.models import Document
 from documents.tasks import update_document_content_maybe_archive_file
 
 logger = logging.getLogger("paperless.management.archiver")
 
 
-class Command(PaperlessCommand):
+class Command(MultiProcessMixin, ProgressBarMixin, BaseCommand):
     help = (
         "Using the current classification model, assigns correspondents, tags "
         "and document types to all documents, effectively allowing you to "
@@ -17,10 +22,7 @@ class Command(PaperlessCommand):
         "modified) after their initial import."
     )
 
-    supports_multiprocessing = True
-
     def add_arguments(self, parser):
-        super().add_arguments(parser)
         parser.add_argument(
             "-f",
             "--overwrite",
@@ -42,8 +44,13 @@ class Command(PaperlessCommand):
                 "run on this specific document."
             ),
         )
+        self.add_argument_progress_bar_mixin(parser)
+        self.add_argument_processes_mixin(parser)
 
     def handle(self, *args, **options):
+        self.handle_processes_mixin(**options)
+        self.handle_progress_bar_mixin(**options)
+
         settings.SCRATCH_DIR.mkdir(parents=True, exist_ok=True)
 
         overwrite = options["overwrite"]
@@ -53,21 +60,35 @@ class Command(PaperlessCommand):
         else:
             documents = Document.objects.all()
 
-        document_ids = [
-            doc.id for doc in documents if overwrite or not doc.has_archive_version
-        ]
+        document_ids = list(
+            map(
+                lambda doc: doc.id,
+                filter(lambda d: overwrite or not d.has_archive_version, documents),
+            ),
+        )
+
+        # Note to future self: this prevents django from reusing database
+        # connections between processes, which is bad and does not work
+        # with postgres.
+        db.connections.close_all()
 
         try:
             logging.getLogger().handlers[0].level = logging.ERROR
 
-            for result in self.process_parallel(
-                update_document_content_maybe_archive_file,
-                document_ids,
-                description="Archiving...",
-            ):
-                if result.error:
-                    self.console.print(
-                        f"[red]Failed document {result.item}: {result.error}[/red]",
+            if self.process_count == 1:
+                for doc_id in document_ids:
+                    update_document_content_maybe_archive_file(doc_id)
+            else:  # pragma: no cover
+                with multiprocessing.Pool(self.process_count) as pool:
+                    list(
+                        tqdm.tqdm(
+                            pool.imap_unordered(
+                                update_document_content_maybe_archive_file,
+                                document_ids,
+                            ),
+                            total=len(document_ids),
+                            disable=self.no_progress_bar,
+                        ),
                     )
-        except KeyboardInterrupt:  # pragma: no cover
-            self.console.print("[yellow]Aborting...[/yellow]")
+        except KeyboardInterrupt:
+            self.stdout.write(self.style.NOTICE("Aborting..."))

src/documents/management/commands/document_fuzzy_match.py

@@ -1,20 +1,24 @@
 import dataclasses
+import multiprocessing
 from typing import Final
 
 import rapidfuzz
+import tqdm
+from django.core.management import BaseCommand
 from django.core.management import CommandError
 
-from documents.management.commands.base import PaperlessCommand
+from documents.management.commands.mixins import MultiProcessMixin
+from documents.management.commands.mixins import ProgressBarMixin
 from documents.models import Document
 
 
-@dataclasses.dataclass(frozen=True, slots=True)
+@dataclasses.dataclass(frozen=True)
 class _WorkPackage:
     first_doc: Document
     second_doc: Document
 
 
-@dataclasses.dataclass(frozen=True, slots=True)
+@dataclasses.dataclass(frozen=True)
 class _WorkResult:
     doc_one_pk: int
     doc_two_pk: int
@@ -27,23 +31,22 @@ class _WorkResult:
 def _process_and_match(work: _WorkPackage) -> _WorkResult:
     """
     Does basic processing of document content, gets the basic ratio
-    and returns the result package.
+    and returns the result package
     """
+    # Normalize the string some, lower case, whitespace, etc
     first_string = rapidfuzz.utils.default_process(work.first_doc.content)
     second_string = rapidfuzz.utils.default_process(work.second_doc.content)
 
+    # Basic matching ratio
     match = rapidfuzz.fuzz.ratio(first_string, second_string)
 
     return _WorkResult(work.first_doc.pk, work.second_doc.pk, match)
 
 
-class Command(PaperlessCommand):
+class Command(MultiProcessMixin, ProgressBarMixin, BaseCommand):
     help = "Searches for documents where the content almost matches"
 
-    supports_multiprocessing = True
-
     def add_arguments(self, parser):
-        super().add_arguments(parser)
         parser.add_argument(
             "--ratio",
             default=85.0,
@@ -56,11 +59,16 @@ class Command(PaperlessCommand):
             action="store_true",
             help="If set, one document of matches above the ratio WILL BE DELETED",
         )
+        self.add_argument_progress_bar_mixin(parser)
+        self.add_argument_processes_mixin(parser)
 
     def handle(self, *args, **options):
         RATIO_MIN: Final[float] = 0.0
         RATIO_MAX: Final[float] = 100.0
 
+        self.handle_processes_mixin(**options)
+        self.handle_progress_bar_mixin(**options)
+
         if options["delete"]:
             self.stdout.write(
                 self.style.WARNING(
@@ -72,58 +80,66 @@ class Command(PaperlessCommand):
         checked_pairs: set[tuple[int, int]] = set()
         work_pkgs: list[_WorkPackage] = []
 
+        # Ratio is a float from 0.0 to 100.0
         if opt_ratio < RATIO_MIN or opt_ratio > RATIO_MAX:
             raise CommandError("The ratio must be between 0 and 100")
 
         all_docs = Document.objects.all().order_by("id")
 
+        # Build work packages for processing
         for first_doc in all_docs:
             for second_doc in all_docs:
+                # doc to doc is obviously not useful
                 if first_doc.pk == second_doc.pk:
                     continue
+                # Skip empty documents (e.g. password-protected)
                 if first_doc.content.strip() == "" or second_doc.content.strip() == "":
                     continue
+                # Skip matching which have already been matched together
+                # doc 1 to doc 2 is the same as doc 2 to doc 1
                 doc_1_to_doc_2 = (first_doc.pk, second_doc.pk)
                 doc_2_to_doc_1 = doc_1_to_doc_2[::-1]
                 if doc_1_to_doc_2 in checked_pairs or doc_2_to_doc_1 in checked_pairs:
                     continue
                 checked_pairs.update([doc_1_to_doc_2, doc_2_to_doc_1])
+                # Actually something useful to work on now
                 work_pkgs.append(_WorkPackage(first_doc, second_doc))
 
-        results: list[_WorkResult] = []
+        # Don't spin up a pool of 1 process
         if self.process_count == 1:
-            for work in self.track(work_pkgs, description="Matching..."):
+            results = []
+            for work in tqdm.tqdm(work_pkgs, disable=self.no_progress_bar):
                 results.append(_process_and_match(work))
         else:  # pragma: no cover
-            for proc_result in self.process_parallel(
-                _process_and_match,
-                work_pkgs,
-                description="Matching...",
-            ):
-                if proc_result.error:
-                    self.console.print(
-                        f"[red]Failed: {proc_result.error}[/red]",
-                    )
-                elif proc_result.result is not None:
-                    results.append(proc_result.result)
-
-        messages: list[str] = []
-        maybe_delete_ids: list[int] = []
-        for match_result in sorted(results):
-            if match_result.ratio >= opt_ratio:
-                messages.append(
-                    self.style.NOTICE(
-                        f"Document {match_result.doc_one_pk} fuzzy match"
-                        f" to {match_result.doc_two_pk}"
-                        f" (confidence {match_result.ratio:.3f})\n",
+            with multiprocessing.Pool(processes=self.process_count) as pool:
+                results = list(
+                    tqdm.tqdm(
+                        pool.imap_unordered(_process_and_match, work_pkgs),
+                        total=len(work_pkgs),
+                        disable=self.no_progress_bar,
                     ),
                 )
-                maybe_delete_ids.append(match_result.doc_two_pk)
+
+        # Check results
+        messages = []
+        maybe_delete_ids = []
+        for result in sorted(results):
+            if result.ratio >= opt_ratio:
+                messages.append(
+                    self.style.NOTICE(
+                        f"Document {result.doc_one_pk} fuzzy match"
+                        f" to {result.doc_two_pk} (confidence {result.ratio:.3f})\n",
+                    ),
+                )
+                maybe_delete_ids.append(result.doc_two_pk)
 
         if len(messages) == 0:
-            messages.append(self.style.SUCCESS("No matches found\n"))
-        self.stdout.writelines(messages)
-
+            messages.append(
+                self.style.SUCCESS("No matches found\n"),
+            )
+        self.stdout.writelines(
+            messages,
+        )
         if options["delete"]:
             self.stdout.write(
                 self.style.NOTICE(

src/documents/management/commands/document_renamer.py

@@ -1,12 +1,25 @@
+import logging
+
+import tqdm
+from django.core.management.base import BaseCommand
 from django.db.models.signals import post_save
 
-from documents.management.commands.base import PaperlessCommand
+from documents.management.commands.mixins import ProgressBarMixin
 from documents.models import Document
 
 
-class Command(PaperlessCommand):
-    help = "Rename all documents"
+class Command(ProgressBarMixin, BaseCommand):
+    help = "This will rename all documents to match the latest filename format."
+
+    def add_arguments(self, parser):
+        self.add_argument_progress_bar_mixin(parser)
 
     def handle(self, *args, **options):
-        for document in self.track(Document.objects.all(), description="Renaming..."):
+        self.handle_progress_bar_mixin(**options)
+        logging.getLogger().handlers[0].level = logging.ERROR
+
+        for document in tqdm.tqdm(
+            Document.objects.all(),
+            disable=self.no_progress_bar,
+        ):
             post_save.send(Document, instance=document, created=False)

src/documents/management/commands/document_retagger.py

@@ -1,7 +1,10 @@
 import logging
 
+import tqdm
+from django.core.management.base import BaseCommand
+
 from documents.classifier import load_classifier
-from documents.management.commands.base import PaperlessCommand
+from documents.management.commands.mixins import ProgressBarMixin
 from documents.models import Document
 from documents.signals.handlers import set_correspondent
 from documents.signals.handlers import set_document_type
@@ -11,7 +14,7 @@ from documents.signals.handlers import set_tags
 logger = logging.getLogger("paperless.management.retagger")
 
 
-class Command(PaperlessCommand):
+class Command(ProgressBarMixin, BaseCommand):
     help = (
         "Using the current classification model, assigns correspondents, tags "
         "and document types to all documents, effectively allowing you to "
@@ -20,7 +23,6 @@ class Command(PaperlessCommand):
     )
 
     def add_arguments(self, parser):
-        super().add_arguments(parser)
         parser.add_argument("-c", "--correspondent", default=False, action="store_true")
         parser.add_argument("-T", "--tags", default=False, action="store_true")
         parser.add_argument("-t", "--document_type", default=False, action="store_true")
@@ -32,7 +34,7 @@ class Command(PaperlessCommand):
             action="store_true",
             help=(
                 "By default this command won't try to assign a correspondent "
-                "if more than one matches the document. Use this flag if "
+                "if more than one matches the document.  Use this flag if "
                 "you'd rather it just pick the first one it finds."
             ),
         )
@@ -47,6 +49,7 @@ class Command(PaperlessCommand):
                 "and tags that do not match anymore due to changed rules."
             ),
         )
+        self.add_argument_progress_bar_mixin(parser)
         parser.add_argument(
             "--suggest",
             default=False,
@@ -65,6 +68,8 @@ class Command(PaperlessCommand):
         )
 
     def handle(self, *args, **options):
+        self.handle_progress_bar_mixin(**options)
+
         if options["inbox_only"]:
             queryset = Document.objects.filter(tags__is_inbox_tag=True)
         else:
@@ -79,7 +84,7 @@ class Command(PaperlessCommand):
 
         classifier = load_classifier()
 
-        for document in self.track(documents, description="Retagging..."):
+        for document in tqdm.tqdm(documents, disable=self.no_progress_bar):
             if options["correspondent"]:
                 set_correspondent(
                     sender=None,
@@ -117,7 +122,6 @@ class Command(PaperlessCommand):
                     stdout=self.stdout,
                     style_func=self.style,
                 )
-
             if options["storage_path"]:
                 set_storage_path(
                     sender=None,

src/documents/management/commands/document_thumbnails.py

@@ -1,45 +1,43 @@
 import logging
+import multiprocessing
 import shutil
 
-from documents.management.commands.base import PaperlessCommand
+import tqdm
+from django import db
+from django.core.management.base import BaseCommand
+
+from documents.management.commands.mixins import MultiProcessMixin
+from documents.management.commands.mixins import ProgressBarMixin
 from documents.models import Document
 from documents.parsers import get_parser_class_for_mime_type
 
-logger = logging.getLogger("paperless.management.thumbnails")
 
-
-def _process_document(doc_id: int) -> None:
+def _process_document(doc_id) -> None:
     document: Document = Document.objects.get(id=doc_id)
     parser_class = get_parser_class_for_mime_type(document.mime_type)
 
-    if parser_class is None:
-        logger.warning(
-            "%s: No parser for mime type %s",
-            document,
-            document.mime_type,
-        )
+    if parser_class:
+        parser = parser_class(logging_group=None)
+    else:
+        print(f"{document} No parser for mime type {document.mime_type}")  # noqa: T201
         return
 
-    parser = parser_class(logging_group=None)
-
     try:
         thumb = parser.get_thumbnail(
             document.source_path,
             document.mime_type,
             document.get_public_filename(),
         )
+
         shutil.move(thumb, document.thumbnail_path)
     finally:
         parser.cleanup()
 
 
-class Command(PaperlessCommand):
+class Command(MultiProcessMixin, ProgressBarMixin, BaseCommand):
     help = "This will regenerate the thumbnails for all documents."
 
-    supports_multiprocessing = True
-
     def add_arguments(self, parser) -> None:
-        super().add_arguments(parser)
         parser.add_argument(
             "-d",
             "--document",
@@ -51,23 +49,36 @@ class Command(PaperlessCommand):
                 "run on this specific document."
             ),
         )
+        self.add_argument_progress_bar_mixin(parser)
+        self.add_argument_processes_mixin(parser)
 
     def handle(self, *args, **options):
         logging.getLogger().handlers[0].level = logging.ERROR
 
+        self.handle_processes_mixin(**options)
+        self.handle_progress_bar_mixin(**options)
+
         if options["document"]:
             documents = Document.objects.filter(pk=options["document"])
         else:
             documents = Document.objects.all()
 
-        ids = list(documents.values_list("id", flat=True))
+        ids = [doc.id for doc in documents]
 
-        for result in self.process_parallel(
-            _process_document,
-            ids,
-            description="Regenerating thumbnails...",
-        ):
-            if result.error:  # pragma: no cover
-                self.console.print(
-                    f"[red]Failed document {result.item}: {result.error}[/red]",
+        # Note to future self: this prevents django from reusing database
+        # connections between processes, which is bad and does not work
+        # with postgres.
+        db.connections.close_all()
+
+        if self.process_count == 1:
+            for doc_id in ids:
+                _process_document(doc_id)
+        else:  # pragma: no cover
+            with multiprocessing.Pool(processes=self.process_count) as pool:
+                list(
+                    tqdm.tqdm(
+                        pool.imap_unordered(_process_document, ids),
+                        total=len(ids),
+                        disable=self.no_progress_bar,
+                    ),
                 )

src/documents/management/commands/mixins.py

@@ -21,6 +21,26 @@ class CryptFields(TypedDict):
     fields: list[str]
 
 
+class MultiProcessMixin:
+    """
+    Small class to handle adding an argument and validating it
+    for the use of multiple processes
+    """
+
+    def add_argument_processes_mixin(self, parser: ArgumentParser) -> None:
+        parser.add_argument(
+            "--processes",
+            default=max(1, os.cpu_count() // 4),
+            type=int,
+            help="Number of processes to distribute work amongst",
+        )
+
+    def handle_processes_mixin(self, *args, **options) -> None:
+        self.process_count = options["processes"]
+        if self.process_count < 1:
+            raise CommandError("There must be at least 1 process")
+
+
 class ProgressBarMixin:
     """
     Many commands use a progress bar, which can be disabled

src/documents/management/commands/prune_audit_logs.py

@@ -1,21 +1,27 @@
 from auditlog.models import LogEntry
+from django.core.management.base import BaseCommand
 from django.db import transaction
+from tqdm import tqdm
 
-from documents.management.commands.base import PaperlessCommand
+from documents.management.commands.mixins import ProgressBarMixin
 
 
-class Command(PaperlessCommand):
-    """Prune the audit logs of objects that no longer exist."""
+class Command(BaseCommand, ProgressBarMixin):
+    """
+    Prune the audit logs of objects that no longer exist.
+    """
 
     help = "Prunes the audit logs of objects that no longer exist."
 
-    def handle(self, *args, **options):
+    def add_arguments(self, parser):
+        self.add_argument_progress_bar_mixin(parser)
+
+    def handle(self, **options):
+        self.handle_progress_bar_mixin(**options)
         with transaction.atomic():
-            for log_entry in self.track(
-                LogEntry.objects.all(),
-                description="Pruning audit logs...",
-            ):
+            for log_entry in tqdm(LogEntry.objects.all(), disable=self.no_progress_bar):
                 model_class = log_entry.content_type.model_class()
+                # use global_objects for SoftDeleteModel
                 objects = (
                     model_class.global_objects
                     if hasattr(model_class, "global_objects")
@@ -26,8 +32,8 @@ class Command(PaperlessCommand):
                     and not objects.filter(pk=log_entry.object_id).exists()
                 ):
                     log_entry.delete()
-                    self.console.print(
-                        f"Deleted audit log entry for "
-                        f"{model_class.__name__} #{log_entry.object_id}",
-                        style="yellow",
+                    tqdm.write(
+                        self.style.NOTICE(
+                            f"Deleted audit log entry for {model_class.__name__} #{log_entry.object_id}",
+                        ),
                     )

src/documents/tests/management/test_management_base_cmd.py

@@ -1,518 +0,0 @@
-"""Tests for PaperlessCommand base class."""
-
-from __future__ import annotations
-
-import io
-from typing import TYPE_CHECKING
-
-import pytest
-from django.core.management import CommandError
-from django.db.models import QuerySet
-from rich.console import Console
-
-from documents.management.commands.base import PaperlessCommand
-from documents.management.commands.base import ProcessResult
-
-if TYPE_CHECKING:
-    from pytest_mock import MockerFixture
-
-
-# --- Test Commands ---
-# These simulate real command implementations for testing
-
-
-class SimpleCommand(PaperlessCommand):
-    """Command with default settings (progress bar, no multiprocessing)."""
-
-    help = "Simple test command"
-
-    def handle(self, *args, **options):
-        items = list(range(5))
-        results = []
-        for item in self.track(items, description="Processing..."):
-            results.append(item * 2)
-        self.stdout.write(f"Results: {results}")
-
-
-class NoProgressBarCommand(PaperlessCommand):
-    """Command with progress bar disabled."""
-
-    help = "No progress bar command"
-    supports_progress_bar = False
-
-    def handle(self, *args, **options):
-        items = list(range(3))
-        for _ in self.track(items):
-            # We don't need to actually work
-            pass
-        self.stdout.write("Done")
-
-
-class MultiprocessCommand(PaperlessCommand):
-    """Command with multiprocessing support."""
-
-    help = "Multiprocess test command"
-    supports_multiprocessing = True
-
-    def handle(self, *args, **options):
-        items = list(range(5))
-        results = []
-        for result in self.process_parallel(
-            _double_value,
-            items,
-            description="Processing...",
-        ):
-            results.append(result)
-        successes = sum(1 for r in results if r.success)
-        self.stdout.write(f"Successes: {successes}")
-
-
-# --- Helper Functions for Multiprocessing ---
-# Must be at module level to be picklable
-
-
-def _double_value(x: int) -> int:
-    """Double the input value."""
-    return x * 2
-
-
-def _divide_ten_by(x: int) -> float:
-    """Divide 10 by x. Raises ZeroDivisionError if x is 0."""
-    return 10 / x
-
-
-# --- Fixtures ---
-
-
-@pytest.fixture
-def console() -> Console:
-    """Create a non-interactive console for testing."""
-    return Console(force_terminal=False, force_interactive=False)
-
-
-@pytest.fixture
-def simple_command(console: Console) -> SimpleCommand:
-    """Create a SimpleCommand instance configured for testing."""
-    command = SimpleCommand()
-    command.stdout = io.StringIO()
-    command.stderr = io.StringIO()
-    command.console = console
-    command.no_progress_bar = True
-    command.process_count = 1
-    return command
-
-
-@pytest.fixture
-def multiprocess_command(console: Console) -> MultiprocessCommand:
-    """Create a MultiprocessCommand instance configured for testing."""
-    command = MultiprocessCommand()
-    command.stdout = io.StringIO()
-    command.stderr = io.StringIO()
-    command.console = console
-    command.no_progress_bar = True
-    command.process_count = 1
-    return command
-
-
-@pytest.fixture
-def mock_queryset():
-    """
-    Create a mock Django QuerySet that tracks method calls.
-
-    This verifies we use .count() instead of len() for querysets.
-    """
-
-    class MockQuerySet(QuerySet):
-        def __init__(self, items: list):
-            self._items = items
-            self.count_called = False
-
-        def count(self) -> int:
-            self.count_called = True
-            return len(self._items)
-
-        def __iter__(self):
-            return iter(self._items)
-
-        def __len__(self):
-            raise AssertionError("len() should not be called on querysets")
-
-    return MockQuerySet
-
-
-# --- Test Classes ---
-
-
-@pytest.mark.management
-class TestProcessResult:
-    """Tests for the ProcessResult dataclass."""
-
-    def test_success_result(self):
-        result = ProcessResult(item=1, result=2, error=None)
-
-        assert result.item == 1
-        assert result.result == 2
-        assert result.error is None
-        assert result.success is True
-
-    def test_error_result(self):
-        error = ValueError("test error")
-        result = ProcessResult(item=1, result=None, error=error)
-
-        assert result.item == 1
-        assert result.result is None
-        assert result.error is error
-        assert result.success is False
-
-
-@pytest.mark.management
-class TestPaperlessCommandArguments:
-    """Tests for argument parsing behavior."""
-
-    def test_progress_bar_argument_added_by_default(self):
-        command = SimpleCommand()
-        parser = command.create_parser("manage.py", "simple")
-
-        options = parser.parse_args(["--no-progress-bar"])
-        assert options.no_progress_bar is True
-
-        options = parser.parse_args([])
-        assert options.no_progress_bar is False
-
-    def test_progress_bar_argument_not_added_when_disabled(self):
-        command = NoProgressBarCommand()
-        parser = command.create_parser("manage.py", "noprogress")
-
-        options = parser.parse_args([])
-        assert not hasattr(options, "no_progress_bar")
-
-    def test_processes_argument_added_when_multiprocessing_enabled(self):
-        command = MultiprocessCommand()
-        parser = command.create_parser("manage.py", "multiprocess")
-
-        options = parser.parse_args(["--processes", "4"])
-        assert options.processes == 4
-
-        options = parser.parse_args([])
-        assert options.processes >= 1
-
-    def test_processes_argument_not_added_when_multiprocessing_disabled(self):
-        command = SimpleCommand()
-        parser = command.create_parser("manage.py", "simple")
-
-        options = parser.parse_args([])
-        assert not hasattr(options, "processes")
-
-
-@pytest.mark.management
-class TestPaperlessCommandExecute:
-    """Tests for the execute() setup behavior."""
-
-    @pytest.fixture
-    def base_options(self) -> dict:
-        """Base options required for execute()."""
-        return {
-            "verbosity": 1,
-            "no_color": True,
-            "force_color": False,
-            "skip_checks": True,
-        }
-
-    @pytest.mark.parametrize(
-        ("no_progress_bar_flag", "expected"),
-        [
-            pytest.param(False, False, id="progress-bar-enabled"),
-            pytest.param(True, True, id="progress-bar-disabled"),
-        ],
-    )
-    def test_no_progress_bar_state_set(
-        self,
-        base_options: dict,
-        *,
-        no_progress_bar_flag: bool,
-        expected: bool,
-    ):
-        command = SimpleCommand()
-        command.stdout = io.StringIO()
-        command.stderr = io.StringIO()
-
-        options = {**base_options, "no_progress_bar": no_progress_bar_flag}
-        command.execute(**options)
-
-        assert command.no_progress_bar is expected
-
-    def test_no_progress_bar_always_true_when_not_supported(self, base_options: dict):
-        command = NoProgressBarCommand()
-        command.stdout = io.StringIO()
-        command.stderr = io.StringIO()
-
-        command.execute(**base_options)
-
-        assert command.no_progress_bar is True
-
-    @pytest.mark.parametrize(
-        ("processes", "expected"),
-        [
-            pytest.param(1, 1, id="single-process"),
-            pytest.param(4, 4, id="four-processes"),
-        ],
-    )
-    def test_process_count_set(
-        self,
-        base_options: dict,
-        processes: int,
-        expected: int,
-    ):
-        command = MultiprocessCommand()
-        command.stdout = io.StringIO()
-        command.stderr = io.StringIO()
-
-        options = {**base_options, "processes": processes, "no_progress_bar": True}
-        command.execute(**options)
-
-        assert command.process_count == expected
-
-    @pytest.mark.parametrize(
-        "invalid_count",
-        [
-            pytest.param(0, id="zero"),
-            pytest.param(-1, id="negative"),
-        ],
-    )
-    def test_process_count_validation_rejects_invalid(
-        self,
-        base_options: dict,
-        invalid_count: int,
-    ):
-        command = MultiprocessCommand()
-        command.stdout = io.StringIO()
-        command.stderr = io.StringIO()
-
-        options = {**base_options, "processes": invalid_count, "no_progress_bar": True}
-
-        with pytest.raises(CommandError, match="--processes must be at least 1"):
-            command.execute(**options)
-
-    def test_process_count_defaults_to_one_when_not_supported(self, base_options: dict):
-        command = SimpleCommand()
-        command.stdout = io.StringIO()
-        command.stderr = io.StringIO()
-
-        options = {**base_options, "no_progress_bar": True}
-        command.execute(**options)
-
-        assert command.process_count == 1
-
-
-@pytest.mark.management
-class TestGetIterableLength:
-    """Tests for the _get_iterable_length() method."""
-
-    def test_uses_count_for_querysets(
-        self,
-        simple_command: SimpleCommand,
-        mock_queryset,
-    ):
-        """Should call .count() on Django querysets rather than len()."""
-        queryset = mock_queryset([1, 2, 3, 4, 5])
-
-        result = simple_command._get_iterable_length(queryset)
-
-        assert result == 5
-        assert queryset.count_called is True
-
-    def test_uses_len_for_sized(self, simple_command: SimpleCommand):
-        """Should use len() for sequences and other Sized types."""
-        result = simple_command._get_iterable_length([1, 2, 3, 4])
-
-        assert result == 4
-
-    def test_returns_none_for_unsized_iterables(self, simple_command: SimpleCommand):
-        """Should return None for generators and other iterables without len()."""
-        result = simple_command._get_iterable_length(x for x in [1, 2, 3])
-
-        assert result is None
-
-
-@pytest.mark.management
-class TestTrack:
-    """Tests for the track() method."""
-
-    def test_with_progress_bar_disabled(self, simple_command: SimpleCommand):
-        simple_command.no_progress_bar = True
-        items = ["a", "b", "c"]
-
-        result = list(simple_command.track(items, description="Test..."))
-
-        assert result == items
-
-    def test_with_progress_bar_enabled(self, simple_command: SimpleCommand):
-        simple_command.no_progress_bar = False
-        items = [1, 2, 3]
-
-        result = list(simple_command.track(items, description="Processing..."))
-
-        assert result == items
-
-    def test_with_explicit_total(self, simple_command: SimpleCommand):
-        simple_command.no_progress_bar = False
-
-        def gen():
-            yield from [1, 2, 3]
-
-        result = list(simple_command.track(gen(), total=3))
-
-        assert result == [1, 2, 3]
-
-    def test_with_generator_no_total(self, simple_command: SimpleCommand):
-        def gen():
-            yield from [1, 2, 3]
-
-        result = list(simple_command.track(gen()))
-
-        assert result == [1, 2, 3]
-
-    def test_empty_iterable(self, simple_command: SimpleCommand):
-        result = list(simple_command.track([]))
-
-        assert result == []
-
-    def test_uses_queryset_count(
-        self,
-        simple_command: SimpleCommand,
-        mock_queryset,
-        mocker: MockerFixture,
-    ):
-        """Verify track() uses .count() for querysets."""
-        simple_command.no_progress_bar = False
-        queryset = mock_queryset([1, 2, 3])
-
-        spy = mocker.spy(simple_command, "_get_iterable_length")
-
-        result = list(simple_command.track(queryset))
-
-        assert result == [1, 2, 3]
-        spy.assert_called_once_with(queryset)
-        assert queryset.count_called is True
-
-
-@pytest.mark.management
-class TestProcessParallel:
-    """Tests for the process_parallel() method."""
-
-    def test_sequential_processing_single_process(
-        self,
-        multiprocess_command: MultiprocessCommand,
-    ):
-        multiprocess_command.process_count = 1
-        items = [1, 2, 3, 4, 5]
-
-        results = list(multiprocess_command.process_parallel(_double_value, items))
-
-        assert len(results) == 5
-        assert all(r.success for r in results)
-
-        result_map = {r.item: r.result for r in results}
-        assert result_map == {1: 2, 2: 4, 3: 6, 4: 8, 5: 10}
-
-    def test_sequential_processing_handles_errors(
-        self,
-        multiprocess_command: MultiprocessCommand,
-    ):
-        multiprocess_command.process_count = 1
-        items = [1, 2, 0, 4]  # 0 causes ZeroDivisionError
-
-        results = list(multiprocess_command.process_parallel(_divide_ten_by, items))
-
-        assert len(results) == 4
-
-        successes = [r for r in results if r.success]
-        failures = [r for r in results if not r.success]
-
-        assert len(successes) == 3
-        assert len(failures) == 1
-        assert failures[0].item == 0
-        assert isinstance(failures[0].error, ZeroDivisionError)
-
-    def test_parallel_closes_db_connections(
-        self,
-        multiprocess_command: MultiprocessCommand,
-        mocker: MockerFixture,
-    ):
-        multiprocess_command.process_count = 2
-        items = [1, 2, 3]
-
-        mock_connections = mocker.patch(
-            "documents.management.commands.base.db.connections",
-        )
-
-        results = list(multiprocess_command.process_parallel(_double_value, items))
-
-        mock_connections.close_all.assert_called_once()
-        assert len(results) == 3
-
-    def test_parallel_processing_handles_errors(
-        self,
-        multiprocess_command: MultiprocessCommand,
-        mocker: MockerFixture,
-    ):
-        multiprocess_command.process_count = 2
-        items = [1, 2, 0, 4]
-
-        mocker.patch("documents.management.commands.base.db.connections")
-
-        results = list(multiprocess_command.process_parallel(_divide_ten_by, items))
-
-        failures = [r for r in results if not r.success]
-        assert len(failures) == 1
-        assert failures[0].item == 0
-
-    def test_empty_items(self, multiprocess_command: MultiprocessCommand):
-        results = list(multiprocess_command.process_parallel(_double_value, []))
-
-        assert results == []
-
-    def test_result_contains_original_item(
-        self,
-        multiprocess_command: MultiprocessCommand,
-    ):
-        items = [10, 20, 30]
-
-        results = list(multiprocess_command.process_parallel(_double_value, items))
-
-        for result in results:
-            assert result.item in items
-            assert result.result == result.item * 2
-
-    def test_sequential_path_used_for_single_process(
-        self,
-        multiprocess_command: MultiprocessCommand,
-        mocker: MockerFixture,
-    ):
-        """Verify single process uses sequential path (important for testing)."""
-        multiprocess_command.process_count = 1
-
-        spy_sequential = mocker.spy(multiprocess_command, "_process_sequential")
-        spy_parallel = mocker.spy(multiprocess_command, "_process_parallel")
-
-        list(multiprocess_command.process_parallel(_double_value, [1, 2, 3]))
-
-        spy_sequential.assert_called_once()
-        spy_parallel.assert_not_called()
-
-    def test_parallel_path_used_for_multiple_processes(
-        self,
-        multiprocess_command: MultiprocessCommand,
-        mocker: MockerFixture,
-    ):
-        """Verify multiple processes uses parallel path."""
-        multiprocess_command.process_count = 2
-
-        mocker.patch("documents.management.commands.base.db.connections")
-        spy_sequential = mocker.spy(multiprocess_command, "_process_sequential")
-        spy_parallel = mocker.spy(multiprocess_command, "_process_parallel")
-
-        list(multiprocess_command.process_parallel(_double_value, [1, 2, 3]))
-
-        spy_parallel.assert_called_once()
-        spy_sequential.assert_not_called()

src/documents/tests/test_api_uisettings.py

@@ -21,16 +21,6 @@ class TestApiUiSettings(DirectoriesMixin, APITestCase):
         self.test_user.save()
         self.client.force_authenticate(user=self.test_user)
 
-    @override_settings(
-        APP_TITLE=None,
-        APP_LOGO=None,
-        AUDIT_LOG_ENABLED=True,
-        EMPTY_TRASH_DELAY=30,
-        ENABLE_UPDATE_CHECK="default",
-        EMAIL_ENABLED=False,
-        GMAIL_OAUTH_ENABLED=False,
-        OUTLOOK_OAUTH_ENABLED=False,
-    )
     def test_api_get_ui_settings(self) -> None:
         response = self.client.get(self.ENDPOINT, format="json")
         self.assertEqual(response.status_code, status.HTTP_200_OK)

src/documents/tests/test_barcodes.py

@@ -919,7 +919,6 @@ class TestTagBarcode(DirectoriesMixin, SampleDirMixin, GetReaderPluginMixin, Tes
     @override_settings(
         CONSUMER_ENABLE_TAG_BARCODE=True,
         CONSUMER_TAG_BARCODE_MAPPING={"ASN(.*)": "\\g<1>"},
-        CONSUMER_ENABLE_ASN_BARCODE=False,
     )
     def test_scan_file_for_many_custom_tags(self) -> None:
         """

src/documents/tests/test_file_handling.py

@@ -329,14 +329,14 @@ class TestFileHandling(DirectoriesMixin, FileSystemAssertsMixin, TestCase):
         FILENAME_FORMAT="{added_year}-{added_month}-{added_day}",
     )
     def test_added_year_month_day(self) -> None:
-        d1 = timezone.make_aware(datetime.datetime(1232, 1, 9, 1, 1, 1))
+        d1 = timezone.make_aware(datetime.datetime(232, 1, 9, 1, 1, 1))
         doc1 = Document.objects.create(
             title="doc1",
             mime_type="application/pdf",
             added=d1,
         )
 
-        self.assertEqual(generate_filename(doc1), Path("1232-01-09.pdf"))
+        self.assertEqual(generate_filename(doc1), Path("232-01-09.pdf"))
 
         doc1.added = timezone.make_aware(datetime.datetime(2020, 11, 16, 1, 1, 1))
 

src/documents/tests/test_management.py

@@ -4,7 +4,6 @@ from io import StringIO
 from pathlib import Path
 from unittest import mock
 
-import pytest
 from auditlog.models import LogEntry
 from django.contrib.contenttypes.models import ContentType
 from django.core.management import call_command
@@ -20,7 +19,6 @@ from documents.tests.utils import FileSystemAssertsMixin
 sample_file: Path = Path(__file__).parent / "samples" / "simple.pdf"
 
 
-@pytest.mark.management
 @override_settings(FILENAME_FORMAT="{correspondent}/{title}")
 class TestArchiver(DirectoriesMixin, FileSystemAssertsMixin, TestCase):
     def make_models(self):
@@ -96,7 +94,6 @@ class TestArchiver(DirectoriesMixin, FileSystemAssertsMixin, TestCase):
         self.assertEqual(doc2.archive_filename, "document_01.pdf")
 
 
-@pytest.mark.management
 class TestMakeIndex(TestCase):
     @mock.patch("documents.management.commands.document_index.index_reindex")
     def test_reindex(self, m) -> None:
@@ -109,7 +106,6 @@ class TestMakeIndex(TestCase):
         m.assert_called_once()
 
 
-@pytest.mark.management
 class TestRenamer(DirectoriesMixin, FileSystemAssertsMixin, TestCase):
     @override_settings(FILENAME_FORMAT="")
     def test_rename(self) -> None:
@@ -144,7 +140,6 @@ class TestCreateClassifier(TestCase):
         m.assert_called_once()
 
 
-@pytest.mark.management
 class TestSanityChecker(DirectoriesMixin, TestCase):
     def test_no_issues(self) -> None:
         with self.assertLogs() as capture:
@@ -170,7 +165,6 @@ class TestSanityChecker(DirectoriesMixin, TestCase):
         self.assertIn("Checksum mismatch. Stored: abc, actual:", capture.output[1])
 
 
-@pytest.mark.management
 class TestConvertMariaDBUUID(TestCase):
     @mock.patch("django.db.connection.schema_editor")
     def test_convert(self, m) -> None:
@@ -184,7 +178,6 @@ class TestConvertMariaDBUUID(TestCase):
         self.assertIn("Successfully converted", stdout.getvalue())
 
 
-@pytest.mark.management
 class TestPruneAuditLogs(TestCase):
     def test_prune_audit_logs(self) -> None:
         LogEntry.objects.create(

src/documents/tests/test_management_consumer.py

@@ -577,7 +577,6 @@ class TestTagsFromPath:
         assert len(tag_ids) == 0
 
 
-@pytest.mark.management
 class TestCommandValidation:
     """Tests for command argument validation."""
 
@@ -606,7 +605,6 @@ class TestCommandValidation:
             cmd.handle(directory=str(sample_pdf), oneshot=True, testing=False)
 
 
-@pytest.mark.management
 @pytest.mark.usefixtures("mock_supported_extensions")
 class TestCommandOneshot:
     """Tests for oneshot mode."""
@@ -777,7 +775,6 @@ def start_consumer(
             )
 
 
-@pytest.mark.management
 @pytest.mark.django_db
 class TestCommandWatch:
     """Integration tests for the watch loop."""
@@ -899,7 +896,6 @@ class TestCommandWatch:
         assert not thread.is_alive()
 
 
-@pytest.mark.management
 @pytest.mark.django_db
 class TestCommandWatchPolling:
     """Tests for polling mode."""
@@ -932,7 +928,6 @@ class TestCommandWatchPolling:
         mock_consume_file_delay.delay.assert_called()
 
 
-@pytest.mark.management
 @pytest.mark.django_db
 class TestCommandWatchRecursive:
     """Tests for recursive watching."""
@@ -996,7 +991,6 @@ class TestCommandWatchRecursive:
         assert len(overrides.tag_ids) == 2
 
 
-@pytest.mark.management
 @pytest.mark.django_db
 class TestCommandWatchEdgeCases:
     """Tests for edge cases and error handling."""

src/documents/tests/test_management_exporter.py

@@ -7,7 +7,6 @@ from pathlib import Path
 from unittest import mock
 from zipfile import ZipFile
 
-import pytest
 from allauth.socialaccount.models import SocialAccount
 from allauth.socialaccount.models import SocialApp
 from allauth.socialaccount.models import SocialToken
@@ -46,7 +45,6 @@ from documents.tests.utils import paperless_environment
 from paperless_mail.models import MailAccount
 
 
-@pytest.mark.management
 class TestExportImport(
     DirectoriesMixin,
     FileSystemAssertsMixin,
@@ -848,7 +846,6 @@ class TestExportImport(
         self.assertEqual(Document.objects.all().count(), 4)
 
 
-@pytest.mark.management
 class TestCryptExportImport(
     DirectoriesMixin,
     FileSystemAssertsMixin,

src/documents/tests/test_management_fuzzy.py

@@ -1,6 +1,5 @@
 from io import StringIO
 
-import pytest
 from django.core.management import CommandError
 from django.core.management import call_command
 from django.test import TestCase
@@ -8,7 +7,6 @@ from django.test import TestCase
 from documents.models import Document
 
 
-@pytest.mark.management
 class TestFuzzyMatchCommand(TestCase):
     MSG_REGEX = r"Document \d fuzzy match to \d \(confidence \d\d\.\d\d\d\)"
 
@@ -51,6 +49,19 @@ class TestFuzzyMatchCommand(TestCase):
             self.call_command("--ratio", "101")
         self.assertIn("The ratio must be between 0 and 100", str(e.exception))
 
+    def test_invalid_process_count(self) -> None:
+        """
+        GIVEN:
+            - Invalid process count less than 0 above upper
+        WHEN:
+            - Command is called
+        THEN:
+            - Error is raised indicating issue
+        """
+        with self.assertRaises(CommandError) as e:
+            self.call_command("--processes", "0")
+        self.assertIn("There must be at least 1 process", str(e.exception))
+
     def test_no_matches(self) -> None:
         """
         GIVEN:
@@ -140,7 +151,7 @@ class TestFuzzyMatchCommand(TestCase):
             mime_type="application/pdf",
             filename="final_test.pdf",
         )
-        stdout, _ = self.call_command("--no-progress-bar", "--processes", "1")
+        stdout, _ = self.call_command()
         lines = [x.strip() for x in stdout.splitlines() if x.strip()]
         self.assertEqual(len(lines), 3)
         for line in lines:
@@ -183,12 +194,7 @@ class TestFuzzyMatchCommand(TestCase):
 
         self.assertEqual(Document.objects.count(), 3)
 
-        stdout, _ = self.call_command(
-            "--delete",
-            "--no-progress-bar",
-            "--processes",
-            "1",
-        )
+        stdout, _ = self.call_command("--delete")
 
         self.assertIn(
             "The command is configured to delete documents.  Use with caution",

src/documents/tests/test_management_importer.py

@@ -4,7 +4,6 @@ from io import StringIO
 from pathlib import Path
 from zipfile import ZipFile
 
-import pytest
 from django.contrib.auth.models import User
 from django.core.management import call_command
 from django.core.management.base import CommandError
@@ -19,7 +18,6 @@ from documents.tests.utils import FileSystemAssertsMixin
 from documents.tests.utils import SampleDirMixin
 
 
-@pytest.mark.management
 class TestCommandImport(
     DirectoriesMixin,
     FileSystemAssertsMixin,

src/documents/tests/test_management_retagger.py

@@ -1,4 +1,3 @@
-import pytest
 from django.core.management import call_command
 from django.core.management.base import CommandError
 from django.test import TestCase
@@ -11,7 +10,6 @@ from documents.models import Tag
 from documents.tests.utils import DirectoriesMixin
 
 
-@pytest.mark.management
 class TestRetagger(DirectoriesMixin, TestCase):
     def make_models(self) -> None:
         self.sp1 = StoragePath.objects.create(

src/documents/tests/test_management_superuser.py

@@ -2,7 +2,6 @@ import os
 from io import StringIO
 from unittest import mock
 
-import pytest
 from django.contrib.auth.models import User
 from django.core.management import call_command
 from django.test import TestCase
@@ -10,7 +9,6 @@ from django.test import TestCase
 from documents.tests.utils import DirectoriesMixin
 
 
-@pytest.mark.management
 class TestManageSuperUser(DirectoriesMixin, TestCase):
     def call_command(self, environ):
         out = StringIO()

src/documents/tests/test_management_thumbnails.py

@@ -2,7 +2,6 @@ import shutil
 from pathlib import Path
 from unittest import mock
 
-import pytest
 from django.core.management import call_command
 from django.test import TestCase
 
@@ -13,7 +12,6 @@ from documents.tests.utils import DirectoriesMixin
 from documents.tests.utils import FileSystemAssertsMixin
 
 
-@pytest.mark.management
 class TestMakeThumbnails(DirectoriesMixin, FileSystemAssertsMixin, TestCase):
     def make_models(self) -> None:
         self.d1 = Document.objects.create(

src/documents/tests/utils.py

@@ -33,11 +33,11 @@ from documents.plugins.helpers import ProgressStatusOptions
 def setup_directories():
     dirs = namedtuple("Dirs", ())
 
-    dirs.data_dir = Path(tempfile.mkdtemp()).resolve()
-    dirs.scratch_dir = Path(tempfile.mkdtemp()).resolve()
-    dirs.media_dir = Path(tempfile.mkdtemp()).resolve()
-    dirs.consumption_dir = Path(tempfile.mkdtemp()).resolve()
-    dirs.static_dir = Path(tempfile.mkdtemp()).resolve()
+    dirs.data_dir = Path(tempfile.mkdtemp())
+    dirs.scratch_dir = Path(tempfile.mkdtemp())
+    dirs.media_dir = Path(tempfile.mkdtemp())
+    dirs.consumption_dir = Path(tempfile.mkdtemp())
+    dirs.static_dir = Path(tempfile.mkdtemp())
     dirs.index_dir = dirs.data_dir / "index"
     dirs.originals_dir = dirs.media_dir / "documents" / "originals"
     dirs.thumbnail_dir = dirs.media_dir / "documents" / "thumbnails"

src/locale/en_US/LC_MESSAGES/django.po

@@ -2,7 +2,7 @@ msgid ""
 msgstr ""
 "Project-Id-Version: paperless-ngx\n"
 "Report-Msgid-Bugs-To: \n"
-"POT-Creation-Date: 2026-02-27 22:38+0000\n"
+"POT-Creation-Date: 2026-02-26 18:09+0000\n"
 "PO-Revision-Date: 2022-02-17 04:17\n"
 "Last-Translator: \n"
 "Language-Team: English\n"
@@ -1856,151 +1856,151 @@ msgstr ""
 msgid "paperless application settings"
 msgstr ""
 
-#: paperless/settings/__init__.py:746
+#: paperless/settings.py:819
 msgid "English (US)"
 msgstr ""
 
-#: paperless/settings/__init__.py:747
+#: paperless/settings.py:820
 msgid "Arabic"
 msgstr ""
 
-#: paperless/settings/__init__.py:748
+#: paperless/settings.py:821
 msgid "Afrikaans"
 msgstr ""
 
-#: paperless/settings/__init__.py:749
+#: paperless/settings.py:822
 msgid "Belarusian"
 msgstr ""
 
-#: paperless/settings/__init__.py:750
+#: paperless/settings.py:823
 msgid "Bulgarian"
 msgstr ""
 
-#: paperless/settings/__init__.py:751
+#: paperless/settings.py:824
 msgid "Catalan"
 msgstr ""
 
-#: paperless/settings/__init__.py:752
+#: paperless/settings.py:825
 msgid "Czech"
 msgstr ""
 
-#: paperless/settings/__init__.py:753
+#: paperless/settings.py:826
 msgid "Danish"
 msgstr ""
 
-#: paperless/settings/__init__.py:754
+#: paperless/settings.py:827
 msgid "German"
 msgstr ""
 
-#: paperless/settings/__init__.py:755
+#: paperless/settings.py:828
 msgid "Greek"
 msgstr ""
 
-#: paperless/settings/__init__.py:756
+#: paperless/settings.py:829
 msgid "English (GB)"
 msgstr ""
 
-#: paperless/settings/__init__.py:757
+#: paperless/settings.py:830
 msgid "Spanish"
 msgstr ""
 
-#: paperless/settings/__init__.py:758
+#: paperless/settings.py:831
 msgid "Persian"
 msgstr ""
 
-#: paperless/settings/__init__.py:759
+#: paperless/settings.py:832
 msgid "Finnish"
 msgstr ""
 
-#: paperless/settings/__init__.py:760
+#: paperless/settings.py:833
 msgid "French"
 msgstr ""
 
-#: paperless/settings/__init__.py:761
+#: paperless/settings.py:834
 msgid "Hungarian"
 msgstr ""
 
-#: paperless/settings/__init__.py:762
+#: paperless/settings.py:835
 msgid "Indonesian"
 msgstr ""
 
-#: paperless/settings/__init__.py:763
+#: paperless/settings.py:836
 msgid "Italian"
 msgstr ""
 
-#: paperless/settings/__init__.py:764
+#: paperless/settings.py:837
 msgid "Japanese"
 msgstr ""
 
-#: paperless/settings/__init__.py:765
+#: paperless/settings.py:838
 msgid "Korean"
 msgstr ""
 
-#: paperless/settings/__init__.py:766
+#: paperless/settings.py:839
 msgid "Luxembourgish"
 msgstr ""
 
-#: paperless/settings/__init__.py:767
+#: paperless/settings.py:840
 msgid "Norwegian"
 msgstr ""
 
-#: paperless/settings/__init__.py:768
+#: paperless/settings.py:841
 msgid "Dutch"
 msgstr ""
 
-#: paperless/settings/__init__.py:769
+#: paperless/settings.py:842
 msgid "Polish"
 msgstr ""
 
-#: paperless/settings/__init__.py:770
+#: paperless/settings.py:843
 msgid "Portuguese (Brazil)"
 msgstr ""
 
-#: paperless/settings/__init__.py:771
+#: paperless/settings.py:844
 msgid "Portuguese"
 msgstr ""
 
-#: paperless/settings/__init__.py:772
+#: paperless/settings.py:845
 msgid "Romanian"
 msgstr ""
 
-#: paperless/settings/__init__.py:773
+#: paperless/settings.py:846
 msgid "Russian"
 msgstr ""
 
-#: paperless/settings/__init__.py:774
+#: paperless/settings.py:847
 msgid "Slovak"
 msgstr ""
 
-#: paperless/settings/__init__.py:775
+#: paperless/settings.py:848
 msgid "Slovenian"
 msgstr ""
 
-#: paperless/settings/__init__.py:776
+#: paperless/settings.py:849
 msgid "Serbian"
 msgstr ""
 
-#: paperless/settings/__init__.py:777
+#: paperless/settings.py:850
 msgid "Swedish"
 msgstr ""
 
-#: paperless/settings/__init__.py:778
+#: paperless/settings.py:851
 msgid "Turkish"
 msgstr ""
 
-#: paperless/settings/__init__.py:779
+#: paperless/settings.py:852
 msgid "Ukrainian"
 msgstr ""
 
-#: paperless/settings/__init__.py:780
+#: paperless/settings.py:853
 msgid "Vietnamese"
 msgstr ""
 
-#: paperless/settings/__init__.py:781
+#: paperless/settings.py:854
 msgid "Chinese Simplified"
 msgstr ""
 
-#: paperless/settings/__init__.py:782
+#: paperless/settings.py:855
 msgid "Chinese Traditional"
 msgstr ""
 

src/paperless/checks.py

@@ -202,43 +202,3 @@ def audit_log_check(app_configs, **kwargs):
         )
 
     return result
-
-
-@register()
-def check_deprecated_db_settings(
-    app_configs: object,
-    **kwargs: object,
-) -> list[Warning]:
-    """Check for deprecated database environment variables.
-
-    Detects legacy advanced options that should be migrated to
-    PAPERLESS_DB_OPTIONS. Returns one Warning per deprecated variable found.
-    """
-    deprecated_vars: dict[str, str] = {
-        "PAPERLESS_DB_TIMEOUT": "timeout",
-        "PAPERLESS_DB_POOLSIZE": "pool.min_size / pool.max_size",
-        "PAPERLESS_DBSSLMODE": "sslmode",
-        "PAPERLESS_DBSSLROOTCERT": "sslrootcert",
-        "PAPERLESS_DBSSLCERT": "sslcert",
-        "PAPERLESS_DBSSLKEY": "sslkey",
-    }
-
-    warnings: list[Warning] = []
-
-    for var_name, db_option_key in deprecated_vars.items():
-        if not os.getenv(var_name):
-            continue
-        warnings.append(
-            Warning(
-                f"Deprecated environment variable: {var_name}",
-                hint=(
-                    f"{var_name} is no longer supported and will be removed in v3.2. "
-                    f"Set the equivalent option via PAPERLESS_DB_OPTIONS instead. "
-                    f'Example: PAPERLESS_DB_OPTIONS=\'{{"{db_option_key}": "<value>"}}\'. '
-                    "See https://docs.paperless-ngx.com/migration/ for the full reference."
-                ),
-                id="paperless.W001",
-            ),
-        )
-
-    return warnings

src/paperless/settings.py

@@ -17,8 +17,6 @@ from dateparser.languages.loader import LocaleDataLoader
 from django.utils.translation import gettext_lazy as _
 from dotenv import load_dotenv
 
-from paperless.settings.custom import parse_db_settings
-
 logger = logging.getLogger("paperless.settings")
 
 # Tap paperless.conf if it's available
@@ -284,7 +282,7 @@ DEBUG = __get_boolean("PAPERLESS_DEBUG", "NO")
 # Directories                                                                 #
 ###############################################################################
 
-BASE_DIR: Path = Path(__file__).resolve().parent.parent.parent
+BASE_DIR: Path = Path(__file__).resolve().parent.parent
 
 STATIC_ROOT = __get_path("PAPERLESS_STATICDIR", BASE_DIR.parent / "static")
 
@@ -724,8 +722,83 @@ EMAIL_CERTIFICATE_FILE = __get_optional_path("PAPERLESS_EMAIL_CERTIFICATE_LOCATI
 ###############################################################################
 # Database                                                                    #
 ###############################################################################
+def _parse_db_settings() -> dict:
+    databases = {
+        "default": {
+            "ENGINE": "django.db.backends.sqlite3",
+            "NAME": DATA_DIR / "db.sqlite3",
+            "OPTIONS": {},
+        },
+    }
+    if os.getenv("PAPERLESS_DBHOST"):
+        # Have sqlite available as a second option for management commands
+        # This is important when migrating to/from sqlite
+        databases["sqlite"] = databases["default"].copy()
 
-DATABASES = parse_db_settings(DATA_DIR)
+        databases["default"] = {
+            "HOST": os.getenv("PAPERLESS_DBHOST"),
+            "NAME": os.getenv("PAPERLESS_DBNAME", "paperless"),
+            "USER": os.getenv("PAPERLESS_DBUSER", "paperless"),
+            "PASSWORD": os.getenv("PAPERLESS_DBPASS", "paperless"),
+            "OPTIONS": {},
+        }
+        if os.getenv("PAPERLESS_DBPORT"):
+            databases["default"]["PORT"] = os.getenv("PAPERLESS_DBPORT")
+
+        # Leave room for future extensibility
+        if os.getenv("PAPERLESS_DBENGINE") == "mariadb":
+            engine = "django.db.backends.mysql"
+            # Contrary to Postgres, Django does not natively support connection pooling for MariaDB.
+            # However, since MariaDB uses threads instead of forks, establishing connections is significantly faster
+            # compared to PostgreSQL, so the lack of pooling is not an issue
+            options = {
+                "read_default_file": "/etc/mysql/my.cnf",
+                "charset": "utf8mb4",
+                "ssl_mode": os.getenv("PAPERLESS_DBSSLMODE", "PREFERRED"),
+                "ssl": {
+                    "ca": os.getenv("PAPERLESS_DBSSLROOTCERT", None),
+                    "cert": os.getenv("PAPERLESS_DBSSLCERT", None),
+                    "key": os.getenv("PAPERLESS_DBSSLKEY", None),
+                },
+            }
+
+        else:  # Default to PostgresDB
+            engine = "django.db.backends.postgresql"
+            options = {
+                "sslmode": os.getenv("PAPERLESS_DBSSLMODE", "prefer"),
+                "sslrootcert": os.getenv("PAPERLESS_DBSSLROOTCERT", None),
+                "sslcert": os.getenv("PAPERLESS_DBSSLCERT", None),
+                "sslkey": os.getenv("PAPERLESS_DBSSLKEY", None),
+            }
+            if int(os.getenv("PAPERLESS_DB_POOLSIZE", 0)) > 0:
+                options.update(
+                    {
+                        "pool": {
+                            "min_size": 1,
+                            "max_size": int(os.getenv("PAPERLESS_DB_POOLSIZE")),
+                        },
+                    },
+                )
+
+        databases["default"]["ENGINE"] = engine
+        databases["default"]["OPTIONS"].update(options)
+
+    if os.getenv("PAPERLESS_DB_TIMEOUT") is not None:
+        if databases["default"]["ENGINE"] == "django.db.backends.sqlite3":
+            databases["default"]["OPTIONS"].update(
+                {"timeout": int(os.getenv("PAPERLESS_DB_TIMEOUT"))},
+            )
+        else:
+            databases["default"]["OPTIONS"].update(
+                {"connect_timeout": int(os.getenv("PAPERLESS_DB_TIMEOUT"))},
+            )
+            databases["sqlite"]["OPTIONS"].update(
+                {"timeout": int(os.getenv("PAPERLESS_DB_TIMEOUT"))},
+            )
+    return databases
+
+
+DATABASES = _parse_db_settings()
 
 if os.getenv("PAPERLESS_DBENGINE") == "mariadb":
     # Silence Django error on old MariaDB versions.

src/paperless/settings/custom.py

@@ -1,122 +0,0 @@
-import os
-from pathlib import Path
-from typing import Any
-
-from paperless.settings.parsers import get_choice_from_env
-from paperless.settings.parsers import get_int_from_env
-from paperless.settings.parsers import parse_dict_from_str
-
-
-def parse_db_settings(data_dir: Path) -> dict[str, dict[str, Any]]:
-    """Parse database settings from environment variables.
-
-    Core connection variables (no deprecation):
-    - PAPERLESS_DBENGINE (sqlite/postgresql/mariadb)
-    - PAPERLESS_DBHOST, PAPERLESS_DBPORT
-    - PAPERLESS_DBNAME, PAPERLESS_DBUSER, PAPERLESS_DBPASS
-
-    Advanced options can be set via:
-    - Legacy individual env vars (deprecated in v3.0, removed in v3.2)
-    - PAPERLESS_DB_OPTIONS (recommended v3+ approach)
-
-    Args:
-        data_dir: The data directory path for SQLite database location.
-
-    Returns:
-        A databases dict suitable for Django DATABASES setting.
-    """
-    try:
-        engine = get_choice_from_env(
-            "PAPERLESS_DBENGINE",
-            {"sqlite", "postgresql", "mariadb"},
-            default="sqlite",
-        )
-    except ValueError:
-        # MariaDB users already had to set PAPERLESS_DBENGINE, so it was picked up above
-        # SQLite users didn't need to set anything
-        engine = "postgresql" if "PAPERLESS_DBHOST" in os.environ else "sqlite"
-
-    db_config: dict[str, Any]
-    base_options: dict[str, Any]
-
-    match engine:
-        case "sqlite":
-            db_config = {
-                "ENGINE": "django.db.backends.sqlite3",
-                "NAME": str((data_dir / "db.sqlite3").resolve()),
-            }
-            base_options = {}
-
-        case "postgresql":
-            db_config = {
-                "ENGINE": "django.db.backends.postgresql",
-                "HOST": os.getenv("PAPERLESS_DBHOST"),
-                "NAME": os.getenv("PAPERLESS_DBNAME", "paperless"),
-                "USER": os.getenv("PAPERLESS_DBUSER", "paperless"),
-                "PASSWORD": os.getenv("PAPERLESS_DBPASS", "paperless"),
-            }
-
-            base_options = {
-                "sslmode": os.getenv("PAPERLESS_DBSSLMODE", "prefer"),
-                "sslrootcert": os.getenv("PAPERLESS_DBSSLROOTCERT"),
-                "sslcert": os.getenv("PAPERLESS_DBSSLCERT"),
-                "sslkey": os.getenv("PAPERLESS_DBSSLKEY"),
-            }
-
-            if (pool_size := get_int_from_env("PAPERLESS_DB_POOLSIZE")) is not None:
-                base_options["pool"] = {
-                    "min_size": 1,
-                    "max_size": pool_size,
-                }
-
-        case "mariadb":
-            db_config = {
-                "ENGINE": "django.db.backends.mysql",
-                "HOST": os.getenv("PAPERLESS_DBHOST"),
-                "NAME": os.getenv("PAPERLESS_DBNAME", "paperless"),
-                "USER": os.getenv("PAPERLESS_DBUSER", "paperless"),
-                "PASSWORD": os.getenv("PAPERLESS_DBPASS", "paperless"),
-            }
-
-            base_options = {
-                "read_default_file": "/etc/mysql/my.cnf",
-                "charset": "utf8mb4",
-                "collation": "utf8mb4_unicode_ci",
-                "ssl_mode": os.getenv("PAPERLESS_DBSSLMODE", "PREFERRED"),
-                "ssl": {
-                    "ca": os.getenv("PAPERLESS_DBSSLROOTCERT"),
-                    "cert": os.getenv("PAPERLESS_DBSSLCERT"),
-                    "key": os.getenv("PAPERLESS_DBSSLKEY"),
-                },
-            }
-        case _:  # pragma: no cover
-            raise NotImplementedError(engine)
-
-    # Handle port setting for external databases
-    if (
-        engine in ("postgresql", "mariadb")
-        and (port := get_int_from_env("PAPERLESS_DBPORT")) is not None
-    ):
-        db_config["PORT"] = port
-
-    # Handle timeout setting (common across all engines, different key names)
-    if (timeout := get_int_from_env("PAPERLESS_DB_TIMEOUT")) is not None:
-        timeout_key = "timeout" if engine == "sqlite" else "connect_timeout"
-        base_options[timeout_key] = timeout
-
-    # Apply PAPERLESS_DB_OPTIONS overrides
-    db_config["OPTIONS"] = parse_dict_from_str(
-        os.getenv("PAPERLESS_DB_OPTIONS"),
-        defaults=base_options,
-        separator=";",
-        type_map={
-            # SQLite options
-            "timeout": int,
-            # Postgres/MariaDB options
-            "connect_timeout": int,
-            "pool.min_size": int,
-            "pool.max_size": int,
-        },
-    )
-
-    return {"default": db_config}

src/paperless/settings/parsers.py

@@ -1,192 +0,0 @@
-import copy
-import os
-from collections.abc import Callable
-from collections.abc import Mapping
-from pathlib import Path
-from typing import Any
-from typing import TypeVar
-from typing import overload
-
-T = TypeVar("T")
-
-
-def str_to_bool(value: str) -> bool:
-    """
-    Converts a string representation of truth to a boolean value.
-
-    Recognizes 'true', '1', 't', 'y', 'yes' as True, and
-    'false', '0', 'f', 'n', 'no' as False. Case-insensitive.
-
-    Args:
-        value: The string to convert.
-
-    Returns:
-        The boolean representation of the string.
-
-    Raises:
-        ValueError: If the string is not a recognized boolean value.
-    """
-    val_lower = value.strip().lower()
-    if val_lower in ("true", "1", "t", "y", "yes"):
-        return True
-    elif val_lower in ("false", "0", "f", "n", "no"):
-        return False
-    raise ValueError(f"Cannot convert '{value}' to a boolean.")
-
-
-@overload
-def get_int_from_env(key: str) -> int | None: ...
-
-
-@overload
-def get_int_from_env(key: str, default: None) -> int | None: ...
-
-
-@overload
-def get_int_from_env(key: str, default: int) -> int: ...
-
-
-def get_int_from_env(key: str, default: int | None = None) -> int | None:
-    """
-    Return an integer value based on the environment variable.
-    If default is provided, returns that value when key is missing.
-    If default is None, returns None when key is missing.
-    """
-    if key not in os.environ:
-        return default
-
-    return int(os.environ[key])
-
-
-def parse_dict_from_str(
-    env_str: str | None,
-    defaults: dict[str, Any] | None = None,
-    type_map: Mapping[str, Callable[[str], Any]] | None = None,
-    separator: str = ",",
-) -> dict[str, Any]:
-    """
-    Parses a key-value string into a dictionary, applying defaults and casting types.
-
-    Supports nested keys via dot-notation, e.g.:
-        "database.host=localhost,database.port=5432"
-
-    Args:
-        env_str: The string from the environment variable (e.g., "port=9090,debug=true").
-        defaults: A dictionary of default values (can contain nested dicts).
-        type_map: A dictionary mapping keys (dot-notation allowed) to a type or a parsing
-                  function (e.g., {'port': int, 'debug': bool, 'database.port': int}).
-                  The special `bool` type triggers custom boolean parsing.
-        separator: The character used to separate key-value pairs. Defaults to ','.
-
-    Returns:
-        A dictionary with the parsed and correctly-typed settings.
-
-    Raises:
-        ValueError: If a value cannot be cast to its specified type.
-    """
-
-    def _set_nested(d: dict, keys: list[str], value: Any) -> None:
-        """Set a nested value, creating intermediate dicts as needed."""
-        cur = d
-        for k in keys[:-1]:
-            if k not in cur or not isinstance(cur[k], dict):
-                cur[k] = {}
-            cur = cur[k]
-        cur[keys[-1]] = value
-
-    def _get_nested(d: dict, keys: list[str]) -> Any:
-        """Get nested value or raise KeyError if not present."""
-        cur = d
-        for k in keys:
-            if not isinstance(cur, dict) or k not in cur:
-                raise KeyError
-            cur = cur[k]
-        return cur
-
-    def _has_nested(d: dict, keys: list[str]) -> bool:
-        try:
-            _get_nested(d, keys)
-            return True
-        except KeyError:
-            return False
-
-    settings: dict[str, Any] = copy.deepcopy(defaults) if defaults else {}
-    _type_map = type_map if type_map else {}
-
-    if not env_str:
-        return settings
-
-    # Parse the environment string using the specified separator
-    pairs = [p.strip() for p in env_str.split(separator) if p.strip()]
-    for pair in pairs:
-        if "=" not in pair:
-            # ignore malformed pairs
-            continue
-        key, val = pair.split("=", 1)
-        key = key.strip()
-        val = val.strip()
-        if not key:
-            continue
-        parts = key.split(".")
-        _set_nested(settings, parts, val)
-
-    # Apply type casting to the updated settings (supports nested keys in type_map)
-    for key, caster in _type_map.items():
-        key_parts = key.split(".")
-        if _has_nested(settings, key_parts):
-            raw_val = _get_nested(settings, key_parts)
-            # Only cast if it's a string (i.e. from env parsing). If defaults already provided
-            # a different type we leave it as-is.
-            if isinstance(raw_val, str):
-                try:
-                    if caster is bool:
-                        parsed = str_to_bool(raw_val)
-                    elif caster is Path:
-                        parsed = Path(raw_val).resolve()
-                    else:
-                        parsed = caster(raw_val)
-                except (ValueError, TypeError) as e:
-                    caster_name = getattr(caster, "__name__", repr(caster))
-                    raise ValueError(
-                        f"Error casting key '{key}' with value '{raw_val}' "
-                        f"to type '{caster_name}'",
-                    ) from e
-                _set_nested(settings, key_parts, parsed)
-
-    return settings
-
-
-def get_choice_from_env(
-    env_key: str,
-    choices: set[str],
-    default: str | None = None,
-) -> str:
-    """
-    Gets and validates an environment variable against a set of allowed choices.
-
-    Args:
-        env_key: The environment variable key to validate
-        choices: Set of valid choices for the environment variable
-        default: Optional default value if environment variable is not set
-
-    Returns:
-        The validated environment variable value
-
-    Raises:
-        ValueError: If the environment variable value is not in choices
-                             or if no default is provided and env var is missing
-    """
-    value = os.environ.get(env_key, default)
-
-    if value is None:
-        raise ValueError(
-            f"Environment variable '{env_key}' is required but not set.",
-        )
-
-    if value not in choices:
-        raise ValueError(
-            f"Environment variable '{env_key}' has invalid value '{value}'. "
-            f"Valid choices are: {', '.join(sorted(choices))}",
-        )
-
-    return value

src/paperless/tests/settings/test_custom_parsers.py

@@ -1,266 +0,0 @@
-import os
-from pathlib import Path
-
-import pytest
-from pytest_mock import MockerFixture
-
-from paperless.settings.custom import parse_db_settings
-
-
-class TestParseDbSettings:
-    """Test suite for parse_db_settings function."""
-
-    @pytest.mark.parametrize(
-        ("env_vars", "expected_database_settings"),
-        [
-            pytest.param(
-                {},
-                {
-                    "default": {
-                        "ENGINE": "django.db.backends.sqlite3",
-                        "NAME": None,  # Will be replaced with tmp_path
-                        "OPTIONS": {},
-                    },
-                },
-                id="default-sqlite",
-            ),
-            pytest.param(
-                {
-                    "PAPERLESS_DBENGINE": "sqlite",
-                    "PAPERLESS_DB_OPTIONS": "timeout=30",
-                },
-                {
-                    "default": {
-                        "ENGINE": "django.db.backends.sqlite3",
-                        "NAME": None,  # Will be replaced with tmp_path
-                        "OPTIONS": {
-                            "timeout": 30,
-                        },
-                    },
-                },
-                id="sqlite-with-timeout-override",
-            ),
-            pytest.param(
-                {
-                    "PAPERLESS_DBENGINE": "postgresql",
-                    "PAPERLESS_DBHOST": "localhost",
-                },
-                {
-                    "default": {
-                        "ENGINE": "django.db.backends.postgresql",
-                        "HOST": "localhost",
-                        "NAME": "paperless",
-                        "USER": "paperless",
-                        "PASSWORD": "paperless",
-                        "OPTIONS": {
-                            "sslmode": "prefer",
-                            "sslrootcert": None,
-                            "sslcert": None,
-                            "sslkey": None,
-                        },
-                    },
-                },
-                id="postgresql-defaults",
-            ),
-            pytest.param(
-                {
-                    "PAPERLESS_DBENGINE": "postgresql",
-                    "PAPERLESS_DBHOST": "paperless-db-host",
-                    "PAPERLESS_DBPORT": "1111",
-                    "PAPERLESS_DBNAME": "customdb",
-                    "PAPERLESS_DBUSER": "customuser",
-                    "PAPERLESS_DBPASS": "custompass",
-                    "PAPERLESS_DB_OPTIONS": "pool.max_size=50;pool.min_size=2;sslmode=require",
-                },
-                {
-                    "default": {
-                        "ENGINE": "django.db.backends.postgresql",
-                        "HOST": "paperless-db-host",
-                        "PORT": 1111,
-                        "NAME": "customdb",
-                        "USER": "customuser",
-                        "PASSWORD": "custompass",
-                        "OPTIONS": {
-                            "sslmode": "require",
-                            "sslrootcert": None,
-                            "sslcert": None,
-                            "sslkey": None,
-                            "pool": {
-                                "min_size": 2,
-                                "max_size": 50,
-                            },
-                        },
-                    },
-                },
-                id="postgresql-overrides",
-            ),
-            pytest.param(
-                {
-                    "PAPERLESS_DBENGINE": "postgresql",
-                    "PAPERLESS_DBHOST": "pghost",
-                    "PAPERLESS_DB_POOLSIZE": "10",
-                },
-                {
-                    "default": {
-                        "ENGINE": "django.db.backends.postgresql",
-                        "HOST": "pghost",
-                        "NAME": "paperless",
-                        "USER": "paperless",
-                        "PASSWORD": "paperless",
-                        "OPTIONS": {
-                            "sslmode": "prefer",
-                            "sslrootcert": None,
-                            "sslcert": None,
-                            "sslkey": None,
-                            "pool": {
-                                "min_size": 1,
-                                "max_size": 10,
-                            },
-                        },
-                    },
-                },
-                id="postgresql-legacy-poolsize",
-            ),
-            pytest.param(
-                {
-                    "PAPERLESS_DBENGINE": "postgresql",
-                    "PAPERLESS_DBHOST": "pghost",
-                    "PAPERLESS_DBSSLMODE": "require",
-                    "PAPERLESS_DBSSLROOTCERT": "/certs/ca.crt",
-                    "PAPERLESS_DB_TIMEOUT": "30",
-                },
-                {
-                    "default": {
-                        "ENGINE": "django.db.backends.postgresql",
-                        "HOST": "pghost",
-                        "NAME": "paperless",
-                        "USER": "paperless",
-                        "PASSWORD": "paperless",
-                        "OPTIONS": {
-                            "sslmode": "require",
-                            "sslrootcert": "/certs/ca.crt",
-                            "sslcert": None,
-                            "sslkey": None,
-                            "connect_timeout": 30,
-                        },
-                    },
-                },
-                id="postgresql-legacy-ssl-and-timeout",
-            ),
-            pytest.param(
-                {
-                    "PAPERLESS_DBENGINE": "mariadb",
-                    "PAPERLESS_DBHOST": "localhost",
-                },
-                {
-                    "default": {
-                        "ENGINE": "django.db.backends.mysql",
-                        "HOST": "localhost",
-                        "NAME": "paperless",
-                        "USER": "paperless",
-                        "PASSWORD": "paperless",
-                        "OPTIONS": {
-                            "read_default_file": "/etc/mysql/my.cnf",
-                            "charset": "utf8mb4",
-                            "collation": "utf8mb4_unicode_ci",
-                            "ssl_mode": "PREFERRED",
-                            "ssl": {
-                                "ca": None,
-                                "cert": None,
-                                "key": None,
-                            },
-                        },
-                    },
-                },
-                id="mariadb-defaults",
-            ),
-            pytest.param(
-                {
-                    "PAPERLESS_DBENGINE": "mariadb",
-                    "PAPERLESS_DBHOST": "paperless-mariadb-host",
-                    "PAPERLESS_DBPORT": "5555",
-                    "PAPERLESS_DBUSER": "my-cool-user",
-                    "PAPERLESS_DBPASS": "my-secure-password",
-                    "PAPERLESS_DB_OPTIONS": "ssl.ca=/path/to/ca.pem;ssl_mode=REQUIRED",
-                },
-                {
-                    "default": {
-                        "ENGINE": "django.db.backends.mysql",
-                        "HOST": "paperless-mariadb-host",
-                        "PORT": 5555,
-                        "NAME": "paperless",
-                        "USER": "my-cool-user",
-                        "PASSWORD": "my-secure-password",
-                        "OPTIONS": {
-                            "read_default_file": "/etc/mysql/my.cnf",
-                            "charset": "utf8mb4",
-                            "collation": "utf8mb4_unicode_ci",
-                            "ssl_mode": "REQUIRED",
-                            "ssl": {
-                                "ca": "/path/to/ca.pem",
-                                "cert": None,
-                                "key": None,
-                            },
-                        },
-                    },
-                },
-                id="mariadb-overrides",
-            ),
-            pytest.param(
-                {
-                    "PAPERLESS_DBENGINE": "mariadb",
-                    "PAPERLESS_DBHOST": "mariahost",
-                    "PAPERLESS_DBSSLMODE": "REQUIRED",
-                    "PAPERLESS_DBSSLROOTCERT": "/certs/ca.pem",
-                    "PAPERLESS_DBSSLCERT": "/certs/client.pem",
-                    "PAPERLESS_DBSSLKEY": "/certs/client.key",
-                    "PAPERLESS_DB_TIMEOUT": "25",
-                },
-                {
-                    "default": {
-                        "ENGINE": "django.db.backends.mysql",
-                        "HOST": "mariahost",
-                        "NAME": "paperless",
-                        "USER": "paperless",
-                        "PASSWORD": "paperless",
-                        "OPTIONS": {
-                            "read_default_file": "/etc/mysql/my.cnf",
-                            "charset": "utf8mb4",
-                            "collation": "utf8mb4_unicode_ci",
-                            "ssl_mode": "REQUIRED",
-                            "ssl": {
-                                "ca": "/certs/ca.pem",
-                                "cert": "/certs/client.pem",
-                                "key": "/certs/client.key",
-                            },
-                            "connect_timeout": 25,
-                        },
-                    },
-                },
-                id="mariadb-legacy-ssl-and-timeout",
-            ),
-        ],
-    )
-    def test_parse_db_settings(
-        self,
-        tmp_path: Path,
-        mocker: MockerFixture,
-        env_vars: dict[str, str],
-        expected_database_settings: dict[str, dict],
-    ) -> None:
-        """Test various database configurations with defaults and overrides."""
-        # Clear environment and set test vars
-        mocker.patch.dict(os.environ, env_vars, clear=True)
-
-        # Update expected paths with actual tmp_path
-        if (
-            "default" in expected_database_settings
-            and expected_database_settings["default"]["NAME"] is None
-        ):
-            expected_database_settings["default"]["NAME"] = str(
-                tmp_path / "db.sqlite3",
-            )
-
-        settings = parse_db_settings(tmp_path)
-
-        assert settings == expected_database_settings

src/paperless/tests/settings/test_environment_parsers.py

@@ -1,414 +0,0 @@
-import os
-from pathlib import Path
-
-import pytest
-from pytest_mock import MockerFixture
-
-from paperless.settings.parsers import get_choice_from_env
-from paperless.settings.parsers import get_int_from_env
-from paperless.settings.parsers import parse_dict_from_str
-from paperless.settings.parsers import str_to_bool
-
-
-class TestStringToBool:
-    @pytest.mark.parametrize(
-        "true_value",
-        [
-            pytest.param("true", id="lowercase_true"),
-            pytest.param("1", id="digit_1"),
-            pytest.param("T", id="capital_T"),
-            pytest.param("y", id="lowercase_y"),
-            pytest.param("YES", id="uppercase_YES"),
-            pytest.param("  True  ", id="whitespace_true"),
-        ],
-    )
-    def test_true_conversion(self, true_value: str):
-        """Test that various 'true' strings correctly evaluate to True."""
-        assert str_to_bool(true_value) is True
-
-    @pytest.mark.parametrize(
-        "false_value",
-        [
-            pytest.param("false", id="lowercase_false"),
-            pytest.param("0", id="digit_0"),
-            pytest.param("f", id="capital_f"),
-            pytest.param("N", id="capital_N"),
-            pytest.param("no", id="lowercase_no"),
-            pytest.param("  False  ", id="whitespace_false"),
-        ],
-    )
-    def test_false_conversion(self, false_value: str):
-        """Test that various 'false' strings correctly evaluate to False."""
-        assert str_to_bool(false_value) is False
-
-    def test_invalid_conversion(self):
-        """Test that an invalid string raises a ValueError."""
-        with pytest.raises(ValueError, match="Cannot convert 'maybe' to a boolean\\."):
-            str_to_bool("maybe")
-
-
-class TestParseDictFromString:
-    def test_empty_and_none_input(self):
-        """Test behavior with None or empty string input."""
-        assert parse_dict_from_str(None) == {}
-        assert parse_dict_from_str("") == {}
-        defaults = {"a": 1}
-        res = parse_dict_from_str(None, defaults=defaults)
-        assert res == defaults
-        # Ensure it returns a copy, not the original object
-        assert res is not defaults
-
-    def test_basic_parsing(self):
-        """Test simple key-value parsing without defaults or types."""
-        env_str = "key1=val1, key2=val2"
-        expected = {"key1": "val1", "key2": "val2"}
-        assert parse_dict_from_str(env_str) == expected
-
-    def test_with_defaults(self):
-        """Test that environment values override defaults correctly."""
-        defaults = {"host": "localhost", "port": 8000, "user": "default"}
-        env_str = "port=9090, host=db.example.com"
-        expected = {"host": "db.example.com", "port": "9090", "user": "default"}
-        result = parse_dict_from_str(env_str, defaults=defaults)
-        assert result == expected
-
-    def test_type_casting(self):
-        """Test successful casting of values to specified types."""
-        env_str = "port=9090, debug=true, timeout=12.5, user=admin"
-        type_map = {"port": int, "debug": bool, "timeout": float}
-        expected = {"port": 9090, "debug": True, "timeout": 12.5, "user": "admin"}
-        result = parse_dict_from_str(env_str, type_map=type_map)
-        assert result == expected
-
-    def test_type_casting_with_defaults(self):
-        """Test casting when values come from both defaults and env string."""
-        defaults = {"port": 8000, "debug": False, "retries": 3}
-        env_str = "port=9090, debug=true"
-        type_map = {"port": int, "debug": bool, "retries": int}
-
-        # The 'retries' value comes from defaults and is already an int,
-        # so it should not be processed by the caster.
-        expected = {"port": 9090, "debug": True, "retries": 3}
-        result = parse_dict_from_str(env_str, defaults=defaults, type_map=type_map)
-        assert result == expected
-        assert isinstance(result["retries"], int)
-
-    def test_path_casting(self, tmp_path: Path):
-        """Test successful casting of a string to a resolved pathlib.Path object."""
-        # Create a dummy file to resolve against
-        test_file = tmp_path / "test_file.txt"
-        test_file.touch()
-
-        env_str = f"config_path={test_file}"
-        type_map = {"config_path": Path}
-        result = parse_dict_from_str(env_str, type_map=type_map)
-
-        # The result should be a resolved Path object
-        assert isinstance(result["config_path"], Path)
-        assert result["config_path"] == test_file.resolve()
-
-    def test_custom_separator(self):
-        """Test parsing with a custom separator like a semicolon."""
-        env_str = "host=db; port=5432; user=test"
-        expected = {"host": "db", "port": "5432", "user": "test"}
-        result = parse_dict_from_str(env_str, separator=";")
-        assert result == expected
-
-    def test_edge_cases_in_string(self):
-        """Test malformed strings to ensure robustness."""
-        # Malformed pair 'debug' is skipped, extra comma is ignored
-        env_str = "key=val,, debug, foo=bar"
-        expected = {"key": "val", "foo": "bar"}
-        assert parse_dict_from_str(env_str) == expected
-
-        # Value can contain the equals sign
-        env_str = "url=postgres://user:pass@host:5432/db"
-        expected = {"url": "postgres://user:pass@host:5432/db"}
-        assert parse_dict_from_str(env_str) == expected
-
-    def test_casting_error_handling(self):
-        """Test that a ValueError is raised for invalid casting."""
-        env_str = "port=not-a-number"
-        type_map = {"port": int}
-
-        with pytest.raises(ValueError) as excinfo:
-            parse_dict_from_str(env_str, type_map=type_map)
-
-        assert "Error casting key 'port'" in str(excinfo.value)
-        assert "value 'not-a-number'" in str(excinfo.value)
-        assert "to type 'int'" in str(excinfo.value)
-
-    def test_bool_casting_error(self):
-        """Test that an invalid boolean string raises a ValueError."""
-        env_str = "debug=maybe"
-        type_map = {"debug": bool}
-        with pytest.raises(ValueError, match="Error casting key 'debug'"):
-            parse_dict_from_str(env_str, type_map=type_map)
-
-    def test_nested_key_parsing_basic(self):
-        """Basic nested key parsing using dot-notation."""
-        env_str = "database.host=db.example.com, database.port=5432, logging.level=INFO"
-        result = parse_dict_from_str(env_str)
-        assert result == {
-            "database": {"host": "db.example.com", "port": "5432"},
-            "logging": {"level": "INFO"},
-        }
-
-    def test_nested_overrides_defaults_and_deepcopy(self):
-        """Nested env keys override defaults and defaults are deep-copied."""
-        defaults = {"database": {"host": "127.0.0.1", "port": 3306, "user": "default"}}
-        env_str = "database.host=db.example.com, debug=true"
-        result = parse_dict_from_str(
-            env_str,
-            defaults=defaults,
-            type_map={"debug": bool},
-        )
-
-        assert result["database"]["host"] == "db.example.com"
-        # Unchanged default preserved
-        assert result["database"]["port"] == 3306
-        assert result["database"]["user"] == "default"
-        # Default object was deep-copied (no same nested object identity)
-        assert result is not defaults
-        assert result["database"] is not defaults["database"]
-
-    def test_nested_type_casting(self):
-        """Type casting for nested keys (dot-notation) should work."""
-        env_str = "database.host=db.example.com, database.port=5433, debug=false"
-        type_map = {"database.port": int, "debug": bool}
-        result = parse_dict_from_str(env_str, type_map=type_map)
-
-        assert result["database"]["host"] == "db.example.com"
-        assert result["database"]["port"] == 5433
-        assert isinstance(result["database"]["port"], int)
-        assert result["debug"] is False
-        assert isinstance(result["debug"], bool)
-
-    def test_nested_casting_error_message(self):
-        """Error messages should include the full dotted key name on failure."""
-        env_str = "database.port=not-a-number"
-        type_map = {"database.port": int}
-        with pytest.raises(ValueError) as excinfo:
-            parse_dict_from_str(env_str, type_map=type_map)
-
-        msg = str(excinfo.value)
-        assert "Error casting key 'database.port'" in msg
-        assert "value 'not-a-number'" in msg
-        assert "to type 'int'" in msg
-
-    def test_type_map_does_not_recast_non_string_defaults(self):
-        """If a default already provides a non-string value, the caster should skip it."""
-        defaults = {"database": {"port": 3306}}
-        type_map = {"database.port": int}
-        result = parse_dict_from_str(None, defaults=defaults, type_map=type_map)
-        assert result["database"]["port"] == 3306
-        assert isinstance(result["database"]["port"], int)
-
-
-class TestGetIntFromEnv:
-    @pytest.mark.parametrize(
-        ("env_value", "expected"),
-        [
-            pytest.param("42", 42, id="positive"),
-            pytest.param("-10", -10, id="negative"),
-            pytest.param("0", 0, id="zero"),
-            pytest.param("999", 999, id="large_positive"),
-            pytest.param("-999", -999, id="large_negative"),
-        ],
-    )
-    def test_existing_env_var_valid_ints(self, mocker, env_value, expected):
-        """Test that existing environment variables with valid integers return correct values."""
-        mocker.patch.dict(os.environ, {"INT_VAR": env_value})
-        assert get_int_from_env("INT_VAR") == expected
-
-    @pytest.mark.parametrize(
-        ("default", "expected"),
-        [
-            pytest.param(100, 100, id="positive_default"),
-            pytest.param(0, 0, id="zero_default"),
-            pytest.param(-50, -50, id="negative_default"),
-            pytest.param(None, None, id="none_default"),
-        ],
-    )
-    def test_missing_env_var_with_defaults(self, mocker, default, expected):
-        """Test that missing environment variables return provided defaults."""
-        mocker.patch.dict(os.environ, {}, clear=True)
-        assert get_int_from_env("MISSING_VAR", default=default) == expected
-
-    def test_missing_env_var_no_default(self, mocker):
-        """Test that missing environment variable with no default returns None."""
-        mocker.patch.dict(os.environ, {}, clear=True)
-        assert get_int_from_env("MISSING_VAR") is None
-
-    @pytest.mark.parametrize(
-        "invalid_value",
-        [
-            pytest.param("not_a_number", id="text"),
-            pytest.param("42.5", id="float"),
-            pytest.param("42a", id="alpha_suffix"),
-            pytest.param("", id="empty"),
-            pytest.param(" ", id="whitespace"),
-            pytest.param("true", id="boolean"),
-            pytest.param("1.0", id="decimal"),
-        ],
-    )
-    def test_invalid_int_values_raise_error(self, mocker, invalid_value):
-        """Test that invalid integer values raise ValueError."""
-        mocker.patch.dict(os.environ, {"INVALID_INT": invalid_value})
-        with pytest.raises(ValueError):
-            get_int_from_env("INVALID_INT")
-
-
-class TestGetEnvChoice:
-    @pytest.fixture
-    def valid_choices(self) -> set[str]:
-        """Fixture providing a set of valid environment choices."""
-        return {"development", "staging", "production"}
-
-    def test_returns_valid_env_value(
-        self,
-        mocker: MockerFixture,
-        valid_choices: set[str],
-    ) -> None:
-        """Test that function returns the environment value when it's valid."""
-        mocker.patch.dict("os.environ", {"TEST_ENV": "development"})
-
-        result = get_choice_from_env("TEST_ENV", valid_choices)
-
-        assert result == "development"
-
-    def test_returns_default_when_env_not_set(
-        self,
-        mocker: MockerFixture,
-        valid_choices: set[str],
-    ) -> None:
-        """Test that function returns default value when env var is not set."""
-        mocker.patch.dict("os.environ", {}, clear=True)
-
-        result = get_choice_from_env("TEST_ENV", valid_choices, default="staging")
-
-        assert result == "staging"
-
-    def test_raises_error_when_env_not_set_and_no_default(
-        self,
-        mocker: MockerFixture,
-        valid_choices: set[str],
-    ) -> None:
-        """Test that function raises ValueError when env var is missing and no default."""
-        mocker.patch.dict("os.environ", {}, clear=True)
-
-        with pytest.raises(ValueError) as exc_info:
-            get_choice_from_env("TEST_ENV", valid_choices)
-
-        assert "Environment variable 'TEST_ENV' is required but not set" in str(
-            exc_info.value,
-        )
-
-    def test_raises_error_when_env_value_invalid(
-        self,
-        mocker: MockerFixture,
-        valid_choices: set[str],
-    ) -> None:
-        """Test that function raises ValueError when env value is not in choices."""
-        mocker.patch.dict("os.environ", {"TEST_ENV": "invalid_value"})
-
-        with pytest.raises(ValueError) as exc_info:
-            get_choice_from_env("TEST_ENV", valid_choices)
-
-        error_msg = str(exc_info.value)
-        assert (
-            "Environment variable 'TEST_ENV' has invalid value 'invalid_value'"
-            in error_msg
-        )
-        assert "Valid choices are:" in error_msg
-        assert "development" in error_msg
-        assert "staging" in error_msg
-        assert "production" in error_msg
-
-    def test_raises_error_when_default_invalid(
-        self,
-        mocker: MockerFixture,
-        valid_choices: set[str],
-    ) -> None:
-        """Test that function raises ValueError when default value is not in choices."""
-        mocker.patch.dict("os.environ", {}, clear=True)
-
-        with pytest.raises(ValueError) as exc_info:
-            get_choice_from_env("TEST_ENV", valid_choices, default="invalid_default")
-
-        error_msg = str(exc_info.value)
-        assert (
-            "Environment variable 'TEST_ENV' has invalid value 'invalid_default'"
-            in error_msg
-        )
-
-    def test_case_sensitive_validation(
-        self,
-        mocker: MockerFixture,
-        valid_choices: set[str],
-    ) -> None:
-        """Test that validation is case sensitive."""
-        mocker.patch.dict("os.environ", {"TEST_ENV": "DEVELOPMENT"})
-
-        with pytest.raises(ValueError):
-            get_choice_from_env("TEST_ENV", valid_choices)
-
-    def test_empty_string_env_value(
-        self,
-        mocker: MockerFixture,
-        valid_choices: set[str],
-    ) -> None:
-        """Test behavior with empty string environment value."""
-        mocker.patch.dict("os.environ", {"TEST_ENV": ""})
-
-        with pytest.raises(ValueError) as exc_info:
-            get_choice_from_env("TEST_ENV", valid_choices)
-
-        assert "has invalid value ''" in str(exc_info.value)
-
-    def test_whitespace_env_value(
-        self,
-        mocker: MockerFixture,
-        valid_choices: set[str],
-    ) -> None:
-        """Test behavior with whitespace-only environment value."""
-        mocker.patch.dict("os.environ", {"TEST_ENV": "  development  "})
-
-        with pytest.raises(ValueError):
-            get_choice_from_env("TEST_ENV", valid_choices)
-
-    def test_single_choice_set(self, mocker: MockerFixture) -> None:
-        """Test function works correctly with single choice set."""
-        single_choice: set[str] = {"production"}
-        mocker.patch.dict("os.environ", {"TEST_ENV": "production"})
-
-        result = get_choice_from_env("TEST_ENV", single_choice)
-
-        assert result == "production"
-
-    def test_large_choice_set(self, mocker: MockerFixture) -> None:
-        """Test function works correctly with large choice set."""
-        large_choices: set[str] = {f"option_{i}" for i in range(100)}
-        mocker.patch.dict("os.environ", {"TEST_ENV": "option_50"})
-
-        result = get_choice_from_env("TEST_ENV", large_choices)
-
-        assert result == "option_50"
-
-    def test_different_env_keys(
-        self,
-        mocker: MockerFixture,
-        valid_choices: set[str],
-    ) -> None:
-        """Test function works with different environment variable keys."""
-        test_cases = [
-            ("DJANGO_ENV", "development"),
-            ("DATABASE_BACKEND", "staging"),
-            ("LOG_LEVEL", "production"),
-            ("APP_MODE", "development"),
-        ]
-
-        for env_key, env_value in test_cases:
-            mocker.patch.dict("os.environ", {env_key: env_value})
-            result = get_choice_from_env(env_key, valid_choices)
-            assert result == env_value

src/paperless/tests/test_adapter.py

@@ -78,15 +78,11 @@ class TestCustomAccountAdapter(TestCase):
             adapter = get_adapter()
 
             # Test when PAPERLESS_URL is None
-            with override_settings(
-                PAPERLESS_URL=None,
-                ACCOUNT_DEFAULT_HTTP_PROTOCOL="https",
-            ):
-                expected_url = f"https://foo.org{reverse('account_reset_password_from_key', kwargs={'uidb36': 'UID', 'key': 'KEY'})}"
-                self.assertEqual(
-                    adapter.get_reset_password_from_key_url("UID-KEY"),
-                    expected_url,
-                )
+            expected_url = f"https://foo.org{reverse('account_reset_password_from_key', kwargs={'uidb36': 'UID', 'key': 'KEY'})}"
+            self.assertEqual(
+                adapter.get_reset_password_from_key_url("UID-KEY"),
+                expected_url,
+            )
 
             # Test when PAPERLESS_URL is not None
             with override_settings(PAPERLESS_URL="https://bar.com"):

src/paperless/tests/test_checks.py

@@ -2,17 +2,13 @@ import os
 from pathlib import Path
 from unittest import mock
 
-import pytest
-from django.core.checks import Warning
 from django.test import TestCase
 from django.test import override_settings
-from pytest_mock import MockerFixture
 
 from documents.tests.utils import DirectoriesMixin
 from documents.tests.utils import FileSystemAssertsMixin
 from paperless.checks import audit_log_check
 from paperless.checks import binaries_check
-from paperless.checks import check_deprecated_db_settings
 from paperless.checks import debug_mode_check
 from paperless.checks import paths_check
 from paperless.checks import settings_values_check
@@ -241,157 +237,3 @@ class TestAuditLogChecks(TestCase):
                     ("auditlog table was found but audit log is disabled."),
                     msg.msg,
                 )
-
-
-DEPRECATED_VARS: dict[str, str] = {
-    "PAPERLESS_DB_TIMEOUT": "timeout",
-    "PAPERLESS_DB_POOLSIZE": "pool.min_size / pool.max_size",
-    "PAPERLESS_DBSSLMODE": "sslmode",
-    "PAPERLESS_DBSSLROOTCERT": "sslrootcert",
-    "PAPERLESS_DBSSLCERT": "sslcert",
-    "PAPERLESS_DBSSLKEY": "sslkey",
-}
-
-
-class TestDeprecatedDbSettings:
-    """Test suite for the check_deprecated_db_settings system check."""
-
-    def test_no_deprecated_vars_returns_empty(
-        self,
-        mocker: MockerFixture,
-    ) -> None:
-        """No warnings when none of the deprecated vars are present."""
-        # clear=True ensures vars from the outer test environment do not leak in
-        mocker.patch.dict(os.environ, {}, clear=True)
-        result = check_deprecated_db_settings(None)
-        assert result == []
-
-    @pytest.mark.parametrize(
-        ("env_var", "db_option_key"),
-        [
-            ("PAPERLESS_DB_TIMEOUT", "timeout"),
-            ("PAPERLESS_DB_POOLSIZE", "pool.min_size / pool.max_size"),
-            ("PAPERLESS_DBSSLMODE", "sslmode"),
-            ("PAPERLESS_DBSSLROOTCERT", "sslrootcert"),
-            ("PAPERLESS_DBSSLCERT", "sslcert"),
-            ("PAPERLESS_DBSSLKEY", "sslkey"),
-        ],
-        ids=[
-            "db-timeout",
-            "db-poolsize",
-            "ssl-mode",
-            "ssl-rootcert",
-            "ssl-cert",
-            "ssl-key",
-        ],
-    )
-    def test_single_deprecated_var_produces_one_warning(
-        self,
-        mocker: MockerFixture,
-        env_var: str,
-        db_option_key: str,
-    ) -> None:
-        """Each deprecated var in isolation produces exactly one warning."""
-        mocker.patch.dict(os.environ, {env_var: "some_value"}, clear=True)
-        result = check_deprecated_db_settings(None)
-
-        assert len(result) == 1
-        warning = result[0]
-        assert isinstance(warning, Warning)
-        assert warning.id == "paperless.W001"
-        assert env_var in warning.hint
-        assert db_option_key in warning.hint
-
-    def test_multiple_deprecated_vars_produce_one_warning_each(
-        self,
-        mocker: MockerFixture,
-    ) -> None:
-        """Each deprecated var present in the environment gets its own warning."""
-        set_vars = {
-            "PAPERLESS_DB_TIMEOUT": "30",
-            "PAPERLESS_DB_POOLSIZE": "10",
-            "PAPERLESS_DBSSLMODE": "require",
-        }
-        mocker.patch.dict(os.environ, set_vars, clear=True)
-        result = check_deprecated_db_settings(None)
-
-        assert len(result) == len(set_vars)
-        assert all(isinstance(w, Warning) for w in result)
-        assert all(w.id == "paperless.W001" for w in result)
-        all_hints = " ".join(w.hint for w in result)
-        for var_name in set_vars:
-            assert var_name in all_hints
-
-    def test_all_deprecated_vars_produces_one_warning_each(
-        self,
-        mocker: MockerFixture,
-    ) -> None:
-        """All deprecated vars set simultaneously produces one warning per var."""
-        all_vars = dict.fromkeys(DEPRECATED_VARS, "some_value")
-        mocker.patch.dict(os.environ, all_vars, clear=True)
-        result = check_deprecated_db_settings(None)
-
-        assert len(result) == len(DEPRECATED_VARS)
-        assert all(isinstance(w, Warning) for w in result)
-        assert all(w.id == "paperless.W001" for w in result)
-
-    def test_unset_vars_not_mentioned_in_warnings(
-        self,
-        mocker: MockerFixture,
-    ) -> None:
-        """Vars absent from the environment do not appear in any warning."""
-        mocker.patch.dict(
-            os.environ,
-            {"PAPERLESS_DB_TIMEOUT": "30"},
-            clear=True,
-        )
-        result = check_deprecated_db_settings(None)
-
-        assert len(result) == 1
-        assert "PAPERLESS_DB_TIMEOUT" in result[0].hint
-        unset_vars = [v for v in DEPRECATED_VARS if v != "PAPERLESS_DB_TIMEOUT"]
-        for var_name in unset_vars:
-            assert var_name not in result[0].hint
-
-    def test_empty_string_var_not_treated_as_set(
-        self,
-        mocker: MockerFixture,
-    ) -> None:
-        """A var set to an empty string is not flagged as a deprecated setting."""
-        mocker.patch.dict(
-            os.environ,
-            {"PAPERLESS_DB_TIMEOUT": ""},
-            clear=True,
-        )
-        result = check_deprecated_db_settings(None)
-        assert result == []
-
-    def test_warning_mentions_migration_target(
-        self,
-        mocker: MockerFixture,
-    ) -> None:
-        """Each warning hints at PAPERLESS_DB_OPTIONS as the migration target."""
-        mocker.patch.dict(
-            os.environ,
-            {"PAPERLESS_DBSSLMODE": "require"},
-            clear=True,
-        )
-        result = check_deprecated_db_settings(None)
-
-        assert len(result) == 1
-        assert "PAPERLESS_DB_OPTIONS" in result[0].hint
-
-    def test_warning_message_identifies_var(
-        self,
-        mocker: MockerFixture,
-    ) -> None:
-        """The warning message (not just the hint) identifies the offending var."""
-        mocker.patch.dict(
-            os.environ,
-            {"PAPERLESS_DBSSLCERT": "/path/to/cert.pem"},
-            clear=True,
-        )
-        result = check_deprecated_db_settings(None)
-
-        assert len(result) == 1
-        assert "PAPERLESS_DBSSLCERT" in result[0].msg

src/paperless/tests/test_settings.py

@@ -9,6 +9,7 @@ from celery.schedules import crontab
 from paperless.settings import _parse_base_paths
 from paperless.settings import _parse_beat_schedule
 from paperless.settings import _parse_dateparser_languages
+from paperless.settings import _parse_db_settings
 from paperless.settings import _parse_ignore_dates
 from paperless.settings import _parse_paperless_url
 from paperless.settings import _parse_redis_url
@@ -377,6 +378,64 @@ class TestCeleryScheduleParsing(TestCase):
         )
 
 
+class TestDBSettings(TestCase):
+    def test_db_timeout_with_sqlite(self) -> None:
+        """
+        GIVEN:
+            - PAPERLESS_DB_TIMEOUT is set
+        WHEN:
+            - Settings are parsed
+        THEN:
+            - PAPERLESS_DB_TIMEOUT set for sqlite
+        """
+        with mock.patch.dict(
+            os.environ,
+            {
+                "PAPERLESS_DB_TIMEOUT": "10",
+            },
+        ):
+            databases = _parse_db_settings()
+
+            self.assertDictEqual(
+                {
+                    "timeout": 10.0,
+                },
+                databases["default"]["OPTIONS"],
+            )
+
+    def test_db_timeout_with_not_sqlite(self) -> None:
+        """
+        GIVEN:
+            - PAPERLESS_DB_TIMEOUT is set but db is not sqlite
+        WHEN:
+            - Settings are parsed
+        THEN:
+            - PAPERLESS_DB_TIMEOUT set correctly in non-sqlite db & for fallback sqlite db
+        """
+        with mock.patch.dict(
+            os.environ,
+            {
+                "PAPERLESS_DBHOST": "127.0.0.1",
+                "PAPERLESS_DB_TIMEOUT": "10",
+            },
+        ):
+            databases = _parse_db_settings()
+
+            self.assertDictEqual(
+                databases["default"]["OPTIONS"],
+                databases["default"]["OPTIONS"]
+                | {
+                    "connect_timeout": 10.0,
+                },
+            )
+            self.assertDictEqual(
+                {
+                    "timeout": 10.0,
+                },
+                databases["sqlite"]["OPTIONS"],
+            )
+
+
 class TestPaperlessURLSettings(TestCase):
     def test_paperless_url(self) -> None:
         """

src/paperless/tests/test_views.py

@@ -1,7 +1,7 @@
 import tempfile
 from pathlib import Path
 
-from django.test import override_settings
+from django.conf import settings
 
 
 def test_favicon_view(client):
@@ -11,14 +11,15 @@ def test_favicon_view(client):
         favicon_path.parent.mkdir(parents=True, exist_ok=True)
         favicon_path.write_bytes(b"FAKE ICON DATA")
 
-        with override_settings(STATIC_ROOT=static_dir):
-            response = client.get("/favicon.ico")
-            assert response.status_code == 200
-            assert response["Content-Type"] == "image/x-icon"
-            assert b"".join(response.streaming_content) == b"FAKE ICON DATA"
+        settings.STATIC_ROOT = static_dir
+
+        response = client.get("/favicon.ico")
+        assert response.status_code == 200
+        assert response["Content-Type"] == "image/x-icon"
+        assert b"".join(response.streaming_content) == b"FAKE ICON DATA"
 
 
 def test_favicon_view_missing_file(client):
-    with override_settings(STATIC_ROOT=Path(tempfile.mkdtemp())):
-        response = client.get("/favicon.ico")
-        assert response.status_code == 404
+    settings.STATIC_ROOT = Path(tempfile.mkdtemp())
+    response = client.get("/favicon.ico")
+    assert response.status_code == 404

src/paperless_mail/parsers.py

@@ -5,7 +5,6 @@ from pathlib import Path
 from bleach import clean
 from bleach import linkify
 from django.conf import settings
-from django.utils import timezone
 from django.utils.timezone import is_naive
 from django.utils.timezone import make_aware
 from gotenberg_client import GotenbergClient
@@ -333,9 +332,7 @@ class MailDocumentParser(DocumentParser):
         if data["attachments"]:
             data["attachments_label"] = "Attachments"
 
-        data["date"] = clean_html(
-            timezone.localtime(mail.date).strftime("%Y-%m-%d %H:%M"),
-        )
+        data["date"] = clean_html(mail.date.astimezone().strftime("%Y-%m-%d %H:%M"))
         data["content"] = clean_html(mail.text.strip())
 
         from django.template.loader import render_to_string

src/paperless_mail/tests/test_parsers.py

@@ -6,7 +6,6 @@ from unittest import mock
 import httpx
 import pytest
 from django.test.html import parse_html
-from django.utils import timezone
 from pytest_django.fixtures import SettingsWrapper
 from pytest_httpx import HTTPXMock
 from pytest_mock import MockerFixture
@@ -635,14 +634,13 @@ class TestParser:
         THEN:
             - Resulting HTML is as expected
         """
-        with timezone.override("UTC"):
-            mail = mail_parser.parse_file_to_message(html_email_file)
-            html_file = mail_parser.mail_to_html(mail)
+        mail = mail_parser.parse_file_to_message(html_email_file)
+        html_file = mail_parser.mail_to_html(mail)
 
-            expected_html = parse_html(html_email_html_file.read_text())
-            actual_html = parse_html(html_file.read_text())
+        expected_html = parse_html(html_email_html_file.read_text())
+        actual_html = parse_html(html_file.read_text())
 
-            assert expected_html == actual_html
+        assert expected_html == actual_html
 
     def test_generate_pdf_from_mail(
         self,

src/paperless_tesseract/tests/test_parser.py

@@ -1,6 +1,5 @@
 import shutil
 import tempfile
-import unicodedata
 import uuid
 from pathlib import Path
 from unittest import mock
@@ -848,18 +847,8 @@ class TestParser(DirectoriesMixin, FileSystemAssertsMixin, TestCase):
             "application/pdf",
         )
 
-        # OCR output for RTL text varies across platforms/versions due to
-        # bidi controls and presentation forms; normalize before assertion.
-        normalized_text = "".join(
-            char
-            for char in unicodedata.normalize("NFKC", parser.get_text())
-            if unicodedata.category(char) != "Cf" and not char.isspace()
-        )
-
-        self.assertIn("ةرازو", normalized_text)
-        self.assertTrue(
-            any(token in normalized_text for token in ("ةیلخادلا", "الاخليد")),
-        )
+        # Copied from the PDF to here.  Don't even look at it
+        self.assertIn("ةﯾﻠﺧﺎدﻻ ةرازو", parser.get_text())
 
     @mock.patch("ocrmypdf.ocr")
     def test_gs_rendering_error(self, m) -> None:

uv.lock

@@ -721,14 +721,14 @@ wheels = [
 
 [[package]]
 name = "concurrent-log-handler"
-version = "0.9.29"
+version = "0.9.28"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "portalocker", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/9c/2c/ba185acc438cff6b58cd8f8dec27e7f4fcabf6968a1facbb6d0cacbde7fe/concurrent_log_handler-0.9.29.tar.gz", hash = "sha256:bc37a76d3f384cbf4a98f693ebd770543edc0f4cd5c6ab6bc70e9e1d7d582265", size = 42114, upload-time = "2026-02-22T18:18:25.758Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/6b/ed/68b9c3a07a2331361a09a194e4375c4ee680a799391cfb1ca924ca2b6523/concurrent_log_handler-0.9.28.tar.gz", hash = "sha256:4cc27969b3420239bd153779266f40d9713ece814e312b7aa753ce62c6eacdb8", size = 30935, upload-time = "2025-06-10T19:02:15.622Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/4a/f3/3e3188fdb3e53c6343fd1c7de41c55d4db626f07db3877eae77b28d58bd2/concurrent_log_handler-0.9.29-py3-none-any.whl", hash = "sha256:0d6c077fbaef2dae49a25975dcf72a602fe0a6a4ce80a3b7c37696d37e10459a", size = 32052, upload-time = "2026-02-22T18:18:24.558Z" },
+    { url = "https://files.pythonhosted.org/packages/d0/a0/1331c3f12d95adc8d0385dc620001054c509db88376d2e17be36b6353020/concurrent_log_handler-0.9.28-py3-none-any.whl", hash = "sha256:65db25d05506651a61573937880789fc51c7555e7452303042b5a402fd78939c", size = 28983, upload-time = "2025-06-10T19:02:14.223Z" },
 ]
 
 [[package]]
@@ -1137,29 +1137,16 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/6d/10/23c0644cf67567bbe4e3a2eeeec0e9c79b701990c0e07c5ee4a4f8897f91/django_multiselectfield-1.0.1-py3-none-any.whl", hash = "sha256:18dc14801f7eca844a48e21cba6d8ec35b9b581f2373bbb2cb75e6994518259a", size = 20481, upload-time = "2025-06-12T14:41:20.107Z" },
 ]
 
-[[package]]
-name = "django-rich"
-version = "2.2.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "django", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
-    { name = "rich", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/a6/67/e307a5fef657e7992468f567b521534c52e01bdda5a1ae5b12de679a670f/django_rich-2.2.0.tar.gz", hash = "sha256:ecec7842d040024ed8a225699388535e46b87277550c33f46193b52cece2f780", size = 62427, upload-time = "2025-09-18T11:42:17.182Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/27/ed/23fa669493d78cd67e7f6734fa380f8690f2b4d75b4f72fd645a52c3b32a/django_rich-2.2.0-py3-none-any.whl", hash = "sha256:a0d2c916bd9750b6e9beb57407aef5e836c8705d7dbe9e4fd4725f7bbe41c407", size = 9210, upload-time = "2025-09-18T11:42:15.779Z" },
-]
-
 [[package]]
 name = "django-soft-delete"
-version = "1.0.23"
+version = "1.0.22"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "django", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/aa/98/c7c52a85b070b1703774df817b6460a7714655302a2d503f6447544f1a29/django_soft_delete-1.0.23.tar.gz", hash = "sha256:814659f0d19d4f2afc58b31ff73f88f0af66715ccef3b4fcd8f6b3a011d59b2a", size = 22458, upload-time = "2026-02-21T17:48:41.345Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/98/d1/c990b731676f93bd4594dee4b5133df52f5d0eee1eb8a969b4030014ac54/django_soft_delete-1.0.22.tar.gz", hash = "sha256:32d0bb95f180c28a40163e78a558acc18901fd56011f91f8ee735c171a6d4244", size = 21982, upload-time = "2025-10-25T13:11:46.199Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/91/9e/77375a163c340fff03d037eac7d970ce006626e6c3aea87b5d159f052f8b/django_soft_delete-1.0.23-py3-none-any.whl", hash = "sha256:dd2133d4925d58308680f389daa2e150abf7b81a4f0abbbf2161a9db3b9f1e74", size = 19308, upload-time = "2026-02-21T17:48:39.974Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/c2/fca2bf69b7ca7e18aed9ac059e89f1043663e207a514e8fb652450e49631/django_soft_delete-1.0.22-py3-none-any.whl", hash = "sha256:81973c541d21452d249151085d617ebbfb5ec463899f47cd6b1306677481e94c", size = 19221, upload-time = "2025-10-25T13:11:44.755Z" },
 ]
 
 [[package]]
@@ -2194,7 +2181,7 @@ wheels = [
 
 [[package]]
 name = "llama-index-core"
-version = "0.14.15"
+version = "0.14.13"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "aiohttp", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
@@ -2222,15 +2209,14 @@ dependencies = [
     { name = "sqlalchemy", extra = ["asyncio"], marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
     { name = "tenacity", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
     { name = "tiktoken", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
-    { name = "tinytag", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
     { name = "tqdm", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
     { name = "typing-extensions", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
     { name = "typing-inspect", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
     { name = "wrapt", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/0c/4f/7c714bdf94dd229707b43e7f8cedf3aed0a99938fd46a9ad8a418c199988/llama_index_core-0.14.15.tar.gz", hash = "sha256:3766aeeb95921b3a2af8c2a51d844f75f404215336e1639098e3652db52c68ce", size = 11593505, upload-time = "2026-02-18T19:05:48.274Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/74/54/d6043a088e5e9c1d62300db7ad0ef417c6b9a92f7b4a5cade066aeafdaca/llama_index_core-0.14.13.tar.gz", hash = "sha256:c3b30d20ae0407e5d0a1d35bb3376a98e242661ebfc22da754b5a3da1f8108c0", size = 11589074, upload-time = "2026-01-21T20:44:16.287Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/41/9e/262f6465ee4fffa40698b3cc2177e377ce7d945d3bd8b7d9c6b09448625d/llama_index_core-0.14.15-py3-none-any.whl", hash = "sha256:e02b321c10673871a38aaefdc4a93d5ae8ec324cad4408683189e5a1aa1e3d52", size = 11937002, upload-time = "2026-02-18T19:05:45.855Z" },
+    { url = "https://files.pythonhosted.org/packages/76/59/9769f03f1cccadcc014b3b65c166de18999b51459a0f0a579d80f6c91d80/llama_index_core-0.14.13-py3-none-any.whl", hash = "sha256:392f0a5a09433e9dea786964ef5fe5ca2a2b10aee9f979a9507c19a14da2a20a", size = 11934761, upload-time = "2026-01-21T20:44:18.892Z" },
 ]
 
 [[package]]
@@ -2288,27 +2274,27 @@ wheels = [
 
 [[package]]
 name = "llama-index-llms-openai"
-version = "0.6.21"
+version = "0.6.18"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "llama-index-core", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
     { name = "openai", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/d8/5b/775289b3064302966cc839bbccfdbe314f706eaf58ad4233b86e5d53343d/llama_index_llms_openai-0.6.21.tar.gz", hash = "sha256:0b92dcfb01cbc7752f5b8bdf6d93430643d295210cf9392b45291d6fdd81e0ee", size = 25961, upload-time = "2026-02-26T04:19:33.604Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/56/78/298de76242aee7f5fdd65a0bffb541b3f81759613de1e8ebc719eec8e8af/llama_index_llms_openai-0.6.18.tar.gz", hash = "sha256:36c0256a7a211bbbc5ecc00d3f2caa9730eea1971ced3b68b7c94025c0448020", size = 25946, upload-time = "2026-02-06T12:01:03.095Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/e3/d7/5b513acbf0bfc2b6ef281b6bbca764062facc431e8f13763c16005fbd34b/llama_index_llms_openai-0.6.21-py3-none-any.whl", hash = "sha256:ef8c048849f844c7db9ff4208cca9878a799bc5fcdd72954197ea11e64b37c97", size = 26965, upload-time = "2026-02-26T04:19:34.561Z" },
+    { url = "https://files.pythonhosted.org/packages/39/46/5a4b62108fb94febe27d35c8476dea042d7a609ee4bf14f5b61f03d5a75a/llama_index_llms_openai-0.6.18-py3-none-any.whl", hash = "sha256:73bbbf233d38116d48350391a3649884829564f4c8f6168c8fa3f3ae1b557376", size = 26945, upload-time = "2026-02-06T12:01:01.25Z" },
 ]
 
 [[package]]
 name = "llama-index-vector-stores-faiss"
-version = "0.5.3"
+version = "0.5.2"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "llama-index-core", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/c5/e6/57da31b38d173cd9124fdcdd47487b9a917b69bd49e8f6e551407ccfa860/llama_index_vector_stores_faiss-0.5.3.tar.gz", hash = "sha256:9620b1e27e96233fda88878c453532fba6061cf7ba7a53698a34703faab21ece", size = 6048, upload-time = "2026-02-12T14:22:14.612Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/2d/5f/c4ae340f178f202cf09dcc24dd0953a41d9ab24bc33e1f7220544ba86e41/llama_index_vector_stores_faiss-0.5.2.tar.gz", hash = "sha256:924504765e68b1f84ec602feb2d9516be6a6c12fad5e133f19cc5da3b23f4282", size = 5910, upload-time = "2025-12-17T21:01:13.21Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/ed/ad/ad192dd624ca2875b8ca74e55fddf9b083d6614524004f7830379d0a0cfd/llama_index_vector_stores_faiss-0.5.3-py3-none-any.whl", hash = "sha256:ef186e38a820e696a1adca15432c8539d73f2959eb05671011db21091a286c8c", size = 7738, upload-time = "2026-02-12T14:22:13.756Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/c1/c8317250c2a83d1d439814d1a7f41fa34a23c224b3099da898f08a249859/llama_index_vector_stores_faiss-0.5.2-py3-none-any.whl", hash = "sha256:72a3a03d9f25c70bbcc8c61aa860cd1db69f2a8070606ecc3266d767b71ff2a2", size = 7605, upload-time = "2025-12-17T21:01:12.429Z" },
 ]
 
 [[package]]
@@ -2780,9 +2766,9 @@ wheels = [
 
 [[package]]
 name = "mysqlclient"
-version = "2.2.8"
+version = "2.2.7"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/eb/b0/9df076488cb2e536d40ce6dbd4273c1f20a386e31ffe6e7cb613902b3c2a/mysqlclient-2.2.8.tar.gz", hash = "sha256:8ed20c5615a915da451bb308c7d0306648a4fd9a2809ba95c992690006306199", size = 92287, upload-time = "2026-02-10T10:58:37.405Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/61/68/810093cb579daae426794bbd9d88aa830fae296e85172d18cb0f0e5dd4bc/mysqlclient-2.2.7.tar.gz", hash = "sha256:24ae22b59416d5fcce7e99c9d37548350b4565baac82f95e149cac6ce4163845", size = 91383, upload-time = "2025-01-10T12:06:00.763Z" }
 
 [[package]]
 name = "nest-asyncio"
@@ -3055,7 +3041,6 @@ dependencies = [
     { name = "django-filter", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
     { name = "django-guardian", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
     { name = "django-multiselectfield", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
-    { name = "django-rich", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
     { name = "django-soft-delete", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
     { name = "django-treenode", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
     { name = "djangorestframework", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
@@ -3096,6 +3081,7 @@ dependencies = [
     { name = "tika-client", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
     { name = "torch", version = "2.10.0", source = { registry = "https://download.pytorch.org/whl/cpu" }, marker = "sys_platform == 'darwin'" },
     { name = "torch", version = "2.10.0+cpu", source = { registry = "https://download.pytorch.org/whl/cpu" }, marker = "sys_platform == 'linux'" },
+    { name = "tqdm", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
     { name = "watchfiles", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
     { name = "whitenoise", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
     { name = "whoosh-reloaded", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
@@ -3176,6 +3162,7 @@ typing = [
     { name = "types-pytz", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
     { name = "types-redis", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
     { name = "types-setuptools", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
+    { name = "types-tqdm", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
 ]
 
 [package.metadata]
@@ -3199,7 +3186,6 @@ requires-dist = [
     { name = "django-filter", specifier = "~=25.1" },
     { name = "django-guardian", specifier = "~=3.3.0" },
     { name = "django-multiselectfield", specifier = "~=1.0.1" },
-    { name = "django-rich", specifier = "~=2.2.0" },
     { name = "django-soft-delete", specifier = "~=1.0.18" },
     { name = "django-treenode", specifier = ">=0.23.2" },
     { name = "djangorestframework", specifier = "~=3.16" },
@@ -3246,6 +3232,7 @@ requires-dist = [
     { name = "setproctitle", specifier = "~=1.3.4" },
     { name = "tika-client", specifier = "~=0.10.0" },
     { name = "torch", specifier = "~=2.10.0", index = "https://download.pytorch.org/whl/cpu" },
+    { name = "tqdm", specifier = "~=4.67.1" },
     { name = "watchfiles", specifier = ">=1.1.1" },
     { name = "whitenoise", specifier = "~=6.11" },
     { name = "whoosh-reloaded", specifier = ">=2.7.5" },
@@ -3310,6 +3297,7 @@ typing = [
     { name = "types-pytz" },
     { name = "types-redis" },
     { name = "types-setuptools" },
+    { name = "types-tqdm" },
 ]
 
 [[package]]
@@ -3549,23 +3537,23 @@ wheels = [
 
 [[package]]
 name = "prek"
-version = "0.3.3"
+version = "0.3.2"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/bf/f1/7613dc8347a33e40fc5b79eec6bc7d458d8bbc339782333d8433b665f86f/prek-0.3.3.tar.gz", hash = "sha256:117bd46ebeb39def24298ce021ccc73edcf697b81856fcff36d762dd56093f6f", size = 343697, upload-time = "2026-02-15T13:33:28.723Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/d3/f5/ee52def928dd1355c20bcfcf765e1e61434635c33f3075e848e7b83a157b/prek-0.3.2.tar.gz", hash = "sha256:dce0074ff1a21290748ca567b4bda7553ee305a8c7b14d737e6c58364a499364", size = 334229, upload-time = "2026-02-06T13:49:47.539Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/2d/8b/dce13d2a3065fd1e8ffce593a0e51c4a79c3cde9c9a15dc0acc8d9d1573d/prek-0.3.3-py3-none-linux_armv6l.whl", hash = "sha256:e8629cac4bdb131be8dc6e5a337f0f76073ad34a8305f3fe2bc1ab6201ede0a4", size = 4644636, upload-time = "2026-02-15T13:33:43.609Z" },
-    { url = "https://files.pythonhosted.org/packages/01/30/06ab4dbe7ce02a8ce833e92deb1d9a8e85ae9d40e33d1959a2070b7494c6/prek-0.3.3-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:4b9e819b9e4118e1e785047b1c8bd9aec7e4d836ed034cb58b7db5bcaaf49437", size = 4651410, upload-time = "2026-02-15T13:33:34.277Z" },
-    { url = "https://files.pythonhosted.org/packages/d4/fc/da3bc5cb38471e7192eda06b7a26b7c24ef83e82da2c1dbc145f2bf33640/prek-0.3.3-py3-none-macosx_11_0_arm64.whl", hash = "sha256:bf29db3b5657c083eb8444c25aadeeec5167dc492e9019e188f87932f01ea50a", size = 4273163, upload-time = "2026-02-15T13:33:42.106Z" },
-    { url = "https://files.pythonhosted.org/packages/b4/74/47839395091e2937beced81a5dd2f8ea9c8239c853da8611aaf78ee21a8b/prek-0.3.3-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.musllinux_1_1_aarch64.whl", hash = "sha256:ae09736149815b26e64a9d350ca05692bab32c2afdf2939114d3211aaad68a3e", size = 4631808, upload-time = "2026-02-15T13:33:20.076Z" },
-    { url = "https://files.pythonhosted.org/packages/e2/89/3f5ef6f7c928c017cb63b029349d6bc03598ab7f6979d4a770ce02575f82/prek-0.3.3-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:856c2b55c51703c366bb4ce81c6a91102b70573a9fc8637db2ac61c66e4565f9", size = 4548959, upload-time = "2026-02-15T13:33:36.325Z" },
-    { url = "https://files.pythonhosted.org/packages/b2/18/80002c4c4475f90ca025f27739a016927a0e5d905c60612fc95da1c56ab7/prek-0.3.3-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:3acdf13a018f685beaff0a71d4b0d2ccbab4eaa1aced6d08fd471c1a654183eb", size = 4862256, upload-time = "2026-02-15T13:33:37.754Z" },
-    { url = "https://files.pythonhosted.org/packages/c5/25/648bf084c2468fa7cfcdbbe9e59956bbb31b81f36e113bc9107d80af26a7/prek-0.3.3-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:0f035667a8bd0a77b2bfa2b2e125da8cb1793949e9eeef0d8daab7f8ac8b57fe", size = 5404486, upload-time = "2026-02-15T13:33:39.239Z" },
-    { url = "https://files.pythonhosted.org/packages/8b/43/261fb60a11712a327da345912bd8b338dc5a050199de800faafa278a6133/prek-0.3.3-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d09b2ad14332eede441d977de08eb57fb3f61226ed5fd2ceb7aadf5afcdb6794", size = 4887513, upload-time = "2026-02-15T13:33:40.702Z" },
-    { url = "https://files.pythonhosted.org/packages/c7/2c/581e757ee57ec6046b32e0ee25660fc734bc2622c319f57119c49c0cab58/prek-0.3.3-py3-none-manylinux_2_28_aarch64.whl", hash = "sha256:c0c3ffac16e37a9daba43a7e8316778f5809b70254be138761a8b5b9ef0df28e", size = 4632336, upload-time = "2026-02-15T13:33:25.867Z" },
-    { url = "https://files.pythonhosted.org/packages/d5/d8/aa276ce5d11b77882da4102ca0cb7161095831105043ae7979bbfdcc3dc4/prek-0.3.3-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:a3dc7720b580c07c0386e17af2486a5b4bc2f6cc57034a288a614dcbc4abe555", size = 4679370, upload-time = "2026-02-15T13:33:22.247Z" },
-    { url = "https://files.pythonhosted.org/packages/70/19/9d4fa7bde428e58d9f48a74290c08736d42aeb5690dcdccc7a713e34a449/prek-0.3.3-py3-none-musllinux_1_1_armv7l.whl", hash = "sha256:60e0fa15da5020a03df2ee40268145ec5b88267ec2141a205317ad4df8c992d6", size = 4540316, upload-time = "2026-02-15T13:33:24.088Z" },
-    { url = "https://files.pythonhosted.org/packages/25/b5/973cce29257e0b47b16cc9b4c162772ea01dbb7c080791ea0c068e106e05/prek-0.3.3-py3-none-musllinux_1_1_i686.whl", hash = "sha256:553515da9586d9624dc42db32b744fdb91cf62b053753037a0cadb3c2d8d82a2", size = 4724566, upload-time = "2026-02-15T13:33:29.832Z" },
-    { url = "https://files.pythonhosted.org/packages/d6/8b/ad8b2658895a8ed2b0bc630bf38686fe38b7ff2c619c58953a80e4de3048/prek-0.3.3-py3-none-musllinux_1_1_x86_64.whl", hash = "sha256:9512cf370e0d1496503463a4a65621480efb41b487841a9e9ff1661edf14b238", size = 4995072, upload-time = "2026-02-15T13:33:27.417Z" },
+    { url = "https://files.pythonhosted.org/packages/76/69/70a5fc881290a63910494df2677c0fb241d27cfaa435bbcd0de5cd2e2443/prek-0.3.2-py3-none-linux_armv6l.whl", hash = "sha256:4f352f9c3fc98aeed4c8b2ec4dbf16fc386e45eea163c44d67e5571489bd8e6f", size = 4614960, upload-time = "2026-02-06T13:50:05.818Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/15/a82d5d32a2207ccae5d86ea9e44f2b93531ed000faf83a253e8d1108e026/prek-0.3.2-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:4a000cfbc3a6ec7d424f8be3c3e69ccd595448197f92daac8652382d0acc2593", size = 4622889, upload-time = "2026-02-06T13:49:53.662Z" },
+    { url = "https://files.pythonhosted.org/packages/89/75/ea833b58a12741397017baef9b66a6e443bfa8286ecbd645d14111446280/prek-0.3.2-py3-none-macosx_11_0_arm64.whl", hash = "sha256:5436bdc2702cbd7bcf9e355564ae66f8131211e65fefae54665a94a07c3d450a", size = 4239653, upload-time = "2026-02-06T13:50:02.88Z" },
+    { url = "https://files.pythonhosted.org/packages/10/b4/d9c3885987afac6e20df4cb7db14e3b0d5a08a77ae4916488254ebac4d0b/prek-0.3.2-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.musllinux_1_1_aarch64.whl", hash = "sha256:0161b5f584f9e7f416d6cf40a17b98f17953050ff8d8350ec60f20fe966b86b6", size = 4595101, upload-time = "2026-02-06T13:49:49.813Z" },
+    { url = "https://files.pythonhosted.org/packages/21/a6/1a06473ed83dbc898de22838abdb13954e2583ce229f857f61828384634c/prek-0.3.2-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:4e641e8533bca38797eebb49aa89ed0e8db0e61225943b27008c257e3af4d631", size = 4521978, upload-time = "2026-02-06T13:49:41.266Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/5e/c38390d5612e6d86b32151c1d2fdab74a57913473193591f0eb00c894c21/prek-0.3.2-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:cfca1810d49d3f9ef37599c958c4e716bc19a1d78a7e88cbdcb332e0b008994f", size = 4829108, upload-time = "2026-02-06T13:49:44.598Z" },
+    { url = "https://files.pythonhosted.org/packages/80/a6/cecce2ab623747ff65ed990bb0d95fa38449ee19b348234862acf9392fff/prek-0.3.2-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e5d69d754299a95a85dc20196f633232f306bee7e7c8cba61791f49ce70404ec", size = 5357520, upload-time = "2026-02-06T13:49:48.512Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/18/d6bcb29501514023c76d55d5cd03bdbc037737c8de8b6bc41cdebfb1682c/prek-0.3.2-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:539dcb90ad9b20837968539855df6a29493b328a1ae87641560768eed4f313b0", size = 4852635, upload-time = "2026-02-06T13:49:58.347Z" },
+    { url = "https://files.pythonhosted.org/packages/1b/0a/ae46f34ba27ba87aea5c9ad4ac9cd3e07e014fd5079ae079c84198f62118/prek-0.3.2-py3-none-manylinux_2_28_aarch64.whl", hash = "sha256:1998db3d0cbe243984736c82232be51318f9192e2433919a6b1c5790f600b5fd", size = 4599484, upload-time = "2026-02-06T13:49:43.296Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/a9/73bfb5b3f7c3583f9b0d431924873928705cdef6abb3d0461c37254a681b/prek-0.3.2-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:07ab237a5415a3e8c0db54de9d63899bcd947624bdd8820d26f12e65f8d19eb7", size = 4657694, upload-time = "2026-02-06T13:50:01.074Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/bc/0994bc176e1a80110fad3babce2c98b0ac4007630774c9e18fc200a34781/prek-0.3.2-py3-none-musllinux_1_1_armv7l.whl", hash = "sha256:0ced19701d69c14a08125f14a5dd03945982edf59e793c73a95caf4697a7ac30", size = 4509337, upload-time = "2026-02-06T13:49:54.891Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/13/e73f85f65ba8f626468e5d1694ab3763111513da08e0074517f40238c061/prek-0.3.2-py3-none-musllinux_1_1_i686.whl", hash = "sha256:ffb28189f976fa111e770ee94e4f298add307714568fb7d610c8a7095cb1ce59", size = 4697350, upload-time = "2026-02-06T13:50:04.526Z" },
+    { url = "https://files.pythonhosted.org/packages/14/47/98c46dcd580305b9960252a4eb966f1a7b1035c55c363f378d85662ba400/prek-0.3.2-py3-none-musllinux_1_1_x86_64.whl", hash = "sha256:f63134b3eea14421789a7335d86f99aee277cb520427196f2923b9260c60e5c5", size = 4955860, upload-time = "2026-02-06T13:49:56.581Z" },
 ]
 
 [[package]]
@@ -4631,24 +4619,24 @@ wheels = [
 
 [[package]]
 name = "ruff"
-version = "0.15.4"
+version = "0.15.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/da/31/d6e536cdebb6568ae75a7f00e4b4819ae0ad2640c3604c305a0428680b0c/ruff-0.15.4.tar.gz", hash = "sha256:3412195319e42d634470cc97aa9803d07e9d5c9223b99bcb1518f0c725f26ae1", size = 4569550, upload-time = "2026-02-26T20:04:14.959Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/c8/39/5cee96809fbca590abea6b46c6d1c586b49663d1d2830a751cc8fc42c666/ruff-0.15.0.tar.gz", hash = "sha256:6bdea47cdbea30d40f8f8d7d69c0854ba7c15420ec75a26f463290949d7f7e9a", size = 4524893, upload-time = "2026-02-03T17:53:35.357Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/f2/82/c11a03cfec3a4d26a0ea1e571f0f44be5993b923f905eeddfc397c13d360/ruff-0.15.4-py3-none-linux_armv6l.whl", hash = "sha256:a1810931c41606c686bae8b5b9a8072adac2f611bb433c0ba476acba17a332e0", size = 10453333, upload-time = "2026-02-26T20:04:20.093Z" },
-    { url = "https://files.pythonhosted.org/packages/ce/5d/6a1f271f6e31dffb31855996493641edc3eef8077b883eaf007a2f1c2976/ruff-0.15.4-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:5a1632c66672b8b4d3e1d1782859e98d6e0b4e70829530666644286600a33992", size = 10853356, upload-time = "2026-02-26T20:04:05.808Z" },
-    { url = "https://files.pythonhosted.org/packages/b1/d8/0fab9f8842b83b1a9c2bf81b85063f65e93fb512e60effa95b0be49bfc54/ruff-0.15.4-py3-none-macosx_11_0_arm64.whl", hash = "sha256:a4386ba2cd6c0f4ff75252845906acc7c7c8e1ac567b7bc3d373686ac8c222ba", size = 10187434, upload-time = "2026-02-26T20:03:54.656Z" },
-    { url = "https://files.pythonhosted.org/packages/85/cc/cc220fd9394eff5db8d94dec199eec56dd6c9f3651d8869d024867a91030/ruff-0.15.4-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b2496488bdfd3732747558b6f95ae427ff066d1fcd054daf75f5a50674411e75", size = 10535456, upload-time = "2026-02-26T20:03:52.738Z" },
-    { url = "https://files.pythonhosted.org/packages/fa/0f/bced38fa5cf24373ec767713c8e4cadc90247f3863605fb030e597878661/ruff-0.15.4-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:3f1c4893841ff2d54cbda1b2860fa3260173df5ddd7b95d370186f8a5e66a4ac", size = 10287772, upload-time = "2026-02-26T20:04:08.138Z" },
-    { url = "https://files.pythonhosted.org/packages/2b/90/58a1802d84fed15f8f281925b21ab3cecd813bde52a8ca033a4de8ab0e7a/ruff-0.15.4-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:820b8766bd65503b6c30aaa6331e8ef3a6e564f7999c844e9a547c40179e440a", size = 11049051, upload-time = "2026-02-26T20:04:03.53Z" },
-    { url = "https://files.pythonhosted.org/packages/d2/ac/b7ad36703c35f3866584564dc15f12f91cb1a26a897dc2fd13d7cb3ae1af/ruff-0.15.4-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:c9fb74bab47139c1751f900f857fa503987253c3ef89129b24ed375e72873e85", size = 11890494, upload-time = "2026-02-26T20:04:10.497Z" },
-    { url = "https://files.pythonhosted.org/packages/93/3d/3eb2f47a39a8b0da99faf9c54d3eb24720add1e886a5309d4d1be73a6380/ruff-0.15.4-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f80c98765949c518142b3a50a5db89343aa90f2c2bf7799de9986498ae6176db", size = 11326221, upload-time = "2026-02-26T20:04:12.84Z" },
-    { url = "https://files.pythonhosted.org/packages/ff/90/bf134f4c1e5243e62690e09d63c55df948a74084c8ac3e48a88468314da6/ruff-0.15.4-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:451a2e224151729b3b6c9ffb36aed9091b2996fe4bdbd11f47e27d8f2e8888ec", size = 11168459, upload-time = "2026-02-26T20:04:00.969Z" },
-    { url = "https://files.pythonhosted.org/packages/b5/e5/a64d27688789b06b5d55162aafc32059bb8c989c61a5139a36e1368285eb/ruff-0.15.4-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:a8f157f2e583c513c4f5f896163a93198297371f34c04220daf40d133fdd4f7f", size = 11104366, upload-time = "2026-02-26T20:03:48.099Z" },
-    { url = "https://files.pythonhosted.org/packages/f1/f6/32d1dcb66a2559763fc3027bdd65836cad9eb09d90f2ed6a63d8e9252b02/ruff-0.15.4-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:917cc68503357021f541e69b35361c99387cdbbf99bd0ea4aa6f28ca99ff5338", size = 10510887, upload-time = "2026-02-26T20:03:45.771Z" },
-    { url = "https://files.pythonhosted.org/packages/ff/92/22d1ced50971c5b6433aed166fcef8c9343f567a94cf2b9d9089f6aa80fe/ruff-0.15.4-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:e9737c8161da79fd7cfec19f1e35620375bd8b2a50c3e77fa3d2c16f574105cc", size = 10285939, upload-time = "2026-02-26T20:04:22.42Z" },
-    { url = "https://files.pythonhosted.org/packages/e6/f4/7c20aec3143837641a02509a4668fb146a642fd1211846634edc17eb5563/ruff-0.15.4-py3-none-musllinux_1_2_i686.whl", hash = "sha256:291258c917539e18f6ba40482fe31d6f5ac023994ee11d7bdafd716f2aab8a68", size = 10765471, upload-time = "2026-02-26T20:03:58.924Z" },
-    { url = "https://files.pythonhosted.org/packages/d0/09/6d2f7586f09a16120aebdff8f64d962d7c4348313c77ebb29c566cefc357/ruff-0.15.4-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:3f83c45911da6f2cd5936c436cf86b9f09f09165f033a99dcf7477e34041cbc3", size = 11263382, upload-time = "2026-02-26T20:04:24.424Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/88/3fd1b0aa4b6330d6aaa63a285bc96c9f71970351579152d231ed90914586/ruff-0.15.0-py3-none-linux_armv6l.whl", hash = "sha256:aac4ebaa612a82b23d45964586f24ae9bc23ca101919f5590bdb368d74ad5455", size = 10354332, upload-time = "2026-02-03T17:52:54.892Z" },
+    { url = "https://files.pythonhosted.org/packages/72/f6/62e173fbb7eb75cc29fe2576a1e20f0a46f671a2587b5f604bfb0eaf5f6f/ruff-0.15.0-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:dcd4be7cc75cfbbca24a98d04d0b9b36a270d0833241f776b788d59f4142b14d", size = 10767189, upload-time = "2026-02-03T17:53:19.778Z" },
+    { url = "https://files.pythonhosted.org/packages/99/e4/968ae17b676d1d2ff101d56dc69cf333e3a4c985e1ec23803df84fc7bf9e/ruff-0.15.0-py3-none-macosx_11_0_arm64.whl", hash = "sha256:d747e3319b2bce179c7c1eaad3d884dc0a199b5f4d5187620530adf9105268ce", size = 10075384, upload-time = "2026-02-03T17:53:29.241Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/bf/9843c6044ab9e20af879c751487e61333ca79a2c8c3058b15722386b8cae/ruff-0.15.0-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:650bd9c56ae03102c51a5e4b554d74d825ff3abe4db22b90fd32d816c2e90621", size = 10481363, upload-time = "2026-02-03T17:52:43.332Z" },
+    { url = "https://files.pythonhosted.org/packages/55/d9/4ada5ccf4cd1f532db1c8d44b6f664f2208d3d93acbeec18f82315e15193/ruff-0.15.0-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:a6664b7eac559e3048223a2da77769c2f92b43a6dfd4720cef42654299a599c9", size = 10187736, upload-time = "2026-02-03T17:53:00.522Z" },
+    { url = "https://files.pythonhosted.org/packages/86/e2/f25eaecd446af7bb132af0a1d5b135a62971a41f5366ff41d06d25e77a91/ruff-0.15.0-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:6f811f97b0f092b35320d1556f3353bf238763420ade5d9e62ebd2b73f2ff179", size = 10968415, upload-time = "2026-02-03T17:53:15.705Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/dc/f06a8558d06333bf79b497d29a50c3a673d9251214e0d7ec78f90b30aa79/ruff-0.15.0-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:761ec0a66680fab6454236635a39abaf14198818c8cdf691e036f4bc0f406b2d", size = 11809643, upload-time = "2026-02-03T17:53:23.031Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/45/0ece8db2c474ad7df13af3a6d50f76e22a09d078af63078f005057ca59eb/ruff-0.15.0-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:940f11c2604d317e797b289f4f9f3fa5555ffe4fb574b55ed006c3d9b6f0eb78", size = 11234787, upload-time = "2026-02-03T17:52:46.432Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/d9/0e3a81467a120fd265658d127db648e4d3acfe3e4f6f5d4ea79fac47e587/ruff-0.15.0-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bcbca3d40558789126da91d7ef9a7c87772ee107033db7191edefa34e2c7f1b4", size = 11112797, upload-time = "2026-02-03T17:52:49.274Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/cb/8c0b3b0c692683f8ff31351dfb6241047fa873a4481a76df4335a8bff716/ruff-0.15.0-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:9a121a96db1d75fa3eb39c4539e607f628920dd72ff1f7c5ee4f1b768ac62d6e", size = 11033133, upload-time = "2026-02-03T17:53:33.105Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/5e/23b87370cf0f9081a8c89a753e69a4e8778805b8802ccfe175cc410e50b9/ruff-0.15.0-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:5298d518e493061f2eabd4abd067c7e4fb89e2f63291c94332e35631c07c3662", size = 10442646, upload-time = "2026-02-03T17:53:06.278Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/9a/3c94de5ce642830167e6d00b5c75aacd73e6347b4c7fc6828699b150a5ee/ruff-0.15.0-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:afb6e603d6375ff0d6b0cee563fa21ab570fd15e65c852cb24922cef25050cf1", size = 10195750, upload-time = "2026-02-03T17:53:26.084Z" },
+    { url = "https://files.pythonhosted.org/packages/30/15/e396325080d600b436acc970848d69df9c13977942fb62bb8722d729bee8/ruff-0.15.0-py3-none-musllinux_1_2_i686.whl", hash = "sha256:77e515f6b15f828b94dc17d2b4ace334c9ddb7d9468c54b2f9ed2b9c1593ef16", size = 10676120, upload-time = "2026-02-03T17:53:09.363Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/c9/229a23d52a2983de1ad0fb0ee37d36e0257e6f28bfd6b498ee2c76361874/ruff-0.15.0-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:6f6e80850a01eb13b3e42ee0ebdf6e4497151b48c35051aab51c101266d187a3", size = 11201636, upload-time = "2026-02-03T17:52:57.281Z" },
 ]
 
 [[package]]
@@ -4839,7 +4827,7 @@ wheels = [
 
 [[package]]
 name = "sentence-transformers"
-version = "5.2.3"
+version = "5.2.2"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "huggingface-hub", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
@@ -4854,9 +4842,9 @@ dependencies = [
     { name = "transformers", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
     { name = "typing-extensions", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/5b/30/21664028fc0776eb1ca024879480bbbab36f02923a8ff9e4cae5a150fa35/sentence_transformers-5.2.3.tar.gz", hash = "sha256:3cd3044e1f3fe859b6a1b66336aac502eaae5d3dd7d5c8fc237f37fbf58137c7", size = 381623, upload-time = "2026-02-17T14:05:20.238Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a6/bc/0bc9c0ec1cf83ab2ec6e6f38667d167349b950fff6dd2086b79bd360eeca/sentence_transformers-5.2.2.tar.gz", hash = "sha256:7033ee0a24bc04c664fd490abf2ef194d387b3a58a97adcc528783ff505159fa", size = 381607, upload-time = "2026-01-27T11:11:02.658Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/46/9f/dba4b3e18ebbe1eaa29d9f1764fbc7da0cd91937b83f2b7928d15c5d2d36/sentence_transformers-5.2.3-py3-none-any.whl", hash = "sha256:6437c62d4112b615ddebda362dfc16a4308d604c5b68125ed586e3e95d5b2e30", size = 494225, upload-time = "2026-02-17T14:05:18.596Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/21/7e925890636791386e81b52878134f114d63072e79fffe14cdcc5e7a5e6a/sentence_transformers-5.2.2-py3-none-any.whl", hash = "sha256:280ac54bffb84c110726b4d8848ba7b7c60813b9034547f8aea6e9a345cd1c23", size = 494106, upload-time = "2026-01-27T11:11:00.983Z" },
 ]
 
 [[package]]
@@ -5145,15 +5133,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/ab/0d/c1ad6f4016a3968c048545f5d9b8ffebf577774b2ede3e2e352553b685fe/tiktoken-0.12.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:5edb8743b88d5be814b1a8a8854494719080c28faaa1ccbef02e87354fe71ef0", size = 1253706, upload-time = "2025-10-06T20:22:33.385Z" },
 ]
 
-[[package]]
-name = "tinytag"
-version = "2.2.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/98/07/fb260bac73119f369a10e884016516d07cd760b5068e703773f83dd5e7bf/tinytag-2.2.0.tar.gz", hash = "sha256:f15b082510f6e0fc717e597edc8759d6f2d3ff6194ac0f3bcd675a9a09d9b798", size = 38120, upload-time = "2025-12-15T21:10:19.093Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/b1/e2/9818fcebb348237389d2ac2fea97cf2b2638378a0866105a45ae9be49728/tinytag-2.2.0-py3-none-any.whl", hash = "sha256:d2cf3ef8ee0f6c854663f77d9d5f8159ee1c834c70f5ea4f214ddc4af8148f79", size = 32861, upload-time = "2025-12-15T21:10:17.63Z" },
-]
-
 [[package]]
 name = "tokenizers"
 version = "0.22.2"
@@ -5502,11 +5481,11 @@ wheels = [
 
 [[package]]
 name = "types-markdown"
-version = "3.10.2.20260211"
+version = "3.10.0.20251106"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/6d/2e/35b30a09f6ee8a69142408d3ceb248c4454aa638c0a414d8704a3ef79563/types_markdown-3.10.2.20260211.tar.gz", hash = "sha256:66164310f88c11a58c6c706094c6f8c537c418e3525d33b76276a5fbd66b01ce", size = 19768, upload-time = "2026-02-11T04:19:29.497Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/de/e4/060f0dadd9b551cae77d6407f2bc84b168f918d90650454aff219c1b3ed2/types_markdown-3.10.0.20251106.tar.gz", hash = "sha256:12836f7fcbd7221db8baeb0d3a2f820b95050d0824bfa9665c67b4d144a1afa1", size = 19486, upload-time = "2025-11-06T03:06:44.317Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/54/c9/659fa2df04b232b0bfcd05d2418e683080e91ec68f636f3c0a5a267350e7/types_markdown-3.10.2.20260211-py3-none-any.whl", hash = "sha256:2d94d08587e3738203b3c4479c449845112b171abe8b5cadc9b0c12fcf3e99da", size = 25854, upload-time = "2026-02-11T04:19:28.647Z" },
+    { url = "https://files.pythonhosted.org/packages/92/58/f666ca9391f2a8bd33bb0b0797cde6ac3e764866708d5f8aec6fab215320/types_markdown-3.10.0.20251106-py3-none-any.whl", hash = "sha256:2c39512a573899b59efae07e247ba088a75b70e3415e81277692718f430afd7e", size = 25862, upload-time = "2025-11-06T03:06:43.082Z" },
 ]
 
 [[package]]
@@ -5595,6 +5574,18 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/2b/7f/016dc5cc718ec6ccaa84fb73ed409ef1c261793fd5e637cdfaa18beb40a9/types_setuptools-80.10.0.20260124-py3-none-any.whl", hash = "sha256:efed7e044f01adb9c2806c7a8e1b6aa3656b8e382379b53d5f26ee3db24d4c01", size = 64333, upload-time = "2026-01-24T03:18:38.344Z" },
 ]
 
+[[package]]
+name = "types-tqdm"
+version = "4.67.3.20260205"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "types-requests", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/53/46/790b9872523a48163bdda87d47849b4466017640e5259d06eed539340afd/types_tqdm-4.67.3.20260205.tar.gz", hash = "sha256:f3023682d4aa3bbbf908c8c6bb35f35692d319460d9bbd3e646e8852f3dd9f85", size = 17597, upload-time = "2026-02-05T04:03:19.721Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/cc/da/7f761868dbaa328392356fab30c18ab90d14cce86b269e7e63328f29d4a3/types_tqdm-4.67.3.20260205-py3-none-any.whl", hash = "sha256:85c31731e81dc3c5cecc34c6c8b2e5166fafa722468f58840c2b5ac6a8c5c173", size = 23894, upload-time = "2026-02-05T04:03:18.48Z" },
+]
+
 [[package]]
 name = "types-webencodings"
 version = "0.5.0.20251108"
@@ -6104,7 +6095,7 @@ wheels = [
 
 [[package]]
 name = "zensical"
-version = "0.0.24"
+version = "0.0.21"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "click", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
@@ -6115,18 +6106,18 @@ dependencies = [
     { name = "pyyaml", marker = "sys_platform == 'darwin' or sys_platform == 'linux'" },
     { name = "tomli", marker = "(python_full_version < '3.11' and sys_platform == 'darwin') or (python_full_version < '3.11' and sys_platform == 'linux')" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/3b/96/9c6cbdd7b351d1023cdbbcf7872d4cb118b0334cfe5821b99e0dd18e3f00/zensical-0.0.24.tar.gz", hash = "sha256:b5d99e225329bf4f98c8022bdf0a0ee9588c2fada7b4df1b7b896fcc62b37ec3", size = 3840688, upload-time = "2026-02-26T09:43:44.557Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/8a/50/2655b5f72d0c72f4366be580f5e2354ff05280d047ea986fe89570e44589/zensical-0.0.21.tar.gz", hash = "sha256:c13563836fa63a3cabeffd83fe3a770ca740cfa5ae7b85df85d89837e31b3b4a", size = 3819731, upload-time = "2026-02-04T17:47:59.396Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/8e/aa/b8201af30e376a67566f044a1c56210edac5ae923fd986a836d2cf593c9c/zensical-0.0.24-cp310-abi3-macosx_10_12_x86_64.whl", hash = "sha256:d390c5453a5541ca35d4f9e1796df942b6612c546e3153dd928236d3b758409a", size = 12263407, upload-time = "2026-02-26T09:43:14.716Z" },
-    { url = "https://files.pythonhosted.org/packages/78/8e/3d910214471ade604fd39b080db3696864acc23678b5b4b8475c7dbfd2ce/zensical-0.0.24-cp310-abi3-macosx_11_0_arm64.whl", hash = "sha256:81ac072869cf4d280853765b2bfb688653da0dfb9408f3ab15aca96455ab8223", size = 12142610, upload-time = "2026-02-26T09:43:17.546Z" },
-    { url = "https://files.pythonhosted.org/packages/cf/d7/eb0983640aa0419ddf670298cfbcf8b75629b6484925429b857851e00784/zensical-0.0.24-cp310-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b5eb1dfa84cae8e960bfa2c6851d2bc8e9710c4c4c683bd3aaf23185f646ae46", size = 12508380, upload-time = "2026-02-26T09:43:20.114Z" },
-    { url = "https://files.pythonhosted.org/packages/a3/04/4405b9e6f937a75db19f0d875798a7eb70817d6a3bec2a2d289a2d5e8aea/zensical-0.0.24-cp310-abi3-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:57d7c9e589da99c1879a1c703e67c85eaa6be4661cdc6ce6534f7bb3575983f4", size = 12440807, upload-time = "2026-02-26T09:43:22.679Z" },
-    { url = "https://files.pythonhosted.org/packages/12/dc/a7ca2a4224b3072a2c2998b6611ad7fd4f8f131ceae7aa23238d97d26e22/zensical-0.0.24-cp310-abi3-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:42fcc121c3095734b078a95a0dae4d4924fb8fbf16bf730456146ad6cab48ad0", size = 12782727, upload-time = "2026-02-26T09:43:25.347Z" },
-    { url = "https://files.pythonhosted.org/packages/42/37/22f1727da356ed3fcbd31f68d4a477f15c232997c87e270cfffb927459ac/zensical-0.0.24-cp310-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:832d4a2a051b9f49561031a2986ace502326f82d9a401ddf125530d30025fdd4", size = 12547616, upload-time = "2026-02-26T09:43:28.031Z" },
-    { url = "https://files.pythonhosted.org/packages/6d/ff/c75ff111b8e12157901d00752beef9d691dbb5a034b6a77359972262416a/zensical-0.0.24-cp310-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:e5fea3bb61238dba9f930f52669db67b0c26be98e1c8386a05eb2b1e3cb875dc", size = 12684883, upload-time = "2026-02-26T09:43:30.642Z" },
-    { url = "https://files.pythonhosted.org/packages/b9/92/4f6ea066382e3d068d3cadbed99e9a71af25e46c84a403e0f747960472a2/zensical-0.0.24-cp310-abi3-musllinux_1_2_armv7l.whl", hash = "sha256:75eef0428eec2958590633fdc82dc2a58af124879e29573aa7e153b662978073", size = 12713825, upload-time = "2026-02-26T09:43:33.273Z" },
-    { url = "https://files.pythonhosted.org/packages/bc/fb/bf735b19bce0034b1f3b8e1c50b2896ebbd0c5d92d462777e759e78bb083/zensical-0.0.24-cp310-abi3-musllinux_1_2_i686.whl", hash = "sha256:3c6b39659156394ff805b4831dac108c839483d9efa4c9b901eaa913efee1ac7", size = 12854318, upload-time = "2026-02-26T09:43:35.632Z" },
-    { url = "https://files.pythonhosted.org/packages/7e/28/0ddab6c1237e3625e7763ff666806f31e5760bb36d18624135a6bb6e8643/zensical-0.0.24-cp310-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:9eef82865a18b3ca4c3cd13e245dff09a865d1da3c861e2fc86eaa9253a90f02", size = 12818270, upload-time = "2026-02-26T09:43:37.749Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/98/90710d232cb35b633815fa7b493da542391b89283b6103a5bb4ae9fc0dd9/zensical-0.0.21-cp310-abi3-macosx_10_12_x86_64.whl", hash = "sha256:67404cc70c330246dfb7269bcdb60a25be0bb60a212a09c9c50229a1341b1f84", size = 12237120, upload-time = "2026-02-04T17:47:28.615Z" },
+    { url = "https://files.pythonhosted.org/packages/97/fb/4280b3781157e8f051711732192f949bf29beeafd0df3e33c1c8bf9b7a1a/zensical-0.0.21-cp310-abi3-macosx_11_0_arm64.whl", hash = "sha256:d4fd253ccfbf5af56434124f13bac01344e456c020148369b18d8836b6537c3c", size = 12118047, upload-time = "2026-02-04T17:47:31.369Z" },
+    { url = "https://files.pythonhosted.org/packages/74/b3/b7f85ae9cf920cf9f17bf157ae6c274919477148feb7716bf735636caa0e/zensical-0.0.21-cp310-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:440e40cdc30a29bf7466bcd6f43ed7bd1c54ea3f1a0fefca65619358b481a5bc", size = 12473440, upload-time = "2026-02-04T17:47:33.577Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/ac/1dc6e98f79ed19b9f103c88a0bd271f9140565d7d26b64bc1542b3ef6d91/zensical-0.0.21-cp310-abi3-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:368e832fc8068e75dc45cab59379db4cefcd81eb116f48d058db8fb7b7aa8d14", size = 12412588, upload-time = "2026-02-04T17:47:36.491Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/76/16a580f6dd32b387caa4a41615451e7dddd1917a2ff2e5b08744f41b4e11/zensical-0.0.21-cp310-abi3-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f4ab962d47f9dd73510eed168469326c7a452554dfbfdb9cdf85efc7140244df", size = 12749438, upload-time = "2026-02-04T17:47:38.969Z" },
+    { url = "https://files.pythonhosted.org/packages/95/30/4baaa1c910eee61db5f49d0d45f2e550a0027218c618f3dd7f8da966a019/zensical-0.0.21-cp310-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b846d53dfce007f056ff31848f87f3f2a388228e24d4851c0cafdce0fa204c9b", size = 12514504, upload-time = "2026-02-04T17:47:41.31Z" },
+    { url = "https://files.pythonhosted.org/packages/76/77/931fccae5580b94409a0448a26106f922dcfa7822e7b93cacd2876dd63a8/zensical-0.0.21-cp310-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:daac1075552d230d52d621d2e4754ba24d5afcaa201a7a991f1a8d57e320c9de", size = 12647832, upload-time = "2026-02-04T17:47:44.073Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/82/3cf75de64340829d55c87c36704f4d1d8c952bd2cdc8a7bc48cbfb8ab333/zensical-0.0.21-cp310-abi3-musllinux_1_2_armv7l.whl", hash = "sha256:7b380f545adb6d40896f9bd698eb0e1540ed4258d35b83f55f91658d0fdae312", size = 12678537, upload-time = "2026-02-04T17:47:46.899Z" },
+    { url = "https://files.pythonhosted.org/packages/77/91/6f4938dceeaa241f78bbfaf58a94acef10ba18be3468795173e3087abeb6/zensical-0.0.21-cp310-abi3-musllinux_1_2_i686.whl", hash = "sha256:5c2227fdab64616bea94b40b8340bafe00e2e23631cc58eeea1e7267167e6ac5", size = 12822164, upload-time = "2026-02-04T17:47:49.231Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/4e/a9c9d25ef0766f767db7b4f09da68da9b3d8a28c3d68cfae01f8e3f9e297/zensical-0.0.21-cp310-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:2e0f5154d236ed0f98662ee68785b67e8cd2138ea9d5e26070649e93c22eeee0", size = 12785632, upload-time = "2026-02-04T17:47:52.613Z" },
 ]
 
 [[package]]

zensical.toml

@@ -18,10 +18,7 @@ nav = [
   "setup.md",
   "usage.md",
   "configuration.md",
-  { Administration = [
-    "administration.md",
-    { "v3 Migration Guide" = "migration-v3.md" },
-  ] },
+  "administration.md",
   "advanced_usage.md",
   "api.md",
   "development.md",