Virtual-LPU / desktop_app.py
iparaco's picture
Upload 118 files
e59bd9d verified
Raw History Blame Contribute Delete
10.4 kB
"""LPU AI Accelerator V7.1 — NATIVE desktop app (no browser window).
Runs the SAME FastAPI server + dashboard, but inside a real OS window via
`pywebview` (WebView2 on Windows 11 — an embedded runtime, not a browser
window: no address bar, its own taskbar entry, native close/minimize).
Modes resolved automatically:
1. native — server started here + native window (default)
2. native-attached — an accelerator server is ALREADY running on the
port: just open a second window on it and never
start a duplicate server
3. browser fallback — pywebview missing OR window creation failed:
honest fallback to the plain loopback server +
system browser, with a clear one-line reason
V7.1.1 hardening (user report: `run_lpu.py --desktop` did nothing and a
Windows Electron/Chromium warning was printed — the .py file association
handed the script to an Electron app, so Python never ran at all; use the
new .cmd launchers, which call python.exe explicitly):
- if pywebview import OR window creation raises, we fall back to browser
mode WITH the reason printed (never silently exit, never a fake window)
- the fallback serve loop is interruptible in-process via
request_shutdown() (tests call it instead of killing the thread)
- Ctrl+C still stops ONLY this app's accelerator; training untouched
Guarantees (unchanged):
- closing the window stops ONLY the server/accelerator owned by THIS app;
training processes are never touched (attach mode never stops anything)
- loopback only; if an LPU server is already on the port we attach to it,
if something ELSE occupies the port we move to the next free port
- every mode is fully testable headless (server thread lifecycle + attach
detection + fallback routing + window-failure fallback) — the window
itself needs a display and is exercised on the rig
"""
from __future__ import annotations
import json
import sys
import threading
import time
import urllib.error
import urllib.request
from pathlib import Path
from typing import Optional
import uvicorn
ROOT = Path(__file__).resolve().parent
WINDOW_TITLE = "LPU AI Accelerator — Intelligent Training Control Center"
DEFAULT_SIZE = (1440, 920)
MIN_SIZE = (1024, 660)
# in-process shutdown signal for the fallback serve loop (tests + embedders)
_SHUTDOWN = threading.Event()
def request_shutdown() -> None:
"""Ask a running fallback session to unwind (idempotent, thread-safe)."""
_SHUTDOWN.set()
def _reset_shutdown() -> None:
_SHUTDOWN.clear()
def _pywebview():
try:
import webview # noqa: PLC0415 - optional dependency, lazy import
return webview
except Exception: # noqa: BLE001 - missing or no GUI backend
return None
def _get_status(host: str, port: int, timeout: float = 1.5) -> Optional[dict]:
"""Read /api/status over loopback. None = nothing answering."""
url = f"http://{host}:{port}/api/status"
try:
with urllib.request.urlopen(url, timeout=timeout) as resp:
return json.loads(resp.read().decode("utf-8"))
except (urllib.error.URLError, OSError, ValueError):
return None
def is_lpu_server_running(host: str, port: int) -> bool:
st = _get_status(host, port)
return bool(st) and str(st.get("runtime_version", "")).startswith("7.") \
and "accelerator_status" in st
def find_port(host: str, start_port: int, tries: int = 10) -> int:
"""First port that either hosts OUR accelerator (attach) or is free.
Ports occupied by NON-LPU services are skipped, never hijacked."""
for port in range(start_port, start_port + tries):
if is_lpu_server_running(host, port):
return port # attach case: same port returned
probe = _get_status(host, port)
if probe is None:
import socket
with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
s.settimeout(0.4)
try:
s.bind((host, port))
return port # truly free
except OSError:
continue # occupied by something else
raise RuntimeError(
f"no free port in {start_port}..{start_port + tries - 1} "
f"(all busy or occupied by non-LPU services)")
class ServerThread:
"""uvicorn in a daemon thread with readiness polling + clean stop."""
def __init__(self, app, host: str, port: int):
config = uvicorn.Config(app, host=host, port=port, log_level="warning")
self.server = uvicorn.Server(config)
self.host, self.port = host, port
self.thread = threading.Thread(target=self.server.run,
name="lpu-server", daemon=True)
self._ready = threading.Event()
def start(self, timeout: float = 20.0) -> bool:
self.thread.start()
deadline = time.time() + timeout
while time.time() < deadline:
if self.server.should_exit:
return False
if _get_status(self.host, self.port, timeout=0.8) is not None:
self._ready.set()
return True
time.sleep(0.1)
return False
def stop(self, timeout: float = 8.0) -> None:
"""Stop ONLY this server (training processes are never touched)."""
self.server.should_exit = True
self.thread.join(timeout=timeout)
def _serve_until_closed(server_thread: "ServerThread",
poll: float = 0.5) -> None:
"""Fallback serve loop: run until the thread dies, Ctrl+C, or an
in-process request_shutdown() (unwindable without killing anything)."""
try:
while server_thread.thread.is_alive():
if _SHUTDOWN.is_set():
break
time.sleep(poll)
except KeyboardInterrupt:
pass
def launch_desktop(config: Optional[dict] = None, host: str = "127.0.0.1",
start_port: int = 8710,
fallback_open_browser: bool = True) -> dict:
"""Resolve the mode and run the app. Blocking (returns after the window
closes). Returns {'mode': ..., 'port': ...} for tests and logging."""
_reset_shutdown()
cfg = config or {}
from server.app import create_app
# security rule kept: non-loopback host => expose+token in config
if host not in ("127.0.0.1", "localhost", "::1"):
srv = cfg.setdefault("server", {})
srv["host"] = host
srv["expose"] = True
port = find_port(host, start_port)
attached = is_lpu_server_running(host, port)
url = f"http://{host}:{port}"
owns_server = False
server_thread: Optional[ServerThread] = None
if not attached:
# open_browser only applies to the plain server path, not desktop
cfg.setdefault("server", {})["open_browser"] = False
app = create_app(cfg)
server_thread = ServerThread(app, host, port)
if not server_thread.start():
raise RuntimeError("accelerator server failed to start")
owns_server = True
webview = _pywebview()
try:
if webview is not None:
try:
window = webview.create_window(
WINDOW_TITLE, url, width=DEFAULT_SIZE[0],
height=DEFAULT_SIZE[1], min_size=MIN_SIZE)
webview.start() # blocks until the window is closed
return {"mode": "native-attached" if attached else "native",
"port": port}
except Exception as exc: # noqa: BLE001
# window creation failed (no GUI backend / WebView2 missing /
# driver error) -> honest browser fallback WITH the reason
print(f"[LPU] native window unavailable ({exc}) -> "
"falling back to the system browser")
webview = None # fall through to the browser path
# ---- honest fallback: no pywebview or window failed ----
if webview is None and not _pywebview() and not _SHUTDOWN.is_set():
print("[LPU] pywebview is not installed -> falling back to the "
"system browser (install once with: "
"pip install pywebview)")
if fallback_open_browser and not _SHUTDOWN.is_set():
# covers BOTH cases: our own server (not attached) and an
# already-running accelerator we attached to (V7.1.1 fix:
# previously the attached case exited silently doing nothing)
try:
import webbrowser
webbrowser.open(url)
except Exception: # noqa: BLE001
pass
print(f"[LPU] Accelerator server running at {url} "
"(Ctrl+C stops ONLY the accelerator; training is untouched)")
if server_thread is not None:
_serve_until_closed(server_thread)
return {"mode": "browser-fallback", "port": port}
finally:
# attach mode: the server belongs to ANOTHER process - never stop it
if owns_server and server_thread is not None:
server_thread.stop()
print("[LPU] native window closed -> accelerator server stopped "
"(training processes untouched)")
def main(argv: Optional[list] = None) -> int:
import argparse
parser = argparse.ArgumentParser(
prog="lpu-desktop",
description="LPU AI Accelerator V7 — native desktop control center "
"(no browser required)")
parser.add_argument("--host", default="127.0.0.1")
parser.add_argument("--port", type=int, default=8710)
parser.add_argument("--config", default=None)
parser.add_argument("--no-browser-fallback", action="store_true",
help="in fallback mode, do not open the system browser")
args = parser.parse_args(argv)
cfg = {}
if args.config:
import yaml
cfg = yaml.safe_load(Path(args.config).read_text(encoding="utf-8")) or {}
result = launch_desktop(cfg, host=args.host, start_port=args.port,
fallback_open_browser=not args.no_browser_fallback)
print(f"[LPU] desktop session ended (mode={result['mode']}, "
f"port={result['port']})")
return 0
if __name__ == "__main__": # pragma: no cover
raise SystemExit(main())