Update app.py

app.py

@@ -575,28 +575,55 @@ class ProfessionalCartoonFilmGenerator:
         """Generate professional videos using Open-Sora 2.0"""
         scene_videos = []
         
+        print(f"🎥 Starting video generation for {len(scenes)} scenes...")
+        print(f"📁 Background images available: {list(background_images.keys())}")
+        
         # Try to use Open-Sora for professional video generation
         opensora_available = self.setup_opensora_for_video()
+        print(f"🎬 Open-Sora available: {opensora_available}")
         
         for scene in scenes:
+            scene_num = scene['scene_number']
+            print(f"\n🎬 Processing scene {scene_num}...")
+            
             try:
                 if opensora_available:
+                    print(f"🎬 Attempting Open-Sora generation for scene {scene_num}...")
                     video_path = self._generate_opensora_video(scene, character_images, background_images)
+                    if video_path:
+                        print(f"✅ Open-Sora video generated for scene {scene_num}")
+                    else:
+                        print(f"❌ Open-Sora failed for scene {scene_num}, trying fallback...")
+                        video_path = self._create_professional_static_video(scene, background_images)
                 else:
+                    print(f"🎬 Using static video fallback for scene {scene_num}...")
                     # Fallback to enhanced static video
                     video_path = self._create_professional_static_video(scene, background_images)
                 
-                if video_path:
+                if video_path and os.path.exists(video_path):
                     scene_videos.append(video_path)
-                    print(f"✅ Generated professional video for scene {scene['scene_number']}")
+                    print(f"✅ Generated professional video for scene {scene_num}: {video_path}")
+                    print(f"📁 Video size: {os.path.getsize(video_path) / (1024*1024):.1f} MB")
+                else:
+                    print(f"❌ No video generated for scene {scene_num}")
                 
             except Exception as e:
-                print(f"❌ Error in scene {scene['scene_number']}: {e}")
+                print(f"❌ Error in scene {scene_num}: {e}")
                 # Create fallback video
-                if scene['scene_number'] in background_images:
-                    video_path = self._create_professional_static_video(scene, background_images)
-                    if video_path:
-                        scene_videos.append(video_path)
+                if scene_num in background_images:
+                    print(f"🔄 Creating emergency fallback for scene {scene_num}...")
+                    try:
+                        video_path = self._create_professional_static_video(scene, background_images)
+                        if video_path and os.path.exists(video_path):
+                            scene_videos.append(video_path)
+                            print(f"✅ Emergency fallback video created for scene {scene_num}")
+                    except Exception as e2:
+                        print(f"❌ Emergency fallback also failed for scene {scene_num}: {e2}")
+        
+        print(f"\n📊 Video generation summary:")
+        print(f"   - Scenes processed: {len(scenes)}")
+        print(f"   - Videos generated: {len(scene_videos)}")
+        print(f"   - Videos list: {scene_videos}")
         
         return scene_videos
     
@@ -654,25 +681,45 @@ class ProfessionalCartoonFilmGenerator:
     
     def _create_professional_static_video(self, scene: Dict, background_images: Dict) -> str:
         """Create professional static video with advanced effects"""
-        if scene['scene_number'] not in background_images:
+        scene_num = scene['scene_number']
+        
+        if scene_num not in background_images:
+            print(f"❌ No background image for scene {scene_num}")
             return None
             
-        video_path = f"{self.temp_dir}/scene_{scene['scene_number']}.mp4"
+        video_path = f"{self.temp_dir}/scene_{scene_num}.mp4"
         
         try:
+            print(f"🎬 Creating static video for scene {scene_num}...")
+            
             # Load background image
-            image = Image.open(background_images[scene['scene_number']])
+            bg_path = background_images[scene_num]
+            print(f"📁 Loading background from: {bg_path}")
+            
+            if not os.path.exists(bg_path):
+                print(f"❌ Background file not found: {bg_path}")
+                return None
+                
+            image = Image.open(bg_path)
             img_array = np.array(image.resize((1024, 768)))  # 4:3 aspect ratio
             img_array = cv2.cvtColor(img_array, cv2.COLOR_RGB2BGR)
             
+            print(f"📐 Image size: {img_array.shape}")
+            
             # Professional video settings
             fourcc = cv2.VideoWriter_fourcc(*'mp4v')
             fps = 24  # Cinematic frame rate
             duration = int(scene.get('duration', 35))
             total_frames = duration * fps
             
+            print(f"🎬 Video settings: {fps}fps, {duration}s duration, {total_frames} frames")
+            
             out = cv2.VideoWriter(video_path, fourcc, fps, (1024, 768))
             
+            if not out.isOpened():
+                print(f"❌ Failed to open video writer for {video_path}")
+                return None
+            
             # Advanced animation effects based on scene mood and type
             for i in range(total_frames):
                 frame = img_array.copy()
@@ -683,10 +730,19 @@ class ProfessionalCartoonFilmGenerator:
                 out.write(frame)
             
             out.release()
-            return video_path
+            
+            if os.path.exists(video_path):
+                file_size = os.path.getsize(video_path)
+                print(f"✅ Static video created: {video_path} ({file_size / (1024*1024):.1f} MB)")
+                return video_path
+            else:
+                print(f"❌ Video file not created: {video_path}")
+                return None
             
         except Exception as e:
-            print(f"❌ Professional static video creation failed: {e}")
+            print(f"❌ Professional static video creation failed for scene {scene_num}: {e}")
+            import traceback
+            traceback.print_exc()
             return None
     
     def _apply_cinematic_effects(self, frame, scene, progress):
