Update app.py

app.py

@@ -1,25 +1,24 @@
-import os
-import time
-import base64
-import mimetypes
-import requests
+import os, time, base64, mimetypes, requests, traceback
 from dataclasses import dataclass
 from typing import Optional, Tuple, Dict, Any
 
 import gradio as gr
-from tenacity import retry, stop_after_attempt, wait_exponential, retry_if_exception_type
 from dotenv import load_dotenv
-from openai import OpenAI
-from openai import RateLimitError, APIConnectionError, APIStatusError
+from tenacity import retry, stop_after_attempt, wait_exponential, retry_if_exception_type
+
+# OpenAI SDK exceptions are defined lazily; guard imports
+try:
+    from openai import OpenAI
+    from openai import RateLimitError, APIConnectionError, APIStatusError
+except Exception:  # pragma: no cover
+    OpenAI = None
+    RateLimitError = APIConnectionError = APIStatusError = Exception  # fallback
 
-# ---- Env (optional) ----
-# You can still set OPENAI_API_KEY as a Space Secret; the UI key overrides it per-run.
 load_dotenv()
-ENV_FALLBACK_KEY = os.getenv("OPENAI_API_KEY")  # optional fallback
+ENV_FALLBACK_KEY = (os.getenv("OPENAI_API_KEY") or "").strip()
 
-# ---- Constants / Validation ----
-ALLOWED_MODELS = ["sora-2", "sora-2-pro", "sora"]  # sora kept as legacy/optional
-ALLOWED_SIZES = ["1280x720", "720x1280", "1792x1024", "1024x1792", "1920x1080", "1080x1920"]
+ALLOWED_MODELS = ["sora-2", "sora-2-pro", "sora"]
+ALLOWED_SIZES  = ["1280x720","720x1280","1792x1024","1024x1792","1920x1080","1080x1920"]
 
 @dataclass
 class JobStatus:
@@ -28,6 +27,14 @@ class JobStatus:
     output_url: Optional[str] = None
     output_b64: Optional[str] = None
 
+# ---------- utilities ----------
+def _safe_video_path() -> str:
+    return "/tmp/sora_output.mp4"
+
+def _file_to_b64(path: str) -> str:
+    with open(path, "rb") as f:
+        return base64.b64encode(f.read()).decode("utf-8")
+
 def _sanitize_prompt(p: str) -> str:
     p = (p or "").strip()
     if not p:
@@ -37,17 +44,13 @@ def _sanitize_prompt(p: str) -> str:
     return p
 
 def _validate_duration(d: int) -> int:
-    try:
-        d = int(d)
-    except Exception:
-        d = 10
+    try: d = int(d)
+    except: d = 10
     return max(1, min(d, 30))
 
 def _validate_guidance(g: float) -> float:
-    try:
-        g = float(g)
-    except Exception:
-        g = 7.5
+    try: g = float(g)
+    except: g = 7.5
     return max(0.0, min(g, 20.0))
 
 def _validate_model(m: str) -> str:
@@ -56,24 +59,18 @@ def _validate_model(m: str) -> str:
 def _validate_size(s: str) -> str:
     return s if s in ALLOWED_SIZES else "1280x720"
 
-def _file_to_b64(path: str) -> str:
-    with open(path, "rb") as f:
-        return base64.b64encode(f.read()).decode("utf-8")
-
-def _safe_video_path() -> str:
-    return "/tmp/sora_output.mp4"
-
-# ---- OpenAI client factories (per-request) ----
 def _make_client(user_key: Optional[str]) -> OpenAI:
-    key = (user_key or "").strip() or (ENV_FALLBACK_KEY or "").strip()
+    if OpenAI is None:
+        raise RuntimeError("OpenAI SDK failed to import. Check requirements.txt and rebuild.")
+    key = (user_key or "").strip() or ENV_FALLBACK_KEY
     if not key:
-        # Dummy client will fail predictably with friendly message
         raise ValueError("Missing API key. Paste a valid OpenAI API key.")
     return OpenAI(api_key=key)
 
