kreuzberg 3.7.0__py3-none-any.whl → 3.8.0__py3-none-any.whl

{kreuzberg-3.7.0.dist-info → kreuzberg-3.8.0.dist-info}/RECORD

@@ -4,12 +4,12 @@ kreuzberg/_chunker.py,sha256=2eHSRHcZdJ2ZjR3in49y3o9tPl5HMO3vkbnMqaVCbHI,1887
 kreuzberg/_cli_config.py,sha256=WD_seFjbuay_NJv77vGLBW6BVV9WZNujdzf3zQkhzPc,5691
 kreuzberg/_constants.py,sha256=Bxc8oiN-wHwnWXT9bEiJhTUcu1ygPpra5qHirAif3b4,191
 kreuzberg/_entity_extraction.py,sha256=EIasBGpkZ-3FwivjEpisz23LilTwx8os-IbfrDtzNl4,7815
-kreuzberg/_gmft.py,sha256=e-UpYwizRX_V-dn0a7ja0Z9nShAmDKA1Q7HThJy8cyA,14856
+kreuzberg/_gmft.py,sha256=ZIEUu4Uy5zYNFEeDRbz1cLJhnCAStVsSzm1PQ3vDeO8,14828
 kreuzberg/_language_detection.py,sha256=22-uXoOu_ws0K8Hz2M7U_SF9QX3npRYLhntAE1dNLFU,3283
-kreuzberg/_mime_types.py,sha256=QgX-k8aI4lTKArObDM0TFPt7DUjUVwWrdIaIZDh_XQY,7815
+kreuzberg/_mime_types.py,sha256=OhJ6gEyyLHjyvRtkk37zyLFBsRcSd_QybBaV8TxinIg,8471
 kreuzberg/_playa.py,sha256=rU6ii2Qnrj8tkDYlSiab5h-BCYLJnUg4QwSLVDEXF5g,11883
-kreuzberg/_registry.py,sha256=c2B_PJbaL0q3ab2eNmj_0jldeyMaqgvRwkZqUU4MM5Q,3290
-kreuzberg/_types.py,sha256=U72a4SXS1e-zV8cXG0tiozMy9mX9wFM1ma6sVz7HpJo,9936
+kreuzberg/_registry.py,sha256=wGSlkS0U1zqruWQCLE95vj4a2mw1yyvf0j6rgz80sJg,3473
+kreuzberg/_types.py,sha256=R_0Xc2kq4nEwkruvkB3qfrLeJ996419hBQ_1C6Xrqjo,13388
 kreuzberg/cli.py,sha256=S0w2nGXBWPFn1NhxppW7dpUwB9f_3ymFuWSAB2aRu9g,12465
 kreuzberg/exceptions.py,sha256=xRaiJh11i8E6Nc-gAQPgNW5xvhiiFBhRS-CBbCEbHQM,2881
 kreuzberg/extraction.py,sha256=mdH45bMAAUUNXYT7UrNyWJ2oD_gXuLUU-NyuYxQM884,17459
@@ -17,40 +17,41 @@ kreuzberg/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 kreuzberg/_api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 kreuzberg/_api/main.py,sha256=kZCMPPzP4BGzEege9pdhQTJPKKVjCaC6kZdMMeaqP2M,2599
 kreuzberg/_extractors/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-kreuzberg/_extractors/_base.py,sha256=YUr6A2n34LlFzbYQkiKqhXAphL9RYrvAls5SlkoQqNg,3028
