parse-anything 0.1.0__tar.gz

parse_anything-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Yugesh
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

parse_anything-0.1.0/PKG-INFO

@@ -0,0 +1,124 @@
+Metadata-Version: 2.4
+Name: parse-anything
+Version: 0.1.0
+Summary: One interface to parse any document: pick an engine (mineru, docling, unstructured, markitdown, lite) and get clean markdown out.
+Author: Yugesh
+License: MIT
+Project-URL: Homepage, https://github.com/yugeshsr13/parse-anything
+Project-URL: Repository, https://github.com/yugeshsr13/parse-anything
+Project-URL: Issues, https://github.com/yugeshsr13/parse-anything/issues
+Keywords: pdf,parsing,ocr,docling,mineru,unstructured,markitdown,paddleocr,tesseract
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Text Processing :: Markup
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: lite
+Requires-Dist: pymupdf4llm>=0.0.17; extra == "lite"
+Provides-Extra: docling
+Requires-Dist: docling>=2.15; extra == "docling"
+Provides-Extra: unstructured
+Requires-Dist: unstructured[all-docs]>=0.16; extra == "unstructured"
+Provides-Extra: markitdown
+Requires-Dist: markitdown[all]>=0.1.1; extra == "markitdown"
+Provides-Extra: mineru
+Requires-Dist: mineru[core]>=2.0; extra == "mineru"
+Provides-Extra: tesseract
+Requires-Dist: pytesseract>=0.3.10; extra == "tesseract"
+Requires-Dist: Pillow>=10.0; extra == "tesseract"
+Requires-Dist: pymupdf>=1.24; extra == "tesseract"
+Provides-Extra: paddle
+Requires-Dist: paddleocr>=3.0; extra == "paddle"
+Requires-Dist: paddlepaddle>=3.0; extra == "paddle"
+Requires-Dist: pymupdf>=1.24; extra == "paddle"
+Provides-Extra: ocr
+Requires-Dist: parse-anything[paddle,tesseract]; extra == "ocr"
+Provides-Extra: all
+Requires-Dist: parse-anything[docling,lite,markitdown,mineru,ocr,unstructured]; extra == "all"
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+Dynamic: license-file
+
+# parse-anything
+
+One interface to parse any document. Pick an engine — **MinerU**, **Docling**, **unstructured**, **MarkItDown**, or the PyMuPDF **lite** path — pass a file path, get clean markdown/text back. OCR runs on **PaddleOCR (PP-OCRv5, default)** or **Tesseract**.
+
+```python
+from parse_anything import parse
+
+result = parse("report.pdf", engine="miner-u")
+print(result.content)          # markdown
+print(result.duration_s)       # seconds
+```
+
+```bash
+parse-anything report.pdf --engine miner-u -o report.md
+parse-anything scan.png  --engine ocr --ocr paddle
+parse-anything deck.pptx                     # auto-picks the best installed engine
+```
+
+## Install
+
+Core has **zero dependencies**; each engine is an optional extra:
+
+```bash
+pip install -e .[all]                        # everything
+pip install -e .[mineru]                     # MinerU (scanned/complex PDFs)
+pip install -e .[docling]                    # Docling (structure fidelity)
+pip install -e .[unstructured]               # unstructured (broadest formats)
+pip install -e .[markitdown]                 # MarkItDown (office/web -> md)
+pip install -e .[lite]                       # PyMuPDF fast path
+pip install -e .[paddle]                     # PaddleOCR (PP-OCRv5)
+pip install -e .[tesseract]                  # pytesseract (+ install the tesseract binary)
+```
+
+Windows Tesseract binary: [UB-Mannheim build](https://github.com/UB-Mannheim/tesseract/wiki) or `choco install tesseract`.
+
+## Engines
+
+| `--engine` | Backed by | Reach for it when |
+|------------|-----------|-------------------|
+| `mineru` / `miner-u` | [MinerU](https://github.com/opendatalab/MinerU) | scanned or complex PDFs — formulas, tables, multi-column; OCR built on PaddleOCR models |
+| `docling` | [Docling](https://github.com/docling-project/docling) | you care about reading order, tables, office formats |
+| `unstructured` | [unstructured](https://github.com/Unstructured-IO/unstructured) | odd formats: email, html, mixed batches |
+| `markitdown` | [MarkItDown](https://github.com/microsoft/markitdown) | fast docx/pptx/xlsx/html → markdown (no OCR) |
+| `lite` / `liteparse` | [PyMuPDF4LLM](https://github.com/pymupdf/RAG) | speed on PDFs that already have a text layer |
+| `ocr` | PaddleOCR / Tesseract | images or fully scanned docs, raw text out |
+| `auto` (default) | — | picks the best installed engine for the file type |
+
+## OCR
+
+`--ocr paddle` (default) uses **PaddleOCR PP-OCRv5** — the current open-source benchmark leader. `--ocr tesseract` is the portable fallback. `--ocr none` skips OCR (text-layer extraction only).
+
+## Logging
+
+Progress prints to stderr by default (auto-selected engine, OCR page-by-page, live MinerU subprocess output with a heartbeat on long runs). `-v` for debug detail, `-q` to silence it. As a library, nothing prints unless you call `logging.basicConfig(...)` yourself.
+
+See [SKILLS.md](SKILLS.md) for the full skill contract (inputs, outputs, failure modes).
+
+## Layout
+
+```
+src/parse_anything/
+├── __init__.py        # parse(path, engine=..., ocr=...) public API
+├── factory.py         # engine registry, aliases, auto-selection
+├── result.py          # ParseResult
+├── cli.py             # parse-anything CLI
+├── engines/           # one module per backend (lazy imports)
+└── ocr/               # paddle + tesseract backends, PDF rasterization
+```
+
+## Tests
+
+```bash
+pip install -e .[dev]
+pytest
+```

parse_anything-0.1.0/README.md

@@ -0,0 +1,75 @@
+# parse-anything
+
+One interface to parse any document. Pick an engine — **MinerU**, **Docling**, **unstructured**, **MarkItDown**, or the PyMuPDF **lite** path — pass a file path, get clean markdown/text back. OCR runs on **PaddleOCR (PP-OCRv5, default)** or **Tesseract**.
+
+```python
+from parse_anything import parse
+
+result = parse("report.pdf", engine="miner-u")
+print(result.content)          # markdown
+print(result.duration_s)       # seconds
+```
+
+```bash
+parse-anything report.pdf --engine miner-u -o report.md
+parse-anything scan.png  --engine ocr --ocr paddle
+parse-anything deck.pptx                     # auto-picks the best installed engine
+```
+
+## Install
+
+Core has **zero dependencies**; each engine is an optional extra:
+
+```bash
+pip install -e .[all]                        # everything
+pip install -e .[mineru]                     # MinerU (scanned/complex PDFs)
+pip install -e .[docling]                    # Docling (structure fidelity)
+pip install -e .[unstructured]               # unstructured (broadest formats)
+pip install -e .[markitdown]                 # MarkItDown (office/web -> md)
+pip install -e .[lite]                       # PyMuPDF fast path
+pip install -e .[paddle]                     # PaddleOCR (PP-OCRv5)
+pip install -e .[tesseract]                  # pytesseract (+ install the tesseract binary)
+```
+
+Windows Tesseract binary: [UB-Mannheim build](https://github.com/UB-Mannheim/tesseract/wiki) or `choco install tesseract`.
+
+## Engines
+
+| `--engine` | Backed by | Reach for it when |
+|------------|-----------|-------------------|
+| `mineru` / `miner-u` | [MinerU](https://github.com/opendatalab/MinerU) | scanned or complex PDFs — formulas, tables, multi-column; OCR built on PaddleOCR models |
+| `docling` | [Docling](https://github.com/docling-project/docling) | you care about reading order, tables, office formats |
+| `unstructured` | [unstructured](https://github.com/Unstructured-IO/unstructured) | odd formats: email, html, mixed batches |
+| `markitdown` | [MarkItDown](https://github.com/microsoft/markitdown) | fast docx/pptx/xlsx/html → markdown (no OCR) |
+| `lite` / `liteparse` | [PyMuPDF4LLM](https://github.com/pymupdf/RAG) | speed on PDFs that already have a text layer |
+| `ocr` | PaddleOCR / Tesseract | images or fully scanned docs, raw text out |
+| `auto` (default) | — | picks the best installed engine for the file type |
+
+## OCR
+
+`--ocr paddle` (default) uses **PaddleOCR PP-OCRv5** — the current open-source benchmark leader. `--ocr tesseract` is the portable fallback. `--ocr none` skips OCR (text-layer extraction only).
+
+## Logging
+
+Progress prints to stderr by default (auto-selected engine, OCR page-by-page, live MinerU subprocess output with a heartbeat on long runs). `-v` for debug detail, `-q` to silence it. As a library, nothing prints unless you call `logging.basicConfig(...)` yourself.
+
+See [SKILLS.md](SKILLS.md) for the full skill contract (inputs, outputs, failure modes).
+
+## Layout
+
+```
+src/parse_anything/
+├── __init__.py        # parse(path, engine=..., ocr=...) public API
+├── factory.py         # engine registry, aliases, auto-selection
+├── result.py          # ParseResult
+├── cli.py             # parse-anything CLI
+├── engines/           # one module per backend (lazy imports)
+└── ocr/               # paddle + tesseract backends, PDF rasterization
+```
+
+## Tests
+
+```bash
+pip install -e .[dev]
+pytest
+```

parse_anything-0.1.0/pyproject.toml

@@ -0,0 +1,55 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "parse-anything"
+version = "0.1.0"
+description = "One interface to parse any document: pick an engine (mineru, docling, unstructured, markitdown, lite) and get clean markdown out."
+readme = "README.md"
+requires-python = ">=3.10"
+license = { text = "MIT" }
+authors = [{ name = "Yugesh" }]
+keywords = ["pdf", "parsing", "ocr", "docling", "mineru", "unstructured", "markitdown", "paddleocr", "tesseract"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Operating System :: OS Independent",
+    "Topic :: Text Processing :: Markup",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+]
+
+# Core is dependency-free: every engine is an optional extra so you only
+# install the (heavy) backends you actually use.
+dependencies = []
+
+[project.urls]
+Homepage = "https://github.com/yugeshsr13/parse-anything"
+Repository = "https://github.com/yugeshsr13/parse-anything"
+Issues = "https://github.com/yugeshsr13/parse-anything/issues"
+
+[project.optional-dependencies]
+lite = ["pymupdf4llm>=0.0.17"]
+docling = ["docling>=2.15"]
+unstructured = ["unstructured[all-docs]>=0.16"]
+markitdown = ["markitdown[all]>=0.1.1"]
+mineru = ["mineru[core]>=2.0"]
+tesseract = ["pytesseract>=0.3.10", "Pillow>=10.0", "pymupdf>=1.24"]
+paddle = ["paddleocr>=3.0", "paddlepaddle>=3.0", "pymupdf>=1.24"]
+ocr = ["parse-anything[tesseract,paddle]"]
+all = ["parse-anything[lite,docling,unstructured,markitdown,mineru,ocr]"]
+dev = ["pytest>=8.0"]
+
+[project.scripts]
+parse-anything = "parse_anything.cli:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

parse_anything-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

parse_anything-0.1.0/src/parse_anything/__init__.py

@@ -0,0 +1,54 @@
+"""parse-anything: one interface over mineru, docling, unstructured, markitdown,
+lite (PyMuPDF) and raw OCR (PaddleOCR / Tesseract).
+
+    from parse_anything import parse
+
+    result = parse("report.pdf", engine="mineru")
+    print(result.content)  # markdown
+"""
+
+import logging
+from pathlib import Path
+
+from .factory import engine_names, get_engine
+from .result import ParseResult
+
+__version__ = "0.1.0"
+
+# Library convention: don't configure handlers here, just make sure "no
+# handlers found" warnings don't show up for callers who haven't set up
+# logging themselves. The CLI (cli.py) calls logging.basicConfig() instead.
+logging.getLogger(__name__).addHandler(logging.NullHandler())
+logger = logging.getLogger(__name__)
+
+
+def parse(
+    path: str | Path,
+    engine: str = "auto",
+    ocr: str = "paddle",
+    **options,
+) -> ParseResult:
+    """Parses a document and returns its extracted content.
+
+    path:    file to parse (pdf, docx, pptx, xlsx, html, images, ...)
+    engine:  "auto" (default), "mineru"/"miner-u", "docling", "unstructured",
+             "markitdown", "lite"/"liteparse", or "ocr"
+    ocr:     "paddle" (default, PP-OCRv5), "tesseract", or "none"
+    options: engine-specific knobs, e.g. strategy="hi_res" (unstructured),
+             force_ocr=True (mineru), dpi=300 (ocr), lang="ch" (ocr backends)
+    """
+    file_path = Path(path)
+    if not file_path.exists():
+        raise FileNotFoundError(f"No such file: {file_path}")
+
+    logger.info("parsing %s (engine=%s, ocr=%s)", file_path.name, engine, ocr)
+    backend = get_engine(engine, path=file_path)
+    result = backend.parse(file_path, ocr=ocr, **options)
+    logger.info(
+        "finished %s: engine=%s ocr=%s %d chars in %.2fs",
+        file_path.name, result.engine, result.ocr, len(result.content), result.duration_s,
+    )
+    return result
+
+
+__all__ = ["parse", "ParseResult", "get_engine", "engine_names", "__version__"]

parse_anything-0.1.0/src/parse_anything/__main__.py

@@ -0,0 +1,3 @@
+from .cli import main
+
+raise SystemExit(main())

parse_anything-0.1.0/src/parse_anything/cli.py

@@ -0,0 +1,104 @@
+import argparse
+import logging
+import sys
+
+from . import __version__, parse
+from .factory import engine_names
+
+logger = logging.getLogger("parse_anything.cli")
+
+
+def build_parser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(
+        prog="parse-anything",
+        description="Parse any document with your engine of choice and print the extracted content.",
+    )
+    p.add_argument("path", nargs="?", help="File to parse (pdf, docx, pptx, html, png, ...)")
+    p.add_argument(
+        "-e", "--engine", default="auto",
+        help="auto | mineru (miner-u) | docling | unstructured | markitdown | lite (liteparse) | ocr",
+    )
+    p.add_argument(
+        "--ocr", default="paddle", choices=["paddle", "tesseract", "none"],
+        help="OCR backend for scanned pages/images (default: paddle / PP-OCRv5)",
+    )
+    p.add_argument("-o", "--output", help="Write result here (.md/.txt for content, .json for full result)")
+    p.add_argument(
+        "-f", "--format", default="content", choices=["content", "json"],
+        help="stdout format: raw extracted content (default) or the full JSON result",
+    )
+    p.add_argument("--strategy", help="unstructured only: fast | hi_res | ocr_only | auto")
+    p.add_argument("--force-ocr", action="store_true", help="mineru only: OCR every page")
+    p.add_argument("--lang", help="OCR language (paddle: en/ch/..., tesseract: eng/deu/...)")
+    p.add_argument("--dpi", type=int, help="ocr engine only: PDF rasterization DPI (default 200)")
+    p.add_argument("--timeout", type=int, default=900, help="mineru timeout in seconds (default 900 / 15 min)")
+    p.add_argument("--list-engines", action="store_true", help="List engines and exit")
+    p.add_argument(
+        "-v", "--verbose", action="count", default=0,
+        help="raise log verbosity to debug (resolved engine names, per-page timing, ...); "
+             "progress logs (auto-selection, mineru output, OCR page progress) print by default",
+    )
+    p.add_argument("-q", "--quiet", action="store_true", help="suppress progress logs, print only errors")
+    p.add_argument("--version", action="version", version=f"%(prog)s {__version__}")
+    return p
+
+
+def _configure_logging(verbose: int, quiet: bool) -> None:
+    if quiet:
+        level = logging.ERROR
+    elif verbose >= 1:
+        level = logging.DEBUG
+    else:
+        level = logging.INFO
+    logging.basicConfig(
+        level=level,
+        format="%(asctime)s %(levelname)-7s %(name)s: %(message)s",
+        datefmt="%H:%M:%S",
+        stream=sys.stderr,
+    )
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = build_parser().parse_args(argv)
+    _configure_logging(args.verbose, args.quiet)
+
+    if args.list_engines:
+        print("\n".join(engine_names()))
+        return 0
+    if not args.path:
+        build_parser().print_help()
+        return 2
+
+    options = {}
+    if args.strategy:
+        options["strategy"] = args.strategy
+    if args.force_ocr:
+        options["force_ocr"] = True
+    if args.lang:
+        options["lang"] = args.lang
+    if args.dpi:
+        options["dpi"] = args.dpi
+    if args.timeout != 900:
+        options["timeout"] = args.timeout
+
+    try:
+        result = parse(args.path, engine=args.engine, ocr=args.ocr, **options)
+    except (FileNotFoundError, ValueError, ImportError, RuntimeError) as exc:
+        logger.error(str(exc))
+        return 1
+
+    if args.output:
+        saved = result.save(args.output)
+        if not args.quiet:
+            print(
+                f"[{result.engine}] {result.path} -> {saved} "
+                f"({len(result.content)} chars, {result.duration_s:.1f}s)",
+                file=sys.stderr,
+            )
+    else:
+        print(result.to_json() if args.format == "json" else result.content)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

parse_anything-0.1.0/src/parse_anything/engines/__init__.py

@@ -0,0 +1,3 @@
+from .base import ParserEngine
+
+__all__ = ["ParserEngine"]

parse_anything-0.1.0/src/parse_anything/engines/base.py

@@ -0,0 +1,34 @@
+from abc import ABC, abstractmethod
+from pathlib import Path
+
+from ..result import ParseResult
+
+
+class ParserEngine(ABC):
+    """Common interface every parsing backend implements.
+
+    Deliberately minimal — file path in, ParseResult out — so callers can swap
+    engines (mineru, docling, unstructured, markitdown, lite) without changing
+    any downstream code.
+    """
+
+    name: str
+
+    #: pip extra that pulls in this engine's dependencies, used in error messages.
+    extra: str
+
+    @abstractmethod
+    def parse(self, path: Path, ocr: str = "paddle", **options) -> ParseResult:
+        """Extracts content from the file.
+
+        ocr: "paddle" (default), "tesseract", or "none". Engines that bundle
+        their own OCR pipeline (mineru) or don't support choosing (markitdown)
+        document how they interpret this.
+        """
+        raise NotImplementedError
+
+    def _missing_dep(self, package: str) -> ImportError:
+        return ImportError(
+            f"Engine '{self.name}' needs '{package}'. "
+            f"Install it with: pip install parse-anything[{self.extra}]"
+        )

parse_anything-0.1.0/src/parse_anything/engines/docling_engine.py

@@ -0,0 +1,99 @@
+import logging
+from pathlib import Path
+
+from ..result import ParseResult, Timer
+from .base import ParserEngine
+
+logger = logging.getLogger(__name__)
+
+
+class DoclingEngine(ParserEngine):
+    """Docling (IBM) — high-fidelity structure extraction (reading order,
+    tables, headings) for PDFs and office formats, exported as markdown.
+
+    OCR backends docling supports natively: easyocr (its default), tesseract,
+    rapidocr. It has no PaddleOCR plugin, so ocr="paddle" falls back to
+    docling's default with a note in metadata — pick engine="mineru" (whose
+    pipeline is built on PaddleOCR models) when paddle-quality OCR matters.
+    """
+
+    name = "docling"
+    extra = "docling"
+
+    def parse(self, path: Path, ocr: str = "paddle", **options) -> ParseResult:
+        try:
+            from docling.document_converter import DocumentConverter
+        except ImportError:
+            raise self._missing_dep("docling") from None
+
+        converter, ocr_used, note = self._build_converter(ocr)
+        if note:
+            logger.warning(note)
+        logger.info("running docling on %s (ocr=%s)", path.name, ocr_used)
+
+        with Timer() as t:
+            result = converter.convert(str(path))
+            content = result.document.export_to_markdown()
+
+        metadata = {"pages": len(getattr(result.document, "pages", []) or [])}
+        if note:
+            metadata["ocr_note"] = note
+        logger.info("docling finished %s: %d pages, %d chars", path.name, metadata["pages"], len(content))
+        return ParseResult(
+            path=str(path),
+            engine=self.name,
+            content=content,
+            format="markdown",
+            ocr=ocr_used,
+            metadata=metadata,
+            duration_s=t.elapsed,
+        )
+
+    def _build_converter(self, ocr: str):
+        from docling.document_converter import DocumentConverter
+
+        if ocr == "tesseract":
+            try:
+                from docling.datamodel.base_models import InputFormat
+                from docling.datamodel.pipeline_options import (
+                    PdfPipelineOptions,
+                    TesseractOcrOptions,
+                )
+                from docling.document_converter import PdfFormatOption
+
+                opts = PdfPipelineOptions()
+                opts.do_ocr = True
+                opts.ocr_options = TesseractOcrOptions()
+                converter = DocumentConverter(
+                    format_options={InputFormat.PDF: PdfFormatOption(pipeline_options=opts)}
+                )
+                return converter, "tesseract", None
+            except ImportError:
+                return (
+                    DocumentConverter(),
+                    "easyocr (docling default)",
+                    "tesseract requested but docling's tesseract option is unavailable",
+                )
+
+        if ocr == "none":
+            try:
+                from docling.datamodel.base_models import InputFormat
+                from docling.datamodel.pipeline_options import PdfPipelineOptions
+                from docling.document_converter import PdfFormatOption
+
+                opts = PdfPipelineOptions()
+                opts.do_ocr = False
+                converter = DocumentConverter(
+                    format_options={InputFormat.PDF: PdfFormatOption(pipeline_options=opts)}
+                )
+                return converter, None, None
+            except ImportError:
+                return DocumentConverter(), None, None
+
+        note = (
+            "docling has no PaddleOCR backend; used its default (easyocr). "
+            "Use engine='mineru' for a PaddleOCR-based pipeline."
+            if ocr in ("paddle", "paddleocr")
+            else None
+        )
+        return DocumentConverter(), "easyocr (docling default)", note

parse_anything-0.1.0/src/parse_anything/engines/lite_engine.py

@@ -0,0 +1,67 @@
+import logging
+from pathlib import Path
+
+from ..ocr import IMAGE_SUFFIXES, get_ocr
+from ..result import ParseResult, Timer
+from .base import ParserEngine
+
+logger = logging.getLogger(__name__)
+
+
+class LiteEngine(ParserEngine):
+    """liteparse — the lightweight, fast path. PyMuPDF-based markdown for PDFs
+    (no ML models, near-instant), direct OCR for images, plain text extraction
+    for everything else PyMuPDF can open (epub, xps, txt).
+
+    Best when documents have a real text layer and speed matters more than
+    layout reconstruction.
+    """
+
+    name = "lite"
+    extra = "lite"
+
+    def parse(self, path: Path, ocr: str = "paddle", **options) -> ParseResult:
+        suffix = path.suffix.lower()
+
+        if suffix in IMAGE_SUFFIXES:
+            if ocr == "none":
+                raise ValueError(f"'{path.name}' is an image; lite needs ocr='paddle' or 'tesseract' for images.")
+            logger.info("lite: routing image %s to OCR backend '%s'", path.name, ocr)
+            backend = get_ocr(ocr, lang=options.get("lang"))
+            with Timer() as t:
+                text, meta = backend.parse_file(path)
+            return ParseResult(
+                path=str(path), engine=self.name, content=text, format="text",
+                ocr=backend.name, metadata=meta, duration_s=t.elapsed,
+            )
+
+        if suffix == ".pdf":
+            try:
+                import pymupdf4llm
+            except ImportError:
+                raise self._missing_dep("pymupdf4llm") from None
+            logger.info("lite: extracting text layer from %s via pymupdf4llm", path.name)
+            with Timer() as t:
+                content = pymupdf4llm.to_markdown(str(path))
+            logger.info("lite: finished %s, %d chars in %.2fs", path.name, len(content), t.elapsed)
+            return ParseResult(
+                path=str(path), engine=self.name, content=content, format="markdown",
+                ocr=None, metadata={}, duration_s=t.elapsed,
+            )
+
+        # Anything else PyMuPDF understands (epub, xps, cbz, txt...)
+        try:
+            import pymupdf as fitz
+        except ImportError:
+            try:
+                import fitz
+            except ImportError:
+                raise self._missing_dep("pymupdf") from None
+        with Timer() as t:
+            with fitz.open(str(path)) as doc:
+                page_count = doc.page_count
+                content = "\n\n".join(page.get_text() for page in doc)
+        return ParseResult(
+            path=str(path), engine=self.name, content=content, format="text",
+            ocr=None, metadata={"pages": page_count}, duration_s=t.elapsed,
+        )