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

kreuzberg/exceptions.py

@@ -7,6 +7,8 @@ from typing import Any
 class KreuzbergError(Exception):
     """Base exception for all Kreuzberg errors."""
 
+    __slots__ = ("context",)
+
     context: Any
     """The context of the error."""
 
@@ -43,14 +45,20 @@ class KreuzbergError(Exception):
 class ParsingError(KreuzbergError):
     """Raised when a parsing error occurs."""
 
+    __slots__ = ()
+
 
 class ValidationError(KreuzbergError):
     """Raised when a validation error occurs."""
 
+    __slots__ = ()
+
 
 class MissingDependencyError(KreuzbergError):
     """Raised when a dependency is missing."""
 
+    __slots__ = ()
+
     @classmethod
     def create_for_package(
         cls, *, dependency_group: str, functionality: str, package_name: str
@@ -79,3 +87,5 @@ class MissingDependencyError(KreuzbergError):
 
 class OCRError(KreuzbergError):
     """Raised when an OCR error occurs."""
+
+    __slots__ = ()

kreuzberg/extraction.py

@@ -1,5 +1,7 @@
 from __future__ import annotations
 
+import multiprocessing as mp
+from concurrent.futures import ThreadPoolExecutor, as_completed
 from pathlib import Path
 from typing import TYPE_CHECKING, Any, Final, cast
 
@@ -14,6 +16,8 @@ from kreuzberg._mime_types import (
 )
 from kreuzberg._registry import ExtractorRegistry
 from kreuzberg._types import ExtractionConfig
+from kreuzberg._utils._document_cache import get_document_cache
+from kreuzberg._utils._errors import create_error_context
 from kreuzberg._utils._string import safe_decode
 from kreuzberg._utils._sync import run_maybe_sync, run_sync_only
 from kreuzberg.exceptions import ValidationError
@@ -136,8 +140,6 @@ async def extract_file(
     Raises:
         ValidationError: If the file path or configuration is invalid.
     """
-    from kreuzberg._utils._document_cache import get_document_cache
-
     cache = get_document_cache()
     path = Path(file_path)
     cached_result = cache.get(path, config)
@@ -194,8 +196,6 @@ async def batch_extract_file(
     if not file_paths:
         return []
 
-    import multiprocessing as mp
-
     max_concurrency = min(len(file_paths), mp.cpu_count() * 2)
     semaphore = anyio.Semaphore(max_concurrency)
 
@@ -211,8 +211,6 @@ async def batch_extract_file(
                 )
                 results[index] = result
             except Exception as e:  # noqa: BLE001
-                from kreuzberg._utils._errors import create_error_context
-
                 error_result = ExtractionResult(
                     content=f"Error: {type(e).__name__}: {e!s}",
                     mime_type="text/plain",
@@ -251,8 +249,6 @@ async def batch_extract_bytes(
     if not contents:
         return []
 
-    import multiprocessing as mp
-
     max_concurrency = min(len(contents), mp.cpu_count() * 2)
     semaphore = anyio.Semaphore(max_concurrency)
 
@@ -264,8 +260,6 @@ async def batch_extract_bytes(
                 result = await extract_bytes(content, mime_type, config)
                 results[index] = result
             except Exception as e:  # noqa: BLE001
-                from kreuzberg._utils._errors import create_error_context
-
                 error_result = ExtractionResult(
                     content=f"Error: {type(e).__name__}: {e!s}",
                     mime_type="text/plain",
@@ -331,8 +325,6 @@ def extract_file_sync(
     Raises:
         ValidationError: If the file path or configuration is invalid.
     """
-    from kreuzberg._utils._document_cache import get_document_cache
-
     cache = get_document_cache()
     path = Path(file_path)
     cached_result = cache.get(path, config)
@@ -389,9 +381,6 @@ def batch_extract_file_sync(
     if len(file_paths) <= 1:
         return [extract_file_sync(file_path=Path(file_path), mime_type=None, config=config) for file_path in file_paths]
 
-    import multiprocessing as mp
-    from concurrent.futures import ThreadPoolExecutor, as_completed
-
     max_workers = min(len(file_paths), mp.cpu_count())
 
     def extract_single(file_path: PathLike[str] | str) -> tuple[int, ExtractionResult]:
@@ -402,8 +391,6 @@ def batch_extract_file_sync(
                 extract_file_sync(file_path=Path(file_path), mime_type=None, config=config),
             )
         except Exception as e:  # noqa: BLE001
-            from kreuzberg._utils._errors import create_error_context
-
             error_result = ExtractionResult(
                 content=f"Error: {type(e).__name__}: {e!s}",
                 mime_type="text/plain",
@@ -447,9 +434,6 @@ def batch_extract_bytes_sync(
             extract_bytes_sync(content=content, mime_type=mime_type, config=config) for content, mime_type in contents
         ]
 
-    import multiprocessing as mp
-    from concurrent.futures import ThreadPoolExecutor, as_completed
-
     max_workers = min(len(contents), mp.cpu_count())
 
     def extract_single(index_and_content: tuple[int, tuple[bytes, str]]) -> tuple[int, ExtractionResult]:
@@ -458,8 +442,6 @@ def batch_extract_bytes_sync(
         try:
             return (index, extract_bytes_sync(content=content, mime_type=mime_type, config=config))
         except Exception as e:  # noqa: BLE001
-            from kreuzberg._utils._errors import create_error_context
-
             error_result = ExtractionResult(
                 content=f"Error: {type(e).__name__}: {e!s}",
                 mime_type="text/plain",
@@ -478,8 +460,8 @@ def batch_extract_bytes_sync(
             return (index, error_result)
 
     with ThreadPoolExecutor(max_workers=max_workers) as executor:
-        indexed_contents = list(enumerate(contents))
-        future_to_index = {executor.submit(extract_single, ic): i for i, ic in enumerate(indexed_contents)}
+        # Avoid creating intermediate list, use enumerate directly
+        future_to_index = {executor.submit(extract_single, (i, content)): i for i, content in enumerate(contents)}
 
         results: list[ExtractionResult] = [None] * len(contents)  # type: ignore[list-item]
         for future in as_completed(future_to_index):

kreuzberg-3.8.2.dist-info/METADATA

@@ -0,0 +1,265 @@
+Metadata-Version: 2.4
+Name: kreuzberg
+Version: 3.8.2
+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
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Information Technology
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Database
+Classifier: Topic :: Multimedia :: Graphics :: Capture :: Scanners
+Classifier: Topic :: Office/Business :: Office Suites
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Scientific/Engineering :: Information Analysis
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Text Processing :: General
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Requires-Dist: anyio>=4.9.0
+Requires-Dist: chardetng-py>=0.3.4
+Requires-Dist: exceptiongroup>=1.2.2; python_version < '3.11'
+Requires-Dist: html-to-markdown[lxml]>=1.8.0
+Requires-Dist: mcp>=1.11.0
+Requires-Dist: msgspec>=0.18.0
+Requires-Dist: playa-pdf>=0.6.1
+Requires-Dist: psutil>=7.0.0
+Requires-Dist: pypdfium2==4.30.0
+Requires-Dist: python-calamine>=0.3.2
+Requires-Dist: python-pptx>=1.0.2
+Requires-Dist: typing-extensions>=4.14.0; python_version < '3.12'
+Provides-Extra: additional-extensions
+Requires-Dist: mailparse>=1.0.15; extra == 'additional-extensions'
+Requires-Dist: tomli>=2.0.0; (python_version < '3.11') and extra == 'additional-extensions'
+Provides-Extra: all
+Requires-Dist: click>=8.2.1; extra == 'all'
+Requires-Dist: easyocr>=1.7.2; extra == 'all'
+Requires-Dist: fast-langdetect>=0.3.2; extra == 'all'
+Requires-Dist: gmft>=0.4.2; extra == 'all'
+Requires-Dist: keybert>=0.9.0; extra == 'all'
+Requires-Dist: litestar[opentelemetry,standard,structlog]>=2.16.0; extra == 'all'
+Requires-Dist: mailparse>=1.0.15; extra == 'all'
+Requires-Dist: paddleocr>=3.1.0; extra == 'all'
+Requires-Dist: paddlepaddle>=3.1.0; extra == 'all'
+Requires-Dist: rich>=14.0.0; extra == 'all'
+Requires-Dist: semantic-text-splitter>=0.27.0; extra == 'all'
+Requires-Dist: setuptools>=80.9.0; extra == 'all'
+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: chunking
+Requires-Dist: semantic-text-splitter>=0.27.0; extra == 'chunking'
+Provides-Extra: cli
+Requires-Dist: click>=8.2.1; extra == 'cli'
+Requires-Dist: rich>=14.0.0; extra == 'cli'
+Requires-Dist: tomli>=2.0.0; (python_version < '3.11') and extra == 'cli'
+Provides-Extra: easyocr
+Requires-Dist: easyocr>=1.7.2; extra == 'easyocr'
+Provides-Extra: entity-extraction
+Requires-Dist: keybert>=0.9.0; extra == 'entity-extraction'
+Requires-Dist: spacy>=3.8.7; extra == 'entity-extraction'
+Provides-Extra: gmft
+Requires-Dist: gmft>=0.4.2; extra == 'gmft'
+Provides-Extra: langdetect
+Requires-Dist: fast-langdetect>=0.3.2; extra == 'langdetect'
+Provides-Extra: paddleocr
+Requires-Dist: paddleocr>=3.1.0; extra == 'paddleocr'
+Requires-Dist: paddlepaddle>=3.1.0; extra == 'paddleocr'
+Requires-Dist: setuptools>=80.9.0; extra == 'paddleocr'
+Description-Content-Type: text/markdown
+
+# Kreuzberg
+
+[![Discord](https://img.shields.io/badge/Discord-Join%20our%20community-7289da)](https://discord.gg/pXxagNK2zN)
+[![PyPI version](https://badge.fury.io/py/kreuzberg.svg)](https://badge.fury.io/py/kreuzberg)
+[![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)
+
+**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.
+
+📖 **[Complete Documentation](https://kreuzberg.dev/)**
+
+## Framework Overview
+
+### Document Intelligence Capabilities
+
+- **Text Extraction**: High-fidelity text extraction preserving document structure and formatting
+- **Metadata Extraction**: Comprehensive metadata including author, creation date, language, and document properties
+- **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
+
+### Technical Architecture
+
+- **Performance**: Highest throughput among Python document processing frameworks (30+ docs/second)
+- **Resource Efficiency**: 71MB installation, ~360MB runtime memory footprint
+- **Extensibility**: Plugin architecture for custom extractors via the Extractor base class
+- **API Design**: Synchronous and asynchronous APIs with consistent interfaces
+- **Type Safety**: Complete type annotations throughout the codebase
+
+### Open Source Foundation
+
+Kreuzberg leverages established open source technologies:
+
+- **Pandoc**: Universal document converter for robust format support
+- **PDFium**: Google's PDF rendering engine for accurate PDF processing
+- **Tesseract**: Google's OCR engine for text recognition
+- **Python-docx/pptx**: Native Microsoft Office format support
+
+## Quick Start
+
+### Extract Text with CLI
+
+```bash
+# Extract text from any file to markdown
+uvx kreuzberg extract document.pdf > output.md
+
+# With all features (OCR, table extraction, etc.)
+uvx --from "kreuzberg[all]" kreuzberg extract invoice.pdf --ocr --format markdown
+
+# Extract with rich metadata
+uvx kreuzberg extract report.pdf --show-metadata --format json
+```
+
+### Python Usage
+
+**Async (recommended for web apps):**
+
+```python
+from kreuzberg import extract_file
+
+# In your async function
+result = await extract_file("presentation.pptx")
+print(result.content)
+
+# Rich metadata extraction
+print(f"Title: {result.metadata.title}")
+print(f"Author: {result.metadata.author}")
+print(f"Page count: {result.metadata.page_count}")
+print(f"Created: {result.metadata.created_at}")
+```
+
+**Sync (for scripts and CLI tools):**
+
+```python
+from kreuzberg import extract_file_sync
+
+result = extract_file_sync("report.docx")
+print(result.content)
+
+# Access rich metadata
+print(f"Language: {result.metadata.language}")
+print(f"Word count: {result.metadata.word_count}")
+print(f"Keywords: {result.metadata.keywords}")
+```
+
+### Docker
+
+```bash
+# Run the REST API
+docker run -p 8000:8000 goldziher/kreuzberg
+
+# Extract via API
+curl -X POST -F "file=@document.pdf" http://localhost:8000/extract
+```
+
+📖 **[Installation Guide](https://kreuzberg.dev/getting-started/installation/)** • **[CLI Documentation](https://kreuzberg.dev/cli/)** • **[API Reference](https://kreuzberg.dev/api-reference/)**
+
+## Deployment Options
+
+### 🤖 MCP Server (AI Integration)
+
+**Add to Claude Desktop with one command:**
+
+```bash
+claude mcp add kreuzberg uvx -- --from "kreuzberg[all]" kreuzberg-mcp
+```
+
+**Or configure manually in `claude_desktop_config.json`:**
+
+```json
+{
+  "mcpServers": {
+    "kreuzberg": {
+      "command": "uvx",
+      "args": ["--from", "kreuzberg[all]", "kreuzberg-mcp"]
+    }
+  }
+}
+```
+
+**MCP capabilities:**
+
+- Extract text from PDFs, images, Office docs, and more
+- Full OCR support with multiple engines
+- Table extraction and metadata parsing
+
+📖 **[MCP Documentation](https://kreuzberg.dev/user-guide/mcp-server/)**
+
+## Supported Formats
+
+| Category          | Formats                        |
+| ----------------- | ------------------------------ |
+| **Documents**     | PDF, DOCX, DOC, RTF, TXT, EPUB |
+| **Images**        | JPG, PNG, TIFF, BMP, GIF, WEBP |
+| **Spreadsheets**  | XLSX, XLS, CSV, ODS            |
+| **Presentations** | PPTX, PPT, ODP                 |
+| **Web**           | HTML, XML, MHTML               |
+| **Archives**      | Support via extraction         |
+
+## 📊 Performance Characteristics
+
+[View comprehensive benchmarks](https://benchmarks.kreuzberg.dev/) • [Benchmark methodology](https://github.com/Goldziher/python-text-extraction-libs-benchmarks) • [**Detailed Analysis**](https://kreuzberg.dev/performance-analysis/)
+
+### Technical Specifications
+
+| Metric                       | Kreuzberg Sync | Kreuzberg Async | Benchmarked        |
+| ---------------------------- | -------------- | --------------- | ------------------ |
+| **Throughput (tiny files)**  | 31.78 files/s  | 23.94 files/s   | Highest throughput |
+| **Throughput (small files)** | 8.91 files/s   | 9.31 files/s    | Highest throughput |
+| **Memory footprint**         | 359.8 MB       | 395.2 MB        | Lowest usage       |
+| **Installation size**        | 71 MB          | 71 MB           | Smallest size      |
+| **Success rate**             | 100%           | 100%            | Perfect            |
+| **Supported formats**        | 18             | 18              | Comprehensive      |
+
+### Architecture Advantages
+
+- **Native C extensions**: Built on PDFium and Tesseract for maximum performance
+- **Async/await support**: True asynchronous processing with intelligent task scheduling
+- **Memory efficiency**: Streaming architecture minimizes memory allocation
+- **Process pooling**: Automatic multiprocessing for CPU-intensive operations
+- **Optimized data flow**: Efficient data handling with minimal transformations
+
+> **Benchmark details**: Tests include PDFs, Word docs, HTML, images, and spreadsheets in multiple languages (English, Hebrew, German, Chinese, Japanese, Korean) on standardized hardware.
+
+## Documentation
+
+### Quick Links
+
+- [Installation Guide](https://kreuzberg.dev/getting-started/installation/) - Setup and dependencies
+- [User Guide](https://kreuzberg.dev/user-guide/) - Comprehensive usage guide
+- [Performance Analysis](https://kreuzberg.dev/performance-analysis/) - Detailed benchmark results
+- [API Reference](https://kreuzberg.dev/api-reference/) - Complete API documentation
+- [Docker Guide](https://kreuzberg.dev/user-guide/docker/) - Container deployment
+- [REST API](https://kreuzberg.dev/user-guide/api-server/) - HTTP endpoints
+- [CLI Guide](https://kreuzberg.dev/cli/) - Command-line usage
+- [OCR Configuration](https://kreuzberg.dev/user-guide/ocr-configuration/) - OCR engine setup
+
+## License
+
+MIT License - see [LICENSE](LICENSE) for details.

kreuzberg-3.8.2.dist-info/RECORD

@@ -0,0 +1,53 @@
+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/_constants.py,sha256=Bxc8oiN-wHwnWXT9bEiJhTUcu1ygPpra5qHirAif3b4,191
+kreuzberg/_entity_extraction.py,sha256=woNxARG27Z3T_l6w6N-dbt1PPe1IHptFMOZY_6etv54,7819
+kreuzberg/_gmft.py,sha256=Q46CyBxRxY_oDGpSuXMOJ7qfR9LwuCKXnrl60wcPvU4,25286
+kreuzberg/_language_detection.py,sha256=eEfj4tsh91SfB2_zQIdY-qD7TlPcppaFm0SqQmETS6Y,3295
+kreuzberg/_mime_types.py,sha256=OhJ6gEyyLHjyvRtkk37zyLFBsRcSd_QybBaV8TxinIg,8471
+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/exceptions.py,sha256=PTiAZgQwcG9hXbgYg2W7sfxksFhq5_wzOFgZGnTJAoc,2991
+kreuzberg/extraction.py,sha256=UmeEVN-eSile4HMxP0iqG9092BrsH5_zSZNVHhwy0ko,16993
+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
+kreuzberg/_extractors/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+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/_pandoc.py,sha256=51k7XISfKaPorhapG7aIeQb94KGsfozxKyT2rwhk9Bk,26553
+kreuzberg/_extractors/_pdf.py,sha256=d-hG_mhAMj22bQ35YuP2nq017z27_2Pp08r1qyHxlYI,16676
+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/_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/_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/_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
+kreuzberg/_utils/_process_pool.py,sha256=4BqhmRspwMyPT2EBfTu_rrn7v722wlMLD8qlYvYsc00,8621
+kreuzberg/_utils/_quality.py,sha256=-nKzj5n7yJDYrvl556oq2T5S5oKMEOrjpcRMlZ00Jqo,7668
+kreuzberg/_utils/_serialization.py,sha256=cqqxqN2cmtndBhIr4v2wqiMwnNadnKhvuN7EUj3i18M,2290
+kreuzberg/_utils/_string.py,sha256=bCzO3UO6nXupxvtMWvHqfp1Vd9CTzEH9jmpJXQ7upAU,6800
+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/_cli_config.py

@@ -1,175 +0,0 @@
-"""Configuration parsing for the CLI."""
-
-from __future__ import annotations
-
-import sys
-from pathlib import Path
-from typing import TYPE_CHECKING, Any
-
-if sys.version_info >= (3, 11):
-    import tomllib
-else:
-    import tomli as tomllib  # type: ignore[import-not-found]
-
-from kreuzberg._gmft import GMFTConfig
-from kreuzberg._ocr._easyocr import EasyOCRConfig
-from kreuzberg._ocr._paddleocr import PaddleOCRConfig
-from kreuzberg._ocr._tesseract import TesseractConfig
-from kreuzberg._types import ExtractionConfig, OcrBackendType
-from kreuzberg.exceptions import ValidationError
-
-if TYPE_CHECKING:
-    from collections.abc import MutableMapping
-
-
-def load_config_from_file(config_path: Path) -> dict[str, Any]:
-    """Load configuration from a TOML file.
-
-    Args:
-        config_path: Path to the configuration file.
-
-    Returns:
-        Dictionary containing the loaded configuration.
-
-    Raises:
-        ValidationError: If the file cannot be read or parsed.
-    """
-    try:
-        with config_path.open("rb") as f:
-            data = tomllib.load(f)
-    except FileNotFoundError as e:
-        raise ValidationError(f"Configuration file not found: {config_path}") from e
-    except tomllib.TOMLDecodeError as e:
-        raise ValidationError(f"Invalid TOML in configuration file: {e}") from e
-
-    return data.get("tool", {}).get("kreuzberg", {})  # type: ignore[no-any-return]
-
-
-def merge_configs(base: dict[str, Any], override: dict[str, Any]) -> dict[str, Any]:
-    """Merge two configuration dictionaries recursively.
-
-    Args:
-        base: Base configuration dictionary.
-        override: Configuration dictionary to override base values.
-
-    Returns:
-        Merged configuration dictionary.
-    """
-    result = base.copy()
-    for key, value in override.items():
-        if isinstance(value, dict) and key in result and isinstance(result[key], dict):
-            result[key] = merge_configs(result[key], value)
-        else:
-            result[key] = value
-    return result
-
-
-def parse_ocr_backend_config(
-    config_dict: dict[str, Any], backend: OcrBackendType
-) -> TesseractConfig | EasyOCRConfig | PaddleOCRConfig | None:
-    """Parse OCR backend-specific configuration.
-
-    Args:
-        config_dict: Configuration dictionary.
-        backend: The OCR backend type.
-
-    Returns:
-        Backend-specific configuration object or None.
-    """
-    if backend not in config_dict:
-        return None
-
-    backend_config = config_dict[backend]
-    if not isinstance(backend_config, dict):
-        return None
-
-    if backend == "tesseract":
-        return TesseractConfig(**backend_config)
-    if backend == "easyocr":
-        return EasyOCRConfig(**backend_config)
-    if backend == "paddleocr":
-        return PaddleOCRConfig(**backend_config)
-    return None
-
-
-def build_extraction_config(  # noqa: C901, PLR0912
-    file_config: dict[str, Any],
-    cli_args: MutableMapping[str, Any],
-) -> ExtractionConfig:
-    """Build ExtractionConfig from file config and CLI arguments.
-
-    Args:
-        file_config: Configuration loaded from file.
-        cli_args: CLI arguments.
-
-    Returns:
-        ExtractionConfig instance.
-    """
-    config_dict: dict[str, Any] = {}
-
-    if file_config:
-        for field in ["force_ocr", "chunk_content", "extract_tables", "max_chars", "max_overlap", "ocr_backend"]:
-            if field in file_config:
-                config_dict[field] = file_config[field]
-
-    for field in ["force_ocr", "chunk_content", "extract_tables", "max_chars", "max_overlap", "ocr_backend"]:
-        cli_key = field
-        if cli_key in cli_args and cli_args[cli_key] is not None:
-            config_dict[field] = cli_args[cli_key]
-
-    ocr_backend = config_dict.get("ocr_backend")
-    if ocr_backend and ocr_backend != "none":
-        ocr_config = None
-
-        if cli_args.get(f"{ocr_backend}_config"):
-            backend_args = cli_args[f"{ocr_backend}_config"]
-            if ocr_backend == "tesseract":
-                ocr_config = TesseractConfig(**backend_args)
-            elif ocr_backend == "easyocr":
-                ocr_config = EasyOCRConfig(**backend_args)  # type: ignore[assignment]
-            elif ocr_backend == "paddleocr":
-                ocr_config = PaddleOCRConfig(**backend_args)  # type: ignore[assignment]
-
-        if not ocr_config and file_config:
-            ocr_config = parse_ocr_backend_config(file_config, ocr_backend)  # type: ignore[assignment]
-
-        if ocr_config:
-            config_dict["ocr_config"] = ocr_config
-
-    if config_dict.get("extract_tables"):
-        gmft_config = None
-
-        if cli_args.get("gmft_config"):
-            gmft_config = GMFTConfig(**cli_args["gmft_config"])
-
-        elif "gmft" in file_config and isinstance(file_config["gmft"], dict):
-            gmft_config = GMFTConfig(**file_config["gmft"])
-
-        if gmft_config:
-            config_dict["gmft_config"] = gmft_config
-
-    if config_dict.get("ocr_backend") == "none":
-        config_dict["ocr_backend"] = None
-
-    return ExtractionConfig(**config_dict)
-
-
-def find_default_config() -> Path | None:
-    """Find the default configuration file (pyproject.toml).
-
-    Returns:
-        Path to the configuration file or None if not found.
-    """
-    current = Path.cwd()
-    while current != current.parent:
-        config_path = current / "pyproject.toml"
-        if config_path.exists():
-            try:
-                with config_path.open("rb") as f:
-                    data = tomllib.load(f)
-                if "tool" in data and "kreuzberg" in data["tool"]:
-                    return config_path
-            except Exception:  # noqa: BLE001
-                pass
-        current = current.parent
-    return None

kreuzberg/_multiprocessing/__init__.py

@@ -1,5 +0,0 @@
-"""Multiprocessing utilities for kreuzberg."""
-
-from .gmft_isolated import extract_tables_isolated, extract_tables_isolated_async
-
-__all__ = ["extract_tables_isolated", "extract_tables_isolated_async"]