Update app.py

app.py

@@ -1,73 +1,411 @@
 import gradio as gr
-import ffmpeg
 import os
-import logging
-import mimetypes
+import json
+import tempfile
+import time
+import requests
+from datetime import datetime
+import google.generativeai as genai
+from typing import Optional, Dict, Any
 
-# Konfigurasi logging
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
+# CSS untuk styling
+CSS = """
+.container {
+    max-width: 1200px;
+    margin: auto;
+    padding: 20px;
+}
+.title {
+    text-align: center;
+    font-size: 2.5em;
+    font-weight: bold;
+    margin-bottom: 20px;
+    background: linear-gradient(135deg, #4285f4 0%, #ea4335 100%);
+    -webkit-background-clip: text;
+    -webkit-text-fill-color: transparent;
+}
+.subtitle {
+    text-align: center;
+    font-size: 1.2em;
+    color: #5f6368;
+    margin-bottom: 30px;
+}
+.generate-btn {
+    background: #4285f4 !important;
+    color: white !important;
+    font-size: 1.2em !important;
+    padding: 15px 30px !important;
+    border-radius: 24px !important;
+    border: none !important;
+    cursor: pointer !important;
+    transition: all 0.3s ease !important;
+}
+.generate-btn:hover {
+    background: #1a73e8 !important;
+    box-shadow: 0 1px 2px 0 rgba(60,64,67,0.3), 0 2px 6px 2px rgba(60,64,67,0.15) !important;
+}
+.api-key-input {
+    border: 2px solid #e0e0e0 !important;
+    border-radius: 8px !important;
+    padding: 10px !important;
+    font-family: monospace !important;
+    background-color: #f8f9fa !important;
+}
+.api-key-input:focus {
+    border-color: #4285f4 !important;
+    outline: none !important;
+}
+.status-box {
+    padding: 10px;
+    border-radius: 8px;
+    margin: 10px 0;
+}
+.status-success {
+    background-color: #e6f4ea;
+    border: 1px solid #34a853;
+    color: #1e8e3e;
+}
+.status-error {
+    background-color: #fce8e6;
+    border: 1px solid #ea4335;
+    color: #d33b27;
+}
+.status-info {
+    background-color: #e8f0fe;
+    border: 1px solid #4285f4;
+    color: #1967d2;
+}
+"""
 
