Add initial project structure with Docker support and UI components

- Create .gitignore to exclude environment and compiled files
- Add requirements.txt for project dependencies
- Implement Dockerfile for containerized application
- Set up docker-compose.yml for service orchestration
- Create empty __init__.py for lib package
- Add error_utils.py for error message formatting
- Include loading_messages.json for status messages
- Develop ui_components.py for Gradio UI layout
- Implement status_utils.py for progress tracking
- Add image_utils.py for image preparation and uploading

.gitignore

@@ -0,0 +1,2 @@
+*.env
+*.pyc

Dockerfile

@@ -0,0 +1,14 @@
+FROM python:3.10-slim
+
+WORKDIR /usr/src/app
+
+COPY requirements.txt .
+
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY gradio_app.py .
+
+EXPOSE 7860
+ENV GRADIO_SERVER_NAME="0.0.0.0"
+
+CMD ["python", "gradio_app.py"]

docker-compose.yml

@@ -0,0 +1,14 @@
+version: '3.8'
+
+services:
+  luma-gradio:
+    build: .
+    ports:
+      - "7860:7860"
+    volumes:
+      - .:/usr/src/app
+    environment:
+      - GRADIO_SERVER_NAME=0.0.0.0
+      - PYTHONUNBUFFERED=1
+    restart: unless-stopped
+    container_name: luma-gradio

gradio_app.py

@@ -0,0 +1,135 @@
+import gradio as gr
+import time
+import random
+import requests
+from lumaai import LumaAI
+import traceback
+
+from lib.status_utils import StatusTracker, load_messages
+from lib.image_utils import prepare_image
+from lib.api_utils import get_camera_motions
+from lib.ui_components import create_input_column, create_output_column
+
+def generate_video(api_key, prompt, camera_motion, image=None, progress=gr.Progress()):
+    status_box = gr.Markdown()  # Create status box
+    if not api_key or not prompt:
+        return None, "Please provide both API key and prompt (I'm not a mind reader... yet)"
+    
+    try:
+        status_tracker = StatusTracker(progress, status_box)
+        status_tracker.add_step("LumaAI initialized", 0.01)
+        client = LumaAI(auth_token=api_key)
+        
+        # Prepare generation parameters
+        generation_params = {
+            "prompt": f"{prompt} {camera_motion if camera_motion != 'None' else ''}",
+            "loop": True,
+            "aspect_ratio": "1:1"  # Force square aspect ratio
+        }
+
+        # Handle image if provided
+        if image is not None:
+            try:
+                cdn_url = prepare_image(image, status_tracker)
+                generation_params["keyframes"] = {
+                    "frame0": {
+                        "type": "image",
+                        "url": cdn_url
+                    }
+                }
+                status_tracker.add_step("Image ready for its starring role", 0.1)
+            except Exception as e:
+                return None, f"🎭 Drama in the image department: {str(e)}"
+
+        status_tracker.add_step("Sending your creative masterpiece to LumaAI", 0.15)
+        try:
+            generation = client.generations.create(**generation_params)
+        except Exception as e:
+            return None, f"🎬 LumaAI didn't like that: {str(e)}"
+        
+        # Load and shuffle status messages
+        status_messages = load_messages()
+        random.shuffle(status_messages)
+        
+        # Poll for completion
+        start_time = time.time()
+        message_index = 0
+        last_status = None
+        
+        while True:
+            try:
+                generation_status = client.generations.get(generation.id)
+                status = generation_status.state
+                elapsed_time = time.time() - start_time
+                
+                if status != last_status:
+                    status_tracker.add_step(f"Status: {status}", min(0.2 + (elapsed_time/300), 0.8))
+                    last_status = status
+                
+                current_message = status_messages[message_index % len(status_messages)]
+                status_tracker.update_message(current_message, min(0.2 + (elapsed_time/300), 0.8))
+                message_index += 1
+                
+                if status == 'completed':
+                    status_tracker.add_step("Generation completed!", 0.9)
+                    download_url = generation_status.assets.video
+                    break
+                elif status == 'failed':
+                    failure_reason = generation_status.failure_reason or "It's not you, it's me"
+                    return None, f"🎭 Generation failed: {failure_reason}"
+                
+                if elapsed_time > 300:
+                    return None, "⏰ Generation timeout (5 minutes of awkward silence)"
+                
+                time.sleep(10)
+                
+            except Exception as e:
+                print(f"Error during generation polling: {str(e)}")
+                print(traceback.format_exc())
+                time.sleep(10)
+                continue
+        
+        # Download the video
+        status_tracker.update_message("Downloading your masterpiece...", 0.95)
+        try:
+            response = requests.get(download_url, stream=True, timeout=30)
+            response.raise_for_status()
+            file_path = "output_video.mp4"
+            with open(file_path, 'wb') as file:
+                file.write(response.content)
+            
+            status_tracker.add_step("🎉 Video ready!", 1.0)
+            return file_path, status_box
+        except Exception as e:
+            return None, f"📺 Video download failed: {str(e)}"
+    
+    except Exception as e:
+        print(f"Error during generation: {str(e)}")
+        print(traceback.format_exc())
+        return None, f"🎪 The show must go on, but: {str(e)}"
+
+# Create Gradio interface with a modern theme
+with gr.Blocks(theme=gr.themes.Soft(
+    primary_hue="indigo",
+    secondary_hue="purple",
+)) as app:
+    gr.Markdown(
+        """
+        # 🎬 LumaAI Video Generator
+        ### Transform your prompts into mesmerizing videos
+        """
+    )
+    
+    with gr.Row():
+        # Create input and output columns
+        prompt, camera_motion, api_key, image_input, generate_btn, status_display = create_input_column()
+        video_output = create_output_column()
+    
+    generate_btn.click(
+        fn=generate_video,
+        inputs=[api_key, prompt, camera_motion, image_input],
+        outputs=[video_output, status_display]
+    )
+
+if __name__ == "__main__":
+    app.launch()

