@legios/quartermaster 0.1.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (46) hide show
  1. package/LICENSE +21 -0
  2. package/README.md +1276 -0
  3. package/bin/qm +66 -0
  4. package/bin/qm-barra +63 -0
  5. package/bin/qm-barra.swift +1253 -0
  6. package/bin/qm-indicator +2063 -0
  7. package/bin/qm-tray +41 -0
  8. package/bin/qm-tray.ps1 +1241 -0
  9. package/bin/qm-web +137 -0
  10. package/dist/adapters/cache-cuota.js +45 -0
  11. package/dist/adapters/cache-cuota.js.map +1 -0
  12. package/dist/adapters/cache-endpoint.js +66 -0
  13. package/dist/adapters/cache-endpoint.js.map +1 -0
  14. package/dist/adapters/codex.js +462 -0
  15. package/dist/adapters/codex.js.map +1 -0
  16. package/dist/adapters/credenciales.js +88 -0
  17. package/dist/adapters/credenciales.js.map +1 -0
  18. package/dist/adapters/cuota.js +73 -0
  19. package/dist/adapters/cuota.js.map +1 -0
  20. package/dist/adapters/historial.js +103 -0
  21. package/dist/adapters/historial.js.map +1 -0
  22. package/dist/adapters/opencode.js +214 -0
  23. package/dist/adapters/opencode.js.map +1 -0
  24. package/dist/adapters/transcripciones.js +129 -0
  25. package/dist/adapters/transcripciones.js.map +1 -0
  26. package/dist/adapters/utilizacion.js +151 -0
  27. package/dist/adapters/utilizacion.js.map +1 -0
  28. package/dist/cli/demo-h1.js +60 -0
  29. package/dist/cli/demo-h1.js.map +1 -0
  30. package/dist/cli/preflight.js +39 -0
  31. package/dist/cli/preflight.js.map +1 -0
  32. package/dist/cli/qm.js +779 -0
  33. package/dist/cli/qm.js.map +1 -0
  34. package/dist/core/config.js +63 -0
  35. package/dist/core/config.js.map +1 -0
  36. package/dist/core/perfiles.js +139 -0
  37. package/dist/core/perfiles.js.map +1 -0
  38. package/dist/core/proyeccion.js +83 -0
  39. package/dist/core/proyeccion.js.map +1 -0
  40. package/dist/core/tipos.js +101 -0
  41. package/dist/core/tipos.js.map +1 -0
  42. package/dist/render/barras.js +62 -0
  43. package/dist/render/barras.js.map +1 -0
  44. package/dist/render/tablero.html +664 -0
  45. package/package.json +59 -0
  46. package/src/render/tablero.html +664 -0
