fix: post-review polish — slider defaults, error handling, comment

- I5: t2i steps/cfg sliders update via gr.change() when model selector
toggles base/turbo (was: stuck at turbo defaults, base generations
silently used cfg=1 steps=8 → bad output).
- I3: controlnet preprocessor wraps in try/except with raw-input
fallback + stderr warning.
- I1: zerogpu 'gpu task aborted' retries once with 2x duration
via __retry_multiplier__ in params. duration_for honors it.
- I4: 'Eager backend boot' comment renamed to 'Lazy backend singleton'
to match the actual lazy get_backend() behavior.
- bonus: fix pre-existing ruff failures in test_smoke_gpu.py
(unused meta vars, unsorted local imports).

app.py

@@ -35,7 +35,7 @@ def _bootstrap() -> None:
 _bootstrap()
 
 
-# ----- Eager backend boot ----------------------------------------------------
+# ----- Lazy backend singleton ------------------------------------------------
 
 _BACKEND: backend.ZImageStudioBackend | None = None
 
@@ -62,6 +62,13 @@ def _coerce_lora(lora_path: str | None) -> Path | None:
     return p
 
 
+def _on_model_change(model_name: str) -> tuple[int, float]:
+    """When the user clicks Base / Turbo in the custom selector, update steps + cfg."""
+    if model_name == "Base":
+        return 25, 4.0
+    return 8, 1.0  # Turbo
+
+
 def _esrgan_path() -> str:
     """Locate the preloaded RealESRGAN_x4plus.pth."""
     from huggingface_hub import hf_hub_download
@@ -87,7 +94,7 @@ def on_t2i_generate(prompt, negative_prompt, model, steps, cfg, width, height, s
         lora_path=lora_p,
         lora_strength=float(lora_strength),
     )
-    image, meta = get_backend().generate(mode="t2i", params=params)
+    image, meta = backend.generate_with_retry(get_backend(), mode="t2i", params=params)
     return image, meta
 
 
@@ -107,7 +114,7 @@ def on_controlnet_generate(prompt, input_image, preprocessor, controlnet_scale,
         lora_path=lora_p,
         lora_strength=float(lora_strength),
     )
-    image, meta = get_backend().generate(mode="controlnet", params=params)
+    image, meta = backend.generate_with_retry(get_backend(), mode="controlnet", params=params)
     return image, meta
 
 
@@ -127,7 +134,7 @@ def on_upscale_generate(prompt, input_image, refine_steps, refine_denoise, seed,
         lora_strength=float(lora_strength),
         esrgan_model_path=_esrgan_path(),
     )
-    image, meta = get_backend().generate(mode="upscale", params=params)
+    image, meta = backend.generate_with_retry(get_backend(), mode="upscale", params=params)
     return image, meta
 
 
@@ -192,6 +199,11 @@ def build_app() -> gr.Blocks:
                     ],
                     outputs=[t["output_image"], t["output_meta"]],
                 )
+                t["model_state"].change(
+                    fn=_on_model_change,
+                    inputs=[t["model_state"]],
+                    outputs=[t["steps"], t["cfg"]],
+                )
 
             with gr.Tab("ControlNet"):
                 c = ui.build_controlnet_tab()

backend.py

