epub2pdf-cli 0.3.0__py3-none-any.whl

epub2pdf_cli/pdf/validate.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+from pypdf import PdfReader
+
+from epub2pdf_cli.errors import StageError
+from epub2pdf_cli.pdf.text import extract_text
+
+
+def validate_pdf(output_path: Path, *, expect_text: bool) -> dict[str, Any]:
+    if not output_path.exists():
+        raise StageError("validate", f"Output PDF was not created: {output_path}")
+    if output_path.stat().st_size == 0:
+        raise StageError("validate", f"Output PDF is empty: {output_path}")
+
+    try:
+        reader = PdfReader(str(output_path))
+    except Exception as exc:
+        raise StageError("validate", f"Unable to read output PDF: {output_path}") from exc
+
+    page_count = len(reader.pages)
+    if page_count <= 0:
+        raise StageError("validate", "Output PDF does not contain any pages")
+
+    extraction = extract_text(output_path, reader=reader)
+    if expect_text and not extraction["has_text"]:
+        raise StageError("validate", "Output PDF does not contain extractable text")
+
+    return {
+        "page_count": page_count,
+        "has_text": extraction["has_text"],
+        "text_length": extraction["text_length"],
+        "extractor": extraction["extractor"],
+        "text_sample": extraction["text_sample"],
+    }

epub2pdf_cli/pipeline/__init__.py

@@ -0,0 +1,6 @@
+from epub2pdf_cli.pipeline.batch import batch_convert
+from epub2pdf_cli.pipeline.convert import convert_epub
+from epub2pdf_cli.pipeline.extract import extract_pdf
+from epub2pdf_cli.pipeline.inspect import inspect_epub
+
+__all__ = ["inspect_epub", "convert_epub", "extract_pdf", "batch_convert"]

epub2pdf_cli/pipeline/batch.py

@@ -0,0 +1,84 @@
+"""Batch conversion pipeline with optional process-level parallelism."""
+
+from __future__ import annotations
+
+import logging
+import time
+from concurrent.futures import ProcessPoolExecutor
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+from epub2pdf_cli.config import BatchConfig, ConvertConfig
+from epub2pdf_cli.errors import Epub2PdfError
+from epub2pdf_cli.pipeline.convert import convert_epub
+
+LOGGER = logging.getLogger(__name__)
+
+
+def batch_convert(config: BatchConfig) -> dict[str, Any]:
+    """Convert multiple EPUBs in parallel using separate worker processes."""
+    config.output_dir.mkdir(parents=True, exist_ok=True)
+
+    jobs = [_build_convert_config(path, config) for path in config.input_paths]
+    start = time.perf_counter()
+
+    if config.workers == 1:
+        results = [_convert_one(job) for job in jobs]
+    else:
+        with ProcessPoolExecutor(max_workers=config.workers) as executor:
+            results = list(executor.map(_convert_one, jobs))
+
+    total_time = round(time.perf_counter() - start, 3)
+    successes = sum(1 for r in results if "error" not in r)
+    failures = len(results) - successes
+
+    LOGGER.info(
+        "Batch conversion finished: %d succeeded, %d failed, %.3fs total",
+        successes,
+        failures,
+        total_time,
+    )
+
+    return {
+        "engine": config.engine,
+        "workers": config.workers,
+        "output_dir": str(config.output_dir),
+        "total_time": total_time,
+        "successes": successes,
+        "failures": failures,
+        "results": results,
+        "completed_at": datetime.now(timezone.utc).isoformat(),
+    }
+
+
+def _build_convert_config(input_path: Path, batch_config: BatchConfig) -> ConvertConfig:
+    stem = input_path.stem
+    output_path = batch_config.output_dir / f"{stem}.pdf"
+    return ConvertConfig(
+        input_path=input_path,
+        output_path=output_path,
+        engine=batch_config.engine,
+        sidecar_json_path=(batch_config.output_dir / f"{stem}.json") if batch_config.sidecar_json else None,
+        sidecar_html_path=(batch_config.output_dir / f"{stem}.html") if batch_config.sidecar_html else None,
+        sidecar_markdown_path=(batch_config.output_dir / f"{stem}.md") if batch_config.sidecar_markdown else None,
+        page_size=batch_config.page_size,
+        margin_mm=batch_config.margin_mm,
+        cover=batch_config.cover,
+        validate=batch_config.validate,
+        force=batch_config.force,
+        verbose=batch_config.verbose,
+    )
+
+
+def _convert_one(convert_config: ConvertConfig) -> dict[str, Any]:
+    try:
+        return convert_epub(convert_config)
+    except Epub2PdfError as exc:
+        LOGGER.warning("Conversion failed for %s: %s", convert_config.input_path, exc)
+        return {
+            "source": {"path": str(convert_config.input_path)},
+            "output": {"path": str(convert_config.output_path), "error": str(exc)},
+            "error": str(exc),
+            "exit_code": exc.exit_code,
+        }