@@ -0,0 +1,2063 @@
1
+ #!/usr/bin/env python3
2
+ """qm en la barra de arriba de GNOME.
3
+
4
+ Es la parte de "renderizado" que SOUL.md dejaba para después de tener los
5
+ números bien. Dibuja y nada más: le pide el JSON a `qm` y no sabe qué es una
6
+ credencial ni habla HTTP.
7
+
8
+ Tres cosas que lo hacen algo más que un reloj:
9
+
10
+ · Se entera solo. Vigila el .claude.json de cada perfil con Gio.FileMonitor,
11
+ así que cuando Claude Code refresca la cuota el número cambia en el acto en
12
+ vez de esperar al próximo minuto. El sondeo lento queda de red de seguridad.
13
+ · Avisa sin que lo mires. Notifica al cruzar 80 % y 95 %, y cuando la
14
+ proyección pasa a decir que tocás el techo ANTES del reinicio — que es el
15
+ momento útil para enterarte, no cuando ya chocaste.
16
+ · No repite. Cada aviso se recuerda por (perfil, barra, reinicio), así que
17
+ una ventana avisa una vez y vuelve a avisar recién en la siguiente.
18
+
19
+ Requiere el soporte de AppIndicator en GNOME (la extensión
20
+ appindicatorsupport@rgcjonas.gmail.com), que es lo que convierte un
21
+ KStatusNotifierItem en un item de la barra.
22
+ """
23
+
24
+ import json
25
+ import math
26
+ import os
27
+ import pathlib
28
+ import shutil
29
+ import py_compile
30
+ import subprocess
31
+ import sys
32
+ import tempfile
33
+ import time
34
+ from datetime import datetime, timezone
35
+ from pathlib import Path
36
+
37
+ # El panel se abre pegado a la barra, y para eso hay que poder decir DÓNDE va la
38
+ # ventana. En Wayland un cliente no puede: la ubica el compositor, y un panel que
39
+ # aparece en el medio de la pantalla no es el panel que se está copiando. Sobre
40
+ # XWayland sí se puede, y al item de la barra no le cambia nada porque es DBus
41
+ # puro. Si no hay X11 a mano se sigue por Wayland y el panel cae donde caiga.
42
+ if os.environ.get("DISPLAY") and not os.environ.get("QM_SIN_X11"):
43
+ os.environ.setdefault("GDK_BACKEND", "x11")
44
+
45
+ import cairo # noqa: E402
46
+ import gi # noqa: E402
47
+
48
+ gi.require_version("Gtk", "3.0")
49
+ gi.require_version("Pango", "1.0")
50
+ gi.require_version("PangoCairo", "1.0")
51
+ gi.require_version("AyatanaAppIndicator3", "0.1")
52
+ from gi.repository import AyatanaAppIndicator3 as AppIndicator # noqa: E402
53
+ from gi.repository import Gdk, Gio, GLib, Gtk, Pango, PangoCairo # noqa: E402
54
+
55
+
56
+ ID = "quartermaster"
57
+ # Red de seguridad: el FileMonitor es el que manda. Esto sólo cubre el caso de
58
+ # un monitor que se pierda un evento (montajes raros, archivos reemplazados).
59
+ SEGUNDOS_SONDEO = 300
60
+ # Piso para cualquier cadencia que salga a la RED. Claude Code pide la cuota del
61
+ # orden de una vez por sesión; un endpoint no documentado, que además puede
62
+ # desaparecer sin aviso, no es lugar para sondear más rápido que esto. Y la
63
+ # diferencia real es chica: a 1,6 puntos por minuto, 60 s son 1,6 puntos de
64
+ # atraso.
65
+ MINIMO_RED = 60
66
+ # Coalescer escrituras: Claude Code reescribe .claude.json varias veces seguidas.
67
+ DEBOUNCE_MS = 1500
68
+ UMBRALES = (80, 95)
69
+
70
+ # El directorio que comparten este proceso y la extensión de GNOME Shell.
71
+ CACHE = Path(os.environ.get("XDG_CACHE_HOME", str(Path.home() / ".cache"))) / "quartermaster"
72
+ # Lo que se acaba de dibujar, para que la extensión sepa qué mostrar y de qué tamaño.
73
+ ESTADO = CACHE / "estado.json"
74
+ # Mientras exista, la barra la maneja la extensión y este proceso esconde su
75
+ # propio item de AppIndicator: si no, quedan dos items diciendo lo mismo.
76
+ EXTENSION_VIVA = CACHE / "extension-viva"
77
+ # Donde la extensión deja el click.
78
+ PEDIDO = CACHE / "pedido"
79
+ # El panel, dibujado a un PNG para que lo muestre la extensión.
80
+ #
81
+ # Por qué un PNG y no la ventana: un menú de GTK sobre XWayland no logra
82
+ # sostener su agarre contra la actividad real del escritorio. Aislado aguanta
83
+ # minutos; con alguien usando la máquina se cierra a los segundos, y tocarlo
84
+ # para rodarlo lo cierra. Medido tres veces, con tres arquitecturas (ventana con
85
+ # foco, ventana con agarre a mano, y menú de GTK). Adentro de la extensión el
86
+ # panel es un actor del compositor: no hay agarre que romper, no hay XWayland, y
87
+ # rueda y se cierra como cualquier menú del shell.
88
+ # Cuánto se le cree a `extension-viva` sin que lo renueven. La extensión lo
89
+ # toca cada 30 s; el triple da margen para una máquina cargada sin dejar el
90
+ # item escondido más de minuto y medio si del otro lado ya no hay nadie.
91
+ VIVA_SEGUNDOS = 90
92
+
93
+ # Este mismo archivo, resuelto: se instala enlazado desde ~/.local/bin y desde
94
+ # /usr/bin, y hay que vigilar el de verdad, no el enlace.
95
+ YO = pathlib.Path(__file__).resolve()
96
+
97
+ ICONO_OK = "utilities-system-monitor-symbolic"
98
+ ICONO_AVISO = "dialog-warning-symbolic"
99
+ ICONO_GRAVE = "dialog-error-symbolic"
100
+
101
+
102
+ # ── formato ──────────────────────────────────────────────────────────────
103
+ def corto(nombre: str) -> str:
104
+ """`.claude-teams` -> `teams`; el perfil por defecto -> `main`."""
105
+ return nombre.removeprefix(".claude").lstrip("-") or "main"
106
+
107
+
108
+ def faltan(iso: str | None) -> int | None:
109
+ if not iso:
110
+ return None
111
+ try:
112
+ cuando = datetime.fromisoformat(iso.replace("Z", "+00:00"))
113
+ except ValueError:
114
+ return None
115
+ return int((cuando - datetime.now(timezone.utc)).total_seconds())
116
+
117
+
118
+ def al_minuto(iso: str | None) -> str:
119
+ """Un instante ISO recortado al minuto, para usar de clave estable."""
120
+ if not iso:
121
+ return "sin-reinicio"
122
+ try:
123
+ return datetime.fromisoformat(iso.replace("Z", "+00:00")).strftime("%Y-%m-%dT%H:%M")
124
+ except ValueError:
125
+ return iso
126
+
127
+
128
+ def nombre_ventana(v: dict) -> str:
129
+ """El nombre ya viene resuelto; el fallback es por si el JSON es viejo."""
130
+ return v.get("nombre") or (
131
+ v["clave"] if not v.get("alcance") else f"{v['clave']} ({v['alcance']})"
132
+ )
133
+
134
+
135
+ # Acá había un `peor()` y un `mostrables()` reimplementados. Eran la MISMA
136
+ # regla que vive en src/core/tipos.ts, copiada — y llegó a estar copiada tres
137
+ # veces, en Python, JavaScript y Swift. Una regla en tres lenguajes vale
138
+ # distinto en cuanto alguien toca uno solo, y justamente esta es la que evita
139
+ # que un 75 % con aviso quede tapado por un 8 % que se ve más lindo.
140
+ #
141
+ # Ahora `qm --json` manda `mostrar`, `frena`, `sesion` y `semanal` ya resueltas
142
+ # y esto sólo dibuja, que es lo que dice el docstring de arriba de todo.
143
+
144
+
145
+ # ── el panel ─────────────────────────────────────────────────────────────
146
+ # GNOME no deja dibujar adentro del menú de la barra: la extensión que convierte
147
+ # un KStatusNotifierItem en un item de arriba manda los renglones por DBus y del
148
+ # otro lado hace `label.set_text(...)` — texto pelado, sin markup — y los iconos
149
+ # los mete en un St.Icon de 16 px. O sea que ni colores ni medidores ni curvas
150
+ # entran ahí. Lo que sí se puede es abrir una ventana propia y dibujarla, que es
151
+ # lo que hace esto: las mismas dos vistas del panel de macOS (bin/qm-barra.swift,
152
+ # VistaResumen y VistaCuenta), con las mismas medidas y la misma paleta.
153
+ #
154
+ # Va por X11 (XWayland) a propósito: en Wayland un cliente no puede elegir dónde
155
+ # se pone su ventana, y un panel que aparece en el medio de la pantalla en vez de
156
+ # abajo del ícono no es el panel de macOS. Con GDK_BACKEND=x11 el move() manda.
157
+
158
+ # El panel es más ancho y más aireado que el de macOS: la tipografía de GNOME
159
+ # —Cantarell— es más grande de cuerpo que la del sistema de Apple, y con las
160
+ # medidas de allá los renglones quedaban apretados y el texto rozando el borde.
161
+ ANCHO_PANEL = 360
162
+ MARGEN = 12
163
+ # Cada cuenta va en una tarjeta redondeada, que es como GNOME agrupa cosas
164
+ # (la «boxed list» de libadwaita), en vez de la línea de pelo que separa las
165
+ # secciones en macOS.
166
+ PAD_TARJETA = 14
167
+ RADIO_TARJETA = 12
168
+ ENTRE_TARJETAS = 8
169
+ ALTO_CABECERA = 76
170
+ # El renglón de abajo de todo: cuándo vuelve a preguntar.
171
+ ALTO_PIE_LECTURA = 26
172
+ VIEJO_SEGUNDOS = 6 * 3600
173
+
174
+
175
+ def _hex(c: str, alfa: float = 1.0):
176
+ return (int(c[1:3], 16) / 255, int(c[3:5], 16) / 255, int(c[5:7], 16) / 255, alfa)
177
+
178
+
179
+ # La paleta de estado es la de GNOME (Adwaita), no la de macOS: son los mismos
180
+ # cuatro estados, con los colores que el escritorio ya usa para decirlos, y con
181
+ # la variante que cada fondo pide — un verde que se lee sobre blanco se apaga
182
+ # sobre negro y al revés.
183
+ NIVELES_CLARO = {"ok": "#26a269", "atento": "#e5a50a", "aviso": "#ff7800", "critico": "#c01c28"}
184
+ NIVELES_OSCURO = {"ok": "#33d17a", "atento": "#f6d32d", "aviso": "#ffa348", "critico": "#f66151"}
185
+ # El color de cada cuenta, deliberadamente lejos de la paleta de estado: verde,
186
+ # ámbar y rojo ya significan algo y no pueden significar además «cuenta 2». Azul,
187
+ # violeta y rosa no se confunden con «vas bien» ni con «te frenaste».
188
+ CUENTAS_CLARO = ["#1c71d8", "#813d9c", "#c9208a"]
189
+ CUENTAS_OSCURO = ["#62a0ea", "#c061cb", "#ed67b0"]
190
+
191
+
192
+ def nivel_de(pct: float, preocupa: bool) -> str:
193
+ if pct >= 95:
194
+ return "critico"
195
+ if preocupa or pct >= 80:
196
+ return "aviso"
197
+ if pct >= 60:
198
+ return "atento"
199
+ return "ok"
200
+
201
+
202
+ def duracion(segundos: int) -> str:
203
+ """La escalera de duración del proyecto.
204
+
205
+ El canon es `duracion()` en src/render/barras.ts, que es por donde pasa todo
206
+ lo que imprime el CLI, y está congelado en test/fixtures/duraciones.json.
207
+ Las cuatro implementaciones —ésta, la de TypeScript, la de Swift y la de
208
+ PowerShell— tienen que dar exactamente lo mismo, y `make gate-duraciones` lo
209
+ comprueba corriéndolas, no leyéndolas.
210
+
211
+ Había dos convenciones conviviendo: las tres GUIs decían `ya`, `1h` y `1d0h`
212
+ donde el CLI decía `vencido`, `1h00m` y `1d`. Sobrevivió porque nadie había
213
+ comparado una GUI contra el CLI. Ganó el CLI: es donde el propio repo dice
214
+ que pasa todo lo que se imprime, y es la única con tests.
215
+ """
216
+ if segundos < 0:
217
+ return "vencido"
218
+ h, m = segundos // 3600, (segundos % 3600) // 60
219
+ if h >= 24:
220
+ d = h // 24
221
+ return f"{d}d" if h % 24 == 0 else f"{d}d{h % 24}h"
222
+ if h > 0:
223
+ return f"{h}h{m:02d}m"
224
+ if m > 0:
225
+ return f"{m}m"
226
+ return f"{segundos}s"
227
+
228
+
229
+ def cuenta_regresiva(segundos: float) -> str:
230
+ """Como dur_larga, pero sin tirar los segundos abajo de la hora.
231
+
232
+ dur_larga habla de duraciones que se reportan —«reinicia en 2d14h»— y ahí
233
+ los segundos son ruido. Esto es un reloj que baja a la vista: si dijera sólo
234
+ los minutos cambiaría una vez por minuto, y una cuenta regresiva que no se
235
+ mueve no parece una cuenta regresiva, parece un número roto.
236
+ """
237
+ seg = max(0, int(segundos))
238
+ if seg >= 3600:
239
+ return duracion(seg)
240
+ if seg >= 60:
241
+ return f"{seg // 60}m {seg % 60:02d}s"
242
+ return f"{seg}s"
243
+
244
+
245
+ def cada_cuanto(historia: list) -> float | None:
246
+ """Cada cuánto se lee la cuota de verdad, en segundos.
247
+
248
+ No es la cadencia que este programa se propone: es la MEDIDA. El historial
249
+ se indexa por `medidoEn` —el instante que informa el servidor, no el momento
250
+ en que qm miró el disco— así que cada muestra es una lectura real y los
251
+ huecos entre muestras son los intervalos entre lectura y lectura. Va la
252
+ mediana y no el promedio: una sola pausa larga (la máquina suspendida, por
253
+ ejemplo) desplaza el promedio y no dice nada del ritmo normal.
254
+ """
255
+ ts = sorted(t for t, _ in historia)
256
+ huecos = sorted(b - a for a, b in zip(ts, ts[1:]) if b > a)
257
+ if not huecos:
258
+ return None
259
+ return huecos[len(huecos) // 2] / 1000
260
+
261
+
262
+ def reinicio(segundos: int | None) -> str:
263
+ """«reinicia en vencido» no es castellano. Cuando ya pasó, se dice que pasó."""
264
+ if segundos is None:
265
+ return ""
266
+ return "reinicio vencido" if segundos < 0 else f"reinicia en {duracion(segundos)}"
267
+
268
+
269
+ class Tema:
270
+ """Los dos fondos posibles, con los grises de GNOME.
271
+
272
+ El panel vive adentro de un menú de GTK, así que el fondo y la sombra los
273
+ pone el tema del escritorio: acá sólo se define lo que se dibuja encima.
274
+ """
275
+
276
+ def __init__(self, oscuro: bool) -> None:
277
+ self.oscuro = oscuro
278
+ if oscuro:
279
+ self.etiqueta = _hex("#ffffff")
280
+ self.secundario = _hex("#ffffff", 0.70)
281
+ self.terciario = _hex("#ffffff", 0.45)
282
+ self.tarjeta = _hex("#ffffff", 0.06)
283
+ self.borde_tarjeta = _hex("#ffffff", 0.08)
284
+ self.pista = _hex("#ffffff", 0.15)
285
+ else:
286
+ self.etiqueta = _hex("#000000", 0.87)
287
+ self.secundario = _hex("#000000", 0.65)
288
+ self.terciario = _hex("#000000", 0.45)
289
+ self.tarjeta = _hex("#000000", 0.04)
290
+ self.borde_tarjeta = _hex("#000000", 0.07)
291
+ self.pista = _hex("#000000", 0.15)
292
+
293
+ @staticmethod
294
+ def desde(widget) -> "Tema":
295
+ """El tema que de verdad tiene el widget que va abajo del dibujo.
296
+
297
+ Preguntarle a un ajuste y dibujar sobre otra cosa es exactamente cómo el
298
+ panel terminó blanco sobre blanco. El color de texto del propio menú no
299
+ puede mentir: si es claro, el fondo es oscuro.
300
+ """
301
+ try:
302
+ c = widget.get_style_context().get_color(Gtk.StateFlags.NORMAL)
303
+ luz = 0.2126 * c.red + 0.7152 * c.green + 0.0722 * c.blue
304
+ tema = Tema(luz > 0.5)
305
+ # Y los grises salen de ESE color, no de un blanco o un negro
306
+ # supuestos: así el contraste es el que el tema ya eligió.
307
+ base = (c.red, c.green, c.blue)
308
+ tema.etiqueta = base + (1.0,)
309
+ tema.secundario = base + (0.72,)
310
+ tema.terciario = base + (0.46,)
311
+ tema.tarjeta = base + (0.06,)
312
+ tema.borde_tarjeta = base + (0.10,)
313
+ tema.pista = base + (0.16,)
314
+ return tema
315
+ except (AttributeError, TypeError):
316
+ return tema_actual()
317
+
318
+ def nivel(self, clave: str):
319
+ return _hex((NIVELES_OSCURO if self.oscuro else NIVELES_CLARO)[clave])
320
+
321
+ def color_cuenta(self, i: int):
322
+ tabla = CUENTAS_OSCURO if self.oscuro else CUENTAS_CLARO
323
+ return _hex(tabla[i % len(tabla)])
324
+
325
+
326
+ def prefiere_oscuro() -> bool | None:
327
+ """Lo que dice GNOME, o None si no lo dice."""
328
+ try:
329
+ fuente = Gio.SettingsSchemaSource.get_default()
330
+ esquema = fuente.lookup("org.gnome.desktop.interface", True) if fuente else None
331
+ if esquema is not None and esquema.has_key("color-scheme"):
332
+ v = Gio.Settings.new("org.gnome.desktop.interface").get_string("color-scheme")
333
+ if v == "prefer-dark":
334
+ return True
335
+ if v == "prefer-light":
336
+ return False
337
+ except (GLib.Error, AttributeError, TypeError):
338
+ pass
339
+ return None
340
+
341
+
342
+ def alinear_tema_gtk() -> None:
343
+ """Que GTK3 se entere de que GNOME está en oscuro.
344
+
345
+ Esto no es cosmética, es el bug que dejaba el panel ilegible: GNOME dice
346
+ `color-scheme = prefer-dark` y el dibujo se pintaba con letras blancas, pero
347
+ una app GTK3 no se entera sola —su `gtk-application-prefer-dark-theme` sigue
348
+ en False— así que el menú que hace de fondo se dibujaba CLARO. Blanco sobre
349
+ blanco, y no se leía nada.
350
+ """
351
+ oscuro = prefiere_oscuro()
352
+ if oscuro is None:
353
+ return
354
+ try:
355
+ Gtk.Settings.get_default().set_property("gtk-application-prefer-dark-theme", oscuro)
356
+ except (AttributeError, TypeError):
357
+ pass
358
+
359
+
360
+ def tema_actual() -> Tema:
361
+ oscuro = prefiere_oscuro()
362
+ if oscuro is not None:
363
+ return Tema(oscuro)
364
+ try:
365
+ cfg = Gtk.Settings.get_default()
366
+ if cfg.get_property("gtk-application-prefer-dark-theme"):
367
+ return Tema(True)
368
+ return Tema("dark" in (cfg.get_property("gtk-theme-name") or "").lower())
369
+ except (AttributeError, TypeError):
370
+ return Tema(True)
371
+
372
+
373
+ def familia_del_sistema() -> str:
374
+ """La tipografía de la interfaz, sin el cuerpo que trae pegado."""
375
+ try:
376
+ nombre = Gtk.Settings.get_default().get_property("gtk-font-name") or ""
377
+ except (AttributeError, TypeError):
378
+ nombre = ""
379
+ fd = Pango.FontDescription(nombre) if nombre else Pango.FontDescription()
380
+ return fd.get_family() or "Cantarell"
381
+
382
+
383
+ # Se resuelven en main(), cuando Gtk ya leyó los ajustes del escritorio.
384
+ TEMA = Tema(True)
385
+ FAMILIA = "Cantarell"
386
+
387
+
388
+ # ── dibujo ───────────────────────────────────────────────────────────────
389
+ def _color(cr, c) -> None:
390
+ cr.set_source_rgba(c[0], c[1], c[2], c[3] if len(c) > 3 else 1.0)
391
+
392
+
393
+ def _redondeado(cr, x, y, w, h, r) -> None:
394
+ r = min(r, w / 2, h / 2)
395
+ cr.new_sub_path()
396
+ cr.arc(x + w - r, y + r, r, -math.pi / 2, 0)
397
+ cr.arc(x + w - r, y + h - r, r, 0, math.pi / 2)
398
+ cr.arc(x + r, y + h - r, r, math.pi / 2, math.pi)
399
+ cr.arc(x + r, y + r, r, math.pi, 3 * math.pi / 2)
400
+ cr.close_path()
401
+
402
+
403
+ class Pluma:
404
+ """Texto en píxeles, no en puntos.
405
+
406
+ Las medidas del panel de macOS son píxeles a 1x. Pango, si le pasás un
407
+ cuerpo en puntos, lo convierte a 96 dpi y un 13 se vuelve 17: el panel
408
+ entero queda un tercio más grande y los renglones se pisan. Por eso todo
409
+ va por set_absolute_size().
410
+ """
411
+
412
+ def __init__(self, cr, familia: str) -> None:
413
+ self.cr = cr
414
+ self.familia = familia
415
+
416
+ def caja(self, texto: str, px: float, peso=Pango.Weight.NORMAL, ancho=None,
417
+ tabular=False, elipsis=False):
418
+ lay = PangoCairo.create_layout(self.cr)
419
+ fd = Pango.FontDescription()
420
+ fd.set_family(self.familia)
421
+ fd.set_weight(peso)
422
+ fd.set_absolute_size(px * Pango.SCALE)
423
+ lay.set_font_description(fd)
424
+ if tabular:
425
+ # Cifras de ancho fijo: sin esto el porcentaje, que va pegado al
426
+ # borde derecho, baila un píxel cada vez que cambia un dígito.
427
+ try:
428
+ attrs = Pango.AttrList()
429
+ attrs.insert(Pango.attr_font_features_new("tnum=1"))
430
+ lay.set_attributes(attrs)
431
+ except (AttributeError, TypeError):
432
+ pass
433
+ if ancho is not None:
434
+ lay.set_width(int(ancho * Pango.SCALE))
435
+ if elipsis:
436
+ # Un renglón que no se puede achicar: se corta con puntos.
437
+ # Cairo no recorta nada por su cuenta, así que sin esto un
438
+ # nombre de perfil largo se dibuja por encima del borde de la
439
+ # tarjeta y sale del panel.
440
+ lay.set_single_paragraph_mode(True)
441
+ lay.set_ellipsize(Pango.EllipsizeMode.END)
442
+ else:
443
+ lay.set_wrap(Pango.WrapMode.WORD_CHAR)
444
+ lay.set_text(texto, -1)
445
+ return lay
446
+
447
+ def alto(self, *a, **k) -> float:
448
+ return self.caja(*a, **k).get_pixel_size()[1]
449
+
450
+ def ancho(self, *a, **k) -> float:
451
+ return self.caja(*a, **k).get_pixel_size()[0]
452
+
453
+ def escribir(self, x, y, texto, px, color, peso=Pango.Weight.NORMAL,
454
+ derecha=None, ancho=None, tabular=False, elipsis=False):
455
+ lay = self.caja(texto, px, peso, ancho=ancho, tabular=tabular, elipsis=elipsis)
456
+ w, h = lay.get_pixel_size()
457
+ _color(self.cr, color)
458
+ self.cr.move_to(derecha - w if derecha is not None else x, y)
459
+ PangoCairo.show_layout(self.cr, lay)
460
+ return h
461
+
462
+ def linea_base(self, texto: str, px: float, peso=Pango.Weight.NORMAL) -> float:
463
+ return self.caja(texto, px, peso).get_baseline() / Pango.SCALE
464
+
465
+
466
+ def glifo_producto(cr, producto: str, color, x: float, y: float, lado: float) -> None:
467
+ """La marca de cada producto, dibujada: ni Claude ni Codex tienen ícono en
468
+ ningún tema. El asterisco es la forma de la de Claude; los chevrones, código.
469
+ """
470
+ cx, cy = x + lado / 2, y + lado / 2
471
+ cr.save()
472
+ cr.set_line_width(1.3)
473
+ cr.set_line_cap(cairo.LINE_CAP_ROUND)
474
+ _color(cr, color)
475
+ if producto == "opencode":
476
+ r0 = lado * 0.34
477
+ cr.move_to(cx, cy - r0)
478
+ cr.line_to(cx + r0, cy)
479
+ cr.line_to(cx, cy + r0)
480
+ cr.line_to(cx - r0, cy)
481
+ cr.close_path()
482
+ elif producto == "codex":
483
+ a, hueco = lado * 0.30, lado * 0.20
484
+ cr.move_to(cx - hueco, cy - a)
485
+ cr.line_to(cx - hueco - a * 0.85, cy)
486
+ cr.line_to(cx - hueco, cy + a)
487
+ cr.move_to(cx + hueco, cy - a)
488
+ cr.line_to(cx + hueco + a * 0.85, cy)
489
+ cr.line_to(cx + hueco, cy + a)
490
+ else:
491
+ r0 = lado * 0.36
492
+ for k in range(3):
493
+ ang = k * math.pi / 3
494
+ cr.move_to(cx + r0 * math.cos(ang), cy + r0 * math.sin(ang))
495
+ cr.line_to(cx - r0 * math.cos(ang), cy - r0 * math.sin(ang))
496
+ cr.stroke()
497
+ cr.restore()
498
+
499
+
500
+ # ── lo que se dibuja de cada cuenta ──────────────────────────────────────
501
+ class VistaCuenta:
502
+ """Una cuenta del panel, en su tarjeta: cabecera, un renglón por barra, la
503
+ curva pegada a la que frena, y el ritmo. Mide primero y dibuja después,
504
+ porque el menú necesita el alto antes de que exista nada.
505
+ """
506
+
507
+ # Un renglón de barra = nombre (18) + medidor (11) + pie (16). Si esto no
508
+ # coincide con lo que dibuja pintar(), los renglones se pisan.
509
+ ALTO_BARRA = 45
510
+ # 18 de curva + 16 de rótulos.
511
+ ALTO_CURVA = 34
512
+
513
+ def __init__(self, p: dict, indice_color: int) -> None:
514
+ cuota = p.get("cuota") or {}
515
+ self.producto = p.get("producto") or "claude"
516
+ self.indice_color = indice_color
517
+ self.titulo = corto(p.get("perfil") or "?")
518
+ partes = [x for x in (p.get("cuenta"), p.get("plan")) if x]
519
+ self.sub = " · ".join(partes)
520
+ self.hay_numero = cuota.get("estado") == "ok"
521
+ self.frase = None if self.hay_numero else (cuota.get("frase") or "sin cuota")
522
+ self.historia = [
523
+ (m["t"], m["porcentaje"])
524
+ for m in (cuota.get("historia") or [])
525
+ if "t" in m and "porcentaje" in m
526
+ ]
527
+ frena = cuota.get("frena")
528
+ self.clave_frena = frena.get("nombre") if frena else None
529
+ proy = p.get("proyeccion")
530
+ sube = bool(proy and proy.get("estado") == "sube")
531
+ choca = bool(sube and proy.get("chocasAntesDelReinicio"))
532
+ edad = cuota.get("edadSegundos")
533
+
534
+ self.barras = []
535
+ for v in (cuota.get("mostrar") or []) if self.hay_numero else []:
536
+ pie = reinicio(faltan(v.get("reinicia")))
537
+ es_la_que_frena = bool(frena and v.get("clave") == frena.get("clave"))
538
+ self.barras.append({
539
+ "nombre": nombre_ventana(v),
540
+ "pct": v.get("porcentaje", 0),
541
+ "nivel": nivel_de(v.get("porcentaje", 0),
542
+ v.get("preocupa", False) or (choca and es_la_que_frena)),
543
+ "activa": bool(v.get("activa")),
544
+ "pie": pie,
545
+ })
546
+
547
+ self.ritmo = None
548
+ if sube:
549
+ seg = faltan(proy.get("techo"))
550
+ # Una proyección con el techo en el pasado ya no proyecta nada: se
551
+ # leía «100 % en vencido», que no quiere decir nada. Cuando ya
552
+ # tocaste el techo la pregunta es cuándo te liberás, y ésa la
553
+ # contesta la cabecera.
554
+ if seg is not None and seg > 0:
555
+ self.ritmo = (f"{proy.get('ritmoPuntosPorHora', 0):.1f} pts/h · 100 % en "
556
+ f"{duracion(seg)}"
557
+ + (" — antes del reinicio" if choca else ""))
558
+ self.ritmo_rojo = choca
559
+
560
+ # Cada cuánto se lee ESTA cuenta y cuándo fue la última: la pregunta
561
+ # «¿este número de cuándo es?» no se contesta con un porcentaje.
562
+ self.lecturas = None
563
+ if self.hay_numero:
564
+ partes = []
565
+ cada = cada_cuanto(self.historia)
566
+ if cada is not None:
567
+ partes.append(f"cada ~{duracion(int(cada))}")
568
+ if edad is not None:
569
+ partes.append(f"última hace {duracion(edad)}"
570
+ + (" · viejo" if edad >= VIEJO_SEGUNDOS else ""))
571
+ self.lecturas = "lecturas: " + " · ".join(partes) if partes else None
572
+
573
+ @staticmethod
574
+ def _ancho_contenido() -> float:
575
+ return ANCHO_PANEL - 2 * MARGEN - 2 * PAD_TARJETA
576
+
577
+ def medir(self, pluma: Pluma) -> float:
578
+ alto = PAD_TARJETA + 20 + (17 if self.sub else 0) + 6
579
+ if self.frase is not None:
580
+ return alto + pluma.alto(self.frase, 11.5, ancho=self._ancho_contenido()) + PAD_TARJETA
581
+ alto += len(self.barras) * self.ALTO_BARRA
582
+ if self.clave_frena and len(self.historia) >= 3:
583
+ alto += self.ALTO_CURVA
584
+ if self.ritmo:
585
+ alto += 20
586
+ if self.lecturas:
587
+ alto += 17
588
+ return alto + PAD_TARJETA - 4
589
+
590
+ def _curva(self, cr, pluma, caja, color) -> None:
591
+ """Las muestras recientes, dibujadas. El eje Y va del mínimo al máximo
592
+ de la serie y no de 0 a 100: lo que interesa acá es la PENDIENTE, y a
593
+ escala completa una subida de tres puntos se ve plana."""
594
+ x0, y0, w, h = caja
595
+ ts = [m[0] for m in self.historia]
596
+ ps = [float(m[1]) for m in self.historia]
597
+ t_min, t_max = min(ts), max(ts)
598
+ p_min, p_max = min(ps), max(ps)
599
+ if t_max <= t_min:
600
+ return
601
+ rango = max(1.0, p_max - p_min)
602
+ px = lambda t: x0 + w * (t - t_min) / (t_max - t_min)
603
+ py = lambda p: y0 + h - h * (p - p_min) / rango
604
+
605
+ cr.move_to(px(ts[0]), y0 + h)
606
+ for t, p in zip(ts, ps):
607
+ cr.line_to(px(t), py(p))
608
+ cr.line_to(px(ts[-1]), y0 + h)
609
+ cr.close_path()
610
+ _color(cr, color[:3] + (0.16,))
611
+ cr.fill()
612
+
613
+ cr.set_line_width(1.5)
614
+ cr.set_line_join(cairo.LINE_JOIN_ROUND)
615
+ cr.move_to(px(ts[0]), py(ps[0]))
616
+ for t, p in list(zip(ts, ps))[1:]:
617
+ cr.line_to(px(t), py(p))
618
+ _color(cr, color)
619
+ cr.stroke()
620
+
621
+ cr.arc(px(ts[-1]), py(ps[-1]), 2.5, 0, 2 * math.pi)
622
+ _color(cr, color)
623
+ cr.fill()
624
+
625
+ horas = (t_max - t_min) / 3_600_000
626
+ pluma.escribir(x0, y0 + h + 2, f"{p_min:.0f}%", 9.5, TEMA.terciario)
627
+ pluma.escribir(0, y0 + h + 2,
628
+ f"últimas {horas:.1f} h" if horas >= 1 else "última hora",
629
+ 9.5, TEMA.terciario, derecha=x0 + w)
630
+
631
+ def pintar(self, cr, pluma: Pluma, arriba: float) -> float:
632
+ alto = self.medir(pluma)
633
+ # La tarjeta: así agrupa GNOME, con una caja redondeada y un fondo
634
+ # apenas distinto, en vez de la línea de pelo de macOS.
635
+ _redondeado(cr, MARGEN + 0.5, arriba + 0.5,
636
+ ANCHO_PANEL - 2 * MARGEN - 1, alto - 1, RADIO_TARJETA)
637
+ _color(cr, TEMA.tarjeta)
638
+ cr.fill_preserve()
639
+ _color(cr, TEMA.borde_tarjeta)
640
+ cr.set_line_width(1)
641
+ cr.stroke()
642
+
643
+ ix = MARGEN + PAD_TARJETA
644
+ ancho = self._ancho_contenido()
645
+ der = ix + ancho
646
+ y = arriba + PAD_TARJETA
647
+
648
+ glifo_producto(cr, self.producto, TEMA.color_cuenta(self.indice_color), ix, y + 2, 14)
649
+ pluma.escribir(ix + 21, y, self.titulo, 13.5, TEMA.etiqueta, Pango.Weight.BOLD,
650
+ ancho=ancho - 21, elipsis=True)
651
+ y += 20
652
+ if self.sub:
653
+ pluma.escribir(ix + 21, y, self.sub, 11, TEMA.terciario,
654
+ ancho=ancho - 21, elipsis=True)
655
+ y += 17
656
+ y += 6
657
+
658
+ if self.frase is not None:
659
+ pluma.escribir(ix, y, self.frase, 11.5, TEMA.secundario, ancho=ancho)
660
+ return arriba + alto
661
+
662
+ for b in self.barras:
663
+ nombre = f"{b['nombre']} ▸" if b["activa"] else b["nombre"]
664
+ cifra = f"{b['pct']:.0f}%"
665
+ # El nombre cede: el número es el dato y nunca se recorta.
666
+ hueco = ancho - pluma.ancho(cifra, 12, Pango.Weight.BOLD, tabular=True) - 12
667
+ pluma.escribir(ix, y, nombre, 11.5,
668
+ TEMA.etiqueta if b["activa"] else TEMA.secundario,
669
+ Pango.Weight.MEDIUM if b["activa"] else Pango.Weight.NORMAL,
670
+ ancho=hueco, elipsis=True)
671
+ pluma.escribir(0, y - 0.5, cifra, 12, TEMA.etiqueta,
672
+ Pango.Weight.BOLD, derecha=der, tabular=True)
673
+ y += 18
674
+ # El medidor: pista tenue y relleno con el color del estado.
675
+ _redondeado(cr, ix, y, ancho, 5, 2.5)
676
+ _color(cr, TEMA.pista)
677
+ cr.fill()
678
+ lleno = max(5.0, ancho * max(0.0, min(100.0, b["pct"])) / 100.0)
679
+ _redondeado(cr, ix, y, lleno, 5, 2.5)
680
+ _color(cr, TEMA.nivel(b["nivel"]))
681
+ cr.fill()
682
+ y += 11
683
+ if b["pie"]:
684
+ pluma.escribir(ix, y, b["pie"], 10.5, TEMA.terciario, ancho=ancho, elipsis=True)
685
+ y += 16
686
+ # La curva va pegada a la barra que frena: es de ella.
687
+ if b["nombre"] == self.clave_frena and len(self.historia) >= 3:
688
+ self._curva(cr, pluma, (ix, y - 2, ancho, 18), TEMA.nivel(b["nivel"]))
689
+ y += self.ALTO_CURVA
690
+
691
+ if self.ritmo:
692
+ y += 4
693
+ pluma.escribir(ix, y, self.ritmo, 11,
694
+ TEMA.nivel("critico") if self.ritmo_rojo else TEMA.terciario,
695
+ Pango.Weight.MEDIUM if self.ritmo_rojo else Pango.Weight.NORMAL,
696
+ ancho=ancho, elipsis=True)
697
+ y += 16
698
+ if self.lecturas:
699
+ if not self.ritmo:
700
+ y += 4
701
+ pluma.escribir(ix, y, self.lecturas, 10.5, TEMA.terciario, ancho=ancho, elipsis=True)
702
+ return arriba + alto
703
+
704
+
705
+ class VistaSinCuota:
706
+ """Las cuentas que todavía no tienen número, juntas en una tarjeta.
707
+
708
+ Cada una ocupaba una tarjeta entera para decir la misma frase, y el panel
709
+ —que en una pantalla de 768 px ya no entra— gastaba doscientos píxeles en
710
+ repetirla. Juntas además se leen mejor: no son tres misterios distintos,
711
+ es un hecho con varios nombres.
712
+ """
713
+
714
+ def __init__(self, cuentas: list[tuple[str, str]]) -> None:
715
+ # Agrupadas por frase y en el orden en que aparecieron: dos cuentas
716
+ # pueden estar calladas por motivos distintos, y ahí la frase importa.
717
+ self.grupos: list[tuple[str, list[str]]] = []
718
+ for nombre, frase in cuentas:
719
+ for f, nombres in self.grupos:
720
+ if f == frase:
721
+ nombres.append(nombre)
722
+ break
723
+ else:
724
+ self.grupos.append((frase, [nombre]))
725
+
726
+ @staticmethod
727
+ def _ancho_contenido() -> float:
728
+ return ANCHO_PANEL - 2 * MARGEN - 2 * PAD_TARJETA
729
+
730
+ def medir(self, pluma: Pluma) -> float:
731
+ alto = PAD_TARJETA
732
+ for frase, nombres in self.grupos:
733
+ alto += 18 + pluma.alto(frase, 10.5, ancho=self._ancho_contenido()) + 8
734
+ return alto + PAD_TARJETA - 8
735
+
736
+ def pintar(self, cr, pluma: Pluma, arriba: float) -> float:
737
+ alto = self.medir(pluma)
738
+ _redondeado(cr, MARGEN + 0.5, arriba + 0.5,
739
+ ANCHO_PANEL - 2 * MARGEN - 1, alto - 1, RADIO_TARJETA)
740
+ _color(cr, TEMA.tarjeta)
741
+ cr.fill_preserve()
742
+ _color(cr, TEMA.borde_tarjeta)
743
+ cr.set_line_width(1)
744
+ cr.stroke()
745
+
746
+ ix = MARGEN + PAD_TARJETA
747
+ y = arriba + PAD_TARJETA
748
+ for frase, nombres in self.grupos:
749
+ pluma.escribir(ix, y, " · ".join(nombres), 11.5, TEMA.secundario,
750
+ Pango.Weight.MEDIUM, ancho=self._ancho_contenido(), elipsis=True)
751
+ y += 18
752
+ y += pluma.escribir(ix, y, frase, 10.5, TEMA.terciario,
753
+ ancho=self._ancho_contenido())
754
+ y += 8
755
+ return arriba + alto
756
+
757
+
758
+ class VistaResumen:
759
+ """La cabecera: la respuesta de una línea. La misma pregunta que contesta el
760
+ héroe del tablero —qué me frena primero, en toda la máquina— y que si no
761
+ está acá hay que sacarla comparando las cuentas a ojo."""
762
+
763
+ def __init__(self, cuenta: str, barra: str, pct: float, nivel: str, reinicia) -> None:
764
+ self.cuenta, self.barra, self.pct = cuenta, barra, pct
765
+ self.nivel, self.reinicia = nivel, reinicia
766
+
767
+ @staticmethod
768
+ def desde(perfiles: list) -> "VistaResumen | None":
769
+ mejor = None
770
+ for p in perfiles:
771
+ cuota = p.get("cuota") or {}
772
+ if cuota.get("estado") != "ok":
773
+ continue
774
+ v = cuota.get("frena")
775
+ if v and (mejor is None or v["porcentaje"] > mejor[1]["porcentaje"]):
776
+ mejor = (p, v)
777
+ if mejor is None:
778
+ return None
779
+ p, v = mejor
780
+ proy = p.get("proyeccion")
781
+ choca = bool(proy and proy.get("estado") == "sube" and proy.get("chocasAntesDelReinicio"))
782
+ return VistaResumen(corto(p.get("perfil") or "?"), nombre_ventana(v), v["porcentaje"],
783
+ nivel_de(v["porcentaje"], v.get("preocupa", False) or choca),
784
+ v.get("reinicia"))
785
+
786
+ def pintar(self, cr, pluma: Pluma, arriba: float) -> float:
787
+ color = TEMA.nivel(self.nivel)
788
+ lado = 46.0
789
+ izq = MARGEN + 6
790
+ centro = (izq + lado / 2, arriba + ALTO_CABECERA / 2 - 2)
791
+ radio = lado / 2 - 3
792
+
793
+ cr.set_line_width(5.5)
794
+ cr.set_line_cap(cairo.LINE_CAP_BUTT)
795
+ cr.arc(centro[0], centro[1], radio, 0, 2 * math.pi)
796
+ _color(cr, color[:3] + (0.20,))
797
+ cr.stroke()
798
+
799
+ frac = max(0.0, min(100.0, self.pct)) / 100.0
800
+ if frac > 0:
801
+ cr.set_line_cap(cairo.LINE_CAP_ROUND)
802
+ cr.arc(centro[0], centro[1], radio, -math.pi / 2, -math.pi / 2 + 2 * math.pi * frac)
803
+ _color(cr, color)
804
+ cr.stroke()
805
+
806
+ x = izq + lado + 14
807
+ pluma.escribir(x, arriba + 12, "Lo primero que te frena", 10.5, TEMA.terciario,
808
+ Pango.Weight.SEMIBOLD, ancho=ANCHO_PANEL - MARGEN - x, elipsis=True)
809
+ cifra = f"{self.pct:.0f}%"
810
+ y_cifra = arriba + 26
811
+ ancho_cifra = pluma.ancho(cifra, 22, Pango.Weight.BOLD, tabular=True)
812
+ pluma.escribir(x, y_cifra, cifra, 22, TEMA.etiqueta, Pango.Weight.BOLD, tabular=True)
813
+ # El nombre va a la derecha de la cifra, sobre su misma línea de base.
814
+ corrimiento = (pluma.linea_base(cifra, 22, Pango.Weight.BOLD)
815
+ - pluma.linea_base("x", 12))
816
+ pluma.escribir(x + ancho_cifra + 8, y_cifra + corrimiento,
817
+ f"{self.cuenta} · {self.barra}", 12, TEMA.secundario,
818
+ ancho=ANCHO_PANEL - MARGEN - (x + ancho_cifra + 8), elipsis=True)
819
+
820
+ seg = faltan(self.reinicia)
821
+ if seg is None:
822
+ texto, urgente = "sin reinicio informado", False
823
+ elif self.pct >= 95:
824
+ # Cuando ya te frenó, lo que importa no es cuándo «reinicia»: es
825
+ # cuándo volvés a poder trabajar. Misma fecha, otra pregunta.
826
+ texto, urgente = f"libre en {duracion(seg)}", True
827
+ else:
828
+ texto, urgente = reinicio(seg), False
829
+ pluma.escribir(x, arriba + 54, texto, 11, color if urgente else TEMA.terciario,
830
+ Pango.Weight.MEDIUM if urgente else Pango.Weight.NORMAL,
831
+ ancho=ANCHO_PANEL - MARGEN - x, elipsis=True)
832
+ return arriba + ALTO_CABECERA
833
+
834
+
835
+ # ── el item de la barra, dibujado ────────────────────────────────────────
836
+ # Un medidor vertical por cuenta, en el orden del menú, lleno hasta la semanal
837
+ # que la frena antes y pintado por severidad. Es el mismo dibujo que el item de
838
+ # la barra de macOS (bin/qm-barra.swift, medidores()) y con las mismas medidas:
839
+ # tres cuentas entran en el ancho de una palabra.
840
+ #
841
+ # Entra en la barra de GNOME por una puerta que la extensión deja abierta sin
842
+ # documentar: si el nombre del ícono empieza con «/» lo toma como un archivo, y
843
+ # si esa imagen es ANCHA —`width >= height * 1.5`— la dibuja a lo ancho en vez
844
+ # de encajarla en el cuadrado de 16 px de un ícono. Abajo de esa proporción se
845
+ # vuelve un ícono cuadrado y los medidores quedan ilegibles, así que el ancho
846
+ # se rellena hasta cruzarla.
847
+ ALTO_ITEM = 22
848
+ ALTO_MEDIDOR = 15
849
+ ANCHO_MEDIDOR = 3
850
+ ENTRE_GRUPOS = 5
851
+ LADO_GLIFO = 9
852
+ AIRE_GLIFO = 2
853
+ AIRE_NUMERO = 3
854
+ # La proporción que separa «imagen ancha» de «ícono cuadrado», con un margen
855
+ # para no quedar justo en el filo.
856
+ PROPORCION_ANCHA = 1.6
857
+
858
+
859
+ def _numero_de(t: dict) -> str | None:
860
+ """El número de cada cuenta es el de la SESIÓN de 5 h: es el que contesta
861
+ «¿puedo seguir trabajando ahora?». La semanal se sigue viendo —es el
862
+ medidor, con su color— sin gastar dígitos.
863
+
864
+ Sin marca de cache viejo: un `~` pegado al número obliga a saber qué
865
+ significa para poder leer el número, y la edad del cache ya está escrita con
866
+ todas las letras en el panel, que es donde se la va a buscar.
867
+ """
868
+ if t["sesion"] is None:
869
+ return None
870
+ return f"{t['sesion']:.0f}"
871
+
872
+
873
+ def piezas_de(datos, avisar=None) -> list[dict]:
874
+ """Una pieza por cuenta con número, en el orden del panel.
875
+
876
+ Sólo entran las cuentas que tienen un número. Una cuenta sin cuota no se
877
+ dibuja como un medidor vacío —eso se leería como «0 %, todo bien»—: su
878
+ frase está en el panel.
879
+ """
880
+ piezas: list[dict] = []
881
+ if not isinstance(datos, dict):
882
+ return piezas
883
+ for p in datos.get("perfiles", []):
884
+ cuota = p.get("cuota") or {}
885
+ frena = cuota.get("frena") if cuota.get("estado") == "ok" else None
886
+ if frena is None:
887
+ continue
888
+ proy = p.get("proyeccion")
889
+ chocas = bool(proy and proy["estado"] == "sube" and proy["chocasAntesDelReinicio"])
890
+
891
+ def alerta(v, _frena=frena, _chocas=chocas) -> bool:
892
+ if not v:
893
+ return False
894
+ return bool(v.get("preocupa")) or (_chocas and v.get("clave") == _frena.get("clave"))
895
+
896
+ ses, sem = cuota.get("sesion"), cuota.get("semanal")
897
+ nombre = corto(p["perfil"])
898
+ piezas.append({
899
+ "nombre": nombre,
900
+ "perfil": p["perfil"],
901
+ "producto": p.get("producto") or "claude",
902
+ "indice": len(piezas),
903
+ "sesion": ses.get("porcentaje") if ses else None,
904
+ "sesion_alerta": alerta(ses),
905
+ "semanal": sem.get("porcentaje") if sem else None,
906
+ "semanal_alerta": alerta(sem),
907
+ "viejo": (cuota.get("edadSegundos") or 0) >= VIEJO_SEGUNDOS,
908
+ })
909
+ if avisar is not None:
910
+ # Todas las barras, no sólo la que frena: la semanal puede estar
911
+ # tranquila mientras la de sesión te para, y al revés.
912
+ avisar(nombre, cuota.get("mostrar") or [], frena, proy, chocas)
913
+ return piezas
914
+
915
+
916
+ def dibujar_item(piezas: list[dict], destino: str, escala: float = 1.0) -> tuple[int, int, str]:
917
+ """Deja el PNG en `destino` y devuelve (ancho, alto, descripción accesible).
918
+
919
+ `escala` multiplica los píxeles del archivo sin tocar las medidas que
920
+ devuelve: a 3 salen los mismos 99×22 de siempre, dibujados sobre 297×66
921
+ píxeles. Sirve para mostrarlo grande sin agrandar un bitmap chico, que es
922
+ interpolar los bordes de un medidor de 3 px de ancho y verlo todo blando.
923
+ """
924
+ superficie = cairo.ImageSurface(cairo.FORMAT_ARGB32, 1, 1)
925
+ pluma = Pluma(cairo.Context(superficie), FAMILIA)
926
+
927
+ anchos = []
928
+ for t in piezas:
929
+ n = _numero_de(t)
930
+ ancho = LADO_GLIFO + AIRE_GLIFO + ANCHO_MEDIDOR
931
+ if n is not None:
932
+ ancho += AIRE_NUMERO + math.ceil(pluma.ancho(n, 10, Pango.Weight.MEDIUM, tabular=True))
933
+ anchos.append(ancho)
934
+ # Un par de píxeles al final: sin eso el último dígito termina exactamente
935
+ # en el borde de la imagen y el antialias se lo come.
936
+ total = sum(anchos) + max(0, len(piezas) - 1) * ENTRE_GRUPOS + 2
937
+ ancho_total = max(int(math.ceil(total)), int(ALTO_ITEM * PROPORCION_ANCHA))
938
+
939
+ superficie = cairo.ImageSurface(cairo.FORMAT_ARGB32,
940
+ int(ancho_total * escala), int(ALTO_ITEM * escala))
941
+ cr = cairo.Context(superficie)
942
+ cr.scale(escala, escala)
943
+ pluma = Pluma(cr, FAMILIA)
944
+ base = (ALTO_ITEM - ALTO_MEDIDOR) / 2
945
+ radio = ANCHO_MEDIDOR / 2
946
+
947
+ def medidor(x: float, pct, color) -> None:
948
+ _redondeado(cr, x, base, ANCHO_MEDIDOR, ALTO_MEDIDOR, radio)
949
+ _color(cr, TEMA.pista)
950
+ cr.fill()
951
+ if pct is None:
952
+ return
953
+ # Crece desde abajo, como el de macOS: lleno es «no te queda nada».
954
+ alto = max(ANCHO_MEDIDOR, ALTO_MEDIDOR * max(0.0, min(100.0, pct)) / 100.0)
955
+ _redondeado(cr, x, base + ALTO_MEDIDOR - alto, ANCHO_MEDIDOR, alto, radio)
956
+ _color(cr, color)
957
+ cr.fill()
958
+
959
+ if not piezas:
960
+ medidor((ancho_total - ANCHO_MEDIDOR) / 2, None, None)
961
+
962
+ x = 0.0
963
+ for i, t in enumerate(piezas):
964
+ # El glifo dice QUÉ suscripción es: la forma, el producto; el color,
965
+ # cuál de ellas. La identidad va acá y nunca en los medidores, que
966
+ # están reservados para el estado.
967
+ glifo_producto(cr, t["producto"], TEMA.color_cuenta(t["indice"]),
968
+ x, (ALTO_ITEM - LADO_GLIFO) / 2, LADO_GLIFO)
969
+ xb = x + LADO_GLIFO + AIRE_GLIFO
970
+ # El medidor es SIEMPRE la semanal. Si la cuenta no informa ninguna,
971
+ # queda la pista vacía: mejor un hueco honesto que dibujar otra cosa.
972
+ medidor(xb, t["semanal"],
973
+ TEMA.nivel(nivel_de(t["semanal"], t["semanal_alerta"])) if t["semanal"] is not None else None)
974
+ n = _numero_de(t)
975
+ if n is not None:
976
+ # El número es la sesión, así que lleva el estado DE LA SESIÓN. Se
977
+ # tiñe recién cuando aprieta: si se pintara siempre, el color
978
+ # dejaría de querer decir algo.
979
+ nivel = nivel_de(t["sesion"], t["sesion_alerta"])
980
+ color = TEMA.nivel(nivel) if nivel in ("aviso", "critico") else TEMA.etiqueta
981
+ alto_n = pluma.alto(n, 10, Pango.Weight.MEDIUM, tabular=True)
982
+ pluma.escribir(xb + ANCHO_MEDIDOR + AIRE_NUMERO, (ALTO_ITEM - alto_n) / 2,
983
+ n, 10, color, Pango.Weight.MEDIUM, tabular=True)
984
+ x += anchos[i] + ENTRE_GRUPOS
985
+
986
+ superficie.write_to_png(destino)
987
+ return ancho_total, ALTO_ITEM, "; ".join(
988
+ f"{t['nombre']}: "
989
+ + (f"sesión {t['sesion']} por ciento" if t["sesion"] is not None else "sin sesión")
990
+ + ", "
991
+ + (f"semana {t['semanal']} por ciento" if t["semanal"] is not None else "sin semanal")
992
+ + (", con aviso" if t["sesion_alerta"] or t["semanal_alerta"] else "")
993
+ for t in piezas
994
+ )
995
+
996
+
997
+ # ── el panel, dibujado ───────────────────────────────────────────────────
998
+ # Vive afuera del widget a propósito: `--captura` dibuja esto mismo sobre una
999
+ # superficie de archivo, así que lo que se ve en el PNG es lo que se ve en
1000
+ # pantalla y no una segunda implementación que se parece.
1001
+ def modelo_panel(datos):
1002
+ if not isinstance(datos, dict):
1003
+ return None, []
1004
+ perfiles = datos.get("perfiles", [])
1005
+ vistas, calladas, i = [], [], 0
1006
+ for p in perfiles:
1007
+ cuota = p.get("cuota") or {}
1008
+ if cuota.get("estado") != "ok":
1009
+ calladas.append((corto(p.get("perfil") or "?"), cuota.get("frase") or "sin cuota"))
1010
+ continue
1011
+ vistas.append(VistaCuenta(p, i))
1012
+ # El índice de color sólo avanza con las cuentas que tienen número, para
1013
+ # que dos cuentas con barras nunca compartan color.
1014
+ i += 1
1015
+ if calladas:
1016
+ vistas.append(VistaSinCuota(calladas))
1017
+ return VistaResumen.desde(perfiles), vistas
1018
+
1019
+
1020
+ def _pluma_de_medir() -> Pluma:
1021
+ return Pluma(cairo.Context(cairo.ImageSurface(cairo.FORMAT_ARGB32, 1, 1)), FAMILIA)
1022
+
1023
+
1024
+ def medir_panel(datos, pie: bool = False) -> int:
1025
+ pluma = _pluma_de_medir()
1026
+ if isinstance(datos, str):
1027
+ return int(MARGEN * 2 + pluma.alto(datos, 11.5, ancho=ANCHO_PANEL - 2 * MARGEN))
1028
+ cabecera, vistas = modelo_panel(datos)
1029
+ alto = ALTO_CABECERA if cabecera else MARGEN
1030
+ for v in vistas:
1031
+ alto += v.medir(pluma) + ENTRE_TARJETAS
1032
+ if vistas:
1033
+ alto -= ENTRE_TARJETAS
1034
+ return int(alto + MARGEN + (ALTO_PIE_LECTURA if pie else 0))
1035
+
1036
+
1037
+ def dibujar_panel(cr, datos, alto: float, proxima: float | None = None) -> None:
1038
+ pluma = Pluma(cr, FAMILIA)
1039
+ if isinstance(datos, str):
1040
+ # Silencio es el bug: si no hay número, hay una frase.
1041
+ pluma.escribir(MARGEN, MARGEN, datos, 11.5, TEMA.secundario,
1042
+ ancho=ANCHO_PANEL - 2 * MARGEN)
1043
+ return
1044
+ cabecera, vistas = modelo_panel(datos)
1045
+ y = cabecera.pintar(cr, pluma, 0.0) if cabecera else float(MARGEN)
1046
+ for v in vistas:
1047
+ y = v.pintar(cr, pluma, y) + ENTRE_TARJETAS
1048
+ if proxima is not None:
1049
+ # Cada cuenta dice de cuándo es su número; esto dice cuándo deja de
1050
+ # serlo. Es la otra mitad de la misma pregunta.
1051
+ y += 4
1052
+ pluma.escribir(MARGEN + PAD_TARJETA, y,
1053
+ f"próxima lectura en {cuenta_regresiva(proxima)}",
1054
+ 10.5, TEMA.terciario)
1055
+
1056
+
1057
+ def fondo_panel(cr, ancho: float, alto: float) -> None:
1058
+ """Sólo para la captura: en pantalla el fondo lo pone el menú de GTK."""
1059
+ cr.save()
1060
+ cr.set_operator(cairo.OPERATOR_SOURCE)
1061
+ cr.set_source_rgba(0, 0, 0, 0)
1062
+ cr.paint()
1063
+ cr.restore()
1064
+ _redondeado(cr, 0.5, 0.5, ancho - 1, alto - 1, 12)
1065
+ _color(cr, _hex("#242424") if TEMA.oscuro else _hex("#ffffff"))
1066
+ cr.fill_preserve()
1067
+ _color(cr, TEMA.borde_tarjeta)
1068
+ cr.set_line_width(1)
1069
+ cr.stroke()
1070
+
1071
+
1072
+ def capturar(datos, ruta: str, proxima: float | None = None) -> int:
1073
+ """El panel a un PNG, sin abrir nada. Para mirarlo sin tener la barra
1074
+ adelante, para que un cambio de dibujo se revise en una imagen, y para que
1075
+ lo muestre la extensión de GNOME.
1076
+
1077
+ Devuelve el alto dibujado. Hay que usar ESE número y no volver a medir por
1078
+ fuera: medir con el renglón de «próxima lectura» y dibujar sin él daba una
1079
+ imagen de 1034 px declarada como 1060, y la diferencia se ve como un hueco.
1080
+ """
1081
+ alto = medir_panel(datos, proxima is not None)
1082
+ superficie = cairo.ImageSurface(cairo.FORMAT_ARGB32, ANCHO_PANEL, alto)
1083
+ cr = cairo.Context(superficie)
1084
+ fondo_panel(cr, ANCHO_PANEL, alto)
1085
+ dibujar_panel(cr, datos, alto, proxima)
1086
+ superficie.write_to_png(ruta)
1087
+ return alto
1088
+
1089
+
1090
+ # ── el panel, en pantalla ────────────────────────────────────────────────
1091
+ # En texto y no en bytes: load_from_data() quiere bytes, pero un literal b"" no
1092
+ # admite un solo carácter fuera de ASCII, y un comentario en castellano adentro
1093
+ # rompe el archivo entero.
1094
+ CSS_PANEL = """
1095
+ menu.qm { padding: 6px 0; }
1096
+ menuitem.qm-lienzo { padding: 0; background: none; background-color: transparent; }
1097
+ menuitem.qm-lienzo:hover { background: none; background-color: transparent; }
1098
+ /* Insensible no quiere decir apagado: el dibujo se pinta con sus propios
1099
+ colores y no tiene que perder opacidad por no ser un botón. */
1100
+ menuitem.qm-lienzo:disabled { opacity: 1; color: inherit; }
1101
+ menuitem.qm-lienzo:disabled drawingarea { opacity: 1; }
1102
+ """.encode("utf-8")
1103
+
1104
+
1105
+ class Panel:
1106
+ """El panel adentro de un menú de GTK propio.
1107
+
1108
+ No es una ventana suelta, y la razón se midió: en este escritorio ninguna
1109
+ ventana sostiene el foco. Se probaron los cuatro tipos —UTILITY, NORMAL,
1110
+ DIALOG, POPUP_MENU— y las cuatro lo pierden solas entre 0,15 s y 4,6 s
1111
+ después de abrir, sin que nadie toque nada: mutter se lo devuelve al lado
1112
+ Wayland. O sea que «cerrar al perder el foco» cerraba el panel solo, y
1113
+ agarrar el asiento a mano no alcanzaba porque un agarre de XWayland no ve
1114
+ los clicks que caen sobre una ventana Wayland.
1115
+
1116
+ Un menú de GTK no tiene ninguno de esos problemas: agarra el puntero como lo
1117
+ agarra cualquier menú de cualquier app del escritorio, así que se cierra con
1118
+ un click afuera y con Escape sin que haya que programarlo. Y de yapa la caja
1119
+ redondeada, la sombra y el fondo los pone el tema, con lo cual el panel se ve
1120
+ como se ve todo lo demás en vez de como una ventana ajena.
1121
+
1122
+ Sigue haciendo falta X11 para una sola cosa: `popup_at_rect()` contra la
1123
+ ventana raíz, que es lo que lo pega arriba a la derecha.
1124
+ """
1125
+
1126
+ def __init__(self, al_actualizar, cuanto_falta=None) -> None:
1127
+ self.al_actualizar = al_actualizar
1128
+ # Una función y no un número: así la cuenta regresiva de abajo baja sola
1129
+ # mientras el panel está abierto, en vez de congelarse en el valor que
1130
+ # tenía cuando se abrió.
1131
+ self.cuanto_falta = cuanto_falta or (lambda: None)
1132
+ self.tictac: int | None = None
1133
+ self.datos: dict | str | None = None
1134
+ self.alto = 0
1135
+ self.cerrado = 0
1136
+
1137
+ self.menu = Gtk.Menu()
1138
+ self.menu.get_style_context().add_class("qm")
1139
+ self.menu.set_reserve_toggle_size(False)
1140
+
1141
+ # Un item por tarjeta, y no una sola superficie gigante.
1142
+ #
1143
+ # Un Gtk.Menu rueda ITEM por item: con un único item más alto que la
1144
+ # pantalla no hay nada que rodar, y el menú directamente no abre. Se vio
1145
+ # con un panel de 946 px en un monitor cuyo área útil son 728 — antes
1146
+ # medía 740 y entraba raspando, así que el bug apareció recién cuando el
1147
+ # panel creció. Partido en tarjetas, cada item entra y GTK pone las
1148
+ # flechas de rodar solo.
1149
+ self.css = Gtk.CssProvider()
1150
+ self.css.load_from_data(CSS_PANEL)
1151
+ self.menu.get_style_context().add_provider(
1152
+ self.css, Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION)
1153
+ self.filas: list[Gtk.MenuItem] = []
1154
+
1155
+ self.menu.realize()
1156
+ # Si el compositor le rompe el agarre —pasa cuando el foco se va al lado
1157
+ # Wayland— el menú tiene que cerrarse, no quedarse colgado arriba de
1158
+ # todo sin forma de sacarlo.
1159
+ self.menu.connect("grab-broken-event", lambda *_: (self.menu.popdown(), False)[1])
1160
+ self.menu.connect("unmap", self._al_cerrar)
1161
+
1162
+ @property
1163
+ def abierto(self) -> bool:
1164
+ """Si el menú está mapeado, y no lo que crea una bandera nuestra.
1165
+
1166
+ Antes esto era un booleano que se prendía en «map» y se apagaba en
1167
+ «unmap», y se quedó pegado en True: el menú se cerró sin que llegara el
1168
+ unmap, así que cada click siguiente llamaba a popdown() sobre algo ya
1169
+ cerrado y el panel no volvía a abrir nunca. Preguntarle al widget no se
1170
+ puede desincronizar.
1171
+ """
1172
+ try:
1173
+ return bool(self.menu.get_mapped())
1174
+ except (AttributeError, TypeError):
1175
+ return False
1176
+
1177
+ def _al_cerrar(self, *_) -> None:
1178
+ self.cerrado = GLib.get_monotonic_time()
1179
+ if self.tictac is not None:
1180
+ GLib.source_remove(self.tictac)
1181
+ self.tictac = None
1182
+
1183
+ def _tic(self) -> bool:
1184
+ """Sólo redibuja: la medida no cambia, así que no hay que volver a
1185
+ medir ni a mover nada."""
1186
+ if not self.abierto:
1187
+ self.tictac = None
1188
+ return False
1189
+ for fila in self.filas:
1190
+ fila.get_child().queue_draw()
1191
+ return True
1192
+
1193
+ def _fila(self, dibujo, alto: float) -> Gtk.MenuItem:
1194
+ """Un renglón del menú que se dibuja solo."""
1195
+ lienzo = Gtk.DrawingArea()
1196
+ lienzo.set_size_request(ANCHO_PANEL, int(alto))
1197
+ lienzo.connect("draw", lambda _w, cr, d=dibujo: (d(cr), False)[1])
1198
+ fila = Gtk.MenuItem()
1199
+ # Insensible a propósito, y es lo único que hace que el panel se pueda
1200
+ # usar: en un menú de GTK un item se ACTIVA al soltar el botón encima, y
1201
+ # activar un item cierra el menú. Con las tarjetas sensibles, tocar el
1202
+ # panel para rodarlo lo cerraba en el acto — el dibujo no es un botón,
1203
+ # es contenido. Los renglones de acción de abajo sí quedan sensibles.
1204
+ fila.set_sensitive(False)
1205
+ fila.get_style_context().add_class("qm-lienzo")
1206
+ fila.get_style_context().add_provider(
1207
+ self.css, Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION)
1208
+ fila.add(lienzo)
1209
+ return fila
1210
+
1211
+ def _armar(self) -> None:
1212
+ # Todo se construye de nuevo, incluidos el separador y «Actualizar».
1213
+ # Sacar un widget de un contenedor de GTK lo DESTRUYE, así que guardarlo
1214
+ # para reusarlo en la próxima vuelta deja un objeto muerto: el menú se
1215
+ # armaba una vez, se cerraba, y de ahí en adelante no abría nunca más.
1216
+ for hijo in self.menu.get_children():
1217
+ self.menu.remove(hijo)
1218
+ self.filas = []
1219
+
1220
+ pluma = _pluma_de_medir()
1221
+ if isinstance(self.datos, str):
1222
+ # Silencio es el bug: si no hay número, hay una frase.
1223
+ alto = pluma.alto(self.datos, 11.5, ancho=ANCHO_PANEL - 2 * MARGEN) + 2 * MARGEN
1224
+ texto = self.datos
1225
+ self.filas.append(self._fila(
1226
+ lambda cr, t=texto: Pluma(cr, FAMILIA).escribir(
1227
+ MARGEN, MARGEN, t, 11.5, TEMA.secundario,
1228
+ ancho=ANCHO_PANEL - 2 * MARGEN), alto))
1229
+ else:
1230
+ cabecera, vistas = modelo_panel(self.datos)
1231
+ if cabecera:
1232
+ self.filas.append(self._fila(
1233
+ lambda cr, v=cabecera: v.pintar(cr, Pluma(cr, FAMILIA), 0.0),
1234
+ ALTO_CABECERA))
1235
+ for v in vistas:
1236
+ self.filas.append(self._fila(
1237
+ lambda cr, v=v: v.pintar(cr, Pluma(cr, FAMILIA), 0.0),
1238
+ v.medir(pluma) + ENTRE_TARJETAS))
1239
+ if self.cuanto_falta() is not None:
1240
+ self.filas.append(self._fila(self._pintar_lectura, ALTO_PIE_LECTURA))
1241
+
1242
+ for fila in self.filas:
1243
+ self.menu.append(fila)
1244
+ self.menu.append(Gtk.SeparatorMenuItem())
1245
+ actualizar = Gtk.MenuItem(label="Actualizar ahora")
1246
+ actualizar.connect("activate", lambda _: self.al_actualizar())
1247
+ self.menu.append(actualizar)
1248
+ self.menu.show_all()
1249
+
1250
+ def _pintar_lectura(self, cr) -> None:
1251
+ falta = self.cuanto_falta()
1252
+ if falta is None:
1253
+ return
1254
+ # Cada cuenta dice de cuándo es su número; esto dice cuándo deja de
1255
+ # serlo. Es la otra mitad de la misma pregunta.
1256
+ Pluma(cr, FAMILIA).escribir(
1257
+ MARGEN + PAD_TARJETA, 4, f"próxima lectura en {cuenta_regresiva(falta)}",
1258
+ 10.5, TEMA.terciario)
1259
+
1260
+ @staticmethod
1261
+ def _area():
1262
+ disp = Gdk.Display.get_default()
1263
+ mon = None
1264
+ try:
1265
+ _, px, py = disp.get_default_seat().get_pointer().get_position()
1266
+ mon = disp.get_monitor_at_point(px, py)
1267
+ except (AttributeError, TypeError):
1268
+ pass
1269
+ mon = mon or disp.get_primary_monitor() or disp.get_monitor(0)
1270
+ return mon.get_workarea()
1271
+
1272
+ @staticmethod
1273
+ def _disparo(raiz):
1274
+ """El evento que GTK pide para popear un menú.
1275
+
1276
+ Acá no hay ninguno: el panel lo abre un mensaje de DBus, no un click que
1277
+ haya pasado por este proceso. Sin evento GTK avisa «no trigger event for
1278
+ menu popup» y el agarre que toma después se rompe solo a
1279
+ los pocos segundos: el menú se cerraba sin que nadie tocara nada.
1280
+
1281
+ El tiempo va en CURRENT_TIME a propósito. Preguntarle la hora al
1282
+ servidor X con x11_get_server_time() sobre la ventana raíz **cuelga el
1283
+ proceso**: esa función escribe una propiedad y se queda esperando un
1284
+ PropertyNotify que la raíz nunca manda, y el bucle principal no vuelve.
1285
+ Para agarrar el puntero, CURRENT_TIME quiere decir «ahora» y alcanza.
1286
+ """
1287
+ ev = Gdk.Event.new(Gdk.EventType.BUTTON_PRESS)
1288
+ ev.window = raiz
1289
+ ev.send_event = True
1290
+ ev.button = 1
1291
+ asiento = Gdk.Display.get_default().get_default_seat()
1292
+ puntero = asiento.get_pointer()
1293
+ try:
1294
+ ev.set_device(puntero)
1295
+ _, x, y = puntero.get_position()
1296
+ ev.x_root, ev.y_root = float(x), float(y)
1297
+ except (AttributeError, TypeError):
1298
+ pass
1299
+ ev.time = Gdk.CURRENT_TIME
1300
+ return ev
1301
+
1302
+ def mostrar(self, datos) -> None:
1303
+ """Abre —o redibuja, si ya estaba abierto— el panel con estos datos."""
1304
+ global TEMA
1305
+ # Cada vez, no una sola al arrancar: el tema del escritorio se cambia
1306
+ # mientras el programa corre y el dibujo tiene que seguirlo.
1307
+ TEMA = Tema.desde(self.menu)
1308
+ self.datos = datos
1309
+ self.alto = medir_panel(datos, self.cuanto_falta() is not None)
1310
+ if self.abierto:
1311
+ # Con el menú abierto no se reconstruyen los items —eso lo cerraría—
1312
+ # así que sólo se repintan.
1313
+ for fila in self.filas:
1314
+ fila.get_child().queue_draw()
1315
+ return
1316
+ self._armar()
1317
+ # Arriba a la derecha del área útil, que ya excluye la barra.
1318
+ area = self._area()
1319
+ donde = Gdk.Rectangle()
1320
+ donde.x, donde.y, donde.width, donde.height = area.x + area.width - 6, area.y, 1, 1
1321
+ raiz = Gdk.get_default_root_window()
1322
+ if raiz is None: # sin X11 no hay dónde anclarlo; que lo ubique GTK
1323
+ self.menu.popup_at_pointer(None)
1324
+ return
1325
+ self.menu.popup_at_rect(raiz, donde, Gdk.Gravity.NORTH_EAST,
1326
+ Gdk.Gravity.NORTH_EAST, self._disparo(raiz))
1327
+ if self.tictac is None:
1328
+ self.tictac = GLib.timeout_add_seconds(1, self._tic)
1329
+
1330
+ def alternar(self, datos) -> None:
1331
+ """Abre o cierra.
1332
+
1333
+ El margen no es paranoia: el click del medio sobre la barra cierra el
1334
+ menú antes de que el evento llegue hasta acá, así que sin él el click
1335
+ que tenía que cerrarlo lo vuelve a abrir.
1336
+ """
1337
+ if self.abierto or (GLib.get_monotonic_time() - self.cerrado) < 300_000:
1338
+ self.menu.popdown()
1339
+ else:
1340
+ self.mostrar(datos)
1341
+
1342
+
1343
+ # ── avisos ───────────────────────────────────────────────────────────────
1344
+ class Avisos:
1345
+ """Notificaciones sin repetir.
1346
+
1347
+ La clave incluye el instante de reinicio: cuando la ventana se reinicia,
1348
+ la clave cambia sola y el mismo umbral puede volver a avisar. Sin eso, o
1349
+ spameás cada minuto o avisás una sola vez en la vida.
1350
+ """
1351
+
1352
+ def __init__(self) -> None:
1353
+ self.bus = Gio.bus_get_sync(Gio.BusType.SESSION, None)
1354
+ self.ruta = Path(
1355
+ os.environ.get("XDG_CACHE_HOME", str(Path.home() / ".cache"))
1356
+ ) / "quartermaster" / "avisados.json"
1357
+ try:
1358
+ self.vistos = set(json.loads(self.ruta.read_text()))
1359
+ except (OSError, ValueError):
1360
+ self.vistos = set()
1361
+
1362
+ def guardar(self) -> None:
1363
+ try:
1364
+ self.ruta.parent.mkdir(parents=True, exist_ok=True)
1365
+ self.ruta.write_text(json.dumps(sorted(self.vistos)))
1366
+ except OSError:
1367
+ pass # sin memoria de avisos se avisa de más, no de menos
1368
+
1369
+ def avisar(self, clave: str, titulo: str, cuerpo: str, urgente: bool) -> None:
1370
+ """Una vez por clave y nunca más."""
1371
+ if clave in self.vistos:
1372
+ return
1373
+ self.vistos.add(clave)
1374
+ self.guardar()
1375
+ self.notificar(titulo, cuerpo, urgente)
1376
+
1377
+ def notificar(self, titulo: str, cuerpo: str, urgente: bool) -> None:
1378
+ """Sin memoria: para lo que sí tiene que volver a avisar cada vez que
1379
+ pasa, como un reinicio."""
1380
+ try:
1381
+ self.bus.call_sync(
1382
+ "org.freedesktop.Notifications",
1383
+ "/org/freedesktop/Notifications",
1384
+ "org.freedesktop.Notifications",
1385
+ "Notify",
1386
+ GLib.Variant(
1387
+ "(susssasa{sv}i)",
1388
+ (
1389
+ "quartermaster",
1390
+ 0,
1391
+ ICONO_GRAVE if urgente else ICONO_AVISO,
1392
+ titulo,
1393
+ cuerpo,
1394
+ [],
1395
+ {"urgency": GLib.Variant("y", 2 if urgente else 1)},
1396
+ 0 if urgente else 10_000,
1397
+ ),
1398
+ ),
1399
+ GLib.VariantType("(u)"),
1400
+ Gio.DBusCallFlags.NONE,
1401
+ -1,
1402
+ None,
1403
+ )
1404
+ except GLib.Error:
1405
+ pass # sin servidor de notificaciones el indicador igual funciona
1406
+
1407
+
1408
+ # ── leer a qm ────────────────────────────────────────────────────────────
1409
+ def leer_qm(qm: str) -> dict | str:
1410
+ """El JSON de qm, o la frase que explica por qué no hay JSON."""
1411
+ try:
1412
+ r = subprocess.run(
1413
+ [qm, "--json", "--breve"],
1414
+ capture_output=True,
1415
+ text=True,
1416
+ timeout=20,
1417
+ check=False,
1418
+ )
1419
+ except (OSError, subprocess.TimeoutExpired) as e:
1420
+ return f"no pude correr qm: {e}"
1421
+ # 3 es «alguna barra pasó el umbral», no un error.
1422
+ if r.returncode not in (0, 3):
1423
+ lineas = (r.stderr or r.stdout or "").strip().splitlines()
1424
+ return f"qm salió {r.returncode}: {lineas[0] if lineas else 'sin detalle'}"
1425
+ try:
1426
+ return json.loads(r.stdout)
1427
+ except json.JSONDecodeError:
1428
+ return "qm no devolvió JSON"
1429
+
1430
+
1431
+ class Previos:
1432
+ """Cuánto valía cada barra la última vez, para poder ver que se reinició.
1433
+
1434
+ Un porcentaje solo no dice nada de eso: 3 % puede ser «recién empezás» o
1435
+ «acabás de salir de estar contra el techo», y la diferencia es justo lo que
1436
+ hay que avisar. Se guarda el minuto de reinicio junto al número: cuando el
1437
+ minuto cambia, la ventana es otra.
1438
+ """
1439
+
1440
+ def __init__(self) -> None:
1441
+ self.ruta = CACHE / "previos.json"
1442
+ try:
1443
+ self.mapa = json.loads(self.ruta.read_text())
1444
+ except (OSError, ValueError):
1445
+ self.mapa = {}
1446
+
1447
+ def ver_y_guardar(self, clave: str, minuto: str, pct: float):
1448
+ """Devuelve lo anterior (minuto, pct) o None, y anota lo de ahora."""
1449
+ antes = self.mapa.get(clave)
1450
+ self.mapa[clave] = [minuto, pct]
1451
+ if not isinstance(antes, list) or len(antes) != 2:
1452
+ return None
1453
+ return antes[0], antes[1]
1454
+
1455
+ def guardar(self) -> None:
1456
+ try:
1457
+ self.ruta.parent.mkdir(parents=True, exist_ok=True)
1458
+ self.ruta.write_text(json.dumps(self.mapa))
1459
+ except OSError:
1460
+ pass # sin memoria se avisa de más, no de menos
1461
+
1462
+
1463
+ # ── indicador ────────────────────────────────────────────────────────────
1464
+ class Indicador:
1465
+ def __init__(self, qm: str):
1466
+ self.qm = qm
1467
+ self.avisos = Avisos()
1468
+ self.previos = Previos()
1469
+ self.pendiente: int | None = None
1470
+ self.pedido_pendiente: int | None = None
1471
+ self.reinicio_pendiente: int | None = None
1472
+ self.apertura_pendiente: int | None = None
1473
+ self.menu = Gtk.Menu()
1474
+ self.ind = AppIndicator.Indicator.new(
1475
+ ID, ICONO_OK, AppIndicator.IndicatorCategory.SYSTEM_SERVICES
1476
+ )
1477
+ self.ind.set_status(AppIndicator.IndicatorStatus.ACTIVE)
1478
+ self.ind.set_title("quartermaster")
1479
+ self.ind.set_menu(self.menu)
1480
+ self.datos: dict | str | None = None
1481
+ self.piezas: list[dict] = []
1482
+ self.minutos_al_techo: float | None = None
1483
+ self.calentando = False
1484
+ self.reloj: int | None = None
1485
+ self.proxima_lectura: int | None = None
1486
+ self.turno = 0
1487
+ self.iconos = CACHE
1488
+ self.panel = Panel(self.refrescar, self.falta_para_lectura)
1489
+ self.monitores: list[Gio.FileMonitor] = []
1490
+ self.refrescar()
1491
+ self.vigilar()
1492
+ self.vigilar_extension()
1493
+ self.vigilar_tema()
1494
+ self.vigilar_version()
1495
+ GLib.timeout_add_seconds(SEGUNDOS_SONDEO, self.refrescar)
1496
+ self.programar_calentado(5)
1497
+
1498
+ # Vigilancia de archivos ------------------------------------------------
1499
+ def vigilar(self) -> None:
1500
+ """Un monitor por .claude.json. Es donde aparece la cuota nueva."""
1501
+ casa = Path.home()
1502
+ rutas = [casa / ".claude.json"]
1503
+ rutas += [d / ".claude.json" for d in casa.glob(".claude-*") if d.is_dir()]
1504
+ for r in rutas:
1505
+ try:
1506
+ mon = Gio.File.new_for_path(str(r)).monitor_file(
1507
+ Gio.FileMonitorFlags.NONE, None
1508
+ )
1509
+ except GLib.Error:
1510
+ continue
1511
+ mon.connect("changed", self.cambio)
1512
+ self.monitores.append(mon)
1513
+
1514
+ def vigilar_extension(self) -> None:
1515
+ """Los dos archivos que escribe la extensión: el click y su presencia."""
1516
+ for ruta, accion in ((PEDIDO, self.atender_pedido),
1517
+ (EXTENSION_VIVA, self.mandar_en_la_barra)):
1518
+ try:
1519
+ mon = Gio.File.new_for_path(str(ruta)).monitor_file(
1520
+ Gio.FileMonitorFlags.NONE, None)
1521
+ except GLib.Error:
1522
+ continue
1523
+ mon.connect("changed", lambda *a, f=accion: f())
1524
+ self.monitores.append(mon)
1525
+ self.mandar_en_la_barra()
1526
+ # Un archivo que se quedó viejo no dispara ningún evento, así que hay
1527
+ # que ir a mirarlo.
1528
+ GLib.timeout_add_seconds(VIVA_SEGUNDOS // 2, self.mandar_en_la_barra)
1529
+
1530
+ def vigilar_version(self) -> None:
1531
+ """Cuando el paquete se actualiza, este proceso sigue con el código viejo.
1532
+
1533
+ `apt upgrade`, `brew upgrade` y `npm update` reemplazan los archivos y se
1534
+ van; el proceso que ya está corriendo tiene el módulo cargado en memoria
1535
+ y sigue igual hasta que alguien lo reinicie a mano — que no lo hace
1536
+ nadie, porque el indicador es justamente lo que se deja andando y se
1537
+ olvida. Así que se mira a sí mismo y se vuelve a lanzar.
1538
+ """
1539
+ try:
1540
+ mon = Gio.File.new_for_path(str(YO)).monitor_file(
1541
+ Gio.FileMonitorFlags.NONE, None)
1542
+ except GLib.Error:
1543
+ return
1544
+ mon.connect("changed", self._quizas_reiniciar)
1545
+ self.monitores.append(mon)
1546
+
1547
+ def _quizas_reiniciar(self, _mon, _f, _o, evento) -> None:
1548
+ if evento not in (Gio.FileMonitorEvent.CHANGES_DONE_HINT,
1549
+ Gio.FileMonitorEvent.CREATED,
1550
+ Gio.FileMonitorEvent.RENAMED,
1551
+ Gio.FileMonitorEvent.MOVED_IN):
1552
+ return
1553
+ # Un gestor de paquetes escribe en varios pasos; se espera a que pare.
1554
+ if self.reinicio_pendiente is not None:
1555
+ GLib.source_remove(self.reinicio_pendiente)
1556
+ self.reinicio_pendiente = GLib.timeout_add_seconds(3, self._reiniciar)
1557
+
1558
+ def _reiniciar(self) -> bool:
1559
+ self.reinicio_pendiente = None
1560
+ # Compila antes de saltar. Si la versión nueva está rota, reiniciar deja
1561
+ # al usuario SIN indicador; quedarse con la vieja lo deja con una que
1562
+ # anda. Entre las dos, la que anda.
1563
+ # El .pyc va a un temporal de verdad: py_compile se niega a escribir en
1564
+ # /dev/null —«is a non-regular file»— y con eso el chequeo fallaba
1565
+ # SIEMPRE, así que nunca reiniciaba y parecía que la vigilancia no
1566
+ # andaba. La red de seguridad tapaba la puerta.
1567
+ try:
1568
+ with tempfile.NamedTemporaryFile(suffix=".pyc", delete=True) as tmp:
1569
+ py_compile.compile(str(YO), cfile=tmp.name, doraise=True)
1570
+ except (py_compile.PyCompileError, OSError, ValueError) as e:
1571
+ print(f"la versión nueva no compila, me quedo con ésta: {e}", file=sys.stderr)
1572
+ return False
1573
+ self.panel.menu.popdown()
1574
+ try:
1575
+ os.execv(sys.executable, [sys.executable, str(YO), *sys.argv[1:]])
1576
+ except OSError as e:
1577
+ print(f"no pude reiniciarme: {e}", file=sys.stderr)
1578
+ return False
1579
+
1580
+ def vigilar_tema(self) -> None:
1581
+ """El tema del escritorio se cambia con esto andando.
1582
+
1583
+ El color del número de la barra sale de TEMA, que se resolvía una sola
1584
+ vez al arrancar: pasar el escritorio a claro dejaba el número blanco
1585
+ sobre una barra clara hasta el próximo reinicio del indicador.
1586
+ """
1587
+ try:
1588
+ fuente = Gio.SettingsSchemaSource.get_default()
1589
+ esquema = fuente.lookup("org.gnome.desktop.interface", True) if fuente else None
1590
+ if esquema is None or not esquema.has_key("color-scheme"):
1591
+ return
1592
+ self.ajustes = Gio.Settings.new("org.gnome.desktop.interface")
1593
+ self.ajustes.connect("changed::color-scheme", lambda *_: self.cambio_de_tema())
1594
+ except (GLib.Error, AttributeError, TypeError):
1595
+ pass
1596
+
1597
+ def cambio_de_tema(self) -> None:
1598
+ global TEMA
1599
+ alinear_tema_gtk()
1600
+ TEMA = tema_actual()
1601
+ self.refrescar()
1602
+
1603
+ def atender_pedido(self) -> None:
1604
+ """Un click, una acción.
1605
+
1606
+ Escribir un archivo son VARIOS eventos de inotify —se midieron tres por
1607
+ escritura: changed, changed, changes-done-hint— y sin juntarlos un solo
1608
+ click abría el panel y los dos eventos siguientes lo cerraban en el
1609
+ mismo instante. Desde afuera se veía como que el item no hacía nada.
1610
+ """
1611
+ if self.pedido_pendiente is not None:
1612
+ GLib.source_remove(self.pedido_pendiente)
1613
+ self.pedido_pendiente = GLib.timeout_add(120, self._pedido_listo)
1614
+
1615
+ def _pedido_listo(self) -> bool:
1616
+ self.pedido_pendiente = None
1617
+ try:
1618
+ accion = PEDIDO.read_text().split(" ", 1)[0].strip()
1619
+ except OSError:
1620
+ return False
1621
+ if accion == "alternar":
1622
+ # La extensión sólo pide esto cuando NO puede dibujar el panel ella
1623
+ # misma; si puede, abre su propio menú y no manda nada.
1624
+ self.abrir_panel()
1625
+ elif accion == "actualizar":
1626
+ self.refrescar()
1627
+ return False
1628
+
1629
+ def extension_viva(self) -> bool:
1630
+ """La extensión está puesta y sigue viva.
1631
+
1632
+ No alcanza con que el archivo exista: si el shell se cae sin llamar a
1633
+ disable(), queda para siempre y este item se escondería para siempre —
1634
+ ningún icono en ningún lado. La extensión le renueva la fecha cada 30 s,
1635
+ así que un archivo viejo quiere decir que del otro lado no hay nadie.
1636
+ """
1637
+ try:
1638
+ return (time.time() - EXTENSION_VIVA.stat().st_mtime) < VIVA_SEGUNDOS
1639
+ except OSError:
1640
+ return False
1641
+
1642
+ def mandar_en_la_barra(self) -> bool:
1643
+ """Si la extensión está puesta, el item de AppIndicator sobra.
1644
+
1645
+ No se destruye, se pone en PASSIVE: la extensión se puede apagar en
1646
+ cualquier momento y entonces este item tiene que volver, sin reiniciar
1647
+ nada y sin dejar la barra vacía en el medio.
1648
+ """
1649
+ propia = not self.extension_viva()
1650
+ self.ind.set_status(AppIndicator.IndicatorStatus.ACTIVE if propia
1651
+ else AppIndicator.IndicatorStatus.PASSIVE)
1652
+ return True
1653
+
1654
+ def cambio(self, _mon, _f, _o, evento) -> None:
1655
+ if evento not in (
1656
+ Gio.FileMonitorEvent.CHANGES_DONE_HINT,
1657
+ Gio.FileMonitorEvent.CREATED,
1658
+ Gio.FileMonitorEvent.RENAMED,
1659
+ ):
1660
+ return
1661
+ # Claude Code reescribe el archivo varias veces seguidas; una sola
1662
+ # relectura al final alcanza.
1663
+ if self.pendiente is not None:
1664
+ GLib.source_remove(self.pendiente)
1665
+ self.pendiente = GLib.timeout_add(DEBOUNCE_MS, self.disparar)
1666
+
1667
+ # Calentado -------------------------------------------------------------
1668
+ # `qm --breve` lee del disco y no habla con nadie, que es lo que lo hace
1669
+ # instantáneo — pero entonces el número es tan fresco como la última vez que
1670
+ # ALGUIEN preguntó. Y Claude Code refresca su propio cache cuando quiere:
1671
+ # medido acá, 1 día y 11 horas sin tocarlo, con la semanal 14 puntos abajo
1672
+ # de la realidad. Así que el indicador pregunta él, igual que la barra de
1673
+ # macOS y la bandeja de Windows, y deja el número en el cache para que las
1674
+ # lecturas sigan siendo de disco.
1675
+ @staticmethod
1676
+ def _tope(t: dict) -> int:
1677
+ return max(t["sesion"] or 0, t["semanal"] or 0)
1678
+
1679
+ def cadencia(self) -> int:
1680
+ # Una barra que ya está en 100 no puede subir: hasta el reinicio no hay
1681
+ # nada nuevo que leer, y el instante del reinicio ya lo sabemos sin
1682
+ # preguntar. Contarla como «alto» hacía que el sondeo se fuera al piso
1683
+ # de 60 s para mirar un número congelado — un pedido por minuto a un
1684
+ # endpoint que no es nuestro, para confirmar que seguís frenado.
1685
+ moviles = [self._tope(t) for t in self.piezas if self._tope(t) < 100]
1686
+ alto = max(moviles, default=0)
1687
+ seg = SEGUNDOS_SONDEO
1688
+ if alto >= 90:
1689
+ seg = MINIMO_RED
1690
+ elif alto >= 75:
1691
+ seg = 120
1692
+ elif alto >= 50:
1693
+ seg = 240
1694
+ # Si la proyección dice que el techo está cerca, el número viejo deja de
1695
+ # servir mucho antes que en el caso normal.
1696
+ m = self.minutos_al_techo
1697
+ if m is not None and m <= 30:
1698
+ seg = min(seg, MINIMO_RED)
1699
+ elif m is not None and m <= 90:
1700
+ seg = min(seg, 120)
1701
+ return max(MINIMO_RED, seg)
1702
+
1703
+ def programar_calentado(self, segundos: int | None = None) -> None:
1704
+ if self.reloj is not None:
1705
+ GLib.source_remove(self.reloj)
1706
+ cuanto = self.cadencia() if segundos is None else segundos
1707
+ self.proxima_lectura = GLib.get_monotonic_time() + cuanto * 1_000_000
1708
+ self.reloj = GLib.timeout_add_seconds(cuanto, self.calentar)
1709
+
1710
+ def falta_para_lectura(self) -> float | None:
1711
+ """Segundos hasta la próxima vez que se le pregunta al servidor."""
1712
+ if self.proxima_lectura is None:
1713
+ return None
1714
+ if self.calentando:
1715
+ return 0.0
1716
+ return max(0.0, (self.proxima_lectura - GLib.get_monotonic_time()) / 1_000_000)
1717
+
1718
+ def calentar(self) -> bool:
1719
+ self.reloj = None
1720
+ if self.calentando:
1721
+ return False
1722
+ args = [self.qm, "--calentar"]
1723
+ # Sólo las cuentas que se mueven: refrescar una que va al 9 % es gastar
1724
+ # un pedido para confirmar que no pasó nada.
1725
+ mueven = [t["perfil"] for t in self.piezas if 40 <= self._tope(t) < 100]
1726
+ if mueven and len(mueven) != len(self.piezas):
1727
+ args.append("--cuentas=" + ",".join(mueven))
1728
+ try:
1729
+ proc = Gio.Subprocess.new(
1730
+ args, Gio.SubprocessFlags.STDOUT_SILENCE | Gio.SubprocessFlags.STDERR_SILENCE
1731
+ )
1732
+ except GLib.Error:
1733
+ self.programar_calentado()
1734
+ return False
1735
+ self.calentando = True
1736
+ proc.wait_async(None, self._fin_calentado)
1737
+ return False
1738
+
1739
+ def _fin_calentado(self, proc, resultado) -> None:
1740
+ self.calentando = False
1741
+ try:
1742
+ proc.wait_finish(resultado)
1743
+ except GLib.Error:
1744
+ pass # si el endpoint no contesta se sigue mostrando lo viejo, con su edad a la vista
1745
+ self.refrescar()
1746
+
1747
+ def disparar(self) -> bool:
1748
+ self.pendiente = None
1749
+ self.refrescar()
1750
+ return False
1751
+
1752
+ # Datos -----------------------------------------------------------------
1753
+ def leer(self) -> dict | str:
1754
+ return leer_qm(self.qm)
1755
+
1756
+ # Dibujo ----------------------------------------------------------------
1757
+ def refrescar(self) -> bool:
1758
+ datos = self.leer()
1759
+ self.datos = datos
1760
+ for hijo in self.menu.get_children():
1761
+ self.menu.remove(hijo)
1762
+
1763
+ # El menú es tres renglones y nada más. Antes repetía cada perfil con
1764
+ # cada barra en bloques `█░`, que es lo único que GNOME sabe dibujar
1765
+ # acá adentro —la extensión manda los items por DBus y del otro lado
1766
+ # hace label.set_text(), texto pelado— y era justamente lo que el panel
1767
+ # vino a reemplazar. Un muro de texto feo delante del dibujo bueno es
1768
+ # peor que no tener menú.
1769
+ abrir = Gtk.MenuItem(label="Panel de cuota · click del medio")
1770
+ abrir.connect("activate", lambda _: self.abrir_panel())
1771
+ self.menu.append(abrir)
1772
+ # El click del medio abre el panel sin pasar por el menú, que es lo más
1773
+ # parecido al click único de macOS que deja hacer GNOME (el izquierdo se
1774
+ # lo queda la extensión para el menú, y el AboutToShow que manda ni
1775
+ # siquiera llega hasta acá).
1776
+ #
1777
+ # El objetivo tiene que ser un item que VIVA dentro del menú y esté
1778
+ # visible: con un widget suelto, libayatana descarta el evento sin decir
1779
+ # nada. Y como el menú se reconstruye en cada refresco, hay que volver a
1780
+ # apuntarlo cada vez o el click deja de hacer efecto en silencio.
1781
+ abrir.show()
1782
+ self.ind.set_secondary_activate_target(abrir)
1783
+
1784
+ if isinstance(datos, str):
1785
+ # Un estado que no produce número tiene que producir una frase.
1786
+ self.ind.set_label("qm ?", "qm")
1787
+ self.ind.set_icon_full(ICONO_AVISO, "qm sin datos")
1788
+ self.item(datos)
1789
+ else:
1790
+ self.pintar(datos)
1791
+
1792
+ # «Actualizar» ya está adentro del panel, que es donde se mira el
1793
+ # número: repetirlo acá sólo agrega un renglón que hay que saltear.
1794
+ self.menu.append(Gtk.SeparatorMenuItem())
1795
+ salir = Gtk.MenuItem(label="Salir")
1796
+ salir.connect("activate", lambda _: Gtk.main_quit())
1797
+ self.menu.append(salir)
1798
+ self.menu.show_all()
1799
+ if self.panel.abierto:
1800
+ self.panel.mostrar(datos)
1801
+ self.programar_calentado()
1802
+ return True
1803
+
1804
+ def abrir_panel(self) -> None:
1805
+ """Un respiro antes de abrir.
1806
+
1807
+ Cuando esto lo dispara el renglón «Panel de cuota» del menú de GNOME, el
1808
+ click que lo activó todavía no terminó: el shell está cerrando su propio
1809
+ menú y soltando su agarre, y el button-release de ese mismo click llega
1810
+ DESPUÉS de que nuestro menú ya se agarró el puntero. Un menú de GTK
1811
+ interpreta ese release como «soltaron afuera» y se cierra en el acto —
1812
+ desde afuera se ve como que el panel parpadea y desaparece sin que
1813
+ puedas hacer nada.
1814
+
1815
+ Esperar a que el evento original se consuma lo arregla. No se nota:
1816
+ menos de dos décimas.
1817
+ """
1818
+ if self.apertura_pendiente is not None:
1819
+ GLib.source_remove(self.apertura_pendiente)
1820
+ self.apertura_pendiente = GLib.timeout_add(180, self._abrir_ya)
1821
+
1822
+ def _abrir_ya(self) -> bool:
1823
+ self.apertura_pendiente = None
1824
+ self.panel.alternar(self.datos)
1825
+ return False
1826
+
1827
+ def item(self, texto: str) -> None:
1828
+ it = Gtk.MenuItem(label=texto)
1829
+ it.set_sensitive(False)
1830
+ self.menu.append(it)
1831
+
1832
+ def pintar(self, datos: dict) -> None:
1833
+ piezas = piezas_de(datos, self.revisar_avisos)
1834
+ self.piezas = piezas
1835
+ techos = []
1836
+ for p in datos.get("perfiles", []):
1837
+ proy = p.get("proyeccion") or {}
1838
+ if proy.get("estado") == "sube" and proy.get("chocasAntesDelReinicio"):
1839
+ seg = faltan(proy.get("techo"))
1840
+ if seg is not None:
1841
+ techos.append(seg / 60)
1842
+ self.minutos_al_techo = min(techos) if techos else None
1843
+ if not piezas:
1844
+ # Sin una sola cuenta con número no hay nada que medir, y un dibujo
1845
+ # vacío sería un item mudo. Ahí sí sirve el ícono con nombre.
1846
+ self.ind.set_label("sin cuota", "qm")
1847
+ self.ind.set_icon_full(ICONO_AVISO, "sin cuota")
1848
+ return
1849
+
1850
+ # Se alterna el nombre del archivo porque el shell cachea la textura por
1851
+ # ruta: reescribiendo siempre la misma, el item se queda con el dibujo
1852
+ # viejo y parece que la cuota no se mueve.
1853
+ self.turno = 1 - self.turno
1854
+ destino = self.iconos / f"barra-{self.turno}.png"
1855
+ try:
1856
+ self.iconos.mkdir(parents=True, exist_ok=True)
1857
+ ancho, alto, descripcion = dibujar_item(piezas, str(destino))
1858
+ except (OSError, MemoryError) as e:
1859
+ self.ind.set_icon_full(ICONO_AVISO, f"no pude dibujar el item: {e}")
1860
+ return
1861
+ # El dibujo ya dice todo lo que decía el texto. Dejar los dos es repetir
1862
+ # el mismo número en dos idiomas y ocupar el doble de barra.
1863
+ self.ind.set_label("", "")
1864
+ self.ind.set_icon_full(str(destino), descripcion)
1865
+ self.publicar(destino, ancho, alto, descripcion)
1866
+
1867
+ def publicar(self, ruta: Path, ancho: int, alto: int, descripcion: str) -> None:
1868
+ """Deja escrito qué dibujó, para la extensión de GNOME Shell."""
1869
+ panel = {}
1870
+ try:
1871
+ # El nombre alterna igual que el del item: el shell cachea la
1872
+ # textura por ruta y si no, muestra el panel de hace un rato.
1873
+ destino = self.iconos / f"panel-{self.turno}.png"
1874
+ alto = capturar(self.datos, str(destino), self.falta_para_lectura())
1875
+ panel = {"panel": str(destino), "panelAncho": ANCHO_PANEL, "panelAlto": alto}
1876
+ except (OSError, MemoryError):
1877
+ pass # sin panel dibujado la extensión sigue mostrando el item
1878
+ try:
1879
+ ESTADO.write_text(json.dumps({
1880
+ "icono": str(ruta), "ancho": ancho, "alto": alto,
1881
+ "descripcion": descripcion, **panel,
1882
+ }))
1883
+ except OSError:
1884
+ pass # sin extensión instalada esto no le importa a nadie
1885
+
1886
+ def revisar_avisos(self, perfil: str, ventanas: list, frena: dict | None,
1887
+ proy: dict | None, chocas: bool) -> None:
1888
+ for v in ventanas:
1889
+ nombre = nombre_ventana(v)
1890
+ minuto = al_minuto(v.get("reinicia"))
1891
+ pct = v["porcentaje"]
1892
+ # El reinicio va en la clave: cuando la ventana se reinicia, el
1893
+ # mismo umbral vuelve a poder avisar. Va redondeado al minuto porque
1894
+ # el servidor manda microsegundos y no siempre los mismos entre
1895
+ # lecturas (se vieron .117894 y .118092 en la misma respuesta): con
1896
+ # el valor crudo, cada jitter estrena clave y vuelve a notificar lo
1897
+ # mismo.
1898
+ base = f"{perfil}|{nombre}|{minuto}"
1899
+ for u in UMBRALES:
1900
+ if pct >= u:
1901
+ seg = faltan(v.get("reinicia"))
1902
+ cola = f" Se reinicia en {duracion(seg)}." if seg is not None else ""
1903
+ self.avisos.avisar(
1904
+ f"{base}|{u}",
1905
+ f"{perfil}: {pct:.0f}% de {nombre}",
1906
+ f"Pasaste el {u}%.{cola}",
1907
+ urgente=u >= 95,
1908
+ )
1909
+ self.revisar_liberada(perfil, nombre, minuto, pct)
1910
+
1911
+ if chocas and proy and frena:
1912
+ seg = faltan(proy["techo"])
1913
+ self.avisos.avisar(
1914
+ f"{perfil}|{nombre_ventana(frena)}|{al_minuto(frena.get('reinicia'))}|choque",
1915
+ f"{perfil}: a este ritmo llegás al 100%",
1916
+ f"{proy['ritmoPuntosPorHora']:.1f} pts/h — tocás el techo en "
1917
+ f"{duracion(faltan(proy['techo']) or 0)}, antes de que la ventana se reinicie.",
1918
+ urgente=True,
1919
+ )
1920
+ self.previos.guardar()
1921
+
1922
+ def revisar_liberada(self, perfil: str, nombre: str, minuto: str, pct: float) -> None:
1923
+ """El aviso que faltaba: ya podés volver a trabajar.
1924
+
1925
+ Todo lo demás avisa cuando subís. Este avisa cuando la ventana se
1926
+ reinicia habiendo estado contra el techo, que es el único momento en
1927
+ que la noticia sirve para hacer algo distinto ahora mismo — y es
1928
+ justamente cuando dejaste de mirar la barra, porque no había nada que
1929
+ mirar.
1930
+ """
1931
+ antes = self.previos.ver_y_guardar(f"{perfil}|{nombre}", minuto, pct)
1932
+ if antes is None:
1933
+ return
1934
+ minuto_antes, pct_antes = antes
1935
+ if minuto == minuto_antes or pct_antes < 80 or pct >= pct_antes:
1936
+ return
1937
+ self.avisos.notificar(
1938
+ f"{perfil}: se reinició {nombre}",
1939
+ f"Estabas {pct_antes:.0f} % y ahora vas {pct:.0f} %.",
1940
+ urgente=False,
1941
+ )
1942
+
1943
+
1944
+ NOMBRE_BUS = "ai.legios.quartermaster"
1945
+ _nombre_tomado = None
1946
+
1947
+
1948
+ def soy_el_unico() -> bool:
1949
+ """Un indicador por sesión, y el segundo se va.
1950
+
1951
+ Sin esto, arrancarlo dos veces —el arranque automático más un `make
1952
+ indicador` a mano, que es lo más fácil del mundo— deja DOS items en la
1953
+ barra, abre DOS paneles con un solo click, y los dos procesos se pisan
1954
+ escribiendo el mismo PNG y el mismo estado.json. Medido, no supuesto.
1955
+
1956
+ El candado es un nombre en el bus de sesión y no un archivo: si el proceso
1957
+ muere de cualquier forma, el bus suelta el nombre solo. Un archivo con el
1958
+ PID hay que limpiarlo, y nunca se limpia en el caso que importa.
1959
+ """
1960
+ global _nombre_tomado
1961
+ resultado = {"mio": None}
1962
+ bucle = GLib.MainLoop()
1963
+
1964
+ def adquirido(*_):
1965
+ resultado["mio"] = True
1966
+ bucle.quit()
1967
+
1968
+ def perdido(*_):
1969
+ resultado["mio"] = False
1970
+ bucle.quit()
1971
+
1972
+ _nombre_tomado = Gio.bus_own_name(
1973
+ Gio.BusType.SESSION, NOMBRE_BUS, Gio.BusNameOwnerFlags.DO_NOT_QUEUE,
1974
+ None, adquirido, perdido)
1975
+ # Si el bus no contesta, seguir es mejor que quedarse esperando para siempre.
1976
+ GLib.timeout_add_seconds(3, lambda: (bucle.quit(), False)[1])
1977
+ bucle.run()
1978
+ return resultado["mio"] is not False
1979
+
1980
+
1981
+ def buscar_qm() -> str | None:
1982
+ """qm en el PATH; si no, el hermano de este archivo.
1983
+
1984
+ El arranque automático de la sesión no pasa por el .zshrc del usuario, así
1985
+ que ~/.local/bin puede no estar en el PATH ahí aunque sí lo esté en una
1986
+ terminal. El hermano siempre está donde este script.
1987
+ """
1988
+ encontrado = shutil.which("qm")
1989
+ if encontrado:
1990
+ return encontrado
1991
+ vecino = Path(__file__).resolve().parent / "qm"
1992
+ return str(vecino) if vecino.is_file() else None
1993
+
1994
+
1995
+ def leer_desde(ruta: str) -> dict:
1996
+ """El JSON de un archivo en vez del de qm.
1997
+
1998
+ Existe para el gate de dibujo: con una entrada fija, lo que sale es
1999
+ comparable entre corridas y entre máquinas. Si el archivo no se puede leer
2000
+ se levanta, no se devuelve una frase: una frase se dibujaría como un panel
2001
+ chiquito y perfectamente válido, y el gate lo daría por bueno.
2002
+ """
2003
+ return json.loads(pathlib.Path(ruta).read_text())
2004
+
2005
+
2006
+ def main() -> int:
2007
+ fijo = None
2008
+ if "--desde" in sys.argv:
2009
+ i = sys.argv.index("--desde")
2010
+ if i + 1 >= len(sys.argv):
2011
+ print("--desde necesita una ruta", file=sys.stderr)
2012
+ return 1
2013
+ fijo = sys.argv[i + 1]
2014
+
2015
+ qm = buscar_qm()
2016
+ if qm is None and fijo is None:
2017
+ print("qm no está en el PATH. Corré `make instalar` en el repo.", file=sys.stderr)
2018
+ return 1
2019
+ global TEMA, FAMILIA
2020
+ try:
2021
+ CACHE.mkdir(parents=True, exist_ok=True)
2022
+ except OSError:
2023
+ pass
2024
+ alinear_tema_gtk()
2025
+ TEMA = tema_actual()
2026
+ FAMILIA = familia_del_sistema()
2027
+ if "--claro" in sys.argv:
2028
+ TEMA = Tema(False)
2029
+ if "--oscuro" in sys.argv:
2030
+ TEMA = Tema(True)
2031
+
2032
+ # `--captura ruta.png` dibuja el panel y sale. Es la forma de revisar un
2033
+ # cambio de dibujo sin tener que abrir la barra y sacar una foto.
2034
+ for bandera, dibujo in (("--captura", "panel"), ("--captura-item", "item")):
2035
+ if bandera not in sys.argv:
2036
+ continue
2037
+ i = sys.argv.index(bandera)
2038
+ if i + 1 >= len(sys.argv):
2039
+ print(f"{bandera} necesita una ruta", file=sys.stderr)
2040
+ return 1
2041
+ try:
2042
+ datos = leer_desde(fijo) if fijo is not None else leer_qm(qm)
2043
+ except (OSError, json.JSONDecodeError) as e:
2044
+ print(f"no pude leer {fijo}: {e}", file=sys.stderr)
2045
+ return 1
2046
+ if dibujo == "panel":
2047
+ capturar(datos, sys.argv[i + 1])
2048
+ else:
2049
+ dibujar_item(piezas_de(datos), sys.argv[i + 1]) # devuelve medidas, no se usan acá
2050
+ print(sys.argv[i + 1])
2051
+ return 0
2052
+
2053
+ if not soy_el_unico():
2054
+ print("ya hay un quartermaster corriendo en esta sesión.", file=sys.stderr)
2055
+ return 0
2056
+
2057
+ Indicador(qm)
2058
+ Gtk.main()
2059
+ return 0
2060
+
2061
+
2062
+ if __name__ == "__main__":
2063
+ sys.exit(main())