epub2pdf-cli 0.3.0__py3-none-any.whl

epub2pdf_cli/__init__.py

@@ -0,0 +1,5 @@
+"""epub2pdf package."""
+
+__all__ = ["__version__"]
+
+__version__ = "0.3.0"

epub2pdf_cli/__main__.py

@@ -0,0 +1,4 @@
+from epub2pdf_cli.cli import main
+
+if __name__ == "__main__":
+    raise SystemExit(main())

epub2pdf_cli/api.py

@@ -0,0 +1,160 @@
+"""Programmatic API for epub2pdf.
+
+The :class:`Epub2Pdf` client provides a reusable context manager. When the
+``playwright`` engine is selected, the browser instance is launched once and
+reused across conversions, avoiding per-call launch overhead.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Iterable
+from concurrent.futures import ProcessPoolExecutor
+from contextlib import suppress
+from pathlib import Path
+from types import TracebackType
+from typing import Any
+
+from epub2pdf_cli.config import ConvertConfig, EngineName, PageSize
+from epub2pdf_cli.pipeline.batch import _convert_one
+from epub2pdf_cli.pipeline.convert import convert_epub
+from epub2pdf_cli.render.playwright import PlaywrightEngine
+from epub2pdf_cli.render.protocol import Renderer
+
+
+class Epub2Pdf:
+    """High-level client for converting EPUB files to PDF.
+
+    Use as a context manager when ``engine="playwright"`` to keep a single
+    browser process alive for multiple conversions:
+
+        with Epub2Pdf(engine="playwright") as client:
+            report1 = client.convert("a.epub", "a.pdf")
+            report2 = client.convert("b.epub", "b.pdf")
+
+    The WeasyPrint engine does not require context-manager entry.
+    """
+
+    def __init__(
+        self,
+        engine: EngineName = "weasyprint",
+        *,
+        page_size: PageSize = "A4",
+        margin_mm: int = 12,
+        cover: str = "first",
+        validate: bool = True,
+        verbose: bool = False,
+        **defaults: Any,
+    ) -> None:
+        self.engine = engine
+        self.page_size = page_size
+        self.margin_mm = margin_mm
+        self.cover = cover
+        self.validate = validate
+        self.verbose = verbose
+        self._defaults = defaults
+        self._browser: Any | None = None
+        self._playwright: Any | None = None
+
+    def __enter__(self) -> Epub2Pdf:
+        if self.engine == "playwright":
+            self._start_browser()
+        return self
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc: BaseException | None,
+        tb: TracebackType | None,
+    ) -> None:
+        self.close()
+
+    def close(self) -> None:
+        """Release any pooled browser resources."""
+        if self._browser is not None:
+            with suppress(Exception):
+                self._browser.close()
+            self._browser = None
+        if self._playwright is not None:
+            with suppress(Exception):
+                self._playwright.stop()
+            self._playwright = None
+
+    def _start_browser(self) -> None:
+        try:
+            from playwright.sync_api import sync_playwright
+        except Exception as exc:
+            raise RuntimeError(
+                "Playwright is not installed. Install with `python3 -m pip install -e '.[playwright]'`."
+            ) from exc
+
+        try:
+            self._playwright = sync_playwright().start()
+            self._browser = self._playwright.chromium.launch()
+        except Exception as exc:
+            self.close()
+            raise RuntimeError(
+                "Playwright failed to launch Chromium. Ensure `playwright install chromium` has been run."
+            ) from exc
+
+    def convert(
+        self,
+        input_path: Path | str,
+        output_path: Path | str,
+        **kwargs: Any,
+    ) -> dict[str, Any]:
+        """Convert a single EPUB to PDF.
+
+        Keyword arguments override the client's default settings for this call.
+        """
+        config = self._build_config(input_path, output_path, **kwargs)
+        engine = self._render_engine()
+        return convert_epub(config, engine=engine)
+
+    def batch_convert(
+        self,
+        jobs: Iterable[tuple[Path | str, Path | str]],
+        max_workers: int = 1,
+        **kwargs: Any,
+    ) -> list[dict[str, Any]]:
+        """Convert multiple EPUBs.
+
+        When ``max_workers`` is greater than 1, worker processes are used. For
+        Playwright this means each worker starts its own browser; the client's
+        pooled browser is only reused when ``max_workers`` is 1.
+
+        Returns a list of conversion reports in the same order as ``jobs``.
+        """
+        configs = [self._build_config(input_path, output_path, **kwargs) for input_path, output_path in jobs]
+        if max_workers == 1:
+            engine = self._render_engine()
+            return [convert_epub(config, engine=engine) for config in configs]
+
+        with ProcessPoolExecutor(max_workers=max_workers) as executor:
+            return list(executor.map(_convert_one, configs))
+
+    def _render_engine(self) -> Renderer | None:
+        if self.engine == "playwright" and self._browser is not None:
+            return PlaywrightEngine(browser=self._browser)
+        return None
+
+    def _build_config(
+        self,
+        input_path: Path | str,
+        output_path: Path | str,
+        **kwargs: Any,
+    ) -> ConvertConfig:
+        merged = {
+            "page_size": self.page_size,
+            "margin_mm": self.margin_mm,
+            "cover": self.cover,
+            "validate": self.validate,
+            "verbose": self.verbose,
+            **self._defaults,
+            **kwargs,
+        }
+        return ConvertConfig(
+            input_path=Path(input_path),
+            output_path=Path(output_path),
+            engine=self.engine,
+            **merged,
+        )

epub2pdf_cli/cli.py

@@ -0,0 +1,223 @@
+from __future__ import annotations
+
+import argparse
+import json
+import logging
+import sys
+from collections.abc import Sequence
+from pathlib import Path
+
+from epub2pdf_cli import __version__
+from epub2pdf_cli.config import (
+    BatchConfig,
+    ConvertConfig,
+    InspectConfig,
+    PdfExtractConfig,
+    PdfExtractFormat,
+)
+from epub2pdf_cli.errors import Epub2PdfError, ExitCode
+from epub2pdf_cli.pipeline import batch_convert, convert_epub, extract_pdf, inspect_epub
+
+PDF_EXTRACT_FORMATS: tuple[PdfExtractFormat, ...] = (
+    "markdown",
+    "json",
+    "text",
+    "html",
+    "markdown-with-html",
+    "markdown-with-images",
+    "tagged-pdf",
+)
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(prog="epub2pdf", description="Convert EPUB files into machine-readable PDFs.")
+    parser.add_argument("--version", action="version", version=f"%(prog)s {__version__}")
+    subparsers = parser.add_subparsers(dest="command", required=True)
+
+    convert_parser = subparsers.add_parser("convert", help="Render an EPUB into PDF.")
+    convert_parser.add_argument("input", help="Path to the input .epub file.")
+    convert_parser.add_argument("-o", "--output", help="Path to the output PDF. Defaults to the input basename with .pdf.")
+    convert_parser.add_argument("--engine", choices=("playwright", "weasyprint"), default="weasyprint", help="Rendering backend. Default: weasyprint.")
+    convert_parser.add_argument("--sidecar-json", help="Write structured conversion output JSON to this path.")
+    convert_parser.add_argument("--sidecar-html", help="Write the normalized merged HTML to this path.")
+    convert_parser.add_argument("--sidecar-markdown", help="Write a Markdown version of the EPUB to this path.")
+    convert_parser.add_argument("--page-size", choices=("A4", "Letter"), default="A4")
+    convert_parser.add_argument("--margin-mm", type=int, default=12)
+    convert_parser.add_argument("--cover", choices=("first", "none"), default="first")
+    convert_parser.add_argument("--no-validate", action="store_true", help="Skip PDF validation after rendering.")
+    convert_parser.add_argument("--force", action="store_true", help="Overwrite the output file if it already exists.")
+    convert_parser.add_argument("--verbose", action="store_true", help="Enable verbose logs.")
+
+    batch_parser = subparsers.add_parser("batch", help="Convert multiple EPUBs in parallel.")
+    batch_parser.add_argument("inputs", nargs="+", help="Paths to input .epub files.")
+    batch_parser.add_argument("-o", "--output-dir", required=True, help="Directory for output PDFs.")
+    batch_parser.add_argument("--engine", choices=("playwright", "weasyprint"), default="weasyprint", help="Rendering backend. Default: weasyprint.")
+    batch_parser.add_argument("-j", "--workers", type=int, default=1, help="Number of parallel worker processes. Default: 1.")
+    batch_parser.add_argument("--sidecar-json", action="store_true", help="Write a JSON report next to each PDF.")
+    batch_parser.add_argument("--sidecar-html", action="store_true", help="Write merged HTML next to each PDF.")
+    batch_parser.add_argument("--sidecar-markdown", action="store_true", help="Write Markdown next to each PDF.")
+    batch_parser.add_argument("--page-size", choices=("A4", "Letter"), default="A4")
+    batch_parser.add_argument("--margin-mm", type=int, default=12)
+    batch_parser.add_argument("--cover", choices=("first", "none"), default="first")
+    batch_parser.add_argument("--no-validate", action="store_true", help="Skip PDF validation after rendering.")
+    batch_parser.add_argument("--force", action="store_true", help="Overwrite existing output files.")
+    batch_parser.add_argument("--verbose", action="store_true", help="Enable verbose logs.")
+
+    inspect_parser = subparsers.add_parser("inspect", help="Inspect EPUB metadata, manifest, spine, and TOC.")
+    inspect_parser.add_argument("input", help="Path to the input .epub file.")
+    inspect_parser.add_argument("--json", help="Write inspection output JSON to this path. Defaults to stdout.")
+    inspect_parser.add_argument("--verbose", action="store_true", help="Enable verbose logs.")
+
+    pdf_parser = subparsers.add_parser("pdf-extract", help="Extract Markdown/JSON/HTML from a PDF.")
+    pdf_parser.add_argument("input", help="Path to the input .pdf file.")
+    pdf_parser.add_argument("-o", "--output-dir", help="Directory for extracted files. Defaults to <pdf-stem>_extracted.")
+    pdf_parser.add_argument("--engine", choices=("pypdfium2", "docling", "pdfplumber", "opendataloader"), default="pypdfium2", help="Extraction backend. Default: pypdfium2.")
+    pdf_parser.add_argument(
+        "--format",
+        default="markdown,json",
+        help="Comma-separated output formats. Default: markdown,json.",
+    )
+    pdf_parser.add_argument("--pages", help='Pages to extract, for example "1,3,5-7".')
+    pdf_parser.add_argument("--password", help="Password for encrypted PDF files.")
+    pdf_parser.add_argument("--use-struct-tree", action="store_true", help="Use tagged PDF structure tree when available.")
+    pdf_parser.add_argument("--sanitize", action="store_true", help="Sanitize emails, phone numbers, IPs, cards, and URLs.")
+    pdf_parser.add_argument("--keep-line-breaks", action="store_true", help="Preserve original text line breaks.")
+    pdf_parser.add_argument("--include-header-footer", action="store_true", help="Include page headers and footers.")
+    pdf_parser.add_argument("--detect-strikethrough", action="store_true", help="Detect strikethrough text in Markdown/HTML.")
+    pdf_parser.add_argument("--table-method", choices=("default", "cluster"), help="Table detection method.")
+    pdf_parser.add_argument("--reading-order", choices=("off", "xycut"), default="xycut", help="Reading order algorithm.")
+    pdf_parser.add_argument("--markdown-page-separator", help="Separator between Markdown pages; supports %%page-number%%.")
+    pdf_parser.add_argument("--html-page-separator", help="Separator between HTML pages; supports %%page-number%%.")
+    pdf_parser.add_argument("--image-output", choices=("off", "embedded", "external"), default="external")
+    pdf_parser.add_argument("--image-dir", help="Directory for extracted images.")
+    pdf_parser.add_argument("--threads", type=int, help="Worker thread count for native extraction.")
+    pdf_parser.add_argument("--sidecar-json", help="Write structured extraction report JSON to this path.")
+    pdf_parser.add_argument("--force", action="store_true", help="Overwrite existing extraction outputs.")
+    pdf_parser.add_argument("--verbose", action="store_true", help="Enable verbose logs.")
+    return parser
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    parser = build_parser()
+    args = parser.parse_args(list(argv) if argv is not None else None)
+    _configure_logging(args.verbose)
+
+    try:
+        if args.command == "convert":
+            input_path = Path(args.input)
+            output_path = Path(args.output) if args.output else input_path.with_suffix(".pdf")
+            report = convert_epub(
+                ConvertConfig(
+                    input_path=input_path,
+                    output_path=output_path,
+                    engine=args.engine,
+                    sidecar_json_path=Path(args.sidecar_json) if args.sidecar_json else None,
+                    sidecar_html_path=Path(args.sidecar_html) if args.sidecar_html else None,
+                    sidecar_markdown_path=Path(args.sidecar_markdown) if args.sidecar_markdown else None,
+                    page_size=args.page_size,
+                    margin_mm=args.margin_mm,
+                    cover=args.cover,
+                    validate=not args.no_validate,
+                    force=args.force,
+                    verbose=args.verbose,
+                )
+            )
+            print(str(output_path))
+            logging.getLogger(__name__).debug("Conversion report: %s", json.dumps(report, ensure_ascii=False))
+            return ExitCode.OK
+
+        if args.command == "batch":
+            report = batch_convert(
+                BatchConfig(
+                    input_paths=[Path(p) for p in args.inputs],
+                    output_dir=Path(args.output_dir),
+                    engine=args.engine,
+                    workers=args.workers,
+                    sidecar_json=args.sidecar_json,
+                    sidecar_html=args.sidecar_html,
+                    sidecar_markdown=args.sidecar_markdown,
+                    page_size=args.page_size,
+                    margin_mm=args.margin_mm,
+                    cover=args.cover,
+                    validate=not args.no_validate,
+                    force=args.force,
+                    verbose=args.verbose,
+                )
+            )
+            for result in report["results"]:
+                output_path = result.get("output", {}).get("path")
+                if output_path:
+                    print(output_path)
+            logging.getLogger(__name__).debug("Batch report: %s", json.dumps(report, ensure_ascii=False))
+            return ExitCode.OK if report["failures"] == 0 else ExitCode.UNEXPECTED
+
+        if args.command == "inspect":
+            report = inspect_epub(
+                InspectConfig(
+                    input_path=Path(args.input),
+                    json_path=Path(args.json) if args.json else None,
+                )
+            )
+            if not args.json:
+                json.dump(report, sys.stdout, ensure_ascii=False, indent=2)
+                sys.stdout.write("\n")
+            return ExitCode.OK
+
+        if args.command == "pdf-extract":
+            input_path = Path(args.input)
+            output_dir = Path(args.output_dir) if args.output_dir else input_path.with_name(f"{input_path.stem}_extracted")
+            report = extract_pdf(
+                PdfExtractConfig(
+                    input_path=input_path,
+                    output_dir=output_dir,
+                    formats=_parse_pdf_formats(args.format),
+                    engine=args.engine,
+                    pages=args.pages,
+                    password=args.password,
+                    use_struct_tree=args.use_struct_tree,
+                    sanitize=args.sanitize,
+                    keep_line_breaks=args.keep_line_breaks,
+                    include_header_footer=args.include_header_footer,
+                    detect_strikethrough=args.detect_strikethrough,
+                    table_method=args.table_method,
+                    reading_order=args.reading_order,
+                    markdown_page_separator=args.markdown_page_separator,
+                    html_page_separator=args.html_page_separator,
+                    image_output=args.image_output,
+                    image_dir=Path(args.image_dir) if args.image_dir else None,
+                    threads=args.threads,
+                    sidecar_json_path=Path(args.sidecar_json) if args.sidecar_json else None,
+                    force=args.force,
+                    verbose=args.verbose,
+                )
+            )
+            for output in report["outputs"]:
+                print(output)
+            return ExitCode.OK
+    except Epub2PdfError as exc:
+        print(str(exc), file=sys.stderr)
+        return exc.exit_code
+    except Exception as exc:
+        logging.getLogger(__name__).exception("Unexpected error")
+        print(f"Unexpected error: {exc}", file=sys.stderr)
+        return ExitCode.UNEXPECTED
+
+    # Unreachable because subparsers are required, but kept for safety.
+    parser.error(f"Unsupported command: {args.command}")
+    return ExitCode.USAGE
+
+
+def _configure_logging(verbose: bool) -> None:
+    level = logging.DEBUG if verbose else logging.WARNING
+    logging.basicConfig(level=level, format="%(levelname)s %(message)s")
+
+
+def _parse_pdf_formats(raw: str) -> list[PdfExtractFormat]:
+    formats = [part.strip() for part in raw.split(",") if part.strip()]
+    if not formats:
+        raise Epub2PdfError("At least one --format value is required.", exit_code=ExitCode.USAGE)
+    invalid = [fmt for fmt in formats if fmt not in PDF_EXTRACT_FORMATS]
+    if invalid:
+        allowed = ", ".join(PDF_EXTRACT_FORMATS)
+        raise Epub2PdfError(f"Unsupported PDF extract format(s): {', '.join(invalid)}. Allowed: {allowed}", exit_code=ExitCode.USAGE)
+    return formats  # type: ignore[return-value]

epub2pdf_cli/config.py

@@ -0,0 +1,109 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Literal
+
+EngineName = Literal["playwright", "weasyprint"]
+CoverMode = Literal["first", "none"]
+PageSize = Literal["A4", "Letter"]
+PdfExtractFormat = Literal[
+    "markdown",
+    "json",
+    "text",
+    "html",
+    "markdown-with-html",
+    "markdown-with-images",
+    "tagged-pdf",
+]
+ImageOutputMode = Literal["off", "embedded", "external"]
+TableMethod = Literal["default", "cluster"]
+ReadingOrder = Literal["off", "xycut"]
+PdfExtractorName = Literal["pypdfium2", "docling", "pdfplumber", "opendataloader"]
+
+
+@dataclass(frozen=True, slots=True)
+class ConvertConfig:
+    input_path: Path
+    output_path: Path
+    engine: EngineName = "weasyprint"
+    sidecar_json_path: Path | None = None
+    sidecar_html_path: Path | None = None
+    sidecar_markdown_path: Path | None = None
+    page_size: PageSize = "A4"
+    margin_mm: int = 12
+    cover: CoverMode = "first"
+    validate: bool = True
+    force: bool = False
+    verbose: bool = False
+
+    def __post_init__(self) -> None:
+        if self.margin_mm < 0:
+            raise ValueError("margin_mm must be non-negative")
+
+
+@dataclass(frozen=True, slots=True)
+class BatchConfig:
+    input_paths: list[Path]
+    output_dir: Path
+    engine: EngineName = "weasyprint"
+    workers: int = 1
+    sidecar_json: bool = False
+    sidecar_html: bool = False
+    sidecar_markdown: bool = False
+    page_size: PageSize = "A4"
+    margin_mm: int = 12
+    cover: CoverMode = "first"
+    validate: bool = True
+    force: bool = False
+    verbose: bool = False
+
+    def __post_init__(self) -> None:
+        if self.margin_mm < 0:
+            raise ValueError("margin_mm must be non-negative")
+        if self.workers < 1:
+            raise ValueError("workers must be at least 1")
+
+
+@dataclass(frozen=True, slots=True)
+class InspectConfig:
+    input_path: Path
+    json_path: Path | None = None
+
+
+@dataclass(frozen=True, slots=True)
+class PdfExtractConfig:
+    input_path: Path
+    output_dir: Path
+    formats: list[PdfExtractFormat]
+    engine: PdfExtractorName = "pypdfium2"
+    pages: str | None = None
+    password: str | None = None
+    use_struct_tree: bool = False
+    sanitize: bool = False
+    keep_line_breaks: bool = False
+    include_header_footer: bool = False
+    detect_strikethrough: bool = False
+    table_method: TableMethod | None = None
+    reading_order: ReadingOrder | None = "xycut"
+    markdown_page_separator: str | None = None
+    html_page_separator: str | None = None
+    image_output: ImageOutputMode | None = "external"
+    image_dir: Path | None = None
+    threads: int | None = None
+    sidecar_json_path: Path | None = None
+    force: bool = False
+    verbose: bool = False
+
+
+@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/epub/__init__.py

@@ -0,0 +1,3 @@
+from epub2pdf_cli.epub.parser import read_epub
+
+__all__ = ["read_epub"]

epub2pdf_cli/epub/chapters.py

@@ -0,0 +1,81 @@
+from __future__ import annotations
+
+from collections.abc import Iterable
+from pathlib import Path
+
+from bs4 import BeautifulSoup
+
+from epub2pdf_cli.errors import StageError
+from epub2pdf_cli.models import Chapter, ManifestItem, SpineItem
+
+TEXT_MEDIA_TYPES = {"application/xhtml+xml", "text/html"}
+UNSUPPORTED_TAGS = {"script", "audio", "video", "canvas", "iframe", "form"}
+
+
+def read_chapters(
+    spine: Iterable[SpineItem],
+    manifest: dict[str, ManifestItem],
+) -> tuple[list[Chapter], list[str]]:
+    chapters: list[Chapter] = []
+    warnings: list[str] = []
+    for item in spine:
+        if item.media_type not in TEXT_MEDIA_TYPES:
+            continue
+        manifest_item = manifest[item.idref]
+        if not manifest_item.content:
+            raise StageError("spine", f"Spine item is missing chapter content: {manifest_item.href}")
+        soup = BeautifulSoup(manifest_item.content, "lxml")
+        title = _extract_title(soup, fallback=Path(manifest_item.href).stem)
+        text = soup.get_text(" ", strip=True)
+        chapter_warnings = _chapter_warnings(soup, manifest_item.href, text)
+        warnings.extend(chapter_warnings)
+        chapters.append(
+            Chapter(
+                idref=item.idref,
+                href=manifest_item.href,
+                media_type=item.media_type,
+                title=title,
+                html=manifest_item.content.decode("utf-8", errors="replace"),
+                text=text,
+                linear=item.linear,
+            )
+        )
+    if not chapters:
+        raise StageError("spine", "Spine did not contain any XHTML/HTML documents")
+    return chapters, warnings
+
+
+def _extract_title(soup: BeautifulSoup, fallback: str) -> str:
+    for selector in ("title", "h1", "h2"):
+        node = soup.find(selector)
+        if node:
+            text = str(node.get_text(" ", strip=True))
+            if text:
+                return text
+    return fallback
+
+
+def _chapter_warnings(soup: BeautifulSoup, href: str, text: str) -> list[str]:
+    warnings: list[str] = []
+    if not text.strip() and soup.find("img"):
+        warnings.append(f"Chapter is image-heavy or image-only: {href}")
+    found: set[str] = set()
+    for tag in soup.find_all(True):
+        if tag.name in UNSUPPORTED_TAGS:
+            found.add(tag.name)
+    for tag_name in sorted(found):
+        warnings.append(f"Unsupported <{tag_name}> content detected in {href}")
+    return warnings
+
+
+def manifest_warnings(manifest: dict[str, ManifestItem]) -> list[str]:
+    warnings: list[str] = []
+    supported_prefixes = ("application/xhtml+xml", "text/html", "text/css", "image/", "font/")
+    supported_exact = {"application/x-dtbncx+xml"}
+    for item in manifest.values():
+        if any(item.media_type.startswith(prefix) for prefix in supported_prefixes):
+            continue
+        if item.media_type in supported_exact:
+            continue
+        warnings.append(f"Manifest item may not be fully represented in PDF: {item.href} ({item.media_type})")
+    return warnings

epub2pdf_cli/epub/container.py

@@ -0,0 +1,25 @@
+from __future__ import annotations
+
+import zipfile
+from xml.etree import ElementTree as ET
+
+from epub2pdf_cli.errors import ExitCode, StageError
+
+CONTAINER_NS = {"c": "urn:oasis:names:tc:opendocument:xmlns:container"}
+
+
+def read_rootfile_path(archive: zipfile.ZipFile) -> str:
+    try:
+        container_bytes = archive.read("META-INF/container.xml")
+    except KeyError as exc:
+        raise StageError("container", "Missing required EPUB resource: META-INF/container.xml", exit_code=ExitCode.USAGE) from exc
+
+    try:
+        container = ET.fromstring(container_bytes)
+    except ET.ParseError as exc:
+        raise StageError("container", "Unable to parse META-INF/container.xml") from exc
+
+    rootfile = container.find("c:rootfiles/c:rootfile", CONTAINER_NS)
+    if rootfile is None or not rootfile.attrib.get("full-path"):
+        raise StageError("container", "container.xml does not declare a rootfile")
+    return rootfile.attrib["full-path"]

epub2pdf_cli/epub/href.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+import posixpath
+
+
+def split_href(href: str) -> tuple[str, str]:
+    if "#" not in href:
+        return href, ""
+    path, fragment = href.split("#", 1)
+    return path, fragment
+
+
+def resolve_relative_href(base_href: str, target: str) -> str:
+    if not target:
+        return base_href
+    if "://" in target or target.startswith("mailto:"):
+        return target
+    path, fragment = split_href(target)
+    resolved_path = (
+        posixpath.normpath(posixpath.join(posixpath.dirname(base_href), path))
+        if path
+        else base_href
+    )
+    return f"{resolved_path}#{fragment}" if fragment else resolved_path