epub2pdf_cli/pipeline/convert.py

@@ -0,0 +1,122 @@
+from __future__ import annotations
+
+import logging
+import time
+from collections.abc import Callable
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, TypeVar
+
+from epub2pdf_cli.config import ConvertConfig
+from epub2pdf_cli.epub import read_epub
+from epub2pdf_cli.errors import ExitCode, StageError
+from epub2pdf_cli.html.builder import build_html
+from epub2pdf_cli.io_utils import sha256, write_json, write_text
+from epub2pdf_cli.markdown import build_markdown
+from epub2pdf_cli.pdf import validate_pdf
+from epub2pdf_cli.render import ENGINES
+from epub2pdf_cli.render.options import RenderOptions
+from epub2pdf_cli.render.protocol import Renderer
+
+LOGGER = logging.getLogger(__name__)
+
+T = TypeVar("T")
+
+
+def convert_epub(config: ConvertConfig, engine: Renderer | None = None) -> dict[str, Any]:
+    _check_output_path(config.output_path, force=config.force)
+
+    timings: dict[str, float] = {}
+
+    book, timings["read_epub"] = _timed_stage("read_epub", lambda: read_epub(config.input_path))
+
+    build_result, timings["build_html"] = _timed_stage("build_html", lambda: build_html(book, config))
+
+    if config.sidecar_markdown_path:
+        markdown_path = config.sidecar_markdown_path
+        timings["markdown"] = _timed_stage_void(
+            "markdown",
+            lambda: write_text(markdown_path, build_markdown(book)),
+        )
+
+    render_options = RenderOptions(
+        output_path=config.output_path,
+        page_size=config.page_size,
+        margin_mm=config.margin_mm,
+        cover=config.cover,
+        title=book.metadata.get("title") or "Untitled EPUB",
+    )
+
+    config.output_path.parent.mkdir(parents=True, exist_ok=True)
+    if engine is None:
+        try:
+            engine = ENGINES[config.engine]()
+        except KeyError as exc:
+            raise StageError(
+                "convert",
+                f"Rendering engine '{config.engine}' is not installed. "
+                f"Install with `python3 -m pip install -e '.[{config.engine}]'`.",
+                exit_code=ExitCode.USAGE,
+            ) from exc
+    _, timings["render"] = _timed_stage("render", lambda: engine.render(build_result.html, render_options))
+
+    if config.validate:
+        validation, timings["validate_pdf"] = _timed_stage(
+            "validate_pdf",
+            lambda: validate_pdf(config.output_path, expect_text=True),
+        )
+    else:
+        validation = None
+        timings["validate_pdf"] = 0.0
+
+    if config.sidecar_html_path:
+        write_text(config.sidecar_html_path, build_result.html)
+
+    report: dict[str, Any] = {
+        "source": {
+            "path": str(config.input_path),
+            "sha256": sha256(config.input_path),
+        },
+        "output": {
+            "path": str(config.output_path),
+            "engine": config.engine,
+            "validation": validation,
+            "timings": timings,
+        },
+        "html": {
+            "chapters": build_result.chapters,
+            "assets": build_result.assets,
+            "warnings": build_result.warnings,
+        },
+        "converted_at": datetime.now(timezone.utc).isoformat(),
+    }
+
+    if config.sidecar_json_path:
+        write_json(config.sidecar_json_path, report)
+
+    return report
+
+
+def _check_output_path(output_path: Path, *, force: bool) -> None:
+    if output_path.exists() and not force:
+        raise StageError(
+            "convert",
+            f"Output already exists: {output_path}. Use --force to overwrite.",
+            exit_code=ExitCode.OUTPUT_EXISTS,
+        )
+
+
+def _timed_stage(name: str, fn: Callable[[], T]) -> tuple[T, float]:
+    start = time.perf_counter()
+    result = fn()
+    duration = round(time.perf_counter() - start, 3)
+    LOGGER.info("Stage %s took %.3fs", name, duration)
+    return result, duration
+
+
+def _timed_stage_void(name: str, fn: Callable[[], None]) -> float:
+    start = time.perf_counter()
+    fn()
+    duration = round(time.perf_counter() - start, 3)
+    LOGGER.info("Stage %s took %.3fs", name, duration)
+    return duration

