pg-sui 0.2.3__py3-none-any.whl → 1.6.16a3__py3-none-any.whl

pgsui/electron/app/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "pgsui-gui",
+  "version": "1.0.0",
+  "description": "PG-SUI GUI wrapper for the Python CLI",
+  "author": { "name": "Bradley T. Martin", "email": "evobio721@gmail.com" },
+  "homepage": "https://github.com/btmartin721/PG-SUI",
+  "main": "main.js",
+  "type": "commonjs",
+  "scripts": {
+    "start": "electron .",
+    "icons": "electron-icon-builder --input=ui/logo.png --output=icons --flatten",
+    "dist": "electron-builder -mwl"
+  },
+  "devDependencies": {
+    "electron": "^38.4.0",
+    "electron-builder": "^24.13.3",
+    "electron-icon-builder": "^2.0.1"
+  },
+"build": {
+    "appId": "io.pgsui.gui",
+    "directories": {
+      "buildResources": "icons",
+      "output": "dist"
+    },
+    "asar": true,
+    "extraResources": [
+      { "from": "../../cli.py", "to": "pgsui/cli.py" },
+      { "from": "extra-resources", "to": "extras" }
+    ],
+    "files": [
+      "main.js",
+      "preload.js",
+      "ui/**/*",
+      "icons/**/*"
+    ],
+    "mac": {
+      "target": ["dmg", "zip"],
+      "category": "public.app-category.science",
+      "icon": "icons/icon.icns"
+    },
+    "linux": {
+      "target": ["AppImage", "deb"],
+      "category": "Science",
+      "icon": "icons"
+    },
+    "win": {
+      "target": ["nsis"],
+      "icon": "icons/icon.ico"
+    }
+  }
+}

pgsui/electron/app/preload.js

@@ -0,0 +1,15 @@
+const { contextBridge, ipcRenderer } = require('electron');
+
+contextBridge.exposeInMainWorld('pgsui', {
+  detectPgSui: () => ipcRenderer.invoke('detect:pgsui'),
+  start: (payload) => ipcRenderer.invoke('pgsui:start', payload),
+  stop: () => ipcRenderer.invoke('pgsui:stop'),
+  pickFile: (filters) => ipcRenderer.invoke('pick:file', { filters }),
+  pickDir: () => ipcRenderer.invoke('pick:dir'),
+  pickSave: (defaultPath) => ipcRenderer.invoke('pick:save', { defaultPath }),
+  onLog: (fn) => ipcRenderer.on('pgsui:log', (_e, d) => fn(d)),
+  onError: (fn) => ipcRenderer.on('pgsui:error', (_e, d) => fn(d)),
+  onExit: (fn) => ipcRenderer.on('pgsui:exit', (_e, d) => fn(d)),
+  onStarted: (fn) => ipcRenderer.on('pgsui:started', (_e, d) => fn(d)),
+  defaultCli: () => ipcRenderer.invoke('default:cli'),
+});

pgsui/electron/app/server.py

