Update app.py

app.py

@@ -21,7 +21,8 @@ import replicate
 from PIL import Image
 import io as io_module
 import base64
-
+import concurrent.futures
+from threading import Lock
 # --- Logging setup ---
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
 logger = logging.getLogger(__name__)
@@ -121,17 +122,19 @@ class WebtoonBible:
     
 @dataclass
 class StoryboardPanel:
-    """Individual storyboard panel"""
+    """Individual storyboard panel with unique ID"""
     panel_number: int
     scene_type: str  # wide, close-up, medium, establishing
     image_prompt: str  # Image generation prompt with character descriptions
+    panel_id: str = ""  # Unique panel identifier
     dialogue: List[str] = field(default_factory=list)
     narration: str = ""
     sound_effects: List[str] = field(default_factory=list)
     emotion_notes: str = ""
     camera_angle: str = ""
     background: str = ""
-    characters_in_scene: List[str] = field(default_factory=list)  # Character names in this panel
+    characters_in_scene: List[str] = field(default_factory=list)
+    generated_image_url: str = ""  # URL of generated image
 
 @dataclass
 class EpisodeStoryboard:
@@ -354,15 +357,20 @@ class WebtoonDatabase:
 
 # --- Image Generation ---
 class ImageGenerator:
-    """Handle image generation using Replicate API"""
+    """Handle image generation using Replicate API with multi-threading"""
     
-    @staticmethod
-    def generate_image(prompt: str, panel_num: int, session_id: str) -> Optional[str]:
+    def __init__(self):
+        self.generation_lock = Lock()
+        self.active_generations = {}
+    
+    def generate_image(self, prompt: str, panel_id: str, session_id: str) -> Dict[str, Any]:
         """Generate image using Replicate API"""
         try:
             if not REPLICATE_API_TOKEN:
                 logger.warning("No Replicate API token, returning placeholder")
