Update app.py

app.py

@@ -1,77 +1,491 @@
 import os
+import time
 import gradio as gr
+import replicate
+from dotenv import load_dotenv
+from PIL import Image, ImageDraw, ImageFont, ImageOps
 import requests
-from PIL import Image
 from io import BytesIO
-import logging
+import textwrap
+import uuid
+import json
+from pathlib import Path
+import numpy as np
+import tempfile
 
-# Set up logging
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
+# Load environment variables
+load_dotenv()
 
-# Configuration - set these in your Hugging Face Space secrets
-RUNPOD_API_KEY = os.getenv("RUNPOD_API_KEY", "your_key_here")
-RUNPOD_ENDPOINT = os.getenv("RUNPOD_ENDPOINT", "your_endpoint_here")
-
-def debug_runpod(prompt):
-    """Simplest possible RunPod test"""
-    try:
-        logger.info("Sending request to RunPod...")
+# Configuration
+class Config:
+    # Model configurations
+    SDXL_MODEL = "stability-ai/sdxl:39ed52f2a78e934b3ba6e2a89f5b1c712de7dfea535525255b1aa35c5565e08b"
+    VIDEO_MODEL = "stability-ai/stable-video-diffusion:3f0457e4619daac51203dedb472816fd4af51f3149fa7a9e0b5ffcf1b8172438"
+    
+    # Path configurations
+    SAVE_FOLDER = "user_creations"
+    FONT_PATH = "assets/fonts/comic.ttf"
+    ASSET_PATH = "assets/"
+    BUBBLE_TEMPLATES = {
+        "Speech": "assets/bubbles/speech.png",
+        "Thought": "assets/bubbles/thought.png",
+        "Shout": "assets/bubbles/shout.png",
+        "Whisper": "assets/bubbles/whisper.png"
+    }
+    
+    # Layout settings
+    LAYOUTS = {
+        "Single Panel": [{"x":0, "y":0, "w":1, "h":1}],
+        "Comic Strip": [{"x":i*0.33, "y":0, "w":0.33, "h":1} for i in range(3)],
+        "2x2 Grid": [
+            {"x":0, "y":0, "w":0.5, "h":0.5},
+            {"x":0.5, "y":0, "w":0.5, "h":0.5},
+            {"x":0, "y":0.5, "w":0.5, "h":0.5},
+            {"x":0.5, "y":0.5, "w":0.5, "h":0.5}
+        ]
+    }
+    
+    @classmethod
+    def init(cls):
+        """Initialize required directories and files"""
+        Path(cls.SAVE_FOLDER).mkdir(exist_ok=True)
+        Path(cls.ASSET_PATH).mkdir(exist_ok=True)
         
-        payload = {
-            "input": {
-                "prompt": prompt,
-                "width": 512,
-                "height": 512,
-                "num_inference_steps": 20,
-                "return_base64": True
-            }
-        }
+        # Download comic font if not exists
+        if not Path(cls.FONT_PATH).exists():
+            cls.download_comic_font()
         
