pdf-to-markdown-cli 0.5.1__tar.gz → 0.5.2__tar.gz

pdf_to_markdown_cli-0.5.2/CHANGELOG.md

@@ -0,0 +1,25 @@
+# Changelog
+
+All notable changes to this project are documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project follows [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+### Added
+
+- Added fallback handling for non-writable cache/tmp directories.
+- Added support tests for HTML output CLI configuration and both example PDFs.
+
+### Changed
+
+- Expanded supported input MIME/extension mappings for document and image formats.
+- Improved result polling with per-chunk exponential backoff and cleaner logging.
+- Modernized packaging and project metadata in `pyproject.toml`.
+
+### Fixed
+
+- Fixed false "unsupported file type" failures by adding MIME detection fallbacks.
+- Fixed cache retrieval edge case where empty payloads were treated as missing.
+- Fixed request state tracking semantics for completion/failure handling.

pdf_to_markdown_cli-0.5.2/CONTRIBUTING.md

@@ -0,0 +1,38 @@
+# Contributing
+
+Thanks for contributing to `pdf-to-markdown-cli`.
+
+## Development setup
+
+1. Fork and clone the repository.
+2. Create a virtual environment.
+3. Install in editable mode:
+
+```bash
+pip install -e .
+```
+
+4. Run tests before submitting changes:
+
+```bash
+python -m unittest discover -s tests -v
+```
+
+## Pull request checklist
+
+- Keep changes focused and explain the motivation.
+- Add or update tests when behavior changes.
+- Keep CLI behavior backward-compatible unless the change is intentional.
+- Update docs (`README.md`, examples, or this guide) when user-facing behavior changes.
+- Ensure all tests pass locally.
+
+## Coding guidelines
+
+- Target Python 3.10+.
+- Prefer clear, small functions with explicit error handling.
+- Avoid silent failures; log contextual errors where useful.
+- Do not commit API keys, credentials, or private documents.
+
+## Reporting issues
+
+Use GitHub issues for bug reports and feature requests.

pdf_to_markdown_cli-0.5.2/MANIFEST.in

@@ -0,0 +1,13 @@
+# Include the README and LICENSE
+include README.md
+include LICENSE
+include CHANGELOG.md
+include CONTRIBUTING.md
+
+# Include package source
+recursive-include src/docs_to_md *.py
+
+# Exclude generated files
+global-exclude *.py[cod]
+global-exclude __pycache__
+global-exclude .DS_Store

pdf_to_markdown_cli-0.5.2/PKG-INFO

@@ -0,0 +1,143 @@
+Metadata-Version: 2.4
+Name: pdf-to-markdown-cli
+Version: 0.5.2
+Summary: CLI utility to convert PDFs and supported document formats to Markdown/JSON/HTML with Marker API.
+Author-email: Nikita Sokolsky <sokolx@gmail.com>
+Maintainer-email: Nikita Sokolsky <sokolx@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/SokolskyNikita/pdf-to-markdown-cli
+Project-URL: Repository, https://github.com/SokolskyNikita/pdf-to-markdown-cli
+Project-URL: Documentation, https://github.com/SokolskyNikita/pdf-to-markdown-cli#readme
+Project-URL: Issues, https://github.com/SokolskyNikita/pdf-to-markdown-cli/issues
+Project-URL: Changelog, https://github.com/SokolskyNikita/pdf-to-markdown-cli/releases
+Keywords: pdf,markdown,converter,cli,document,marker,md
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Operating System :: OS Independent
+Classifier: Environment :: Console
+Classifier: Topic :: Office/Business
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Text Processing
+Classifier: Topic :: Utilities
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: backoff>=2.0
+Requires-Dist: diskcache>=5.0
+Requires-Dist: filetype>=1.0
+Requires-Dist: pikepdf>=8.0
+Requires-Dist: pydantic>=2.0
+Requires-Dist: ratelimit>=2.0
+Requires-Dist: requests>=2.0
+Requires-Dist: tqdm>=4.0
+Provides-Extra: test
+Requires-Dist: pytest>=8.3.0; extra == "test"
+Requires-Dist: pytest-cov>=5.0.0; extra == "test"
+Provides-Extra: dev
+Requires-Dist: build>=1.2.0; extra == "dev"
+Requires-Dist: twine>=5.1.0; extra == "dev"
+Requires-Dist: ruff>=0.11.0; extra == "dev"
+Requires-Dist: types-requests>=2.32.0; extra == "dev"
+Dynamic: license-file
+
+# PDF to markdown CLI
+
+[![PyPI](https://img.shields.io/pypi/v/pdf-to-markdown-cli.svg)](https://pypi.org/project/pdf-to-markdown-cli/)
+[![Python versions](https://img.shields.io/pypi/pyversions/pdf-to-markdown-cli.svg)](https://pypi.org/project/pdf-to-markdown-cli/)
+[![License: MIT](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
+
+Command-line utility for converting PDFs and other supported documents into Markdown, JSON, or HTML using the [Marker API](https://www.datalab.to/marker).
+
+## Why use this tool
+
+- Converts single files or entire directories
+- Automatically splits large PDFs into chunks and merges results
+- Persists request state locally so interrupted runs can recover
+- Rewrites and copies extracted images into deterministic output folders
+- Supports OCR/LLM tuning flags from the Marker API
+
+## Supported formats
+
+### Input
+
+- PDF (`.pdf`)
+- Word (`.doc`, `.docx`, `.odt`)
+- PowerPoint (`.ppt`, `.pptx`, `.odp`)
+- Spreadsheets (`.xls`, `.xlsx`, `.ods`)
+- EPUB/HTML (`.epub`, `.html`)
+- Images (`.png`, `.jpg`, `.jpeg`, `.webp`, `.gif`, `.tiff`)
+
+### Output
+
+- Markdown (`.md`, default)
+- JSON (`.json`)
+- HTML (`.html`)
+
+## Installation
+
+```bash
+pip install pdf-to-markdown-cli
+```
+
+From source:
+
+```bash
+git clone https://github.com/SokolskyNikita/pdf-to-markdown-cli.git
+cd pdf-to-markdown-cli
+pip install -e .
+```
+
+## Quick start
+
+```bash
+export MARKER_PDF_KEY="your_api_key"
+pdf-to-md ./examples/equations.pdf
+```
+
+Process a directory:
+
+```bash
+pdf-to-md ./docs
+```
+
+Use JSON or HTML output:
+
+```bash
+pdf-to-md ./examples/equations.pdf --json
+pdf-to-md ./examples/equations.pdf --html
+```
+
+## CLI options
+
+- `input`: input file or directory path
+- `--json`: output JSON instead of Markdown
+- `--html`: output HTML instead of Markdown
+- `--langs`: comma-separated OCR languages (default: `English`)
+- `--llm`: enable LLM-enhanced processing
+- `--strip`: redo OCR
+- `--noimg`: disable image extraction
+- `--force`: force OCR on all pages
+- `--pages`: include page delimiters
+- `--max`: enable all OCR enhancement flags (`--llm --strip --force`)
+- `-mp`, `--max-pages`: process only the first N pages
+- `--no-chunk`: disable PDF chunking
+- `-cs`, `--chunk-size`: PDF pages per chunk (default: `25`)
+- `-o`, `--output-dir`: absolute output directory path
+- `-v`, `--verbose`: debug logging
+- `--version`: show installed package version
+
+## Development
+
+Run tests:
+
+```bash
+python -m unittest discover -s tests -v
+```
+
+For contributions or questions, open a GitHub issue.

pdf_to_markdown_cli-0.5.2/README.md

@@ -0,0 +1,95 @@
+# PDF to markdown CLI
+
+[![PyPI](https://img.shields.io/pypi/v/pdf-to-markdown-cli.svg)](https://pypi.org/project/pdf-to-markdown-cli/)
+[![Python versions](https://img.shields.io/pypi/pyversions/pdf-to-markdown-cli.svg)](https://pypi.org/project/pdf-to-markdown-cli/)
+[![License: MIT](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
+
+Command-line utility for converting PDFs and other supported documents into Markdown, JSON, or HTML using the [Marker API](https://www.datalab.to/marker).
+
+## Why use this tool
+
+- Converts single files or entire directories
+- Automatically splits large PDFs into chunks and merges results
+- Persists request state locally so interrupted runs can recover
+- Rewrites and copies extracted images into deterministic output folders
+- Supports OCR/LLM tuning flags from the Marker API
+
+## Supported formats
+
+### Input
+
+- PDF (`.pdf`)
+- Word (`.doc`, `.docx`, `.odt`)
+- PowerPoint (`.ppt`, `.pptx`, `.odp`)
+- Spreadsheets (`.xls`, `.xlsx`, `.ods`)
+- EPUB/HTML (`.epub`, `.html`)
+- Images (`.png`, `.jpg`, `.jpeg`, `.webp`, `.gif`, `.tiff`)
+
+### Output
+
+- Markdown (`.md`, default)
+- JSON (`.json`)
+- HTML (`.html`)
+
+## Installation
+
+```bash
+pip install pdf-to-markdown-cli
+```
+
+From source:
+
+```bash
+git clone https://github.com/SokolskyNikita/pdf-to-markdown-cli.git
+cd pdf-to-markdown-cli
+pip install -e .
+```
+
+## Quick start
+
+```bash
+export MARKER_PDF_KEY="your_api_key"
+pdf-to-md ./examples/equations.pdf
+```
+
+Process a directory:
+
+```bash
+pdf-to-md ./docs
+```
+
+Use JSON or HTML output:
+
+```bash
+pdf-to-md ./examples/equations.pdf --json
+pdf-to-md ./examples/equations.pdf --html
+```
+
+## CLI options
+
+- `input`: input file or directory path
+- `--json`: output JSON instead of Markdown
+- `--html`: output HTML instead of Markdown
+- `--langs`: comma-separated OCR languages (default: `English`)
+- `--llm`: enable LLM-enhanced processing
+- `--strip`: redo OCR
+- `--noimg`: disable image extraction
+- `--force`: force OCR on all pages
+- `--pages`: include page delimiters
+- `--max`: enable all OCR enhancement flags (`--llm --strip --force`)
+- `-mp`, `--max-pages`: process only the first N pages
+- `--no-chunk`: disable PDF chunking
+- `-cs`, `--chunk-size`: PDF pages per chunk (default: `25`)
+- `-o`, `--output-dir`: absolute output directory path
+- `-v`, `--verbose`: debug logging
+- `--version`: show installed package version
+
+## Development
+
+Run tests:
+
+```bash
+python -m unittest discover -s tests -v
+```
+
+For contributions or questions, open a GitHub issue.

pdf_to_markdown_cli-0.5.2/pyproject.toml

@@ -0,0 +1,74 @@
+[build-system]
+requires = ["setuptools>=69.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "pdf-to-markdown-cli"
+version = "0.5.2"
+description = "CLI utility to convert PDFs and supported document formats to Markdown/JSON/HTML with Marker API."
+readme = { file = "README.md", content-type = "text/markdown" }
+authors = [
+    { name = "Nikita Sokolsky", email = "sokolx@gmail.com" },
+]
+maintainers = [
+    { name = "Nikita Sokolsky", email = "sokolx@gmail.com" },
+]
+license = "MIT"
+license-files = ["LICENSE"]
+requires-python = ">=3.10"
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Intended Audience :: End Users/Desktop",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Operating System :: OS Independent",
+    "Environment :: Console",
+    "Topic :: Office/Business",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Topic :: Text Processing",
+    "Topic :: Utilities",
+]
+keywords = ["pdf", "markdown", "converter", "cli", "document", "marker", "md"]
+dependencies = [
+    "backoff>=2.0",
+    "diskcache>=5.0",
+    "filetype>=1.0",
+    "pikepdf>=8.0",
+    "pydantic>=2.0",
+    "ratelimit>=2.0",
+    "requests>=2.0",
+    "tqdm>=4.0",
+]
+
+[project.urls]
+"Homepage" = "https://github.com/SokolskyNikita/pdf-to-markdown-cli"
+"Repository" = "https://github.com/SokolskyNikita/pdf-to-markdown-cli"
+"Documentation" = "https://github.com/SokolskyNikita/pdf-to-markdown-cli#readme"
+"Issues" = "https://github.com/SokolskyNikita/pdf-to-markdown-cli/issues"
+"Changelog" = "https://github.com/SokolskyNikita/pdf-to-markdown-cli/releases"
+
+[project.scripts]
+pdf-to-md = "docs_to_md.main:main"
+
+[project.optional-dependencies]
+test = [
+    "pytest>=8.3.0",
+    "pytest-cov>=5.0.0",
+]
+dev = [
+    "build>=1.2.0",
+    "twine>=5.1.0",
+    "ruff>=0.11.0",
+    "types-requests>=2.32.0",
+]
+
+[tool.setuptools]
+package-dir = { "" = "src" }
+include-package-data = true
+
+[tool.setuptools.packages.find]
+where = ["src"]

{pdf_to_markdown_cli-0.5.1 → pdf_to_markdown_cli-0.5.2}/src/docs_to_md/api/client.py

@@ -1,5 +1,6 @@
 import json
 import logging
+import mimetypes
 from pathlib import Path
 from typing import Optional
 
@@ -27,6 +28,19 @@ logger = logging.getLogger(__name__)
 
 class MarkerClient:
     BASE_MARKER_API_ENDPOINT = "https://www.datalab.to/api/v1/marker"
+    _EXTENSION_TO_MIME = {
+        ".doc": "application/msword",
+        ".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+        ".odt": "application/vnd.oasis.opendocument.text",
+        ".ppt": "application/vnd.ms-powerpoint",
+        ".pptx": "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+        ".odp": "application/vnd.oasis.opendocument.presentation",
+        ".xls": "application/vnd.ms-excel",
+        ".xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+        ".ods": "application/vnd.oasis.opendocument.spreadsheet",
+        ".epub": "application/epub+zip",
+        ".html": "text/html",
+    }
 
     # See datalab_marker_api_docs.md#authentication for API key details
     def __init__(self, api_key: str):
@@ -35,6 +49,19 @@ class MarkerClient:
 
         self.headers = {"X-Api-Key": api_key.strip()}
 
+    def _detect_mime_type(self, file_path: Path, file_data: bytes) -> Optional[str]:
+        """Infer MIME type from file header first, then file extension."""
+        detected = filetype.guess(file_data)
+        if detected and detected.mime:
+            return detected.mime
+
+        suffix = file_path.suffix.lower()
+        if suffix in self._EXTENSION_TO_MIME:
+            return self._EXTENSION_TO_MIME[suffix]
+
+        guessed, _ = mimetypes.guess_type(file_path.name)
+        return guessed
+
     @sleep_and_retry
     @limits(calls=MAX_REQUESTS_PER_MINUTE, period=60)
     @backoff.on_exception(
@@ -62,16 +89,17 @@ class MarkerClient:
                 raise APIError(f"File not found: {file_path}")
 
             file_data = FileIO.read_file(file_path)
-            kind = filetype.guess(file_data)
+            mime_type = self._detect_mime_type(file_path, file_data)
 
             # Supported types listed in datalab_marker_api_docs.md#supported-file-types
-            if not kind or kind.mime not in SUPPORTED_MIME_TYPES:
+            if not mime_type or mime_type not in SUPPORTED_MIME_TYPES:
                 raise APIError(
-                    f"Unsupported file type: {kind.mime if kind else 'unknown'}"
+                    f"Unsupported file type for '{file_path.name}': "
+                    f"{mime_type or 'unknown'}"
                 )
 
             form_data = {
-                "file": (file_path.name, file_data, kind.mime),
+                "file": (file_path.name, file_data, mime_type),
                 "langs": (None, langs),
                 "output_format": (None, output_format),
             }

{pdf_to_markdown_cli-0.5.1 → pdf_to_markdown_cli-0.5.2}/src/docs_to_md/api/models.py

@@ -50,45 +50,63 @@ SUPPORTED_FORMAT_EXTENSIONS = {
     "markdown": ".md",
     "json": ".json",
     "html": ".html",
-    "txt": ".txt"
 }
 
 SUPPORTED_IMAGE_EXTENSIONS: Set[str] = {
     "jpg",
     "jpeg",
     "png",
+    "webp",
     "gif",
-    "tiff"
+    "tiff",
 }
 
 SUPPORTED_INPUT_EXTENSIONS: Set[str] = {
     "pdf",
     "docx",
     "doc",
+    "odt",
     "pptx",
     "ppt",
+    "odp",
+    "xlsx",
+    "xls",
+    "ods",
+    "epub",
+    "html",
     "jpg",
     "jpeg",
     "png",
+    "webp",
     "gif",
-    "tiff"
+    "tiff",
 }
 
 # Supported mime types according to datalab_marker_api_docs.md#supported-file-types
 SUPPORTED_MIME_TYPES: Set[str] = {
     # PDF
-    'application/pdf',
+    "application/pdf",
     # Word documents
-    'application/msword',
-    'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+    "application/msword",
+    "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+    "application/vnd.oasis.opendocument.text",
     # Powerpoint
-    'application/vnd.ms-powerpoint',
-    'application/vnd.openxmlformats-officedocument.presentationml.presentation',
+    "application/vnd.ms-powerpoint",
+    "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+    "application/vnd.oasis.opendocument.presentation",
+    # Spreadsheets
+    "application/vnd.ms-excel",
+    "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+    "application/vnd.oasis.opendocument.spreadsheet",
+    # HTML/EPUB
+    "text/html",
+    "application/xhtml+xml",
+    "application/epub+zip",
     # Images
-    'image/png',
-    'image/jpeg',
-    'image/webp',
-    'image/gif',
-    'image/tiff',
-    'image/jpg'
+    "image/png",
+    "image/jpeg",
+    "image/webp",
+    "image/gif",
+    "image/tiff",
+    "image/jpg",
 } 

{pdf_to_markdown_cli-0.5.1 → pdf_to_markdown_cli-0.5.2}/src/docs_to_md/config/cli.py

@@ -16,7 +16,7 @@ def parse_args() -> argparse.Namespace:
         __version__ = 'unknown' # Fallback if package not installed
         
     parser = argparse.ArgumentParser(
-        description="Process PDF files using Marker API.",
+        description="Process documents with the Marker API.",
         formatter_class=argparse.ArgumentDefaultsHelpFormatter
     )
     
@@ -28,8 +28,10 @@ def parse_args() -> argparse.Namespace:
     )
     
     parser.add_argument("input", help="Input file or directory path")
-    
-    parser.add_argument("--json", action="store_true", help="Output in JSON format")
+
+    output_group = parser.add_mutually_exclusive_group()
+    output_group.add_argument("--json", action="store_true", help="Output in JSON format")
+    output_group.add_argument("--html", action="store_true", help="Output in HTML format")
     
     parser.add_argument("-l", "--langs", default="English", help="Comma-separated OCR languages")
     parser.add_argument("--llm", action="store_true", help="Use LLM for enhanced processing")
@@ -54,17 +56,23 @@ def create_config_from_args() -> Config:
     
     try:
         api_key = get_env_var("MARKER_PDF_KEY")
-    except Exception as e:
+    except FileError as e:
         raise ConfigurationError(f"API key not found: {e}. Set the MARKER_PDF_KEY environment variable.")
         
     # If --no-chunk is specified, override chunk size to effectively disable chunking
     chunk_size = 1_000_000 if args.no_chunk else args.chunk_size
     
+    output_format = "markdown"
+    if args.json:
+        output_format = "json"
+    elif args.html:
+        output_format = "html"
+
     config = Config(
         api_key=api_key,
         input_path=args.input,
         output_dir=Path(args.output_dir) if args.output_dir else None,
-        output_format="json" if args.json else "markdown",
+        output_format=output_format,
         langs=args.langs,
         use_llm=args.llm or args.max,
         strip_existing_ocr=args.strip or args.max,

pdf_to_markdown_cli-0.5.2/src/docs_to_md/config/settings.py

@@ -0,0 +1,99 @@
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Optional
+import logging
+import tempfile
+
+from docs_to_md.api.models import SUPPORTED_FORMAT_EXTENSIONS
+from docs_to_md.utils.exceptions import ConfigurationError
+
+logger = logging.getLogger(__name__)
+SETTINGS_DIR_NAME = ".docs_to_md"
+
+
+@dataclass
+class Config:
+    """Global configuration for marker PDF conversion."""
+    api_key: str
+    
+    input_path: str
+    output_dir: Optional[Path] = None
+    cache_dir: Path = Path.home() / SETTINGS_DIR_NAME / "cache" # Root directory for cache files
+    root_tmp_dir: Path = Path.home() / SETTINGS_DIR_NAME / "tmp" # Root directory for temporary files
+    
+    output_format: str = "markdown"
+    langs: str = "English"
+    chunk_size: int = 25
+    
+    use_llm: bool = False
+    strip_existing_ocr: bool = False
+    disable_image_extraction: bool = False
+    force_ocr: bool = False
+    paginate: bool = False
+    max_pages: Optional[int] = None
+
+    @staticmethod
+    def _resolve_writable_directory(path: Path, label: str) -> Path:
+        resolved = Path(path).expanduser().resolve(strict=False)
+
+        try:
+            resolved.mkdir(parents=True, exist_ok=True)
+            probe_path = resolved / ".write_probe"
+            probe_path.write_text("")
+            probe_path.unlink(missing_ok=True)
+            return resolved
+        except OSError as error:
+            fallback = (
+                Path(tempfile.gettempdir()) / SETTINGS_DIR_NAME / label
+            ).resolve(strict=False)
+            try:
+                fallback.mkdir(parents=True, exist_ok=True)
+                probe_path = fallback / ".write_probe"
+                probe_path.write_text("")
+                probe_path.unlink(missing_ok=True)
+            except OSError as fallback_error:
+                raise ConfigurationError(
+                    f"{label} directory is not writable: '{resolved}' "
+                    f"(fallback '{fallback}' also failed: {fallback_error})"
+                ) from fallback_error
+
+            logger.warning(
+                "Directory '%s' is not writable (%s); falling back to '%s'.",
+                resolved,
+                error,
+                fallback,
+            )
+            return fallback
+            
+    def validate(self) -> None:
+        self.output_format = (self.output_format or "").strip().lower()
+        if not self.api_key:
+            raise ConfigurationError("API key is required")
+                    
+        if not self.input_path:
+            raise ConfigurationError("Input path is required")
+
+        normalized_input = Path(self.input_path).expanduser()
+        if not normalized_input.exists():
+            raise ConfigurationError(f"Input path does not exist: {self.input_path}")
+        self.input_path = str(normalized_input.resolve())
+        
+        if 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:
+            raise ConfigurationError("Max pages must be at least 1")
+            
+        if not self.output_format or self.output_format not in SUPPORTED_FORMAT_EXTENSIONS:
+            raise ConfigurationError(f"Unsupported output format: {self.output_format}")
+
+        if self.output_dir is not None:
+            output_dir = Path(self.output_dir).expanduser()
+            if not output_dir.is_absolute():
+                raise ConfigurationError(
+                    f"Output directory must be an absolute path: {self.output_dir}"
+                )
+            self.output_dir = output_dir.resolve(strict=False)
+
+        self.cache_dir = self._resolve_writable_directory(self.cache_dir, "cache")
+        self.root_tmp_dir = self._resolve_writable_directory(self.root_tmp_dir, "tmp")