-kreuzberg/_extractors/_html.py,sha256=L_vcKyv1ObI6irPaD3-WTKqxeRfZA4Rhsl3zUiAe_ws,1312
-kreuzberg/_extractors/_image.py,sha256=pYfh3x9CkiIxOLvp0jkkZcmLbB_FpdfDo01klSc6OzQ,4819
+kreuzberg/_extractors/_base.py,sha256=ECEwBpxnIy_J9kGZGuqsaPCgLFfxRn7kn4hIf11gDJ8,4478
+kreuzberg/_extractors/_email.py,sha256=6-Mk1TRXPyy9ylWKCpgdrogyzhiFnJOTuTRld1ghO8I,5695
+kreuzberg/_extractors/_html.py,sha256=lOM1Tgrrvd7vpEeFAxC1dp0Tibr6N2FEHCjgFx0FK64,1745
+kreuzberg/_extractors/_image.py,sha256=0kzOQTTeJacaA8I9833fFvVQSz6FtUe9Nuw1oy0ToD0,4939
 kreuzberg/_extractors/_pandoc.py,sha256=oQ4DgQSPoX1LXjGAKh_A40JHqiKWb91LeRBYSS_6EUA,26750
-kreuzberg/_extractors/_pdf.py,sha256=R33ggTd0IU6NsEnzgHFTr9ScgcnM8nIIstDq7XMVcvg,14792
-kreuzberg/_extractors/_presentation.py,sha256=ZX-EKQppHwvKtyKk0-IQVF6QAqJi0SfGgCiiyqMQh0w,8701
-kreuzberg/_extractors/_spread_sheet.py,sha256=HOzCeYQc6kaMveAHfi80LrsF0yU7Kn74aKQ7lrMAlo8,6480
+kreuzberg/_extractors/_pdf.py,sha256=giYG3aEdmsxT0tGWKBaMzHDPz74-jVmK4HZARDEBhsM,17108
+kreuzberg/_extractors/_presentation.py,sha256=CUlqZl_QCdJdumsZh0BpROkFbvi9uq7yMoIt3bRTUeE,10859
+kreuzberg/_extractors/_spread_sheet.py,sha256=Nvyz7XT7C2ai4QeUashBeENQpuP5rs8SmKfumxEqlCg,13712
+kreuzberg/_extractors/_structured.py,sha256=i3jAvhHZt_BsRGgZZfgcsUqlwAg_RNc8vsuecb04T0c,5581
 kreuzberg/_mcp/__init__.py,sha256=8PYV-omC8Rln7Cove8C3rHu3d7sR1FuiwSBG1O7vkAE,92
 kreuzberg/_mcp/server.py,sha256=BQHeKI89aKf24BIE4n6m8r1rVA1Zgt6vM8Ki_OHuGnc,6780
-kreuzberg/_multiprocessing/__init__.py,sha256=nwYQpKH7ixHwzkQbTMFCstOCBKktmbNq5dTrwI2Mn94,203
+kreuzberg/_multiprocessing/__init__.py,sha256=X2BtgKmWhF1rl0JYg2gvoSUaozKExfsWh-RRNvzNoOs,202
 kreuzberg/_multiprocessing/gmft_isolated.py,sha256=ZfbhiL5bhBEJnibUSls3WV-FECrnU9VvKfq5O2foHcc,11191
-kreuzberg/_multiprocessing/process_manager.py,sha256=_qtB8y9td2coJevlIl4z6F__jau320RdI1lqdyuaeD4,6061
-kreuzberg/_multiprocessing/sync_easyocr.py,sha256=-3_Ol0H8G6RhPxTbTPvoe8fTsTz3e-dg2QbHHnoJL48,7693
-kreuzberg/_multiprocessing/sync_paddleocr.py,sha256=5558iTjPXCyJWuyhZckmuJLadUwJDb5YVC8Cv-FOaWg,6090
-kreuzberg/_multiprocessing/sync_tesseract.py,sha256=Ck1PvHGWOMQWUcC7RyVrBt8K9VDFQ0lQcwFkwYzl3rE,8240
-kreuzberg/_multiprocessing/tesseract_pool.py,sha256=UN7BtS_ib1ux9xuR6d6AB3PY7UEUhd-5Ti1n1H0UnYw,10945
-kreuzberg/_ocr/__init__.py,sha256=VTqwKDlIRbjve71Y11Ztygyhv5aWG9LWTj8iX66ANxE,533
+kreuzberg/_ocr/__init__.py,sha256=CC9Ob1t_ltTYUamK1ZtmkswfCYdn1B-Z0kPemsQU0xU,1439
 kreuzberg/_ocr/_base.py,sha256=lNT0Tin4hzbmaamqqySxvYEwNtrJB5gGlStrANQQcyc,1637
 kreuzberg/_ocr/_easyocr.py,sha256=90Dv1xaLXbpG7EtmRQE5ykvnhqZJR3xSFXlxFMCSVSI,13740
 kreuzberg/_ocr/_paddleocr.py,sha256=UvugDdZd7RojHUiFeBaI8aqz36ecegPLj2v6oT6c42g,13776
-kreuzberg/_ocr/_tesseract.py,sha256=3s3MkZN9xA_Uedx4s2p5m4IEIMhGjs9gYHxan9Iz-2g,13044
+kreuzberg/_ocr/_pool.py,sha256=Yb0l_GxnPsIWn3NA2FuBYEC8ipIqgwaYglUt0ltqSvk,10948
+kreuzberg/_ocr/_sync.py,sha256=cdLiH9hYqygzqW3LkibhrE6C8atin7mfTv_k3JJFE0k,18287
+kreuzberg/_ocr/_tesseract.py,sha256=KtenEIGL63gRhdH2hxOEVM89locAETGo2bNjQMXjTwY,13266
 kreuzberg/_utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-kreuzberg/_utils/_cache.py,sha256=JGiwwcNBoD950IbsPUUAD5gAGS7byUuz0BqYSneVakc,13088
+kreuzberg/_utils/_cache.py,sha256=CtpSmEggWoIPDZ9_Nl0i5pr7wtPyci8EVT-ajYsARGI,13609
 kreuzberg/_utils/_device.py,sha256=rnaSSB5ibf2wr7EDxrcmOUZ4Ocor0pHkwb3N1pC46EY,10276
 kreuzberg/_utils/_document_cache.py,sha256=z8irioKsOu8xve1YgHatm__wIFvs9I1gDK3tLNsNyqM,6926
 kreuzberg/_utils/_errors.py,sha256=AV3oaRQDgJxe1YUZd9pCQUysUv9KW8Ib37MvnyFOZ4o,6386
 kreuzberg/_utils/_pdf_lock.py,sha256=nqxAYCNlfWDrJtP4ZNu57st1YnkDl-gYXdr0q8nv0kA,1961
-kreuzberg/_utils/_process_pool.py,sha256=-0SNP01Qz21D7hgJmN0eHoqKusSygwPbi1U7IzJlPio,2895
-kreuzberg/_utils/_serialization.py,sha256=AhZvyAu4KsjAqyZDh--Kn2kSWGgCuH7udio8lTklO0g,2132
-kreuzberg/_utils/_string.py,sha256=owIVkUtP0__GiJD9RIJzPdvyIigT5sQho3mOXPbsnW0,958
-kreuzberg/_utils/_sync.py,sha256=oT4Y_cDBKtE_BFEoLTae3rSisqlYXzW-jlUG_x-dmLM,4725
+kreuzberg/_utils/_process_pool.py,sha256=E3bHOO67TeoLUBjtw5HoY9gyFl621VaImYI-_itQ96c,8653
+kreuzberg/_utils/_quality.py,sha256=dgFLt40NSqB8Ciej5QcZQLiV4U7LcrGux0vXckiE31U,7568
+kreuzberg/_utils/_serialization.py,sha256=Rt5zSkvzf1SVNDrI6F2Zvnkel24mQkD1QvP0WjgZUgk,2195
+kreuzberg/_utils/_string.py,sha256=5YKu9EZlZQ-LkphXUq8fdwKQrX9jWACFEhMGfjIysf4,6381
+kreuzberg/_utils/_sync.py,sha256=7LSavBmxVKQUzdjfx9fYRAI9IbJtRw8iGf_Q8B7RX9g,4923
+kreuzberg/_utils/_table.py,sha256=C2skLtcyczxDEH33Qw2dOwnR15SGillvNEP-NzBG3R8,8156
 kreuzberg/_utils/_tmp.py,sha256=hVn-VVijIg2FM7EZJ899gc7wZg-TGoJZoeAcxMX-Cxg,1044