-                return None
+                return {"panel_id": panel_id, "status": "error", "message": "No API token"}
+            
+            logger.info(f"Generating image for panel {panel_id}")
             
             # Run the model
             input_params = {
@@ -381,16 +389,64 @@ class ImageGenerator:
                 image_url = output[0].url() if hasattr(output[0], 'url') else str(output[0])
                 
                 # Cache the image
-                cache_key = f"{session_id}_{panel_num}"
+                cache_key = f"{session_id}_{panel_id}"
                 generated_images_cache[cache_key] = image_url
                 
-                return image_url
+                logger.info(f"Successfully generated image for panel {panel_id}")
+                return {
+                    "panel_id": panel_id,
+                    "status": "success",
+                    "image_url": image_url,
+                    "prompt": prompt
+                }
             
-            return None
+            return {"panel_id": panel_id, "status": "error", "message": "No output from model"}
             
         except Exception as e:
-            logger.error(f"Image generation error: {e}")
-            return None
+            logger.error(f"Image generation error for panel {panel_id}: {e}")
+            return {"panel_id": panel_id, "status": "error", "message": str(e)}
+    
+    def generate_multiple_images(self, panel_prompts: List[Dict], session_id: str, max_workers: int = 5) -> List[Dict]:
+        """Generate multiple images in parallel"""
+        results = []
+        
+        with concurrent.futures.ThreadPoolExecutor(max_workers=max_workers) as executor:
+            # Submit all tasks
+            future_to_panel = {}
+            for panel_data in panel_prompts:
+                panel_id = panel_data['panel_id']
+                prompt = panel_data['prompt']
+                
+                future = executor.submit(
+                    self.generate_image,
+                    prompt,
+                    panel_id,
+                    session_id
+                )
+                future_to_panel[future] = panel_data
+            
+            # Collect results as they complete
+            for future in concurrent.futures.as_completed(future_to_panel):
+                panel_data = future_to_panel[future]
+                try:
+                    result = future.result(timeout=60)
+                    results.append(result)
+                except concurrent.futures.TimeoutError:
+                    results.append({
+                        "panel_id": panel_data['panel_id'],
+                        "status": "error",
+                        "message": "Generation timeout"
+                    })
+                except Exception as e:
+                    results.append({
+                        "panel_id": panel_data['panel_id'],
+                        "status": "error",
+                        "message": str(e)
+                    })
+        
+        # Sort results by panel_id to maintain order
+        results.sort(key=lambda x: int(x['panel_id'].split('_panel')[1]))
+        return results
 
 # --- LLM Integration ---
 class WebtoonSystem:
@@ -864,7 +920,7 @@ Write detailed image prompts including celebrity lookalike descriptions.
             yield f"❌ 오류 발생: {e}", "", "", self.current_session_id, {}
 
     def parse_storyboard(self, content: str, episode_num: int, character_profiles: Dict[str, CharacterProfile]) -> EpisodeStoryboard:
-        """Parse storyboard text into structured format"""
+        """Parse storyboard text into structured format with unique panel IDs"""
         storyboard = EpisodeStoryboard(episode_number=episode_num, title=f"{episode_num}화")
         
         panels = []
@@ -877,10 +933,13 @@ Write detailed image prompts including celebrity lookalike descriptions.
                 if current_panel:
                     panels.append(current_panel)
                 panel_number += 1
+                # Create unique panel ID
+                panel_id = f"ep{episode_num}_panel{panel_number}"
                 current_panel = StoryboardPanel(
-                    panel_number=panel_number, 
+                    panel_number=panel_number,
                     scene_type="medium",
-                    image_prompt=""
+                    image_prompt="",
+                    panel_id=panel_id  # Add unique panel_id
                 )
             elif current_panel:
                 if '이미지 프롬프트:' in line or 'Image prompt:' in line:
@@ -904,6 +963,7 @@ Write detailed image prompts including celebrity lookalike descriptions.
         storyboard.panels = panels[:30]
         return storyboard
 
+
 # --- Format storyboard for display ---
 def format_storyboard_for_display(storyboard_content: str, character_profiles: Dict[str, CharacterProfile], session_id: str) -> str:
     """Format storyboard content for panel display with image generation buttons"""
@@ -1074,22 +1134,39 @@ def create_interface():
         </style>
         
         <script>
-            async function generateImage(panelNum, sessionId) {
-                const promptElement = document.querySelector(`#panel_${panelNum}_prompt`);
-                if (!promptElement) return;
+            // 기존 generateImage, regenerateImage 함수 삭제하고 아래로 교체
+            
+            async function regeneratePanel(panelId, sessionId, prompt) {
+                const container = document.querySelector(`#image_${panelId}`);
+                if (!container) {
+                    console.error('Container not found for panel:', panelId);
+                    return;
+                }
                 
-                const prompt = promptElement.textContent;
-                const imageContainer = document.querySelector(`#panel_${panelNum}_image`);
+                const parentDiv = container.parentElement;
+                parentDiv.innerHTML = '<p style="text-align: center; padding: 20px;">🔄 재생성 중...</p>';
                 
-                imageContainer.innerHTML = '<p>이미지 생성 중...</p>';
+                // Gradio의 Python 함수를 직접 호출하는 방식으로 변경
+                // 실제로는 Gradio의 이벤트 시스템을 통해 처리됨
+                console.log('Regenerating panel:', panelId, 'with prompt:', prompt);
                 
-                // Call image generation API
-                // This would be connected to your backend
-                console.log('Generating image for panel', panelNum, 'with prompt:', prompt);
+                // 임시 표시 (실제 구현시 Python 백엔드와 연동)
+                setTimeout(() => {
+                    parentDiv.innerHTML = `
+                        <h4>패널 ${panelId.split('_panel')[1]}</h4>
+                        <p style="color: orange;">⚠️ 재생성 기능 연동 중...</p>
+                        <button onclick="regeneratePanel('${panelId}', '${sessionId}', '${prompt}')" 
+                                style="background: #764ba2; color: white; padding: 8px 16px; border: none; border-radius: 4px; cursor: pointer; margin-top: 10px;">
+                            🔄 재생성
+                        </button>
+                    `;
+                }, 2000);
             }
             
-            async function regenerateImage(panelNum, sessionId) {
-                generateImage(panelNum, sessionId);
+            // 개별 패널 이미지 생성 함수
+            function generateSinglePanel(panelNum, sessionId) {
+                console.log('Generating single panel:', panelNum);
+                // Gradio 이벤트와 연동 필요
             }
         </script>
         
@@ -1272,27 +1349,108 @@ def create_interface():
                 gr.Warning(f"다운로드 중 오류 발생: {str(e)}")
                 return None
         
-        def generate_all_images(session_id, storyboard_content):
-            """Generate images for all panels"""
+        def generate_all_images(session_id, storyboard_content, character_profiles):
+            """Generate images for all panels using multi-threading"""
             if not REPLICATE_API_TOKEN:
                 return "<p style='color: red;'>Replicate API 토큰이 설정되지 않았습니다.</p>"
-            
-            # Parse panels and generate images
+    
+    # Parse storyboard to extract prompts
+            panel_prompts = []
+            lines = storyboard_content.split('\n')
+            current_panel_num = 0
+            current_prompt = ""
+    
+            for line in lines:
+                if '패널' in line or 'Panel' in line:
+                    if current_prompt and current_panel_num > 0:
+                        panel_prompts.append({
+                            'panel_id': f"ep1_panel{current_panel_num}",
+                            'panel_num': current_panel_num,
+                            'prompt': current_prompt
+                        })
+                    current_panel_num += 1
+                    current_prompt = ""
+                elif '이미지 프롬프트:' in line or 'Image prompt:' in line:
+                    current_prompt = line.split(':', 1)[1].strip()
+    
+    # Add last panel if exists
+            if current_prompt and current_panel_num > 0:
+                panel_prompts.append({
+                    'panel_id': f"ep1_panel{current_panel_num}",
+                    'panel_num': current_panel_num,
+                    'prompt': current_prompt
+                })
+    
+    # Limit to 30 panels
+            panel_prompts = panel_prompts[:30]
+    
+    # Generate images in parallel
+            image_generator = ImageGenerator()
+    
+    # Start generation with progress indication
+            image_html = "<div style='padding: 20px;'>"
+            image_html += "<h3>🖼️ 이미지 생성 중...</h3>"
+            image_html += f"<p>총 {len(panel_prompts)}개 패널 이미지를 동시에 생성합니다.</p>"
+    
+    # Generate images using multi-threading
+            results = image_generator.generate_multiple_images(
+                panel_prompts,
+                session_id,
+                max_workers=5  # Adjust based on API rate limits
+            )
+    
+    # Display results with regenerate buttons
             image_html = "<div style='padding: 20px;'>"
             image_html += "<h3>🖼️ 생성된 이미지</h3>"
-            
-            # This would iterate through panels and generate images
-            # For now, returning placeholder
-            for i in range(1, 31):
-                image_html += f"""
-                <div class="panel-image-container" id="panel_{i}_image">
-                    <p style='color: #999;'>패널 {i} 이미지 (생성 대기)</p>
-                </div>
-                """
-            
+    
+            success_count = sum(1 for r in results if r['status'] == 'success')
+            image_html += f"<p>✅ 성공: {success_count}/{len(results)} 패널</p>"
+    
+    # Display each panel's image with regenerate button
+            for result in results:
+                panel_num = int(result['panel_id'].split('_panel')[1])
+                panel_id = result['panel_id']
+        
+                if result['status'] == 'success':
+                    image_html += f"""
+                    <div class="panel-image-container" style="margin-bottom: 20px; border: 1px solid #ddd; padding: 15px; border-radius: 8px;">
+                        <h4>패널 {panel_num}</h4>
+                        <img src="{result['image_url']}" style="width: 100%; max-width: 600px; border-radius: 8px;" 
+                             id="image_{panel_id}">
+                        <p style="font-size: 12px; color: #666; margin-top: 10px;">
+                            프롬프트: {result.get('prompt', '')[:100]}...
+                        </p>
+                        <button onclick="regeneratePanel('{panel_id}', '{session_id}', `{result.get('prompt', '')}`)" 
+                                style="background: #764ba2; color: white; padding: 8px 16px; border: none; border-radius: 4px; cursor: pointer; margin-top: 10px;">
+                            🔄 재생성
+                        </button>
+                    </div>
+                    """
+                else:
+                    image_html += f"""
+                    <div class="panel-image-container" style="margin-bottom: 20px; background: #fee; padding: 15px; border-radius: 8px;">
+                        <h4>패널 {panel_num}</h4>
+                        <p style="color: red;">❌ 생성 실패: {result.get('message', 'Unknown error')}</p>
+                        <button onclick="regeneratePanel('{panel_id}', '{session_id}', '')" 
+                                style="background: #667eea; color: white; padding: 8px 16px; border: none; border-radius: 4px; cursor: pointer;">
+                            🎨 다시 생성
+                        </button>
+                    </div>
+                    """
+    
             image_html += "</div>"
             return image_html
-        
+
+        def regenerate_single_panel(panel_id: str, prompt: str, session_id: str) -> Dict:
+            """Regenerate a single panel image"""
+            if not REPLICATE_API_TOKEN:
+                return {"status": "error", "message": "No API token"}
+            
+            image_generator = ImageGenerator()
+            result = image_generator.generate_image(prompt, panel_id, session_id)
+            return result
+
+
         def clear_all_images():
             """Clear all generated images"""
             return """