-# ---- Robust network helpers ----
+# ---------- networking ----------
+from requests import RequestException as ReqErr
 @retry(
-    retry=retry_if_exception_type((APIConnectionError, RateLimitError, APIStatusError, requests.RequestException)),
+    retry=retry_if_exception_type((ReqErr,)),
     wait=wait_exponential(multiplier=1, min=1, max=10),
     stop=stop_after_attempt(5),
     reraise=True,
@@ -82,34 +79,54 @@ def _download_stream(url: str, out_path: str) -> str:
     with requests.get(url, stream=True, timeout=60) as r:
         r.raise_for_status()
         with open(out_path, "wb") as f:
-            for chunk in r.iter_content(chunk_size=1024 * 256):
+            for chunk in r.iter_content(1024 * 256):
                 if chunk:
                     f.write(chunk)
     return out_path
 
+# Some envs expose different exception classes; normalize
+_OAI_EXC = tuple(e for e in [RateLimitError, APIConnectionError, APIStatusError] if isinstance(e, type)) or (Exception,)
+
 @retry(
-    retry=retry_if_exception_type((APIConnectionError, RateLimitError, APIStatusError)),
+    retry=retry_if_exception_type(_OAI_EXC),
     wait=wait_exponential(multiplier=1, min=1, max=8),
     stop=stop_after_attempt(5),
     reraise=True,
 )
 def _videos_generate(client: OpenAI, **kwargs) -> Any:
-    return client.videos.generate(**kwargs)
+    """
+    Dual-path: try new Videos API; if not available, try jobs.create
+    """
+    # Path A: videos.generate(...)
+    try:
+        return client.videos.generate(**kwargs)
+    except Exception as e_a:
+        # Path B: videos.jobs.create(...)
+        try:
+            # Map kwargs as-is; most fields are identical in rollouts
+            return client.videos.jobs.create(**kwargs)
+        except Exception as e_b:
+            # Bubble both errors for debugging in status panel
+            raise RuntimeError(f"videos.generate failed: {e_a}\njobs.create failed: {e_b}")
 
 @retry(
-    retry=retry_if_exception_type((APIConnectionError, RateLimitError, APIStatusError)),
+    retry=retry_if_exception_type(_OAI_EXC),
     wait=wait_exponential(multiplier=1, min=1, max=8),
-    stop=stop_after_attempt(60),  # generous; API jobs can be long
+    stop=stop_after_attempt(120),   # generous polling
     reraise=True,
 )
 def _videos_retrieve(client: OpenAI, job_id: str) -> Any:
-    return client.videos.retrieve(job_id)
+    """
+    Dual-path retrieve: videos.retrieve and videos.jobs.retrieve
+    """
+    try:
+        return client.videos.retrieve(job_id)
+    except Exception:
+        return client.videos.jobs.retrieve(job_id)
 
 def _extract_status(resp: Any) -> JobStatus:
     status = getattr(resp, "status", None) or getattr(resp, "state", None) or "unknown"
-    err = None
-    out_url = None
-    out_b64 = None
+    err = None; out_url = None; out_b64 = None
 
     output = getattr(resp, "output", None) or getattr(resp, "result", None)
     if output:
@@ -118,10 +135,8 @@ def _extract_status(resp: Any) -> JobStatus:
         artifacts = getattr(output, "artifacts", None)
         if artifacts and isinstance(artifacts, list):
             for a in artifacts:
-                if not out_b64:
-                    out_b64 = getattr(a, "b64_mp4", None) or getattr(a, "b64_video", None)
-                if not out_url:
-                    out_url = getattr(a, "url", None)
+                out_b64 = out_b64 or getattr(a, "b64_mp4", None) or getattr(a, "b64_video", None)
+                out_url = out_url or getattr(a, "url", None)
 
     err_obj = getattr(resp, "error", None)
     if err_obj:
@@ -129,7 +144,7 @@ def _extract_status(resp: Any) -> JobStatus:
 
     return JobStatus(status=status, error=err, output_url=out_url, output_b64=out_b64)
 
-# ---- Core generation ----
+# ---------- core ----------
 def generate_video(api_key: str,
                    prompt: str,
                    model: str,
@@ -138,11 +153,18 @@ def generate_video(api_key: str,
                    seed: int,
                    audio: str,
                    guidance: float,
-                   init_image: Optional[str]) -> Tuple[Optional[str], str]:
-
+                   init_image: Optional[str],
+                   progress=gr.Progress(track_tqdm=False)) -> Tuple[Optional[str], str]:
+    """
+    Always returns (video_path_or_url, status_text)
+    Never raises to Gradio.
+    """
     try:
         client = _make_client(api_key)
+    except Exception as e_init:
+        return None, f"Setup error: {e_init}"
 
+    try:
         prompt = _sanitize_prompt(prompt)
         model = _validate_model(model)
         duration = _validate_duration(duration)
@@ -168,13 +190,16 @@ def generate_video(api_key: str,
         if init_image:
             req["image"] = {"b64": _file_to_b64(init_image)}
 
+        progress(0.02, desc="Submitting job...")
         job = _videos_generate(client, **req)
         job_id = getattr(job, "id", None) or getattr(job, "job_id", None)
         if not job_id:
             return None, "Could not get a job id from the API response."
 
         start = time.time()
+        last_tick = start
         while True:
+            progress(min(0.95, 0.05 + (time.time() - start) / 600.0), desc="Rendering...")
             status_obj = _videos_retrieve(client, job_id)
             js = _extract_status(status_obj)
 
@@ -190,7 +215,7 @@ def generate_video(api_key: str,
                         return out_path, f"Downloaded from URL. Done with {model}."
                     except Exception as dl_err:
                         return js.output_url, f"Ready (URL) — local download failed: {dl_err}"
-                return None, "Job succeeded but no payload was returned. Try a shorter duration or different size."
+                return None, "Job succeeded but no video payload was returned."
 
             if js.status in ("failed", "error", "canceled", "cancelled"):
                 detail = f"Status: {js.status}."
@@ -198,23 +223,29 @@ def generate_video(api_key: str,
                     detail += f" Error: {js.error}"
                 return None, detail
 
-            if time.time() - start > 1200:  # 20 min safety timeout
-                return None, "Timed out waiting for the video. Try a shorter duration."
+            # heartbeat so Spaces doesn’t think nothing’s happening
+            if time.time() - last_tick > 15:
+                last_tick = time.time()
+
+            if time.time() - start > 1800:  # 30 min cap
+                return None, "Timed out waiting for the video. Try shorter duration or lower resolution."
 
             time.sleep(2)
 
-    except (APIConnectionError, RateLimitError, APIStatusError) as oe:
+    except _OAI_EXC as oe:
         return None, f"OpenAI API issue: {oe}. Retried with backoff; try shorter duration/resolution."
     except Exception as e:
-        return None, f"Error: {e}"
+        # full trace into status (so it never looks like “nothing happened”)
+        msg = f"Error: {e}\n\n{traceback.format_exc(limit=3)}"
+        return None, msg
 
-# ---- UI ----
+# ---------- UI ----------
 def build_ui():
     with gr.Blocks(title="ZEN — Sora / Sora-2 / Sora-2-Pro", theme=gr.themes.Soft()) as demo:
         gr.Markdown("## ZEN — Sora / Sora-2 / Sora-2-Pro (OpenAI Videos API)")
         gr.Markdown(
-            "Paste an OpenAI API key (never stored). Provide a detailed prompt. "
-            "This app retries automatically and never crashes the UI."
+            "Paste an OpenAI API key (not stored). Provide a detailed prompt. "
+            "This app uses retries, progress, and robust polling—no silent resets."
         )
 
         with gr.Row():
@@ -226,7 +257,7 @@ def build_ui():
             duration = gr.Slider(1, 30, value=10, step=1, label="Duration (seconds)")
             seed = gr.Number(value=0, precision=0, label="Seed (0 = random)")
             guidance = gr.Slider(0.0, 20.0, value=7.5, step=0.5, label="Guidance")
-            audio = gr.Dropdown(["on", "off"], value="on", label="Audio")
+            audio = gr.Dropdown(["on","off"], value="on", label="Audio")
 
         prompt = gr.Textbox(
             label="Prompt",
@@ -237,17 +268,18 @@ def build_ui():
 
         go = gr.Button("Generate", variant="primary")
         video = gr.Video(label="Result", autoplay=True)
-        status = gr.Textbox(label="Status", interactive=False)
+        status = gr.Textbox(label="Status / Logs", interactive=False)
 
         go.click(
             fn=generate_video,
             inputs=[api_key, prompt, model, duration, size, seed, audio, guidance, init_image],
             outputs=[video, status],
-            queue=True,
-            concurrency_limit=2
+            queue=True
         )
-
     return demo
 
+demo = build_ui()
+# Global queue so clicks are sticky; status tracker keeps a panel in Spaces
+demo.queue(concurrency_count=2, status_tracker=True)
 if __name__ == "__main__":
-    build_ui().launch()
+    demo.launch()