@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.
- package/LICENSE +21 -0
- package/README.md +1276 -0
- package/bin/qm +66 -0
- package/bin/qm-barra +63 -0
- package/bin/qm-barra.swift +1253 -0
- package/bin/qm-indicator +2063 -0
- package/bin/qm-tray +41 -0
- package/bin/qm-tray.ps1 +1241 -0
- package/bin/qm-web +137 -0
- package/dist/adapters/cache-cuota.js +45 -0
- package/dist/adapters/cache-cuota.js.map +1 -0
- package/dist/adapters/cache-endpoint.js +66 -0
- package/dist/adapters/cache-endpoint.js.map +1 -0
- package/dist/adapters/codex.js +462 -0
- package/dist/adapters/codex.js.map +1 -0
- package/dist/adapters/credenciales.js +88 -0
- package/dist/adapters/credenciales.js.map +1 -0
- package/dist/adapters/cuota.js +73 -0
- package/dist/adapters/cuota.js.map +1 -0
- package/dist/adapters/historial.js +103 -0
- package/dist/adapters/historial.js.map +1 -0
- package/dist/adapters/opencode.js +214 -0
- package/dist/adapters/opencode.js.map +1 -0
- package/dist/adapters/transcripciones.js +129 -0
- package/dist/adapters/transcripciones.js.map +1 -0
- package/dist/adapters/utilizacion.js +151 -0
- package/dist/adapters/utilizacion.js.map +1 -0
- package/dist/cli/demo-h1.js +60 -0
- package/dist/cli/demo-h1.js.map +1 -0
- package/dist/cli/preflight.js +39 -0
- package/dist/cli/preflight.js.map +1 -0
- package/dist/cli/qm.js +779 -0
- package/dist/cli/qm.js.map +1 -0
- package/dist/core/config.js +63 -0
- package/dist/core/config.js.map +1 -0
- package/dist/core/perfiles.js +139 -0
- package/dist/core/perfiles.js.map +1 -0
- package/dist/core/proyeccion.js +83 -0
- package/dist/core/proyeccion.js.map +1 -0
- package/dist/core/tipos.js +101 -0
- package/dist/core/tipos.js.map +1 -0
- package/dist/render/barras.js +62 -0
- package/dist/render/barras.js.map +1 -0
- package/dist/render/tablero.html +664 -0
- package/package.json +59 -0
- package/src/render/tablero.html +664 -0
package/bin/qm-indicator
ADDED
|
@@ -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())
|