New Crowdin translations by GitHub Action

src/documents/management/commands/document_consumer.py

@@ -314,7 +314,7 @@ def _consume_file(
     consumption_dir: Path,
     *,
     subdirs_as_tags: bool,
-) -> bool:
+) -> None:
     """
     Queue a file for consumption.
 
@@ -322,20 +322,15 @@ def _consume_file(
         filepath: Path to the file to consume.
         consumption_dir: Base consumption directory.
         subdirs_as_tags: Whether to create tags from subdirectory names.
-
-    Returns:
-        True if the file was successfully handed to Celery, False otherwise.
-        Callers must not record the file as queued on failure, or the rescan
-        will never retry it.
     """
     # Verify file still exists and is accessible
     try:
         if not filepath.is_file():
             logger.debug(f"Not consuming {filepath}: not a file or doesn't exist")
-            return False
+            return
     except OSError as e:
         logger.warning(f"Not consuming {filepath}: {e}")
-        return False
+        return
 
     # Get tags from path if configured
     tag_ids: list[int] | None = None
@@ -360,9 +355,6 @@ def _consume_file(
         )
     except Exception:
         logger.exception(f"Error while queuing document {filepath}")
-        return False
-
-    return True
 
 
 class Command(BaseCommand):
@@ -500,12 +492,12 @@ class Command(BaseCommand):
             if not consumer_filter(Change.added, str(filepath)):
                 continue
 
-            if _consume_file(
+            _consume_file(
                 filepath=filepath,
                 consumption_dir=directory,
                 subdirs_as_tags=subdirs_as_tags,
-            ):
-                queued.add(filepath.resolve())
+            )
+            queued.add(filepath.resolve())
 
         return queued
 
@@ -659,16 +651,14 @@ class Command(BaseCommand):
 
                     # Check for stable files
                     for stable_path in tracker.get_stable_files():
-                        # Only remember files that were actually queued, so the
-                        # rescan does not re-queue them while the consume task
-                        # has yet to remove them from disk, but does retry a
-                        # failed publish instead of stranding it
-                        if _consume_file(
+                        _consume_file(
                             filepath=stable_path,
                             consumption_dir=directory,
                             subdirs_as_tags=subdirs_as_tags,
-                        ):
-                            queued.add(stable_path)
+                        )
+                        # Remember it so the rescan does not re-queue it while
+                        # the consume task has yet to remove it from disk
+                        queued.add(stable_path)
 
                     # Exit watch loop to reconfigure timeout
                     break

src/documents/signals/handlers.py

