markitdown-wolfxl 0.1.0__tar.gz

markitdown_wolfxl-0.1.0/.github/workflows/ci.yml

@@ -0,0 +1,25 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+
+permissions:
+  contents: read
+
+jobs:
+  test:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, macos-latest]
+        python: ["3.10", "3.12", "3.13"]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python }}
+      - run: python -m pip install -e '.[test]'
+      - run: python -m pytest -q

markitdown_wolfxl-0.1.0/.github/workflows/publish.yml

@@ -0,0 +1,41 @@
+name: Publish to PyPI
+
+on:
+  push:
+    tags: ["v*"]
+
+permissions:
+  contents: read
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+      - name: Check tag matches package version
+        run: |
+          version=$(python -c "import tomllib; print(tomllib.load(open('pyproject.toml','rb'))['project']['version'])")
+          test "v$version" = "$GITHUB_REF_NAME"
+      - run: python -m pip install build -e '.[test]'
+      - run: python -m pytest -q
+      - run: python -m build
+      - uses: actions/upload-artifact@v4
+        with:
+          name: dist
+          path: dist/
+
+  publish:
+    needs: build
+    runs-on: ubuntu-latest
+    environment: pypi
+    permissions:
+      id-token: write
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          name: dist
+          path: dist/
+      - uses: pypa/gh-action-pypi-publish@release/v1

markitdown_wolfxl-0.1.0/.gitignore

@@ -0,0 +1,6 @@
+.venv/
+__pycache__/
+*.egg-info/
+build/
+dist/
+.pytest_cache/

markitdown_wolfxl-0.1.0/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2026 Wolfgang Schoenberger
+Copyright (c) Microsoft Corporation.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

markitdown_wolfxl-0.1.0/PKG-INFO

