markitdown-ocr 0.1.0__tar.gz → 0.1.1b2__tar.gz

{markitdown_ocr-0.1.0 → markitdown_ocr-0.1.1b2}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: markitdown-ocr
-Version: 0.1.0
+Version: 0.1.1b2
 Summary: OCR plugin for MarkItDown - Extracts text from images in PDF, DOCX, PPTX, and XLSX via LLM Vision
 Project-URL: Documentation, https://github.com/microsoft/markitdown#readme
 Project-URL: Issues, https://github.com/microsoft/markitdown/issues

{markitdown_ocr-0.1.0 → markitdown_ocr-0.1.1b2}/src/markitdown_ocr/__about__.py

@@ -1,4 +1,4 @@
 # SPDX-FileCopyrightText: 2025-present Contributors
 # SPDX-License-Identifier: MIT
 
-__version__ = "0.1.0"
+__version__ = "0.1.1b2"

{markitdown_ocr-0.1.0 → markitdown_ocr-0.1.1b2}/src/markitdown_ocr/_docx_converter_with_ocr.py

@@ -29,6 +29,18 @@ except ImportError:
 # Must be a single token with no special markdown characters.
 _PLACEHOLDER = "MARKITDOWNOCRBLOCK{}"
 
+_UNDERLINE_STYLE_MAP = "u => u"
+
+
+def _read_embedded_style_map(file_stream: BinaryIO) -> Optional[str]:
+    """Read the style map embedded in a .docx, if it has one."""
+    position = file_stream.tell()
+    file_stream.seek(0)
+    try:
+        return mammoth.read_embedded_style_map(file_stream)
+    finally:
+        file_stream.seek(position)
+
 
 class DocxConverterWithOCR(HtmlConverter):
     """
@@ -82,16 +94,40 @@ class DocxConverterWithOCR(HtmlConverter):
             kwargs.get("ocr_service") or self.ocr_service
         )
 
+        # Pre-process once, up front, so that every subsequent read sees the
+        # repaired archive. pre_process_docx() also fixes .docx files whose ZIP
+        # local file headers disagree with the central directory; reading the
+        # original stream first would make those raise, or silently yield no
+        # images and drop the OCR output.
+        pre_process_stream = pre_process_docx(file_stream)
+
+        # Read the embedded style map and combine with any provided style map
+        caller_style_map = kwargs.get("style_map")
+        embedded_style_map = _read_embedded_style_map(pre_process_stream)
+
+        style_map = "\n".join(
+            part
+            for part in (
+                caller_style_map,
+                embedded_style_map,
+                _UNDERLINE_STYLE_MAP,
+            )
+            if part
+        )
+
         if ocr_service:
             # 1. Extract and OCR images — returns raw text per image
-            file_stream.seek(0)
-            image_ocr_map = self._extract_and_ocr_images(file_stream, ocr_service)
+            pre_process_stream.seek(0)
+            image_ocr_map = self._extract_and_ocr_images(
+                pre_process_stream, ocr_service
+            )
 
             # 2. Convert DOCX → HTML via mammoth
-            file_stream.seek(0)
-            pre_process_stream = pre_process_docx(file_stream)
+            pre_process_stream.seek(0)
             html_result = mammoth.convert_to_html(
-                pre_process_stream, style_map=kwargs.get("style_map")
+                pre_process_stream,
+                style_map=style_map,
+                include_embedded_style_map=False,
             ).value
 
             # 3. Replace <img> tags with plain placeholder tokens so that
@@ -116,10 +152,13 @@ class DocxConverterWithOCR(HtmlConverter):
             return DocumentConverterResult(markdown=md)
         else:
             # Standard conversion without OCR
-            style_map = kwargs.get("style_map", None)
-            pre_process_stream = pre_process_docx(file_stream)
+            pre_process_stream.seek(0)
             return self._html_converter.convert_string(
-                mammoth.convert_to_html(pre_process_stream, style_map=style_map).value,
+                mammoth.convert_to_html(
+                    pre_process_stream,
+                    style_map=style_map,
+                    include_embedded_style_map=False,
+                ).value,
                 **kwargs,
             )
 

{markitdown_ocr-0.1.0 → markitdown_ocr-0.1.1b2}/src/markitdown_ocr/_pptx_converter_with_ocr.py

@@ -222,7 +222,11 @@ class PptxConverterWithOCR(DocumentConverter):
     def _convert_chart_to_markdown(self, chart):
         try:
             md = "\\n\\n### Chart"
-            if chart.has_title:
+            # ChartTitle.text_frame is documented as destructive -- it creates
+            # a text frame if one isn't already present, so it never returns
+            # None. has_text_frame is the property that actually reflects
+            # whether a text frame exists.
+            if chart.has_title and chart.chart_title.has_text_frame:
                 md += f": {chart.chart_title.text_frame.text}"
             md += "\\n\\n"
             data = []

markitdown_ocr-0.1.1b2/tests/test_docx_converter.py

@@ -0,0 +1,428 @@
+"""
+Unit tests for DocxConverterWithOCR.
+
+For each DOCX test file: convert with a mock OCR service then compare the
+full output string against the expected snapshot.
+
+OCR block format used by the converter:
+    *[Image OCR]
+    MOCK_OCR_TEXT_12345
+    [End OCR]*
+"""
+
+import io
+import struct
+import sys
+import zipfile
+from pathlib import Path
+from typing import Any
+
+import pytest
+
+sys.path.insert(0, str(Path(__file__).parent.parent / "src"))
+
+from markitdown_ocr._ocr_service import OCRResult  # noqa: E402
+from markitdown_ocr._docx_converter_with_ocr import (  # noqa: E402
+    DocxConverterWithOCR,
+)
+from markitdown import StreamInfo  # noqa: E402
+
+TEST_DATA_DIR = Path(__file__).parent / "ocr_test_data"
+
+_MOCK_TEXT = "MOCK_OCR_TEXT_12345"
+
+
+class MockOCRService:
+    def extract_text(  # noqa: ANN101
+        self, image_stream: Any, **kwargs: Any
+    ) -> OCRResult:
+        return OCRResult(text=_MOCK_TEXT, backend_used="mock")
+
+
+@pytest.fixture(scope="module")
+def svc() -> MockOCRService:
+    return MockOCRService()
+
+
+def _convert(filename: str, ocr_service: MockOCRService) -> str:
+    path = TEST_DATA_DIR / filename
+    if not path.exists():
+        pytest.skip(f"Test file not found: {path}")
+    converter = DocxConverterWithOCR()
+    with open(path, "rb") as f:
+        return converter.convert(
+            f, StreamInfo(extension=".docx"), ocr_service=ocr_service
+        ).text_content
+
+
+# ---------------------------------------------------------------------------
+# docx_image_start.docx
+# ---------------------------------------------------------------------------
+
+
+def test_docx_image_start(svc: MockOCRService) -> None:
+    expected = (
+        "Document with Image at Start\n\n"
+        "*[Image OCR]\nMOCK_OCR_TEXT_12345\n[End OCR]*\n\n"
+        "This is the main content after the header image.\n\n"
+        "More text content here."
+    )
+    assert _convert("docx_image_start.docx", svc) == expected
+
+
+# ---------------------------------------------------------------------------
+# docx_image_middle.docx
+# ---------------------------------------------------------------------------
+
+
+def test_docx_image_middle(svc: MockOCRService) -> None:
+    expected = (
+        "# Introduction\n\n"
+        "This is the introduction section.\n\n"
+        "We will see an image below.\n\n"
+        "*[Image OCR]\nMOCK_OCR_TEXT_12345\n[End OCR]*\n\n"
+        "# Analysis\n\n"
+        "This section comes after the image."
+    )
+    assert _convert("docx_image_middle.docx", svc) == expected
+
+
+# ---------------------------------------------------------------------------
+# docx_image_end.docx
+# ---------------------------------------------------------------------------
+
+
+def test_docx_image_end(svc: MockOCRService) -> None:
+    expected = (
+        "Report\n\n"
+        "Main findings of the report.\n\n"
+        "Details and analysis.\n\n"
+        "Recommendations.\n\n"
+        "*[Image OCR]\nMOCK_OCR_TEXT_12345\n[End OCR]*"
+    )
+    assert _convert("docx_image_end.docx", svc) == expected
+
+
+# ---------------------------------------------------------------------------
+# docx_multiple_images.docx
+# ---------------------------------------------------------------------------
+
+
+def test_docx_multiple_images(svc: MockOCRService) -> None:
+    expected = (
+        "Multi-Image Document\n\n"
+        "First section\n\n"
+        "*[Image OCR]\nMOCK_OCR_TEXT_12345\n[End OCR]*\n\n"
+        "Second section with another image\n\n"
+        "*[Image OCR]\nMOCK_OCR_TEXT_12345\n[End OCR]*\n\n"
+        "Conclusion"
+    )
+    assert _convert("docx_multiple_images.docx", svc) == expected
+
+
+# ---------------------------------------------------------------------------
+# docx_multipage.docx
+# ---------------------------------------------------------------------------
+
+
+def test_docx_multipage(svc: MockOCRService) -> None:
+    expected = (
+        "# Page 1 - Mixed Content\n\n"
+        "This is the first paragraph on page 1.\n\n"
+        "BEFORE IMAGE: Important content appears here.\n\n"
+        "*[Image OCR]\nMOCK_OCR_TEXT_12345\n[End OCR]*\n\n"
+        "AFTER IMAGE: This content follows the image.\n\n"
+        "More text on page 1.\n\n"
+        "# Page 2 - Image at End\n\n"
+        "Content on page 2.\n\n"
+        "Multiple paragraphs of text.\n\n"
+        "Building up to the image...\n\n"
+        "Final paragraph before image.\n\n"
+        "*[Image OCR]\nMOCK_OCR_TEXT_12345\n[End OCR]*\n\n"
+        "# Page 3 - Image at Start\n\n"
+        "*[Image OCR]\nMOCK_OCR_TEXT_12345\n[End OCR]*\n\n"
+        "Content that follows the header image.\n\n"
+        "AFTER IMAGE: This text is after the image."
+    )
+    assert _convert("docx_multipage.docx", svc) == expected
+
+
+# ---------------------------------------------------------------------------
+# docx_complex_layout.docx
+# ---------------------------------------------------------------------------
+
+
+def test_docx_complex_layout(svc: MockOCRService) -> None:
+    expected = (
+        "Complex Document\n\n"
+        "|  |  |\n"
+        "| --- | --- |\n"
+        "| Feature | Status |\n"
+        "| Authentication | Active |\n"
+        "| Encryption | Enabled |\n\n"
+        "Security notice:\n\n"
+        "*[Image OCR]\nMOCK_OCR_TEXT_12345\n[End OCR]*"
+    )
+    assert _convert("docx_complex_layout.docx", svc) == expected
+
+
+# ---------------------------------------------------------------------------
+# _inject_placeholders — internal unit tests (no file I/O)
+# ---------------------------------------------------------------------------
+
+
+def test_inject_placeholders_single_image() -> None:
+    converter = DocxConverterWithOCR()
+    html = "<p>Before</p><img src='x.png'/><p>After</p>"
+    result_html, texts = converter._inject_placeholders(html, {"rId1": "TEXT"})
+    assert "<img" not in result_html
+    assert "MARKITDOWNOCRBLOCK0" in result_html
+    assert texts == ["TEXT"]
+
+
+def test_inject_placeholders_two_images_sequential_tokens() -> None:
+    converter = DocxConverterWithOCR()
+    html = "<img src='a.png'/><p>Mid</p><img src='b.png'/>"
+    result_html, texts = converter._inject_placeholders(
+        html, {"rId1": "FIRST", "rId2": "SECOND"}
+    )
+    assert "MARKITDOWNOCRBLOCK0" in result_html
+    assert "MARKITDOWNOCRBLOCK1" in result_html
+    assert result_html.index("MARKITDOWNOCRBLOCK0") < result_html.index(
+        "MARKITDOWNOCRBLOCK1"
+    )
+    assert len(texts) == 2
+
+
+def test_inject_placeholders_no_img_tag_appends_at_end() -> None:
+    converter = DocxConverterWithOCR()
+    html = "<p>No images</p>"
+    result_html, texts = converter._inject_placeholders(html, {"rId1": "ORPHAN"})
+    assert "MARKITDOWNOCRBLOCK0" in result_html
+    assert texts == ["ORPHAN"]
+
+
+def test_inject_placeholders_empty_map_leaves_html_unchanged() -> None:
+    converter = DocxConverterWithOCR()
+    html = "<p>Content</p><img src='pic.jpg'/>"
+    result_html, texts = converter._inject_placeholders(html, {})
+    assert result_html == html
+    assert texts == []
+
+
+# ---------------------------------------------------------------------------
+# No OCR service — no OCR tags emitted
+# ---------------------------------------------------------------------------
+
+
+def test_docx_no_ocr_service_no_tags() -> None:
+    path = TEST_DATA_DIR / "docx_image_middle.docx"
+    if not path.exists():
+        pytest.skip(f"Test file not found: {path}")
+    converter = DocxConverterWithOCR()
+    with open(path, "rb") as f:
+        md = converter.convert(f, StreamInfo(extension=".docx")).text_content
+    assert "*[Image OCR]" not in md
+    assert "[End OCR]*" not in md
+
+
+@pytest.mark.parametrize("double_strike", [False, True])
+@pytest.mark.parametrize("use_ocr", [False, True])
+def test_docx_styles_with_redundant_default_namespace(
+    svc: MockOCRService, use_ocr: bool, double_strike: bool
+) -> None:
+    path = TEST_DATA_DIR / "docx_image_middle.docx"
+    if not path.exists():
+        pytest.skip(f"Test file not found: {path}")
+    original = path.read_bytes()
+    fixture = io.BytesIO()
+    namespace = "http://schemas.openxmlformats.org/wordprocessingml/2006/main"
+    declaration = f'xmlns:w="{namespace}"'.encode("utf-8")
+    with zipfile.ZipFile(io.BytesIO(original)) as source, zipfile.ZipFile(
+        fixture, "w"
+    ) as target:
+        for item in source.infolist():
+            content = source.read(item)
+            if item.filename == "word/styles.xml":
+                if double_strike:
+                    assert content.count(b"</w:styles>") == 1
+                    content = content.replace(
+                        b"</w:styles>",
+                        b'<w:style w:type="character" w:styleId="DoubleStrike">'
+                        b'<w:name w:val="Double Strike"/>'
+                        b'<w:rPr><w:dstrike w:val="1"/></w:rPr>'
+                        b"</w:style></w:styles>",
+                        1,
+                    )
+                assert content.count(declaration) == 1
+                content = content.replace(
+                    declaration, declaration + f' xmlns="{namespace}"'.encode(), 1
+                )
+            target.writestr(item, content)
+
+    converter = DocxConverterWithOCR()
+    service = svc if use_ocr else None
+    expected = converter.convert(
+        io.BytesIO(original), StreamInfo(extension=".docx"), ocr_service=service
+    ).markdown
+    fixture.seek(0)
+    actual = converter.convert(
+        fixture, StreamInfo(extension=".docx"), ocr_service=service
+    ).markdown
+
+    assert "# Introduction" in actual
+    assert actual == expected
+    if use_ocr:
+        assert _MOCK_TEXT in actual
+
+
+# ---------------------------------------------------------------------------
+# Underlined runs survive both the OCR and the non-OCR mammoth paths
+# ---------------------------------------------------------------------------
+
+
+def _underlined_docx(
+    tmp_path: Path,
+    *,
+    paragraph_xml: str = (
+        "<w:r><w:t>plain </w:t></w:r>"
+        '<w:r><w:rPr><w:u w:val="single"/></w:rPr><w:t>underlined</w:t></w:r>'
+    ),
+) -> Path:
+    docx_file = tmp_path / "underlined.docx"
+    document_xml = f"""<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<w:document xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main">
+  <w:body>
+    <w:p>{paragraph_xml}</w:p>
+  </w:body>
+</w:document>"""
+
+    with zipfile.ZipFile(docx_file, "w") as archive:
+        archive.writestr(
+            "[Content_Types].xml",
+            """<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<Types xmlns="http://schemas.openxmlformats.org/package/2006/content-types">
+  <Default Extension="rels" ContentType="application/vnd.openxmlformats-package.relationships+xml"/>
+  <Default Extension="xml" ContentType="application/xml"/>
+  <Override PartName="/word/document.xml" ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.document.main+xml"/>
+</Types>""",
+        )
+        archive.writestr(
+            "_rels/.rels",
+            """<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">
+  <Relationship Id="rId1" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument" Target="word/document.xml"/>
+</Relationships>""",
+        )
+        archive.writestr("word/document.xml", document_xml)
+
+    return docx_file
+
+
+def test_docx_underlined_text_is_preserved_without_ocr(tmp_path: Path) -> None:
+    converter = DocxConverterWithOCR()
+    with open(_underlined_docx(tmp_path), "rb") as f:
+        md = converter.convert(f, StreamInfo(extension=".docx")).markdown
+    assert "plain <u>underlined</u>" in md
+
+
+def test_docx_underlined_text_is_preserved_with_ocr(
+    tmp_path: Path, svc: MockOCRService
+) -> None:
+    converter = DocxConverterWithOCR()
+    with open(_underlined_docx(tmp_path), "rb") as f:
+        md = converter.convert(
+            f, StreamInfo(extension=".docx"), ocr_service=svc
+        ).markdown
+    assert "plain <u>underlined</u>" in md
+
+
+@pytest.mark.parametrize("use_ocr", [False, True])
+@pytest.mark.parametrize(
+    ("run_xml", "expected"),
+    [
+        ('<w:t xml:space="preserve"> </w:t>', "First Last"),
+        ("<w:tab/>", "First Last"),
+        ("<w:t>&#160;</w:t>", "First\u00a0Last"),
+        # Direct conversion keeps the two-space hard break; the dispatcher strips it.
+        ("<w:br/>", "First  \nLast"),
+    ],
+)
+def test_docx_underlined_whitespace_is_preserved(
+    tmp_path: Path,
+    svc: MockOCRService,
+    use_ocr: bool,
+    run_xml: str,
+    expected: str,
+) -> None:
+    path = _underlined_docx(
+        tmp_path,
+        paragraph_xml=(
+            "<w:r><w:t>First</w:t></w:r>"
+            f'<w:r><w:rPr><w:u w:val="single"/></w:rPr>{run_xml}</w:r>'
+            "<w:r><w:t>Last</w:t></w:r>"
+        ),
+    )
+    converter = DocxConverterWithOCR()
+    with path.open("rb") as stream:
+        result = converter.convert(
+            stream, StreamInfo(extension=".docx"), ocr_service=svc if use_ocr else None
+        )
+
+    assert result.markdown == expected
+
+
+# ---------------------------------------------------------------------------
+# ZIP local file header casing mismatch
+# ---------------------------------------------------------------------------
+
+
+def _uppercase_local_header_names(docx_bytes: bytes) -> bytes:
+    """Uppercase every local file header filename, leaving the central directory
+    untouched, to mimic generators that disagree with themselves about casing."""
+    raw = bytearray(docx_bytes)
+    offset = patched = 0
+    while offset + 30 <= len(raw) and raw[offset : offset + 4] == b"PK\x03\x04":
+        fname_len = struct.unpack_from("<H", raw, offset + 26)[0]
+        extra_len = struct.unpack_from("<H", raw, offset + 28)[0]
+        comp_size = struct.unpack_from("<I", raw, offset + 18)[0]
+        name = raw[offset + 30 : offset + 30 + fname_len]
+        if name.upper() != name:
+            raw[offset + 30 : offset + 30 + fname_len] = name.upper()
+            patched += 1
+        offset += 30 + fname_len + extra_len + comp_size
+    assert patched, "fixture produced no mismatched local file headers"
+    return bytes(raw)
+
+
+def test_docx_zip_filename_casing_mismatch_preserves_ocr(svc: MockOCRService) -> None:
+    """OCR output survives a .docx whose local file headers disagree with the
+    central directory on casing.
+
+    The image extraction swallows every exception, so an unrepaired stream used
+    to yield an empty OCR map and silently drop the OCR blocks rather than fail.
+    """
+    path = TEST_DATA_DIR / "docx_image_middle.docx"
+    if not path.exists():
+        pytest.skip(f"Test file not found: {path}")
+
+    original = path.read_bytes()
+    mismatched = _uppercase_local_header_names(original)
+
+    # Plain zipfile cannot read the mismatched archive ...
+    with pytest.raises(zipfile.BadZipFile):
+        with zipfile.ZipFile(io.BytesIO(mismatched), "r") as zf:
+            for name in zf.namelist():
+                zf.read(name)
+
+    # ... but the converter produces the same output it does for the original.
+    converter = DocxConverterWithOCR()
+    expected = converter.convert(
+        io.BytesIO(original), StreamInfo(extension=".docx"), ocr_service=svc
+    ).markdown
+    actual = converter.convert(
+        io.BytesIO(mismatched), StreamInfo(extension=".docx"), ocr_service=svc
+    ).markdown
+
+    assert _MOCK_TEXT in actual
+    assert actual == expected

{markitdown_ocr-0.1.0 → markitdown_ocr-0.1.1b2}/tests/test_pdf_converter.py

@@ -144,17 +144,30 @@ def test_pdf_complex_layout(svc: MockOCRService) -> None:
 
 
 # ---------------------------------------------------------------------------
-# pdf_multipage.pdf — pdfplumber/pdfminer fail (EOF); PyMuPDF fallback used
+# pdf_multipage.pdf
 # ---------------------------------------------------------------------------
 
 
 def test_pdf_multipage(svc: MockOCRService) -> None:
-    # pdfplumber cannot open this file (Unexpected EOF), so _ocr_full_pages
-    # falls back to PyMuPDF for page rendering.  Each page becomes one OCR block.
     expected = (
-        f"## Page 1\n\n\n{_OCR_BLOCK}\n\n\n"
-        f"## Page 2\n\n\n{_OCR_BLOCK}\n\n\n"
-        f"## Page 3\n\n\n{_OCR_BLOCK}"
+        "## Page 1\n\n\n"
+        "Page 1 - Content before image\n\n"
+        "This is important text that appears BEFORE the image.\n\n\n\n"
+        "*[Image OCR]\nMOCK_OCR_TEXT_12345\n[End OCR]*\n\n\n"
+        "This text appears AFTER the image on page 1.\n\n"
+        "More content follows here.\n\n\n"
+        "## Page 2\n\n\n"
+        "Page 2 - Content with image at end\n\n"
+        "Main content of page 2 starts here.\n\n"
+        "This is paragraph 1.\n\n"
+        "This is paragraph 2.\n\n"
+        "Final paragraph before image.\n\n\n\n"
+        "*[Image OCR]\nMOCK_OCR_TEXT_12345\n[End OCR]*\n\n\n\n"
+        "## Page 3\n\n\n"
+        "Page 3 - Image at top\n\n\n\n"
+        "*[Image OCR]\nMOCK_OCR_TEXT_12345\n[End OCR]*\n\n\n"
+        "Content that follows the image.\n\n"
+        "This text is AFTER the image."
     )
     assert _convert("pdf_multipage.pdf", svc) == expected
 

{markitdown_ocr-0.1.0 → markitdown_ocr-0.1.1b2}/tests/test_pptx_converter.py

@@ -146,3 +146,56 @@ def test_pptx_no_ocr_service_no_tags() -> None:
         md = converter.convert(f, StreamInfo(extension=".pptx")).text_content
     assert "*[Image OCR]" not in md
     assert "[End OCR]*" not in md
+
+
+def test_pptx_ocr_chart_no_title_text_frame() -> None:
+    from unittest.mock import MagicMock
+    from markitdown_ocr._pptx_converter_with_ocr import PptxConverterWithOCR
+
+    # python-pptx's ChartTitle.text_frame is destructive -- it creates a text
+    # frame if one isn't already present, so it never returns None.
+    # has_text_frame is the property that actually reflects presence/absence.
+    mock_chart = MagicMock()
+    mock_chart.has_title = True
+    mock_chart.chart_title.has_text_frame = False
+
+    mock_category = MagicMock()
+    mock_category.label = "Cat 1"
+    mock_chart.plots = [MagicMock(categories=[mock_category])]
+
+    mock_series = MagicMock()
+    mock_series.name = "Series 1"
+    mock_series.values = [10.0]
+    mock_chart.series = [mock_series]
+
+    converter = PptxConverterWithOCR()
+    result = converter._convert_chart_to_markdown(mock_chart)
+
+    assert "### Chart" in result
+    assert "Cat 1" in result
+    assert "Series 1" in result
+    assert ":" not in result
+
+
+def test_pptx_ocr_chart_with_title_text_frame() -> None:
+    from unittest.mock import MagicMock
+    from markitdown_ocr._pptx_converter_with_ocr import PptxConverterWithOCR
+
+    mock_chart = MagicMock()
+    mock_chart.has_title = True
+    mock_chart.chart_title.has_text_frame = True
+    mock_chart.chart_title.text_frame.text = "Revenue"
+
+    mock_category = MagicMock()
+    mock_category.label = "Cat 1"
+    mock_chart.plots = [MagicMock(categories=[mock_category])]
+
+    mock_series = MagicMock()
+    mock_series.name = "Series 1"
+    mock_series.values = [10.0]
+    mock_chart.series = [mock_series]
+
+    converter = PptxConverterWithOCR()
+    result = converter._convert_chart_to_markdown(mock_chart)
+
+    assert "### Chart: Revenue" in result

markitdown_ocr-0.1.0/tests/test_docx_converter.py

@@ -1,223 +0,0 @@
-"""
-Unit tests for DocxConverterWithOCR.
-
-For each DOCX test file: convert with a mock OCR service then compare the
-full output string against the expected snapshot.
-
-OCR block format used by the converter:
-    *[Image OCR]
-    MOCK_OCR_TEXT_12345
-    [End OCR]*
-"""
-
-import sys
-from pathlib import Path
-from typing import Any
-
-import pytest
-
-sys.path.insert(0, str(Path(__file__).parent.parent / "src"))
-
-from markitdown_ocr._ocr_service import OCRResult  # noqa: E402
-from markitdown_ocr._docx_converter_with_ocr import (  # noqa: E402
-    DocxConverterWithOCR,
-)
-from markitdown import StreamInfo  # noqa: E402
-
-TEST_DATA_DIR = Path(__file__).parent / "ocr_test_data"
-
-_MOCK_TEXT = "MOCK_OCR_TEXT_12345"
-
-
-class MockOCRService:
-    def extract_text(  # noqa: ANN101
-        self, image_stream: Any, **kwargs: Any
-    ) -> OCRResult:
-        return OCRResult(text=_MOCK_TEXT, backend_used="mock")
-
-
-@pytest.fixture(scope="module")
-def svc() -> MockOCRService:
-    return MockOCRService()
-
-
-def _convert(filename: str, ocr_service: MockOCRService) -> str:
-    path = TEST_DATA_DIR / filename
-    if not path.exists():
-        pytest.skip(f"Test file not found: {path}")
-    converter = DocxConverterWithOCR()
-    with open(path, "rb") as f:
-        return converter.convert(
-            f, StreamInfo(extension=".docx"), ocr_service=ocr_service
-        ).text_content
-
-
-# ---------------------------------------------------------------------------
-# docx_image_start.docx
-# ---------------------------------------------------------------------------
-
-
-def test_docx_image_start(svc: MockOCRService) -> None:
-    expected = (
-        "Document with Image at Start\n\n"
-        "*[Image OCR]\nMOCK_OCR_TEXT_12345\n[End OCR]*\n\n"
-        "This is the main content after the header image.\n\n"
-        "More text content here."
-    )
-    assert _convert("docx_image_start.docx", svc) == expected
-
-
-# ---------------------------------------------------------------------------
-# docx_image_middle.docx
-# ---------------------------------------------------------------------------
-
-
-def test_docx_image_middle(svc: MockOCRService) -> None:
-    expected = (
-        "# Introduction\n\n"
-        "This is the introduction section.\n\n"
-        "We will see an image below.\n\n"
-        "*[Image OCR]\nMOCK_OCR_TEXT_12345\n[End OCR]*\n\n"
-        "# Analysis\n\n"
-        "This section comes after the image."
-    )
-    assert _convert("docx_image_middle.docx", svc) == expected
-
-
-# ---------------------------------------------------------------------------
-# docx_image_end.docx
-# ---------------------------------------------------------------------------
-
-
-def test_docx_image_end(svc: MockOCRService) -> None:
-    expected = (
-        "Report\n\n"
-        "Main findings of the report.\n\n"
-        "Details and analysis.\n\n"
-        "Recommendations.\n\n"
-        "*[Image OCR]\nMOCK_OCR_TEXT_12345\n[End OCR]*"
-    )
-    assert _convert("docx_image_end.docx", svc) == expected
-
-
-# ---------------------------------------------------------------------------
-# docx_multiple_images.docx
-# ---------------------------------------------------------------------------
-
-
-def test_docx_multiple_images(svc: MockOCRService) -> None:
-    expected = (
-        "Multi-Image Document\n\n"
-        "First section\n\n"
-        "*[Image OCR]\nMOCK_OCR_TEXT_12345\n[End OCR]*\n\n"
-        "Second section with another image\n\n"
-        "*[Image OCR]\nMOCK_OCR_TEXT_12345\n[End OCR]*\n\n"
-        "Conclusion"
-    )
-    assert _convert("docx_multiple_images.docx", svc) == expected
-
-
-# ---------------------------------------------------------------------------
-# docx_multipage.docx
-# ---------------------------------------------------------------------------
-
-
-def test_docx_multipage(svc: MockOCRService) -> None:
-    expected = (
-        "# Page 1 - Mixed Content\n\n"
-        "This is the first paragraph on page 1.\n\n"
-        "BEFORE IMAGE: Important content appears here.\n\n"
-        "*[Image OCR]\nMOCK_OCR_TEXT_12345\n[End OCR]*\n\n"
-        "AFTER IMAGE: This content follows the image.\n\n"
-        "More text on page 1.\n\n"
-        "# Page 2 - Image at End\n\n"
-        "Content on page 2.\n\n"
-        "Multiple paragraphs of text.\n\n"
-        "Building up to the image...\n\n"
-        "Final paragraph before image.\n\n"
-        "*[Image OCR]\nMOCK_OCR_TEXT_12345\n[End OCR]*\n\n"
-        "# Page 3 - Image at Start\n\n"
-        "*[Image OCR]\nMOCK_OCR_TEXT_12345\n[End OCR]*\n\n"
-        "Content that follows the header image.\n\n"
-        "AFTER IMAGE: This text is after the image."
-    )
-    assert _convert("docx_multipage.docx", svc) == expected
-
-
-# ---------------------------------------------------------------------------
-# docx_complex_layout.docx
-# ---------------------------------------------------------------------------
-
-
-def test_docx_complex_layout(svc: MockOCRService) -> None:
-    expected = (
-        "Complex Document\n\n"
-        "|  |  |\n"
-        "| --- | --- |\n"
-        "| Feature | Status |\n"
-        "| Authentication | Active |\n"
-        "| Encryption | Enabled |\n\n"
-        "Security notice:\n\n"
-        "*[Image OCR]\nMOCK_OCR_TEXT_12345\n[End OCR]*"
-    )
-    assert _convert("docx_complex_layout.docx", svc) == expected
-
-
-# ---------------------------------------------------------------------------
-# _inject_placeholders — internal unit tests (no file I/O)
-# ---------------------------------------------------------------------------
-
-
-def test_inject_placeholders_single_image() -> None:
-    converter = DocxConverterWithOCR()
-    html = "<p>Before</p><img src='x.png'/><p>After</p>"
-    result_html, texts = converter._inject_placeholders(html, {"rId1": "TEXT"})
-    assert "<img" not in result_html
-    assert "MARKITDOWNOCRBLOCK0" in result_html
-    assert texts == ["TEXT"]
-
-
-def test_inject_placeholders_two_images_sequential_tokens() -> None:
-    converter = DocxConverterWithOCR()
-    html = "<img src='a.png'/><p>Mid</p><img src='b.png'/>"
-    result_html, texts = converter._inject_placeholders(
-        html, {"rId1": "FIRST", "rId2": "SECOND"}
-    )
-    assert "MARKITDOWNOCRBLOCK0" in result_html
-    assert "MARKITDOWNOCRBLOCK1" in result_html
-    assert result_html.index("MARKITDOWNOCRBLOCK0") < result_html.index(
-        "MARKITDOWNOCRBLOCK1"
-    )
-    assert len(texts) == 2
-
-
-def test_inject_placeholders_no_img_tag_appends_at_end() -> None:
-    converter = DocxConverterWithOCR()
-    html = "<p>No images</p>"
-    result_html, texts = converter._inject_placeholders(html, {"rId1": "ORPHAN"})
-    assert "MARKITDOWNOCRBLOCK0" in result_html
-    assert texts == ["ORPHAN"]
-
-
-def test_inject_placeholders_empty_map_leaves_html_unchanged() -> None:
-    converter = DocxConverterWithOCR()
-    html = "<p>Content</p><img src='pic.jpg'/>"
-    result_html, texts = converter._inject_placeholders(html, {})
-    assert result_html == html
-    assert texts == []
-
-
-# ---------------------------------------------------------------------------
-# No OCR service — no OCR tags emitted
-# ---------------------------------------------------------------------------
-
-
-def test_docx_no_ocr_service_no_tags() -> None:
-    path = TEST_DATA_DIR / "docx_image_middle.docx"
-    if not path.exists():
-        pytest.skip(f"Test file not found: {path}")
-    converter = DocxConverterWithOCR()
-    with open(path, "rb") as f:
-        md = converter.convert(f, StreamInfo(extension=".docx")).text_content
-    assert "*[Image OCR]" not in md
-    assert "[End OCR]*" not in md