Update app.py

app.py

@@ -517,4 +517,460 @@ def save_to_oci_bucket(image, text_content, story_title, page_number, file_type=
         
         print(f"📨 OCI API Response: {response.status_code}")
         
-        if response.status_
+        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 FUNCTIONS
+def create_job(story_request: StorybookRequest) -> str:
+    job_id = str(uuid.uuid4())
+    
+    # Process character descriptions from n8n
+    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,
+        "message": "Job created and queued",
+        "request": story_request.dict(),
+        "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 from n8n request")
+    
+    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
+    
+    # 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"]
+            
+            # Enhanced callback data
+            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"]),
+                "timestamp": time.time(),
+                "source": "huggingface-storybook-generator",
+                "estimated_time_remaining": calculate_remaining_time(job_id, progress)
+            }
+            
+            # Add result data for completed jobs
+            if status == JobStatus.COMPLETED and result:
+                callback_data["result"] = {
+                    "total_pages": result.get("total_pages", 0),
+                    "generation_time": result.get("generation_time", 0),
+                    "oci_bucket_url": result.get("oci_bucket_url", ""),
+                    "pages_generated": result.get("generated_pages", 0),
+                    "characters_used": result.get("characters_used", 0)
+                }
+            
+            # Add current scene info for processing jobs
+            if status == JobStatus.PROCESSING:
+                current_scene = progress // (100 // len(request_data["scenes"])) + 1
+                callback_data["current_scene"] = current_scene
+                callback_data["total_scenes"] = len(request_data["scenes"])
+                if current_scene <= len(request_data["scenes"]):
+                    scene_visual = request_data["scenes"][current_scene-1]["visual"]
+                    callback_data["scene_description"] = scene_visual[:100] + "..."
+                    
+                    # Add characters in current scene
+                    if "characters_present" in request_data["scenes"][current_scene-1]:
+                        callback_data["characters_in_scene"] = request_data["scenes"][current_scene-1]["characters_present"]
+            
+            headers = {
+                'Content-Type': 'application/json',
+                'User-Agent': 'Storybook-Generator/1.0'
+            }
+            
+            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
+
+def calculate_remaining_time(job_id, progress):
+    """Calculate estimated time remaining"""
+    if progress == 0:
+        return "Calculating..."
+    
+    job_data = job_storage.get(job_id)
+    if not job_data:
+        return "Unknown"
+    
+    time_elapsed = time.time() - job_data["created_at"]
+    if progress > 0:
+        total_estimated = (time_elapsed / progress) * 100
+        remaining = total_estimated - time_elapsed
+        return f"{int(remaining // 60)}m {int(remaining % 60)}s"
+    
+    return "Unknown"
+
+# ENHANCED BACKGROUND TASK WITH DYNAMIC CHARACTER CONSISTENCY
+def generate_storybook_background(job_id: str):
+    """Background task to generate complete storybook with dynamic character consistency"""
+    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 DYNAMIC storybook generation for job {job_id}")
+        print(f"📖 Story: {story_request.story_title}")
+        print(f"👥 Characters: {len(story_request.characters)} (from n8n)")
+        print(f"📄 Scenes: {len(story_request.scenes)}")
+        print(f"🌱 Consistency seed: {story_request.consistency_seed}")
+        
+        # Log character details
+        for char in story_request.characters:
+            print(f"   - {char.name}: {char.description[:50]}...")
+        
+        update_job_status(job_id, JobStatus.PROCESSING, 5, "Starting storybook generation with dynamic character consistency...")
+        
+        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:
+                # Fallback: extract from visual description using available characters
+                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: {scene.visual[:50]}..."
+            )
+            
+            try:
+                print(f"🖼️ Generating page {i+1} with characters: {characters_present}")
+                
+                # Generate consistent image using dynamic character templates
+                image = generate_consistent_image(
+                    scene.visual, 
+                    story_request.model_choice, 
+                    story_request.style,
+                    characters_present,
+                    character_templates,
+                    i + 1,
+                    story_request.consistency_seed
+                )
+                
+                # Save IMAGE to OCI bucket
+                image_url = save_to_oci_bucket(
+                    image, 
+                    "",  # No text for image
+                    story_request.story_title, 
+                    i + 1, 
+                    "image"
+                )
+                
+                # Save TEXT to OCI bucket
+                text_url = save_to_oci_bucket(
+                    None,  # No image for text
+                    scene.text, 
+                    story_request.story_title, 
+                    i + 1, 
+                    "text"
+                )
+                
+                # Store page data
+                page_data = {
+                    "page_number": i + 1,
+                    "image_url": image_url,
+                    "text_url": text_url,
+                    "text_content": scene.text,
+                    "visual_description": scene.visual,
+                    "characters_present": characters_present,
+                    "prompt_used": f"Dynamic consistent generation with {len(characters_present)} characters"
+                }
+                generated_pages.append(page_data)
+                
+                print(f"✅ Page {i+1} completed - Characters: {characters_present}")
+                
+            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
+        
+        # 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}",
+            "oci_bucket_url": f"https://oci.com/stories/{story_request.story_title}",
+            "consistency_seed": story_request.consistency_seed,
+            "character_names": [char.name for char in story_request.characters],
+            "pages": generated_pages,
+            "file_structure": {
+                "images": [f"page_{i+1:03d}.png" for i in range(total_scenes)],
+                "texts": [f"page_{i+1:03d}.txt" for i in range(total_scenes)]
+            }
+        }
+        
+        update_job_status(
+            job_id, 
+            JobStatus.COMPLETED, 
+            100, 
+            f"🎉 Storybook completed! {len(generated_pages)} pages with {len(story_request.characters)} dynamic characters created in {generation_time:.2f}s.",
+            result
+        )
+        
+        print(f"🎉 DYNAMIC Storybook generation finished for job {job_id}")
+        print(f"📁 Saved to: stories/{story_request.story_title} in OCI bucket")
+        print(f"👥 Dynamic character consistency maintained for {len(story_request.characters)} characters across {total_scenes} scenes")
+        
+    except Exception as e:
+        error_msg = f"Dynamic story generation failed: {str(e)}"
+        print(f"❌ {error_msg}")
+        update_job_status(job_id, JobStatus.FAILED, 0, error_msg)
+
+# 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 with dynamic character consistency"""
+    try:
+        print(f"📥 Received n8n request for story: {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']:
+                    # Generate visual prompt from description if not provided
+                    char['visual_prompt'] = ""
+                if 'key_features' not in char:
+                    char['key_features'] = []
+        
+        # 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 immediately
+        job_id = create_job(story_request)
+        
+        # Start background processing (runs independently of HF idle)
+        background_tasks.add_task(generate_storybook_background, job_id)
+        
+        # Immediate response for n8n
+        response_data = {
+            "status": "success",
+            "message": "Storybook generation with dynamic character consistency started successfully",
+            "job_id": job_id,
+            "story_title": story_request.story_title,
+            "total_scenes": len(story_request.scenes),
+            "total_characters": len(story_request.characters),
+            "character_names": [char.name for char in story_request.characters],
+            "consistency_seed": story_request.consistency_seed,
+            "callback_url": story_request.callback_url,
+            "estimated_time_seconds": len(story_request.scenes) * 35,
+            "timestamp": datetime.now().isoformat()
+        }
+        
+        print(f"✅ Job {job_id} started with dynamic character consistency for: {story_request.story_title}")
+        
+        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):
+    """Check job status"""
+    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():
+    """Health check endpoint for n8n"""
+    return {
+        "status": "healthy",
+        "service": "storybook-generator",
+        "timestamp": datetime.now().isoformat(),
+        "active_jobs": len(job_storage),
+        "models_loaded": list(model_cache.keys()),
+        "fallback_templates": list(FALLBACK_CHARACTER_TEMPLATES.keys()),
+        "oci_api_connected": 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)}
+
+# MISSING HELPER FUNCTIONS FOR GRADIO INTERFACE
+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()
+
+# Enhanced Gradio interface with dynamic character testing
+def create_gradio_interface():
+    """Create Gradio interface with dynamic character consistency features"""
+    
+    def generate_test_image_with_characters(prompt, model_choice, style_choice, character_names_text):
+        """Generate a single image for testing character consistency"""
+        try:
+            if not prompt.strip():
+                return None, "❌ Please enter a prompt", None
+            
+            # Parse character names from text input
+            character_names = [name.strip() for name in character_names_text.split(",") if name.strip()]
+            
+            print(f"🎨 Generating test image with prompt: {prompt}")
+            print(f"👥 Character names: {character_names}")
+            
+            # Create dynamic character templates for testing
+            character_templates = {}
+            for char_name in character_names:
+                character_templates[char_name] = {
+                    "visual_prompt": f"{char_name}, distinctive appearance, consistent features",
+                    "key_features": ["consistent appearance", "maintain features"],
+                    "consistency_keywords": f"consistent {char_name}"
+                }
+            
+            # Enhance the prompt with character consistency
+            enhanced_prompt, negative_prompt = enhance_prompt_with_characters(
+                prompt, character_names, character_templates, style_choice, 1
+            )
+            
+            # Generate the image
+            image = generate_consistent_image(
+                prompt, 
+                model_choice, 
+                style_choice,
+                character_names,
+                character_templates,
+                1
+            )
+            
+            # 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"
+            
+            status_msg = f"""✅ Success! Generated: {prompt}
+{character_info}
+🎨 Enhanced prompt: {enhanced_prompt[:200]}...
+📁 **Local file:** {filename if filename else 'Not saved'}"""
+            
+            return image, status_msg, filepath
+            
+        except Exception as e:
+            error_msg = f"❌ Generation failed: {str(e)}"
+