"""Arranque y turnos del motor en un servidor compartido (el Space). - `Warmup`: el servidor responde de inmediato y el modelo (y el catálogo) se cargan en segundo plano; mientras tanto la interfaz muestra "despertando". - `Turnstile`: una generación a la vez, en orden de llegada, con un máximo de peticiones esperando. Quien se va antes de su turno no bloquea a los demás. """ import logging import os import threading from collections.abc import Callable log = logging.getLogger(__name__) def env_int(name: str, default: int) -> int: return int(os.environ.get(name, str(default))) class Warmup: """Carga única y segura entre hilos; `start()` la lanza en segundo plano.""" def __init__(self, load: Callable[[], None]): self._load = load self._lock = threading.Lock() self._ready = threading.Event() self.error: str | None = None @property def ready(self) -> bool: return self._ready.is_set() def run(self) -> None: """Carga ahora (o espera a que termine la carga en curso). Idempotente.""" with self._lock: if self._ready.is_set(): return try: self._load() except Exception as e: # se informa por /info y se reintenta en la próxima llamada self.error = f"{type(e).__name__}: {e}" log.exception("Falló la carga del motor") raise self.error = None self._ready.set() def start(self) -> threading.Thread: def target(): try: self.run() except Exception: pass # ya quedó en self.error thread = threading.Thread(target=target, name="warmup", daemon=True) thread.start() return thread class Busy(Exception): """La cola está llena.""" class Turnstile: """Turnos FIFO con números: `take()` da un número; `wait()` espera a que sea su turno; `release()` lo libera (terminado o abandonado).""" def __init__(self, max_waiting: int): self.max_waiting = max_waiting self._cond = threading.Condition() self._next = 0 # próximo número a entregar self._serving = 0 # número que tiene el turno self._abandoned: set[int] = set() def take(self) -> int: with self._cond: if self._next - self._serving - len(self._abandoned) > self.max_waiting: # el atendido no cuenta raise Busy(f"Too many people waiting ({self.max_waiting}); try again in a moment") ticket = self._next self._next += 1 return ticket def ahead(self, ticket: int) -> int: """Cuántos turnos faltan (0 = es su turno).""" with self._cond: return max(0, ticket - self._serving - sum(1 for t in self._abandoned if self._serving <= t < ticket)) def wait(self, ticket: int, timeout: float | None = None) -> bool: with self._cond: return self._cond.wait_for(lambda: self._serving == ticket, timeout) def release(self, ticket: int) -> None: with self._cond: if ticket == self._serving: self._serving += 1 elif ticket > self._serving: self._abandoned.add(ticket) # Saltar a los que se fueron mientras esperaban. while self._serving in self._abandoned: self._abandoned.discard(self._serving) self._serving += 1 self._cond.notify_all() @property def waiting(self) -> int: with self._cond: return self._next - self._serving - len(self._abandoned)