markitdown-pro 1.3.2__tar.gz → 1.3.4__tar.gz

{markitdown_pro-1.3.2 → markitdown_pro-1.3.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: markitdown-pro
-Version: 1.3.2
+Version: 1.3.4
 Summary: A package that converts almost any file format to Markdown.
 Author: Developer
 Classifier: Programming Language :: Python :: 3
@@ -29,6 +29,8 @@ Requires-Dist: youtube-transcript-api
 Requires-Dist: tabulate
 Requires-Dist: ebooklib
 Requires-Dist: beautifulsoup4
+Requires-Dist: cairosvg
+Requires-Dist: pillow_heif
 Dynamic: author
 Dynamic: classifier
 Dynamic: description

{markitdown_pro-1.3.2 → markitdown_pro-1.3.4}/markitdown_pro/conversion_pipeline.py

@@ -39,6 +39,7 @@ import httpx
 
 from .common.logger import logger
 from .common.utils import clean_markdown, detect_extension, ensure_minimum_content
+from .converters.azure_doc_intel_wrapper import DocIntelligenceWrapper
 from .handlers.audio_handler import AudioHandler
 from .handlers.base_handler import BaseHandler
 from .handlers.email_handler import EmailHandler
@@ -88,6 +89,7 @@ class ConversionPipeline:
         self.pst_handler = PSTHandler()
         self.ipynb_handler = IpynbHandler()
         self.markitdown_handler = MarkItDownHandler()
+        self.doc_intel_wrapper = DocIntelligenceWrapper()
 
         # Map extensions to handlers (normalized lowercase with dot)
         self.handlers_mapping: dict[str, BaseHandler] = {
@@ -108,7 +110,7 @@ class ConversionPipeline:
             # region Images
             ".bmp": self.image_handler,
             ".gif": self.image_handler,
-            ".heic": self.image_handler,
+            # ".heic": self.image_handler,
             ".jpeg": self.image_handler,
             ".jpg": self.image_handler,
             ".png": self.image_handler,
@@ -129,8 +131,8 @@ class ConversionPipeline:
             ".tsv": self.tabular_handler,
             # endregion
             # region Office/Spreadsheet/Slides
-            ".xls": self.office_handler,
-            ".xlsx": self.office_handler,
+            ".xls": self.tabular_handler,
+            ".xlsx": self.tabular_handler,
             ".docx": self.office_handler,
             # ".odt": self.office_handler,
             # ".rtf": self.office_handler,
@@ -161,7 +163,11 @@ class ConversionPipeline:
     # ---------------------------------------------------------------------
 
     async def convert_document_to_md(
-        self, file_path: str | Path, output_md: Optional[str | Path] = None
+        self,
+        file_path: str | Path,
+        output_md: Optional[str | Path] = None,
+        *args,
+        **kwargs,
     ) -> Optional[str]:
         """
         Convert a **local file** to Markdown.
@@ -193,7 +199,7 @@ class ConversionPipeline:
             raise RuntimeError(f"No handler for extension '{extension}'.")
 
         try:
-            md_content = await handler.handle(str(file_path))
+            md_content = await handler.handle(str(file_path), *args, **kwargs)
             if not md_content or not ensure_minimum_content(md_content):
                 return None
 
@@ -281,3 +287,29 @@ class ConversionPipeline:
             return await self.convert_document_to_md(local_path, output_md=output_md)
         finally:
             local_path.unlink(missing_ok=True)
+
+    async def get_page_count(self, file_path: str | Path) -> Optional[int]:
+        """
+        Get the page count of a document if supported by its handler.
+
+        Parameters
+        ----------
+        file_path : str | Path
+            Path to the local file.
+        """
+        file_path = Path(file_path)
+        if not file_path.is_file():
+            raise ValueError(f"The provided path '{file_path}' is not a valid file.")
+
+        # handle file extensions individually to avoid using the wrong handlers
+        extension = detect_extension(str(file_path)).lower()
+
+        if extension in self.image_handler.SUPPORTED_EXTENSIONS:
+            return await self.image_handler.get_page_count(file_path)
+        elif extension in self.pdf_handler.SUPPORTED_EXTENSIONS:
+            return await self.doc_intel_wrapper.get_page_count(file_path)
+        # elif extension in self.doc_intel_wrapper.SUPPORTED_EXTENSIONS:
+        #     return await self.doc_intel_wrapper.get_page_count(file_path)
+        else:
+            logger.warning(f"ConversionPipeline: No page count support for extension '{extension}'")
+            return None

{markitdown_pro-1.3.2 → markitdown_pro-1.3.4}/markitdown_pro/converters/azure_doc_intel_wrapper.py

@@ -1,3 +1,4 @@
+from pathlib import Path
 from typing import Optional
 
 from ..services.azure_doc_intelligence import DocumentIntelligenceHandler
@@ -16,3 +17,6 @@ class DocIntelligenceWrapper(ConverterWrapper):
         markdown = await self.converter.convert_to_md(file_path)
         await self.converter.aclose()
         return markdown
+
+    async def get_page_count(self, file_path: str | Path) -> Optional[int]:
+        return await self.converter.get_page_count(file_path)

{markitdown_pro-1.3.2 → markitdown_pro-1.3.4}/markitdown_pro/converters/markitdown_wrapper.py

@@ -3,6 +3,7 @@ from typing import Optional
 from markitdown_pro.handlers.markitdown_handler import MarkItDownHandler
 
 from ..common.logger import logger
+from ..common.utils import detect_extension
 from .base import ConverterWrapper
 
 
@@ -14,7 +15,7 @@ class MarkItDownWrapper(ConverterWrapper):
         self.handler = MarkItDownHandler(*args, **kwargs)
 
     async def convert(self, file_path: str) -> Optional[str]:
-        file_extension = f".{file_path.split('.')[-1].lower()}"
+        file_extension = detect_extension(file_path)
         if file_extension not in self.SUPPORTED_EXTENSIONS:
             logger.warning(f"MarkItDownWrapper: Unsupported file format: {file_extension}")
             return None

{markitdown_pro-1.3.2 → markitdown_pro-1.3.4}/markitdown_pro/converters/pymupdf_wrapper.py

@@ -3,6 +3,7 @@ from typing import Optional
 import fitz  # PyMuPDF
 
 from ..common.logger import logger
+from ..common.utils import detect_extension
 from .base import ConverterWrapper
 
 
@@ -13,11 +14,7 @@ class PyMuPDFWrapper(ConverterWrapper):
         super().__init__("PyMuPDF")
 
     async def convert(self, file_path: str) -> Optional[str]:
-        file_extension = file_path.split(".")[-1].lower()
-        logger.info(
-            f"PyMuPDFWrapper: Processing file: {file_path} with extension: {file_extension}"
-        )
-
+        file_extension = detect_extension(file_path)
         if file_extension not in self.SUPPORTED_EXTENSIONS:
             logger.warning(f"PyMuPDFWrapper: Unsupported file format: {file_extension}")
             return None

{markitdown_pro-1.3.2 → markitdown_pro-1.3.4}/markitdown_pro/handlers/audio_handler.py

@@ -3,9 +3,9 @@ from __future__ import annotations
 from typing import Optional
 
 from ..common.logger import logger
+from ..common.utils import ensure_minimum_content
 from ..converters.azure_speech_wrapper import AzureSpeechWrapper
 from ..converters.base import ConverterWrapper
-from ..converters.markitdown_wrapper import MarkItDownWrapper
 from ..handlers.base_handler import BaseHandler
 
 
@@ -13,8 +13,7 @@ class AudioHandler(BaseHandler):
     """
     Convert audio files to Markdown by trying two converters in order:
 
-      1) **MarkItDown** — fast local extractor (works when the file format is supported).
-      2) **Azure Speech** — cloud speech-to-text fallback for actual audio transcription.
+      1) **Azure Speech** — cloud speech-to-text fallback for actual audio transcription.
 
     The first converter that yields non-trivial Markdown (as determined by
     `ensure_minimum_content`) is returned. If both fail, `None` is returned.