-kreuzberg-3.7.0.dist-info/METADATA,sha256=0rBXhtDYCdZ2AGpQdXTTZUQUX8T01OsKzwrm2nl14QA,11137
-kreuzberg-3.7.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-kreuzberg-3.7.0.dist-info/entry_points.txt,sha256=GplGhFryCP7kyAG_k-Mdahznvo2fwi73qLFg5yQfH_A,91
-kreuzberg-3.7.0.dist-info/licenses/LICENSE,sha256=-8caMvpCK8SgZ5LlRKhGCMtYDEXqTKH9X8pFEhl91_4,1066
-kreuzberg-3.7.0.dist-info/RECORD,,
+kreuzberg-3.8.0.dist-info/METADATA,sha256=d1N7v0EvJA-22g071Dctler5zF11WlKGTgLjGpsV8iw,11422
+kreuzberg-3.8.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+kreuzberg-3.8.0.dist-info/entry_points.txt,sha256=GplGhFryCP7kyAG_k-Mdahznvo2fwi73qLFg5yQfH_A,91
+kreuzberg-3.8.0.dist-info/licenses/LICENSE,sha256=-8caMvpCK8SgZ5LlRKhGCMtYDEXqTKH9X8pFEhl91_4,1066
+kreuzberg-3.8.0.dist-info/RECORD,,

kreuzberg/_multiprocessing/process_manager.py

