Update app.py

app.py

@@ -1,6 +1,6 @@
-import os, time, base64, mimetypes, requests, traceback
+import os, time, base64, mimetypes, requests, traceback, json
 from dataclasses import dataclass
-from typing import Optional, Tuple, Dict, Any, Generator
+from typing import Optional, Dict, Any, Generator, List
 
 import gradio as gr
 from dotenv import load_dotenv
@@ -87,6 +87,7 @@ def _download_stream(url: str, out_path: str) -> str:
 # Normalize OpenAI exceptions across versions
 _OAI_EXC = tuple(e for e in [RateLimitError, APIConnectionError, APIStatusError] if isinstance(e, type)) or (Exception,)
 
+# -------- Videos API wrappers (dual path) --------
 @retry(
     retry=retry_if_exception_type(_OAI_EXC),
     wait=wait_exponential(multiplier=1, min=1, max=8),
@@ -95,15 +96,25 @@ _OAI_EXC = tuple(e for e in [RateLimitError, APIConnectionError, APIStatusError]
 )
 def _videos_generate(client: OpenAI, **kwargs) -> Any:
     """
-    Dual-path: try Videos API; fallback to Jobs API.
+    Try the new Videos API; fallback to Jobs API. Surface both errors if they fail.
     """
-    try:
-        return client.videos.generate(**kwargs)
-    except Exception as e_a:
+    # Path A
+    if hasattr(client, "videos") and hasattr(client.videos, "generate"):
+        try:
+            return client.videos.generate(**kwargs)
+        except Exception as e_a:
+            # fall through to jobs
+            last_a = e_a
+    else:
+        last_a = "client.videos.generate not found"
+
+    # Path B
+    if hasattr(client, "videos") and hasattr(client.videos, "jobs") and hasattr(client.videos.jobs, "create"):
         try:
             return client.videos.jobs.create(**kwargs)
         except Exception as e_b:
-            raise RuntimeError(f"videos.generate failed: {e_a}\njobs.create failed: {e_b}")
+            raise RuntimeError(f"videos.generate failed/absent: {last_a}\njobs.create failed: {e_b}")
+    raise RuntimeError(f"Your OpenAI SDK doesn't expose videos endpoints on this key/org. Seen attributes: {dir_safe(client)}")
 
 @retry(
     retry=retry_if_exception_type(_OAI_EXC),
@@ -112,10 +123,14 @@ def _videos_generate(client: OpenAI, **kwargs) -> Any:
     reraise=True,
 )
 def _videos_retrieve(client: OpenAI, job_id: str) -> Any:
-    try:
-        return client.videos.retrieve(job_id)
-    except Exception:
+    if hasattr(client, "videos") and hasattr(client.videos, "retrieve"):
+        try:
+            return client.videos.retrieve(job_id)
+        except Exception:
+            pass  # try jobs next
+    if hasattr(client, "videos") and hasattr(client.videos, "jobs") and hasattr(client.videos.jobs, "retrieve"):
         return client.videos.jobs.retrieve(job_id)
+    raise RuntimeError("No videos.retrieve or videos.jobs.retrieve on this SDK. Upgrade openai python.")
 
 def _extract_status(resp: Any) -> JobStatus:
     status = getattr(resp, "status", None) or getattr(resp, "state", None) or "unknown"
@@ -137,7 +152,13 @@ def _extract_status(resp: Any) -> JobStatus:
 
     return JobStatus(status=status, error=err, output_url=out_url, output_b64=out_b64)
 
-# -------- Core (STREAMING with gr.update) --------
+def dir_safe(obj) -> Dict[str, Any]:
+    try:
+        return sorted([a for a in dir(obj) if not a.startswith("_")])
+    except Exception:
+        return {"inspect_error": "dir() failed"}
+
+# -------- Core (STREAMING; yields LISTS matching outputs) --------
 def generate_video_stream(
     api_key: str,
     prompt: str,
@@ -148,31 +169,46 @@ def generate_video_stream(
     audio: str,
     guidance: float,
     init_image: Optional[str],
-) -> Generator[Tuple[Any, str], None, None]:
+) -> Generator[List[Any], None, None]:
     """
-    Generator that yields (video_component_value, status_text).
-    Uses gr.update() to keep Gradio happy even when no video is ready yet.
+    Generator that ALWAYS yields a list [video_value_or_update, status_text].
+    Many Gradio builds ignore tuple yields; lists are safest.
     """
+
+    # First visible tick so UI never blanks:
+    yield [gr.update(), "Starting…"]
+
     # 0) Setup
     try:
         client = _make_client(api_key)
     except Exception as e_init:
-        yield gr.update(), f"Setup error: {e_init}"
+        yield [gr.update(), f"Setup error: {e_init}"]
         return
 
+    # 0.1) Preflight SDK visibility (prints once so we know what exists)
+    try:
+        vids = hasattr(client, "videos")
+        methods = []
+        if vids:
+            methods = [m for m in dir(client.videos) if not m.startswith("_")]
+        msg = f"SDK preflight → videos: {vids}, methods: {methods}"
+        yield [gr.update(), msg]
+    except Exception as e_pref:
+        yield [gr.update(), f"SDK preflight error: {e_pref}"]
+
     # 1) Validate inputs
     try:
         prompt = _sanitize_prompt(prompt)
-        model = _validate_model(model)
+        model  = _validate_model(model)
         duration = _validate_duration(duration)
-        size = _validate_size(size)
+        size   = _validate_size(size)
         guidance = _validate_guidance(guidance)
-        audio = "on" if audio == "on" else "off"
+        audio  = "on" if audio == "on" else "off"
 
         if init_image:
             mt, _ = mimetypes.guess_type(init_image)
             if not (mt and mt.startswith("image/")):
-                yield gr.update(), "Provided conditioning file isn’t an image."
+                yield [gr.update(), "Provided conditioning file isn’t an image."]
                 return
 
         req: Dict[str, Any] = {
@@ -188,22 +224,23 @@ def generate_video_stream(
         if init_image:
             req["image"] = {"b64": _file_to_b64(init_image)}
     except Exception as e_val:
-        yield gr.update(), f"Validation error: {e_val}"
+        yield [gr.update(), f"Validation error: {e_val}"]
         return
 
     # 2) Submit job
     try:
-        yield gr.update(), "Submitting job…"
+        yield [gr.update(), "Submitting job…"]
         job = _videos_generate(client, **req)
         job_id = getattr(job, "id", None) or getattr(job, "job_id", None)
         if not job_id:
-            yield gr.update(), "Could not get a job id from the API response."
+            yield [gr.update(), f"Could not get a job id. Raw job object: {repr(job)}"]
             return
+        yield [gr.update(), f"Job accepted → id={job_id}"]
     except _OAI_EXC as oe:
-        yield gr.update(), f"OpenAI API issue on submit: {oe}"
+        yield [gr.update(), f"OpenAI API issue on submit: {oe}"]
         return
     except Exception as e_submit:
-        yield gr.update(), f"Submit error: {e_submit}\n{traceback.format_exc(limit=2)}"
+        yield [gr.update(), f"Submit error: {e_submit}\n{traceback.format_exc(limit=2)}"]
         return
 
     # 3) Poll job
@@ -214,16 +251,16 @@ def generate_video_stream(
             status_obj = _videos_retrieve(client, job_id)
             js = _extract_status(status_obj)
         except _OAI_EXC as oe:
-            yield gr.update(), f"OpenAI API issue on poll: {oe}"
+            yield [gr.update(), f"OpenAI API issue on poll: {oe}"]
             return
         except Exception as e_poll:
-            yield gr.update(), f"Polling error: {e_poll}\n{traceback.format_exc(limit=2)}"
+            yield [gr.update(), f"Polling error: {e_poll}\n{traceback.format_exc(limit=2)}"]
             return
 
         now = time.time()
         if now - last_emit > 5:
             last_emit = now
-            yield gr.update(), f"Rendering… status={js.status}"
+            yield [gr.update(), f"Rendering… status={js.status}"]
 
         if js.status in ("succeeded", "completed", "complete"):
             out_path = _safe_video_path()
@@ -231,37 +268,36 @@ def generate_video_stream(
                 try:
                     with open(out_path, "wb") as f:
                         f.write(base64.b64decode(js.output_b64))
-                    yield out_path, f"Done with {model} ({size}, {duration}s)."
+                    yield [out_path, f"Done with {model} ({size}, {duration}s)."]
                 except Exception as werr:
-                    yield gr.update(), f"Write error: {werr}"
+                    yield [gr.update(), f"Write error: {werr}"]
                 return
             if js.output_url:
                 try:
                     _download_stream(js.output_url, out_path)
-                    yield out_path, f"Downloaded from URL. Done with {model}."
+                    yield [out_path, f"Downloaded from URL. Done with {model}."]
                 except Exception as dl_err:
-                    # Gradio Video can play URLs if local download fails
-                    yield js.output_url, f"Ready (URL) — local download failed: {dl_err}"
+                    yield [js.output_url, f"Ready (URL) — local download failed: {dl_err}"]
                 return
-            yield gr.update(), "Job succeeded but no video payload was returned."
+            yield [gr.update(), "Job succeeded but no video payload was returned."]
             return
 
         if js.status in ("failed", "error", "canceled", "cancelled"):
             detail = f"Status: {js.status}."
             if js.error:
                 detail += f" Error: {js.error}"
-            yield gr.update(), detail
+            yield [gr.update(), detail]
             return
 
         if now - start > 1800:  # 30 min timeout
-            yield gr.update(), "Timed out waiting for the video. Try shorter duration."
+            yield [gr.update(), "Timed out waiting for the video. Try shorter duration."]
             return
 
         time.sleep(2)
 
 # -------- UI --------
 def build_ui():
-    with gr.Blocks(title="ZEN — Sora / Sora-2 / Sora-2-Pro", theme=gr.themes.Soft()) as demo:
+    with gr.Blocks(title="ZEN — Sora / Sora-2 / Sora-2-Pro") as demo:
         gr.Markdown("## ZEN — Sora / Sora-2 / Sora-2-Pro (OpenAI Videos API)")
         gr.Markdown(
             "Paste an OpenAI API key (not stored). Provide a detailed prompt. "
@@ -290,7 +326,7 @@ def build_ui():
         video = gr.Video(label="Result", autoplay=True)
         status = gr.Textbox(label="Status / Logs", interactive=False)
 
-        # Generator → always yields something visible
+        # IMPORTANT: outputs must be exactly two and we yield LISTS [video, status]
         go.click(
             fn=generate_video_stream,
             inputs=[api_key, prompt, model, duration, size, seed, audio, guidance, init_image],