-# Batasan ukuran file (100 MB)
-MAX_FILE_SIZE = 100 * 1024 * 1024
-
-def is_valid_video(file_path):
-    mime_type, _ = mimetypes.guess_type(file_path)
-    return mime_type and mime_type.startswith('video/')
-
-def generate_video(input_video, text_overlay):
-    logger.info("Starting video generation...")
-
-    # Ambil file path langsung dari Gradio
-    input_path = input_video
-
-    # Cek apakah file adalah video
-    if not is_valid_video(input_path):
-        raise gr.Error("Invalid file type. Please upload a video file.")
-
-    # Cek ukuran file
-    if os.path.getsize(input_path) > MAX_FILE_SIZE:
-        raise gr.Error(f"File size exceeds the maximum limit of {MAX_FILE_SIZE / (1024 * 1024):.2f} MB.")
-
-    # Path untuk output video
-    output_path = os.path.join(os.getcwd(), "output_video.mp4")
-
-    try:
-        # Proses video dengan FFmpeg
-        (
-            ffmpeg
-            .input(input_path)
-            .drawtext(
-                text=text_overlay,
-                fontsize=24,
-                fontcolor='white',
-                x=(10),
-                y=(10),
-                box=1,
-                boxcolor='black@0.5'
-            )
-            .output(output_path)
-            .run(capture_stderr=True)
+class VideoGenerator:
+    def __init__(self):
+        self.api_key = None
+        self.model = None
+        
+    def validate_api_key(self, api_key: str) -> tuple[bool, str]:
+        """Validate Google API key"""
+        if not api_key or api_key.strip() == "":
+            return False, "❌ API key cannot be empty"
+        
+        try:
+            # Configure genai with the provided API key
+            genai.configure(api_key=api_key.strip())
+            
+            # Test the API key by listing models
+            models = genai.list_models()
+            model_names = [m.name for m in models]
+            
+            # Check for video generation models
+            video_models = [m for m in model_names if 'video' in m.lower() or 'gemini' in m.lower()]
+            
+            if video_models:
+                self.api_key = api_key.strip()
+                return True, f"✅ API key validated! Found {len(video_models)} compatible models."
+            else:
+                self.api_key = api_key.strip()
+                return True, "✅ API key validated! Using image generation with frame interpolation."
+                
+        except Exception as e:
+            return False, f"❌ Invalid API key: {str(e)}"
+    
+    def generate_video_from_images(
+        self,
+        prompt: str,
+        negative_prompt: str,
+        duration: int,
+        fps: int,
+        resolution: tuple,
+        style: str,
+        progress=gr.Progress()
+    ) -> tuple[Optional[str], str]:
+        """Generate video by creating multiple images and combining them"""
+        
+        try:
+            import cv2
+            import numpy as np
+            from PIL import Image
+            
+            progress(0.1, desc="Initializing image generation...")
+            
+            # Use Gemini for image generation (if available)
+            model = genai.GenerativeModel('gemini-pro')
+            
+            # Calculate number of frames
+            total_frames = duration * fps
+            keyframes_count = min(duration * 2, 8)  # 2 keyframes per second, max 8
+            
+            # Generate text variations for each keyframe
+            progress(0.2, desc="Creating scene descriptions...")
+            
+            scene_descriptions = []
+            for i in range(keyframes_count):
+                time_point = i / (keyframes_count - 1) if keyframes_count > 1 else 0
+                
+                # Create temporal description
+                temporal_desc = ""
+                if i == 0:
+                    temporal_desc = "Beginning scene: "
+                elif i == keyframes_count - 1:
+                    temporal_desc = "Final scene: "
+                else:
+                    temporal_desc = f"Scene at {int(time_point * 100)}% progress: "
+                
+                full_prompt = f"{temporal_desc}{prompt}. Style: {style}."
+                if negative_prompt:
+                    full_prompt += f" Avoid: {negative_prompt}"
+                
+                scene_descriptions.append(full_prompt)
+            
+            # Since we can't generate images directly with Gemini,
+            # we'll create a placeholder video with text
+            progress(0.5, desc="Generating video frames...")
+            
+            width, height = resolution
+            fourcc = cv2.VideoWriter_fourcc(*'mp4v')
+            temp_path = tempfile.mktemp(suffix='.mp4')
+            out = cv2.VideoWriter(temp_path, fourcc, fps, (width, height))
+            
+            # Create frames with gradient background and text
+            for frame_idx in range(total_frames):
+                progress(0.5 + 0.4 * (frame_idx / total_frames), 
+                        desc=f"Creating frame {frame_idx + 1}/{total_frames}...")
+                
+                # Create gradient background
+                frame = np.zeros((height, width, 3), dtype=np.uint8)
+                
+                # Animated gradient
+                t = frame_idx / total_frames
+                color1 = np.array([66, 133, 244])  # Google Blue
+                color2 = np.array([234, 67, 53])   # Google Red
+                
+                for y in range(height):
+                    blend = (y / height + t) % 1.0
+                    color = color1 * (1 - blend) + color2 * blend
+                    frame[y, :] = color.astype(np.uint8)
+                
+                # Add text overlay
+                text_lines = [
+                    "AI Video Generation Preview",
+                    f"Prompt: {prompt[:50]}...",
+                    f"Frame: {frame_idx + 1}/{total_frames}",
+                    f"Duration: {duration}s | Style: {style}"
+                ]
+                
+                y_position = height // 4
+                for line in text_lines:
+                    cv2.putText(frame, line, (50, y_position), 
+                               cv2.FONT_HERSHEY_SIMPLEX, 0.7, (255, 255, 255), 2)
+                    y_position += 40
+                
+                # Add loading animation
+                center = (width // 2, height // 2 + 100)
+                radius = 30
+                angle = (frame_idx * 10) % 360
+                end_point = (
+                    int(center[0] + radius * np.cos(np.radians(angle))),
+                    int(center[1] + radius * np.sin(np.radians(angle)))
+                )
+                cv2.circle(frame, center, radius, (255, 255, 255), 2)
+                cv2.line(frame, center, end_point, (255, 255, 255), 3)
+                
+                out.write(frame)
+            
+            out.release()
+            progress(1.0, desc="Video generation complete!")
+            
+            return temp_path, "✅ Preview video generated successfully! (Note: This is a placeholder. Real video generation requires specific API access.)"
+            
+        except Exception as e:
+            return None, f"❌ Error generating video: {str(e)}"
+    
+    def generate_video_with_api(
+        self,
+        api_key: str,
+        prompt: str,
+        negative_prompt: str,
+        duration: int,
+        resolution: str,
+        aspect_ratio: str,
+        style: str,
+        motion_intensity: float,
+        camera_movement: str,
+        progress=gr.Progress()
+    ) -> tuple[Optional[str], str]:
+        """Main video generation function"""
+        
+        # Validate API key first
+        is_valid, message = self.validate_api_key(api_key)
+        if not is_valid:
+            return None, message
+        
+        if not prompt:
+            return None, "❌ Please enter a video description."
+        
+        # Parse resolution
+        res_map = {
+            "480p": (640, 480),
+            "720p": (1280, 720),
+            "1080p": (1920, 1080),
+            "4K": (3840, 2160)
+        }
+        width, height = res_map.get(resolution, (1280, 720))
+        
+        # Adjust for aspect ratio
+        if aspect_ratio == "9:16":  # Portrait
+            width, height = height, width
+        elif aspect_ratio == "1:1":  # Square
+            width = height = min(width, height)
+        elif aspect_ratio == "4:3":
+            width = int(height * 4 / 3)
+        elif aspect_ratio == "21:9":
+            width = int(height * 21 / 9)
+        
+        # Set FPS based on motion intensity
+        fps = int(8 + motion_intensity * 16)  # 8-24 fps
+        
+        # Generate video
+        return self.generate_video_from_images(
+            prompt, negative_prompt, duration, fps, 
+            (width, height), style, progress
         )
-    except ffmpeg.Error as e:
-        logger.error(f"FFmpeg error: {e.stderr.decode()}")
-        raise gr.Error("Failed to process video. Please check the input file and try again.")
-
-    logger.info("Video generated successfully.")
-    return output_path
 
-# Antarmuka Gradio
-iface = gr.Interface(
-    fn=generate_video,
-    inputs=[
-        gr.File(label="Upload Video", file_types=["video"]),
-        gr.Textbox(lines=2, label="Text Overlay"),
-    ],
-    outputs=gr.Video(label="Generated Video"),
-    title="Video Generator (Veo 3 Style)",
-    description="Upload a video, add text overlay, and generate a new video.",
-)
+# Create global instance
+video_generator = VideoGenerator()
 
-# Jalankan aplikasi
-if __name__ == "__main__":
-    iface.launch()
+# Create Gradio interface
+with gr.Blocks(css=CSS, theme=gr.themes.Default()) as demo:
+    gr.HTML("""
+        <div class="container">
+            <h1 class="title">🎬 Google AI Video Generator</h1>
+            <p class="subtitle">Create AI-generated videos using Google Generative AI</p>
+        </div>
+    """)
+    
+    # API Key Section
+    with gr.Row():
+        with gr.Column():
+            gr.HTML("""
+                <div class="status-box status-info">
+                    <strong>🔑 API Key Required</strong><br>
+                    Enter your Google AI API key below. Get one from 
+                    <a href="https://makersuite.google.com/app/apikey" target="_blank">Google AI Studio</a>
+                </div>
+            """)
+            
+            api_key_input = gr.Textbox(
+                label="Google AI API Key",
+                placeholder="Enter your API key here...",
+                type="password",
+                elem_classes="api-key-input"
+            )
+            
+            validate_btn = gr.Button("🔍 Validate API Key", size="sm")
+            api_status = gr.HTML()
+    
+    gr.HTML("<hr style='margin: 30px 0;'>")
+    
+    with gr.Row():
+        with gr.Column(scale=1):
+            # Main inputs
+            prompt = gr.Textbox(
+                label="Video Description",
+                placeholder="Describe the video you want to create...",
+                lines=4
+            )
+            
+            with gr.Accordion("⚙️ Advanced Settings", open=False):
+                negative_prompt = gr.Textbox(
+                    label="Negative Prompt (what to avoid)",
+                    placeholder="Things you don't want in the video...",
+                    lines=2
+                )
+                
+                with gr.Row():
+                    duration = gr.Slider(
+                        minimum=1,
+                        maximum=10,
+                        value=5,
+                        step=1,
+                        label="Duration (seconds)"
+                    )
+                    
+                    resolution = gr.Dropdown(
+                        choices=["480p", "720p", "1080p", "4K"],
+                        value="720p",
+                        label="Resolution"
+                    )
+                
+                with gr.Row():
+                    aspect_ratio = gr.Dropdown(
+                        choices=["16:9", "9:16", "1:1", "4:3", "21:9"],
+                        value="16:9",
+                        label="Aspect Ratio"
+                    )
+                    
+                    style = gr.Dropdown(
+                        choices=["auto", "realistic", "animated", "artistic", "cinematic", "abstract"],
+                        value="auto",
+                        label="Visual Style"
+                    )
+                
+                with gr.Row():
+                    motion_intensity = gr.Slider(
+                        minimum=0.0,
+                        maximum=1.0,
+                        value=0.5,
+                        step=0.1,
+                        label="Motion Intensity"
+                    )
+                    
+                    camera_movement = gr.Dropdown(
+                        choices=["static", "pan", "zoom", "orbit", "tracking"],
+                        value="static",
+                        label="Camera Movement"
+                    )
+            
+            generate_btn = gr.Button("🎥 Generate Video", elem_classes="generate-btn", size="lg")
+            
+            # Examples
+            gr.Examples(
+                examples=[
+                    ["A serene sunrise over mountain peaks with moving clouds"],
+                    ["Futuristic city with flying vehicles and neon lights at night"],
+                    ["Ocean waves gently crashing on a tropical beach at sunset"],
+                    ["Cherry blossoms falling in slow motion in a Japanese garden"],
+                    ["Aurora borealis dancing across the arctic night sky"],
+                    ["A cat playing with a ball of yarn in slow motion"],
+                    ["Time-lapse of a flower blooming"],
+                    ["Aerial view of a winding river through a forest"],
+                ],
+                inputs=prompt,
+                label="Example Prompts"
+            )
+        
+        with gr.Column(scale=1):
+            # Output
+            video_output = gr.Video(label="Generated Video")
+            status_text = gr.Textbox(label="Generation Status", interactive=False, lines=3)
+            
+            # Tips
+            gr.Markdown("""
+            ### 💡 Tips for Better Results:
+            
+            1. **Be Specific**: Include details about objects, colors, lighting, and mood
+            2. **Describe Motion**: Specify how things should move in your video
+            3. **Set the Scene**: Include time of day, weather, and environment details
+            4. **Use Style Keywords**: Add words like "cinematic", "realistic", or "animated"
+            5. **Camera Angles**: Mention perspectives like "aerial view" or "close-up"
+            
+            ### 📝 Example Format:
+            ```
+            [Subject] [Action] [Environment] [Style] [Mood]
+            ```
+            
+            ### ⚠️ Note:
+            This demo creates preview videos. Full video generation requires 
+            specific API access from Google Cloud.
+            """)
+    
+    # Event handlers
+    def validate_api_key(api_key):
+        is_valid, message = video_generator.validate_api_