@@ -26,27 +25,13 @@ class AudioHandler(BaseHandler):
     - This handler runs converters **sequentially** to avoid unnecessary API calls.
     """
 
-    SUPPORTED_EXTENSIONS = frozenset(
-        {
-            ".mp3",
-            ".wav",
-            ".ogg",
-            ".flac",
-            ".m4a",
-            ".aac",
-            ".wma",
-            ".webm",
-            ".opus",
-        }
-    )
+    SUPPORTED_EXTENSIONS = AzureSpeechWrapper.SUPPORTED_EXTENSIONS
 
     def __init__(self, *args, **kwargs) -> None:
         super().__init__(*args, **kwargs)
-        self.markitdown = MarkItDownWrapper()
         self.azure_speech = AzureSpeechWrapper()
 
         self._pipeline: list[tuple[ConverterWrapper, str]] = [
-            (self.markitdown, "MarkItDown"),
             (self.azure_speech, "Azure Speech"),
         ]
 
@@ -71,7 +56,8 @@ class AudioHandler(BaseHandler):
             logger.info(f"AudioHandler: Trying {name} for '{file_path}'")
             try:
                 md = await converter.convert(file_path)
-                return md
+                if md and ensure_minimum_content(md):
+                    return md
             except Exception as e:
                 logger.error(f"AudioHandler: {name} failed for '{file_path}': {e}")
 

{markitdown_pro-1.3.2 → markitdown_pro-1.3.4}/markitdown_pro/handlers/image_handler.py

@@ -1,7 +1,9 @@
 import contextlib
+from pathlib import Path
 from typing import Optional
 
 from ..common.logger import logger
+from ..common.utils import detect_extension
 from ..converters.gpt_vision_wrapper import GPTVisionWrapper
 from .base_handler import BaseHandler
 
@@ -37,6 +39,27 @@ class ImageHandler(BaseHandler):
                 if hasattr(self.gpt_vision, "gpt_vision"):
                     await self.gpt_vision.gpt_vision.aclose()
 
+    async def get_page_count(self, file_path: str | Path) -> Optional[int]:
+        """
+        Determines the number of pages in the given image file.
+        """
+        p = Path(file_path)
+        ext = detect_extension(str(p.absolute()))
+        if ext not in self.SUPPORTED_EXTENSIONS:
+            logger.warning(f"ImageHandler: Unsupported file format: {ext}")
+            return None
+
+        if ext in {".tif", ".tiff"}:
+            try:
+                from PIL import Image, ImageSequence  # optional dependency
+
+                with Image.open(str(p)) as im:
+                    return sum(1 for _ in ImageSequence.Iterator(im)) or 1
+            except Exception as e_tiff:
+                logger.warning(f"ImageHandler: local TIFF page count failed for '{p}': {e_tiff}")
+        else:
+            return 1
+
     async def aclose(self) -> None:
         if hasattr(self, "gpt_vision") and self.gpt_vision:
             await self.gpt_vision.aclose()

{markitdown_pro-1.3.2 → markitdown_pro-1.3.4}/markitdown_pro/handlers/office_handler.py

@@ -4,7 +4,6 @@ from ..common.logger import logger
 from ..converters.azure_doc_intel_wrapper import DocIntelligenceWrapper
 from ..converters.base import ConverterWrapper
 from ..converters.markitdown_wrapper import MarkItDownWrapper
-from ..converters.tabular_wrapper import TabularWrapper
 from ..converters.unstructured_wrapper import UnstructuredWrapper
 from .base_handler import BaseHandler
 
@@ -13,10 +12,9 @@ class OfficeHandler(BaseHandler):
     """
     Convert Office documents to Markdown by trying a series of converters in order:
 
-      1) TabularHandler (specialized handler for tabular data)
-      2) MarkItDown (fast, local parsing for Office formats)
-      3) Azure Document Intelligence (cloud extraction + OCR for embedded images)
-      4) Unstructured (robust fallback parser)
+      1) MarkItDown (fast, local parsing for Office formats)
+      2) Azure Document Intelligence (cloud extraction + OCR for embedded images)
+      3) Unstructured (robust fallback parser)
 
     The first converter that returns non-trivial Markdown (as judged by
     `ensure_minimum_content`) wins. If all fail, `None` is returned.
@@ -28,21 +26,18 @@ class OfficeHandler(BaseHandler):
       avoid unnecessary API calls when earlier options succeed.
     """
 
-    # Supported Office-like extensions (lowercase with dot)
     SUPPORTED_EXTENSIONS = frozenset({".doc", ".docx", ".odt", ".rtf", ".ppt", ".pptx"})
 
     def __init__(self, *args, **kwargs) -> None:
         super().__init__(*args, **kwargs)
 
         # Ordered, fastest → most comprehensive
-        self.tabular = TabularWrapper()
         self.markitdown = MarkItDownWrapper()
         self.doc_intelligence = DocIntelligenceWrapper()
         self.unstructured = UnstructuredWrapper()
 
         # (converter, human_readable_name) in the exact order to try
         self._pipeline: list[tuple[ConverterWrapper, str]] = [
-            (self.tabular, "TabularHandler"),
             (self.markitdown, "MarkItDown"),
             (self.doc_intelligence, "Azure Document Intelligence"),
             (self.unstructured, "Unstructured"),

markitdown_pro-1.3.4/markitdown_pro/handlers/pdf_handler.py

@@ -0,0 +1,377 @@
+import asyncio
+import os
+import re
+import tempfile
+from contextlib import contextmanager
+from enum import Enum
+from itertools import groupby
+from operator import itemgetter
+from pathlib import Path
+from typing import Optional
+
+import fitz
+
+from ..common.logger import logger
+from ..common.utils import detect_extension
+from ..converters.azure_doc_intel_wrapper import DocIntelligenceWrapper
+from ..converters.gpt_vision_wrapper import GPTVisionWrapper
+from ..converters.markitdown_wrapper import MarkItDownWrapper
+from ..converters.pymupdf_wrapper import PyMuPDFWrapper
+from ..converters.unstructured_wrapper import UnstructuredWrapper
+from .base_handler import BaseHandler
+
+
+class ConversionError(Exception):
+    pass
+
+
+# region helpers: page parsing / slicing
+def _parse_pages_spec(pages: str | list[int], total_pages: int) -> list[int]:
+    """Return a sorted, de-duped, 0-based list of page indexes within bounds."""
+    if pages is None:
+        return list(range(total_pages))
+    if isinstance(pages, (list, tuple)):
+        idxs = [int(p) - 1 if p >= 1 else int(p) for p in pages]  # allow 1-based
+    else:
+        idxs = []
+        for tok in re.split(r"[,\s]+", pages.strip()):
+            if not tok:
+                continue
+            if "-" in tok:
+                a, b = tok.split("-", 1)
+                a, b = int(a), int(b)
+                if a > b:
+                    a, b = b, a
+                idxs.extend(range(a - 1, b))  # user passes 1-based
+            else:
+                idxs.append(int(tok) - 1)
+    idxs = sorted(set(i for i in idxs if 0 <= i < total_pages))
+    return idxs
+
+
+def _coalesce_runs(idxs: list[int]) -> list[tuple[int, int]]:
+    """Turn [0,1,2,4,7,8] into [(0,2),(4,4),(7,8)]"""
+    runs = []
+    for k, g in groupby(enumerate(idxs), key=lambda t: t[0] - t[1]):
+        group = list(map(itemgetter(1), g))
+        runs.append((group[0], group[-1]))
+    return runs
+
+
+@contextmanager
+def _maybe_slice_pdf(src_path: str, page_idxs: list[int], total_pages: int):
+    """Yield original pdf if full-range, else a temp sliced pdf with selected pages."""
+    full_range = (
+        len(page_idxs) == total_pages and page_idxs[0] == 0 and page_idxs[-1] == total_pages - 1
+    )
+    if full_range:
+        yield src_path
+        return
+    import fitz
+
+    tmp = tempfile.NamedTemporaryFile(delete=False, suffix=".pdf")
+    tmp.close()
+    try:
+        with fitz.open(src_path) as src:
+            dst = fitz.open()
+            for start, end in _coalesce_runs(page_idxs):
+                dst.insert_pdf(src, from_page=start, to_page=end)
+            dst.save(tmp.name)
+            dst.close()
+        yield tmp.name
+    finally:
+        try:
+            os.remove(tmp.name)
+        except Exception:
+            pass
+
+
+# endregion
+
+
+class PDFType(Enum):
+    """
+    Simple classification of a PDF based on page contents.
+
+    - TEXT_ONLY:        Every page has "enough" extractable text; no pages contain images.
+    - TEXT_PLUS_IMAGES: At least one page contains text and at least one page contains images.
+    - ALL_IMAGES:       Every page has at least one image and no page has "enough" text
+                        (typical of scanned/image-only PDFs).
+    """
+
+    TEXT_ONLY = "TEXT_ONLY"
+    TEXT_PLUS_IMAGES = "TEXT_PLUS_IMAGES"
+    ALL_IMAGES = "ALL_IMAGES"
+
+
+class PDFHandler(BaseHandler):
+    """
+    Orchestrates PDF → Markdown conversion by trying a sequence of converters
+    chosen from a text-oriented pipeline or an image/OCR pipeline depending
+    on a quick content scan of the PDF.
+
+    The flow is:
+      1) `_detect_pdf_type` runs a fast pass over the PDF (offloaded to a thread)
+         to count text-bearing and image-bearing pages.
+      2) Based on the detected `PDFType`, choose a pipeline:
+           - TEXT_ONLY:         text pipeline
+           - ALL_IMAGES:        image pipeline (OCR)
+           - TEXT_PLUS_IMAGES:  image pipeline (OCR)
+      3) Iterate the chosen converters in order until one returns acceptable Markdown.
+
+    Notes:
+    - Converters MUST implement an async `convert(file_path: str) -> Optional[str]`.
+    - `ensure_minimum_content` is used to filter out trivial/empty results.
+    """
+
+    # File extensions handled by this handler
+    SUPPORTED_EXTENSIONS = frozenset([".pdf"])
+
+    def __init__(self, *args, **kwargs) -> None:
+        super().__init__(*args, **kwargs)
+
+        # Text-first converters (fastest/cheapest first, progressively more robust)
+        self.markitdown = MarkItDownWrapper()
+        self.unstructured = UnstructuredWrapper()
+        self.pymu = PyMuPDFWrapper()
+        self.azure_docint = DocIntelligenceWrapper()
+
+        # OCR-based converter for scanned/image-only PDFs
+        self.gpt_vision = GPTVisionWrapper()
+
+        # Pipelines in the order they should be attempted
+        self.text_pipeline = [self.markitdown, self.unstructured, self.pymu, self.azure_docint]
+        self.image_pipeline = [self.gpt_vision]
+
+    async def handle(self, file_path: str, *args, **kwargs) -> Optional[str]:
+        """
+        Convert a PDF to Markdown, honoring page selection from kwargs only.
+
+        Expected kwargs:
+        - pages: list[int] (1-based page numbers). If absent/invalid → process all pages.
+        """
+        try:
+            # Resolve selection to 0-based page indexes (offloaded: PyMuPDF is CPU-bound)
+            def _resolve():
+                with fitz.open(file_path) as doc:
+                    total = doc.page_count
+                pages_kw = kwargs.get("pages", None)
+                if isinstance(pages_kw, list) and all(isinstance(p, int) for p in pages_kw):
+                    idxs = sorted(set(p - 1 for p in pages_kw))
+                    idxs = [i for i in idxs if 0 <= i < total]
+                    if not idxs:
+                        logger.warning(
+                            f"PDFHandler: 'pages' kwarg produced no valid pages for {file_path}; defaulting to all pages."
+                        )
+                        idxs = list(range(total))
+                else:
+                    if pages_kw is not None:
+                        logger.warning(
+                            "PDFHandler: 'pages' must be a list[int] (1-based). Defaulting to all pages."
+                        )
+                    idxs = list(range(total))
+                return idxs, total
+
+            page_idxs, total_pages = await asyncio.to_thread(_resolve)
+
+            # Detect type using only the selected pages
+            pdf_type = await self._detect_pdf_type(file_path, page_indexes=page_idxs)
+            pipeline = (
+                self.image_pipeline
+                if pdf_type in (PDFType.ALL_IMAGES, PDFType.TEXT_PLUS_IMAGES)
+                else self.text_pipeline
+            )
+
+            # Slice once and feed to converters
+            with _maybe_slice_pdf(file_path, page_idxs, total_pages) as to_process:
+                for converter in pipeline:
+                    preview = [i + 1 for i in page_idxs[:5]]
+                    logger.info(
+                        f"PDFHandler: Trying {converter.name} for {file_path} pages={preview}{'...' if len(page_idxs) > 5 else ''}"
+                    )
+                    try:
+                        md_content = await converter.convert(to_process)
+                        return md_content
+                    except Exception as e:
+                        logger.error(
+                            f"PDFHandler: Converter {converter.name} failed for subset {file_path}: {e}"
+                        )
+
+            raise RuntimeError(f"PDF conversion failed with all converters for {file_path}")
+        except Exception as e:
+            logger.error(f"PDFHandler: Error handling PDF '{file_path}': {e}")
+            return None
+
+    async def _detect_pdf_type(
+        self,
+        file_path: str,
+        page_indexes: list[int] | None = None,
+    ) -> PDFType:
+        """
+        Quickly scan the PDF to decide which pipeline to run.
+
+        Heuristic
+        ---------
+        - A page is considered to have "text" if the extracted text length ≥ `min_text_length_threshold`.
+        - A page is considered to have "images" if `page.get_images(full=True)` returns any entries.
+        - The final classification is derived from counts across all pages.
+
+        Parameters
+        ----------
+        file_path : str
+            Path to the input PDF.
+
+        Returns
+        -------
+        PDFType
+            Classification result used to pick the processing pipeline.
+
+        Raises
+        ------
+        Exception
+            If the file cannot be opened or scanned.
+        """
+        min_text_length_threshold = 20
+        try:
+
+            def _scan() -> PDFType:
+                with fitz.open(file_path) as doc:
+                    total_pages = doc.page_count
+                    idxs = page_indexes or list(range(total_pages))
+                    pages_with_text = 0
+                    pages_with_images = 0
+                    for i in idxs:
+                        page = doc.load_page(i)
+                        if not page:
+                            continue
+                        if len((page.get_text() or "").strip()) >= min_text_length_threshold:
+                            pages_with_text += 1
+                        if page.get_images(full=True):
+                            pages_with_images += 1
+                    is_text_only = pages_with_text == len(idxs) and pages_with_images == 0
+                    is_all_images = pages_with_images == len(idxs) and pages_with_text == 0
+                    has_text_and_images = pages_with_text > 0 and pages_with_images > 0
+                    if is_text_only:
+                        return PDFType.TEXT_ONLY
+                    elif is_all_images:
+                        return PDFType.ALL_IMAGES
+                    elif has_text_and_images:
+                        return PDFType.TEXT_PLUS_IMAGES
+                    return PDFType.TEXT_PLUS_IMAGES
+
+            return await asyncio.to_thread(_scan)
+        except Exception as e:
+            logger.error(f"PDFHandler: Error analyzing PDF '{file_path}': {e}")
+            raise
+
+    async def get_page_count(self, file_path: str | os.PathLike) -> Optional[int]:
+        p = Path(file_path)
+        ext = detect_extension(str(p.absolute()))
+        if ext not in self.SUPPORTED_EXTENSIONS:
+            logger.warning(f"DocumentIntelligenceHandler: Unsupported file format: {ext}")
+            return None
+        if ext in self.SUPPORTED_EXTENSIONS:
+            try:
+                import pypdf as _pypdf
+
+                try:
+                    reader = _pypdf.PdfReader(str(p))
+                except Exception:
+                    with open(p, "rb") as fh:
+                        reader = _pypdf.PdfReader(fh)
+                return len(reader.pages)
+            except Exception as e_pdf:
+                logger.warning(
+                    f"DocumentIntelligenceHandler: local PDF page count failed for '{p}': {e_pdf}"
+                )
+
+    # async def _run_soffice_convert(
+    #     self, file_path: Path, filter_name: Optional[str] = None, timeout_s: int = 180
+    # ) -> Path:
+    #     """
+    #     Generic converter via LibreOffice 'soffice' headless CLI.
+    #     `filter_name` can be 'writer_pdf_Export' for DOCX or 'impress_pdf_Export' for PPTX.
+    #     Returns final PDF path placed next to the source file.
+    #     """
+    #     soffice = shutil.which("soffice") or shutil.which("libreoffice")
+    #     if not soffice:
+    #         raise ConversionError("LibreOffice not found on PATH (need 'soffice').")
+
+    #     if not file_path.exists():
+    #         raise FileNotFoundError(file_path)
+
+    #     # Output to a temp dir, then move next to source
+    #     tmp_out = Path(tempfile.mkdtemp())
+    #     try:
+    #         convert_to = "pdf" if not filter_name else f"pdf:{filter_name}"
+    #         cmd = [
+    #             soffice,
+    #             "--headless",
+    #             "--invisible",
+    #             "--norestore",
+    #             "--nodefault",
+    #             "--nolockcheck",
+    #             "--nofirststartwizard",
+    #             "--convert-to",
+    #             convert_to,
+    #             str(file_path),
+    #             "--outdir",
+    #             str(tmp_out),
+    #         ]
+
+    #         proc = await asyncio.create_subprocess_exec(
+    #             *cmd, stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE
+    #         )
+    #         try:
+    #             stdout, stderr = await asyncio.wait_for(proc.communicate(), timeout=timeout_s)
+    #         except asyncio.TimeoutError:
+    #             proc.kill()
+    #             raise ConversionError("LibreOffice timed out during conversion")
+
+    #         if proc.returncode != 0:
+    #             raise ConversionError(
+    #                 f"LibreOffice failed (code {proc.returncode}). Stderr: {stderr.decode(errors='ignore')}"
+    #             )
+
+    #         produced = tmp_out / (file_path.stem + ".pdf")
+    #         if not produced.exists():
+    #             # Some LO versions may change the output name; find the first PDF
+    #             candidates = list(tmp_out.glob("*.pdf"))
+    #             if not candidates:
+    #                 raise ConversionError("Expected PDF not created by LibreOffice")
+    #             produced = candidates[0]
+
+    #         final_pdf = file_path.with_suffix(".pdf")
+    #         if final_pdf.exists():
+    #             final_pdf.unlink()
+    #         produced.replace(final_pdf)
+    #         return final_pdf
+    #     finally:
+    #         try:
+    #             # Clean temp dir
+    #             for f in tmp_out.glob("*"):
+    #                 try:
+    #                     f.unlink()
+    #                 except Exception:
+    #                     pass
+    #             tmp_out.rmdir()
+    #         except Exception:
+    #             pass
+
+    # async def docx_to_pdf(self, file_path: str | Path, timeout_s: int = 180) -> Path:
+    #     src = Path(file_path).resolve()
+    #     if src.suffix.lower() != ".docx":
+    #         raise ValueError("docx_to_pdf expects a .docx file")
+    #     # writer filter produces better pagination on Writer docs
+    #     return await self._run_soffice_convert(
+    #         src, filter_name="writer_pdf_Export", timeout_s=timeout_s
+    #     )
+
+    # async def pptx_to_pdf(self, file_path: str | Path, timeout_s: int = 180) -> Path:
+    #     src = Path(file_path).resolve()
+    #     if src.suffix.lower() != ".pptx":
+    #         raise ValueError("pptx_to_pdf expects a .pptx file")
+    #     # impress filter produces better pagination on Impress/PowerPoint
+    #     return await self._run_soffice_convert(
+    #         src, filter_name="impress_pdf_Export", timeout_s=timeout_s
+    #     )