File size: 8,848 Bytes
d601f7c
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
"""Servizio GPU di Neuronal (solo nel container su Hugging Face).

Il container non ha una GPU: quando il motore deve calcolare, questo servizio chiede a uno Space ZeroGPU

di avviare il modello per pochi secondi. Il modello si collega da solo al motore; qui si fa solo la richiesta.

Se la GPU non arriva (coda, tempo del giorno finito) lo dice al motore, che continua sulla CPU.



Variabili: NEURONAL_GPU_SPACE (utente/nome dello Space col modello), NEURONAL_GPU_KEY (la sua chiave),

HF_TOKEN (di chi è il tempo di GPU; serve anche se lo Space è privato), SPACE_HOST (lo mette Hugging Face)."""
import asyncio, json, os, re, secrets, sys, threading, time, urllib.error, urllib.request

import websockets

sys.stdout.reconfigure(encoding="utf-8", line_buffering=True)
MOTORE = os.environ.get("NEURONAL_WS", "ws://127.0.0.1:8765/ws?role=voice").replace("role=voice", "role=gpu")
SPACE = os.environ.get("NEURONAL_GPU_SPACE", "")
CHIAVE = os.environ.get("NEURONAL_GPU_KEY", "")
TOKEN = os.environ.get("HF_TOKEN", "")
SECONDI = int(os.environ.get("NEURONAL_GPU_SECONDS", "40"))   # durata di una sessione: più è corta, più a lungo basta il tempo del giorno
MINIMO = 12                                                    # sotto questa durata non vale la pena
PUBBLICO = os.environ.get("NEURONAL_PUBLIC_WS") or ("wss://" + os.environ["SPACE_HOST"] + "/ws" if os.environ.get("SPACE_HOST") else "")
BASE = "https://" + re.sub(r"[^a-z0-9]+", "-", SPACE.lower()).strip("-") + ".hf.space/"
# Con il login attivo, chi non accede resta sulla CPU: la GPU veloce è per chi usa i propri minuti (così quelli dello Space non finiscono).
# NEURONAL_GPU_ANONIMI=1 la dà anche a chi non accede, finché durano i minuti dello Space.
ANONIMI = os.environ.get("NEURONAL_GPU_ANONIMI", "") == "1" or not os.environ.get("OAUTH_CLIENT_ID")
INTEST = {"Content-Type": "application/json"}
if TOKEN:
    INTEST["Authorization"] = "Bearer " + TOKEN
funzione = None                                                # numero della funzione "sessione" nello Space


def apri(url, corpo=None, attesa=30, chiave=None):
    """chiave: quella del visitatore (login Hugging Face): il tempo di GPU è contato sul suo account e non sul tuo."""
    intest = INTEST if not chiave else {"Content-Type": "application/json", "Authorization": "Bearer " + chiave}
    dati = json.dumps(corpo).encode() if corpo is not None else None
    return urllib.request.urlopen(urllib.request.Request(url, data=dati, headers=intest), timeout=attesa)


def sveglia(attesa=240):
    """Uno Space che dorme (dopo giorni senza visite) si risveglia alla prima visita, ma ci mette un paio di minuti:

    lo si chiama e si aspetta che risponda. Non consuma tempo di GPU."""
    fine = time.time() + attesa
    while time.time() < fine:
        try:
            with apri(BASE + "config", attesa=15) as r:
                if r.status == 200:
                    return True
        except Exception:
            pass
        time.sleep(5)
    return False


SVEGLIA = threading.Lock()


def sveglia_in_fondo():
    if SVEGLIA.acquire(blocking=False):
        def lavoro():
            try:
                ok = sveglia()
                print("Servizio GPU: lo Space del modello " + ("è sveglio." if ok else "non risponde ancora."))
            finally:
                SVEGLIA.release()
        threading.Thread(target=lavoro, daemon=True).start()