@@ -1,189 +0,0 @@
-"""Process pool manager for resource-aware multiprocessing."""
-
-from __future__ import annotations
-
-import multiprocessing as mp
-from concurrent.futures import ProcessPoolExecutor
-from typing import TYPE_CHECKING, Any, TypeVar
-
-import anyio
-import psutil
-from typing_extensions import Self
-
-if TYPE_CHECKING:
-    import types
-    from collections.abc import Callable
-
-T = TypeVar("T")
-
-
-class ProcessPoolManager:
-    """Resource-aware process pool manager for CPU-intensive tasks."""
-
-    def __init__(
-        self,
-        max_processes: int | None = None,
-        memory_limit_gb: float | None = None,
-    ) -> None:
-        """Initialize the process pool manager.
-
-        Args:
-            max_processes: Maximum number of processes. Defaults to CPU count.
-            memory_limit_gb: Memory limit in GB. Defaults to 75% of available memory.
-        """
-        self.max_processes = max_processes or mp.cpu_count()
-
-        if memory_limit_gb is None:
-            available_memory = psutil.virtual_memory().available
-            self.memory_limit_bytes = int(available_memory * 0.75)  # Use 75% of available  # ~keep
-        else:
-            self.memory_limit_bytes = int(memory_limit_gb * 1024**3)
-
-        self._executor: ProcessPoolExecutor | None = None
-        self._active_tasks = 0
-
-    def get_optimal_workers(self, task_memory_mb: float = 100) -> int:
-        """Calculate optimal number of workers based on memory constraints.
-
-        Args:
-            task_memory_mb: Estimated memory usage per task in MB.
-
-        Returns:
-            Optimal number of workers.
-        """
-        task_memory_bytes = task_memory_mb * 1024**2
-        memory_based_limit = max(1, int(self.memory_limit_bytes / task_memory_bytes))
-
-        return min(self.max_processes, memory_based_limit)
-
-    def _ensure_executor(self, max_workers: int | None = None) -> ProcessPoolExecutor:
-        """Ensure process pool executor is initialized."""
-        if self._executor is None or getattr(self._executor, "_max_workers", None) != max_workers:
-            if self._executor is not None:
-                self._executor.shutdown(wait=False)
-
-            workers = max_workers or self.max_processes
-            self._executor = ProcessPoolExecutor(max_workers=workers)
-
-        return self._executor
-
-    async def submit_task(
-        self,
-        func: Callable[..., T],
-        *args: Any,
-        task_memory_mb: float = 100,
-    ) -> T:
-        """Submit a task to the process pool.
-
-        Args:
-            func: Function to execute.
-            *args: Positional arguments for the function.
-            task_memory_mb: Estimated memory usage in MB.
-
-        Returns:
-            Result of the function execution.
-        """
-        workers = self.get_optimal_workers(task_memory_mb)
-        self._ensure_executor(workers)
-
-        self._active_tasks += 1
-
-        try:
-            return await anyio.to_thread.run_sync(func, *args)
-        finally:
-            self._active_tasks -= 1
-
-    async def submit_batch(
-        self,
-        func: Callable[..., T],
-        arg_batches: list[tuple[Any, ...]],
-        task_memory_mb: float = 100,
-        max_concurrent: int | None = None,
-    ) -> list[T]:
-        """Submit a batch of tasks to the process pool.
-
-        Args:
-            func: Function to execute.
-            arg_batches: List of argument tuples for each task.
-            task_memory_mb: Estimated memory usage per task in MB.
-            max_concurrent: Maximum concurrent tasks. Defaults to optimal workers.
-
-        Returns:
-            List of results in the same order as input.
-        """
-        if not arg_batches:
-            return []
-
-        workers = self.get_optimal_workers(task_memory_mb)
-        max_concurrent = max_concurrent or workers
-
-        self._ensure_executor(workers)
-
-        semaphore = anyio.CapacityLimiter(max_concurrent)
-
-        async def submit_single(args: tuple[Any, ...]) -> T:
-            async with semaphore:
-                self._active_tasks += 1
-                try:
-                    return await anyio.to_thread.run_sync(func, *args)
-                finally:
-                    self._active_tasks -= 1
-
-        async with anyio.create_task_group() as tg:
-            results: list[T] = [None] * len(arg_batches)  # type: ignore[list-item]
-
-            async def run_task(idx: int, args: tuple[Any, ...]) -> None:
-                results[idx] = await submit_single(args)
-
-            for idx, args in enumerate(arg_batches):
-                tg.start_soon(run_task, idx, args)
-
-        return results
-
-    def get_system_info(self) -> dict[str, Any]:
-        """Get current system resource information."""
-        memory = psutil.virtual_memory()
-        cpu_percent = psutil.cpu_percent(interval=1)
-
-        return {
-            "cpu_count": mp.cpu_count(),
-            "cpu_percent": cpu_percent,
-            "memory_total": memory.total,
-            "memory_available": memory.available,
-            "memory_percent": memory.percent,
-            "active_tasks": self._active_tasks,
-            "max_processes": self.max_processes,
-            "memory_limit": self.memory_limit_bytes,
-        }
-
-    def shutdown(self, wait: bool = True) -> None:
-        """Shutdown the process pool."""
-        if self._executor is not None:
-            self._executor.shutdown(wait=wait)
-            self._executor = None
-
-    def __enter__(self) -> Self:
-        """Context manager entry."""
-        return self
-
-    def __exit__(
-        self,
-        exc_type: type[BaseException] | None,
-        exc_val: BaseException | None,
-        exc_tb: types.TracebackType | None,
-    ) -> None:
-        """Context manager exit."""
-        self.shutdown()
-
-    async def __aenter__(self) -> Self:
-        """Async context manager entry."""
-        return self
-
-    async def __aexit__(
-        self,
-        exc_type: type[BaseException] | None,
-        exc_val: BaseException | None,
-        exc_tb: types.TracebackType | None,
-    ) -> None:
-        """Async context manager exit."""
-        self.shutdown()

