markitdown-pro 2.1.0__tar.gz → 2.1.2__tar.gz

{markitdown_pro-2.1.0 → markitdown_pro-2.1.2}/.github/workflows/test.yml

@@ -1,13 +1,6 @@
 name: '🧪 Test package'
 
 on:
-  push:
-    branches:
-      - main
-    paths:
-      - 'markitdown_pro/**'
-      - 'tests/**'
-      - 'pyproject.toml'
   pull_request:
     branches:
       - main
@@ -15,6 +8,7 @@ on:
       - 'markitdown_pro/**'
       - 'tests/**'
       - 'pyproject.toml'
+  workflow_dispatch:
 
 permissions:
   contents: read

{markitdown_pro-2.1.0 → markitdown_pro-2.1.2}/.gitignore

@@ -25,3 +25,4 @@ docs/
 **/CONTINUITY.md
 **/CHANGELOG.md
 .mcp.json
+.worktrees/

{markitdown_pro-2.1.0 → markitdown_pro-2.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: markitdown-pro
-Version: 2.1.0
+Version: 2.1.2
 Summary: A package that converts almost any file format to Markdown.
 Author: Developer
 License-Expression: MIT

{markitdown_pro-2.1.0 → markitdown_pro-2.1.2}/markitdown_pro/converters/gotenberg_converter.py

@@ -15,10 +15,14 @@ If the Gotenberg service is configured but unreachable at call time,
 converter.
 """
 
+import asyncio
 import contextlib
+import functools
 import os
 import tempfile
+from collections.abc import Awaitable, Callable
 from pathlib import Path
+from typing import TypeVar
 
 import httpx
 
@@ -28,6 +32,52 @@ from .base import Converter
 _COMPONENT = "GotenbergConverter"
 _CONVERT_ENDPOINT = "/forms/libreoffice/convert"
 
+# Transient failures worth retrying. ConnectError is intentionally excluded —
+# "service unreachable" is handled as a graceful skip, not a retry.
+_RETRYABLE_EXC: tuple[type[BaseException], ...] = (
+    httpx.TimeoutException,
+    httpx.RemoteProtocolError,
+    httpx.ReadError,
+    httpx.WriteError,
+)
+
+T = TypeVar("T")
+
+
+def _retry_transient(
+    attempts: int = 3, delays: tuple[float, ...] = (1.0, 3.0)
+) -> Callable[[Callable[..., Awaitable[T | None]]], Callable[..., Awaitable[T | None]]]:
+    """Retry an async method on transient httpx errors. Sleeps between attempts
+    are taken from ``delays`` (short, fixed backoff — enough to ride out a
+    worker restart or a brief connection hiccup)."""
+
+    def decorator(
+        fn: Callable[..., Awaitable[T | None]],
+    ) -> Callable[..., Awaitable[T | None]]:
+        """Wrap ``fn`` with the retry-on-transient-httpx-errors policy above."""
+
+        @functools.wraps(fn)
+        async def wrapper(self, *args, **kwargs) -> T | None:
+            """Call ``fn`` up to ``attempts`` times, sleeping per ``delays``."""
+            tag = args[1] if len(args) >= 2 else kwargs.get("tag", _COMPONENT)
+            for i in range(attempts):
+                try:
+                    return await fn(self, *args, **kwargs)
+                except _RETRYABLE_EXC as e:
+                    if i == attempts - 1:
+                        raise
+                    sleep_for = delays[min(i, len(delays) - 1)]
+                    logger.warning(
+                        f"{tag} | transient {type(e).__name__}: {e}; "
+                        f"retry {i + 1}/{attempts - 1} in {sleep_for:.1f}s"
+                    )
+                    await asyncio.sleep(sleep_for)
+            return None
+
+        return wrapper
+
+    return decorator
+
 
 class GotenbergConverter(Converter):
     """
@@ -81,7 +131,11 @@ class GotenbergConverter(Converter):
 
         logger.info(f"{tag} | converting to PDF via Gotenberg ({self.gotenberg_url})")
 
-        pdf_bytes = await self._convert_to_pdf(file_path, tag)
+        try:
+            pdf_bytes = await self._convert_to_pdf(file_path, tag)
+        except _RETRYABLE_EXC as e:
+            logger.error(f"{tag} | Gotenberg error after retries: {type(e).__name__}: {e}")
+            return None
         if not pdf_bytes:
             return None
 
@@ -90,7 +144,7 @@ class GotenbergConverter(Converter):
         try:
             fd, tmp_pdf = tempfile.mkstemp(suffix=".pdf", prefix="mkdpro_")
             os.close(fd)
-            Path(tmp_pdf).write_bytes(pdf_bytes)
+            await asyncio.to_thread(Path(tmp_pdf).write_bytes, pdf_bytes)
 
             logger.info(f"{tag} | PDF received ({len(pdf_bytes)} bytes), delegating to PDFHandler")
 
@@ -114,34 +168,42 @@ class GotenbergConverter(Converter):
                 with contextlib.suppress(Exception):
                     os.unlink(tmp_pdf)
 
+    @_retry_transient(attempts=3, delays=(1.0, 3.0))
     async def _convert_to_pdf(self, file_path: str, tag: str) -> bytes | None:
-        """Send file to Gotenberg and return PDF bytes."""
-        try:
-            async with httpx.AsyncClient(timeout=120) as client:
-                with open(file_path, "rb") as f:
-                    response = await client.post(
-                        self._convert_url,
-                        files={"files": (Path(file_path).name, f)},
-                        data={
-                            "losslessImageCompression": "true",
-                            "quality": "100",
-                        },
-                    )
-
-                if response.status_code == 200:
-                    return response.content
-
-                logger.warning(
-                    f"{tag} | Gotenberg returned {response.status_code}: {response.text[:200]}"
-                )
-                return None
+        """Send file to Gotenberg and return PDF bytes.
 
+        The HTTP call runs inside ``asyncio.to_thread`` with a sync
+        ``httpx.Client`` + open file handle so httpx streams the multipart
+        body from disk instead of holding the entire upload in memory.
+        Keeps peak memory bounded under concurrent large-file conversions.
+        """
+        try:
+            return await asyncio.to_thread(self._post_sync, file_path, tag)
         except httpx.ConnectError:
             logger.info(f"{tag} | Gotenberg not reachable at {self.gotenberg_url}, skipping")
             return None
-        except httpx.TimeoutException:
-            logger.warning(f"{tag} | Gotenberg timed out after 120s")
-            return None
+        except _RETRYABLE_EXC:
+            # Let the retry decorator handle transient errors. If retries are
+            # exhausted it re-raises, and the caller in ``convert()`` logs.
+            raise
         except Exception as e:
-            logger.warning(f"{tag} | Gotenberg error: {e}")
+            logger.error(f"{tag} | Gotenberg error: {e}")
             return None
+
+    def _post_sync(self, file_path: str, tag: str) -> bytes | None:
+        """Blocking multipart upload to Gotenberg. Called via ``to_thread``."""
+        with httpx.Client(timeout=120) as client, open(file_path, "rb") as f:
+            response = client.post(
+                self._convert_url,
+                files={"files": (Path(file_path).name, f)},
+                data={
+                    "losslessImageCompression": "true",
+                    "quality": "100",
+                },
+            )
+
+        if response.status_code == 200:
+            return response.content
+
+        logger.error(f"{tag} | Gotenberg returned {response.status_code}: {response.text[:200]}")
+        return None

{markitdown_pro-2.1.0 → markitdown_pro-2.1.2}/markitdown_pro/converters/gpt_vision_converter.py

@@ -11,6 +11,8 @@ Returns Markdown when successful, or `None` if conversion produced
 insufficient content (as determined by `ensure_minimum_content` in the service).
 """
 
+from pathlib import Path
+
 from ..common import config
 from ..common.utils import is_pdf
 from ..services.openai_services import GPTVision
@@ -115,6 +117,7 @@ class GPTVisionConverter(Converter):
             max_retries=_retries,
             base_delay=base_delay,
             max_delay=max_delay,
+            context_label=Path(file_path).name,
         )
 
     async def aclose(self) -> None:

{markitdown_pro-2.1.0 → markitdown_pro-2.1.2}/markitdown_pro/handlers/page_pdf_converter.py

@@ -158,6 +158,7 @@ class PagePDFConverter:
             png_path = await asyncio.to_thread(self._render_page_to_png, file_path, page_idx)
             content = await self.gpt_vision.gpt_vision.process_image(
                 file_or_url=png_path,
+                context_label=f"{Path(file_path).name} page {page_idx + 1}",
             )
             if content:
                 logger.info(f"{tag} | succeeded ({len(content)} chars)")

{markitdown_pro-2.1.0 → markitdown_pro-2.1.2}/markitdown_pro/services/azure_doc_intelligence.py

@@ -114,7 +114,7 @@ class DocumentIntelligenceService:
             return None
 
         try:
-            data = file_path.read_bytes()
+            data = await asyncio.to_thread(file_path.read_bytes)
 
             poller = await self._client.begin_analyze_document(
                 model_id="prebuilt-layout",

{markitdown_pro-2.1.0 → markitdown_pro-2.1.2}/markitdown_pro/services/openai_services.py

@@ -240,6 +240,7 @@ class GPTVision:
         base_delay: float = 0.5,
         max_delay: float = 20.0,
         retry_http_statuses: tuple[int, ...] = _RETRY_HTTP_STATUSES,
+        context_label: str | None = None,
     ):
         """
         Call self.lang_client.ainvoke with:
@@ -275,8 +276,9 @@ class GPTVision:
                 raise last_err
             cap = min(max_delay, base_delay * (2 ** (attempt - 1)))
             sleep_for = random.uniform(0, cap)
+            label = context_label or file_or_url
             logger.warning(
-                f"GPTVision: ainvoke transient error {file_or_url}: attempt {attempt}/{max_retries}: "
+                f"GPTVision: ainvoke transient error {label}: attempt {attempt}/{max_retries}: "
                 f"{type(last_err).__name__}: {last_err}. Retrying in {sleep_for:.2f}s"
             )
             await asyncio.sleep(sleep_for)
@@ -331,6 +333,7 @@ class GPTVision:
         max_retries: int = 6,
         base_delay: float = 0.5,
         max_delay: float = 20.0,
+        context_label: str | None = None,
     ) -> str | None:
         """
         OCR a single image (local path or URL) with the vision model.
@@ -373,6 +376,7 @@ class GPTVision:
                     max_retries=max_retries,
                     base_delay=base_delay,
                     max_delay=max_delay,
+                    context_label=context_label,
                 )
             finally:
                 with suppress(Exception):
@@ -469,7 +473,11 @@ class GPTVision:
                             # Per-page hard timeout so one slow page cannot stall the run
                             try:
                                 partial_md = await asyncio.wait_for(
-                                    self.process_image(png_path), timeout=self.page_timeout_s
+                                    self.process_image(
+                                        png_path,
+                                        context_label=f"{file_stem} page {page_index + 1}/{num_pages}",
+                                    ),
+                                    timeout=self.page_timeout_s,
                                 )
                             except TimeoutError:
                                 logger.error(