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

{markitdown_pro-2.1.0 → markitdown_pro-2.1.1}/.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.1}/.gitignore

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: markitdown-pro
-Version: 2.1.0
+Version: 2.1.1
 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.1}/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,49 @@ 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]]:
+        @functools.wraps(fn)
+        async def wrapper(self, *args, **kwargs) -> T | None:
+            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 +128,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
 
@@ -114,6 +165,7 @@ 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:
@@ -131,7 +183,7 @@ class GotenbergConverter(Converter):
                 if response.status_code == 200:
                     return response.content
 
-                logger.warning(
+                logger.error(
                     f"{tag} | Gotenberg returned {response.status_code}: {response.text[:200]}"
                 )
                 return None
@@ -139,9 +191,10 @@ class GotenbergConverter(Converter):
         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

{markitdown_pro-2.1.0 → markitdown_pro-2.1.1}/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.1}/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.1}/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(