classifyre-cli 0.4.55__tar.gz → 0.4.56__tar.gz

{classifyre_cli-0.4.55 → classifyre_cli-0.4.56}/.turbo/turbo-build.log

@@ -1,3 +1,3 @@
 $ uv sync
-Resolved 292 packages in 12ms
+Resolved 292 packages in 322ms
 Checked 51 packages in 1ms

{classifyre_cli-0.4.55 → classifyre_cli-0.4.56}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: classifyre-cli
-Version: 0.4.55
+Version: 0.4.56
 Summary: Classifyre CLI — scan and classify unstructured data sources
 License: MIT
 Keywords: data,ingestion,metadata,pii,secrets,unstructured

{classifyre_cli-0.4.55 → classifyre_cli-0.4.56}/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@classifyre/cli",
-  "version": "0.4.55",
+  "version": "0.4.56",
   "private": true,
   "scripts": {
     "build": "uv sync",

{classifyre_cli-0.4.55 → classifyre_cli-0.4.56}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "classifyre-cli"
-version = "0.4.55"
+version = "0.4.56"
 description = "Classifyre CLI — scan and classify unstructured data sources"
 readme = "README.md"
 requires-python = ">=3.12"
@@ -83,7 +83,6 @@ content = [
 ]
 quality = [
     "datasketch>=1.10.0",
-    "sentence-transformers>=5.5.0",
     "textstat>=0.7.13",
     "transformers>=4.50.0,<6.0.0",
     "torch>=2.12.0",
@@ -101,7 +100,6 @@ custom = [
     "datasets>=4.8.5",
     "scikit-learn>=1.7.2",
     "gliner2>=1.3.1",
-    "sentence-transformers>=5.5.0",
     # Direct declaration so the [tool.uv.sources] cpu-index pin applies (timm
     # pulls torchvision transitively; see the ocr group note).
     "torchvision>=0.27.0",

{classifyre_cli-0.4.55 → classifyre_cli-0.4.56}/src/detectors/custom/runners/__init__.py

@@ -14,7 +14,6 @@ from ._base import (
     _resolve_pipeline_severity,
 )
 from ._factory import create_runner
-from ._feature_extraction import FeatureExtractionRunner, _chunk_text_with_offsets, _pool_hidden
 from ._gliner2 import (
     GLiNER2Runner,
     _apply_classification_validation,
@@ -35,7 +34,6 @@ __all__ = [
     "_IMAGE_CONTENT_TYPES",
     "_TEXT_CONTENT_TYPES",
     "BaseRunner",
-    "FeatureExtractionRunner",
     "GLiNER2Runner",
     "ImageClassificationRunner",
     "LLMRunner",
@@ -45,12 +43,10 @@ __all__ = [
     "_apply_classification_validation",
     "_apply_entity_validation",
     "_chunk_text",
-    "_chunk_text_with_offsets",
     "_load_regex_engine",
     "_normalise_classification_output",
     "_normalise_entity_output",
     "_normalise_span",
-    "_pool_hidden",
     "_resolve_pipeline_severity",
     "create_runner",
 ]

{classifyre_cli-0.4.55 → classifyre_cli-0.4.56}/src/detectors/custom/runners/_factory.py

@@ -3,7 +3,6 @@
 from __future__ import annotations
 
 from ....models.generated_detectors import (
-    FeatureExtractionPipelineSchema,
     GLiNER2PipelineSchema,
     ImageClassificationPipelineSchema,
     LLMPipelineSchema,
@@ -12,7 +11,6 @@ from ....models.generated_detectors import (
     TextClassificationPipelineSchema,
 )
 from ._base import BaseRunner
-from ._feature_extraction import FeatureExtractionRunner
 from ._gliner2 import GLiNER2Runner
 from ._image_classification import ImageClassificationRunner
 from ._llm import LLMRunner
@@ -28,7 +26,6 @@ def create_runner(
         | LLMPipelineSchema
         | TextClassificationPipelineSchema
         | ImageClassificationPipelineSchema
-        | FeatureExtractionPipelineSchema
         | ObjectDetectionPipelineSchema
     ),
     detector_key: str = "",
@@ -39,8 +36,6 @@ def create_runner(
         return TextClassificationRunner(schema, detector_key, detector_name)
     if isinstance(schema, ImageClassificationPipelineSchema):
         return ImageClassificationRunner(schema, detector_key, detector_name)
-    if isinstance(schema, FeatureExtractionPipelineSchema):
-        return FeatureExtractionRunner(schema, detector_key, detector_name)
     if isinstance(schema, ObjectDetectionPipelineSchema):
         return ObjectDetectionRunner(schema, detector_key, detector_name)
     if isinstance(schema, RegexPipelineSchema):

{classifyre_cli-0.4.55 → classifyre_cli-0.4.56}/src/main.py

@@ -264,7 +264,7 @@ async def run_command_async(args: argparse.Namespace, recipe: dict[str, Any]) ->
                     logger.info("Phase 1 complete: %d assets discovered", total_assets)
 
                     # --- Phase 2: Processing ---
-                    if has_detectors and all_stubs:
+                    if all_stubs:
                         import asyncio as _asyncio
 
                         processed_count = 0
@@ -319,6 +319,10 @@ async def run_command_async(args: argparse.Namespace, recipe: dict[str, Any]) ->
                                 )
                                 payload = _asset_to_payload(result)
                                 await sink.emit_batch([payload], skip_findings=False)
+                                if hasattr(sink, "emit_text_chunks"):
+                                    artifact = pipeline.take_text_artifact(asset_hash)
+                                    if artifact is not None:
+                                        await sink.emit_text_chunks(asset_hash, artifact)
 
                                 if hasattr(sink, "update_asset_status"):
                                     f_total, f_by_sev, f_by_det = _compute_findings_counts(
@@ -353,22 +357,6 @@ async def run_command_async(args: argparse.Namespace, recipe: dict[str, Any]) ->
                             processed_count,
                             error_count,
                         )
-                    elif all_stubs and hasattr(sink, "update_asset_status"):
-                        # No detectors configured: mark discovered assets as PROCESSED
-                        import asyncio as _asyncio
-
-                        async def _mark_processed(asset: Any) -> None:
-                            asset_hash = getattr(asset, "hash", None) or ""
-                            await sink.update_asset_status(
-                                asset_hash, "PROCESSED", findings_total=0
-                            )
-
-                        tasks = [_asyncio.create_task(_mark_processed(a)) for a in all_stubs]
-                        await _asyncio.gather(*tasks, return_exceptions=True)
-                        logger.info(
-                            "Phase 2 skipped (no detectors): %d assets marked processed",
-                            len(all_stubs),
-                        )
 
                     # Persist the advanced AUTOMATIC sampling cursor (no-op for
                     # other strategies, which return None). Only on the normal

{classifyre_cli-0.4.55 → classifyre_cli-0.4.56}/src/models/generated_detectors.py

@@ -1255,78 +1255,6 @@ class ImageClassificationPipelineSchema(BaseModel):
 
 
 class Type7(StrEnum):
-    FEATURE_EXTRACTION = 'FEATURE_EXTRACTION'
-
-
-class PoolingStrategy(StrEnum):
-    """
-    How to aggregate per-token hidden states into a single embedding vector.
-    """
-
-    mean = 'mean'
-    cls = 'cls'
-    max = 'max'
-    none = 'none'
-
-
-class ChunkSize2(RootModel[int]):
-    root: int = Field(
-        None,
-        description='Split text into chunks of this many characters before embedding. Each chunk produces its own finding.',
-        ge=1,
-    )
-
-
-class FeatureExtractionPipelineSchema(BaseModel):
-    """
-    Feature extraction (embedding) pipeline using a HuggingFace model. Runs a single encoder; create multiple custom detectors to run multiple embedding models.
-    """
-
-    model_config = ConfigDict(
-        extra='forbid',
-    )
-    type: Literal['FEATURE_EXTRACTION']
-    model: str = Field(
-        ...,
-        description="HuggingFace hub ID (e.g. 'BAAI/bge-base-en-v1.5', 'sentence-transformers/all-MiniLM-L6-v2') or absolute local directory path.",
-    )
-    model_revision: str | None = Field(
-        None,
-        description='Git branch, tag, or commit hash when fetching from the HuggingFace hub.',
-    )
-    device: str | None = Field(
-        'cpu',
-        description="Inference device: 'cpu' (default), 'cuda', 'mps', or a CUDA device string like 'cuda:0'.",
-    )
-    pooling_strategy: PoolingStrategy | None = Field(
-        'mean',
-        description='How to aggregate per-token hidden states into a single embedding vector.',
-    )
-    normalize_embeddings: bool | None = Field(
-        True,
-        description='L2-normalise the final embedding vector. Recommended for cosine-similarity workloads.',
-    )
-    truncation: bool | None = Field(
-        True, description="Truncate input to the model's maximum sequence length."
-    )
-    max_length: int | None = Field(
-        None, description="Override the tokenizer's default maximum sequence length."
-    )
-    batch_size: int | None = Field(
-        8, description='Number of texts to encode in a single forward pass.'
-    )
-    chunk_size: ChunkSize2 | None = Field(
-        None,
-        description='Split text into chunks of this many characters before embedding. Each chunk produces its own finding.',
-    )
-    chunk_overlap: ChunkOverlap1 | None = Field(
-        0,
-        description='Character overlap between consecutive chunks.',
-        validate_default=True,
-    )
-
-
-class Type8(StrEnum):
     OBJECT_DETECTION = 'OBJECT_DETECTION'
 
 
@@ -1407,7 +1335,6 @@ class CustomDetectorConfig(DetectorConfig):
         | LLMPipelineSchema
         | TextClassificationPipelineSchema
         | ImageClassificationPipelineSchema
-        | FeatureExtractionPipelineSchema
         | ObjectDetectionPipelineSchema
         | None
     ) = Field(None, discriminator='type', title='AnyPipelineSchema')

{classifyre_cli-0.4.55 → classifyre_cli-0.4.56}/src/models/generated_single_asset_scan_results.py

@@ -87,6 +87,19 @@ class Location(BaseModel):
     end: int | None = Field(None, description='End offset (0-indexed)')
 
 
+class TextExtractionStatus(StrEnum):
+    """
+    Structured text coverage outcome. EXTRACTED means detector-visible text was produced. EMPTY means extraction completed without an error but yielded no text. ENGINE_UNAVAILABLE, ZERO_FRAMES, and FAILED are incomplete coverage states and must not be treated as an empty document.
+    """
+
+    NOT_APPLICABLE = 'NOT_APPLICABLE'
+    EXTRACTED = 'EXTRACTED'
+    EMPTY = 'EMPTY'
+    ENGINE_UNAVAILABLE = 'ENGINE_UNAVAILABLE'
+    ZERO_FRAMES = 'ZERO_FRAMES'
+    FAILED = 'FAILED'
+
+
 class DetectionResult(BaseModel):
     """
     Result from detector scan
@@ -221,6 +234,10 @@ class ScanStats(BaseModel):
         None,
         description="True when an asset that should carry text yielded none. Most significant for assets whose text is derived rather than native (OCR'd images and scanned PDFs, transcribed audio/video): empty derived text means the content may have been missed entirely, not that the document is blank. Distinct from an error — nothing failed — so it is reported as coverage, not as a run failure.",
     )
+    text_extraction_status: TextExtractionStatus | None = Field(
+        None,
+        description='Structured text coverage outcome. EXTRACTED means detector-visible text was produced. EMPTY means extraction completed without an error but yielded no text. ENGINE_UNAVAILABLE, ZERO_FRAMES, and FAILED are incomplete coverage states and must not be treated as an empty document.',
+    )
     findings_count: int | None = Field(
         None, description='Total number of findings detected'
     )

{classifyre_cli-0.4.55 → classifyre_cli-0.4.56}/src/outputs/rest.py

@@ -10,6 +10,7 @@ from pydantic import BaseModel, ConfigDict, Field
 from requests.adapters import HTTPAdapter
 from urllib3.util.retry import Retry  # type: ignore[import-untyped]
 
+from ..pipeline.text_artifact import TextArtifact
 from .base import OutputRuntimeContext, OutputType
 
 logger = logging.getLogger(__name__)
@@ -223,6 +224,15 @@ class RestOutputSink:
                 payload.model_dump(mode="json", by_alias=True),
             )
 
+    async def emit_text_chunks(self, asset_hash: str, artifact: TextArtifact) -> None:
+        """Send extracted text provenance; the API embeds it asynchronously."""
+        source_id = self._require_source_id()
+        self._request_json(
+            "POST",
+            f"/sources/{source_id}/embeddings/chunks",
+            {"assetHash": asset_hash, "chunks": artifact.chunks},
+        )
+
     def _split_by_size(self, assets: list[dict[str, Any]]) -> list[list[dict[str, Any]]]:
         """Split assets into chunks that each stay under _MAX_BATCH_BYTES."""
         import json as _json

classifyre_cli-0.4.56/src/pipeline/__init__.py

@@ -0,0 +1,25 @@
+"""Pipeline for processing assets through detectors.
+
+Exports are lazy so lightweight callers do not import the detector and source
+graph (which itself uses the REST output types).
+"""
+
+from typing import Any
+
+__all__ = ["ContentProvider", "DetectorPipeline", "ParsedContentProvider"]
+
+
+def __getattr__(name: str) -> Any:
+    if name == "ContentProvider":
+        from .content_provider import ContentProvider
+
+        return ContentProvider
+    if name == "DetectorPipeline":
+        from .detector_pipeline import DetectorPipeline
+
+        return DetectorPipeline
+    if name == "ParsedContentProvider":
+        from .parsed_content_provider import ParsedContentProvider
+
+        return ParsedContentProvider
+    raise AttributeError(name)

{classifyre_cli-0.4.55 → classifyre_cli-0.4.56}/src/pipeline/detector_pipeline.py

@@ -20,10 +20,12 @@ from ..models.generated_single_asset_scan_results import (
     ScanStats,
     SingleAssetScanResults,
     Status,
+    TextExtractionStatus,
 )
 from ..sources.base import BaseSource
-from ..utils.file_parser import resolve_mime_type
+from ..utils.file_parser import TextExtractionCoverageError, resolve_mime_type
 from .content_provider import ContentProvider
+from .text_artifact import TextArtifact
 from .worker_pool import DetectorWorkerPool, is_io_bound_detector
 
 logger = logging.getLogger(__name__)
@@ -67,6 +69,12 @@ class DetectorPipeline:
 
             self.content_provider = ParsedContentProvider(source)
         self.init_warnings: list[str] = []
+        self._text_artifacts: dict[str, TextArtifact] = {}
+        self._text_extraction_errors: dict[str, list[str]] = {}
+        self._text_extraction_statuses: dict[str, TextExtractionStatus] = {}
+
+    def take_text_artifact(self, asset_hash: str) -> TextArtifact | None:
+        return self._text_artifacts.pop(asset_hash, None)
 
     def _register_detector_info(self, detector: BaseDetector, info: _DetectorInfo) -> None:
         self._detector_info[id(detector)] = info
@@ -105,10 +113,6 @@ class DetectorPipeline:
         findings_flush_size: int = 50,
     ) -> SingleAssetScanResults:
         """Process a single asset through detectors."""
-        if not self.detectors:
-            asset.findings = []
-            return asset
-
         scan_started = datetime.now(UTC)
         text_content_type = self._text_content_type_for_asset(asset.asset_type)
         link_content = self._build_links_payload(asset.links)
@@ -167,8 +171,10 @@ class DetectorPipeline:
         # Per-asset, per-detector outcomes. Local to this call, so concurrent
         # assets never share it.
         outcome_sink: dict[tuple[DetectorType, str | None], DetectorOutcome] = {}
+        artifact = TextArtifact()
+        self._text_artifacts[str(asset.hash)] = artifact
 
-        if text_detectors:
+        if text_content_type:
             (
                 text_findings,
                 text_detector_types_run,
@@ -187,6 +193,7 @@ class DetectorPipeline:
             findings.extend(text_findings)
             scan_warnings.extend(text_warnings)
             scan_errors.extend(text_errors)
+            scan_errors.extend(self._text_extraction_errors.pop(str(asset.hash), []))
             detector_types_run = self._merge_detector_types(
                 detector_types_run,
                 text_detector_types_run,
@@ -243,6 +250,16 @@ class DetectorPipeline:
             # Structured rather than left for a consumer to parse out of the
             # warning strings, so missing-text coverage is queryable.
             empty_text=should_warn_on_empty_text and content_size == 0,
+            text_extraction_status=self._text_extraction_statuses.pop(
+                str(asset.hash),
+                (
+                    TextExtractionStatus.EXTRACTED
+                    if text_content_type and content_size > 0
+                    else TextExtractionStatus.EMPTY
+                    if text_content_type
+                    else TextExtractionStatus.NOT_APPLICABLE
+                ),
+            ),
             findings_count=len(findings),
             warnings=scan_warnings or None,
             errors=scan_errors or None,
@@ -354,6 +371,7 @@ class DetectorPipeline:
         async for text_content in self._iter_text_content_pages(asset):
             page_index += 1
             content_size += len(text_content)
+            self._text_artifacts[str(asset.hash)].add_page(text_content, page_index)
 
             if not text_content:
                 continue
@@ -484,6 +502,7 @@ class DetectorPipeline:
         async for text_content in self._iter_text_content_pages(asset):
             page_index += 1
             content_size += len(text_content)
+            self._text_artifacts[str(asset.hash)].add_page(text_content, page_index)
 
             if not text_content:
                 continue
@@ -535,11 +554,23 @@ class DetectorPipeline:
 
         for candidate_id in candidate_ids:
             saw_candidate_content = False
-            async for text_content in self.content_provider.fetch_text_pages(candidate_id):
-                if not text_content:
-                    continue
-                saw_candidate_content = True
-                yield text_content
+            try:
+                async for text_content in self.content_provider.fetch_text_pages(candidate_id):
+                    if not text_content:
+                        continue
+                    saw_candidate_content = True
+                    yield text_content
+            except TextExtractionCoverageError as exc:
+                # Text extraction failure must not discard independent link or
+                # binary detector results. The structured empty-text coverage
+                # signal still records that this asset was not embedded.
+                message = f"Text extraction failed for {candidate_id}: {exc}"
+                logger.warning(message)
+                self._text_extraction_errors.setdefault(str(asset.hash), []).append(message)
+                self._text_extraction_statuses[str(asset.hash)] = TextExtractionStatus(
+                    exc.code.value
+                )
+                return
 
             if saw_candidate_content:
                 return

classifyre_cli-0.4.56/src/pipeline/text_artifact.py

@@ -0,0 +1,54 @@
+"""Extracted text chunks sent to the API for asynchronous semantic indexing."""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass, field
+from typing import Any
+
+_WHITESPACE = re.compile(r"\s+")
+
+
+def normalize_text(text: str) -> str:
+    return _WHITESPACE.sub(" ", text).strip()
+
+
+def chunk_text_with_offsets(
+    text: str, *, max_chars: int = 1200, overlap_chars: int = 200
+) -> list[tuple[str, int, int]]:
+    normalized = normalize_text(text)
+    if not normalized:
+        return []
+    chunks: list[tuple[str, int, int]] = []
+    start = 0
+    while start < len(normalized):
+        end = min(len(normalized), start + max_chars)
+        if end < len(normalized):
+            boundary = normalized.rfind(" ", start + max_chars // 2, end)
+            if boundary > start:
+                end = boundary
+        value = normalized[start:end].strip()
+        if value:
+            actual_start = normalized.find(value, start, end + 1)
+            chunks.append((value, actual_start, len(value)))
+        if end >= len(normalized):
+            break
+        start = max(start + 1, end - overlap_chars)
+    return chunks
+
+
+@dataclass
+class TextArtifact:
+    chunks: list[dict[str, Any]] = field(default_factory=list)
+
+    def add_page(self, text: str, page: int) -> None:
+        for value, offset, length in chunk_text_with_offsets(text):
+            self.chunks.append(
+                {
+                    "ordinal": len(self.chunks),
+                    "page": page,
+                    "charOffset": offset,
+                    "charLength": length,
+                    "text": value,
+                }
+            )

{classifyre_cli-0.4.55 → classifyre_cli-0.4.56}/src/pipeline/worker_pool.py

@@ -158,7 +158,6 @@ _ML_PIPELINE_TYPES = frozenset(
         "GLINER2",
         "TEXT_CLASSIFICATION",
         "IMAGE_CLASSIFICATION",
-        "FEATURE_EXTRACTION",
         "OBJECT_DETECTION",
     }
 )

{classifyre_cli-0.4.55 → classifyre_cli-0.4.56}/src/utils/file_parser.py

@@ -7,12 +7,34 @@ import tempfile
 import threading
 from collections.abc import Generator
 from dataclasses import dataclass
+from enum import StrEnum
 from pathlib import Path
 from urllib.parse import urlsplit
 
 logger = logging.getLogger(__name__)
 
 
+class TextExtractionCoverageCode(StrEnum):
+    """Machine-readable reason detector-visible text could not be produced."""
+
+    ENGINE_UNAVAILABLE = "ENGINE_UNAVAILABLE"
+    ZERO_FRAMES = "ZERO_FRAMES"
+    FAILED = "FAILED"
+
+
+class TextExtractionCoverageError(RuntimeError):
+    """Extraction failed after source content was fetched successfully."""
+
+    def __init__(
+        self,
+        message: str,
+        *,
+        code: TextExtractionCoverageCode = TextExtractionCoverageCode.FAILED,
+    ) -> None:
+        super().__init__(message)
+        self.code = code
+
+
 @dataclass
 class ParsedFile:
     """Result of parsing a local file."""
@@ -432,6 +454,7 @@ def extract_text(
     Returns:
         (text_content, error_message_or_None)
     """
+    ocr_error: str | None = None
     if _supports_docling_ocr(mime_type, file_name):
         # PDFs: try cheap native text extraction first.  Only hand off to the
         # heavy docling pipeline when the native path yields too little text,
@@ -460,6 +483,7 @@ def extract_text(
             return text, None
         if error:
             logger.warning("OCR extraction failed for %s: %s", file_name or mime_type, error)
+            ocr_error = error
 
     # Media processing is based on detected content type, never source config.
     if mime_type.startswith("audio/"):
@@ -497,11 +521,12 @@ def extract_text(
     # Unsupported image formats have no native text path; supported images were
     # already handled by the automatic OCR branch above.
     if mime_type.startswith("image/"):
-        return "", None
+        return "", ocr_error
 
     # PDF
     if mime_type == "application/pdf":
-        return _extract_pdf_text(file_bytes)
+        native_text, native_error = _extract_pdf_text(file_bytes)
+        return native_text, native_error or ocr_error
 
     # DOCX
     if mime_type == "application/vnd.openxmlformats-officedocument.wordprocessingml.document":
@@ -576,7 +601,7 @@ def extract_text(
             return "", f"Parquet extraction failed: {e}"
 
     # Unknown / binary
-    return "", None
+    return "", ocr_error
 
 
 def _decode_bytes(file_bytes: bytes) -> str:
@@ -707,7 +732,11 @@ def iter_file_pages(
         )
     elif normalized.startswith("video/"):
         from .transcription import iter_transcription_pages
-        from .video_processing import iter_video_ocr_segments
+        from .video_processing import (
+            VideoOCREngineUnavailableError,
+            VideoOCRZeroFramesError,
+            iter_video_ocr_segments,
+        )
 
         try:
             yield from iter_transcription_pages(
@@ -721,7 +750,15 @@ def iter_file_pages(
         try:
             yield from iter_video_ocr_segments(file_bytes, file_name=file_name)
         except Exception as exc:
-            logger.warning("Video OCR failed for %s: %s", file_name or mime_type, exc)
+            code = TextExtractionCoverageCode.FAILED
+            if isinstance(exc, VideoOCREngineUnavailableError):
+                code = TextExtractionCoverageCode.ENGINE_UNAVAILABLE
+            elif isinstance(exc, VideoOCRZeroFramesError):
+                code = TextExtractionCoverageCode.ZERO_FRAMES
+            raise TextExtractionCoverageError(
+                f"Video OCR coverage failed for {file_name or mime_type}: {exc}",
+                code=code,
+            ) from exc
     else:
         text, error = extract_text(
             file_bytes,
@@ -730,6 +767,17 @@ def iter_file_pages(
         )
         if error:
             logger.warning("Text extraction error (%s): %s", mime_type, error)
+            if not text:
+                normalized_error = error.casefold()
+                unavailable = "unavailable" in normalized_error or "dependency" in normalized_error
+                raise TextExtractionCoverageError(
+                    f"Text extraction coverage failed for {file_name or mime_type}: {error}",
+                    code=(
+                        TextExtractionCoverageCode.ENGINE_UNAVAILABLE
+                        if unavailable
+                        else TextExtractionCoverageCode.FAILED
+                    ),
+                )
         if text:
             yield from _iter_text_lines(text, batch_size)