Update app-backup.py

app-backup.py

@@ -537,67 +537,93 @@ class ImageGenerator:
             enhanced_prompt = core_elements
     
         return enhanced_prompt  # 올바른 인덴테이션
-   
+
+    
     def generate_image(self, prompt: str, panel_id: str, session_id: str, 
                       scene_type: str = "medium", genre: str = "로맨스", 
+                      force_regenerate: bool = False,  # 재생성 강제 플래그 추가
                       progress_callback=None) -> Dict[str, Any]:
-        """Generate image using qwen/qwen-image with webtoon optimization and auto-resize to 690x1227"""
+        """Generate image using qwen/qwen-image with regeneration support"""
         try:
             if not REPLICATE_API_TOKEN:
                 logger.warning("No Replicate API token")
                 return {"panel_id": panel_id, "status": "error", "message": "No API token"}
             
-            # Fix: Use panel_id to extract panel_number
+            # 캐시 키 생성
+            cache_key = f"{session_id}_{panel_id}"
+            
+            # force_regenerate가 True이면 캐시 무시하고 새로 생성
+            if not force_regenerate and cache_key in generated_images_cache:
+                logger.info(f"Using cached image for {panel_id}")
+                # 캐시된 이미지 반환하지 않고 새로 생성하도록 수정
+                # return {"panel_id": panel_id, "status": "success", "image_url": generated_images_cache[cache_key]}
+                pass  # 캐시 무시하고 계속 진행
+            
+            # Panel number 추출
             panel_number = int(re.findall(r'\d+', panel_id)[-1]) if re.findall(r'\d+', panel_id) else 1
             
             # 웹툰 스타일 프롬프트 강화
             enhanced_prompt = self.enhance_prompt_for_webtoon(prompt, panel_number, scene_type, genre)
             
-            # qwen/qwen-image 파라미터 설정 (지원되는 옵션들)
+            # 재생성 시 프롬프트에 변화 추가 (더 다양한 결과를 위해)
+            if force_regenerate or cache_key in generated_images_cache:
+                # 프롬프트에 약간의 변화 추가
+                variation_keywords = [
+                    "different angle", "alternative view", "varied perspective",
+                    "new composition", "fresh approach", "revised scene",
+                    "different lighting", "alternative mood", "varied atmosphere"
+                ]
+                variation = random.choice(variation_keywords)
+                enhanced_prompt = f"{enhanced_prompt}, {variation}"
+                logger.info(f"Regenerating with variation: {variation}")
+            
+            # 재생성 시 다른 seed 사용하여 다른 이미지 생성 보장
+            if force_regenerate or cache_key in generated_images_cache:
+                # 랜덤 seed 생성 (1-1000000 범위)
+                random_seed = random.randint(1, 1000000)
+                logger.info(f"Using random seed for regeneration: {random_seed}")
+            else:
+                # 첫 생성 시에도 랜덤 seed 사용
+                random_seed = random.randint(1, 1000000)
+            
+            # qwen/qwen-image 파라미터 설정
             input_params = {
                 "prompt": enhanced_prompt,
-                "aspect_ratio": "9:16",  # 세로형 웹툰 포맷 (9:16, 16:9, 1:1, 4:3, 3:4 등 지원)
-                "num_outputs": 1,  # 생성할 이미지 수
-                "guidance_scale": 4.5,  # 프롬프트 충실도 (1-10, 높을수록 프롬프트에 충실)
-                "num_inference_steps": 50,  # 생성 단계 수 (더 높으면 품질 향상, 속도 감소)
-                "output_format": "jpg",  # JPG 포맷으로 변경 (웹툰에 적합)
-                "output_quality": 95,  # 이미지 품질 (1-100, jpg/webp에만 적용)
-                "disable_safety_checker": False,  # 안전 검사 비활성화 (기본: False)
+                "aspect_ratio": "9:16",
+                "num_outputs": 1,
+                "guidance_scale": 4.5 + random.uniform(-0.5, 0.5),  # 약간의 랜덤성 추가
+                "num_inference_steps": 50,
+                "output_format": "jpg",
+                "output_quality": 95,
+                "disable_safety_checker": False,
                 "negative_prompt": "comic strip, multiple panels, divided frames, split screen, grid layout, manga panels",
-                "seed": -1  # 시드값 (-1은 랜덤)
+                "seed": random_seed  # 명시적으로 랜덤 seed 설정
             }
             
