Fix ZeroGPU GPU access: switch from subprocess.Popen to multiprocessing.Process

The spaces library only patches multiprocessing.Process.start() to register
child PIDs with the GPU broker. subprocess.Popen children are not registered
and get no GPU access (CUDA init fails with "No CUDA GPUs are available").

Changes:
- generate.py: extract run_generation() callable + _worker_entrypoint for
multiprocessing pickling; add immediate torch.zeros(1, device='cuda') right
after signal received to establish CUDA context before lease expires
- app.py: import _worker_entrypoint, use multiprocessing.get_context('spawn')
.Process instead of subprocess.Popen; sleep 0.8s in GPU lease to give
worker time to init CUDA; proc.join() instead of proc.wait()

app.py

@@ -1,9 +1,11 @@
 """
 Sulphur — Image to Video (HF Spaces).
 
-POC-proven pattern: subprocess is pre-spawned from the main Gradio process,
-@spaces.GPU(duration=1) is used only to signal CUDA initialisation.
-The subprocess retains GPU access for the full generation duration.
+POC-proven pattern: subprocess is pre-spawned from the main Gradio process via
+multiprocessing.Process (NOT subprocess.Popen — ZeroGPU only grants GPU access
+to children spawned through the patched multiprocessing API).
+@spaces.GPU(duration=1) signals CUDA initialisation; the worker retains the
+context for the full generation.
 Billing cost: 1 second per generation regardless of inference time.
 """
 
@@ -11,8 +13,6 @@ import json
 import multiprocessing
 import os
 import shutil
-import subprocess
-import sys
 import tempfile
 import threading
 import time
@@ -21,13 +21,17 @@ from pathlib import Path
 import gradio as gr
 import spaces
 
+from generate import _worker_entrypoint
+
 _HF_TOKEN     = os.environ.get("HF_TOKEN")
 _PERSISTENT   = Path("/data") if Path("/data").exists() else Path(tempfile.gettempdir())
 WAN2GP_ROOT   = _PERSISTENT / "Wan2GP"
 CKPTS_DIR     = WAN2GP_ROOT / "ckpts"
 LORAS_DIR     = WAN2GP_ROOT / "loras" / "ltx2"
 FINETUNES_DIR = WAN2GP_ROOT / "finetunes"
