Feature: Switch progress bar library to rich (#12169)

src/documents/management/commands/base.py

@@ -0,0 +1,320 @@
+"""
+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,20 +1,15 @@
 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.mixins import MultiProcessMixin
-from documents.management.commands.mixins import ProgressBarMixin
+from documents.management.commands.base import PaperlessCommand
 from documents.models import Document
 from documents.tasks import update_document_content_maybe_archive_file
 
 logger = logging.getLogger("paperless.management.archiver")
 
 
-class Command(MultiProcessMixin, ProgressBarMixin, BaseCommand):
+class Command(PaperlessCommand):
     help = (
         "Using the current classification model, assigns correspondents, tags "
         "and document types to all documents, effectively allowing you to "
@@ -22,7 +17,10 @@ class Command(MultiProcessMixin, ProgressBarMixin, BaseCommand):
         "modified) after their initial import."
     )
 
+    supports_multiprocessing = True
+
     def add_arguments(self, parser):
+        super().add_arguments(parser)
         parser.add_argument(
             "-f",
             "--overwrite",
@@ -44,13 +42,8 @@ class Command(MultiProcessMixin, ProgressBarMixin, BaseCommand):
                 "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"]
@@ -60,35 +53,21 @@ class Command(MultiProcessMixin, ProgressBarMixin, BaseCommand):
         else:
             documents = Document.objects.all()
 
-        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()
+        document_ids = [
+            doc.id for doc in documents if overwrite or not doc.has_archive_version
+        ]
 
         try:
             logging.getLogger().handlers[0].level = logging.ERROR
 
-            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,
-                        ),
+            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]",
                     )
-        except KeyboardInterrupt:
-            self.stdout.write(self.style.NOTICE("Aborting..."))
+        except KeyboardInterrupt:  # pragma: no cover
+            self.console.print("[yellow]Aborting...[/yellow]")

src/documents/management/commands/document_fuzzy_match.py

@@ -1,24 +1,20 @@
 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.mixins import MultiProcessMixin
-from documents.management.commands.mixins import ProgressBarMixin
+from documents.management.commands.base import PaperlessCommand
 from documents.models import Document
 
 
-@dataclasses.dataclass(frozen=True)
+@dataclasses.dataclass(frozen=True, slots=True)
 class _WorkPackage:
     first_doc: Document
     second_doc: Document
 
 
-@dataclasses.dataclass(frozen=True)
+@dataclasses.dataclass(frozen=True, slots=True)
 class _WorkResult:
     doc_one_pk: int
     doc_two_pk: int
@@ -31,22 +27,23 @@ 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(MultiProcessMixin, ProgressBarMixin, BaseCommand):
+class Command(PaperlessCommand):
     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,
@@ -59,16 +56,11 @@ class Command(MultiProcessMixin, ProgressBarMixin, BaseCommand):
             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(
@@ -80,66 +72,58 @@ class Command(MultiProcessMixin, ProgressBarMixin, BaseCommand):
         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))
 
-        # Don't spin up a pool of 1 process
+        results: list[_WorkResult] = []
         if self.process_count == 1:
-            results = []
-            for work in tqdm.tqdm(work_pkgs, disable=self.no_progress_bar):
+            for work in self.track(work_pkgs, description="Matching..."):
                 results.append(_process_and_match(work))
         else:  # pragma: no cover
-            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,
-                    ),
-                )
+            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)
 
-        # Check results
-        messages = []
-        maybe_delete_ids = []
-        for result in sorted(results):
-            if result.ratio >= opt_ratio:
+        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 {result.doc_one_pk} fuzzy match"
-                        f" to {result.doc_two_pk} (confidence {result.ratio:.3f})\n",
+                        f"Document {match_result.doc_one_pk} fuzzy match"
+                        f" to {match_result.doc_two_pk}"
+                        f" (confidence {match_result.ratio:.3f})\n",
                     ),
                 )
-                maybe_delete_ids.append(result.doc_two_pk)
+                maybe_delete_ids.append(match_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,25 +1,12 @@
-import logging
-
-import tqdm
-from django.core.management.base import BaseCommand
 from django.db.models.signals import post_save
 
-from documents.management.commands.mixins import ProgressBarMixin
+from documents.management.commands.base import PaperlessCommand
 from documents.models import Document
 
 
-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)
+class Command(PaperlessCommand):
+    help = "Rename all documents"
 
     def handle(self, *args, **options):
-        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,
-        ):
+        for document in self.track(Document.objects.all(), description="Renaming..."):
             post_save.send(Document, instance=document, created=False)

src/documents/management/commands/document_retagger.py

@@ -1,10 +1,7 @@
 import logging
 
-import tqdm
-from django.core.management.base import BaseCommand
-
 from documents.classifier import load_classifier
-from documents.management.commands.mixins import ProgressBarMixin
+from documents.management.commands.base import PaperlessCommand
 from documents.models import Document
 from documents.signals.handlers import set_correspondent
 from documents.signals.handlers import set_document_type
@@ -14,7 +11,7 @@ from documents.signals.handlers import set_tags
 logger = logging.getLogger("paperless.management.retagger")
 
 
-class Command(ProgressBarMixin, BaseCommand):
+class Command(PaperlessCommand):
     help = (
         "Using the current classification model, assigns correspondents, tags "
         "and document types to all documents, effectively allowing you to "
@@ -23,6 +20,7 @@ class Command(ProgressBarMixin, BaseCommand):
     )
 
     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")
@@ -34,7 +32,7 @@ class Command(ProgressBarMixin, BaseCommand):
             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."
             ),
         )
@@ -49,7 +47,6 @@ class Command(ProgressBarMixin, BaseCommand):
                 "and tags that do not match anymore due to changed rules."
             ),
         )
-        self.add_argument_progress_bar_mixin(parser)
         parser.add_argument(
             "--suggest",
             default=False,
@@ -68,8 +65,6 @@ class Command(ProgressBarMixin, BaseCommand):
         )
 
     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:
@@ -84,7 +79,7 @@ class Command(ProgressBarMixin, BaseCommand):
 
         classifier = load_classifier()
 
-        for document in tqdm.tqdm(documents, disable=self.no_progress_bar):
+        for document in self.track(documents, description="Retagging..."):
             if options["correspondent"]:
                 set_correspondent(
                     sender=None,
@@ -122,6 +117,7 @@ class Command(ProgressBarMixin, BaseCommand):
                     stdout=self.stdout,
                     style_func=self.style,
                 )
+
             if options["storage_path"]:
                 set_storage_path(
                     sender=None,

src/documents/management/commands/document_thumbnails.py

@@ -1,43 +1,45 @@
 import logging
-import multiprocessing
 import shutil
 
-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.management.commands.base import PaperlessCommand
 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) -> None:
+
+def _process_document(doc_id: int) -> None:
     document: Document = Document.objects.get(id=doc_id)
     parser_class = get_parser_class_for_mime_type(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
+    if parser_class is None:
+        logger.warning(
+            "%s: No parser for mime type %s",
+            document,
+            document.mime_type,
+        )
         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(MultiProcessMixin, ProgressBarMixin, BaseCommand):
+class Command(PaperlessCommand):
     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",
@@ -49,36 +51,23 @@ class Command(MultiProcessMixin, ProgressBarMixin, BaseCommand):
                 "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 = [doc.id for doc in documents]
+        ids = list(documents.values_list("id", flat=True))
 
-        # 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,
-                    ),
+        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]",
                 )

src/documents/management/commands/mixins.py

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