-            logger.info(f"Generating image for panel {panel_id} with qwen/qwen-image")
-            logger.info(f"Prompt (first 200 chars): {enhanced_prompt[:200]}...")
+            logger.info(f"Generating {'new variant' if force_regenerate else 'image'} for panel {panel_id}")
+            logger.info(f"Seed: {random_seed}, Guidance: {input_params['guidance_scale']:.2f}")
             
             try:
-                # Replicate API 호출 - qwen/qwen-image 사용
+                # Replicate API 호출
                 output = replicate.run(
                     "qwen/qwen-image",
                     input=input_params
                 )
                 
                 if output:
-                    # qwen/qwen-image는 FileObject 리스트를 반환
-                    # 예제처럼 .url() 메서드를 사용
+                    # 이미지 URL 추출
                     if isinstance(output, list) and len(output) > 0:
-                        # 첫 번째 이미지 가져오기
                         image_item = output[0]
-                        
-                        # FileObject의 url() 메서드 호출
                         if hasattr(image_item, 'url'):
                             if callable(image_item.url):
                                 image_url = image_item.url()
                             else:
                                 image_url = image_item.url
                         else:
-                            # 문자열로 변환 시도
                             image_url = str(image_item)
                     elif isinstance(output, str):
-                        # 직접 URL 문자열인 경우
                         image_url = output
                     else:
-                        # 기타 형식 처리
                         image_url = str(output)
                     
                     # URL 유효성 확인
@@ -605,7 +631,7 @@ class ImageGenerator:
                         logger.error(f"Invalid image URL: {image_url}")
                         return {"panel_id": panel_id, "status": "error", "message": "Invalid image URL format"}
                     
-                    # 이미지를 690x1227로 리사이즈
+                    # 이미지 리사이즈
                     logger.info(f"Resizing image to {WEBTOON_IMAGE_WIDTH}x{WEBTOON_IMAGE_HEIGHT}px")
                     resized_image_url = self.resize_image_from_url(
                         image_url, 
@@ -613,18 +639,19 @@ class ImageGenerator:
                         WEBTOON_IMAGE_HEIGHT
                     )
                     
-                    # 캐시 저장 (리사이즈된 이미지 URL 저장)
-                    cache_key = f"{session_id}_{panel_id}"
+                    # 캐시 업데이트 (재생성 시에도 새 이미지로 덮어쓰기)
                     generated_images_cache[cache_key] = resized_image_url
                     
-                    logger.info(f"Successfully generated and resized image for panel {panel_id}")
+                    logger.info(f"Successfully generated {'variant' if force_regenerate else 'image'} for panel {panel_id}")
                     return {
                         "panel_id": panel_id,
                         "status": "success",
-                        "image_url": resized_image_url,  # 리사이즈된 이미지 URL 반환
-                        "original_url": image_url,  # 원본 URL도 저장
+                        "image_url": resized_image_url,
+                        "original_url": image_url,
                         "prompt": enhanced_prompt,
-                        "size": f"{WEBTOON_IMAGE_WIDTH}x{WEBTOON_IMAGE_HEIGHT}"  # 크기 정보 추가
+                        "size": f"{WEBTOON_IMAGE_WIDTH}x{WEBTOON_IMAGE_HEIGHT}",
+                        "seed": random_seed,  # seed 정보 반환
+                        "regenerated": force_regenerate  # 재생성 여부 표시
                     }
                 else:
                     logger.error(f"No output from qwen/qwen-image for panel {panel_id}")
@@ -641,6 +668,8 @@ class ImageGenerator:
             logger.error(f"Image generation error: {e}", exc_info=True)
             return {"panel_id": panel_id, "status": "error", "message": str(e)}
 
+
+
 # --- LLM Integration ---
 class WebtoonSystem:
    """Webtoon planning and storyboard generation system"""
@@ -1959,68 +1988,133 @@ def create_interface():
         
 # 주요 수정 부분만 포함한 패치 코드
         # generate_selected_panel_images 함수 수정
-        def generate_selected_panel_images(panel_data, selected_panels, session_id, character_profiles, webtoon_system, panel_prompts, genre, progress=gr.Progress()):
-            """Generate images for selected panels only - 수정된 버전"""
+        def generate_selected_panel_images_fixed(panel_data, selected_panels, session_id, 
+                                               character_profiles, webtoon_system, 
+                                               panel_prompts, genre, progress=gr.Progress()):
+            """Generate images for selected panels with regeneration support"""
             if not REPLICATE_API_TOKEN:
