Spaces:
Running
Running
Download desktop_app.py from iparaco/Virtual-LPU: direct link, hf CLI and curl.
- Browser
- Download file 10.4 kB
-
https://huggingface.co/spaces/iparaco/Virtual-LPU/resolve/main/desktop_app.py
- Command line
-
hf download hf://spaces/iparaco/Virtual-LPU/desktop_app.py
-
curl -L -o desktop_app.py https://huggingface.co/spaces/iparaco/Virtual-LPU/resolve/main/desktop_app.py
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()) | |