chore: import upstream snapshot with attribution

2026-07-13 13:03:19 +08:00
commit 91e75e620b
3227 changed files with 1307078 additions and 0 deletions
@@ -0,0 +1,10 @@
+[bumpversion]
+current_version = 0.7.0
+commit = True
+tag = True
+tag_name = bench-ui-v{new_version}
+message = chore: bump cua-bench-ui version to {new_version}
+
+[bumpversion:file:pyproject.toml]
+search = version = "{current_version}"
+replace = version = "{new_version}"
@@ -0,0 +1,26 @@
+# Cua Bench UI
+
+Lightweight webUI window controller for Cua bench environments using pywebview
+
+## Usage
+
+```python
+from bench_ui import launch_window, get_element_rect, execute_javascript
+
+# Launch a window with inline HTML content
+pid = launch_window(html="<html><body><h1>Hello</h1></body></html>")
+
+# Get element rect in screen space
+rect = get_element_rect(pid, "h1", space="screen")
+print(rect)
+
+# Execute arbitrary JavaScript
+text = execute_javascript(pid, "document.querySelector('h1')?.textContent")
+print(text)
+```
+
+## Installation
+
+```bash
+pip install cua-bench-ui
+```
@@ -0,0 +1,3 @@
+from .api import execute_javascript, get_element_rect, launch_window
+
+__all__ = ["launch_window", "get_element_rect", "execute_javascript"]
@@ -0,0 +1,181 @@
+import json
+import os
+import subprocess
+import sys
+import tempfile
+import time
+from pathlib import Path
+from typing import Any, Dict, Optional
+from urllib import request
+from urllib.error import HTTPError, URLError
+
+import psutil
+
+# Map child PID -> listening port
+_pid_to_port: Dict[int, int] = {}
+
+
+def _post_json(url: str, payload: Dict[str, Any]) -> Dict[str, Any]:
+    data = json.dumps(payload).encode("utf-8")
+    req = request.Request(
+        url, data=data, headers={"Content-Type": "application/json"}, method="POST"
+    )
+    try:
+        with request.urlopen(req, timeout=5) as resp:
+            text = resp.read().decode("utf-8")
+            return json.loads(text)
+    except HTTPError as e:
+        try:
+            body = (e.read() or b"").decode("utf-8", errors="ignore")
+            return json.loads(body)
+        except Exception:
+            return {"error": "http_error", "status": getattr(e, "code", None)}
+    except URLError as e:
+        return {"error": "url_error", "reason": str(e.reason)}
+
+
+def _detect_port_for_pid(pid: int) -> int:
+    """Detect a listening local TCP port for the given PID using psutil.
+
+    Fails fast if psutil is unavailable or if no suitable port is found.
+    """
+    if psutil is None:
+        raise RuntimeError("psutil is required for PID->port detection. Please install psutil.")
+
+    # Scan system-wide connections and filter by PID
+    for c in psutil.net_connections(kind="tcp"):
+        if getattr(c, "pid", None) != pid:
+            continue
+        laddr = getattr(c, "laddr", None)
+        status = str(getattr(c, "status", ""))
+        if not laddr or not isinstance(laddr, tuple) or len(laddr) < 2:
+            continue
+        lip, lport = laddr[0], int(laddr[1])
+        if status.upper() != "LISTEN":
+            continue
+        if lip in ("127.0.0.1", "::1", "0.0.0.0", "::"):
+            return lport
+
+    raise RuntimeError(f"Could not detect listening port for pid {pid}")
+
+
+def launch_window(
+    url: Optional[str] = None,
+    *,
+    html: Optional[str] = None,
+    folder: Optional[str] = None,
+    title: str = "Window",
+    x: Optional[int] = None,
+    y: Optional[int] = None,
+    width: int = 600,
+    height: int = 400,
+    icon: Optional[str] = None,
+    use_inner_size: bool = False,
+    title_bar_style: str = "default",
+) -> int:
+    """Create a pywebview window in a child process and return its PID.
+
+    Preferred input is a URL via the positional `url` parameter.
+    To load inline HTML instead, pass `html=...`.
+    To serve a static folder, pass `folder=...` (path to directory).
+
+    Spawns `python -m bench_ui.child` with a JSON config passed via a temp file.
+    The child prints a single JSON line: {"pid": <pid>, "port": <port>}.
+    We cache pid->port for subsequent control calls like get_element_rect.
+    """
+    if not url and not html and not folder:
+        raise ValueError("launch_window requires either a url, html, or folder")
+
+    config = {
+        "url": url,
+        "html": html,
+        "folder": folder,
+        "title": title,
+        "x": x,
+        "y": y,
+        "width": width,
+        "height": height,
+        "icon": icon,
+        "use_inner_size": use_inner_size,
+        "title_bar_style": title_bar_style,
+    }
+
+    with tempfile.NamedTemporaryFile("w", delete=False, suffix=".json") as f:
+        json.dump(config, f)
+        cfg_path = f.name
+
+    try:
+        # Launch child process
+        proc = subprocess.Popen(
+            [sys.executable, "-m", "bench_ui.child", cfg_path],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+            text=True,
+        )
+        assert proc.stdout is not None
+        # Read first line with startup info
+        line = proc.stdout.readline().strip()
+        info = json.loads(line)
+        pid = int(info["pid"]) if "pid" in info else proc.pid
+        port = int(info["port"])  # required
+        _pid_to_port[pid] = port
+        return pid
+    finally:
+        try:
+            os.unlink(cfg_path)
+        except Exception:
+            pass
+
+
+def get_element_rect(pid: int, selector: str, *, space: str = "window"):
+    """Ask the child process to compute element client rect via injected JS.
+
+    Returns a dict like {"x": float, "y": float, "width": float, "height": float} or None if not found.
+    """
+    if pid not in _pid_to_port:
+        _pid_to_port[pid] = _detect_port_for_pid(pid)
+    port = _pid_to_port[pid]
+    url = f"http://127.0.0.1:{port}/rect"
+    last: Dict[str, Any] = {}
+    for _ in range(30):  # ~3s total
+        resp = _post_json(url, {"selector": selector, "space": space})
+        last = resp or {}
+        rect = last.get("rect") if isinstance(last, dict) else None
+        err = last.get("error") if isinstance(last, dict) else None
+        if rect is not None:
+            return rect
+        if err in ("window_not_ready", "invalid_json"):
+            time.sleep(0.1)
+            continue
+        # If other transient errors, brief retry
+        if err:
+            time.sleep(0.1)
+            continue
+        time.sleep(0.1)
+    raise RuntimeError(f"Failed to get element rect: {last}")
+
+
+def execute_javascript(pid: int, javascript: str):
+    """Execute arbitrary JavaScript in the window and return its result.
+
+    Retries briefly while the window is still becoming ready.
+    """
+    if pid not in _pid_to_port:
+        _pid_to_port[pid] = _detect_port_for_pid(pid)
+    port = _pid_to_port[pid]
+    url = f"http://127.0.0.1:{port}/eval"
+    last: Dict[str, Any] = {}
+    for _ in range(30):  # ~3s total
+        resp = _post_json(url, {"javascript": javascript})
+        last = resp or {}
+        if isinstance(last, dict):
+            if "result" in last:
+                return last["result"]
+            if last.get("error") in ("window_not_ready", "invalid_json"):
+                time.sleep(0.1)
+                continue
+            if last.get("error"):
+                time.sleep(0.1)
+                continue
+        time.sleep(0.1)
+    raise RuntimeError(f"Failed to execute JavaScript: {last}")
@@ -0,0 +1,221 @@
+import asyncio
+import json
+import os
+import random
+import socket
+import sys
+import threading
+from pathlib import Path
+from typing import Optional
+
+import webview
+from aiohttp import web
+
+
+def _get_free_port() -> int:
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+        s.bind(("127.0.0.1", 0))
+        return s.getsockname()[1]
+
+
+def _start_http_server(
+    window: webview.Window,
+    port: int,
+    ready_event: threading.Event,
+    html_content: str | None = None,
+    folder_path: str | None = None,
+):
+    async def rect_handler(request: web.Request):
+        try:
+            data = await request.json()
+        except Exception:
+            return web.json_response({"error": "invalid_json"}, status=400)
+        selector = data.get("selector")
+        space = data.get("space", "window")
+        if not isinstance(selector, str):
+            return web.json_response({"error": "selector_required"}, status=400)
+
+        # Ensure window content is loaded
+        if not ready_event.is_set():
+            # give it a short chance to finish loading
+            ready_event.wait(timeout=2.0)
+        if not ready_event.is_set():
+            return web.json_response({"error": "window_not_ready"}, status=409)
+
+        # Safely embed selector into JS
+        selector_js = json.dumps(selector)
+        if space == "screen":
+            # Compute approximate screen coordinates using window metrics
+            js = (
+                "(function(){"
+                f"const s = {selector_js};"
+                "const el = document.querySelector(s);"
+                "if(!el){return null;}"
+                "const r = el.getBoundingClientRect();"
+                "const sx = (window.screenX ?? window.screenLeft ?? 0);"
+                "const syRaw = (window.screenY ?? window.screenTop ?? 0);"
+                "const frameH = (window.outerHeight - window.innerHeight) || 0;"
+                "const sy = syRaw + frameH;"
+                "return {x:sx + r.left, y:sy + r.top, width:r.width, height:r.height};"
+                "})()"
+            )
+        else:
+            js = (
+                "(function(){"
+                f"const s = {selector_js};"
+                "const el = document.querySelector(s);"
+                "if(!el){return null;}"
+                "const r = el.getBoundingClientRect();"
+                "return {x:r.left,y:r.top,width:r.width,height:r.height};"
+                "})()"
+            )
+        try:
+            # Evaluate JS on the target window; this call is thread-safe in pywebview
+            result = window.evaluate_js(js)
+        except Exception as e:
+            return web.json_response({"error": str(e)}, status=500)
+        return web.json_response({"rect": result})
+
+    async def eval_handler(request: web.Request):
+        try:
+            data = await request.json()
+        except Exception:
+            return web.json_response({"error": "invalid_json"}, status=400)
+        code = data.get("javascript") or data.get("code")
+        if not isinstance(code, str):
+            return web.json_response({"error": "javascript_required"}, status=400)
+
+        if not ready_event.is_set():
+            ready_event.wait(timeout=2.0)
+        if not ready_event.is_set():
+            return web.json_response({"error": "window_not_ready"}, status=409)
+
+        try:
+            result = window.evaluate_js(code)
+        except Exception as e:
+            return web.json_response({"error": str(e)}, status=500)
+        return web.json_response({"result": result})
+
+    async def index_handler(request: web.Request):
+        if html_content is None:
+            return web.json_response({"status": "ok", "message": "bench-ui control server"})
+        return web.Response(text=html_content, content_type="text/html")
+
+    app = web.Application()
+
+    # If serving a folder, add static file routes
+    if folder_path:
+        app.router.add_static("/", folder_path, show_index=True)
+    else:
+        app.router.add_get("/", index_handler)
+
+    app.router.add_post("/rect", rect_handler)
+    app.router.add_post("/eval", eval_handler)
+
+    loop = asyncio.new_event_loop()
+
+    def run_loop():
+        asyncio.set_event_loop(loop)
+        runner = web.AppRunner(app)
+        loop.run_until_complete(runner.setup())
+        site = web.TCPSite(runner, "127.0.0.1", port)
+        loop.run_until_complete(site.start())
+        loop.run_forever()
+
+    t = threading.Thread(target=run_loop, daemon=True)
+    t.start()
+
+
+def main():
+    if len(sys.argv) < 2:
+        print("Usage: python -m bench_ui.child <config.json>", file=sys.stderr)
+        sys.exit(2)
+
+    cfg_path = Path(sys.argv[1])
+    cfg = json.loads(cfg_path.read_text(encoding="utf-8"))
+
+    html: Optional[str] = cfg.get("html") or ""
+    url: Optional[str] = cfg.get("url")
+    folder: Optional[str] = cfg.get("folder")
+    title: str = cfg.get("title", "Window")
+    x: Optional[int] = cfg.get("x")
+    y: Optional[int] = cfg.get("y")
+    width: int = int(cfg.get("width", 600))
+    height: int = int(cfg.get("height", 400))
+    icon: Optional[str] = cfg.get("icon")
+    use_inner_size: bool = bool(cfg.get("use_inner_size", False))
+    title_bar_style: str = cfg.get("title_bar_style", "default")
+
+    # Choose port early so we can point the window to it when serving inline HTML or folder
+    port = _get_free_port()
+
+    # Create window
+    if url:
+        window = webview.create_window(
+            title,
+            url=url,
+            width=width,
+            height=height,
+            x=x,
+            y=y,
+            confirm_close=False,
+            text_select=True,
+            background_color="#FFFFFF",
+        )
+        html_for_server = None
+        folder_for_server = None
+    elif folder:
+        # Serve static folder at control server root and point window to index.html
+        resolved_url = f"http://127.0.0.1:{port}/index.html"
+        window = webview.create_window(
+            title,
+            url=resolved_url,
+            width=width,
+            height=height,
+            x=x,
+            y=y,
+            confirm_close=False,
+            text_select=True,
+            background_color="#FFFFFF",
+        )
+        html_for_server = None
+        folder_for_server = folder
+    else:
+        # Serve inline HTML at control server root and point window to it
+        resolved_url = f"http://127.0.0.1:{port}/"
+        window = webview.create_window(
+            title,
+            url=resolved_url,
+            width=width,
+            height=height,
+            x=x,
+            y=y,
+            confirm_close=False,
+            text_select=True,
+            background_color="#FFFFFF",
+        )
+        html_for_server = html
+        folder_for_server = None
+
+    # Track when the page is loaded so JS execution succeeds
+    window_ready = threading.Event()
+
+    def _on_loaded():
+        window_ready.set()
+
+    window.events.loaded += _on_loaded  # type: ignore[attr-defined]
+
+    # Start HTTP server for control (and optionally serve inline HTML or static folder)
+    _start_http_server(
+        window, port, window_ready, html_content=html_for_server, folder_path=folder_for_server
+    )
+
+    # Print startup info for parent to read
+    print(json.dumps({"pid": os.getpid(), "port": port}), flush=True)
+
+    # Start GUI (blocking)
+    webview.start(debug=os.environ.get("CUA_BENCH_UI_DEBUG", "false").lower() in ("true", "1"))
+
+
+if __name__ == "__main__":
+    main()
@@ -0,0 +1,43 @@
+from __future__ import annotations
+
+import os
+import time
+from pathlib import Path
+
+from bench_ui import execute_javascript, get_element_rect, launch_window
+
+
+def main():
+    os.environ["CUA_BENCH_UI_DEBUG"] = "1"
+
+    # Get the path to the gui folder
+    gui_folder = Path(__file__).parent / "gui"
+
+    # Launch a window serving the static folder
+    pid = launch_window(
+        folder=str(gui_folder),
+        title="Static Folder Example",
+        width=800,
+        height=600,
+    )
+    print(f"Launched window with PID: {pid}")
+    print(f"Serving folder: {gui_folder}")
+
+    # Give the window a moment to render
+    time.sleep(1.5)
+
+    # Query the client rect of the button element
+    rect = get_element_rect(pid, "#testButton", space="window")
+    print("Button rect (window space):", rect)
+
+    # Check if button has been clicked
+    clicked = execute_javascript(pid, "document.getElementById('testButton').disabled")
+    print("Button clicked:", clicked)
+
+    # Get the page title
+    title = execute_javascript(pid, "document.title")
+    print("Page title:", title)
+
+
+if __name__ == "__main__":
+    main()
@@ -0,0 +1,40 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Static Folder Example</title>
+    <link rel="stylesheet" href="styles.css" />
+  </head>
+
+  <body>
+    <div class="container">
+      <h1>Static Folder Example</h1>
+      <p>This page is served from a static folder using bench-ui!</p>
+
+      <div class="image-container">
+        <img src="logo.svg" alt="Example SVG Logo" class="logo" />
+      </div>
+
+      <div class="info">
+        <p>This example demonstrates:</p>
+        <ul>
+          <li>Serving a static folder with bench-ui</li>
+          <li>Loading external CSS files (styles.css)</li>
+          <li>Loading SVG images (logo.svg)</li>
+        </ul>
+      </div>
+
+      <button id="testButton" class="btn">Click Me!</button>
+      <p id="status"></p>
+    </div>
+
+    <script>
+      document.getElementById('testButton').addEventListener('click', function () {
+        document.getElementById('status').textContent = 'Button clicked! ✓';
+        this.disabled = true;
+        this.textContent = 'Clicked!';
+      });
+    </script>
+  </body>
+</html>
@@ -0,0 +1,24 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 200 200">
+  <defs>
+    <linearGradient id="grad1" x1="0%" y1="0%" x2="100%" y2="100%">
+      <stop offset="0%" style="stop-color:#667eea;stop-opacity:1" />
+      <stop offset="100%" style="stop-color:#764ba2;stop-opacity:1" />
+    </linearGradient>
+  </defs>
+  
+  <!-- Background circle -->
+  <circle cx="100" cy="100" r="95" fill="url(#grad1)" />
+  
+  <!-- Window icon -->
+  <rect x="50" y="50" width="100" height="100" rx="8" fill="white" opacity="0.9" />
+  
+  <!-- Window panes -->
+  <line x1="100" y1="50" x2="100" y2="150" stroke="url(#grad1)" stroke-width="4" />
+  <line x1="50" y1="100" x2="150" y2="100" stroke="url(#grad1)" stroke-width="4" />
+  
+  <!-- Decorative dots -->
+  <circle cx="75" cy="75" r="8" fill="url(#grad1)" />
+  <circle cx="125" cy="75" r="8" fill="url(#grad1)" />
+  <circle cx="75" cy="125" r="8" fill="url(#grad1)" />
+  <circle cx="125" cy="125" r="8" fill="url(#grad1)" />
+</svg>
@@ -0,0 +1,100 @@
+body {
+  font-family:
+    system-ui,
+    -apple-system,
+    BlinkMacSystemFont,
+    'Segoe UI',
+    Roboto,
+    sans-serif;
+  margin: 0;
+  padding: 20px;
+  background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+  min-height: 100vh;
+  display: flex;
+  justify-content: center;
+  align-items: center;
+}
+
+.container {
+  background: white;
+  border-radius: 12px;
+  padding: 40px;
+  box-shadow: 0 20px 60px rgba(0, 0, 0, 0.3);
+  max-width: 600px;
+  width: 100%;
+}
+
+h1 {
+  color: #333;
+  margin-top: 0;
+  font-size: 2em;
+}
+
+p {
+  color: #666;
+  line-height: 1.6;
+}
+
+.image-container {
+  display: flex;
+  justify-content: center;
+  margin: 30px 0;
+}
+
+.logo {
+  width: 150px;
+  height: 150px;
+}
+
+.info {
+  background: #f8f9fa;
+  border-left: 4px solid #667eea;
+  padding: 20px;
+  margin: 20px 0;
+  border-radius: 4px;
+}
+
+.info ul {
+  margin: 10px 0;
+  padding-left: 20px;
+}
+
+.info li {
+  color: #555;
+  margin: 8px 0;
+}
+
+.btn {
+  background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+  color: white;
+  border: none;
+  padding: 12px 30px;
+  font-size: 16px;
+  border-radius: 6px;
+  cursor: pointer;
+  transition:
+    transform 0.2s,
+    box-shadow 0.2s;
+  font-weight: 600;
+}
+
+.btn:hover:not(:disabled) {
+  transform: translateY(-2px);
+  box-shadow: 0 5px 15px rgba(102, 126, 234, 0.4);
+}
+
+.btn:active:not(:disabled) {
+  transform: translateY(0);
+}
+
+.btn:disabled {
+  opacity: 0.6;
+  cursor: not-allowed;
+}
+
+#status {
+  margin-top: 15px;
+  font-weight: 600;
+  color: #28a745;
+  font-size: 18px;
+}
@@ -0,0 +1,80 @@
+from __future__ import annotations
+
+import os
+import time
+from pathlib import Path
+
+from bench_ui import execute_javascript, get_element_rect, launch_window
+
+HTML = """
+<!doctype html>
+<html>
+  <head>
+    <meta charset="utf-8" />
+    <title>Bench UI Example</title>
+    <style>
+      body { font-family: system-ui, sans-serif; margin: 24px; }
+      #target { width: 220px; height: 120px; background: #4f46e5; color: white; display: flex; align-items: center; justify-content: center; border-radius: 8px; }
+    </style>
+  </head>
+  <body>
+    <h1>Bench UI Example</h1>
+    <div id="target">Hello from pywebview</div>
+
+    
+    <h1>Click the button</h1>
+    <button id="submit" class="btn" data-instruction="the button">Submit</button>
+    <script>
+        window.__submitted = false;
+        document.getElementById('submit').addEventListener('click', function() {
+            window.__submitted = true;
+            this.textContent = 'Submitted!';
+            this.disabled = true;
+        });
+    </script>
+  </body>
+</html>
+"""
+
+
+def main():
+    os.environ["CUA_BENCH_UI_DEBUG"] = "1"
+
+    # Launch a window with inline HTML content
+    pid = launch_window(
+        html=HTML,
+        title="Bench UI Example",
+        width=800,
+        height=600,
+    )
+    print(f"Launched window with PID: {pid}")
+
+    # Give the window a brief moment to render
+    time.sleep(1.0)
+
+    # Query the client rect of an element via CSS selector in SCREEN space
+    rect = get_element_rect(pid, "#target", space="screen")
+    print("Element rect (screen space):", rect)
+
+    # Take a screenshot and overlay the bbox
+    try:
+        from PIL import ImageDraw, ImageGrab
+
+        img = ImageGrab.grab()  # full screen
+        draw = ImageDraw.Draw(img)
+        x, y, w, h = rect["x"], rect["y"], rect["width"], rect["height"]
+        box = (x, y, x + w, y + h)
+        draw.rectangle(box, outline=(255, 0, 0), width=3)
+        out_path = Path(__file__).parent / "output_overlay.png"
+        img.save(out_path)
+        print(f"Saved overlay screenshot to: {out_path}")
+    except Exception as e:
+        print(f"Failed to capture/annotate screenshot: {e}")
+
+    # Execute arbitrary JavaScript
+    text = execute_javascript(pid, "window.__submitted")
+    print("text:", text)
+
+
+if __name__ == "__main__":
+    main()
@@ -0,0 +1,25 @@
+[build-system]
+requires = ["pdm-backend"]
+build-backend = "pdm.backend"
+
+[project]
+name = "cua-bench-ui"
+version = "0.7.0"
+description = "Lightweight webUI window controller for Cua bench using pywebview"
+readme = "README.md"
+authors = [
+    { name = "TryCua", email = "gh@trycua.com" }
+]
+dependencies = [
+    "pywebview>=5.3",
+    "aiohttp>=3.9.0",
+    "psutil>=5.9",
+]
+requires-python = ">=3.12"
+
+[tool.pdm]
+distribution = true
+
+[tool.pdm.build]
+includes = ["bench_ui/"]
+source-includes = ["README.md"]
@@ -0,0 +1,50 @@
+import time
+
+import psutil
+import pytest
+from bench_ui import execute_javascript, launch_window
+from bench_ui.api import _pid_to_port
+
+HTML = """
+<!doctype html>
+<html>
+  <head>
+    <meta charset="utf-8" />
+    <title>Bench UI Test</title>
+  </head>
+  <body>
+    <div id="t">hello-world</div>
+  </body>
+</html>
+"""
+
+
+def test_execute_js_after_clearing_port_mapping():
+    # Skip if pywebview backend is unavailable on this machine
+    pywebview = pytest.importorskip("webview")
+
+    pid = launch_window(html=HTML, title="Bench UI Test", width=400, height=300)
+    try:
+        # Give a brief moment for window to render and server to start
+        time.sleep(1.0)
+
+        # Sanity: mapping should exist initially
+        assert pid in _pid_to_port
+
+        # Clear the cached mapping to simulate a fresh process lookup
+        del _pid_to_port[pid]
+
+        # Now execute JS; this should succeed by detecting the port via psutil
+        result = execute_javascript(pid, "document.querySelector('#t')?.textContent")
+        assert result == "hello-world"
+    finally:
+        # Best-effort cleanup of the child process
+        try:
+            p = psutil.Process(pid)
+            p.terminate()
+            try:
+                p.wait(timeout=3)
+            except psutil.TimeoutExpired:
+                p.kill()
+        except Exception:
+            pass