@@ -0,0 +1,75 @@
+Metadata-Version: 2.5
+Name: markitdown-wolfxl
+Version: 0.1.0
+Summary: An opt-in WolfXL XLSX converter plugin for MarkItDown
+Project-URL: Repository, https://github.com/SynthGL/markitdown-wolfxl
+Project-URL: Issues, https://github.com/SynthGL/markitdown-wolfxl/issues
+Author: Wolfgang Schoenberger
+License-Expression: MIT
+License-File: LICENSE
+Keywords: excel,markdown,markitdown,markitdown-plugin,wolfxl,xlsx
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Office/Business :: Financial :: Spreadsheet
+Classifier: Topic :: Text Processing :: Markup :: Markdown
+Requires-Python: >=3.10
+Requires-Dist: markitdown<0.2,>=0.1.9
+Requires-Dist: pandas<3,>=2.2
+Requires-Dist: wolfxl<2.1,>=2.0.17
+Provides-Extra: test
+Requires-Dist: openpyxl<4,>=3.1; extra == 'test'
+Requires-Dist: pytest; extra == 'test'
+Description-Content-Type: text/markdown
+
+# markitdown-wolfxl
+
+A third-party, opt-in XLSX converter plugin for [MarkItDown](https://github.com/microsoft/markitdown) that reads workbooks with [WolfXL](https://github.com/SynthGL/wolfxl-oss). It uses only WolfXL's public workbook API and public pandas constructors. It does not modify MarkItDown, register a pandas engine, or import private pandas modules.
+
+## Install
+
+```sh
+pip install markitdown-wolfxl
+markitdown --list-plugins
+```
+
+The package requires `wolfxl>=2.0.17,<2.1`, pandas 2.x, and MarkItDown `>=0.1.9,<0.2`. WolfXL ships native wheels for common platforms; see its project page for the current list.
+
+## Explicit activation
+
+Installing the package does not change ordinary MarkItDown conversions, because MarkItDown keeps plugins disabled by default. Enable plugins to use it:
+
+```python
+from markitdown import MarkItDown
+
+result = MarkItDown(enable_plugins=True).convert("workbook.xlsx")
+print(result.markdown)
+```
+
+```sh
+markitdown --use-plugins workbook.xlsx
+```
+
+The package follows MarkItDown's version-1 plugin interface: entry point group `markitdown.plugin`, `__plugin_interface_version__ = 1`, and `register_converters`. Its XLSX converter is registered at priority `PRIORITY_SPECIFIC_FILE_FORMAT - 1`, ahead of the built-in converter. Files with an explicit non-XLSX extension, including `.xls`, are declined. XLSX MIME information can identify streams without a filename. Other enabled plugins remain subject to MarkItDown's normal priority rules.
+
+## Output and limitations
+
+Each worksheet becomes a Markdown heading and a cell table, in workbook order, using first-row headers, pandas-compatible missing values and dtype inference, and MarkItDown's public HTML converter. Workbooks are closed on success and on conversion failure. The reader ignores understated worksheet-dimension hints instead of silently truncating data.
+
+This converter handles worksheet cell content, not embedded-image OCR or custom image hooks. Do not enable it when another XLSX plugin's image processing is required. Malformed ZIP or XML, encrypted, Strict OOXML, and some legacy-producer files can convert differently from the built-in reader. WolfXL's rejection of duplicate ZIP entry names is kept.
+
+When this plugin raises an ordinary exception, MarkItDown may fall back to another converter, so a successful MarkItDown result does not by itself show that WolfXL converted the file. For example, WolfXL rejects a workbook with a case-insensitive duplicate ZIP entry, and MarkItDown's built-in reader then accepts it. Enabling this plugin is **not an application-wide ZIP validation policy or security boundary**.
+
+On a 353-file XLSX test corpus, 318 files that WolfXL converts produce Markdown byte-identical to MarkItDown's built-in converter. No performance claim is made.
+
+## Tests
+
+```sh
+pip install -e '.[test]'
+pytest
+```
+
+Tests cover entry-point discovery, explicit activation, registration priority, XLSX-only acceptance, public-API dispatch, headers and type inference, dimension hints, workbook closure, and fallback behavior.
+
+## License
+
+MIT. This is an independent third-party plugin, not sponsored by or affiliated with Microsoft. MarkItDown's copyright notice is retained in `LICENSE` for the adapted table-to-Markdown assembly.

markitdown_wolfxl-0.1.0/README.md

@@ -0,0 +1,52 @@
+# markitdown-wolfxl
+
+A third-party, opt-in XLSX converter plugin for [MarkItDown](https://github.com/microsoft/markitdown) that reads workbooks with [WolfXL](https://github.com/SynthGL/wolfxl-oss). It uses only WolfXL's public workbook API and public pandas constructors. It does not modify MarkItDown, register a pandas engine, or import private pandas modules.
+
+## Install
+
+```sh
+pip install markitdown-wolfxl
+markitdown --list-plugins
+```
+
+The package requires `wolfxl>=2.0.17,<2.1`, pandas 2.x, and MarkItDown `>=0.1.9,<0.2`. WolfXL ships native wheels for common platforms; see its project page for the current list.
+
+## Explicit activation
+
+Installing the package does not change ordinary MarkItDown conversions, because MarkItDown keeps plugins disabled by default. Enable plugins to use it:
+
+```python
+from markitdown import MarkItDown
+
+result = MarkItDown(enable_plugins=True).convert("workbook.xlsx")
+print(result.markdown)
+```
+
+```sh
+markitdown --use-plugins workbook.xlsx
+```
+
+The package follows MarkItDown's version-1 plugin interface: entry point group `markitdown.plugin`, `__plugin_interface_version__ = 1`, and `register_converters`. Its XLSX converter is registered at priority `PRIORITY_SPECIFIC_FILE_FORMAT - 1`, ahead of the built-in converter. Files with an explicit non-XLSX extension, including `.xls`, are declined. XLSX MIME information can identify streams without a filename. Other enabled plugins remain subject to MarkItDown's normal priority rules.
+
+## Output and limitations
+
+Each worksheet becomes a Markdown heading and a cell table, in workbook order, using first-row headers, pandas-compatible missing values and dtype inference, and MarkItDown's public HTML converter. Workbooks are closed on success and on conversion failure. The reader ignores understated worksheet-dimension hints instead of silently truncating data.
+
+This converter handles worksheet cell content, not embedded-image OCR or custom image hooks. Do not enable it when another XLSX plugin's image processing is required. Malformed ZIP or XML, encrypted, Strict OOXML, and some legacy-producer files can convert differently from the built-in reader. WolfXL's rejection of duplicate ZIP entry names is kept.
+
+When this plugin raises an ordinary exception, MarkItDown may fall back to another converter, so a successful MarkItDown result does not by itself show that WolfXL converted the file. For example, WolfXL rejects a workbook with a case-insensitive duplicate ZIP entry, and MarkItDown's built-in reader then accepts it. Enabling this plugin is **not an application-wide ZIP validation policy or security boundary**.
+
+On a 353-file XLSX test corpus, 318 files that WolfXL converts produce Markdown byte-identical to MarkItDown's built-in converter. No performance claim is made.
+
+## Tests
+
+```sh
+pip install -e '.[test]'
+pytest
+```
+
+Tests cover entry-point discovery, explicit activation, registration priority, XLSX-only acceptance, public-API dispatch, headers and type inference, dimension hints, workbook closure, and fallback behavior.
+
+## License
+
+MIT. This is an independent third-party plugin, not sponsored by or affiliated with Microsoft. MarkItDown's copyright notice is retained in `LICENSE` for the adapted table-to-Markdown assembly.

markitdown_wolfxl-0.1.0/pyproject.toml

@@ -0,0 +1,41 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "markitdown-wolfxl"
+version = "0.1.0"
+description = "An opt-in WolfXL XLSX converter plugin for MarkItDown"
+readme = "README.md"
+requires-python = ">=3.10"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [{ name = "Wolfgang Schoenberger" }]
+keywords = ["markitdown", "markitdown-plugin", "xlsx", "excel", "wolfxl", "markdown"]
+classifiers = [
+  "Programming Language :: Python :: 3",
+  "Operating System :: OS Independent",
+  "Topic :: Office/Business :: Financial :: Spreadsheet",
+  "Topic :: Text Processing :: Markup :: Markdown",
+]
+dependencies = [
+  "markitdown>=0.1.9,<0.2",
+  "pandas>=2.2,<3",
+  "wolfxl>=2.0.17,<2.1",
+]
+
+[project.urls]
+Repository = "https://github.com/SynthGL/markitdown-wolfxl"
+Issues = "https://github.com/SynthGL/markitdown-wolfxl/issues"
+
+[project.optional-dependencies]
+test = ["pytest", "openpyxl>=3.1,<4"]
+
+[project.entry-points."markitdown.plugin"]
+wolfxl = "markitdown_wolfxl"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/markitdown_wolfxl"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

markitdown_wolfxl-0.1.0/src/markitdown_wolfxl/__init__.py

@@ -0,0 +1,65 @@
+"""Opt-in WolfXL XLSX conversion for MarkItDown's version-1 plugin interface."""
+
+from typing import Any, BinaryIO
+
+from markitdown import (
+    PRIORITY_SPECIFIC_FILE_FORMAT,
+    DocumentConverter,
+    DocumentConverterResult,
+    MarkItDown,
+    StreamInfo,
+)
+from markitdown.converters import HtmlConverter
+
+from ._reader import WolfxlReader
+
+__version__ = "0.1.0"
+__plugin_interface_version__ = 1
+
+__all__ = [
+    "__version__",
+    "__plugin_interface_version__",
+    "register_converters",
+    "WolfxlXlsxConverter",
+]
+
+
+def register_converters(markitdown: MarkItDown, **kwargs: Any) -> None:
+    """Register before the built-in XLSX converter, only when plugins are enabled."""
+    markitdown.register_converter(
+        WolfxlXlsxConverter(), priority=PRIORITY_SPECIFIC_FILE_FORMAT - 1
+    )
+
+
+class WolfxlXlsxConverter(DocumentConverter):
+    """Convert XLSX worksheet cell tables with WolfXL and public pandas APIs."""
+
+    def __init__(self) -> None:
+        super().__init__()
+        self._html_converter = HtmlConverter()
+
+    def accepts(
+        self, file_stream: BinaryIO, stream_info: StreamInfo, **kwargs: Any
+    ) -> bool:
+        extension = (stream_info.extension or "").lower()
+        if extension:
+            return extension == ".xlsx"
+        return (stream_info.mimetype or "").lower() == (
+            "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
+        )
+
+    def convert(
+        self, file_stream: BinaryIO, stream_info: StreamInfo, **kwargs: Any
+    ) -> DocumentConverterResult:
+        reader = WolfxlReader(file_stream)
+        try:
+            sheets = reader.parse()
+        finally:
+            reader.close()
+        fragments = []
+        for name, frame in sheets.items():
+            markdown = self._html_converter.convert_string(
+                frame.to_html(index=False), **kwargs
+            ).markdown.strip()
+            fragments.append(f"## {name}\n{markdown}")
+        return DocumentConverterResult(markdown="\n\n".join(fragments).strip())

markitdown_wolfxl-0.1.0/src/markitdown_wolfxl/_reader.py

@@ -0,0 +1,148 @@
+"""Opt-in XLSX loading using only public WolfXL and pandas APIs."""
+
+from typing import Any
+
+import pandas as pd
+from wolfxl import load_workbook
+
+_NAN = float("nan")
+
+# pandas' documented default missing-value spellings for read_excel/read_csv.
+_NA_VALUES = {
+    "",
+    "#N/A",
+    "#N/A N/A",
+    "#NA",
+    "-1.#IND",
+    "-1.#QNAN",
+    "-NaN",
+    "-nan",
+    "1.#IND",
+    "1.#QNAN",
+    "<NA>",
+    "N/A",
+    "NA",
+    "NULL",
+    "NaN",
+    "None",
+    "n/a",
+    "nan",
+    "null",
+}
+
+
+def _cell_value(cell: Any) -> Any:
+    value = cell.value
+    if value is None:
+        return ""
+    if cell.data_type == "e":
+        return _NAN
+    if cell.data_type == "n" and isinstance(value, (int, float)):
+        integer = int(value)
+        return integer if integer == value else float(value)
+    return value
+
+
+def _frame(rows: list[list[Any]]) -> pd.DataFrame:
+    # Ignore trailing empty rows/cells, but retain interior blanks and sheet order.
+    while rows and not rows[-1]:
+        rows.pop()
+    if not rows:
+        return pd.DataFrame()
+    width = max(map(len, rows))
+    rows = [row + [""] * (width - len(row)) for row in rows]
+    names = [
+        value if value != "" else f"Unnamed: {i}" for i, value in enumerate(rows[0])
+    ]
+    # Match the default header=0 naming, including collisions with literal suffixes.
+    counts: dict[Any, int] = {}
+    order = [i for i, value in enumerate(rows[0]) if value != ""] + [
+        i for i, value in enumerate(rows[0]) if value == ""
+    ]
+    for i in order:
+        name = names[i]
+        count = counts.get(name, 0)
+        while count:
+            counts[name] = count + 1
+            candidate = f"{name}.{count}"
+            if candidate not in names:
+                name = candidate
+            count = counts.get(name, 0)
+        names[i] = name
+        counts[name] = count + 1
+    if len(rows) == 1:
+        return pd.DataFrame(columns=names)
+    columns = []
+    for i in range(width):
+        raw_values = [row[i] for row in rows[1:]]
+        values = [
+            _NAN if isinstance(value, str) and value in _NA_VALUES else value
+            for value in raw_values
+        ]
+        series = pd.Series(values, dtype=object)
+        if series.isna().any():
+            try:
+                nonmissing_numeric = pd.to_numeric(series.dropna())
+            except (ValueError, TypeError):
+                pass
+            else:
+                # read_excel retains object values, including NA spellings, when
+                # unsigned 64-bit integers and missing values cannot share a
+                # lossless NumPy dtype. Do not round those integers to float.
+                if pd.api.types.is_unsigned_integer_dtype(nonmissing_numeric.dtype):
+                    columns.append(pd.Series(raw_values, dtype=object))
+                    continue
+        try:
+            series = pd.to_numeric(series)
+        except (ValueError, TypeError):
+            # Object columns retain the first equal scalar, including Python's
+            # 1 == True / 0 == False aliases, just as read_excel does.
+            canonical: dict[Any, Any] = {}
+            for value in series:
+                canonical.setdefault(value, value)
+            series = series.map(canonical)
+            # Numeric inference precedes boolean inference, as in read_excel.
+            nonmissing = series.dropna()
+            boolean_values = {
+                True: True,
+                False: False,
+                "True": True,
+                "TRUE": True,
+                "true": True,
+                "False": False,
+                "FALSE": False,
+                "false": False,
+            }
+            if len(nonmissing) and all(
+                isinstance(value, (str, bool)) and value in boolean_values
+                for value in nonmissing
+            ):
+                series = series.map(boolean_values)
+        columns.append(series.infer_objects())
+    frame = pd.concat(columns, axis=1)
+    frame.columns = names
+    return frame
+
+
+class WolfxlReader:
+    def __init__(self, filepath_or_buffer: Any) -> None:
+        self.book = load_workbook(
+            filepath_or_buffer, read_only=True, data_only=True, keep_links=False
+        )
+
+    def parse(self, sheet_name: None = None) -> dict[str, pd.DataFrame]:
+        sheets = {}
+        for sheet in self.book.worksheets:
+            # Producer dimension hints can understate the actual XML data.
+            sheet.reset_dimensions()
+            rows = []
+            for row in sheet.iter_rows():
+                values = [_cell_value(cell) for cell in row]
+                while values and values[-1] == "":
+                    values.pop()
+                rows.append(values)
+            sheets[sheet.title] = _frame(rows)
+        return sheets
+
+    def close(self) -> None:
+        self.book.close()

markitdown_wolfxl-0.1.0/tests/test_plugin.py

@@ -0,0 +1,237 @@
+import datetime
+import importlib.metadata
+import io
+import re
+import subprocess
+import sys
+import zipfile
+from unittest.mock import Mock
+
+import markitdown_wolfxl as plugin
+import openpyxl
+import pandas as pd
+import pytest
+from markitdown import PRIORITY_SPECIFIC_FILE_FORMAT, MarkItDown, StreamInfo
+from markitdown.converters import XlsxConverter
+from markitdown_wolfxl import _reader
+
+
+def workbook_bytes(rows, *, second_sheet=True):
+    workbook = openpyxl.Workbook()
+    workbook.active.title = "Second"
+    for row in rows:
+        workbook.active.append(row)
+    if second_sheet:
+        workbook.create_sheet("First").append(["Other"])
+    stream = io.BytesIO()
+    workbook.save(stream)
+    workbook.close()
+    return stream.getvalue()
+
+
+def convert(data, enabled):
+    return (
+        MarkItDown(enable_plugins=enabled)
+        .convert_stream(io.BytesIO(data), stream_info=StreamInfo(extension=".xlsx"))
+        .markdown
+    )
+
+
+def test_installed_entry_point_and_interface():
+    entry = next(
+        entry
+        for entry in importlib.metadata.entry_points(group="markitdown.plugin")
+        if entry.name == "wolfxl"
+    )
+    assert entry.value == "markitdown_wolfxl"
+    assert entry.load() is plugin
+    assert plugin.__plugin_interface_version__ == 1
+
+
+def test_registration_priority():
+    host = Mock()
+    plugin.register_converters(host)
+    (converter,), kwargs = host.register_converter.call_args
+    assert isinstance(converter, plugin.WolfxlXlsxConverter)
+    assert kwargs == {"priority": PRIORITY_SPECIFIC_FILE_FORMAT - 1}
+
+
+@pytest.mark.parametrize("extension", [".xlsx", ".XLSX"])
+def test_accepts_xlsx_without_consuming_input(extension):
+    stream = io.BytesIO(b"not inspected by accepts")
+    stream.seek(3)
+    assert plugin.WolfxlXlsxConverter().accepts(stream, StreamInfo(extension=extension))
+    assert stream.tell() == 3
+
+
+@pytest.mark.parametrize("extension", [".xls", ".xlsm", ".docx", ".txt", ".zip"])
+def test_declines_other_extensions_even_with_xlsx_mime(extension):
+    assert not plugin.WolfxlXlsxConverter().accepts(
+        io.BytesIO(),
+        StreamInfo(
+            extension=extension,
+            mimetype="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+        ),
+    )
+
+
+def test_accepts_mime_only_xlsx_stream():
+    assert plugin.WolfxlXlsxConverter().accepts(
+        io.BytesIO(),
+        StreamInfo(
+            mimetype="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
+        ),
+    )
+    assert not plugin.WolfxlXlsxConverter().accepts(io.BytesIO(), StreamInfo())
+
+
+def test_plugin_only_runs_with_explicit_activation(monkeypatch):
+    original = plugin.WolfxlXlsxConverter.convert
+    calls = []
+
+    def observed(self, *args, **kwargs):
+        calls.append(True)
+        return original(self, *args, **kwargs)
+
+    monkeypatch.setattr(plugin.WolfxlXlsxConverter, "convert", observed)
+    data = workbook_bytes([["A", "B"], ["<cell> & *value*", 12]])
+    expected = convert(data, False)
+    assert not calls
+    assert convert(data, True) == expected
+    assert calls == [True]
+
+
+def test_public_api_builtin_fallback_is_not_suppressed(monkeypatch):
+    data = workbook_bytes([["A"], [12]])
+    expected = convert(data, False)
+    calls = []
+
+    def fail(*args, **kwargs):
+        calls.append(True)
+        raise ValueError("plugin rejection")
+
+    monkeypatch.setattr(plugin.WolfxlXlsxConverter, "convert", fail)
+    assert convert(data, True) == expected
+    assert calls
+
+
+@pytest.mark.parametrize(
+    "rows",
+    [
+        [],
+        [["A", "B"]],
+        [["A", "A", "A.1", None], [1, 2, 3, 4]],
+        [[30, None], [1, 2], [None, 3], [None, None]],
+        [["A", "B"], [True, 1], [None, 2], [False, 3]],
+        [["A", "B"], ["True", 1], ["FALSE", 2], [None, 3]],
+        [["A", "B"], ["01", 1], ["1.5", 2], ["NA", 3]],
+        [["A", "B"], ["x", 1], [None, 2], ["<NA>", 3]],
+        [["A", "B"], ["#DIV/0!", 1], [2, 3]],
+        [[None, None], [1, 2]],
+        [["A", "B"], [None, None], [1, 2]],
+        [[None, "Unnamed: 0"], [1, 2]],
+        [["A", "B"], [0, 1], ["TRUE", 2]],
+        [["A", "B"], [None, 1], [2**63, 2]],
+        [["A", "B"], ["NA", 1], [2**63, 2]],
+        [["A"], [1], [True], ["text"]],
+        [["A"], [True], [1], ["text"]],
+        [["#DIV/0!", True, "#N/A", "#REF!"], [1, 2, 3, 4]],
+    ],
+)
+def test_frames_and_public_api_markdown_match_stock(rows):
+    data = workbook_bytes(rows)
+    expected = pd.read_excel(io.BytesIO(data), sheet_name=None, engine="openpyxl")
+    reader = _reader.WolfxlReader(io.BytesIO(data))
+    try:
+        actual = reader.parse()
+    finally:
+        reader.close()
+    assert list(actual) == ["Second", "First"] == list(expected)
+    for name in expected:
+        pd.testing.assert_frame_equal(actual[name], expected[name])
+    direct = (
+        plugin.WolfxlXlsxConverter()
+        .convert(io.BytesIO(data), StreamInfo(extension=".xlsx"))
+        .markdown
+    )
+    assert (
+        direct
+        == XlsxConverter()
+        .convert(io.BytesIO(data), StreamInfo(extension=".xlsx"))
+        .markdown
+    )
+    assert convert(data, True) == convert(data, False)
+
+
+def test_date_and_time_inference():
+    data = workbook_bytes(
+        [
+            ["date", "time", "mixed"],
+            [datetime.datetime(2026, 1, 1), datetime.time(12, 30), 1],
+            [None, None, datetime.datetime(2026, 1, 2)],
+        ]
+    )
+    reader = _reader.WolfxlReader(io.BytesIO(data))
+    try:
+        actual = reader.parse()
+    finally:
+        reader.close()
+    expected = pd.read_excel(io.BytesIO(data), sheet_name=None, engine="openpyxl")
+    for name in expected:
+        pd.testing.assert_frame_equal(actual[name], expected[name])
+    assert convert(data, True) == convert(data, False)
+
+
+@pytest.mark.parametrize("fail", [False, True])
+def test_workbook_is_closed_even_if_iteration_fails(monkeypatch, fail):
+    workbook = Mock()
+    if fail:
+        sheet = Mock()
+        sheet.iter_rows.side_effect = ValueError("iteration failed")
+        workbook.worksheets = [sheet]
+    else:
+        workbook.worksheets = []
+    monkeypatch.setattr(_reader, "load_workbook", Mock(return_value=workbook))
+    converter = plugin.WolfxlXlsxConverter()
+    if fail:
+        with pytest.raises(ValueError, match="iteration failed"):
+            converter.convert(io.BytesIO(), StreamInfo(extension=".xlsx"))
+    else:
+        assert (
+            converter.convert(io.BytesIO(), StreamInfo(extension=".xlsx")).markdown
+            == ""
+        )
+    workbook.close.assert_called_once_with()
+
+
+def test_understated_dimensions_do_not_truncate():
+    source = workbook_bytes([["A", "B"], [1, 2], [3, 4]])
+    target = io.BytesIO()
+    with zipfile.ZipFile(io.BytesIO(source)) as src, zipfile.ZipFile(
+        target, "w"
+    ) as dst:
+        for entry in src.infolist():
+            data = src.read(entry.filename)
+            if entry.filename.startswith("xl/worksheets/"):
+                data = re.sub(rb'<dimension ref="[^"]*"', b'<dimension ref="A1"', data)
+            dst.writestr(entry, data)
+    assert convert(target.getvalue(), True) == convert(target.getvalue(), False)
+
+
+def test_cli_plugin_discovery_and_activation(tmp_path):
+    path = tmp_path / "test.xlsx"
+    path.write_bytes(workbook_bytes([["A"], [12]]))
+    plugins = subprocess.run(
+        [sys.executable, "-m", "markitdown", "--list-plugins"],
+        capture_output=True,
+        text=True,
+        check=True,
+    )
+    assert "wolfxl" in plugins.stdout
+    result = subprocess.run(
+        [sys.executable, "-m", "markitdown", "--use-plugins", str(path)],
+        capture_output=True,
+        text=True,
+        check=True,
+    )
+    assert result.stdout.strip() == convert(path.read_bytes(), True)