Update app.py

app.py

@@ -1,91 +1,56 @@
 import gradio as gr
 import os
 import tempfile
-import requests
 import cv2
 import numpy as np
-from PIL import Image
-import replicate
-import base64
-from typing import Optional, Tuple, List
+from PIL import Image, ImageDraw, ImageFont
 import json
 
 # CSS untuk styling
 CSS = """
-.container {
-    max-width: 1400px;
-    margin: auto;
-}
 .title {
     text-align: center;
-    font-size: 2.5em;
+    font-size: 2em;
     font-weight: bold;
     margin-bottom: 20px;
-    background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
-    -webkit-background-clip: text;
-    -webkit-text-fill-color: transparent;
-}
-.feature-card {
-    background: #f8f9fa;
-    padding: 20px;
-    border-radius: 12px;
-    margin: 10px 0;
-    border: 1px solid #e0e0e0;
-}
-.edit-btn {
-    background: linear-gradient(135deg, #667eea 0%, #764ba2 100%) !important;
-    color: white !important;
-    padding: 12px 24px !important;
-    border-radius: 8px !important;
-    border: none !important;
-    font-weight: bold !important;
 }
 """
 
 class VideoEditor:
     def __init__(self):
         self.api_key = None
-        
-    def set_api_key(self, api_key: str) -> Tuple[bool, str]:
-        """Validate and set API key"""
-        if not api_key:
-            return False, "❌ Please enter your API key"
-        
-        try:
-            # Test API key
-            os.environ["REPLICATE_API_TOKEN"] = api_key
-            self.api_key = api_key
-            return True, "✅ API key set successfully!"
-        except Exception as e:
-            return False, f"❌ Error: {str(e)}"
     
-    def extract_frames(self, video_path: str, sample_rate: int = 10) -> List[np.ndarray]:
+    def extract_frames(self, video_path, max_frames=30):
         """Extract frames from video"""
         frames = []
+        if not video_path:
+            return frames
+            
         cap = cv2.VideoCapture(video_path)
