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

kreuzberg/_utils/_table.py

@@ -0,0 +1,261 @@
+"""Table processing and export utilities."""
+
+from __future__ import annotations
+
+import csv
+from io import StringIO
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from kreuzberg._types import TableData
+
+
+def export_table_to_csv(table: TableData, separator: str = ",") -> str:
+    r"""Export a TableData object to CSV/TSV format.
+
+    Args:
+        table: TableData object containing DataFrame
+        separator: Field separator ("," for CSV, "\t" for TSV)
+
+    Returns:
+        String representation in CSV/TSV format
+    """
+    if "df" not in table or table["df"] is None:
+        return ""
+
+    output = StringIO()
+    table["df"].to_csv(output, sep=separator, index=False, quoting=csv.QUOTE_MINIMAL)
+    return output.getvalue().strip()
+
+
+def export_table_to_tsv(table: TableData) -> str:
+    """Export a TableData object to TSV format.
+
+    Args:
+        table: TableData object containing DataFrame
+
+    Returns:
+        String representation in TSV format
+    """
+    return export_table_to_csv(table, separator="\t")
+
+
+def enhance_table_markdown(table: TableData) -> str:
+    """Generate enhanced markdown table with better formatting.
+
+    Args:
+        table: TableData object
+
+    Returns:
+        Enhanced markdown table string
+    """
+    if "df" not in table or table["df"] is None:
+        return table.get("text", "")
+
+    df = table["df"]
+
+    if df.empty:
+        return table.get("text", "")
+
+    # Create enhanced markdown with proper alignment
+    lines = []
+
+    # Header row
+    headers = [str(col).strip() for col in df.columns]
+    lines.append("| " + " | ".join(headers) + " |")
+
+    # Separator row with alignment hints
+    lines.append(_generate_separator_row(df))
+
+    # Analyze float columns to determine formatting strategy
+    float_col_formatting = _analyze_float_columns(df)
+
+    # Data rows with proper formatting
+    for _, row in df.iterrows():
+        formatted_row = _format_table_row(row, df, float_col_formatting)
+        lines.append("| " + " | ".join(formatted_row) + " |")
+
+    return "\n".join(lines)
+
+
+def _generate_separator_row(df: Any) -> str:
+    """Generate separator row with proper alignment hints."""
+    separators = []
+    for col in df.columns:
+        # Check if column contains mostly numbers for right alignment
+        if df[col].dtype in ["int64", "float64"] or _is_numeric_column(df[col]):
+            separators.append("---:")  # Right align numbers
+        else:
+            separators.append("---")  # Left align text
+    return "| " + " | ".join(separators) + " |"
+
+
+def _analyze_float_columns(df: Any) -> dict[str, str]:
+    """Analyze float columns to determine formatting strategy."""
+    float_col_formatting = {}
+    for col in df.columns:
+        if str(df[col].dtype) == "float64":
+            non_null_values = df[col].dropna()
+            if len(non_null_values) > 0:
+                # If all non-null values are whole numbers, format as integers
+                all_integers = all(val.is_integer() for val in non_null_values)
+                float_col_formatting[col] = "int" if all_integers else "float"
+            else:
+                float_col_formatting[col] = "int"
+    return float_col_formatting
+
+
+def _format_table_row(row: Any, df: Any, float_col_formatting: dict[str, str]) -> list[str]:
+    """Format a single table row with proper value formatting."""
+    formatted_row = []
+    for col_name, value in row.items():
+        if value is None or (isinstance(value, float) and str(value) == "nan"):
+            formatted_row.append("")
+        elif str(df[col_name].dtype) in ["int64", "int32"]:
+            # For integer columns, format as integers
+            formatted_row.append(str(int(value)))
+        elif isinstance(value, float):
+            # For float columns, use the determined formatting strategy
+            if col_name in float_col_formatting and float_col_formatting[col_name] == "int":
+                formatted_row.append(str(int(value)))
+            else:
+                formatted_row.append(f"{value:.2f}")
+        else:
+            # Clean up text values
+            clean_value = str(value).strip().replace("|", "\\|")  # Escape pipes
+            formatted_row.append(clean_value)
+    return formatted_row
+
+
+def _is_numeric_column(series: Any) -> bool:
+    """Check if a pandas Series contains mostly numeric values."""
+    if len(series) == 0:
+        return False
+
+    try:
+        # Check if already numeric dtype first (fastest path)
+        if str(series.dtype) in {"int64", "float64", "int32", "float32"}:
+            return True
+
+        # Sample-based approach for large series (>1000 rows)
+        sample_size = min(100, len(series))
+        if len(series) > 1000:
+            sample_series = series.dropna().sample(n=sample_size, random_state=42)
+        else:
+            sample_series = series.dropna()
+
+        if len(sample_series) == 0:
+            return False
+
+        # Optimized numeric conversion - avoid exception overhead
+        numeric_count = 0
+        for val in sample_series:
+            val_str = str(val).replace(",", "").replace("$", "").replace("%", "")
+            # Quick check: if it contains only digits, decimal point, minus, plus, or e
+            if val_str and all(c in "0123456789.-+eE" for c in val_str):
+                try:
+                    float(val_str)
+                    numeric_count += 1
+                except (ValueError, TypeError):
+                    pass
+
+        # Consider numeric if >70% of sampled values are numeric
+        return (numeric_count / len(sample_series)) > 0.7
+
+    except (ValueError, TypeError, ZeroDivisionError):
+        return False
+
+
+def generate_table_summary(tables: list[TableData]) -> dict[str, Any]:
+    """Generate summary statistics for extracted tables.
+
+    Args:
+        tables: List of TableData objects
+
+    Returns:
+        Dictionary with table statistics
+    """
+    if not tables:
+        return {
+            "table_count": 0,
+            "total_rows": 0,
+            "total_columns": 0,
+            "pages_with_tables": 0,
+        }
+
+    total_rows = 0
+    total_columns = 0
+    pages_with_tables = set()
+    tables_by_page = {}
+
+    for table in tables:
+        if "df" in table and table["df"] is not None:
+            df = table["df"]
+            total_rows += len(df)
+            total_columns += len(df.columns)
+
+        if "page_number" in table:
+            page_num = table["page_number"]
+            pages_with_tables.add(page_num)
+
+            if page_num not in tables_by_page:
+                tables_by_page[page_num] = 0
+            tables_by_page[page_num] += 1
+
+    return {
+        "table_count": len(tables),
+        "total_rows": total_rows,
+        "total_columns": total_columns,
+        "pages_with_tables": len(pages_with_tables),
+        "avg_rows_per_table": total_rows / len(tables) if tables else 0,
+        "avg_columns_per_table": total_columns / len(tables) if tables else 0,
+        "tables_by_page": dict(tables_by_page),
+    }
+
+
+def extract_table_structure_info(table: TableData) -> dict[str, Any]:
+    """Extract structural information from a table.
+
+    Args:
+        table: TableData object
+
+    Returns:
+        Dictionary with structural information
+    """
+    info = {
+        "has_headers": False,
+        "row_count": 0,
+        "column_count": 0,
+        "numeric_columns": 0,
+        "text_columns": 0,
+        "empty_cells": 0,
+        "data_density": 0.0,
+    }
+
+    if "df" not in table or table["df"] is None:
+        return info
+
+    df = table["df"]
+
+    if df.empty:
+        return info
+
+    info["row_count"] = len(df)
+    info["column_count"] = len(df.columns)
+    info["has_headers"] = len(df.columns) > 0
+
+    # Analyze column types
+    for col in df.columns:
+        if _is_numeric_column(df[col]):
+            info["numeric_columns"] += 1
+        else:
+            info["text_columns"] += 1
+
+    # Calculate data density
+    total_cells = len(df) * len(df.columns)
+    if total_cells > 0:
+        empty_cells = df.isnull().sum().sum()
+        info["empty_cells"] = int(empty_cells)
+        info["data_density"] = (total_cells - empty_cells) / total_cells
+
+    return info

