From e1a14ec3fc1e51ac5b9ae4048dd04c2b9adbb520 Mon Sep 17 00:00:00 2001 From: rafa Date: Sun, 2 Aug 2026 21:15:41 -0400 Subject: [PATCH] TTS backlog: tamano de tanda adaptativo y reparto de la cuota semanal (#188) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Un tamano fijo de tanda no maximiza: deja la ventana de 5h a medias cuando esta libre y no cabe cuando esta medio usada. Ahora cada corrida mide la cuota y calcula cuantos audios caben. Coste medido (2 tandas de 10 el 2-ago): 4,4 puntos de la ventana de 5h y 0,4 de la semanal por audio. Con la ventana limpia salen 20, no 10. Pero la semanal NO se gasta a tope en cada ventana: se REPARTE entre las que quedan hasta su reset. Llenar cada ventana de 5h al 90% son ~8 puntos de semanal, y hay 20 ventanas activas por semana = 160 puntos para un presupuesto de 85. Sin reparto, domingo y lunes se lo comen y el fin de semana se queda a cero (simulado: se seca en la ventana 12 de 20). Con reparto salen ~10 por ventana, 204 audios/semana, y la semanal acaba justo en el 85% al llegar el reset. En la ultima ventana el reparto vale todo lo que sobre, asi que tampoco queda cuota sin usar: eso sustituye al apano anterior de "apurar en las ultimas 12h", que se retira. El gate binario tambien desaparece: si otro esta usando MiniMax, en vez de saltarse la ventana entera se hace una tanda pequena con lo que quede. Validado en vivo: "reset semanal en 166h, 20 ventanas por delante · Caben: 10 por la de 5h, 10 por el reparto semanal". Co-Authored-By: Claude Opus 5 --- scripts/tts_backlog_cron.sh | 105 ++++++++++++++++++++++++++---------- 1 file changed, 78 insertions(+), 27 deletions(-) diff --git a/scripts/tts_backlog_cron.sh b/scripts/tts_backlog_cron.sh index e0774b1..259f831 100755 --- a/scripts/tts_backlog_cron.sh +++ b/scripts/tts_backlog_cron.sh @@ -2,9 +2,10 @@ # Cron del backlog de TTS por autor (issue rafa/feadulta#188). # Corre cada 5 h los lunes, viernes, sábados y domingos, aprovechando la cuota # ociosa de MiniMax para locutar artículos antiguos. Por ventana: -# 1) Gate de cuota MiniMax: si la semana va alta, o si la ventana de 5 h ya la -# está usando alguien (la carta semanal, el backfill de summaraise...), se -# salta. El trabajo de fondo nunca le come la cuota al trabajo con dueño. +# 1) Mide la cuota y CALCULA el tamaño de la tanda para llenar la ventana hasta +# el objetivo. Un tamaño fijo desaprovecha: deja la ventana a medias cuando +# está libre, y no cabe cuando está medio usada. Al dimensionar por hueco +# libre, además, deja de importar dónde caiga el cron respecto a la ventana. # 2) tts_produce.py --autor ... --max N: la cola sale de la BD, así que esto es # idempotente por construcción — lo ya locutado no vuelve a salir. # SOLO LOCAL: no toca producción. Publicar en prod es sync_audio_to_prod.py, que @@ -27,16 +28,29 @@ LOCK="$WORK/cron.lock" AUTOR="${FEA_TTS_AUTOR:-382}" DESDE="${FEA_TTS_DESDE:-2025}" HASTA="${FEA_TTS_HASTA:-2026}" -BATCH="${FEA_TTS_BATCH:-10}" -# Gates de cuota (%). El semanal es el techo real del backlog. El de 5 h es -# "¿cabe esta tanda en lo que queda de ventana?": medido, cada audio gasta ~3-4 % -# de la ventana de 5 h, así que un batch de 10 pide ~40 %. Gate en 55 % deja sitio -# y frena solo cuando la ventana ya la está usando otro (la carta semanal son ~28 -# audios de golpe) o cuando la está llenando este mismo cron. Si se sube BATCH, -# subir también este número o se saltarán ventanas. -MAX_SEMANA="${FEA_TTS_MAX_SEMANA:-85}" -MAX_5H="${FEA_TTS_MAX_5H:-55}" +# Coste medido de un audio, en DÉCIMAS de punto porcentual (aritmética entera en +# bash). Dos tandas de 10 el 2026-08-02: la ventana de 5 h fue 0→45→88 (~4,4 pts +# por audio) y la semanal 10→14→18 (~0,4 pts). Artículos de Fray Marcos de +# 4.000-5.000 caracteres; si se locuta a otro autor con textos mucho más largos, +# revisar estos números con un par de tandas. +COSTE_5H="${FEA_TTS_COSTE_5H:-44}" +COSTE_SEM="${FEA_TTS_COSTE_SEM:-4}" + +# Objetivos de llenado (%). Dejar cuota sin usar al llegar el reset es tirarla. +OBJ_5H="${FEA_TTS_OBJ_5H:-90}" +OBJ_SEM="${FEA_TTS_OBJ_SEM:-85}" + +# La semanal NO se gasta a tope en cada ventana: se REPARTE entre las ventanas +# que quedan hasta su reset. Llenar cada ventana de 5 h al 90 % son ~8 puntos de +# semanal, y hay 20 ventanas activas por semana: 160 puntos para un presupuesto +# de 85. Sin reparto, domingo y lunes se lo comen y el fin de semana se queda a +# cero. Con reparto sale ~10 audios por ventana, y en la última ventana de la +# semana el reparto vale todo lo que sobre, así que tampoco queda cuota sin usar. + +# Tope de seguridad por tanda y override manual (FEA_TTS_BATCH fija el tamaño y +# se salta el cálculo). +MAX_BATCH="${FEA_TTS_MAX_BATCH:-25}" mkdir -p "$WORK" cd "$REPO" || exit 1 @@ -47,39 +61,76 @@ if ! flock -n 9; then echo "[$(ts)] otra corrida en curso, salto." >> "$LOG"; exit 0 fi -echo "[$(ts)] === cron TTS backlog start (autor=$AUTOR $DESDE-$HASTA batch=$BATCH) ===" >> "$LOG" +echo "[$(ts)] === cron TTS backlog start (autor=$AUTOR $DESDE-$HASTA) ===" >> "$LOG" -# 1) Gate de cuota MiniMax (ventana de 5 h y semanal) -read -r PCT5 PCTW <<< "$(python3 "$QUOTA" --json --no-local 2>/dev/null | python3 -c ' +# 1) Medir la cuota, y contar cuántas ventanas del cron quedan hasta que se +# reinicie la semanal — es el denominador del reparto. +read -r PCT5 PCTW HSEM VENTANAS <<< "$(python3 "$QUOTA" --json --no-local 2>/dev/null | python3 -c ' import json, sys +from datetime import datetime, timedelta, timezone + +# DEBEN COINCIDIR CON EL CRONTAB: 0 */5 * * 1,5,6,0 +HORAS = {0, 5, 10, 15, 20} +DIAS = {0, 4, 5, 6} # lun, vie, sab, dom en datetime.weekday() + def pct(v): # OJO: 0.0 es un valor legítimo (ventana entera libre) y es falsy en Python. # Un `v or 100` aquí aborta la tanda justo cuando hay toda la cuota disponible. return int(v) if v is not None else 100 + try: d = json.load(sys.stdin) m = next(p for p in d["providers"] if p["provider"] == "minimax" and p.get("ok")) - print(pct(m.get("five_h_pct")), pct(m.get("week_pct"))) + horas, ventanas = 999, 1 + try: + fin = datetime.fromisoformat(m["week_reset"]).astimezone() + ahora = datetime.now().astimezone() + horas = max(int((fin - ahora).total_seconds() // 3600), 0) + # Esta corrida cuenta como una; se suman las que quedan programadas. + t = (ahora + timedelta(hours=1)).replace(minute=0, second=0, microsecond=0) + while t < fin: + if t.hour in HORAS and t.weekday() in DIAS: + ventanas += 1 + t += timedelta(hours=1) + except Exception: + pass + print(pct(m.get("five_h_pct")), pct(m.get("week_pct")), horas, ventanas) except Exception: - print(100, 100) # sin lectura fiable de cuota, no se gasta -' 2>/dev/null || echo "100 100")" -echo "[$(ts)] MiniMax 5h=${PCT5}% semana=${PCTW}%" >> "$LOG" + print(100, 100, 999, 1) # sin lectura fiable de cuota, no se gasta +' 2>/dev/null || echo "100 100 999 1")" +[ "${VENTANAS:-0}" -lt 1 ] && VENTANAS=1 -if [ "${PCTW:-100}" -ge "$MAX_SEMANA" ]; then - echo "[$(ts)] ABORT: cuota semanal ${PCTW}% >= ${MAX_SEMANA}%, salto esta ventana." >> "$LOG" - exit 0 -fi -if [ "${PCT5:-100}" -ge "$MAX_5H" ]; then - echo "[$(ts)] ABORT: ventana de 5h al ${PCT5}% >= ${MAX_5H}%, no cabe la tanda; salto." >> "$LOG" +# 2) Dimensionar la tanda. Dos límites, manda el más restrictivo: +# - la ventana de 5 h: se llena hasta OBJ_5H aquí y ahora; +# - la semanal: solo la parte que le toca a esta ventana de lo que queda. +CABE_5H=$(( ((OBJ_5H - PCT5) * 10) / COSTE_5H )) +CABE_SEM=$(( (((OBJ_SEM - PCTW) * 10) / VENTANAS) / COSTE_SEM )) +[ "$CABE_5H" -lt 0 ] && CABE_5H=0 +[ "$CABE_SEM" -lt 0 ] && CABE_SEM=0 + +BATCH=$CABE_5H +[ "$CABE_SEM" -lt "$BATCH" ] && BATCH=$CABE_SEM +[ "$BATCH" -gt "$MAX_BATCH" ] && BATCH=$MAX_BATCH +# Override manual: fija el tamaño y se salta todo el cálculo. +[ -n "${FEA_TTS_BATCH:-}" ] && BATCH="$FEA_TTS_BATCH" + +echo "[$(ts)] MiniMax 5h=${PCT5}% semana=${PCTW}% · reset semanal en ${HSEM}h, ${VENTANAS} ventanas por delante" >> "$LOG" +echo "[$(ts)] Caben: ${CABE_5H} por la de 5h, ${CABE_SEM} por el reparto semanal → tanda de ${BATCH}" >> "$LOG" + +if [ "$BATCH" -lt 1 ]; then + echo "[$(ts)] ABORT: no cabe ni un audio sin pasarse del objetivo; salto esta ventana." >> "$LOG" exit 0 fi -# 2) Tanda. tts_produce.py ya para solo ante rc 2056/1039 (cuota/rate limit). +# 3) Tanda. tts_produce.py ya para solo ante rc 2056/1039 (cuota/rate limit). +# Una tanda larga puede desbordar el reset de 5 h (~2,6 min por audio): no pasa +# nada, lo que sobra lo absorbe la ventana siguiente y la próxima corrida la +# mide y se redimensiona sola. Cortar por tiempo dejaría cuota sin gastar. echo "[$(ts)] tts_produce --autor $AUTOR --desde $DESDE --hasta $HASTA --max $BATCH ..." >> "$LOG" "$PY" scripts/tts_produce.py --autor "$AUTOR" --desde "$DESDE" --hasta "$HASTA" \ --max "$BATCH" >> "$LOG" 2>&1 -# 3) Cuánto queda tras la tanda (recuento fresco de la BD, barato y sin cuota). +# 4) Cuánto queda tras la tanda (recuento fresco de la BD, barato y sin cuota). QUEDAN="$("$PY" scripts/tts_produce.py --autor "$AUTOR" --desde "$DESDE" --hasta "$HASTA" \ --dry-run 2>/dev/null | sed -n 's/.*Cola: \([0-9]*\) posts.*/\1/p' | tail -1)" echo "[$(ts)] === cron TTS backlog done. Pendientes autor $AUTOR $DESDE-$HASTA: ${QUEDAN:-?} ===" >> "$LOG"