tablewise 1.1.0__py3-none-any.whl

tablewise-1.1.0.dist-info/METADATA

@@ -0,0 +1,217 @@
+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
+Author: Luis Francisco Palomares Gamarra
+License: MIT License
+        
+        Copyright (c) 2026 Luis Francisco Palomares Gamarra
+        
+        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.
+        
+Keywords: markdown,rag,pdf,docx,xlsx,markitdown,docling
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Environment :: MacOS X
+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"
+Provides-Extra: docling
+Requires-Dist: docling; extra == "docling"
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == "dev"
+Requires-Dist: openpyxl>=3.1; extra == "dev"
+Requires-Dist: PyYAML>=6; extra == "dev"
+Dynamic: license-file
+
+# Tablewise
+
+**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.
+
+Every output file starts with a header that tells your retrieval layer where the
+text came from:
+
+```markdown
+---
+source: "2026-budget.xlsx"
+engine: "excel"
+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.
+- **Hosted API** — `POST /v1/convert`, per-month plans, no install. See
+  [PRICING.md](PRICING.md).
+
+## The problem it solves
+
+Most converters flatten a financial table into something no model can use. A
+three-level header (`Hotel · 2026 · Real/Budget · Jan..Dec`) comes out as 70
+columns named `Unnamed: 12`, formulas vanish, and a percentage becomes `0.8769`.
+A RAG built on that answers with the wrong number and no way to prove it.
+
+Tablewise routes spreadsheets to an engine that reads the sheet as a sheet:
+
+| Hotel | 2026 | 2026 | 2026 |
+|  | Real | Budget | Last year |
+|  | Jan | Feb | Jan |
+| ADR | 120.50 | 110 | 105.25 |
+| Occupancy | 87.69% |  |  |
+
+- Merged cells and multi-level headers preserved as a real Markdown table.
+- Dates as `YYYY-MM-DD`, percentages with their format, `-0.00` never appears.
+- 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.
+
+## Quickstart
+
+```bash
+pip install -e .            # installs the `tablewise` command
+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
+curl -X POST https://api.tablewise.dev/v1/convert \
+  -H "Authorization: Bearer $TABLEWISE_API_KEY" \
+  -F "file=@budget.xlsx"
+```
+
+## Why not just MarkItDown / Docling?
+
+They are good engines and Tablewise uses both. The difference is the routing,
+the table fidelity and the provenance — not a new parser.
+
+| | MarkItDown | Docling | Tablewise |
+|---|---|---|---|
+| Excel with merged / multi-level header | flattened | partial | read as a sheet |
+| 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
+
+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)
+- `.doc` `.rtf` `.odt` → `textutil` (macOS) → HTML → `motor_docling.py`
+- `.xls` `.ppt` (Office 97-2003) → LibreOffice → `.xlsx`/`.pptx` → `motor_excel.py` / `motor_docling.py`
+- 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.
+
+## CLI reference
+
+```
+tablewise DOCUMENT [-o DIR] [-n NAME] [--python PATH] [--markitdown PATH]
+                   [--force] [--dry-run] [-q] [--version]
+```
+
+- Never overwrites an existing `.md` without `--force`.
+- Exit codes: `0` ok · `1` the engine produced no file · `2` invalid input.
+- `--python` / `TABLEWISE_PYTHON`: interpreter that carries docling/openpyxl.
+- `--markitdown` / `TABLEWISE_MARKITDOWN`: MarkItDown executable.
+
+## Hosted API
+
+The API is the same engine behind HTTP, for teams that cannot install anything:
+
+| Plan | Units / month | Price |
+|---|---|---|
+| Free | 50 | $0 |
+| Starter | 1,000 | $19 |
+| Pro | 5,000 | $49 |
+| 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
+[PRICING.md](PRICING.md) and on the website.
+
+## Development
+
+Runner: `pytest`, using the engines virtualenv (it carries openpyxl and PyYAML):
+
+```bash
+.venv/bin/python3 -m pytest -q              # 432 tests
+.venv/bin/python3 -m pytest server/tests -q # 46 API tests
+```
+
+| File | What it covers |
+|---|---|
+| `tests/test_core.py` | `tablewise_core.py`: extension routing, safe names, engine command (`shlex`, `~`), YAML frontmatter, atomic write, free name |
+| `tests/test_motor_excel.py` | `motor_excel.py` on synthetic books: merged cells, unevaluated formulas, empty rows/columns, dates, hidden sheets, safety ceiling |
+| `tests/test_cli_motores.py` | engine CLI contract by subprocess (exit code + message, never a traceback) |
+| `tests/test_motor_docling.py` | `.doc`/`.rtf`/`.odt` preconversion to HTML with `textutil` (no Docling import; skipped off macOS) |
+| `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_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 |
+| `tests/test_motor_docling_cli.py` | `motor_docling` CLI with a fake `docling` package |
+| `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 |
+
+No test uses real documents.
+
+## Limits and security
+
+- Upload limit 25 MB and 2,000 units per request (configurable).
+- Engines run as subprocesses with a timeout; a hung converter cannot take the
+  worker down.
+- API keys are stored as SHA-256 hashes and shown once.
+- No document content is logged. See `web/privacy.html` and `web/dpa.html`.
+- macOS-only pieces: `textutil` (`.doc`/`.rtf`/`.odt`) and the Tkinter app.
+  LibreOffice is needed for `.xls`/`.ppt`.
+
+## License
+
+MIT. See [LICENSE](LICENSE).
+
+---
+
+Spanish engineering log, kept for continuity: [README.es.md](README.es.md).

tablewise-1.1.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+motor_docling.py,sha256=vO4dCZRdtDP5lp81oXjr87c2dcgrAiYlJAyYQPO4tT0,3064
+motor_excel.py,sha256=mosa8TOq7tBBNU-eNB59mkyxMbr6w8Dvx5RjMK5n8mQ,22658
+preconversion.py,sha256=uW4yumm1uvJLTPENDVcvd9sLxqkYOLuL1COqBLOD_WQ,4086
+tablewise_app.py,sha256=GG8yeAQ8wTHACzDFieibYlnTUmq3CjsNgoNrQy7QxAs,14394
+tablewise_cli.py,sha256=8JGZRT-dFVoPWn_9OV0x2g8mcwryMypE3N13irEzq-o,7519
+tablewise_core.py,sha256=pEhNKvPt3ZnGRs9hYHKu5H1o4YOk6fbfOsT8z_Is2Co,17613
+tablewise-1.1.0.dist-info/licenses/LICENSE,sha256=eVMFbxicWd3q6ZW5pdQMp_r0CmFyUAwszOotrKm1Bfc,1089
+tablewise-1.1.0.dist-info/METADATA,sha256=SjHw65svOtfV2lQ8RsFiUFRPHvX_2TpYj-YTnUyxQ_0,9322
+tablewise-1.1.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+tablewise-1.1.0.dist-info/entry_points.txt,sha256=NBBxSTLetAtuZTAqVsH2BGl8gTvKDvSCHjPrWF2d-nQ,49
+tablewise-1.1.0.dist-info/top_level.txt,sha256=bQfEdO7eznTOxxEgK2Mb53fg794IiZjtfdJK1yD8EfY,83
+tablewise-1.1.0.dist-info/RECORD,,

tablewise-1.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.2.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

tablewise-1.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+tablewise = tablewise_cli:main

tablewise-1.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Luis Francisco Palomares Gamarra
+
+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.

tablewise-1.1.0.dist-info/top_level.txt

@@ -0,0 +1,6 @@
+motor_docling
+motor_excel
+preconversion
+tablewise_app
+tablewise_cli
+tablewise_core

tablewise_app.py

@@ -0,0 +1,361 @@
+from __future__ import annotations
+import datetime
+import os
+import subprocess
+import sys
+import shutil
+import tempfile
+from pathlib import Path
+import tkinter as tk
+from tkinter import filedialog, messagebox
+
+import tablewise_core
+import preconversion
+
+HOME = Path.home()
+REPO_DIR = Path(__file__).resolve().parent
+DEFAULT_OUTPUT_DIR = HOME / "md-repo"
+VENV_MARKITDOWN = HOME / "markitdown-env" / "bin" / "markitdown"
+
+VENV_TOOLS_PY = REPO_DIR / ".venv" / "bin" / "python3"
+
+class App:
+    def __init__(self, root: tk.Tk):
+        self.root = root
+        self.root.title("Documentos a Markdown → Repo")
+        self.root.geometry("760x520")
+        self.root.configure(bg="#f5f3ef")
+
+        self.pdf_path = tk.StringVar()
+        self.repo_path = tk.StringVar(value=str(DEFAULT_OUTPUT_DIR))
+        self.filename = tk.StringVar()
+        self.status = tk.StringVar(value="Selecciona un documento y una carpeta destino.")
+        # LibreOffice (opcional) habilita .xls/.ppt: se mira una vez al abrir.
+        self.hay_soffice = preconversion.buscar_soffice() is not None
+
+        self.build_ui()
+
+    def build_ui(self):
+        wrap = tk.Frame(self.root, bg="#f5f3ef", padx=24, pady=24)
+        wrap.pack(fill="both", expand=True)
+
+        tk.Label(
+            wrap,
+            text="Documentos a Markdown → Repo",
+            font=("Helvetica", 20, "bold"),
+            bg="#f5f3ef",
+            fg="#1f2937"
+        ).pack(anchor="w")
+
+        tk.Label(
+            wrap,
+            text="Mini app local para convertir PDF/Word/Excel/PowerPoint a .md (motor según tipo de documento) y guardarlo en tu repositorio de conocimiento.",
+            font=("Helvetica", 11),
+            bg="#f5f3ef",
+            fg="#4b5563",
+            wraplength=680,
+            justify="left",
+        ).pack(anchor="w", pady=(8, 20))
+
+        self._field(wrap, "1) Documento de entrada (PDF/Word/Excel/PowerPoint)", self.pdf_path, self.pick_pdf, "Elegir documento")
+        self._field(wrap, "2) Carpeta repo destino", self.repo_path, self.pick_repo, "Elegir carpeta")
+        self._text_field(wrap, "3) Nombre del .md (sin extensión)", self.filename)
+
+        btns = tk.Frame(wrap, bg="#f5f3ef")
+        btns.pack(fill="x", pady=(18, 10))
+
+        tk.Button(
+            btns,
+            text="Convertir y guardar",
+            command=self.convert,
+            bg="#0f766e",
+            fg="white",
+            padx=16,
+            pady=10
+        ).pack(side="left")
+
+        tk.Button(
+            btns,
+            text="Abrir carpeta repo",
+            command=self.open_repo,
+            bg="#e5e7eb",
+            fg="#111827",
+            padx=16,
+            pady=10
+        ).pack(side="left", padx=10)
+
+        tk.Button(
+            btns,
+            text="Copiar comando CLI",
+            command=self.copy_cli,
+            bg="#e5e7eb",
+            fg="#111827",
+            padx=16,
+            pady=10
+        ).pack(side="left")
+
+        notes = (
+            "Flujo recomendado:\n"
+            "- Soporta PDF, Word (.docx/.doc/.rtf/.odt), Excel (.xlsx/.xlsm; .xls con LibreOffice) y PowerPoint (.pptx; .ppt con LibreOffice).\n"
+            "- Deja tu repo de Markdown en ~/md-repo o cambia la carpeta aquí.\n"
+            "- Enrutamiento automático por tipo (23/08/2026):\n"
+            "    · .xlsx/.xlsm/.xltx/.xltm → motor Excel propio (openpyxl, sin IA, exacto con celdas combinadas)\n"
+            "    · .pdf/.docx/.pptx → Docling (local, gratis, reconstruye tablas complejas)\n"
+            "    · .doc/.rtf/.odt → textutil (macOS) a HTML → Docling\n"
+            "    · .xls/.ppt (97-2003) → LibreOffice a .xlsx/.pptx → motor Excel / Docling\n"
+            "    · el resto (HTML, CSV, EPUB...) → MarkItDown\n"
+            "- El archivo resultante se guarda en la carpeta repo lista para tu RAG/IA."
+        )
+
+        tk.Label(
+            wrap,
+            text=notes,
+            bg="#eef2f7",
+            fg="#374151",
+            justify="left",
+            anchor="w",
+            padx=14,
+            pady=14
+        ).pack(fill="x", pady=(12, 18))
+
+        tk.Label(
+            wrap,
+            textvariable=self.status,
+            bg="#f5f3ef",
+            fg="#7c2d12",
+            justify="left",
+            wraplength=690
+        ).pack(anchor="w")
+
+    def _field(self, parent, label, var, command, button_text):
+        tk.Label(
+            parent,
+            text=label,
+            font=("Helvetica", 11, "bold"),
+            bg="#f5f3ef",
+            fg="#111827"
+        ).pack(anchor="w", pady=(8, 6))
+
+        row = tk.Frame(parent, bg="#f5f3ef")
+        row.pack(fill="x")
+
+        tk.Entry(
+            row,
+            textvariable=var,
+            font=("Helvetica", 11),
+            relief="solid",
+            bd=1
+        ).pack(side="left", fill="x", expand=True, ipady=8)
+
+        tk.Button(
+            row,
+            text=button_text,
+            command=command,
+            bg="#d1fae5",
+            fg="#065f46",
+            padx=12,
+            pady=8
+        ).pack(side="left", padx=(10, 0))
+
+    def _text_field(self, parent, label, var):
+        tk.Label(
+            parent,
+            text=label,
+            font=("Helvetica", 11, "bold"),
+            bg="#f5f3ef",
+            fg="#111827"
+        ).pack(anchor="w", pady=(16, 6))
+
+        tk.Entry(
+            parent,
+            textvariable=var,
+            font=("Helvetica", 11),
+            relief="solid",
+            bd=1
+        ).pack(fill="x", ipady=8)
+
+    def pick_pdf(self):
+        # El filtro sale de las mismas extensiones que enrutan (tablewise_core):
+        # así no se vuelve a quedar atrás cuando se añade un formato.
+        path = filedialog.askopenfilename(filetypes=tablewise_core.tipos_dialogo(self.hay_soffice))
+        if path:
+            self.pdf_path.set(path)
+            if not self.filename.get():
+                self.filename.set(Path(path).stem)
+
+    def pick_repo(self):
+        path = filedialog.askdirectory()
+        if path:
+            self.repo_path.set(path)
+
+    def get_markitdown_cmd(self):
+        if VENV_MARKITDOWN.exists():
+            return str(VENV_MARKITDOWN)
+        found = shutil.which("markitdown")
+        return found
+
+    def convert(self):
+        name = self.filename.get().strip()
+        v = tablewise_core.validar_conversion(self.pdf_path.get(), name, self.repo_path.get(),
+                                           hay_soffice=self.hay_soffice)
+        if v.error:
+            messagebox.showerror(*v.error)
+            return
+        pdf, repo = v.origen, v.destino.parent
+        nombre, out_file = v.nombre, v.destino
+        if not name:
+            self.filename.set(nombre)
+        try:
+            repo.mkdir(parents=True, exist_ok=True)
+        except OSError as e:  # un tramo de la ruta es un fichero, sin permisos...
+            messagebox.showerror("Carpeta repo inválida", f"No se pudo crear {repo}:\n\n{e}")
+            return
+
+        # No se comprueba en tablewise_core si `.venv` existe -- se decide aquí
+        # para avisar con un mensaje específico en vez de degradar en
+        # silencio a MarkItDown (hallazgo de careo, MEDIA, 23/08).
+        motor = tablewise_core.elegir_motor(pdf)
+        if motor:
+            if not VENV_TOOLS_PY.exists():
+                messagebox.showerror(
+                    "Falta el venv de motores",
+                    f"{pdf.suffix} necesita el motor {motor}, pero no encuentro "
+                    f"{VENV_TOOLS_PY}. Instálalo con:\n\n"
+                    f"cd {REPO_DIR}\npython3 -m venv .venv\n"
+                    ".venv/bin/pip install -r requirements-motores.txt"
+                )
+                return
+            markitdown_cmd = ""
+            motor_legible = {"motor_excel": "motor Excel (openpyxl, sin IA)", "motor_docling": "Docling (local, gratis)"}[motor]
+        else:
+            markitdown_cmd = self.get_markitdown_cmd()
+            if not markitdown_cmd:
+                messagebox.showerror(
+                    "MarkItDown no encontrado",
+                    "No encuentro markitdown. Instálalo en ~/markitdown-env o en tu PATH."
+                )
+                return
+            motor_legible = "MarkItDown"
+        # Después de comprobar motores: no preguntar para luego fallar.
+        if out_file.exists():
+            copia = tablewise_core.ruta_libre(repo, nombre)
+            respuesta = messagebox.askyesnocancel(
+                "El .md ya existe",
+                f"Ya existe {out_file.name} en la carpeta repo.\n\n"
+                "Sí → sobrescribirlo\n"
+                f"No → guardar como {copia.name}\n"
+                "Cancelar → no convertir",
+                default=messagebox.NO,  # Enter no debe pisar nada
+            )
+            if respuesta is None:
+                return
+            if respuesta is False:
+                out_file = copia
+
+        # El motor escribe en un temporal de la misma carpeta y el destino
+        # solo se reemplaza tras validar el resultado: con "sobrescribir",
+        # un motor que trunca su salida y falla, o que acaba bien sin
+        # escribir nada, destruía o daba por convertido el .md retocado a
+        # mano (hallazgos de careo, IMPORTANTE, 15/10).
+        # Carpeta temporal exclusiva de esta ejecución (no un nombre fijo,
+        # que borraba un fichero ajeno o el temporal de otra conversión), y
+        # dentro el fichero aún sin crear: así "existe" sigue probando que
+        # el motor escribió. Misma carpeta → os.replace atómico.
+        try:
+            carpeta_temporal = Path(tempfile.mkdtemp(prefix=".convirtiendo-", dir=repo))
+        except OSError as e:
+            self.status.set(f"No se pudo escribir en {repo}: {e}")
+            messagebox.showerror("Carpeta repo inválida", f"No se pudo escribir en {repo}:\n\n{e}")
+            return
+        temporal = carpeta_temporal / out_file.name
+        cmd = tablewise_core.construir_comando(
+            pdf, temporal, python_motores=VENV_TOOLS_PY, repo_dir=REPO_DIR,
+            markitdown=markitdown_cmd,
+        )
+
+        try:
+            result = subprocess.run(cmd, capture_output=True, text=True, check=True)
+            # Código 0 sin fichero (un conversor que no reconoce el formato
+            # y "acaba bien"): no se puede anunciar un .md que no existe.
+            if not temporal.exists():
+                detalle = (result.stderr or result.stdout or "").strip()
+                self.status.set(f"{motor_legible} terminó sin generar {out_file.name}.\n{detalle[:1200]}")
+                messagebox.showerror(
+                    "Falló la conversión",
+                    f"Motor: {motor_legible}\n\nTerminó sin errores pero no generó "
+                    f"{out_file}.\n\n{detalle[:1500]}",
+                )
+                return
+            msg = f"OK ({motor_legible}). Markdown generado en:\n{out_file}"
+            try:
+                tablewise_core.anadir_frontmatter(
+                    temporal, pdf, motor or "markitdown", datetime.date.today()
+                )
+            except (OSError, UnicodeError) as e:
+                # La conversión ya está hecha: sin cabecera sigue sirviendo.
+                msg += f"\n\n(No se pudo añadir la cabecera de procedencia: {e})"
+            try:
+                os.replace(temporal, out_file)
+            except OSError as e:
+                self.status.set(f"No se pudo guardar {out_file}: {e}")
+                messagebox.showerror("Falló la conversión", f"No se pudo guardar {out_file}:\n\n{e}")
+                return
+            salida = result.stdout.replace(str(temporal), str(out_file))
+            if salida.strip():
+                msg += f"\n\nSalida:\n{salida[:800]}"
+            self.status.set(msg)
+            messagebox.showinfo("Conversión completada", msg)
+        except subprocess.CalledProcessError as e:
+            err = e.stderr or e.stdout or str(e)
+            self.status.set(f"Error al convertir con {motor_legible}:\n{err[:1200]}")
+            messagebox.showerror("Falló la conversión", f"Motor: {motor_legible}\n\n{err[:1500]}")
+        except OSError as e:
+            # El ejecutable existe pero no se pudo lanzar (permisos, venv
+            # roto, etc.) -- CalledProcessError no cubre esto (hallazgo de
+            # careo, MEDIA, 23/08: antes terminaba en traceback crudo).
+            self.status.set(f"No se pudo lanzar {motor_legible}: {e}")
+            messagebox.showerror("Falló la conversión", f"No se pudo lanzar {motor_legible}:\n\n{e}")
+        finally:
+            # Solo lo creado por esta ejecución; un fallo al limpiar no debe
+            # tapar el mensaje ya mostrado con un traceback.
+            shutil.rmtree(carpeta_temporal, ignore_errors=True)
+
+    def open_repo(self):
+        repo = Path(self.repo_path.get()).expanduser()
+        repo.mkdir(parents=True, exist_ok=True)
+        subprocess.run(["open", str(repo)])
+
+    def copy_cli(self):
+        elegido = self.pdf_path.get().strip()
+
+        # Mismas comprobaciones que convert(): sin esto se copiaban comandos
+        # que pisaban el origen o convertían un "~$x.xlsx". Sin documento
+        # elegido se copia una plantilla, sin exigir que exista.
+        v = tablewise_core.validar_conversion(elegido or "/ruta/a/tu.pdf", self.filename.get().strip(),
+                                           self.repo_path.get(), hay_soffice=self.hay_soffice,
+                                           comprobar_existe=bool(elegido))
+        if v.error:
+            self.status.set(f"No se copió el comando: {v.error[1]}")
+            messagebox.showerror(*v.error)
+            return
+
+        # Mismo constructor que convert(): el comando copiado es el que
+        # ejecutaría la app, con MarkItDown resuelto a ruta absoluta.
+        cmd = tablewise_core.construir_comando(
+            v.origen, v.destino, python_motores=VENV_TOOLS_PY, repo_dir=REPO_DIR,
+            markitdown=self.get_markitdown_cmd() or "markitdown",
+        )
+
+        self.root.clipboard_clear()
+        self.root.clipboard_append(tablewise_core.comando_shell(cmd))
+        self.status.set("Comando copiado al portapapeles.")
+
+def main():
+    root = tk.Tk()
+    app = App(root)
+    root.mainloop()
+
+if __name__ == "__main__":
+    if sys.platform != "darwin":
+        print("Esta mini app está pensada para macOS, pero se puede adaptar fácilmente.")
+    main()