kreuzberg 1.6.0__py3-none-any.whl → 2.0.0__py3-none-any.whl

kreuzberg-2.0.0.dist-info/METADATA

@@ -0,0 +1,419 @@
+Metadata-Version: 2.2
+Name: kreuzberg
+Version: 2.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.8.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: pypdfium2>=4.30.1
+Requires-Dist: python-calamine>=0.3.1
+Requires-Dist: python-pptx>=1.0.2
+Requires-Dist: typing-extensions>=4.12.2; python_version < "3.11"
+
+# Kreuzberg
+
+Kreuzberg is a Python library for text extraction from documents. It provides a unified async interface for extracting text from PDFs, images, office documents, and more.
+
+## 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
+- **Lightweight**: Has few curated dependencies and a minimal footprint
+- **Format Support**: Comprehensive support for documents, images, and text formats
+- **Modern Python**: Built with async/await, type hints, and functional first approach
+- **Permissive OSS**: Kreuzberg and its dependencies have a permissive OSS license
+
+Kreuzberg was built for RAG (Retrieval Augmented Generation) applications, focusing on local processing with minimal dependencies. Its designed for modern async applications, serverless functions, and dockerized applications.
+
+## Installation
+
+### 1. Install the Python Package
+
+```shell
+pip install kreuzberg
+```
+
+### 2. Install System Dependencies
+
+Kreuzberg requires two system level dependencies:
+
+- [Pandoc](https://pandoc.org/installing.html) - For document format conversion
+- [Tesseract OCR](https://tesseract-ocr.github.io/) - For image and PDF OCR
+
+Please install these using their respective installation guides.
+
+## Architecture
+
+Kreuzberg integrates:
+
+- **PDF Processing**:
+  - `pdfium2` for searchable PDFs
+  - Tesseract OCR for scanned content
+- **Document Conversion**:
+  - Pandoc for many document and markup formats
+  - `python-pptx` for PowerPoint files
+  - `html-to-markdown` for HTML content
+  - `calamine` for Excel spreadsheets (with multi-sheet support)
+- **Text Processing**:
+  - Smart encoding detection
+  - Markdown and plain text handling
+
+### Supported Formats
+
+#### Document Formats
+
+- PDF (`.pdf`, both searchable and scanned)
+- Microsoft Word (`.docx`)
+- PowerPoint presentations (`.pptx`)
+- OpenDocument Text (`.odt`)
+- Rich Text Format (`.rtf`)
+- EPUB (`.epub`)
+- DocBook XML (`.dbk`, `.xml`)
+- FictionBook (`.fb2`)
+- LaTeX (`.tex`, `.latex`)
+- Typst (`.typ`)
+
+#### Markup and Text Formats
+
+- HTML (`.html`, `.htm`)
+- Plain text (`.txt`) and Markdown (`.md`, `.markdown`)
+- reStructuredText (`.rst`)
+- Org-mode (`.org`)
+- DokuWiki (`.txt`)
+- Pod (`.pod`)
+- Troff/Man (`.1`, `.2`, etc.)
+
+#### Data and Research Formats
+
+- Spreadsheets (`.xlsx`, `.xls`, `.xlsm`, `.xlsb`, `.xlam`, `.xla`, `.ods`)
+- CSV (`.csv`) and TSV (`.tsv`) files
+- OPML files (`.opml`)
+- Jupyter Notebooks (`.ipynb`)
+- BibTeX (`.bib`) and BibLaTeX (`.bib`)
+- CSL-JSON (`.json`)
+- EndNote and JATS XML (`.xml`)
+- RIS (`.ris`)
+
+#### Image Formats
+
+- JPEG (`.jpg`, `.jpeg`, `.pjpeg`)
+- PNG (`.png`)
+- TIFF (`.tiff`, `.tif`)
+- BMP (`.bmp`)
+- GIF (`.gif`)
+- JPEG 2000 family (`.jp2`, `.jpm`, `.jpx`, `.mj2`)
+- WebP (`.webp`)
+- Portable anymap formats (`.pbm`, `.pgm`, `.ppm`, `.pnm`)
+
+## Usage
+
+Kreuzberg provides both async and sync APIs for text extraction, including batch processing. The library exports the following main functions:
+
+- Single Item Processing:
+
+  - `extract_file()`: Async function to extract text from a file (accepts string path or `pathlib.Path`)
+  - `extract_bytes()`: Async function to extract text from bytes (accepts a byte string)
+  - `extract_file_sync()`: Synchronous version of `extract_file()`
+  - `extract_bytes_sync()`: Synchronous version of `extract_bytes()`
+
+- Batch Processing:
+  - `batch_extract_file()`: Async function to extract text from multiple files concurrently
+  - `batch_extract_bytes()`: Async function to extract text from multiple byte contents concurrently
+  - `batch_extract_file_sync()`: Synchronous version of `batch_extract_file()`
+  - `batch_extract_bytes_sync()`: Synchronous version of `batch_extract_bytes()`
+
+### Configuration Parameters
+
+All extraction functions accept the following optional parameters for configuring OCR and performance:
+
+#### OCR Configuration
+
+- `language` (default: "eng"): Specifies the language model for Tesseract OCR. This affects text recognition accuracy for non-English documents. Examples:
+  - "eng" for English
+  - "deu" for German
+  - "fra" for French
+
+Consult the [Tesseract documentation](https://tesseract-ocr.github.io/tessdoc/) for more information.
+
+- `psm` (Page Segmentation Mode, default: PSM.AUTO): Controls how Tesseract analyzes page layout. In most cases you do not need to change this to a different value.
+
+#### Performance Configuration
+
+- `max_processes` (default: CPU count / 2): Maximum number of concurrent processes for Tesseract and Pandoc. Higher values can lead to performance improvements, but may cause resource exhaustion and deadlocks (especially for tesseract).
+
+### Quick Start
+
+```python
+from pathlib import Path
+from kreuzberg import extract_file
+from kreuzberg.extraction import ExtractionResult
+from kreuzberg._tesseract import PSMMode, SupportedLanguage
+
+
+# Basic file extraction
+async def extract_document():
+    # Extract from a PDF file with default settings
+    pdf_result: ExtractionResult = await extract_file("document.pdf")
+    print(f"Content: {pdf_result.content}")
+
+    # Extract from an image with German language model
+    img_result = await extract_file(
+        "scan.png",
+        language="deu",  # German language model
+        psm=PSMMode.SINGLE_BLOCK,  # Treat as single block of text
+        max_processes=4  # Limit concurrent processes
+    )
+    print(f"Image text: {img_result.content}")
+
+    # Extract from Word document with metadata
+    docx_result = await extract_file(Path("document.docx"))
+    if docx_result.metadata:
+        print(f"Title: {docx_result.metadata.get('title')}")
+        print(f"Author: {docx_result.metadata.get('author')}")
+```
+
+### Extracting Bytes
+
+```python
+from kreuzberg import extract_bytes
+from kreuzberg.extraction import ExtractionResult
+
+
+async def process_upload(file_content: bytes, mime_type: str) -> ExtractionResult:
+    """Process uploaded file content with known MIME type."""
+    return await extract_bytes(
+        file_content,
+        mime_type=mime_type,
+    )
+
+
+# Example usage with different file types
+async def handle_uploads(docx_bytes: bytes, pdf_bytes: bytes, image_bytes: bytes):
+    # Process PDF upload
+    pdf_result = await process_upload(pdf_bytes, mime_type="application/pdf")
+    print(f"PDF content: {pdf_result.content}")
+    print(f"PDF metadata: {pdf_result.metadata}")
+
+    # Process image upload (will use OCR)
+    img_result = await process_upload(image_bytes, mime_type="image/jpeg")
+    print(f"Image text: {img_result.content}")
+
+    # Process Word document upload
+    docx_result = await process_upload(
+        docx_bytes,
+        mime_type="application/vnd.openxmlformats-officedocument.wordprocessingml.document"
+    )
+    print(f"Word content: {docx_result.content}")
+```
+
+### Batch Processing
+
+Kreuzberg supports efficient batch processing of multiple files or byte contents:
+
+```python
+from pathlib import Path
+from kreuzberg import batch_extract_file, batch_extract_bytes
+
+
+# Process multiple files concurrently
+async def process_documents(file_paths: list[Path]) -> None:
+    # Extract from multiple files
+    results = await batch_extract_file(file_paths)
+    for path, result in zip(file_paths, results):
+        print(f"File {path}: {result.content[:100]}...")
+
+
+# Process multiple uploaded files concurrently
+async def process_uploads(contents: list[tuple[bytes, str]]) -> None:
+    # Each item is a tuple of (content, mime_type)
+    results = await batch_extract_bytes(contents)
+    for (_, mime_type), result in zip(contents, results):
+        print(f"Upload {mime_type}: {result.content[:100]}...")
+
+
+# Synchronous batch processing is also available
+def process_documents_sync(file_paths: list[Path]) -> None:
+    results = batch_extract_file_sync(file_paths)
+    for path, result in zip(file_paths, results):
+        print(f"File {path}: {result.content[:100]}...")
+```
+
+Features:
+
+- Ordered results
+- Concurrent processing
+- Error handling per item
+- Async and sync interfaces
+- Same options as single extraction
+
+### PDF Processing
+
+Kreuzberg employs a smart approach to PDF text extraction:
+
+1. **Searchable Text Detection**: First attempts to extract text directly from searchable PDFs using `pdfium2`.
+
+2. **Text Validation**: Extracted text is validated for corruption by checking for:
+
+   - Control and non-printable characters
+   - Unicode replacement characters (�)
+   - Zero-width spaces and other invisible characters
+   - Empty or whitespace-only content
+
+3. **Automatic OCR Fallback**: If the extracted text appears corrupted or if the PDF is image-based, automatically falls back to OCR using Tesseract.
+
+This approach works well for searchable PDFs and standard text documents. For complex OCR (e.g., handwriting, photographs), use a specialized tool.
+
+### PDF Processing Options
+
+You can control PDF processing behavior using optional parameters:
+
+```python
+from kreuzberg import extract_file
+
+
+async def process_pdf():
+  # Default behavior: auto-detect and use OCR if needed
+  # By default, max_processes=1 for safe operation
+  result = await extract_file("document.pdf")
+  print(result.content)
+
+  # Force OCR even for searchable PDFs
+  result = await extract_file("document.pdf", force_ocr=True)
+  print(result.content)
+
+  # Control OCR concurrency for large documents
+  # Warning: High concurrency values can cause system resource exhaustion
+  # Start with a low value and increase based on your system's capabilities
+  result = await extract_file(
+    "large_document.pdf",
+    max_processes=4  # Process up to 4 pages concurrently
+  )
+  print(result.content)
+
+  # Process a scanned PDF (automatically uses OCR)
+  result = await extract_file("scanned.pdf")
+  print(result.content)
+```
+
+### ExtractionResult Object
+
+All extraction functions return an `ExtractionResult` or a list thereof (for batch functions). The `ExtractionResult` object is a `NamedTuple`:
+
+- `content`: The extracted text (str)
+- `mime_type`: Output format ("text/plain" or "text/markdown" for Pandoc conversions)
+- `metadata`: A metadata dictionary. Currently this dictionary is only populated when extracting documents using pandoc.
+
+```python
+from kreuzberg import extract_file, ExtractionResult, Metadata
+
+async def process_document(path: str) -> tuple[str, str, Metadata]:
+    # Access as a named tuple
+    result: ExtractionResult = await extract_file(path)
+    print(f"Content: {result.content}")
+    print(f"Format: {result.mime_type}")
+
+    # Or unpack as a tuple
+    content, mime_type, metadata = await extract_file(path)
+    return content, mime_type, metadata
+```
+
+### Error Handling
+
+Kreuzberg provides comprehensive error handling through several exception types, all inheriting from `KreuzbergError`. Each exception includes helpful context information for debugging.
+
+```python
+from kreuzberg import extract_file
+from kreuzberg.exceptions import (
+    ValidationError,
+    ParsingError,
+    OCRError,
+    MissingDependencyError
+)
+
+async def safe_extract(path: str) -> str:
+    try:
+        result = await extract_file(path)
+        return result.content
+
+    except ValidationError as e:
+        # Input validation issues
+        # - Unsupported or undetectable MIME types
+        # - Missing files
+        # - Invalid input parameters
+        print(f"Validation failed: {e}")
+
+    except OCRError as e:
+        # OCR-specific issues
+        # - Tesseract processing failures
+        # - Image conversion problems
+        print(f"OCR failed: {e}")
+
+    except MissingDependencyError as e:
+        # System dependency issues
+        # - Missing Tesseract OCR
+        # - Missing Pandoc
+        # - Incompatible versions
+        print(f"Dependency missing: {e}")
+
+    except ParsingError as e:
+        # General processing errors
+        # - PDF parsing failures
+        # - Format conversion issues
+        # - Encoding problems
+        print(f"Processing failed: {e}")
+
+    return ""
+```
+
+All exceptions include:
+
+- Error message
+- Context in the `context` attribute
+- String representation
+- Exception chaining
+
+## Contribution
+
+This library is open to contribution. Feel free to open issues or submit PRs. Its better to discuss issues before
+submitting PRs to avoid disappointment.
+
+### Local Development
+
+1. Clone the repo
+2. Install the system dependencies
+3. Install the full dependencies with `uv sync`
+4. Install the pre-commit hooks with:
+
+   ```shell
+   pre-commit install && pre-commit install --hook-type commit-msg
+   ```
+
+5. Make your changes and submit a PR
+
+## License
+
+This library uses the MIT license.

kreuzberg-2.0.0.dist-info/RECORD

@@ -0,0 +1,21 @@
+kreuzberg/__init__.py,sha256=3opnj4Q8Ci151QuVqPaM3sCb8mpFIRhZbZUgBmp1LI0,410
+kreuzberg/_constants.py,sha256=BXICWxbtN-22BEQDcGwCH5rLk3HZObtc9fJim1fXzDA,161
+kreuzberg/_html.py,sha256=lj4GjvCGiUeDcBjotKZuMNNsG3wOuFwP1-bJLsI99YQ,978
+kreuzberg/_mime_types.py,sha256=VFaOozh8o7Xv1d3pa9mObkz7DM8tVsZC_W8hxsMUeb4,6451
+kreuzberg/_pandoc.py,sha256=8sggl4nE-BWLKBecGGPnUX-gfNjnKxX-2SInuWmtWKQ,13763
+kreuzberg/_pdf.py,sha256=V1TVwPpGyrE0YJqnmW_5kh4Y1qWwZI5SSF-lwT_Bbac,6288
+kreuzberg/_pptx.py,sha256=oX1WYabKQ02Hla2jYnkEBjJXCPvrcRnzLi3MeY86TN0,3028
+kreuzberg/_string.py,sha256=Z1c53A1-9JtzNthsnrPENxUaMyPS1VD6Oj3SNagSNgg,1093
+kreuzberg/_sync.py,sha256=3biXw0UDwcaxz-PGmfjWV5JaDE7olFpGKZdG12onxO0,981
+kreuzberg/_tesseract.py,sha256=xt_4MU7PfN1nZWlWBVQF6zmJnMs9pJq8yWTzPUxTqm0,9240
+kreuzberg/_tmp.py,sha256=y0PxKJXsRsDCwpFqtJAMl05lMNu3N_E2yaUVL93h7g0,1037
+kreuzberg/_types.py,sha256=Qxlk6qfdtvEsCfjsXU57qgZiONfwF7wUgbCJK8QXNZ4,2195
+kreuzberg/_xlsx.py,sha256=dDsNwJ_AGjUU5CQ8ExDFbiIYBauc3cEYAD-7zcP3Op0,2850
+kreuzberg/exceptions.py,sha256=pxoEPS0T9e5QSgxsfXn1VmxsY_EGXvTwY0gETPiNn8E,945
+kreuzberg/extraction.py,sha256=1RIs7YaUK0wcOpY1eDcIqh3n-UlJY7ZeulZPdaAxdvo,13345
+kreuzberg/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+kreuzberg-2.0.0.dist-info/LICENSE,sha256=-8caMvpCK8SgZ5LlRKhGCMtYDEXqTKH9X8pFEhl91_4,1066
+kreuzberg-2.0.0.dist-info/METADATA,sha256=cvD9ypz004yHqePKuw8eZZcuZ2lanyN1y2jlB5FMG0Q,14201
+kreuzberg-2.0.0.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+kreuzberg-2.0.0.dist-info/top_level.txt,sha256=rbGkygffkZiyKhL8UN41ZOjLfem0jJPA1Whtndne0rE,10
+kreuzberg-2.0.0.dist-info/RECORD,,

kreuzberg/_extractors.py

@@ -1,247 +0,0 @@
-from __future__ import annotations
-
-import re
-from contextlib import suppress
-from html import escape
-from io import BytesIO
-from pathlib import Path
-from tempfile import NamedTemporaryFile
-from typing import TYPE_CHECKING
-
-import html_to_markdown
-import pptx
-import pypdfium2
-from anyio import Path as AsyncPath
-from pptx.enum.shapes import MSO_SHAPE_TYPE
-from xlsx2csv import Xlsx2csv
-
-from kreuzberg._pandoc import process_content, process_file
-from kreuzberg._string import normalize_spaces, safe_decode
-from kreuzberg._sync import run_sync
-from kreuzberg._tesseract import batch_process_images
-from kreuzberg.exceptions import ParsingError
-
-if TYPE_CHECKING:  # pragma: no cover
-    from PIL.Image import Image
-
-
-async def convert_pdf_to_images(file_path: Path) -> list[Image]:
-    """Convert a PDF file to images.
-
-    Args:
-        file_path: The path to the PDF file.
-
-    Raises:
-        ParsingError: If the PDF file could not be converted to images.
-
-    Returns:
-        A list of Pillow Images.
-    """
-    try:
-        pdf = await run_sync(pypdfium2.PdfDocument, str(file_path))
-        return [page.render(scale=2.0).to_pil() for page in pdf]
-    except pypdfium2.PdfiumError as e:
-        raise ParsingError(
-            "Could not convert PDF to images", context={"file_path": str(file_path), "error": str(e)}
-        ) from e
-
-
-async def extract_pdf_with_tesseract(file_path: Path) -> str:
-    """Extract text from a scanned PDF file using pytesseract.
-
-    Args:
-        file_path: The path to the PDF file.
-
-    Returns:
-        The extracted text.
-    """
-    images = await convert_pdf_to_images(file_path)
-    ocr_results = await batch_process_images(images)
-    return normalize_spaces("\n".join(ocr_results))
-
-
-async def extract_pdf_with_pdfium2(file_path: Path) -> str:
-    """Extract text from a searchable PDF file using pypdfium2.
-
-    Args:
-        file_path: The path to the PDF file.
-
-    Raises:
-        ParsingError: If the text could not be extracted from the PDF file.
-
-    Returns:
-        The extracted text.
-    """
-    try:
-        document = await run_sync(pypdfium2.PdfDocument, file_path)
-        text = "\n".join(page.get_textpage().get_text_range() for page in document)
-        return normalize_spaces(text)
-    except pypdfium2.PdfiumError as e:
-        raise ParsingError(
-            "Could not extract text from PDF file", context={"file_path": str(file_path), "error": str(e)}
-        ) from e
-
-
-async def extract_pdf_file(file_path: Path, force_ocr: bool = False) -> str:
-    """Extract text from a PDF file.
-
-    Args:
-        file_path: The path to the PDF file.
-        force_ocr: Whether or not to force OCR on PDF files that have a text layer. Default = false.
-
-    Returns:
-        The extracted text.
-    """
-    if not force_ocr and (content := await extract_pdf_with_pdfium2(file_path)):
-        return normalize_spaces(content)
-
-    return await extract_pdf_with_tesseract(file_path)
-
-
-async def extract_content_with_pandoc(file_data: bytes, mime_type: str) -> str:
-    """Extract text using pandoc.
-
-    Args:
-        file_data: The content of the file.
-        mime_type: The mime type of the file.
-
-    Returns:
-        The extracted text.
-    """
-    result = await process_content(file_data, mime_type=mime_type)
-    return normalize_spaces(result.content)
-
-
-async def extract_file_with_pandoc(file_path: Path | str, mime_type: str) -> str:
-    """Extract text using pandoc.
-
-    Args:
-        file_path: The path to the file.
-        mime_type: The mime type of the file.
-
-    Returns:
-        The extracted text.
-    """
-    result = await process_file(file_path, mime_type=mime_type)
-    return normalize_spaces(result.content)
-
-
-async def extract_pptx_file(file_path_or_contents: Path | bytes) -> str:
-    """Extract text from a PPTX file.
-
-    Notes:
-        This function is based on code vendored from `markitdown`, which has an MIT license as well.
-
-    Args:
-        file_path_or_contents: The path to the PPTX file or its contents as bytes.
-
-    Returns:
-        The extracted text content
-    """
-    md_content = ""
-    file_contents = (
-        file_path_or_contents
-        if isinstance(file_path_or_contents, bytes)
-        else await AsyncPath(file_path_or_contents).read_bytes()
-    )
-    presentation = pptx.Presentation(BytesIO(file_contents))
-
-    for index, slide in enumerate(presentation.slides):
-        md_content += f"\n\n<!-- Slide number: {index + 1} -->\n"
-
-        title = slide.shapes.title
-
-        for shape in slide.shapes:
-            if shape.shape_type == MSO_SHAPE_TYPE.PICTURE or (
-                shape.shape_type == MSO_SHAPE_TYPE.PLACEHOLDER and hasattr(shape, "image")
-            ):
-                alt_text = ""
-                with suppress(AttributeError):
-                    # access non-visual properties
-                    alt_text = shape._element._nvXxPr.cNvPr.attrib.get("descr", "")  # noqa: SLF001
-
-                filename = re.sub(r"\W", "", shape.name) + ".jpg"
-                md_content += f"\n![{alt_text if alt_text else shape.name}]({filename})\n"
-
-            elif shape.shape_type == MSO_SHAPE_TYPE.TABLE:
-                html_table = "<table>"
-                first_row = True
-
-                for row in shape.table.rows:
-                    html_table += "<tr>"
-
-                    for cell in row.cells:
-                        tag = "th" if first_row else "td"
-                        html_table += f"<{tag}>{escape(cell.text)}</{tag}>"
-
-                    html_table += "</tr>"
-                    first_row = False
-
-                html_table += "</table>"
-                md_content += "\n" + html_table + "\n"
-
-            elif shape.has_text_frame:
-                md_content += "# " + shape.text.lstrip() + "\n" if shape == title else shape.text + "\n"
-
-        md_content = md_content.strip()
-        if slide.has_notes_slide:
-            md_content += "\n\n### Notes:\n"
-            notes_frame = slide.notes_slide.notes_text_frame
-
-            if notes_frame is not None:
-                md_content += notes_frame.text
-
-            md_content = md_content.strip()
-
-    return normalize_spaces(md_content)
-
-
-async def extract_xlsx_file(file_path_or_contents: Path | bytes) -> str:
-    """Extract text from an XLSX file by converting it to CSV and then to markdown.
-
-    Args:
-        file_path_or_contents: The path to the XLSX file or its contents as bytes.
-
-    Returns:
-        The extracted text content.
-
-    Raises:
-        ParsingError: If the XLSX file could not be parsed.
-    """
-    try:
-        with NamedTemporaryFile(suffix=".xlsx") as xlsx_file, NamedTemporaryFile(suffix=".csv") as csv_file:
-            if isinstance(file_path_or_contents, bytes):
-                xlsx_file.write(file_path_or_contents)
-                xlsx_file.flush()
-                xlsx_path = xlsx_file.name
-            else:
-                xlsx_path = str(file_path_or_contents)
-
-            await run_sync(Xlsx2csv(xlsx_path).convert, csv_file.name)
-            result = await process_file(csv_file.name, mime_type="text/csv")
-            return normalize_spaces(result.content)
-    except Exception as e:
-        raise ParsingError(
-            "Could not extract text from XLSX file",
-            context={
-                "error": str(e),
-                "file_path": str(file_path_or_contents) if isinstance(file_path_or_contents, Path) else None,
-            },
-        ) from e
-
-
-async def extract_html_string(file_path_or_contents: Path | bytes) -> str:
-    """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()
-    )
-    return normalize_spaces(await run_sync(html_to_markdown.convert_to_markdown, content))