Add Gradio app with RunwayML image generation

app.py

@@ -0,0 +1,209 @@
+import gradio as gr
+from PIL import Image
+import os
+from datetime import datetime
+from text_handler import process_text
+from generate_image import generate_and_wait_for_result
+import concurrent.futures
+
+def create_markdown_with_images(prompt, image_paths, batch_folder, reference_image_paths=None):
+    """
+    Create a markdown file with the prompt, reference images, and generated image links.
+    """
+    markdown_content = f"# Image Generation Results\n\n"
+    markdown_content += f"**Prompt:** {prompt}\n\n"
+    markdown_content += f"**Generated on:** {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n\n"
+    markdown_content += f"**Batch:** {batch_folder}\n\n"
+    
+    if reference_image_paths:
+        markdown_content += "## Reference Images\n\n"
+        markdown_content += "| Character | Scene | Style |\n"
+        markdown_content += "|-----------|-------|-------|\n"
+        ref_cells = []
+        ref_labels = ["Character", "Scene", "Style"]
+        for i, ref_path in enumerate(reference_image_paths):
+            if ref_path and os.path.exists(ref_path):
+                ref_filename = os.path.basename(ref_path)
+                import shutil
+                ref_dest = os.path.join("output", batch_folder, f"ref_{ref_filename}")
+                shutil.copy2(ref_path, ref_dest)
+                ref_cells.append(f"![{ref_labels[i] if i < len(ref_labels) else 'Reference'}](ref_{ref_filename})<br>*{ref_filename}*")
+            else:
+                ref_cells.append("*No image*")
+        while len(ref_cells) < 3:
+            ref_cells.append("*No image*")
+        markdown_content += f"| {ref_cells[0]} | {ref_cells[1]} | {ref_cells[2]} |\n\n"
+    
+    markdown_content += "## Generated Images\n\n"
+    for i, image_path in enumerate(image_paths, 1):
+        if image_path and os.path.exists(image_path):
+            filename = os.path.basename(image_path)
+            markdown_content += f"- **Image {i}:** `![Generated Image {i}]({filename})`\n"
+        else:
+            markdown_content += f"- **Image {i}:** *Generation failed*\n"
+    
+    output_dir = os.path.join("output", batch_folder)
+    os.makedirs(output_dir, exist_ok=True)
+    timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
+    markdown_filename = f"generation_report_{timestamp}.md"
+    markdown_path = os.path.join(output_dir, markdown_filename)
+    
+    with open(markdown_path, 'w', encoding='utf-8') as f:
+        f.write(markdown_content)
+    
+    return markdown_path
+
+def save_uploaded_image(image, folder_name):
+    """
+    Save uploaded image to the appropriate assets folder.
+    """
+    if image is None:
+        return image
+    assets_path = os.path.join("assets", folder_name)
+    os.makedirs(assets_path, exist_ok=True)
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    filename = f"uploaded_{timestamp}.jpg"
+    filepath = os.path.join(assets_path, filename)
+    image.save(filepath, "JPEG", quality=95)
+    print(f"Saved uploaded image to: {filepath}")
+    return image
+
+def process_images(prompt, character_image, scene_image, style_image, num_images):
+    """
+    Process text prompt and input images, generate specified number of images using RunwayML.
+    """
+    num_images = int(num_images)
+    try:
+        processed_prompt = process_text(prompt)
+        
+        reference_images = []
+        temp_paths = []
+        
+        if character_image:
+            char_path = os.path.join("assets", "characters", f"temp_char_{datetime.now().strftime('%Y%m%d_%H%M%S')}.jpg")
+            os.makedirs(os.path.dirname(char_path), exist_ok=True)
+            character_image.save(char_path, "JPEG", quality=95)
+            reference_images.append(char_path)
+            temp_paths.append(char_path)
+        
+        if scene_image:
+            scene_path = os.path.join("assets", "scenes", f"temp_scene_{datetime.now().strftime('%Y%m%d_%H%M%S')}.jpg")
+            os.makedirs(os.path.dirname(scene_path), exist_ok=True)
+            scene_image.save(scene_path, "JPEG", quality=95)
+            reference_images.append(scene_path)
+            temp_paths.append(scene_path)
+        
+        if style_image:
+            style_path = os.path.join("assets", "styles", f"temp_style_{datetime.now().strftime('%Y%m%d_%H%M%S')}.jpg")
+            os.makedirs(os.path.dirname(style_path), exist_ok=True)
+            style_image.save(style_path, "JPEG", quality=95)
+            reference_images.append(style_path)
+            temp_paths.append(style_path)
+        
+        if not reference_images:
+            return "No reference images provided.", []
+        
+        timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
+        batch_folder = f"batch_{timestamp}"
+        batch_folder_path = os.path.join("output", batch_folder)
+        os.makedirs(batch_folder_path, exist_ok=True)
+        
+        image_paths = [os.path.join(batch_folder_path, f"generated_{i+1}_{timestamp}.jpg") for i in range(num_images)]
+        
+        def generate_single_image(index):
+            filename = os.path.basename(image_paths[index])
+            task_id, generated_image_path = generate_and_wait_for_result(
+                prompt_text=processed_prompt,
+                reference_image_paths=reference_images,
+                auto_tag_prompt=False,
+                filename=filename,
+                batch_folder=batch_folder
+            )
+            return index, task_id, generated_image_path
+        
+        with concurrent.futures.ThreadPoolExecutor(max_workers=num_images) as executor:
+            futures = [executor.submit(generate_single_image, i) for i in range(num_images)]
+            completed_image_paths = [None] * num_images
+            for future in concurrent.futures.as_completed(futures):
+                index, task_id, generated_image_path = future.result()
+                completed_image_paths[index] = generated_image_path
+        
+        markdown_path = create_markdown_with_images(
+            prompt=prompt,
+            image_paths=completed_image_paths,
+            batch_folder=batch_folder,
+            reference_image_paths=reference_images
+        )
+        
+        for temp_path in temp_paths:
+            if os.path.exists(temp_path):
+                os.remove(temp_path)
+        
+        existing_image_paths = [path for path in completed_image_paths if path and os.path.exists(path)]
+        status_msg = f"{processed_prompt}\n\nGenerated {len(existing_image_paths)}/{num_images} images in batch: {batch_folder}\nMarkdown report: {markdown_path}"
+        
+        return status_msg, existing_image_paths
+    
+    except Exception as e:
+        return f"Error: {str(e)}", []
+
+# Gradio Interface
+with gr.Blocks(title="RunwayML Image Generation") as demo:
+    gr.Markdown("# RunwayML Image Generation")
+    gr.Markdown("Generate images using RunwayML with reference images. Choose how many images to generate (1-4).")
+    
+    with gr.Tab("RunwayML with References"):
+        with gr.Row():
+            num_images = gr.Dropdown(
+                choices=["1", "2", "3", "4"],
+                value="4",
+                label="Number of Images to Generate"
+            )
+        runway_prompt_input = gr.Textbox(
+            label="Text Prompt",
+            placeholder="Enter your prompt here...",
+            value="@character is in @scene with @style style"
+        )
+        
+        with gr.Row():
+            character_input = gr.Image(label="Character", type="pil")
+            scene_input = gr.Image(label="Scene", type="pil")
+            style_input = gr.Image(label="Style", type="pil")
+        
+        runway_process_btn = gr.Button("Generate Images", variant="primary")
+        
+        runway_output_text = gr.Textbox(label="Status", interactive=False)
+        runway_gallery = gr.Gallery(
+            label="Generated Images",
+            show_label=True,
+            elem_id="gallery",
+            columns=2,
+            rows=2
+        )
+    
+    # Event handlers
+    character_input.upload(
+        fn=lambda img: save_uploaded_image(img, "characters"),
+        inputs=[character_input],
+        outputs=[character_input]
+    )
+    scene_input.upload(
+        fn=lambda img: save_uploaded_image(img, "scenes"),
+        inputs=[scene_input],
+        outputs=[scene_input]
+    )
+    style_input.upload(
+        fn=lambda img: save_uploaded_image(img, "styles"),
+        inputs=[style_input],
+        outputs=[style_input]
+    )
+    
+    runway_process_btn.click(
+        fn=process_images,
+        inputs=[runway_prompt_input, character_input, scene_input, style_input, num_images],
+        outputs=[runway_output_text, runway_gallery]
+    )
+
+if __name__ == "__main__":
+    demo.queue(default_concurrency_limit=2, max_size=20)
+    demo.launch()

