Add detailed export/traceback logging to diagnose post-pipeline UI errors (#20)

The Space logs cut off right after the pipeline stages finish, with no
trace of what happens next in generate_video() (export_to_video and the
run_inference call boundary), even though the UI shows a generic Error.
Log frame metadata and full tracebacks at those points so the next
failure is diagnosable from the Space logs alone.

app.py

@@ -13,6 +13,10 @@ from PIL import Image
 
 from logging_utils import (
     LogUploader,
+    print_export_done,
+    print_export_error,
+    print_export_start,
+    print_frames_info,
     print_infer_done,
     print_infer_error,
     print_infer_start,
@@ -262,8 +266,10 @@ def generate_video(
             progress,
         )
     except Exception as e:
+        import traceback as _tb
         duration = _time.perf_counter() - t0
         print_infer_error(e, duration)
+        print(f"[infer] traceback:\n{_tb.format_exc()}", flush=True)
         if _log_uploader.enabled:
             _spawn_log(
                 resized_image, None, None, prompt, negative_prompt, current_seed, steps,
@@ -274,9 +280,20 @@ def generate_video(
 
     duration = _time.perf_counter() - t0
 
+    print_frames_info("final_frames", final_frames, final_fps)
+    print_frames_info("pre_upscale_frames", pre_upscale_frames, pre_upscale_fps)
+
     with tempfile.NamedTemporaryFile(suffix=".mp4", delete=False) as tmpfile:
         video_path = tmpfile.name
-    export_to_video(final_frames, video_path, fps=final_fps, quality=6)
+    print_export_start(video_path)
+    t_export = _time.perf_counter()
+    try:
+        export_to_video(final_frames, video_path, fps=final_fps, quality=6)
+    except Exception as e:
+        import traceback as _tb
+        print_export_error(e, _tb.format_exc())
+        raise
+    print_export_done(_time.perf_counter() - t_export)
 
     if _log_uploader.enabled:
         # Interpolation/upscale failures are already caught-and-warned (not raised) inside

logging_utils.py

@@ -59,6 +59,36 @@ def print_infer_error(error: Exception, elapsed: float) -> None:
     print(f"[infer] FAILED: {type(error).__name__}: {error} | t={elapsed:.1f}s", flush=True)
 
 
+def print_frames_info(label: str, frames: Any, fps: Any) -> None:
+    if frames is None:
+        print(f"[export] {label}: frames=None, fps={fps}", flush=True)
+        return
+    n = len(frames)
+    first = frames[0] if n else None
+    kind = type(first).__name__ if first is not None else "n/a"
+    shape = getattr(first, "shape", None)
+    dtype = getattr(first, "dtype", None)
+    size = getattr(first, "size", None)  # PIL Image
+    mode = getattr(first, "mode", None)  # PIL Image
+    print(
+        f"[export] {label}: n={n}, fps={fps}, frame_type={kind}, shape={shape}, dtype={dtype}, "
+        f"pil_size={size}, pil_mode={mode}",
+        flush=True,
+    )
+
+
+def print_export_start(video_path: str) -> None:
+    print(f"[export] start -> {video_path}", flush=True)
+
+
+def print_export_done(elapsed: float) -> None:
+    print(f"[export] done — {elapsed:.1f}s", flush=True)
+
+
+def print_export_error(error: Exception, tb: str) -> None:
+    print(f"[export] FAILED: {type(error).__name__}: {error}\n{tb}", flush=True)
+
+
 def print_log_skipped(has_token: bool, has_repo: bool) -> None:
     print(f"[log] skipped — token={'set' if has_token else 'missing'}, repo={'set' if has_repo else 'missing'}")