@@ -37,12 +37,14 @@ def duration_for(
     width = int(params.get("width", 1024))
     height = int(params.get("height", 1024))
 
+    eff_multiplier = float(params.get("__retry_multiplier__", multiplier))
+
     base = _BASE_DURATION_S.get(mode, 30)
     per_step = _PER_STEP_S.get((mode, model), _PER_STEP_S.get((mode, "Turbo"), 1.6))
     size_factor = (width * height) / (1024 * 1024)
     cold_buffer = 15  # CPU→GPU copy on first call after a quiet period
 
-    est = (base + per_step * steps + cold_buffer) * size_factor * multiplier
+    est = (base + per_step * steps + cold_buffer) * size_factor * eff_multiplier
     return max(60, min(int(est), 180))
 
 
@@ -111,3 +113,20 @@ class ZImageStudioBackend:
         if handler is None:
             raise ValueError(f"unknown mode: {mode!r}; expected one of {list(_DISPATCH)}")
         return handler(self.pipeline, params)
+
+
+def generate_with_retry(
+    backend_instance: ZImageStudioBackend,
+    mode: str,
+    params: dict[str, Any],
+) -> tuple[Any, dict[str, Any]]:
+    """Call backend_instance.generate; on ZeroGPU timeout, retry once with 2x duration budget."""
+    try:
+        return backend_instance.generate(mode, params)
+    except Exception as e:
+        msg = str(e).lower()
+        if "gpu task aborted" in msg or ("gpu" in msg and "aborted" in msg):
+            retry_params = dict(params)
+            retry_params["__retry_multiplier__"] = 2.0
+            return backend_instance.generate(mode, retry_params)
+        raise

modes.py

@@ -87,7 +87,15 @@ def call_controlnet(pipe: Any, params: dict[str, Any]) -> tuple[Image.Image, dic
         raise ValueError("ControlNet mode requires an input image")
 
     preproc_mode = params.get("preprocessor", "Canny")
-    control_image = preprocessors.run(preproc_mode, input_image)
+    try:
+        control_image = preprocessors.run(preproc_mode, input_image)
+    except Exception as e:
+        import sys
+
+        print(
+            f"[modes] preprocessor {preproc_mode!r} failed: {e}; falling back to raw input", file=sys.stderr, flush=True
+        )
+        control_image = input_image
 
     _swap_transformer(pipe, "Turbo")
 

tests/test_app.py

@@ -0,0 +1,13 @@
+import app
+
+
+def test_on_model_change_returns_base_defaults():
+    assert app._on_model_change("Base") == (25, 4.0)
+
+
+def test_on_model_change_returns_turbo_defaults():
+    assert app._on_model_change("Turbo") == (8, 1.0)
+
+
+def test_on_model_change_unknown_falls_back_to_turbo():
+    assert app._on_model_change("Edit") == (8, 1.0)

tests/test_backend.py

@@ -93,3 +93,52 @@ def test_backend_generate_routes_controlnet(fake_backend, monkeypatch):
 def test_backend_generate_unknown_mode_raises(fake_backend):
     with pytest.raises(ValueError):
         fake_backend.generate(mode="dance", params={})
+
+
+def test_generate_with_retry_retries_on_gpu_aborted(fake_backend, monkeypatch):
+    call_count = {"n": 0}
+    original_generate = fake_backend.generate
+
+    def flaky(mode, params):
+        call_count["n"] += 1
+        if call_count["n"] == 1:
+            from gradio.exceptions import Error
+
+            raise Error("GPU task aborted")
+        return original_generate(mode, params)
+
+    fake_backend.generate = flaky
+
+    _img, meta = backend.generate_with_retry(
+        fake_backend,
+        mode="t2i",
+        params=dict(
+            prompt="x",
+            negative_prompt="",
+            model="Turbo",
+            steps=8,
+            cfg=1.0,
+            width=1024,
+            height=1024,
+            seed=0,
+            lora_path=None,
+            lora_strength=0.0,
+        ),
+    )
+    assert call_count["n"] == 2  # one fail + one retry
+    assert meta["mode"] == "t2i"
+
+
+def test_generate_with_retry_does_not_retry_other_errors(fake_backend):
+    fake_backend.generate = lambda *a, **kw: (_ for _ in ()).throw(ValueError("not a gpu issue"))
+    with pytest.raises(ValueError):
+        backend.generate_with_retry(fake_backend, mode="t2i", params={})
+
+
+def test_duration_honors_retry_multiplier_in_params():
+    normal = backend.duration_for(mode="t2i", params=dict(model="Turbo", steps=8, width=1024, height=1024))
+    retry = backend.duration_for(
+        mode="t2i",
+        params=dict(model="Turbo", steps=8, width=1024, height=1024, __retry_multiplier__=2.0),
+    )
+    assert retry > normal

tests/test_modes.py

@@ -190,3 +190,29 @@ def test_upscale_rejects_missing_image(fake_pipe):
                 esrgan_model_path="/fake.pth",
             ),
         )
+
+
+def test_controlnet_falls_back_when_preprocessor_raises(fake_pipe, monkeypatch):
+    def boom(mode, img):
+        raise RuntimeError("preprocessor exploded")
+
+    monkeypatch.setattr(modes, "preprocessors", type("P", (), {"run": staticmethod(boom)}))
+
+    input_image = Image.new("RGB", (512, 512))
+    _out, _meta = modes.call_controlnet(
+        fake_pipe,
+        params=dict(
+            prompt="x",
+            input_image=input_image,
+            preprocessor="Canny",
+            controlnet_scale=1.0,
+            steps=9,
+            seed=0,
+            lora_path=None,
+            lora_strength=0.0,
+        ),
+    )
+    # Pipeline still ran — fallback to raw input
+    kwargs = fake_pipe.call_args.kwargs
+    cn_in = kwargs["controlnet_inputs"]
+    assert cn_in[0].image is input_image  # the raw input, not a preprocessed image

