sergio/takana

1#!/usr/bin/env python3
2# drenar.py — el ORDEN DE MASTICADO: qué construir, en qué orden, para acercar una imagen a estar
3# completa. (P4 del plan docs/plan-catalogo-objetivo.md.)
4#
5# POR QUÉ. La cola de la granja era AUTORÍA: 55 ficheros en `tandas/` escritos a mano, y para la
6# deuda una lista que el hub medía con `saldar-deuda-static.sh` y pegaba en `campana-deuda.sh`. Pero
7# el grafo de estado ya sabe qué falta (`state`), qué lo traba (`blocked_by`) y a cuántos destraba
8# (`unblocks`). Este script convierte eso en la cola: DERIVADA, no escrita.
9#
10# ONDAS. No lista "lo que falta" en un montón: lo parte en ondas topológicas. Onda 1 = construible
11# YA (ninguna dep en deuda). Onda 2 = lo que la onda 1 destraba. Etc. Eso da tres cosas que una
12# lista plana no da: el orden correcto, la PROFUNDIDAD real de la cadena (cuántos pasos secuenciales
13# faltan, que es lo que manda en el reloj de pared), y qué se puede paralelizar sin pisarse.
14# Dentro de cada onda ordena por `unblocks` desc: primero lo que libera más.
15#
16# LA REGLA DE LA FUENTE ÚNICA. Un nodo `wanted` (sin receta) no tiene deps propias; se le miran las
17# SEMBRADAS (`seed-edges.json`, P3). En cuanto tiene receta, manda la receta — ya corregida por el
18# veredicto de harkaq. La semilla es andamio y se cae sola.
19#
20# NO LANZA NADA. Sólo imprime/escribe la cola; construir cuesta € y es decisión explícita
21# (`farm-up` + `campana-deuda.sh`). Ver el pie de la salida.
22#
23# Uso:  scripts/drenar.py --perfil escritorio-kde       # ondas de una imagen
24#       scripts/drenar.py                               # todo el corpus en deuda
25#       scripts/drenar.py --perfil cli --n 20           # sólo las 20 primeras construibles ya
26#       scripts/drenar.py --perfil escritorio-kde --tanda tandas/kde-drenaje.txt
27import json, sys
28from pathlib import Path
29
30ROOT = Path(__file__).resolve().parent.parent
31GRAFOS = ["docs/state/build-state.json", "docs/state/build-state-kde.json",
32          "docs/state/build-state-gnome.json"]
33SEMILLA = ROOT / "docs/state/seed-edges.json"
34EN_DEUDA = ("debt", "never", "unhashable", "wanted")
35
36
37def cargar(perfil):
38    """Elige el grafo por la COLA que el perfil declara en `targets.toml`, no por cuál tiene más
39    nodos. La diferencia importa: la cola `incoming-kde` SOMBREA recetas canónicas, así que medir
40    `escritorio-mirada` contra el grafo KDE mide una imagen que nadie construye. Cada perfil se mide
41    contra el árbol de recetas del que realmente sale."""
42    sys.path.insert(0, str(ROOT / "scripts"))
43    import targets as targets_mod
44    cola = "corpus"
45    if perfil is not None:
46        try:
47            cola = targets_mod.load().get(perfil, {}).get("cola", "corpus")
48        except Exception:
49            pass
50    for f in GRAFOS:
51        p = ROOT / f
52        if not p.exists():
53            continue
54        d = json.loads(p.read_text())
55        if cola not in (d.get("by_queue") or {}):
56            continue
57        # Una cola NO-corpus identifica su grafo unívocamente (incoming-kde/gnome sólo viven en su
58        # propio grafo), así que basta con que la cola coincida. La comprobación por ETIQUETA de perfil
59        # sólo desambigua dentro de `corpus` (donde varios perfiles se solapan). Sin este atajo, un
60        # perfil cuyas RAÍCES aún no están autoradas (0 nodos etiquetados, p.ej. escritorio-gnome
61        # recién arrancado) no hallaba su grafo y drenar erraba "¿corriste build-state.py?" en vez de
62        # reckonar honestamente un perfil todavía sin cierre.
63        if cola != "corpus":
64            return d, f
65        if perfil is None or any(perfil in (r.get("perfiles") or []) for r in d["nodes"].values()):
66            return d, f
67    return None, None
68
69
70def deps_de(nombre, nodo, semilla):
71    """La regla de la fuente única: con receta manda la receta; sin receta (nodo `wanted`) se usan
72    las aristas SEMBRADAS, que son hipótesis y se marcan como tales."""
73    if nodo["state"] != "wanted":
74        return nodo.get("deps") or [], "receta"
75    aristas = (semilla.get("nodos") or {}).get(nombre)
76    if isinstance(aristas, list):
77        return [a["dep"] for a in aristas if a.get("clase") in ("conocida", "frontera")], "semilla"
78    return [], "sin-datos"
79
80
81def ondas_de(perfil):
82    """(ondas, deuda, ambito, grafo) — el cálculo puro, sin imprimir. Reutilizado por --todos."""
83    doc, cual = cargar(perfil)
84    if doc is None:
85        return None, None, None, None
86    semilla = json.loads(SEMILLA.read_text()) if SEMILLA.exists() else {}
87    nodos = doc["nodes"]
88    ambito = {n: r for n, r in nodos.items()
89              if perfil is None or perfil in (r.get("perfiles") or [])}
90    deuda = {n: r for n, r in ambito.items() if r["state"] in EN_DEUDA}
91    restante, ondas = dict(deuda), []
92    while restante:
93        onda = [n for n, r in restante.items()
94                if not any(d in restante for d in deps_de(n, r, semilla)[0])]
95        if not onda:
96            ondas.append(sorted(restante)); break
97        onda.sort(key=lambda n: (-restante[n].get("unblocks", 0), restante[n].get("cls", ""), n))
98        ondas.append(onda)
99        for n in onda:
100            del restante[n]
101    return ondas, deuda, ambito, cual
102
103
104def todos_los_perfiles():
105    """Artefacto versionado con el drenaje de CADA imagen. El `git diff` entre dos corridas es el
106    avance real: qué salió de la deuda y qué onda se vació. Lo regenera el latido de la granja."""
107    sys.path.insert(0, str(ROOT / "scripts"))
108    import targets as targets_mod
109    doc = {"schema": "hammer-drenaje/1",
110           "nota": "DERIVADO del grafo de estado por scripts/drenar.py — no editar a mano.",
111           "perfiles": {}}
112    for p in sorted(targets_mod.load()):
113        ondas, deuda, ambito, cual = ondas_de(p)
114        if ondas is None:
115            continue
116        doc["perfiles"][p] = dict(
117            grafo=cual, nodos=len(ambito), en_deuda=len(deuda), ondas=len(ondas),
118            profundidad=len(ondas), construibles_ya=ondas[0] if ondas else [],
119            olas=[{"n": i + 1, "recetas": o} for i, o in enumerate(ondas)])
120        print(f"   {p:20} {len(deuda):3} en deuda · {len(ondas):2} ondas · "
121              f"onda 1 = {len(ondas[0]) if ondas else 0}")
122    salida = ROOT / "docs/state/drenaje.json"
123    salida.write_text(json.dumps(doc, indent=1, ensure_ascii=False) + "\n")
124    print(f"   → {salida.relative_to(ROOT)}")
125    return 0
126
127
128def main():
129    args = sys.argv[1:]
130    if "--todos" in args:
131        return todos_los_perfiles()
132    perfil = args[args.index("--perfil") + 1] if "--perfil" in args else None
133    tope = int(args[args.index("--n") + 1]) if "--n" in args else None
134    tanda = args[args.index("--tanda") + 1] if "--tanda" in args else None
135
136    doc, cual = cargar(perfil)
137    if doc is None:
138        print(f"no encontré un grafo con el perfil `{perfil}` "
139              f"(¿corriste scripts/build-state.py [--kde]?)", file=sys.stderr)
140        return 1
141    semilla = json.loads(SEMILLA.read_text()) if SEMILLA.exists() else {}
142    nodos = doc["nodes"]
143
144    ambito = {n: r for n, r in nodos.items()
145              if perfil is None or perfil in (r.get("perfiles") or [])}
146    deuda = {n: r for n, r in ambito.items() if r["state"] in EN_DEUDA}
147    etiqueta = f"perfil `{perfil}`" if perfil else "corpus entero"
148    print(f"== drenaje de {etiqueta} ({cual})")
149    print(f"   {len(ambito)} nodos en ámbito · {len(deuda)} en deuda "
150          f"({len(ambito)-len(deuda)} ya sellados)")
151    if perfil is not None and not ambito:
152        # Ámbito vacío = ninguna raíz del perfil está autorada ⇒ el perfil NO tiene cierre todavía
153        # (top-down sin arrancar). Distinto de "completa": completa tendría nodos sellados en ámbito.
154        # Puede haber recetas SUELTAS en la cola (leaves) que ninguna raíz alcanza aún.
155        print(f"   perfil SIN CIERRE todavía: 0 raíces autoradas — autorá desde las raíces "
156              f"declaradas en targets.toml (top-down feature-minimal), no al revés.")
157        return 0
158    if not deuda:
159        print("   nada que drenar: la imagen está completa.")
160        return 0
161
162    # Ondas topológicas sobre el subgrafo EN DEUDA: una receta sólo espera por deps que también
163    # estén en deuda (las selladas ya están en el store y no bloquean).
164    restante = dict(deuda)
165    ondas, procedencia = [], {}
166    while restante:
167        onda = []
168        for n, r in restante.items():
169            ds, origen = deps_de(n, r, semilla)
170            procedencia[n] = origen
171            if not any(d in restante for d in ds):
172                onda.append(n)
173        if not onda:  # ciclo entre nodos en deuda: no debería pasar (topo_ok), pero no se oculta
174            print(f"\n   ⚠ CICLO entre {len(restante)} nodos en deuda: "
175                  f"{' '.join(sorted(restante)[:10])}")
176            ondas.append(sorted(restante))
177            break
178        onda.sort(key=lambda n: (-restante[n].get("unblocks", 0), restante[n].get("cls", ""), n))
179        ondas.append(onda)
180        for n in onda:
181            del restante[n]
182
183    print(f"\n== {len(ondas)} ondas (profundidad real de la cadena; el reloj de pared manda acá)")
184    for i, onda in enumerate(ondas, 1):
185        muestra = onda if tope is None or i > 1 else onda[:tope]
186        cab = f"   onda {i}: {len(onda):3} construibles"
187        if i == 1:
188            cab += "  ← ARRANCÁ POR ACÁ (nada las bloquea)"
189        print(cab)
190        for n in muestra[:25]:
191            r = deuda[n]
192            u = r.get("unblocks", 0)
193            marca = f" [{procedencia[n]}]" if procedencia[n] != "receta" else ""
194            print(f"        {n:28} {r['state']:10} destraba {u:3}  {r.get('cls','')}{marca}")
195        if len(muestra) > 25:
196            print(f"        … y {len(muestra)-25} más")
197
198    primera = ondas[0][:tope] if tope else ondas[0]
199    print(f"\n== cola para el worker ({len(primera)} recetas de la onda 1)")
200    print("   " + " ".join(primera))
201    if tanda:
202        p = ROOT / tanda
203        p.parent.mkdir(parents=True, exist_ok=True)
204        p.write_text(f"# DERIVADA de {cual} por scripts/drenar.py — no editar a mano.\n"
205                     f"# {etiqueta}: onda 1 de {len(ondas)}, ordenada por `unblocks` desc.\n"
206                     + "\n".join(primera) + "\n")
207        print(f"   → {tanda}")
208    print("\n   construir NO es gratis (€): esto no lanza nada. En el worker:")
209    print(f"     scripts/farm/campana-deuda.sh {' '.join(primera[:6])}…")
210    return 0
211
212
213if __name__ == "__main__":
214    sys.exit(main())