epub2pdf_cli/pipeline/extract.py

@@ -0,0 +1,64 @@
+from __future__ import annotations
+
+import logging
+import time
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+from epub2pdf_cli.config import PdfExtractConfig
+from epub2pdf_cli.errors import ExitCode, StageError
+from epub2pdf_cli.io_utils import sha256, write_json
+from epub2pdf_cli.pdf.extract import planned_extract_paths, run_pdf_extraction
+
+LOGGER = logging.getLogger(__name__)
+
+
+def extract_pdf(config: PdfExtractConfig) -> dict[str, Any]:
+    _check_input_path(config.input_path, suffix=".pdf")
+    _check_extract_outputs(config)
+
+    timings: dict[str, float] = {}
+    start = time.perf_counter()
+    outputs = run_pdf_extraction(config, timings=timings)
+    timings["pdf-extract"] = round(time.perf_counter() - start, 3)
+    LOGGER.info("Stage pdf-extract took %.3fs", timings["pdf-extract"])
+
+    if not outputs:
+        raise StageError("pdf-extract", f"No extraction outputs were created in: {config.output_dir}")
+
+    report: dict[str, Any] = {
+        "source": {
+            "path": str(config.input_path),
+            "sha256": sha256(config.input_path),
+            "extracted_at": datetime.now(timezone.utc).isoformat(),
+        },
+        "formats": config.formats,
+        "output_dir": str(config.output_dir),
+        "outputs": outputs,
+        "engine": config.engine,
+        "mode": "local",
+        "timings": timings,
+    }
+
+    if config.sidecar_json_path:
+        write_json(config.sidecar_json_path, report)
+
+    return report
+
+
+def _check_input_path(path: Path, *, suffix: str) -> None:
+    if not path.exists():
+        raise StageError("pdf-extract", f"Input file does not exist: {path}", exit_code=ExitCode.USAGE)
+    if path.suffix.lower() != suffix:
+        raise StageError("pdf-extract", f"Expected a {suffix} input file: {path}", exit_code=ExitCode.USAGE)
+
+
+def _check_extract_outputs(config: PdfExtractConfig) -> None:
+    if config.force:
+        return
+    planned = planned_extract_paths(config.input_path, config.output_dir, list(config.formats))
+    existing = [path for path in planned if path.exists()]
+    if existing:
+        formatted = ", ".join(str(path) for path in existing)
+        raise StageError("pdf-extract", f"Output already exists: {formatted}. Use --force to overwrite.", exit_code=ExitCode.OUTPUT_EXISTS)

epub2pdf_cli/pipeline/inspect.py

@@ -0,0 +1,15 @@
+from __future__ import annotations
+
+from typing import Any
+
+from epub2pdf_cli.config import InspectConfig
+from epub2pdf_cli.epub import read_epub
+from epub2pdf_cli.io_utils import write_json
+
+
+def inspect_epub(config: InspectConfig) -> dict[str, Any]:
+    book = read_epub(config.input_path)
+    report = book.to_inspection_dict()
+    if config.json_path:
+        write_json(config.json_path, report)
+    return report

epub2pdf_cli/render/__init__.py

@@ -0,0 +1,17 @@
+from epub2pdf_cli.render.options import RenderOptions
+from epub2pdf_cli.render.protocol import Renderer
+from epub2pdf_cli.render.weasyprint import WeasyPrintEngine
+
+ENGINES: dict[str, type[Renderer]] = {
+    "weasyprint": WeasyPrintEngine,
+}
+
+try:
+    from epub2pdf_cli.render.playwright import PlaywrightEngine
+except Exception:
+    PlaywrightEngine = None  # type: ignore[misc,assignment]
+
+if PlaywrightEngine is not None:
+    ENGINES["playwright"] = PlaywrightEngine
+
+__all__ = ["Renderer", "RenderOptions", "WeasyPrintEngine", "ENGINES"]

epub2pdf_cli/render/options.py

@@ -0,0 +1,19 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+
+from epub2pdf_cli.config import CoverMode, PageSize
+
+
+@dataclass(frozen=True, slots=True)
+class RenderOptions:
+    output_path: Path
+    page_size: PageSize
+    margin_mm: int
+    cover: CoverMode
+    title: str = ""
+
+    def __post_init__(self) -> None:
+        if self.margin_mm < 0:
+            raise ValueError("margin_mm must be non-negative")