-                html, _ = display_panels_with_editable_prompts(panel_data, panel_prompts, session_id, character_profiles, webtoon_system, genre)
-                return panel_data, html, gr.update(visible=True, value="⚠️ Replicate API 토큰이 설정되지 않았습니다.")
-            
+               html, _ = display_panels_with_editable_prompts(panel_data, panel_prompts, 
+                                                             session_id, character_profiles, 
+                                                             webtoon_system, genre)
+               return panel_data, html, gr.update(visible=True, value="⚠️ Replicate API 토큰이 설정되지 않았습니다.")
+           
             if not panel_data:
-                html, _ = display_panels_with_editable_prompts(panel_data, panel_prompts, session_id, character_profiles, webtoon_system, genre)
-                return panel_data, html, gr.update(visible=True, value="⚠️ 패널 데이터가 없습니다.")
-            
+               html, _ = display_panels_with_editable_prompts(panel_data, panel_prompts, 
+                                                             session_id, character_profiles, 
+                                                             webtoon_system, genre)
+               return panel_data, html, gr.update(visible=True, value="⚠️ 패널 데이터가 없습니다.")
+           
             if not selected_panels:
-                html, _ = display_panels_with_editable_prompts(panel_data, panel_prompts, session_id, character_profiles, webtoon_system, genre)
-                return panel_data, html, gr.update(visible=True, value="⚠️ 생성할 패널을 선택하세요.")
-            
+               html, _ = display_panels_with_editable_prompts(panel_data, panel_prompts, 
+                                                             session_id, character_profiles, 
+                                                             webtoon_system, genre)
+               return panel_data, html, gr.update(visible=True, value="⚠️ 생성할 패널을 선택하세요.")
+           
             if not webtoon_system:
-                webtoon_system = WebtoonSystem()
-                webtoon_system.current_genre = genre
-            
+               webtoon_system = WebtoonSystem()
+               webtoon_system.current_genre = genre
+           
             selected_numbers = [int(p.split()[1]) for p in selected_panels]
             total = len(selected_numbers)
             successful = 0
-            
-            # panel_data를 복사하여 작업 (원본 보존)
+            regenerated = 0
+           
+           # panel_data를 복사하여 작업
             updated_panel_data = panel_data.copy()
-            
+           
             for i, panel in enumerate(updated_panel_data):
                 if panel['number'] in selected_numbers:
                     idx = selected_numbers.index(panel['number'])
                     progress((idx / total), desc=f"패널 {panel['number']} 생성 중...")
-                    
+                   
                     panel_id = f"panel_{panel['number']}"
                     prompt = panel_prompts.get(panel_id, panel.get('prompt', ''))
-                    
+                   
+                   # 이미 이미지가 있는지 확인
+                    has_existing_image = bool(panel.get('image_url'))
+                   
                     if prompt:
                         try:
                             panel['prompt'] = prompt
-                            
-                            if not panel.get('prompt_en'):
-                                panel['prompt_en'] = webtoon_system.translate_prompt_to_english(
-                                    prompt, character_profiles
-                                )
-                            
+                           
+                           # 영어 프롬프트 번역
+                            if not panel.get('prompt_en') or has_existing_image:
+                               # 재생성 시 프롬프트 다시 번역
+                               panel['prompt_en'] = webtoon_system.translate_prompt_to_english(
+                                   prompt, character_profiles
+                               )
+                           
+                           # 이미지 생성 (재생성 플래그 포함)
                             result = webtoon_system.image_generator.generate_image(
-                                panel['prompt_en'],
-                                f"ep1_panel{panel['number']}",
-                                session_id,
-                                scene_type=panel.get('scene_type', 'medium'),
-                                genre=genre
+                               panel['prompt_en'],
+                               f"ep1_panel{panel['number']}",
+                               session_id,
+                               scene_type=panel.get('scene_type', 'medium'),
+                               genre=genre,
+                               force_regenerate=has_existing_image  # 기존 이미지가 있으면 재생성
                             )
-                            
+                           
                             if result['status'] == 'success':
                                 panel['image_url'] = result['image_url']
                                 successful += 1
+                                if result.get('regenerated'):
+                                    regenerated += 1
+                               
+                               # seed 정보 저장 (디버깅용)
+                                if 'seed' in result:
+                                    panel['last_seed'] = result['seed']
+                                   
                         except Exception as e:
                             logger.error(f"Error generating panel {panel['number']}: {e}")
