Handles a bad client sending malformed JSON or non-int primary keys

Perf: avoid per-instance CustomField reload in DocumentMetadataOverrides
send_websocket_document_updated calls document.refresh_from_db() before building overrides, which drops the custom_fields prefetch (and its select_related("field")) set up by the view's queryset. DocumentMetadataOverrides.from_document() then lazily reloads field once per custom field instance. Since from_document() can't rely on the caller having a prefetched document, select_related explicitly at the point of use instead.
2026-08-27 21:23:20 +00:00 · 2026-08-27 09:42:39 -07:00 · 2026-08-27 09:42:39 -07:00 · 2026-08-27 09:42:39 -07:00 · 2026-08-27 09:42:39 -07:00
55 changed files with 495 additions and 317 deletions
@@ -186,110 +186,29 @@ line-ending = "lf"
 # https://docs.astral.sh/ruff/rules/
 select = [ "E4", "E7", "E9", "F" ]
 extend-select = [
-  "ASYNC",   # https://docs.astral.sh/ruff/rules/#flake8-async-async
-  "B002",    # https://docs.astral.sh/ruff/rules/#flake8-bugbear-b
-  "B003",    # https://docs.astral.sh/ruff/rules/#flake8-bugbear-b
-  "B004",    # https://docs.astral.sh/ruff/rules/#flake8-bugbear-b
-  "B005",    # https://docs.astral.sh/ruff/rules/#flake8-bugbear-b
-  "B006",    # https://docs.astral.sh/ruff/rules/#flake8-bugbear-b
-  "B008",    # https://docs.astral.sh/ruff/rules/#flake8-bugbear-b
-  "B009",    # https://docs.astral.sh/ruff/rules/#flake8-bugbear-b
-  "B010",    # https://docs.astral.sh/ruff/rules/#flake8-bugbear-b
-  "B012",    # https://docs.astral.sh/ruff/rules/#flake8-bugbear-b
-  "B013",    # https://docs.astral.sh/ruff/rules/#flake8-bugbear-b
-  "B014",    # https://docs.astral.sh/ruff/rules/#flake8-bugbear-b
-  "B015",    # https://docs.astral.sh/ruff/rules/#flake8-bugbear-b
-  "B016",    # https://docs.astral.sh/ruff/rules/#flake8-bugbear-b
-  "B017",    # https://docs.astral.sh/ruff/rules/#flake8-bugbear-b
-  "B018",    # https://docs.astral.sh/ruff/rules/#flake8-bugbear-b
-  "B019",    # https://docs.astral.sh/ruff/rules/#flake8-bugbear-b
-  "B020",    # https://docs.astral.sh/ruff/rules/#flake8-bugbear-b
-  "B021",    # https://docs.astral.sh/ruff/rules/#flake8-bugbear-b
-  "B022",    # https://docs.astral.sh/ruff/rules/#flake8-bugbear-b
-  "B023",    # https://docs.astral.sh/ruff/rules/#flake8-bugbear-b
-  "B025",    # https://docs.astral.sh/ruff/rules/#flake8-bugbear-b
-  "B026",    # https://docs.astral.sh/ruff/rules/#flake8-bugbear-b
-  "B029",    # https://docs.astral.sh/ruff/rules/#flake8-bugbear-b
-  "B030",    # https://docs.astral.sh/ruff/rules/#flake8-bugbear-b
-  "B031",    # https://docs.astral.sh/ruff/rules/#flake8-bugbear-b
-  "B032",    # https://docs.astral.sh/ruff/rules/#flake8-bugbear-b
-  "B033",    # https://docs.astral.sh/ruff/rules/#flake8-bugbear-b
-  "B035",    # https://docs.astral.sh/ruff/rules/#flake8-bugbear-b
-  "B039",    # https://docs.astral.sh/ruff/rules/#flake8-bugbear-b
-  "C4",      # https://docs.astral.sh/ruff/rules/#flake8-comprehensions-c4
-  "COM",     # https://docs.astral.sh/ruff/rules/#flake8-commas-com
-  "D419",    # https://docs.astral.sh/ruff/rules/#pydocstyle-d
-  "DJ",      # https://docs.astral.sh/ruff/rules/#flake8-django-dj
-  "DTZ",     # https://docs.astral.sh/ruff/rules/#flake8-datetimez-dtz
-  "EXE",     # https://docs.astral.sh/ruff/rules/#flake8-executable-exe
-  "FA",      # https://docs.astral.sh/ruff/rules/#flake8-future-annotations-fa
-  "FBT",     # https://docs.astral.sh/ruff/rules/#flake8-boolean-trap-fbt
-  "FLY",     # https://docs.astral.sh/ruff/rules/#flynt-fly
-  "FURB",    # https://docs.astral.sh/ruff/rules/#refurb-furb
-  "G010",    # https://docs.astral.sh/ruff/rules/#flake8-logging-format-g
-  "G101",    # https://docs.astral.sh/ruff/rules/#flake8-logging-format-g
-  "G201",    # https://docs.astral.sh/ruff/rules/#flake8-logging-format-g
-  "G202",    # https://docs.astral.sh/ruff/rules/#flake8-logging-format-g
-  "I",       # https://docs.astral.sh/ruff/rules/#isort-i
-  "ICN",     # https://docs.astral.sh/ruff/rules/#flake8-import-conventions-icn
-  "INP",     # https://docs.astral.sh/ruff/rules/#flake8-no-pep420-inp
-  "INT001",  # https://docs.astral.sh/ruff/rules/#flake8-gettext-int
-  "INT002",  # https://docs.astral.sh/ruff/rules/#flake8-gettext-int
-  "INT003",  # https://docs.astral.sh/ruff/rules/#flake8-gettext-int
-  "ISC",     # https://docs.astral.sh/ruff/rules/#flake8-implicit-str-concat-isc
-  "LOG001",  # https://docs.astral.sh/ruff/rules/#flake8-logging-log
-  "LOG002",  # https://docs.astral.sh/ruff/rules/#flake8-logging-log
-  "LOG009",  # https://docs.astral.sh/ruff/rules/#flake8-logging-log
-  "LOG014",  # https://docs.astral.sh/ruff/rules/#flake8-logging-log
-  "LOG015",  # https://docs.astral.sh/ruff/rules/#flake8-logging-log
-  "N999",    # https://docs.astral.sh/ruff/rules/#pep8-naming-n
-  "PERF101", # https://docs.astral.sh/ruff/rules/#perflint-perf
-  "PERF102", # https://docs.astral.sh/ruff/rules/#perflint-perf
-  "PERF402", # https://docs.astral.sh/ruff/rules/#perflint-perf
-  "PGH005",  # https://docs.astral.sh/ruff/rules/#pygrep-hooks-pgh
-  "PIE",     # https://docs.astral.sh/ruff/rules/#flake8-pie-pie
-  "PLC",     # https://docs.astral.sh/ruff/rules/#pylint-pl
-  "PLE",     # https://docs.astral.sh/ruff/rules/#pylint-pl
-  "PLR0124", # https://docs.astral.sh/ruff/rules/#pylint-pl
-  "PLR0133", # https://docs.astral.sh/ruff/rules/#pylint-pl
-  "PLR0206", # https://docs.astral.sh/ruff/rules/#pylint-pl
-  "PLR0402", # https://docs.astral.sh/ruff/rules/#pylint-pl
-  "PLR1704", # https://docs.astral.sh/ruff/rules/#pylint-pl
-  "PLR1708", # https://docs.astral.sh/ruff/rules/#pylint-pl
-  "PLR1711", # https://docs.astral.sh/ruff/rules/#pylint-pl
-  "PLR1716", # https://docs.astral.sh/ruff/rules/#pylint-pl
-  "PLR1722", # https://docs.astral.sh/ruff/rules/#pylint-pl
-  "PLR1730", # https://docs.astral.sh/ruff/rules/#pylint-pl
-  "PLR1733", # https://docs.astral.sh/ruff/rules/#pylint-pl
-  "PLR1736", # https://docs.astral.sh/ruff/rules/#pylint-pl
-  "PLR2044", # https://docs.astral.sh/ruff/rules/#pylint-pl
-  "PLW",     # https://docs.astral.sh/ruff/rules/#pylint-pl
-  "PT010",   # https://docs.astral.sh/ruff/rules/#flake8-pytest-style-pt
-  "PT014",   # https://docs.astral.sh/ruff/rules/#flake8-pytest-style-pt
-  "PT020",   # https://docs.astral.sh/ruff/rules/#flake8-pytest-style-pt
-  "PT025",   # https://docs.astral.sh/ruff/rules/#flake8-pytest-style-pt
-  "PT026",   # https://docs.astral.sh/ruff/rules/#flake8-pytest-style-pt
-  "PT031",   # https://docs.astral.sh/ruff/rules/#flake8-pytest-style-pt
-  "PTH",     # https://docs.astral.sh/ruff/rules/#flake8-use-pathlib-pth
-  "Q",       # https://docs.astral.sh/ruff/rules/#flake8-quotes-q
-  "RSE",     # https://docs.astral.sh/ruff/rules/#flake8-raise-rse
-  "RUF",     # https://docs.astral.sh/ruff/rules/#ruff-specific-rules-ruf
-  "S102",    # https://docs.astral.sh/ruff/rules/#flake8-bandit-s
-  "S110",    # https://docs.astral.sh/ruff/rules/#flake8-bandit-s
-  "S112",    # https://docs.astral.sh/ruff/rules/#flake8-bandit-s
-  "SIM",     # https://docs.astral.sh/ruff/rules/#flake8-simplify-sim
-  "T100",    # https://docs.astral.sh/ruff/rules/#flake8-debugger-t10
-  "T20",     # https://docs.astral.sh/ruff/rules/#flake8-print-t20
-  "TC",      # https://docs.astral.sh/ruff/rules/#flake8-type-checking-tc
-  "TID",     # https://docs.astral.sh/ruff/rules/#flake8-tidy-imports-tid
-  "TRY002",  # https://docs.astral.sh/ruff/rules/#tryceratops-try
-  "TRY004",  # https://docs.astral.sh/ruff/rules/#tryceratops-try
-  "TRY201",  # https://docs.astral.sh/ruff/rules/#tryceratops-try
-  "TRY203",  # https://docs.astral.sh/ruff/rules/#tryceratops-try
-  "TRY401",  # https://docs.astral.sh/ruff/rules/#tryceratops-try
-  "UP",      # https://docs.astral.sh/ruff/rules/#pyupgrade-up
-  "W",       # https://docs.astral.sh/ruff/rules/#pycodestyle-e-w
-  "YTT",     # https://docs.astral.sh/ruff/rules/#flake8-2020-ytt
+  "COM",  # https://docs.astral.sh/ruff/rules/#flake8-commas-com
+  "DJ",   # https://docs.astral.sh/ruff/rules/#flake8-django-dj
+  "EXE",  # https://docs.astral.sh/ruff/rules/#flake8-executable-exe
+  "FBT",  # https://docs.astral.sh/ruff/rules/#flake8-boolean-trap-fbt
+  "FLY",  # https://docs.astral.sh/ruff/rules/#flynt-fly
+  "G201", # https://docs.astral.sh/ruff/rules/#flake8-logging-format-g
+  "I",    # https://docs.astral.sh/ruff/rules/#isort-i
+  "ICN",  # https://docs.astral.sh/ruff/rules/#flake8-import-conventions-icn
+  "INP",  # https://docs.astral.sh/ruff/rules/#flake8-no-pep420-inp
+  "ISC",  # https://docs.astral.sh/ruff/rules/#flake8-implicit-str-concat-isc
+  "PIE",  # https://docs.astral.sh/ruff/rules/#flake8-pie-pie
+  "PLC",  # https://docs.astral.sh/ruff/rules/#pylint-pl
+  "PLE",  # https://docs.astral.sh/ruff/rules/#pylint-pl
+  "PTH",  # https://docs.astral.sh/ruff/rules/#flake8-use-pathlib-pth
+  "Q",    # https://docs.astral.sh/ruff/rules/#flake8-quotes-q
+  "RSE",  # https://docs.astral.sh/ruff/rules/#flake8-raise-rse
+  "RUF",  # https://docs.astral.sh/ruff/rules/#ruff-specific-rules-ruf
+  "SIM",  # https://docs.astral.sh/ruff/rules/#flake8-simplify-sim
+  "T20",  # https://docs.astral.sh/ruff/rules/#flake8-print-t20
+  "TC",   # https://docs.astral.sh/ruff/rules/#flake8-type-checking-tc
+  "TID",  # https://docs.astral.sh/ruff/rules/#flake8-tidy-imports-tid
+  "UP",   # https://docs.astral.sh/ruff/rules/#pyupgrade-up
+  "W",    # https://docs.astral.sh/ruff/rules/#pycodestyle-e-w
 ]
 ignore = [
  "DJ001",
@@ -305,7 +224,6 @@ per-file-ignores."*/migrations/*.py" = [
 ]
 # Testing
 per-file-ignores."*/tests/*.py" = [
-  "DTZ",
  "E501",
  "SIM117",
 ]
@@ -507,8 +507,8 @@ def rotate(
            logger.info(
                f"Queued new rotated version for document {pair.root_doc.id} by {degrees} degrees",
            )
-        except Exception:
-            logger.exception(f"Error rotating document {pair.root_doc.id}")
+        except Exception as e:
+            logger.exception(f"Error rotating document {pair.root_doc.id}: {e}")

    return "OK"

@@ -554,9 +554,9 @@ def merge(
            affected_docs.append(doc.id)
            if handoff_asn is None and doc.archive_serial_number is not None:
                handoff_asn = doc.archive_serial_number
-        except Exception:
+        except Exception as e:
            logger.exception(
-                f"Error merging document {doc.id}, it will not be included in the merge",
+                f"Error merging document {doc.id}, it will not be included in the merge: {e}",
            )
    if len(affected_docs) == 0:
        logger.warning("No documents were merged")
@@ -805,8 +805,8 @@ def split(
            else:
                group(consume_tasks).delay()

-    except Exception:
-        logger.exception(f"Error splitting document {doc.id}")
+    except Exception as e:
+        logger.exception(f"Error splitting document {doc.id}: {e}")

    return "OK"

@@ -858,8 +858,8 @@ def delete_pages(
        logger.info(
            f"Queued new version for document {pair.root_doc.id} after deleting pages {pages}",
        )
-    except Exception:
-        logger.exception(f"Error deleting pages from document {pair.root_doc.id}")
+    except Exception as e:
+        logger.exception(f"Error deleting pages from document {pair.root_doc.id}: {e}")

    return "OK"

@@ -986,7 +986,7 @@ def edit_pdf(
                group(consume_tasks).delay()

    except Exception as e:
-        logger.exception(f"Error editing document {pair.root_doc.id}")
+        logger.exception(f"Error editing document {pair.root_doc.id}: {e}")
        raise ValueError(
            f"An error occurred while editing the document: {e}",
        ) from e
@@ -1097,7 +1097,7 @@ def remove_password(

        except Exception as e:
            logger.exception(
-                f"Error removing password from document {pair.root_doc.id}",
+                f"Error removing password from document {pair.root_doc.id}: {e}",
            )
            raise ValueError(
                f"An error occurred while removing the password: {e}",
@@ -69,8 +69,8 @@ def load_classifier(*, raise_exception: bool = False) -> DocumentClassifier | No
        Path(settings.MODEL_FILE).unlink()
        classifier = None
        if raise_exception:
-            raise
-    except ClassifierModelCorruptError:
+            raise e
+    except ClassifierModelCorruptError as e:
        # there's something wrong with the model file.
        logger.exception(
            "Unrecoverable error while loading document "
@@ -79,17 +79,17 @@ def load_classifier(*, raise_exception: bool = False) -> DocumentClassifier | No
        Path(settings.MODEL_FILE).unlink()
        classifier = None
        if raise_exception:
-            raise
-    except OSError:
+            raise e
+    except OSError as e:
        logger.exception("IO error while loading document classification model")
        classifier = None
        if raise_exception:
-            raise
-    except Exception:  # pragma: no cover
+            raise e
+    except Exception as e:  # pragma: no cover
        logger.exception("Unknown error while loading document classification model")
        classifier = None
        if raise_exception:
-            raise
+            raise e

    return classifier

@@ -216,7 +216,7 @@ class ConsumerPluginMixin:
            current_progress,
            max_progress,
            document_id=document_id,
-            owner_id=self.metadata.owner_id or None,
+            owner_id=self.metadata.owner_id if self.metadata.owner_id else None,
            users_can_view=(self.metadata.view_users or [])
            + (self.metadata.change_users or []),
            groups_can_view=(self.metadata.view_groups or [])
@@ -674,7 +674,9 @@ class ConsumerPlugin(
                            document=document,
                            logging_group=self.logging_group,
                            classifier=classifier,
-                            original_file=self.unmodified_original or self.working_copy,
+                            original_file=self.unmodified_original
+                            if self.unmodified_original
+                            else self.working_copy,
                        )

                        # After everything is in the database, copy the files into
@@ -847,7 +849,7 @@ class ConsumerPlugin(
        else:
            stats = Path(self.input_doc.original_file).stat()
            create_date = timezone.make_aware(
-                datetime.datetime.fromtimestamp(stats.st_mtime),  # noqa: DTZ006 - make_aware() requires a naive datetime
+                datetime.datetime.fromtimestamp(stats.st_mtime),
            )
            self.log.debug(f"Creation date from st_mtime: {create_date}")

@@ -961,7 +963,7 @@ class ConsumerPlugin(
        try:
            copy_basic_file_stats(source, target)
        except Exception:  # pragma: no cover
-            self.log.debug("Unable to copy file stats from %s to %s", source, target)
+            pass


 class ConsumerPreflightPlugin(
@@ -129,7 +129,7 @@ class DocumentMetadataOverrides:
        )
        overrides.custom_fields = {
            custom_field.field.id: custom_field.value
-            for custom_field in doc.custom_fields.all()
+            for custom_field in doc.custom_fields.select_related("field").all()
        }

        groups_with_perms = get_groups_with_perms(
@@ -78,9 +78,7 @@ class CollatePlugin(NoCleanupPluginMixin, NoSetupPluginMixin, ConsumeTaskPlugin)
            stats = staging.stat()
            # if the file is older than the timeout, we don't consider
            # it valid
-            if (
-                dt.datetime.now(tz=dt.UTC).timestamp() - stats.st_mtime
-            ) > TIMEOUT_SECONDS:
+            if (dt.datetime.now().timestamp() - stats.st_mtime) > TIMEOUT_SECONDS:
                logger.warning("Outdated double sided staging file exists, deleting it")
                staging.unlink()
            else:
@@ -136,7 +134,7 @@ class CollatePlugin(NoCleanupPluginMixin, NoSetupPluginMixin, ConsumeTaskPlugin)
            shutil.move(pdf_file, staging)
            # update access to modification time so we know if the file
            # is outdated when another file gets uploaded
-            timestamp = dt.datetime.now(tz=dt.UTC).timestamp()
+            timestamp = dt.datetime.now().timestamp()
            os.utime(staging, (timestamp, timestamp))
            logger.info(
                "Got scan with odd numbered pages of double-sided scan, moved it to %s",
@@ -734,7 +734,7 @@ class CustomFieldQueryParser:
        )

        # Check if any of the requested IDs are missing.
-        missing_ids = set(value) - {link.document_id for link in links}
+        missing_ids = set(value) - set(link.document_id for link in links)
        if missing_ids:
            # The result should be an empty set in this case.
            return Q(id__in=[])
@@ -631,25 +631,23 @@ class Command(BaseCommand):
                ):
                    # Process each change
                    for change_type, path in changes:
-                        resolved_path = Path(path).resolve()
+                        path = Path(path).resolve()
                        if change_type == Change.deleted:
                            # Consumed (or otherwise removed); a later file
                            # reusing this name must not be skipped as
                            # already-queued.
-                            queued.discard(resolved_path)
-                        if not resolved_path.is_file():
+                            queued.discard(path)
+                        if not path.is_file():
                            continue
-                        if resolved_path in queued:
+                        if path in queued:
                            # Already queued and awaiting consumption; a stray
                            # event (NAS metadata touch, AV scan, etc.) while
                            # the file sits on disk mid-consumption must not
                            # cause it to be queued a second time (GH #13511).
-                            logger.debug(
-                                f"Ignoring event for queued file: {resolved_path}",
-                            )
+                            logger.debug(f"Ignoring event for queued file: {path}")
                            continue
-                        logger.debug(f"Event: {change_type.name} for {resolved_path}")
-                        tracker.track(resolved_path, change_type)
+                        logger.debug(f"Event: {change_type.name} for {path}")
+                        tracker.track(path, change_type)

                    # Check for stable files
                    for stable_path in tracker.get_stable_files():
@@ -30,10 +30,6 @@ if TYPE_CHECKING:
 logger = logging.getLogger("paperless.matching")


-class UnsupportedWorkflowTriggerTypeError(Exception):
-    pass
-
-
 def log_reason(
    matching_model: MatchingModel | WorkflowTrigger,
    document: Document,
@@ -695,9 +691,7 @@ def document_matches_workflow(
                )
            else:
                # New trigger types need to be explicitly checked above
-                raise UnsupportedWorkflowTriggerTypeError(
-                    f"Trigger type {trigger_type} not yet supported",
-                )
+                raise Exception(f"Trigger type {trigger_type} not yet supported")

            if trigger_matched:
                logger.info(f"Document matched {trigger} from {workflow}")
@@ -377,7 +377,7 @@ class Document(SoftDeleteModel, ModelWithOwner):  # type: ignore[django-manager-
        from documents.versioning import versions_newest_first

        if hasattr(self, "effective_content"):
-            return self.effective_content
+            return getattr(self, "effective_content")

        if self.root_document_id is not None or self.pk is None:
            return self.content
@@ -41,7 +41,7 @@ def get_default_file_extension(mime_type: str) -> str:
            return supported[mime_type]

    ext = mimetypes.guess_extension(mime_type)
-    return ext or ""
+    return ext if ext else ""


 def is_file_ext_supported(ext: str) -> bool:
@@ -43,8 +43,8 @@ def _discover_parser_class() -> type[DateParserPluginBase]:
                valid_plugins.append(ep)
            else:
                logger.warning(f"Plugin {ep.name} does not subclass DateParser.")
-        except Exception:
-            logger.exception(f"Unable to load date parser plugin {ep.name}")
+        except Exception as e:
+            logger.exception(f"Unable to load date parser plugin {ep.name}: {e}")

    if not valid_plugins:
        return RegexDateParserPlugin
@@ -91,8 +91,8 @@ class DateParserPluginBase(ABC):
                },
                locales=self.config.languages,
            )
-        except Exception:
-            logger.exception(f"Error while parsing date string '{date_string}'")
+        except Exception as e:
+            logger.exception(f"Error while parsing date string '{date_string}': {e}")
            return None

    def _filter_date(
@@ -59,10 +59,11 @@ def safe_regex_match(pattern: str, text: str, *, flags: int = 0):
    try:
        validate_regex_pattern(pattern)
        compiled = regex.compile(pattern, flags=flags)
-    except (regex.error, ValueError):
+    except (regex.error, ValueError) as exc:
        logger.exception(
-            "Error while processing regular expression %s",
+            "Error while processing regular expression %s: %s",
            textwrap.shorten(pattern, width=80, placeholder="…"),
+            exc,
        )
        return None

@@ -85,10 +86,11 @@ def safe_regex_sub(pattern: str, repl: str, text: str, *, flags: int = 0) -> str
    try:
        validate_regex_pattern(pattern)
        compiled = regex.compile(pattern, flags=flags)
-    except (regex.error, ValueError):
+    except (regex.error, ValueError) as exc:
        logger.exception(
-            "Error while processing regular expression %s",
+            "Error while processing regular expression %s: %s",
            textwrap.shorten(pattern, width=80, placeholder="…"),
+            exc,
        )
        return None

@@ -1142,7 +1142,7 @@ def get_backend() -> TantivyBackend:
    Returns:
        Thread-safe singleton TantivyBackend instance
    """
-    global _backend, _backend_path  # noqa: PLW0603 - module-level singleton, no class to hold this state
+    global _backend, _backend_path

    current_path: Path = settings.INDEX_DIR

@@ -1173,7 +1173,7 @@ def reset_backend() -> None:
    Forces creation of a new backend instance on the next get_backend() call.
    Used for test isolation and when switching between different index directories.
    """
-    global _backend, _backend_path  # noqa: PLW0603 - module-level singleton, no class to hold this state
+    global _backend, _backend_path

    with _backend_lock:
        if _backend is not None:
@@ -240,7 +240,7 @@ def parse_user_query(
            DEFAULT_SEARCH_FIELDS,
            field_boosts=_FIELD_BOOSTS,
            # (prefix=True, distance=1, transposition_cost_one=True) — edit-distance fuzziness
-            fuzzy_fields=dict.fromkeys(DEFAULT_SEARCH_FIELDS, (True, 1, True)),
+            fuzzy_fields={f: (True, 1, True) for f in DEFAULT_SEARCH_FIELDS},
        )
        # 0.1 boost keeps fuzzy hits ranked below exact matches (intentional)
        clauses.append((tantivy.Occur.Should, tantivy.Query.boost_query(fuzzy, 0.1)))
@@ -3,6 +3,7 @@ from __future__ import annotations
 import logging
 import math
 import re
+from collections.abc import Iterable
 from datetime import datetime
 from datetime import timedelta
 from decimal import Decimal
@@ -433,7 +434,7 @@ class OwnedObjectSerializer(
            return set()

        ctype = ContentType.objects.get_for_model(first_obj)
-        object_pks = [obj.pk for obj in objects]
+        object_pks = list(obj.pk for obj in objects)
        pk_type = type(first_obj.pk)

        def get_pks_for_permission_type(model):
@@ -727,7 +728,7 @@ class TagSerializer(MatchingModelSerializer, OwnedObjectSerializer):
                self.instance.clean()
            except ValidationError as e:
                logger.debug("Tag parent validation failed: %s", e)
-                raise
+                raise e
            finally:
                self.instance.tn_parent = original_parent
        else:
@@ -737,7 +738,7 @@ class TagSerializer(MatchingModelSerializer, OwnedObjectSerializer):
                temp.clean()
            except ValidationError as e:
                logger.debug("Tag parent validation failed: %s", e)
-                raise
+                raise e

        return super().validate(attrs)

@@ -876,8 +877,106 @@ def validate_documentlink_targets(user, doc_ids):
        )


+# drf-writable-nested revalidates a document's custom_fields more than once
+# per request: once as the ordinary nested list, then again per-item while
+# matching existing vs. new CustomFieldInstance rows during save() -- and
+# that second pass builds a brand new serializer (and field) instance per
+# item (see its update_or_create_reverse_relations / _get_serializer_for_field),
+# so a cache on the field instance alone only helps the first pass. It does,
+# however, explicitly pass `context=self.context` to every one of those
+# fresh serializers -- the *same* dict object the outer DocumentSerializer
+# is using, not a copy. That context dict is already request-scoped (DRF
+# builds it fresh per request via get_serializer_context()), so stashing the
+# resolved CustomField objects there -- rather than in some new global/
+# thread-local cache -- lets every later pass reuse them for free while
+# staying entirely within DRF's existing, already-request-scoped machinery.
+_CUSTOM_FIELD_CONTEXT_CACHE_KEY = "_custom_field_lookup_cache"
+
+
+class _CachingCustomFieldPrimaryKeyField(serializers.PrimaryKeyRelatedField):
+    """
+    Resolves CustomField ids with as few queries as possible: a per-instance
+    cache for repeat lookups on this exact field instance, backed by a
+    shared cache on the serializer context (see _CUSTOM_FIELD_CONTEXT_CACHE_KEY
+    above) so later, separately-instantiated fields for the same request
+    reuse what was already resolved instead of re-querying.
+    """
+
+    def __init__(self, **kwargs: Any) -> None:
+        super().__init__(**kwargs)
+        self._cache: dict[int, CustomField] = {}
+
+    def _shared_cache(self) -> dict[int, CustomField]:
+        return self.context.setdefault(_CUSTOM_FIELD_CONTEXT_CACHE_KEY, {})
+
+    @staticmethod
+    def _normalize_pk(data: Any) -> int | None:
+        """
+        Returns `data` coerced to the int a valid CustomField pk would be,
+        or None if `data` isn't a plausible pk (wrong type, unhashable,
+        non-numeric, or a bool -- DRF itself rejects bools as pks since
+        `True == 1` would otherwise silently match). None tells callers to
+        leave `data` alone and let `super().to_internal_value()` report the
+        normal validation error instead of touching the cache/queryset with
+        it directly.
+        """
+        if isinstance(data, bool):
+            return None
+        try:
+            return int(data)
+        except (TypeError, ValueError):
+            return None
+
+    def prefetch(self, ids: Iterable[Any]) -> None:
+        shared_cache = self._shared_cache()
+        candidates = {pk for i in ids if (pk := self._normalize_pk(i)) is not None}
+        missing = {
+            i for i in candidates if i not in self._cache and i not in shared_cache
+        }
+        if missing:
+            for obj in self.get_queryset().filter(pk__in=missing):
+                shared_cache[obj.pk] = obj
+        for i in candidates:
+            obj = shared_cache.get(i)
+            if obj is not None:
+                self._cache[i] = obj
+
+    def to_internal_value(self, data: Any) -> CustomField:
+        pk = self._normalize_pk(data)
+        if pk is None:
+            return super().to_internal_value(data)
+        if pk in self._cache:
+            return self._cache[pk]
+        shared_cache = self._shared_cache()
+        if pk in shared_cache:
+            obj = shared_cache[pk]
+            self._cache[pk] = obj
+            return obj
+        obj: CustomField = super().to_internal_value(data)
+        self._cache[obj.pk] = obj
+        shared_cache[obj.pk] = obj
+        return obj
+
+
+class CustomFieldInstanceListSerializer(serializers.ListSerializer):
+    def to_internal_value(self, data: Any) -> list[Any]:
+        if isinstance(data, list):
+            field_ids = []
+            for item in data:
+                if not isinstance(item, dict) or "field" not in item:
+                    continue
+                try:
+                    hash(item["field"])
+                except TypeError:
+                    continue
+                field_ids.append(item["field"])
+            if field_ids:
+                self.child.fields["field"].prefetch(field_ids)
+        return super().to_internal_value(data)
+
+
 class CustomFieldInstanceSerializer(serializers.ModelSerializer[CustomFieldInstance]):
-    field = serializers.PrimaryKeyRelatedField(queryset=CustomField.objects.all())
+    field = _CachingCustomFieldPrimaryKeyField(queryset=CustomField.objects.all())
    value = ReadWriteSerializerMethodField(allow_null=True)

    def create(self, validated_data):
@@ -978,6 +1077,7 @@ class CustomFieldInstanceSerializer(serializers.ModelSerializer[CustomFieldInsta

    class Meta:
        model = CustomFieldInstance
+        list_serializer_class = CustomFieldInstanceListSerializer
        fields = [
            "value",
            "field",
@@ -1147,7 +1247,7 @@ class DocumentSerializer(
    def to_representation(self, instance):
        doc = super().to_representation(instance)
        if "content" in self.fields and hasattr(instance, "effective_content"):
-            doc["content"] = instance.effective_content or ""
+            doc["content"] = getattr(instance, "effective_content") or ""
        if self.truncate_content and "content" in self.fields:
            doc["content"] = doc.get("content")[0:550]
        return doc
@@ -1857,8 +1957,8 @@ class BulkEditSerializer(
        if isinstance(custom_fields, dict):
            try:
                ids = [int(i[0]) for i in custom_fields.items()]
-            except Exception:
-                logger.exception("Error validating custom fields")
+            except Exception as e:
+                logger.exception(f"Error validating custom fields: {e}")
                raise serializers.ValidationError(
                    f"{name} must be a list of integers or a dict of id:value pairs, see the log for details",
                )
@@ -2056,12 +2156,13 @@ class BulkEditSerializer(
            for doc in docs:
                if "-" in doc:
                    pages.append(
-                        list(
-                            range(
+                        [
+                            x
+                            for x in range(
                                int(doc.split("-")[0]),
                                int(doc.split("-")[1]) + 1,
-                            ),
-                        ),
+                            )
+                        ],
                    )
                else:
                    pages.append([int(doc)])
@@ -2922,7 +3023,7 @@ class ShareLinkBundleSerializer(OwnedObjectSerializer):
        return share_link_bundle

    def get_document_count(self, obj: ShareLinkBundle) -> int:
-        return obj.document_total or obj.documents.count()
+        return getattr(obj, "document_total") or obj.documents.count()


 class BulkEditObjectsSerializer(SerializerWithPerms, SetPermissionsMixin):
@@ -636,7 +636,7 @@ def update_filename_and_move_files(
                #  so this is not the end of the world.
                # B: if moving the original file failed, nothing has changed
                #  anyway.
-                logger.exception("Error reverting document changes")
+                pass

            # restore old values on the instance
            instance.filename = old_filename
@@ -1101,11 +1101,10 @@ def _extract_input_data(
                if v is None or k.startswith("_"):
                    continue
                if isinstance(v, datetime.date):
-                    override_dict[k] = v.isoformat()
+                    v = v.isoformat()
                elif isinstance(v, Path):
-                    override_dict[k] = str(v)
-                else:
-                    override_dict[k] = v
+                    v = str(v)
+                override_dict[k] = v
            if override_dict:
                data["overrides"] = override_dict
        return data
@@ -217,9 +217,9 @@ def consume_file(
                overrides.filename or input_doc.original_file.name,
                self.request.id,
            ) as status_mgr,
-            TemporaryDirectory(dir=settings.SCRATCH_DIR) as tmp_dir_name,
+            TemporaryDirectory(dir=settings.SCRATCH_DIR) as tmp_dir,
        ):
-            tmp_dir = Path(tmp_dir_name)
+            tmp_dir = Path(tmp_dir)
            msg = None
            for plugin_class in plugins:
                plugin_name = plugin_class.NAME
@@ -261,7 +261,7 @@ def consume_file(
                    )

                except Exception as e:
-                    logger.exception(f"{plugin_name} failed")
+                    logger.exception(f"{plugin_name} failed: {e}")
                    status_mgr.send_progress(
                        ProgressStatusOptions.FAILED,
                        f"{e}",
@@ -495,8 +495,8 @@ def empty_trash(doc_ids=None) -> None:
                content_type=ContentType.objects.get_for_model(Document),
                object_id__in=deleted_document_ids,
            ).delete()
-    except Exception:  # pragma: no cover
-        logger.exception("Error while emptying trash")
+    except Exception as e:  # pragma: no cover
+        logger.exception(f"Error while emptying trash: {e}")
    finally:
        models.signals.post_delete.disconnect(
            cleanup_document_deletion,
@@ -832,8 +832,9 @@ def build_share_link_bundle(bundle_id: int) -> None:
        logger.info("Built share link bundle %s", bundle.pk)
    except Exception as exc:
        logger.exception(
-            "Failed to build share link bundle %s",
+            "Failed to build share link bundle %s: %s",
            bundle_id,
+            exc,
        )
        bundle.status = ShareLinkBundle.Status.FAILED
        bundle.last_error = {
@@ -78,10 +78,6 @@ class PlaceholderString(str):
    def __ne__(self, other) -> bool:
        return not self.__eq__(other)

-    def __hash__(self) -> int:
-        # Equal to both "-none-" and "none", so hash to a single canonical value
-        return hash("-none-")
-

 NO_VALUE_PLACEHOLDER = PlaceholderString("-none-")

@@ -138,9 +138,9 @@ def parse_w_workflow_placeholders(

        # We're good!
        return rendered_template
-    except UndefinedError:
+    except UndefinedError as e:
        # The undefined class logs this already for us
-        raise
+        raise e
    except TemplateSyntaxError as e:
        logger.warning(f"Template syntax error in title generation: {e}")
    except SecurityError as e:
@@ -150,5 +150,5 @@ def parse_w_workflow_placeholders(
        logger.warning(
            f"Invalid title format '{text}', workflow not applied: {e}",
        )
-        raise
+        raise e
    return None
@@ -296,7 +296,7 @@ class TestRegexDateParser:

            # simulate parse failure for malformed input
            if "99/99/9999" in date_string or "bad date" in date_string:
-                raise Exception("parse failed for malformed date")  # noqa: TRY002 - simulates a generic parser failure
+                raise Exception("parse failed for malformed date")

            return None

@@ -57,13 +57,13 @@ class MultiprocessCommand(PaperlessCommand):

    def handle(self, *args, **options):
        items = list(range(5))
-        results = list(
-            self.process_parallel(
-                _double_value,
-                items,
-                description="Processing...",
-            ),
-        )
+        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}")

@@ -66,7 +66,7 @@ class TestWriteBatchLockRetry:
        )
        mock_sleep = mocker.patch(
            "documents.search._backend.time.sleep",
-            side_effect=sleep_values.append,
+            side_effect=lambda s: sleep_values.append(s),
        )

        # Should not raise — 4th attempt succeeds
@@ -111,7 +111,7 @@ class TestWriteBatchLockRetry:
        sleep_values: list[float] = []
        mocker.patch(
            "documents.search._backend.time.sleep",
-            side_effect=sleep_values.append,
+            side_effect=lambda s: sleep_values.append(s),
        )
        for _ in range(50):
            sleep_values.clear()
@@ -1003,8 +1003,8 @@ class TestBulkEditAPI(DirectoriesMixin, APITestCase):
            for correspondent in response.data[field]:
                self.assertEqual(correspondent["document_count"], 0)
            self.assertCountEqual(
-                (c["id"] for c in response.data[field]),
-                (c["id"] for c in Entity.objects.values("id")),
+                map(lambda c: c["id"], response.data[field]),
+                map(lambda c: c["id"], Entity.objects.values("id")),
            )

    def test_api_selection_data(self) -> None:
@@ -5,7 +5,9 @@ from unittest.mock import ANY

 from django.contrib.auth.models import Permission
 from django.contrib.auth.models import User
+from django.db import connection
 from django.test import override_settings
+from django.test.utils import CaptureQueriesContext
 from guardian.shortcuts import assign_perm
 from rest_framework import status
 from rest_framework.test import APITestCase
@@ -13,6 +15,9 @@ from rest_framework.test import APITestCase
 from documents.models import CustomField
 from documents.models import CustomFieldInstance
 from documents.models import Document
+from documents.serialisers import CustomFieldInstanceSerializer
+from documents.serialisers import DocumentSerializer
+from documents.tests.factories import DocumentFactory
 from documents.tests.utils import DirectoriesMixin


@@ -530,6 +535,136 @@ class TestCustomFieldsAPI(DirectoriesMixin, APITestCase):
        doc.refresh_from_db()
        self.assertEqual(len(doc.custom_fields.all()), 10)

+    def test_document_serializer_custom_fields_validation_batches_field_lookup(
+        self,
+    ) -> None:
+        """
+        GIVEN:
+            - A document is being validated with several custom field values
+              at once (as happens on every PATCH/PUT/POST)
+        WHEN:
+            - The serializer is validated
+        THEN:
+            - The referenced CustomField objects are resolved with a single
+              query, not one query per custom field
+        """
+        doc = DocumentFactory(mime_type="application/pdf")
+        custom_fields = [
+            CustomField.objects.create(
+                name=f"Test Custom Field {i}",
+                data_type=CustomField.FieldDataType.STRING,
+            )
+            for i in range(5)
+        ]
+
+        serializer = DocumentSerializer(
+            doc,
+            data={
+                "custom_fields": [
+                    {"field": custom_field.id, "value": "test value"}
+                    for custom_field in custom_fields
+                ],
+            },
+            partial=True,
+        )
+
+        with CaptureQueriesContext(connection) as ctx:
+            self.assertTrue(serializer.is_valid(), serializer.errors)
+
+        custom_field_lookups = [
+            query
+            for query in ctx.captured_queries
+            if 'FROM "documents_customfield" WHERE "documents_customfield"."id"'
+            in query["sql"]
+        ]
+        self.assertEqual(
+            len(custom_field_lookups),
+            1,
+            "Expected a single batched query to resolve the custom fields, "
+            f"got {len(custom_field_lookups)}: {custom_field_lookups}",
+        )
+
+    def test_custom_field_lookup_reuses_shared_context_cache(self) -> None:
+        """
+        GIVEN:
+            - A CustomField has already been resolved once, by a serializer
+              sharing a given `context` dict
+        WHEN:
+            - A second, separately-instantiated CustomFieldInstanceSerializer
+              validates the same field id, sharing that same context
+              (this is what drf-writable-nested does: it rebuilds a fresh
+              serializer -- and fresh field instances -- per item while
+              matching existing vs. new instances during save())
+        THEN:
+            - No additional query is issued to resolve the CustomField
+        """
+        custom_field = CustomField.objects.create(
+            name="Test Custom Field",
+            data_type=CustomField.FieldDataType.STRING,
+        )
+
+        context: dict = {}
+        first_pass = CustomFieldInstanceSerializer(
+            data={"field": custom_field.id, "value": "a"},
+            context=context,
+        )
+        self.assertTrue(first_pass.is_valid(), first_pass.errors)
+
+        second_pass = CustomFieldInstanceSerializer(
+            data={"field": custom_field.id, "value": "b"},
+            context=context,
+        )
+        with CaptureQueriesContext(connection) as ctx:
+            self.assertTrue(second_pass.is_valid(), second_pass.errors)
+
+        custom_field_lookups = [
+            query
+            for query in ctx.captured_queries
+            if 'FROM "documents_customfield" WHERE "documents_customfield"."id"'
+            in query["sql"]
+        ]
+        self.assertEqual(
+            len(custom_field_lookups),
+            0,
+            "Expected the second, separately-instantiated serializer to reuse "
+            f"the already-resolved CustomField, got: {custom_field_lookups}",
+        )
+
+    def test_custom_field_validation_rejects_malformed_field_value(self) -> None:
+        """
+        GIVEN:
+            - A document is being validated with a malformed custom_fields
+              entry whose "field" value is neither a valid CustomField id
+              nor a type DRF's own PrimaryKeyRelatedField can safely reject
+              on its own (unhashable, or a non-numeric scalar)
+        WHEN:
+            - The serializer is validated
+        THEN:
+            - A normal validation error is raised, not an unhandled
+              TypeError/ValueError escaping past DRF's validation layer
+        """
+        doc = DocumentFactory(mime_type="application/pdf")
+
+        bad_field_values = {
+            "unhashable-list": [],
+            "unhashable-dict": {},
+            "non-numeric-scalar": "abc",
+        }
+        for case_id, bad_field_value in bad_field_values.items():
+            with self.subTest(case_id):
+                serializer = DocumentSerializer(
+                    doc,
+                    data={
+                        "custom_fields": [
+                            {"field": bad_field_value, "value": "test value"},
+                        ],
+                    },
+                    partial=True,
+                )
+
+                self.assertFalse(serializer.is_valid())
+                self.assertIn("custom_fields", serializer.errors)
+
    def test_change_custom_field_instance_value(self) -> None:
        """
        GIVEN:
@@ -18,8 +18,8 @@ class MockOpenIDProvider:

    def get_brands(self):
        default_servers = [
-            {"id": "yahoo", "name": "Yahoo", "openid_url": "http://me.yahoo.com"},
-            {"id": "hyves", "name": "Hyves", "openid_url": "http://hyves.nl"},
+            dict(id="yahoo", name="Yahoo", openid_url="http://me.yahoo.com"),
+            dict(id="hyves", name="Hyves", openid_url="http://hyves.nl"),
        ]
        return default_servers

@@ -205,12 +205,12 @@ class TestBarcode(
            - Barcode is detected on page 1 (zero indexed)
        """

-        for test_filename in [
+        for test_file in [
            "patch-code-t-middle-reverse.pdf",
            "patch-code-t-middle-distorted.pdf",
            "patch-code-t-middle-fuzzy.pdf",
        ]:
-            test_file = self.BARCODE_SAMPLE_DIR / test_filename
+            test_file = self.BARCODE_SAMPLE_DIR / test_file

            with self.get_reader(test_file) as reader:
                reader.detect()
@@ -777,7 +777,7 @@ class TestPDFActions(DirectoriesMixin, TestCase):
        sig.set.return_value.apply_async.side_effect = Exception("boom")
        mock_consume_file.return_value = sig

-        with self.assertRaises(Exception):  # noqa: B017 - mock injects a bare Exception
+        with self.assertRaises(Exception):
            bulk_edit.merge(doc_ids, delete_originals=True)

        self.doc1.refresh_from_db()
@@ -1318,7 +1318,7 @@ class TestPDFActions(DirectoriesMixin, TestCase):
        sig.apply_async.side_effect = Exception("boom")
        mock_chord.return_value = sig

-        with self.assertRaises(Exception):  # noqa: B017 - mock injects a bare Exception
+        with self.assertRaises(Exception):
            bulk_edit.edit_pdf(doc_ids, operations, delete_original=True)

        self.doc2.refresh_from_db()
@@ -1430,7 +1430,7 @@ class TestPDFActions(DirectoriesMixin, TestCase):
            {"page": 9999},  # invalid page, forces error during PDF load
        ]
        with self.assertLogs("paperless.bulk_edit", level="ERROR"):
-            with self.assertRaises(ValueError):
+            with self.assertRaises(Exception):
                bulk_edit.edit_pdf(doc_ids, operations)
        mock_group.assert_not_called()
        mock_consume_file.assert_not_called()
@@ -783,7 +783,7 @@ class TestClassifier(DirectoriesMixin, TestCase):

        Path(settings.MODEL_FILE).touch()
        mock_load.side_effect = Exception()
-        with self.assertRaises(Exception):  # noqa: B017 - mock injects a bare Exception
+        with self.assertRaises(Exception):
            load_classifier(raise_exception=True)


@@ -137,7 +137,7 @@ class FaultyParser(_BaseNewStyleParser):

 class FaultyGenericExceptionParser(_BaseNewStyleParser):
    def parse(self, document_path, mime_type, *, produce_archive: bool = True) -> None:
-        raise Exception("Generic exception.")  # noqa: TRY002 - deliberately not a ParseError
+        raise Exception("Generic exception.")


 def fake_magic_from_file(file, *, mime=False):  # NOSONAR
@@ -1333,7 +1333,7 @@ class PreConsumeTestCase(DirectoriesMixin, GetConsumerMixin, TestCase):
            script_calls = [
                call
                for call in m.call_args_list
-                if call.args and call.args[0] and call.args[0][0] != "pdftotext"
+                if call.args and call.args[0] and call.args[0][0] not in ("pdftotext",)
            ]
            self.assertEqual(script_calls, [])

@@ -0,0 +1,58 @@
+from django.db import connection
+from django.test import TestCase
+from django.test.utils import CaptureQueriesContext
+
+from documents.data_models import DocumentMetadataOverrides
+from documents.models import CustomField
+from documents.models import CustomFieldInstance
+from documents.tests.factories import DocumentFactory
+from documents.tests.utils import DirectoriesMixin
+
+
+class TestDocumentMetadataOverridesFromDocument(DirectoriesMixin, TestCase):
+    def test_from_document_batches_custom_field_lookup_after_refresh_from_db(
+        self,
+    ) -> None:
+        """
+        GIVEN:
+            - A document has several custom field values
+            - The document instance has just been refreshed from the database,
+              which drops any prefetched related objects (as
+              send_websocket_document_updated does before building overrides)
+        WHEN:
+            - DocumentMetadataOverrides.from_document() reads the document's
+              custom field values
+        THEN:
+            - The referenced CustomField objects are resolved with a single
+              query, not one query per custom field
+        """
+        doc = DocumentFactory(mime_type="application/pdf")
+        for i in range(5):
+            CustomFieldInstance.objects.create(
+                document=doc,
+                field=CustomField.objects.create(
+                    name=f"Test Custom Field {i}",
+                    data_type=CustomField.FieldDataType.STRING,
+                ),
+                value_text="value",
+            )
+
+        doc.refresh_from_db()
+
+        with CaptureQueriesContext(connection) as ctx:
+            overrides = DocumentMetadataOverrides.from_document(doc)
+
+        self.assertEqual(len(overrides.custom_fields), 5)
+        unbatched_field_lookups = [
+            query
+            for query in ctx.captured_queries
+            if 'FROM "documents_customfield" WHERE "documents_customfield"."id"'
+            in query["sql"]
+        ]
+        self.assertEqual(
+            unbatched_field_lookups,
+            [],
+            "Expected CustomField data to come from the CustomFieldInstance "
+            "join, not a separate per-instance lookup, "
+            f"got: {unbatched_field_lookups}",
+        )
@@ -44,7 +44,6 @@ from documents import tasks
 from documents.data_models import ConsumableDocument
 from documents.data_models import DocumentMetadataOverrides
 from documents.data_models import DocumentSource
-from documents.matching import UnsupportedWorkflowTriggerTypeError
 from documents.matching import document_matches_workflow
 from documents.matching import existing_document_matches_workflow
 from documents.matching import prefilter_documents_by_workflowtrigger
@@ -2852,13 +2851,7 @@ class TestWorkflows(
        doc = Document.objects.create(
            title="test",
        )
-        self.assertRaises(
-            UnsupportedWorkflowTriggerTypeError,
-            document_matches_workflow,
-            doc,
-            w,
-            99,
-        )
+        self.assertRaises(Exception, document_matches_workflow, doc, w, 99)

    def test_removal_action_document_updated_workflow(self) -> None:
        """
@@ -21,32 +21,28 @@ def uri_validator(value: str, allowed_schemes: set[str] | None = None) -> None:
        parts = urlparse(value)
        if not parts.scheme:
            raise ValidationError(
-                _("Unable to parse URI %(value)s, missing scheme"),
+                _(f"Unable to parse URI {value}, missing scheme"),
                params={"value": value},
            )
        elif not parts.netloc and not parts.path:
            raise ValidationError(
-                _("Unable to parse URI %(value)s, missing net location or path"),
+                _(f"Unable to parse URI {value}, missing net location or path"),
                params={"value": value},
            )

        if allowed_schemes and parts.scheme not in allowed_schemes:
            raise ValidationError(
                _(
-                    "URI scheme '%(scheme)s' is not allowed. Allowed schemes: %(allowed_schemes)s",
+                    f"URI scheme '{parts.scheme}' is not allowed. Allowed schemes: {', '.join(allowed_schemes)}",
                ),
-                params={
-                    "value": value,
-                    "scheme": parts.scheme,
-                    "allowed_schemes": ", ".join(allowed_schemes),
-                },
+                params={"value": value, "scheme": parts.scheme},
            )

    except ValidationError:
        raise
    except Exception as e:
        raise ValidationError(
-            _("Unable to parse URI %(value)s"),
+            _(f"Unable to parse URI {value}"),
            params={"value": value},
        ) from e

@@ -1440,7 +1440,7 @@ class DocumentViewSet(
        try:
            lang = detect(doc.content)
        except Exception:
-            logger.debug("Unable to detect language for document %s", doc.pk)
+            pass
        meta["lang"] = lang

        return Response(meta)
@@ -1478,12 +1478,13 @@ class DocumentViewSet(
            with get_date_parser() as date_parser:
                gen = date_parser.parse(doc.filename, doc.content)
                dates = sorted(
-                    set(
-                        itertools.islice(
+                    {
+                        i
+                        for i in itertools.islice(
                            gen,
                            settings.NUMBER_OF_SUGGESTED_DATES,
-                        ),
-                    ),
+                        )
+                    },
                )

        resp_data = {
@@ -1567,16 +1568,21 @@ class DocumentViewSet(
            except ValueError as exc:
                logger.exception(
                    "Invalid AI configuration while generating suggestions for "
-                    "document %s",
+                    "document %s: %s",
                    doc.pk,
+                    exc,
+                    exc_info=True,
                )
                raise ValidationError(
                    {"ai": [_("Invalid AI configuration.")]},
                ) from exc
-            except LLMTimeoutError:
+            except LLMTimeoutError as exc:
                logger.exception(
-                    "AI backend timed out while generating suggestions for document %s",
+                    "AI backend timed out while generating suggestions for "
+                    "document %s: %s",
                    doc.pk,
+                    exc,
+                    exc_info=True,
                )
                return Response(
                    {"ai": [_("AI backend request timed out.")]},
@@ -2049,7 +2055,7 @@ class DocumentViewSet(
            doc_name, doc_data = serializer.validated_data.get("document")
            version_label = serializer.validated_data.get("version_label")

-            t = int(mktime(datetime.now().timetuple()))  # noqa: DTZ005 - mktime() requires a local time tuple
+            t = int(mktime(datetime.now().timetuple()))

            settings.SCRATCH_DIR.mkdir(parents=True, exist_ok=True)

@@ -3319,7 +3325,7 @@ class PostDocumentView(GenericAPIView[Any]):
        cf = serializer.validated_data.get("custom_fields")
        from_webui = serializer.validated_data.get("from_webui")

-        t = int(mktime(datetime.now().timetuple()))  # noqa: DTZ005 - mktime() requires a local time tuple
+        t = int(mktime(datetime.now().timetuple()))

        settings.SCRATCH_DIR.mkdir(parents=True, exist_ok=True)

@@ -4129,7 +4135,7 @@ class UiSettingsView(GenericAPIView[Any]):
            user_resp["last_name"] = user.last_name

        # strip <app_label>.
-        roles = (re.sub(r"^\w+.", "", perm) for perm in user.get_all_permissions())
+        roles = map(lambda perm: re.sub(r"^\w+.", "", perm), user.get_all_permissions())
        return Response(
            {
                "user": user_resp,
@@ -5156,11 +5162,11 @@ class SystemStatusView(PassUserMixin):
                f"{m.app}.{m.name}"
                for m in MigrationRecorder.Migration.objects.all().order_by("id")
            ]
-        except Exception:  # pragma: no cover
+        except Exception as e:  # pragma: no cover
            applied_migrations = []
            db_status = "ERROR"
            logger.exception(
-                "System status detected a possible problem while connecting to the database",
+                f"System status detected a possible problem while connecting to the database: {e}",
            )
            db_error = "Error connecting to database, check logs for more detail."

@@ -5176,10 +5182,10 @@ class SystemStatusView(PassUserMixin):
            try:
                client.ping()
                redis_status = "OK"
-            except Exception:
+            except Exception as e:
                redis_status = "ERROR"
                logger.exception(
-                    "System status detected a possible problem while connecting to redis",
+                    f"System status detected a possible problem while connecting to redis: {e}",
                )
                redis_error = "Error connecting to redis, check logs for more detail."

@@ -5209,10 +5215,10 @@ class SystemStatusView(PassUserMixin):
                else:
                    celery_active = "WARNING"
                    celery_error = "Celery worker responded unexpectedly."
-        except Exception:
+        except Exception as e:
            celery_active = "ERROR"
            logger.exception(
-                "System status detected a possible problem while connecting to celery",
+                f"System status detected a possible problem while connecting to celery: {e}",
            )
            celery_error = "Error connecting to celery, check logs for more detail."

@@ -5227,15 +5233,13 @@ class SystemStatusView(PassUserMixin):
            index_dir = settings.INDEX_DIR
            mtimes = [p.stat().st_mtime for p in index_dir.iterdir() if p.is_file()]
            index_last_modified = (
-                make_aware(datetime.fromtimestamp(max(mtimes)))  # noqa: DTZ006 - make_aware() requires a naive datetime
-                if mtimes
-                else None
+                make_aware(datetime.fromtimestamp(max(mtimes))) if mtimes else None
            )
-        except Exception:
+        except Exception as e:
            index_status = "ERROR"
            index_error = "Error opening index, check logs for more detail."
            logger.exception(
-                "System status detected a possible problem while opening the index",
+                f"System status detected a possible problem while opening the index: {e}",
            )
            index_last_modified = None

@@ -66,7 +66,7 @@ def build_workflow_action_context(
        else None
    )

-    filename = document.original_file or ""
+    filename = document.original_file if document.original_file else ""
    return {
        "title": overrides.title
        if overrides and overrides.title
@@ -179,9 +179,9 @@ def execute_email_action(
            f"Sent {n_messages} notification email(s) to {action.email.to}",
            extra={"group": logging_group},
        )
-    except Exception:
+    except Exception as e:
        logger.exception(
-            "Error occurred sending notification email",
+            f"Error occurred sending notification email: {e}",
            extra={"group": logging_group},
        )

@@ -265,9 +265,9 @@ def execute_webhook_action(
            f"Webhook to {action.webhook.url} queued",
            extra={"group": logging_group},
        )
-    except Exception:
+    except Exception as e:
        logger.exception(
-            "Error occurred sending webhook",
+            f"Error occurred sending webhook: {e}",
            extra={"group": logging_group},
        )

@@ -47,7 +47,7 @@ def resolve_date(dates: list[str]) -> date | None:
    """
    for value in dates:
        try:
-            return datetime.strptime(value, "%Y-%m-%d").date()  # noqa: DTZ007 - only the calendar date is used, time/tz is discarded
+            return datetime.strptime(value, "%Y-%m-%d").date()
        except (TypeError, ValueError):
            logger.debug("Ignoring unparsable suggested date %s", value)
    return None
@@ -70,6 +70,6 @@ def send_webhook(
        logger.error(
            f"Failed attempt sending webhook to {url}: {e}",
        )
-        raise
+        raise e
    finally:
        transport.close()
@@ -241,7 +241,7 @@ def check_v3_minimum_upgrade_version(
        return []

    logger = logging.getLogger(__name__)
-    last_applied = max(applied) if applied else "(none)"
+    last_applied = sorted(applied)[-1] if applied else "(none)"
    logger.error(
        "V3 upgrade check failed: last applied documents migration is %r. "
        "Expected '1075_workflowaction_order' (v2.20.15). "
@@ -341,7 +341,6 @@ def get_tesseract_langs():
    proc = subprocess.run(
        [shutil.which("tesseract"), "--list-langs"],
        capture_output=True,
-        check=False,
    )

    # Decode bytes to string, split on newlines, trim out the header
@@ -84,7 +84,7 @@ def get_parser_registry() -> ParserRegistry:
    ParserRegistry
        The shared registry singleton.
    """
-    global _registry, _discovery_complete  # noqa: PLW0603 - module-level singleton, no class to hold this state
+    global _registry, _discovery_complete

    with _lock:
        if _registry is None:
@@ -113,7 +113,7 @@ def init_builtin_parsers() -> None:
    -------
    None
    """
-    global _registry  # noqa: PLW0603 - module-level singleton, no class to hold this state
+    global _registry

    with _lock:
        if _registry is None:
@@ -137,7 +137,7 @@ def reset_parser_registry() -> None:
    -------
    None
    """
-    global _registry, _discovery_complete  # noqa: PLW0603 - module-level singleton, no class to hold this state
+    global _registry, _discovery_complete

    _registry = None
    _discovery_complete = False
@@ -76,7 +76,7 @@ class RemoteEngineConfig:
    def engine_is_valid(self) -> bool:
        """Return True when the engine is known and fully configured."""
        return (
-            self.engine == "azureai"
+            self.engine in ("azureai",)
            and self.api_key is not None
            and not (self.engine == "azureai" and self.endpoint is None)
        )
@@ -467,7 +467,7 @@ class RemoteDocumentParser:
            return result.content

        except Exception as e:
-            logger.exception("Azure AI Vision parsing failed")
+            logger.exception("Azure AI Vision parsing failed: %s", e)
            raise ParseError(f"Azure AI Vision parsing failed: {e}") from e

        finally:
@@ -306,9 +306,8 @@ def extract_pdf_metadata(

    for key, value in meta.items():
        if isinstance(value, list):
-            str_value = " ".join(str(e) for e in value)
-        else:
-            str_value = str(value)
+            value = " ".join(str(e) for e in value)
+        value = str(value)

        try:
            m = namespace_pattern.match(key)
@@ -330,7 +329,7 @@ def extract_pdf_metadata(
                    namespace=namespace,
                    prefix=meta.REVERSE_NS[namespace],
                    key=key_value,
-                    value=str_value,
+                    value=value,
                ),
            )
        except Exception as e:
@@ -294,7 +294,7 @@ if _CHANNELS_BACKEND.startswith("channels_redis."):
 ###############################################################################

 EMAIL_HOST: Final[str] = os.getenv("PAPERLESS_EMAIL_HOST", "localhost")
-EMAIL_PORT: Final[int] = get_int_from_env("PAPERLESS_EMAIL_PORT", 25)
+EMAIL_PORT: Final[int] = int(os.getenv("PAPERLESS_EMAIL_PORT", 25))
 EMAIL_HOST_USER: Final[str] = os.getenv("PAPERLESS_EMAIL_HOST_USER", "")
 EMAIL_HOST_PASSWORD: Final[str] = os.getenv("PAPERLESS_EMAIL_HOST_PASSWORD", "")
 DEFAULT_FROM_EMAIL: Final[str] = os.getenv("PAPERLESS_EMAIL_FROM", EMAIL_HOST_USER)
@@ -381,9 +381,8 @@ ACCOUNT_SESSION_REMEMBER = get_bool_from_env(
    "True",
 )
 SESSION_EXPIRE_AT_BROWSER_CLOSE = not ACCOUNT_SESSION_REMEMBER
-SESSION_COOKIE_AGE = get_int_from_env(
-    "PAPERLESS_SESSION_COOKIE_AGE",
-    60 * 60 * 24 * 7 * 3,
+SESSION_COOKIE_AGE = int(
+    os.getenv("PAPERLESS_SESSION_COOKIE_AGE", 60 * 60 * 24 * 7 * 3),
 )
 # https://docs.djangoproject.com/en/5.1/ref/settings/#std-setting-SESSION_ENGINE
 SESSION_ENGINE = "django.contrib.sessions.backends.cached_db"
@@ -396,6 +395,7 @@ if AUTO_LOGIN_USERNAME:


 def _parse_remote_user_settings() -> str:
+    global MIDDLEWARE, AUTHENTICATION_BACKENDS, REST_FRAMEWORK
    enable = get_bool_from_env("PAPERLESS_ENABLE_HTTP_REMOTE_USER")
    enable_api = get_bool_from_env("PAPERLESS_ENABLE_HTTP_REMOTE_USER_API")
    if enable or enable_api:
@@ -454,6 +454,7 @@ if ALLOWED_HOSTS != ["*"]:


 def _parse_paperless_url():
+    global CSRF_TRUSTED_ORIGINS, CORS_ALLOWED_ORIGINS, ALLOWED_HOSTS
    url = os.getenv("PAPERLESS_URL")
    if url:
        CSRF_TRUSTED_ORIGINS.append(url)
@@ -613,8 +614,8 @@ USE_TZ = True

 LOGGING_DIR.mkdir(parents=True, exist_ok=True)

-LOGROTATE_MAX_SIZE = get_int_from_env("PAPERLESS_LOGROTATE_MAX_SIZE", 1024 * 1024)
-LOGROTATE_MAX_BACKUPS = get_int_from_env("PAPERLESS_LOGROTATE_MAX_BACKUPS", 20)
+LOGROTATE_MAX_SIZE = os.getenv("PAPERLESS_LOGROTATE_MAX_SIZE", 1024 * 1024)
+LOGROTATE_MAX_BACKUPS = os.getenv("PAPERLESS_LOGROTATE_MAX_BACKUPS", 20)

 LOGGING = {
    "version": 1,
@@ -810,15 +811,9 @@ IGNORABLE_FILES: Final[list[str]] = [
    "Thumbs.db",
 ]

-CONSUMER_POLLING_INTERVAL = get_float_from_env(
-    "PAPERLESS_CONSUMER_POLLING_INTERVAL",
-    0.0,
-)
+CONSUMER_POLLING_INTERVAL = float(os.getenv("PAPERLESS_CONSUMER_POLLING_INTERVAL", 0))

-CONSUMER_STABILITY_DELAY = get_float_from_env(
-    "PAPERLESS_CONSUMER_STABILITY_DELAY",
-    5.0,
-)
+CONSUMER_STABILITY_DELAY = float(os.getenv("PAPERLESS_CONSUMER_STABILITY_DELAY", 5))

 CONSUMER_DELETE_DUPLICATES = get_bool_from_env("PAPERLESS_CONSUMER_DELETE_DUPLICATES")

@@ -111,7 +111,7 @@ def parse_dict_from_str(
            return False

    settings: dict[str, Any] = copy.deepcopy(defaults) if defaults else {}
-    _type_map = type_map or {}
+    _type_map = type_map if type_map else {}

    if not env_str:
        return settings
@@ -114,17 +114,17 @@ def test_cache_hit_when_enabled() -> None:
    assert settings.CACHALOT_TIMEOUT == 1

    # Read a table to populate the cache
-    list(Tag.objects.values_list("id", flat=True))
+    list(list(Tag.objects.values_list("id", flat=True)))

    # Invalidate the cache then read the database, there should be DB hit
    invalidate_db_cache()
    with CaptureQueriesContext(connection) as ctx:
-        list(Tag.objects.values_list("id", flat=True))
+        list(list(Tag.objects.values_list("id", flat=True)))
    assert len(ctx)

    # Doing the same request again should hit the cache, not the DB
    with CaptureQueriesContext(connection) as ctx:
-        list(Tag.objects.values_list("id", flat=True))
+        list(list(Tag.objects.values_list("id", flat=True)))
    assert not len(ctx)

    # Wait the end of TTL
@@ -133,7 +133,7 @@ def test_cache_hit_when_enabled() -> None:

    # Read the DB again. The DB should be hit because the cache has expired
    with CaptureQueriesContext(connection) as ctx:
-        list(Tag.objects.values_list("id", flat=True))
+        list(list(Tag.objects.values_list("id", flat=True)))
    assert len(ctx)

    # Invalidate the cache at the end of test
@@ -149,7 +149,7 @@ def test_cache_is_disabled_by_default() -> None:
    # Read the table multiple times: the DB should always be hit without cache
    for _ in range(3):
        with CaptureQueriesContext(connection) as ctx:
-            list(Tag.objects.values_list("id", flat=True))
+            list(list(Tag.objects.values_list("id", flat=True)))
        assert len(ctx)

    # Invalidate the cache at the end of test
@@ -59,7 +59,7 @@ def test_ocr_to_dateparser_languages_exception(
            raise RuntimeError("Simulated error")

    with caplog.at_level(logging.WARNING):
-        monkeypatch.setattr(utils, "LocaleDataLoader", DummyLoader)
+        monkeypatch.setattr(utils, "LocaleDataLoader", lambda: DummyLoader())
        result = utils.ocr_to_dateparser_languages("eng+fra")
        assert result == []
        assert (
@@ -103,8 +103,8 @@ def stream_chat_with_documents(
            documents,
            output_language=output_language,
        )
-    except Exception:
-        logger.exception("Failed to stream document chat response")
+    except Exception as e:
+        logger.exception("Failed to stream document chat response: %s", e)
        yield CHAT_ERROR_MESSAGE


@@ -167,7 +167,7 @@ def test_get_ai_document_classification_failure(mock_run_llm_query, mock_documen
    """
    mock_run_llm_query.side_effect = Exception("LLM query failed")

-    with pytest.raises(Exception):  # noqa: B017 - mock injects a bare Exception
+    with pytest.raises(Exception):
        get_ai_document_classification(mock_document)


@@ -21,6 +21,5 @@ class TestLazyAiImports:
            capture_output=True,
            text=True,
            cwd=_SRC_DIR,
-            check=False,
        )
        assert result.returncode == 0, result.stdout + result.stderr
@@ -7,6 +7,7 @@ import ssl
 import tempfile
 import traceback
 import unicodedata
+from datetime import date
 from datetime import timedelta
 from fnmatch import fnmatch
 from pathlib import Path
@@ -405,7 +406,7 @@ def make_criterias(rule: MailRule, *, supports_gmail_labels: bool):
    Returns criteria to be applied to MailBox.fetch for the given rule.
    """

-    maximum_age = timezone.localdate() - timedelta(days=rule.maximum_age)
+    maximum_age = date.today() - timedelta(days=rule.maximum_age)
    criterias = {}
    if rule.maximum_age > 0:
        criterias["date_gte"] = maximum_age
@@ -722,9 +723,9 @@ class MailAccountHandler(LoggingMixin):
                                f"Rule {rule}: Stopping processing rules due to stop_processing flag",
                            )
                            break
-                    except Exception:
+                    except Exception as e:
                        self.log.exception(
-                            f"Rule {rule}: Error while processing rule",
+                            f"Rule {rule}: Error while processing rule: {e}",
                        )
        except MailError:
            raise
@@ -873,9 +874,9 @@ class MailAccountHandler(LoggingMixin):

                total_processed_files += processed_files
                mails_processed += 1
-            except Exception:
+            except Exception as e:
                self.log.exception(
-                    f"Rule {rule}: Error while processing mail {message.uid}",
+                    f"Rule {rule}: Error while processing mail {message.uid}: {e}",
                )

        self.log.debug(f"Rule {rule}: Processed {mails_processed} matching mail(s)")
@@ -11,10 +11,6 @@ from imap_tools import MailMessage
 from documents.loggers import LoggingMixin


-class MailDecryptionError(Exception):
-    pass
-
-
 class MailMessagePreprocessor(abc.ABC):
    """
    Defines the interface for preprocessors that alter messages before they are handled in MailAccountHandler
@@ -73,7 +69,7 @@ class MailMessageDecryptor(MailMessagePreprocessor, LoggingMixin):
                f"Message decryption failed with status message "
                f"{decrypted_raw_message.status}",
            )
-            raise MailDecryptionError(
+            raise Exception(
                f"Decryption failed: {decrypted_raw_message.status}, {decrypted_raw_message.stderr}",
            )
        self.log.debug("Message decrypted successfully.")
@@ -50,7 +50,7 @@ class ProcessedMailFactory(DjangoModelFactory[ProcessedMail]):

    rule = factory.SubFactory(MailRuleFactory)
    folder = "INBOX"
-    uid = factory.Sequence(str)
+    uid = factory.Sequence(lambda n: str(n))
    subject = factory.Faker("sentence", nb_words=4)
    received = factory.LazyFunction(timezone.now)
    processed = factory.LazyFunction(timezone.now)
@@ -214,7 +214,7 @@ class BogusMailBox(AbstractContextManager):
            )
            self.messages = list(filter(lambda m: m.uid not in uid_list, self.messages))
        else:
-            raise Exception  # noqa: TRY002 - test double simulating a generic mailbox failure
+            raise Exception


 def fake_magic_from_buffer(buffer, *, mime=False):
@@ -14,7 +14,6 @@ from imap_tools import MailMessage

 from paperless_mail.mail import MailAccountHandler
 from paperless_mail.models import MailRule
-from paperless_mail.preprocessor import MailDecryptionError
 from paperless_mail.preprocessor import MailMessageDecryptor
 from paperless_mail.tests.factories import MailAccountFactory
 from paperless_mail.tests.test_mail import TestMail
@@ -83,9 +82,7 @@ class MessageEncryptor:
            armor=True,
        )
        if not encrypted_data.ok:
-            raise Exception(  # noqa: TRY002 - test fixture setup, not production code
-                f"Encryption failed: {encrypted_data.stderr}",
-            )
+            raise Exception(f"Encryption failed: {encrypted_data.stderr}")
        encrypted_email_content = encrypted_data.data

        new_email = MIMEMultipart("encrypted", protocol="application/pgp-encrypted")
@@ -187,11 +184,7 @@ class TestMailMessageGpgDecryptor(TestMail):
                EMAIL_GNUPG_HOME=empty_gpg_home,
            ):
                message_decryptor = MailMessageDecryptor()
-                self.assertRaises(
-                    MailDecryptionError,
-                    message_decryptor.run,
-                    encrypted_message,
-                )
+                self.assertRaises(Exception, message_decryptor.run, encrypted_message)
        finally:
            # Clean up the temporary GPG home used only by this test
            try:
@@ -1,3 +1,4 @@
+import datetime
 import logging
 from datetime import timedelta
 from http import HTTPStatus
@@ -86,7 +87,7 @@ class MailAccountViewSet(PassUserMixin, ModelViewSet[MailAccount]):
    @action(methods=["post"], detail=False)
    def test(self, request):
        logger = logging.getLogger("paperless_mail")
-        request.data["name"] = timezone.now().isoformat()
+        request.data["name"] = datetime.datetime.now().isoformat()
        serializer = self.get_serializer(data=request.data)
        serializer.is_valid(raise_exception=True)
        existing_account = None
Author	SHA1	Message	Date
stumpylog	c200ef8646	Handles a bad client sending malformed JSON or non-int primary keys	2026-08-27 09:42:39 -07:00
Trenton Holmes	1c253c369d	Perf: avoid per-instance CustomField reload in DocumentMetadataOverrides send_websocket_document_updated calls document.refresh_from_db() before building overrides, which drops the custom_fields prefetch (and its select_related("field")) set up by the view's queryset. DocumentMetadataOverrides.from_document() then lazily reloads field once per custom field instance. Since from_document() can't rely on the caller having a prefetched document, select_related explicitly at the point of use instead.	2026-08-27 09:42:39 -07:00
Trenton Holmes	fd9aea0340	Perf: reuse resolved CustomField objects across drf-writable-nested's per-item revalidation drf-writable-nested's update_or_create_reverse_relations rebuilds a fresh serializer -- and fresh field instances -- per custom_fields item while matching existing vs. new instances during save(), so the per-instance lookup cache alone only helped the first validation pass. It passes the same context dict (by reference) to every one of those serializers, so stash resolved CustomField objects there instead: later passes reuse them for free rather than re-querying.	2026-08-27 09:42:39 -07:00
Trenton Holmes	ffdd49bd47	Perf: batch CustomField lookups when validating a document's custom_fields DocumentSerializer.custom_fields validates each item's field id via a plain PrimaryKeyRelatedField, which issues one SELECT per custom field per validation pass (discussion #13690). Batch-resolve all field ids in one query and cache them on the field instance so per-item validation is free instead of re-querying.	2026-08-27 09:42:39 -07:00