Update app.py

app.py

@@ -161,7 +161,7 @@ class MemoryStatusResponse(BaseModel):
     gpu_memory_cached_mb: Optional[float] = None
     status: str
 
-# HIGH-QUALITY MODEL SELECTION - ANIME FOCUSED & WORKING
+# HIGH-QUALITY MODEL SELECTION
 MODEL_CHOICES = {
     "dreamshaper-8": "lykon/dreamshaper-8",
     "realistic-vision": "SG161222/Realistic_Vision_V5.1", 
@@ -182,7 +182,7 @@ current_pipe = None
 model_lock = threading.Lock()
 
 # =============================================
-# FIXED: Infographic Layout Generator with Responsive Design
+# FIXED: Infographic Layout Generator
 # =============================================
 class InfographicLayoutGenerator:
     def __init__(self):
@@ -194,15 +194,14 @@ class InfographicLayoutGenerator:
         
     def get_font(self, size, bold=False):
         """Enhanced font loading with extensive Chinese font support"""
-        # Comprehensive list of fonts that support Chinese
         font_paths = [
             # Windows fonts
-            "C:/Windows/Fonts/msyh.ttc",        # Microsoft YaHei
-            "C:/Windows/Fonts/msyhbd.ttc",      # Microsoft YaHei Bold
-            "C:/Windows/Fonts/simhei.ttf",      # SimHei
-            "C:/Windows/Fonts/simsun.ttc",      # SimSun
-            "C:/Windows/Fonts/STSONG.TTF",      # STSong
-            "C:/Windows/Fonts/STKAITI.TTF",     # STKaiti
+            "C:/Windows/Fonts/msyh.ttc",
+            "C:/Windows/Fonts/msyhbd.ttc",
+            "C:/Windows/Fonts/simhei.ttf",
+            "C:/Windows/Fonts/simsun.ttc",
+            "C:/Windows/Fonts/STSONG.TTF",
+            "C:/Windows/Fonts/STKAITI.TTF",
             # Linux fonts
             "/usr/share/fonts/truetype/wqy/wqy-microhei.ttc",
             "/usr/share/fonts/truetype/wqy/wqy-zenhei.ttc",
@@ -231,7 +230,6 @@ class InfographicLayoutGenerator:
             ]
             font_paths = bold_fonts + font_paths
         
-        # Try each font
         for font_path in font_paths:
             try:
                 if os.path.exists(font_path):
@@ -239,7 +237,6 @@ class InfographicLayoutGenerator:
             except:
                 continue
         
-        # Ultimate fallback - use default font but try to set encoding
         try:
             return ImageFont.truetype("/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf", size)
         except:
@@ -248,46 +245,45 @@ class InfographicLayoutGenerator:
     def smart_remove_background(self, image):
         """Intelligently remove background while keeping the main subject"""
         try:
-            # Convert to RGBA
             if image.mode != 'RGBA':
                 image = image.convert('RGBA')
             
             data = image.getdata()
             new_data = []
             
-            # Get image dimensions
             width, height = image.size
             
-            # Sample edges to determine background color
             edge_samples = []
-            # Top edge
             for x in range(0, width, 10):
-                edge_samples.append(data[x])
-            # Bottom edge
+                if x < len(data):
+                    edge_samples.append(data[x])
             for x in range(0, width, 10):
-                edge_samples.append(data[(height-1) * width + x])
-            # Left edge
+                idx = (height-1) * width + x
+                if idx < len(data):
+                    edge_samples.append(data[idx])
             for y in range(0, height, 10):
-                edge_samples.append(data[y * width])
-            # Right edge
+                idx = y * width
+                if idx < len(data):
+                    edge_samples.append(data[idx])
             for y in range(0, height, 10):
-                edge_samples.append(data[y * width + (width-1)])
+                idx = y * width + (width-1)
+                if idx < len(data):
+                    edge_samples.append(data[idx])
+            
+            if not edge_samples:
+                return image
             
-            # Calculate average background color from edges
             avg_r = sum(s[0] for s in edge_samples) // len(edge_samples)
             avg_g = sum(s[1] for s in edge_samples) // len(edge_samples)
             avg_b = sum(s[2] for s in edge_samples) // len(edge_samples)
             
-            # Threshold for background detection
             threshold = 60
             
             for item in data:
-                # Calculate color distance from average background
                 distance = ((item[0] - avg_r) ** 2 + 
                           (item[1] - avg_g) ** 2 + 
                           (item[2] - avg_b) ** 2) ** 0.5
                 
-                # If pixel is close to background color, make transparent
                 if distance < threshold:
                     new_data.append((255, 255, 255, 0))
                 else:
@@ -302,33 +298,24 @@ class InfographicLayoutGenerator:
     
     def create_responsive_layout(self, num_items):
         """Calculate responsive layout based on number of items"""
-        # 9:16 dimensions
         width = 900
         height = 1600
         
-        # Responsive sizing
         if num_items <= 3:
-            # Few items - larger icons
             icon_size = 180
             columns = 1
             rows = num_items
-            vertical_spacing = 100
         elif num_items <= 6:
-            # Medium items - medium icons
             icon_size = 150
             columns = 2
             rows = (num_items + 1) // 2
-            vertical_spacing = 80
         else:
-            # Many items - smaller icons
             icon_size = 120
             columns = 2
             rows = (num_items + 1) // 2
-            vertical_spacing = 60
         
-        # Calculate positions
         positions = []
-        available_height = height - 300  # Leave space for title and footer
+        available_height = height - 300
         start_y = 200
         
         for i in range(num_items):
@@ -343,7 +330,6 @@ class InfographicLayoutGenerator:
                 else:
                     x = 3 * width // 4 - icon_size // 2
             
-            # Distribute rows evenly
             if rows > 1:
                 y = start_y + (row * (available_height // rows))
             else:
@@ -354,59 +340,41 @@ class InfographicLayoutGenerator:
         return positions, icon_size, columns
     
     def create_food_infographic(self, title, items_with_prompts, generated_images, background_image=None):
-        """
-        Create a responsive 9:16 infographic with proper Chinese text
-        """
-        # 9:16 dimensions
+        """Create responsive 9:16 infographic with proper Chinese text"""
         width = 900
         height = 1600
         
-        # Create clean background
+        # Create background
         if background_image:
-            # Resize background to fit
             bg = background_image.resize((width, height), Image.Resampling.LANCZOS)
             canvas = bg.convert('RGB')
         else:
-            # Clean white background
             canvas = Image.new('RGB', (width, height), (255, 255, 255))
-            
-            # Add very subtle gray gradient at edges only
-            draw = ImageDraw.Draw(canvas)
+            draw_temp = ImageDraw.Draw(canvas)
             for y in range(height):
                 if y < 20 or y > height-20:
-                    opacity = 10
-                    draw.line([(0, y), (width, y)], fill=(240, 240, 240))
-        else:
-            canvas = Image.new('RGB', (width, height), (255, 255, 255))
+                    draw_temp.line([(0, y), (width, y)], fill=(240, 240, 240))
         
         draw = ImageDraw.Draw(canvas)
-        
         num_items = len(items_with_prompts)
-        
-        # Get responsive layout
         positions, icon_size, columns = self.create_responsive_layout(num_items)
         
-        # Draw title with Chinese support
+        # Draw title
         title_font = self.get_font(48, bold=True)
-        
-        # Title with very light background
         title_bbox = draw.textbbox((0, 0), title, font=title_font)
         title_width = title_bbox[2] - title_bbox[0]
         title_x = (width - title_width) // 2
         title_y = 60
         
-        # Very light gray background for title (NO RED)
         draw.rounded_rectangle(
             [title_x-20, title_y-10, title_x+title_width+20, title_y+60],
             radius=20,
             fill=(250, 250, 250),
-            outline=None  # NO OUTLINE
+            outline=None
         )
-        
-        # Draw title text
         draw.text((title_x, title_y), title, font=title_font, fill=self.title_color)
         
-        # Draw subtitle in both languages
+        # Draw subtitle
         subtitle_font = self.get_font(24)
         subtitle = "Healthy Foods · 健康食品"
         subtitle_bbox = draw.textbbox((0, 0), subtitle, font=subtitle_font)
@@ -415,84 +383,55 @@ class InfographicLayoutGenerator:
         subtitle_y = title_y + 60
         draw.text((subtitle_x, subtitle_y), subtitle, font=subtitle_font, fill=(120, 120, 120))
         
-        # Process and place each item
+        # Place items
         for i, ((food_name, _), img) in enumerate(zip(items_with_prompts, generated_images)):
             if i >= len(positions):
                 break
                 
             x, y, size = positions[i]
             
-            # Create clean icon from image
             if img:
-                # Remove background
                 icon_img = self.smart_remove_background(img)
-                
-                # Resize maintaining aspect ratio
                 icon_img.thumbnail((size, size), Image.Resampling.LANCZOS)
                 
-                # Create circular mask for smooth edges
                 mask = Image.new('L', (size, size), 0)
                 mask_draw = ImageDraw.Draw(mask)
                 mask_draw.ellipse((0, 0, size, size), fill=255)
                 
-                # Create final icon with transparency
                 icon_final = Image.new('RGBA', (size, size), (0, 0, 0, 0))
-                
-                # Center the image
                 paste_x = (size - icon_img.width) // 2
                 paste_y = (size - icon_img.height) // 2
                 icon_final.paste(icon_img, (paste_x, paste_y), icon_img)
                 
-                # Very subtle circular background (NO RED OUTLINE)
                 circle_bg = Image.new('RGBA', (size+20, size+20), (0, 0, 0, 0))
                 circle_draw = ImageDraw.Draw(circle_bg)
                 circle_draw.ellipse(
                     [5, 5, size+15, size+15],
-                    fill=(245, 245, 245),  # Very light gray
-                    outline=None  # NO OUTLINE
+                    fill=(245, 245, 245),
+                    outline=None
                 )
-                
-                # Paste circle background
                 canvas.paste(circle_bg, (x-10, y-10), circle_bg)
-                
-                # Paste icon
                 canvas.paste(icon_final, (x, y), icon_final)
             
-            # Draw food name with Chinese support
             name_font = self.get_font(28 if num_items > 6 else 32, bold=True)
             
-            # Calculate name position based on layout
             if columns == 1:
-                # Single column - name below icon
                 name_x = x + (size // 2)
                 name_y = y + size + 15
-                anchor = "mm"  # Center alignment
-                
-                # Draw name
                 draw.text((name_x, name_y), food_name, font=name_font, 
-                         fill=self.text_color, anchor=anchor)
-                
-                # Draw number below name
+                         fill=self.text_color, anchor="mm")
                 number_font = self.get_font(20)
-                number_text = f"#{i+1:02d}"
-                draw.text((name_x, name_y + 35), number_text, font=number_font,
-                         fill=(150, 150, 150), anchor=anchor)
-                
+                draw.text((name_x, name_y + 35), f"#{i+1:02d}", font=number_font,
+                         fill=(150, 150, 150), anchor="mm")
             else:
-                # Two columns - name beside icon
                 name_x = x + size + 15
                 name_y = y + (size // 2) - 20
-                
-                # Draw name
                 draw.text((name_x, name_y), food_name, font=name_font, fill=self.text_color)
-                
-                # Draw number
                 number_font = self.get_font(18)
-                number_text = f"#{i+1:02d}"
-                draw.text((name_x, name_y + 30), number_text, font=number_font,
+                draw.text((name_x, name_y + 30), f"#{i+1:02d}", font=number_font,
                          fill=(150, 150, 150))
         
-        # Draw simple footer (NO RED)
+        # Draw footer
         footer_font = self.get_font(20)
         footer_text = "·  Fresh & Healthy  ·"
         footer_bbox = draw.textbbox((0, 0), footer_text, font=footer_font)
@@ -588,7 +527,6 @@ def get_memory_usage():
     memory_used_mb = memory_info.rss / (1024 * 1024)
     memory_percent = process.memory_percent()
     
-    # GPU memory if available
     gpu_memory_allocated_mb = None
     gpu_memory_cached_mb = None
     
@@ -610,17 +548,13 @@ def clear_memory(clear_models=True, clear_jobs=False, clear_local_images=False,
     """Clear memory by unloading models and cleaning up resources"""
     results = []
     
-    # Clear model cache
     if clear_models:
         with model_lock:
             models_cleared = len(model_cache)
             for model_name, pipe in model_cache.items():
                 try:
-                    # Move to CPU first if it's on GPU
                     if hasattr(pipe, 'to'):
                         pipe.to('cpu')
-                    
-                    # Delete the pipeline
                     del pipe
                     results.append(f"Unloaded model: {model_name}")
                 except Exception as e:
@@ -632,7 +566,6 @@ def clear_memory(clear_models=True, clear_jobs=False, clear_local_images=False,
             current_model_name = None
             results.append(f"Cleared {models_cleared} models from cache")
     
-    # Clear completed jobs
     if clear_jobs:
         jobs_to_clear = []
         for job_id, job_data in job_storage.items():
@@ -645,7 +578,6 @@ def clear_memory(clear_models=True, clear_jobs=False, clear_local_images=False,
         
         results.append(f"Cleared {len(jobs_to_clear)} completed/failed jobs")
     
-    # Clear local images
     if clear_local_images:
         try:
             storage_info = get_local_storage_info()
@@ -659,7 +591,6 @@ def clear_memory(clear_models=True, clear_jobs=False, clear_local_images=False,
         except Exception as e:
             results.append(f"Error clearing local images: {str(e)}")
     
-    # Force garbage collection
     if force_gc:
         gc.collect()
         if torch.cuda.is_available():
@@ -668,7 +599,6 @@ def clear_memory(clear_models=True, clear_jobs=False, clear_local_images=False,
             results.append("GPU cache cleared")
         results.append("Garbage collection forced")
     
-    # Get memory status after cleanup
     memory_status = get_memory_usage()
     
     return {
@@ -678,7 +608,7 @@ def clear_memory(clear_models=True, clear_jobs=False, clear_local_images=False,
     }
 
 def load_model(model_name="dreamshaper-8"):
-    """Thread-safe model loading with HIGH-QUALITY settings and better error handling"""
+    """Thread-safe model loading"""
     global model_cache, current_model_name, current_pipe
     
     with model_lock:
@@ -687,10 +617,9 @@ def load_model(model_name="dreamshaper-8"):
             current_model_name = model_name
             return current_pipe
         
-        print(f"🔄 Loading HIGH-QUALITY model: {model_name}")
+        print(f"🔄 Loading model: {model_name}")
         try:
             model_id = MODEL_CHOICES.get(model_name, "lykon/dreamshaper-8")
-            
             print(f"🔧 Attempting to load: {model_id}")
             
             pipe = StableDiffusionPipeline.from_pretrained(
@@ -709,7 +638,7 @@ def load_model(model_name="dreamshaper-8"):
             current_pipe = pipe
             current_model_name = model_name
             
-            print(f"✅ HIGH-QUALITY Model loaded: {model_name}")
+            print(f"✅ Model loaded: {model_name}")
             return pipe
             
         except Exception as e:
@@ -728,7 +657,7 @@ def load_model(model_name="dreamshaper-8"):
                 current_pipe = pipe
                 current_model_name = "sd-1.5"
                 
-                print(f"✅ Fallback model loaded: stable-diffusion-v1-5")
+                print(f"✅ Fallback model loaded")
                 return pipe
                 
             except Exception as fallback_error:
@@ -740,12 +669,10 @@ print("🚀 Initializing Storybook & Infographic Generator API...")
 load_model("dreamshaper-8")
 print("✅ Model loaded and ready!")
 
-# SIMPLE PROMPT ENGINEERING - USE PURE PROMPTS ONLY
 def enhance_prompt_simple(scene_visual, style="childrens_book"):
-    """Simple prompt enhancement - uses only the provided visual prompt with style"""
-    
+    """Simple prompt enhancement"""
     style_templates = {
-        "childrens_book": "children's book illustration, watercolor style, soft colors, whimsical, magical, storybook art, professional illustration",
+        "childrens_book": "children's book illustration, watercolor style, soft colors, whimsical, magical, storybook art",
         "realistic": "photorealistic, detailed, natural lighting, professional photography",
         "fantasy": "fantasy art, magical, ethereal, digital painting, concept art",
         "anime": "anime style, Japanese animation, vibrant colors, detailed artwork",
@@ -753,22 +680,15 @@ def enhance_prompt_simple(scene_visual, style="childrens_book"):
     }
     
     style_prompt = style_templates.get(style, style_templates["childrens_book"])
-    
     enhanced_prompt = f"{style_prompt}, {scene_visual}"
-    
-    negative_prompt = (
-        "blurry, low quality, bad anatomy, deformed characters, "
-        "wrong proportions, mismatched features"
-    )
+    negative_prompt = "blurry, low quality, bad anatomy, deformed characters, wrong proportions"
     
     return enhanced_prompt, negative_prompt
 
 def generate_image_simple(prompt, model_choice, style, scene_number, consistency_seed=None):
-    """Generate image using pure prompts only"""
-    
+    """Generate image using pure prompts"""
     enhanced_prompt, negative_prompt = enhance_prompt_simple(prompt, style)
     
-    # FIXED: Safer seed calculation
     if consistency_seed is not None:
         scene_seed = (consistency_seed + scene_number) % 2147483647
     else:
@@ -788,18 +708,15 @@ def generate_image_simple(prompt, model_choice, style, scene_number, consistency
         ).images[0]
         
         print(f"✅ Generated image for scene {scene_number}")
-        print(f"🌱 Seed used: {scene_seed}")
-        print(f"📝 Pure prompt used: {prompt}")
-        
         return image
         
     except Exception as e:
         print(f"❌ Generation failed: {str(e)}")
         raise
 
-# LOCAL FILE MANAGEMENT FUNCTIONS
+# LOCAL FILE MANAGEMENT
 def save_image_to_local(image, prompt, style="test"):
-    """Save image to local persistent storage"""
+    """Save image to local 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()
@@ -823,7 +740,6 @@ def delete_local_image(filepath):
     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}"
@@ -890,7 +806,7 @@ def create_job(story_request: StorybookRequest) -> str:
         "pages": []
     }
     
-    print(f"📝 Created job {job_id} for story: {story_request.story_title}")
+    print(f"📝 Created job {job_id}")
     return job_id
 
 def update_job_status(job_id: str, status: JobStatus, progress: int, message: str, result=None):
@@ -918,7 +834,6 @@ def update_job_status(job_id: str, status: JobStatus, progress: int, message: st
                 "status": status.value,
                 "progress": progress,
                 "message": message,
-                "story_title": request_data.get("story_title", request_data.get("title", "Unknown")),
                 "timestamp": time.time()
             }
             
@@ -929,49 +844,21 @@ def update_job_status(job_id: str, status: JobStatus, progress: int, message: st
                 }
             
             requests.post(callback_url, json=callback_data, timeout=5)
-            print(f"📢 Callback sent to {callback_url}")
         except Exception as e:
             print(f"⚠️ Callback failed: {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"
-
-# BACKGROUND TASK WITH HF DATASET
 def generate_storybook_background(job_id: str):
-    """Background task to generate complete storybook and upload to HF Dataset"""
+    """Background task to generate storybook"""
     try:
-        # Ensure HF Dataset exists
         if HF_TOKEN:
             ensure_dataset_exists()
         
         job_data = job_storage[job_id]
         story_request = StorybookRequest(**job_data["request"])
-        
         project_id = story_request.project_id or story_request.story_title.replace(' ', '_').lower()
         
-        print(f"🎬 Starting storybook generation for job {job_id}")
-        print(f"📖 Story: {story_request.story_title}")
-        print(f"📄 Scenes: {len(story_request.scenes)}")
-        print(f"🎨 Style: {story_request.style}")
-        print(f"📦 Project ID: {project_id}")
-        print(f"📤 Saving to HF Dataset: {DATASET_ID}")
-        
         update_job_status(job_id, JobStatus.PROCESSING, 5, "Starting generation...")
         
         total_scenes = len(story_request.scenes)
@@ -981,19 +868,9 @@ def generate_storybook_background(job_id: str):
         
         for i, scene in enumerate(story_request.scenes):
             progress = 5 + int(((i + 1) / total_scenes) * 90)
-            
-            update_job_status(
-                job_id, 
-                JobStatus.PROCESSING, 
-                progress, 
-                f"Generating page {i+1}/{total_scenes}"
-            )
+            update_job_status(job_id, JobStatus.PROCESSING, progress, f"Generating page {i+1}/{total_scenes}")
             
             try:
-                print(f"🖼️ Generating page {i+1}")
-                print(f"📝 Pure prompt: {scene.visual}")
-                
-                # Generate image
                 image = generate_image_simple(
                     scene.visual, 
                     story_request.model_choice, 
@@ -1002,193 +879,82 @@ def generate_storybook_background(job_id: str):
                     story_request.consistency_seed
                 )
                 
-                # Save locally as backup
                 local_filepath, local_filename = save_image_to_local(image, scene.visual, story_request.style)
-                print(f"💾 Image saved locally as backup: {local_filename}")
                 
-                # Upload to HF Dataset
                 hf_url = None
                 if HF_TOKEN:
-                    hf_url = upload_image_to_hf_dataset(
-                        image, 
-                        project_id, 
-                        i + 1, 
-                        scene.visual, 
-                        story_request.style
-                    )
-                    
+                    hf_url = upload_image_to_hf_dataset(image, project_id, i + 1, scene.visual, story_request.style)
                     if hf_url:
                         image_urls.append(hf_url)
-                        print(f"✅ Uploaded to HF Dataset: {hf_url}")
                 
-                # Store page data
-                page_data = {
+                generated_pages.append({
                     "page_number": i + 1,
                     "image_url": hf_url or f"local://{local_filepath}",
-                    "hf_url": hf_url,
                     "text_content": scene.text,
-                    "visual_description": scene.visual,
-                    "prompt_used": scene.visual,
-                    "local_backup_path": local_filepath
-                }
-                generated_pages.append(page_data)
-                
-                print(f"✅ Page {i+1} completed")
+                    "visual_description": scene.visual
+                })
                 
             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, progress, error_msg)
                 return
         
-        # Complete the job
-        generation_time = time.time() - start_time
-        
-        # Count successful HF uploads
-        hf_success_count = len(image_urls)
-        local_fallback_count = total_scenes - hf_success_count
-        
         result = {
             "story_title": story_request.story_title,
             "project_id": project_id,
             "total_pages": total_scenes,
             "generated_pages": len(generated_pages),
-            "generation_time": round(generation_time, 2),
-            "hf_dataset_url": f"https://huggingface.co/datasets/{DATASET_ID}" if HF_TOKEN else None,
             "image_urls": image_urls,
-            "pages": generated_pages,
-            "upload_summary": {
-                "hf_successful": hf_success_count,
-                "local_fallback": local_fallback_count,
-                "total_attempted": total_scenes
-            }
+            "pages": generated_pages
         }
         
-        # Report to tracker when all images are done
         if project_id and image_urls:
-            report_to_tracker(
-                project_id=project_id,
-                service_type="image",
-                status="completed",
-                file_urls=image_urls
-            )
-        
-        status_message = f"🎉 Storybook completed! {len(generated_pages)} pages created."
-        if hf_success_count > 0:
-            status_message += f" {hf_success_count} images uploaded to HF Dataset."
-        if local_fallback_count > 0:
-            status_message += f" {local_fallback_count} pages saved locally."
-        
-        update_job_status(
-            job_id, 
-            JobStatus.COMPLETED, 
-            100, 
-            status_message,
-            result
-        )
+            report_to_tracker(project_id=project_id, service_type="image", status="completed", file_urls=image_urls)
         
-        print(f"🎉 Storybook generation finished for job {job_id}")
-        print(f"📤 HF Uploads: {hf_success_count} successful")
+        update_job_status(job_id, JobStatus.COMPLETED, 100, "Storybook completed!", result)
         
     except Exception as e:
         error_msg = f"Story generation failed: {str(e)}"
-        print(f"❌ {error_msg}")
-        traceback.print_exc()
-        
-        # Report failure to tracker
-        if 'project_id' in locals() and project_id:
-            report_to_tracker(
-                project_id=project_id,
-                service_type="image",
-                status="failed",
-                error=error_msg
-            )
-        
         update_job_status(job_id, JobStatus.FAILED, 0, error_msg)
 
-# =============================================
-# FIXED: Infographic Background Task
-# =============================================
 def generate_infographic_background(job_id: str):
-    """Background task with responsive layout and proper Chinese support"""
+    """Background task to generate infographic"""
     try:
         job_data = job_storage[job_id]
         request = InfographicRequest(**job_data["request"])
-        
         project_id = request.project_id or f"infographic_{int(time.time())}"
         
-        print(f"🎬 Starting infographic generation for job {job_id}")
-        print(f"📊 Title: {request.title}")
-        print(f"📦 Items: {len(request.items)}")
-        
         update_job_status(job_id, JobStatus.PROCESSING, 5, "Starting infographic generation...")
         
-        # Limit items to prevent memory issues
         items = request.items[:10] if len(request.items) > 10 else request.items
-        print(f"📦 Processing {len(items)} items")
         
-        # Download custom background if provided
         background_image = None
         if request.background_url:
             try:
-                print(f"📥 Downloading custom background from: {request.background_url}")
                 response = requests.get(request.background_url, timeout=30)
                 if response.status_code == 200:
                     background_image = Image.open(io.BytesIO(response.content)).convert('RGB')
-                    print("✅ Custom background loaded successfully")
-                else:
-                    print(f"⚠️ Failed to download background: Status {response.status_code}")
             except Exception as e:
-                print(f"⚠️ Error loading custom background: {e}")
+                print(f"⚠️ Error loading background: {e}")
         
-        update_job_status(job_id, JobStatus.PROCESSING, 10, "Generating food images...")
-        
-        # Generate images for each item
         generated_images = []
         image_urls = []
         items_data = []
         
         for i, item in enumerate(items):
             progress = 10 + int(((i + 1) / len(items)) * 70)
-            
-            update_job_status(
-                job_id,
-                JobStatus.PROCESSING,
-                progress,
-                f"Generating image for {item.name} ({i+1}/{len(items)})"
-            )
+            update_job_status(job_id, JobStatus.PROCESSING, progress, f"Generating {item.name} ({i+1}/{len(items)})")
             
             try:
-                print(f"🖼️ Generating image for: {item.name}")
-                
-                # Enhanced prompt for better subject isolation
-                enhanced_prompt = f"professional food photography, {item.prompt}, " \
-                                 f"isolated on white background, cut out, transparent style, " \
-                                 f"sharp focus, studio lighting, clean edges"
-                
-                image = generate_image_simple(
-                    enhanced_prompt,
-                    "dreamshaper-8",
-                    "food_photography",
-                    i + 1,
-                    None
-                )
-                
+                enhanced_prompt = f"professional food photography, {item.prompt}, isolated on white background"
+                image = generate_image_simple(enhanced_prompt, "dreamshaper-8", "food_photography", i + 1, None)
                 generated_images.append(image)
                 
-                # Save locally
                 local_filepath, _ = save_image_to_local(image, item.name, "infographic")
                 
-                # Upload to HF Dataset (limit to first 5 to save memory)
                 hf_url = None
                 if HF_TOKEN and i < 5:
-                    hf_url = upload_image_to_hf_dataset(
-                        image,
-                        project_id,
-                        i + 1,
-                        item.name,
-                        "infographic"
-                    )
+                    hf_url = upload_image_to_hf_dataset(image, project_id, i + 1, item.name, "infographic")
                     if hf_url:
                         image_urls.append(hf_url)
                 
@@ -1198,51 +964,28 @@ def generate_infographic_background(job_id: str):
                     "prompt": item.prompt
                 })
                 
-                print(f"✅ Image generated for {item.name}")
-                
             except Exception as e:
-                print(f"❌ Failed to generate for {item.name}: {e}")
-                # Create a placeholder image
                 placeholder = Image.new('RGB', (512, 512), color=(240, 240, 240))
                 generated_images.append(placeholder)
             
-            # Force garbage collection
             gc.collect()
         
-        update_job_status(job_id, JobStatus.PROCESSING, 85, "Creating infographic layout...")
+        update_job_status(job_id, JobStatus.PROCESSING, 85, "Creating layout...")
         
-        # Create the infographic with responsive layout
         layout_generator = InfographicLayoutGenerator()
         items_with_prompts = [(item.name, item.prompt) for item in items]
+        infographic = layout_generator.create_food_infographic(request.title, items_with_prompts, generated_images, background_image)
         
-        infographic = layout_generator.create_food_infographic(
-            request.title,
-            items_with_prompts,
-            generated_images,
-            background_image=background_image
-        )
-        
-        # Save infographic
         infographic_path = os.path.join(PERSISTENT_IMAGE_DIR, f"infographic_{project_id}.png")
         infographic.save(infographic_path)
-        print(f"💾 Infographic saved locally: {infographic_path}")
         
-        # Upload infographic to HF Dataset
         infographic_url = None
         if HF_TOKEN:
             img_bytes = io.BytesIO()
             infographic.save(img_bytes, format='PNG')
             img_bytes.seek(0)
-            
-            infographic_url = upload_to_hf_dataset(
-                img_bytes.getvalue(),
-                f"infographic_{project_id}.png",
-                f"projects/{project_id}"
-            )
-            if infographic_url:
-                print(f"✅ Infographic uploaded: {infographic_url}")
+            infographic_url = upload_to_hf_dataset(img_bytes.getvalue(), f"infographic_{project_id}.png", f"projects/{project_id}")
         
-        # Clean up
         if background_image:
             background_image.close()
         for img in generated_images:
@@ -1251,72 +994,35 @@ def generate_infographic_background(job_id: str):
         infographic.close()
         gc.collect()
         
-        update_job_status(job_id, JobStatus.PROCESSING, 95, "Finalizing...")
-        
-        # Prepare result
         result = {
             "project_id": project_id,
             "title": request.title,
             "total_items": len(items),
             "infographic_url": infographic_url or f"local://{infographic_path}",
             "item_images": image_urls,
-            "items": items_data,
-            "background_used": request.background_url is not None
+            "items": items_data
         }
         
-        # Report to tracker
         if project_id and infographic_url:
-            report_to_tracker(
-                project_id=project_id,
-                service_type="infographic",
-                status="completed",
-                file_urls=[infographic_url] + image_urls
-            )
-        
-        update_job_status(
-            job_id,
-            JobStatus.COMPLETED,
-            100,
-            f"✅ Infographic created with {len(items)} items",
-            result
-        )
+            report_to_tracker(project_id=project_id, service_type="infographic", status="completed", file_urls=[infographic_url] + image_urls)
         
-        print(f"🎉 Infographic generation finished for job {job_id}")
+        update_job_status(job_id, JobStatus.COMPLETED, 100, f"✅ Infographic created with {len(items)} items", result)
         
     except Exception as e:
         error_msg = f"Infographic generation failed: {str(e)}"
-        print(f"❌ {error_msg}")
-        traceback.print_exc()
-        
-        if 'project_id' in locals() and project_id:
-            report_to_tracker(
-                project_id=project_id,
-                service_type="infographic",
-                status="failed",
-                error=error_msg
-            )
-        
         update_job_status(job_id, JobStatus.FAILED, 0, error_msg)
         gc.collect()
 
 # FASTAPI ENDPOINTS
 @app.post("/api/generate-storybook")
 async def generate_storybook(request: dict, background_tasks: BackgroundTasks):
-    """Main endpoint for n8n integration"""
     try:
-        print(f"📥 Received request for: {request.get('story_title', 'Unknown')}")
-        
         if 'consistency_seed' not in request:
             request['consistency_seed'] = random.randint(1000, 9999)
-        
         if 'project_id' not in request:
             request['project_id'] = request.get('story_title', 'unknown').replace(' ', '_').lower()
         
         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 required")
-        
         job_id = create_job(story_request)
         background_tasks.add_task(generate_storybook_background, job_id)
         
@@ -1324,34 +1030,19 @@ async def generate_storybook(request: dict, background_tasks: BackgroundTasks):
             "status": "success",
             "job_id": job_id,
             "story_title": story_request.story_title,
-            "project_id": request['project_id'],
             "total_scenes": len(story_request.scenes),
-            "hf_dataset": f"https://huggingface.co/datasets/{DATASET_ID}" if HF_TOKEN else None,
             "estimated_time_seconds": len(story_request.scenes) * 35
         }
-        
     except Exception as e:
-        print(f"❌ Error: {e}")
         raise HTTPException(status_code=500, detail=str(e))
 
-# =============================================
-# Infographic API Endpoint
-# =============================================
 @app.post("/api/generate-infographic")
 async def generate_infographic(request: dict, background_tasks: BackgroundTasks):
-    """Generate food infographic with images for each item"""
     try:
-        print(f"📥 Received infographic request for: {request.get('title', 'Unknown')}")
-        
         if 'project_id' not in request:
             request['project_id'] = f"infographic_{int(time.time())}"
         
         infographic_request = InfographicRequest(**request)
-        
-        if not infographic_request.title or not infographic_request.items:
-            raise HTTPException(status_code=400, detail="title and items required")
-        
-        # Create job
         job_id = str(uuid.uuid4())
         job_storage[job_id] = {
             "status": JobStatus.PENDING,
@@ -1362,26 +1053,20 @@ async def generate_infographic(request: dict, background_tasks: BackgroundTasks)
             "created_at": time.time(),
             "updated_at": time.time()
         }
-        
-        # Start background task
         background_tasks.add_task(generate_infographic_background, job_id)
         
         return {
             "status": "success",
             "job_id": job_id,
             "title": infographic_request.title,
-            "project_id": request['project_id'],
             "total_items": len(infographic_request.items),
             "estimated_time_seconds": min(len(infographic_request.items) * 30, 300)
         }
-        
     except Exception as e:
-        print(f"❌ Error: {e}")
         raise HTTPException(status_code=500, detail=str(e))
 
 @app.get("/api/job-status/{job_id}")
 async def get_job_status(job_id: str):
-    """Get job status"""
     job_data = job_storage.get(job_id)
     if not job_data:
         raise HTTPException(status_code=404, detail="Job not found")
@@ -1394,46 +1079,21 @@ async def get_job_status(job_id: str):
         "result": job_data["result"]
     }
 
-@app.get("/api/project-images/{project_id}")
-async def get_project_images(project_id: str):
-    """Get all images for a project from HF Dataset"""
-    try:
-        if not HF_TOKEN:
-            return {"error": "HF_TOKEN not set"}
-        
-        api = HfApi(token=HF_TOKEN)
-        files = api.list_repo_files(repo_id=DATASET_ID, repo_type="dataset")
-        
-        project_files = [f for f in files if f.startswith(f"data/projects/{project_id}/")]
-        urls = [f"https://huggingface.co/datasets/{DATASET_ID}/resolve/main/{f}" for f in project_files]
-        
-        return {
-            "project_id": project_id,
-            "total_images": len(urls),
-            "image_urls": urls
-        }
-    except Exception as e:
-        return {"error": str(e)}
-
 @app.get("/api/health")
 async def health():
-    """Health check"""
     return {
         "status": "healthy",
         "service": "storybook-infographic-generator",
-        "hf_dataset": DATASET_ID if HF_TOKEN else "Disabled",
         "active_jobs": len(job_storage),
         "models_loaded": list(model_cache.keys())
     }
 
 @app.get("/api/memory-status")
 async def memory_status():
-    """Get memory usage"""
     return get_memory_usage()
 
 @app.post("/api/clear-memory")
 async def clear_memory_api(request: MemoryClearanceRequest):
-    """Clear memory"""
     return clear_memory(
         clear_models=request.clear_models,
         clear_jobs=request.clear_jobs,
@@ -1443,16 +1103,11 @@ async def clear_memory_api(request: MemoryClearanceRequest):
 
 @app.get("/api/local-images")
 async def get_local_images():
-    """Get local images"""
     return get_local_storage_info()
 
-# =============================================
-# FIXED: Test Functions for Gradio
-# =============================================
+# GRADIO INTERFACE
 def test_infographic(title, items_text, background_image=None):
-    """Test function with proper Chinese support and responsive layout"""
     try:
-        # Parse items (format: "name:prompt;name2:prompt2")
         items = []
         for item in items_text.split(';'):
             if ':' in item:
@@ -1462,66 +1117,33 @@ def test_infographic(title, items_text, background_image=None):
         if not items:
             return None, "❌ Please enter at least one item"
         
-        # Limit items
         if len(items) > 10:
             items = items[:10]
-            print("⚠️ Limited to 10 items for preview")
-        
-        print(f"🎨 Generating infographic with {len(items)} items...")
         
-        # Generate images
         generated_images = []
-        try:
-            for i, item in enumerate(items):
-                print(f"  🖼️ Generating image {i+1}/{len(items)}: {item['name']}")
-                
-                enhanced_prompt = f"professional food photography, {item['prompt']}, " \
-                                 f"isolated on white background, cut out, transparent style, " \
-                                 f"sharp focus, studio lighting, clean edges"
-                
-                img = generate_image_simple(
-                    enhanced_prompt, 
-                    "dreamshaper-8", 
-                    "food_photography", 
-                    i+1, 
-                    None
-                )
-                generated_images.append(img)
-                time.sleep(0.5)
-            
-            print("  📐 Creating responsive layout...")
-            
-            # Create infographic with responsive layout
-            layout_gen = InfographicLayoutGenerator()
-            items_with_prompts = [(item['name'], item['prompt']) for item in items]
-            
-            infographic = layout_gen.create_food_infographic(
-                title, 
-                items_with_prompts, 
-                generated_images,
-                background_image=background_image
-            )
-            
-            return infographic, f"✅ Generated responsive infographic with {len(items)} items"
-            
-        finally:
-            # Clean up
-            for img in generated_images:
-                if img:
-                    img.close()
-            gc.collect()
+        for i, item in enumerate(items):
+            enhanced_prompt = f"professional food photography, {item['prompt']}, isolated on white background"
+            img = generate_image_simple(enhanced_prompt, "dreamshaper-8", "food_photography", i+1, None)
+            generated_images.append(img)
+            time.sleep(0.5)
+        
+        layout_gen = InfographicLayoutGenerator()
+        items_with_prompts = [(item['name'], item['prompt']) for item in items]
+        infographic = layout_gen.create_food_infographic(title, items_with_prompts, generated_images, background_image)
+        
+        for img in generated_images:
+            img.close()
+        gc.collect()
+        
+        return infographic, f"✅ Generated infographic with {len(items)} items"
         
     except Exception as e:
-        print(f"❌ Error: {str(e)}")
-        traceback.print_exc()
         return None, f"❌ Error: {str(e)}"
 
-# GRADIO INTERFACE
 def create_gradio_interface():
     def generate_test(prompt, model_choice, style_choice):
         if not prompt.strip():
             return None, "❌ Please enter a prompt"
-        
         try:
             image = generate_image_simple(prompt, model_choice, style_choice, 1)
             filepath, filename = save_image_to_local(image, prompt, style_choice)
@@ -1529,11 +1151,8 @@ def create_gradio_interface():
         except Exception as e:
             return None, f"❌ Error: {str(e)}"
     
-    def test_infographic_ui(title, items_text, background_image):
-        return test_infographic(title, items_text, background_image)
-    
     with gr.Blocks(title="Storybook & Infographic Generator") as demo:
-        gr.Markdown("# 🎨 Storybook & Infographic Generator with HF Dataset")
+        gr.Markdown("# 🎨 Storybook & Infographic Generator")
         
         with gr.Tab("Storybook Generator"):
             with gr.Row():
@@ -1542,11 +1161,9 @@ def create_gradio_interface():
                     style = gr.Dropdown(choices=["childrens_book", "realistic", "fantasy", "anime"], value="anime", label="Style")
                     prompt = gr.Textbox(label="Prompt", lines=3)
                     btn = gr.Button("Generate", variant="primary")
-                
                 with gr.Column():
                     output = gr.Image(label="Generated Image", height=500)
                     status = gr.Textbox(label="Status")
-            
             btn.click(fn=generate_test, inputs=[prompt, model, style], outputs=[output, status])
         
         with gr.Tab("Infographic Generator"):
@@ -1555,41 +1172,24 @@ def create_gradio_interface():
                     infographic_title = gr.Textbox(
                         label="Title (Supports Chinese)",
                         value="7월의 맛 (Taste of July)",
-                        placeholder="Enter infographic title in Chinese/English..."
+                        placeholder="Enter infographic title..."
                     )
                     infographic_items = gr.Textbox(
                         label="Items (name:prompt;name2:prompt2)",
                         value="酸菜 (Kimchi):traditional korean cabbage kimchi;萝卜 (Kkakdugi):korean radish kimchi, cubed;派 (Pa-kimchi):green onion kimchi",
-                        lines=5,
-                        placeholder="item1:prompt1;item2:prompt2"
+                        lines=5
                     )
-                    
-                    # Add background image upload
-                    background_image = gr.Image(
-                        label="Custom Background (optional)",
-                        type="pil",
-                        height=200
-                    )
-                    
+                    background_image = gr.Image(label="Custom Background (optional)", type="pil", height=200)
                     infographic_btn = gr.Button("Generate Infographic", variant="primary", size="lg")
-                
                 with gr.Column():
                     infographic_output = gr.Image(label="Generated Infographic", height=700)
                     infographic_status = gr.Textbox(label="Status")
             
             infographic_btn.click(
-                fn=test_infographic_ui,
+                fn=test_infographic,
                 inputs=[infographic_title, infographic_items, background_image],
                 outputs=[infographic_output, infographic_status]
             )
-            
-            gr.Markdown("""
-            ### 📝 Tips:
-            - **Title**: Supports Chinese/English text
-            - **Items**: Format as `name:prompt;name2:prompt2`
-            - **Background**: Upload your own image for custom background
-            - **Responsive**: Layout adapts to number of items (1-10)
-            """)
     
     return demo
 
@@ -1598,15 +1198,12 @@ demo = create_gradio_interface()
 @app.get("/")
 async def root():
     return {
-        "message": "Storybook & Infographic Generator API with HF Dataset",
-        "hf_dataset": DATASET_ID if HF_TOKEN else "Disabled",
-        "tracker_url": TRACKER_URL,
+        "message": "Storybook & Infographic Generator API",
         "endpoints": {
             "generate_storybook": "POST /api/generate-storybook",
             "generate_infographic": "POST /api/generate-infographic",
             "status": "GET /api/job-status/{job_id}",
-            "health": "GET /api/health",
-            "project_images": "GET /api/project-images/{project_id}"
+            "health": "GET /api/health"
         },
         "ui": "/ui"
     }
@@ -1616,8 +1213,6 @@ if __name__ == "__main__":
     
     if os.environ.get('SPACE_ID'):
         print("🚀 Running on Hugging Face Spaces")
-        print(f"📦 HF Dataset: {DATASET_ID if HF_TOKEN else 'Disabled'}")
-        print(f"📡 Tracker URL: {TRACKER_URL}")
         gr.mount_gradio_app(app, demo, path="/ui")
         uvicorn.run(app, host="0.0.0.0", port=7860, log_level="info")
     else: