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

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

@@ -11,6 +11,10 @@ on:
   pull_request:
     branches:
       - main
+    paths:
+      - 'markitdown_pro/**'
+      - 'tests/**'
+      - 'pyproject.toml'
 
 permissions:
   contents: read

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

@@ -24,3 +24,4 @@ docs/
 !./CLAUDE.md
 **/CONTINUITY.md
 **/CHANGELOG.md
+.mcp.json

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

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

{markitdown_pro-2.0.0 → markitdown_pro-2.1.0}/markitdown_pro/conversion_pipeline.py

@@ -152,21 +152,40 @@ class ConversionPipeline:
                 ".pdf": self.pdf_handler,
                 ".xls": self.tabular_handler,
                 ".xlsx": self.tabular_handler,
-                ".docx": self.office_handler,
-                ".pptx": self.office_handler,
             },
         }
 
+        # Register Office extensions dynamically — the handler decides which
+        # legacy formats it supports based on Gotenberg availability. This
+        # keeps ``handlers_mapping`` (what consumers read) truthful at runtime.
+        for ext in self.office_handler.supported_extensions:
+            self.handlers_categories[ExtensionCategory.FORMATTED_DOCS][ext] = self.office_handler
+
         # Normalize map of extensions to handlers
         self.handlers_mapping: dict[str, BaseHandler] = {}
         for handlers in self.handlers_categories.values():
             for ext, handler in handlers.items():
                 self.handlers_mapping[ext] = handler
 
+        # Cache the read-only view so consumers get a stable object (and we
+        # don't rebuild the frozenset on every ``.supported_extensions`` access).
+        # ``handlers_mapping`` is read-only by convention.
+        self._supported_extensions: frozenset[str] = frozenset(self.handlers_mapping)
+
     # ---------------------------------------------------------------------
     # Public APIs
     # ---------------------------------------------------------------------
 
