aioli-cli 0.1.26__tar.gz → 0.1.28__tar.gz

{aioli_cli-0.1.26 → aioli_cli-0.1.28}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: aioli-cli
-Version: 0.1.26
+Version: 0.1.28
 Summary: aioli — local-first AI media suite CLI (images, video, music, voice, podcast)
 Author: aioli contributors
 License: MIT

{aioli_cli-0.1.26 → aioli_cli-0.1.28}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "aioli-cli"
-version = "0.1.26"
+version = "0.1.28"
 description = "aioli — local-first AI media suite CLI (images, video, music, voice, podcast)"
 readme = "README.md"
 requires-python = ">=3.12"
@@ -117,6 +117,12 @@ addopts = "-q"
 dev = [
     "pytest>=8.0",
     "pillow>=10.0",  # solo tests (stubs de imagen); nunca en dependencies
+    # H0.4: tooling de CI pineado aqui (no en `uvx` run-steps) para que
+    # dependabot lo renueve: no ve herramientas invocadas con `uvx` en los
+    # workflows. release.yml ejecuta estas tools con `uv run`.
+    "ruff==0.16.8",
+    "mypy==2.3.1",
+    "pip-audit==2.10.1",
 ]
 
 [tool.mypy]
@@ -175,18 +181,12 @@ exclude = [
 [tool.ruff.lint]
 select = ["E", "F", "W", "I", "UP", "B"]
 ignore = [
-    # E501 lo posee el formatter; activarlo junto al formatter es ruido.
-    "E501",
     # B008 es falso positivo sistemático: typer.Option/Argument en defaults
     # es la API documentada de Typer, no llamada mutable en default.
     "B008",
-    # UP042 (str,Enum)->StrEnum cambia semántica de str()/format; migración
-    # aparte, fuera del alcance de esta wave de lint.
-    "UP042",
 ]
 
 [tool.ruff.format]
 # line-length se hereda de [tool.ruff] line-length = 100.
-# NOTA: `ruff format --check .` aún reporta ~73 ficheros sin formatear.
-# El reformateo masivo (~4900 líneas de diff) es tarea aparte: esta wave
-# solo configura el formatter y limpia el lint sin reescribir el código.
+# H0 (2026-09-18): reformateo masivo aplicado (32 ficheros);
+# `ruff format --check .` verde en CI.

{aioli_cli-0.1.26 → aioli_cli-0.1.28}/src/aioli_cli/fetch_ui.py

@@ -11,11 +11,37 @@ from pathlib import Path
 from threading import Lock
 
 from rich.console import Console
-from rich.progress import Progress, TaskID
+from rich.progress import (
+    BarColumn,
+    DownloadColumn,
+    Progress,
+    TaskID,
+    TaskProgressColumn,
+    TextColumn,
+    TimeElapsedColumn,
+    TransferSpeedColumn,
+)
 
 console = Console()
 
 
+def live_progress() -> Progress:
+    """Live bar for downloads: bytes + speed + elapsed, never a fake ETA.
+
+    H3.1: `TimeRemainingColumn` is deliberately absent. With an unknown
+    total rich would print a bogus countdown, so remaining time is never
+    shown — elapsed time and current speed are honest without a total.
+    """
+    return Progress(
+        TextColumn("{task.description}"),
+        BarColumn(),
+        TaskProgressColumn(),
+        DownloadColumn(),
+        TransferSpeedColumn(),
+        TimeElapsedColumn(),
+    )
+
+
 class _Bar:
     """Thread-safe fan-out: one rich task per file."""
 
@@ -25,13 +51,21 @@ class _Bar:
         self.lock = Lock()
 
     def update(self, path: Path, done_bytes: int, total_bytes: int) -> None:
+        # H3.1: total desconocido (0) = tarea indeterminada (total=None).
+        # El total=1 anterior fingía porcentajes absurdos (p.ej. 1638400%)
+        # con ETA. Cuando el total llega tarde se fija entonces.
         key = str(path)
         with self.lock:
             task = self.tasks.get(key)
             if task is None:
-                task = self.progress.add_task(path.name, total=total_bytes or 1)
+                task = self.progress.add_task(
+                    path.name, total=total_bytes if total_bytes > 0 else None
+                )
                 self.tasks[key] = task
-        self.progress.update(task, completed=done_bytes, total=total_bytes or 1)
+        if total_bytes > 0:
+            self.progress.update(task, completed=done_bytes, total=total_bytes)
+        else:
+            self.progress.update(task, completed=done_bytes)
 
 
 def download_many(
@@ -52,7 +86,7 @@ def download_many(
     failures: list[tuple[str, str]] = []
     flog: Lock = Lock()
 
-    with Progress() as progress:
+    with live_progress() as progress:
         bar = _Bar(progress)
 
         def _one(entry: ModelFile) -> None:

{aioli_cli-0.1.26 → aioli_cli-0.1.28}/src/aioli_cli/main.py

@@ -93,11 +93,16 @@ def setup(
 
 
 @app.command()
-def status() -> None:
+def status(
+    quick: bool = typer.Option(False, "--quick", help="Nivel quick: presencia+tamaño."),
+    full: bool = typer.Option(False, "--full", help="Nivel full: sha256/recibo re-hasheado."),
+) -> None:
     """Límites del equipo + qué motores sirven, faltan y cómo arreglarlos."""
     from aioli_cli.status import run_status
 
-    run_status()
+    if quick and full:
+        raise typer.BadParameter("--quick y --full son excluyentes")
+    run_status(level="full" if full else "quick")
 
 
 @app.command()

{aioli_cli-0.1.26 → aioli_cli-0.1.28}/src/aioli_cli/status.py

@@ -8,7 +8,19 @@ from rich.table import Table
 console = Console()
 
 
-def run_status() -> None:
+def run_status(level: str = "quick") -> None:
+    """Niveles H1 (D08): quick / full / probado por separado.
+
+    - `quick` (defecto): presencia + tamano, sin re-hashear GBs. Nunca
+      vende "listo/certificado": lo presente se marca como presente.
+    - `full`: sha256/recibo re-hasheado; coincide con `setup` sin
+      descargas pendientes y con `models verify`.
+    - `probado`: solo inferencia real; status nunca lo afirma, solo
+      muestra la evidencia de `probe.json` cuando existe.
+    """
+    if level not in ("quick", "full"):
+        raise ValueError(f"nivel desconocido: {level!r} (válidos: quick, full)")
+    quick = level == "quick"
     from aioli_cli import _plugins  # noqa: PLC0415
     from aioli_cli.registry import registry  # noqa: PLC0415
     from aioli_cli.setup import machine_panel  # noqa: PLC0415
@@ -34,6 +46,19 @@ def run_status() -> None:
     console.print()
     console.print(machine_panel(machine))
     console.print()
+    if quick:
+        console.print(
+            "[dim]nivel quick: presencia+tamaño (sin re-hashear). "
+            "No certifica integridad ni inferencia; "
+            "`aioli status --full` re-hashea (sha256/recibo).[/]"
+        )
+    else:
+        console.print(
+            "[dim]nivel full: sha256/recibo re-hasheado "
+            "(coincide con `setup` y `models verify`). "
+            "Probado exige inferencia real (sección probado).[/]"
+        )
+    console.print()
 
     table = Table(title="¿Qué puedo usar?")
     table.add_column("plugin")
@@ -56,7 +81,7 @@ def run_status() -> None:
         runtimes_plat: list[ModelFile] = []  # plataforma actual: ¿hay motor usable?
 
         def _ok_any(entry) -> bool:
-            return any(verify(entry, root, bin_dir, quick=True) == "ok" for root in _roots)
+            return any(verify(entry, root, bin_dir, quick=quick) == "ok" for root in _roots)
 
         for raw in p.models():
             e = ModelFile(**raw)
@@ -111,15 +136,26 @@ def run_status() -> None:
                 )
                 nofit.append(f"{tag} — {v.headline}")
             elif is_ready:
-                table.add_row(
-                    p.name,
-                    engine,
-                    f"{v.icon} cabe",
-                    f"{ok_n}/{len(core)}",
-                    "—",
-                    f"aioli {p.name} … (listo)",
-                )
-                ready.append(tag)
+                if quick:
+                    table.add_row(
+                        p.name,
+                        engine,
+                        f"{v.icon} cabe",
+                        f"{ok_n}/{len(core)}",
+                        "—",
+                        f"aioli {p.name} … (presente quick, confirma con --full)",
+                    )
+                    ready.append(f"{tag} (presente quick, sin verificar)")
+                else:
+                    table.add_row(
+                        p.name,
+                        engine,
+                        f"{v.icon} cabe",
+                        f"{ok_n}/{len(core)}",
+                        "—",
+                        f"aioli {p.name} … (listo, verificado full)",
+                    )
+                    ready.append(tag)
             elif gaps:
                 if "motor piper (binario)" in gaps:
                     fix = "uv tool install piper-tts (o exporta $PIPER_BIN)"
@@ -140,8 +176,18 @@ def run_status() -> None:
                 (licensed if _needs_license(entries) else easy).append(f"{tag} → {fix}")
     console.print(table)
     console.print()
+    probado = _probado_plugins()
+    if probado:
+        console.print("[bold]probado (inferencia real en este equipo):[/]")
+        for line in sorted(probado):
+            console.print(f"🧪 probado: [bold]{line}[/]")
+    else:
+        console.print("[dim]probado: sin evidencia de inferencia en este equipo;[/]")
+        console.print("[dim]solo una inferencia real marca probado (quick/full no bastan).[/]")
+    console.print()
+    ready_icon = "✅ presente (quick)" if quick else "✅ listo (full)"
     for line in ready:
-        console.print(f"✅ listo: [bold]{line}[/]")
+        console.print(f"{ready_icon}: [bold]{line}[/]")
     for line in easy:
         console.print(f"⬇️  instalable fácil: [bold]{line}[/]")
     for line in licensed:
@@ -151,6 +197,31 @@ def run_status() -> None:
     console.print()
 
 
+def _probado_plugins() -> set[str]:
+    """Plugins con al menos una inferencia que cupo en ESTE equipo.
+
+    Lee `probe.json` (solo lectura); vacío o ausente = sin evidencia.
+    """
+    try:
+        from aioli_contract.probe import hardware_fingerprint, load_store  # noqa: PLC0415
+
+        store = load_store()
+        hw = hardware_fingerprint()
+        out: set[str] = set()
+        plugins = store.get(hw, {})
+        for plugin, models in plugins.items():
+            if not isinstance(models, dict):
+                continue
+            for modes in models.values():
+                if not isinstance(modes, dict):
+                    continue
+                if any(isinstance(m, dict) and m.get("fits") for m in modes.values()):
+                    out.add(plugin)
+        return out
+    except Exception:  # noqa: BLE001 — sin evidencia: no probado, sin romper status
+        return set()
+
+
 def _piper_binary() -> bool:
     """El MISMO criterio que el motor en ejecución (A05).
 

{aioli_cli-0.1.26 → aioli_cli-0.1.28}/src/aioli_contract/__init__.py

@@ -16,6 +16,19 @@ from aioli_contract.fetch import (
     smoke_runtime,
     verify,
 )
+from aioli_contract.readiness import (
+    BackendSpec,
+    ExecutionPlan,
+    ProbeOutcome,
+    Readiness,
+    check_abi_ldd,
+    check_exec_bit,
+    check_sdk,
+    evaluate_readiness,
+    probe_runtime,
+    rank,
+    resolve_backend,
+)
 
 __all__ = [
     "AioliConfig",
@@ -34,6 +47,17 @@ __all__ = [
     "human_gb",
     "judge",
     "read_machine",
+    "BackendSpec",
+    "ExecutionPlan",
+    "ProbeOutcome",
+    "Readiness",
+    "check_abi_ldd",
+    "check_exec_bit",
+    "check_sdk",
+    "evaluate_readiness",
+    "probe_runtime",
+    "rank",
+    "resolve_backend",
     "run_checks",
     "sha256_of",
     "smoke_runtime",

{aioli_cli-0.1.26 → aioli_cli-0.1.28}/src/aioli_contract/advise.py

@@ -22,13 +22,33 @@ class GPU:
     name: str
     total_gb: float
     free_gb: float
+    uuid: str = ""
+    index: int = 0
 
 
 @dataclass
 class Machine:
+    """Snapshot de hardware de UNA invocacion (H4.1, D15).
+
+    Un snapshot por comando: `read_machine()` escanea una vez por proceso
+    (cache explicita, ver `invalidate_machine_cache`) y el MISMO objeto se
+    comparte entre todos los checks del comando en lugar de re-escanear
+    por plugin.
+
+    Convencion desconocido != 0:
+    - `gpus == []` = sin NVIDIA medible (desconocido), NO "0 GPUs de 0 GB".
+    - `free_gb == 0.0` en una GPU listada ES un dato valido (GPU ocupada).
+    - `ram_total_gb/ram_available_gb is None` = no medible; `ram_gb == 0.0`
+      es solo el alias legacy de ese desconocido.
+    - `cuda_visible_devices is None` = variable ausente (todo visible).
+    """
+
     gpus: list[GPU] = field(default_factory=list)
     ram_gb: float = 0.0
     disk_free_gb: float = 0.0
+    ram_total_gb: float | None = None
+    ram_available_gb: float | None = None
+    cuda_visible_devices: str | None = None
 
     @property
     def best_vram_gb(self) -> float:
@@ -117,29 +137,100 @@ REQUIREMENTS: dict[tuple[str, str], Requirement] = {
 }
 
 
-def read_machine(models_dir: Path | None = None) -> Machine:
-    gpus: list[GPU] = []
+_MACHINE_CACHE: dict[str, Machine] = {}
+
+
+def invalidate_machine_cache() -> None:
+    """Invalidacion explicita del snapshot (H4.1).
+
+    La cache vive solo en el proceso actual: un comando CLI escanea una
+    vez y comparte el objeto; los tests o un cambio de GPU fuerzan con
+    `force_refresh=True` o llamando aqui.
+    """
+    _MACHINE_CACHE.clear()
+
+
+def _cache_key(models_dir: Path | None) -> str:
     try:
-        out = subprocess.run(
-            ["nvidia-smi", "--query-gpu=name,memory.total,memory.free",
-             "--format=csv,noheader,nounits"],
-            capture_output=True, text=True, timeout=10,
-        )
-        if out.returncode == 0:
-            for line in out.stdout.strip().splitlines():
-                name, total, free = [p.strip() for p in line.split(",")]
-                gpus.append(GPU(name, int(total) / 1024, int(free) / 1024))
-    except Exception:  # noqa: BLE001 — no NVIDIA, CPU life
-        pass
-    ram_gb = 0.0
+        target = models_dir or Path.home()
+        return str(target)
+    except Exception:  # noqa: BLE001 — clave best-effort, nunca rompe el scan
+        return ""
+
+
+def _query_gpus() -> list[GPU]:
+    """Un unico `nvidia-smi` con UUID; fallback al query legacy sin UUID."""
+    queries = [
+        [
+            "nvidia-smi",
+            "--query-gpu=name,uuid,memory.total,memory.free",
+            "--format=csv,noheader,nounits",
+        ],
+        [
+            "nvidia-smi",
+            "--query-gpu=name,memory.total,memory.free",
+            "--format=csv,noheader,nounits",
+        ],
+    ]
+    for argv in queries:
+        try:
+            out = subprocess.run(argv, capture_output=True, text=True, timeout=10)
+        except Exception:  # noqa: BLE001 — no NVIDIA, CPU life
+            return []
+        if out.returncode != 0 or not out.stdout.strip():
+            continue
+        gpus: list[GPU] = []
+        try:
+            for idx, line in enumerate(out.stdout.strip().splitlines()):
+                parts = [s.strip() for s in line.split(",")]
+                if len(parts) == 4:
+                    name, uuid, total, free = parts
+                elif len(parts) == 3:
+                    name, total, free = parts
+                    uuid = ""
+                else:
+                    continue
+                gpus.append(GPU(name, int(total) / 1024, int(free) / 1024, uuid, idx))
+        except (ValueError, TypeError):
+            continue
+        return gpus
+    return []
+
+
+def _read_ram() -> tuple[float | None, float | None]:
+    """(total_GiB, disponible_GiB); (None, None) si no medible."""
+    total: float | None = None
+    avail: float | None = None
     try:
         with Path("/proc/meminfo").open() as fh:
             for line in fh:
                 if line.startswith("MemTotal:"):
-                    ram_gb = int(line.split()[1]) / 1024 / 1024
+                    total = int(line.split()[1]) / 1024 / 1024
+                elif line.startswith("MemAvailable:"):
+                    avail = int(line.split()[1]) / 1024 / 1024
+                if total is not None and avail is not None:
                     break
     except OSError:
-        pass
+        return None, None
+    return total, avail
+
+
+def read_machine(models_dir: Path | None = None, *, force_refresh: bool = False) -> Machine:
+    """Snapshot unico de hardware por comando (H4.1).
+
+    Escanea una vez por proceso (un `nvidia-smi` + `/proc/meminfo` +
+    `shutil.disk_usage`) y devuelve SIEMPRE el mismo objeto mientras la
+    cache viva: todos los `judge()` del comando comparten este snapshot.
+    `force_refresh=True` o `invalidate_machine_cache()` rescanean.
+    """
+    import os as _os
+
+    key = _cache_key(models_dir)
+    if not force_refresh and key in _MACHINE_CACHE:
+        return _MACHINE_CACHE[key]
+    gpus = _query_gpus()
+    ram_total, ram_avail = _read_ram()
+    cuda_env = _os.environ.get("CUDA_VISIBLE_DEVICES", "").strip() or None
     disk = 0.0
     try:
         target = models_dir or Path.home()
@@ -148,7 +239,20 @@ def read_machine(models_dir: Path | None = None) -> Machine:
         disk = shutil.disk_usage(target).free / 1024**3
     except OSError:
         pass
-    return Machine(gpus=gpus, ram_gb=ram_gb, disk_free_gb=disk)
+    machine = Machine(
+        gpus=gpus,
+        ram_gb=ram_total if ram_total is not None else 0.0,
+        disk_free_gb=disk,
+        ram_total_gb=ram_total,
+        ram_available_gb=ram_avail,
+        cuda_visible_devices=cuda_env,
+    )
+    _MACHINE_CACHE[key] = machine
+    return machine
+
+
+#: Alias de contrato H4.1: el snapshot ES la Machine compartida.
+MachineSnapshot = Machine
 
 
 @dataclass
@@ -165,7 +269,8 @@ def judge(plugin: str, backend: str, machine: Machine) -> Verdict:
         # R09: motor sin datos NO es "cabe" — es desconocido. Setup no debe
         # descargar GB a ciegas y status no debe prometer lo no probado.
         return Verdict(
-            False, "❔",
+            False,
+            "❔",
             f"{plugin}/{backend}: sin datos de requisitos, no se instala a ciegas.",
             "Pruébalo a mano y comparte resultados para añadirlo a la tabla.",
         )
@@ -174,7 +279,8 @@ def judge(plugin: str, backend: str, machine: Machine) -> Verdict:
     gpu = machine.effective_gpu
     if gpu is None:
         return Verdict(
-            False, "❌",
+            False,
+            "❌",
             f"{plugin}/{backend} necesita GPU con {req.min_vram_gb:.0f} GB y aquí no hay NVIDIA.",
             f"Prueba {req.fallback}… en otra máquina, o quédate con voice/piper.",
         )
@@ -182,24 +288,38 @@ def judge(plugin: str, backend: str, machine: Machine) -> Verdict:
     free = gpu.free_gb
     # 0 GB libres es un dato válido (GPU ocupada), no "desconocido": con
     # memoria totalmente ocupada no hay veredicto verde.
-    busy = (f"Ahora mismo solo hay {free:.0f} GB libres en GPU ({gpu.name}); "
-            "cierra lo que la esté usando."
-            if free + 2 < req.min_vram_gb else "")
-    disk_warn = (f"Y ojo al disco: {machine.disk_free_gb:.0f} GB libres para "
-                 f"{req.disk_gb:.0f} GB de pesos."
-                 if machine.disk_free_gb and machine.disk_free_gb < req.disk_gb + 10 else "")
-    ram_warn = (f"RAM justa: {machine.ram_gb:.0f} GB (el offload tira de RAM)."
-                if machine.ram_gb and machine.ram_gb < 8 else "")
+    busy = (
+        f"Ahora mismo solo hay {free:.0f} GB libres en GPU ({gpu.name}); "
+        "cierra lo que la esté usando."
+        if free + 2 < req.min_vram_gb
+        else ""
+    )
+    disk_warn = (
+        f"Y ojo al disco: {machine.disk_free_gb:.0f} GB libres para {req.disk_gb:.0f} GB de pesos."
+        if machine.disk_free_gb and machine.disk_free_gb < req.disk_gb + 10
+        else ""
+    )
+    ram_warn = (
+        f"RAM justa: {machine.ram_gb:.0f} GB (el offload tira de RAM)."
+        if machine.ram_gb and machine.ram_gb < 8
+        else ""
+    )
     if vram >= req.min_vram_gb + 4:
         if busy or disk_warn or ram_warn:
             detail = " ".join(x for x in (busy, disk_warn, ram_warn) if x)
-            return Verdict(True, "⚠️", f"{plugin}/{backend}: cabe con {vram:.0f} GB… si liberas. {req.blurb}", detail)
+            return Verdict(
+                True,
+                "⚠️",
+                f"{plugin}/{backend}: cabe con {vram:.0f} GB… si liberas. {req.blurb}",
+                detail,
+            )
         return Verdict(True, "✅", f"{plugin}/{backend}: sobrado con {vram:.0f} GB. {req.blurb}")
     if vram >= req.min_vram_gb:
         detail = " ".join(x for x in (req.risk, busy, disk_warn, ram_warn) if x)
         return Verdict(True, "⚠️", f"{plugin}/{backend}: cabe justo con {vram:.0f} GB.", detail)
     return Verdict(
-        False, "❌",
+        False,
+        "❌",
         f"{plugin}/{backend} pide {req.min_vram_gb:.0f} GB y tienes {vram:.0f} GB.",
         f"Vete a {req.fallback}." if req.fallback else "Ese motor no es para este PC.",
     )