lib/__init__.py

@@ -0,0 +1 @@
+# This file is intentionally empty to make the directory a Python package

lib/api_utils.py

@@ -0,0 +1,70 @@
+import requests
+import traceback
+from typing import Optional
+
+def upload_to_freeimage(file_path: str, status_tracker) -> str:
+    """
+    Upload a file to freeimage.host and return the direct image URL.
+    
+    Args:
+        file_path: Path to the file to upload
+        status_tracker: StatusTracker instance for progress updates
+        
+    Returns:
+        str: Direct URL for the uploaded image
+        
+    Raises:
+        Exception: If upload fails for any reason
+    """
+    try:
+        # API endpoint
+        url = 'https://freeimage.host/api/1/upload'
+        
+        # Read image file
+        with open(file_path, 'rb') as image_file:
+            # Prepare the files and data for upload
+            files = {
+                'source': image_file
+            }
+            data = {
+                'key': '6d207e02198a847aa98d0a2a901485a5'  # Free API key from freeimage.host
+            }
+            
+            status_tracker.update_message("Uploading image to CDN...", 0.05)
+            
+            # Make the request
+            response = requests.post(url, files=files, data=data, timeout=30)
+            response.raise_for_status()
+            
+            # Get the direct image URL from response
+            result = response.json()
+            if result.get('status_code') == 200:
+                image_url = result['image']['url']
+                status_tracker.add_step("Image uploaded to CDN", 0.08)
+                return image_url
+            else:
+                raise Exception(f"Upload failed: {result.get('error', 'Unknown error')}")
+                
+    except requests.Timeout:
+        raise Exception("CDN is taking a coffee break (timeout)")
+    except requests.ConnectionError:
+        raise Exception("Can't reach CDN (is the internet on vacation?)")
+    except Exception as e:
+        print(f"CDN upload error: {str(e)}")
+        print(traceback.format_exc())
+        raise Exception(f"CDN upload failed: {str(e)}")
+
+def get_camera_motions() -> list:
+    """
+    Get list of available camera motions from LumaAI.
+    
+    Returns:
+        list: List of camera motion options
+    """
+    try:
+        from lumaai import LumaAI
+        client = LumaAI()
+        motions = client.generations.camera_motion.list()
+        return ["None"] + motions
+    except:
+        return ["None", "camera orbit left", "camera orbit right", "camera dolly in", "camera dolly out"]

lib/error_utils.py