-        headers = {
-            "Authorization": f"Bearer {RUNPOD_API_KEY}",
-            "Content-Type": "application/json"
+        # Create bubble templates if not exists
+        Path("assets/bubbles/").mkdir(exist_ok=True, parents=True)
+        cls.create_bubble_templates()
+    
+    @classmethod
+    def download_comic_font(cls):
+        """Download comic font for speech bubbles"""
+        try:
+            url = "https://github.com/google/fonts/raw/main/ofl/comicneue/ComicNeue-Regular.ttf"
+            response = requests.get(url)
+            Path(cls.FONT_PATH).parent.mkdir(exist_ok=True)
+            with open(cls.FONT_PATH, 'wb') as f:
+                f.write(response.content)
+        except Exception as e:
+            print(f"Couldn't download comic font: {str(e)}")
+            cls.FONT_PATH = None
+    
+    @classmethod
+    def create_bubble_templates(cls):
+        """Create default bubble templates if they don't exist"""
+        for bubble_type in cls.BUBBLE_TEMPLATES.values():
+            if not Path(bubble_type).exists():
+                img = Image.new('RGBA', (300, 150), (0, 0, 0, 0))
+                draw = ImageDraw.Draw(img)
+                
+                if "speech" in bubble_type:
+                    draw.rounded_rectangle([10, 10, 290, 140], radius=20, 
+                                         fill=(255, 255, 255, 200), outline="black", width=3)
+                    # Add tail
+                    draw.polygon([(100, 140), (80, 160), (120, 160)], 
+                                fill=(255, 255, 255, 200), outline="black", width=3)
+                
+                elif "thought" in bubble_type:
+                    for i in range(3):
+                        offset = i * 10
+                        draw.ellipse([10-offset, 10-offset, 290+offset, 140+offset], 
+                                    outline="black", width=2)
+                
+                img.save(bubble_type)
+
+Config.init()
+
+class StoryEngine:
+    """Core engine for story generation and processing"""
+    DEFAULT_NEGATIVE = "blurry, deformed, bad anatomy, text errors, inconsistent character"
+    
+    GENRE_PRESETS = {
+        "Pixar Style": {
+            "style": "3D animation, Pixar style, vibrant colors",
+            "negative": DEFAULT_NEGATIVE + ", realistic, photo"
+        },
+        "Anime": {
+            "style": "Anime style, vibrant colors, expressive characters",
+            "negative": DEFAULT_NEGATIVE + ", realistic, western, 3D"
+        },
+        "Comic Book": {
+            "style": "comic book style, bold outlines, halftone patterns",
+            "negative": DEFAULT_NEGATIVE + ", realistic, photograph"
+        },
+        "Storyboard": {
+            "style": "rough sketch, storyboard style, quick drawings",
+            "negative": DEFAULT_NEGATIVE + ", detailed, finished artwork"
         }
+    }
+    
+    @staticmethod
+    def generate_images(prompt, num_outputs=1, style_preset=None):
+        """Generate consistent style images from prompt"""
+        try:
+            input_params = {
+                "prompt": f"{prompt}, {style_preset['style']}" if style_preset else prompt,
+                "negative_prompt": style_preset.get("negative", StoryEngine.DEFAULT_NEGATIVE),
+                "width": 1024,
+                "height": 1024,
+                "num_inference_steps": 30,
+                "num_outputs": num_outputs
+            }
+            
+            output = replicate.run(Config.SDXL_MODEL, input=input_params)
+            return [url for url in output if url and isinstance(url, str) and url.startswith('http')]
+        except Exception as e:
+            print(f"Image generation failed: {str(e)}")
+            return []
+
+    @staticmethod
+    def generate_video(image_path, duration_sec=5):
+        """Generate video from image using Stable Video Diffusion"""
+        try:
+            with open(image_path, "rb") as f:
+                image_data = f.read()
+            
+            output = replicate.run(
+                Config.VIDEO_MODEL,
+                input={
+                    "input_image": image_data,
+                    "motion_bucket_id": 80,
+                    "fps": 8,  # Lower FPS for smoother results
+                    "duration": duration_sec
+                }
+            )
+            return output
+        except Exception as e:
+            print(f"Video generation failed: {str(e)}")
+            return None
+
+class BubbleEditor:
+    """Handles customizable speech bubbles"""
+    @staticmethod
+    def add_custom_bubble(base_image, bubble_type, text, position, size):
+        """Add a customizable bubble to the image"""
+        try:
+            # Load bubble template
+            bubble_img = Image.open(Config.BUBBLE_TEMPLATES[bubble_type]).convert("RGBA")
+            bubble_img = bubble_img.resize(size)
+            
+            # Create text layer
+            text_layer = Image.new('RGBA', size, (0, 0, 0, 0))
+            draw = ImageDraw.Draw(text_layer)
+            
+            # Load font
+            if Config.FONT_PATH and os.path.exists(Config.FONT_PATH):
+                font = ImageFont.truetype(Config.FONT_PATH, int(size[1]/6))
+            else:
+                font = ImageFont.load_default()
+            
+            # Calculate text position
+            lines = textwrap.wrap(text, width=20)
+            y_text = (size[1] - len(lines) * font.size) / 2
+            
+            # Draw text
+            for line in lines:
+                line_width = font.getlength(line)
+                x_text = (size[0] - line_width) / 2
+                draw.text((x_text, y_text), line, fill="black", font=font)
+                y_text += font.size
+            
+            # Combine bubble and text
+            bubble_with_text = Image.alpha_composite(bubble_img, text_layer)
+            
+            # Paste onto base image
+            base_image.paste(bubble_with_text, position, bubble_with_text)
+            return base_image
+        except Exception as e:
+            print(f"Bubble editing error: {str(e)}")
+            return base_image
+
+class VideoRenderer:
+    """Handles video and storyboard rendering"""
+    @staticmethod
+    def create_storyboard(images, script):
+        """Create professional storyboard with script"""
+        try:
+            storyboard = Image.new('RGB', (1024, 1024), (240, 240, 240))
+            draw = ImageDraw.Draw(storyboard)
+            
+            # Load font
+            if Config.FONT_PATH and os.path.exists(Config.FONT_PATH):
+                title_font = ImageFont.truetype(Config.FONT_PATH, 40)
+                script_font = ImageFont.truetype(Config.FONT_PATH, 24)
+            else:
+                title_font = ImageFont.load_default(size=24)
+                script_font = ImageFont.load_default(size=16)
+            
+            # Add title
+            draw.text((50, 30), "STORYBOARD", fill="black", font=title_font)
+            
+            # Layout panels (2x2 grid)
+            for i, img_url in enumerate(images[:4]):
+                try:
+                    response = requests.get(img_url)
+                    img = Image.open(BytesIO(response.content))
+                    
+                    x = (i % 2) * 512
+                    y = 100 + (i // 2) * 412
+                    
+                    panel = img.resize((492, 392))
+                    storyboard.paste(panel, (x + 10, y))
+                    
+                    # Add panel number
+                    draw.rectangle([x + 10, y, x + 50, y + 40], fill="white")
+                    draw.text((x + 20, y + 10), str(i+1), fill="black", font=title_font)
+                except Exception as e:
+                    print(f"Couldn't process image {i}: {str(e)}")
+                    continue
+            
+            # Add script area
+            draw.rectangle([50, 824, 974, 994], fill="white", outline="black", width=2)
+            
+            # Add script text
+            y_offset = 840
+            for line in textwrap.wrap(script, width=80)[:5]:
+                draw.text((60, y_offset), line, fill="black", font=script_font)
+                y_offset += 30
+            
+            return storyboard
+        except Exception as e:
+            print(f"Storyboard creation failed: {str(e)}")
+            return None
+
+def create_interface():
+    """Create the Gradio interface"""
+    with gr.Blocks(title="Comic Creator Pro", theme="soft") as app:
+        # Store for bubble positions
+        bubble_data = gr.State([])
         
-        logger.info(f"Payload: {payload}")
-        response = requests.post(RUNPOD_ENDPOINT, json=payload, headers=headers, timeout=60)
-        logger.info(f"Response status: {response.status_code}")
+        # User Story Input
+        with gr.Row():
+            with gr.Column(scale=2):
+                script_input = gr.TextArea(
+                    label="Your Script",
+                    lines=8,
+                    value="Detective (The clues point this way) examines the scene (thinks: Something's not right here)"
+                )
+                
+                with gr.Row():
+                    genre_select = gr.Dropdown(
+                        list(StoryEngine.GENRE_PRESETS.keys()),
+                        label="Style",
+                        value="Comic Book"
+                    )
+                    layout_select = gr.Dropdown(
+                        list(Config.LAYOUTS.keys()),
+                        label="Layout",
+                        value="Single Panel"
+                    )
+                
+                char_consistency = gr.Textbox(
+                    label="Character Consistency",
+                    value="hair_color:black, eye_color:green, outfit:detective"
+                )
+                
+                negative_prompt = gr.Textbox(
+                    label="Negative Prompt",
+                    value=StoryEngine.DEFAULT_NEGATIVE
+                )
+                
+                duration_slider = gr.Slider(
+                    minimum=3,
+                    maximum=15,
+                    value=5,
+                    step=1,
+                    label="Video Duration (seconds)"
+                )
+                
+            with gr.Column():
+                # Bubble customization tools
+                with gr.Accordion("Bubble Editor", open=False):
+                    bubble_type = gr.Dropdown(
+                        list(Config.BUBBLE_TEMPLATES.keys()),
+                        label="Bubble Type",
+                        value="Speech"
+                    )
+                    bubble_text = gr.Textbox(
+                        label="Bubble Text",
+                        value="Enter your text here"
+                    )
+                    bubble_size = gr.Slider(
+                        minimum=50,
+                        maximum=300,
+                        value=150,
+                        step=10,
+                        label="Bubble Size"
+                    )
+                    add_bubble_btn = gr.Button("Add Bubble", variant="secondary")
+                
+                preview_image = gr.Image(
+                    label="Preview",
+                    interactive=True,
+                    tool="select"
+                )
         
-        if response.status_code != 200:
-            return None, f"API error: {response.text}"
-            
-        data = response.json()
-        logger.info(f"Full response: {data}")
+        # Generation Controls
+        with gr.Row():
+            generate_btn = gr.Button("Generate Panels", variant="primary")
+            generate_storyboard_btn = gr.Button("Create Storyboard")
+            generate_video_btn = gr.Button("Generate Video")
         
-        if "output" in data and isinstance(data["output"], list):
-            image_url = data["output"][0]
-            img_data = requests.get(image_url).content
-            return Image.open(BytesIO(img_data)), "Success!"
+        # Output Section
+        with gr.Tabs():
+            with gr.Tab("Comic Panels"):
+                panel_gallery = gr.Gallery(label="Generated Panels")
+                comic_output = gr.Image(label="Final Comic")
             
-        elif "image" in data:
-            img_data = base64.b64decode(data["image"].split(",")[1])
-            return Image.open(BytesIO(img_data)), "Success!"
+            with gr.Tab("Storyboard"):
+                storyboard_output = gr.Image(label="Storyboard")
             
-        return None, "No image data found in response"
+            with gr.Tab("Video"):
+                video_output = gr.Video(label="Generated Video")
         
-    except Exception as e:
-        logger.error(f"Error: {str(e)}")
-        return None, f"Error: {str(e)}"
-
-# Basic Gradio interface
-with gr.Blocks() as app:
-    gr.Markdown("## 🐞 RunPod Debugger")
-    
-    prompt = gr.Textbox(label="Test Prompt", value="A comic book superhero")
-    generate = gr.Button("Test RunPod")
-    output_image = gr.Image(label="Result")
-    status = gr.Textbox(label="Debug Output")
+        # Status
+        status = gr.Textbox(label="Status", visible=False)
+        
+        # Generation Functions
+        def generate_panels(script, genre, consistency, negative):
+            """Generate comic panels from script"""
+            try:
+                full_prompt = f"{script}. {consistency}"
+                style_preset = StoryEngine.GENRE_PRESETS.get(genre)
+                
+                # Update negative prompt
+                if style_preset:
+                    style_preset["negative"] = negative
+                
+                frames = StoryEngine.generate_images(
+                    full_prompt,
+                    num_outputs=4,
+                    style_preset=style_preset
+                )
+                
+                if not frames:
+                    return [], None, "Failed to generate panels"
+                
+                return frames, None, "Panels generated successfully"
+            except Exception as e:
+                print(f"Panel generation error: {str(e)}")
+                return [], None, f"Error: {str(e)}"
+        
+        generate_btn.click(
+            generate_panels,
+            inputs=[script_input, genre_select, char_consistency, negative_prompt],
+            outputs=[panel_gallery, comic_output, status]
+        )
+        
+        def create_storyboard(script, genre):
+            """Generate storyboard from script"""
+            try:
+                style_preset = StoryEngine.GENRE_PRESETS.get(genre)
+                frames = StoryEngine.generate_images(
+                    f"Storyboard frame: {script}",
+                    num_outputs=4,
+                    style_preset=style_preset
+                )
+                
+                if not frames:
+                    return None, "Failed to generate storyboard frames"
+                
+                storyboard = VideoRenderer.create_storyboard(frames, script)
+                if storyboard:
+                    return storyboard, "Storyboard created successfully!"
+                return None, "Failed to create storyboard"
+            except Exception as e:
+                print(f"Storyboard generation error: {str(e)}")
+                return None, f"Error: {str(e)}"
+        
+        generate_storyboard_btn.click(
+            create_storyboard,
+            inputs=[script_input, genre_select],
+            outputs=[storyboard_output, status]
+        )
+        
+        def generate_video(images, duration):
+            """Generate video from selected image"""
+            try:
+                if not images:
+                    return None, "No images to generate video"
+                
+                # Use first image for video generation
+                img_url = images[0] if isinstance(images, list) else images
+                response = requests.get(img_url)
+                
+                with tempfile.NamedTemporaryFile(suffix=".jpg", delete=False) as tmp:
+                    tmp.write(response.content)
+                    tmp_path = tmp.name
+                
+                video_url = StoryEngine.generate_video(tmp_path, duration)
+                os.unlink(tmp_path)
+                
+                if not video_url:
+                    return None, "Failed to generate video"
+                
+                return video_url, "Video generated successfully!"
+            except Exception as e:
+                print(f"Video generation error: {str(e)}")
+                return None, f"Error: {str(e)}"
+        
+        generate_video_btn.click(
+            generate_video,
+            inputs=[panel_gallery, duration_slider],
+            outputs=[video_output, status]
+        )
+        
+        # Bubble editing functions
+        def add_bubble(image, bubble_type, text, size, data):
+            """Add bubble to image"""
+            try:
+                if image is None:
+                    return None, data, "No image to edit"
+                
+                # Convert from Gradio format if needed
+                if isinstance(image, dict):
+                    image = image["image"]
+                elif isinstance(image, str):
+                    if image.startswith('http'):
+                        response = requests.get(image)
+                        image = Image.open(BytesIO(response.content))
+                    else:
+                        image = Image.open(image)
+                
+                # Default position (center)
+                position = (
+                    int(image.width/2 - size/2),
+                    int(image.height/4)
+                )
+                
+                # Add bubble
+                edited_image = BubbleEditor.add_custom_bubble(
+                    image, bubble_type, text, position, (size, size//2)
+                )
+                
+                # Update bubble data
+                new_data = data + [{
+                    "type": bubble_type,
+                    "text": text,
+                    "position": position,
+                    "size": (size, size//2)
+                }]
+                
+                return edited_image, new_data, "Bubble added successfully"
+            except Exception as e:
+                print(f"Bubble addition error: {str(e)}")
+                return image, data, f"Error: {str(e)}"
+        
+        add_bubble_btn.click(
+            add_bubble,
+            inputs=[preview_image, bubble_type, bubble_text, bubble_size, bubble_data],
+            outputs=[preview_image, bubble_data, status]
+        )
     
-    generate.click(
-        debug_runpod,
-        inputs=[prompt],
-        outputs=[output_image, status]
-    )
+    return app
 
-# Run with debug logging
-app.launch(debug=True, show_error=True)
+if __name__ == "__main__":
+    # Create and launch the interface
+    app = create_interface()
+    app.launch(share=True, server_name="0.0.0.0", server_port=7860)