epub2pdf-cli 0.3.0__py3-none-any.whl

epub2pdf_cli/pdf/extract.py

@@ -0,0 +1,79 @@
+from __future__ import annotations
+
+from collections.abc import Sequence
+from pathlib import Path
+
+from epub2pdf_cli.config import PdfExtractConfig
+from epub2pdf_cli.errors import ExitCode, StageError
+from epub2pdf_cli.pdf.extractors.base import Extractor
+
+
+def run_pdf_extraction(config: PdfExtractConfig, timings: dict[str, float] | None = None) -> list[str]:
+    extractor = _select_extractor(config.engine)
+    options = {
+        "sanitize": config.sanitize,
+        "keep_line_breaks": config.keep_line_breaks,
+        "use_struct_tree": config.use_struct_tree,
+        "table_method": config.table_method,
+        "reading_order": config.reading_order,
+        "markdown_page_separator": config.markdown_page_separator,
+        "html_page_separator": config.html_page_separator,
+        "image_output": config.image_output,
+        "image_dir": config.image_dir,
+        "include_header_footer": config.include_header_footer,
+        "detect_strikethrough": config.detect_strikethrough,
+        "threads": config.threads,
+    }
+    return extractor.extract(
+        config.input_path,
+        config.output_dir,
+        config.formats,
+        pages=config.pages,
+        password=config.password,
+        options={k: v for k, v in options.items() if v is not None},
+        timings=timings,
+    )
+
+
+def _select_extractor(name: str) -> Extractor:
+    from epub2pdf_cli.pdf.extractors.docling_extractor import DoclingExtractor
+    from epub2pdf_cli.pdf.extractors.opendataloader_extractor import OpendataloaderExtractor
+    from epub2pdf_cli.pdf.extractors.pdfplumber_extractor import PdfPlumberExtractor
+    from epub2pdf_cli.pdf.extractors.pypdfium2_extractor import Pypdfium2Extractor
+
+    registry: dict[str, type[Extractor]] = {
+        "pypdfium2": Pypdfium2Extractor,
+        "docling": DoclingExtractor,
+        "pdfplumber": PdfPlumberExtractor,
+        "opendataloader": OpendataloaderExtractor,
+    }
+    cls = registry.get(name)
+    if cls is None:
+        raise StageError("pdf-extract", f"Unsupported extractor: {name}. Choose from {', '.join(registry)}.", exit_code=ExitCode.USAGE)
+    return cls()
+
+
+def find_extract_outputs(input_path: Path, output_dir: Path, formats: Sequence[str]) -> list[str]:
+    outputs = [path for path in planned_extract_paths(input_path, output_dir, formats) if path.exists()]
+    if outputs:
+        return [str(path) for path in outputs]
+    return [str(path) for path in sorted(output_dir.glob(f"{input_path.stem}*")) if path.is_file()]
+
+
+def planned_extract_paths(input_path: Path, output_dir: Path, formats: Sequence[str]) -> list[Path]:
+    extension_map = {
+        "json": ".json",
+        "text": ".txt",
+        "html": ".html",
+        "pdf": ".pdf",
+        "markdown": ".md",
+        "markdown-with-html": ".md",
+        "markdown-with-images": ".md",
+        "tagged-pdf": ".pdf",
+    }
+    planned: list[Path] = []
+    for fmt in formats:
+        suffix = extension_map.get(fmt)
+        if suffix:
+            planned.append(output_dir / f"{input_path.stem}{suffix}")
+    return planned

epub2pdf_cli/pdf/extractors/base.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+
+from collections.abc import Sequence
+from pathlib import Path
+from typing import Any, Protocol, runtime_checkable
+
+
+@runtime_checkable
+class Extractor(Protocol):
+    name: str
+
+    def extract(
+        self,
+        input_path: Path,
+        output_dir: Path,
+        formats: Sequence[str],
+        *,
+        pages: str | None = None,
+        password: str | None = None,
+        options: dict[str, Any] | None = None,
+        timings: dict[str, float] | None = None,
+    ) -> list[str]:
+        ...

epub2pdf_cli/pdf/extractors/docling_extractor.py