@@ -734,6 +790,61 @@ class ProfessionalCartoonFilmGenerator:
         
         return frame
     
+    def _create_emergency_fallback_video(self, script_data: Dict) -> str:
+        """Create a simple emergency fallback video when everything else fails"""
+        try:
+            print("🆘 Creating emergency fallback video...")
+            
+            # Create a simple colored background
+            width, height = 1024, 768
+            background_color = (100, 150, 200)  # Blue-ish color
+            
+            # Create video
+            video_path = f"{self.temp_dir}/emergency_fallback.mp4"
+            fourcc = cv2.VideoWriter_fourcc(*'mp4v')
+            fps = 24
+            duration = 30  # 30 seconds
+            total_frames = duration * fps
+            
+            out = cv2.VideoWriter(video_path, fourcc, fps, (width, height))
+            
+            if not out.isOpened():
+                print("❌ Failed to open emergency video writer")
+                return None
+            
+            # Create simple animated background
+            for i in range(total_frames):
+                frame = np.full((height, width, 3), background_color, dtype=np.uint8)
+                
+                # Add simple animation (color shift)
+                progress = i / total_frames
+                color_shift = int(50 * np.sin(progress * 2 * np.pi))
+                frame[:, :, 0] = np.clip(frame[:, :, 0] + color_shift, 0, 255)
+                
+                # Add text
+                font = cv2.FONT_HERSHEY_SIMPLEX
+                text = f"Cartoon Film: {script_data.get('title', 'Adventure')}"
+                text_size = cv2.getTextSize(text, font, 1, 2)[0]
+                text_x = (width - text_size[0]) // 2
+                text_y = height // 2
+                
+                cv2.putText(frame, text, (text_x, text_y), font, 1, (255, 255, 255), 2)
+                
+                out.write(frame)
+            
+            out.release()
+            
+            if os.path.exists(video_path):
+                print(f"✅ Emergency fallback video created: {video_path}")
+                return video_path
+            else:
+                print("❌ Emergency fallback video file not created")
+                return None
+                
+        except Exception as e:
+            print(f"❌ Emergency fallback video creation failed: {e}")
+            return None
+    
     def merge_professional_film(self, scene_videos: List[str], script_data: Dict) -> str:
         """Merge videos into professional cartoon film"""
         if not scene_videos:
@@ -784,10 +895,12 @@ class ProfessionalCartoonFilmGenerator:
             # Step 1: Generate professional script
             print("📝 Creating professional script structure...")
             script_data = self.generate_professional_script(script)
+            print(f"✅ Script generated with {len(script_data['scenes'])} scenes")
             
             # Step 2: Generate high-quality characters  
             print("🎭 Creating professional character designs...")
             character_images = self.generate_professional_character_images(script_data['characters'])
+            print(f"✅ Characters generated: {list(character_images.keys())}")
             
             # Step 3: Generate cinematic backgrounds
             print("🏞️ Creating cinematic backgrounds...")
@@ -795,6 +908,7 @@ class ProfessionalCartoonFilmGenerator:
                 script_data['scenes'], 
                 script_data['color_palette']
             )
+            print(f"✅ Backgrounds generated: {list(background_images.keys())}")
             
             # Step 4: Generate professional videos
             print("🎥 Creating professional animated scenes...")
@@ -803,20 +917,42 @@ class ProfessionalCartoonFilmGenerator:
                 character_images, 
                 background_images
             )
+            print(f"✅ Videos generated: {len(scene_videos)} videos")
             
             # Step 5: Merge into professional film
-            print("🎞️ Creating final professional cartoon film...")
-            final_video = self.merge_professional_film(scene_videos, script_data)
-            
-            if final_video and os.path.exists(final_video):
-                print("✅ Professional cartoon film generation complete!")
-                return final_video, script_data, "✅ Professional cartoon film generated successfully!"
+            if scene_videos:
+                print("🎞️ Creating final professional cartoon film...")
+                final_video = self.merge_professional_film(scene_videos, script_data)
+                
+                if final_video and os.path.exists(final_video):
+                    file_size = os.path.getsize(final_video) / (1024*1024)
+                    print(f"✅ Professional cartoon film generation complete!")
+                    print(f"📁 Final video: {final_video} ({file_size:.1f} MB)")
+                    return final_video, script_data, f"✅ Professional cartoon film generated successfully! ({file_size:.1f} MB)"
+                else:
+                    print("⚠️ Video merging failed")
+                    return None, script_data, "⚠️ Video merging failed"
             else:
-                print("⚠️ Partial success - some components may be missing")
-                return None, script_data, "⚠️ Generation completed with some issues"
+                print("❌ No videos to merge - video generation failed")
+                print("🔄 Creating emergency fallback video...")
+                
+                # Create at least one simple video as fallback
+                try:
+                    emergency_video = self._create_emergency_fallback_video(script_data)
+                    if emergency_video and os.path.exists(emergency_video):
+                        file_size = os.path.getsize(emergency_video) / (1024*1024)
+                        print(f"✅ Emergency fallback video created: {emergency_video} ({file_size:.1f} MB)")
+                        return emergency_video, script_data, f"⚠️ Emergency fallback video created ({file_size:.1f} MB)"
+                    else:
+                        return None, script_data, "❌ No videos generated - all methods failed"
+                except Exception as e:
+                    print(f"❌ Emergency fallback also failed: {e}")
+                    return None, script_data, "❌ No videos generated - all methods failed"
                 
         except Exception as e:
             print(f"❌ Generation failed: {e}")
+            import traceback
+            traceback.print_exc()
             error_info = {
                 "error": True,
                 "message": str(e),