generate_image.py

@@ -0,0 +1,506 @@
+import os
+import base64
+import time
+import requests
+from typing import List, Optional, Tuple
+from runwayml import RunwayML
+import mimetypes
+from urllib.parse import urlparse
+import replicate
+
+def encode_image_to_data_uri(image_path: str) -> str:
+    """Convert a local image file to a data URI."""
+    # Get the MIME type
+    mime_type, _ = mimetypes.guess_type(image_path)
+    if not mime_type or not mime_type.startswith('image/'):
+        raise ValueError(f"Unsupported image type for {image_path}")
+    
+    # Read and encode the image
+    with open(image_path, 'rb') as image_file:
+        encoded_string = base64.b64encode(image_file.read()).decode('utf-8')
+    
+    return f"data:{mime_type};base64,{encoded_string}"
+
+def save_generated_image(image_url: str, filename: str = None, batch_folder: str = None) -> str:
+    """
+    Download and save the generated image to a timestamped batch folder.
+    
+    Args:
+        image_url: URL of the generated image
+        filename: Optional filename (auto-generated if not provided)
+        batch_folder: Optional batch folder name (auto-generated with timestamp if not provided)
+    
+    Returns:
+        Path to the saved image file
+    """
+    # Create batch folder if not provided
+    if not batch_folder:
+        timestamp = time.strftime("%Y%m%d_%H%M%S")
+        batch_folder = f"batch_{timestamp}"
+    
+    # Create directory structure
+    output_dir = os.path.join("output", batch_folder)
+    os.makedirs(output_dir, exist_ok=True)
+    
+    # Generate filename if not provided
+    if not filename:
+        timestamp = int(time.time())
+        filename = f"generated_{timestamp}.jpg"
+    
+    # Ensure filename has extension
+    if not os.path.splitext(filename)[1]:
+        filename += ".jpg"
+    
+    output_path = os.path.join(output_dir, filename)
+    
+    # Download and save the image
+    response = requests.get(image_url)
+    response.raise_for_status()
+    
+    with open(output_path, 'wb') as f:
+        f.write(response.content)
+    
+    return output_path
+
+def generate_image_with_references(
+    prompt_text: str,
+    reference_image_paths: List[str],
+    ratio: str = "1920:1080",
+    model: str = "gen4_image",
+    seed: Optional[int] = None,
+    api_key: Optional[str] = None,
+    auto_tag_prompt: bool = True
+) -> str:
+    """
+    Generate an image using RunwayML API with reference images.
+    
+    Args:
+        prompt_text: Description of the image to generate (max 1000 characters)
+        reference_image_paths: List of local image file paths to use as references
+        ratio: Output image resolution (default: "1920:1080")
+        model: Model to use (default: "gen4_image")
+        seed: Optional seed for reproducible results
+        api_key: Optional API key (uses RUNWAYML_API_SECRET env var if not provided)
+        auto_tag_prompt: Whether to automatically append tags to prompt (default: True)
+                        When False, expects user to manually include @character, @scene, @style in prompt
+    
+    Returns:
+        Task ID for the generation request
+    """
+    # Initialize client
+    client = RunwayML(api_key=api_key or os.environ.get("RUNWAYML_API_SECRET"))
+    
+    # Validate inputs
+    if len(reference_image_paths) > 3:
+        raise ValueError("Maximum 3 reference images allowed")
+    
+    if len(prompt_text) > 1000:
+        raise ValueError("Prompt text must be 1000 characters or less")
+    
+    # Prepare reference images with standardized tags
+    reference_images = []
+    tags = []
+    
+    # Keep track of used standard tags to avoid duplicates
+    used_standard_tags = set()
+    
+    for i, image_path in enumerate(reference_image_paths):
+        if not os.path.exists(image_path):
+            raise FileNotFoundError(f"Image file not found: {image_path}")
+        
+        # Create tag based on path structure, prioritizing standard categories
+        filename = os.path.splitext(os.path.basename(image_path))[0]
+        path_parts = image_path.split(os.sep)
+        
+        # Look for standard category directories
+        tag = None
+        for part in path_parts:
+            if part == 'characters' and 'character' not in used_standard_tags:
+                tag = 'character'
+                used_standard_tags.add('character')
+                break
+            elif part == 'scenes' and 'scene' not in used_standard_tags:
+                tag = 'scene'
+                used_standard_tags.add('scene')
+                break
+            elif part == 'styles' and 'style' not in used_standard_tags:
+                tag = 'style'
+                used_standard_tags.add('style')
+                break
+        
+        # If no standard category found, create a custom tag from filename
+        if not tag:
+            tag = f"ref_{filename}".replace('-', '_').replace(' ', '_')[:16]
+            # Ensure tag starts with letter and is alphanumeric + underscore
+            tag = ''.join(c for c in tag if c.isalnum() or c == '_')
+            if not tag[0].isalpha():
+                tag = f"img_{tag}"
+            tag = tag[:16]  # Ensure max 16 characters
+        
+        tags.append(tag)
+        
+        # Convert to data URI
+        data_uri = encode_image_to_data_uri(image_path)
+        
+        reference_images.append({
+            "uri": data_uri,
+            "tag": tag
+        })
+    
+    # Handle prompt modification based on auto_tag_prompt setting
+    final_prompt = prompt_text
+    if auto_tag_prompt and tags:
+        # Auto-append tags to prompt
+        tag_mentions = " ".join([f"@{tag}" for tag in tags])
+        final_prompt = f"{prompt_text} using references: {tag_mentions}"
+        
+        # Ensure we don't exceed character limit
+        if len(final_prompt) > 1000:
+            # Try without the descriptive text
+            tag_mentions = " ".join([f"@{tag}" for tag in tags])
+            final_prompt = f"{prompt_text} {tag_mentions}"
+            
+            # If still too long, truncate prompt text
+            if len(final_prompt) > 1000:
+                available_chars = 1000 - len(tag_mentions) - 1
+                final_prompt = f"{prompt_text[:available_chars]} {tag_mentions}"
+    
+    print(f"Using tags: {tags}")
+    if auto_tag_prompt:
+        print(f"Auto-tagged prompt: {final_prompt}")
+    else:
+        print(f"Manual tagging mode - use @{', @'.join(tags)} in your prompt")
+        print(f"Original prompt: {final_prompt}")
+    
+    # Prepare the request parameters
+    create_params = {
+        "model": model,
+        "prompt_text": final_prompt,
+        "ratio": ratio,
+        "reference_images": reference_images
+    }
+    
+    # Only include seed if it's not None
+    if seed is not None:
+        create_params["seed"] = seed
+    
+    # Create the generation task
+    task = client.text_to_image.create(**create_params)
+    
+    return task.id
+
+def check_task_status(task_id: str, api_key: Optional[str] = None):
+    """
+    Check the status of a generation task.
+    
+    Args:
+        task_id: The task ID returned from generate_image_with_references
+        api_key: Optional API key (uses RUNWAYML_API_SECRET env var if not provided)
+    
+    Returns:
+        Task details including status and output URLs if completed
+    """
+    client = RunwayML(api_key=api_key or os.environ.get("RUNWAYML_API_SECRET"))
+    return client.tasks.retrieve(id=task_id)
+
+def generate_and_wait_for_result(
+    prompt_text: str,
+    reference_image_paths: List[str],
+    ratio: str = "1920:1080",
+    model: str = "gen4_image",
+    seed: Optional[int] = None,
+    api_key: Optional[str] = None,
+    filename: str = None,
+    batch_folder: str = None,
+    max_retries: int = 8,
+    wait_interval: int = 15,
+    auto_tag_prompt: bool = True
+) -> Tuple[str, str]:
+    """
+    Generate an image and wait for completion with automatic retries.
+    
+    Args:
+        prompt_text: Description of the image to generate
+        reference_image_paths: List of local image file paths to use as references
+        ratio: Output image resolution
+        model: Model to use
+        seed: Optional seed for reproducible results
+        api_key: Optional API key
+        filename: Optional filename for saved image
+        max_retries: Maximum number of status checks (default: 8)
+        wait_interval: Seconds to wait between checks (default: 15)
+        auto_tag_prompt: Whether to automatically append tags to prompt
+    
+    Returns:
+        Tuple of (task_id, saved_image_path)
+    """
+    # Start the generation task
+    task_id = generate_image_with_references(
+        prompt_text=prompt_text,
+        reference_image_paths=reference_image_paths,
+        ratio=ratio,
+        model=model,
+        seed=seed,
+        api_key=api_key,
+        auto_tag_prompt=auto_tag_prompt
+    )
+    
+    print(f"Image generation started. Task ID: {task_id}")
+    print(f"Checking status every {wait_interval} seconds (max {max_retries} attempts)...")
+    
+    # Wait and check status
+    for attempt in range(max_retries):
+        print(f"Attempt {attempt + 1}/{max_retries} - Waiting {wait_interval} seconds...")
+        time.sleep(wait_interval)
+        
+        try:
+            status = check_task_status(task_id, api_key)
+            print(f"Status: {status.status}")
+            
+            if status.status == "SUCCEEDED":
+                if hasattr(status, 'output') and status.output:
+                    image_url = status.output[0]
+                    print(f"Generation completed! Image URL: {image_url}")
+                    
+                    # Save the image
+                    saved_path = save_generated_image(image_url, filename, batch_folder)
+                    print(f"Image saved to: {saved_path}")
+                    
+                    return task_id, saved_path
+                else:
+                    print("Task succeeded but no output found")
+                    return task_id, None
+            
+            elif status.status == "FAILED":
+                print("Task failed")
+                return task_id, None
+            
+            elif status.status in ["PENDING", "RUNNING"]:
+                print("Task still in progress...")
+                continue
+            
+        except Exception as e:
+            print(f"Error checking status: {e}")
+            if attempt == max_retries - 1:
+                print("Max retries reached. Task may still be processing.")
+                return task_id, None
+    
+    print(f"Timeout after {max_retries} attempts. Task may still be processing.")
+    print(f"You can manually check status later using task ID: {task_id}")
+    return task_id, None
+
+def generate_image_with_replicate_imagen(
+    prompt: str,
+    aspect_ratio: str = "1:1",
+    output_format: str = "jpg",
+    model: str = "google/imagen-4-fast",
+    safety_filter_level: str = "block_only_high",
+    filename: str = None,
+    api_token: Optional[str] = None
+) -> str:
+    """
+    Generate an image using Replicate's Google Imagen models.
+    
+    Args:
+        prompt: Text prompt for image generation
+        aspect_ratio: Aspect ratio of the generated image (default: "1:1")
+        output_format: Format of the output image (default: "jpg")
+        model: Imagen model to use (default: "google/imagen-4-fast")
+        safety_filter_level: Safety filter level (default: "block_only_high")
+        filename: Optional filename for saved image
+        api_token: Optional API token (uses REPLICATE_API_TOKEN env var if not provided)
+    
+    Returns:
+        Path to the saved image file
+    """
+    # Set API token
+    if api_token:
+        os.environ["REPLICATE_API_TOKEN"] = api_token
+    elif not os.environ.get("REPLICATE_API_TOKEN"):
+        raise ValueError("REPLICATE_API_TOKEN environment variable must be set or api_token must be provided")
+    
+    print(f"Generating image with model: {model}")
+    print(f"Prompt: {prompt}")
+    print(f"Aspect ratio: {aspect_ratio}, Format: {output_format}")
+    
+    # Run the model
+    try:
+        output = replicate.run(
+            model,
+            input={
+                "prompt": prompt,
+                "aspect_ratio": aspect_ratio,
+                "output_format": output_format,
+                "safety_filter_level": safety_filter_level
+            }
+        )
+        
+        # The output is a URL string
+        image_url = output
+        print(f"Image generated successfully: {image_url}")
+        
+        # Save the image
+        saved_path = save_generated_image(image_url, filename)
+        print(f"Image saved to: {saved_path}")
+        
+        return saved_path
+        
+    except Exception as e:
+        print(f"Error generating image with Replicate Imagen: {e}")
+        raise
+
+def main():
+    """Example usage with model selection between runway and imagen-fast."""
+    print("=== Image Generation Model Selection ===")
+    print("Available models:")
+    print("1. runway - RunwayML with reference images")
+    print("2. imagen-fast - Replicate's Google Imagen 4 Fast")
+    
+    model_choice = input("Enter model choice (runway/imagen-fast): ").strip().lower()
+    
+    if model_choice == "runway":
+        print("\n=== Testing RunwayML with Reference Images ===")
+        # Example reference images
+        reference_images = [
+            "assets/characters/japanese_guy.jpg",
+            "assets/scenes/f1-fields.jpg", 
+            "assets/styles/f1-cockpit.jpg"
+        ]
+        
+        print("=== Manual Tagging Mode (Default for Testing) ===")
+        # Example with manual tagging (auto_tag_prompt=False)
+        manual_prompt = "@character in a @scene with @style composition, cinematic lighting, high detail"
+        
+        try:
+            task_id, saved_path = generate_and_wait_for_result(
+                prompt_text=manual_prompt,
+                reference_image_paths=reference_images,
+                ratio="1920:1080",
+                filename="f1_driver_manual_tags.jpg",
+                auto_tag_prompt=False  # Manual tagging mode
+            )
+            
+            if saved_path:
+                print(f"Manual tagging success! Image saved to: {saved_path}")
+            else:
+                print(f"Manual tagging incomplete. Task ID: {task_id}")
+                
+        except Exception as e:
+            print(f"Manual tagging error: {e}")
+        
+        print("\n" + "="*50)
+        print("=== Auto Tagging Mode Example ===")
+        # Example with automatic tagging (auto_tag_prompt=True)
+        auto_prompt = "A Japanese F1 driver in a cockpit style setting on a racing field, cinematic lighting, high detail"
+        
+        try:
+            task_id, saved_path = generate_and_wait_for_result(
+                prompt_text=auto_prompt,
+                reference_image_paths=reference_images,
+                ratio="1920:1080",
+                filename="f1_driver_auto_tags.jpg",
+                auto_tag_prompt=True  # Auto tagging mode
+            )
+            
+            if saved_path:
+                print(f"Auto tagging success! Image saved to: {saved_path}")
+            else:
+                print(f"Auto tagging incomplete. Task ID: {task_id}")
+                
+        except Exception as e:
+            print(f"Auto tagging error: {e}")
+    
+    elif model_choice == "imagen-fast":
+        print("\n=== Testing Replicate's Google Imagen 4 Fast ===")
+        
+        # Get prompt from user or use default
+        prompt = input("Enter image prompt (or press Enter for default): ").strip()
+        if not prompt:
+            prompt = "A cinematic shot of a futuristic sports car racing through a neon-lit cyberpunk city at night, high detail, dramatic lighting"
+        
+        # Get aspect ratio
+        aspect_ratio = input("Enter aspect ratio (default 16:9): ").strip() or "16:9"
+        
+        # Get model version
+        model_version = input("Enter model version (fast/ultra, default fast): ").strip().lower() or "fast"
+        model_name = "google/imagen-4-fast" if model_version == "fast" else "google/imagen-4-ultra"
+        
+        try:
+            saved_path = generate_image_with_replicate_imagen(
+                prompt=prompt,
+                aspect_ratio=aspect_ratio,
+                model=model_name,
+                filename="imagen_test.jpg"
+            )
+            print(f"Imagen generation success! Image saved to: {saved_path}")
+            
+        except Exception as e:
+            print(f"Imagen generation error: {e}")
+    
+    else:
+        print(f"Invalid model choice: {model_choice}")
+        print("Please choose either 'runway' or 'imagen-fast'")
+
+def example_manual_tagging():
+    """
+    Example function demonstrating manual tagging mode.
+    When auto_tag_prompt=False, users must include @character, @scene, @style in their prompts.
+    """
+    reference_images = [
+        "assets/characters/anime_girl.jpg",
+        "assets/scenes/cyberpunk_city.jpg", 
+        "assets/styles/neon_art.jpg"
+    ]
+    
+    # Manual prompt with explicit tag references
+    prompt_with_tags = """
+    A futuristic @character standing in a @cyberpunk @scene 
+    with @style aesthetic, glowing neon lights, 4k resolution
+    """.strip()
+    
+    print("Manual Tagging Example:")
+    print(f"Prompt: {prompt_with_tags}")
+    
+    try:
+        task_id, saved_path = generate_and_wait_for_result(
+            prompt_text=prompt_with_tags,
+            reference_image_paths=reference_images,
+            auto_tag_prompt=False,  # Disabled - expects manual @tags
+            filename="cyberpunk_manual.jpg"
+        )
+        return task_id, saved_path
+    except Exception as e:
+        print(f"Error in manual tagging example: {e}")
+        return None, None
+
+def example_auto_tagging():
+    """
+    Example function demonstrating auto tagging mode.
+    When auto_tag_prompt=True, tags are automatically appended to the prompt.
+    """
+    reference_images = [
+        "assets/characters/warrior.jpg",
+        "assets/scenes/medieval_castle.jpg", 
+        "assets/styles/oil_painting.jpg"
+    ]
+    
+    # Simple prompt without tag references
+    simple_prompt = "A brave warrior defending a castle, epic fantasy art"
+    
+    print("Auto Tagging Example:")
+    print(f"Original prompt: {simple_prompt}")
+    
+    try:
+        task_id, saved_path = generate_and_wait_for_result(
+            prompt_text=simple_prompt,
+            reference_image_paths=reference_images,
+            auto_tag_prompt=True,  # Enabled - automatically adds @tags
+            filename="fantasy_auto.jpg"
+        )
+        return task_id, saved_path
+    except Exception as e:
+        print(f"Error in auto tagging example: {e}")
+        return None, None
+
+if __name__ == "__main__":
+    main()

requirements.txt

@@ -0,0 +1,4 @@
+gradio
+pillow
+requests
+runwayml

text_handler.py

@@ -0,0 +1,24 @@
+def process_text(input_text):
+    """
+    Function that takes text input and returns it to terminal
+    
+    Args:
+        input_text (str): The text to be processed and returned
+    
+    Returns:
+        str: The same text that was input
+    """
+    print(f"Input received: {input_text}")
+    return input_text
+
+def main():
+    """
+    Main function to demonstrate the text processing
+    """
+    # Example usage
+    user_input = input("Enter some text: ")
+    result = process_text(user_input)
+    print(f"Returned text: {result}")
+
+if __name__ == "__main__":
+    main()