def sessione(biglietto, secondi, utente=""):
    """Una sessione di GPU dall'inizio alla fine. Ritorna None se è andata, altrimenti il testo dell'errore."""
    global funzione
    if funzione is None:
        with apri(BASE + "config") as r:
            deps = json.load(r)["dependencies"]
        funzione = next(d.get("id", i) for i, d in enumerate(deps) if d.get("api_name") == "sessione")
    coda = secrets.token_hex(8)
    corpo = {"data": [CHIAVE, f"{PUBBLICO}?role=brain&ticket={biglietto}", secondi], "fn_index": funzione, "session_hash": coda}
    apri(BASE + "gradio_api/queue/join", corpo, chiave=utente).close()
    with apri(BASE + "gradio_api/queue/data?session_hash=" + coda, attesa=secondi + 240, chiave=utente) as r:
        for riga in r:
            riga = riga.decode("utf-8", "replace").strip()
            if not riga.startswith("data:"):
                continue
            ev = json.loads(riga[5:])
            if ev.get("msg") != "process_completed":
                continue
            out = ev.get("output") or {}
            if ev.get("success") is False or out.get("error"):
                return str(out.get("error") or "errore senza dettagli")
            testo = str((out.get("data") or [""])[0])
            return None if testo.startswith("ok") else testo or "risposta vuota"
    return "lo Space ha chiuso senza rispondere"


def chiedi(biglietto, utente=""):
    """Chiede la GPU e aspetta la fine della sessione. Ritorna None se è andata, altrimenti (motivo, secondi di pausa).

    Con la chiave del visitatore il tempo è il suo; senza, quello incluso nell'account dello Space, finché dura."""
    chi = "il tuo" if utente else "di oggi"
    if not utente and not ANONIMI:
        return ("senza l'accesso con Hugging Face si resta sulla CPU", 600)       # con il login il motore riprova subito
    try:
        errore = sessione(biglietto, SECONDI, utente)
        resta = re.search(r"vs\. (\d+)s left", errore or "")
        if resta:                                          # il tempo del giorno sta finendo: una sessione più corta ci sta ancora?
            corta = int(int(resta.group(1)) / 1.5) - 9     # lo Space chiede 8 secondi in più e ZeroGPU li conta una volta e mezza
            if corta >= MINIMO:
                errore = sessione(biglietto, corta, utente)
        if not errore:
            return None
        if "quota" in errore.lower():
            return (f"il tempo di GPU {chi} è finito", 900)
        return (errore[:140], 120)
    except urllib.error.HTTPError as e:
        if e.code >= 500 or e.code == 429:
            sveglia_in_fondo()
        if utente and e.code in (401, 403):
            return ("la chiave Hugging Face del visitatore non è accettata (accedi di nuovo)", 300)
        return (f"lo Space ha risposto {e.code}", 300 if e.code in (401, 403, 404) else 60)
    except Exception as e:
        sveglia_in_fondo()                                  # probabilmente dorme: lo si sveglia mentre il motore va avanti sulla CPU
        return (f"lo Space non è raggiungibile ({type(e).__name__}): lo sveglio", 60)


async def servi():
    attesa, ultimo = 2, 0.0
    while True:
        try:
            async with websockets.connect(MOTORE, max_size=None) as ws:
                print("Servizio GPU: collegato al motore, lo Space del modello è", SPACE)
                attesa = 2
                sveglia_in_fondo()                                  # se dormiva, intanto si risveglia

                async def tieni_sveglio():                          # una visita ogni 6 ore: così non si addormenta
                    while True:
                        await asyncio.sleep(6 * 3600)
                        sveglia_in_fondo()
                custode = asyncio.ensure_future(tieni_sveglio())

                async def richiesta(biglietto, utente=""):
                    t = time.time()
                    esito = await asyncio.get_running_loop().run_in_executor(None, chiedi, biglietto, utente)
                    if esito:
                        print(f"Servizio GPU: niente GPU ({esito[0]}), il motore continua sulla CPU.")
                        try:
                            await ws.send(json.dumps({"cmd": "gpu_status", "ok": False, "message": esito[0], "retry": esito[1]}))
                        except Exception:
                            pass
                    else:
                        print(f"Servizio GPU: sessione di {time.time() - t:.0f} s conclusa.")

                async for m in ws:
                    if isinstance(m, str) and '"gpu_need"' in m:
                        ev = json.loads(m)
                        asyncio.ensure_future(richiesta(ev["ticket"], ev.get("user") or ""))
        except Exception as e:
            try:
                custode.cancel()
            except NameError:
                pass
            if time.time() - ultimo > 60:
                print(f"Servizio GPU: aspetto il motore ({type(e).__name__}).")
                ultimo = time.time()
            await asyncio.sleep(attesa)
            attesa = min(10, attesa + 2)


if not SPACE or not CHIAVE or not PUBBLICO:
    print("Servizio GPU spento: mancano NEURONAL_GPU_SPACE, NEURONAL_GPU_KEY o l'indirizzo pubblico. Neuronal usa la CPU.")
    sys.exit(2)
asyncio.run(servi())