tests/test_smoke_gpu.py

@@ -7,17 +7,27 @@ pytestmark = pytest.mark.gpu
 def real_backend():
     """Build a real backend with real weights. ~30 GB download on first run."""
     import backend
+
     return backend.ZImageStudioBackend()
 
 
 def test_t2i_turbo_produces_image(real_backend):
     from PIL import Image
+
     image, meta = real_backend.generate(
         mode="t2i",
-        params=dict(prompt="a red apple on a wooden table",
-                    negative_prompt="", model="Turbo",
-                    steps=8, cfg=1.0, width=384, height=384, seed=42,
-                    lora_path=None, lora_strength=0.0),
+        params=dict(
+            prompt="a red apple on a wooden table",
+            negative_prompt="",
+            model="Turbo",
+            steps=8,
+            cfg=1.0,
+            width=384,
+            height=384,
+            seed=42,
+            lora_path=None,
+            lora_strength=0.0,
+        ),
     )
     assert isinstance(image, Image.Image)
     assert image.size == (384, 384)
@@ -26,42 +36,63 @@ def test_t2i_turbo_produces_image(real_backend):
 
 def test_t2i_base_produces_image(real_backend):
     from PIL import Image
-    image, meta = real_backend.generate(
+
+    image, _meta = real_backend.generate(
         mode="t2i",
-        params=dict(prompt="a red apple on a wooden table",
-                    negative_prompt="blurry", model="Base",
-                    steps=15, cfg=4.0, width=384, height=384, seed=42,
-                    lora_path=None, lora_strength=0.0),
+        params=dict(
+            prompt="a red apple on a wooden table",
+            negative_prompt="blurry",
+            model="Base",
+            steps=15,
+            cfg=4.0,
+            width=384,
+            height=384,
+            seed=42,
+            lora_path=None,
+            lora_strength=0.0,
+        ),
     )
     assert isinstance(image, Image.Image)
 
 
 def test_controlnet_produces_image(real_backend):
-    from PIL import Image
     import numpy as np
+    from PIL import Image
+
     arr = np.random.randint(0, 255, (384, 384, 3), dtype=np.uint8)
-    image, meta = real_backend.generate(
+    image, _meta = real_backend.generate(
         mode="controlnet",
-        params=dict(prompt="a portrait of a person, dramatic light",
-                    input_image=Image.fromarray(arr),
-                    preprocessor="Canny", controlnet_scale=1.0,
-                    steps=9, seed=42, lora_path=None, lora_strength=0.0),
+        params=dict(
+            prompt="a portrait of a person, dramatic light",
+            input_image=Image.fromarray(arr),
+            preprocessor="Canny",
+            controlnet_scale=1.0,
+            steps=9,
+            seed=42,
+            lora_path=None,
+            lora_strength=0.0,
+        ),
     )
     assert isinstance(image, Image.Image)
 
 
 def test_upscale_produces_image(real_backend, tmp_path):
-    from PIL import Image
     import numpy as np
     from huggingface_hub import hf_hub_download
+    from PIL import Image
+
     arr = np.random.randint(0, 255, (256, 256, 3), dtype=np.uint8)
-    image, meta = real_backend.generate(
+    image, _meta = real_backend.generate(
         mode="upscale",
-        params=dict(prompt="masterpiece, 8k",
-                    input_image=Image.fromarray(arr),
-                    refine_steps=5, refine_denoise=0.33, seed=42,
-                    lora_path=None, lora_strength=0.0,
-                    esrgan_model_path=hf_hub_download("xinntao/Real-ESRGAN",
-                                                     "RealESRGAN_x4plus.pth")),
+        params=dict(
+            prompt="masterpiece, 8k",
+            input_image=Image.fromarray(arr),
+            refine_steps=5,
+            refine_denoise=0.33,
+            seed=42,
+            lora_path=None,
+            lora_strength=0.0,
+            esrgan_model_path=hf_hub_download("xinntao/Real-ESRGAN", "RealESRGAN_x4plus.pth"),
+        ),
     )
     assert image.size == (512, 512)