update

app.py

@@ -603,107 +603,70 @@ def mcp_agent_pipeline(niche, style, num_variations=1):
         
         # STEP 4: Create multiple video variations
         status_log.append(f"🎬 **MCP TOOL: create_quote_video_tool (x{len(video_results)})**")
-        status_log.append(f"   ⏳ Creating {len(video_results)} video variations...")
+        status_log.append(f"   ⏳ Creating {len(video_results)} video variations in parallel...")
         
         output_dir = "/tmp/quote_videos"
-        gallery_dir = "/data/gallery_videos"  # HF persistent storage
+        gallery_dir = "/data/gallery_videos"
         os.makedirs(output_dir, exist_ok=True)
         os.makedirs(gallery_dir, exist_ok=True)
         
-        created_videos = []
         import time
         timestamp = int(time.time())
         
-        # Use batch processing if Modal configured and multiple videos
-        modal_endpoint = os.getenv("MODAL_ENDPOINT_URL")
-        if modal_endpoint and len(video_results) > 1:
-            try:
-                # Use batch endpoint for parallel processing
-                batch_endpoint = modal_endpoint.replace("process-video-endpoint", "process-batch-endpoint")
-                
-                status_log.append(f"   🚀 Using Modal batch processing (parallel)...")
-                
-                videos_payload = []
-                for video_result in video_results:
-                    videos_payload.append({
-                        "video_url": video_result["video_url"],
-                        "quote_text": quote,
-                        "audio_b64": None
-                    })
-                
-                import requests
-                import base64
-                
-                response = requests.post(
-                    batch_endpoint,
-                    json={"videos": videos_payload},
-                    timeout=180
-                )
-                
-                if response.status_code == 200:
-                    result = response.json()
-                    if result.get("success"):
-                        # Save all videos
-                        for i, video_data in enumerate(result["videos"]):
-                            output_filename = f"quote_video_v{i+1}_{timestamp}.mp4"
-                            output_path = os.path.join(output_dir, output_filename)
-                            
-                            video_bytes = base64.b64decode(video_data["video"])
-                            with open(output_path, 'wb') as f:
-                                f.write(video_bytes)
-                            
-                            created_videos.append(output_path)
-                            status_log.append(f"   ✅ Variation {i+1} created!")
-                            
-                            # Copy to gallery
-                            import shutil
-                            gallery_filename = f"gallery_{timestamp}_v{i+1}.mp4"
-                            gallery_path = os.path.join(gallery_dir, gallery_filename)
-                            try:
-                                shutil.copy2(output_path, gallery_path)
-                            except:
-                                pass
-                        
-                        status_log.append(f"   ⚡ Batch processing complete! All {len(created_videos)} videos done in parallel")
-                    else:
-                        status_log.append(f"   ⚠️ Batch failed, falling back to sequential...")
-                        raise Exception("Batch failed")
-                else:
-                    status_log.append(f"   ⚠️ Batch endpoint error, falling back to sequential...")
-                    raise Exception("Batch endpoint error")
-                    
-            except Exception as e:
-                # Fall back to sequential processing
-                status_log.append(f"   ⚠️ Batch processing failed: {e}")
-                status_log.append(f"   🔄 Falling back to sequential processing...")
-                created_videos = []  # Reset
-        
-        # Sequential processing (fallback or single video)
-        if len(created_videos) == 0:
-            for i, video_result in enumerate(video_results):
-                output_filename = f"quote_video_v{i+1}_{timestamp}.mp4"
-                output_path = os.path.join(output_dir, output_filename)
-                
-                creation_result = create_quote_video_tool(
-                    video_result["video_url"],
-                    quote,
-                    output_path,
-                    None  # No audio
-                )
+        # Use threading for parallel Modal calls
+        import threading
+        import queue
+        
+        results_queue = queue.Queue()
+        
+        def create_single_video(index, video_result):
+            output_filename = f"quote_video_v{index+1}_{timestamp}.mp4"
+            output_path = os.path.join(output_dir, output_filename)
+            
+            creation_result = create_quote_video_tool(
+                video_result["video_url"],
+                quote,
+                output_path,
+                None
+            )
+            
+            results_queue.put((index, creation_result, output_path))
+        
+        # Start all threads
+        threads = []
+        for i, video_result in enumerate(video_results):
+            thread = threading.Thread(target=create_single_video, args=(i, video_result))
+            thread.start()
+            threads.append(thread)
+        
+        # Wait for all to complete
+        for thread in threads:
+            thread.join()
+        
+        # Collect results
+        created_videos = []
+        all_results = []
+        while not results_queue.empty():
+            all_results.append(results_queue.get())
+        
+        # Sort by index
+        all_results.sort(key=lambda x: x[0])
+        
+        # Process results
+        for index, creation_result, output_path in all_results:
+            if creation_result["success"]:
+                created_videos.append(output_path)
+                status_log.append(f"   ✅ Variation {index+1} created!")
                 
-                if creation_result["success"]:
-                    created_videos.append(creation_result["output_path"])
-                    status_log.append(f"   ✅ Variation {i+1} created!")
-                    
-                    # Copy to gallery for public viewing
-                    import shutil
-                    gallery_filename = f"gallery_{timestamp}_v{i+1}.mp4"
-                    gallery_path = os.path.join(gallery_dir, gallery_filename)
-                    try:
-                        shutil.copy2(creation_result["output_path"], gallery_path)
-                    except:
-                        pass  # Silently fail if can't copy to gallery
-                else:
+                # Copy to gallery
+                import shutil
+                gallery_filename = f"gallery_{timestamp}_v{index+1}.mp4"
+                gallery_path = os.path.join(gallery_dir, gallery_filename)
+                try:
+                    shutil.copy2(output_path, gallery_path)
+                except:
+                    pass
+            else:
                     error_msg = creation_result.get("message", "Unknown error")
                     status_log.append(f"   ⚠️ Variation {i+1} failed: {error_msg}")
         

modal_video_processing.py

@@ -23,9 +23,9 @@ image = modal.Image.debian_slim(python_version="3.11").pip_install(
     cpu=2,
     memory=2048,
     timeout=180,
-    keep_warm=1,  # Keep 1 container warm
-    container_idle_timeout=300,
-    concurrency_limit=10,  # Allow multiple videos in parallel
+    concurrency_limit=10,  # Allow 10 videos at once
+    allow_concurrent_inputs=10,  # Process multiple in parallel
+    container_idle_timeout=120,
 )
 def process_quote_video(video_url: str, quote_text: str, audio_b64: str = None) -> bytes:
     """
@@ -215,4 +215,4 @@ def process_batch_endpoint(data: dict):
     
     except Exception as e:
         return {"error": str(e)}, 500
-
+