updated app

app.py

@@ -428,68 +428,144 @@ def generate_video_happyhorse_app(prompt, api_key, duration=5, aspect="16:9", im
         "aspect_ratio": aspect,
         "sound": False,
     }
-    if image_url:
+    if image_url and not image_url.startswith("data:"):
+        # Only pass public URLs, not data URIs (happyhorse.app may not support data URIs)
         payload["image_urls"] = [image_url]
 
-    resp = http_requests.post(
-        HAPPYHORSE_PROVIDERS["happyhorse.app"]["generate"],
-        json=payload, headers=headers, timeout=30,
-    )
-    if resp.status_code != 200:
-        raise RuntimeError(f"happyhorse.app submit failed: {resp.text[:200]}")
+    generate_url = HAPPYHORSE_PROVIDERS["happyhorse.app"]["generate"]
+    print(f"[HappyHorse] Submitting to {generate_url}")
+    print(f"[HappyHorse] Prompt: {prompt[:100]}...")
+
+    resp = http_requests.post(generate_url, json=payload, headers=headers, timeout=60)
+    print(f"[HappyHorse] Submit response: {resp.status_code}")
 
-    task_id = resp.json().get("data", {}).get("task_id")
+    if resp.status_code != 200:
+        resp_text = resp.text[:500]
+        print(f"[HappyHorse] Error: {resp_text}")
+        raise RuntimeError(f"happyhorse.app submit failed ({resp.status_code}): {resp_text}")
+
+    resp_data = resp.json()
+    print(f"[HappyHorse] Response data: {json.dumps(resp_data)[:300]}")
+
+    # Handle different response structures
+    task_id = (
+        resp_data.get("data", {}).get("task_id")
+        or resp_data.get("task_id")
+        or resp_data.get("id")
+    )
     if not task_id:
-        raise RuntimeError("No task_id returned")
+        raise RuntimeError(f"No task_id in response: {json.dumps(resp_data)[:300]}")
+
+    print(f"[HappyHorse] Task ID: {task_id}")
 
+    # Poll for completion
     status_url = HAPPYHORSE_PROVIDERS["happyhorse.app"]["status"]
-    for _ in range(120):
+    for attempt in range(90):  # ~15 minutes max
         time.sleep(10)
-        s = http_requests.get(f"{status_url}?task_id={task_id}", headers=headers, timeout=30).json()
-        status = s.get("data", {}).get("status", "")
-        if status == "SUCCESS":
-            urls = s.get("data", {}).get("response", {}).get("resultUrls", [])
-            return urls[0] if urls else None
-        elif status == "FAILED":
-            raise RuntimeError(f"happyhorse.app failed: {s.get('data', {}).get('error_message', '')}")
-    raise RuntimeError("happyhorse.app timeout")
+        try:
+            s = http_requests.get(
+                f"{status_url}?task_id={task_id}",
+                headers=headers, timeout=30,
+            ).json()
+        except Exception as e:
+            print(f"[HappyHorse] Poll error (attempt {attempt}): {e}")
+            continue
+
+        # Handle different status response structures
+        status_data = s.get("data", s)
+        status = (
+            status_data.get("status", "")
+            or s.get("status", "")
+        )
+        print(f"[HappyHorse] Poll {attempt}: status={status}")
+
+        if status in ("SUCCESS", "COMPLETED", "completed", "succeeded"):
+            # Try different result URL paths
+            urls = (
+                status_data.get("response", {}).get("resultUrls", [])
+                or status_data.get("resultUrls", [])
+                or [status_data.get("video_url")]
+                or [status_data.get("output", {}).get("video_url")]
+            )
+            urls = [u for u in urls if u]  # Filter None
+            if urls:
+                print(f"[HappyHorse] Video URL: {urls[0][:100]}")
+                return urls[0]
+            raise RuntimeError(f"Status SUCCESS but no video URL found in: {json.dumps(s)[:300]}")
+
+        elif status in ("FAILED", "failed", "error"):
+            error_msg = (
+                status_data.get("error_message", "")
+                or status_data.get("error", "")
+                or "Unknown error"
+            )
+            raise RuntimeError(f"happyhorse.app failed: {error_msg}")
+
+    raise RuntimeError("happyhorse.app timeout after 15 minutes")
 
 
 def generate_video_dashscope(prompt, api_key, duration=5, aspect="16:9", image_url=None):
     """Generate video via DashScope Bailian (async task API)."""
-    headers = {"Authorization": f"Bearer {api_key}", "Content-Type": "application/json", "X-DashScope-Async": "enable"}
+    headers = {
+        "Authorization": f"Bearer {api_key}",
+        "Content-Type": "application/json",
+        "X-DashScope-Async": "enable",
+    }
     payload = {
         "model": "happyhorse-1.0",
         "input": {"prompt": prompt},
         "parameters": {"duration": duration, "aspect_ratio": aspect},
     }
-    if image_url:
+    if image_url and not image_url.startswith("data:"):
         payload["input"]["image_url"] = image_url
 
-    resp = http_requests.post(
-        HAPPYHORSE_PROVIDERS["DashScope (Bailian)"]["generate"],
-        json=payload, headers=headers, timeout=30,
-    )
+    generate_url = HAPPYHORSE_PROVIDERS["DashScope (Bailian)"]["generate"]
+    print(f"[DashScope] Submitting to {generate_url}")
+    print(f"[DashScope] Prompt: {prompt[:100]}...")
+
+    resp = http_requests.post(generate_url, json=payload, headers=headers, timeout=60)
+    print(f"[DashScope] Submit response: {resp.status_code}")
+
     if resp.status_code != 200:
