Update app.py

app.py

@@ -12,18 +12,36 @@ import time
 import base64
 import json
 from typing import Dict, List, Tuple
+from fastapi import FastAPI, HTTPException
+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"
 
-# Try to import your existing OCI connector for direct access
-try:
-    from app import oci_connector
-    DIRECT_OCI_ACCESS = True
-    print("✅ Direct OCI access available - using existing OCI connector")
-except ImportError:
-    DIRECT_OCI_ACCESS = False
-    print("⚠️  Direct OCI access not available - using external API endpoint")
+# Initialize FastAPI app
+app = FastAPI(title="Storybook Generator API")
+
+# Add CORS middleware
+from fastapi.middleware.cors import CORSMiddleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Story scene model
+class StoryScene(BaseModel):
+    visual: str
+    text: str
+
+class StorybookRequest(BaseModel):
+    story_title: str
+    scenes: List[StoryScene]
+    model_choice: str = "dreamshaper-8"
+    style: str = "childrens_book"
 
 # HIGH-QUALITY MODEL SELECTION
 MODEL_CHOICES = {
@@ -34,10 +52,7 @@ MODEL_CHOICES = {
     "sd-2.1": "stabilityai/stable-diffusion-2-1",
 }
 
-# Story tracking for sequence numbering
-story_registry: Dict[str, int] = {}  # {story_title: current_sequence}
-
-# Initialize the HIGH-QUALITY Stable Diffusion model
+# Initialize the Stable Diffusion model
 def load_model(model_name="dreamshaper-8"):
     """Load and return a high-quality Stable Diffusion model"""
     print(f"🔄 Loading {model_name} model...")
@@ -51,6 +66,7 @@ def load_model(model_name="dreamshaper-8"):
             requires_safety_checker=False
         )
         
+        # Use better scheduler for quality
         pipe.scheduler = EulerAncestralDiscreteScheduler.from_config(pipe.scheduler.config)
         pipe = pipe.to("cpu")
         
@@ -58,6 +74,7 @@ def load_model(model_name="dreamshaper-8"):
         return pipe
     except Exception as e:
         print(f"❌ Model loading failed: {e}")
+        # Fallback to SD 1.5
         return StableDiffusionPipeline.from_pretrained(
             "runwayml/stable-diffusion-v1-5", 
             torch_dtype=torch.float32,
@@ -96,20 +113,24 @@ def enhance_prompt(prompt, style="childrens_book"):
         ]
     }
     
+    # Choose style template
     templates = style_templates.get(style, style_templates["childrens_book"])
-    style_prompt = templates[0]
+    style_prompt = templates[0]  # Use the first template
     
+    # 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"
     ]
     
-    import random
+    # 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, "
@@ -119,82 +140,49 @@ def enhance_prompt(prompt, style="childrens_book"):
     
     return enhanced, negative_prompt
 
-def get_next_sequence_number(story_title: str) -> int:
-    """Get the next sequence number for a story"""
-    # Clean the story title for use in filenames
-    clean_title = re.sub(r'[^a-zA-Z0-9_\-]', '', story_title.strip().replace(' ', '_'))
-    
-    if clean_title not in story_registry:
-        story_registry[clean_title] = 0
-    
-    story_registry[clean_title] += 1
-    return story_registry[clean_title], clean_title
-
-def save_to_oci_via_api(image, prompt, story_title, sequence_number):
-    """Save image with organized storybook structure"""
+def save_complete_storybook_page(image, story_title, sequence_number, scene_text):
+    """Save image AND text to OCI with organized structure"""
     try:
         # Convert image to bytes
         img_bytes = io.BytesIO()
         image.save(img_bytes, format='PNG')
         img_data = img_bytes.getvalue()
         
-        # Get sequence number and clean title
-        seq_num, clean_title = get_next_sequence_number(story_title)
-        if sequence_number is not None:
-            seq_num = sequence_number  # Use provided sequence number if available
-        
-        # Create organized filename with sequence
-        filename = f"page_{seq_num:03d}_{clean_title}.png"
-        
-        # Use the EXTERNAL API URL
-        api_url = f"{OCI_API_BASE_URL}/api/upload"
+        # Clean title for filenames
+        clean_title = re.sub(r'[^a-zA-Z0-9_\-]', '', story_title.strip().replace(' ', '_'))
         
