Update app.py

app.py

@@ -6,20 +6,10 @@ from PIL import Image
 import io
 import json
 import time
-import cv2
-import numpy as np
+import zipfile
 import tempfile
 import os
 from gtts import gTTS
-import base64
-import zipfile
-
-# Check for MoviePy availability
-try:
-    from moviepy.editor import ImageSequenceClip, concatenate_videoclips
-    MOVIEPY_AVAILABLE = True
-except ImportError:
-    MOVIEPY_AVAILABLE = False
 
 # Configure page
 st.set_page_config(
@@ -33,32 +23,38 @@ if 'generated_script' not in st.session_state:
     st.session_state.generated_script = None
 if 'storyboard_images' not in st.session_state:
     st.session_state.storyboard_images = []
-if 'video_preview' not in st.session_state:
-    st.session_state.video_preview = None
+if 'gif_preview' not in st.session_state:
+    st.session_state.gif_preview = None
 
-# API Configuration from secrets
-try:
-    gemini_api_key = st.secrets["GEMINI_API_KEY"]
-    hf_token = st.secrets["HF_TOKEN"]
-    
-    # Configure Gemini API
-    genai.configure(api_key=gemini_api_key)
-    
-    # Show success message in sidebar
-    st.sidebar.success("✅ API Keys loaded successfully!")
-    
-except Exception as e:
-    st.error("❌ API Keys not found in secrets. Please configure them in your deployment settings.")
-    st.info("Required secrets: GEMINI_API_KEY, HF_TOKEN")
-    st.stop()
+# API Configuration
+def load_api_keys():
+    """Load API keys from secrets or environment"""
+    try:
+        gemini_api_key = st.secrets.get("GEMINI_API_KEY") or os.getenv("GEMINI_API_KEY")
+        hf_token = st.secrets.get("HF_TOKEN") or os.getenv("HF_TOKEN")
+        
+        if not gemini_api_key or not hf_token:
+            st.error("❌ API Keys not found. Please configure GEMINI_API_KEY and HF_TOKEN")
+            st.stop()
+            
+        return gemini_api_key, hf_token
+    except Exception as e:
+        st.error(f"❌ Error loading API keys: {str(e)}")
+        st.stop()
+
+# Load API keys
+gemini_api_key, hf_token = load_api_keys()
+
+# Configure Gemini API
+genai.configure(api_key=gemini_api_key)
+
+# Initialize Hugging Face client
+client = InferenceClient(token=hf_token)
 
 # Main title
 st.title("🎬 AI Video Script & Storyboard Generator")
 st.markdown("Create professional video scripts and visual storyboards with AI assistance")
 
-# Add information about the app
-st.info("🔑 **API Keys are pre-configured** - Just enter your video details and generate!")
-
 # Input section
 st.header("📝 Video Specifications")
 
@@ -105,7 +101,6 @@ with col2:
 def generate_script_with_gemini(topic, length, style, tone, platform):
     """Generate video script using Gemini API"""
     try:
-        # Use the current Gemini model
         model = genai.GenerativeModel('gemini-1.5-flash')
         
         prompt = f"""
@@ -135,13 +130,13 @@ def generate_script_with_gemini(topic, length, style, tone, platform):
         
         Make sure the scenes add up to the total duration and are engaging for {platform}.
         Include specific visual descriptions that can be used to generate storyboard images.
-        Make sure to return valid JSON only, no additional text or formatting.
+        Return only valid JSON, no additional text.
         """
         
         response = model.generate_content(prompt)
-        
-        # Clean the response text to extract JSON
         response_text = response.text.strip()
+        
+        # Clean JSON response
         if response_text.startswith("```json"):
             response_text = response_text[7:-3]
         elif response_text.startswith("```"):
@@ -150,139 +145,149 @@ def generate_script_with_gemini(topic, length, style, tone, platform):
         script_data = json.loads(response_text)
         return script_data
         
-    except json.JSONDecodeError as e:
-        st.error(f"Error parsing JSON response: {str(e)}")
-        st.write("Raw response:", response.text if 'response' in locals() else "No response")
-        return None
     except Exception as e:
         st.error(f"Error generating script: {str(e)}")
-        # Try alternative model if the first one fails
-        try:
-            st.info("Trying alternative model...")
-            model = genai.GenerativeModel('gemini-1.5-pro')
-            response = model.generate_content(prompt)
-            response_text = response.text.strip()
-            if response_text.startswith("```json"):
-                response_text = response_text[7:-3]
-            elif response_text.startswith("```"):
-                response_text = response_text[3:-3]
-            script_data = json.loads(response_text)
-            return script_data
-        except:
-            return None
+        return generate_fallback_script(topic, length, style, tone, platform)
 
-def generate_storyboard_image(scene_description, art_style):
-    """Generate storyboard image using free Hugging Face models"""
+def generate_fallback_script(topic, length, style, tone, platform):
+    """Generate a simple fallback script"""
     try:
-        # Initialize Hugging Face client
-        client = InferenceClient(token=hf_token)
-        
-        # Style-specific enhancements
-        style_prompts = {
-            "Realistic": "photorealistic, high quality, detailed, professional photography",
-            "Cartoon": "cartoon style, animated, colorful, Disney-like, illustration",
-            "Cinematic": "cinematic lighting, dramatic, film still, high contrast, movie scene",
-            "Minimalistic": "minimalist, clean, simple, geometric, modern design",
-            "Sketch": "pencil sketch, hand-drawn, artistic, black and white line art",
-            "Digital Art": "digital art, concept art, detailed, vibrant colors, fantasy art"
-        }
-        
-        enhanced_prompt = f"{scene_description}, {style_prompts.get(art_style, '')}, storyboard frame, professional, high quality"
+        # Parse length
+        if "second" in length.lower():
+            total_seconds = int(length.split()[0])
+        elif "minute" in length.lower():
+            minutes = int(length.split()[0])
+            total_seconds = minutes * 60
+        else:
+            total_seconds = 60
         
-        # Try multiple free models in case one fails
-        models_to_try = [
-            "black-forest-labs/FLUX.1-schnell",
-            "stabilityai/stable-diffusion-2-1",
-            "runwayml/stable-diffusion-v1-5",
-            "CompVis/stable-diffusion-v1-4"
-        ]
+        # Create scenes
+        num_scenes = max(3, min(8, total_seconds // 10))  # 3-8 scenes
+        scene_duration = total_seconds // num_scenes
         
-        for model in models_to_try:
-            try:
-                image = client.text_to_image(
-                    enhanced_prompt,
-                    model=model
-                )
-                return image
-            except Exception as model_error:
-                st.warning(f"Model {model} failed, trying next...")
-                continue
+        scenes = []
+        scene_types = ["opening", "main content", "detail", "conclusion"]
         
-        # If all models fail, return None
-        st.error("All image generation models failed")
-        return None
+        for i in range(num_scenes):
+            scene_type = scene_types[min(i, len(scene_types)-1)]
+            scene = {
+                "scene_number": i + 1,
+                "duration": f"{scene_duration} seconds",
+                "description": f"A {style.lower()} {scene_type} scene about {topic}, showing professional visuals in {art_style.lower()} style",
+                "dialogue": f"Engaging {tone.lower()} narration about {topic} for scene {i+1}",
+                "camera_angle": ["Wide shot", "Medium shot", "Close-up", "Over shoulder"][i % 4],
+                "visual_elements": f"Professional visuals related to {topic}, {style.lower()} cinematography"
+            }
+            scenes.append(scene)
         
+        return {
+            "title": f"{topic} - {style} Video",
+            "total_duration": length,
+            "scenes": scenes
+        }
     except Exception as e:
-        st.error(f"Error generating image: {str(e)}")
+        st.error(f"Error creating fallback script: {str(e)}")
         return None
 
-def create_video_preview(images, script_data):
-    """Create a basic video preview with Ken Burns effect"""
-    if not images or not script_data or not MOVIEPY_AVAILABLE:
-        return None
+def generate_storyboard_image_stable(scene_description, art_style, max_retries=3):
+    """Generate storyboard image with better error handling"""
+    
+    style_prompts = {
+        "Realistic": "photorealistic, professional, high quality, detailed",
+        "Cartoon": "cartoon style, animated, colorful, illustration, Disney-like",
+        "Cinematic": "cinematic, dramatic lighting, film still, movie scene",
+        "Minimalistic": "minimalist, clean, simple, modern design",
+        "Sketch": "pencil sketch, hand-drawn, artistic, line art",
+        "Digital Art": "digital art, concept art, vibrant colors, detailed"
+    }
+    
+    # Create enhanced prompt
+    base_prompt = f"{scene_description}"
+    style_enhancement = style_prompts.get(art_style, "professional, high quality")
+    enhanced_prompt = f"{base_prompt}, {style_enhancement}, storyboard frame"
+    
+    # Try different approaches
+    approaches = [
+        enhanced_prompt,
+        f"storyboard illustration: {base_prompt}, {style_enhancement}",
+        f"{base_prompt}, simple illustration, clean design"
+    ]
+    
+    for attempt, prompt in enumerate(approaches):
+        try:
+            # Use a more reliable model
+            image = client.text_to_image(
+                prompt,
+                model="runwayml/stable-diffusion-v1-5"  # More reliable model
+            )
+            
+            if image and hasattr(image, 'size'):
+                return image
+            else:
+                raise Exception("Invalid image returned")
+                
+        except Exception as e:
+            if attempt < len(approaches) - 1:
+                time.sleep(2)  # Wait before retry
+                continue
+            else:
+                # Create a placeholder image as last resort
+                return create_placeholder_image(f"Scene: {scene_description[:50]}...")
     
+    return None
+
+def create_placeholder_image(text):
+    """Create a placeholder image with text"""
     try:
-        # Create temporary directory
-        temp_dir = tempfile.mkdtemp()
+        from PIL import Image, ImageDraw, ImageFont
         
-        clips = []
-        for i, (image, scene) in enumerate(zip(images, script_data['scenes'])):
-            if image:
-                # Save image temporarily
-                img_path = os.path.join(temp_dir, f"scene_{i}.jpg")
-                image.save(img_path)
-                
-                # Parse duration (extract number from string like "10 seconds")
-                duration_str = scene.get('duration', '5 seconds')
-                try:
-                    duration = float(duration_str.split()[0])
-                except:
-                    duration = 5.0  # Default duration
-                
-                # Create image clip
-                clip = ImageSequenceClip([img_path], durations=[duration])
-                clip = clip.resize(height=480)  # Standardize height
-                clips.append(clip)
+        # Create a simple placeholder
+        img = Image.new('RGB', (512, 384), color=(200, 200, 200))
+        draw = ImageDraw.Draw(img)
         
-        if clips:
-            # Concatenate all clips
-            final_video = concatenate_videoclips(clips, method="compose")
-            
-            # Save video
-            video_path = os.path.join(temp_dir, "preview.mp4")
-            final_video.write_videofile(
-                video_path,
-                fps=24,
-                codec='libx264',
-                audio_codec='aac',
-                verbose=False,
-                logger=None
-            )
-            
-            return video_path
-            
-    except Exception as e:
-        st.error(f"Error creating video preview: {str(e)}")
+        # Try to use default font
+        try:
+            font = ImageFont.load_default()
+        except:
+            font = None
+        
+        # Add text
+        text_lines = text.split(' ')
+        line_height = 30
+        y_pos = 150
+        
+        for i in range(0, len(text_lines), 4):  # 4 words per line
+            line = ' '.join(text_lines[i:i+4])
+            draw.text((50, y_pos), line, fill=(50, 50, 50), font=font)
+            y_pos += line_height
+            if y_pos > 300:  # Don't overflow
+                break
+        
+        return img
+    except Exception:
         return None
 
 def create_gif_preview(images, script_data):
-    """Create a GIF preview as an alternative to video"""
-    if not images or not script_data:
-        return None
-    
+    """Create a GIF preview"""
     try:
-        # Filter out None images
+        # Filter valid images
         valid_images = [img for img in images if img is not None]
         if not valid_images:
             return None
         
-        # Resize images to consistent size
+        # Resize images
+        target_size = (400, 300)
         resized_images = []
-        target_size = (512, 384)
         
         for image in valid_images:
-            resized_img = image.resize(target_size, Image.Resampling.LANCZOS)
-            resized_images.append(resized_img)
+            try:
+                resized_img = image.resize(target_size, Image.Resampling.LANCZOS)
+                resized_images.append(resized_img)
+            except Exception:
+                continue
+        
+        if not resized_images:
+            return None
         
         # Create GIF
         gif_buffer = io.BytesIO()
@@ -290,21 +295,24 @@ def create_gif_preview(images, script_data):
             gif_buffer,
             format='GIF',
             save_all=True,
-            append_images=resized_images[1:],
-            duration=2000,  # 2 seconds per frame
+            append_images=resized_images[1:] if len(resized_images) > 1 else [],
+            duration=2500,  # 2.5 seconds per frame
             loop=0
         )
         gif_buffer.seek(0)
-        
         return gif_buffer
         
     except Exception as e:
-        st.error(f"Error creating GIF preview: {str(e)}")
+        st.error(f"Error creating GIF: {str(e)}")
         return None
 
 def text_to_speech(text, language='en'):
     """Convert text to speech using gTTS"""
     try:
+        # Limit text length to avoid issues
+        if len(text) > 500:
+            text = text[:500] + "..."
+            
         tts = gTTS(text=text, lang=language, slow=False)
         audio_buffer = io.BytesIO()
         tts.write_to_fp(audio_buffer)
@@ -314,81 +322,103 @@ def text_to_speech(text, language='en'):
         st.error(f"Error generating speech: {str(e)}")
         return None
 
-def generate_fallback_script(topic, length, style, tone, platform):
-    """Generate a fallback script if Gemini fails"""
+def create_download_zip(images, script_data):
+    """Create a ZIP file with all content"""
     try:
-        # Parse length to get number of seconds
-        if "second" in length:
-            total_seconds = int(length.split()[0])
-        elif "minute" in length:
-            minutes = int(length.split()[0])
-            total_seconds = minutes * 60
-        else:
-            total_seconds = 60
-        
-        # Calculate number of scenes (roughly 10-15 seconds per scene)
-        num_scenes = max(2, total_seconds // 12)
-        scene_duration = total_seconds // num_scenes
+        zip_buffer = io.BytesIO()
         
-        scenes = []
-        for i in range(num_scenes):
-            scene = {
-                "scene_number": i + 1,
-                "duration": f"{scene_duration} seconds",
-                "description": f"Scene {i+1} showing {topic} in {style.lower()} style",
-                "dialogue": f"Narration for scene {i+1} about {topic}",
-                "camera_angle": "Medium shot" if i % 2 == 0 else "Close-up",
-                "visual_elements": f"Key visuals related to {topic}"
-            }
-            scenes.append(scene)
-        
-        return {
-            "title": f"{topic} - {style} Video",
-            "total_duration": length,
-            "scenes": scenes
-        }
-    except:
+        with zipfile.ZipFile(zip_buffer, 'w', zipfile.ZIP_DEFLATED) as zip_file:
+            # Add script as JSON
+            script_json = json.dumps(script_data, indent=2)
+            zip_file.writestr("script.json", script_json)
+            
+            # Add script as readable text
+            script_text = f"Title: {script_data.get('title', '')}\n"
+            script_text += f"Duration: {script_data.get('total_duration', '')}\n\n"
+            
+            for i, scene in enumerate(script_data.get('scenes', []), 1):
+                script_text += f"=== SCENE {i} ===\n"
+                script_text += f"Duration: {scene.get('duration', '')}\n"
+                script_text += f"Camera: {scene.get('camera_angle', '')}\n"
+                script_text += f"Description: {scene.get('description', '')}\n"
+                script_text += f"Dialogue: {scene.get('dialogue', '')}\n"
+                script_text += f"Visual Elements: {scene.get('visual_elements', '')}\n\n"
+            
+            zip_file.writestr("script.txt", script_text)
+            
+            # Add images
+            for i, image in enumerate(images):
+                if image:
+                    img_buffer = io.BytesIO()
+                    try:
+                        image.save(img_buffer, format='PNG')
+                        zip_file.writestr(f"scene_{i+1:02d}.png", img_buffer.getvalue())
+                    except Exception:
+                        continue
+        
+        zip_buffer.seek(0)
+        return zip_buffer
+    except Exception as e:
+        st.error(f"Error creating ZIP file: {str(e)}")
         return None
 
 # Main generation button
 if st.button("🚀 Generate Video Script & Storyboard", type="primary"):
-    if not video_topic:
+    if not video_topic.strip():
         st.error("Please enter a video topic")
     else:
+        # Generate script
         with st.spinner("🤖 Generating script with AI..."):
             script_data = generate_script_with_gemini(video_topic, video_length, style, tone, platform)
             
-            # If Gemini fails, use fallback
-            if not script_data:
-                st.warning("Primary AI model failed, using fallback script generation...")
-                script_data = generate_fallback_script(video_topic, video_length, style, tone, platform)
-            
         if script_data:
             st.session_state.generated_script = script_data
             st.success("✅ Script generated successfully!")
             
             # Generate storyboard images
-            with st.spinner("🎨 Creating storyboard images..."):
-                images = []
+            st.info("🎨 Generating storyboard images (this may take a few minutes)...")
+            images = []
+            
+            # Create progress tracking
+            progress_container = st.container()
+            with progress_container:
                 progress_bar = st.progress(0)
+                status_text = st.empty()
+                
+                total_scenes = len(script_data['scenes'])
                 
                 for i, scene in enumerate(script_data['scenes']):
-                    with st.spinner(f"Generating image {i+1}/{len(script_data['scenes'])}..."):
-                        image = generate_storyboard_image(
+                    status_text.text(f"Generating image {i+1}/{total_scenes}: Scene {i+1}")
+                    
+                    try:
+                        image = generate_storyboard_image_stable(
                             scene['description'], 
                             art_style
                         )
                         images.append(image)
-                        progress_bar.progress((i + 1) / len(script_data['scenes']))
                         
-                        # Add a small delay to avoid rate limiting
-                        time.sleep(1)
+                        if image:
+                            st.success(f"✅ Scene {i+1} generated successfully")
+                        else:
+                            st.warning(f"⚠️ Scene {i+1} failed, using placeholder")
+                            
+                    except Exception as e:
+                        st.error(f"❌ Error generating scene {i+1}: {str(e)}")
+                        images.append(None)
+                    
+                    progress_bar.progress((i + 1) / total_scenes)
+                    
+                    # Rate limiting
+                    if i < total_scenes - 1:  # Don't wait after last image
+                        time.sleep(3)  # Wait 3 seconds between requests
+                
+                status_text.text("✅ Storyboard generation complete!")
                 
-                st.session_state.storyboard_images = images
+            st.session_state.storyboard_images = images
+            st.success(f"✅ Generated {len([img for img in images if img is not None])} out of {len(images)} storyboard images!")
             
-            st.success("✅ Storyboard images generated!")
         else:
-            st.error("Failed to generate script. Please try again or modify your request.")
+            st.error("Failed to generate script. Please try again.")
 
 # Display results
 if st.session_state.generated_script:
@@ -399,11 +429,11 @@ if st.session_state.generated_script:
     st.write(f"**Duration:** {script_data.get('total_duration', 'N/A')}")
     
     # Display script in tabs
-    tab1, tab2, tab3 = st.tabs(["📝 Script Details", "🖼️ Storyboard", "🎥 Preview"])
+    tab1, tab2, tab3 = st.tabs(["📝 Script Details", "🖼️ Storyboard", "📥 Export"])
     
     with tab1:
         for i, scene in enumerate(script_data.get('scenes', []), 1):
-            with st.expander(f"Scene {i} - {scene.get('duration', 'N/A')}"):
+            with st.expander(f"Scene {i} - {scene.get('duration', 'N/A')}", expanded=False):
                 col1, col2 = st.columns(2)
                 
                 with col1:
@@ -418,202 +448,130 @@ if st.session_state.generated_script:
                     st.write("**Visual Elements:**")
                     st.write(scene.get('visual_elements', 'N/A'))
                 
-                # Add text-to-speech for dialogue
-                if scene.get('dialogue'):
-                    if st.button(f"🔊 Play Audio - Scene {i}", key=f"audio_{i}"):
-                        with st.spinner("Generating audio..."):
-                            audio_buffer = text_to_speech(scene['dialogue'])
-                            if audio_buffer:
-                                st.audio(audio_buffer.getvalue(), format='audio/mp3')
+                # Text-to-speech
+                dialogue = scene.get('dialogue', '')
+                if dialogue and st.button(f"🔊 Play Audio - Scene {i}", key=f"audio_{i}"):
+                    with st.spinner("Generating audio..."):
+                        audio_buffer = text_to_speech(dialogue)
+                        if audio_buffer:
+                            st.audio(audio_buffer.getvalue(), format='audio/mp3')
     
     with tab2:
         if st.session_state.storyboard_images:
             st.subheader("🎨 Storyboard Images")
             
-            for i, (scene, image) in enumerate(zip(script_data['scenes'], st.session_state.storyboard_images)):
-                col1, col2 = st.columns([1, 2])
+            # Show images in a grid
+            cols_per_row = 2
+            for i in range(0, len(st.session_state.storyboard_images), cols_per_row):
+                cols = st.columns(cols_per_row)
                 
-                with col1:
-                    if image:
-                        st.image(image, caption=f"Scene {i+1}", use_column_width=True)
+                for j, col in enumerate(cols):
+                    idx = i + j
+                    if idx < len(st.session_state.storyboard_images):
+                        image = st.session_state.storyboard_images[idx]
+                        scene = script_data['scenes'][idx] if idx < len(script_data['scenes']) else {}
                         
-                        # Refinement option
-                        if st.button(f"🔄 Regenerate Scene {i+1}", key=f"regen_{i}"):
-                            with st.spinner(f"Regenerating scene {i+1}..."):
-                                new_image = generate_storyboard_image(
-                                    scene['description'], 
-                                    art_style
-                                )
-                                if new_image:
-                                    st.session_state.storyboard_images[i] = new_image
-                                    st.rerun()
-                    else:
-                        st.write("❌ Image generation failed for this scene")
-                        if st.button(f"🔄 Try Again - Scene {i+1}", key=f"retry_{i}"):
-                            with st.spinner(f"Trying to generate scene {i+1}..."):
-                                new_image = generate_storyboard_image(
-                                    scene['description'], 
-                                    art_style
-                                )
-                                if new_image:
-                                    st.session_state.storyboard_images[i] = new_image
-                                    st.rerun()
-                
-                with col2:
-                    st.write(f"**Scene {i+1}: {scene.get('duration', 'N/A')}**")
-                    st.write(f"**Description:** {scene.get('description', 'N/A')}")
-                    st.write(f"**Dialogue:** {scene.get('dialogue', 'N/A')}")
-        else:
-            st.info("No storyboard images generated yet. Click the generate button above.")
-    
-    with tab3:
-        st.subheader("🎥 Video Preview")
-        
-        col1, col2 = st.columns(2)
-        
-        with col1:
-            if MOVIEPY_AVAILABLE:
-                if st.button("🎬 Create Video Preview"):
-                    if st.session_state.storyboard_images:
-                        with st.spinner("Creating video preview..."):
-                            video_path = create_video_preview(
-                                st.session_state.storyboard_images,
-                                script_data
-                            )
+                        with col:
+                            if image:
+                                st.image(image, caption=f"Scene {idx+1}", use_column_width=True)
+                            else:
+                                st.write(f"❌ Scene {idx+1} - Image failed to generate")
                             
-                            if video_path:
-                                st.session_state.video_preview = video_path
-                                st.success("Video preview created!")
-            else:
-                st.info("Video preview requires MoviePy. Feature not available in this deployment.")
-        
-        with col2:
-            if st.button("📱 Create GIF Preview"):
-                if st.session_state.storyboard_images:
-                    with st.spinner("Creating GIF preview..."):
+                            st.write(f"**Duration:** {scene.get('duration', 'N/A')}")
+                            st.write(f"**Description:** {scene.get('description', 'N/A')[:100]}...")
+            
+            # GIF Preview section
+            st.subheader("📱 Animated Preview")
+            col1, col2 = st.columns([1, 2])
+            
+            with col1:
+                if st.button("🎬 Create GIF Preview"):
+                    with st.spinner("Creating animated preview..."):
                         gif_buffer = create_gif_preview(
                             st.session_state.storyboard_images,
                             script_data
                         )
-                        
                         if gif_buffer:
-                            st.session_state.video_preview = gif_buffer
+                            st.session_state.gif_preview = gif_buffer
                             st.success("GIF preview created!")
-        
-        # Display preview
-        if st.session_state.video_preview:
-            if isinstance(st.session_state.video_preview, str) and os.path.exists(st.session_state.video_preview):
-                # Video file
-                st.video(st.session_state.video_preview)
-            elif hasattr(st.session_state.video_preview, 'getvalue'):
-                # GIF buffer
-                st.image(st.session_state.video_preview.getvalue())
-        
-        # Export options
-        st.subheader("📥 Export Options")
+                        else:
+                            st.error("Failed to create GIF preview")
+            
+            with col2:
+                if st.session_state.gif_preview:
+                    st.image(st.session_state.gif_preview.getvalue(), caption="Storyboard Preview")
+        else:
+            st.info("Generate storyboard images first using the button above.")
+    
+    with tab3:
+        st.subheader("📥 Download Options")
         
         col1, col2, col3 = st.columns(3)
         
         with col1:
-            if st.button("📄 Download Script (JSON)"):
-                script_json = json.dumps(script_data, indent=2)
-                st.download_button(
-                    label="Download JSON",
-                    data=script_json,
-                    file_name="video_script.json",
-                    mime="application/json"
-                )
+            # Script download
+            script_json = json.dumps(script_data, indent=2)
+            st.download_button(
+                label="📄 Download Script (JSON)",
+                data=script_json,
+                file_name=f"script_{int(time.time())}.json",
+                mime="application/json"
+            )
         
         with col2:
-            if st.button("🖼️ Download Storyboard Images"):
-                if st.session_state.storyboard_images:
-                    # Create a zip file with all images
-                    zip_buffer = io.BytesIO()
-                    
-                    with zipfile.ZipFile(zip_buffer, 'w') as zip_file:
-                        for i, image in enumerate(st.session_state.storyboard_images):
-                            if image:
-                                img_buffer = io.BytesIO()
-                                image.save(img_buffer, format='PNG')
-                                zip_file.writestr(f"scene_{i+1}.png", img_buffer.getvalue())
-                    
+            # ZIP download
+            if st.session_state.storyboard_images:
+                zip_data = create_download_zip(st.session_state.storyboard_images, script_data)
+                if zip_data:
                     st.download_button(
-                        label="Download ZIP",
-                        data=zip_buffer.getvalue(),
-                        file_name="storyboard_images.zip",
+                        label="📦 Download Complete Package",
+                        data=zip_data.getvalue(),
+                        file_name=f"storyboard_package_{int(time.time())}.zip",
                         mime="application/zip"
                     )
         
         with col3:
-            if st.session_state.video_preview:
-                if isinstance(st.session_state.video_preview, str) and st.session_state.video_preview.endswith('.mp4'):
-                    # MP4 video file
-                    if os.path.exists(st.session_state.video_preview):
-                        with open(st.session_state.video_preview, 'rb') as f:
-                            st.download_button(
-                                label="🎥 Download Video",
-                                data=f.read(),
-                                file_name="video_preview.mp4",
-                                mime="video/mp4"
-                            )
-                elif hasattr(st.session_state.video_preview, 'getvalue'):
-                    # GIF buffer
-                    st.download_button(
-                        label="📱 Download GIF",
-                        data=st.session_state.video_preview.getvalue(),
-                        file_name="storyboard_preview.gif",
-                        mime="image/gif"
-                    )
-
-# Footer
-st.markdown("---")
-st.markdown("🤖 **Powered by**: Gemini AI • Free Hugging Face Models • gTTS")
-st.markdown("💡 **Tips**: Use detailed topic descriptions for better results. Experiment with different art styles!")
+            # GIF download
+            if st.session_state.gif_preview:
+                st.download_button(
+                    label="🎬 Download GIF Preview",
+                    data=st.session_state.gif_preview.getvalue(),
+                    file_name=f"storyboard_preview_{int(time.time())}.gif",
+                    mime="image/gif"
+                )
 
-# Sidebar info
+# Sidebar
 with st.sidebar:
-    st.markdown("---")
     st.markdown("### 📚 How to Use")
     st.markdown("""
-    1. **Define Video**: Enter topic, length, and style
-    2. **Generate**: Click the generate button
-    3. **Refine**: Regenerate individual scenes if needed
-    4. **Export**: Download script, images, or video
+    1. **Enter Details**: Describe your video topic and preferences
+    2. **Generate**: Click the generate button and wait
+    3. **Review**: Check the script and storyboard images
+    4. **Export**: Download your files
     """)
     
-    st.markdown("---")
     st.markdown("### 🔧 Features")
     st.markdown("""
-    - ✅ **AI Script Generation** with Gemini
-    - ✅ **Visual Storyboards** with Free HF Models
-    - ✅ **Text-to-Speech** for narration
-    - ✅ **Multiple Export Formats**
-    - ✅ **Scene Regeneration**
-    - ✅ **GIF Preview Creation**
+    - ✅ AI-powered script generation
+    - ✅ Visual storyboard creation
+    - ✅ Text-to-speech narration
+    - ✅ GIF preview generation
+    - ✅ Complete package download
     """)
     
-    st.markdown("---")
-    st.markdown("### 🆓 Free Models Used")
+    st.markdown("### ⚙️ Settings")
     st.markdown("""
-    - **Script**: Gemini 1.5 Flash/Pro
-    - **Images**: FLUX.1, Stable Diffusion
-    - **Speech**: Google TTS
-    """)
+    **Required API Keys:**
+    - GEMINI_API_KEY
+    - HF_TOKEN (Hugging Face)
     
-    if not MOVIEPY_AVAILABLE:
-        st.markdown("---")
-        st.markdown("### ℹ️ Note")
-        st.markdown("Video preview feature disabled for faster deployment. GIF preview available!")
-
-# Additional configuration section
-st.sidebar.markdown("---")
-st.sidebar.markdown("### ⚙️ Configuration")
-st.sidebar.markdown("""
-**Required Environment Variables:**
-- `GEMINI_API_KEY`: Your Gemini API key
-- `HF_TOKEN`: Your Hugging Face token
+    **Models Used:**
+    - Script: Gemini 1.5 Flash
+    - Images: Stable Diffusion v1.5
+    - Speech: Google TTS
+    """)
 
-**Free API Limits:**
-- Gemini: 15 RPM, 32K TPM
-- Hugging Face: Rate limited per model
-""")
+# Footer
+st.markdown("---")
+st.markdown("🤖 **Powered by**: Gemini AI • Hugging Face • Google TTS")
+st.markdown("💡 **Tips**: Be specific in your descriptions for better results!")