fix(user-files): skip embedded-image caps when image extraction is off (#14251) to release v4.6 (#14257)

Co-authored-by: Danelegend <43459662+Danelegend@users.noreply.github.com>
Co-authored-by: Claude Fable 5 <noreply@anthropic.com>

Author: 3 people

backend/onyx/file_processing/extract_file_text.py

@@ -896,22 +896,26 @@ def _extract_text_and_images(
     # Default processing
     try:
         extension = get_file_ext(file_name)
-        # docx example for embedded images
+        # One setting read per file. With extraction off, no image is decoded
+        # for any format, which is what lets upload validation skip its caps.
+        extract_images = get_image_extraction_and_analysis_enabled()
+
         if extension == ".docx":
             text_content, images = read_docx_file(
-                file, file_name, extract_images=True, image_callback=image_callback
+                file,
+                file_name,
+                extract_images=extract_images,
+                image_callback=image_callback,
             )
             return ExtractionResult(
                 text_content=text_content, embedded_images=images, metadata={}
             )
 
-        # PDF example: we do not show complicated PDF image extraction here
-        # so we simply extract text for now and skip images.
         if extension == ".pdf":
             text_content, pdf_metadata, images = read_pdf_file(
                 file,
                 pdf_pass,
-                extract_images=get_image_extraction_and_analysis_enabled(),
+                extract_images=extract_images,
                 image_callback=image_callback,
             )
             return ExtractionResult(
@@ -920,7 +924,10 @@ def _extract_text_and_images(
 
         if extension == ".pptx":
             text_content, images = read_pptx_file(
-                file, file_name, extract_images=True, image_callback=image_callback
+                file,
+                file_name,
+                extract_images=extract_images,
+                image_callback=image_callback,
             )
             return ExtractionResult(
                 text_content=text_content, embedded_images=images, metadata={}

backend/onyx/server/features/projects/projects_file_utils.py

@@ -269,10 +269,12 @@ def categorize_uploaded_files(
                 # images (either per-file or accumulated across this upload
                 # batch). A file with thousands of embedded images can OOM the
                 # user-file-processing celery worker because every image is
-                # decoded with PIL and then sent to the vision LLM.
+                # decoded with PIL and then sent to the vision LLM. With image
+                # extraction off, no image is ever decoded, so the caps (and
+                # the cost of counting) do not apply.
                 count: int = 0
                 image_bearing_ext = extension in (".pdf", ".docx")
-                if image_bearing_ext:
+                if image_bearing_ext and image_extraction_enabled:
                     file_cap = MAX_EMBEDDED_IMAGES_PER_FILE
                     batch_cap = MAX_EMBEDDED_IMAGES_PER_UPLOAD
                     # Use the larger of the two caps as the short-circuit
@@ -320,9 +322,9 @@ def categorize_uploaded_files(
                 if not text_content:
                     # Documents with embedded images (e.g. scans) have no
                     # extractable text but can still be indexed via the
-                    # vision-LLM captioning path when image analysis is
-                    # enabled.
-                    if image_bearing_ext and count > 0 and image_extraction_enabled:
+                    # vision-LLM captioning path. `count` is only populated
+                    # when image extraction is enabled.
+                    if image_bearing_ext and count > 0:
                         results.acceptable.append(upload)
                         results.acceptable_file_to_token_count[filename] = 0
                         try:
@@ -336,11 +338,15 @@ def categorize_uploaded_files(
                         continue
 
                     logger.warning("No text content extracted from '%s'", filename)
-                    results.rejected.append(
-                        RejectedFile(
-                            filename=filename,
-                            reason=f"Unsupported file type: {extension}",
+                    if image_bearing_ext and not image_extraction_enabled:
+                        reason = (
+                            "No text could be extracted, and image processing "
+                            "is disabled by an admin"
                         )
+                    else:
+                        reason = f"Unsupported file type: {extension}"
+                    results.rejected.append(
+                        RejectedFile(filename=filename, reason=reason)
                     )
                     continue
 

backend/tests/unit/onyx/file_processing/test_embedded_image_extraction_setting.py

@@ -0,0 +1,42 @@
+"""The workspace image-extraction setting gates embedded-image extraction for every
+image-bearing format, not only PDFs."""
+
+import io
+from typing import Any
+from unittest.mock import patch
+
+import pytest
+
+from onyx.file_processing.extract_file_text import extract_text_and_images
+
+_MOD = "onyx.file_processing.extract_file_text"
+
+
+@pytest.mark.parametrize("enabled", [True, False])
+@pytest.mark.parametrize(
+    "extension, reader, reader_return",
+    [
+        (".docx", "read_docx_file", ("text", [])),
+        (".pdf", "read_pdf_file", ("text", {}, [])),
+        (".pptx", "read_pptx_file", ("text", [])),
+    ],
+)
+def test_extract_images_follows_workspace_setting(
+    enabled: bool,
+    extension: str,
+    reader: str,
+    reader_return: tuple[Any, ...],
+) -> None:
+    with (
+        patch(f"{_MOD}.get_unstructured_api_key", return_value=None),
+        patch(
+            f"{_MOD}.get_image_extraction_and_analysis_enabled",
+            return_value=enabled,
+        ),
+        patch(f"{_MOD}.{reader}", return_value=reader_return) as mock_reader,
+    ):
+        result = extract_text_and_images(io.BytesIO(b"bytes"), f"doc{extension}")
+
+    assert result.text_content == "text"
+    mock_reader.assert_called_once()
+    assert mock_reader.call_args.kwargs["extract_images"] is enabled

backend/tests/unit/onyx/server/test_projects_file_utils.py

@@ -478,3 +478,71 @@ def test_pdf_over_token_threshold_rejected(
     assert result.rejected[0].filename == "big.pdf"
     assert "1K token limit" in result.rejected[0].reason
     assert len(result.acceptable) == 0
+
+
+_IMAGE_BEARING_CASES = [
+    ("many_images.pdf", "count_pdf_embedded_images"),
+    ("many_images.docx", "count_docx_embedded_images"),
+]
+
+
+@pytest.mark.parametrize("filename, counter_name", _IMAGE_BEARING_CASES)
+def test_many_images_accepted_when_image_extraction_disabled(
+    monkeypatch: pytest.MonkeyPatch, filename: str, counter_name: str
+) -> None:
+    """With image extraction off, no image is ever decoded, so the embedded-image
+    caps do not apply and the (expensive) count is skipped."""
+    _patch_common_dependencies(monkeypatch, upload_size_mb=1000)
+    monkeypatch.setattr(
+        utils, "get_image_extraction_and_analysis_enabled", lambda: False
+    )
+    counter = MagicMock(return_value=utils.MAX_EMBEDDED_IMAGES_PER_FILE + 1)
+    monkeypatch.setattr(utils, counter_name, counter)
+    monkeypatch.setattr(utils, "extract_file_text", lambda **_kwargs: "some text")
+
+    upload = _make_upload(filename, size=100)
+    result = utils.categorize_uploaded_files([upload], MagicMock())
+
+    assert result.rejected == []
+    assert result.acceptable == [upload]
+    counter.assert_not_called()
+
+
+@pytest.mark.parametrize("filename, counter_name", _IMAGE_BEARING_CASES)
+def test_many_images_rejected_when_image_extraction_enabled(
+    monkeypatch: pytest.MonkeyPatch, filename: str, counter_name: str
+) -> None:
+    _patch_common_dependencies(monkeypatch, upload_size_mb=1000)
+    monkeypatch.setattr(
+        utils, "get_image_extraction_and_analysis_enabled", lambda: True
+    )
+    counter = MagicMock(return_value=utils.MAX_EMBEDDED_IMAGES_PER_FILE + 1)
+    monkeypatch.setattr(utils, counter_name, counter)
+    monkeypatch.setattr(utils, "extract_file_text", lambda **_kwargs: "some text")
+
+    upload = _make_upload(filename, size=100)
+    result = utils.categorize_uploaded_files([upload], MagicMock())
+
+    counter.assert_called_once()
+    assert result.acceptable == []
+    assert len(result.rejected) == 1
+    assert "too many embedded images" in result.rejected[0].reason
+
+
+@pytest.mark.parametrize("filename", ["scan.pdf", "scan.docx"])
+def test_no_text_rejected_with_image_processing_disabled_reason(
+    monkeypatch: pytest.MonkeyPatch, filename: str
+) -> None:
+    """A scan-only document cannot be indexed when captioning is off; say why."""
+    _patch_common_dependencies(monkeypatch, upload_size_mb=1000)
+    monkeypatch.setattr(
+        utils, "get_image_extraction_and_analysis_enabled", lambda: False
+    )
+    monkeypatch.setattr(utils, "extract_file_text", lambda **_kwargs: "")
+
+    upload = _make_upload(filename, size=100)
+    result = utils.categorize_uploaded_files([upload], MagicMock())
+
+    assert result.acceptable == []
+    assert len(result.rejected) == 1
+    assert "image processing is disabled" in result.rejected[0].reason