-                        
+                       
+                       # API 부하 방지를 위한 딜레이
                         time.sleep(0.5)
-            
-            progress(1.0, desc=f"완료! {successful}/{total} 패널 생성 성공")
-            html, _ = display_panels_with_editable_prompts(updated_panel_data, panel_prompts, session_id, character_profiles, webtoon_system, genre)
+           
+            status_msg = f"완료! {successful}/{total} 패널 생성 성공"
+            if regenerated > 0:
+               status_msg += f" (재생성: {regenerated}개)"
+           
+            progress(1.0, desc=status_msg)
+            html, _ = display_panels_with_editable_prompts(updated_panel_data, panel_prompts, 
+                                                          session_id, character_profiles, 
+                                                          webtoon_system, genre)
             return updated_panel_data, html, gr.update(visible=False)
 
+        def clear_image_cache(session_id=None):
+            """이미지 캐시 클리어"""
+            global generated_images_cache
+    
+            if session_id:
+                # 특정 세션의 캐시만 클리어
+                keys_to_remove = [k for k in generated_images_cache.keys() if k.startswith(f"{session_id}_")]
+                for key in keys_to_remove:
+                    del generated_images_cache[key]
+                logger.info(f"Cleared {len(keys_to_remove)} cached images for session {session_id}")
+            else:
+                # 전체 캐시 클리어
+                cache_size = len(generated_images_cache)
+                generated_images_cache.clear()
+                logger.info(f"Cleared all {cache_size} cached images")
+
+
+        def clear_all_images_with_cache(panel_data, panel_prompts, session_id, 
+                                       character_profiles, webtoon_system, genre):
+            """Clear all images and cache"""
+            # 캐시 클리어
+            clear_image_cache(session_id)
+    
+    # panel_data를 복사하여 수정
+            updated_panel_data = panel_data.copy()
+            for panel in updated_panel_data:
+                panel['image_url'] = None
+                panel.pop('last_seed', None)  # seed 정보도 제거
+    
+            html, _ = display_panels_with_editable_prompts(updated_panel_data, panel_prompts, 
+                                                          session_id, character_profiles, 
+                                                          webtoon_system, genre)
+            return updated_panel_data, html
+
+        
         # generate_all_panel_images 함수 수정
         def generate_all_panel_images(panel_data, session_id, character_profiles, webtoon_system, panel_prompts, genre, progress=gr.Progress()):
             """Generate images for all panels - 수정된 버전"""
@@ -2288,11 +2382,23 @@ def create_interface():
             inputs=[panel_data_state],
             outputs=[panel_data_state, generation_progress]
         ).then(
-            fn=generate_selected_panel_images,
-            inputs=[panel_data_state, panel_selector, current_session_id, character_profiles_state, webtoon_system, panel_prompts_state, current_genre],
-            outputs=[panel_data_state, panels_display, generation_progress]  # panel_data_state 출력 추가
+            fn=generate_selected_panel_images_fixed,  # 수정된 함수 이름 사용
+            inputs=[panel_data_state, panel_selector, current_session_id, 
+                    character_profiles_state, webtoon_system, panel_prompts_state, current_genre],
+            outputs=[panel_data_state, panels_display, generation_progress]
+        )
+
+# clear_all_images_with_cache 함수도 이벤트 핸들러에서 사용
+        clear_images_btn.click(
+            fn=clear_all_images_with_cache,  # 캐시 클리어 기능이 포함된 버전 사용
+            inputs=[panel_data_state, panel_prompts_state, current_session_id, 
+                    character_profiles_state, webtoon_system, current_genre],
+            outputs=[panel_data_state, panels_display]
         )
 
+
+
+
 # 모든 패널 이미지 생성 - panel_data_state 업데이트 추가
         generate_all_images_btn.click(
             fn=lambda pd: (pd, gr.update(visible=True, value="모든 패널 이미지 생성 시작...")),
@@ -2304,12 +2410,7 @@ def create_interface():
             outputs=[panel_data_state, panels_display, generation_progress]  # panel_data_state 출력 추가
         )
 
-# 이미지 초기화 - panel_data_state 업데이트 추가
-        clear_images_btn.click(
-            fn=clear_all_images,
-            inputs=[panel_data_state, panel_prompts_state, current_session_id, character_profiles_state, webtoon_system, current_genre],
-            outputs=[panel_data_state, panels_display]  # panel_data_state 출력 추가
-        )
+
 
 # 전체 이미지 다운로드 - 수정된 메시지
         download_all_images_btn.click(