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

kreuzberg-3.0.1.dist-info/RECORD

@@ -0,0 +1,32 @@
+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/_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=VQgSFSzXIMX3A52-DyvuKgfTRXUJIjYn6IX4-sQWWdg,2626
+kreuzberg/_extractors/_pandoc.py,sha256=a6cYQxoh5G9EMrDWVcQhrTkE4Mar24sNiGCY0zOOzw4,20121
+kreuzberg/_extractors/_pdf.py,sha256=dcSAXyqH8SZ-z45OUAjjwdboSEbrli0YekS8PxCaVGA,6384
+kreuzberg/_extractors/_presentation.py,sha256=K4ALrpmZ0EWyp2O-3oEmTRCS7yAET9xjinrzo13rpWo,8764
+kreuzberg/_extractors/_spread_sheet.py,sha256=1ejRZk8AE1dXS1tRIdg2S0J9Vo0wG81iKkW2IF6PjlE,4445
+kreuzberg/_ocr/__init__.py,sha256=VTqwKDlIRbjve71Y11Ztygyhv5aWG9LWTj8iX66ANxE,533
+kreuzberg/_ocr/_base.py,sha256=lNT0Tin4hzbmaamqqySxvYEwNtrJB5gGlStrANQQcyc,1637
+kreuzberg/_ocr/_easyocr.py,sha256=VfYW66SkB2Bigbrtd7WEeJ6QZ_1Y5d8Z_rZYBPMsuk0,11037
+kreuzberg/_ocr/_paddleocr.py,sha256=X5es69QMl0P6DZuuRNKWHaRtLi1OJqFs-mWHR_gVKvY,10837
+kreuzberg/_ocr/_tesseract.py,sha256=cdnVxNpaKjxtBN4xy0Timz-uYtPA9wq9kc6kyYVeDug,9779
+kreuzberg/_utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+kreuzberg/_utils/_string.py,sha256=oNO0cmwjVNG0jAzaqNCjYtzvM_nxH5TW2KV-Uh3oEUU,978
+kreuzberg/_utils/_sync.py,sha256=lycobEMXk0tBMWLwkuMdOuNMStDwPKMC0V1Qgp_oi6k,4071
+kreuzberg/_utils/_tmp.py,sha256=5rqG_Nlb9xweaLqJA8Kc5csHDase9_eY_Fq93rNQGWc,1044
+kreuzberg-3.0.1.dist-info/licenses/LICENSE,sha256=-8caMvpCK8SgZ5LlRKhGCMtYDEXqTKH9X8pFEhl91_4,1066
+kreuzberg-3.0.1.dist-info/METADATA,sha256=5Kt0w9rFBAina8SzbO-m2umEMRJQL-4mcPGAQASko_k,6545
+kreuzberg-3.0.1.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+kreuzberg-3.0.1.dist-info/top_level.txt,sha256=rbGkygffkZiyKhL8UN41ZOjLfem0jJPA1Whtndne0rE,10
+kreuzberg-3.0.1.dist-info/RECORD,,