kreuzberg/_multiprocessing/sync_easyocr.py

@@ -1,235 +0,0 @@
-"""Pure synchronous EasyOCR without any async overhead."""
-
-from __future__ import annotations
-
-import tempfile
-from pathlib import Path
-from typing import Any
-
-from PIL import Image
-
-from kreuzberg._mime_types import PLAIN_TEXT_MIME_TYPE
-from kreuzberg._ocr._easyocr import EasyOCRConfig
-from kreuzberg._types import ExtractionResult
-from kreuzberg._utils._string import normalize_spaces
-from kreuzberg.exceptions import MissingDependencyError, OCRError
-
-
-def _get_easyocr_instance(config: EasyOCRConfig) -> Any:
-    """Get an EasyOCR Reader instance with the given configuration."""
-    try:
-        import easyocr
-    except ImportError as e:
-        raise MissingDependencyError("EasyOCR is not installed. Install it with: pip install easyocr") from e
-
-    gpu = False
-    if hasattr(config, "device"):
-        if config.device and config.device.lower() != "cpu":
-            gpu = True
-    elif hasattr(config, "use_gpu"):
-        gpu = config.use_gpu
-
-    language = config.language if hasattr(config, "language") else "en"
-    if isinstance(language, str):
-        lang_list = [lang.strip().lower() for lang in language.split(",")]
-    else:
-        lang_list = [lang.lower() for lang in language]
-
-    kwargs = {
-        "lang_list": lang_list,
-        "gpu": gpu,
-        "model_storage_directory": getattr(config, "model_storage_directory", None),
-        "user_network_directory": getattr(config, "user_network_directory", None),
-        "recog_network": getattr(config, "recog_network", None),
-        "detector": getattr(config, "detector", None),
-        "recognizer": getattr(config, "recognizer", None),
-        "verbose": False,
-        "quantize": getattr(config, "quantize", None),
-        "cudnn_benchmark": getattr(config, "cudnn_benchmark", None),
-    }
-
-    kwargs = {k: v for k, v in kwargs.items() if v is not None}
-
-    return easyocr.Reader(**kwargs)
-
-
-def process_image_sync_pure(
-    image_path: str | Path,
-    config: EasyOCRConfig | None = None,
-) -> ExtractionResult:
-    """Process an image with EasyOCR using pure sync implementation.
-
-    This bypasses all async overhead and calls EasyOCR directly.
-
-    Args:
-        image_path: Path to the image file.
-        config: EasyOCR configuration.
-
-    Returns:
-        Extraction result.
-    """
-    cfg = config or EasyOCRConfig()
-
-    try:
-        reader = _get_easyocr_instance(cfg)
-
-        readtext_kwargs = {
-            "decoder": cfg.decoder,
-            "beamWidth": cfg.beam_width,
-            "batch_size": getattr(cfg, "batch_size", 1),
-            "workers": getattr(cfg, "workers", 0),
-            "allowlist": getattr(cfg, "allowlist", None),
-            "blocklist": getattr(cfg, "blocklist", None),
-            "detail": getattr(cfg, "detail", 1),
-            "rotation_info": cfg.rotation_info,
-            "paragraph": getattr(cfg, "paragraph", False),
-            "min_size": cfg.min_size,
-            "text_threshold": cfg.text_threshold,
-            "low_text": cfg.low_text,
-            "link_threshold": cfg.link_threshold,
-            "canvas_size": cfg.canvas_size,
-            "mag_ratio": cfg.mag_ratio,
-            "slope_ths": cfg.slope_ths,
-            "ycenter_ths": cfg.ycenter_ths,
-            "height_ths": cfg.height_ths,
-            "width_ths": cfg.width_ths,
-            "add_margin": cfg.add_margin,
-            "x_ths": cfg.x_ths,
-            "y_ths": cfg.y_ths,
-        }
-
-        readtext_kwargs = {k: v for k, v in readtext_kwargs.items() if v is not None}
-
-        results = reader.readtext(str(image_path), **readtext_kwargs)
-
-        if not results:
-            return ExtractionResult(
-                content="",
-                mime_type=PLAIN_TEXT_MIME_TYPE,
-                metadata={},
-                chunks=[],
-            )
-
-        texts = []
-        confidences = []
-
-        detail_value = getattr(cfg, "detail", 1)
-        if detail_value:
-            for result in results:
-                min_result_length = 2
-                max_confidence_index = 2
-                if len(result) >= min_result_length:
-                    _bbox, text = result[0], result[1]
-                    confidence = result[max_confidence_index] if len(result) > max_confidence_index else 1.0
-                    texts.append(text)
-                    confidences.append(confidence)
-        else:
-            texts = results
-            confidences = [1.0] * len(texts)
-
-        content = "\n".join(texts)
-        content = normalize_spaces(content)
-
-        avg_confidence = sum(confidences) / len(confidences) if confidences else 0.0
-
-        metadata = {"confidence": avg_confidence} if confidences else {}
-
-        return ExtractionResult(
-            content=content,
-            mime_type=PLAIN_TEXT_MIME_TYPE,
-            metadata=metadata,  # type: ignore[arg-type]
-            chunks=[],
-        )
-
-    except Exception as e:
-        raise OCRError(f"EasyOCR processing failed: {e}") from e
-
-
-def process_image_bytes_sync_pure(
-    image_bytes: bytes,
-    config: EasyOCRConfig | None = None,
-) -> ExtractionResult:
-    """Process image bytes with EasyOCR using pure sync implementation.
-
-    Args:
-        image_bytes: Image data as bytes.
-        config: EasyOCR configuration.
-
-    Returns:
-        Extraction result.
-    """
-    import io
-
-    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")
-        image_path = tmp_image.name
-
-    try:
-        return process_image_sync_pure(image_path, config)
-    finally:
-        image_file = Path(image_path)
-        if image_file.exists():
-            image_file.unlink()
-
-
-def process_batch_images_sync_pure(
-    image_paths: list[str | Path],
-    config: EasyOCRConfig | None = None,
-) -> list[ExtractionResult]:
-    """Process a batch of images sequentially with pure sync implementation.
-
-    Args:
-        image_paths: List of image file paths.
-        config: EasyOCR configuration.
-
-    Returns:
-        List of extraction results.
-    """
-    results = []
-    for image_path in image_paths:
-        result = process_image_sync_pure(image_path, config)
-        results.append(result)
-    return results
-
-
-def process_batch_images_threaded(
-    image_paths: list[str | Path],
-    config: EasyOCRConfig | None = None,
-    max_workers: int | None = None,
-) -> list[ExtractionResult]:
-    """Process a batch of images using threading.
-
-    Args:
-        image_paths: List of image file paths.
-        config: EasyOCR configuration.
-        max_workers: Maximum number of threads.
-
-    Returns:
-        List of extraction results in same order as input.
-    """
-    import multiprocessing as mp
-    from concurrent.futures import ThreadPoolExecutor, as_completed
-
-    if max_workers is None:
-        max_workers = min(len(image_paths), mp.cpu_count())
-
-    with ThreadPoolExecutor(max_workers=max_workers) as executor:
-        future_to_index = {
-            executor.submit(process_image_sync_pure, path, config): i for i, path in enumerate(image_paths)
-        }
-
-        results: list[ExtractionResult] = [None] * len(image_paths)  # type: ignore[list-item]
-        for future in as_completed(future_to_index):
-            index = future_to_index[future]
-            try:
-                results[index] = future.result()
-            except Exception as e:  # noqa: BLE001
-                results[index] = ExtractionResult(
-                    content=f"Error: {e}",
-                    mime_type=PLAIN_TEXT_MIME_TYPE,
-                    metadata={"error": str(e)},  # type: ignore[typeddict-unknown-key]
-                    chunks=[],
-                )
-
-    return results