tablewise 1.1.0__tar.gz → 1.1.2__tar.gz

{tablewise-1.1.0 → tablewise-1.1.2}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: tablewise
-Version: 1.1.0
-Summary: Convierte PDF/Word/Excel/PowerPoint a Markdown con cabecera de procedencia, listo para un RAG
+Version: 1.1.2
+Summary: Spreadsheet-grade document to Markdown with provenance, ready for RAG and LLM ingestion
 Author: Luis Francisco Palomares Gamarra
 License: MIT License
         
@@ -25,6 +25,8 @@ License: MIT License
         OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
         SOFTWARE.
         
+Project-URL: Homepage, https://tablewise.dev
+Project-URL: Documentation, https://tablewise.dev/docs
 Keywords: markdown,rag,pdf,docx,xlsx,markitdown,docling
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
@@ -32,22 +34,39 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Environment :: MacOS X
+Classifier: Environment :: Win32 (MS Windows)
+Classifier: Environment :: X11 Applications
 Classifier: Topic :: Text Processing :: Markup :: Markdown
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Provides-Extra: excel
 Requires-Dist: openpyxl>=3.1; extra == "excel"
+Requires-Dist: xlrd>=2.0; extra == "excel"
 Provides-Extra: docling
 Requires-Dist: docling; extra == "docling"
+Provides-Extra: office
+Requires-Dist: python-docx>=1.1; extra == "office"
+Requires-Dist: python-pptx>=0.6.23; extra == "office"
+Provides-Extra: propio
+Requires-Dist: onnxruntime>=1.24; extra == "propio"
+Requires-Dist: pymupdf>=1.24; extra == "propio"
+Requires-Dist: numpy>=1.26; extra == "propio"
+Requires-Dist: pillow>=10; extra == "propio"
+Requires-Dist: rapidocr<4,>=3.9; extra == "propio"
 Provides-Extra: dev
 Requires-Dist: pytest>=8; extra == "dev"
 Requires-Dist: openpyxl>=3.1; extra == "dev"
 Requires-Dist: PyYAML>=6; extra == "dev"
+Requires-Dist: python-docx>=1.1; extra == "dev"
+Requires-Dist: python-pptx>=0.6.23; extra == "dev"
 Dynamic: license-file
 
 # Tablewise
 