{kreuzberg-2.1.2.dist-info → kreuzberg-3.0.1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.8.2)
+Generator: setuptools (78.1.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

kreuzberg/_html.py

@@ -1,31 +0,0 @@
-from __future__ import annotations
-
-from typing import TYPE_CHECKING
-
-import html_to_markdown
-from anyio import Path as AsyncPath
-
-from kreuzberg import ExtractionResult
-from kreuzberg._mime_types import MARKDOWN_MIME_TYPE
-from kreuzberg._string import normalize_spaces, safe_decode
-
-if TYPE_CHECKING:
-    from pathlib import Path
-
-
-async def extract_html_string(file_path_or_contents: Path | bytes) -> ExtractionResult:
-    """Extract text from an HTML string.
-
-    Args:
-        file_path_or_contents: The HTML content.
-
-    Returns:
-        The extracted text content.
-    """
-    content = (
-        safe_decode(file_path_or_contents)
-        if isinstance(file_path_or_contents, bytes)
-        else await AsyncPath(file_path_or_contents).read_text()
-    )
-    result = html_to_markdown.convert_to_markdown(content)
-    return ExtractionResult(content=normalize_spaces(result), mime_type=MARKDOWN_MIME_TYPE, metadata={})

kreuzberg/_pandoc.py

@@ -1,366 +0,0 @@
-from __future__ import annotations
-
-import re
-import sys
-from json import JSONDecodeError, loads
-from typing import TYPE_CHECKING, Any, Final, Literal, cast
-
-from anyio import Path as AsyncPath
-from anyio import run_process
-
-from kreuzberg import ValidationError
-from kreuzberg._constants import MINIMAL_SUPPORTED_PANDOC_VERSION
-from kreuzberg._mime_types import MARKDOWN_MIME_TYPE
-from kreuzberg._string import normalize_spaces
-from kreuzberg._sync import run_taskgroup
-from kreuzberg._tmp import create_temp_file
-from kreuzberg._types import ExtractionResult, Metadata
-from kreuzberg.exceptions import MissingDependencyError, ParsingError
-
-if TYPE_CHECKING:  # pragma: no cover
-    from collections.abc import Mapping
-    from os import PathLike
-
-if sys.version_info < (3, 11):  # pragma: no cover
-    from exceptiongroup import ExceptionGroup  # type: ignore[import-not-found]
-
-version_ref: Final[dict[str, bool]] = {"checked": False}
-
-# Block-level node types in Pandoc AST
-BLOCK_HEADER: Final = "Header"  # Header with level, attributes and inline content
-BLOCK_PARA: Final = "Para"  # Paragraph containing inline content
-BLOCK_CODE: Final = "CodeBlock"  # Code block with attributes and string content
-BLOCK_QUOTE: Final = "BlockQuote"  # Block quote containing blocks
-BLOCK_LIST: Final = "BulletList"  # Bullet list containing items (blocks)
-BLOCK_ORDERED: Final = "OrderedList"  # Numbered list with attrs and items
-
-# Inline-level node types in Pandoc AST
-INLINE_STR: Final = "Str"  # Plain text string
-INLINE_SPACE: Final = "Space"  # Single space
-INLINE_EMPH: Final = "Emph"  # Emphasized text (contains inlines)
-INLINE_STRONG: Final = "Strong"  # Strong/bold text (contains inlines)
-INLINE_LINK: Final = "Link"  # Link with text and target
-INLINE_IMAGE: Final = "Image"  # Image with alt text and source
-INLINE_CODE: Final = "Code"  # Inline code span
-INLINE_MATH: Final = "Math"  # Math expression
-
-# Metadata node types in Pandoc AST
-META_MAP: Final = "MetaMap"  # Key-value mapping of metadata
-META_LIST: Final = "MetaList"  # List of metadata values
-META_INLINES: Final = "MetaInlines"  # Inline content in metadata
-META_STRING: Final = "MetaString"  # Plain string in metadata
-META_BLOCKS: Final = "MetaBlocks"  # Block content in metadata
-
-# Node content field name
-CONTENT_FIELD: Final = "c"
-TYPE_FIELD: Final = "t"
-
-# Valid node types
-NodeType = Literal[
-    # Block types
-    "Header",
-    "Para",
-    "CodeBlock",
-    "BlockQuote",
-    "BulletList",
-    "OrderedList",
-    # Inline types
-    "Str",
-    "Space",
-    "Emph",
-    "Strong",
-    "Link",
-    "Image",
-    "Code",
-    "Math",
-    # Meta types
-    "MetaMap",
-    "MetaList",
-    "MetaInlines",
-    "MetaString",
-    "MetaBlocks",
-]
-
-MIMETYPE_TO_PANDOC_TYPE_MAPPING: Final[Mapping[str, str]] = {
-    "application/csl+json": "csljson",
-    "application/docbook+xml": "docbook",
-    "application/epub+zip": "epub",
-    "application/rtf": "rtf",
-    "application/vnd.oasis.opendocument.text": "odt",
-    "application/vnd.openxmlformats-officedocument.wordprocessingml.document": "docx",
-    "application/x-biblatex": "biblatex",
-    "application/x-bibtex": "bibtex",
-    "application/x-endnote+xml": "endnotexml",
-    "application/x-fictionbook+xml": "fb2",
-    "application/x-ipynb+json": "ipynb",
-    "application/x-jats+xml": "jats",
-    "application/x-latex": "latex",
-    "application/x-opml+xml": "opml",
-    "application/x-research-info-systems": "ris",
-    "application/x-typst": "typst",
-    "text/csv": "csv",
-    "text/tab-separated-values": "tsv",
-    "text/troff": "man",
-    "text/x-commonmark": "commonmark",
-    "text/x-dokuwiki": "dokuwiki",
-    "text/x-gfm": "gfm",
-    "text/x-markdown": "markdown",
-    "text/x-markdown-extra": "markdown_phpextra",
-    "text/x-mdoc": "mdoc",
-    "text/x-multimarkdown": "markdown_mmd",
-    "text/x-org": "org",
-    "text/x-pod": "pod",
-    "text/x-rst": "rst",
-}
-
-MIMETYPE_TO_FILE_EXTENSION_MAPPING: Final[Mapping[str, str]] = {
-    "application/csl+json": "json",
-    "application/docbook+xml": "xml",
-    "application/epub+zip": "epub",
-    "application/rtf": "rtf",
-    "application/vnd.oasis.opendocument.text": "odt",
-    "application/vnd.openxmlformats-officedocument.wordprocessingml.document": "docx",
-    "application/x-biblatex": "bib",
-    "application/x-bibtex": "bib",
-    "application/x-endnote+xml": "xml",
-    "application/x-fictionbook+xml": "fb2",
-    "application/x-ipynb+json": "ipynb",
-    "application/x-jats+xml": "xml",
-    "application/x-latex": "tex",
-    "application/x-opml+xml": "opml",
-    "application/x-research-info-systems": "ris",
-    "application/x-typst": "typst",
-    "text/csv": "csv",
-    "text/tab-separated-values": "tsv",
-    "text/troff": "1",
-    "text/x-commonmark": "md",
-    "text/x-dokuwiki": "wiki",
-    "text/x-gfm": "md",
-    "text/x-markdown": "md",
-    "text/x-markdown-extra": "md",
-    "text/x-mdoc": "md",
-    "text/x-multimarkdown": "md",
-    "text/x-org": "org",
-    "text/x-pod": "pod",
-    "text/x-rst": "rst",
-}
-
-
-def _extract_inline_text(node: dict[str, Any]) -> str | None:
-    if node_type := node.get(TYPE_FIELD):
-        if node_type == INLINE_STR:
-            return node.get(CONTENT_FIELD)
-        if node_type == INLINE_SPACE:
-            return " "
-        if node_type in (INLINE_EMPH, INLINE_STRONG):
-            return _extract_inlines(node.get(CONTENT_FIELD, []))
-    return None  # pragma: no cover
-
-
-def _extract_inlines(nodes: list[dict[str, Any]]) -> str | None:
-    texts = [text for node in nodes if (text := _extract_inline_text(node))]
-    result = "".join(texts).strip()
-    return result if result else None
-
-
-def _extract_meta_value(node: Any) -> str | list[str] | None:
-    if not isinstance(node, dict) or CONTENT_FIELD not in node or TYPE_FIELD not in node:
-        return None
-
-    content = node[CONTENT_FIELD]
-    node_type = node[TYPE_FIELD]
-
-    if not content or node_type not in {
-        META_STRING,
-        META_INLINES,
-        META_LIST,
-        META_BLOCKS,
-    }:
-        return None
-
-    if node_type == META_STRING and isinstance(content, str):
-        return content
-
-    if isinstance(content, list) and (content := [v for v in content if isinstance(v, dict)]):
-        if node_type == META_INLINES:
-            return _extract_inlines(cast(list[dict[str, Any]], content))
-
-        if node_type == META_LIST:
-            results = []
-            for value in [value for item in content if (value := _extract_meta_value(item))]:
-                if isinstance(value, list):  # pragma: no cover
-                    results.extend(value)
-                else:
-                    results.append(value)
-            return results
-
-        # This branch is only taken for complex metadata blocks which we don't use
-        if blocks := [block for block in content if block.get(TYPE_FIELD) == BLOCK_PARA]:  # pragma: no cover
-            block_texts = []
-            for block in blocks:
-                block_content = block.get(CONTENT_FIELD, [])
-                if isinstance(block_content, list) and (text := _extract_inlines(block_content)):
-                    block_texts.append(text)
-            return block_texts if block_texts else None
-
-    return None
-
-
-def _extract_metadata(raw_meta: dict[str, Any]) -> Metadata:
-    meta: Metadata = {}
-
-    for key, value in raw_meta.items():
-        if extracted := _extract_meta_value(value):
-            meta[key] = extracted  # type: ignore[literal-required]
-
-    citations = [
-        cite["citationId"]
-        for block in raw_meta.get("blocks", [])
-        if block.get(TYPE_FIELD) == "Cite"
-        for cite in block.get(CONTENT_FIELD, [[{}]])[0]
-        if isinstance(cite, dict)
-    ]
-    if citations:
-        meta["citations"] = citations
-
-    return meta
-
-
-def _get_pandoc_type_from_mime_type(mime_type: str) -> str:
-    if pandoc_type := (MIMETYPE_TO_PANDOC_TYPE_MAPPING.get(mime_type, "")):
-        return pandoc_type
-
-    if any(k.startswith(mime_type) for k in MIMETYPE_TO_PANDOC_TYPE_MAPPING):
-        return next(
-            MIMETYPE_TO_PANDOC_TYPE_MAPPING[k] for k in MIMETYPE_TO_PANDOC_TYPE_MAPPING if k.startswith(mime_type)
-        )
-
-    raise ValidationError(f"Unsupported mime type: {mime_type}")
-
-
-async def _validate_pandoc_version() -> None:
-    try:
-        if version_ref["checked"]:
-            return
-
-        command = ["pandoc", "--version"]
-        result = await run_process(command)
-
-        version_match = re.search(r"pandoc\s+v?(\d+)\.\d+\.\d+", result.stdout.decode())
-        if not version_match or int(version_match.group(1)) < MINIMAL_SUPPORTED_PANDOC_VERSION:
-            raise MissingDependencyError("Pandoc version 2 or above is required")
-
-        version_ref["checked"] = True
-
-    except FileNotFoundError as e:
-        raise MissingDependencyError("Pandoc is not installed") from e
-
-
-async def _handle_extract_metadata(input_file: str | PathLike[str], *, mime_type: str) -> Metadata:
-    pandoc_type = _get_pandoc_type_from_mime_type(mime_type)
-    metadata_file, unlink = await create_temp_file(".json")
-    try:
-        command = [
-            "pandoc",
-            str(input_file),
-            f"--from={pandoc_type}",
-            "--to=json",
-            "--standalone",
-            "--quiet",
-            "--output",
-            str(metadata_file),
-        ]
-
-        result = await run_process(command)
-
-        if result.returncode != 0:
-            raise ParsingError("Failed to extract file data", context={"file": str(input_file), "error": result.stderr})
-
-        json_data = loads(await AsyncPath(metadata_file).read_text("utf-8"))
-        return _extract_metadata(json_data)
-    except (RuntimeError, OSError, JSONDecodeError) as e:
-        raise ParsingError("Failed to extract file data", context={"file": str(input_file)}) from e
-    finally:
-        await unlink()
-
-
-async def _handle_extract_file(input_file: str | PathLike[str], *, mime_type: str) -> str:
-    pandoc_type = _get_pandoc_type_from_mime_type(mime_type)
-    output_path, unlink = await create_temp_file(".md")
-    try:
-        command = [
-            "pandoc",
-            str(input_file),
-            f"--from={pandoc_type}",
-            "--to=markdown",
-            "--standalone",
-            "--wrap=preserve",
-            "--quiet",
-        ]
-
-        command.extend(["--output", str(output_path)])
-
-        result = await run_process(command)
-
-        if result.returncode != 0:
-            raise ParsingError("Failed to extract file data", context={"file": str(input_file), "error": result.stderr})
-
-        text = await AsyncPath(output_path).read_text("utf-8")
-
-        return normalize_spaces(text)
-    except (RuntimeError, OSError) as e:
-        raise ParsingError("Failed to extract file data", context={"file": str(input_file)}) from e
-    finally:
-        await unlink()
-
-
-async def process_file_with_pandoc(input_file: str | PathLike[str], *, mime_type: str) -> ExtractionResult:
-    """Process a single file using Pandoc and convert to markdown.
-
-    Args:
-        input_file: The path to the file to process.
-        mime_type: The mime type of the file.
-
-    Raises:
-        ParsingError: If the file data could not be extracted.
-
-    Returns:
-        ExtractionResult
-    """
-    await _validate_pandoc_version()
-
-    _get_pandoc_type_from_mime_type(mime_type)
-
-    try:
-        metadata_task = _handle_extract_metadata(input_file, mime_type=mime_type)
-        content_task = _handle_extract_file(input_file, mime_type=mime_type)
-        results = await run_taskgroup(metadata_task, content_task)
-        metadata, content = cast(tuple[Metadata, str], results)
-
-        return ExtractionResult(
-            content=normalize_spaces(content),
-            metadata=metadata,
-            mime_type=MARKDOWN_MIME_TYPE,
-        )
-    except ExceptionGroup as eg:
-        raise ParsingError("Failed to process file", context={"file": str(input_file), "errors": eg.exceptions}) from eg
-
-
-async def process_content_with_pandoc(content: bytes, *, mime_type: str) -> ExtractionResult:
-    """Process content using Pandoc and convert to markdown.
-
-    Args:
-        content: The content to process.
-        mime_type: The mime type of the content.
-
-    Returns:
-        ExtractionResult
-    """
-    extension = MIMETYPE_TO_FILE_EXTENSION_MAPPING.get(mime_type) or "md"
-    input_file, unlink = await create_temp_file(f".{extension}")
-
-    await AsyncPath(input_file).write_bytes(content)
-    result = await process_file_with_pandoc(input_file, mime_type=mime_type)
-
-    await unlink()
-    return result

kreuzberg/_pdf.py

@@ -1,190 +0,0 @@
-from __future__ import annotations
-
-from re import Pattern
-from re import compile as compile_regex
-from typing import TYPE_CHECKING, Final, cast
-
-import pypdfium2
-from anyio import Path as AsyncPath
-
-from kreuzberg import ExtractionResult
-from kreuzberg._mime_types import PLAIN_TEXT_MIME_TYPE
-from kreuzberg._string import normalize_spaces
-from kreuzberg._sync import run_sync
-from kreuzberg._tesseract import PSMMode, batch_process_images
-from kreuzberg.exceptions import ParsingError
-
-if TYPE_CHECKING:  # pragma: no cover
-    from pathlib import Path
-
-    from PIL.Image import Image
-
-
-# Pattern to detect common PDF text extraction corruption:
-# - Control and non-printable characters
-# - Unicode replacement and invalid characters
-# - Zero-width spaces and other invisible characters
-CORRUPTED_PATTERN: Final[Pattern[str]] = compile_regex(r"[\x00-\x08\x0B-\x0C\x0E-\x1F]|\uFFFD")
-SHORT_TEXT_THRESHOLD: Final[int] = 50
-MINIMUM_CORRUPTED_RESULTS: Final[int] = 2
-
-
-def _validate_extracted_text(text: str, corruption_threshold: float = 0.05) -> bool:
-    """Check if text extracted from PDF is valid or corrupted.
-
-    This checks for indicators of corrupted PDF text extraction:
-    1. Empty or whitespace-only text
-    2. High concentration of control characters and null bytes
-    3. High concentration of Unicode replacement characters
-
-    Args:
-        text: The extracted text to validate
-        corruption_threshold: Maximum allowed percentage (0.0-1.0) of corrupted
-            characters (default: 0.05 or 5%)
-
-    Returns:
-        True if the text appears valid, False if it seems corrupted
-    """
-    if not text or not text.strip():
-        return False
-
-    corruption_matches = CORRUPTED_PATTERN.findall(text)
-
-    if len(text) < SHORT_TEXT_THRESHOLD:
-        return len(corruption_matches) <= MINIMUM_CORRUPTED_RESULTS
-
-    return (len(corruption_matches) / len(text)) < corruption_threshold
-
-
-async def _convert_pdf_to_images(input_file: Path) -> list[Image]:
-    """Convert a PDF file to images.
-
-    Args:
-        input_file: The path to the PDF file.
-
-    Raises:
-        ParsingError: If the PDF file could not be converted to images.
-
-    Returns:
-        A list of Pillow Images.
-    """
-    document: pypdfium2.PdfDocument | None = None
-    try:
-        document = await run_sync(pypdfium2.PdfDocument, str(input_file))
-        return [page.render(scale=4.25).to_pil() for page in cast(pypdfium2.PdfDocument, document)]
-    except pypdfium2.PdfiumError as e:
-        raise ParsingError(
-            "Could not convert PDF to images", context={"file_path": str(input_file), "error": str(e)}
-        ) from e
-    finally:
-        if document:
-            await run_sync(document.close)
-
-
-async def _extract_pdf_text_with_ocr(
-    input_file: Path,
-    *,
-    language: str = "eng",
-    max_processes: int,
-    psm: PSMMode = PSMMode.AUTO,
-) -> ExtractionResult:
-    """Extract text from a scanned PDF file using pytesseract.
-
-    Args:
-        input_file: The path to the PDF file.
-        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.
-
-    Returns:
-        The extracted text.
-    """
-    images = await _convert_pdf_to_images(input_file)
-    ocr_results = await batch_process_images(images, max_processes=max_processes, psm=psm, language=language)
-    return ExtractionResult(
-        content="\n".join([v.content for v in ocr_results]), mime_type=PLAIN_TEXT_MIME_TYPE, metadata={}
-    )
-
-
-async def _extract_pdf_searchable_text(input_file: Path) -> str:
-    """Extract text from a searchable PDF file using pypdfium2.
-
-    Args:
-        input_file: The path to the PDF file.
-
-    Raises:
-        ParsingError: If the text could not be extracted from the PDF file.
-
-    Returns:
-        The extracted text.
-    """
-    document: pypdfium2.PdfDocument | None = None
-    try:
-        document = await run_sync(pypdfium2.PdfDocument, str(input_file))
-        text = "\n".join(page.get_textpage().get_text_bounded() for page in cast(pypdfium2.PdfDocument, document))
-        return normalize_spaces(text)
-    except pypdfium2.PdfiumError as e:
-        raise ParsingError(
-            "Could not extract text from PDF file", context={"file_path": str(input_file), "error": str(e)}
-        ) from e
-    finally:
-        if document:
-            await run_sync(document.close)
-
-
-async def extract_pdf_file(
-    input_file: Path,
-    *,
-    force_ocr: bool,
-    language: str = "eng",
-    max_processes: int,
-    psm: PSMMode = PSMMode.AUTO,
-) -> ExtractionResult:
-    """Extract text from a PDF file.
-
-    Args:
-        input_file: The path to the PDF file.
-        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.
-
-    Returns:
-        The extracted text.
-    """
-    if not force_ocr:
-        content = await _extract_pdf_searchable_text(input_file)
-        if _validate_extracted_text(content):
-            return ExtractionResult(content=content, mime_type=PLAIN_TEXT_MIME_TYPE, metadata={})
-    return await _extract_pdf_text_with_ocr(input_file, max_processes=max_processes, language=language, psm=psm)
-
-
-async def extract_pdf_content(
-    content: bytes,
-    *,
-    force_ocr: bool,
-    language: str = "eng",
-    max_processes: int,
-    psm: PSMMode = PSMMode.AUTO,
-) -> ExtractionResult:
-    """Extract text from a PDF file content.
-
-    Args:
-        content: The PDF file 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.
-
-    Returns:
-        The extracted text.
-    """
-    from kreuzberg._tmp import create_temp_file
-
-    file_path, unlink = await create_temp_file(".pdf")
-    await AsyncPath(file_path).write_bytes(content)
-    result = await extract_pdf_file(
-        file_path, force_ocr=force_ocr, max_processes=max_processes, psm=psm, language=language
-    )
-    await unlink()
-    return result