kreuzberg 2.1.2__py3-none-any.whl → 3.0.0__py3-none-any.whl

kreuzberg/extraction.py

@@ -1,198 +1,140 @@
-"""This module provides functions to extract textual content from files.
-
-It includes vendored code:
-
-- The extract PPTX logic is based on code vendored from `markitdown` to extract text from PPTX files.
-    See: https://github.com/microsoft/markitdown/blob/main/src/markitdown/_markitdown.py
-    Refer to the markitdown repository for it's license (MIT).
-"""
-
 from __future__ import annotations
 
-from functools import partial
-from io import BytesIO
 from pathlib import Path
-from typing import TYPE_CHECKING, cast
+from typing import TYPE_CHECKING, Final, cast
 
 import anyio
-from anyio import Path as AsyncPath
-from PIL.Image import open as open_image
 
 from kreuzberg import ExtractionResult
-from kreuzberg._constants import DEFAULT_MAX_PROCESSES
-from kreuzberg._html import extract_html_string
+from kreuzberg._chunker import get_chunker
 from kreuzberg._mime_types import (
-    EXCEL_MIME_TYPE,
-    HTML_MIME_TYPE,
-    IMAGE_MIME_TYPES,
-    PANDOC_SUPPORTED_MIME_TYPES,
-    PDF_MIME_TYPE,
-    POWER_POINT_MIME_TYPE,
-    SUPPORTED_MIME_TYPES,
     validate_mime_type,
 )
-from kreuzberg._pandoc import process_content_with_pandoc, process_file_with_pandoc
-from kreuzberg._pdf import (
-    extract_pdf_content,
-    extract_pdf_file,
-)
-from kreuzberg._pptx import extract_pptx_file_content
-from kreuzberg._string import safe_decode
-from kreuzberg._tesseract import PSMMode, process_image_with_tesseract
-from kreuzberg._xlsx import extract_xlsx_content, extract_xlsx_file
-from kreuzberg.exceptions import ValidationError
+from kreuzberg._registry import ExtractorRegistry
+from kreuzberg._types import ExtractionConfig
+from kreuzberg._utils._string import safe_decode
+from kreuzberg._utils._sync import run_maybe_async, run_maybe_sync
 
 if TYPE_CHECKING:
     from collections.abc import Sequence
     from os import PathLike
 
 