epub2pdf_cli/render/playwright.py

@@ -0,0 +1,91 @@
+from __future__ import annotations
+
+from contextlib import suppress
+from typing import Any
+
+from playwright.sync_api import Browser, sync_playwright
+from playwright.sync_api import TimeoutError as PlaywrightTimeoutError
+
+from epub2pdf_cli.errors import StageError
+from epub2pdf_cli.render.options import RenderOptions
+
+DEFAULT_TIMEOUT_MS = 120_000
+
+
+class PlaywrightEngine:
+    name = "playwright"
+
+    def __init__(self, timeout_ms: int = DEFAULT_TIMEOUT_MS, *, browser: Browser | None = None) -> None:
+        self.timeout_ms = timeout_ms
+        self._provided_browser = browser
+        self._owned_browser: Browser | None = None
+        self._owned_playwright: Any | None = None
+
+    def render(self, html: str, options: RenderOptions) -> None:
+        browser = self._provided_browser
+        own_browser = False
+        if browser is None:
+            browser, own_browser = self._launch_browser()
+        try:
+            page = browser.new_page()
+            try:
+                page.set_default_timeout(self.timeout_ms)
+                page.set_content(html, wait_until="load")
+                page.emulate_media(media="print")
+                page.pdf(
+                    path=str(options.output_path),
+                    format=options.page_size,
+                    print_background=True,
+                    prefer_css_page_size=True,
+                    margin={
+                        "top": f"{options.margin_mm}mm",
+                        "bottom": f"{options.margin_mm}mm",
+                        "left": f"{options.margin_mm}mm",
+                        "right": f"{options.margin_mm}mm",
+                    },
+                    tagged=True,
+                    outline=False,
+                )
+            finally:
+                page.close()
+        except PlaywrightTimeoutError as exc:
+            raise StageError(
+                "render",
+                f"Playwright rendering timed out after {self.timeout_ms}ms.",
+            ) from exc
+        except Exception as exc:
+            raise StageError(
+                "render",
+                "Playwright rendering failed. Ensure `playwright install chromium` has been run.",
+            ) from exc
+        finally:
+            if own_browser:
+                self._close_owned_browser()
+
+    def _launch_browser(self) -> tuple[Browser, bool]:
+        try:
+            self._owned_playwright = sync_playwright().start()
+            self._owned_browser = self._owned_playwright.chromium.launch()
+            return self._owned_browser, True
+        except Exception as exc:
+            self._close_owned_browser()
+            raise StageError(
+                "render",
+                "Playwright failed to launch Chromium. Ensure `playwright install chromium` has been run.",
+            ) from exc
+
+    def _close_owned_browser(self) -> None:
+        if self._owned_browser:
+            with suppress(Exception):
+                self._owned_browser.close()
+            self._owned_browser = None
+        if self._owned_playwright:
+            with suppress(Exception):
+                self._owned_playwright.stop()
+            self._owned_playwright = None
+
+    def __enter__(self) -> PlaywrightEngine:
+        return self
+
+    def __exit__(self, *exc: Any) -> None:
+        self._close_owned_browser()

epub2pdf_cli/render/protocol.py

@@ -0,0 +1,13 @@
+from __future__ import annotations
+
+from typing import Protocol, runtime_checkable
+
+from epub2pdf_cli.render.options import RenderOptions
+
+
+@runtime_checkable
+class Renderer(Protocol):
+    name: str
+
+    def render(self, html: str, options: RenderOptions) -> None:
+        ...

epub2pdf_cli/render/weasyprint.py

@@ -0,0 +1,28 @@
+from __future__ import annotations
+
+from epub2pdf_cli.errors import ExitCode, StageError
+from epub2pdf_cli.render.options import RenderOptions
+
+
+class WeasyPrintEngine:
+    name = "weasyprint"
+
+    def render(self, html: str, options: RenderOptions) -> None:
+        try:
+            from weasyprint import HTML
+        except Exception as exc:
+            raise StageError(
+                "render",
+                "WeasyPrint is not installed. Install with `python3 -m pip install -e '.[weasyprint]'`.",
+                exit_code=ExitCode.USAGE,
+            ) from exc
+
+        try:
+            HTML(string=html).write_pdf(
+                str(options.output_path),
+                size=options.page_size,
+                margin=f"{options.margin_mm}mm",
+                title=options.title or None,
+            )
+        except Exception as exc:
+            raise StageError("render", "WeasyPrint rendering failed.") from exc