kreuzberg/cli.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 import json
 import sys
+import traceback
 from pathlib import Path
 from typing import TYPE_CHECKING, Any
 
@@ -211,8 +212,6 @@ def handle_error(error: Exception, verbose: bool) -> None:
     else:
         console.print(f"[red]Unexpected error:[/red] {type(error).__name__}: {error}", style="bold")
         if verbose:
-            import traceback
-
             console.print("\n[dim]Traceback:[/dim]")
             traceback.print_exc()
         sys.exit(1)

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",

{kreuzberg-3.7.0.dist-info → kreuzberg-3.8.1.dist-info}/METADATA

@@ -1,14 +1,16 @@
 Metadata-Version: 2.4
 Name: kreuzberg
-Version: 3.7.0
-Summary: A text extraction library supporting PDFs, images, office documents and more
+Version: 3.8.1
+Summary: Advanced document intelligence framework for extracting structured content from PDFs, images, and office documents
 Project-URL: homepage, https://github.com/Goldziher/kreuzberg
 Author-email: Na'aman Hirschfeld <nhirschfed@gmail.com>
 License: MIT
 License-File: LICENSE
-Keywords: document-processing,entity-extraction,image-to-text,keyword-extraction,named-entity-recognition,ner,ocr,pandoc,pdf-extraction,rag,spacy,table-extraction,tesseract,text-extraction,text-processing
+Keywords: automation,content-extraction,data-processing,document-analysis,document-intelligence,document-processing,entity-extraction,image-to-text,information-extraction,ocr,pdf-extraction,rag,structured-data,table-extraction,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
@@ -16,16 +18,19 @@ 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: Topic :: Utilities
 Classifier: Typing :: Typed
 Requires-Python: >=3.10
 Requires-Dist: anyio>=4.9.0