-async def extract_bytes(
-    content: bytes,
-    mime_type: str,
-    *,
-    force_ocr: bool = False,
-    language: str = "eng",
-    max_processes: int = DEFAULT_MAX_PROCESSES,
-    psm: PSMMode = PSMMode.AUTO,
-) -> ExtractionResult:
-    """Extract the textual content from a given byte string representing a file's contents.
+DEFAULT_CONFIG: Final[ExtractionConfig] = ExtractionConfig()
 
-    Args:
-        content: The content to extract.
-        mime_type: The mime type of the content.
-        force_ocr: Whether to force OCR on PDF files that have a text layer.
-        language: The language code for OCR. Defaults to "eng".
-        max_processes: Maximum number of concurrent processes. Defaults to CPU count / 2 (minimum 1).
-        psm: Page segmentation mode for Tesseract OCR. Defaults to PSMMode.AUTO.
 
-    Raises:
-        ValidationError: If the mime type is not supported.
+async def _validate_and_post_process_async(result: ExtractionResult, config: ExtractionConfig) -> ExtractionResult:
+    for validator in config.validators or []:
+        await run_maybe_sync(validator, result)
 
-    Returns:
-        The extracted content and the mime type of the content.
-    """
-    if mime_type not in SUPPORTED_MIME_TYPES or not any(mime_type.startswith(value) for value in SUPPORTED_MIME_TYPES):
-        raise ValidationError(
-            f"Unsupported mime type: {mime_type}",
-            context={"mime_type": mime_type, "supported_mimetypes": ",".join(sorted(SUPPORTED_MIME_TYPES))},
+    if config.chunk_content:
+        result.chunks = _handle_chunk_content(
+            mime_type=result.mime_type,
+            config=config,
+            content=result.content,
         )
 
-    if mime_type == PDF_MIME_TYPE or mime_type.startswith(PDF_MIME_TYPE):
-        return await extract_pdf_content(
-            content, force_ocr=force_ocr, max_processes=max_processes, psm=psm, language=language
-        )
+    for post_processor in config.post_processing_hooks or []:
+        result = await run_maybe_sync(post_processor, result)
 
-    if mime_type == EXCEL_MIME_TYPE or mime_type.startswith(EXCEL_MIME_TYPE):
-        return await extract_xlsx_content(content)
+    return result
 
-    if mime_type in IMAGE_MIME_TYPES or any(mime_type.startswith(value) for value in IMAGE_MIME_TYPES):
-        return await process_image_with_tesseract(open_image(BytesIO(content)), psm=psm, language=language)
 
-    if mime_type in PANDOC_SUPPORTED_MIME_TYPES or any(
-        mime_type.startswith(value) for value in PANDOC_SUPPORTED_MIME_TYPES
-    ):
-        return await process_content_with_pandoc(content=content, mime_type=mime_type)
+def _validate_and_post_process_sync(result: ExtractionResult, config: ExtractionConfig) -> ExtractionResult:
+    for validator in config.validators or []:
+        run_maybe_async(validator, result)
 
-    if mime_type == POWER_POINT_MIME_TYPE or mime_type.startswith(POWER_POINT_MIME_TYPE):
-        return await extract_pptx_file_content(content)
+    if config.chunk_content:
+        result.chunks = _handle_chunk_content(
+            mime_type=result.mime_type,
+            config=config,
+            content=result.content,
+        )
 
-    if mime_type == HTML_MIME_TYPE or mime_type.startswith(HTML_MIME_TYPE):
-        return await extract_html_string(content)
+    for post_processor in config.post_processing_hooks or []:
+        result = run_maybe_async(post_processor, result)
 
-    return ExtractionResult(
-        content=safe_decode(content),
-        mime_type=mime_type,
-        metadata={},
-    )
+    return result
 
 
-async def extract_file(
-    file_path: PathLike[str] | str,
-    mime_type: str | None = None,
-    *,
-    force_ocr: bool = False,
-    language: str = "eng",
-    max_processes: int = DEFAULT_MAX_PROCESSES,
-    psm: PSMMode = PSMMode.AUTO,
-) -> ExtractionResult:
-    """Extract the textual content from a given file.
+def _handle_chunk_content(
+    mime_type: str,
+    config: ExtractionConfig,
+    content: str,
+) -> list[str]:
+    chunker = get_chunker(mime_type=mime_type, max_characters=config.max_chars, overlap_characters=config.max_overlap)
+    return chunker.chunks(content)
+
+
+async def extract_bytes(content: bytes, mime_type: str, config: ExtractionConfig = DEFAULT_CONFIG) -> ExtractionResult:
+    """Extract the textual content from a given byte string representing a file's contents.
 
     Args:
-        file_path: The path to the file.
+        content: The content to extract.
         mime_type: The mime type of the content.
-        force_ocr: Whether to force OCR on PDF files that have a text layer.
-        language: The language code for OCR. Defaults to "eng".
-        max_processes: Maximum number of concurrent processes. Defaults to CPU count / 2 (minimum 1).
-        psm: Page segmentation mode for Tesseract OCR. Defaults to PSMMode.AUTO.
+        config: Extraction options object, defaults to the default object.
 
-    Raises:
-        ValidationError: If the mime type is not supported.
 
     Returns:
         The extracted content and the mime type of the content.
     """
-    input_file = await AsyncPath(file_path).resolve()
-
-    mime_type = validate_mime_type(input_file, mime_type)
-
-    if not await input_file.exists():
-        raise ValidationError("The file does not exist.", context={"input_file": str(input_file)})
-
-    if mime_type == PDF_MIME_TYPE or mime_type.startswith(PDF_MIME_TYPE):
-        return await extract_pdf_file(
-            Path(input_file), force_ocr=force_ocr, max_processes=max_processes, psm=psm, language=language
+    mime_type = validate_mime_type(mime_type=mime_type)
+    if extractor := ExtractorRegistry.get_extractor(mime_type=mime_type, config=config):
+        result = await extractor.extract_bytes_async(content)
+    else:
+        result = ExtractionResult(
+            content=safe_decode(content),
+            chunks=[],
+            mime_type=mime_type,
+            metadata={},
         )
 
-    if mime_type == EXCEL_MIME_TYPE or mime_type.startswith(EXCEL_MIME_TYPE):
-        return await extract_xlsx_file(Path(input_file))
+    return await _validate_and_post_process_async(result=result, config=config)
 
-    if mime_type in IMAGE_MIME_TYPES or any(mime_type.startswith(value) for value in IMAGE_MIME_TYPES):
-        return await process_image_with_tesseract(input_file, psm=psm, language=language)
 
-    if mime_type in PANDOC_SUPPORTED_MIME_TYPES or any(
-        mime_type.startswith(value) for value in PANDOC_SUPPORTED_MIME_TYPES
-    ):
-        return await process_file_with_pandoc(input_file=input_file, mime_type=mime_type)
+async def extract_file(
+    file_path: PathLike[str] | str, mime_type: str | None = None, config: ExtractionConfig = DEFAULT_CONFIG
+) -> ExtractionResult:
+    """Extract the textual content from a given file.
 
-    if mime_type == POWER_POINT_MIME_TYPE or mime_type.startswith(POWER_POINT_MIME_TYPE):
-        return await extract_pptx_file_content(Path(input_file))
+    Args:
+        file_path: The path to the file.
+        mime_type: The mime type of the content.
+        config: Extraction options object, defaults to the default object.
 
-    if mime_type == HTML_MIME_TYPE or mime_type.startswith(HTML_MIME_TYPE):
-        return await extract_html_string(Path(input_file))
+    Returns:
+        The extracted content and the mime type of the content.
+    """
+    mime_type = validate_mime_type(file_path=file_path, mime_type=mime_type)
+    if extractor := ExtractorRegistry.get_extractor(mime_type=mime_type, config=config):
+        result = await extractor.extract_path_async(Path(file_path))
+    else:
+        result = ExtractionResult(
+            content=safe_decode(await anyio.Path(file_path).read_bytes()), chunks=[], mime_type=mime_type, metadata={}
+        )
 
-    return ExtractionResult(content=safe_decode(await input_file.read_bytes()), mime_type=mime_type, metadata={})
+    return await _validate_and_post_process_async(result=result, config=config)
 
 
 async def batch_extract_file(
-    file_paths: Sequence[PathLike[str] | str],
-    *,
-    force_ocr: bool = False,
-    language: str = "eng",
-    max_processes: int = DEFAULT_MAX_PROCESSES,
-    psm: PSMMode = PSMMode.AUTO,
+    file_paths: Sequence[PathLike[str] | str], config: ExtractionConfig = DEFAULT_CONFIG
 ) -> list[ExtractionResult]:
     """Extract text from multiple files concurrently.
 
     Args:
         file_paths: A sequence of paths to files to extract text from.
-        force_ocr: Whether to force OCR on PDF files that have a text layer.
-        language: The language code for OCR. Defaults to "eng".
-        max_processes: Maximum number of concurrent processes. Defaults to CPU count / 2 (minimum 1).
-        psm: Page segmentation mode for Tesseract OCR. Defaults to PSMMode.AUTO.
+        config: Extraction options object, defaults to the default object.
 
     Returns:
         A list of extraction results in the same order as the input paths.
     """
-    results = cast(list[ExtractionResult], ([None] * len(file_paths)))
+    results = cast("list[ExtractionResult]", ([None] * len(file_paths)))
 
     async def _extract_file(path: PathLike[str] | str, index: int) -> None:
         result = await extract_file(
             path,
-            force_ocr=force_ocr,
-            max_processes=max_processes,
-            psm=psm,
-            language=language,
+            None,
+            config,
         )
         results[index] = result
 
@@ -204,36 +146,21 @@ async def batch_extract_file(
 
 
 async def batch_extract_bytes(
-    contents: Sequence[tuple[bytes, str]],
-    *,
-    force_ocr: bool = False,
-    language: str = "eng",
-    max_processes: int = DEFAULT_MAX_PROCESSES,
-    psm: PSMMode = PSMMode.AUTO,
+    contents: Sequence[tuple[bytes, str]], config: ExtractionConfig = DEFAULT_CONFIG
 ) -> list[ExtractionResult]:
     """Extract text from multiple byte contents concurrently.
 
     Args:
         contents: A sequence of tuples containing (content, mime_type) pairs.
-        force_ocr: Whether to force OCR on PDF files that have a text layer.
-        language: The language code for OCR. Defaults to "eng".
-        max_processes: Maximum number of concurrent processes. Defaults to CPU count / 2 (minimum 1).
-        psm: Page segmentation mode for Tesseract OCR. Defaults to PSMMode.AUTO.
+        config: Extraction options object, defaults to the default object.
 
     Returns:
         A list of extraction results in the same order as the input contents.
     """
-    results = cast(list[ExtractionResult], [None] * len(contents))
+    results = cast("list[ExtractionResult]", [None] * len(contents))
 
     async def _extract_bytes(content: bytes, mime_type: str, index: int) -> None:
-        result = await extract_bytes(
-            content,
-            mime_type,
-            force_ocr=force_ocr,
-            max_processes=max_processes,
-            psm=psm,
-            language=language,
-        )
+        result = await extract_bytes(content, mime_type, config)
         results[index] = result
 
     async with anyio.create_task_group() as tg:
@@ -243,122 +170,82 @@ async def batch_extract_bytes(
     return results
 
 
-### Sync proxies
-
-
-def extract_bytes_sync(
-    content: bytes,
-    mime_type: str,
-    *,
-    force_ocr: bool = False,
-    language: str = "eng",
-    max_processes: int = DEFAULT_MAX_PROCESSES,
-    psm: PSMMode = PSMMode.AUTO,
-) -> ExtractionResult:
+def extract_bytes_sync(content: bytes, mime_type: str, config: ExtractionConfig = DEFAULT_CONFIG) -> ExtractionResult:
     """Synchronous version of extract_bytes.
 
     Args:
         content: The content to extract.
         mime_type: The mime type of the content.
-        force_ocr: Whether to force OCR on PDF files that have a text layer.
-        language: The language code for OCR. Defaults to "eng".
-        max_processes: Maximum number of concurrent processes. Defaults to CPU count / 2 (minimum 1).
-        psm: Page segmentation mode for Tesseract OCR. Defaults to PSMMode.AUTO.
+        config: Extraction options object, defaults to the default object.
 
     Returns:
         The extracted content and the mime type of the content.
     """
-    handler = partial(
-        extract_bytes, content, mime_type, max_processes=max_processes, force_ocr=force_ocr, language=language, psm=psm
-    )
-    return anyio.run(handler)
+    mime_type = validate_mime_type(mime_type=mime_type)
+    if extractor := ExtractorRegistry.get_extractor(mime_type=mime_type, config=config):
+        result = extractor.extract_bytes_sync(content)
+    else:
+        result = ExtractionResult(
+            content=safe_decode(content),
+            chunks=[],
+            mime_type=mime_type,
+            metadata={},
+        )
+
+    return _validate_and_post_process_sync(result=result, config=config)
 
 
 def extract_file_sync(
-    file_path: Path | str,
-    mime_type: str | None = None,
-    *,
-    force_ocr: bool = False,
-    language: str = "eng",
-    max_processes: int = DEFAULT_MAX_PROCESSES,
-    psm: PSMMode = PSMMode.AUTO,
+    file_path: Path | str, mime_type: str | None = None, config: ExtractionConfig = DEFAULT_CONFIG
 ) -> ExtractionResult:
     """Synchronous version of extract_file.
 
     Args:
         file_path: The path to the file.
         mime_type: The mime type of the content.
-        force_ocr: Whether to force OCR on PDF files that have a text layer.
-        language: The language code for OCR. Defaults to "eng".
-        max_processes: Maximum number of concurrent processes. Defaults to CPU count / 2 (minimum 1).
-        psm: Page segmentation mode for Tesseract OCR. Defaults to PSMMode.AUTO.
+        config: Extraction options object, defaults to the default object.
 
     Returns:
         The extracted content and the mime type of the content.
     """
-    handler = partial(
-        extract_file, file_path, mime_type, max_processes=max_processes, force_ocr=force_ocr, language=language, psm=psm
-    )
-    return anyio.run(handler)
+    mime_type = validate_mime_type(file_path=file_path, mime_type=mime_type)
+    if extractor := ExtractorRegistry.get_extractor(mime_type=mime_type, config=config):
+        result = extractor.extract_path_sync(Path(file_path))
+    else:
+        result = ExtractionResult(
+            content=Path(file_path).read_text(),
+            chunks=[],
+            mime_type=mime_type,
+            metadata={},
+        )
+    return _validate_and_post_process_sync(result=result, config=config)
 
 
 def batch_extract_file_sync(
-    file_paths: Sequence[PathLike[str] | str],
-    *,
-    force_ocr: bool = False,
-    language: str = "eng",
-    max_processes: int = DEFAULT_MAX_PROCESSES,
-    psm: PSMMode = PSMMode.AUTO,
+    file_paths: Sequence[PathLike[str] | str], config: ExtractionConfig = DEFAULT_CONFIG
 ) -> list[ExtractionResult]:
     """Synchronous version of batch_extract_file.
 
     Args:
         file_paths: A sequence of paths to files to extract text from.
-        force_ocr: Whether to force OCR on PDF files that have a text layer.
-        language: The language code for OCR. Defaults to "eng".
-        max_processes: Maximum number of concurrent processes. Defaults to CPU count / 2 (minimum 1).
-        psm: Page segmentation mode for Tesseract OCR. Defaults to PSMMode.AUTO.
+        config: Extraction options object, defaults to the default object.
 
     Returns:
         A list of extraction results in the same order as the input paths.
     """
-    handler = partial(
-        batch_extract_file,
-        file_paths,
-        force_ocr=force_ocr,
-        max_processes=max_processes,
-        language=language,
-        psm=psm,
-    )
-    return anyio.run(handler)
+    return [extract_file_sync(file_path=Path(file_path), mime_type=None, config=config) for file_path in file_paths]
 
 
 def batch_extract_bytes_sync(
-    contents: Sequence[tuple[bytes, str]],
-    *,
-    force_ocr: bool = False,
-    language: str = "eng",
-    max_processes: int = DEFAULT_MAX_PROCESSES,
-    psm: PSMMode = PSMMode.AUTO,
+    contents: Sequence[tuple[bytes, str]], config: ExtractionConfig = DEFAULT_CONFIG
 ) -> list[ExtractionResult]:
     """Synchronous version of batch_extract_bytes.
 
     Args:
         contents: A sequence of tuples containing (content, mime_type) pairs.
-        force_ocr: Whether to force OCR on PDF files that have a text layer.
-        language: The language code for OCR. Defaults to "eng".
-        max_processes: Maximum number of concurrent processes. Defaults to CPU count / 2 (minimum 1).
-        psm: Page segmentation mode for Tesseract OCR. Defaults to PSMMode.AUTO.
+        config: Extraction options object, defaults to the default object.
 
     Returns:
         A list of extraction results in the same order as the input contents.
     """
-    handler = partial(
-        batch_extract_bytes,
-        contents,
-        force_ocr=force_ocr,
-        max_processes=max_processes,
-        language=language,
-        psm=psm,
-    )
-    return anyio.run(handler)
+    return [extract_bytes_sync(content=content, mime_type=mime_type, config=config) for content, mime_type in contents]

kreuzberg-3.0.0.dist-info/METADATA

@@ -0,0 +1,178 @@
+Metadata-Version: 2.4
+Name: kreuzberg
+Version: 3.0.0
+Summary: A text extraction library supporting PDFs, images, office documents and more
+Author-email: Na'aman Hirschfeld <nhirschfed@gmail.com>
+License: MIT
+Project-URL: homepage, https://github.com/Goldziher/kreuzberg
+Keywords: document-processing,image-to-text,ocr,pandoc,pdf-extraction,rag,tesseract,text-extraction,text-processing
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.9
+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 :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Text Processing :: General
+Classifier: Topic :: Utilities
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: anyio>=4.9.0
+Requires-Dist: charset-normalizer>=3.4.1
+Requires-Dist: exceptiongroup>=1.2.2; python_version < "3.11"
+Requires-Dist: html-to-markdown>=1.2.0
+Requires-Dist: playa-pdf>=0.4.1
+Requires-Dist: pypdfium2==4.30.0
+Requires-Dist: python-calamine>=0.3.1
+Requires-Dist: python-pptx>=1.0.2
+Requires-Dist: typing-extensions>=4.12.2; python_version < "3.12"
+Provides-Extra: all
+Requires-Dist: easyocr>=1.7.2; extra == "all"
+Requires-Dist: numpy>=2.0.2; extra == "all"
+Requires-Dist: paddleocr>=2.10.0; extra == "all"
+Requires-Dist: paddlepaddle>=2.6.2; python_version < "3.13" and extra == "all"
+Requires-Dist: semantic-text-splitter>=0.24.1; extra == "all"
+Requires-Dist: setuptools>=76.0.0; extra == "all"
+Provides-Extra: chunking
+Requires-Dist: semantic-text-splitter>=0.24.1; extra == "chunking"
+Provides-Extra: easyocr
+Requires-Dist: easyocr>=1.7.2; extra == "easyocr"
+Provides-Extra: paddleocr
+Requires-Dist: numpy>=2.0.2; extra == "paddleocr"
+Requires-Dist: paddleocr>=2.10.0; extra == "paddleocr"
+Requires-Dist: paddlepaddle>=2.6.2; python_version < "3.13" and extra == "paddleocr"
+Requires-Dist: setuptools>=76.0.0; extra == "paddleocr"
+Dynamic: license-file
+
+# Kreuzberg
+
+[![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)
+
+Kreuzberg is a Python library for text extraction from documents. It provides a unified interface for extracting text from PDFs, images, office documents, and more, with both async and sync APIs.
+
+## Why Kreuzberg?
+
+- **Simple and Hassle-Free**: Clean API that just works, without complex configuration
+- **Local Processing**: No external API calls or cloud dependencies required
+- **Resource Efficient**: Lightweight processing without GPU requirements
+- **Format Support**: Comprehensive support for documents, images, and text formats
+- **Multiple OCR Engines**: Support for Tesseract, EasyOCR, and PaddleOCR
+- **Modern Python**: Built with async/await, type hints, and a functional-first approach
+- **Permissive OSS**: MIT licensed with permissively licensed dependencies
+
+## Quick Start
+
+```bash
+pip install kreuzberg
+```
+
+Install pandoc:
+
+```bash
+# Ubuntu/Debian
+sudo apt-get install tesseract-ocr pandoc
+
+# macOS
+brew install tesseract pandoc
+
+# Windows
+choco install -y tesseract pandoc
+```
+
+The tesseract OCR engine is the default OCR engine. You can decide not to use it - and then either use one of the two alternative OCR engines, or have no OCR at all.
+
+### Alternative OCR engines
+
+```bash
+# Install with EasyOCR support
+pip install "kreuzberg[easyocr]"
+
+# Install with PaddleOCR support
+pip install "kreuzberg[paddleocr]"
+```
+
+## Quick Example
+
+```python
+import asyncio
+from kreuzberg import extract_file
+
+async def main():
+    # Extract text from a PDF
+    result = await extract_file("document.pdf")
+    print(result.content)
+
+    # Extract text from an image
+    result = await extract_file("scan.jpg")
+    print(result.content)
+
+    # Extract text from a Word document
+    result = await extract_file("report.docx")
+    print(result.content)
+
+asyncio.run(main())
+```
+
+## Documentation
+
+For comprehensive documentation, visit our [GitHub Pages](https://goldziher.github.io/kreuzberg/):
+
+- [Getting Started](https://goldziher.github.io/kreuzberg/getting-started/) - Installation and basic usage
+- [User Guide](https://goldziher.github.io/kreuzberg/user-guide/) - In-depth usage information
+- [API Reference](https://goldziher.github.io/kreuzberg/api-reference/) - Detailed API documentation
+- [Examples](https://goldziher.github.io/kreuzberg/examples/) - Code examples for common use cases
+- [OCR Configuration](https://goldziher.github.io/kreuzberg/user-guide/ocr-configuration/) - Configure OCR engines
+- [OCR Backends](https://goldziher.github.io/kreuzberg/user-guide/ocr-backends/) - Choose the right OCR engine
+
+## Supported Formats
+
+Kreuzberg supports a wide range of document formats:
+
+- **Documents**: PDF, DOCX, DOC, RTF, TXT, EPUB, etc.
+- **Images**: JPG, PNG, TIFF, BMP, GIF, etc.
+- **Spreadsheets**: XLSX, XLS, CSV, etc.
+- **Presentations**: PPTX, PPT, etc.
+- **Web Content**: HTML, XML, etc.
+
+## OCR Engines
+
+Kreuzberg supports multiple OCR engines:
+
+- **Tesseract** (Default): Lightweight, fast startup, requires system installation
+- **EasyOCR**: Good for many languages, pure Python, but downloads models on first use
+- **PaddleOCR**: Excellent for Asian languages, pure Python, but downloads models on first use
+
+For comparison and selection guidance, see the [OCR Backends](https://example.com/ocr-backends) documentation.
+
+## Contribution
+
+This library is open to contribution. Feel free to open issues or submit PRs. It's better to discuss issues before submitting PRs to avoid disappointment.
+
+### Local Development
+
+1. Clone the repo
+
+1. Install the system dependencies
+
+1. Install the full dependencies with `uv sync`
+
+1. Install the pre-commit hooks with:
+
+    ```shell
+    pre-commit install && pre-commit install --hook-type commit-msg
+    ```
+
+1. Make your changes and submit a PR
+
+## License
+
+This library is released under the MIT license.

kreuzberg-3.0.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+kreuzberg/__init__.py,sha256=KZ_y21m64cafWL7goGeG3EIDutM184st28n4UGajADs,1131
+kreuzberg/_chunker.py,sha256=2eHSRHcZdJ2ZjR3in49y3o9tPl5HMO3vkbnMqaVCbHI,1887
+kreuzberg/_constants.py,sha256=Bxc8oiN-wHwnWXT9bEiJhTUcu1ygPpra5qHirAif3b4,191
+kreuzberg/_mime_types.py,sha256=pKtxBPDoye2knyou_VODDMPIt3eXotP-ak4MAKFI2SU,6310
+kreuzberg/_playa.py,sha256=agHdhKfKLNtiP37XdNncbCP65v3Qv3m1Gn2KTRUkVx8,10396
+kreuzberg/_registry.py,sha256=c2B_PJbaL0q3ab2eNmj_0jldeyMaqgvRwkZqUU4MM5Q,3290
+kreuzberg/_types.py,sha256=sZMxjRZQ1c_MzxdumhYSWghW6yXBwohTUIBa5eR-FKA,6582
+kreuzberg/exceptions.py,sha256=xRaiJh11i8E6Nc-gAQPgNW5xvhiiFBhRS-CBbCEbHQM,2881
+kreuzberg/extraction.py,sha256=0sjvbunx5srbR5lzjOAQjGK5JY3bCUHw-dRFmHjFz7o,8671
+kreuzberg/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+kreuzberg-3.0.0.dist-info/licenses/LICENSE,sha256=-8caMvpCK8SgZ5LlRKhGCMtYDEXqTKH9X8pFEhl91_4,1066
+kreuzberg-3.0.0.dist-info/METADATA,sha256=wlO9VCvZQy_gJJTmhGzH9j8BlPQPFQdmMZQxJOcQAUg,6515
+kreuzberg-3.0.0.dist-info/WHEEL,sha256=1tXe9gY0PYatrMPMDd6jXqjfpz_B-Wqm32CPfRC58XU,91
+kreuzberg-3.0.0.dist-info/top_level.txt,sha256=rbGkygffkZiyKhL8UN41ZOjLfem0jJPA1Whtndne0rE,10
+kreuzberg-3.0.0.dist-info/RECORD,,