Spaces:
Running
Running
File size: 23,646 Bytes
deda7a1 ad5e3da 899d656 deda7a1 e67ce48 77bdfea e67ce48 deda7a1 77bdfea cda9c71 deda7a1 cda9c71 deda7a1 ad5e3da 77bdfea ad5e3da 77bdfea 899d656 8d34056 899d656 8d34056 77bdfea 8d34056 77bdfea 8d34056 77bdfea 8d34056 899d656 ad5e3da 899d656 ad5e3da 77bdfea ad5e3da deda7a1 ad5e3da e67ce48 ad5e3da 899d656 8d34056 ad5e3da 899d656 ad5e3da 77bdfea ad5e3da 899d656 ad5e3da 77bdfea ad5e3da 77bdfea ad5e3da 77bdfea ad5e3da 77bdfea ad5e3da 77bdfea deda7a1 e67ce48 deda7a1 ad5e3da deda7a1 ad5e3da deda7a1 ad5e3da e67ce48 deda7a1 e67ce48 deda7a1 e67ce48 deda7a1 e67ce48 deda7a1 e67ce48 deda7a1 e67ce48 77bdfea e67ce48 deda7a1 e67ce48 deda7a1 e67ce48 deda7a1 e67ce48 deda7a1 e67ce48 deda7a1 899d656 8d34056 899d656 8d34056 899d656 8d34056 899d656 deda7a1 899d656 deda7a1 | 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 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 | #!/usr/bin/env python3
"""Hebrew<->Russian live translator: browser <-> this server <-> Gemini Live API.
The API key stays here (env GEMINI_API_KEY); the browser only talks to /ws."""
import os, json, asyncio, base64, time, secrets, re, pathlib, logging
import aiohttp
try:
import opus_mt # local Helsinki-NLP opus-mt he<->ru (CTranslate2 int8); optional
if not opus_mt.available(): opus_mt = None
except Exception:
opus_mt = None
from aiohttp import web, ClientSession, WSMsgType
KEY = os.environ["GEMINI_API_KEY"]
TOKEN = os.environ.get("ACCESS_TOKEN") or pathlib.Path(__file__).with_name(".token").read_text().strip()
PORT = int(os.environ.get("PORT", "8787"))
LIVE_MODEL = os.environ.get("LIVE_MODEL", "gemini-3.8-live")
# tried in order when the live model refuses the session (quota / unavailable)
LIVE_MODELS = [LIVE_MODEL] + [m for m in os.environ.get("LIVE_FALLBACK_MODELS",
"gemini-3.1-flash-live-preview,gemini-2.5-flash-native-audio-preview-12-2025").split(",") if m and m != LIVE_MODEL]
def friendly(err):
e = str(err)
if "429" in e or "RESOURCE_EXHAUSTED" in e or "quota" in e.lower(): return "Лимит Gemini (квота исчерпана)"
if "1008" in e or "not found" in e.lower() or "not supported" in e.lower(): return "Модель Gemini недоступна"
return "Ошибка Gemini"
TRANSLATE_MODEL = os.environ.get("TRANSLATE_MODEL", "gemini-3.5-live-translate-preview")
URL = "wss://generativelanguage.googleapis.com/ws/google.ai.generativelanguage.v1beta.GenerativeService.BidiGenerateContent"
# server VAD (docs: ai.google.dev/gemini-api/docs/live-api/capabilities, realtimeInputConfig.automaticActivityDetection)
VAD = {"automaticActivityDetection": {"disabled": False,
"startOfSpeechSensitivity": os.environ.get("VAD_START", "START_SENSITIVITY_HIGH"),
"endOfSpeechSensitivity": os.environ.get("VAD_END", "END_SENSITIVITY_HIGH"),
"prefixPaddingMs": int(os.environ.get("VAD_PREFIX_MS", "100")),
"silenceDurationMs": int(os.environ.get("VAD_SILENCE_MS", "400"))}}
IN_TR = json.loads(os.environ.get("IN_TR", '{"languageCodes": ["he-IL", "ru-RU"]}'))
ROOT = pathlib.Path(__file__).parent
logging.basicConfig(level=logging.INFO, format="%(asctime)s %(message)s")
log = logging.getLogger("tr")
def system_prompt(glossary: str) -> str:
p = ("You are a real-time voice interpreter between EXACTLY two languages: Russian and Hebrew. You are NOT a conversation partner.\n"
"HARD RULES:\n"
"1. The input speech is ALWAYS either Hebrew or Russian. It is NEVER Arabic, English, Yiddish or any other language, "
"even if it sounds like one. Never treat or transcribe it as another language.\n"
"2. If the speech is Russian, say ONLY its faithful Hebrew translation.\n"
"3. Otherwise (Hebrew, or anything unclear, accented, mispronounced, mumbled or not clearly Russian) ASSUME IT IS HEBREW "
"spoken by a non-native speaker (often with a Russian or other accent): interpret it as the most plausible Hebrew words "
"and say ONLY its faithful Russian translation.\n"
"4. Your output is ALWAYS only Russian or only Hebrew. Never output any other language.\n"
"Never answer questions, never add comments, greetings, explanations or the original text. Keep names as they are (transliterate). "
"Preserve meaning, tone and register; be concise. If the audio is silence or noise, say nothing.")
if glossary.strip():
p += ("\nPersonal glossary (names/terms; always use these renderings, format 'source = target'):\n" + glossary.strip()[:3000])
return p
def check(req):
if req.query.get("t") != TOKEN:
raise web.HTTPForbidden(text="bad token")
async def index(req):
check(req)
return web.FileResponse(ROOT / "public" / "index.html", headers={"Cache-Control": "no-store"})
async def save(req):
check(req)
data = await req.json()
d = ROOT / "transcripts"; d.mkdir(exist_ok=True)
fn = d / time.strftime("transcript-%Y%m%d-%H%M%S.json")
fn.write_text(json.dumps(data, ensure_ascii=False, indent=1))
return web.json_response({"saved": fn.name})
GATE = os.environ.get("GATE", "1") == "1"
VOICE = {"he": os.environ.get("VOICE_HE", "Puck"), "ru": os.environ.get("VOICE_RU", "Kore")}
HE_RE, RU_RE, LET_RE = re.compile(r"[\u0590-\u05FF]"), re.compile(r"[\u0400-\u04FF]"), re.compile(r"[^\W\d_]")
def script(t):
"""'ru' if Cyrillic, 'he' if Hebrew, 'x' other letters, None if no letters yet."""
h, r = len(HE_RE.findall(t)), len(RU_RE.findall(t))
if r > h: return "ru"
if h: return "he"
return "x" if LET_RE.search(t) else None
def target_for(inp): # deterministic: Cyrillic input -> Hebrew, anything else -> Russian
return "he" if script(inp) == "ru" else "ru"
def valid(inp, out):
"""Output must be Hebrew or Russian and must be the OTHER language of a Hebrew/Cyrillic input.
Latin-transcribed input (e.g. 'da') is ambiguous, so either direction is accepted for it."""
si, so = script(inp), script(out)
if so not in ("he", "ru"): return False
return si not in ("he", "ru") or so != si
FIX_MODELS = os.environ.get("FIX_MODELS", "gemini-3.5-flash-lite,gemini-3.8-flash").split(",")
TTS_MODELS = os.environ.get("TTS_MODELS", "gemini-3.8-flash-lite-tts").split(",")
async def gen(http, models, body, pick, timeout=8):
"""generateContent with model fallback (quota/errors); returns pick(response)."""
err = None
for m in models:
try:
async with http.post(f"https://generativelanguage.googleapis.com/v1beta/models/{m}:generateContent", json=body,
headers={"x-goog-api-key": KEY}, timeout=aiohttp.ClientTimeout(total=timeout)) as r:
d = await r.json()
if r.status == 200: return pick(d)
err = f"{m}: {r.status} {d.get('error', {}).get('status')}"
except Exception as e:
err = f"{m}: {e!r}"
log.warning("gen fail %s", err)
raise RuntimeError(err)
async def fix_translate(http, text, target, glossary):
lang = {"he": "Hebrew", "ru": "Russian"}[target]
src = "Russian" if target == "he" else "Hebrew (possibly accented or mis-transcribed; interpret as Hebrew)"
prompt = (f"Translate this {src} utterance into {lang}. Output ONLY the {lang} translation, nothing else.\n"
+ (f"Glossary (source = target):\n{glossary[:3000]}\n" if glossary.strip() else "") + f"Utterance: {text}")
return await gen(http, FIX_MODELS, {"contents": [{"parts": [{"text": prompt}]}]},
lambda d: "".join(p.get("text", "") for p in d["candidates"][0]["content"]["parts"]).strip(), FIX_TIMEOUT)
FIX_TIMEOUT = float(os.environ.get("FIX_TIMEOUT", "4"))
FALLBACK_TTS = os.environ.get("FALLBACK_TTS", "browser") # browser (instant) | gemini
OPUS = os.environ.get("OPUS", "1") == "1"
async def local_translate(text, target, glossary=""):
"""opus-mt int8 on CPU, off the event loop -> (text, missing glossary terms, method). Raises if unavailable."""
if not (OPUS and opus_mt): raise RuntimeError("opus-mt not available")
return await asyncio.to_thread(opus_mt.translate_ex, text, target, glossary)
async def text_translate(http, text, target, glossary="", use_gemini=True):
"""Fallback text translation: opus-mt and Gemini text run IN PARALLEL; first valid result wins
(opus-mt result counts only if it is in the target script and hits all glossary terms). -> (text, engine)."""
jobs = {}
if script(text) in ("he", "ru"): # Latin-transcribed / garbled ASR goes to Gemini only
jobs[asyncio.create_task(local_translate(text, target, glossary))] = "opus"
if use_gemini:
jobs[asyncio.create_task(fix_translate(http, text, target, glossary))] = "gemini"
local = None
try:
for fut in asyncio.as_completed(list(jobs)):
try: r = await fut
except Exception as e: log.warning("fallback engine failed: %r", e); continue
if isinstance(r, tuple):
out, miss, meth = r
if script(out) != target: log.warning("opus-mt wrong script: %r", out); continue
if not miss: return out, f"opus-mt/{meth}"
local = (out, f"opus-mt/{meth}-glossary-miss"); log.info("opus-mt missed glossary %r", miss)
else:
if script(r) == target: return r, "gemini"
log.warning("gemini fallback wrong script: %r", r)
finally:
for t in jobs:
if not t.done(): t.cancel()
if local: return local
raise RuntimeError("no fallback translation")
TTS_COOLDOWN = float(os.environ.get("TTS_COOLDOWN", "90")); _tts_off_until = 0.0
async def tts(http, text, target):
"""Gemini TTS; after a quota error skip it for TTS_COOLDOWN s (the browser speaks instead, no wasted round-trips)."""
global _tts_off_until
if time.time() < _tts_off_until: raise RuntimeError("tts quota cooldown")
try:
return await _tts(http, text, target)
except Exception as e:
if "429" in str(e) or "RESOURCE_EXHAUSTED" in str(e): _tts_off_until = time.time() + TTS_COOLDOWN
raise
async def _tts(http, text, target):
body = {"contents": [{"parts": [{"text": text}]}], "generationConfig": {"responseModalities": ["AUDIO"],
"speechConfig": {"voiceConfig": {"prebuiltVoiceConfig": {"voiceName": VOICE[target]}}}}}
return await gen(http, TTS_MODELS, body, lambda d: d["candidates"][0]["content"]["parts"][0]["inlineData"]["data"], 6)
class Upstream:
"""One Gemini Live session; forwards events to the browser tagged with `tag`."""
def __init__(self, http, client, tag, setup, glossary=""):
self.http, self.client, self.tag, self.setup, self.glossary = http, client, tag, setup, glossary
self.ws = None; self.ready = asyncio.Event(); self.task = None; self.fail = None; self.bytes = 0
self.gate = GATE and tag == "live"; self.stats = {"ok": 0, "fixed": 0}
self.reset()
def reset(self):
self.inp = ""; self.out = ""; self.held = []; self.state = "wait" # wait | pass | drop
self.forced = None # target language of a re-request turn
def ok(self, final=False):
if self.forced: return script(self.out) == self.forced
return valid(self.inp, self.out)
def decide(self, final=False):
"""Validate output script against the target derived from the input script."""
if self.state != "wait": return
si, so = script(self.inp), script(self.out)
if so is None and not final: return
if si is None and not final and not self.forced:
if so == "x": self.state = "drop"; return # neither Hebrew nor Russian output: always wrong
return # wait for input transcript
self.state = "pass" if self.ok() else "drop"
async def flush(self):
if self.state == "pass":
held, self.held = self.held, []
for o in held: await self.send(o)
async def fallback(self, inp, bad):
"""Wrong-language output was discarded: re-translate the transcript as text, speak it with the target's voice."""
inp = inp.strip(); tgt = target_for(inp)
if not inp: return
t0 = time.perf_counter(); txt = None; engine = None
# 1) local opus-mt (no quota, ~30-100 ms); 2) Gemini text models; 3) re-ask the live session
try:
txt, engine = await text_translate(self.http, inp, tgt, self.glossary)
except Exception as e:
log.warning("fallback translate failed: %r", e)
if not txt: # text API unavailable (quota): re-ask the live session itself, as text, with an explicit target
lang = "Hebrew" if tgt == "he" else "Russian"
self.forced = tgt
await self.send({"type": "in", "text": inp})
await self.ws.send_str(json.dumps({"clientContent": {"turns": [{"role": "user", "parts": [{"text":
f"Translate into {lang} and say ONLY the {lang} translation: {inp}"}]}], "turnComplete": True}}))
log.info("RE-REQUEST via live in=%r -> %s", inp, tgt)
return
await self.send({"type": "in", "text": inp})
if txt:
t_txt = (time.perf_counter() - t0) * 1000
await self.send({"type": "out", "text": txt, "fixed": True, "engine": engine})
try:
if FALLBACK_TTS != "gemini": raise RuntimeError("browser voice")
audio = await tts(self.http, txt, tgt)
await self.send({"type": "audio", "data": audio, "voice": VOICE[tgt]})
except Exception as e: # server TTS unavailable: let the browser speak it in the target language
log.warning("fallback tts failed: %r", e)
await self.send({"type": "speak", "text": txt, "lang": "he-IL" if tgt == "he" else "ru-RU"})
self.stats["fixed"] += 1
log.info("FIX[%s] in=%r bad=%r -> %r (text %d ms, total %d ms)", engine, inp, bad, txt, t_txt, (time.perf_counter() - t0) * 1000)
await self.send({"type": "turn"})
async def emit(self, obj, kind=None):
"""Stream events to the browser immediately; validate the output language on the fly.
On wrong language: tell the browser to cut playback (interrupted+drop) and run the text fallback."""
if not self.gate: return await self.send(obj)
if kind == "in": self.inp += obj["text"]
if kind == "out": self.out += obj["text"]
if kind == "turn":
log.info("TURN state=%s in=%r out=%r", self.state, self.inp, self.out)
if self.state == "wait": self.decide(final=True)
if self.state == "pass" and not self.ok(): await self.drop()
if self.state != "drop":
self.stats["ok"] += 1; self.reset(); return await self.send(obj)
inp, bad, was_forced = self.inp, self.out, self.forced; self.reset()
log.info("DROP in=%r out=%r%s", inp, bad, " (re-request also wrong; silent)" if was_forced else "")
if was_forced: return await self.send({"type": "turn"})
return asyncio.create_task(self.fallback(inp, bad))
if self.state == "drop": return # rest of a wrong-language turn is swallowed
if kind != "in" or not self.forced: await self.send(obj)
self.decide()
if self.state == "drop": self.state = "pass"; await self.drop()
async def drop(self):
if self.state != "drop":
self.state = "drop"; await self.send({"type": "interrupted", "drop": True})
async def start(self):
self.ws = await self.http.ws_connect(URL, headers={"x-goog-api-key": KEY}, max_msg_size=0, heartbeat=20)
await self.ws.send_str(json.dumps({"setup": self.setup}))
self.task = asyncio.create_task(self.pump())
await asyncio.wait_for(self.ready.wait(), 15)
if self.fail: raise RuntimeError(self.fail)
async def pump(self):
try:
async for m in self.ws:
if m.type not in (WSMsgType.TEXT, WSMsgType.BINARY):
break
d = json.loads(m.data)
if "setupComplete" in d:
self.ready.set(); continue
sc = d.get("serverContent")
if not sc:
if "goAway" in d: await self.send({"type": "info", "text": "goAway: session will end soon"})
continue
if "inputTranscription" in sc and sc["inputTranscription"].get("text"):
await self.emit({"type": "in", "text": sc["inputTranscription"]["text"]}, "in")
if "outputTranscription" in sc and sc["outputTranscription"].get("text"):
await self.emit({"type": "out", "text": sc["outputTranscription"]["text"]}, "out")
for part in (sc.get("modelTurn") or {}).get("parts", []):
if "inlineData" in part:
await self.emit({"type": "audio", "data": part["inlineData"]["data"]}, "audio")
if sc.get("interrupted"): await self.emit({"type": "interrupted"}, "interrupted")
if sc.get("turnComplete"): await self.emit({"type": "turn"}, "turn")
cc = self.ws.close_code; msg = f"upstream closed {cc} {getattr(self.ws, '_close_message', '') or ''} {self.ws.exception() or ''}".strip()
log.warning("UPSTREAM %s %s (ready=%s, audio in %d KB)", self.tag, msg, self.ready.is_set(), self.bytes // 1024)
if not self.ready.is_set(): self.fail = msg; self.ready.set(); return
await self.send({"type": "error", "text": f"{friendly(msg)}: {msg}", "code": cc})
if not self.client.closed: await self.client.close() # browser reconnects -> new upstream session
except Exception as e:
log.warning("UPSTREAM %s exception %r", self.tag, e)
if not self.ready.is_set(): self.fail = repr(e); self.ready.set(); return
await self.send({"type": "error", "text": f"{friendly(e)}: {e!r}"})
async def send(self, obj):
obj["src"] = self.tag
if not self.client.closed:
await self.client.send_str(json.dumps(obj, ensure_ascii=False))
async def audio(self, b64):
self.bytes += len(b64) * 3 // 4
if self.ws and not self.ws.closed:
await self.ws.send_str(json.dumps({"realtimeInput": {"audio": {"data": b64, "mimeType": "audio/pcm;rate=16000"}}}))
async def end_stream(self):
if self.ws and not self.ws.closed:
await self.ws.send_str(json.dumps({"realtimeInput": {"audioStreamEnd": True}}))
async def close(self):
if self.ws: await self.ws.close()
if self.task: self.task.cancel()
async def ws_handler(req):
check(req)
client = web.WebSocketResponse(heartbeat=25, max_msg_size=0)
await client.prepare(req)
ups = []; nbytes = 0; nmsg = 0
async with ClientSession() as http:
try:
first = await client.receive_json(timeout=30) # {"type":"start","mode":"live|translate","glossary":"..."}
mode = first.get("mode", "live")
if mode == "translate":
for lang in ("ru", "he"):
ups.append(Upstream(http, client, lang, {
"model": f"models/{TRANSLATE_MODEL}",
"generationConfig": {"responseModalities": ["AUDIO"],
"translationConfig": {"targetLanguageCode": lang, "echoTargetLanguage": False}},
"inputAudioTranscription": {}, "outputAudioTranscription": {}}))
model = TRANSLATE_MODEL
if mode == "translate":
await asyncio.gather(*(u.start() for u in ups))
else:
last = None
for model in LIVE_MODELS:
u = Upstream(http, client, "live", {
"model": f"models/{model}",
"generationConfig": {"responseModalities": ["AUDIO"]},
"systemInstruction": {"parts": [{"text": os.environ.get("TEST_PROMPT") or system_prompt(first.get("glossary", ""))}]},
"realtimeInputConfig": VAD, "inputAudioTranscription": IN_TR, "outputAudioTranscription": {}}, first.get("glossary", ""))
try:
await u.start(); ups = [u]; break
except Exception as e:
last = e; await u.close()
log.warning("live model %s failed to start: %s", model, e)
await client.send_str(json.dumps({"type": "info", "text": f"{friendly(e)} ({model}) — пробую другую модель…"}))
else:
raise RuntimeError(f"{friendly(last)}: {last}")
await client.send_str(json.dumps({"type": "ready", "mode": mode, "model": model}))
log.info("session start mode=%s model=%s ua=%s", mode, model, req.headers.get("User-Agent", "")[:120])
async for m in client:
if m.type == WSMsgType.BINARY:
nbytes += len(m.data); nmsg += 1
if nmsg == 1: log.info("first client audio frame %d bytes", len(m.data))
b64 = base64.b64encode(m.data).decode()
for u in ups: await u.audio(b64)
elif m.type == WSMsgType.TEXT:
d = json.loads(m.data)
if d.get("type") == "diag": log.info("CLIENT %s", json.dumps(d, ensure_ascii=False)[:500])
if d.get("type") == "flush":
for u in ups: await u.end_stream()
else:
break
except Exception as e:
log.exception("session error")
if not client.closed:
await client.send_str(json.dumps({"type": "error", "text": f"{friendly(e)}: {type(e).__name__}: {e}"}))
finally:
for u in ups: await u.close()
log.info("session end: client audio %d KB (%.1f s), msgs=%d, stats=%s", nbytes // 1024, nbytes / 32000, nmsg,
[u.stats for u in ups])
return client
async def translate_http(req):
"""Text-only translation with local opus-mt: GET/POST /translate?t=TOKEN&text=...[&to=he|ru][&glossary=...][&gemini=0]
(POST may send JSON {"text","to","glossary"}). Gemini text is used only if opus-mt misses a glossary term
or fails (gemini=0 disables it). Target defaults to the other language of the input script."""
check(req)
q = dict(req.query)
if req.method == "POST" and req.can_read_body:
try: q.update(await req.json())
except Exception: pass
text = (q.get("text") or "").strip()[:2000]
if not text: raise web.HTTPBadRequest(text="text required")
to = q.get("to") or target_for(text)
if to not in ("he", "ru"): raise web.HTTPBadRequest(text="to must be he or ru")
t0 = time.perf_counter()
try:
if str(q.get("gemini", "1")) == "0":
out, miss, meth = await local_translate(text, to, q.get("glossary", "")); engine = f"opus-mt/{meth}"
else:
async with ClientSession() as http:
out, engine = await text_translate(http, text, to, q.get("glossary", ""))
except Exception as e:
return web.json_response({"error": f"{type(e).__name__}: {e}"}, status=503)
return web.json_response({"text": out, "to": to, "engine": engine, "ms": round((time.perf_counter() - t0) * 1000)},
dumps=lambda o: json.dumps(o, ensure_ascii=False))
async def on_start(app):
if OPUS and opus_mt: # load both models in the background so the first fallback is fast
t0 = time.perf_counter()
try:
await asyncio.to_thread(opus_mt.preload); log.info("opus-mt loaded in %d ms", (time.perf_counter() - t0) * 1000)
except Exception as e:
log.warning("opus-mt preload failed: %r", e)
else:
log.warning("opus-mt not available; fallback uses Gemini text only")
app = web.Application(client_max_size=20 * 2**20)
async def start_preload(app): app["preload"] = asyncio.create_task(on_start(app))
app.on_startup.append(start_preload)
app.add_routes([web.get("/", index), web.get("/ws", ws_handler), web.post("/save", save),
web.get("/translate", translate_http), web.post("/translate", translate_http)])
if __name__ == "__main__":
web.run_app(app, host=os.environ.get("HOST", "127.0.0.1"), port=PORT, access_log=None)
|