Update app.py

app.py

@@ -23,6 +23,11 @@ import random
 # External OCI API URL - YOUR BUCKET SAVING API
 OCI_API_BASE_URL = "https://yukee1992-oci-story-book.hf.space"
 
+# Create local directories for test images
+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="Storybook Generator API")
 
@@ -202,6 +207,87 @@ def generate_high_quality_image(prompt, model_choice="dreamshaper-8", style="chi
         print(f"❌ HQ Generation failed: {str(e)}")
         raise
 
+# 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 []
+
+# OCI BUCKET FUNCTIONS (for n8n API)
 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:
@@ -242,7 +328,7 @@ def save_to_oci_bucket(image, text_content, story_title, page_number, file_type=
     except Exception as e:
         raise Exception(f"OCI upload failed: {str(e)}")
 
-# JOB MANAGEMENT FUNCTIONS
+# JOB MANAGEMENT FUNCTIONS (for n8n API)
 def create_job(story_request: StorybookRequest) -> str:
     job_id = str(uuid.uuid4())
     
@@ -303,7 +389,7 @@ def update_job_status(job_id: str, status: JobStatus, progress: int, message: st
     
     return True
 
-# BACKGROUND TASK FOR COMPLETE STORYBOOK GENERATION
+# BACKGROUND TASK FOR COMPLETE STORYBOOK GENERATION (n8n API)
 def generate_storybook_background(job_id: str):
     """Background task to generate complete storybook with images and text"""
     try:
@@ -415,7 +501,7 @@ def generate_storybook_background(job_id: str):
         print(f"❌ {error_msg}")
         update_job_status(job_id, JobStatus.FAILED, 0, error_msg)
 
-# FASTAPI ENDPOINTS
+# FASTAPI ENDPOINTS (for n8n)
 @app.post("/api/generate-storybook")
 async def generate_storybook(request: dict, background_tasks: BackgroundTasks):
     """Main endpoint for n8n integration - generates complete storybook"""
@@ -443,7 +529,7 @@ async def generate_storybook(request: dict, background_tasks: BackgroundTasks):
             "story_title": story_request.story_title,
             "total_scenes": len(story_request.scenes),
             "callback_url": story_request.callback_url,
-            "estimated_time_seconds": len(story_request.scenes) * 30,  # ~30s per image
+            "estimated_time_seconds": len(story_request.scenes) * 30,
             "timestamp": datetime.now().isoformat()
         }
         
@@ -485,27 +571,31 @@ async def api_health():
         "oci_api_connected": OCI_API_BASE_URL
     }
 
-@app.get("/")
-async def root():
-    return {
-        "message": "Storybook Generator API is running!",
-        "endpoints": {
-            "generate_storybook": "POST /api/generate-storybook",
-            "check_status": "GET /api/job-status/{job_id}",
-            "health": "GET /api/health"
-        },
-        "oci_bucket_api": OCI_API_BASE_URL
-    }
+@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 FOR TESTING
+# GRADIO INTERFACE WITH LOCAL FILE MANAGEMENT
 def create_gradio_interface():
-    """Create Gradio interface for testing image generation"""
+    """Create Gradio interface with complete local file management"""
     
     def generate_test_image(prompt, model_choice, style_choice):
-        """Generate a single image for testing"""
+        """Generate a single image for testing and save locally"""
         try:
             if not prompt.strip():
-                return None, "❌ Please enter a prompt"
+                return None, "❌ Please enter a prompt", None
             
             print(f"🎨 Generating test image with prompt: {prompt}")
             
@@ -520,27 +610,81 @@ def create_gradio_interface():
                 negative_prompt
             )
             
+            # Save to local storage
+            filepath, filename = save_image_to_local(image, prompt, style_choice)
+            
+            if filepath:
+                save_info = f"💾 **Saved locally:** `{filepath}`"
+            else:
+                save_info = "⚠️ Could not save to local storage"
+            
             status_msg = f"""✅ Success! Generated: {prompt}
 
+{save_info}
+
 🎨 Enhanced prompt: {enhanced_prompt}
 
-💡 This is a test image. For complete storybook generation, use the API endpoint:
-POST /api/generate-storybook"""
+📁 **Local file:** {filename if filename else 'Not saved'}"""
             
-            return image, status_msg
+            return image, status_msg, filepath
             
         except Exception as e:
             error_msg = f"❌ Generation failed: {str(e)}"
             print(error_msg)
-            return None, error_msg
+            return None, error_msg, None
     
-    with gr.Blocks(title="Storybook Generator - Test Interface", theme="soft") as demo:
-        gr.Markdown("# 🎨 Storybook Generator - Test Interface")
-        gr.Markdown("**Test image generation • Full storybooks via API**")
+    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()
+        storage_info = get_local_storage_info()
+        
+        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()
+    
+    with gr.Blocks(title="Storybook Generator - Complete Interface", theme="soft") as demo:
+        gr.Markdown("# 🎨 Storybook Generator - Complete Interface")
+        gr.Markdown("**Test images (local) • Storybooks (OCI) • File management**")
+        
+        # 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"
         
         with gr.Row():
             with gr.Column(scale=1):
-                gr.Markdown("### ⚙️ Test Settings")
+                gr.Markdown("### ⚙️ Test Image Generation")
                 
                 model_dropdown = gr.Dropdown(
                     label="AI Model",
@@ -562,12 +706,17 @@ POST /api/generate-storybook"""
                 
                 generate_btn = gr.Button("✨ Generate Test Image", variant="primary")
                 
-                gr.Markdown("### 📚 API Usage")
+                # 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)
+                
+                gr.Markdown("### 📚 API Usage for n8n")
                 gr.Markdown("""
-                **For complete storybooks with multiple images:**
-                - Use: `POST /api/generate-storybook`
-                - Send: story_title, scenes[], characters[]
-                - Returns: job_id for status tracking
+                **For complete storybooks (OCI bucket):**
+                - Endpoint: `POST /api/generate-storybook`
+                - Input: `story_title`, `scenes[]`, `characters[]`
+                - Output: Saves to OCI bucket automatically
                 """)
             
             with gr.Column(scale=2):
@@ -597,59 +746,99 @@ POST /api/generate-storybook"""
                 outputs=prompt_input
             )
         
-        # API info section
-        with gr.Accordion("🔧 API Documentation", open=False):
-            gr.Markdown("""
-            ### API Endpoints
+        # Local file management section
+        with gr.Accordion("📁 Manage Local Test Images", open=True):
+            gr.Markdown("### Locally Saved Images")
             
-            **Generate Storybook**
-            ```bash
-            POST /api/generate-storybook
-            {
-              "story_title": "Your Story",
-              "scenes": [
-                {
-                  "visual": "Scene description",
-                  "text": "Story text"
-                }
-              ],
-              "callback_url": "your-webhook-url"
-            }
-            ```
+            with gr.Row():
+                refresh_btn = gr.Button("🔄 Refresh List")
+                clear_all_btn = gr.Button("🗑️ Clear All Images", variant="stop")
             
-            **Check Status**
-            ```bash
-            GET /api/job-status/{job_id}
-            ```
+            file_gallery = gr.Gallery(
+                label="Local Images",
+                show_label=True,
+                elem_id="gallery",
+                columns=4,
+                height="auto"
+            )
             
-            **Health Check**
-            ```bash
-            GET /api/health
-            ```
-            """)
+            clear_status = gr.Textbox(label="Clear Status", interactive=False)
         
+        # Connect events
         generate_btn.click(
             fn=generate_test_image,
             inputs=[prompt_input, model_dropdown, style_dropdown],
-            outputs=[image_output, status_output]
+            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
+        )
+        
+        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
+        )
+        
+        # Initialize on load
+        demo.load(fn=refresh_local_images, outputs=file_gallery)
+        demo.load(fn=update_storage_info, outputs=storage_info)
     
     return demo
 
 # Create Gradio app
 gradio_app = create_gradio_interface()
 
+@app.get("/")
+async def root():
+    return {
+        "message": "Storybook Generator API + UI is running!",
+        "features": [
+            "API: Complete storybook generation to OCI bucket",
+            "UI: Test image generation with local file management",
+            "File Management: View, download, delete local images"
+        ],
+        "endpoints": {
+            "generate_storybook": "POST /api/generate-storybook",
+            "check_status": "GET /api/job-status/{job_id}",
+            "local_images": "GET /api/local-images"
+        }
+    }
+
 # For Hugging Face Spaces deployment
 def get_app():
     return app
 
 if __name__ == "__main__":
     import uvicorn
-    print("🚀 Starting Storybook Generator API + Gradio Interface...")
-    print("📚 Features: Multi-image generation + Text saving + OCI bucket storage")
+    print("🚀 Starting Complete Storybook Generator...")
+    print("📚 Features: API (n8n) + UI (Gradio) + Local File Management")
     print("🔗 OCI API:", OCI_API_BASE_URL)
+    print("📁 Local storage:", PERSISTENT_IMAGE_DIR)
     print("🌐 Web Interface: http://localhost:7860")
     print("🔌 API Endpoints: http://localhost:7860/api/")
     
-    # Launch both FastAPI and Gradio
+    # Launch Gradio interface
     gradio_app.launch(server_name="0.0.0.0", server_port=7860)