+[![PyPI](https://img.shields.io/pypi/v/tablewise.svg)](https://pypi.org/project/tablewise/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)](LICENSE)
+
 **Spreadsheet-grade document conversion to Markdown, with provenance.**
 PDF, Word, Excel and PowerPoint in; clean, citable Markdown out — built for RAG,
 LLM ingestion and audit trails.
@@ -66,10 +85,23 @@ converted: 2026-10-22
 Three front ends, one decision engine:
 
 - **`tablewise` CLI** — one document in, one `.md` out. Scripts, agents, batches.
-- **Desktop app** (Tkinter) — for people who do not live in a terminal.
+- **Done-for-you ingestion sprint** — we convert your corpus and check it against a
+  sample you approve: https://tablewise.dev/#done-for-you (a Tkinter desktop app ships
+  in this repository but is not packaged).
 - **Hosted API** — `POST /v1/convert`, per-month plans, no install. See
   [PRICING.md](PRICING.md).
 
+## Documentation
+
+- [User guide](docs/USER_GUIDE.md) — CLI, desktop app and API, step by step.
+- [Architecture](docs/ARCHITECTURE.md) — components, data model, failure modes.
+- [Maintenance](docs/MAINTENANCE.md) — cadence, automation, incidents.
+- [Business model](docs/BUSINESS_MODEL.md) — public repo + paid product (open-core).
+- [Decisions](docs/DECISIONS.md) — short ADR log (why SQLite, monthly only, engine fallback).
+- [Retainer](docs/RETAINER.md) — how the monthly ingestion service works, end to end.
+- [Operations](docs/OPERATIONS.md) · [Pricing](PRICING.md) · [Security](SECURITY.md) ·
+  [Contributing](CONTRIBUTING.md) · [Changelog](CHANGELOG.md).
+
 ## The problem it solves
 
 Most converters flatten a financial table into something no model can use. A
@@ -90,23 +122,17 @@ Tablewise routes spreadsheets to an engine that reads the sheet as a sheet:
 - Hidden sheets kept but labelled `(hidden sheet)`.
 - A formula that was never recalculated says `(formula not calculated)` instead
   of an empty cell that a model reads as zero.
-- Deterministic: no AI, no network, same bytes in → same Markdown out.
+- Deterministic: no AI, no network, same input and same content (the provenance date is the only variable).
 
 ## Quickstart
 
 ```bash
-pip install -e .            # installs the `tablewise` command
+pip install "tablewise[excel]"   # from PyPI; add [docling] or [propio] for PDF/DOCX tables
 tablewise report.pdf                    # -> ~/md-repo/report.md
 tablewise budget.xlsx -o ~/md-repo -n "2026 budget"
 tablewise contract.docx --dry-run       # print the engine command, do not run it
 ```
 
-The desktop app:
-
-```bash
-python tablewise_app.py
-```
-
 The API:
 
 ```bash
@@ -115,6 +141,14 @@ curl -X POST https://api.tablewise.dev/v1/convert \
   -F "file=@budget.xlsx"
 ```
 
+## Benchmark in one line
+
+On the synthetic P&L of the public benchmark (three-level header, merged cells,
+formulas, percentages), MarkItDown produces 11 `Unnamed` columns and 41 empty cells;
+Tablewise produces none, keeps the 3 percentages and labels the 3 unevaluated
+formulas. Reproduce it with `python bench/run_benchmark.py` or download the five
+workbooks from https://tablewise.dev/benchmark.
+
 ## Why not just MarkItDown / Docling?
 
 They are good engines and Tablewise uses both. The difference is the routing,
@@ -126,7 +160,6 @@ the table fidelity and the provenance — not a new parser.
 | Formula never recalculated | empty cell | empty cell | labelled |
 | Provenance header on every file | no | no | yes |
 | Deterministic, no AI, no network | yes | yes (heavy) | yes |
-| Desktop GUI for non-technical users | no | no | yes |
 | Hosted API with per-month plans and batch | no | no | yes |
 
 ## Engine routing
@@ -134,14 +167,44 @@ the table fidelity and the provenance — not a new parser.
 Each extension has exactly one owner:
 
 - `.xlsx` `.xlsm` `.xltx` `.xltm` → `motor_excel.py` (openpyxl, local, no AI)
-- `.pdf` `.docx` `.pptx` → `motor_docling.py` (Docling, local, no AI)
+- `.docx` `.pptx` → `motor_office.py` (python-docx/python-pptx, local, no AI) when the `office` extra is installed; otherwise `motor_docling.py`
+- `.pdf` → `motor_propio.py` when its models are installed; otherwise `motor_docling.py` (Docling, local, no AI) — **optional** in the hosted image (`INSTALL_DOCLING=0` by default)
 - `.doc` `.rtf` `.odt` → `textutil` (macOS) → HTML → `motor_docling.py`
-- `.xls` `.ppt` (Office 97-2003) → LibreOffice → `.xlsx`/`.pptx` → `motor_excel.py` / `motor_docling.py`
+- `.xls` (Office 97-2003) → LibreOffice → `.xlsx` → `motor_excel.py`
+- `.ppt` (Office 97-2003) → LibreOffice → `.pptx` inside `motor_docling.py` (legacy path; `motor_office` does not read `.ppt`)
 - everything else (CSV, HTML, EPUB, …) → MarkItDown
 
-The two own engines are `motor_excel.py` and `motor_docling.py`. A format
-without an available engine is refused with an explicit message, never silently
-degraded.
+The own engines are `motor_excel.py`, `motor_office.py`, `motor_docling.py` and `motor_propio.py`.
+Known limits of `motor_office`: headers/footers are not extracted, text boxes
+are appended at the end (visual order is not guaranteed), and a nested table is
+emitted after its parent table. Legacy `.doc/.rtf/.odt/.ppt` stay on Docling.
+
+### PDF tables (own engine)
+
+PDFs use the own **`motor_propio.py`** engine (Microsoft Table Transformer +
+RapidOCR, ONNX, CPU) instead of Docling **only when its models are installed**:
+it is faster (~0.9 s/doc digital, ~2.6 s scanned) and more accurate on tables
+(0.94 exact rows on the blind control and 0.92 on the real set; v1: 0.92 / 0.90).
+Full per-set table: [tablewise.dev/benchmark#pdf-engine](https://tablewise.dev/benchmark#pdf-engine).
+Since `modelos-v2` (c07) it runs two detectors (`det` v1 + `det2` c06) and picks
+the better box per page; the structure model is unchanged. The models are
+published at
+[`tablewise-modelos`](https://github.com/lfpalomaresg/tablewise-modelos/releases/tag/modelos-v2);
+install them with:
+
+```bash
+curl -fsSL -O https://github.com/lfpalomaresg/tablewise-modelos/releases/download/modelos-v2/SHA256SUMS
+python3 scripts/modelos_propio.py \
+  --url https://github.com/lfpalomaresg/tablewise-modelos/releases/download/modelos-v2/ \
+  --sha256 SHA256SUMS
+python3 scripts/modelos_propio.py --verificar   # det2: sí
+```
+
+They go to `~/.cache/tablewise/modelos` (or `TABLEWISE_PROPIO_MODELS`); ~347 MB,
+never in the repo or the wheel. `PROPIO_DET2=0` disables the second detector.
+Without the models, PDFs stay on Docling — no
+change in behaviour. A format without an available engine is refused with an
+explicit message, never silently degraded.
 
 ## CLI reference
 
@@ -167,9 +230,14 @@ The API is the same engine behind HTTP, for teams that cannot install anything:
 | Business | 25,000 | $149 |
 
 One unit = one PDF page, one spreadsheet sheet, one slide, or one document.
-Overage $0.015/unit. Annual −20%. The full contract (quota, DPA, refunds) is in
+No overage billing yet (upgrade the plan). Annual billing is not available yet. The full contract (quota, DPA, refunds) is in
 [PRICING.md](PRICING.md) and on the website.
 
+## Operations
+
+Deploying, billing, support, backups and incident playbook:
+[docs/OPERATIONS.md](docs/OPERATIONS.md).
+
 ## Development
 
 Runner: `pytest`, using the engines virtualenv (it carries openpyxl and PyYAML):
@@ -188,6 +256,10 @@ Runner: `pytest`, using the engines virtualenv (it carries openpyxl and PyYAML):
 | `tests/test_preconversion.py` | LibreOffice (`soffice`): lookup outside PATH and `.xls` → `.xlsx` keeping merges (skipped without LibreOffice) |
 | `tests/test_preconversion_errores.py` | `preconversion.py` with simulated `subprocess.run`: timeout, tool that cannot start, exit 0 without file, error code, own profile |
 | `tests/test_motor_docling_convertir.py` | `motor_docling.convertir` with an injected fake Docling: empty output, temp cleanup, `.ppt` routing, uppercase extensions |
+| `tests/test_motor_propio.py` | own PDF engine: model resolution, safe PDF→own/Docling routing, table repairs, CLI error contract |
+| `tests/test_motor_propio_escaneados.py` | own PDF engine on scans: OCR without line-orientation classifier, lone dash in empty value cells |
+| `tests/test_quality.py` | synthetic quality KPI: table/row metric and table-text filtering without loading the ONNX models |
+| `tests/test_motor_office.py` | light Office engine: `.docx`/`.pptx` paragraphs and tables without Docling, CLI contract |
 | `tests/test_entradas_externas.py` | `.xls` path, malformed array formulas, backslashes in the YAML header, non-UTF-8 output, BOM and CRLF |
 | `tests/test_preconversion_ejecutables_falsos.py` | textutil/LibreOffice boundary with fake executables |
 | `tests/test_app_convertir.py` | `App.convert()` with fake tkinter and engine: existing `.md` (cancel / numbered copy / overwrite), failing engine, non-UTF-8 output, partial writes |
@@ -195,6 +267,8 @@ Runner: `pytest`, using the engines virtualenv (it carries openpyxl and PyYAML):
 | `tests/test_red_sintaxis.py` | regression net: every application file is valid Python and the app imports without opening a window |
 | `tests/test_cli.py` | `tablewise` CLI: same decisions as the app, `--dry-run`, no overwrite without `--force`, exit codes |
 | `tests/test_docs.py` | drift net: this README lists every test file and every routed extension |
+| `tests/test_sprint_deliver.py` | `scripts/sprint_deliver.py`: delivery package, manifest hashes, failed files listed, determinism check |
+| `tests/test_weekly_summary.py` | `scripts/weekly_summary.py`: the 5-number weekly funnel summary |
 
 No test uses real documents.
 

{tablewise-1.1.0 → tablewise-1.1.2}/README.md

@@ -1,5 +1,8 @@
 # Tablewise
 
+[![PyPI](https://img.shields.io/pypi/v/tablewise.svg)](https://pypi.org/project/tablewise/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)](LICENSE)
+
 **Spreadsheet-grade document conversion to Markdown, with provenance.**
 PDF, Word, Excel and PowerPoint in; clean, citable Markdown out — built for RAG,
 LLM ingestion and audit trails.
@@ -18,10 +21,23 @@ converted: 2026-10-22
 Three front ends, one decision engine:
 
 - **`tablewise` CLI** — one document in, one `.md` out. Scripts, agents, batches.
-- **Desktop app** (Tkinter) — for people who do not live in a terminal.
+- **Done-for-you ingestion sprint** — we convert your corpus and check it against a
+  sample you approve: https://tablewise.dev/#done-for-you (a Tkinter desktop app ships
+  in this repository but is not packaged).
 - **Hosted API** — `POST /v1/convert`, per-month plans, no install. See
   [PRICING.md](PRICING.md).
 
+## Documentation
+
+- [User guide](docs/USER_GUIDE.md) — CLI, desktop app and API, step by step.
+- [Architecture](docs/ARCHITECTURE.md) — components, data model, failure modes.
+- [Maintenance](docs/MAINTENANCE.md) — cadence, automation, incidents.
+- [Business model](docs/BUSINESS_MODEL.md) — public repo + paid product (open-core).
+- [Decisions](docs/DECISIONS.md) — short ADR log (why SQLite, monthly only, engine fallback).
+- [Retainer](docs/RETAINER.md) — how the monthly ingestion service works, end to end.
+- [Operations](docs/OPERATIONS.md) · [Pricing](PRICING.md) · [Security](SECURITY.md) ·
+  [Contributing](CONTRIBUTING.md) · [Changelog](CHANGELOG.md).
+
 ## The problem it solves
 
 Most converters flatten a financial table into something no model can use. A
@@ -42,23 +58,17 @@ Tablewise routes spreadsheets to an engine that reads the sheet as a sheet:
 - Hidden sheets kept but labelled `(hidden sheet)`.
 - A formula that was never recalculated says `(formula not calculated)` instead
   of an empty cell that a model reads as zero.
-- Deterministic: no AI, no network, same bytes in → same Markdown out.
+- Deterministic: no AI, no network, same input and same content (the provenance date is the only variable).
 
 ## Quickstart
 
 ```bash
-pip install -e .            # installs the `tablewise` command
+pip install "tablewise[excel]"   # from PyPI; add [docling] or [propio] for PDF/DOCX tables
 tablewise report.pdf                    # -> ~/md-repo/report.md
 tablewise budget.xlsx -o ~/md-repo -n "2026 budget"
 tablewise contract.docx --dry-run       # print the engine command, do not run it
 ```
 
-The desktop app:
-
-```bash
-python tablewise_app.py
-```
-
 The API:
 
 ```bash
@@ -67,6 +77,14 @@ curl -X POST https://api.tablewise.dev/v1/convert \
   -F "file=@budget.xlsx"
 ```
 
+## Benchmark in one line
+
+On the synthetic P&L of the public benchmark (three-level header, merged cells,
+formulas, percentages), MarkItDown produces 11 `Unnamed` columns and 41 empty cells;
+Tablewise produces none, keeps the 3 percentages and labels the 3 unevaluated
+formulas. Reproduce it with `python bench/run_benchmark.py` or download the five
+workbooks from https://tablewise.dev/benchmark.
+
 ## Why not just MarkItDown / Docling?
 
 They are good engines and Tablewise uses both. The difference is the routing,
@@ -78,7 +96,6 @@ the table fidelity and the provenance — not a new parser.
 | Formula never recalculated | empty cell | empty cell | labelled |
 | Provenance header on every file | no | no | yes |
 | Deterministic, no AI, no network | yes | yes (heavy) | yes |
-| Desktop GUI for non-technical users | no | no | yes |
 | Hosted API with per-month plans and batch | no | no | yes |
 
 ## Engine routing
@@ -86,14 +103,44 @@ the table fidelity and the provenance — not a new parser.
 Each extension has exactly one owner:
 
 - `.xlsx` `.xlsm` `.xltx` `.xltm` → `motor_excel.py` (openpyxl, local, no AI)
-- `.pdf` `.docx` `.pptx` → `motor_docling.py` (Docling, local, no AI)
+- `.docx` `.pptx` → `motor_office.py` (python-docx/python-pptx, local, no AI) when the `office` extra is installed; otherwise `motor_docling.py`
+- `.pdf` → `motor_propio.py` when its models are installed; otherwise `motor_docling.py` (Docling, local, no AI) — **optional** in the hosted image (`INSTALL_DOCLING=0` by default)
 - `.doc` `.rtf` `.odt` → `textutil` (macOS) → HTML → `motor_docling.py`
-- `.xls` `.ppt` (Office 97-2003) → LibreOffice → `.xlsx`/`.pptx` → `motor_excel.py` / `motor_docling.py`
+- `.xls` (Office 97-2003) → LibreOffice → `.xlsx` → `motor_excel.py`
+- `.ppt` (Office 97-2003) → LibreOffice → `.pptx` inside `motor_docling.py` (legacy path; `motor_office` does not read `.ppt`)
 - everything else (CSV, HTML, EPUB, …) → MarkItDown
 
-The two own engines are `motor_excel.py` and `motor_docling.py`. A format
-without an available engine is refused with an explicit message, never silently
-degraded.
+The own engines are `motor_excel.py`, `motor_office.py`, `motor_docling.py` and `motor_propio.py`.
+Known limits of `motor_office`: headers/footers are not extracted, text boxes
+are appended at the end (visual order is not guaranteed), and a nested table is
+emitted after its parent table. Legacy `.doc/.rtf/.odt/.ppt` stay on Docling.
+
+### PDF tables (own engine)
+
+PDFs use the own **`motor_propio.py`** engine (Microsoft Table Transformer +
+RapidOCR, ONNX, CPU) instead of Docling **only when its models are installed**:
+it is faster (~0.9 s/doc digital, ~2.6 s scanned) and more accurate on tables
+(0.94 exact rows on the blind control and 0.92 on the real set; v1: 0.92 / 0.90).
+Full per-set table: [tablewise.dev/benchmark#pdf-engine](https://tablewise.dev/benchmark#pdf-engine).
+Since `modelos-v2` (c07) it runs two detectors (`det` v1 + `det2` c06) and picks
+the better box per page; the structure model is unchanged. The models are
+published at
+[`tablewise-modelos`](https://github.com/lfpalomaresg/tablewise-modelos/releases/tag/modelos-v2);
+install them with:
+
+```bash
+curl -fsSL -O https://github.com/lfpalomaresg/tablewise-modelos/releases/download/modelos-v2/SHA256SUMS
+python3 scripts/modelos_propio.py \
+  --url https://github.com/lfpalomaresg/tablewise-modelos/releases/download/modelos-v2/ \
+  --sha256 SHA256SUMS
+python3 scripts/modelos_propio.py --verificar   # det2: sí
+```
+
+They go to `~/.cache/tablewise/modelos` (or `TABLEWISE_PROPIO_MODELS`); ~347 MB,
+never in the repo or the wheel. `PROPIO_DET2=0` disables the second detector.
+Without the models, PDFs stay on Docling — no
+change in behaviour. A format without an available engine is refused with an
+explicit message, never silently degraded.
 
 ## CLI reference
 
@@ -119,9 +166,14 @@ The API is the same engine behind HTTP, for teams that cannot install anything:
 | Business | 25,000 | $149 |
 
 One unit = one PDF page, one spreadsheet sheet, one slide, or one document.
-Overage $0.015/unit. Annual −20%. The full contract (quota, DPA, refunds) is in
+No overage billing yet (upgrade the plan). Annual billing is not available yet. The full contract (quota, DPA, refunds) is in
 [PRICING.md](PRICING.md) and on the website.
 
+## Operations
+
+Deploying, billing, support, backups and incident playbook:
+[docs/OPERATIONS.md](docs/OPERATIONS.md).
+
 ## Development
 
 Runner: `pytest`, using the engines virtualenv (it carries openpyxl and PyYAML):
@@ -140,6 +192,10 @@ Runner: `pytest`, using the engines virtualenv (it carries openpyxl and PyYAML):
 | `tests/test_preconversion.py` | LibreOffice (`soffice`): lookup outside PATH and `.xls` → `.xlsx` keeping merges (skipped without LibreOffice) |
 | `tests/test_preconversion_errores.py` | `preconversion.py` with simulated `subprocess.run`: timeout, tool that cannot start, exit 0 without file, error code, own profile |
 | `tests/test_motor_docling_convertir.py` | `motor_docling.convertir` with an injected fake Docling: empty output, temp cleanup, `.ppt` routing, uppercase extensions |
+| `tests/test_motor_propio.py` | own PDF engine: model resolution, safe PDF→own/Docling routing, table repairs, CLI error contract |
+| `tests/test_motor_propio_escaneados.py` | own PDF engine on scans: OCR without line-orientation classifier, lone dash in empty value cells |
+| `tests/test_quality.py` | synthetic quality KPI: table/row metric and table-text filtering without loading the ONNX models |
+| `tests/test_motor_office.py` | light Office engine: `.docx`/`.pptx` paragraphs and tables without Docling, CLI contract |
 | `tests/test_entradas_externas.py` | `.xls` path, malformed array formulas, backslashes in the YAML header, non-UTF-8 output, BOM and CRLF |
 | `tests/test_preconversion_ejecutables_falsos.py` | textutil/LibreOffice boundary with fake executables |
 | `tests/test_app_convertir.py` | `App.convert()` with fake tkinter and engine: existing `.md` (cancel / numbered copy / overwrite), failing engine, non-UTF-8 output, partial writes |
@@ -147,6 +203,8 @@ Runner: `pytest`, using the engines virtualenv (it carries openpyxl and PyYAML):
 | `tests/test_red_sintaxis.py` | regression net: every application file is valid Python and the app imports without opening a window |
 | `tests/test_cli.py` | `tablewise` CLI: same decisions as the app, `--dry-run`, no overwrite without `--force`, exit codes |
 | `tests/test_docs.py` | drift net: this README lists every test file and every routed extension |
+| `tests/test_sprint_deliver.py` | `scripts/sprint_deliver.py`: delivery package, manifest hashes, failed files listed, determinism check |
+| `tests/test_weekly_summary.py` | `scripts/weekly_summary.py`: the 5-number weekly funnel summary |
 
 No test uses real documents.
 

tablewise-1.1.2/motor_office.py

@@ -0,0 +1,172 @@
+"""Conversor ligero de Word (.docx) y PowerPoint (.pptx) a Markdown.
+
+Lee la estructura nativa del OOXML con `python-docx` / `python-pptx` (MIT), en
+vez de cargar Docling + torch (~3 GB) solo para reconstruir tablas que ya están
+etiquetadas como tablas en el documento. No usa IA ni modelos: es determinista,
+rápido y conserva el orden párrafo/tabla del cuerpo.
+
+Los formatos legacy (.doc/.rtf/.odt/.ppt) siguen en Docling (o en LibreOffice
+antes de Docling): aquí no se adivina un binario de 1997.
+
+CLI: python motor_office.py <origen.docx|.pptx> <destino.md>
+Librería: from motor_office import convertir
+"""
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+from postpro import _render
+from tablewise_core import escribir_atomico, misma_ruta
+
+
+class ConversionVacia(Exception):
+    """El documento no produjo contenido."""
+
+
+def _heading(paragraph) -> str:
+    estilo = (getattr(paragraph.style, "name", "") or "").lower()
+    texto = paragraph.text.strip()
+    if not texto:
+        return ""
+    if estilo == "title":
+        return f"# {texto}"
+    if estilo.startswith("heading"):
+        digits = "".join(ch for ch in estilo if ch.isdigit())
+        nivel = max(1, min(6, int(digits) if digits else 1))
+        return f"{'#' * nivel} {texto}"
+    return texto
+
+
+def _docx(origen: Path) -> str:
+    from docx import Document
+    from docx.oxml.ns import qn
+    from docx.table import Table
+    from docx.text.paragraph import Paragraph
+
+    doc = Document(str(origen))
+    partes: list[str] = []
+
+    vistos_tablas: set = set()
+
+    def add_tabla(tabla) -> None:
+        # `walk` y `celda.tables` pueden llegar a la misma tabla por caminos
+        # distintos (sdt, tabla anidada): se emite una sola vez.
+        if tabla._tbl in vistos_tablas:
+            return
+        vistos_tablas.add(tabla._tbl)
+        filas = [[celda.text for celda in fila.cells] for fila in tabla.rows]
+        if filas and any(any(c.strip() for c in fila) for fila in filas):
+            partes.append(_render(filas))
+        # Una tabla anidada en una celda no aparece en cell.text: se emite
+        # después de la exterior, en el mismo bloque, para no perderla.
+        # `row.cells` repite la celda combinada una vez por columna del grid:
+        # sin deduplicar por el XML subyacente, su tabla anidada saldría dos veces.
+        vistos_celdas: set = set()
+        for fila in tabla.rows:
+            for celda in fila.cells:
+                tc = celda._tc
+                if tc in vistos_celdas:
+                    continue
+                vistos_celdas.add(tc)
+                for anidada in celda.tables:
+                    add_tabla(anidada)
+                # Un content control dentro de una celda esconde su tabla y su
+                # texto de cell.text/tables. Se recorre por hijos (no con
+                # tc.iter, que bajaría dos veces por sdts anidados) y solo
+                # desde el sdt: el texto directo de la celda ya está en la tabla.
+                walk(tc, solo_sdt=True)
+
+    def add_parrafo(parrafo) -> None:
+        texto = _heading(parrafo)
+        if texto:
+            partes.append(texto)
+
+    def walk(parent, *, solo_sdt: bool = False) -> None:
+        for child in parent.iterchildren():
+            if child.tag == qn("w:sdt"):
+                contenido = child.find(qn("w:sdtContent"))
+                if contenido is not None:
+                    walk(contenido)
+            elif not solo_sdt and child.tag == qn("w:p"):
+                add_parrafo(Paragraph(child, doc))
+            elif not solo_sdt and child.tag == qn("w:tbl"):
+                add_tabla(Table(child, doc))
+
+    walk(doc.element.body)
+    # Contenido de cuadros de texto: cuelga de un run, no del body, así que
+    # p.text no lo ve. Se añade al final para no perderlo (orden no garantizado).
+    for caja in doc.element.body.iter(qn("w:txbxContent")):
+        for parrafo in caja.iter(qn("w:p")):
+            add_parrafo(Paragraph(parrafo, doc))
+    return "\n\n".join(partes)
+
+
+def _pptx(origen: Path) -> str:
+    from pptx import Presentation
+    from pptx.enum.shapes import MSO_SHAPE_TYPE
+
+    prs = Presentation(str(origen))
+    partes: list[str] = []
+
+    def render_shape(shape):
+        if shape.shape_type == MSO_SHAPE_TYPE.GROUP:
+            for hijo in shape.shapes:
+                render_shape(hijo)
+            return
+        if getattr(shape, "has_table", False):
+            filas = [[celda.text for celda in fila.cells] for fila in shape.table.rows]
+            if filas and any(any(c.strip() for c in fila) for fila in filas):
+                partes.append(_render(filas))
+        elif getattr(shape, "has_text_frame", False):
+            texto = shape.text_frame.text.strip()
+            if texto:
+                partes.append(texto)
+
+    for slide in prs.slides:
+        titulo = slide.shapes.title
+        if titulo is not None and getattr(titulo, "has_text_frame", False):
+            texto = titulo.text_frame.text.strip()
+            if texto:
+                partes.append(f"# {texto}")
+        for shape in slide.shapes:
+            if titulo is not None and shape.shape_id == titulo.shape_id:
+                continue
+            render_shape(shape)
+    return "\n\n".join(partes)
+
+
+def convertir(origen: Path) -> str:
+    origen = Path(origen)
+    ext = origen.suffix.lower()
+    if ext == ".docx":
+        md = _docx(origen)
+    elif ext == ".pptx":
+        md = _pptx(origen)
+    else:
+        raise ValueError(f"motor_office solo convierte .docx/.pptx, no {ext or '(sin extensión)'}")
+    if not md.strip():
+        raise ConversionVacia(f"motor_office no produjo contenido para {origen.name}.")
+    return md
+
+
+if __name__ == "__main__":
+    if len(sys.argv) < 3:
+        sys.exit("Uso: python motor_office.py <origen.docx|.pptx> <destino.md>")
+    origen = Path(sys.argv[1]).expanduser()
+    destino = Path(sys.argv[2]).expanduser()
+    if not origen.exists():
+        sys.exit(f"No existe: {origen}")
+    if misma_ruta(origen, destino):
+        sys.exit(f"El destino es el propio documento de origen ({origen.name}): no se sobrescribe.")
+    try:
+        md = convertir(origen)
+    except ValueError as e:
+        sys.exit(f"motor_office: {e}")
+    except Exception as e:
+        sys.exit(f"motor_office falló con {origen.name}: {e}")
+    try:
+        escribir_atomico(destino, md)
+    except (OSError, UnicodeError) as e:
+        sys.exit(f"No se pudo escribir {destino}: {e}")
+    print(f"Guardado en {destino} ({len(md)} caracteres)")