-        print(f"📁 Saving to: stories/{clean_title}/{filename}")
+        # Create filenames
+        image_filename = f"page_{sequence_number:03d}_{clean_title}.png"
+        text_filename = f"page_{sequence_number:03d}_{clean_title}.txt"
         
-        # Prepare form data for API request
-        files = {
-            'file': (filename, img_data, 'image/png')
-        }
+        # Save image to OCI
+        image_api_url = f"{OCI_API_BASE_URL}/api/upload"
+        files = {'file': (image_filename, img_data, 'image/png')}
+        data = {'project_id': 'storybook-library', 'subfolder': f'stories/{clean_title}'}
+        response = requests.post(image_api_url, files=files, data=data, timeout=30)
         
-        data = {
+        # Save text to OCI
+        text_api_url = f"{OCI_API_BASE_URL}/api/upload-text"
+        text_data = {
             'project_id': 'storybook-library',
-            'subfolder': f'stories/{clean_title}'
+            'subfolder': f'stories/{clean_title}',
+            'filename': text_filename,
+            'content': scene_text
         }
+        text_response = requests.post(text_api_url, data=text_data, timeout=30)
         
-        # Make the API request
-        response = requests.post(api_url, files=files, data=data, timeout=30)
-        
-        if response.status_code == 200:
-            result = response.json()
-            if result['status'] == 'success':
-                return f"✅ Saved: {filename} | Story: {clean_title}"
-            else:
-                return f"❌ API Error: {result.get('message', 'Unknown error')}"
-        else:
-            return f"❌ HTTP Error: {response.status_code}"
+        return f"✅ Page {sequence_number}: Image & Text saved"
             
     except Exception as e:
-        return f"❌ Upload failed: {str(e)}"
+        return f"❌ Save failed: {str(e)}"
 
-def generate_storybook_page(prompt, story_title, sequence_number=None, model_choice="dreamshaper-8", style="childrens_book"):
-    """Generate a storybook page with organized naming"""
+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"""
     try:
-        if not prompt or not prompt.strip():
-            return None, "❌ Please enter a scene description"
-        
-        if not story_title or not story_title.strip():
-            return None, "❌ Please enter a story title"
+        # Enhanced prompt for better quality
+        enhanced_prompt, negative_prompt = enhance_prompt(scene_visual, style)
         
-        # Reload model if different choice
-        global pipe
-        if model_choice != "dreamshaper-8":
-            pipe = load_model(model_choice)
-        
-        # Professional prompt enhancement
-        enhanced_prompt, negative_prompt = enhance_prompt(prompt, style)
-        
-        print(f"📖 Generating page for: {story_title}")
-        print(f"🎨 Prompt: {enhanced_prompt}")
+        print(f"📖 Generating page {sequence_number} for: {story_title}")
         
         # Generate high-quality image
         image = pipe(
@@ -207,52 +195,123 @@ def generate_storybook_page(prompt, story_title, sequence_number=None, model_cho
             generator=torch.Generator(device="cpu").manual_seed(int(time.time()))
         ).images[0]
         
-        print("✅ Page generated successfully!")
-        
-        # Save with organized structure
-        save_status = save_to_oci_via_api(image, prompt, story_title, sequence_number)
-        print(f"💾 {save_status}")
+        # Save both image and text
+        save_status = save_complete_storybook_page(image, story_title, sequence_number, scene_text)
         
         return image, save_status
         
     except Exception as e:
-        error_msg = f"❌ Generation failed: {str(e)}"
-        print(error_msg)
-        return None, error_msg
+        return None, f"❌ Generation failed: {str(e)}"
 
-def batch_generate_storybook(story_title, scenes_text, model_choice="dreamshaper-8", style="childrens_book"):
-    """Generate multiple pages for a complete storybook"""
-    if not story_title or not scenes_text:
-        return [], "❌ Please provide story title and scenes"
-    
-    scenes = [scene.strip() for scene in scenes_text.split('\n') if scene.strip()]
+def batch_generate_complete_storybook(story_title, scenes_data, model_choice="dreamshaper-8", style="childrens_book"):
+    """Generate complete storybook with images and text"""
     results = []
     status_messages = []
     
-    for i, scene in enumerate(scenes, 1):
-        print(f"📖 Generating page {i}/{len(scenes)} for: {story_title}")
+    for i, scene_data in enumerate(scenes_data, 1):
+        scene_visual = scene_data.get('visual', '')
+        scene_text = scene_data.get('text', '')
+        
         image, status = generate_storybook_page(
-            scene, story_title, i, model_choice, style
+            scene_visual, story_title, i, scene_text, model_choice, style
         )
         
         if image:
-            results.append((f"Page {i}: {scene}", image))
+            results.append((f"Page {i}", image, scene_text))
         status_messages.append(f"Page {i}: {status}")
     
     return results, "\n".join(status_messages)
 
-# Create the enhanced Gradio interface
-with gr.Blocks(title="Professional Storybook Generator", theme="soft") as demo:
-    gr.Markdown("# 📚 Professional Storybook Generator")
-    gr.Markdown("Create organized storybooks with sequential page numbering")
+# FastAPI endpoint for n8n
+@app.post("/api/generate-storybook")
+async def api_generate_storybook(request: StorybookRequest):
+    """API endpoint for n8n automation"""
+    try:
+        print(f"📚 Received storybook request: {request.story_title}")
+        print(f"📖 Pages to generate: {len(request.scenes)}")
+        
+        # Convert to scene data format
+        scenes_data = [{"visual": scene.visual, "text": scene.text} for scene in request.scenes]
+        
+        # Generate storybook
+        results, status = batch_generate_complete_storybook(
+            request.story_title,
+            scenes_data,
+            request.model_choice,
+            request.style
+        )
+        
+        return {
+            "status": "success",
+            "story_title": request.story_title,
+            "total_pages": len(request.scenes),
+            "generated_pages": len(results),
+            "message": status,
+            "folder_path": f"storybook-library/stories/{request.story_title.replace(' ', '_')}/",
+            "pages": [
+                {
+                    "page_number": i+1,
+                    "image_file": f"page_{i+1:03d}_{request.story_title.replace(' ', '_')}.png",
+                    "text_file": f"page_{i+1:03d}_{request.story_title.replace(' ', '_')}.txt"
+                } for i in range(len(request.scenes))
+            ]
+        }
+        
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Storybook generation failed: {str(e)}")
+
+# Health check endpoint
+@app.get("/api/health")
+async def health_check():
+    return {
+        "status": "healthy",
+        "service": "Storybook Generator API",
+        "timestamp": datetime.now().isoformat(),
+        "models_available": list(MODEL_CHOICES.keys())
+    }
+
+# Gradio Interface Functions
+def generate_single_page(prompt, story_title, scene_text, model_choice, style):
+    """Generate a single page for Gradio interface"""
+    if not prompt or not story_title:
+        return None, "❌ Please enter both scene description and story title"
+    
+    image, status = generate_storybook_page(
+        prompt, story_title, 1, scene_text or "", model_choice, style
+    )
+    return image, status
+
+def generate_full_storybook(story_title, scenes_text, model_choice, style):
+    """Generate full storybook for Gradio interface"""
+    if not story_title or not scenes_text:
+        return [], "❌ Please provide story title and scenes"
+    
+    # Parse scenes from text input
+    scenes = []
+    for i, line in enumerate(scenes_text.split('\n')):
+        if line.strip():
+            scenes.append({
+                "visual": line.strip(),
+                "text": f"Page {i+1} text description"
+            })
+    
+    results, status = batch_generate_complete_storybook(
+        story_title, scenes, model_choice, style
+    )
+    return results, status
+
+# Create the Gradio interface
+with gr.Blocks(title="Storybook Generator", theme="soft") as demo:
+    gr.Markdown("# 📚 Storybook Generator")
+    gr.Markdown("Create beautiful storybooks with images and text")
     
     with gr.Row():
         with gr.Column(scale=1):
             gr.Markdown("### 📖 Story Information")
             
-            story_title = gr.Textbox(
+            story_title_input = gr.Textbox(
                 label="Story Title",
-                placeholder="Enter your story title...\nExample: The Dragon's Reading Adventure",
+                placeholder="Enter your story title...",
                 lines=1
             )
             
@@ -274,14 +333,20 @@ with gr.Blocks(title="Professional Storybook Generator", theme="soft") as demo:
             gr.Markdown("### 🎨 Single Page Generation")
             
             prompt_input = gr.Textbox(
-                label="Page Description",
-                placeholder="Describe this page's scene...\nExample: The dragon discovers a magical library in the forest",
+                label="Visual Description",
+                placeholder="Describe the scene for image generation...",
+                lines=3
+            )
+            
+            text_input = gr.Textbox(
+                label="Story Text (Optional)",
+                placeholder="Enter the story text for this page...",
                 lines=2
             )
             
             generate_btn = gr.Button("✨ Generate Single Page", variant="primary")
-            image_output = gr.Image(label="Generated Page", height=400, show_download_button=True)
-            status_output = gr.Textbox(label="Status", interactive=False, lines=2)
+            image_output = gr.Image(label="Generated Page", height=400)
+            status_output = gr.Textbox(label="Status", interactive=False)
     
     with gr.Row():
         gr.Markdown("### 📚 Complete Storybook Generation")
@@ -289,72 +354,44 @@ with gr.Blocks(title="Professional Storybook Generator", theme="soft") as demo:
     with gr.Row():
         with gr.Column():
             scenes_input = gr.Textbox(
-                label="Story Scenes (One per line = One per page)",
-                placeholder="Enter each page's scene on a separate line...\nExample:\nThe dragon finds a mysterious book\nHe learns to read with owl friend\nThey discover hidden treasure map\nFriends celebrate with magical feast",
+                label="Visual Descriptions (One per line)",
+                placeholder="Enter each page's visual description on separate lines...",
                 lines=6
             )
             
             batch_btn = gr.Button("📖 Generate Complete Storybook", variant="primary")
         
         with gr.Column():
-            batch_status = gr.Textbox(label="Generation Status", interactive=False, lines=8)
+            batch_status = gr.Textbox(label="Generation Status", interactive=False, lines=6)
             batch_gallery = gr.Gallery(label="Storybook Pages", columns=2, height=600)
-    
-    with gr.Accordion("📁 Folder Structure Preview", open=True):
-        gr.Markdown("""
-        **Your story will be organized as:**
-        ```
-        storybook-library/
-        └── stories/
-            └── The_Dragons_Reading_Adventure/
-                ├── page_001_The_Dragons_Reading_Adventure.png
-                ├── page_002_The_Dragons_Reading_Adventure.png
-                ├── page_003_The_Dragons_Reading_Adventure.png
-                └── page_004_The_Dragons_Reading_Adventure.png
-        ```
-        
-        **Perfect for:** 
-        - ✅ Easy PDF compilation later
-        - ✅ Automatic sequencing
-        - ✅ Organized by story title
-        - ✅ Ready for n8n automation
-        """)
-    
-    with gr.Accordion("💡 API Usage for n8n", open=False):
-        gr.Markdown("""
-        **For n8n automation, use this JSON format:**
-        ```json
-        {
-          "story_title": "The Dragon's Reading Adventure",
-          "scenes": [
-            "The dragon finds a mysterious old book in the forest",
-            "He meets an owl who teaches him to read",
-            "They discover a hidden treasure map in the book",
-            "All animal friends celebrate with a magical feast"
-          ],
-          "model_choice": "dreamshaper-8",
-          "style": "childrens_book"
-        }
-        ```
-        """)
 
     # Connect buttons to functions
     generate_btn.click(
-        fn=generate_storybook_page,
-        inputs=[prompt_input, story_title, gr.Number(visible=False), model_choice, style_choice],
+        fn=generate_single_page,
+        inputs=[prompt_input, story_title_input, text_input, model_choice, style_choice],
         outputs=[image_output, status_output]
     )
     
     batch_btn.click(
-        fn=batch_generate_storybook,
-        inputs=[story_title, scenes_input, model_choice, style_choice],
+        fn=generate_full_storybook,
+        inputs=[story_title_input, scenes_input, model_choice, style_choice],
         outputs=[batch_gallery, batch_status]
     )
 
+# Mount Gradio app to FastAPI
+app = gr.mount_gradio_app(app, demo, path="/")
+
+# For Hugging Face Spaces deployment
 def get_app():
-    return demo
+    return app
 
 if __name__ == "__main__":
-    print("🚀 Starting Professional Storybook Generator...")
-    print("📁 Feature: Organized story sequencing enabled")
-    demo.launch(server_name="0.0.0.0", server_port=7860)
+    print("🚀 Starting Storybook Generator API...")
+    print("📚 Available models:", list(MODEL_CHOICES.keys()))
+    print("🌐 API endpoints:")
+    print("   - POST /api/generate-storybook")
+    print("   - GET  /api/health")
+    print("   - GET  / (Gradio UI)")
+    
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=7860)