@@ -0,0 +1,39 @@
+def style_error(message: str) -> str:
+    """
+    Style an error message with a muted red background and border.
+    
+    Args:
+        message: The error message to style
+        
+    Returns:
+        str: HTML-formatted error message with styling
+    """
+    return f"""
+        <div style="padding: 1rem; 
+                    border-radius: 0.5rem; 
+                    background-color: #fee2e2; 
+                    border: 1px solid #ef4444; 
+                    margin: 1rem 0;">
+            <p style="color: #dc2626; margin: 0;">🎭 {message}</p>
+        </div>
+    """
+
+def format_error(error: Exception, prefix: str = "") -> str:
+    """
+    Format an exception into a user-friendly error message.
+    
+    Args:
+        error: The exception to format
+        prefix: Optional prefix for the error message
+        
+    Returns:
+        str: Styled error message
+    """
+    error_msg = str(error)
+    if len(error_msg) > 100:
+        error_msg = error_msg[:100] + "..."
+    
+    if prefix:
+        error_msg = f"{prefix}: {error_msg}"
+        
+    return style_error(error_msg)

lib/image_utils.py

@@ -0,0 +1,69 @@
+from PIL import Image
+import io
+from pathlib import Path
+import time
+import traceback
+from typing import Union, Optional
+from .api_utils import upload_to_freeimage
+
+def prepare_image(image: Union[str, bytes, Image.Image, None], status_tracker) -> Optional[str]:
+    """
+    Prepare an image for use with LumaAI by resizing and uploading to CDN.
+    
+    Args:
+        image: Input image (can be path, bytes, or PIL Image)
+        status_tracker: StatusTracker instance for progress updates
+        
+    Returns:
+        Optional[str]: CDN URL of the prepared image, or None if no image provided
+        
+    Raises:
+        Exception: If image preparation fails
+    """
+    if image is None:
+        return None
+        
+    try:
+        status_tracker.update_message("Preparing your image for its big moment...", 0.01)
+        
+        # Convert to PIL Image if needed
+        if isinstance(image, str):
+            image = Image.open(image)
+        elif isinstance(image, bytes):
+            image = Image.open(io.BytesIO(image))
+        elif not isinstance(image, Image.Image):
+            raise Exception("That doesn't look like an image (unless I need glasses)")
+
+        # Resize image to 512x512
+        image = image.resize((512, 512), Image.Resampling.LANCZOS)
+        status_tracker.add_step("Image resized to 512x512", 0.02)
+
+        # Convert to RGB if necessary
+        if image.mode not in ('RGB', 'RGBA'):
+            image = image.convert('RGB')
+
+        # Save to temporary file
+        temp_dir = Path("temp")
+        temp_dir.mkdir(exist_ok=True)
+        temp_path = temp_dir / f"temp_image_{int(time.time())}.png"
+        image.save(str(temp_path), format='PNG', optimize=True)
+        
+        # Upload to freeimage.host
+        try:
+            cdn_url = upload_to_freeimage(temp_path, status_tracker)
+            
+            # Clean up temporary file
+            if temp_path.exists():
+                temp_path.unlink()
+                
+            return cdn_url
+        except Exception as e:
+            # Clean up temporary file in case of error
+            if temp_path.exists():
+                temp_path.unlink()
+            raise Exception(f"Image upload failed: {str(e)}")
+            
+    except Exception as e:
+        print(f"Error preparing image: {str(e)}")
+        print(traceback.format_exc())
+        raise Exception(f"Image preparation failed: {str(e)}")

lib/status_utils.py

@@ -0,0 +1,70 @@
+import time
+import json
+from pathlib import Path
+
+def load_messages() -> list:
+    """Load status messages from JSON file."""
+    with open('loading_messages.json', 'r') as f:
+        return json.load(f)['messages']
+
+class StatusTracker:
+    """
+    Track and display progress status for video generation.
+    """
+    def __init__(self, progress, status_box=None):
+        self.progress = progress
+        self.status_box = status_box
+        self.steps = []
+        self.current_message = ""
+        self._status_markdown = "### 🎬 Ready to Generate"
+        
+    def add_step(self, message: str, progress_value: float):
+        """
+        Add a permanent step to the progress display.
+        
+        Args:
+            message: Step description
+            progress_value: Progress value between 0 and 1
+        """
+        self.steps.append(f"✓ {message}")
+        self._update_display(progress_value)
+        time.sleep(0.5)  # Brief pause for visibility
+        
+    def update_message(self, message: str, progress_value: float):
+        """
+        Update the current working message.
+        
+        Args:
+            message: Current status message
+            progress_value: Progress value between 0 and 1
+        """
+        self.current_message = f"➤ {message}"
+        self._update_display(progress_value)
+        
+    def _update_display(self, progress_value: float):
+        """
+        Update the status display with current progress.
+        
+        Args:
+            progress_value: Progress value between 0 and 1
+        """
+        # Create markdown-formatted status display
+        status_md = "### 🎬 Generation Progress:\n"
+        for step in self.steps:
+            status_md += f"- {step}\n"
+        if self.current_message:
+            status_md += f"\n**Current Step:**\n{self.current_message}"
+            
+        self._status_markdown = status_md
+        self.progress(progress_value)
+        
+        # Only try to update status_box if it exists
+        if self.status_box is not None:
+            try:
+                self.status_box.update(value=self._status_markdown)
+            except:
+                pass  # Silently handle if update fails
+    
+    def get_status(self) -> str:
+        """Get the current status markdown."""
+        return self._status_markdown

