kreuzberg 3.8.2__py3-none-any.whl → 3.9.0__py3-none-any.whl

kreuzberg/_chunker.py

@@ -2,9 +2,9 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING
 
-from kreuzberg import MissingDependencyError
 from kreuzberg._constants import DEFAULT_MAX_CHARACTERS, DEFAULT_MAX_OVERLAP
 from kreuzberg._mime_types import MARKDOWN_MIME_TYPE
+from kreuzberg.exceptions import MissingDependencyError
 
 if TYPE_CHECKING:
     from semantic_text_splitter import MarkdownSplitter, TextSplitter
@@ -36,11 +36,11 @@ def get_chunker(
     if key not in _chunkers:
         try:
             if mime_type == MARKDOWN_MIME_TYPE:
-                from semantic_text_splitter import MarkdownSplitter
+                from semantic_text_splitter import MarkdownSplitter  # noqa: PLC0415
 
                 _chunkers[key] = MarkdownSplitter(max_characters, overlap_characters)
             else:
-                from semantic_text_splitter import TextSplitter
+                from semantic_text_splitter import TextSplitter  # noqa: PLC0415
 
                 _chunkers[key] = TextSplitter(max_characters, overlap_characters)
         except ImportError as e:

kreuzberg/_config.py

@@ -95,7 +95,7 @@ def parse_ocr_backend_config(
         # Convert psm integer to PSMMode enum if needed
         processed_config = backend_config.copy()
         if "psm" in processed_config and isinstance(processed_config["psm"], int):
-            from kreuzberg._ocr._tesseract import PSMMode
+            from kreuzberg._ocr._tesseract import PSMMode  # noqa: PLC0415
 
             processed_config["psm"] = PSMMode(processed_config["psm"])
         return TesseractConfig(**processed_config)

kreuzberg/_document_classification.py

@@ -0,0 +1,156 @@
+from __future__ import annotations
+
+import re
+from typing import TYPE_CHECKING
+
+from kreuzberg._ocr import get_ocr_backend
+from kreuzberg.exceptions import MissingDependencyError
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+    from kreuzberg._types import ExtractionConfig, ExtractionResult
+
+
+DOCUMENT_CLASSIFIERS = {
+    "invoice": [
+        r"invoice",
+        r"bill to",
+        r"invoice number",
+        r"total amount",
+        r"tax id",
+    ],
+    "receipt": [
+        r"receipt",
+        r"cash receipt",
+        r"payment",
+        r"subtotal",
+        r"total due",
+    ],
+    "contract": [
+        r"agreement",
+        r"contract",
+        r"party a",
+        r"party b",
+        r"terms and conditions",
+        r"signature",
+    ],
+    "report": [r"report", r"summary", r"analysis", r"findings", r"conclusion"],
+    "form": [r"form", r"fill out", r"signature", r"date", r"submit"],
+}
+
+
+def _get_translated_text(result: ExtractionResult) -> str:
+    """Translate extracted text to English using Google Translate API.
+
+    Args:
+        result: ExtractionResult containing the text to be translated
+
+    Returns:
+        str: The translated text in lowercase English
+
+    Raises:
+        MissingDependencyError: If the deep-translator package is not installed
+    """
+    try:
+        from deep_translator import GoogleTranslator  # noqa: PLC0415
+    except ImportError as e:
+        raise MissingDependencyError(
+            "The 'deep-translator' library is not installed. Please install it with: pip install 'kreuzberg[auto-classify-document-type]'"
+        ) from e
+
+    return str(GoogleTranslator(source="auto", target="en").translate(result.content).lower())
+
+
+def classify_document(result: ExtractionResult, config: ExtractionConfig) -> tuple[str | None, float | None]:
+    """Classifies the document type based on keywords and patterns.
+
+    Args:
+        result: The extraction result containing the content.
+        config: The extraction configuration.
+
+    Returns:
+        A tuple containing the detected document type and the confidence score,
+        or (None, None) if no type is detected with sufficient confidence.
+    """
+    translated_text = _get_translated_text(result)
+    scores = dict.fromkeys(DOCUMENT_CLASSIFIERS, 0)
+
+    for doc_type, patterns in DOCUMENT_CLASSIFIERS.items():
+        for pattern in patterns:
+            if re.search(pattern, translated_text):
+                scores[doc_type] += 1
+
+    total_score = sum(scores.values())
+    if total_score == 0:
+        return None, None
+
+    confidences = {doc_type: score / total_score for doc_type, score in scores.items()}
+
+    best_type, best_confidence = max(confidences.items(), key=lambda item: item[1])
+
+    if best_confidence >= config.document_type_confidence_threshold:
+        return best_type, best_confidence
+
+    return None, None
+
+
+def classify_document_from_layout(
+    result: ExtractionResult, config: ExtractionConfig
+) -> tuple[str | None, float | None]:
+    """Classifies the document type based on layout information from OCR.
+
+    Args:
+        result: The extraction result containing the layout data.
+        config: The extraction configuration.
+
+    Returns:
+        A tuple containing the detected document type and the confidence score,
+        or (None, None) if no type is detected with sufficient confidence.
+    """
+    translated_text = _get_translated_text(result)
+
+    if result.layout is None or result.layout.empty:
+        return None, None
+
+    layout_df = result.layout
+    if not all(col in layout_df.columns for col in ["text", "top", "height"]):
+        return None, None
+
+    layout_df["translated_text"] = translated_text
+
+    page_height = layout_df["top"].max() + layout_df["height"].max()
+    scores = dict.fromkeys(DOCUMENT_CLASSIFIERS, 0.0)
+
+    for doc_type, patterns in DOCUMENT_CLASSIFIERS.items():
+        for pattern in patterns:
+            found_words = layout_df[layout_df["translated_text"].str.contains(pattern, case=False, na=False)]
+            if not found_words.empty:
+                scores[doc_type] += 1.0
+                word_top = found_words.iloc[0]["top"]
+                if word_top < page_height * 0.3:
+                    scores[doc_type] += 0.5
+
+    total_score = sum(scores.values())
+    if total_score == 0:
+        return None, None
+
+    confidences = {doc_type: score / total_score for doc_type, score in scores.items()}
+
+    best_type, best_confidence = max(confidences.items(), key=lambda item: item[1])
+
+    if best_confidence >= config.document_type_confidence_threshold:
+        return best_type, best_confidence
+
+    return None, None
+
+
+def auto_detect_document_type(
+    result: ExtractionResult, config: ExtractionConfig, file_path: Path | None = None
+) -> ExtractionResult:
+    if config.document_classification_mode == "vision" and file_path:
+        layout_result = get_ocr_backend("tesseract").process_file_sync(file_path, **config.get_config_dict())
+        result.document_type, result.document_type_confidence = classify_document_from_layout(layout_result, config)
+    else:
+        result.document_type, result.document_type_confidence = classify_document(result, config)
+    return result

kreuzberg/_entity_extraction.py

@@ -138,7 +138,7 @@ def extract_entities(
         spacy_config = SpacyEntityExtractionConfig()
 
     try:
-        import spacy  # noqa: F401
+        import spacy  # noqa: F401, PLC0415
     except ImportError as e:
         raise MissingDependencyError.create_for_package(
             package_name="spacy",
@@ -179,7 +179,7 @@ def extract_entities(
 def _load_spacy_model(model_name: str, spacy_config: SpacyEntityExtractionConfig) -> Any:
     """Load a spaCy model with caching."""
     try:
-        import spacy
+        import spacy  # noqa: PLC0415
 
         if spacy_config.model_cache_dir:
             os.environ["SPACY_DATA"] = str(spacy_config.model_cache_dir)
@@ -223,7 +223,7 @@ def extract_keywords(
         MissingDependencyError: If `keybert` is not installed.
     """
     try:
-        from keybert import KeyBERT
+        from keybert import KeyBERT  # noqa: PLC0415
 
         kw_model = KeyBERT()
         keywords = kw_model.extract_keywords(text, top_n=keyword_count)

kreuzberg/_extractors/_image.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import contextlib
 import os
 import tempfile
+from dataclasses import asdict
 from pathlib import Path
 from typing import TYPE_CHECKING, ClassVar
 
@@ -88,17 +89,17 @@ class ImageExtractor(Extractor):
             config = (
                 self.config.ocr_config if isinstance(self.config.ocr_config, TesseractConfig) else TesseractConfig()
             )
-            result = backend.process_file_sync(path, **config.__dict__)
+            result = backend.process_file_sync(path, **asdict(config))
         elif self.config.ocr_backend == "paddleocr":
             paddle_config = (
                 self.config.ocr_config if isinstance(self.config.ocr_config, PaddleOCRConfig) else PaddleOCRConfig()
             )
-            result = backend.process_file_sync(path, **paddle_config.__dict__)
+            result = backend.process_file_sync(path, **asdict(paddle_config))
         elif self.config.ocr_backend == "easyocr":
             easy_config = (
                 self.config.ocr_config if isinstance(self.config.ocr_config, EasyOCRConfig) else EasyOCRConfig()
             )
-            result = backend.process_file_sync(path, **easy_config.__dict__)
+            result = backend.process_file_sync(path, **asdict(easy_config))
         else:
             raise NotImplementedError(f"Sync OCR not implemented for {self.config.ocr_backend}")
         return self._apply_quality_processing(result)

kreuzberg/_extractors/_pdf.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import contextlib
 import os
 import tempfile
+from dataclasses import asdict
 from multiprocessing import cpu_count
 from pathlib import Path
 from re import Pattern
@@ -58,9 +59,13 @@ class PDFExtractor(Extractor):
         result: ExtractionResult | None = None
 
         if not self.config.force_ocr:
-            content = await self._extract_pdf_searchable_text(path)
-            if self._validate_extracted_text(content):
-                result = ExtractionResult(content=content, mime_type=PLAIN_TEXT_MIME_TYPE, metadata={}, chunks=[])
+            try:
+                content = await self._extract_pdf_searchable_text(path)
+                if self._validate_extracted_text(content):
+                    result = ExtractionResult(content=content, mime_type=PLAIN_TEXT_MIME_TYPE, metadata={}, chunks=[])
+            except ParsingError:
+                # If searchable text extraction fails, continue to OCR or empty result
+                pass
 
         if not result and self.config.ocr_backend is not None:
             result = await self._extract_pdf_text_with_ocr(path, self.config.ocr_backend)
@@ -73,7 +78,7 @@ class PDFExtractor(Extractor):
         if self.config.extract_tables:
             # GMFT is optional dependency
             try:
-                from kreuzberg._gmft import extract_tables
+                from kreuzberg._gmft import extract_tables  # noqa: PLC0415
 
                 result.tables = await extract_tables(path, self.config.gmft_config)
             except ImportError:
@@ -112,16 +117,19 @@ class PDFExtractor(Extractor):
 
     def extract_path_sync(self, path: Path) -> ExtractionResult:
         """Pure sync implementation of PDF extraction from path."""
-        text = self._extract_pdf_searchable_text_sync(path)
+        try:
+            text = self._extract_pdf_searchable_text_sync(path)
+        except ParsingError:
+            text = ""
 
-        if self.config.force_ocr or not self._validate_extracted_text(text):
+        if (self.config.force_ocr or not self._validate_extracted_text(text)) and self.config.ocr_backend is not None:
             text = self._extract_pdf_with_ocr_sync(path)
 
         tables = []
         if self.config.extract_tables:
             # GMFT is optional dependency
             try:
-                from kreuzberg._gmft import extract_tables_sync
+                from kreuzberg._gmft import extract_tables_sync  # noqa: PLC0415
 
                 tables = extract_tables_sync(path)
             except ImportError:
@@ -381,17 +389,17 @@ class PDFExtractor(Extractor):
             config = (
                 self.config.ocr_config if isinstance(self.config.ocr_config, TesseractConfig) else TesseractConfig()
             )
-            results = backend.process_batch_sync(paths, **config.__dict__)
+            results = backend.process_batch_sync(paths, **asdict(config))
         elif self.config.ocr_backend == "paddleocr":
             paddle_config = (
                 self.config.ocr_config if isinstance(self.config.ocr_config, PaddleOCRConfig) else PaddleOCRConfig()
             )
-            results = backend.process_batch_sync(paths, **paddle_config.__dict__)
+            results = backend.process_batch_sync(paths, **asdict(paddle_config))
         elif self.config.ocr_backend == "easyocr":
             easy_config = (
                 self.config.ocr_config if isinstance(self.config.ocr_config, EasyOCRConfig) else EasyOCRConfig()
             )
-            results = backend.process_batch_sync(paths, **easy_config.__dict__)
+            results = backend.process_batch_sync(paths, **asdict(easy_config))
         else:
             raise NotImplementedError(f"Sync OCR not implemented for {self.config.ocr_backend}")
 

kreuzberg/_extractors/_spread_sheet.py

@@ -11,6 +11,7 @@ from pathlib import Path
 from typing import Any
 
 from anyio import Path as AsyncPath
+from PIL import Image
 from python_calamine import CalamineWorkbook
 
 from kreuzberg._extractors._base import Extractor
@@ -197,9 +198,9 @@ class SpreadSheetExtractor(Extractor):
         """Enhanced sheet processing with better table structure preservation."""
         try:
             # pandas is optional dependency
-            import pandas as pd
+            import pandas as pd  # noqa: PLC0415
 
-            from kreuzberg._utils._table import enhance_table_markdown
+            from kreuzberg._utils._table import enhance_table_markdown  # noqa: PLC0415
 
             sheet = workbook.get_sheet_by_name(sheet_name)
             data = sheet.to_python()
@@ -217,9 +218,7 @@ class SpreadSheetExtractor(Extractor):
                 return f"## {sheet_name}\n\n*No data*"
 
             # Create a mock TableData for enhanced formatting
-            from PIL import Image
-
-            from kreuzberg._types import TableData
+            from kreuzberg._types import TableData  # noqa: PLC0415
 
             # Create a 1x1 transparent image as placeholder
             placeholder_image = Image.new("RGBA", (1, 1), (0, 0, 0, 0))

kreuzberg/_extractors/_structured.py

@@ -1,8 +1,22 @@
 from __future__ import annotations
 
 import json
+import sys
 from typing import TYPE_CHECKING, Any, ClassVar
 
+if sys.version_info >= (3, 11):
+    import tomllib
+else:
+    try:
+        import tomli as tomllib  # type: ignore[import-not-found]
+    except ImportError:
+        tomllib = None
+
+try:
+    import yaml
+except ImportError:
+    yaml = None
+
 from anyio import Path as AsyncPath
 
 from kreuzberg._extractors._base import Extractor
@@ -44,31 +58,23 @@ class StructuredDataExtractor(Extractor):
             if self.mime_type in {JSON_MIME_TYPE, "text/json"}:
                 data = json.loads(text_content)
             elif self.mime_type in {TOML_MIME_TYPE, "text/toml"}:
-                try:
-                    import tomllib  # type: ignore[import-not-found]
-                except ImportError:
-                    try:
-                        import tomli as tomllib  # type: ignore[import-not-found]
-                    except ImportError:
-                        return ExtractionResult(
-                            content=normalize_spaces(text_content),
-                            mime_type=PLAIN_TEXT_MIME_TYPE,
-                            metadata={"warning": "tomllib/tomli not available, returning raw text"},
-                            chunks=[],
-                        )
+                if tomllib is None:
+                    return ExtractionResult(
+                        content=normalize_spaces(text_content),
+                        mime_type=PLAIN_TEXT_MIME_TYPE,
+                        metadata={"warning": "tomllib/tomli not available, returning raw text"},
+                        chunks=[],
+                    )
                 data = tomllib.loads(text_content)
             else:
-                try:
-                    import yaml
-
-                    data = yaml.safe_load(text_content)
-                except ImportError:
+                if yaml is None:
                     return ExtractionResult(
                         content=normalize_spaces(text_content),
                         mime_type=PLAIN_TEXT_MIME_TYPE,
                         metadata={"warning": "PyYAML not available, returning raw text"},
                         chunks=[],
                     )
+                data = yaml.safe_load(text_content)
 
             text_parts: list[str] = []
             metadata: dict[str, Any] = {}
@@ -90,7 +96,7 @@ class StructuredDataExtractor(Extractor):
                 chunks=[],
             )
 
-        except (ValueError, TypeError, KeyError, AttributeError, UnicodeDecodeError) as e:
+        except (json.JSONDecodeError, ValueError, TypeError) as e:
             return ExtractionResult(
                 content=normalize_spaces(text_content),
                 mime_type=PLAIN_TEXT_MIME_TYPE,

kreuzberg/_gmft.py

@@ -5,12 +5,16 @@ import multiprocessing as mp
 import os
 import queue
 import signal
+import time
 import traceback
 from dataclasses import dataclass, field
 from io import StringIO
+from pathlib import Path
 from typing import TYPE_CHECKING, Any, Literal
 
+import anyio
 import msgspec
+from PIL import Image
 
 from kreuzberg._types import TableData
 from kreuzberg._utils._sync import run_sync
@@ -134,7 +138,7 @@ class GMFTConfig:
     """
 
 
-async def extract_tables(  # noqa: PLR0915
+async def extract_tables(
     file_path: str | PathLike[str], config: GMFTConfig | None = None, use_isolated_process: bool | None = None
 ) -> list[TableData]:
     """Extracts tables from a PDF file.
@@ -154,9 +158,7 @@ async def extract_tables(  # noqa: PLR0915
     Returns:
         A list of table data dictionaries.
     """
-    from pathlib import Path
-
-    from kreuzberg._utils._cache import get_table_cache
+    from kreuzberg._utils._cache import get_table_cache  # noqa: PLC0415
 
     # Determine if we should use isolated process  # ~keep
     if use_isolated_process is None:
@@ -190,8 +192,6 @@ async def extract_tables(  # noqa: PLR0915
         return cached_result  # type: ignore[no-any-return]
 
     if table_cache.is_processing(**cache_kwargs):
-        import anyio
-
         event = table_cache.mark_processing(**cache_kwargs)
         await anyio.to_thread.run_sync(event.wait)
 
@@ -211,10 +211,13 @@ async def extract_tables(  # noqa: PLR0915
             return result
 
         try:
-            from gmft.auto import AutoTableDetector, AutoTableFormatter  # type: ignore[attr-defined]
-            from gmft.detectors.tatr import TATRDetectorConfig  # type: ignore[attr-defined]
-            from gmft.formatters.tatr import TATRFormatConfig
-            from gmft.pdf_bindings.pdfium import PyPDFium2Document
+            from gmft.auto import (  # type: ignore[attr-defined]  # noqa: PLC0415  # noqa: PLC0415
+                AutoTableDetector,
+                AutoTableFormatter,
+            )
+            from gmft.detectors.tatr import TATRDetectorConfig  # type: ignore[attr-defined]  # noqa: PLC0415
+            from gmft.formatters.tatr import TATRFormatConfig  # noqa: PLC0415  # noqa: PLC0415
+            from gmft.pdf_bindings.pdfium import PyPDFium2Document  # noqa: PLC0415  # noqa: PLC0415
 
             formatter: Any = AutoTableFormatter(  # type: ignore[no-untyped-call]  # type: ignore[no-untyped-call]
                 config=TATRFormatConfig(
@@ -284,9 +287,7 @@ def extract_tables_sync(
     Returns:
         A list of table data dictionaries.
     """
-    from pathlib import Path
-
-    from kreuzberg._utils._cache import get_table_cache
+    from kreuzberg._utils._cache import get_table_cache  # noqa: PLC0415
 
     # Determine if we should use isolated process  # ~keep
     if use_isolated_process is None:
@@ -327,10 +328,10 @@ def extract_tables_sync(
         return result
 
     try:
-        from gmft.auto import AutoTableDetector, AutoTableFormatter  # type: ignore[attr-defined]
-        from gmft.detectors.tatr import TATRDetectorConfig  # type: ignore[attr-defined]
-        from gmft.formatters.tatr import TATRFormatConfig
-        from gmft.pdf_bindings.pdfium import PyPDFium2Document
+        from gmft.auto import AutoTableDetector, AutoTableFormatter  # type: ignore[attr-defined]  # noqa: PLC0415
+        from gmft.detectors.tatr import TATRDetectorConfig  # type: ignore[attr-defined]  # noqa: PLC0415
+        from gmft.formatters.tatr import TATRFormatConfig  # noqa: PLC0415
+        from gmft.pdf_bindings.pdfium import PyPDFium2Document  # noqa: PLC0415
 
         formatter: Any = AutoTableFormatter(  # type: ignore[no-untyped-call]
             config=TATRFormatConfig(
@@ -399,10 +400,10 @@ def _extract_tables_in_process(
     signal.signal(signal.SIGINT, signal.SIG_IGN)
 
     try:
-        from gmft.auto import AutoTableDetector, AutoTableFormatter  # type: ignore[attr-defined]
-        from gmft.detectors.tatr import TATRDetectorConfig  # type: ignore[attr-defined]
-        from gmft.formatters.tatr import TATRFormatConfig
-        from gmft.pdf_bindings.pdfium import PyPDFium2Document
+        from gmft.auto import AutoTableDetector, AutoTableFormatter  # type: ignore[attr-defined]  # noqa: PLC0415
+        from gmft.detectors.tatr import TATRDetectorConfig  # type: ignore[attr-defined]  # noqa: PLC0415
+        from gmft.formatters.tatr import TATRFormatConfig  # noqa: PLC0415
+        from gmft.pdf_bindings.pdfium import PyPDFium2Document  # noqa: PLC0415
 
         config = GMFTConfig(**config_dict)
 
@@ -495,7 +496,6 @@ def _extract_tables_isolated(
 
     try:
         # Wait for result with timeout, checking for process death  # ~keep
-        import time
 
         start_time = time.time()
         while True:
@@ -529,10 +529,8 @@ def _extract_tables_isolated(
         if success:
             tables = []
             for table_dict in result:
-                from PIL import Image
-
                 img = Image.open(io.BytesIO(table_dict["cropped_image_bytes"]))
-                import pandas as pd
+                import pandas as pd  # noqa: PLC0415
 
                 df = pd.read_csv(StringIO(table_dict["df_csv"]))
 
@@ -577,7 +575,7 @@ def _extract_tables_isolated(
 async def _extract_tables_isolated_async(
     file_path: str | PathLike[str],
     config: GMFTConfig | None = None,
-    timeout: float = 300.0,
+    timeout: float = 300.0,  # noqa: ASYNC109
 ) -> list[TableData]:
     """Async version of extract_tables_isolated using asyncio.
 
@@ -592,8 +590,6 @@ async def _extract_tables_isolated_async(
     Raises:
         RuntimeError: If extraction fails or times out
     """
-    import anyio
-
     config = config or GMFTConfig()
     config_dict = msgspec.to_builtins(config)
 
@@ -639,10 +635,8 @@ async def _extract_tables_isolated_async(
         if success:
             tables = []
             for table_dict in result:
-                from PIL import Image
-
                 img = Image.open(io.BytesIO(table_dict["cropped_image_bytes"]))
-                import pandas as pd
+                import pandas as pd  # noqa: PLC0415
 
                 df = pd.read_csv(StringIO(table_dict["df_csv"]))
 

kreuzberg/_mime_types.py

@@ -191,7 +191,7 @@ def validate_mime_type(
         return _validate_explicit_mime_type(mime_type)
 
     if file_path:
-        from kreuzberg._utils._cache import get_mime_cache
+        from kreuzberg._utils._cache import get_mime_cache  # noqa: PLC0415
 
         path = Path(file_path)
 

kreuzberg/_ocr/_base.py

@@ -103,7 +103,7 @@ class OCRBackend(ABC, Generic[T]):
         Returns:
             List of extraction result objects in the same order as input paths
         """
-        from kreuzberg._utils._sync import run_taskgroup
+        from kreuzberg._utils._sync import run_taskgroup  # noqa: PLC0415
 
         tasks = [self.process_file(path, **kwargs) for path in paths]
         return await run_taskgroup(*tasks)

kreuzberg/_ocr/_easyocr.py

@@ -180,7 +180,7 @@ class EasyOCRBackend(OCRBackend[EasyOCRConfig]):
         Raises:
             OCRError: If OCR processing fails.
         """
-        import numpy as np
+        import numpy as np  # noqa: PLC0415
 
         await self._init_easyocr(**kwargs)
 
@@ -318,7 +318,7 @@ class EasyOCRBackend(OCRBackend[EasyOCRConfig]):
             bool: True if GPU support is available.
         """
         try:
-            import torch
+            import torch  # noqa: PLC0415
 
             return bool(torch.cuda.is_available())
         except ImportError:
@@ -339,7 +339,7 @@ class EasyOCRBackend(OCRBackend[EasyOCRConfig]):
             return
 
         try:
-            import easyocr
+            import easyocr  # noqa: PLC0415
         except ImportError as e:
             raise MissingDependencyError.create_for_package(
                 dependency_group="easyocr", functionality="EasyOCR as an OCR backend", package_name="easyocr"
@@ -507,7 +507,7 @@ class EasyOCRBackend(OCRBackend[EasyOCRConfig]):
             return
 
         try:
-            import easyocr
+            import easyocr  # noqa: PLC0415
         except ImportError as e:
             raise MissingDependencyError.create_for_package(
                 dependency_group="easyocr", functionality="EasyOCR as an OCR backend", package_name="easyocr"

kreuzberg/_ocr/_paddleocr.py

@@ -124,7 +124,7 @@ class PaddleBackend(OCRBackend[PaddleOCRConfig]):
         Raises:
             OCRError: If OCR processing fails.
         """
-        import numpy as np
+        import numpy as np  # noqa: PLC0415
 
         await self._init_paddle_ocr(**kwargs)
 
@@ -260,7 +260,7 @@ class PaddleBackend(OCRBackend[PaddleOCRConfig]):
             return
 
         try:
-            from paddleocr import PaddleOCR
+            from paddleocr import PaddleOCR  # noqa: PLC0415
         except ImportError as e:
             raise MissingDependencyError.create_for_package(
                 dependency_group="paddleocr", functionality="PaddleOCR as an OCR backend", package_name="paddleocr"
@@ -427,7 +427,7 @@ class PaddleBackend(OCRBackend[PaddleOCRConfig]):
             return
 
         try:
-            from paddleocr import PaddleOCR
+            from paddleocr import PaddleOCR  # noqa: PLC0415
         except ImportError as e:
             raise MissingDependencyError.create_for_package(
                 dependency_group="paddleocr", functionality="PaddleOCR as an OCR backend", package_name="paddleocr"

kreuzberg/_ocr/_tesseract.py

@@ -12,8 +12,10 @@ from enum import Enum
 from pathlib import Path
 from typing import TYPE_CHECKING, Any, ClassVar, Final
 
+import anyio
 from anyio import Path as AsyncPath
 from anyio import run_process
+from PIL import Image
 from typing_extensions import Self
 
 from kreuzberg._mime_types import PLAIN_TEXT_MIME_TYPE
@@ -25,7 +27,7 @@ from kreuzberg._utils._tmp import create_temp_file
 from kreuzberg.exceptions import MissingDependencyError, OCRError, ValidationError
 
 if TYPE_CHECKING:
-    from PIL.Image import Image
+    from PIL.Image import Image as PILImage
 
 try:  # pragma: no cover
     from typing import Unpack  # type: ignore[attr-defined]
@@ -233,10 +235,10 @@ class TesseractBackend(OCRBackend[TesseractConfig]):
 
     async def process_image(
         self,
-        image: Image,
+        image: PILImage,
         **kwargs: Unpack[TesseractConfig],
     ) -> ExtractionResult:
-        from kreuzberg._utils._cache import get_ocr_cache
+        from kreuzberg._utils._cache import get_ocr_cache  # noqa: PLC0415
 
         image_buffer = io.BytesIO()
         await run_sync(image.save, image_buffer, format="PNG")
@@ -254,8 +256,6 @@ class TesseractBackend(OCRBackend[TesseractConfig]):
             return cached_result
 
         if ocr_cache.is_processing(**cache_kwargs):
-            import anyio
-
             event = ocr_cache.mark_processing(**cache_kwargs)
             await anyio.to_thread.run_sync(event.wait)
 
@@ -286,7 +286,7 @@ class TesseractBackend(OCRBackend[TesseractConfig]):
         path: Path,
         **kwargs: Unpack[TesseractConfig],
     ) -> ExtractionResult:
-        from kreuzberg._utils._cache import get_ocr_cache
+        from kreuzberg._utils._cache import get_ocr_cache  # noqa: PLC0415
 
         try:
             stat = path.stat()
@@ -314,8 +314,6 @@ class TesseractBackend(OCRBackend[TesseractConfig]):
             return cached_result
 
         if ocr_cache.is_processing(**cache_kwargs):
-            import anyio
-
             event = ocr_cache.mark_processing(**cache_kwargs)
             await anyio.to_thread.run_sync(event.wait)
 
@@ -411,7 +409,7 @@ class TesseractBackend(OCRBackend[TesseractConfig]):
 
     def process_image_sync(
         self,
-        image: Image,
+        image: PILImage,
         **kwargs: Unpack[TesseractConfig],
     ) -> ExtractionResult:
         """Synchronously process an image and extract its text and metadata.
@@ -423,7 +421,7 @@ class TesseractBackend(OCRBackend[TesseractConfig]):
         Returns:
             The extraction result object
         """
-        from kreuzberg._utils._cache import get_ocr_cache
+        from kreuzberg._utils._cache import get_ocr_cache  # noqa: PLC0415
 
         image_buffer = io.BytesIO()
         image.save(image_buffer, format="PNG")
@@ -482,7 +480,7 @@ class TesseractBackend(OCRBackend[TesseractConfig]):
         Returns:
             The extraction result object
         """
-        from kreuzberg._utils._cache import get_ocr_cache
+        from kreuzberg._utils._cache import get_ocr_cache  # noqa: PLC0415
 
         file_info = self._get_file_info(path)
 
@@ -771,8 +769,6 @@ def _process_image_bytes_with_tesseract(
         OCR result as dictionary.
     """
     try:
-        from PIL import Image
-
         with tempfile.NamedTemporaryFile(suffix=".png", delete=False) as tmp_image:
             with Image.open(io.BytesIO(image_bytes)) as image:
                 image.save(tmp_image.name, format="PNG")
@@ -810,7 +806,7 @@ class TesseractProcessPool:
             max_processes: Maximum number of processes.
             memory_limit_gb: Memory limit in GB.
         """
-        from kreuzberg._utils._process_pool import ProcessPoolManager
+        from kreuzberg._utils._process_pool import ProcessPoolManager  # noqa: PLC0415
 
         self.config = config or TesseractConfig()
         self.process_manager = ProcessPoolManager(

kreuzberg/_types.py

@@ -8,7 +8,11 @@ from typing import TYPE_CHECKING, Any, Literal, TypedDict
 import msgspec
 
 from kreuzberg._constants import DEFAULT_MAX_CHARACTERS, DEFAULT_MAX_OVERLAP
-from kreuzberg._utils._table import export_table_to_csv, export_table_to_tsv, extract_table_structure_info
+from kreuzberg._utils._table import (
+    export_table_to_csv,
+    export_table_to_tsv,
+    extract_table_structure_info,
+)
 from kreuzberg.exceptions import ValidationError
 
 if sys.version_info < (3, 11):  # pragma: no cover
@@ -228,6 +232,12 @@ class ExtractionResult:
     """Extracted keywords and their scores, if keyword extraction is enabled."""
     detected_languages: list[str] | None = None
     """Languages detected in the extracted content, if language detection is enabled."""
+    document_type: str | None = None
+    """Detected document type, if document type detection is enabled."""
+    document_type_confidence: float | None = None
+    """Confidence of the detected document type."""
+    layout: DataFrame | None = field(default=None, repr=False, hash=False)
+    """Internal layout data from OCR, not for public use."""
 
     def to_dict(self, include_none: bool = False) -> dict[str, Any]:
         """Converts the ExtractionResult to a dictionary.
@@ -339,6 +349,12 @@ class ExtractionConfig:
     """Configuration for language detection. If None, uses default settings."""
     spacy_entity_extraction_config: SpacyEntityExtractionConfig | None = None
     """Configuration for spaCy entity extraction. If None, uses default settings."""
+    auto_detect_document_type: bool = False
+    """Whether to automatically detect the document type."""
+    document_type_confidence_threshold: float = 0.7
+    """Confidence threshold for document type detection."""
+    document_classification_mode: Literal["text", "vision"] = "text"
+    """The mode to use for document classification."""
     enable_quality_processing: bool = True
     """Whether to apply quality post-processing to improve extraction results."""
 
@@ -349,9 +365,9 @@ class ExtractionConfig:
             object.__setattr__(self, "post_processing_hooks", tuple(self.post_processing_hooks))
         if self.validators is not None and isinstance(self.validators, list):
             object.__setattr__(self, "validators", tuple(self.validators))
-        from kreuzberg._ocr._easyocr import EasyOCRConfig
-        from kreuzberg._ocr._paddleocr import PaddleOCRConfig
-        from kreuzberg._ocr._tesseract import TesseractConfig
+        from kreuzberg._ocr._easyocr import EasyOCRConfig  # noqa: PLC0415
+        from kreuzberg._ocr._paddleocr import PaddleOCRConfig  # noqa: PLC0415
+        from kreuzberg._ocr._tesseract import TesseractConfig  # noqa: PLC0415
 
         if self.ocr_backend is None and self.ocr_config is not None:
             raise ValidationError("'ocr_backend' is None but 'ocr_config' is provided")
@@ -381,14 +397,14 @@ class ExtractionConfig:
 
         # Lazy load and cache default configs instead of creating new instances
         if self.ocr_backend == "tesseract":
-            from kreuzberg._ocr._tesseract import TesseractConfig
+            from kreuzberg._ocr._tesseract import TesseractConfig  # noqa: PLC0415
 
             return asdict(TesseractConfig())
         if self.ocr_backend == "easyocr":
-            from kreuzberg._ocr._easyocr import EasyOCRConfig
+            from kreuzberg._ocr._easyocr import EasyOCRConfig  # noqa: PLC0415
 
             return asdict(EasyOCRConfig())
         # paddleocr
-        from kreuzberg._ocr._paddleocr import PaddleOCRConfig
+        from kreuzberg._ocr._paddleocr import PaddleOCRConfig  # noqa: PLC0415
 
         return asdict(PaddleOCRConfig())

kreuzberg/_utils/_cache.py

@@ -7,6 +7,7 @@ import os
 import threading
 import time
 from contextlib import suppress
+from io import StringIO
 from pathlib import Path
 from typing import Any, Generic, TypeVar
 
@@ -126,9 +127,7 @@ class KreuzbergCache(Generic[T]):
         data = cached_data["data"]
 
         if cached_data.get("type") == "TableDataList" and isinstance(data, list):
-            from io import StringIO
-
-            import pandas as pd
+            import pandas as pd  # noqa: PLC0415
 
             deserialized_data = []
             for item in data:

kreuzberg/_utils/_device.py

@@ -141,7 +141,7 @@ def get_device_memory_info(device: DeviceInfo) -> tuple[float | None, float | No
 def _is_cuda_available() -> bool:
     """Check if CUDA is available."""
     try:
-        import torch  # type: ignore[import-not-found,unused-ignore]
+        import torch  # type: ignore[import-not-found,unused-ignore]  # noqa: PLC0415
 
         return bool(torch.cuda.is_available())
     except ImportError:
@@ -151,7 +151,7 @@ def _is_cuda_available() -> bool:
 def _is_mps_available() -> bool:
     """Check if MPS (Apple Silicon) is available."""
     try:
-        import torch  # type: ignore[import-not-found,unused-ignore]
+        import torch  # type: ignore[import-not-found,unused-ignore]  # noqa: PLC0415
 
         return bool(torch.backends.mps.is_available())
     except ImportError:
@@ -163,7 +163,7 @@ def _get_cuda_devices() -> list[DeviceInfo]:
     devices: list[DeviceInfo] = []
 
     try:
-        import torch
+        import torch  # noqa: PLC0415
 
         if not torch.cuda.is_available():
             return devices
@@ -199,7 +199,7 @@ def _get_cuda_devices() -> list[DeviceInfo]:
 def _get_mps_device() -> DeviceInfo | None:
     """Get information about the MPS device."""
     try:
-        import torch
+        import torch  # noqa: PLC0415
 
         if not torch.backends.mps.is_available():
             return None
@@ -216,7 +216,7 @@ def _get_mps_device() -> DeviceInfo | None:
 def _get_cuda_memory_info(device_id: int) -> tuple[float | None, float | None]:
     """Get CUDA memory information for a specific device."""
     try:
-        import torch
+        import torch  # noqa: PLC0415
 
         if not torch.cuda.is_available():
             return None, None
@@ -329,7 +329,7 @@ def cleanup_device_memory(device: DeviceInfo) -> None:
     """
     if device.device_type == "cuda":
         try:
-            import torch
+            import torch  # noqa: PLC0415
 
             if torch.cuda.is_available():
                 torch.cuda.empty_cache()
@@ -338,7 +338,7 @@ def cleanup_device_memory(device: DeviceInfo) -> None:
 
     elif device.device_type == "mps":
         try:
-            import torch
+            import torch  # noqa: PLC0415
 
             if torch.backends.mps.is_available():
                 torch.mps.empty_cache()

kreuzberg/cli.py

@@ -160,7 +160,7 @@ def _perform_extraction(file: Path | None, extraction_config: ExtractionConfig,
             progress.add_task("Extracting text...", total=None)
 
             try:
-                import magic  # type: ignore[import-not-found]
+                import magic  # type: ignore[import-not-found]  # noqa: PLC0415
 
                 mime_type = magic.from_buffer(input_bytes, mime=True)
             except ImportError:
@@ -260,7 +260,7 @@ def cli(ctx: click.Context) -> None:
 @click.option("--paddleocr-languages", help="PaddleOCR language codes (comma-separated, e.g., 'en,german')")
 @click.pass_context
 def extract(  # noqa: PLR0913
-    ctx: click.Context,  # noqa: ARG001
+    _: click.Context,
     file: Path | None,
     output: Path | None,
     force_ocr: bool,

kreuzberg/extraction.py

@@ -7,15 +7,15 @@ from typing import TYPE_CHECKING, Any, Final, cast
 
 import anyio
 
-from kreuzberg import ExtractionResult
 from kreuzberg._chunker import get_chunker
+from kreuzberg._document_classification import auto_detect_document_type
 from kreuzberg._entity_extraction import extract_entities, extract_keywords
 from kreuzberg._language_detection import detect_languages
 from kreuzberg._mime_types import (
     validate_mime_type,
 )
 from kreuzberg._registry import ExtractorRegistry
-from kreuzberg._types import ExtractionConfig
+from kreuzberg._types import ExtractionConfig, ExtractionResult
 from kreuzberg._utils._document_cache import get_document_cache
 from kreuzberg._utils._errors import create_error_context
 from kreuzberg._utils._string import safe_decode
@@ -30,7 +30,9 @@ if TYPE_CHECKING:
 DEFAULT_CONFIG: Final[ExtractionConfig] = ExtractionConfig()
 
 
-def _validate_and_post_process_helper(result: ExtractionResult, config: ExtractionConfig) -> ExtractionResult:
+def _validate_and_post_process_helper(
+    result: ExtractionResult, config: ExtractionConfig, file_path: Path | None = None
+) -> ExtractionResult:
     if config.chunk_content:
         result.chunks = _handle_chunk_content(
             mime_type=result.mime_type,
@@ -62,14 +64,19 @@ def _validate_and_post_process_helper(result: ExtractionResult, config: Extracti
             config=config.language_detection_config,
         )
 
+    if config.auto_detect_document_type:
+        result = auto_detect_document_type(result, config, file_path=file_path)
+
     return result
 
 
-async def _validate_and_post_process_async(result: ExtractionResult, config: ExtractionConfig) -> ExtractionResult:
+async def _validate_and_post_process_async(
+    result: ExtractionResult, config: ExtractionConfig, file_path: Path | None = None
+) -> ExtractionResult:
     for validator in config.validators or []:
         await run_maybe_sync(validator, result)
 
-    result = _validate_and_post_process_helper(result, config)
+    result = _validate_and_post_process_helper(result, config, file_path)
 
     for post_processor in config.post_processing_hooks or []:
         result = await run_maybe_sync(post_processor, result)
@@ -77,11 +84,13 @@ async def _validate_and_post_process_async(result: ExtractionResult, config: Ext
     return result
 
 
-def _validate_and_post_process_sync(result: ExtractionResult, config: ExtractionConfig) -> ExtractionResult:
+def _validate_and_post_process_sync(
+    result: ExtractionResult, config: ExtractionConfig, file_path: Path | None = None
+) -> ExtractionResult:
     for validator in config.validators or []:
         run_sync_only(validator, result)
 
-    result = _validate_and_post_process_helper(result, config)
+    result = _validate_and_post_process_helper(result, config, file_path)
 
     for post_processor in config.post_processing_hooks or []:
         result = run_sync_only(post_processor, result)
@@ -172,7 +181,7 @@ async def extract_file(
                 metadata={},
             )
 
-        result = await _validate_and_post_process_async(result=result, config=config)
+        result = await _validate_and_post_process_async(result=result, config=config, file_path=path)
 
         cache.set(path, config, result)
 
@@ -357,7 +366,7 @@ def extract_file_sync(
                 metadata={},
             )
 
-        result = _validate_and_post_process_sync(result=result, config=config)
+        result = _validate_and_post_process_sync(result=result, config=config, file_path=path)
 
         cache.set(path, config, result)
 

{kreuzberg-3.8.2.dist-info → kreuzberg-3.9.0.dist-info}/METADATA

@@ -1,13 +1,13 @@
 Metadata-Version: 2.4
 Name: kreuzberg
-Version: 3.8.2
+Version: 3.9.0
 Summary: Document intelligence framework for Python - Extract text, metadata, and structured data from diverse file formats
 Project-URL: documentation, https://kreuzberg.dev
 Project-URL: homepage, https://github.com/Goldziher/kreuzberg
 Author-email: Na'aman Hirschfeld <nhirschfed@gmail.com>
 License: MIT
 License-File: LICENSE
-Keywords: async,document-analysis,document-intelligence,document-processing,extensible,information-extraction,mcp,metadata-extraction,model-context-protocol,ocr,pandoc,pdf-extraction,pdfium,plugin-architecture,rag,retrieval-augmented-generation,structured-data,table-extraction,tesseract,text-extraction
+Keywords: async,document-analysis,document-classification,document-intelligence,document-processing,extensible,information-extraction,mcp,metadata-extraction,model-context-protocol,ocr,pandoc,pdf-extraction,pdfium,plugin-architecture,rag,retrieval-augmented-generation,structured-data,table-extraction,tesseract,text-extraction
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Information Technology
@@ -60,6 +60,9 @@ Requires-Dist: spacy>=3.8.7; extra == 'all'
 Requires-Dist: tomli>=2.0.0; (python_version < '3.11') and extra == 'all'
 Provides-Extra: api
 Requires-Dist: litestar[opentelemetry,standard,structlog]>=2.16.0; extra == 'api'
+Provides-Extra: auto-classify-document-type
+Requires-Dist: deep-translator>=1.11.4; extra == 'auto-classify-document-type'
+Requires-Dist: pandas>=2.3.1; extra == 'auto-classify-document-type'
 Provides-Extra: chunking
 Requires-Dist: semantic-text-splitter>=0.27.0; extra == 'chunking'
 Provides-Extra: cli
@@ -88,7 +91,7 @@ Description-Content-Type: text/markdown
 [![Documentation](https://img.shields.io/badge/docs-kreuzberg.dev-blue)](https://kreuzberg.dev/)
 [![Benchmarks](https://img.shields.io/badge/benchmarks-fastest%20CPU-orange)](https://benchmarks.kreuzberg.dev/)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
-[![Test Coverage](https://img.shields.io/badge/coverage-95%25-green)](https://github.com/Goldziher/kreuzberg)
+[![DeepSource](https://app.deepsource.com/gh/Goldziher/kreuzberg.svg/?label=code+coverage&show_trend=true&token=U8AW1VWWSLwVhrbtL8LmLBDN)](https://app.deepsource.com/gh/Goldziher/kreuzberg/)
 
 **A document intelligence framework for Python.** Extract text, metadata, and structured information from diverse document formats through a unified, extensible API. Built on established open source foundations including Pandoc, PDFium, and Tesseract.
 
@@ -103,6 +106,7 @@ Description-Content-Type: text/markdown
 - **Format Support**: 18 document types including PDF, Microsoft Office, images, HTML, and structured data formats
 - **OCR Integration**: Multiple OCR engines (Tesseract, EasyOCR, PaddleOCR) with automatic fallback
 - **Table Detection**: Structured table extraction with cell-level precision via GMFT integration
+- **Document Classification**: Automatic document type detection (contracts, forms, invoices, receipts, reports)
 
 ### Technical Architecture
 

{kreuzberg-3.8.2.dist-info → kreuzberg-3.9.0.dist-info}/RECORD

@@ -1,18 +1,19 @@
 kreuzberg/__init__.py,sha256=0OJ_jNKbS6GxzWC5-EfRCiE80as_ya0-wwyNsTYbxzY,1721
 kreuzberg/__main__.py,sha256=s2qM1nPEkRHAQP-G3P7sf5l6qA_KJeIEHS5LpPz04lg,183
-kreuzberg/_chunker.py,sha256=2eHSRHcZdJ2ZjR3in49y3o9tPl5HMO3vkbnMqaVCbHI,1887
-kreuzberg/_config.py,sha256=_9JU88ChId8dWUjZ13ueo9_JoFekkyzuv7rZpFkrPZk,12966
+kreuzberg/_chunker.py,sha256=QmYbPHPE36ztMT70xPwg_Y4NIftCDl0wyufg5X9lmTo,1932
+kreuzberg/_config.py,sha256=EvrBFAawjfKgXu49tACi4CuMmmoIRt_EzbHayZqM_jU,12983
 kreuzberg/_constants.py,sha256=Bxc8oiN-wHwnWXT9bEiJhTUcu1ygPpra5qHirAif3b4,191
-kreuzberg/_entity_extraction.py,sha256=woNxARG27Z3T_l6w6N-dbt1PPe1IHptFMOZY_6etv54,7819
-kreuzberg/_gmft.py,sha256=Q46CyBxRxY_oDGpSuXMOJ7qfR9LwuCKXnrl60wcPvU4,25286
+kreuzberg/_document_classification.py,sha256=8XVTKh8ohsb4mbKw2gPFr5OB6v4dWuzXhFE_63vHLrw,5189
+kreuzberg/_entity_extraction.py,sha256=43VxtCPbuSrfi-XGSop-VRoZadJcNe02qRGwjGSaR0c,7862
+kreuzberg/_gmft.py,sha256=JWDeBYWSDkh3tLUhwTmW5CbIBEig2A3o712BLshk7hE,25533
 kreuzberg/_language_detection.py,sha256=eEfj4tsh91SfB2_zQIdY-qD7TlPcppaFm0SqQmETS6Y,3295
-kreuzberg/_mime_types.py,sha256=OhJ6gEyyLHjyvRtkk37zyLFBsRcSd_QybBaV8TxinIg,8471
+kreuzberg/_mime_types.py,sha256=2warRVqfBUNIg8JBg8yP4pRqaMPvwINosHMkJwtH_Fc,8488
 kreuzberg/_playa.py,sha256=9z4If0WHxbYQxfb8xT7T96L9Du2Fj3Ar5-rF0OHHiMM,11877
 kreuzberg/_registry.py,sha256=wGSlkS0U1zqruWQCLE95vj4a2mw1yyvf0j6rgz80sJg,3473
-kreuzberg/_types.py,sha256=GisvL0ps2LCc0heKopFwSyrEbzH3WpDxaeev4vn59X4,14257
-kreuzberg/cli.py,sha256=vTGS2TJlFTNMWp5LwZd3G2SS8u0m6bhQkH9n6a1oOoM,12439
+kreuzberg/_types.py,sha256=Si-Kb58HgE4ckGyZnJFqbWRbCNbdyC_Y0-p75aQP838,15065
+kreuzberg/cli.py,sha256=lmthZa0x8pz7SQfCoPPdTaUF9aQZ8W4w5FlnPcsGr9k,12438
 kreuzberg/exceptions.py,sha256=PTiAZgQwcG9hXbgYg2W7sfxksFhq5_wzOFgZGnTJAoc,2991
-kreuzberg/extraction.py,sha256=UmeEVN-eSile4HMxP0iqG9092BrsH5_zSZNVHhwy0ko,16993
+kreuzberg/extraction.py,sha256=Kt1mOxdlOb35yVOdpdhiRPuTgA9BW_TTG9qwCkSxSkc,17332
 kreuzberg/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 kreuzberg/_api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 kreuzberg/_api/main.py,sha256=g3kqXUfSie2pcw3-EWOM4TAoJUqM7yj2e-cBQJ_bmYc,3253
@@ -20,22 +21,22 @@ kreuzberg/_extractors/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3h
 kreuzberg/_extractors/_base.py,sha256=yNVQSECFad-8_MjqpQZ4q0jQoNdzP6-tqw6l3TfgsMc,4418
 kreuzberg/_extractors/_email.py,sha256=6-Mk1TRXPyy9ylWKCpgdrogyzhiFnJOTuTRld1ghO8I,5695
 kreuzberg/_extractors/_html.py,sha256=lOM1Tgrrvd7vpEeFAxC1dp0Tibr6N2FEHCjgFx0FK64,1745
-kreuzberg/_extractors/_image.py,sha256=eZ7mR4F-mTwYwUzd70xrY7SZYZrNiDxnP5bYDY5P75U,4455
+kreuzberg/_extractors/_image.py,sha256=OmkqR5Cd6bTM_qHEdNHeXa5eK-3KvtLgHX-JE5oZWec,4483
 kreuzberg/_extractors/_pandoc.py,sha256=51k7XISfKaPorhapG7aIeQb94KGsfozxKyT2rwhk9Bk,26553
-kreuzberg/_extractors/_pdf.py,sha256=d-hG_mhAMj22bQ35YuP2nq017z27_2Pp08r1qyHxlYI,16676
+kreuzberg/_extractors/_pdf.py,sha256=UlliWggWHuVwwJE-bRa7H9-_cieSa8kdrQP3x_GOxxY,17018
 kreuzberg/_extractors/_presentation.py,sha256=CUlqZl_QCdJdumsZh0BpROkFbvi9uq7yMoIt3bRTUeE,10859
-kreuzberg/_extractors/_spread_sheet.py,sha256=vPxEDAyH-gDoVXSg-A0guOjOfaWIuRI3i2NU8xPwhK8,13695
-kreuzberg/_extractors/_structured.py,sha256=d0x6EyRimr8eWmr1qPb7HRWnrbKBuD-GpIrZd8XJp0o,5824
+kreuzberg/_extractors/_spread_sheet.py,sha256=iagiyJsnl-89OP1eqmEv8jWl7gZBJm2x0YOyqBgLasA,13733
+kreuzberg/_extractors/_structured.py,sha256=J7op5ZZ663a_CkE2SB5eKjPQPXKHdqPst-GFCJMNGqw,5727
 kreuzberg/_mcp/__init__.py,sha256=8PYV-omC8Rln7Cove8C3rHu3d7sR1FuiwSBG1O7vkAE,92
 kreuzberg/_mcp/server.py,sha256=Ab0w7kR3m7_L1cfhYHiC8HqDL282vt4uBYwYc9w9E08,8703
 kreuzberg/_ocr/__init__.py,sha256=grshVFwVQl2rMvH1hg1JNlYXjy5-Tdb_rusLD1Cselk,706
-kreuzberg/_ocr/_base.py,sha256=CUzYMsJjCqCmHzWckmDeIB2L5hd261xrPrK8Ql-Gdm0,3876
-kreuzberg/_ocr/_easyocr.py,sha256=c2ndpDlIHvAI2WyvQUXLQ1hb6XynKeKARsXQcQ3ntJ0,17110
-kreuzberg/_ocr/_paddleocr.py,sha256=fab8a-3cvDgnt97qF-Km9ZfmkacFeKD_g15O8HXYRVc,17492
-kreuzberg/_ocr/_tesseract.py,sha256=r1g_PCAXgJbZ0RPGn4aSxctZ0F9lLvI3zLGLEPAnviI,31455
+kreuzberg/_ocr/_base.py,sha256=urvsLRgOmVYHjxil_IsSL69FmMnboklC4CHAjdBQLKQ,3893
+kreuzberg/_ocr/_easyocr.py,sha256=pw2uDmULuMQ9T1Gl4axP_ev7-qwjLt1mJHHyZ34P_FI,17178
+kreuzberg/_ocr/_paddleocr.py,sha256=s75aQJILXm1ZbacyZiLPXh6jEAg9tk2NYnwPnfSDrRU,17543
+kreuzberg/_ocr/_tesseract.py,sha256=teLMH1pBhpcmEXDcyZlv56hYINLGMuaKZ0CQtcu_czQ,31510
 kreuzberg/_utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-kreuzberg/_utils/_cache.py,sha256=H2d6JOiTTAoJx5HPJoToCk4ik-ztTRNEJRrHgcSUTLs,15249
-kreuzberg/_utils/_device.py,sha256=PC8YUPE95pzOyU7sU_icqNZpSfi6HZlEFfmWcV1Uees,10226
+kreuzberg/_utils/_cache.py,sha256=hYd_a5Ni5VJBE1XU_eN9gvQ5gg0FRsdbRgmJe-OIJHM,15253
+kreuzberg/_utils/_device.py,sha256=arVrJOSp_2LbbN6lu_rMEUOezzRogdWdkF8d5q5Bg8U,10345
 kreuzberg/_utils/_document_cache.py,sha256=z8irioKsOu8xve1YgHatm__wIFvs9I1gDK3tLNsNyqM,6926
 kreuzberg/_utils/_errors.py,sha256=UsktQ_p7eOj9crPsFDg8HgRSE5-IpuFC7y1e6dDI_fY,6503
 kreuzberg/_utils/_pdf_lock.py,sha256=nqxAYCNlfWDrJtP4ZNu57st1YnkDl-gYXdr0q8nv0kA,1961
@@ -46,8 +47,8 @@ kreuzberg/_utils/_string.py,sha256=bCzO3UO6nXupxvtMWvHqfp1Vd9CTzEH9jmpJXQ7upAU,6
 kreuzberg/_utils/_sync.py,sha256=7LSavBmxVKQUzdjfx9fYRAI9IbJtRw8iGf_Q8B7RX9g,4923
 kreuzberg/_utils/_table.py,sha256=IomrfQBP85DZI8RmQjOVs2Siq7VP9FUTYPaZR4t3yRw,8199
 kreuzberg/_utils/_tmp.py,sha256=hVn-VVijIg2FM7EZJ899gc7wZg-TGoJZoeAcxMX-Cxg,1044
-kreuzberg-3.8.2.dist-info/METADATA,sha256=RiP64og5wOaf9gPZ7CwOsNYYx9GBnVMg8orgqZdncKA,11466
-kreuzberg-3.8.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-kreuzberg-3.8.2.dist-info/entry_points.txt,sha256=GplGhFryCP7kyAG_k-Mdahznvo2fwi73qLFg5yQfH_A,91
-kreuzberg-3.8.2.dist-info/licenses/LICENSE,sha256=-8caMvpCK8SgZ5LlRKhGCMtYDEXqTKH9X8pFEhl91_4,1066
-kreuzberg-3.8.2.dist-info/RECORD,,
+kreuzberg-3.9.0.dist-info/METADATA,sha256=C83JYzqxhGHhrqWDUmo0eJwK_2szx9ZQt3cnkocgwBY,11876
+kreuzberg-3.9.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+kreuzberg-3.9.0.dist-info/entry_points.txt,sha256=GplGhFryCP7kyAG_k-Mdahznvo2fwi73qLFg5yQfH_A,91
+kreuzberg-3.9.0.dist-info/licenses/LICENSE,sha256=-8caMvpCK8SgZ5LlRKhGCMtYDEXqTKH9X8pFEhl91_4,1066
+kreuzberg-3.9.0.dist-info/RECORD,,