@@ -1003,7 +1003,7 @@ def run_workflows(
 
                         # kwargs so the PaperlessTask record can note the
                         # document, see _extract_input_data
-                        apply_ai_suggestions.delay_on_commit(
+                        apply_ai_suggestions.delay(
                             action_id=action.pk,
                             document_id=document.pk,
                         )

src/documents/tests/test_management_consumer.py

@@ -445,13 +445,12 @@ class TestConsumeFile:
         target = consumption_dir / "document.pdf"
         shutil.copy(sample_pdf, target)
 
-        result = _consume_file(
+        _consume_file(
             filepath=target,
             consumption_dir=consumption_dir,
             subdirs_as_tags=False,
         )
 
-        assert result is True
         mock_consume_file_delay.apply_async.assert_called_once()
         call_args = mock_consume_file_delay.apply_async.call_args
         consumable_doc = call_args.kwargs["kwargs"]["input_doc"]
@@ -465,12 +464,11 @@ class TestConsumeFile:
         mock_consume_file_delay: MagicMock,
     ) -> None:
         """Test _consume_file handles nonexistent files gracefully."""
-        result = _consume_file(
+        _consume_file(
             filepath=consumption_dir / "nonexistent.pdf",
             consumption_dir=consumption_dir,
             subdirs_as_tags=False,
         )
-        assert result is False
         mock_consume_file_delay.apply_async.assert_not_called()
 
     def test_consume_directory(
@@ -482,12 +480,11 @@ class TestConsumeFile:
         subdir = consumption_dir / "subdir"
         subdir.mkdir()
 
-        result = _consume_file(
+        _consume_file(
             filepath=subdir,
             consumption_dir=consumption_dir,
             subdirs_as_tags=False,
         )
-        assert result is False
         mock_consume_file_delay.apply_async.assert_not_called()
 
     def test_consume_with_permission_error(
@@ -502,33 +499,13 @@ class TestConsumeFile:
         shutil.copy(sample_pdf, target)
 
         mocker.patch.object(Path, "is_file", side_effect=PermissionError("denied"))
-        result = _consume_file(
+        _consume_file(
             filepath=target,
             consumption_dir=consumption_dir,
             subdirs_as_tags=False,
         )
-        assert result is False
         mock_consume_file_delay.apply_async.assert_not_called()
 
-    def test_consume_with_apply_async_failure(
-        self,
-        consumption_dir: Path,
-        sample_pdf: Path,
-        mock_consume_file_delay: MagicMock,
-    ) -> None:
-        """Test _consume_file reports failure when apply_async raises."""
-        target = consumption_dir / "document.pdf"
-        shutil.copy(sample_pdf, target)
-
-        mock_consume_file_delay.apply_async.side_effect = Exception("broker down")
-
-        result = _consume_file(
-            filepath=target,
-            consumption_dir=consumption_dir,
-            subdirs_as_tags=False,
-        )
-        assert result is False
-
     def test_consume_with_tags_error(
         self,
         consumption_dir: Path,
@@ -545,12 +522,11 @@ class TestConsumeFile:
             side_effect=DatabaseError("Something happened"),
         )
 
-        result = _consume_file(
+        _consume_file(
             filepath=target,
             consumption_dir=consumption_dir,
             subdirs_as_tags=True,
         )
-        assert result is True
         mock_consume_file_delay.apply_async.assert_called_once()
         call_args = mock_consume_file_delay.apply_async.call_args
         overrides = call_args.kwargs["kwargs"]["overrides"]
@@ -1273,52 +1249,6 @@ class TestProcessExistingFilesQueued:
         assert target.resolve() in queued
 
 
-@pytest.mark.management
-@pytest.mark.django_db
-class TestCommandRetryAfterQueueFailure:
-    """
-    Regression test for GH #13923.
-
-    A file whose ``apply_async`` publish fails (e.g. broker briefly down)
-    must not be marked as queued, so the periodic rescan retries it once
-    the broker recovers, instead of stranding it until the consumer
-    process is restarted.
-    """
-
-    def test_watch_loop_retries_failed_publish_on_rescan(
-        self,
-        consumption_dir: Path,
-        sample_pdf: Path,
-        mock_consume_file_delay: MagicMock,
-        start_consumer: Callable[..., ConsumerThread],
-    ) -> None:
-        """A publish failure from the watch loop is retried by the rescan."""
-        apply_async = mock_consume_file_delay.apply_async
-
-        def fail_first_call(*args: object, **kwargs: object) -> None:
-            if apply_async.call_count == 1:
-                raise Exception("broker down")
-
-        apply_async.side_effect = fail_first_call
-
-        thread = start_consumer(stability_delay=0.1, rescan_interval=0.3)
-
-        target = consumption_dir / "document.pdf"
-        shutil.copy(sample_pdf, target)
-
-        deadline = monotonic() + 5.0
-        while apply_async.call_count < 2 and monotonic() < deadline:
-            sleep(0.1)
-
-        if thread.exception:
-            raise thread.exception
-
-        assert apply_async.call_count >= 2, (
-            "Expected the failed publish to be retried by the rescan, "
-            f"but apply_async was only called {apply_async.call_count} time(s)"
-        )
-
-
 @pytest.mark.management
 @pytest.mark.django_db
 class TestCommandRescanRecovery:

src/documents/tests/test_workflows.py

@@ -5621,15 +5621,11 @@ class TestApplyAISuggestionsWorkflowAction(
         action = self.make_action()
         self.make_workflow(action, WorkflowTrigger.WorkflowTriggerType.DOCUMENT_ADDED)
 
-        with (
-            mock.patch("documents.tasks.apply_ai_suggestions.delay") as delay,
-            self.captureOnCommitCallbacks(execute=True),
-        ):
+        with mock.patch("documents.tasks.apply_ai_suggestions.delay") as delay:
             run_workflows(
                 WorkflowTrigger.WorkflowTriggerType.DOCUMENT_ADDED,
                 self.doc,
             )
-            delay.assert_not_called()
 
         delay.assert_called_once_with(action_id=action.pk, document_id=self.doc.pk)
 

src/paperless/settings/__init__.py

@@ -705,12 +705,6 @@ CELERY_BROKER_TRANSPORT_OPTIONS = {
 CELERY_TASK_TRACK_STARTED = True
 CELERY_TASK_TIME_LIMIT: Final[int] = get_int_from_env("PAPERLESS_WORKER_TIMEOUT", 1800)
 
-# https://docs.celeryq.dev/en/stable/userguide/configuration.html#std-setting-task_allow_error_cb_on_chord_header
-# Without this, a failing chord header never triggers the errback, so a mail
-# whose attachments all fail is never recorded and is re-fetched forever.
-# The errback runs once per failed header task, so it must be idempotent.
-CELERY_TASK_ALLOW_ERROR_CB_ON_CHORD_HEADER = True
-
 CELERY_CACHE_BACKEND = "default"
 
 # https://docs.celeryq.dev/en/stable/userguide/configuration.html#task-serializer

src/paperless_mail/mail.py

@@ -334,24 +334,18 @@ def error_callback(
     """
     A shared task that is called whenever something goes wrong during
     consumption of a file. See queue_consumption_tasks.
-
-    With CELERY_TASK_ALLOW_ERROR_CB_ON_CHORD_HEADER enabled this runs once per
-    failed header task, not once per chord, so it must be idempotent.
     """
     rule = MailRule.objects.get(pk=rule_id)
-    received = make_aware(message_date) if is_naive(message_date) else message_date
 
-    ProcessedMail.objects.get_or_create(
+    ProcessedMail.objects.create(
         rule=rule,
         folder=rule.folder,
         uid=message_uid,
         uid_validity=uid_validity,
-        defaults={
-            "subject": message_subject,
-            "received": received,
-            "status": "FAILED",
-            "error": traceback.format_exc(),
-        },
+        subject=message_subject,
+        received=make_aware(message_date) if is_naive(message_date) else message_date,
+        status="FAILED",
+        error=traceback.format_exc(),
     )