-        frame_count = 0
+        total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+        sample_rate = max(1, total_frames // max_frames)
         
-        while cap.isOpened():
+        frame_count = 0
+        while cap.isOpened() and len(frames) < max_frames:
             ret, frame = cap.read()
             if not ret:
                 break
             
             if frame_count % sample_rate == 0:
                 frames.append(cv2.cvtColor(frame, cv2.COLOR_BGR2RGB))
-            
             frame_count += 1
         
         cap.release()
         return frames
     
-    def frames_to_video(self, frames: List[np.ndarray], output_path: str, fps: int = 30):
-        """Convert frames back to video"""
+    def create_video_from_frames(self, frames, output_path, fps=24):
+        """Create video from frames"""
         if not frames:
             return None
-        
-        height, width = frames[0].shape[:2]
+            
+        h, w = frames[0].shape[:2]
         fourcc = cv2.VideoWriter_fourcc(*'mp4v')
-        out = cv2.VideoWriter(output_path, fourcc, fps, (width, height))
+        out = cv2.VideoWriter(output_path, fourcc, fps, (w, h))
         
         for frame in frames:
             out.write(cv2.cvtColor(frame, cv2.COLOR_RGB2BGR))
@@ -93,419 +58,217 @@ class VideoEditor:
         out.release()
         return output_path
     
-    def change_background(
-        self, 
-        video_path: str, 
-        background_prompt: str,
-        progress=gr.Progress()
-    ) -> Tuple[Optional[str], str]:
-        """Change video background using AI"""
-        
-        if not self.api_key:
-            return None, "❌ Please set your API key first"
-        
-        try:
-            progress(0.1, desc="Extracting frames...")
-            frames = self.extract_frames(video_path, sample_rate=15)
+    def add_text_overlay(self, frame, text, position=(50, 50)):
+        """Add text overlay to frame"""
+        frame_copy = frame.copy()
+        cv2.putText(frame_copy, text, position, 
+                   cv2.FONT_HERSHEY_SIMPLEX, 0.7, (255, 255, 255), 2,
+                   cv2.LINE_AA)
+        return frame_copy
+    
+    def change_background(self, video_path, bg_prompt):
+        """Simulate background change"""
+        if not video_path:
+            return None, "Please upload a video first"
             
+        try:
+            # Extract frames
+            frames = self.extract_frames(video_path)
             if not frames:
-                return None, "❌ Failed to extract frames"
-            
-            edited_frames = []
+                return None, "Failed to extract frames"
             
+            # Process frames (simulation)
+            processed_frames = []
             for i, frame in enumerate(frames):
-                progress(0.1 + 0.8 * (i / len(frames)), 
-                        desc=f"Processing frame {i+1}/{len(frames)}...")
-                
-                # Convert frame to PIL Image
-                pil_image = Image.fromarray(frame)
-                
-                # Save temp image
-                temp_img = tempfile.mktemp(suffix='.jpg')
-                pil_image.save(temp_img)
+                # Add overlay to simulate processing
+                text = f"BG: {bg_prompt[:30]}..."
+                processed = self.add_text_overlay(frame, text, (10, 30))
                 
-                # Use Replicate API for background removal and replacement
-                output = replicate.run(
-                    "arielreplicate/robust-video-matting:73d4066550ac7b7c1f58f80439d60e8e31006a0626b8d31895f6b21e0e90e904",
-                    input={
-                        "input_video": open(temp_img, "rb"),
-                        "background_source": background_prompt
-                    }
-                )
-                
-                # Process output (this is a simplified version)
-                # In reality, you'd need to handle the actual API response
-                edited_frames.append(frame)  # Placeholder
-                
-                os.remove(temp_img)
+                # Simple color tint based on prompt
+                if "beach" in bg_prompt.lower():
+                    processed[:,:,2] = np.clip(processed[:,:,2] * 1.1, 0, 255)
+                elif "forest" in bg_prompt.lower():
+                    processed[:,:,1] = np.clip(processed[:,:,1] * 1.2, 0, 255)
+                elif "city" in bg_prompt.lower():
+                    processed = processed * 0.8
+                    
+                processed_frames.append(processed.astype(np.uint8))
             
-            progress(0.9, desc="Creating final video...")
+            # Create output video
             output_path = tempfile.mktemp(suffix='.mp4')
-            self.frames_to_video(edited_frames, output_path)
+            self.create_video_from_frames(processed_frames, output_path)
             
-            return output_path, f"✅ Background changed to: {background_prompt}"
+            return output_path, f"Background changed to: {bg_prompt}"
             
         except Exception as e:
-            return None, f"❌ Error: {str(e)}"
+            return None, f"Error: {str(e)}"
     
-    def change_character_outfit(
-        self,
-        video_path: str,
-        outfit_prompt: str,
-        progress=gr.Progress()
-    ) -> Tuple[Optional[str], str]:
-        """Change character outfit in video"""
-        
-        if not self.api_key:
-            return None, "❌ Please set your API key first"
-        
+    def change_outfit(self, video_path, outfit_prompt):
+        """Simulate outfit change"""
+        if not video_path:
+            return None, "Please upload a video first"
+            
         try:
-            progress(0.1, desc="Analyzing video...")
+            frames = self.extract_frames(video_path)
+            if not frames:
+                return None, "Failed to extract frames"
             
-            # Use AI model for outfit change
-            # This is a placeholder - real implementation would use specific models
-            output = replicate.run(
-                "stability-ai/stable-diffusion:27b93a2413e0f699b8f066bf11dd33bdbbc48333f404ce3be91d8ab4dc19bbc6",
-                input={
-                    "prompt": f"Change outfit to {outfit_prompt}",
-                    "video": open(video_path, "rb")
-                }
-            )
+            processed_frames = []
+            for frame in frames:
+                text = f"Outfit: {outfit_prompt[:25]}..."
+                processed = self.add_text_overlay(frame, text, (10, 60))
+                processed_frames.append(processed)
+            
+            output_path = tempfile.mktemp(suffix='.mp4')
+            self.create_video_from_frames(processed_frames, output_path)
             
-            # For demo purposes, return the original video
-            return video_path, f"✅ Outfit changed to: {outfit_prompt}"
+            return output_path, f"Outfit changed to: {outfit_prompt}"
             
         except Exception as e:
-            return None, f"❌ Error: {str(e)}"
+            return None, f"Error: {str(e)}"
     
-    def change_video_style(
-        self,
-        video_path: str,
-        style_prompt: str,
-        color_prompt: str,
-        progress=gr.Progress()
-    ) -> Tuple[Optional[str], str]:
-        """Apply style and color changes to video"""
-        
-        if not self.api_key:
-            return None, "❌ Please set your API key first"
-        
-        try:
-            progress(0.1, desc="Applying style transfer...")
+    def apply_style(self, video_path, style_prompt, color_prompt):
+        """Apply style and color effects"""
+        if not video_path:
+            return None, "Please upload a video first"
             
-            # Style transfer using AI
-            # Placeholder implementation
-            frames = self.extract_frames(video_path, sample_rate=10)
+        try:
+            frames = self.extract_frames(video_path)
+            if not frames:
+                return None, "Failed to extract frames"
             
-            # Apply color grading based on prompt
-            edited_frames = []
-            for i, frame in enumerate(frames):
-                progress(0.1 + 0.8 * (i / len(frames)), 
-                        desc=f"Styling frame {i+1}/{len(frames)}...")
-                
-                # Simple color adjustment for demo
+            processed_frames = []
+            for frame in frames:
+                # Apply color effects
                 if "warm" in color_prompt.lower():
-                    frame[:, :, 0] = np.clip(frame[:, :, 0] * 1.2, 0, 255)  # Boost red
+                    frame[:,:,0] = np.clip(frame[:,:,0] * 1.2, 0, 255)
+                    frame[:,:,2] = np.clip(frame[:,:,2] * 0.8, 0, 255)
                 elif "cool" in color_prompt.lower():
-                    frame[:, :, 2] = np.clip(frame[:, :, 2] * 1.2, 0, 255)  # Boost blue
+                    frame[:,:,0] = np.clip(frame[:,:,0] * 0.8, 0, 255)
+                    frame[:,:,2] = np.clip(frame[:,:,2] * 1.2, 0, 255)
                 elif "vintage" in color_prompt.lower():
                     # Sepia effect
                     gray = cv2.cvtColor(frame, cv2.COLOR_RGB2GRAY)
                     frame = cv2.cvtColor(gray, cv2.COLOR_GRAY2RGB)
-                    frame[:, :, 0] = np.clip(frame[:, :, 0] * 1.2, 0, 255)
-                    frame[:, :, 1] = np.clip(frame[:, :, 1] * 1.0, 0, 255)
-                    frame[:, :, 2] = np.clip(frame[:, :, 2] * 0.8, 0, 255)
+                    frame[:,:,0] = np.clip(frame[:,:,0] * 1.1, 0, 255)
                 
-                edited_frames.append(frame.astype(np.uint8))
+                text = f"Style: {style_prompt[:20]}..."
+                processed = self.add_text_overlay(frame.astype(np.uint8), text, (10, 90))
+                processed_frames.append(processed)
             
             output_path = tempfile.mktemp(suffix='.mp4')
-            self.frames_to_video(edited_frames, output_path)
+            self.create_video_from_frames(processed_frames, output_path)
             
-            return output_path, f"✅ Style applied: {style_prompt}, Colors: {color_prompt}"
+            return output_path, f"Style applied: {style_prompt}"
             
         except Exception as e:
-            return None, f"❌ Error: {str(e)}"
-    
-    def edit_storyline(
-        self,
-        video_path: str,
-        storyline_prompt: str,
-        scene_changes: str,
-        progress=gr.Progress()
-    ) -> Tuple[Optional[str], str]:
-        """Edit video storyline and scenes"""
-        
-        if not self.api_key:
-            return None, "❌ Please set your API key first"
-        
-        try:
-            progress(0.1, desc="Analyzing storyline...")
-            
-            # This would use advanced AI models for video understanding and generation
-            # For now, we'll create a storyboard visualization
-            
-            frames = self.extract_frames(video_path, sample_rate=30)
-            
-            # Create storyboard with annotations
-            storyboard_frames = []
-            scenes = scene_changes.split('\n')
-            
-            for i, (frame, scene) in enumerate(zip(frames, scenes + [''] * len(frames))):
-                progress(0.1 + 0.8 * (i / len(frames)), 
-                        desc=f"Processing scene {i+1}...")
-                
-                # Add text overlay for scene description
-                frame_copy = frame.copy()
-                cv2.putText(frame_copy, f"Scene {i+1}: {scene[:50]}...", 
-                           (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (255, 255, 255), 2)
-                
-                storyboard_frames.append(frame_copy)
-            
-            output_path = tempfile.mktemp(suffix='.mp4')
-            self.frames_to_video(storyboard_frames, output_path, fps=10)
-            
-            return output_path, f"✅ Storyline edited: {storyline_prompt[:100]}..."
-            
-        except Exception as e:
-            return None, f"❌ Error: {str(e)}"
+            return None, f"Error: {str(e)}"
 
 # Create instance
 editor = VideoEditor()
 
-# Create Gradio interface
-with gr.Blocks(css=CSS, theme=gr.themes.Soft()) as demo:
+# Create interface
+with gr.Blocks(css=CSS) as demo:
     gr.HTML("""
-        <div class="container">
-            <h1 class="title">🎬 AI Video Editor Pro</h1>
-            <p style="text-align: center; font-size: 1.2em; color: #666;">
-                Transform your videos with AI-powered editing using simple prompts
-            </p>
-        </div>
+        <h1 class="title">🎬 AI Video Editor</h1>
+        <p style="text-align: center;">Transform videos with AI-powered editing</p>
     """)
     
-    # API Key Setup
+    # Video input
     with gr.Row():
-        with gr.Column():
-            gr.Markdown("""
-            ### 🔑 Step 1: API Setup
-            Get your API key from [Replicate](https://replicate.com/account/api-tokens) 
-            or [RunwayML](https://runwayml.com/)
-            """)
-            
-            api_key_input = gr.Textbox(
-                label="API Key",
-                placeholder="Enter your API key...",
-                type="password"
-            )
-            
-            api_status = gr.Textbox(label="Status", interactive=False)
-            set_key_btn = gr.Button("Set API Key", size="sm")
+        video_input = gr.Video(label="Upload Video")
     
-    gr.HTML("<hr>")
-    
-    # Video Upload
-    with gr.Row():
-        with gr.Column():
-            gr.Markdown("### 📹 Step 2: Upload Your Video")
-            video_input = gr.Video(label="Input Video")
-    
-    # Editing Features
+    # Tabs for different features
     with gr.Tabs():
         # Background Tab
-        with gr.TabItem("🏞️ Background"):
-            with gr.Row():
-                with gr.Column():
-                    gr.HTML('<div class="feature-card">')
-                    gr.Markdown("""
-                    **Change Video Background**
-                    
-                    Replace the background with AI-generated scenes
-                    """)
-                    
-                    bg_prompt = gr.Textbox(
-                        label="Background Description",
-                        placeholder="E.g., tropical beach at sunset, futuristic city, enchanted forest...",
-                        lines=2
-                    )
-                    
-                    bg_examples = gr.Examples(
-                        examples=[
-                            "Tropical beach with palm trees and sunset",
-                            "Futuristic cyberpunk city at night",
-                            "Enchanted forest with glowing mushrooms",
-                            "Space station interior with Earth view",
-                            "Japanese garden with cherry blossoms"
-                        ],
-                        inputs=bg_prompt
-                    )
-                    
-                    change_bg_btn = gr.Button("Change Background", elem_classes="edit-btn")
-                    gr.HTML('</div>')
-                
-                with gr.Column():
-                    bg_output = gr.Video(label="Result")
-                    bg_status = gr.Textbox(label="Status", interactive=False)
-        
-        # Character/Outfit Tab
-        with gr.TabItem("👔 Character & Outfit"):
-            with gr.Row():
-                with gr.Column():
-                    gr.HTML('<div class="feature-card">')
-                    gr.Markdown("""
-                    **Change Character Appearance**
-                    
-                    Modify clothing, accessories, and character style
-                    """)
-                    
-                    outfit_prompt = gr.Textbox(
-                        label="Outfit Description",
-                        placeholder="E.g., elegant business suit, superhero costume, medieval armor...",
-                        lines=2
-                    )
-                    
-                    outfit_examples = gr.Examples(
-                        examples=[
-                            "Elegant black business suit with red tie",
-                            "Superhero costume with cape and mask",
-                            "Medieval knight armor with sword",
-                            "Casual summer dress with sunhat",
-                            "Futuristic space suit with helmet"
-                        ],
-                        inputs=outfit_prompt
-                    )
-                    
-                    change_outfit_btn = gr.Button("Change Outfit", elem_classes="edit-btn")
-                    gr.HTML('</div>')
-                
-                with gr.Column():
-                    outfit_output = gr.Video(label="Result")
-                    outfit_status = gr.Textbox(label="Status", interactive=False)
+        with gr.Tab("🏞️ Background"):
+            gr.Markdown("### Change Video Background")
+            bg_prompt = gr.Textbox(
+                placeholder="Describe the new background...",
+                label="Background Description"
+            )
+            bg_button = gr.Button("Change Background", variant="primary")
+            bg_output = gr.Video(label="Result")
+            bg_status = gr.Textbox(label="Status")
+            
+            gr.Examples(
+                examples=[
+                    "Tropical beach with palm trees",
+                    "Modern city skyline at night",
+                    "Enchanted forest with fireflies"
+                ],
+                inputs=bg_prompt
+            )
+            
+            bg_button.click(
+                fn=editor.change_background,
+                inputs=[video_input, bg_prompt],
+                outputs=[bg_output, bg_status]
+            )
         
-        # Style & Color Tab
-        with gr.TabItem("🎨 Style & Color"):
-            with gr.Row():
-                with gr.Column():
-                    gr.HTML('<div class="feature-card">')
-                    gr.Markdown("""
-                    **Apply Visual Style & Color Grading**
-                    
-                    Transform the visual aesthetic of your video
-                    """)
-                    
-                    style_prompt = gr.Textbox(
-                        label="Visual Style",
-                        placeholder="E.g., cinematic, anime, oil painting, noir...",
-                        lines=2
-                    )
-                    
-                    color_prompt = gr.Textbox(
-                        label="Color Grading",
-                        placeholder="E.g., warm sunset tones, cool blue, vintage sepia...",
-                        lines=2
-                    )
-                    
-                    style_examples = gr.Examples(
-                        examples=[
-                            ["Cinematic Hollywood style", "Warm golden hour lighting"],
-                            ["Anime/manga art style", "Vibrant saturated colors"],
-                            ["Film noir style", "High contrast black and white"],
-                            ["Oil painting style", "Rich earthy tones"],
-                            ["Cyberpunk neon style", "Purple and cyan neon colors"]
-                        ],
-                        inputs=[style_prompt, color_prompt]
-                    )
-                    
-                    apply_style_btn = gr.Button("Apply Style", elem_classes="edit-btn")
-                    gr.HTML('</div>')
-                
-                with gr.Column():
-                    style_output = gr.Video(label="Result")
-                    style_status = gr.Textbox(label="Status", interactive=False)
+        # Outfit Tab
+        with gr.Tab("👔 Outfit"):
+            gr.Markdown("### Change Character Outfit")
+            outfit_prompt = gr.Textbox(
+                placeholder="Describe the new outfit...",
+                label="Outfit Description"
+            )
+            outfit_button = gr.Button("Change Outfit", variant="primary")
+            outfit_output = gr.Video(label="Result")
+            outfit_status = gr.Textbox(label="Status")
+            
+            gr.Examples(
+                examples=[
+                    "Business suit with red tie",
+                    "Casual summer dress",
+                    "Superhero costume"
+                ],
+                inputs=outfit_prompt
+            )
+            
+            outfit_button.click(
+                fn=editor.change_outfit,
+                inputs=[video_input, outfit_prompt],
+                outputs=[outfit_output, outfit_status]
+            )
         
-        # Storyline Tab
-        with gr.TabItem("📖 Storyline"):
-            with gr.Row():
-                with gr.Column():
-                    gr.HTML('<div class="feature-card">')
-                    gr.Markdown("""
-                    **Edit Video Storyline**
-                    
-                    Modify the narrative flow and add scene transitions
-                    """)
-                    
-                    storyline_prompt = gr.Textbox(
-                        label="New Storyline",
-                        placeholder="Describe the new narrative flow...",
-                        lines=3
-                    )
-                    
-                    scene_changes = gr.Textbox(
-                        label="Scene-by-Scene Changes",
-                        placeholder="Scene 1: Hero enters the room\nScene 2: Discovers the treasure\nScene 3: Epic battle begins...",
-                        lines=5
-                    )
-                    
-                    edit_story_btn = gr.Button("Edit Storyline", elem_classes="edit-btn")
-                    gr.HTML('</div>')
-                
-                with gr.Column():
-                    story_output = gr.Video(label="Result")
-                    story_status = gr.Textbox(label="Status", interactive=False)
+        # Style Tab
+        with gr.Tab("🎨 Style"):
+            gr.Markdown("### Apply Visual Style")
+            style_prompt = gr.Textbox(
+                placeholder="Visual style...",
+                label="Style"
+            )
+            color_prompt = gr.Textbox(
+                placeholder="Color grading...",
+                label="Colors"
+            )
+            style_button = gr.Button("Apply Style", variant="primary")
+            style_output = gr.Video(label="Result")
+            style_status = gr.Textbox(label="Status")
+            
+            gr.Examples(
+                examples=[
+                    ["Cinematic", "Warm sunset tones"],
+                    ["Anime style", "Vibrant colors"],
+                    ["Film noir", "Cool blue tones"]
+                ],
+                inputs=[style_prompt, color_prompt]
+            )
+            
+            style_button.click(
+                fn=editor.apply_style,
+                inputs=[video_input, style_prompt, color_prompt],
+                outputs=[style_output, style_status]
+            )
     
-    # Instructions
     gr.Markdown("""
     ---
-    ### 📋 How to Use:
-    
-    1. **Set your API key** from Replicate, RunwayML, or similar services
-    2. **Upload your video** (MP4, AVI, MOV supported)
-    3. **Choose an editing feature** from the tabs above
-    4. **Describe your changes** using natural language prompts
-    5. **Click the edit button** and wait for AI processing
-    
-    ### 🚀 Capabilities:
-    
-    - **Background Replacement**: Remove and replace video backgrounds
-    - **Outfit Change**: Modify character clothing and accessories
-    - **Style Transfer**: Apply artistic styles and color grading
-    - **Storyline Editing**: Restructure narrative and add transitions
-    
-    ### ⚠️ Note:
-    
-    Processing time depends on video length and complexity. Shorter clips (< 30s) work best.
+    ### 📝 Notes:
+    - This is a demonstration with simulated effects
+    - Real implementation requires AI model APIs
+    - Upload short videos (<30s) for best results
     """)
-    
-    # Event handlers
-    set_key_btn.click(
-        fn=editor.set_api_key,
-        inputs=[api_key_input],
-        outputs=[api_status]
-    )
-    
-    change_bg_btn.click(
-        fn=editor.change_background,
-        inputs=[video_input, bg_prompt],
-        outputs=[bg_output, bg_status]
-    )
-    
-    change_outfit_btn.click(
-        fn=editor.change_character_outfit,
-        inputs=[video_input, outfit_prompt],
-        outputs=[outfit_output, outfit_status]
-    )
-    
-    apply_style_btn.click(
-        fn=editor.change_video_style,
-        inputs=[video_input, style_prompt, color_prompt],
-        outputs=[style_output, style_status]
-    )
-    
-    edit_story_btn.click(
-        fn=editor.edit_storyline,
-        inputs=[video_input, storyline_prompt, scene_changes],
-        outputs=[story_output, story_status]
-    )
 
 # Launch
-if __name__ == "__main__":
-    demo.queue().launch()
+demo.launch()