"""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())