@@ -0,0 +1,139 @@
+from __future__ import annotations
+
+import json
+import time
+from collections.abc import Callable, Sequence
+from pathlib import Path
+from typing import Any, TypeVar
+
+from epub2pdf_cli.errors import ExitCode, StageError
+from epub2pdf_cli.pdf.extractors.base import Extractor
+
+T = TypeVar("T")
+
+
+class DoclingExtractor(Extractor):
+    name = "docling"
+
+    def extract(
+        self,
+        input_path: Path,
+        output_dir: Path,
+        formats: Sequence[str],
+        *,
+        pages: str | None = None,
+        password: str | None = None,
+        options: dict[str, Any] | None = None,
+        timings: dict[str, float] | None = None,
+    ) -> list[str]:
+        try:
+            from docling.datamodel.base_models import ConversionStatus
+            from docling.document_converter import DocumentConverter
+        except Exception as exc:
+            raise StageError(
+                "pdf-extract",
+                "Docling is not installed. Install with `python3 -m pip install -e '.[docling]'`.",
+                exit_code=ExitCode.USAGE,
+            ) from exc
+
+        output_dir.mkdir(parents=True, exist_ok=True)
+        base_name = input_path.stem
+
+        converter = DocumentConverter()
+        result, _ = _timed_stage(
+            "convert_document",
+            lambda: converter.convert(str(input_path)),
+            timings,
+        )
+
+        if result.status != ConversionStatus.SUCCESS:
+            raise StageError("pdf-extract", f"Docling conversion status: {result.status.name}")
+
+        outputs: list[str] = []
+
+        if "markdown" in formats:
+            md, _ = _timed_stage("export_markdown", lambda: result.document.export_to_markdown(), timings)
+            path = output_dir / f"{base_name}.md"
+            _timed_stage_void("write_markdown", lambda: path.write_text(md, encoding="utf-8"), timings)
+            outputs.append(str(path))
+
+        if "text" in formats:
+            md, _ = _timed_stage("export_markdown", lambda: result.document.export_to_markdown(), timings)
+            text, _ = _timed_stage("markdown_to_text", lambda: self._markdown_to_text(md), timings)
+            path = output_dir / f"{base_name}.txt"
+            _timed_stage_void("write_text", lambda: path.write_text(text, encoding="utf-8"), timings)
+            outputs.append(str(path))
+
+        if "html" in formats:
+            md, _ = _timed_stage("export_markdown", lambda: result.document.export_to_markdown(), timings)
+            html, _ = _timed_stage("markdown_to_html", lambda: self._markdown_to_html(md), timings)
+            path = output_dir / f"{base_name}.html"
+            _timed_stage_void("write_html", lambda: path.write_text(html, encoding="utf-8"), timings)
+            outputs.append(str(path))
+
+        if "json" in formats:
+            data, _ = _timed_stage("export_to_dict", lambda: result.document.export_to_dict(), timings)
+            path = output_dir / f"{base_name}.json"
+            _timed_stage_void("write_json", lambda: path.write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8"), timings)
+            outputs.append(str(path))
+
+        return outputs
+
+    def _markdown_to_text(self, markdown: str) -> str:
+        # Minimal conversion: strip heading markers and list markers
+        lines = []
+        for line in markdown.splitlines():
+            line = line.lstrip("#> ").lstrip("- ").lstrip("* ")
+            lines.append(line)
+        return "\n".join(lines)
+
+    def _markdown_to_html(self, markdown: str) -> str:
+        from html import escape
+
+        lines = []
+        in_list = False
+        for raw in markdown.splitlines():
+            stripped = raw.strip()
+            if stripped.startswith("# "):
+                text = escape(stripped[2:])
+                lines.append(f"<h1>{text}</h1>")
+            elif stripped.startswith("## "):
+                text = escape(stripped[3:])
+                lines.append(f"<h2>{text}</h2>")
+            elif stripped.startswith("### "):
+                text = escape(stripped[4:])
+                lines.append(f"<h3>{text}</h3>")
+            elif stripped.startswith("- ") or stripped.startswith("* "):
+                if not in_list:
+                    lines.append("<ul>")
+                    in_list = True
+                text = escape(stripped[2:])
+                lines.append(f"<li>{text}</li>")
+            else:
+                if in_list:
+                    lines.append("</ul>")
+                    in_list = False
+                if stripped:
+                    lines.append(f"<p>{escape(stripped)}</p>")
+        if in_list:
+            lines.append("</ul>")
+        body = "\n".join(lines)
+        return f"<!DOCTYPE html>\n<html><body>\n{body}\n</body></html>\n"
+
+
+def _timed_stage(name: str, fn: Callable[[], T], timings: dict[str, float] | None) -> tuple[T, float]:
+    start = time.perf_counter()
+    result = fn()
+    duration = round(time.perf_counter() - start, 3)
+    if timings is not None:
+        timings[name] = duration
+    return result, duration
+
+
+def _timed_stage_void(name: str, fn: Callable[[], object], timings: dict[str, float] | None) -> float:
+    start = time.perf_counter()
+    fn()
+    duration = round(time.perf_counter() - start, 3)
+    if timings is not None:
+        timings[name] = duration
+    return duration

epub2pdf_cli/pdf/extractors/opendataloader_extractor.py

@@ -0,0 +1,86 @@
+from __future__ import annotations
+
+import time
+from collections.abc import Callable, Sequence
+from pathlib import Path
+from typing import Any, TypeVar
+
+from epub2pdf_cli.errors import ExitCode, StageError
+from epub2pdf_cli.pdf.extractors.base import Extractor
+
+T = TypeVar("T")
+
+
+class OpendataloaderExtractor(Extractor):
+    name = "opendataloader"
+
+    def extract(
+        self,
+        input_path: Path,
+        output_dir: Path,
+        formats: Sequence[str],
+        *,
+        pages: str | None = None,
+        password: str | None = None,
+        options: dict[str, Any] | None = None,
+        timings: dict[str, float] | None = None,
+    ) -> list[str]:
+        try:
+            import opendataloader_pdf
+        except Exception as exc:
+            raise StageError(
+                "pdf-extract",
+                "opendataloader-pdf is not installed. Install with `python3 -m pip install -e '.[legacy-pdf]'`.",
+                exit_code=ExitCode.USAGE,
+            ) from exc
+
+        output_dir.mkdir(parents=True, exist_ok=True)
+        opts = options or {}
+        image_dir = opts.get("image_dir")
+
+        def _convert() -> None:
+            opendataloader_pdf.convert(
+                input_path=str(input_path),
+                output_dir=str(output_dir),
+                password=password,
+                format=",".join(formats),
+                quiet=True,
+                sanitize=opts.get("sanitize", False),
+                keep_line_breaks=opts.get("keep_line_breaks", False),
+                use_struct_tree=opts.get("use_struct_tree", False),
+                table_method=opts.get("table_method"),
+                reading_order=opts.get("reading_order"),
+                markdown_page_separator=opts.get("markdown_page_separator"),
+                html_page_separator=opts.get("html_page_separator"),
+                image_output=opts.get("image_output"),
+                image_dir=str(image_dir) if image_dir else None,
+                pages=pages,
+                include_header_footer=opts.get("include_header_footer", False),
+                detect_strikethrough=opts.get("detect_strikethrough", False),
+                threads=opts.get("threads"),
+            )
+
+        _timed_stage_void("opendataloader_convert", _convert, timings)
+
+        from epub2pdf_cli.pdf.extract import find_extract_outputs
+
+        outputs, _ = _timed_stage("find_outputs", lambda: find_extract_outputs(input_path, output_dir, formats), timings)
+        return outputs
+
+
+def _timed_stage(name: str, fn: Callable[[], T], timings: dict[str, float] | None) -> tuple[T, float]:
+    start = time.perf_counter()
+    result = fn()
+    duration = round(time.perf_counter() - start, 3)
+    if timings is not None:
+        timings[name] = duration
+    return result, duration
+
+
+def _timed_stage_void(name: str, fn: Callable[[], object], timings: dict[str, float] | None) -> float:
+    start = time.perf_counter()
+    fn()
+    duration = round(time.perf_counter() - start, 3)
+    if timings is not None:
+        timings[name] = duration
+    return duration

epub2pdf_cli/pdf/extractors/pdfplumber_extractor.py

@@ -0,0 +1,150 @@
+from __future__ import annotations
+
+import json
+import time
+from collections.abc import Callable, Sequence
+from pathlib import Path
+from typing import Any, TypeVar
+
+from epub2pdf_cli.errors import ExitCode, StageError
+from epub2pdf_cli.pdf.extractors.base import Extractor
+
+T = TypeVar("T")
+
+
+class PdfPlumberExtractor(Extractor):
+    name = "pdfplumber"
+
+    def extract(
+        self,
+        input_path: Path,
+        output_dir: Path,
+        formats: Sequence[str],
+        *,
+        pages: str | None = None,
+        password: str | None = None,
+        options: dict[str, Any] | None = None,
+        timings: dict[str, float] | None = None,
+    ) -> list[str]:
+        try:
+            import pdfplumber
+        except Exception as exc:
+            raise StageError(
+                "pdf-extract",
+                "pdfplumber is not installed. Install with `python3 -m pip install -e '.[pdfplumber]'`.",
+                exit_code=ExitCode.USAGE,
+            ) from exc
+
+        output_dir.mkdir(parents=True, exist_ok=True)
+        base_name = input_path.stem
+
+        try:
+            pdf = _timed_stage("open_pdf", lambda: pdfplumber.open(str(input_path), password=password), timings)[0]
+        except Exception as exc:
+            raise StageError("pdf-extract", f"Unable to open PDF: {input_path}") from exc
+
+        with pdf:
+            page_numbers = _parse_page_numbers(pages, len(pdf.pages)) if pages else list(range(1, len(pdf.pages) + 1))
+
+            outputs: list[str] = []
+
+            if "text" in formats or "markdown" in formats or "html" in formats:
+                text, _ = _timed_stage("extract_text", lambda: self._extract_text(pdf, page_numbers), timings)
+                if "text" in formats:
+                    path = output_dir / f"{base_name}.txt"
+                    _timed_stage_void("write_text", lambda: path.write_text(text, encoding="utf-8"), timings)
+                    outputs.append(str(path))
+                if "markdown" in formats:
+                    md, _ = _timed_stage("text_to_markdown", lambda: self._text_to_markdown(text), timings)
+                    path = output_dir / f"{base_name}.md"
+                    _timed_stage_void("write_markdown", lambda: path.write_text(md, encoding="utf-8"), timings)
+                    outputs.append(str(path))
+                if "html" in formats:
+                    html, _ = _timed_stage("text_to_html", lambda: self._text_to_html(text), timings)
+                    path = output_dir / f"{base_name}.html"
+                    _timed_stage_void("write_html", lambda: path.write_text(html, encoding="utf-8"), timings)
+                    outputs.append(str(path))
+
+            if "json" in formats:
+                data, _ = _timed_stage("extract_json", lambda: self._extract_json(pdf, page_numbers), timings)
+                path = output_dir / f"{base_name}.json"
+                _timed_stage_void("write_json", lambda: path.write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8"), timings)
+                outputs.append(str(path))
+
+            return outputs
+
+    def _extract_text(self, pdf: Any, page_numbers: list[int]) -> str:
+        parts: list[str] = []
+        for num in page_numbers:
+            try:
+                page = pdf.pages[num - 1]
+                text = page.extract_text() or ""
+                if text:
+                    parts.append(text)
+            except Exception:
+                continue
+        return "\n\n".join(parts)
+
+    def _text_to_markdown(self, text: str) -> str:
+        lines = []
+        for paragraph in text.split("\n\n"):
+            paragraph = paragraph.strip().replace("\n", " ")
+            if paragraph:
+                lines.append(paragraph)
+                lines.append("")
+        return "\n".join(lines)
+
+    def _text_to_html(self, text: str) -> str:
+        paragraphs = [p.strip().replace("\n", "<br/>") for p in text.split("\n\n") if p.strip()]
+        body = "\n".join(f"<p>{p}</p>" for p in paragraphs)
+        return f"<!DOCTYPE html>\n<html><body>\n{body}\n</body></html>\n"
+
+    def _extract_json(self, pdf: Any, page_numbers: list[int]) -> dict[str, Any]:
+        pages = []
+        for num in page_numbers:
+            try:
+                page = pdf.pages[num - 1]
+                tables = page.extract_tables() or []
+                pages.append({
+                    "page": num,
+                    "text": page.extract_text() or "",
+                    "tables": tables,
+                })
+            except Exception as exc:
+                pages.append({"page": num, "text": "", "tables": [], "error": str(exc)})
+        return {
+            "source": str(pdf.stream.name),
+            "page_count": len(pdf.pages),
+            "extracted_pages": page_numbers,
+            "pages": pages,
+        }
+
+
+def _parse_page_numbers(pages: str, total: int) -> list[int]:
+    numbers: set[int] = set()
+    for part in pages.split(","):
+        part = part.strip()
+        if "-" in part:
+            start, end = part.split("-", 1)
+            numbers.update(range(int(start), int(end) + 1))
+        else:
+            numbers.add(int(part))
+    return sorted(n for n in numbers if 1 <= n <= total)
+
+
+def _timed_stage(name: str, fn: Callable[[], T], timings: dict[str, float] | None) -> tuple[T, float]:
+    start = time.perf_counter()
+    result = fn()
+    duration = round(time.perf_counter() - start, 3)
+    if timings is not None:
+        timings[name] = duration
+    return result, duration
+
+
+def _timed_stage_void(name: str, fn: Callable[[], object], timings: dict[str, float] | None) -> float:
+    start = time.perf_counter()
+    fn()
+    duration = round(time.perf_counter() - start, 3)
+    if timings is not None:
+        timings[name] = duration
+    return duration

epub2pdf_cli/pdf/extractors/pypdfium2_extractor.py

@@ -0,0 +1,151 @@
+from __future__ import annotations
+
+import json
+import time
+from collections.abc import Callable, Sequence
+from pathlib import Path
+from typing import Any, TypeVar
+
+from epub2pdf_cli.errors import ExitCode, StageError
+from epub2pdf_cli.pdf.extractors.base import Extractor
+
+T = TypeVar("T")
+
+
+class Pypdfium2Extractor(Extractor):
+    name = "pypdfium2"
+
+    def extract(
+        self,
+        input_path: Path,
+        output_dir: Path,
+        formats: Sequence[str],
+        *,
+        pages: str | None = None,
+        password: str | None = None,
+        options: dict[str, Any] | None = None,
+        timings: dict[str, float] | None = None,
+    ) -> list[str]:
+        try:
+            import pypdfium2 as pdfium
+        except Exception as exc:
+            raise StageError(
+                "pdf-extract",
+                "pypdfium2 is not installed. Install with `python3 -m pip install pypdfium2`.",
+                exit_code=ExitCode.USAGE,
+            ) from exc
+
+        output_dir.mkdir(parents=True, exist_ok=True)
+        opts: dict[str, Any] = {}
+        if password:
+            opts["password"] = password
+
+        document, _ = _timed_stage("open_pdf", lambda: pdfium.PdfDocument(str(input_path), **opts), timings)
+
+        try:
+            page_indices = _parse_page_range(pages, len(document)) if pages else range(len(document))
+
+            outputs: list[str] = []
+            base_name = input_path.stem
+
+            if "text" in formats or "markdown" in formats or "html" in formats:
+                text, _ = _timed_stage("extract_text", lambda: self._extract_text(document, page_indices), timings)
+                if "text" in formats:
+                    path = output_dir / f"{base_name}.txt"
+                    _timed_stage_void("write_text", lambda: path.write_text(text, encoding="utf-8"), timings)
+                    outputs.append(str(path))
+                if "markdown" in formats:
+                    md, _ = _timed_stage("text_to_markdown", lambda: self._text_to_markdown(text), timings)
+                    path = output_dir / f"{base_name}.md"
+                    _timed_stage_void("write_markdown", lambda: path.write_text(md, encoding="utf-8"), timings)
+                    outputs.append(str(path))
+                if "html" in formats:
+                    html, _ = _timed_stage("text_to_html", lambda: self._text_to_html(text), timings)
+                    path = output_dir / f"{base_name}.html"
+                    _timed_stage_void("write_html", lambda: path.write_text(html, encoding="utf-8"), timings)
+                    outputs.append(str(path))
+
+            if "json" in formats:
+                data, _ = _timed_stage("extract_json", lambda: self._extract_json(document, page_indices), timings)
+                path = output_dir / f"{base_name}.json"
+                _timed_stage_void("write_json", lambda: path.write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8"), timings)
+                outputs.append(str(path))
+
+            return outputs
+        finally:
+            document.close()
+
+    def _extract_text(self, document: Any, page_indices: range) -> str:
+        parts: list[str] = []
+        for idx in page_indices:
+            try:
+                textpage = document[idx].get_textpage()
+                page_text = textpage.get_text_bounded()
+                if page_text:
+                    parts.append(page_text)
+            except Exception:
+                continue
+        return "\n\n".join(parts)
+
+    def _text_to_markdown(self, text: str) -> str:
+        lines = []
+        for paragraph in text.split("\n\n"):
+            paragraph = paragraph.strip().replace("\n", " ")
+            if paragraph:
+                lines.append(paragraph)
+                lines.append("")
+        return "\n".join(lines)
+
+    def _text_to_html(self, text: str) -> str:
+        paragraphs = [p.strip().replace("\n", "<br/>") for p in text.split("\n\n") if p.strip()]
+        body = "\n".join(f"<p>{p}</p>" for p in paragraphs)
+        return f"<!DOCTYPE html>\n<html><body>\n{body}\n</body></html>\n"
+
+    def _extract_json(self, document: Any, page_indices: range) -> dict[str, Any]:
+        pages = []
+        for idx in page_indices:
+            try:
+                textpage = document[idx].get_textpage()
+                text = textpage.get_text_bounded()
+                pages.append({"page": idx + 1, "text": text})
+            except Exception as exc:
+                pages.append({"page": idx + 1, "text": "", "error": str(exc)})
+        return {
+            "source": str(document),
+            "page_count": len(document),
+            "extracted_pages": list(page_indices),
+            "pages": pages,
+        }
+
+
+def _parse_page_range(pages: str, total: int) -> range:
+    indices: set[int] = set()
+    for part in pages.split(","):
+        part = part.strip()
+        if "-" in part:
+            start, end = part.split("-", 1)
+            indices.update(range(int(start) - 1, int(end)))
+        else:
+            indices.add(int(part) - 1)
+    # Clamp and sort
+    valid = sorted(i for i in indices if 0 <= i < total)
+    return range(valid[0], valid[-1] + 1) if valid else range(total)
+
+
+
+def _timed_stage(name: str, fn: Callable[[], T], timings: dict[str, float] | None) -> tuple[T, float]:
+    start = time.perf_counter()
+    result = fn()
+    duration = round(time.perf_counter() - start, 3)
+    if timings is not None:
+        timings[name] = duration
+    return result, duration
+
+
+def _timed_stage_void(name: str, fn: Callable[[], object], timings: dict[str, float] | None) -> float:
+    start = time.perf_counter()
+    fn()
+    duration = round(time.perf_counter() - start, 3)
+    if timings is not None:
+        timings[name] = duration
+    return duration

epub2pdf_cli/pdf/text.py

@@ -0,0 +1,45 @@
+from __future__ import annotations
+
+import shutil
+import subprocess
+from pathlib import Path
+from typing import Any
+
+from pypdf import PdfReader
+
+
+def extract_text(output_path: Path, *, reader: PdfReader | None = None) -> dict[str, Any]:
+    pdftotext_bin = shutil.which("pdftotext")
+    if pdftotext_bin:
+        try:
+            result = subprocess.run(
+                [pdftotext_bin, str(output_path), "-"],
+                check=True,
+                capture_output=True,
+                text=True,
+            )
+            text = result.stdout.strip()
+            return {
+                "has_text": bool(text),
+                "text_length": len(text),
+                "extractor": "pdftotext",
+                "text_sample": text[:240],
+            }
+        except Exception:
+            pass
+
+    if reader is None:
+        reader = PdfReader(str(output_path))
+    text_chunks = []
+    for page in reader.pages:
+        try:
+            text_chunks.append(page.extract_text() or "")
+        except Exception:
+            continue
+    text = "\n".join(text_chunks).strip()
+    return {
+        "has_text": bool(text),
+        "text_length": len(text),
+        "extractor": "pypdf",
+        "text_sample": text[:240],
+    }