Update app.py

app.py

@@ -17,7 +17,7 @@ from pydantic import BaseModel
 import random
 
 # External OCI API URL
-OCI_API_BASE_URL = "https://yukee1992-oci-story-book.hf.space"
+OCI_API_BASE_URL = "https://yukee1992-oci-video-storage.hf.space"
 
 # Initialize FastAPI app
 app = FastAPI(title="Storybook Generator API")
@@ -52,10 +52,21 @@ MODEL_CHOICES = {
     "sd-2.1": "stabilityai/stable-diffusion-2-1",
 }
 
-# Initialize the Stable Diffusion model
+# GLOBAL MODEL CACHE - Load once, reuse forever
+model_cache = {}
+current_model_name = None
+pipe = None
+
 def load_model(model_name="dreamshaper-8"):
-    """Load and return a high-quality Stable Diffusion model"""
-    print(f"🔄 Loading {model_name} model...")
+    """Load model into global cache - runs only once per model"""
+    global model_cache, current_model_name, pipe
+    
+    # Return cached model if already loaded
+    if model_name in model_cache:
+        print(f"✅ Using cached model: {model_name}")
+        return model_cache[model_name]
+    
+    print(f"🔄 Loading model for the first time: {model_name}")
     try:
         model_id = MODEL_CHOICES.get(model_name, "lykon/dreamshaper-8")
         
@@ -70,8 +81,13 @@ def load_model(model_name="dreamshaper-8"):
         pipe.scheduler = EulerAncestralDiscreteScheduler.from_config(pipe.scheduler.config)
         pipe = pipe.to("cpu")
         
-        print(f"✅ {model_name} loaded successfully!")
+        # Cache the model for future use
+        model_cache[model_name] = pipe
+        current_model_name = model_name
+        
+        print(f"✅ Model loaded and cached: {model_name}")
         return pipe
+        
     except Exception as e:
         print(f"❌ Model loading failed: {e}")
         # Fallback to SD 1.5
@@ -82,8 +98,10 @@ def load_model(model_name="dreamshaper-8"):
             requires_safety_checker=False
         ).to("cpu")
 
-# Load the model once at startup
-pipe = load_model()
+# Load the default model once at startup
+print("🚀 Initializing Storybook Generator...")
+pipe = load_model("dreamshaper-8")
+print("✅ Default model loaded and ready!")
 
 # PROFESSIONAL PROMPT ENGINEERING
 def enhance_prompt(prompt, style="childrens_book"):
@@ -113,24 +131,19 @@ def enhance_prompt(prompt, style="childrens_book"):
         ]
     }
     
-    # Choose style template
     templates = style_templates.get(style, style_templates["childrens_book"])
-    style_prompt = templates[0]  # Use the first template
+    style_prompt = templates[0]
     
-    # Enhanced prompt construction
     enhanced = f"{style_prompt}, {prompt}"
     
-    # Add quality boosters
     quality_boosters = [
         "intricate details", "beautiful composition", "perfect lighting",
         "professional artwork", "award winning", "trending on artstation"
     ]
     
-    # Add 2-3 random quality boosters
     boosters = random.sample(quality_boosters, 2)
     enhanced += ", " + ", ".join(boosters)
     
-    # Negative prompt to avoid bad quality
     negative_prompt = (
         "blurry, low quality, low resolution, ugly, deformed, poorly drawn, "
         "bad anatomy, wrong anatomy, extra limb, missing limb, floating limbs, "
@@ -178,7 +191,14 @@ def save_complete_storybook_page(image, story_title, sequence_number, scene_text
 
 def generate_storybook_page(scene_visual, story_title, sequence_number, scene_text, model_choice="dreamshaper-8", style="childrens_book"):
     """Generate a storybook page with both image and text"""
+    global pipe, current_model_name
+    
     try:
+        # Switch model if different from current
+        if model_choice != current_model_name:
+            print(f"🔄 Switching to model: {model_choice}")
+            pipe = load_model(model_choice)
+        
         # Enhanced prompt for better quality
         enhanced_prompt, negative_prompt = enhance_prompt(scene_visual, style)
         
@@ -204,14 +224,25 @@ def generate_storybook_page(scene_visual, story_title, sequence_number, scene_te
         return None, f"❌ Generation failed: {str(e)}"
 
 def batch_generate_complete_storybook(story_title, scenes_data, model_choice="dreamshaper-8", style="childrens_book"):
-    """Generate complete storybook with images and text"""
+    """Generate complete storybook with images and text - MODEL LOADS ONLY ONCE"""
     results = []
     status_messages = []
     
+    print(f"📚 Starting batch generation for: {story_title}")
+    print(f"📖 Total pages: {len(scenes_data)}")
+    print(f"🎨 Using model: {model_choice}")
+    
+    # Load model once at the beginning
+    global pipe
+    pipe = load_model(model_choice)
+    
+    start_time = time.time()
+    
     for i, scene_data in enumerate(scenes_data, 1):
         scene_visual = scene_data.get('visual', '')
         scene_text = scene_data.get('text', '')
         
+        print(f"🔄 Generating page {i}/{len(scenes_data)}...")
         image, status = generate_storybook_page(
             scene_visual, story_title, i, scene_text, model_choice, style
         )
@@ -220,20 +251,26 @@ def batch_generate_complete_storybook(story_title, scenes_data, model_choice="dr
             results.append((f"Page {i}", image, scene_text))
         status_messages.append(f"Page {i}: {status}")
     
+    total_time = time.time() - start_time
+    print(f"✅ Batch generation completed in {total_time:.2f} seconds")
+    print(f"📊 Average: {total_time/len(scenes_data):.2f} seconds per page")
+    
     return results, "\n".join(status_messages)
 
 # FastAPI endpoint for n8n
 @app.post("/api/generate-storybook")
 async def api_generate_storybook(request: StorybookRequest):
-    """API endpoint for n8n automation"""
+    """API endpoint for n8n automation - OPTIMIZED"""
     try:
         print(f"📚 Received storybook request: {request.story_title}")
         print(f"📖 Pages to generate: {len(request.scenes)}")
+        print(f"🎨 Model: {request.model_choice}")
+        print(f"🎨 Style: {request.style}")
         
         # Convert to scene data format
         scenes_data = [{"visual": scene.visual, "text": scene.text} for scene in request.scenes]
         
-        # Generate storybook
+        # Generate storybook (model loads only once)
         results, status = batch_generate_complete_storybook(
             request.story_title,
             scenes_data,
@@ -258,7 +295,9 @@ async def api_generate_storybook(request: StorybookRequest):
         }
         
     except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Storybook generation failed: {str(e)}")
+        error_msg = f"Storybook generation failed: {str(e)}"
+        print(f"❌ {error_msg}")
+        raise HTTPException(status_code=500, detail=error_msg)
 
 # Health check endpoint
 @app.get("/api/health")
@@ -267,9 +306,13 @@ async def health_check():
         "status": "healthy",
         "service": "Storybook Generator API",
         "timestamp": datetime.now().isoformat(),
-        "models_available": list(MODEL_CHOICES.keys())
+        "models_loaded": list(model_cache.keys()),
+        "current_model": current_model_name,
+        "cached_models_count": len(model_cache)
     }
 
+# ... (keep the rest of your Gradio interface code the same) ...
+
 # Gradio Interface Functions
 def generate_single_page(prompt, story_title, scene_text, model_choice, style):
     """Generate a single page for Gradio interface"""