lib/ui_components.py

@@ -0,0 +1,57 @@
+import gradio as gr
+from .api_utils import get_camera_motions
+
+def create_input_column():
+    """Create the input column of the UI."""
+    with gr.Column(scale=1, min_width=400) as column:
+        # Main inputs
+        prompt = gr.Textbox(
+            label="Prompt",
+            placeholder="Describe your video scene here...",
+            lines=3
+        )
+        camera_motion = gr.Dropdown(
+            choices=get_camera_motions(),
+            label="Camera Motion",
+            value="None"
+        )
+        
+        # Collapsible sections
+        with gr.Accordion("🔑 API Settings", open=False):
+            api_key = gr.Textbox(
+                label="LumaAI API Key", 
+                placeholder="Enter your API key here",
+                type="password"
+            )
+        
+        with gr.Accordion("🖼️ Advanced Options", open=False):
+            image_input = gr.Image(
+                label="Starting Image (will be resized to 512x512)",
+                type="pil"
+            )
+        
+        generate_btn = gr.Button("🚀 Generate Video", variant="primary", size="lg")
+        
+        # Status display
+        status_display = gr.Markdown()
+        
+        gr.Markdown(
+            """
+            ### 🎯 Pro Tips:
+            - Be specific and descriptive in your prompts
+            - Try different camera motions for dynamic effects
+            - Generation usually takes 1-3 minutes ☕
+            """
+        )
+        
+        return prompt, camera_motion, api_key, image_input, generate_btn, status_display
+
+def create_output_column():
+    """Create the output column of the UI."""
+    with gr.Column(scale=1, min_width=600) as column:
+        video_output = gr.Video(
+            label="Generated Video",
+            width="100%",
+            height="400px"
+        )
+        return video_output

loading_messages.json

@@ -0,0 +1,34 @@
+{
+    "messages": [
+        "AI is pondering the meaning of your prompt... and life",
+        "Converting caffeine into video frames...",
+        "Teaching pixels to dance to your prompt...",
+        "Negotiating with stubborn neurons...",
+        "Bribing the GPU with more electricity...",
+        "Asking ChatGPT for video editing advice (just kidding)",
+        "Performing ancient AI rituals for better results...",
+        "Consulting the sacred scrolls of deep learning...",
+        "Attempting to reason with random number generators...",
+        "Convincing the AI that your prompt is totally reasonable...",
+        "Feeding hamsters that power the GPU...",
+        "Downloading more RAM (don't tell Chrome)...",
+        "Reticulating splines in the neural network...",
+        "Teaching AI about color theory using memes...",
+        "Calculating the meaning of life (currently at 42)...",
+        "Asking senior AI for approval (they're on coffee break)...",
+        "Debugging quantum fluctuations in the matrix...",
+        "Optimizing neural pathways with rubber duck debugging...",
+        "Applying machine learning to procrastination...",
+        "Converting your prompt into interpretive dance...",
+        "Consulting with the AI elders...",
+        "Summoning the spirit of Alan Turing...",
+        "Teaching AI about human humor (still confused)...",
+        "Reorganizing bits into artistic arrangements...",
+        "Explaining art theory to silicon chips...",
+        "Motivating lazy neurons with inspirational quotes...",
+        "Performing ritual sacrifices to the GPU gods...",
+        "Translating prompt into binary and back again...",
+        "Asking AI to think outside the box (it's stuck)...",
+        "Generating random excuses for slow processing..."
+    ]
+}

requirements.txt

@@ -0,0 +1,4 @@
+gradio
+lumaai
+requests
+python-dotenv