pdf-to-markdown-cli 1.1.0__tar.gz → 1.2.0__tar.gz

{pdf_to_markdown_cli-1.1.0 → pdf_to_markdown_cli-1.2.0}/CHANGELOG.md

@@ -8,6 +8,16 @@ This project follows [Semantic Versioning](https://semver.org/spec/v2.0.0.html),
 
 ## [Unreleased]
 
+## [1.2.0] - 2026-09-29
+
+### Added
+
+- `--backend` option for choosing the conversion service. `datalab` is the default and, for now, the only choice.
+
+### Changed
+
+- Conversion now goes through a pluggable backend interface (`docs_to_md.backends`), so other services or local engines can be added without touching the pipeline. Datalab behavior is unchanged. The Datalab client and API types moved from `docs_to_md.client` and `docs_to_md.models` to `docs_to_md.backends.datalab`.
+
 ## [1.1.0] - 2026-09-29
 
 ### Added

{pdf_to_markdown_cli-1.1.0 → pdf_to_markdown_cli-1.2.0}/CONTRIBUTING.md

@@ -45,9 +45,10 @@ src/docs_to_md/
 ├── cli.py        arguments, entry point, exit codes, summary
 ├── config.py     validated runtime configuration
 ├── discovery.py  input discovery, deterministic output names
-├── pipeline.py   split, submit concurrently, poll, report
-├── client.py     API client: retries, timeouts, error types
-├── models.py     API request/response types, formats
+├── pipeline.py   split, convert chunks concurrently, report
+├── backends/     conversion backends, selected with --backend
+│   ├── base.py       Backend contract and BackendInfo capabilities
+│   └── datalab/      Datalab Convert API: submit/poll, HTTP client, types
 ├── pdf.py        page ranges and PDF splitting (pikepdf)
 ├── assemble.py   merge chunks, renumber pages, write files
 ├── markdown.py   Markdown clean-up (reflow, captions)
@@ -61,7 +62,8 @@ examples/         sample documents with reference outputs
 
 - Python 3.11+, type-hinted, with `from __future__ import annotations`.
 - Raise exceptions from `errors.py`. Use `FatalAPIError` only for problems that affect every request (bad key, no credits). It aborts the whole run.
-- Keep network code in `client.py` and orchestration in `pipeline.py`. Pipeline tests use `FakeClient` from `tests/conftest.py`. HTTP behavior is tested with the fake session in `tests/test_client.py`.
+- Keep orchestration in `pipeline.py` and everything service-specific in its backend under `backends/`. The pipeline must not know which backend it runs. Pipeline tests use `FakeBackend` from `tests/conftest.py`. Datalab behavior is tested with `FakeClient` in `tests/test_datalab_backend.py`, and HTTP behavior with the fake session in `tests/test_datalab_client.py`.
+- A new backend subclasses `Backend` (`backends/base.py`), declares what it accepts in a `BackendInfo`, and is registered in `BACKENDS` (`backends/__init__.py`).
 - Add tests with every behavior change, in the module's test file. The suite is fast (under a second), so keep it that way.
 - Update the docs in the same pull request: `README.md` for user-facing changes, `CHANGELOG.md` under **Unreleased**, and `AGENTS.md` when the module map or conventions change.
 

{pdf_to_markdown_cli-1.1.0 → pdf_to_markdown_cli-1.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pdf-to-markdown-cli
-Version: 1.1.0
+Version: 1.2.0
 Summary: Convert PDFs, Office documents, ebooks, and images to Markdown, HTML, or JSON with the Datalab API.
 Author-email: Nikita Sokolsky <sokolx@gmail.com>
 Maintainer-email: Nikita Sokolsky <sokolx@gmail.com>
@@ -218,6 +218,7 @@ pdf-to-md INPUT [INPUT ...] [options]
 
 | Option | Description |
 | --- | --- |
+| `--backend NAME` | Conversion service. Default and currently only choice: `datalab`. |
 | `-m`, `--mode MODE` | `fast` (the API default), `balanced`, or `accurate`. |
 | `--paginate` | Insert page separators. |
 | `--no-images` | Don't extract images. |

{pdf_to_markdown_cli-1.1.0 → pdf_to_markdown_cli-1.2.0}/README.md

@@ -175,6 +175,7 @@ pdf-to-md INPUT [INPUT ...] [options]
 
 | Option | Description |
 | --- | --- |
+| `--backend NAME` | Conversion service. Default and currently only choice: `datalab`. |
 | `-m`, `--mode MODE` | `fast` (the API default), `balanced`, or `accurate`. |
 | `--paginate` | Insert page separators. |
 | `--no-images` | Don't extract images. |

{pdf_to_markdown_cli-1.1.0 → pdf_to_markdown_cli-1.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pdf-to-markdown-cli"
-version = "1.1.0"
+version = "1.2.0"
 description = "Convert PDFs, Office documents, ebooks, and images to Markdown, HTML, or JSON with the Datalab API."
 readme = { file = "README.md", content-type = "text/markdown" }
 authors = [

{pdf_to_markdown_cli-1.1.0 → pdf_to_markdown_cli-1.2.0}/src/docs_to_md/assemble.py

@@ -1,4 +1,4 @@
-"""Combine per-chunk API results into one output document plus images."""
+"""Combine per-chunk backend results into one output document plus images."""
 
 from __future__ import annotations
 
@@ -20,6 +20,13 @@ from docs_to_md.markdown import normalize_line_breaks, remove_duplicate_captions
 
 logger = logging.getLogger(__name__)
 
+# Output format -> file extension
+OUTPUT_EXTENSIONS: dict[str, str] = {
+    "markdown": ".md",
+    "html": ".html",
+    "json": ".json",
+}
+
 _MD_PAGE_MARKER = re.compile(r"^\{(\d+)\}(-{48})$", re.MULTILINE)
 _HTML_PAGE_ID = re.compile(r'(data-page-id=")(\d+)(")')
 _BLOCK_ID = re.compile(r"(^|['\"])/page/(\d+)/")  # block ids and <content-ref src='/page/N/...'>
@@ -30,7 +37,13 @@ _HTML_HEAD = re.compile(r"<head[^>]*>.*?</head>", re.DOTALL | re.IGNORECASE)
 
 @dataclass
 class ChunkOutput:
-    """The result of converting one chunk."""
+    """The result of converting one chunk.
+
+    ``content`` follows Marker's output conventions, with page numbers local to
+    the chunk (0 is its first page): Markdown ``{N}`` + 48 dashes separators and
+    ``page-N-M`` anchors, HTML ``data-page-id``, and JSON ``/page/N/`` block ids
+    and ``page`` fields. Images are referenced by their key in ``images``.
+    """
 
     pages: Sequence[int]  # source page numbers covered by this chunk, in order
     content: Any  # str for markdown/html, dict for json

pdf_to_markdown_cli-1.2.0/src/docs_to_md/backends/__init__.py

@@ -0,0 +1,31 @@
+"""Conversion backends, selected with ``--backend``.
+
+To add one, subclass ``Backend`` (see ``base.py``) and list it in ``BACKENDS``.
+"""
+
+from __future__ import annotations
+
+from docs_to_md.backends.base import Backend, BackendInfo, CancelCheck
+from docs_to_md.backends.datalab import DatalabBackend
+from docs_to_md.errors import ConfigurationError
+
+DEFAULT_BACKEND = "datalab"
+
+BACKENDS: dict[str, type[Backend]] = {backend.info.name: backend for backend in (DatalabBackend,)}
+
+
+def get_backend(name: str) -> type[Backend]:
+    try:
+        return BACKENDS[name]
+    except KeyError:
+        raise ConfigurationError(f"Unknown backend: {name} (available: {', '.join(BACKENDS)})") from None
+
+
+__all__ = [
+    "BACKENDS",
+    "DEFAULT_BACKEND",
+    "Backend",
+    "BackendInfo",
+    "CancelCheck",
+    "get_backend",
+]

pdf_to_markdown_cli-1.2.0/src/docs_to_md/backends/base.py

@@ -0,0 +1,72 @@
+"""The contract between the pipeline and a conversion backend.
+
+The pipeline plans outputs, splits PDFs, schedules chunks on worker threads,
+merges the results, and writes files. A backend only turns one chunk into
+Markdown, HTML, or JSON.
+"""
+
+from __future__ import annotations
+
+import threading
+from abc import ABC, abstractmethod
+from collections.abc import Callable
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, ClassVar
+
+from docs_to_md.assemble import ChunkOutput
+from docs_to_md.pdf import Chunk
+
+if TYPE_CHECKING:
+    from docs_to_md.config import Config
+
+CancelCheck = Callable[[], None]
+"""Raises ``Cancelled`` once the run is interrupted or another chunk of the file failed."""
+
+
+@dataclass(frozen=True)
+class BackendInfo:
+    """What a backend accepts, used to validate the config before any work starts."""
+
+    name: str  # the --backend value
+    label: str  # human-readable name for messages
+    input_extensions: frozenset[str]  # lowercase, without the dot
+    output_formats: frozenset[str]  # keys of assemble.OUTPUT_EXTENSIONS
+    modes: tuple[str, ...] = ()  # accepted --mode values
+    max_upload_bytes: int | None = None  # limit for a document sent whole
+    api_key_env_vars: tuple[str, ...] = ()  # lookup order; empty if no key is needed
+    api_key_url: str | None = None  # where to get a key
+
+    @property
+    def requires_api_key(self) -> bool:
+        return bool(self.api_key_env_vars)
+
+
+class Backend(ABC):
+    """Converts one chunk at a time.
+
+    ``convert`` runs concurrently on up to ``--concurrency`` worker threads, so
+    implementations must be thread-safe. Errors decide how far a failure spreads:
+
+    - ``FatalAPIError`` affects every request (bad key, no credits) and stops the run.
+    - ``Cancelled`` comes from ``check_cancelled`` and must be allowed to propagate.
+    - Any other ``DocsToMdError`` fails only the file the chunk belongs to.
+    """
+
+    info: ClassVar[BackendInfo]
+
+    @classmethod
+    @abstractmethod
+    def from_config(cls, config: Config, stop_event: threading.Event) -> Backend:
+        """Build a backend for a validated ``config``.
+
+        ``stop_event`` is set when the run is interrupted. Long waits should wake
+        up on it instead of sleeping through Ctrl-C.
+        """
+
+    @abstractmethod
+    def convert(self, chunk: Chunk, check_cancelled: CancelCheck) -> ChunkOutput:
+        """Convert ``chunk`` to ``config.output_format``, blocking until done.
+
+        Call ``check_cancelled`` between slow steps (uploads, polls, retries) so
+        an abandoned chunk stops spending time and credits.
+        """

pdf_to_markdown_cli-1.2.0/src/docs_to_md/backends/datalab/__init__.py

@@ -0,0 +1,5 @@
+"""The hosted Datalab Convert API (https://www.datalab.to)."""
+
+from docs_to_md.backends.datalab.backend import DatalabBackend
+
+__all__ = ["DatalabBackend"]

pdf_to_markdown_cli-1.2.0/src/docs_to_md/backends/datalab/backend.py

@@ -0,0 +1,119 @@
+"""Convert chunks with the hosted Datalab Convert API: submit, then poll."""
+
+from __future__ import annotations
+
+import logging
+import threading
+import time
+from typing import TYPE_CHECKING
+
+from docs_to_md.assemble import ChunkOutput
+from docs_to_md.backends.base import Backend, BackendInfo, CancelCheck
+from docs_to_md.backends.datalab.client import DatalabClient
+from docs_to_md.backends.datalab.models import (
+    INPUT_MIME_TYPES,
+    MODES,
+    OUTPUT_FORMATS,
+    ConvertOptions,
+    ConvertResult,
+)
+from docs_to_md.console import format_elapsed
+from docs_to_md.errors import APIError, RetryableAPIError
+from docs_to_md.pdf import Chunk
+
+if TYPE_CHECKING:
+    from docs_to_md.config import Config
+
+logger = logging.getLogger(__name__)
+
+INITIAL_POLL_SECONDS = 2.0
+MAX_POLL_SECONDS = 15.0
+MAX_RATE_LIMIT_RESUBMITS = 3
+
+
+class DatalabBackend(Backend):
+    info = BackendInfo(
+        name="datalab",
+        label="Datalab",
+        input_extensions=frozenset(INPUT_MIME_TYPES),
+        output_formats=OUTPUT_FORMATS,
+        modes=MODES,
+        max_upload_bytes=200 * 1024 * 1024,
+        api_key_env_vars=("DATALAB_API_KEY", "MARKER_PDF_KEY"),
+        api_key_url="https://www.datalab.to/app/keys",
+    )
+
+    def __init__(self, config: Config, client: DatalabClient):
+        self.config = config
+        self.client = client
+
+    @classmethod
+    def from_config(cls, config: Config, stop_event: threading.Event) -> DatalabBackend:
+        return cls(config, DatalabClient(config.api_key or "", stop_event=stop_event))
+
+    def options_for(self, chunk: Chunk) -> ConvertOptions:
+        """Form fields for ``chunk``.
+
+        Split PDFs already contain only the selected pages, so ``page_range`` and
+        ``max_pages`` are sent only for documents uploaded whole.
+        """
+        config = self.config
+        select_remotely = not chunk.pages
+        return ConvertOptions(
+            output_format=config.output_format,
+            mode=config.mode,
+            paginate=config.paginate,
+            disable_image_extraction=config.disable_image_extraction,
+            disable_image_captions=config.disable_image_captions,
+            skip_cache=config.skip_cache,
+            page_range=config.page_range if select_remotely else None,
+            max_pages=config.max_pages if select_remotely else None,
+            extra=dict(config.extra_options),
+        )
+
+    def convert(self, chunk: Chunk, check_cancelled: CancelCheck) -> ChunkOutput:
+        options = self.options_for(chunk)
+        deadline = time.monotonic() + self.config.timeout
+        for attempt in range(MAX_RATE_LIMIT_RESUBMITS + 1):
+            check_cancelled()
+            request_id = self.client.submit(chunk.path, options)
+            result = self._wait_for_result(request_id, deadline, check_cancelled)
+            if result.status == "complete" and result.success is not False:
+                content = result.content_for(self.config.output_format)
+                if content is None:
+                    raise APIError(f"the API returned no {self.config.output_format} output")
+                return ChunkOutput(
+                    pages=chunk.pages,
+                    content=content,
+                    images=result.images,
+                    page_count=result.page_count or len(chunk.pages),
+                    cost_cents=result.cost_cents or 0.0,
+                )
+            error = result.error or f"conversion {result.status}"
+            # Page throughput limits surface as failed results, not HTTP 429.
+            if "rate limit" in error.lower() and attempt < MAX_RATE_LIMIT_RESUBMITS:
+                logger.debug("Request %s hit a rate limit; resubmitting", request_id)
+                self.client.sleep(30.0 * (attempt + 1))
+                continue
+            raise APIError(error)
+        raise AssertionError("unreachable")
+
+    def _wait_for_result(
+        self, request_id: str, deadline: float, check_cancelled: CancelCheck
+    ) -> ConvertResult:
+        delay = INITIAL_POLL_SECONDS
+        while True:
+            check_cancelled()
+            try:
+                result = self.client.get_result(request_id)
+                if result.status != "processing":
+                    return result
+            except RetryableAPIError as e:
+                logger.debug("Polling %s: %s", request_id, e)
+            if time.monotonic() + delay > deadline:
+                raise APIError(
+                    f"timed out after {format_elapsed(self.config.timeout)} waiting for "
+                    f"request {request_id} (raise --timeout for very large jobs)"
+                )
+            self.client.sleep(delay)
+            delay = min(delay * 1.5, MAX_POLL_SECONDS)

{pdf_to_markdown_cli-1.1.0/src/docs_to_md → pdf_to_markdown_cli-1.2.0/src/docs_to_md/backends/datalab}/client.py

@@ -13,13 +13,13 @@ from typing import Any
 
 import requests
 
+from docs_to_md.backends.datalab.models import INPUT_MIME_TYPES, ConvertOptions, ConvertResult
 from docs_to_md.errors import (
     APIError,
     Cancelled,
     FatalAPIError,
     RetryableAPIError,
 )
-from docs_to_md.models import INPUT_MIME_TYPES, ConvertOptions, ConvertResult
 
 logger = logging.getLogger(__name__)
 

{pdf_to_markdown_cli-1.1.0/src/docs_to_md → pdf_to_markdown_cli-1.2.0/src/docs_to_md/backends/datalab}/models.py

@@ -1,4 +1,4 @@
-"""Datalab Convert API data types and supported format tables.
+"""Datalab Convert API data types and supported formats.
 
 Reference: https://documentation.datalab.to/api-reference/convert-document
 """
@@ -9,13 +9,7 @@ from dataclasses import dataclass, field
 from typing import Any
 
 MODES = ("fast", "balanced", "accurate")
-
-# Output format -> file extension
-SUPPORTED_FORMAT_EXTENSIONS: dict[str, str] = {
-    "markdown": ".md",
-    "json": ".json",
-    "html": ".html",
-}
+OUTPUT_FORMATS = frozenset({"markdown", "html", "json"})
 
 # Input extension (without dot) -> MIME type sent to the API.
 # https://documentation.datalab.to/docs/common/supportedfiletypes
@@ -45,9 +39,6 @@ INPUT_MIME_TYPES: dict[str, str] = {
     "tif": "image/tiff",
 }
 
-SUPPORTED_INPUT_EXTENSIONS = frozenset(INPUT_MIME_TYPES)
-SUPPORTED_MIME_TYPES = frozenset(INPUT_MIME_TYPES.values())
-
 
 @dataclass
 class ConvertOptions:

{pdf_to_markdown_cli-1.1.0 → pdf_to_markdown_cli-1.2.0}/src/docs_to_md/cli.py

@@ -11,18 +11,18 @@ from collections.abc import Sequence
 from pathlib import Path
 
 from docs_to_md import __version__
-from docs_to_md.client import DatalabClient
+from docs_to_md.assemble import OUTPUT_EXTENSIONS
+from docs_to_md.backends import BACKENDS, DEFAULT_BACKEND, get_backend
 from docs_to_md.config import (
     DEFAULT_CHUNK_SIZE,
     DEFAULT_CONCURRENCY,
     DEFAULT_TIMEOUT_SECONDS,
     Config,
 )
-from docs_to_md.console import Console, setup_logging
+from docs_to_md.console import Console, format_cost, format_elapsed, setup_logging
 from docs_to_md.discovery import plan_jobs
 from docs_to_md.errors import Cancelled, ConfigurationError, FatalAPIError
-from docs_to_md.models import MODES
-from docs_to_md.pipeline import CONVERTED, FAILED, SKIPPED, Pipeline, format_cost, format_elapsed
+from docs_to_md.pipeline import CONVERTED, FAILED, SKIPPED, Pipeline
 
 logger = logging.getLogger(__name__)
 
@@ -31,8 +31,6 @@ EXIT_FAILURES = 1
 EXIT_USAGE = 2
 EXIT_INTERRUPTED = 130
 
-API_KEY_ENV_VARS = ("DATALAB_API_KEY", "MARKER_PDF_KEY")
-
 EPILOG = """\
 examples:
   pdf-to-md report.pdf                  convert to report.md (+ report_images/)
@@ -84,7 +82,7 @@ def build_parser() -> argparse.ArgumentParser:
         "-f",
         "--format",
         dest="output_format",
-        choices=("markdown", "html", "json"),
+        choices=tuple(OUTPUT_EXTENSIONS),
         default="markdown",
         help="output format (default: markdown)",
     )
@@ -112,11 +110,17 @@ def build_parser() -> argparse.ArgumentParser:
     )
 
     conv = parser.add_argument_group("conversion")
+    conv.add_argument(
+        "--backend",
+        choices=tuple(BACKENDS),
+        default=DEFAULT_BACKEND,
+        help=f"conversion service (default: {DEFAULT_BACKEND})",
+    )
     conv.add_argument(
         "-m",
         "--mode",
-        choices=MODES,
-        help="quality/speed trade-off; the API defaults to fast",
+        choices=tuple(dict.fromkeys(mode for backend in BACKENDS.values() for mode in backend.info.modes)),
+        help="quality/speed trade-off; Datalab defaults to fast",
     )
     conv.add_argument("--paginate", action="store_true", help="insert page separators in the output")
     conv.add_argument(
@@ -189,10 +193,11 @@ def build_parser() -> argparse.ArgumentParser:
     return parser
 
 
-def resolve_api_key(explicit: str | None) -> str | None:
+def resolve_api_key(explicit: str | None, env_vars: Sequence[str]) -> str | None:
+    """``--api-key`` if given, else the first non-empty variable in ``env_vars``."""
     if explicit:
         return explicit.strip()
-    for name in API_KEY_ENV_VARS:
+    for name in env_vars:
         value = os.environ.get(name, "").strip()
         if value:
             return value
@@ -211,9 +216,11 @@ def config_from_args(args: argparse.Namespace, console: Console) -> Config:
         if used:
             console.warning(f"{flag} is no longer supported by the Datalab API and is ignored")
 
+    backend = get_backend(args.backend)
     return Config(
         inputs=list(args.inputs),
-        api_key=resolve_api_key(args.api_key),
+        backend=backend.info.name,
+        api_key=resolve_api_key(args.api_key, backend.info.api_key_env_vars),
         output_dir=args.output_dir,
         output_format=args.output_format,
         mode=mode,
@@ -265,12 +272,18 @@ def main(argv: Sequence[str] | None = None, console: Console | None = None) -> i
     stop_event = threading.Event()
     try:
         config = config_from_args(args, console)
-        jobs = plan_jobs(config.inputs, config.output_format, config.output_dir)
+        backend_type = get_backend(config.backend)
+        jobs = plan_jobs(
+            config.inputs,
+            config.output_format,
+            config.output_dir,
+            input_extensions=backend_type.info.input_extensions,
+        )
         if not jobs:
             console.error("No supported files to convert.")
             return EXIT_FAILURES
-        client = None if config.dry_run else DatalabClient(config.api_key or "", stop_event=stop_event)
-        pipeline = Pipeline(config, console, client=client, stop_event=stop_event)
+        backend = None if config.dry_run else backend_type.from_config(config, stop_event)
+        pipeline = Pipeline(config, console, backend=backend, stop_event=stop_event)
         summary = pipeline.run(jobs)
     except ConfigurationError as e:
         console.error(str(e))

{pdf_to_markdown_cli-1.1.0 → pdf_to_markdown_cli-1.2.0}/src/docs_to_md/config.py

@@ -5,8 +5,9 @@ from __future__ import annotations
 from dataclasses import dataclass, field
 from pathlib import Path
 
+from docs_to_md.assemble import OUTPUT_EXTENSIONS
+from docs_to_md.backends import DEFAULT_BACKEND, get_backend
 from docs_to_md.errors import ConfigurationError
-from docs_to_md.models import MODES, SUPPORTED_FORMAT_EXTENSIONS, ConvertOptions
 from docs_to_md.pdf import validate_page_range
 
 DEFAULT_CHUNK_SIZE = 25
@@ -17,6 +18,7 @@ DEFAULT_TIMEOUT_SECONDS = 3600.0
 @dataclass
 class Config:
     inputs: list[Path]
+    backend: str = DEFAULT_BACKEND
     api_key: str | None = None
     output_dir: Path | None = None
     output_format: str = "markdown"
@@ -33,20 +35,24 @@ class Config:
     overwrite: bool = False
     dry_run: bool = False
     reflow_markdown: bool = True
-    extra_options: dict = field(default_factory=dict)
+    extra_options: dict = field(default_factory=dict)  # passed through to the backend
 
     def validate(self) -> Config:
+        info = get_backend(self.backend).info
         if not self.inputs:
             raise ConfigurationError("At least one input path is required")
-        if not self.dry_run and not self.api_key:
-            raise ConfigurationError(
-                "No API key found. Set DATALAB_API_KEY (or MARKER_PDF_KEY), or pass "
-                "--api-key. Get a key at https://www.datalab.to/app/keys"
-            )
-        if self.output_format not in SUPPORTED_FORMAT_EXTENSIONS:
+        if not self.dry_run and info.requires_api_key and not self.api_key:
+            primary, *others = info.api_key_env_vars
+            also = f" (or {', '.join(others)})" if others else ""
+            where = f" Get a key at {info.api_key_url}" if info.api_key_url else ""
+            raise ConfigurationError(f"No API key found. Set {primary}{also}, or pass --api-key.{where}")
+        if self.output_format not in OUTPUT_EXTENSIONS:
             raise ConfigurationError(f"Unsupported output format: {self.output_format}")
-        if self.mode is not None and self.mode not in MODES:
-            raise ConfigurationError(f"Unsupported mode: {self.mode}")
+        if self.output_format not in info.output_formats:
+            raise ConfigurationError(f"The {info.label} backend cannot produce {self.output_format} output")
+        if self.mode is not None and self.mode not in info.modes:
+            choices = f" (choose from {', '.join(info.modes)})" if info.modes else ""
+            raise ConfigurationError(f"Unsupported mode for {info.label}: {self.mode}{choices}")
         if self.chunk_size is not None and self.chunk_size < 1:
             raise ConfigurationError("--chunk-size must be at least 1")
         if self.max_pages is not None and self.max_pages < 1:
@@ -62,20 +68,3 @@ class Config:
             if self.output_dir.exists() and not self.output_dir.is_dir():
                 raise ConfigurationError(f"Output path is not a directory: {self.output_dir}")
         return self
-
-    def convert_options(self, *, local_page_selection: bool) -> ConvertOptions:
-        """API options for one request.
-
-        PDFs are split locally, so their page selection is not sent to the API.
-        """
-        return ConvertOptions(
-            output_format=self.output_format,
-            mode=self.mode,
-            paginate=self.paginate,
-            disable_image_extraction=self.disable_image_extraction,
-            disable_image_captions=self.disable_image_captions,
-            skip_cache=self.skip_cache,
-            page_range=None if local_page_selection else self.page_range,
-            max_pages=None if local_page_selection else self.max_pages,
-            extra=dict(self.extra_options),
-        )

{pdf_to_markdown_cli-1.1.0 → pdf_to_markdown_cli-1.2.0}/src/docs_to_md/console.py

@@ -15,6 +15,16 @@ from typing import TextIO
 from tqdm import tqdm
 
 
+def format_cost(cents: float) -> str:
+    dollars = cents / 100
+    return f"${dollars:.2f}" if dollars >= 0.01 or dollars == 0 else f"${dollars:.4f}"
+
+
+def format_elapsed(seconds: float) -> str:
+    minutes, secs = divmod(round(seconds), 60)
+    return f"{minutes}m{secs:02d}s" if minutes else f"{seconds:.1f}s"
+
+
 def setup_logging(verbose: bool) -> None:
     handler = logging.StreamHandler(sys.stderr)
     if verbose: