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,7 +9,7 @@ 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
@@ -19,7 +19,6 @@ import uuid
 import hashlib
 from enum import Enum
 import random
-import numpy as np
 
 # External OCI API URL - YOUR BUCKET SAVING API
 OCI_API_BASE_URL = "https://yukee1992-oci-story-book.hf.space"
@@ -30,7 +29,7 @@ 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
@@ -45,9 +44,6 @@ app.add_middleware(
 # 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"
@@ -56,26 +52,23 @@ class JobStatus(str, Enum):
 class StoryScene(BaseModel):
     visual: str
     text: str
-    characters_present: List[str] = []
-    scene_type: str = "general"
-    background_context: str = ""
+    characters_present: List[str] = []  # Which characters are in this scene
+    scene_type: str = "general"  # "action", "dialogue", "establishing", etc.
 
 class CharacterDescription(BaseModel):
     name: str
     description: str
-    visual_prompt: str = ""
-    key_features: List[str] = []
-    pose_reference: str = "standing naturally"
+    visual_prompt: str = ""  # Detailed visual description for AI
+    key_features: List[str] = []  # Critical features that must stay consistent
 
 class StorybookRequest(BaseModel):
     story_title: str
     scenes: List[StoryScene]
     characters: List[CharacterDescription] = []
-    model_choice: str = "sd-1.5"  # CHANGED: Default to working model
+    model_choice: str = "dreamshaper-8"
     style: str = "childrens_book"
     callback_url: Optional[str] = None
-    consistency_seed: Optional[int] = None
-    pipeline_type: str = "standard"
+    consistency_seed: Optional[int] = None  # For consistent character generation
 
 class JobStatusResponse(BaseModel):
     job_id: str
@@ -86,14 +79,16 @@ class JobStatusResponse(BaseModel):
     created_at: float
     updated_at: float
 
-# UPDATED MODEL CHOICES - Only use working models
+# HIGH-QUALITY MODEL SELECTION
 MODEL_CHOICES = {
-    "sd-1.5": "runwayml/stable-diffusion-v1-5",  # Most reliable
-    "openjourney": "prompthero/openjourney",     # Public & free
-    "sd-2.1": "stabilityai/stable-diffusion-2-1", # Public alternative
+    "dreamshaper-8": "lykon/dreamshaper-8",
+    "realistic-vision": "SG161222/Realistic_Vision_V5.1",
+    "anything-v5": "andite/anything-v5.0",
+    "openjourney": "prompthero/openjourney",
+    "sd-2.1": "stabilityai/stable-diffusion-2-1",
 }
 
-# FALLBACK CHARACTER TEMPLATES
+# FALLBACK CHARACTER TEMPLATES (used only if n8n doesn't provide character details)
 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",
@@ -102,20 +97,22 @@ FALLBACK_CHARACTER_TEMPLATES = {
     "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()
 
-# FIXED MODEL LOADING - With fallback like old script
-def load_model(model_name="sd-1.5"):
-    """Thread-safe model loading with FALLBACK like old working script"""
+def load_model(model_name="dreamshaper-8"):
+    """Thread-safe model loading with HIGH-QUALITY settings"""
     global model_cache, current_model_name, current_pipe
     
     with model_lock:
@@ -124,9 +121,9 @@ def load_model(model_name="sd-1.5"):
             current_model_name = model_name
             return current_pipe
         
-        print(f"🔄 Loading model: {model_name}")
+        print(f"🔄 Loading HIGH-QUALITY model: {model_name}")
         try:
-            model_id = MODEL_CHOICES.get(model_name, "runwayml/stable-diffusion-v1-5")
+            model_id = MODEL_CHOICES.get(model_name, "lykon/dreamshaper-8")
             
             pipe = StableDiffusionPipeline.from_pretrained(
                 model_id, 
@@ -142,57 +139,24 @@ def load_model(model_name="sd-1.5"):
             current_pipe = pipe
             current_model_name = model_name
             
-            print(f"✅ Model loaded: {model_name}")
+            print(f"✅ HIGH-QUALITY Model loaded: {model_name}")
             return pipe
             
         except Exception as e:
             print(f"❌ Model loading failed: {e}")
-            # FALLBACK TO SD 1.5 LIKE OLD SCRIPT
-            print("🔄 Falling back to stable-diffusion-v1-5")
-            try:
-                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
-            except Exception as fallback_error:
-                print(f"❌ Fallback model also failed: {fallback_error}")
-                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("sd-1.5")  # CHANGED: Initialize with working model
-print("✅ Models loaded and ready!")
+            return StableDiffusionPipeline.from_pretrained(
+                "runwayml/stable-diffusion-v1-5", 
+                torch_dtype=torch.float32,
+                safety_checker=None,
+                requires_safety_checker=False
+            ).to("cpu")
 
-# ============================================================================
-# CHARACTER PROCESSING FUNCTIONS (from old script - working)
-# ============================================================================
+# Initialize default model
+print("🚀 Initializing Storybook Generator API...")
+load_model("dreamshaper-8")
+print("✅ Model loaded and ready!")
 
+# DYNAMIC CHARACTER PROCESSING FUNCTIONS
 def process_character_descriptions(characters_from_request):
     """Process character descriptions from n8n and create consistency templates"""
     character_templates = {}
@@ -200,11 +164,14 @@ def process_character_descriptions(characters_from_request):
     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:
@@ -214,7 +181,7 @@ def process_character_descriptions(characters_from_request):
             "visual_prompt": visual_prompt,
             "key_features": key_features,
             "consistency_keywords": f"consistent character, same {char_name.split()[-1].lower()}, maintaining appearance",
-            "source": "n8n_request"
+            "source": "n8n_request"  # Track where this template came from
         }
     
     print(f"✅ Processed {len(character_templates)} characters from n8n request")
@@ -222,8 +189,10 @@ def process_character_descriptions(characters_from_request):
 
 def generate_visual_prompt_from_description(description, character_name):
     """Generate a visual prompt from character description"""
+    # Basic extraction of visual elements
     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:
@@ -231,18 +200,21 @@ def generate_visual_prompt_from_description(description, character_name):
             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}")
@@ -254,6 +226,7 @@ def generate_visual_prompt_from_description(description, 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:
@@ -269,6 +242,7 @@ def extract_key_features_from_description(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)",
@@ -280,8 +254,10 @@ def extract_key_features_from_description(description):
         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"]
@@ -295,25 +271,11 @@ def extract_key_features_from_description(description):
     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()
-    
-    for char_name in available_characters:
-        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
-
-# ============================================================================
-# STANDARD PIPELINE FUNCTIONS (from old script - working)
-# ============================================================================
-
+# ENHANCED PROMPT ENGINEERING WITH DYNAMIC CHARACTER CONSISTENCY
 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 = []
     
@@ -323,9 +285,11 @@ def enhance_prompt_with_characters(scene_visual, characters_present, character_t
             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",
@@ -335,6 +299,7 @@ def enhance_prompt_with_characters(scene_visual, characters_present, character_t
     
     style_prompt = style_templates.get(style, style_templates["childrens_book"])
     
+    # Build the enhanced prompt
     character_context = ". ".join(character_descriptions)
     consistency_context = ", ".join(consistency_keywords)
     
@@ -345,6 +310,7 @@ def enhance_prompt_with_characters(scene_visual, characters_present, character_t
         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",
@@ -354,6 +320,7 @@ def enhance_prompt_with_characters(scene_visual, characters_present, character_t
     
     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, "
@@ -363,30 +330,60 @@ def enhance_prompt_with_characters(scene_visual, characters_present, character_t
     
     return enhanced_prompt, negative_prompt
 
+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
+
 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,
+            num_inference_steps=35,  # Increased for better quality
+            guidance_scale=7.5,      # Slightly lower for more consistency
             width=768,
             height=768,
             generator=torch.Generator(device="cpu").manual_seed(scene_seed)
@@ -402,447 +399,122 @@ def generate_consistent_image(prompt, model_choice, style, characters_present, c
         print(f"❌ Consistent generation failed: {str(e)}")
         raise
 
-# ============================================================================
-# SIMPLIFIED ENHANCED PIPELINE (Basic composition without complex models)
-# ============================================================================
+# Backward compatibility functions
+def enhance_prompt(prompt, style="childrens_book"):
+    """Legacy function for backward compatibility"""
+    return enhance_prompt_with_characters(prompt, [], {}, style, 1)
 
-def generate_character_image(character: CharacterDescription, model_choice: str, style: str, seed: int = None) -> Image.Image:
-    """Generate a single character with simple background"""
-    
-    character_prompt = f"{character.visual_prompt or character.description}, {character.pose_reference}, full body character, children's book character design"
-    
-    character_prompt = re.sub(r'\s+', ' ', character_prompt).strip()
-    
-    negative_prompt = "background, scenery, environment, other characters, blurry, low quality"
-    
-    pipe = load_model(model_choice)
-    if pipe is None:
-        raise Exception("Model not available")
-    
-    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=25,  # Reduced for speed
-        guidance_scale=7.0,
-        width=512,
-        height=768,
-        generator=generator
-    ).images[0]
-    
-    print(f"✅ Generated character: {character.name}")
-    return image
+def generate_high_quality_image(prompt, model_choice="dreamshaper-8", style="childrens_book", negative_prompt=""):
+    """Legacy function for backward compatibility"""
+    return generate_consistent_image(prompt, model_choice, style, [], {}, 1)
 
-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, background environment, children's book background"
-    
-    background_prompt = re.sub(r'\s+', ' ', background_prompt).strip()
-    
-    negative_prompt = "characters, people, animals, person, human, animal, blurry, low quality"
-    
-    pipe = load_model(model_choice)
-    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)
-    
-    image = pipe(
-        prompt=background_prompt,
-        negative_prompt=negative_prompt,
-        num_inference_steps=25,  # Reduced for speed
-        guidance_scale=7.0,
-        width=768,
-        height=768,
-        generator=generator
-    ).images[0]
-    
-    print(f"✅ Generated background for scene")
-    return image
-
-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"""
-    
-    final_image = background.copy()
-    
-    # Simple positioning
-    positions = []
-    num_chars = len(characters_present)
-    
-    if num_chars == 1:
-        positions.append((284, 300, 200, 300))  # Center
-    elif num_chars == 2:
-        positions.extend([(184, 300, 200, 300), (484, 300, 200, 300)])  # Left & right
-    else:
-        for i in range(num_chars):
-            x = 150 + (i % 3) * 200
-            y = 250 + (i // 3) * 200
-            positions.append((x, y, 180, 270))
-    
-    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]
-        
-        char_resized = char_image.resize((width, height))
-        final_image.paste(char_resized, (x, y), char_resized)
-    
-    return final_image
-
-# ============================================================================
-# OCI BUCKET FUNCTIONS (from old script)
-# ============================================================================
-
-def save_to_oci_bucket(file_data, filename, story_title, file_type="image", subfolder=""):
-    """Save files to OCI bucket"""
+# LOCAL FILE MANAGEMENT FUNCTIONS
+def save_image_to_local(image, prompt, style="test"):
+    """Save image to local persistent storage"""
     try:
-        api_url = f"{OCI_API_BASE_URL}/api/upload"
+        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"
         
-        if subfolder:
-            full_subfolder = f'stories/{story_title}/{subfolder}'
-        else:
-            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 = {
-            'project_id': 'storybook-library',
-            'subfolder': full_subfolder
-        }
+        # 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)
         
-        response = requests.post(api_url, files=files, data=data, timeout=30)
+        # Save the image
+        image.save(filepath)
+        print(f"💾 Image saved locally: {filepath}")
         
-        print(f"📨 OCI API Response: {response.status_code}")
+        return filepath, filename
         
-        if response.status_code == 200:
-            result = response.json()
-            if result['status'] == 'success':
-                return result.get('file_url', 'Unknown URL')
-            else:
-                raise Exception(f"OCI API Error: {result.get('message', 'Unknown error')}")
-        else:
-            raise Exception(f"HTTP Error: {response.status_code}")
-            
     except Exception as e:
-        raise Exception(f"OCI upload failed: {str(e)}")
-
-# ============================================================================
-# JOB MANAGEMENT (from old script with enhancements)
-# ============================================================================
-
-def create_job(story_request: StorybookRequest) -> str:
-    job_id = str(uuid.uuid4())
-    
-    character_templates = process_character_descriptions(story_request.characters)
-    
-    job_storage[job_id] = {
-        "status": JobStatus.PENDING,
-        "progress": 0,
-        "message": "Job created and queued",
-        "request": story_request.dict(),
-        "result": None,
-        "created_at": time.time(),
-        "updated_at": time.time(),
-        "pages": [],
-        "character_templates": character_templates,
-    }
-    
-    print(f"📝 Created job {job_id} for story: {story_request.story_title}")
-    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):
-    if job_id not in job_storage:
-        return False
-    
-    job_storage[job_id].update({
-        "status": status,
-        "progress": progress,
-        "message": message,
-        "updated_at": time.time()
-    })
-    
-    if result:
-        job_storage[job_id]["result"] = result
-    
-    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(),
-            }
-            
-            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}")
-                
-        except Exception as e:
-            print(f"⚠️ Callback failed: {str(e)}")
-    
-    return True
+        print(f"❌ Failed to save locally: {e}")
+        return None, None
 
-# ============================================================================
-# BACKGROUND TASKS - SIMPLIFIED
-# ============================================================================
+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 generate_storybook_standard(job_id: str):
-    """Standard pipeline background task"""
+def get_local_storage_info():
+    """Get information about local storage usage"""
     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}")
-        
-        update_job_status(job_id, JobStatus.PROCESSING, 5, "Starting storybook 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)
-            
-            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}..."
-            )
-            
-            try:
-                print(f"🖼️ Generating page {i+1}")
-                
-                image = generate_consistent_image(
-                    scene.visual, 
-                    story_request.model_choice, 
-                    story_request.style,
-                    characters_present,
-                    character_templates,
-                    i + 1,
-                    story_request.consistency_seed
-                )
-                
-                img_bytes = io.BytesIO()
-                image.save(img_bytes, format='PNG')
-                image_url = save_to_oci_bucket(
-                    img_bytes.getvalue(),
-                    f"page_{i+1:03d}.png",
-                    story_request.story_title,
-                    "image"
-                )
-                
-                text_url = save_to_oci_bucket(
-                    scene.text.encode('utf-8'),
-                    f"page_{i+1:03d}.txt",
-                    story_request.story_title,
-                    "text"
-                )
-                
-                page_data = {
-                    "page_number": i + 1,
-                    "image_url": image_url,
-                    "text_url": text_url,
-                    "text_content": scene.text,
-                }
-                generated_pages.append(page_data)
-                
-                print(f"✅ Page {i+1} completed")
-                
-            except Exception as e:
-                error_msg = f"Failed to generate page {i+1}: {str(e)}"
-                print(f"❌ {error_msg}")
-                update_job_status(job_id, JobStatus.FAILED, 0, error_msg)
-                return
-        
-        generation_time = time.time() - start_time
-        
-        result = {
-            "story_title": story_request.story_title,
-            "total_pages": total_scenes,
-            "generated_pages": len(generated_pages),
-            "generation_time": round(generation_time, 2),
-            "pipeline_used": "standard",
-            "pages": generated_pages
+        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)
         }
-        
-        update_job_status(
-            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)
+        return {"error": str(e)}
 
-def generate_storybook_dispatcher(job_id: str):
-    """Choose between pipelines"""
-    job_data = job_storage[job_id]
-    story_request_data = job_data["request"]
-    
-    pipeline_type = story_request_data.get("pipeline_type", "standard")
-    
-    # For now, only use standard pipeline until models are stable
-    generate_storybook_standard(job_id)
-
-# ============================================================================
-# FASTAPI ENDPOINTS (simplified)
-# ============================================================================
+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 []
 
-@app.post("/api/generate-storybook")
-async def generate_storybook_unified(request: dict, background_tasks: BackgroundTasks):
-    """Unified endpoint that handles both pipelines"""
+# OCI BUCKET FUNCTIONS
+def save_to_oci_bucket(image, text_content, story_title, page_number, file_type="image"):
+    """Save both images and text to OCI bucket via your OCI API"""
     try:
-        print(f"📥 Received storybook request: {request.get('story_title', 'Unknown')}")
-        
-        if 'consistency_seed' not in request or not request['consistency_seed']:
-            request['consistency_seed'] = random.randint(1000, 9999)
-        
-        # Ensure model_choice is valid
-        if request.get('model_choice') not in MODEL_CHOICES:
-            request['model_choice'] = "sd-1.5"  # Force to working model
-        
-        story_request = StorybookRequest(**request)
-        
-        if not story_request.story_title or not story_request.scenes:
-            raise HTTPException(status_code=400, detail="story_title and scenes are required")
-        
-        job_id = create_job(story_request)
-        background_tasks.add_task(generate_storybook_dispatcher, job_id)
+        if file_type == "image":
+            # Convert image to bytes
+            img_bytes = io.BytesIO()
+            image.save(img_bytes, format='PNG')
+            file_data = img_bytes.getvalue()
+            filename = f"page_{page_number:03d}.png"
+            mime_type = "image/png"
+        else:  # text
+            file_data = text_content.encode('utf-8')
+            filename = f"page_{page_number:03d}.txt"
+            mime_type = "text/plain"
+        
+        # Use your OCI API to save the file
+        api_url = f"{OCI_API_BASE_URL}/api/upload"
         
-        response_data = {
-            "status": "success",
-            "message": f"Storybook generation started with {story_request.pipeline_type} pipeline",
-            "job_id": job_id,
-            "story_title": story_request.story_title,
-            "total_scenes": len(story_request.scenes),
-            "model_choice": story_request.model_choice,
-            "pipeline_type": story_request.pipeline_type,
-            "timestamp": datetime.now().isoformat()
+        files = {'file': (filename, file_data, mime_type)}
+        data = {
+            'project_id': 'storybook-library',
+            'subfolder': f'stories/{story_title}'
         }
         
-        print(f"✅ Job {job_id} started")
-        
-        return response_data
-        
-    except Exception as e:
-        error_msg = f"API Error: {str(e)}"
-        print(f"❌ {error_msg}")
-        raise HTTPException(status_code=500, detail=error_msg)
-
-@app.get("/api/job-status/{job_id}")
-async def get_job_status_endpoint(job_id: str):
-    job_data = job_storage.get(job_id)
-    if not job_data:
-        raise HTTPException(status_code=404, detail="Job not found")
-    
-    return JobStatusResponse(
-        job_id=job_id,
-        status=job_data["status"],
-        progress=job_data["progress"],
-        message=job_data["message"],
-        result=job_data["result"],
-        created_at=job_data["created_at"],
-        updated_at=job_data["updated_at"]
-    )
-
-@app.get("/api/health")
-async def api_health():
-    return {
-        "status": "healthy",
-        "service": "storybook-generator",
-        "timestamp": datetime.now().isoformat(),
-        "active_jobs": len(job_storage),
-        "models_loaded": list(model_cache.keys()),
-        "available_models": list(MODEL_CHOICES.keys()),
-        "oci_api_connected": OCI_API_BASE_URL
-    }
-
-# Simple Gradio interface
-def create_simple_interface():
-    with gr.Blocks(title="Storybook Generator") as demo:
-        gr.Markdown("# Storybook Generator")
-        
-        with gr.Row():
-            with gr.Column():
-                prompt = gr.Textbox(label="Prompt")
-                generate_btn = gr.Button("Generate")
-            with gr.Column():
-                output = gr.Image(label="Output")
+        response = requests.post(api_url, files=files, data=data, timeout=30)
         
-        def generate_image(prompt_text):
-            pipe = load_model("sd-1.5")
-            if pipe:
-                image = pipe(prompt_text, num_inference_steps=20).images[0]
-                return image
-            return None
+        print(f"📨 OCI API Response: {response.status_code}")
         
-        generate_btn.click(generate_image, inputs=prompt, outputs=output)
-    
-    return demo
-
-demo = create_simple_interface()
-
-@app.get("/")
-async def root():
-    return {
-        "message": "Storybook Generator API is running!",
-        "available_models": list(MODEL_CHOICES.keys()),
-        "default_model": "sd-1.5"
-    }
-
-# Mount Gradio for Hugging Face Spaces
-def get_app():
-    return app
-
-if __name__ == "__main__":
-    import uvicorn
-    import os
-    
-    HF_SPACE = os.environ.get('SPACE_ID') is not None
-    
-    if HF_SPACE:
-        print("🚀 Running on Hugging Face Spaces")
-        gr.mount_gradio_app(app, demo, path="/ui")
-        uvicorn.run(app, host="0.0.0.0", port=7860, log_level="info")
-    else:
-        print("🚀 Running locally")
-        uvicorn.run(app, host="0.0.0.0", port=8000, log_level="info")
+        if response.status_