@@ -0,0 +1,157 @@
+from __future__ import annotations
+
+import asyncio
+import os
+import signal
+import shutil
+from pathlib import Path
+
+from fastapi import FastAPI, Query, WebSocket, WebSocketDisconnect
+from fastapi.responses import HTMLResponse
+from fastapi.staticfiles import StaticFiles
+
+ROOT = Path(__file__).resolve().parent / "ui"
+WORK = Path("/work")
+app = FastAPI()
+_proc = None
+_log_queue: asyncio.Queue[str] = asyncio.Queue()
+
+
+def _build_args(p: dict[str, str | int | bool | list[str] | None]) -> list[str]:
+    a: list[str] = []
+
+    def kv(flag, v):
+        if v not in (None, "", []):
+            a.extend([flag, str(v)])
+
+    def fl(flag, cond):
+        if cond:
+            a.append(flag)
+
+    kv("--input", p.get("inputPath"))
+    kv("--format", p.get("format"))
+    kv("--popmap", p.get("popmapPath"))
+    kv("--prefix", p.get("prefix"))
+    kv("--config", p.get("yamlPath"))
+    kv("--dump-config", p.get("dumpConfigPath"))
+    kv("--preset", p.get("preset") or "fast")
+    kv("--sim-strategy", p.get("simStrategy"))
+    m = p.get("models") or []
+    if m:
+        a.extend(["--models", *m])
+    inc = p.get("includePops") or []
+    if inc:
+        a.extend(["--include-pops", *inc])
+    fl("--tune", bool(p.get("tune")))
+    if p.get("tuneNTrials"):
+        kv("--tune-n-trials", p["tuneNTrials"])
+    kv("--batch-size", p.get("batchSize") or 64)
+    dev = p.get("device")
+    if dev in ("cpu", "cuda", "mps"):
+        kv("--device", dev)
+    if p.get("nJobs"):
+        kv("--n-jobs", p["nJobs"])
+    pf = p.get("plotFormat")
+    if pf in ("png", "pdf", "svg"):
+        kv("--plot-format", pf)
+    if p.get("seed"):
+        kv("--seed", p["seed"])
+    fl("--verbose", bool(p.get("verbose")))
+    if p.get("logFile"):
+        kv("--log-file", p["logFile"])
+    fl("--force-popmap", bool(p.get("forcePopmap")))
+    fl("--dry-run", bool(p.get("dryRun")))
+    for kvp in p.get("setPairs") or []:
+        if isinstance(kvp, str) and "=" in kvp:
+            a.extend(["--set", kvp])
+    return a
+
+
+@app.get("/api/status")
+def status():
+    return {"running": _proc is not None}
+
+
+@app.get("/api/ls")
+def ls(path: str = Query("/work")):
+    p = Path(path).resolve()
+    if not str(p).startswith(str(WORK)):
+        return {"ok": False, "error": "out_of_root"}
+    items = [
+        {"name": e.name, "path": str(e), "dir": e.is_dir()} for e in sorted(p.iterdir())
+    ]
+    return {"ok": True, "cwd": str(p), "items": items}
+
+
+@app.post("/api/start")
+async def start(payload: dict):
+    global _proc
+    if _proc:
+        return {"ok": False, "error": "already_running"}
+    cwd = Path(payload.get("cwd") or "/work").resolve()
+    if not str(cwd).startswith(str(WORK)):
+        return {"ok": False, "error": "cwd_must_be_under_/work"}
+    args = _build_args(payload)
+    use_pg = bool(payload.get("usePgSui", True))
+    if use_pg:
+        cmd = ["pg-sui", *args]
+    else:
+        py_candidates = [
+            payload.get("pythonPath"),
+            os.environ.get("PGSUI_PYTHON"),
+            "/opt/homebrew/bin/python3.12",
+            "/usr/local/bin/python3.12",
+            "python3.12",
+            "python3",
+            "python",
+        ]
+        py = next((c for c in py_candidates if c and shutil.which(c)), "python3")
+        cli = payload.get("cliPath")
+        if not cli:
+            return {"ok": False, "error": "cli_path_required"}
+        cmd = [py, cli, *args]
+    _proc = await asyncio.create_subprocess_exec(
+        *cmd,
+        cwd=str(cwd),
+        stdout=asyncio.subprocess.PIPE,
+        stderr=asyncio.subprocess.PIPE,
+        env=os.environ.copy(),
+    )
+
+    async def pump(stream, tag):
+        async for line in stream:
+            await _log_queue.put(f"{tag}|{line.decode(errors='ignore').rstrip()}")
+
+    asyncio.create_task(pump(_proc.stdout, "stdout"))
+    asyncio.create_task(pump(_proc.stderr, "stderr"))
+    return {"ok": True, "argv": cmd, "cwd": str(cwd)}
+
+
+@app.post("/api/stop")
+async def stop():
+    global _proc
+    if not _proc:
+        return {"ok": False, "error": "not_running"}
+    try:
+        _proc.send_signal(signal.SIGTERM)
+        try:
+            await asyncio.wait_for(_proc.wait(), timeout=5)
+        except asyncio.TimeoutError:
+            _proc.kill()
+    finally:
+        _proc = None
+    return {"ok": True}
+
+
+@app.websocket("/api/logs")
+async def logs(ws: WebSocket):
+    await ws.accept()
+    try:
+        while True:
+            msg = await _log_queue.get()
+            await ws.send_text(msg)
+    except WebSocketDisconnect:
+        return
+
+
+app.mount("/", StaticFiles(directory=ROOT, html=True), name="ui")

