kreuzberg 3.11.3__py3-none-any.whl → 3.13.0__py3-none-any.whl

kreuzberg/__init__.py

@@ -1,16 +1,20 @@
 from importlib.metadata import version
 
-from kreuzberg._config import discover_and_load_config, load_config_from_path, try_discover_config
-from kreuzberg._entity_extraction import SpacyEntityExtractionConfig
-from kreuzberg._gmft import GMFTConfig
-from kreuzberg._language_detection import LanguageDetectionConfig
-from kreuzberg._ocr._easyocr import EasyOCRConfig
-from kreuzberg._ocr._paddleocr import PaddleOCRConfig
-from kreuzberg._ocr._tesseract import TesseractConfig
-
-from ._ocr._tesseract import PSMMode
 from ._registry import ExtractorRegistry
-from ._types import Entity, ExtractionConfig, ExtractionResult, Metadata, TableData
+from ._types import (
+    EasyOCRConfig,
+    Entity,
+    ExtractionConfig,
+    ExtractionResult,
+    GMFTConfig,
+    LanguageDetectionConfig,
+    Metadata,
+    PaddleOCRConfig,
+    PSMMode,
+    SpacyEntityExtractionConfig,
+    TableData,
+    TesseractConfig,
+)
 from .exceptions import KreuzbergError, MissingDependencyError, OCRError, ParsingError, ValidationError
 from .extraction import (
     batch_extract_bytes,
@@ -49,11 +53,8 @@ __all__ = [
     "batch_extract_bytes_sync",
     "batch_extract_file",
     "batch_extract_file_sync",
-    "discover_and_load_config",
     "extract_bytes",
     "extract_bytes_sync",
     "extract_file",
     "extract_file_sync",
-    "load_config_from_path",
-    "try_discover_config",
 ]

kreuzberg/__main__.py

@@ -1,5 +1,3 @@
-"""Entry point for running kreuzberg as a module with python -m kreuzberg."""
-
 from __future__ import annotations
 
 from kreuzberg.cli import cli

kreuzberg/_api/main.py

@@ -1,20 +1,24 @@
 from __future__ import annotations
 
-from json import dumps
-from typing import TYPE_CHECKING, Annotated, Any
+from functools import lru_cache
+from json import dumps, loads
+from typing import TYPE_CHECKING, Annotated, Any, Literal
 
 import msgspec
 
 from kreuzberg import (
+    EasyOCRConfig,
     ExtractionConfig,
     ExtractionResult,
     KreuzbergError,
     MissingDependencyError,
+    PaddleOCRConfig,
     ParsingError,
+    TesseractConfig,
     ValidationError,
     batch_extract_bytes,
 )
-from kreuzberg._config import try_discover_config
+from kreuzberg._config import discover_config
 
 if TYPE_CHECKING:
     from litestar.datastructures import UploadFile
@@ -65,17 +69,123 @@ def exception_handler(request: Request[Any, Any, Any], exception: KreuzbergError
     )
 
 
+def _convert_value_type(current_value: Any, new_value: Any) -> Any:
+    if isinstance(current_value, bool):
+        if isinstance(new_value, str):
+            return str(new_value).lower() in ("true", "1", "yes", "on")
+        return bool(new_value)
+    if isinstance(current_value, int) and not isinstance(new_value, bool):
+        return int(new_value) if new_value is not None else current_value
+    if isinstance(current_value, float):
+        return float(new_value) if new_value is not None else current_value
+    return new_value
+
+
+def _create_ocr_config(
+    ocr_backend: Literal["tesseract", "easyocr", "paddleocr"] | None, config_dict: dict[str, Any]
+) -> Any:
+    if ocr_backend == "tesseract":
+        return TesseractConfig(**config_dict)
+    if ocr_backend == "easyocr":
+        return EasyOCRConfig(**config_dict)
+    if ocr_backend == "paddleocr":
+        return PaddleOCRConfig(**config_dict)
+    return config_dict
+
+
+@lru_cache(maxsize=128)
+def _merge_configs_cached(
+    static_config: ExtractionConfig | None,
+    query_params: tuple[tuple[str, Any], ...],
+    header_config: tuple[tuple[str, Any], ...] | None,
+) -> ExtractionConfig:
+    """Cached implementation of merge_configs with hashable parameters."""
+    base_config = static_config or ExtractionConfig()
+    config_dict = base_config.to_dict()
+
+    query_dict = dict(query_params) if query_params else {}
+    for key, value in query_dict.items():
+        if value is not None and key in config_dict:
+            config_dict[key] = _convert_value_type(config_dict[key], value)
+
+    if header_config:
+        header_dict = dict(header_config)
+        for key, value in header_dict.items():
+            if key in config_dict:
+                config_dict[key] = value
+
+    if "ocr_config" in config_dict and isinstance(config_dict["ocr_config"], dict):
+        ocr_backend = config_dict.get("ocr_backend")
+        config_dict["ocr_config"] = _create_ocr_config(ocr_backend, config_dict["ocr_config"])
+
+    return ExtractionConfig(**config_dict)
+
+
+def merge_configs(
+    static_config: ExtractionConfig | None,
+    query_params: dict[str, Any],
+    header_config: dict[str, Any] | None,
+) -> ExtractionConfig:
+    """Merge configurations with precedence: header > query > static > default."""
+    query_tuple = tuple(sorted(query_params.items())) if query_params else ()
+    header_tuple = tuple(sorted(header_config.items())) if header_config else None
+
+    return _merge_configs_cached(static_config, query_tuple, header_tuple)
+
+
 @post("/extract", operation_id="ExtractFiles")
-async def handle_files_upload(
+async def handle_files_upload(  # noqa: PLR0913
+    request: Request[Any, Any, Any],
     data: Annotated[list[UploadFile], Body(media_type=RequestEncodingType.MULTI_PART)],
+    chunk_content: str | bool | None = None,
+    max_chars: int | None = None,
+    max_overlap: int | None = None,
+    extract_tables: str | bool | None = None,
+    extract_entities: str | bool | None = None,
+    extract_keywords: str | bool | None = None,
+    keyword_count: int | None = None,
+    force_ocr: str | bool | None = None,
+    ocr_backend: Literal["tesseract", "easyocr", "paddleocr"] | None = None,
+    auto_detect_language: str | bool | None = None,
+    pdf_password: str | None = None,
 ) -> list[ExtractionResult]:
-    """Extracts text content from an uploaded file."""
-    # Try to discover configuration from files
-    config = try_discover_config()
+    """Extracts text content from uploaded files with optional runtime configuration.
+
+    Configuration can be provided via:
+    1. Query parameters for common settings
+    2. X-Extraction-Config header for complex nested configurations (JSON format)
+    3. Static configuration file (kreuzberg.toml or pyproject.toml)
+
+    Precedence: Header config > Query params > Static config > Defaults
+    """
+    static_config = discover_config()
+
+    query_params = {
+        "chunk_content": chunk_content,
+        "max_chars": max_chars,
+        "max_overlap": max_overlap,
+        "extract_tables": extract_tables,
+        "extract_entities": extract_entities,
+        "extract_keywords": extract_keywords,
+        "keyword_count": keyword_count,
+        "force_ocr": force_ocr,
+        "ocr_backend": ocr_backend,
+        "auto_detect_language": auto_detect_language,
+        "pdf_password": pdf_password,
+    }
+
+    header_config = None
+    if config_header := request.headers.get("X-Extraction-Config"):
+        try:
+            header_config = loads(config_header)
+        except Exception as e:
+            raise ValidationError(f"Invalid JSON in X-Extraction-Config header: {e}", context={"error": str(e)}) from e
+
+    final_config = merge_configs(static_config, query_params, header_config)
 
     return await batch_extract_bytes(
         [(await file.read(), file.content_type) for file in data],
-        config=config or ExtractionConfig(),
+        config=final_config,
     )
 
 
@@ -88,7 +198,7 @@ async def health_check() -> dict[str, str]:
 @get("/config", operation_id="GetConfiguration")
 async def get_configuration() -> dict[str, Any]:
     """Get the current configuration."""
-    config = try_discover_config()
+    config = discover_config()
     if config is None:
         return {"message": "No configuration file found", "config": None}