Update app.py

app.py

@@ -1,7 +1,7 @@
 import gradio as gr
 import torch
-from diffusers import StableDiffusionPipeline, EulerAncestralDiscreteScheduler, StableDiffusionInpaintPipeline
-from PIL import Image, ImageDraw
+from diffusers import StableDiffusionPipeline, EulerAncestralDiscreteScheduler
+from PIL import Image
 import io
 import requests
 import os
@@ -9,30 +9,24 @@ from datetime import datetime
 import re
 import time
 import json
-from typing import List, Optional, Dict, Tuple
+from typing import List, Optional, Dict
 from fastapi import FastAPI, HTTPException, BackgroundTasks
 from pydantic import BaseModel
-import gc
-import psutil
 import threading
 import uuid
-import hashlib
-from enum import Enum
 import random
-import numpy as np
 
-# External OCI API URL - YOUR BUCKET SAVING API
+# External OCI API URL
 OCI_API_BASE_URL = "https://yukee1992-oci-story-book.hf.space"
 
-# Create local directories for test images
+# Create local directories
 PERSISTENT_IMAGE_DIR = "generated_test_images"
 os.makedirs(PERSISTENT_IMAGE_DIR, exist_ok=True)
 print(f"📁 Created local image directory: {PERSISTENT_IMAGE_DIR}")
 
 # Initialize FastAPI app
-app = FastAPI(title="Dual-Pipeline Storybook Generator API")
+app = FastAPI(title="Storybook Generator API")
 
-# Add CORS middleware
 from fastapi.middleware.cors import CORSMiddleware
 app.add_middleware(
     CORSMiddleware,
@@ -42,40 +36,31 @@ app.add_middleware(
     allow_headers=["*"],
 )
 
-# Job Status Enum
 class JobStatus(str, Enum):
     PENDING = "pending"
-    GENERATING_CHARACTERS = "generating_characters"
-    GENERATING_BACKGROUNDS = "generating_backgrounds"
-    COMPOSING_SCENES = "composing_scenes"
     PROCESSING = "processing"
     COMPLETED = "completed"
     FAILED = "failed"
 
-# Enhanced Story scene model with character consistency
 class StoryScene(BaseModel):
     visual: str
     text: str
-    characters_present: List[str] = []  # Which characters are in this scene
-    scene_type: str = "general"  # "action", "dialogue", "establishing", etc.
-    background_context: str = ""  # Specific background description
+    characters_present: List[str] = []
 
 class CharacterDescription(BaseModel):
     name: str
     description: str
-    visual_prompt: str = ""  # Detailed visual description for AI
-    key_features: List[str] = []  # Critical features that must stay consistent
-    pose_reference: str = "standing naturally"  # For consistent posing
+    visual_prompt: str = ""
+    key_features: List[str] = []
 
 class StorybookRequest(BaseModel):
     story_title: str
     scenes: List[StoryScene]
     characters: List[CharacterDescription] = []
-    model_choice: str = "dreamshaper-8"
+    model_choice: str = "sd-1.5"
     style: str = "childrens_book"
     callback_url: Optional[str] = None
     consistency_seed: Optional[int] = None
-    pipeline_type: str = "standard"  # "standard" or "enhanced"
 
 class JobStatusResponse(BaseModel):
     job_id: str
@@ -86,41 +71,19 @@ class JobStatusResponse(BaseModel):
     created_at: float
     updated_at: float
 
-# HIGH-QUALITY MODEL SELECTION
+# SIMPLE MODEL CHOICES - Only working models
 MODEL_CHOICES = {
-    "dreamshaper-8": "lykon/dreamshaper-8",
-    "realistic-vision": "SG161222/Realistic_Vision_V5.1",
-    "anything-v5": "andite/anything-v5.0",
-    "openjourney": "prompthero/openjourney",
     "sd-1.5": "runwayml/stable-diffusion-v1-5",
 }
 
-# FALLBACK CHARACTER TEMPLATES
-FALLBACK_CHARACTER_TEMPLATES = {
-    "Sparkle the Star Cat": {
-        "visual_prompt": "small white kitten with distinctive silver star-shaped spots on fur, big golden eyes, shiny blue collar with star charm, playful expression",
-        "key_features": ["star-shaped spots", "blue collar", "golden eyes", "white fur"],
-    },
-    "Benny the Bunny": {
-        "visual_prompt": "fluffy brown rabbit with long ears, bright green eyes, red scarf around neck, cheerful expression",
-        "key_features": ["red scarf", "long ears", "green eyes", "brown fur"],
-    },
-    "Tilly the Turtle": {
-        "visual_prompt": "gentle green turtle with shiny turquoise shell decorated with swirl patterns, wise expression, slow-moving",
-        "key_features": ["turquoise shell", "swirl patterns", "green skin", "wise expression"],
-    }
-}
-
-# GLOBAL STORAGE
 job_storage = {}
 model_cache = {}
-inpaint_pipe = None
 current_model_name = None
 current_pipe = None
 model_lock = threading.Lock()
 
-def load_model(model_name="dreamshaper-8"):
-    """Thread-safe model loading with HIGH-QUALITY settings"""
+def load_model(model_name="sd-1.5"):
+    """EXACT WORKING VERSION FROM OLD SCRIPT"""
     global model_cache, current_model_name, current_pipe
     
     with model_lock:
@@ -129,9 +92,9 @@ def load_model(model_name="dreamshaper-8"):
             current_model_name = model_name
             return current_pipe
         
-        print(f"🔄 Loading HIGH-QUALITY model: {model_name}")
+        print(f"🔄 Loading model: {model_name}")
         try:
-            model_id = MODEL_CHOICES.get(model_name, "lykon/dreamshaper-8")
+            model_id = MODEL_CHOICES.get(model_name, "runwayml/stable-diffusion-v1-5")
             
             pipe = StableDiffusionPipeline.from_pretrained(
                 model_id, 
@@ -147,535 +110,54 @@ def load_model(model_name="dreamshaper-8"):
             current_pipe = pipe
             current_model_name = model_name
             
-            print(f"✅ HIGH-QUALITY Model loaded: {model_name}")
+            print(f"✅ Model loaded: {model_name}")
             return pipe
             
         except Exception as e:
             print(f"❌ Model loading failed: {e}")
-            return None
-
-def load_inpaint_model():
-    """Load inpainting model for composition"""
-    global inpaint_pipe
-    
-    if inpaint_pipe is not None:
-        return inpaint_pipe
-    
-    print("🔄 Loading inpainting model...")
-    try:
-        inpaint_pipe = StableDiffusionInpaintPipeline.from_pretrained(
-            "runwayml/stable-diffusion-inpainting",
-            torch_dtype=torch.float32,
-            safety_checker=None,
-            requires_safety_checker=False
-        )
-        inpaint_pipe = inpaint_pipe.to("cpu")
-        print("✅ Inpainting model loaded")
-        return inpaint_pipe
-    except Exception as e:
-        print(f"❌ Inpainting model failed: {e}")
-        return None
-
-# Initialize models
-print("🚀 Initializing Dual-Pipeline Storybook Generator API...")
-load_model("dreamshaper-8")
-load_inpaint_model()
-print("✅ Models loaded and ready!")
-
-# ============================================================================
-# CHARACTER PROCESSING FUNCTIONS (for both pipelines)
-# ============================================================================
-
-def process_character_descriptions(characters_from_request):
-    """Process character descriptions from n8n and create consistency templates"""
-    character_templates = {}
-    
-    for character in characters_from_request:
-        char_name = character.name
-        
-        # Use provided visual_prompt or generate from description
-        if character.visual_prompt:
-            visual_prompt = character.visual_prompt
-        else:
-            # Generate visual prompt from description
-            visual_prompt = generate_visual_prompt_from_description(character.description, char_name)
-        
-        # Use provided key_features or extract from description
-        if character.key_features:
-            key_features = character.key_features
-        else:
-            key_features = extract_key_features_from_description(character.description)
-        
-        character_templates[char_name] = {
-            "visual_prompt": visual_prompt,
-            "key_features": key_features,
-            "consistency_keywords": f"consistent character, same {char_name.split()[-1].lower()}, maintaining appearance",
-            "source": "n8n_request"
-        }
-    
-    print(f"✅ Processed {len(character_templates)} characters from n8n request")
-    return character_templates
-
-def generate_visual_prompt_from_description(description, character_name):
-    """Generate a visual prompt from character description"""
-    description_lower = description.lower()
-    
-    # Extract species/type
-    species_keywords = ["kitten", "cat", "rabbit", "bunny", "turtle", "dog", "bird", "dragon", "bear", "fox"]
-    species = "character"
-    for keyword in species_keywords:
-        if keyword in description_lower:
-            species = keyword
-            break
-    
-    # Extract colors
-    color_keywords = ["white", "black", "brown", "red", "blue", "green", "yellow", "golden", "silver", "orange"]
-    colors = []
-    for color in color_keywords:
-        if color in description_lower:
-            colors.append(color)
-    
-    # Extract distinctive features
-    feature_keywords = ["spots", "stripes", "collar", "scarf", "shell", "wings", "horn", "tail", "ears", "eyes"]
-    features = []
-    for feature in feature_keywords:
-        if feature in description_lower:
-            features.append(feature)
-    
-    # Build visual prompt
-    visual_prompt_parts = []
-    if colors:
-        visual_prompt_parts.append(f"{' '.join(colors)} {species}")
-    else:
-        visual_prompt_parts.append(species)
-    
-    visual_prompt_parts.append(character_name)
-    
-    if features:
-        visual_prompt_parts.append(f"with {', '.join(features)}")
-    
-    # Add emotional/character traits
-    trait_keywords = ["playful", "brave", "curious", "kind", "cheerful", "wise", "calm", "friendly"]
-    traits = [trait for trait in trait_keywords if trait in description_lower]
-    if traits:
-        visual_prompt_parts.append(f"{', '.join(traits)} expression")
-    
-    visual_prompt = " ".join(visual_prompt_parts)
-    print(f"🔧 Generated visual prompt for {character_name}: {visual_prompt}")
-    
-    return visual_prompt
-
-def extract_key_features_from_description(description):
-    """Extract key features from character description"""
-    description_lower = description.lower()
-    key_features = []
-    
-    # Look for distinctive physical features
-    feature_patterns = [
-        r"(\w+)\s+(?:spots|stripes|marks)",
-        r"(\w+)\s+(?:collar|scarf|ribbon)",
-        r"(\w+)\s+(?:eyes|fur|skin|shell)",
-        r"(\w+)\s+(?:ears|tail|wings|horn)"
-    ]
-    
-    for pattern in feature_patterns:
-        matches = re.findall(pattern, description_lower)
-        key_features.extend(matches)
-    
-    # Remove duplicates and limit to 3 most important features
-    key_features = list(set(key_features))[:3]
-    
-    # If no features found, use some defaults based on character type
-    if not key_features:
-        if any(word in description_lower for word in ["kitten", "cat"]):
-            key_features = ["whiskers", "tail", "paws"]
-        elif any(word in description_lower for word in ["rabbit", "bunny"]):
-            key_features = ["long ears", "fluffy tail", "paws"]
-        elif any(word in description_lower for word in ["turtle"]):
-            key_features = ["shell", "slow moving", "wise eyes"]
-        else:
-            key_features = ["distinctive appearance", "consistent features"]
-    
-    print(f"🔧 Extracted key features: {key_features}")
-    return key_features
-
-def extract_characters_from_visual(visual_description, available_characters):
-    """Extract character names from visual description using available characters"""
-    characters = []
-    visual_lower = visual_description.lower()
-    
-    # Check for each available character name in the visual description
-    for char_name in available_characters:
-        # Use the first word or main identifier from character name
-        char_identifier = char_name.split()[0].lower()
-        if char_identifier in visual_lower or char_name.lower() in visual_lower:
-            characters.append(char_name)
-    
-    return characters
-
-def generate_character_reference_sheet(characters):
-    """Generate reference descriptions for consistent character generation"""
-    reference_sheet = {}
-    
-    for character in characters:
-        char_name = character.name
-        reference_sheet[char_name] = {
-            "name": char_name,
-            "base_prompt": character.visual_prompt if character.visual_prompt else generate_visual_prompt_from_description(character.description, char_name),
-            "key_features": character.key_features if character.key_features else extract_key_features_from_description(character.description),
-            "must_include": character.key_features[:2] if character.key_features else []
-        }
-    
-    return reference_sheet
-
-# ============================================================================
-# STANDARD PIPELINE FUNCTIONS (Your original approach)
-# ============================================================================
-
-def enhance_prompt_with_characters(scene_visual, characters_present, character_templates, style="childrens_book", scene_number=1):
-    """Create prompts that maintain character consistency using dynamic templates"""
-    
-    # Get character descriptions for this scene
-    character_descriptions = []
-    consistency_keywords = []
-    
-    for char_name in characters_present:
-        if char_name in character_templates:
-            char_data = character_templates[char_name]
-            character_descriptions.append(f"{char_name}: {char_data['visual_prompt']}")
-            consistency_keywords.append(char_data['consistency_keywords'])
-        else:
-            # Fallback if character not in templates
-            character_descriptions.append(f"{char_name}: distinctive character")
-            consistency_keywords.append(f"consistent {char_name}")
-    
-    # Style templates
-    style_templates = {
-        "childrens_book": "children's book illustration, watercolor style, soft colors, whimsical, magical, storybook art, professional illustration",
-        "realistic": "photorealistic, detailed, natural lighting, professional photography",
-        "fantasy": "fantasy art, magical, ethereal, digital painting, concept art",
-        "anime": "anime style, Japanese animation, vibrant colors, detailed artwork"
-    }
-    
-    style_prompt = style_templates.get(style, style_templates["childrens_book"])
-    
-    # Build the enhanced prompt
-    character_context = ". ".join(character_descriptions)
-    consistency_context = ", ".join(consistency_keywords)
-    
-    enhanced_prompt = (
-        f"{style_prompt}, {scene_visual}. "
-        f"Featuring: {character_context}. "
-        f"Maintain character consistency: {consistency_context}. "
-        f"Scene {scene_number} of storybook series. "
-    )
-    
-    # Quality boosters for consistency
-    quality_boosters = [
-        "consistent character design", "maintain identical features", 
-        "same characters throughout", "continuous visual narrative",
-        "professional storybook illustration", "cohesive art style",
-        "character continuity", "consistent proportions"
-    ]
-    
-    enhanced_prompt += ", ".join(quality_boosters)
-    
-    # Enhanced negative prompt to avoid inconsistencies
-    negative_prompt = (
-        "inconsistent characters, different appearances, changing features, "
-        "multiple versions of same character, inconsistent art style, "
-        "blurry, low quality, bad anatomy, deformed characters, "
-        "wrong proportions, mismatched features, different art style"
-    )
-    
-    return enhanced_prompt, negative_prompt
-
-def generate_consistent_image(prompt, model_choice, style, characters_present, character_templates, scene_number, consistency_seed=None):
-    """Generate image with character consistency measures using dynamic templates"""
-    
-    # Enhance prompt with character consistency
-    enhanced_prompt, negative_prompt = enhance_prompt_with_characters(
-        prompt, characters_present, character_templates, style, scene_number
-    )
-    
-    # Use a consistent seed for character generation
-    if consistency_seed:
-        base_seed = consistency_seed
-    else:
-        base_seed = hash("".join(characters_present)) % 1000000 if characters_present else random.randint(1000, 9999)
-    
-    # Adjust seed slightly per scene but maintain character consistency
-    scene_seed = base_seed + scene_number
-    
-    try:
-        pipe = load_model(model_choice)
-        if pipe is None:
-            raise Exception("Model not available")
-        
-        image = pipe(
-            prompt=enhanced_prompt,
-            negative_prompt=negative_prompt,
-            num_inference_steps=35,
-            guidance_scale=7.5,
-            width=768,
-            height=768,
-            generator=torch.Generator(device="cpu").manual_seed(scene_seed)
-        ).images[0]
-        
-        print(f"✅ Generated consistent image for scene {scene_number}")
-        print(f"👥 Characters: {characters_present}")
-        print(f"🌱 Seed used: {scene_seed}")
-        
-        return image
-        
-    except Exception as e:
-        print(f"❌ Consistent generation failed: {str(e)}")
-        raise
-
-# ============================================================================
-# ENHANCED PIPELINE FUNCTIONS (3-stage approach)
-# ============================================================================
-
-def generate_character_image(character: CharacterDescription, model_choice: str, style: str, seed: int = None) -> Image.Image:
-    """Generate a single character with transparent background"""
-    
-    character_prompt = f"""
-    {character.visual_prompt or character.description}, 
-    {character.pose_reference},
-    full body character, clean outline, studio lighting, 
-    plain white background, isolated character, no background,
-    children's book character design, professional illustration,
-    {style} style, detailed features, vibrant colors
-    """
-    
-    # Clean up prompt
-    character_prompt = re.sub(r'\s+', ' ', character_prompt).strip()
-    
-    negative_prompt = """
-    background, scenery, environment, other characters, 
-    blurry, low quality, bad anatomy, deformed,
-    complex background, shadows, ground, text, watermark
-    """
-    
-    pipe = load_model(model_choice)
-    if pipe is None:
-        raise Exception("Model not available")
-    
-    # Use consistent seed for character
-    if seed is None:
-        seed = hash(character.name) % 1000000
-    
-    generator = torch.Generator(device="cpu").manual_seed(seed)
-    
-    image = pipe(
-        prompt=character_prompt,
-        negative_prompt=negative_prompt,
-        num_inference_steps=30,
-        guidance_scale=7.5,
-        width=512,
-        height=768,
-        generator=generator
-    ).images[0]
-    
-    # Simple background removal
-    image = remove_background_simple(image)
-    
-    print(f"✅ Generated character: {character.name}")
-    return image
-
-def remove_background_simple(image: Image.Image) -> Image.Image:
-    """Simple background removal (replace with proper segmentation in production)"""
-    # Convert to RGBA if not already
-    if image.mode != 'RGBA':
-        image = image.convert('RGBA')
-    
-    # Simple white background removal
-    datas = image.getdata()
-    new_data = []
-    for item in datas:
-        # Change white (and near-white) pixels to transparent
-        if item[0] > 200 and item[1] > 200 and item[2] > 200:
-            new_data.append((255, 255, 255, 0))
-        else:
-            new_data.append(item)
-    
-    image.putdata(new_data)
-    return image
-
-def generate_scene_background(scene: StoryScene, model_choice: str, style: str, seed: int = None) -> Image.Image:
-    """Generate scene background without characters"""
-    
-    background_prompt = f"""
-    {scene.visual} {scene.background_context},
-    empty scene, no characters, no people, no animals,
-    background environment, landscape, setting,
-    children's book background, {style} style,
-    detailed background, vibrant colors, professional illustration
-    """
-    
-    # Clean up prompt
-    background_prompt = re.sub(r'\s+', ' ', background_prompt).strip()
-    
-    negative_prompt = """
-    characters, people, animals, creatures, person, human, animal,
-    blurry, low quality, deformed objects, text, watermark,
-    foreground elements, main subject, face, body
-    """
-    
-    pipe = load_model(model_choice)
+            # FALLBACK THAT WORKS
+            fallback_pipe = StableDiffusionPipeline.from_pretrained(
+                "runwayml/stable-diffusion-v1-5", 
+                torch_dtype=torch.float32,
+                safety_checker=None,
+                requires_safety_checker=False
+            ).to("cpu")
+            model_cache["sd-1.5"] = fallback_pipe
+            return fallback_pipe
+
+# Initialize model
+print("🚀 Initializing Storybook Generator API...")
+load_model("sd-1.5")
+print("✅ Model loaded and ready!")
+
+def generate_simple_image(prompt, negative_prompt="", seed=None):
+    """Simple image generation"""
+    pipe = load_model("sd-1.5")
     if pipe is None:
         raise Exception("Model not available")
     
-    if seed is None:
-        seed = random.randint(1000, 9999)
-    
-    generator = torch.Generator(device="cpu").manual_seed(seed)
+    generator = None
+    if seed:
+        generator = torch.Generator(device="cpu").manual_seed(seed)
     
     image = pipe(
-        prompt=background_prompt,
+        prompt=prompt,
         negative_prompt=negative_prompt,
-        num_inference_steps=30,
+        num_inference_steps=25,
         guidance_scale=7.5,
         width=768,
         height=768,
         generator=generator
     ).images[0]
     
-    print(f"✅ Generated background for scene")
     return image
 
-def create_character_mask(character_image: Image.Image, position: Tuple[int, int], size: Tuple[int, int]) -> Image.Image:
-    """Create mask for character placement"""
-    mask = Image.new("L", (768, 768), 0)
-    char_resized = character_image.resize(size)
-    
-    # Create white mask where character will be placed
-    mask_canvas = Image.new("L", (768, 768), 0)
-    mask_canvas.paste(Image.new("L", size, 255), position)
-    
-    return mask_canvas
-
-def smart_character_placement(background: Image.Image, num_characters: int, scene_context: str) -> List[Tuple[int, int, int, int]]:
-    """Calculate smart positions for characters based on scene context"""
-    positions = []
-    
-    if num_characters == 1:
-        # Center character
-        positions.append((284, 300, 200, 300))
-    elif num_characters == 2:
-        # Two characters side by side
-        positions.extend([
-            (184, 300, 200, 300),
-            (484, 300, 200, 300)
-        ])
-    elif num_characters >= 3:
-        # Arrange in a grid
-        for i in range(num_characters):
-            x = 150 + (i % 3) * 200
-            y = 250 + (i // 3) * 200
-            positions.append((x, y, 180, 270))
-    
-    return positions
-
-def compose_scene_with_characters(background: Image.Image, character_images: Dict[str, Image.Image], 
-                                characters_present: List[str], scene_context: str) -> Image.Image:
-    """Simple composition by placing characters on background"""
-    
-    # Start with background
-    final_image = background.copy()
-    
-    # Get character positions
-    positions = smart_character_placement(background, len(characters_present), scene_context)
-    
-    for i, char_name in enumerate(characters_present):
-        if i >= len(positions) or char_name not in character_images:
-            continue
-            
-        char_image = character_images[char_name]
-        x, y, width, height = positions[i]
-        
-        # Resize character
-        char_resized = char_image.resize((width, height))
-        
-        # Paste character with transparency
-        final_image.paste(char_resized, (x, y), char_resized)
-    
-    return final_image
-
-def compose_with_inpainting(background: Image.Image, character_images: Dict[str, Image.Image], 
-                          characters_present: List[str], scene_prompt: str) -> Image.Image:
-    """Enhanced composition using inpainting for better blending"""
-    
-    # Load inpainting model
-    pipe = load_inpaint_model()
-    if pipe is None:
-        # Fallback to simple composition
-        return compose_scene_with_characters(background, character_images, characters_present, scene_prompt)
-    
-    # Start with background
-    composite = background.copy()
-    
-    # Get character positions
-    positions = smart_character_placement(background, len(characters_present), scene_prompt)
-    
-    for i, char_name in enumerate(characters_present):
-        if i >= len(positions) or char_name not in character_images:
-            continue
-            
-        char_image = character_images[char_name]
-        x, y, width, height = positions[i]
-        
-        # Resize character
-        char_resized = char_image.resize((width, height))
-        
-        # Create temporary composite with character
-        temp_composite = composite.copy()
-        temp_composite.paste(char_resized, (x, y), char_resized)
-        
-        # Create mask for this character
-        mask = create_character_mask(char_resized, (x, y), (width, height))
-        
-        # Use inpainting to blend character into background
-        inpainting_prompt = f"""
-        {scene_prompt}, with {char_name} naturally integrated into the scene,
-        proper lighting and shadows, realistic composition,
-        children's book illustration style, consistent lighting
-        """
-        
-        try:
-            # Apply inpainting
-            inpainted_image = pipe(
-                prompt=inpainting_prompt,
-                image=temp_composite,
-                mask_image=mask,
-                num_inference_steps=20,
-                guidance_scale=7.0,
-                strength=0.7
-            ).images[0]
-            
-            composite = inpainted_image
-            print(f"✅ Blended {char_name} into scene with inpainting")
-            
-        except Exception as e:
-            print(f"❌ Inpainting failed for {char_name}, using simple composition: {e}")
-            composite.paste(char_resized, (x, y), char_resized)
-    
-    return composite
-
-# ============================================================================
-# OCI BUCKET FUNCTIONS
-# ============================================================================
-
-def save_to_oci_bucket(file_data, filename, story_title, file_type="image", subfolder=""):
-    """Save files to OCI bucket with organized structure"""
+def save_to_oci_bucket(file_data, filename, story_title, file_type="image"):
+    """Save files to OCI bucket"""
     try:
         api_url = f"{OCI_API_BASE_URL}/api/upload"
         
-        if subfolder:
-            full_subfolder = f'stories/{story_title}/{subfolder}'
-        else:
-            full_subfolder = f'stories/{story_title}'
-        
+        full_subfolder = f'stories/{story_title}'
         mime_type = "image/png" if file_type == "image" else "text/plain"
         files = {'file': (filename, file_data, mime_type)}
         data = {
@@ -685,8 +167,6 @@ def save_to_oci_bucket(file_data, filename, story_title, file_type="image", subf
         
         response = requests.post(api_url, files=files, data=data, timeout=30)
         
-        print(f"📨 OCI API Response: {response.status_code}")
-        
         if response.status_code == 200:
             result = response.json()
             if result['status'] == 'success':
@@ -699,17 +179,9 @@ def save_to_oci_bucket(file_data, filename, story_title, file_type="image", subf
     except Exception as e:
         raise Exception(f"OCI upload failed: {str(e)}")
 
-# ============================================================================
-# JOB MANAGEMENT FUNCTIONS
-# ============================================================================
-
 def create_job(story_request: StorybookRequest) -> str:
     job_id = str(uuid.uuid4())
     
-    # Process character descriptions
-    character_templates = process_character_descriptions(story_request.characters)
-    character_references = generate_character_reference_sheet(story_request.characters)
-    
     job_storage[job_id] = {
         "status": JobStatus.PENDING,
         "progress": 0,
@@ -718,15 +190,9 @@ def create_job(story_request: StorybookRequest) -> str:
         "result": None,
         "created_at": time.time(),
         "updated_at": time.time(),
-        "pages": [],
-        "character_templates": character_templates,
-        "character_references": character_references
     }
     
     print(f"📝 Created job {job_id} for story: {story_request.story_title}")
-    print(f"👥 Processed {len(character_templates)} characters")
-    print(f"🚀 Pipeline type: {story_request.pipeline_type}")
-    
     return job_id
 
 def update_job_status(job_id: str, status: JobStatus, progress: int, message: str, result=None):
@@ -743,35 +209,21 @@ def update_job_status(job_id: str, status: JobStatus, progress: int, message: st
     if result:
         job_storage[job_id]["result"] = result
     
-    # Send webhook notification if callback URL exists
     job_data = job_storage[job_id]
     request_data = job_data["request"]
     
     if request_data.get("callback_url"):
         try:
             callback_url = request_data["callback_url"]
-            
             callback_data = {
                 "job_id": job_id,
                 "status": status.value,
                 "progress": progress,
                 "message": message,
                 "story_title": request_data["story_title"],
-                "total_scenes": len(request_data["scenes"]),
-                "total_characters": len(request_data["characters"]),
-                "pipeline_type": request_data.get("pipeline_type", "standard"),
                 "timestamp": time.time(),
-                "source": "huggingface-storybook-generator"
             }
             
-            if status == JobStatus.COMPLETED and result:
-                callback_data["result"] = {
-                    "total_pages": result.get("total_pages", 0),
-                    "generation_time": result.get("generation_time", 0),
-                    "pipeline_used": result.get("pipeline_used", "standard"),
-                    "consistency_level": result.get("consistency_level", "good")
-                }
-            
             headers = {'Content-Type': 'application/json'}
             response = requests.post(callback_url, json=callback_data, headers=headers, timeout=30)
             print(f"📢 Callback sent: Status {response.status_code}")
@@ -781,60 +233,39 @@ def update_job_status(job_id: str, status: JobStatus, progress: int, message: st
     
     return True
 
-# ============================================================================
-# BACKGROUND TASKS - BOTH PIPELINES
-# ============================================================================
-
-def generate_storybook_standard(job_id: str):
-    """Original standard pipeline background task"""
+def generate_storybook_background(job_id: str):
+    """Simple background task"""
     try:
         job_data = job_storage[job_id]
         story_request_data = job_data["request"]
         story_request = StorybookRequest(**story_request_data)
-        character_templates = job_data["character_templates"]
         
-        print(f"🎬 Starting STANDARD pipeline for job {job_id}")
-        print(f"📖 Story: {story_request.story_title}")
+        print(f"🎬 Starting storybook generation for job {job_id}")
         
-        update_job_status(job_id, JobStatus.PROCESSING, 5, "Starting standard storybook generation...")
+        update_job_status(job_id, JobStatus.PROCESSING, 10, "Starting generation...")
         
         total_scenes = len(story_request.scenes)
         generated_pages = []
         start_time = time.time()
         
         for i, scene in enumerate(story_request.scenes):
-            progress = 5 + int((i / total_scenes) * 90)
-            
-            # Extract characters for this scene
-            characters_present = []
-            if hasattr(scene, 'characters_present') and scene.characters_present:
-                characters_present = scene.characters_present
-            else:
-                available_chars = [char.name for char in story_request.characters]
-                characters_present = extract_characters_from_visual(scene.visual, available_chars)
-            
-            update_job_status(
-                job_id, 
-                JobStatus.PROCESSING, 
-                progress, 
-                f"Generating page {i+1}/{total_scenes} with {len(characters_present)} characters..."
-            )
+            progress = 10 + int((i / total_scenes) * 80)
+            update_job_status(job_id, JobStatus.PROCESSING, progress, f"Generating page {i+1}/{total_scenes}...")
             
             try:
-                print(f"🖼️ Generating page {i+1} with characters: {characters_present}")
+                print(f"🖼️ Generating page {i+1}")
                 
-                # Generate consistent image
-                image = generate_consistent_image(
-                    scene.visual, 
-                    story_request.model_choice, 
-                    story_request.style,
-                    characters_present,
-                    character_templates,
-                    i + 1,
+                # Simple prompt enhancement
+                enhanced_prompt = f"children's book illustration, {scene.visual}, professional illustration, vibrant colors"
+                negative_prompt = "blurry, low quality, bad anatomy"
+                
+                image = generate_simple_image(
+                    enhanced_prompt, 
+                    negative_prompt,
                     story_request.consistency_seed
                 )
                 
-                # Save to OCI bucket
+                # Save image
                 img_bytes = io.BytesIO()
                 image.save(img_bytes, format='PNG')
                 image_url = save_to_oci_bucket(
@@ -856,9 +287,6 @@ def generate_storybook_standard(job_id: str):
                     "page_number": i + 1,
                     "image_url": image_url,
                     "text_url": text_url,
-                    "text_content": scene.text,
-                    "visual_description": scene.visual,
-                    "characters_present": characters_present
                 }
                 generated_pages.append(page_data)
                 
@@ -870,18 +298,12 @@ def generate_storybook_standard(job_id: str):
                 update_job_status(job_id, JobStatus.FAILED, 0, error_msg)
                 return
         
-        # Complete the job
         generation_time = time.time() - start_time
         
         result = {
             "story_title": story_request.story_title,
             "total_pages": total_scenes,
-            "characters_used": len(story_request.characters),
-            "generated_pages": len(generated_pages),
             "generation_time": round(generation_time, 2),
-            "folder_path": f"stories/{story_request.story_title}",
-            "pipeline_used": "standard",
-            "consistency_level": "good",
             "pages": generated_pages
         }
         
@@ -889,372 +311,48 @@ def generate_storybook_standard(job_id: str):
             job_id, 
             JobStatus.COMPLETED, 
             100, 
-            f"🎉 Standard pipeline completed! {len(generated_pages)} pages in {generation_time:.2f}s.",
-            result
-        )
-        
-        print(f"🎉 STANDARD pipeline finished for job {job_id}")
-        
-    except Exception as e:
-        error_msg = f"Standard pipeline failed: {str(e)}"
-        print(f"❌ {error_msg}")
-        update_job_status(job_id, JobStatus.FAILED, 0, error_msg)
-
-def generate_storybook_enhanced(job_id: str):
-    """Enhanced 3-stage pipeline background task"""
-    try:
-        job_data = job_storage[job_id]
-        story_request_data = job_data["request"]
-        story_request = StorybookRequest(**story_request_data)
-        
-        print(f"🎬 Starting ENHANCED 3-stage pipeline for: {story_request.story_title}")
-        print(f"👥 Characters: {len(story_request.characters)}")
-        print(f"📄 Scenes: {len(story_request.scenes)}")
-
-        # STAGE 1: Generate Characters
-        update_job_status(job_id, JobStatus.GENERATING_CHARACTERS, 10, "Generating character images...")
-        
-        character_images = {}
-        for i, character in enumerate(story_request.characters):
-            progress = 10 + int((i / len(story_request.characters)) * 30)
-            update_job_status(job_id, JobStatus.GENERATING_CHARACTERS, progress, f"Generating {character.name}...")
-            
-            try:
-                char_image = generate_character_image(
-                    character, 
-                    story_request.model_choice,
-                    story_request.style,
-                    story_request.consistency_seed
-                )
-                
-                # Save character to OCI
-                img_bytes = io.BytesIO()
-                char_image.save(img_bytes, format='PNG')
-                char_url = save_to_oci_bucket(
-                    img_bytes.getvalue(),
-                    f"character_{character.name.replace(' ', '_')}.png",
-                    story_request.story_title,
-                    "image",
-                    "characters"
-                )
-                
-                character_images[character.name] = char_image
-                print(f"✅ Saved character: {character.name}")
-                
-            except Exception as e:
-                print(f"❌ Failed to generate {character.name}: {e}")
-                raise
-        
-        # STAGE 2: Generate Backgrounds
-        update_job_status(job_id, JobStatus.GENERATING_BACKGROUNDS, 40, "Generating scene backgrounds...")
-        
-        background_images = []
-        for i, scene in enumerate(story_request.scenes):
-            progress = 40 + int((i / len(story_request.scenes)) * 30)
-            update_job_status(job_id, JobStatus.GENERATING_BACKGROUNDS, progress, f"Generating background {i+1}...")
-            
-            try:
-                bg_image = generate_scene_background(
-                    scene,
-                    story_request.model_choice,
-                    story_request.style,
-                    (story_request.consistency_seed or 42) + i + 1000
-                )
-                
-                # Save background to OCI
-                img_bytes = io.BytesIO()
-                bg_image.save(img_bytes, format='PNG')
-                bg_url = save_to_oci_bucket(
-                    img_bytes.getvalue(),
-                    f"background_scene_{i+1:03d}.png",
-                    story_request.story_title,
-                    "image",
-                    "backgrounds"
-                )
-                
-                background_images.append(bg_image)
-                print(f"✅ Saved background for scene {i+1}")
-                
-            except Exception as e:
-                print(f"❌ Failed to generate background {i+1}: {e}")
-                raise
-        
-        # STAGE 3: Compose Final Scenes
-        update_job_status(job_id, JobStatus.COMPOSING_SCENES, 70, "Composing final scenes...")
-        
-        final_pages = []
-        start_time = time.time()
-        
-        for i, (scene, background) in enumerate(zip(story_request.scenes, background_images)):
-            progress = 70 + int((i / len(story_request.scenes)) * 25)
-            update_job_status(job_id, JobStatus.COMPOSING_SCENES, progress, f"Composing scene {i+1}...")
-            
-            try:
-                # Get characters for this scene
-                scene_characters = scene.characters_present if scene.characters_present else []
-                characters_in_scene = {name: character_images[name] for name in scene_characters if name in character_images}
-                
-                # Compose final image
-                final_image = compose_with_inpainting(
-                    background,
-                    characters_in_scene,
-                    scene_characters,
-                    scene.visual
-                )
-                
-                # Save final image to OCI
-                img_bytes = io.BytesIO()
-                final_image.save(img_bytes, format='PNG')
-                final_url = save_to_oci_bucket(
-                    img_bytes.getvalue(),
-                    f"page_{i+1:03d}.png",
-                    story_request.story_title,
-                    "image",
-                    "final"
-                )
-                
-                # Save text
-                text_url = save_to_oci_bucket(
-                    scene.text.encode('utf-8'),
-                    f"page_{i+1:03d}.txt",
-                    story_request.story_title,
-                    "text",
-                    "text"
-                )
-                
-                final_pages.append({
-                    "page_number": i + 1,
-                    "image_url": final_url,
-                    "text_url": text_url,
-                    "text_content": scene.text,
-                    "characters_present": scene_characters
-                })
-                
-                print(f"✅ Composed final scene {i+1}")
-                
-            except Exception as e:
-                print(f"❌ Failed to compose scene {i+1}: {e}")
-                raise
-        
-        # Complete job
-        generation_time = time.time() - start_time
-        
-        result = {
-            "story_title": story_request.story_title,
-            "total_pages": len(final_pages),
-            "characters_generated": len(character_images),
-            "backgrounds_generated": len(background_images),
-            "final_pages": len(final_pages),
-            "generation_time": round(generation_time, 2),
-            "pipeline_used": "enhanced",
-            "consistency_level": "perfect",
-            "folder_structure": {
-                "characters": f"stories/{story_request.story_title}/characters/",
-                "backgrounds": f"stories/{story_request.story_title}/backgrounds/", 
-                "final": f"stories/{story_request.story_title}/final/",
-                "text": f"stories/{story_request.story_title}/text/"
-            },
-            "pages": final_pages
-        }
-        
-        update_job_status(
-            job_id, 
-            JobStatus.COMPLETED, 
-            100, 
-            f"🎉 Enhanced pipeline complete! {len(final_pages)} pages with perfect consistency in {generation_time:.2f}s",
+            f"🎉 Storybook completed! {len(generated_pages)} pages in {generation_time:.2f}s.",
             result
         )
         
-        print(f"🎉 ENHANCED pipeline completed for job {job_id}")
+        print(f"🎉 Storybook finished for job {job_id}")
         
     except Exception as e:
-        error_msg = f"Enhanced pipeline failed: {str(e)}"
+        error_msg = f"Story generation failed: {str(e)}"
         print(f"❌ {error_msg}")
         update_job_status(job_id, JobStatus.FAILED, 0, error_msg)
 
-def generate_storybook_dispatcher(job_id: str):
-    """Choose between standard or enhanced pipeline"""
-    job_data = job_storage[job_id]
-    story_request_data = job_data["request"]
-    
-    pipeline_type = story_request_data.get("pipeline_type", "standard")
-    
-    if pipeline_type == "enhanced":
-        generate_storybook_enhanced(job_id)
-    else:
-        generate_storybook_standard(job_id)
-
-# ============================================================================
-# LOCAL FILE MANAGEMENT FUNCTIONS
-# ============================================================================
-
-def save_image_to_local(image, prompt, style="test"):
-    """Save image to local persistent storage"""
-    try:
-        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-        safe_prompt = "".join(c for c in prompt[:50] if c.isalnum() or c in (' ', '-', '_')).rstrip()
-        filename = f"image_{safe_prompt}_{timestamp}.png"
-        
-        # Create style subfolder
-        style_dir = os.path.join(PERSISTENT_IMAGE_DIR, style)
-        os.makedirs(style_dir, exist_ok=True)
-        filepath = os.path.join(style_dir, filename)
-        
-        # Save the image
-        image.save(filepath)
-        print(f"💾 Image saved locally: {filepath}")
-        
-        return filepath, filename
-        
-    except Exception as e:
-        print(f"❌ Failed to save locally: {e}")
-        return None, None
-
-def delete_local_image(filepath):
-    """Delete an image from local storage"""
-    try:
-        if os.path.exists(filepath):
-            os.remove(filepath)
-            print(f"🗑️ Deleted local image: {filepath}")
-            return True, f"✅ Deleted: {os.path.basename(filepath)}"
-        else:
-            return False, f"❌ File not found: {filepath}"
-    except Exception as e:
-        return False, f"❌ Error deleting: {str(e)}"
-
-def get_local_storage_info():
-    """Get information about local storage usage"""
-    try:
-        total_size = 0
-        file_count = 0
-        images_list = []
-        
-        for root, dirs, files in os.walk(PERSISTENT_IMAGE_DIR):
-            for file in files:
-                if file.endswith(('.png', '.jpg', '.jpeg')):
-                    filepath = os.path.join(root, file)
-                    if os.path.exists(filepath):
-                        file_size = os.path.getsize(filepath)
-                        total_size += file_size
-                        file_count += 1
-                        images_list.append({
-                            'path': filepath,
-                            'filename': file,
-                            'size_kb': round(file_size / 1024, 1),
-                            'created': os.path.getctime(filepath)
-                        })
-        
-        return {
-            "total_files": file_count,
-            "total_size_mb": round(total_size / (1024 * 1024), 2),
-            "images": sorted(images_list, key=lambda x: x['created'], reverse=True)
-        }
-    except Exception as e:
-        return {"error": str(e)}
-
-def refresh_local_images():
-    """Get list of all locally saved images"""
-    try:
-        image_files = []
-        for root, dirs, files in os.walk(PERSISTENT_IMAGE_DIR):
-            for file in files:
-                if file.endswith(('.png', '.jpg', '.jpeg')):
-                    filepath = os.path.join(root, file)
-                    if os.path.exists(filepath):
-                        image_files.append(filepath)
-        return image_files
-    except Exception as e:
-        print(f"Error refreshing local images: {e}")
-        return []
-
-def delete_current_image(filepath):
-    """Delete the currently displayed image"""
-    if not filepath:
-        return "❌ No image to delete", None, None, refresh_local_images()
-    
-    success, message = delete_local_image(filepath)
-    updated_files = refresh_local_images()
-    
-    if success:
-        status_msg = f"✅ {message}"
-        return status_msg, None, "Image deleted successfully!", updated_files
-    else:
-        return f"❌ {message}", None, "Delete failed", updated_files
-
-def clear_all_images():
-    """Delete all local images"""
-    try:
-        storage_info = get_local_storage_info()
-        deleted_count = 0
-        
-        if "images" in storage_info:
-            for image_info in storage_info["images"]:
-                success, _ = delete_local_image(image_info["path"])
-                if success:
-                    deleted_count += 1
-        
-        updated_files = refresh_local_images()
-        return f"✅ Deleted {deleted_count} images", updated_files
-    except Exception as e:
-        return f"❌ Error: {str(e)}", refresh_local_images()
-
-# ============================================================================
-# FASTAPI ENDPOINTS
-# ============================================================================
-
 @app.post("/api/generate-storybook")
-async def generate_storybook_unified(request: dict, background_tasks: BackgroundTasks):
-    """Unified endpoint that handles both pipelines"""
+async def generate_storybook(request: dict, background_tasks: BackgroundTasks):
+    """Simple storybook generation endpoint"""
     try:
         print(f"📥 Received storybook request: {request.get('story_title', 'Unknown')}")
         
-        # Add consistency seed if not provided
         if 'consistency_seed' not in request or not request['consistency_seed']:
             request['consistency_seed'] = random.randint(1000, 9999)
-            print(f"🌱 Generated consistency seed: {request['consistency_seed']}")
         
-        # Ensure characters have required fields
-        if 'characters' in request:
-            for char in request['characters']:
-                if 'visual_prompt' not in char or not char['visual_prompt']:
-                    char['visual_prompt'] = ""
-                if 'key_features' not in char:
-                    char['key_features'] = []
+        # Force to working model
+        request['model_choice'] = "sd-1.5"
         
-        # Convert to Pydantic model
         story_request = StorybookRequest(**request)
         
-        # Validate required fields
         if not story_request.story_title or not story_request.scenes:
             raise HTTPException(status_code=400, detail="story_title and scenes are required")
         
-        # Create job
         job_id = create_job(story_request)
-        
-        # Start background processing
-        background_tasks.add_task(generate_storybook_dispatcher, job_id)
-        
-        # Immediate response
-        pipeline_type = story_request.pipeline_type
-        estimated_time = "2-3 minutes" if pipeline_type == "standard" else "5-8 minutes"
-        consistency_level = "good" if pipeline_type == "standard" else "perfect"
+        background_tasks.add_task(generate_storybook_background, job_id)
         
         response_data = {
             "status": "success",
-            "message": f"Storybook generation started with {pipeline_type} pipeline",
+            "message": "Storybook generation started successfully",
             "job_id": job_id,
             "story_title": story_request.story_title,
             "total_scenes": len(story_request.scenes),
-            "total_characters": len(story_request.characters),
-            "pipeline_type": pipeline_type,
-            "estimated_time": estimated_time,
-            "expected_consistency": consistency_level,
-            "consistency_seed": story_request.consistency_seed,
-            "callback_url": story_request.callback_url,
+            "model_used": "sd-1.5",
             "timestamp": datetime.now().isoformat()
         }
         
-        print(f"✅ Job {job_id} started with {pipeline_type} pipeline")
+        print(f"✅ Job {job_id} started")
         
         return response_data
         
@@ -1265,7 +363,6 @@ async def generate_storybook_unified(request: dict, background_tasks: Background
 
 @app.get("/api/job-status/{job_id}")
 async def get_job_status_endpoint(job_id: str):
-    """Check job status"""
     job_data = job_storage.get(job_id)
     if not job_data:
         raise HTTPException(status_code=404, detail="Job not found")
@@ -1282,364 +379,49 @@ async def get_job_status_endpoint(job_id: str):
 
 @app.get("/api/health")
 async def api_health():
-    """Health check endpoint for n8n"""
     return {
         "status": "healthy",
-        "service": "dual-pipeline-storybook-generator",
+        "service": "storybook-generator",
         "timestamp": datetime.now().isoformat(),
         "active_jobs": len(job_storage),
-        "models_loaded": list(model_cache.keys()),
-        "inpaint_model_ready": inpaint_pipe is not None,
-        "pipelines_available": ["standard", "enhanced"],
-        "fallback_templates": list(FALLBACK_CHARACTER_TEMPLATES.keys()),
+        "model_loaded": "sd-1.5" in model_cache,
         "oci_api_connected": OCI_API_BASE_URL
     }
 
-@app.get("/api/system-status")
-async def system_status():
-    """Comprehensive system status"""
-    active_jobs = len([job for job in job_storage.values() if job["status"] in ["processing", "pending"]])
-    
-    return {
-        "status": "healthy",
-        "active_jobs": active_jobs,
-        "models_loaded": list(model_cache.keys()),
-        "inpaint_ready": inpaint_pipe is not None,
-        "pipelines_available": ["standard", "enhanced"],
-        "storage_available": True,
-        "timestamp": datetime.now().isoformat()
-    }
-
-@app.get("/api/local-images")
-async def get_local_images():
-    """API endpoint to get locally saved test images"""
-    storage_info = get_local_storage_info()
-    return storage_info
-
-@app.delete("/api/local-images/{filename:path}")
-async def delete_local_image_api(filename: str):
-    """API endpoint to delete a local image"""
-    try:
-        filepath = os.path.join(PERSISTENT_IMAGE_DIR, filename)
-        success, message = delete_local_image(filepath)
-        return {"status": "success" if success else "error", "message": message}
-    except Exception as e:
-        return {"status": "error", "message": str(e)}
-
-# ============================================================================
-# GRADIO INTERFACE
-# ============================================================================
-
-def create_dual_pipeline_gradio_interface():
-    """Create Gradio interface with both pipeline options"""
-    
-    def generate_test_image(prompt, model_choice, style_choice, pipeline_type, character_names_text):
-        """Generate a single image for testing"""
-        try:
-            if not prompt.strip():
-                return None, "❌ Please enter a prompt", None
-            
-            # Parse character names
-            character_names = [name.strip() for name in character_names_text.split(",") if name.strip()]
-            
-            print(f"🎨 Generating test image with {pipeline_type} pipeline")
-            print(f"👥 Character names: {character_names}")
-            
-            if pipeline_type == "enhanced" and character_names:
-                # Test enhanced pipeline with character generation
-                character_templates = {}
-                for char_name in character_names:
-                    character_templates[char_name] = {
-                        "visual_prompt": f"{char_name}, distinctive appearance",
-                        "key_features": ["consistent appearance"],
-                        "consistency_keywords": f"consistent {char_name}"
-                    }
-                
-                # For testing, we'll just use the standard generation
-                enhanced_prompt, negative_prompt = enhance_prompt_with_characters(
-                    prompt, character_names, character_templates, style_choice, 1
-                )
-                
-                image = generate_consistent_image(
-                    prompt, 
-                    model_choice, 
-                    style_choice,
-                    character_names,
-                    character_templates,
-                    1
-                )
-            else:
-                # Standard generation
-                pipe = load_model(model_choice)
-                if pipe is None:
-                    return None, "❌ Model not available", None
-                
-                image = pipe(
-                    prompt=prompt,
-                    num_inference_steps=30,
-                    guidance_scale=7.5,
-                    width=768,
-                    height=768,
-                ).images[0]
-            
-            # Save to local storage
-            filepath, filename = save_image_to_local(image, prompt, style_choice)
-            
-            character_info = f"👥 Characters: {', '.join(character_names)}" if character_names else "👥 No specific characters"
-            pipeline_info = f"🚀 Pipeline: {pipeline_type.upper()}"
-            
-            status_msg = f"""✅ Success! Generated: {prompt}
-
-{character_info}
-{pipeline_info}
-
-📁 **Local file:** {filename if filename else 'Not saved'}"""
-            
-            return image, status_msg, filepath
-            
-        except Exception as e:
-            error_msg = f"❌ Generation failed: {str(e)}"
-            print(error_msg)
-            return None, error_msg, None
-    
-    with gr.Blocks(title="Dual-Pipeline Storybook Generator", theme="soft") as demo:
-        gr.Markdown("# 🎨 Dual-Pipeline Storybook Generator")
-        gr.Markdown("Choose between **Standard** (fast) or **Enhanced** (perfect consistency) pipeline")
-        
-        # Storage info display
-        storage_info = gr.Textbox(
-            label="📊 Local Storage Information",
-            interactive=False,
-            lines=2
-        )
-        
-        def update_storage_info():
-            info = get_local_storage_info()
-            if "error" not in info:
-                return f"📁 Local Storage: {info['total_files']} images, {info['total_size_mb']} MB used"
-            return "📁 Local Storage: Unable to calculate"
+# Simple Gradio interface
+def create_simple_interface():
+    with gr.Blocks() as demo:
+        gr.Markdown("# Storybook Generator")
         
         with gr.Row():
-            with gr.Column(scale=1):
-                gr.Markdown("### ⚙️ Pipeline Selection")
-                
-                pipeline_radio = gr.Radio(
-                    choices=["standard", "enhanced"],
-                    value="standard",
-                    label="Generation Pipeline",
-                    info="Standard: Faster | Enhanced: Perfect character consistency"
-                )
-                
-                gr.Markdown("#### 🚀 Standard Pipeline")
-                gr.Markdown("- Faster generation (2-3 minutes)")
-                gr.Markdown("- Good character consistency")
-                gr.Markdown("- Single-pass generation")
-                
-                gr.Markdown("#### 🎯 Enhanced Pipeline") 
-                gr.Markdown("- Perfect character consistency")
-                gr.Markdown("- Better prompt understanding")
-                gr.Markdown("- 3-stage process (5-8 minutes)")
-                
-                gr.Markdown("### 🎯 Quality Settings")
-                
-                model_dropdown = gr.Dropdown(
-                    label="AI Model",
-                    choices=list(MODEL_CHOICES.keys()),
-                    value="dreamshaper-8"
-                )
-                
-                style_dropdown = gr.Dropdown(
-                    label="Art Style",
-                    choices=["childrens_book", "realistic", "fantasy", "anime"],
-                    value="childrens_book"
-                )
-                
-                character_names_input = gr.Textbox(
-                    label="Character Names (comma-separated)",
-                    placeholder="Enter character names: Sparkle the Star Cat, Benny the Bunny, Tilly the Turtle",
-                    info="Enter character names to test consistency features",
-                    lines=2
-                )
-                
-                prompt_input = gr.Textbox(
-                    label="Scene Description",
-                    placeholder="Describe your scene with character interactions...",
-                    lines=3
-                )
-                
-                generate_btn = gr.Button("✨ Generate Test Image", variant="primary")
-                
-                # Current image management
-                current_file_path = gr.State()
-                delete_btn = gr.Button("🗑️ Delete This Image", variant="stop")
-                delete_status = gr.Textbox(label="Delete Status", interactive=False, lines=2)
-                
-            with gr.Column(scale=2):
-                image_output = gr.Image(label="Generated Image", height=500, show_download_button=True)
-                status_output = gr.Textbox(label="Status", interactive=False, lines=4)
-        
-        # Pipeline comparison section
-        with gr.Accordion("📊 Pipeline Comparison", open=False):
-            gr.Markdown("""
-            | Feature | Standard Pipeline | Enhanced Pipeline |
-            |---------|-------------------|-------------------|
-            | **Speed** | 🚀 Fast (2-3 min) | 🐢 Slower (5-8 min) |
-            | **Consistency** | ✅ Good (80-90%) | 🎯 Perfect (100%) |
-            | **Prompt Understanding** | 👍 Good | 🎨 Excellent |
-            | **Best For** | Quick stories, testing | Final production, critical stories |
-            | **Storage** | Single folder | Organized subfolders |
-            """)
-
-        # API usage section
-        with gr.Accordion("📚 API Usage for n8n", open=False):
-            gr.Markdown("""
-            **For complete storybooks (OCI bucket):**
-            - Endpoint: `POST /api/generate-storybook`
-            - Add `"pipeline_type": "enhanced"` for perfect consistency
-            - Add `"pipeline_type": "standard"` for faster generation
-            
-            **Example Enhanced Pipeline Payload:**
-            ```json
-            {
-              "story_title": "Magical Adventure",
-              "pipeline_type": "enhanced",
-              "characters": [
-                {
-                  "name": "Sparkle the Star Cat",
-                  "description": "A magical kitten with star-shaped spots"
-                }
-              ],
-              "scenes": [
-                {
-                  "visual": "Sparkle discovering a magical portal",
-                  "text": "Once upon a time...",
-                  "characters_present": ["Sparkle the Star Cat"]
-                }
-              ]
-            }
-            ```
-            """)
-        
-        # Local file management section
-        with gr.Accordion("📁 Manage Local Test Images", open=True):
-            gr.Markdown("### Locally Saved Images")
-            
-            with gr.Row():
-                refresh_btn = gr.Button("🔄 Refresh List")
-                clear_all_btn = gr.Button("🗑️ Clear All Images", variant="stop")
-            
-            file_gallery = gr.Gallery(
-                label="Local Images",
-                show_label=True,
-                elem_id="gallery",
-                columns=4,
-                height="auto"
-            )
-            
-            clear_status = gr.Textbox(label="Clear Status", interactive=False)
-        
-        # System status section
-        with gr.Accordion("🔧 System Status", open=False):
-            debug_btn = gr.Button("🔄 Check System Status", variant="secondary")
-            debug_output = gr.Textbox(label="System Info", interactive=False, lines=4)
-        
-        def check_system_status():
-            """Check system status"""
-            active_jobs = len(job_storage)
-            return f"""**System Status:**
-- Model: {current_model_name}
-- Pipelines: Standard ✅ | Enhanced ✅
-- Inpainting Model: {"✅ Ready" if inpaint_pipe else "❌ Not available"}
-- Local Storage: {get_local_storage_info().get('total_files', 0)} images
-- Active Jobs: {active_jobs}
-- Ready for dual-pipeline generation!"""
-
-        # Connect buttons to functions
-        generate_btn.click(
-            fn=generate_test_image,
-            inputs=[prompt_input, model_dropdown, style_dropdown, pipeline_radio, character_names_input],
-            outputs=[image_output, status_output, current_file_path]
-        ).then(
-            fn=refresh_local_images,
-            outputs=file_gallery
-        ).then(
-            fn=update_storage_info,
-            outputs=storage_info
-        )
-        
-        delete_btn.click(
-            fn=delete_current_image,
-            inputs=current_file_path,
-            outputs=[delete_status, image_output, status_output, file_gallery]
-        ).then(
-            fn=update_storage_info,
-            outputs=storage_info
-        )
+            with gr.Column():
+                prompt = gr.Textbox(label="Test Prompt", value="a cute cartoon cat in a garden")
+                generate_btn = gr.Button("Test Generate")
+            with gr.Column():
+                output = gr.Image(label="Generated Image")
         
-        refresh_btn.click(
-            fn=refresh_local_images,
-            outputs=file_gallery
-        ).then(
-            fn=update_storage_info,
-            outputs=storage_info
-        )
-        
-        clear_all_btn.click(
-            fn=clear_all_images,
-            outputs=[clear_status, file_gallery]
-        ).then(
-            fn=update_storage_info,
-            outputs=storage_info
-        )
-        
-        debug_btn.click(
-            fn=check_system_status,
-            inputs=None,
-            outputs=debug_output
-        )
+        def test_generate(prompt_text):
+            try:
+                image = generate_simple_image(prompt_text)
+                return image
+            except Exception as e:
+                print(f"Test generation failed: {e}")
+                return None
         
-        # Initialize on load
-        demo.load(fn=refresh_local_images, outputs=file_gallery)
-        demo.load(fn=update_storage_info, outputs=storage_info)
+        generate_btn.click(test_generate, inputs=prompt, outputs=output)
     
     return demo
 
-# Create enhanced Gradio app
-demo = create_dual_pipeline_gradio_interface()
+demo = create_simple_interface()
 
-# Enhanced root endpoint
 @app.get("/")
 async def root():
     return {
-        "message": "Dual-Pipeline Storybook Generator API is running!",
-        "pipelines": {
-            "standard": "Fast generation with good consistency",
-            "enhanced": "Slower generation with perfect consistency"
-        },
-        "api_endpoints": {
-            "generate_storybook": "POST /api/generate-storybook",
-            "job_status": "GET /api/job-status/{job_id}",
-            "health": "GET /api/health",
-            "system_status": "GET /api/system-status"
-        },
-        "web_interface": "GET /ui",
-        "note": "Add 'pipeline_type': 'enhanced' to your request for perfect character consistency"
+        "message": "Storybook Generator API is running!",
+        "model": "sd-1.5",
+        "status": "ready"
     }
 
-# Add a test endpoint
-@app.get("/api/test")
-async def test_endpoint():
-    return {
-        "status": "success", 
-        "message": "Dual-pipeline API is working correctly",
-        "pipelines": {
-            "standard": "✅ Available",
-            "enhanced": "✅ Available" 
-        },
-        "timestamp": datetime.now().isoformat()
-    }
-
-# For Hugging Face Spaces deployment
 def get_app():
     return app
 
@@ -1647,66 +429,12 @@ if __name__ == "__main__":
     import uvicorn
     import os
     
-    # Check if we're running on Hugging Face Spaces
     HF_SPACE = os.environ.get('SPACE_ID') is not None
     
     if HF_SPACE:
-        print("🚀 Running on Hugging Face Spaces - Integrated Mode")
-        print("📚 API endpoints available at: /api/*")
-        print("🎨 Web interface available at: /ui")
-        print("🔧 Dual-pipeline system: Standard ✅ | Enhanced ✅")
-        print("👥 Perfect character consistency available with enhanced pipeline")
-        
-        # Mount Gradio without reassigning app
+        print("🚀 Running on Hugging Face Spaces")
         gr.mount_gradio_app(app, demo, path="/ui")
-        
-        # Run the combined app
-        uvicorn.run(
-            app, 
-            host="0.0.0.0", 
-            port=7860, 
-            log_level="info"
-        )
+        uvicorn.run(app, host="0.0.0.0", port=7860, log_level="info")
     else:
-        # Local development - run separate servers
-        print("🚀 Running locally - Separate API and UI servers")
-        print("📚 API endpoints: http://localhost:8000/api/*")
-        print("🎨 Web interface: http://localhost:7860/ui")
-        print("🔧 Dual-pipeline system: Standard ✅ | Enhanced ✅")
-        
-        def run_fastapi():
-            """Run FastAPI on port 8000 for API calls"""
-            uvicorn.run(
-                app, 
-                host="0.0.0.0", 
-                port=8000, 
-                log_level="info",
-                access_log=False
-            )
-        
-        def run_gradio():
-            """Run Gradio on port 7860 for web interface"""
-            demo.launch(
-                server_name="0.0.0.0",
-                server_port=7860,
-                share=False,
-                show_error=True,
-                quiet=True
-            )
-        
-        # Start both servers in separate threads
-        api_thread = threading.Thread(target=run_fastapi, daemon=True)
-        ui_thread = threading.Thread(target=run_gradio, daemon=True)
-        
-        api_thread.start()
-        print("✅ FastAPI server started on port 8000")
-        
-        ui_thread.start()
-        print("✅ Gradio server started on port 7860")
-        
-        # Keep the main thread alive
-        try:
-            while True:
-                time.sleep(1)
-        except KeyboardInterrupt:
-            print("🛑 Shutting down servers...")
+        print("🚀 Running locally")
+        uvicorn.run(app, host="0.0.0.0", port=8000, log_level="info")