-GENERATE_PY   = Path(__file__).parent / "generate.py"
+
+# Propagate to spawned worker processes
+os.environ["WAN2GP_ROOT"] = str(WAN2GP_ROOT)
 
 SULPHUR_ASSETS = [
     ("SulphurAI/Sulphur-2-base", "sulphur_distil_bf16.safetensors", CKPTS_DIR),
@@ -86,6 +90,7 @@ def setup():
     if not (WAN2GP_ROOT / "shared" / "api.py").exists():
         WAN2GP_ROOT.mkdir(parents=True, exist_ok=True)
         print("[setup] Cloning Wan2GP...")
+        import subprocess
         subprocess.run(
             ["git", "clone", "--depth=1",
              "https://github.com/deepbeepmeep/Wan2GP.git", str(WAN2GP_ROOT)],
@@ -126,7 +131,7 @@ RESOLUTIONS = ["832x480", "480x832", "640x640", "1024x576", "576x1024"]
 def _signal_cuda_init(signal_path):
     """Acquire a 1-second GPU lease just long enough for the worker to init CUDA."""
     Path(signal_path).write_text("go")
-    time.sleep(0.5)
+    time.sleep(0.8)
 
 
 def generate_video(image, prompt, resolution, steps, guidance_scale, frames, seed):
@@ -140,25 +145,17 @@ def generate_video(image, prompt, resolution, steps, guidance_scale, frames, see
     out_dir     = tempfile.mkdtemp()
     out_file    = os.path.join(out_dir, "output.mp4")
 
-    cmd = [
-        sys.executable, str(GENERATE_PY),
-        "--image",          image,
-        "--prompt",         prompt,
-        "--output",         out_file,
-        "--model",          "sulphur-2",
-        "--seed",           str(int(seed)),
-        "--resolution",     resolution,
-        "--steps",          str(int(steps)),
-        "--guidance_scale", str(float(guidance_scale)),
-        "--frames",         str(int(frames)),
-        "--signal-path",    signal_path,
-        "--result-path",    result_path,
-    ]
-
-    env = {**os.environ, "WAN2GP_ROOT": str(WAN2GP_ROOT)}
-
-    # Spawn from main Gradio process (not inside ZeroGPU daemon — avoids daemon-child restriction)
-    proc = subprocess.Popen(cmd, env=env)
+    # Use multiprocessing.Process — ZeroGPU patches this to grant GPU access to children.
+    # subprocess.Popen does NOT get GPU access (not patched by the spaces library).
+    ctx = multiprocessing.get_context("spawn")
+    proc = ctx.Process(
+        target=_worker_entrypoint,
+        args=(image, prompt, out_file, "sulphur-2",
+              int(steps), float(guidance_scale), int(frames),
+              resolution, int(seed), signal_path, result_path),
+        daemon=False,
+    )
+    proc.start()
 
     log_lines = ["Worker spawned, acquiring GPU lease..."]
     yield None, "\n".join(log_lines)
@@ -191,7 +188,9 @@ def generate_video(image, prompt, resolution, steps, guidance_scale, frames, see
         else:
             yield None, "\n".join(log_lines)
 
-    proc.wait()
+    proc.join(timeout=10)
+    if proc.is_alive():
+        proc.terminate()
 
     for path in (signal_path, result_path):
         try:

generate.py

@@ -1,7 +1,7 @@
 """
-HF Spaces version of generate.py — paths adapted for /data/Wan2GP.
-Called as a subprocess from app.py.
+HF Spaces generate module — called via multiprocessing.Process from app.py.
 Waits for --signal-path before touching CUDA, writes incremental JSON to --result-path.
+Also usable as a CLI script.
 """
 
 import argparse
@@ -30,7 +30,7 @@ _log_entries = []
 _result_path = None
 
 
-def p(msg):
+def _p(msg):
     ts = time.strftime("%H:%M:%S")
     entry = f"[{ts}] {msg}"
     _log_entries.append(entry)
@@ -43,72 +43,70 @@ def p(msg):
             pass
 
 
-def parse_args():
-    ap = argparse.ArgumentParser()
-    ap.add_argument("--image",          required=True)
-    ap.add_argument("--prompt",         required=True)
-    ap.add_argument("--output",         required=True)
-    ap.add_argument("--model",          default="sulphur-2")
-    ap.add_argument("--steps",          type=int,   default=None)
-    ap.add_argument("--guidance_scale", type=float, default=None)
-    ap.add_argument("--frames",         type=int,   default=None)
-    ap.add_argument("--resolution",     default=None)
-    ap.add_argument("--seed",           type=int,   default=-1)
-    ap.add_argument("--signal-path",    default=None, dest="signal_path")
-    ap.add_argument("--result-path",    default=None, dest="result_path")
-    return ap.parse_args()
-
-
-def main():
-    global _result_path
-
-    args = parse_args()
-    _result_path = args.result_path
-
-    if args.signal_path:
-        p("Waiting for GPU lease signal...")
-        while not Path(args.signal_path).exists():
+def _done(error=None):
+    if _result_path:
+        with open(_result_path, "w") as f:
+            data = {"log": _log_entries, "done": True}
+            if error:
+                data["error"] = error
+            json.dump(data, f)
+
+
+def run_generation(image, prompt, output, model="sulphur-2", steps=None,
+                   guidance_scale=None, frames=None, resolution=None, seed=-1,
+                   signal_path=None, result_path=None):
+    global _log_entries, _result_path
+    _log_entries = []
+    _result_path = result_path
+
+    if signal_path:
+        _p("Waiting for GPU lease signal...")
+        while not Path(signal_path).exists():
             time.sleep(0.05)
-        p("Signal received — GPU lease active, initialising CUDA...")
-
-    model_type = MODEL_SHORTHANDS.get(args.model, args.model)
+        _p("Signal received — initialising CUDA context immediately...")
+        try:
+            import torch
+            _ = torch.zeros(1, device="cuda")
+            _p(f"CUDA ready: {torch.cuda.get_device_name(0)}")
+        except Exception as exc:
+            _p(f"CUDA init failed: {exc}")
+            _done(error=str(exc))
+            return
+
+    model_type = MODEL_SHORTHANDS.get(model, model)
     defaults   = DEFAULTS.get(model_type, DEFAULTS["sulphur_2_base"])
 
-    image_path = str(Path(args.image.strip()).resolve())
+    image_path = str(Path(image.strip()).resolve())
     if not Path(image_path).exists():
-        p(f"Fatal: image not found: {image_path}")
-        if _result_path:
-            with open(_result_path, "w") as f:
-                json.dump({"log": _log_entries, "done": True, "error": "image not found"}, f)
-        sys.exit(1)
+        _p(f"Fatal: image not found: {image_path}")
+        _done(error="image not found")
+        return
 
-    resolution = args.resolution or defaults["resolution"]
-    if not args.resolution:
+    res = resolution or defaults["resolution"]
+    if not resolution:
         try:
             from PIL import Image as _PIL
             img = _PIL.open(image_path)
             iw, ih = img.size
             if ih > iw:
-                tw = 480
-                th = round(ih / iw * tw / 32) * 32
+                tw = 480; th = round(ih / iw * tw / 32) * 32
             else:
-                th = 480
-                tw = round(iw / ih * th / 32) * 32
-            resolution = f"{tw}x{th}"
-            p(f"Auto-detected resolution: {resolution} (from {iw}x{ih} input)")
+                th = 480; tw = round(iw / ih * th / 32) * 32
+            res = f"{tw}x{th}"
+            _p(f"Auto-detected resolution: {res} (from {iw}x{ih} input)")
         except Exception:
             pass
 
     task = {
         "model_type":           model_type,
         "base_model_type":      model_type,
-        "prompt":               args.prompt,
+        "prompt":               prompt,
         "image_start":          image_path,
-        "num_inference_steps":  args.steps         or defaults["num_inference_steps"],
-        "guidance_scale":       args.guidance_scale or defaults["guidance_scale"],
-        "resolution":           resolution,
-        "video_length":         args.frames        or defaults["video_length"],
-        "seed":                 args.seed,
+        "num_inference_steps":  steps         or defaults["num_inference_steps"],
+        "guidance_scale":       guidance_scale or defaults["guidance_scale"],
+        "resolution":           res,
+        "video_length":         frames        or defaults["video_length"],
+        "seed":                 seed,
         "image_prompt_type":    "S",
         "input_video_strength": 1.0,
         "activated_loras": [
@@ -118,28 +116,27 @@ def main():
         "loras_multipliers": ["0.5", "1.0"],
     }
 
-    p(f"Model:      {model_type}")
-    p(f"Image:      {image_path}")
-    p(f"Steps:      {task['num_inference_steps']}  Guidance: {task['guidance_scale']}")
-    p(f"Resolution: {task['resolution']}  Frames: {task['video_length']}")
-    p(f"Prompt:     {args.prompt[:80]}")
+    _p(f"Model:      {model_type}")
+    _p(f"Image:      {image_path}")
+    _p(f"Steps:      {task['num_inference_steps']}  Guidance: {task['guidance_scale']}")
+    _p(f"Resolution: {task['resolution']}  Frames: {task['video_length']}")
+    _p(f"Prompt:     {prompt[:80]}")
 
     sys.path.insert(0, str(WAN2GP_ROOT))
     os.chdir(WAN2GP_ROOT)
 
     from shared.api import WanGPSession
 
-    output_dir = Path(args.output).parent
+    output_dir = Path(output).parent
     output_dir.mkdir(parents=True, exist_ok=True)
 
-    p("Starting WanGPSession...")
+    _p("Starting WanGPSession...")
     session = WanGPSession(root=WAN2GP_ROOT, output_dir=output_dir, console_output=True)
 
-    p("Running generation...")
+    _p("Running generation...")
     result = session.run_task(task)
 
     output_file = None
-
     if result.artifacts:
         src = result.artifacts[0].path
         if src and Path(src).exists():
@@ -149,26 +146,58 @@ def main():
         candidates = sorted(output_dir.glob("**/*.mp4"), key=lambda f: f.stat().st_mtime, reverse=True)
         if candidates:
             output_file = str(candidates[0])
-            p(f"Found output via dir scan: {output_file}")
+            _p(f"Found output via dir scan: {output_file}")
 
     if output_file:
         import shutil
-        shutil.copy2(output_file, args.output)
-        p(f"Done: {args.output}")
+        shutil.copy2(output_file, output)
+        _p(f"Done: {output}")
     else:
-        p(f"No output found in {output_dir}")
+        _p(f"No output found in {output_dir}")
         if result.errors:
-            p(f"Errors: {result.errors}")
-        if _result_path:
-            with open(_result_path, "w") as f:
-                json.dump({"log": _log_entries, "done": True, "error": "no output"}, f)
-        sys.exit(1)
+            _p(f"Errors: {result.errors}")
+        _done(error="no output produced")
+        return
 
     session.close()
+    _done()
 
-    if _result_path:
-        with open(_result_path, "w") as f:
-            json.dump({"log": _log_entries, "done": True}, f)
+
+# Top-level function required for multiprocessing.Process pickling
+def _worker_entrypoint(image, prompt, output, model, steps, guidance_scale,
+                       frames, resolution, seed, signal_path, result_path):
+    run_generation(
+        image=image, prompt=prompt, output=output, model=model,
+        steps=steps, guidance_scale=guidance_scale, frames=frames,
+        resolution=resolution, seed=seed,
+        signal_path=signal_path, result_path=result_path,
+    )
+
+
+def parse_args():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--image",          required=True)
+    ap.add_argument("--prompt",         required=True)
+    ap.add_argument("--output",         required=True)
+    ap.add_argument("--model",          default="sulphur-2")
+    ap.add_argument("--steps",          type=int,   default=None)
+    ap.add_argument("--guidance_scale", type=float, default=None)
+    ap.add_argument("--frames",         type=int,   default=None)
+    ap.add_argument("--resolution",     default=None)
+    ap.add_argument("--seed",           type=int,   default=-1)
+    ap.add_argument("--signal-path",    default=None, dest="signal_path")
+    ap.add_argument("--result-path",    default=None, dest="result_path")
+    return ap.parse_args()
+
+
+def main():
+    args = parse_args()
+    run_generation(
+        image=args.image, prompt=args.prompt, output=args.output,
+        model=args.model, steps=args.steps, guidance_scale=args.guidance_scale,
+        frames=args.frames, resolution=args.resolution, seed=args.seed,
+        signal_path=args.signal_path, result_path=args.result_path,
+    )
 
 
 if __name__ == "__main__":