-Requires-Dist: charset-normalizer>=3.4.2
+Requires-Dist: chardetng-py>=0.3.4
 Requires-Dist: exceptiongroup>=1.2.2; python_version < '3.11'
-Requires-Dist: html-to-markdown[lxml]>=1.6.0
+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
@@ -34,6 +39,9 @@ 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'
@@ -41,6 +49,7 @@ 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'
@@ -77,22 +86,33 @@ Description-Content-Type: text/markdown
 [![PyPI version](https://badge.fury.io/py/kreuzberg.svg)](https://badge.fury.io/py/kreuzberg)
 [![Documentation](https://img.shields.io/badge/docs-GitHub_Pages-blue)](https://goldziher.github.io/kreuzberg/)
 [![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)
 
-**High-performance Python library for text extraction from documents.** Extract text from PDFs, images, office documents, and more with both async and sync APIs.
+**Advanced Document Intelligence for Modern Python Applications.** Transform PDFs, images, and office documents into structured data with production-grade performance. Built by engineers who understand that speed, reliability, and developer experience matter.
 
 📖 **[Complete Documentation](https://goldziher.github.io/kreuzberg/)**
 
-## Why Kreuzberg?
+## Why Choose Kreuzberg?
 
-- **🚀 Fastest Performance**: [35+ files/second](https://goldziher.github.io/python-text-extraction-libs-benchmarks/) - the fastest text extraction library
-- **💾 Memory Efficient**: 14x smaller than alternatives (71MB vs 1GB+) with lowest memory usage (~530MB)
-- **⚡ Dual APIs**: Only library with both sync and async support
-- **🔧 Zero Configuration**: Works out of the box with sane defaults
-- **🏠 Local Processing**: No cloud dependencies or external API calls
-- **📦 Rich Format Support**: PDFs, images, Office docs, HTML, and more
-- **🔍 Multiple OCR Engines**: Tesseract, EasyOCR, and PaddleOCR support
-- **🤖 AI Integration**: Native MCP server for Claude and other AI tools
-- **🐳 Production Ready**: CLI, REST API, MCP server, and Docker images included
+### ⚡ Proven Performance
+
+[Benchmarked](https://goldziher.github.io/python-text-extraction-libs-benchmarks/) 6-126x faster than alternatives while using minimal resources. Process up to 14 files per second with 87MB install size and ~360MB memory usage. Optimized for production workloads and resource-constrained environments.
+
+### 🏗️ Production Engineering
+
+Comprehensive test coverage (95%+), robust error handling, and true async/await support. Built with modern Python practices for reliability in production environments.
+
+### 🔧 Developer Experience
+
+Works immediately with smart defaults, scales as you grow. Native MCP integration for AI tools, full type safety, and clear documentation.
+
+### 🚀 Flexible Deployment
+
+Deploy on serverless platforms, containers, or traditional servers. Supports both CPU and GPU processing (via PaddleOCR and EasyOCR). No external API dependencies. Multiple deployment modes: CLI, REST API, MCP server.
+
+### 📄 Comprehensive Format Support
+
+Extract from PDFs, images, Office documents, HTML, spreadsheets, and presentations. Multiple OCR engines with intelligent fallbacks, table extraction, and content preparation for RAG workflows.
 
 ## Quick Start
 
@@ -128,7 +148,7 @@ import asyncio
 from kreuzberg import extract_file
 
 async def main():
-    # Extract from any document type
+    # Extract content from files
     result = await extract_file("document.pdf")
     print(result.content)
     print(result.metadata)
@@ -197,7 +217,7 @@ docker run -p 8000:8000 goldziher/kreuzberg:latest
 curl -X POST http://localhost:8000/extract -F "data=@document.pdf"
 ```
 
-Available variants: `latest`, `3.6.1`, `3.6.1-easyocr`, `3.6.1-paddle`, `3.6.1-gmft`, `3.6.1-all`
+Available variants: `latest`, `v3.8.0`, `v3.8.0-easyocr`, `v3.8.0-paddle`, `v3.8.0-gmft`, `v3.8.0-all`
 
 ### 🌐 REST API
 
@@ -240,23 +260,28 @@ kreuzberg extract *.pdf --output-dir ./extracted/
 | **Web**           | HTML, XML, MHTML               |
 | **Archives**      | Support via extraction         |
 
-## Performance
+## 📊 Performance Comparison
 
-**[Comprehensive benchmarks](https://goldziher.github.io/python-text-extraction-libs-benchmarks/)** across 94 real-world documents (~210MB) • [View source](https://github.com/Goldziher/python-text-extraction-libs-benchmarks):
+[Comprehensive benchmarks](https://goldziher.github.io/python-text-extraction-libs-benchmarks/) across ~100 real-world documents • [View source](https://github.com/Goldziher/python-text-extraction-libs-benchmarks) • [**Detailed Analysis**](https://goldziher.github.io/kreuzberg/performance-analysis/):
 
-| Library       | Speed           | Memory    | Install Size | Dependencies | Success Rate |
-| ------------- | --------------- | --------- | ------------ | ------------ | ------------ |
-| **Kreuzberg** | **35+ files/s** | **530MB** | **71MB**     | **20**       | High\*       |
-| Unstructured  | Moderate        | ~1GB      | 146MB        | 54           | 88%+         |
-| MarkItDown    | Good†           | ~1.5GB    | 251MB        | 25           | 80%†         |
-| Docling       | 60+ min/file‡   | ~5GB      | 1,032MB      | 88           | Low‡         |
+| Framework     | Speed        | Memory | Install Size | Dependencies | Success Rate |
+| ------------- | ------------ | ------ | ------------ | ------------ | ------------ |
+| **Kreuzberg** | 14.4 files/s | 360MB  | 87MB         | 43           | 100%         |
+| Unstructured  | ~12 files/s  | ~1GB   | 146MB        | 54           | 88%+         |
+| MarkItDown    | ~15 files/s  | ~1.5GB | 251MB        | 25           | 80%\*        |
+| Docling       | ~1 file/min  | ~5GB   | 1,032MB      | 88           | 45%\*        |
 
-\*_Can achieve 75% reliability with 15% performance trade-off when configured_
-†_Good on simple documents, struggles with large/complex files (>10MB)_
-‡_Frequently fails/times out on medium files (>1MB)_
+\*_Performance varies significantly with document complexity and size_
 
-> **Benchmark details**: Tested across PDFs, Word docs, HTML, images, spreadsheets in 6 languages (English, Hebrew, German, Chinese, Japanese, Korean)
-> **Rule of thumb**: Use async API for complex documents and batch processing (up to 4.5x faster)
+**Key strengths:**
+
+- 6-126x faster processing than comparable frameworks
+- Smallest installation footprint and memory usage
+- Only framework with built-in async/await support
+- Supports both CPU and GPU processing
+- Built by software engineers for production reliability
+
+> **Benchmark details**: Tests include PDFs, Word docs, HTML, images, and spreadsheets in multiple languages (English, Hebrew, German, Chinese, Japanese, Korean) on standardized hardware.
 
 ## Documentation
 
@@ -264,34 +289,13 @@ kreuzberg extract *.pdf --output-dir ./extracted/
 
 - [Installation Guide](https://goldziher.github.io/kreuzberg/getting-started/installation/) - Setup and dependencies
 - [User Guide](https://goldziher.github.io/kreuzberg/user-guide/) - Comprehensive usage guide
+- [Performance Analysis](https://goldziher.github.io/kreuzberg/performance-analysis/) - Detailed benchmark results
 - [API Reference](https://goldziher.github.io/kreuzberg/api-reference/) - Complete API documentation
 - [Docker Guide](https://goldziher.github.io/kreuzberg/user-guide/docker/) - Container deployment
 - [REST API](https://goldziher.github.io/kreuzberg/user-guide/api-server/) - HTTP endpoints
 - [CLI Guide](https://goldziher.github.io/kreuzberg/cli/) - Command-line usage
 - [OCR Configuration](https://goldziher.github.io/kreuzberg/user-guide/ocr-configuration/) - OCR engine setup
 
-## Advanced Features
-
-- **🤖 MCP Server**: Native integration with Claude Desktop and AI tools
-- **📊 Table Extraction**: Extract tables from PDFs with GMFT
-- **🧩 Content Chunking**: Split documents for RAG applications
-- **🎯 Custom Extractors**: Extend with your own document handlers
-- **🔧 Configuration**: Flexible TOML-based configuration
-- **🪝 Hooks**: Pre/post-processing customization
-- **🌍 Multi-language OCR**: 100+ languages supported
-- **⚙️ Metadata Extraction**: Rich document metadata
-- **🔄 Batch Processing**: Efficient bulk document processing
-
 ## License
 
 MIT License - see [LICENSE](LICENSE) for details.
-
-______________________________________________________________________
-
-<div align="center">
-
-**[Documentation](https://goldziher.github.io/kreuzberg/) • [PyPI](https://pypi.org/project/kreuzberg/) • [Docker Hub](https://hub.docker.com/r/goldziher/kreuzberg) • [Benchmarks](https://github.com/Goldziher/python-text-extraction-libs-benchmarks) • [Discord](https://discord.gg/pXxagNK2zN)**
-
-Made with ❤️ by the [Kreuzberg contributors](https://github.com/Goldziher/kreuzberg/graphs/contributors)
-
-</div>

kreuzberg-3.8.1.dist-info/RECORD

@@ -0,0 +1,53 @@
+kreuzberg/__init__.py,sha256=wVxbug-w1cO2xHcP04Bf6QeIKmT2Ep6aeenb8EOYLA0,1534
+kreuzberg/__main__.py,sha256=s2qM1nPEkRHAQP-G3P7sf5l6qA_KJeIEHS5LpPz04lg,183
+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=nqpQPmR2Rf1vOwoQsjm22nPLDIcsXdYfMwCL3h8iUTQ,7802
+kreuzberg/_gmft.py,sha256=Heovj2n2kgi7eHtvvRzpBgSLGyXjz8M9PAQMX-npd40,25295
+kreuzberg/_language_detection.py,sha256=22-uXoOu_ws0K8Hz2M7U_SF9QX3npRYLhntAE1dNLFU,3283
+kreuzberg/_mime_types.py,sha256=OhJ6gEyyLHjyvRtkk37zyLFBsRcSd_QybBaV8TxinIg,8471
+kreuzberg/_playa.py,sha256=rU6ii2Qnrj8tkDYlSiab5h-BCYLJnUg4QwSLVDEXF5g,11883
+kreuzberg/_registry.py,sha256=wGSlkS0U1zqruWQCLE95vj4a2mw1yyvf0j6rgz80sJg,3473
+kreuzberg/_types.py,sha256=R_0Xc2kq4nEwkruvkB3qfrLeJ996419hBQ_1C6Xrqjo,13388
+kreuzberg/cli.py,sha256=H9xxh4-zhGLfbhya2iD-NcEs-BvajVttm6cSiNx3ANU,12452
+kreuzberg/exceptions.py,sha256=xRaiJh11i8E6Nc-gAQPgNW5xvhiiFBhRS-CBbCEbHQM,2881
+kreuzberg/extraction.py,sha256=hY5d4oelwocX6eOBF0Bu3nHCcCbTL5JOIbaPCCFNKsU,16972
+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=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=Deb1ZIcqDY18CHa7cJL4vO4S7gy09yXWNSuH7O7kSzY,16430
+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/_ocr/__init__.py,sha256=grshVFwVQl2rMvH1hg1JNlYXjy5-Tdb_rusLD1Cselk,706
+kreuzberg/_ocr/_base.py,sha256=CUzYMsJjCqCmHzWckmDeIB2L5hd261xrPrK8Ql-Gdm0,3876
+kreuzberg/_ocr/_easyocr.py,sha256=sWyVnF7My4F1GU-IPSVtpaDJPYogw8N-NYxwuy-6loc,17098
+kreuzberg/_ocr/_paddleocr.py,sha256=nXfQq6t2a7O-IpbCZRv8BvzP_lEBLgyYwXI5-wjzec0,17480
+kreuzberg/_ocr/_tesseract.py,sha256=RjJ_C8c74LmLN53sdDo8WPCpUYeJ6fmRwsQdp6dJYio,31490
+kreuzberg/_utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+kreuzberg/_utils/_cache.py,sha256=6T2K9BXWaPkEKphSFrfXtFFE7ck5q9CYV9NmAFS56e4,15204
+kreuzberg/_utils/_device.py,sha256=rnaSSB5ibf2wr7EDxrcmOUZ4Ocor0pHkwb3N1pC46EY,10276
+kreuzberg/_utils/_document_cache.py,sha256=z8irioKsOu8xve1YgHatm__wIFvs9I1gDK3tLNsNyqM,6926
+kreuzberg/_utils/_errors.py,sha256=4OseKJI5qscD9jHxpP8CtpPWNHAOdhrJwcg6dlQl2fk,6310
+kreuzberg/_utils/_pdf_lock.py,sha256=nqxAYCNlfWDrJtP4ZNu57st1YnkDl-gYXdr0q8nv0kA,1961
+kreuzberg/_utils/_process_pool.py,sha256=4BqhmRspwMyPT2EBfTu_rrn7v722wlMLD8qlYvYsc00,8621
+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.8.1.dist-info/METADATA,sha256=IqJ6RTcFlwkMN6JZIkb9c8O4rgTrPqIuzXWerD6He1I,11507
+kreuzberg-3.8.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+kreuzberg-3.8.1.dist-info/entry_points.txt,sha256=GplGhFryCP7kyAG_k-Mdahznvo2fwi73qLFg5yQfH_A,91
+kreuzberg-3.8.1.dist-info/licenses/LICENSE,sha256=-8caMvpCK8SgZ5LlRKhGCMtYDEXqTKH9X8pFEhl91_4,1066
+kreuzberg-3.8.1.dist-info/RECORD,,

kreuzberg/_multiprocessing/__init__.py

@@ -1,6 +0,0 @@
-"""Multiprocessing utilities for kreuzberg."""
-
-from .process_manager import ProcessPoolManager
-from .tesseract_pool import TesseractProcessPool
-
-__all__ = ["ProcessPoolManager", "TesseractProcessPool"]