update

app.py

@@ -614,30 +614,96 @@ def mcp_agent_pipeline(niche, style, num_variations=1):
         import time
         timestamp = int(time.time())
         
-        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
-            )
-            
-            if creation_result["success"]:
-                created_videos.append(creation_result["output_path"])
-                status_log.append(f"   ✅ Variation {i+1} created!")
+        # 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")
                 
-                # 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:
+                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
+                )
+                
+                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:
                 error_msg = creation_result.get("message", "Unknown error")
                 status_log.append(f"   ⚠️ Variation {i+1} failed: {error_msg}")
         

modal_video_processing.py

@@ -25,6 +25,7 @@ image = modal.Image.debian_slim(python_version="3.11").pip_install(
     timeout=180,
     keep_warm=1,  # Keep 1 container warm
     container_idle_timeout=300,
+    concurrency_limit=10,  # Allow multiple videos in parallel
 )
 def process_quote_video(video_url: str, quote_text: str, audio_b64: str = None) -> bytes:
     """
@@ -173,3 +174,45 @@ def process_video_endpoint(data: dict):
     
     except Exception as e:
         return {"error": str(e)}, 500
+
+
+@app.function(image=image)
+@modal.web_endpoint(method="POST")
+def process_batch_endpoint(data: dict):
+    """
+    Batch endpoint - process multiple videos in PARALLEL.
+    Much faster for generating 2-3 variations!
+    """
+    videos_data = data.get("videos", [])
+    
+    if not videos_data:
+        return {"error": "Missing videos array"}, 400
+    
+    try:
+        # Process all videos in parallel using .map()
+        results = list(process_quote_video.map(
+            [v["video_url"] for v in videos_data],
+            [v["quote_text"] for v in videos_data],
+            [v.get("audio_b64") for v in videos_data]
+        ))
+        
+        # Encode all results
+        import base64
+        encoded_results = []
+        for video_bytes in results:
+            video_b64 = base64.b64encode(video_bytes).decode()
+            encoded_results.append({
+                "success": True,
+                "video": video_b64,
+                "size_mb": len(video_bytes) / 1024 / 1024
+            })
+        
+        return {
+            "success": True,
+            "videos": encoded_results,
+            "count": len(encoded_results)
+        }
+    
+    except Exception as e:
+        return {"error": str(e)}, 500
+