tablewise 1.1.2__tar.gz → 1.1.3__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tablewise
-Version: 1.1.2
+Version: 1.1.3
 Summary: Spreadsheet-grade document to Markdown with provenance, ready for RAG and LLM ingestion
 Author: Luis Francisco Palomares Gamarra
 License: MIT License
@@ -261,6 +261,9 @@ Runner: `pytest`, using the engines virtualenv (it carries openpyxl and PyYAML):
 | `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_cli_paridad_api.py` | CLI and app decide like the API: unreadable file exits 2 before any engine, last-engine failure gives the cause without a traceback, MarkItDown is the last resort after any engine |
+| `tests/test_documento_cifrado.py` | password-protected PDF/Office rejected before any engine with its own reason; owner-password-only PDFs still convert; no guessing without pypdf |
+| `tests/test_contenedor_ilegible.py` | container check before any engine: empty file, non-zip or truncated `.xlsx`, zip without OOXML structure; CSV/XLS/PDF untouched |
 | `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 |

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

@@ -197,6 +197,9 @@ Runner: `pytest`, using the engines virtualenv (it carries openpyxl and PyYAML):
 | `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_cli_paridad_api.py` | CLI and app decide like the API: unreadable file exits 2 before any engine, last-engine failure gives the cause without a traceback, MarkItDown is the last resort after any engine |
+| `tests/test_documento_cifrado.py` | password-protected PDF/Office rejected before any engine with its own reason; owner-password-only PDFs still convert; no guessing without pypdf |
+| `tests/test_contenedor_ilegible.py` | container check before any engine: empty file, non-zip or truncated `.xlsx`, zip without OOXML structure; CSV/XLS/PDF untouched |
 | `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 |