pgsui/electron/app/ui/renderer.js

@@ -0,0 +1,131 @@
+/* ---- helpers (define first) ---- */
+const $ = (id) => document.getElementById(id);
+const logEl = $('log');
+
+function appendLog({ stream, line }) {
+  const span = document.createElement('span');
+  if (stream === 'stderr') span.className = 'err';
+  span.textContent = line + '\n';
+  logEl.appendChild(span);
+  if (logEl.textContent.length > 2_000_000) logEl.textContent = logEl.textContent.slice(-1_000_000);
+  logEl.scrollTop = logEl.scrollHeight;
+}
+
+/* ---- payload ---- */
+function collectPayload() {
+  const modelsSel = Array.from($('models').selectedOptions).map(o => o.value);
+  const includePops = $('includePops').value.trim().split(/\s+/).filter(Boolean);
+  const setPairs = $('setPairs').value.split('\n').map(s => s.trim()).filter(Boolean);
+  const bs = $('batchSize').value ? Number($('batchSize').value) : 64;
+  return {
+    pythonPath: undefined,
+    cliPath: undefined,
+    cwd: $('cwd').value.trim(),
+    inputPath: $('inputPath').value.trim(),
+    format: $('format').value,
+    popmapPath: $('popmapPath').value.trim() || undefined,
+    prefix: $('prefix').value.trim() || undefined,
+    yamlPath: $('yamlPath').value.trim() || undefined,
+    dumpConfigPath: $('dumpConfigPath').value.trim() || undefined,
+    preset: $('preset').value || 'fast',
+    simStrategy: $('simStrategy').value || 'random',
+    models: modelsSel,
+    includePops,
+    device: $('device').value || undefined,
+    batchSize: bs,
+    nJobs: $('nJobs').value ? Number($('nJobs').value) : undefined,
+    plotFormat: $('plotFormat').value || undefined,
+    seed: $('seed').value.trim() || undefined,
+    verbose: $('verbose').checked,
+    forcePopmap: $('forcePopmap').checked,
+    dryRun: $('dryRun').checked,
+    setPairs,
+    logFile: $('logFile').value.trim() || undefined,
+    tune: $('tune').checked,
+    tuneNTrials: $('tune').checked ? (Number($('tuneNTrials').value) || 50) : undefined
+  };
+}
+
+function setRunningUI(isRunning) {
+  $('start').disabled = isRunning;
+  $('stop').disabled = !isRunning;
+  document.querySelectorAll('button').forEach(b => { if (b.id !== 'stop') b.disabled = isRunning; });
+}
+
+/* ---- init small UI bits ---- */
+(() => {
+  const tune = $('tune'), tuneOpts = $('tuneOpts');
+  if (tune && tuneOpts) tune.addEventListener('change', () => { tuneOpts.style.display = tune.checked ? '' : 'none'; });
+  const logoEl = $('logo');
+  if (logoEl) logoEl.addEventListener('error', () => { logoEl.style.display = 'none'; });
+})();
+
+/* ---- events (wire exactly once) ---- */
+const on = (id, ev, fn) => { const el = $(id); if (el) el.addEventListener(ev, fn); };
+
+on('pickCwd', 'click', async () => {
+  const d = await window.pgsui.pickDir();
+  if (d) $('cwd').value = d;
+});
+
+on('start', 'click', async () => {
+  try {
+    if (!window.pgsui) { appendLog({ stream:'stderr', line:'Bridge missing (preload).' }); return; }
+    logEl.textContent = '';
+    const payload = collectPayload();
+    if (!payload.cwd) { appendLog({ stream:'stderr', line:'Working directory is required.' }); return; }
+    if (!payload.inputPath) { appendLog({ stream:'stderr', line:'Input file required.' }); return; }
+    if (!payload.cliPath) {
+      const r = await window.pgsui.defaultCli?.();
+      if (r?.ok && r.path) payload.cliPath = r.path;
+    }
+    if (!payload.cliPath) { appendLog({ stream:'stderr', line:'Could not find <project_root>/pgsui/cli.py. Set PGSUI_CLI_DEFAULT or adjust repo layout.' }); return; }
+    const res = await window.pgsui.start(payload);
+    if (!res?.ok) appendLog({ stream:'stderr', line:`Start failed: ${res?.error || 'unknown error'}` });
+  } catch (e) {
+    appendLog({ stream:'stderr', line:`Start exception: ${e?.message || String(e)}` });
+  }
+});
+
+on('stop', 'click', async () => {
+  const res = await window.pgsui.stop();
+  if (!res.ok) appendLog({ stream:'stderr', line: res.error });
+});
+
+on('pickInput', 'click', async () => {
+  const fmt = $('format').value;
+  const filters = {
+    vcf: [{ name: 'VCF', extensions: ['vcf','gz'] }],
+    phylip: [{ name: 'PHYLIP', extensions: ['phy','phylip'] }],
+    structure: [{ name: 'STRUCTURE', extensions: ['str','stru'] }],
+    genepop: [{ name: 'GENEPOP', extensions: ['gen','genepop'] }]
+  }[fmt] || [{ name: 'All', extensions: ['*'] }];
+  const f = await window.pgsui.pickFile(filters);
+  if (f) $('inputPath').value = f;
+});
+on('pickPopmap', 'click', async () => {
+  const f = await window.pgsui.pickFile();
+  if (f) $('popmapPath').value = f;
+});
+on('pickYaml', 'click', async () => {
+  const f = await window.pgsui.pickFile([{ name: 'YAML', extensions: ['yml','yaml'] }]);
+  if (f) $('yamlPath').value = f;
+});
+on('pickDump', 'click', async () => {
+  const f = await window.pgsui.pickSave('effective.yaml');
+  if (f) $('dumpConfigPath').value = f;
+});
+on('pickLogFile', 'click', async () => {
+  const f = await window.pgsui.pickSave('pgsui-run.log');
+  if (f) $('logFile').value = f;
+});
+
+/* ---- streams ---- */
+window.pgsui.onLog(appendLog);
+window.pgsui.onError((e) => appendLog({ stream:'stderr', line: e.message || String(e) }));
+window.pgsui.onExit(({ code }) => { appendLog({ stream:'stdout', line:`Process exited with code ${code}` }); setRunningUI(false); });
+window.pgsui.onStarted(({ argv, cwd }) => {
+  appendLog({ stream:'stdout', line:`Started: ${argv?.join(' ') || ''}` });
+  appendLog({ stream:'stdout', line:`CWD: ${cwd}` });
+  setRunningUI(true);
+});

pgsui/electron/app/ui/styles.css

@@ -0,0 +1,59 @@
+:root{
+  --bg:#0b0f14; --panel:#0f1621; --muted:#8aa0b4; --text:#e7eef7;
+  --accent:#3aa0ff; --accent-2:#8b5cf6; --danger:#ef4444; --ok:#22c55e;
+  --border:#1b2433; --mono: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", monospace;
+  --sans: Inter, ui-sans-serif, system-ui, -apple-system, Segoe UI, Roboto, "Helvetica Neue", Arial, "Noto Sans", "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol";
+}
+*{box-sizing:border-box}
+html,body{height:100%}
+body{
+  margin:0; background:
+  radial-gradient(1200px 600px at 10% -10%, rgba(58,160,255,.12), transparent 60%),
+  radial-gradient(900px 500px at 120% -20%, rgba(139,92,246,.10), transparent 60%),
+  var(--bg);
+  color:var(--text); font-family:var(--sans);
+}
+.titlebar{height:64px; display:flex; align-items:center; padding:12px 20px 0}
+.logo-row{display:flex; gap:12px; align-items:center}
+.logo{width:40px; height:40px; border-radius:10px; box-shadow:0 6px 18px rgba(0,0,0,.4)}
+h1{margin:0; font-weight:700; letter-spacing:.2px}
+.subtitle{margin:2px 0 0; color:var(--muted); font-size:12px}
+
+main{padding:12px 20px; max-width:1200px; margin:0 auto}
+.card{
+  background:linear-gradient(180deg, rgba(255,255,255,.02), rgba(255,255,255,.00));
+  border:1px solid var(--border); border-radius:16px; padding:16px; margin:12px 0;
+  box-shadow:0 8px 30px rgba(0,0,0,.25);
+}
+h2{margin:0 0 12px 0; font-size:16px; color:#cfe6ff}
+.muted{color:var(--muted); font-size:12px}
+
+.grid{
+  display:grid; gap:12px;
+  grid-template-columns: repeat(3, minmax(260px, 1fr));
+}
+.grid .colspan{grid-column:1 / -1}
+label{display:block; font-size:12px; color:var(--muted); margin:0 0 6px}
+input,select,textarea{
+  width:100%; padding:10px 12px; border-radius:10px; border:1px solid var(--border);
+  background:#0d1420; color:var(--text); outline:none;
+}
+input:focus,select:focus,textarea:focus{border-color:var(--accent)}
+textarea{resize:vertical}
+.hstack{display:flex; gap:8px}
+button{
+  border:none; border-radius:10px; padding:10px 14px; cursor:pointer; color:#fff;
+  background:#1c2433; border:1px solid var(--border);
+}
+button.primary{background:linear-gradient(90deg, var(--accent), var(--accent-2))}
+button.danger{background:linear-gradient(90deg, var(--danger), #f97316)}
+button.ghost{background:transparent; border:1px solid var(--border)}
+button:disabled{opacity:.5; cursor:not-allowed}
+.controls{display:flex; gap:10px; margin:12px 0}
+
+.log{
+  background:#06090f; color:#e0e8f5; border:1px solid var(--border); border-radius:12px;
+  padding:12px; height:340px; overflow:auto; font-family:var(--mono); font-size:12px; line-height:1.35;
+  white-space:pre-wrap; word-break:break-word;
+}
+.log .err{color:#ff8a8a}

pgsui/electron/app/ui/ui_shim.js

@@ -0,0 +1,72 @@
+// ui-shim.js: Browser shim for Electron's window.pgsui API
+
+(function () {
+    function wsConnect(onLog) {
+        const ws = new WebSocket(`ws://${location.host}/api/logs`);
+        ws.onmessage = (e) => {
+        const s = e.data.indexOf('|');
+            if (s > 0) {
+                const stream = e.data.slice(0, s);
+                const line = e.data.slice(s + 1);
+                onLog({ stream, line });
+        }
+    };
+        ws.onerror = () => {/* no-op */};
+        return ws;
+    }
+
+    const listeners = { log: [], error: [], exit: [], started: [] };
+    function emit(type, payload) { listeners[type].forEach(fn => fn(payload)); }
+
+    let ws = null;
+
+    const api = {
+        // Electron feature parity stubs
+        pickFile: async () => null,   // Browser cannot provide host filesystem paths
+        pickDir: async () => null,
+        pickSave: async () => null,
+
+        // Detect pg-sui presence by calling the API once we start; return optimistic true
+        detectPgSui: async () => ({ ok: true }),
+
+        // Start/stop map to REST
+        start: async (payload) => {
+            try {
+                const r = await fetch('/api/start', {
+                method: 'POST', headers: { 'content-type': 'application/json' },
+                body: JSON.stringify(payload)
+            });
+                const j = await r.json();
+                if (!j.ok) return j;
+                emit('started', { argv: j.argv || [], cwd: j.cwd || '' });
+                if (!ws) ws = wsConnect((m) => emit('log', m));
+                return { ok: true };
+            } catch (e) {
+                emit('error', { message: String(e) });
+                return { ok: false, error: String(e) };
+            }
+        },
+        stop: async () => {
+            try {
+                const r = await fetch('/api/stop', { method: 'POST' });
+                const j = await r.json();
+                if (!j.ok) return j;
+                emit('exit', { code: 0 });
+                return { ok: true };
+            } catch (e) {
+                emit('error', { message: String(e) });
+                return { ok: false, error: String(e) };
+            }
+        },
+
+    // Event wiring
+    onLog:   (fn) => { listeners.log.push(fn); },
+    onError: (fn) => { listeners.error.push(fn); },
+    onExit:  (fn) => { listeners.exit.push(fn); },
+    onStarted: (fn) => { listeners.started.push(fn); },
+    };
+
+    // Expose only if Electron preload didn't define it
+    if (!window.pgsui) window.pgsui = api;
+
+})();

pgsui/electron/bootstrap.py

@@ -0,0 +1,43 @@
+from __future__ import annotations
+
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+
+APP_DIR = Path(__file__).resolve().parent / "app"
+
+
+def _which(cmd: str) -> str | None:
+    return shutil.which(cmd)
+
+
+def main() -> int:
+    if not APP_DIR.exists():
+        print(f"[pgsui-gui-setup] Missing Electron app at {APP_DIR}", file=sys.stderr)
+        return 2
+
+    node = _which("node")
+    npm = _which("npm")
+    if not node or not npm:
+        print(
+            "[pgsui-gui-setup] Node.js and npm are required. Install from https://nodejs.org/",
+            file=sys.stderr,
+        )
+        return 2
+
+    # Prefer deterministic installs if package-lock.json exists
+    lock = APP_DIR / "package-lock.json"
+    cmd = ["npm", "ci"] if lock.exists() else ["npm", "install"]
+    try:
+        print(f"[pgsui-gui-setup] Running: {' '.join(cmd)} in {APP_DIR}")
+        subprocess.check_call(cmd, cwd=str(APP_DIR))
+        print("[pgsui-gui-setup] Done.")
+        return 0
+    except subprocess.CalledProcessError as e:
+        print(f"[pgsui-gui-setup] Failed: {e}", file=sys.stderr)
+        return e.returncode
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

pgsui/electron/launch.py

@@ -0,0 +1,57 @@
+from __future__ import annotations
+
+import os
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+
+APP_DIR = Path(__file__).resolve().parent / "app"
+
+
+def _bin(path: Path, name: str) -> Path:
+    # node_modules/.bin on POSIX, node_modules\\.bin on Windows
+    d = path / ("node_modules/.bin" if os.name != "nt" else r"node_modules\.bin")
+    exe = name + (".cmd" if os.name == "nt" else "")
+    return d / exe
+
+
+def main() -> int:
+    if not APP_DIR.exists():
+        print(f"[pgsui-gui] Missing Electron app at {APP_DIR}", file=sys.stderr)
+        return 2
+
+    # Resolve electron binary: local install first, else global npx fallback
+    local_electron = _bin(APP_DIR, "electron")
+    npx = shutil.which("npx")
+
+    env = os.environ.copy()
+    env.setdefault("PGSUI_PYTHON", sys.executable)
+    env.setdefault("PGSUI_CLI_DEFAULT", str(Path(__file__).resolve().parents[1] / "cli.py"))
+
+    try:
+        if local_electron.exists():
+            cmd = [str(local_electron), "."]
+            proc = subprocess.Popen(cmd, cwd=str(APP_DIR), env=env)
+        elif npx:
+            # Uses Electron from registry on demand
+            cmd = ["npx", "electron", "."]
+            proc = subprocess.Popen(cmd, cwd=str(APP_DIR), env=env)
+        else:
+            print(
+                "[pgsui-gui] Electron is not installed. Run: pgsui-gui-setup",
+                file=sys.stderr,
+            )
+            return 2
+
+        proc.wait()
+        return proc.returncode or 0
+    except KeyboardInterrupt:
+        return 130
+    except FileNotFoundError as e:
+        print(f"[pgsui-gui] Failed to start Electron: {e}", file=sys.stderr)
+        return 2
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

pgsui/electron/package.json

@@ -0,0 +1,14 @@
+{
+  "name": "pgsui-gui-root",
+  "private": true,
+  "scripts": {
+    "start": "electron app",
+    "dist": "electron-builder -mwl --projectDir app",
+    "icons": "electron-icon-builder --input=app/ui/logo.png --output=app/icons --flatten"
+  },
+  "devDependencies": {
+    "electron": "^38.4.0",
+    "electron-builder": "^24.13.3",
+    "electron-icon-builder": "^2.0.1"
+  }
+}