-        raise RuntimeError(f"DashScope submit failed: {resp.text[:200]}")
+        resp_text = resp.text[:500]
+        print(f"[DashScope] Error: {resp_text}")
+        raise RuntimeError(f"DashScope submit failed ({resp.status_code}): {resp_text}")
+
+    resp_data = resp.json()
+    print(f"[DashScope] Response: {json.dumps(resp_data)[:300]}")
 
-    task_id = resp.json().get("output", {}).get("task_id")
+    task_id = resp_data.get("output", {}).get("task_id")
     if not task_id:
-        raise RuntimeError("No task_id returned from DashScope")
+        raise RuntimeError(f"No task_id from DashScope: {json.dumps(resp_data)[:300]}")
 
-    for _ in range(120):
+    print(f"[DashScope] Task ID: {task_id}")
+
+    for attempt in range(90):
         time.sleep(10)
-        s = http_requests.get(
-            f"{HAPPYHORSE_PROVIDERS['DashScope (Bailian)']['status']}/{task_id}",
-            headers={"Authorization": f"Bearer {api_key}"}, timeout=30,
-        ).json()
+        try:
+            s = http_requests.get(
+                f"{HAPPYHORSE_PROVIDERS['DashScope (Bailian)']['status']}/{task_id}",
+                headers={"Authorization": f"Bearer {api_key}"}, timeout=30,
+            ).json()
+        except Exception as e:
+            print(f"[DashScope] Poll error (attempt {attempt}): {e}")
+            continue
+
         status = s.get("output", {}).get("task_status", "")
+        print(f"[DashScope] Poll {attempt}: status={status}")
+
         if status == "SUCCEEDED":
             results = s.get("output", {}).get("results", [])
-            return results[0].get("url") if results else None
+            if results:
+                video_url = results[0].get("url")
+                print(f"[DashScope] Video URL: {video_url[:100] if video_url else 'None'}")
+                return video_url
+            raise RuntimeError(f"SUCCEEDED but no results: {json.dumps(s)[:300]}")
         elif status == "FAILED":
-            raise RuntimeError(f"DashScope failed: {s.get('output', {}).get('message', '')}")
-    raise RuntimeError("DashScope timeout")
+            msg = s.get("output", {}).get("message", "Unknown error")
+            raise RuntimeError(f"DashScope failed: {msg}")
+
+    raise RuntimeError("DashScope timeout after 15 minutes")
 
 
 def generate_video(prompt, provider, api_key, duration=5, aspect="16:9", image_url=None):
@@ -662,6 +738,7 @@ def generate_storybook(
 
             # --- Step 2: Generate video ---
             progress(base_frac + 0.02, desc=f"Scene {i+1}/{total}: Generating video...")
+            video_error = None
             try:
                 video_url = generate_video(
                     video_prompt, video_provider, video_key,
@@ -670,18 +747,32 @@ def generate_storybook(
                 scene_video_path = os.path.join(tmp_dir, f"scene_{i:03d}_video.mp4")
                 if video_url:
                     download_video(video_url, scene_video_path)
+                    # Verify the downloaded file is a valid video
+                    file_size = os.path.getsize(scene_video_path)
+                    if file_size < 1000:
+                        video_error = f"Downloaded file too small ({file_size} bytes) - likely not a video"
+                        scene_video_path = None
                 else:
-                    raise RuntimeError("No video URL returned")
+                    video_error = "No video URL returned from API"
+                    scene_video_path = None
             except Exception as e:
-                # Create a black placeholder video
-                scene_video_path = os.path.join(tmp_dir, f"scene_{i:03d}_black.mp4")
+                video_error = str(e)
+                scene_video_path = None
+
+            if scene_video_path is None:
+                # Create a placeholder with text overlay showing the error
+                scene_video_path = os.path.join(tmp_dir, f"scene_{i:03d}_placeholder.mp4")
+                # Escape special chars for ffmpeg drawtext
+                safe_prompt = video_prompt[:80].replace("'", "").replace('"', '').replace(':', ' ')
                 subprocess.run([
                     "ffmpeg", "-y", "-f", "lavfi", "-i",
-                    f"color=c=black:s=1280x720:d={video_duration}:r=24",
+                    f"color=c=0x1a1a2e:s=1280x720:d={video_duration}:r=24",
+                    "-vf", f"drawtext=text='Scene {i+1}':fontsize=48:fontcolor=white:x=(w-text_w)/2:y=(h-text_h)/2-40,"
+                           f"drawtext=text='{safe_prompt[:60]}':fontsize=20:fontcolor=0xaaaaaa:x=(w-text_w)/2:y=(h-text_h)/2+30",
                     "-c:v", "libx264", "-preset", "fast",
                     scene_video_path,
                 ], capture_output=True, check=True)
-                all_transcripts.append(f"Scene {i+1} video failed: {str(e)[:100]}")
+                all_transcripts.append(f"**Scene {i+1} VIDEO ERROR:** {video_error}")
 
             # --- Step 3: Generate narration audio ---
             progress(base_frac + 0.04, desc=f"Scene {i+1}/{total}: Narrating...")