Spaces:
Sleeping
Sleeping
Download engine/app/runtime.py from lorcapoul/smol-neuron-studio: direct link, hf CLI and curl.
- Browser
- Download file 3.69 kB
-
https://huggingface.co/spaces/lorcapoul/smol-neuron-studio/resolve/main/engine/app/runtime.py
- Command line
-
hf download hf://spaces/lorcapoul/smol-neuron-studio/engine/app/runtime.py
-
curl -L -o runtime.py https://huggingface.co/spaces/lorcapoul/smol-neuron-studio/resolve/main/engine/app/runtime.py
3.69 kB
| """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 | |
| 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() | |
| def waiting(self) -> int: | |
| with self._cond: | |
| return self._next - self._serving - len(self._abandoned) | |