+    @property
+    def supported_extensions(self) -> frozenset[str]:
+        """Canonical set of extensions this pipeline can route.
+
+        This is the source of truth for consumers advertising supported
+        formats (e.g., a ``/extensions`` endpoint). ``handlers_mapping`` is
+        the routing table; ``supported_extensions`` is its read-only view.
+        """
+        return self._supported_extensions
+
     async def convert_document_to_md(
         self,
         file_path: str | Path,

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

@@ -5,11 +5,14 @@ Gotenberg (https://gotenberg.dev) is a Docker-based API that wraps LibreOffice
 for document-to-PDF conversion. It handles concurrency internally and scales
 horizontally via container replicas.
 
-Configure via environment variable:
-    GOTENBERG_URL=http://gotenberg:3000  (default)
-
-If the Gotenberg service is unreachable, convert() returns None and the caller
-should fall through to the next converter.
+Configure via the ``GOTENBERG_URL`` environment variable or pass
+``gotenberg_url=...`` explicitly. If neither is provided, the converter is
+disabled and ``convert()`` returns ``None`` without any network I/O — this lets
+downstream consumers advertise supported formats accurately.
+
+If the Gotenberg service is configured but unreachable at call time,
+``convert()`` returns ``None`` and the caller should fall through to the next
+converter.
 """
 
 import contextlib
@@ -23,7 +26,6 @@ from ..common.logger import logger
 from .base import Converter
 
 _COMPONENT = "GotenbergConverter"
-_DEFAULT_URL = "http://gotenberg:3000"
 _CONVERT_ENDPOINT = "/forms/libreoffice/convert"
 
 
@@ -36,21 +38,48 @@ class GotenbergConverter(Converter):
     DocIntelligence can extract from Office files directly.
 
     Requires a running Gotenberg instance. Gracefully returns None if
-    the service is unavailable, allowing fallback to other converters.
+    the service is unavailable or if the converter is disabled, allowing
+    fallback to other converters.
     """
 
     SUPPORTED_EXTENSIONS = frozenset({".docx", ".pptx", ".doc", ".ppt", ".odt", ".rtf"})
 
     def __init__(self, gotenberg_url: str | None = None) -> None:
         super().__init__(_COMPONENT)
-        self._url = gotenberg_url or os.getenv("GOTENBERG_URL", _DEFAULT_URL)
-        self._convert_url = f"{self._url.rstrip('/')}{_CONVERT_ENDPOINT}"
+        # gotenberg_url is the single source of truth; ``enabled`` derives from it.
+        # Treat empty/whitespace values as unconfigured to catch a common
+        # ``docker-compose`` misconfiguration (``environment: GOTENBERG_URL=``).
+        raw = (gotenberg_url if gotenberg_url is not None else os.getenv("GOTENBERG_URL")) or ""
+        self.gotenberg_url: str | None = raw.strip() or None
+
+    @property
+    def enabled(self) -> bool:
+        return bool(self.gotenberg_url)
+
+    @property
+    def _convert_url(self) -> str:
+        """The fully-qualified Gotenberg endpoint URL.
+
+        Only safe to access when ``self.enabled`` is True. Callers in this
+        class are already guarded by the ``if not self.enabled`` short-circuit
+        in ``convert()``; raising here makes the invariant explicit instead
+        of letting a ``None`` propagate into ``httpx`` or the format string.
+        """
+        if not self.gotenberg_url:
+            raise RuntimeError(
+                "GotenbergConverter is not configured (set GOTENBERG_URL "
+                "or pass gotenberg_url=...). Check ``enabled`` before calling."
+            )
+        return f"{self.gotenberg_url.rstrip('/')}{_CONVERT_ENDPOINT}"
 
     async def convert(self, file_path: str) -> str | None:
+        if not self.enabled:
+            return None
+
         file_name = Path(file_path).name
         tag = f"{_COMPONENT} | {file_name}"
 
-        logger.info(f"{tag} | converting to PDF via Gotenberg ({self._url})")
+        logger.info(f"{tag} | converting to PDF via Gotenberg ({self.gotenberg_url})")
 
         pdf_bytes = await self._convert_to_pdf(file_path, tag)
         if not pdf_bytes:
@@ -108,7 +137,7 @@ class GotenbergConverter(Converter):
                 return None
 
         except httpx.ConnectError:
-            logger.info(f"{tag} | Gotenberg not reachable at {self._url}, skipping")
+            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")

{markitdown_pro-2.0.0 → markitdown_pro-2.1.0}/markitdown_pro/handlers/office_handler.py

@@ -38,11 +38,22 @@ class OfficeHandler(BaseHandler):
     the pipeline order when initializing the handler.
 
     Supported formats: .docx, .pptx (modern Office XML formats).
-    Old binary formats (.doc, .ppt, .odt, .rtf) supported via Gotenberg only.
+    Legacy binary formats (.doc, .ppt, .odt, .rtf) are supported at runtime
+    only when the configured pipeline contains an enabled ``GotenbergConverter``.
+    Callers should inspect the instance attribute ``supported_extensions`` (not
+    the class constant) to learn which formats this handler will actually
+    process.
     """
 
+    # Class constant stays narrow (the always-supported modern formats) so that
+    # ``BaseHandler.is_valid`` and any class-level introspection never falsely
+    # advertise legacy formats that would fail without Gotenberg. Dynamic
+    # runtime capability lives on the instance attribute ``supported_extensions``
+    # set in ``__init__``.
     SUPPORTED_EXTENSIONS = frozenset({".docx", ".pptx"})
 
+    _GOTENBERG_ONLY_EXTS = frozenset({".doc", ".ppt", ".odt", ".rtf"})
+
     def __init__(
         self,
         pipeline: list[tuple[Converter, str]] | None = None,
@@ -62,6 +73,26 @@ class OfficeHandler(BaseHandler):
             (self.markitdown, "MarkItDown"),
         ]
 
+        # isinstance catches subclasses/proxies users might pass in custom
+        # pipelines. We explicitly check that the imported ``GotenbergConverter``
+        # is still a real class before using it as an isinstance second arg —
+        # if tests patch the name to a MagicMock *instance* (not a class),
+        # we fall back to ``gotenberg_enabled = False`` instead of wrapping
+        # the whole generator in try/except TypeError, which would otherwise
+        # silently swallow a real bug inside an ``enabled`` property.
+        if isinstance(GotenbergConverter, type):
+            gotenberg_enabled = any(
+                isinstance(c, GotenbergConverter) and getattr(c, "enabled", False)
+                for c, _ in self._pipeline
+            )
+        else:
+            gotenberg_enabled = False
+        self.supported_extensions: frozenset[str] = (
+            self.SUPPORTED_EXTENSIONS | self._GOTENBERG_ONLY_EXTS
+            if gotenberg_enabled
+            else self.SUPPORTED_EXTENSIONS
+        )
+
     async def handle(self, file_path: str, *args, **kwargs) -> str | None:
         """
         Convert an Office document to Markdown by trying the configured pipeline in order.

{markitdown_pro-2.0.0 → markitdown_pro-2.1.0}/tests/data/test_expectations.yaml

@@ -74,6 +74,62 @@ gotenberg_converter:
     expect: ["what is lorem ipsum?", "where does it come from"]
 
 
+# =============================================================================
+# LEGACY OFFICE FORMATS — Gotenberg-gated (.doc / .ppt / .odt / .rtf)
+# Same fixtures as above re-saved / pandoc-converted into legacy formats.
+# Routed through OfficeHandler → Gotenberg → PDF → PDFHandler per-page OCR.
+# Only available iff GOTENBERG_URL is configured on the pipeline.
+# =============================================================================
+legacy_office_formats:
+  # .doc (re-saved from .docx via Word)
+  - file: tests/data/word-legacy/lorem-ipsum-only-text.doc
+    expect: ["what is lorem ipsum?", "where does it come from"]
+  - file: tests/data/word-legacy/lorem-ipsum-text-with-image.doc
+    expect: ["what is lorem ipsum?", "red", "green", "blue"]
+  - file: tests/data/word-legacy/geometry-colors.doc
+    expect: ["red", "green", "blue"]
+  - file: tests/data/word-legacy/lorem-ipsum-scanned-text.doc
+    expect: ["what is lorem ipsum?", "why do we use it?"]
+  - file: tests/data/word-legacy/lorem-ipsum-text-with-scanned-text.doc
+    expect: ["what is lorem ipsum?", "where does it come from"]
+
+  # .ppt (re-saved from .pptx via PowerPoint)
+  - file: tests/data/powerpoint-legacy/lorem-ipsum-only-text.ppt
+    expect: ["what is lorem ipsum?", "where does it come from"]
+  - file: tests/data/powerpoint-legacy/lorem-ipsum-text-with-image.ppt
+    expect: ["what is lorem ipsum", "red", "green", "blue"]
+  - file: tests/data/powerpoint-legacy/geometry-colors.ppt
+    expect: ["red", "green", "blue"]
+  - file: tests/data/powerpoint-legacy/lorem-ipsum-scanned-text.ppt
+    expect: ["what is lorem ipsum", "why do we use it"]
+  - file: tests/data/powerpoint-legacy/lorem-ipsum-text-with-scanned-text.ppt
+    expect: ["what is lorem ipsum?", "where does it come from"]
+
+  # .odt (re-saved from .docx via Word)
+  - file: tests/data/word-legacy/lorem-ipsum-only-text.odt
+    expect: ["what is lorem ipsum?", "where does it come from"]
+  - file: tests/data/word-legacy/lorem-ipsum-text-with-image.odt
+    expect: ["what is lorem ipsum?", "red", "green", "blue"]
+  - file: tests/data/word-legacy/geometry-colors.odt
+    expect: ["red", "green", "blue"]
+  - file: tests/data/word-legacy/lorem-ipsum-scanned-text.odt
+    expect: ["what is lorem ipsum?", "why do we use it?"]
+  - file: tests/data/word-legacy/lorem-ipsum-text-with-scanned-text.odt
+    expect: ["what is lorem ipsum?", "where does it come from"]
+
+  # .rtf (re-saved from .docx via Word)
+  - file: tests/data/word-legacy/lorem-ipsum-only-text.rtf
+    expect: ["what is lorem ipsum?", "where does it come from"]
+  - file: tests/data/word-legacy/lorem-ipsum-text-with-image.rtf
+    expect: ["what is lorem ipsum?", "red", "green", "blue"]
+  - file: tests/data/word-legacy/geometry-colors.rtf
+    expect: ["red", "green", "blue"]
+  - file: tests/data/word-legacy/lorem-ipsum-scanned-text.rtf
+    expect: ["what is lorem ipsum?", "why do we use it?"]
+  - file: tests/data/word-legacy/lorem-ipsum-text-with-scanned-text.rtf
+    expect: ["what is lorem ipsum?", "where does it come from"]
+
+
 # =============================================================================
 # MARKITDOWN CONVERTER — text extraction only, NO OCR, NO image content
 # =============================================================================