{tablewise-1.1.2 → tablewise-1.1.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "tablewise"
-version = "1.1.2"
+version = "1.1.3"
 description = "Spreadsheet-grade document to Markdown with provenance, ready for RAG and LLM ingestion"
 readme = "README.md"
 license = { file = "LICENSE" }

{tablewise-1.1.2 → tablewise-1.1.3}/tablewise.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tablewise
-Version: 1.1.2
+Version: 1.1.3
 Summary: Spreadsheet-grade document to Markdown with provenance, ready for RAG and LLM ingestion
 Author: Luis Francisco Palomares Gamarra
 License: MIT License
@@ -261,6 +261,9 @@ Runner: `pytest`, using the engines virtualenv (it carries openpyxl and PyYAML):
 | `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_cli_paridad_api.py` | CLI and app decide like the API: unreadable file exits 2 before any engine, last-engine failure gives the cause without a traceback, MarkItDown is the last resort after any engine |
+| `tests/test_documento_cifrado.py` | password-protected PDF/Office rejected before any engine with its own reason; owner-password-only PDFs still convert; no guessing without pypdf |
+| `tests/test_contenedor_ilegible.py` | container check before any engine: empty file, non-zip or truncated `.xlsx`, zip without OOXML structure; CSV/XLS/PDF untouched |
 | `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 |

{tablewise-1.1.2 → tablewise-1.1.3}/tablewise.egg-info/SOURCES.txt

@@ -19,8 +19,11 @@ tablewise.egg-info/top_level.txt
 tests/test_app_convertir.py
 tests/test_cli.py
 tests/test_cli_motores.py
+tests/test_cli_paridad_api.py
+tests/test_contenedor_ilegible.py
 tests/test_core.py
 tests/test_docs.py
+tests/test_documento_cifrado.py
 tests/test_entradas_externas.py
 tests/test_motor_docling.py
 tests/test_motor_docling_cli.py

{tablewise-1.1.2 → tablewise-1.1.3}/tablewise_app.py

@@ -285,12 +285,14 @@ class App:
         try:
             # Si el motor propio falla con los modelos instalados (ONNX
             # corrupto, OOM, opset incompatible), el PDF no se queda sin
-            # convertir: segundo intento con Docling.
+            # convertir: segundo intento con Docling. Detrás de cualquier
+            # motor, MarkItDown como última red: la misma cadena que la CLI
+            # y la API.
             intentos = [motor]
             if motor in {"motor_propio", "motor_office"}:
                 intentos.append("motor_docling")
-                if markitdown_cmd:
-                    intentos.append("markitdown")
+            if motor is not None and markitdown_cmd:
+                intentos.append("markitdown")
             result = None
             for i, intento in enumerate(intentos):
                 cmd = tablewise_core.construir_comando(
@@ -298,7 +300,7 @@ class App:
                     markitdown=markitdown_cmd, forzar_motor=intento,
                 )
                 result = subprocess.run(cmd, capture_output=True, text=True, check=False)
-                if result.returncode == 0 and temporal.exists():
+                if result.returncode == 0 and temporal.exists() and temporal.stat().st_size > 0:
                     motor = None if intento == "markitdown" else intento
                     if intento == "markitdown":
                         motor_legible = "MarkItDown"

{tablewise-1.1.2 → tablewise-1.1.3}/tablewise_cli.py

@@ -50,7 +50,7 @@ def _version() -> str:
     try:
         return importlib.metadata.version("tablewise")
     except importlib.metadata.PackageNotFoundError:
-        return "1.1.2"
+        return "1.1.3"
 
 
 def _ruta_modulo(nombre: str) -> Path:
@@ -90,6 +90,8 @@ _EN_TITLES = {
     "Formato no soportado": "Unsupported format",
     "Nombre inválido": "Invalid name",
     "Destino igual al origen": "Output equals input",
+    "Documento ilegible": "Unreadable document",
+    "Documento protegido": "Password-protected document",
 }
 _EN_LEGACY = {
     ".ppt": "PowerPoint 97-2003 (.ppt) needs LibreOffice, which is not installed. Install it "
@@ -114,6 +116,14 @@ def _mensaje_en(titulo: str, mensaje: str, documento: str, salida: str) -> str:
         texto = _EN_LEGACY.get(origen.suffix.lower(), mensaje)
     elif titulo == "Nombre inválido":
         texto = "the output name cannot be empty or just a path (\".\" or \"..\")."
+    elif titulo in {"Documento ilegible", "Documento protegido"}:
+        try:  # the English cause comes from the same check the API uses
+            tablewise_core.validar_contenedor(origen)
+            texto = mensaje
+        except tablewise_core.DocumentoIlegible as e:
+            texto = str(e)
+        except OSError:  # the file vanished between both checks
+            texto = mensaje
     elif titulo == "Destino igual al origen":
         texto = "the output .md would overwrite the source document. Change --name or --output."
     else:
@@ -122,6 +132,20 @@ def _mensaje_en(titulo: str, mensaje: str, documento: str, salida: str) -> str:
     return f"Tablewise: {texto}" if etiqueta == "Error" else f"Tablewise: {etiqueta}: {texto}"
 
 
+def _motivo(salida: str) -> str:
+    """What the user needs from a failed engine: the error, not the traceback.
+
+    The engines are separate programs and an uncaught exception prints a full
+    Python traceback (MarkItDown does it for an encrypted PDF). Keep only the
+    final exception and the lines after it."""
+    texto = salida.strip()
+    if "Traceback (most recent call last)" not in texto:
+        return texto[:1500]
+    lineas = texto.splitlines()
+    inicio = max(i for i, linea in enumerate(lineas) if linea and not linea[0].isspace())
+    return "\n".join(lineas[inicio:]).strip()[:800]
+
+
 def construir_parser() -> argparse.ArgumentParser:
     p = argparse.ArgumentParser(
         prog="tablewise",
@@ -203,13 +227,15 @@ def convertir(documento: str, salida: str, nombre: str = "", *, python: str | No
     with tempfile.TemporaryDirectory(prefix=".convirtiendo-", dir=repo) as carpeta:
         temporal = Path(carpeta) / destino.name
         # Si el motor elegido falla (ONNX corrupto, OOM, python-docx ausente),
-        # el documento no se queda sin convertir: Docling y, como última red,
-        # MarkItDown.
+        # el documento no se queda sin convertir: Docling detrás de los motores
+        # de PDF y Office y, detrás de cualquier motor, MarkItDown como última
+        # red. Es la misma cadena que la API (`server/api/converter.py`); antes
+        # la CLI no probaba MarkItDown tras motor_excel y la API sí.
         intentos = [motor]
         if motor in {"motor_propio", "motor_office"}:
             intentos.append("motor_docling")
-            if markitdown_cmd:
-                intentos.append("markitdown")
+        if motor is not None and markitdown_cmd:
+            intentos.append("markitdown")
         for i, intento in enumerate(intentos):
             if not quiet:
                 print(f"Converting {origen.name} with {intento or 'markitdown'}…", file=sys.stderr)
@@ -225,12 +251,14 @@ def convertir(documento: str, salida: str, nombre: str = "", *, python: str | No
             except subprocess.TimeoutExpired as e:
                 raise RuntimeError(
                     f"the {intento or 'markitdown'} engine timed out after {timeout}s.") from e
-            if resultado.returncode == 0 and temporal.exists():
+            # Como la API: un .md vacío no es una conversión (MarkItDown puede
+            # acabar bien sin texto).
+            if resultado.returncode == 0 and temporal.exists() and temporal.stat().st_size > 0:
                 motor = None if intento == "markitdown" else intento
                 break
             temporal.unlink(missing_ok=True)
             if i == len(intentos) - 1:
-                detalle = (resultado.stderr or resultado.stdout or "").strip()[:1500]
+                detalle = _motivo(resultado.stderr or resultado.stdout or "")
                 raise RuntimeError(f"the {intento or 'markitdown'} engine did not produce {destino.name}.\n{detalle}")
             if not quiet:
                 print(f"Tablewise: warning: {intento or 'markitdown'} failed, falling back to "

{tablewise-1.1.2 → tablewise-1.1.3}/tablewise_core.py

@@ -167,6 +167,152 @@ def es_bloqueo_office(origen: Path) -> bool:
     return Path(origen).name.startswith("~$")
 
 
+# Formatos que son un contenedor zip. Los OOXML (Excel, Word, PowerPoint)
+# llevan además "[Content_Types].xml" en la raíz; el .odt es zip ODF.
+EXTENSIONES_OOXML = EXTENSIONES_EXCEL | EXTENSIONES_OFFICE
+EXTENSIONES_ZIP = EXTENSIONES_OOXML | {".odt"}
+# Un [Content_Types].xml real pesa unos KB; 1 MB deja margen de sobra.
+MAX_BYTES_MANIFIESTO = 1024 * 1024
+
+
+class DocumentoIlegible(ValueError):
+    """El fichero no se puede leer como el formato que dice ser."""
+
+
+class DocumentoCifrado(DocumentoIlegible):
+    """Protegido con contraseña de apertura: hay que quitarla para convertirlo.
+
+    Subclase de DocumentoIlegible para que la CLI, la app y el lote, que ya
+    tratan esa, no tengan por dónde dejarlo escapar."""
+
+
+# Word/Excel/PowerPoint guardan un OOXML con contraseña como contenedor OLE
+# (CFB, [MS-CFB]) con un flujo "EncryptedPackage", no como zip.
+_FIRMA_CFB = bytes.fromhex("D0CF11E0A1B11AE1")
+_FLUJO_CIFRADO = "EncryptedPackage"
+_MAX_SECTORES_DIRECTORIO = 64  # un OOXML cifrado tiene ~10 entradas
+
+
+def _ooxml_cifrado(origen: Path) -> bool:
+    """¿Es un contenedor CFB con un flujo llamado EncryptedPackage?
+
+    Lee la cabecera, la cadena de sectores del directorio (con tope) y los
+    nombres de sus entradas; no recorre el contenido. Un CFB que no se deja
+    leer así no se declara cifrado: sigue siendo "no es un zip" (ilegible)."""
+    def entero(datos: bytes, inicio: int, largo: int) -> int:
+        return int.from_bytes(datos[inicio:inicio + largo], "little")
+
+    try:
+        with open(origen, "rb") as f:
+            cabecera = f.read(512)
+            if len(cabecera) < 512 or cabecera[:8] != _FIRMA_CFB:
+                return False
+            desplazamiento = entero(cabecera, 30, 2)
+            if desplazamiento not in (9, 12):  # sectores de 512 o 4096 bytes
+                return False
+            tam = 1 << desplazamiento
+            n_fat = min(entero(cabecera, 44, 4), 109)
+            # Los primeros 109 sectores de la FAT están en la cabecera; un
+            # directorio que necesite más (ficheros enormes) no se sigue.
+            fat = [entero(cabecera, 76 + 4 * i, 4) for i in range(n_fat)]
+
+            def sector(n: int) -> bytes:
+                f.seek((n + 1) * tam)
+                return f.read(tam)
+
+            def siguiente(n: int) -> int:
+                bloque, posicion = divmod(n, tam // 4)
+                if bloque >= len(fat):
+                    return 0xFFFFFFFE  # fin de cadena: no se adivina más allá
+                return entero(sector(fat[bloque]), posicion * 4, 4)
+
+            actual = entero(cabecera, 48, 4)
+            for _ in range(_MAX_SECTORES_DIRECTORIO):
+                if actual >= 0xFFFFFFFA:  # fin de cadena o sector especial
+                    break
+                datos = sector(actual)
+                for i in range(0, len(datos) - 127, 128):
+                    entrada = datos[i:i + 128]
+                    largo = entero(entrada, 64, 2)  # en bytes, con el NUL final
+                    if entrada[66] == 2 and 2 <= largo <= 64:  # 2 = flujo
+                        nombre = entrada[:largo - 2].decode("utf-16-le", "replace")
+                        if nombre == _FLUJO_CIFRADO:
+                            return True
+                actual = siguiente(actual)
+    except OSError:
+        return False
+    return False
+
+
+def _pdf_cifrado(origen: Path) -> bool:
+    """¿Pide contraseña para abrirlo? Solo True cuando pypdf lo confirma.
+
+    Un PDF con solo contraseña de propietario (limita imprimir o copiar) se
+    abre con la contraseña vacía y no cuenta. Si pypdf no está (el paquete
+    de PyPI no lo exige), falta la librería de cifrado o pypdf no entiende el
+    fichero, no se adivina: deciden los motores."""
+    try:
+        from pypdf import PdfReader
+    except ImportError:
+        return False
+    try:
+        with open(origen, "rb") as fichero:
+            lector = PdfReader(fichero, strict=False)
+            if not lector.is_encrypted:
+                return False
+            return not lector.decrypt("")  # PasswordType.NOT_DECRYPTED == 0
+    except Exception:
+        return False
+
+
+def validar_contenedor(origen: Path) -> None:
+    """Rechaza, antes de lanzar ningún motor, un fichero vacío, uno protegido
+    con contraseña (DocumentoCifrado: PDF u OOXML) o un contenedor zip roto (no
+    es zip, truncado, o zip sin estructura OOXML).
+
+    Batería del 26/10: un .xlsx que no era zip llegó a MarkItDown como último
+    recurso; MarkItDown lee lo que no reconoce como texto plano y devolvió los
+    bytes crudos como si fueran la conversión, y la API lo cobró. Lee el
+    directorio central del zip y, en OOXML, solo el manifiesto
+    "[Content_Types].xml" con tope de MAX_BYTES_MANIFIESTO (barato y sin riesgo
+    de zip bomb). El resto de miembros no se descomprime: si alguno está dañado,
+    los motores fallan y la API reembolsa la reserva.
+    """
+    import zipfile
+    import zlib
+
+    origen = Path(origen)
+    ext = origen.suffix.lower()
+    if origen.stat().st_size == 0:
+        raise DocumentoIlegible("The file is empty (0 bytes).")
+    if ext == ".pdf" and _pdf_cifrado(origen):
+        raise DocumentoCifrado(
+            "The PDF is password-protected. Remove the password and try again.")
+    if ext not in EXTENSIONES_ZIP:
+        return
+    if ext in EXTENSIONES_OOXML and _ooxml_cifrado(origen):
+        raise DocumentoCifrado(
+            f"The {ext} file is password-protected. Remove the password and try again.")
+    try:
+        with zipfile.ZipFile(origen) as z:
+            nombres = set(z.namelist())
+            if ext in EXTENSIONES_OOXML and "[Content_Types].xml" in nombres:
+                # El manifiesto se lee entero (pesa unos KB) para que su CRC se
+                # compruebe; con tope, que un manifiesto inflado no sea una bomba.
+                with z.open("[Content_Types].xml") as manifiesto:
+                    if len(manifiesto.read(MAX_BYTES_MANIFIESTO + 1)) > MAX_BYTES_MANIFIESTO:
+                        raise DocumentoIlegible(
+                            f"The file is not a real {ext} (oversized Office manifest).")
+    except DocumentoIlegible:
+        raise
+    except (zipfile.BadZipFile, OSError, ValueError, EOFError, RuntimeError,
+            NotImplementedError, zlib.error) as e:
+        raise DocumentoIlegible(
+            f"The file is damaged or is not a real {ext} (unreadable zip container).") from e
+    if ext in EXTENSIONES_OOXML and "[Content_Types].xml" not in nombres:
+        raise DocumentoIlegible(f"The file is not a real {ext} (missing Office structure).")
+
+
 # APFS/ext4 admiten 255 bytes por componente de ruta. El nombre tiene que
 # caber con ".md", el "-N" de ruta_libre y el ".<nombre>.tmp" de
 # escribir_atomico: 200 deja margen de sobra. Sin tope, un nombre largo
@@ -497,6 +643,24 @@ def validar_conversion(origen: str | Path, tecleado: str, repo: str | Path, *, h
     motivo = motivo_no_soportado(origen, hay_soffice)
     if motivo:
         return Validacion(error=("Formato no soportado", motivo))
+    if comprobar_existe:
+        # La misma barrera que la API pone antes de cobrar: sin ella la CLI y
+        # la app lanzaban motores sobre un fichero vacío o un zip roto y acababan
+        # enseñando la traza de MarkItDown (batería del 14/11).
+        try:
+            validar_contenedor(origen)
+        except DocumentoCifrado:
+            return Validacion(error=(
+                "Documento protegido",
+                f"{origen.name} está protegido con contraseña. Quítasela y vuelve a "
+                "intentarlo.",
+            ))
+        except DocumentoIlegible:
+            return Validacion(error=(
+                "Documento ilegible",
+                f"{origen.name} no se puede leer: está vacío, dañado o no es un "
+                f"{origen.suffix.lower() or 'documento'} de verdad.",
+            ))
     nombre = nombre_salida(tecleado, origen)
     if nombre is None:
         return Validacion(error=(

{tablewise-1.1.2 → tablewise-1.1.3}/tests/test_app_convertir.py

@@ -56,6 +56,15 @@ class _MessageBox(types.ModuleType):
         return [t for t, _, _ in self.llamadas]
 
 
+
+def _ooxml(ruta, marca: str = "") -> None:
+    """Contenedor OOXML mínimo y legible: desde el 14/11 la CLI y la app
+    rechazan antes de convertir un .xlsx/.docx que no es un zip de verdad."""
+    import zipfile
+    with zipfile.ZipFile(ruta, "w") as z:
+        z.writestr("[Content_Types].xml", "<Types/>")
+        z.writestr("marca.txt", marca)
+
 @pytest.fixture
 def entorno(monkeypatch, tmp_path):
     """Importa la app con un tkinter falso y devuelve (modulo, App, messagebox)."""
@@ -106,7 +115,7 @@ def _motor_que_escribe(contenido: bytes = b"| hola |\n", llamadas=None):
 def documento(tmp_path):
     origen = tmp_path / "docs" / "cierre.xlsx"
     origen.parent.mkdir()
-    origen.write_bytes(b"xlsx sintetico")
+    _ooxml(origen, "xlsx sintetico")
     return origen
 
 
@@ -381,3 +390,72 @@ def test_motor_propio_que_falla_reintenta_con_docling(entorno, tmp_path, monkeyp
     assert 'engine: "motor_docling"' in salida.read_text()
     assert "motor propio falló" in app.status.get()
     assert mb.tipos() == ["info"]
+
+
+def test_la_app_rechaza_un_documento_ilegible_sin_lanzar_motores(entorno, tmp_path, monkeypatch):
+    """Misma barrera que la CLI y la API (14/11): un .xlsx que no es zip no
+    llega a ningún motor."""
+    modulo, mb = entorno
+    roto = tmp_path / "roto.xlsx"
+    roto.write_bytes(b"this is not a zip file")
+    llamadas = []
+    monkeypatch.setattr(modulo.subprocess, "run", _motor_que_escribe(llamadas=llamadas))
+
+    _app(modulo, roto, tmp_path / "repo").convert()
+
+    assert llamadas == []
+    assert any(c[0] == "error" and c[1][0] == "Documento ilegible" for c in mb.llamadas)
+    assert not (tmp_path / "repo" / "roto.md").exists()
+
+
+def test_la_app_recurre_a_markitdown_si_falla_el_motor_excel(entorno, documento, tmp_path,
+                                                            monkeypatch):
+    """Cadena de respaldo igual que la CLI y la API: MarkItDown tras cualquier motor."""
+    modulo, mb = entorno
+    monkeypatch.setattr(modulo.App, "get_markitdown_cmd", lambda self: "markitdown")
+    llamadas = []
+
+    def run(cmd, **kwargs):
+        llamadas.append(cmd)
+        if cmd[0] != "markitdown":  # motor_excel falla sin escribir
+            return subprocess.CompletedProcess(cmd, 1, stdout="", stderr="roto")
+        Path(cmd[cmd.index("-o") + 1]).write_bytes(b"| hoja |\n")
+        return subprocess.CompletedProcess(cmd, 0, stdout="", stderr="")
+    monkeypatch.setattr(modulo.subprocess, "run", run)
+
+    _app(modulo, documento, tmp_path / "repo").convert()
+
+    assert [c[0] for c in llamadas][-1] == "markitdown"
+    texto = (tmp_path / "repo" / "cierre.md").read_text(encoding="utf-8")
+    assert 'engine: "markitdown"' in texto
+
+
+def test_la_app_no_da_por_convertido_un_md_vacio(entorno, documento, tmp_path, monkeypatch):
+    modulo, mb = entorno
+    monkeypatch.setattr(modulo.App, "get_markitdown_cmd", lambda self: "markitdown")
+    monkeypatch.setattr(modulo.subprocess, "run", _motor_que_escribe(contenido=b""))
+
+    _app(modulo, documento, tmp_path / "repo").convert()
+
+    assert not (tmp_path / "repo" / "cierre.md").exists()
+    assert any(c[0] == "error" for c in mb.llamadas)
+
+
+def test_la_app_rechaza_un_pdf_protegido_sin_lanzar_motores(entorno, tmp_path, monkeypatch):
+    pypdf = pytest.importorskip("pypdf")
+    import io
+    writer = pypdf.PdfWriter()
+    writer.add_blank_page(width=200, height=200)
+    writer.encrypt(user_password="secreta", owner_password="otra", algorithm="RC4-128")
+    buf = io.BytesIO()
+    writer.write(buf)
+    pdf = tmp_path / "cifrado.pdf"
+    pdf.write_bytes(buf.getvalue())
+    modulo, mb = entorno
+    llamadas = []
+    monkeypatch.setattr(modulo.subprocess, "run", _motor_que_escribe(llamadas=llamadas))
+
+    _app(modulo, pdf, tmp_path / "repo").convert()
+
+    assert llamadas == []
+    assert any(c[0] == "error" and c[1][0] == "Documento protegido" for c in mb.llamadas)

{tablewise-1.1.2 → tablewise-1.1.3}/tests/test_cli.py

@@ -13,9 +13,19 @@ import pytest
 import tablewise_cli
 
 
+
+def _ooxml(ruta, marca: str = "") -> None:
+    """Contenedor OOXML mínimo y legible: desde el 14/11 la CLI y la app
+    rechazan antes de convertir un .xlsx/.docx que no es un zip de verdad.
+    `marca` distingue un fichero de otro, como hacía el texto plano."""
+    import zipfile
+    with zipfile.ZipFile(ruta, "w") as z:
+        z.writestr("[Content_Types].xml", "<Types/>")
+        z.writestr("marca.txt", marca)
+
 def _doc(tmp_path: Path, nombre: str = "documento.xlsx") -> Path:
     ruta = tmp_path / nombre
-    ruta.write_text("contenido de prueba", encoding="utf-8")
+    _ooxml(ruta, "contenido de prueba")
     return ruta
 
 
@@ -29,6 +39,17 @@ def _motor_falso(tmp_path: Path) -> Path:
     return motor
 
 
+
+def _markitdown_mudo(tmp_path: Path) -> str:
+    """MarkItDown falso que falla: desde el 14/11 la CLI lo prueba como última
+    red tras cualquier motor (igual que la API), y un test de «todos los motores
+    fallan» no puede depender del markitdown real del PATH."""
+    import stat
+    ruta = tmp_path / "markitdown-mudo"
+    ruta.write_text(f"#!{sys.executable}\nraise SystemExit(1)\n", encoding="utf-8")
+    ruta.chmod(ruta.stat().st_mode | stat.S_IXUSR)
+    return str(ruta)
+
 @pytest.fixture()
 def motor(monkeypatch, tmp_path):
     falso = _motor_falso(tmp_path)
@@ -88,7 +109,7 @@ def test_motor_que_no_escribe_es_fallo(tmp_path, monkeypatch, capsys):
     monkeypatch.setattr(tablewise_cli, "_python_motores", lambda argumento: Path(sys.executable))
     # Sin este parche, en un equipo sin markitdown el CLI sale con 2 (entorno)
     # antes de llegar al fallo del motor, y el test mediría otra cosa.
-    monkeypatch.setattr(tablewise_cli, "_markitdown", lambda argumento: "markitdown")
+    monkeypatch.setattr(tablewise_cli, "_markitdown", lambda argumento: _markitdown_mudo(tmp_path))
     origen = _doc(tmp_path)
 
     codigo = tablewise_cli.main([str(origen), "-o", str(tmp_path / "repo"), "-q"])
@@ -142,7 +163,7 @@ def test_el_temporal_se_limpia_tras_fallo(tmp_path, monkeypatch):
     mudo.write_text("raise SystemExit(3)\n", encoding="utf-8")
     monkeypatch.setattr(tablewise_cli, "_ruta_modulo", lambda nombre: mudo)
     monkeypatch.setattr(tablewise_cli, "_python_motores", lambda argumento: Path(sys.executable))
-    monkeypatch.setattr(tablewise_cli, "_markitdown", lambda argumento: "markitdown")
+    monkeypatch.setattr(tablewise_cli, "_markitdown", lambda argumento: _markitdown_mudo(tmp_path))
     repo = tmp_path / "repo"
 
     with pytest.raises(RuntimeError):
@@ -194,8 +215,8 @@ def test_avisa_si_un_documento_no_tiene_tablas(tmp_path, motor, capsys):
 def _carpeta(tmp_path):
     entrada = tmp_path / "entrada"
     (entrada / "sub").mkdir(parents=True)
-    (entrada / "a.xlsx").write_text("a", encoding="utf-8")
-    (entrada / "sub" / "b.xlsx").write_text("b", encoding="utf-8")
+    _ooxml(entrada / "a.xlsx", "a")
+    _ooxml(entrada / "sub" / "b.xlsx", "b")
     return entrada
 
 
@@ -222,7 +243,7 @@ def test_lote_sin_recursive_no_entra_en_subcarpetas(tmp_path, motor):
 def test_lote_no_pisa_un_md_existente(tmp_path, motor):
     entrada = tmp_path / "entrada"
     entrada.mkdir()
-    (entrada / "a.xlsx").write_text("a", encoding="utf-8")
+    _ooxml(entrada / "a.xlsx", "a")
     salida = tmp_path / "salida"
     salida.mkdir()
     previo = salida / "a.md"
@@ -239,7 +260,7 @@ def test_lote_sigue_tras_un_fallo_y_devuelve_1(tmp_path, motor, monkeypatch):
     monkeypatch.setattr(preconversion, "buscar_soffice", lambda: None)
     entrada = tmp_path / "entrada"
     entrada.mkdir()
-    (entrada / "a.xlsx").write_text("a", encoding="utf-8")
+    _ooxml(entrada / "a.xlsx", "a")
     (entrada / "b.xls").write_text("b", encoding="utf-8")
     salida = tmp_path / "salida"
 
@@ -251,8 +272,8 @@ def test_lote_sigue_tras_un_fallo_y_devuelve_1(tmp_path, motor, monkeypatch):
 def test_lote_resuelve_colisiones_de_nombre(tmp_path, motor):
     entrada = tmp_path / "entrada"
     entrada.mkdir()
-    (entrada / "a.xlsx").write_text("a", encoding="utf-8")
-    (entrada / "a.xlsm").write_text("b", encoding="utf-8")
+    _ooxml(entrada / "a.xlsx", "a")
+    _ooxml(entrada / "a.xlsm", "b")
     salida = tmp_path / "salida"
 
     assert tablewise_cli.main([str(entrada), "-o", str(salida), "-q"]) == 0
@@ -269,7 +290,7 @@ def test_name_y_recursive_solo_valen_con_carpeta(tmp_path, motor):
 def test_lote_puede_escribir_en_la_misma_carpeta(tmp_path, motor):
     entrada = tmp_path / "entrada"
     entrada.mkdir()
-    (entrada / "a.xlsx").write_text("a", encoding="utf-8")
+    _ooxml(entrada / "a.xlsx", "a")
 
     assert tablewise_cli.main([str(entrada), "-o", str(entrada), "-q"]) == 0
     assert (entrada / "a.md").is_file()
@@ -279,8 +300,8 @@ def test_lote_excluye_la_subcarpeta_de_salida(tmp_path, motor):
     entrada = tmp_path / "entrada"
     salida = entrada / "out"
     salida.mkdir(parents=True)
-    (entrada / "a.xlsx").write_text("a", encoding="utf-8")
-    (salida / "seed.xlsx").write_text("seed", encoding="utf-8")
+    _ooxml(entrada / "a.xlsx", "a")
+    _ooxml(salida / "seed.xlsx", "seed")
 
     assert tablewise_cli.main([str(entrada), "-o", str(salida), "--recursive", "-q"]) == 0
     assert (salida / "a.md").is_file()
@@ -292,9 +313,9 @@ def test_lote_fail_fast_para_en_el_primer_fallo(tmp_path, motor, monkeypatch):
     monkeypatch.setattr(preconversion, "buscar_soffice", lambda: None)
     entrada = tmp_path / "entrada"
     entrada.mkdir()
-    (entrada / "a.xlsx").write_text("a", encoding="utf-8")
+    _ooxml(entrada / "a.xlsx", "a")
     (entrada / "b.xls").write_text("b", encoding="utf-8")
-    (entrada / "c.xlsx").write_text("c", encoding="utf-8")
+    _ooxml(entrada / "c.xlsx", "c")
     salida = tmp_path / "salida"
 
     assert tablewise_cli.main([str(entrada), "-o", str(salida), "--fail-fast", "-q"]) == 1
@@ -314,8 +335,8 @@ def test_lote_dry_run_no_crea_carpetas(tmp_path, motor):
 def test_lote_force_pisa_el_md_previo_pero_no_los_duplicados(tmp_path, motor):
     entrada = tmp_path / "entrada"
     entrada.mkdir()
-    (entrada / "a.xlsx").write_text("a", encoding="utf-8")
-    (entrada / "a.xlsm").write_text("b", encoding="utf-8")
+    _ooxml(entrada / "a.xlsx", "a")
+    _ooxml(entrada / "a.xlsm", "b")
     salida = tmp_path / "salida"
     salida.mkdir()
     previo = salida / "a.md"
@@ -328,7 +349,7 @@ def test_lote_force_pisa_el_md_previo_pero_no_los_duplicados(tmp_path, motor):
 
 def test_documento_vacio_es_error(tmp_path, motor, monkeypatch):
     monkeypatch.chdir(tmp_path)
-    (tmp_path / "a.xlsx").write_text("a", encoding="utf-8")
+    _ooxml(tmp_path / "a.xlsx", "a")
     assert tablewise_cli.main([""]) == 2
     assert not (tmp_path / "a.md").exists()
 
@@ -336,7 +357,7 @@ def test_documento_vacio_es_error(tmp_path, motor, monkeypatch):
 def test_una_carpeta_normal_con_sufijo_pages_no_es_un_paquete(tmp_path, motor):
     carpeta = tmp_path / "datos.pages"
     carpeta.mkdir()
-    (carpeta / "a.xlsx").write_text("a", encoding="utf-8")
+    _ooxml(carpeta / "a.xlsx", "a")
 
     assert tablewise_cli.main([str(carpeta), "-o", str(tmp_path / "salida"), "-q"]) == 0
     assert (tmp_path / "salida" / "a.md").is_file()
@@ -347,7 +368,7 @@ def test_lote_recursive_ignora_paquetes_mac_anidados(tmp_path, motor):
     paquete = entrada / "informe.pages" / "QuickLook"
     paquete.mkdir(parents=True)
     (paquete / "Preview.pdf").write_text("interno", encoding="utf-8")
-    (entrada / "a.xlsx").write_text("a", encoding="utf-8")
+    _ooxml(entrada / "a.xlsx", "a")
     salida = tmp_path / "salida"
 
     assert tablewise_cli.main([str(entrada), "-o", str(salida), "--recursive", "-q"]) == 0

tablewise-1.1.3/tests/test_cli_paridad_api.py

@@ -0,0 +1,139 @@
+"""La CLI decide como la API (batería del 14/11).
+
+Tres costuras que la batería encontró entre las dos superficies:
+- un documento ilegible: la API lo rechaza antes de cobrar (422) y la CLI
+  llegaba a lanzar motores y acababa enseñando la traza de MarkItDown;
+- cuando falla el último motor, la CLI volcaba el stderr entero (traza de
+  Python incluida) al usuario;
+- tras `motor_excel` la API prueba MarkItDown como última red y la CLI no.
+"""
+from __future__ import annotations
+
+import stat
+import sys
+import zipfile
+from pathlib import Path
+
+import pytest
+
+import tablewise_cli
+import tablewise_core
+
+
+def _xlsx(tmp_path: Path, nombre: str = "libro.xlsx") -> Path:
+    ruta = tmp_path / nombre
+    with zipfile.ZipFile(ruta, "w") as z:
+        z.writestr("[Content_Types].xml", "<Types/>")
+        z.writestr("xl/workbook.xml", "<workbook/>")
+    return ruta
+
+
+def _script(tmp_path: Path, nombre: str, cuerpo: str) -> Path:
+    """Ejecutable de verdad (con shebang): construir_comando llama a
+    MarkItDown como programa, no como módulo de Python."""
+    ruta = tmp_path / nombre
+    ruta.write_text(f"#!{sys.executable}\n{cuerpo}", encoding="utf-8")
+    ruta.chmod(ruta.stat().st_mode | stat.S_IXUSR)
+    return ruta
+
+
+ESCRIBE = ("import pathlib, sys\n"
+           "pathlib.Path(sys.argv[-1]).write_text('# hoja\\n\\n| a |\\n|---|\\n| 1 |\\n', "
+           "encoding='utf-8')\n")
+PETA = ("def leer():\n"
+        "    raise ValueError('PDFPasswordIncorrect: el documento pide clave')\n"
+        "leer()\n")
+
+
+@pytest.fixture()
+def motores(monkeypatch, tmp_path):
+    """Motor propio y MarkItDown falsos; cada test decide si escriben o fallan."""
+    estado = {"motor": ESCRIBE, "markitdown": ESCRIBE, "llamadas": []}
+
+    def ruta_modulo(nombre):
+        estado["llamadas"].append(nombre)
+        return _script(tmp_path / "bin", f"{nombre}.py", estado["motor"])
+
+    def markitdown(argumento):
+        return str(_script(tmp_path / "bin", "markitdown", estado["markitdown"]))
+
+    (tmp_path / "bin").mkdir()
+    monkeypatch.setattr(tablewise_cli, "_ruta_modulo", ruta_modulo)
+    monkeypatch.setattr(tablewise_cli, "_python_motores", lambda argumento: Path(sys.executable))
+    monkeypatch.setattr(tablewise_cli, "_markitdown", markitdown)
+    return estado
+
+
+@pytest.mark.parametrize("nombre, contenido, pista", [
+    ("roto.xlsx", b"this is not a zip file", "damaged"),
+    ("vacio.pdf", b"", "empty"),
+])
+def test_documento_ilegible_sale_con_2_sin_lanzar_motores(tmp_path, motores, capsys,
+                                                         nombre, contenido, pista):
+    origen = tmp_path / nombre
+    origen.write_bytes(contenido)
+
+    codigo = tablewise_cli.main([str(origen), "-o", str(tmp_path / "repo"), "-q"])
+
+    err = capsys.readouterr().err
+    assert codigo == 2
+    assert pista in err
+    assert "Traceback" not in err
+    assert motores["llamadas"] == []
+    assert not (tmp_path / "repo" / f"{origen.stem}.md").exists()
+
+
+def test_la_app_tambien_rechaza_el_documento_ilegible(tmp_path):
+    origen = tmp_path / "roto.docx"
+    origen.write_bytes(b"PK\x03\x04 truncado")
+
+    v = tablewise_core.validar_conversion(origen, "", tmp_path / "repo", hay_soffice=False)
+
+    assert v.error is not None
+    assert v.error[0] == "Documento ilegible"
+
+
+def test_la_plantilla_de_comando_sin_documento_no_valida_el_contenedor(tmp_path):
+    # «Copiar comando CLI» sin documento elegido: no hay fichero que leer.
+    v = tablewise_core.validar_conversion(tmp_path / "aun-no.xlsx", "", tmp_path / "repo",
+                                          hay_soffice=False, comprobar_existe=False)
+    assert v.error is None
+
+
+def test_fallo_final_da_el_motivo_sin_traza(tmp_path, motores, capsys):
+    motores["motor"] = PETA
+    motores["markitdown"] = PETA
+    origen = _xlsx(tmp_path)
+
+    codigo = tablewise_cli.main([str(origen), "-o", str(tmp_path / "repo"), "-q"])
+
+    err = capsys.readouterr().err
+    assert codigo == 1
+    assert "did not produce libro.md" in err
+    assert "el documento pide clave" in err
+    assert "Traceback" not in err
+    assert 'File "' not in err
+
+
+def test_motor_excel_que_falla_recurre_a_markitdown_como_la_api(tmp_path, motores):
+    motores["motor"] = "raise SystemExit(1)\n"
+    origen = _xlsx(tmp_path)
+
+    destino = tablewise_cli.convertir(str(origen), str(tmp_path / "repo"), quiet=True)
+
+    assert motores["llamadas"]  # se intentó primero motor_excel
+    texto = destino.read_text(encoding="utf-8")
+    assert 'engine: "markitdown"' in texto
+    assert "| 1 |" in texto
+
+
+def test_motor_que_acaba_bien_con_md_vacio_no_cuenta_como_conversion(tmp_path, motores, capsys):
+    # La API exige salida no vacía; la CLI daba por bueno un .md de 0 bytes.
+    motores["motor"] = "import pathlib, sys\npathlib.Path(sys.argv[-1]).write_text('')\n"
+    motores["markitdown"] = motores["motor"]
+    origen = _xlsx(tmp_path)
+
+    codigo = tablewise_cli.main([str(origen), "-o", str(tmp_path / "repo"), "-q"])
+
+    assert codigo == 1
+    assert not (tmp_path / "repo" / "libro.md").exists()

tablewise-1.1.3/tests/test_contenedor_ilegible.py

@@ -0,0 +1,119 @@
+"""Integrity of the document container, checked before any engine runs.
+
+Defect from the 26/10 battery: `11_corrupted.xlsx` (not a zip) reached
+MarkItDown's last-resort fallback, which reads an unknown file as plain text
+and returned its raw bytes as "Markdown". The API answered 200 and billed it.
+A document whose container is broken must be rejected up front.
+"""
+from __future__ import annotations
+
+import io
+import zipfile
+from pathlib import Path
+
+import pytest
+
+from tablewise_core import DocumentoIlegible, validar_contenedor
+
+
+def _xlsx_valido(path: Path) -> Path:
+    from openpyxl import Workbook
+
+    wb = Workbook()
+    wb.active["A1"] = "ok"
+    wb.save(path)
+    return path
+
+
+def test_xlsx_que_no_es_zip_es_ilegible(tmp_path):
+    p = tmp_path / "11_corrupted.xlsx"
+    p.write_bytes(b"this is not a zip file\n" * 8)
+    with pytest.raises(DocumentoIlegible):
+        validar_contenedor(p)
+
+
+@pytest.mark.parametrize("nombre", ["vacio.pdf", "vacio.xlsx", "vacio.csv", "vacio.docx"])
+def test_fichero_de_cero_bytes_es_ilegible(tmp_path, nombre):
+    p = tmp_path / nombre
+    p.write_bytes(b"")
+    with pytest.raises(DocumentoIlegible):
+        validar_contenedor(p)
+
+
+def test_xlsx_truncado_es_ilegible(tmp_path):
+    bueno = _xlsx_valido(tmp_path / "bueno.xlsx").read_bytes()
+    p = tmp_path / "truncado.xlsx"
+    p.write_bytes(bueno[: len(bueno) // 2])
+    with pytest.raises(DocumentoIlegible):
+        validar_contenedor(p)
+
+
+def test_zip_sin_content_types_no_es_ooxml(tmp_path):
+    buf = io.BytesIO()
+    with zipfile.ZipFile(buf, "w") as z:
+        z.writestr("hola.txt", "no soy un libro")
+    p = tmp_path / "falso.docx"
+    p.write_bytes(buf.getvalue())
+    with pytest.raises(DocumentoIlegible):
+        validar_contenedor(p)
+
+
+def test_xlsx_valido_pasa(tmp_path):
+    validar_contenedor(_xlsx_valido(tmp_path / "bueno.xlsx"))
+
+
+@pytest.mark.parametrize("nombre,contenido", [
+    ("datos.csv", b"a;b\n1;2\n"),
+    ("viejo.xls", b"\xd0\xcf\x11\xe0 not checked: legacy binary"),
+    ("informe.pdf", b"%PDF-1.4 the engines decide"),
+])
+def test_formatos_sin_contenedor_zip_no_se_tocan(tmp_path, nombre, contenido):
+    p = tmp_path / nombre
+    p.write_bytes(contenido)
+    validar_contenedor(p)
+
+
+def _corromper_miembro(datos: bytes, miembro: str) -> bytes:
+    """Daña los bytes comprimidos de un miembro sin tocar el directorio central."""
+    z = zipfile.ZipFile(io.BytesIO(datos))
+    info = z.getinfo(miembro)
+    inicio = info.header_offset + 30 + len(info.filename.encode()) + len(info.extra)
+    roto = bytearray(datos)
+    for k in range(inicio, inicio + info.compress_size):
+        roto[k] ^= 0x5A
+    return bytes(roto)
+
+
+def test_manifiesto_ooxml_corrupto_es_ilegible(tmp_path):
+    """Codex R1: el directorio central intacto no basta; el manifiesto se lee
+    (pequeño y con tope) y su CRC se comprueba."""
+    bueno = _xlsx_valido(tmp_path / "bueno.xlsx").read_bytes()
+    p = tmp_path / "manifiesto_roto.xlsx"
+    p.write_bytes(_corromper_miembro(bueno, "[Content_Types].xml"))
+    with pytest.raises(DocumentoIlegible):
+        validar_contenedor(p)
+
+
+def test_manifiesto_desmesurado_es_ilegible(tmp_path):
+    """El tope evita descomprimir un manifiesto inflado (zip bomb)."""
+    buf = io.BytesIO()
+    with zipfile.ZipFile(buf, "w", zipfile.ZIP_DEFLATED) as z:
+        z.writestr("[Content_Types].xml", "<Types>" + " " * (3 * 1024 * 1024) + "</Types>")
+    p = tmp_path / "inflado.docx"
+    p.write_bytes(buf.getvalue())
+    with pytest.raises(DocumentoIlegible):
+        validar_contenedor(p)
+
+
+def test_extension_en_mayusculas_tambien_se_valida(tmp_path):
+    p = tmp_path / "ROTO.XLSX"
+    p.write_bytes(b"this is not a zip file\n" * 8)
+    with pytest.raises(DocumentoIlegible):
+        validar_contenedor(p)
+
+
+def test_zip_con_datos_antepuestos_sigue_siendo_valido(tmp_path):
+    bueno = _xlsx_valido(tmp_path / "bueno.xlsx").read_bytes()
+    p = tmp_path / "con_prefijo.xlsx"
+    p.write_bytes(b"\0" * 64 + bueno)
+    validar_contenedor(p)

{tablewise-1.1.2 → tablewise-1.1.3}/tests/test_core.py

@@ -8,6 +8,15 @@ import pytest
 from tablewise_core import analizar_calidad, elegir_motor, nombre_seguro
 
 
+
+def _ooxml(ruta, marca: str = "") -> None:
+    """Contenedor OOXML mínimo y legible: desde el 14/11 la CLI y la app
+    rechazan antes de convertir un .xlsx/.docx que no es un zip de verdad."""
+    import zipfile
+    with zipfile.ZipFile(ruta, "w") as z:
+        z.writestr("[Content_Types].xml", "<Types/>")
+        z.writestr("marca.txt", marca)
+
 @pytest.mark.parametrize("nombre,esperado", [
     ("informe", "informe"),
     ("  informe  ", "informe"),
@@ -482,7 +491,10 @@ from tablewise_core import validar_conversion
 
 def _doc(tmp_path, nombre="cierre.xlsx"):
     ruta = tmp_path / nombre
-    ruta.write_bytes(b"sintetico")
+    if ruta.suffix.lower() in {".xlsx", ".xlsm", ".docx", ".pptx"}:
+        _ooxml(ruta, "sintetico")
+    else:
+        ruta.write_bytes(b"sintetico")
     return ruta
 
 

tablewise-1.1.3/tests/test_documento_cifrado.py

@@ -0,0 +1,159 @@
+"""Un documento protegido con contraseña se rechaza con su propio motivo.
+
+Batería del 14/11: `16_encrypted.pdf` llegaba a los motores y acababa en un
+«conversion_failed» genérico (API) o en la excepción de MarkItDown (CLI). El
+cliente no sabía que bastaba con quitar la contraseña. Ahora se detecta antes
+de lanzar motores y, en la API, antes de reservar unidades.
+
+Cuidado con el falso positivo: un PDF con solo contraseña de propietario
+(limita imprimir o copiar) se abre sin clave y SÍ se convierte.
+"""
+from __future__ import annotations
+
+import io
+import sys
+from pathlib import Path
+
+import pytest
+
+import tablewise_cli
+from tablewise_core import DocumentoCifrado, DocumentoIlegible, validar_contenedor
+
+CFB = bytes.fromhex("D0CF11E0A1B11AE1")
+
+
+def _cfb(flujos: list[str], contenido: bytes = b"") -> bytes:
+    """Contenedor CFB v3 mínimo y válido ([MS-CFB]): sector 0 = FAT, sector 1 =
+    directorio (raíz + un flujo por nombre), sector 2 = datos opcionales."""
+    def u32(n):
+        return n.to_bytes(4, "little")
+    FREE, END, FATSECT = 0xFFFFFFFF, 0xFFFFFFFE, 0xFFFFFFFD
+    cab = bytearray(512)
+    cab[:8] = CFB
+    cab[24:26] = (0x3E).to_bytes(2, "little")
+    cab[26:28] = (3).to_bytes(2, "little")
+    cab[28:30] = b"\xfe\xff"
+    cab[30:32] = (9).to_bytes(2, "little")
+    cab[32:34] = (6).to_bytes(2, "little")
+    cab[44:48] = u32(1)            # sectores de FAT
+    cab[48:52] = u32(1)            # primer sector del directorio
+    cab[56:60] = u32(4096)
+    cab[60:64] = u32(END)
+    cab[68:72] = u32(END)
+    cab[76:80] = u32(0)            # DIFAT[0] = sector 0
+    for i in range(1, 109):
+        cab[76 + 4 * i:80 + 4 * i] = u32(FREE)
+    fat = bytearray(u32(FATSECT) + u32(END) + u32(END if contenido else FREE))
+    fat += u32(FREE) * (128 - 3)
+
+    def entrada(nombre: str, tipo: int) -> bytes:
+        e = bytearray(128)
+        bruto = nombre.encode("utf-16-le") + b"\0\0"
+        e[:len(bruto)] = bruto
+        e[64:66] = len(bruto).to_bytes(2, "little")
+        e[66] = tipo
+        return bytes(e)
+    directorio = entrada("Root Entry", 5) + b"".join(entrada(n, 2) for n in flujos)
+    directorio = directorio.ljust(512, b"\0")[:512]
+    return bytes(cab) + bytes(fat) + directorio + contenido.ljust(512, b"\0")[:512] * bool(contenido)
+
+
+def _pdf(tmp_path: Path, nombre: str = "doc.pdf", *, usuario: str | None = None,
+         propietario: str = "propietario", algoritmo: str = "RC4-128") -> Path:
+    pypdf = pytest.importorskip("pypdf")
+    writer = pypdf.PdfWriter()
+    writer.add_blank_page(width=200, height=200)
+    if usuario is not None:
+        writer.encrypt(user_password=usuario, owner_password=propietario, algorithm=algoritmo)
+    buf = io.BytesIO()
+    writer.write(buf)
+    ruta = tmp_path / nombre
+    ruta.write_bytes(buf.getvalue())
+    return ruta
+
+
+@pytest.mark.parametrize("algoritmo", ["RC4-128", "AES-256"])
+def test_pdf_con_contrasena_de_apertura_es_cifrado(tmp_path, algoritmo):
+    origen = _pdf(tmp_path, usuario="secreta", algoritmo=algoritmo)
+    with pytest.raises(DocumentoCifrado, match="password"):
+        validar_contenedor(origen)
+
+
+def test_cifrado_es_un_caso_de_ilegible(tmp_path):
+    # La CLI, la app y el lote ya tratan DocumentoIlegible: no hay ruta nueva
+    # por la que se escape.
+    assert issubclass(DocumentoCifrado, DocumentoIlegible)
+
+
+def test_pdf_con_solo_contrasena_de_propietario_se_convierte(tmp_path):
+    origen = _pdf(tmp_path, usuario="", propietario="solo-permisos")
+    import pypdf
+    assert pypdf.PdfReader(origen).is_encrypted  # de verdad está cifrado
+    validar_contenedor(origen)  # y aun así se abre sin clave: no se rechaza
+
+
+def test_pdf_normal_pasa(tmp_path):
+    validar_contenedor(_pdf(tmp_path))
+
+
+def test_pdf_que_pypdf_no_entiende_lo_deciden_los_motores(tmp_path):
+    # Un fallo de pypdf no es prueba de cifrado: rechazarlo daría falsos
+    # positivos con PDF que el motor propio sí lee.
+    origen = tmp_path / "raro.pdf"
+    origen.write_bytes(b"%PDF-1.4\nesto no es un pdf completo\n")
+    validar_contenedor(origen)
+
+
+def test_sin_pypdf_no_se_rechaza_nada(tmp_path, monkeypatch):
+    # El paquete de PyPI no exige pypdf: sin él no se adivina.
+    origen = _pdf(tmp_path, usuario="secreta")
+    monkeypatch.setitem(sys.modules, "pypdf", None)
+    validar_contenedor(origen)
+
+
+def test_office_cifrado_es_cifrado(tmp_path):
+    # Word/Excel guardan un OOXML con contraseña como contenedor OLE con un
+    # flujo «EncryptedPackage», no como zip.
+    origen = tmp_path / "presupuesto.xlsx"
+    origen.write_bytes(_cfb(["EncryptionInfo", "EncryptedPackage"]))
+    with pytest.raises(DocumentoCifrado, match="password"):
+        validar_contenedor(origen)
+
+
+@pytest.mark.parametrize("flujos, contenido", [
+    (["WordDocument"], b""),                                    # .doc renombrado a .docx
+    (["Workbook"], "EncryptedPackage".encode("utf-16-le")),     # el texto, en una celda
+])
+def test_cfb_sin_flujo_cifrado_sigue_siendo_ilegible_no_cifrado(tmp_path, flujos, contenido):
+    # Codex R1: el nombre cuenta solo si es una entrada del directorio, no si
+    # aparece en el contenido de otro flujo.
+    origen = tmp_path / "viejo.docx"
+    origen.write_bytes(_cfb(flujos, contenido))
+    with pytest.raises(DocumentoIlegible) as exc:
+        validar_contenedor(origen)
+    assert not isinstance(exc.value, DocumentoCifrado)
+
+
+def test_cfb_truncado_no_se_declara_cifrado(tmp_path):
+    origen = tmp_path / "corto.xlsx"
+    origen.write_bytes(_cfb(["EncryptedPackage"])[:600])  # el directorio no llega
+    with pytest.raises(DocumentoIlegible) as exc:
+        validar_contenedor(origen)
+    assert not isinstance(exc.value, DocumentoCifrado)
+
+
+def test_cli_rechaza_el_pdf_cifrado_con_codigo_2_y_sin_motores(tmp_path, monkeypatch, capsys):
+    llamadas = []
+    monkeypatch.setattr(tablewise_cli, "_ruta_modulo", lambda n: llamadas.append(n))
+    monkeypatch.setattr(tablewise_cli, "_python_motores", lambda a: Path(sys.executable))
+    monkeypatch.setattr(tablewise_cli, "_markitdown", lambda a: "markitdown")
+    origen = _pdf(tmp_path, usuario="secreta")
+
+    codigo = tablewise_cli.main([str(origen), "-o", str(tmp_path / "repo"), "-q"])
+
+    err = capsys.readouterr().err
+    assert codigo == 2
+    assert "password" in err.lower()
+    assert len(err.strip().splitlines()) == 1  # una línea, sin traza ni detalle
+    assert "Traceback" not in err
+    assert llamadas == []

{tablewise-1.1.2 → tablewise-1.1.3}/tests/test_sprint_deliver.py

@@ -16,6 +16,16 @@ sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "scripts"))
 import sprint_deliver  # noqa: E402
 
 
+
+def _ooxml(ruta, marca: str = "") -> None:
+    """Contenedor OOXML mínimo y legible: desde el 14/11 la CLI y la app
+    rechazan antes de convertir un .xlsx/.docx que no es un zip de verdad.
+    `marca` distingue un fichero de otro, como hacía el texto plano."""
+    import zipfile
+    with zipfile.ZipFile(ruta, "w") as z:
+        z.writestr("[Content_Types].xml", "<Types/>")
+        z.writestr("marca.txt", marca)
+
 @pytest.fixture()
 def motor(monkeypatch, tmp_path):
     falso = tmp_path / "motor_excel.py"
@@ -35,9 +45,9 @@ def motor(monkeypatch, tmp_path):
 def _corpus(root: Path) -> Path:
     src = root / "corpus"
     (src / "2026" / "q3").mkdir(parents=True)
-    (src / "pl-enero.xlsx").write_text("a", encoding="utf-8")
-    (src / "2026" / "q3" / "pl-julio.xlsx").write_text("bb", encoding="utf-8")
-    (src / "roto.xlsx").write_text("c", encoding="utf-8")
+    _ooxml(src / "pl-enero.xlsx", "a")
+    _ooxml(src / "2026" / "q3" / "pl-julio.xlsx", "bb")
+    _ooxml(src / "roto.xlsx", "c")
     (src / ".DS_Store").write_text("x", encoding="utf-8")
     return src
 
@@ -108,7 +118,7 @@ def test_rerun_script_is_portable(tmp_path, motor):
 
 def test_optional_engine_formats_use_the_api_router(monkeypatch, tmp_path, motor):
     src = _corpus(tmp_path)
-    (src / "memo.docx").write_text("x", encoding="utf-8")
+    _ooxml(src / "memo.docx", "x")
     seen = []
 
     class Result:
@@ -128,7 +138,7 @@ def test_optional_engine_formats_use_the_api_router(monkeypatch, tmp_path, motor
 
 def test_same_stem_does_not_overwrite_and_engine_is_normalised(tmp_path, motor):
     src = _corpus(tmp_path)
-    (src / "pl-enero.xlsm").write_text("x", encoding="utf-8")
+    _ooxml(src / "pl-enero.xlsm", "x")
     out = tmp_path / "d"
     report = sprint_deliver.build(src, out, client="Acme", quiet=True)
     assert report.converted == 3 and report.failed == ["roto.xlsx"]
@@ -143,7 +153,7 @@ def test_same_stem_does_not_overwrite_and_engine_is_normalised(tmp_path, motor):
 
 def test_rerun_handles_same_stem_collisions(tmp_path, motor):
     src = _corpus(tmp_path)
-    (src / "pl-enero.xlsm").write_text("x", encoding="utf-8")
+    _ooxml(src / "pl-enero.xlsm", "x")
     out = tmp_path / "d"
     sprint_deliver.build(src, out, client="Acme", quiet=True)
 
@@ -177,7 +187,7 @@ printf '# %s\n' "$name" > "$dest/$name.md"
 
 def test_sanitised_name_matches_the_manifest_and_the_file(tmp_path, motor):
     src = _corpus(tmp_path)
-    (src / ".informe.xlsx").write_text("x", encoding="utf-8")
+    _ooxml(src / ".informe.xlsx", "x")
     out = tmp_path / "d"
     report = sprint_deliver.build(src, out, client="Acme", quiet=True)
     assert report.converted == 3 and report.failed == ["roto.xlsx"]
@@ -190,7 +200,7 @@ def test_sanitised_name_matches_the_manifest_and_the_file(tmp_path, motor):
 
 def test_rerun_groups_skipped_files_for_collision_names(monkeypatch, tmp_path, motor):
     src = _corpus(tmp_path)
-    (src / "presupuesto.xlsx").write_text("x", encoding="utf-8")
+    _ooxml(src / "presupuesto.xlsx", "x")
     (src / "presupuesto.pdf").write_text("x", encoding="utf-8")
 
     class Result: