Update app.py

app.py

@@ -10,6 +10,8 @@ from PIL import Image
 from typing import List, Tuple, Dict
 import zipfile
 from datetime import datetime
+import time
+import traceback
 
 # 환경 변수에서 토큰 가져오기
 REPLICATE_API_TOKEN = os.getenv("RAPI_TOKEN")
@@ -159,13 +161,14 @@ PPT_TEMPLATES = {
 
 def generate_prompt_with_llm(topic: str, style_example: str = None, slide_context: str = None) -> str:
     """주제와 스타일 예제를 받아서 LLM을 사용해 이미지 프롬프트를 생성"""
+    print(f"[LLM] 프롬프트 생성 시작: {slide_context}")
+    
     url = "https://api.friendli.ai/dedicated/v1/chat/completions"
     headers = {
         "Authorization": f"Bearer {FRIENDLI_TOKEN}",
         "Content-Type": "application/json"
     }
     
-    # PPT 제작을 위한 강화된 시스템 프롬프트
     system_prompt = """You are an expert image prompt engineer specializing in creating prompts for professional presentation slides. 
 
 Your task is to create prompts that:
@@ -208,20 +211,28 @@ Important guidelines:
     }
     
     try:
-        response = requests.post(url, json=payload, headers=headers)
+        response = requests.post(url, json=payload, headers=headers, timeout=30)
         if response.status_code == 200:
             result = response.json()
-            return result['choices'][0]['message']['content'].strip()
+            prompt = result['choices'][0]['message']['content'].strip()
+            print(f"[LLM] 프롬프트 생성 완료: {prompt[:50]}...")
+            return prompt
         else:
-            return f"프롬프트 생성 실패: {response.status_code}"
+            error_msg = f"프롬프트 생성 실패: {response.status_code}"
+            print(f"[LLM] {error_msg}")
+            return error_msg
     except Exception as e:
-        return f"프롬프트 생성 중 오류 발생: {str(e)}"
+        error_msg = f"프롬프트 생성 중 오류 발생: {str(e)}"
+        print(f"[LLM] {error_msg}")
+        return error_msg
 
 def translate_to_english(text: str) -> str:
     """한글 텍스트를 영어로 번역 (LLM 사용)"""
     if not any(ord('가') <= ord(char) <= ord('힣') for char in text):
         return text
     
+    print(f"[번역] 한글 감지, 영어로 번역 시작")
+    
     url = "https://api.friendli.ai/dedicated/v1/chat/completions"
     headers = {
         "Authorization": f"Bearer {FRIENDLI_TOKEN}",
@@ -246,23 +257,33 @@ def translate_to_english(text: str) -> str:
     }
     
     try:
-        response = requests.post(url, json=payload, headers=headers)
+        response = requests.post(url, json=payload, headers=headers, timeout=30)
         if response.status_code == 200:
             result = response.json()
-            return result['choices'][0]['message']['content'].strip()
+            translated = result['choices'][0]['message']['content'].strip()
+            print(f"[번역] 완료")
+            return translated
         else:
+            print(f"[번역] 실패, 원본 사용")
             return text
     except Exception as e:
+        print(f"[번역] 오류: {str(e)}, 원본 사용")
         return text
 
-def generate_image(prompt: str, seed: int = 10) -> Tuple[Image.Image, str]:
+def generate_image(prompt: str, seed: int = 10, slide_info: str = "") -> Tuple[Image.Image, str]:
     """Replicate API를 사용해 이미지 생성"""
+    print(f"\n[이미지 생성] {slide_info}")
+    print(f"[이미지 생성] 프롬프트: {prompt[:50]}...")
+    
     try:
         english_prompt = translate_to_english(prompt)
         
         if not REPLICATE_API_TOKEN:
-            return None, "RAPI_TOKEN 환경변수가 설정되지 않았습니다."
+            error_msg = "RAPI_TOKEN 환경변수가 설정되지 않았습니다."
+            print(f"[이미지 생성] 오류: {error_msg}")
+            return None, error_msg
         
+        print(f"[이미지 생성] Replicate API 호출 중...")
         client = replicate.Client(api_token=REPLICATE_API_TOKEN)
         
         input_params = {
@@ -272,28 +293,42 @@ def generate_image(prompt: str, seed: int = 10) -> Tuple[Image.Image, str]:
             "output_quality": 80
         }
         
+        start_time = time.time()
         output = client.run(
             "prunaai/hidream-l1-fast:17c237d753218fed0ed477cb553902b6b75735f48c128537ab829096ef3d3645",
             input=input_params
         )
         
+        elapsed = time.time() - start_time
+        print(f"[이미지 생성] API 응답 받음 ({elapsed:.1f}초)")
+        
         if output:
             if isinstance(output, str) and output.startswith('http'):
-                response = requests.get(output)
+                print(f"[이미지 생성] URL에서 이미지 다운로드 중...")
+                response = requests.get(output, timeout=30)
                 img = Image.open(BytesIO(response.content))
+                print(f"[이미지 생성] 완료!")
                 return img, english_prompt
             else:
+                print(f"[이미지 생성] 바이너리 데이터 처리 ���...")
                 img = Image.open(BytesIO(output.read()))
+                print(f"[이미지 생성] 완료!")
                 return img, english_prompt
         else:
-            return None, "이미지 생성 실패"
+            error_msg = "이미지 생성 실패 - 빈 응답"
+            print(f"[이미지 생성] {error_msg}")
+            return None, error_msg
             
     except Exception as e:
-        return None, f"오류: {str(e)}"
+        error_msg = f"오류: {str(e)}"
+        print(f"[이미지 생성] {error_msg}")
+        print(f"[이미지 생성] 상세 오류:\n{traceback.format_exc()}")
+        return None, error_msg
 
-def generate_ppt_images(topic: str, template_name: str, custom_slides: List[Dict], seed: int) -> Tuple[List[Dict], str]:
-    """PPT 템플릿에 따라 이미지 생성"""
+def generate_ppt_images_sequential(topic: str, template_name: str, custom_slides: List[Dict], seed: int, progress=gr.Progress()):
+    """PPT 템플릿에 따라 이미지를 순차적으로 생성하며 진행 상황 표시"""
     results = []
+    images_for_gallery = []
     
     # 템플릿 선택
     if template_name == "사용자 정의" and custom_slides:
@@ -302,69 +337,94 @@ def generate_ppt_images(topic: str, template_name: str, custom_slides: List[Dict
         slides = PPT_TEMPLATES[template_name]["slides"]
     
     if not slides:
-        return results, "슬라이드가 정의되지 않았습니다."
+        yield [], "슬라이드가 정의되지 않았습니다."
+        return
     
-    # 각 슬라이드에 대한 프롬프트 생성
-    prompts = []
-    for slide in slides:
+    total_slides = len(slides)
+    print(f"\n[PPT 생성] 시작 - 총 {total_slides}개 슬라이드")
+    print(f"[PPT 생성] 주제: {topic}")
+    print(f"[PPT 생성] 템플릿: {template_name}")
+    
+    # 각 슬라이드 순차 처리
+    for i, slide in enumerate(slides):
+        progress((i + 1) / (total_slides + 1), f"슬라이드 {i+1}/{total_slides} 처리 중...")
+        
+        slide_info = f"슬라이드 {i+1}: {slide['title']}"
+        status_msg = f"\n### 🔄 {slide_info} 생성 중...\n"
+        
+        # 현재까지의 상태 업데이트
+        yield images_for_gallery, status_msg + format_results_status(results)
+        
         style_key = slide["style"]
         if style_key in STYLE_TEMPLATES:
             style_info = STYLE_TEMPLATES[style_key]
             slide_context = f"{slide['title']} - {slide.get('prompt_hint', '')}"
+            
+            # 프롬프트 생성
             prompt = generate_prompt_with_llm(topic, style_info["example"], slide_context)
-            prompts.append({
-                "slide": slide,
-                "prompt": prompt,
-                "style_info": style_info
-            })
-    
-    # 병렬로 이미지 생성
-    with concurrent.futures.ThreadPoolExecutor(max_workers=5) as executor:
-        future_to_slide = {}
-        for i, prompt_data in enumerate(prompts):
-            # 각 슬라이드마다 다른 시드 사용하여 다양성 확보
+            
+            # 이미지 생성
             slide_seed = seed + i
-            future = executor.submit(generate_image, prompt_data["prompt"], slide_seed)
-            future_to_slide[future] = prompt_data
-        
-        for future in concurrent.futures.as_completed(future_to_slide):
-            prompt_data = future_to_slide[future]
-            try:
-                img, used_prompt = future.result()
-                results.append({
-                    "slide_title": prompt_data["slide"]["title"],
-                    "style": prompt_data["slide"]["style"],
-                    "image": img,
-                    "prompt": prompt_data["prompt"],
-                    "used_prompt": used_prompt,
-                    "success": img is not None
-                })
-            except Exception as e:
-                results.append({
-                    "slide_title": prompt_data["slide"]["title"],
-                    "style": prompt_data["slide"]["style"],
-                    "image": None,
-                    "prompt": prompt_data["prompt"],
-                    "used_prompt": str(e),
-                    "success": False
-                })
-    
-    # 결과 정리
+            img, used_prompt = generate_image(prompt, slide_seed, slide_info)
+            
+            # 결과 저장
+            result = {
+                "slide_title": slide["title"],
+                "style": slide["style"],
+                "image": img,
+                "prompt": prompt,
+                "used_prompt": used_prompt,
+                "success": img is not None
+            }
+            results.append(result)
+            
+            # 성공한 이미지는 갤러리에 추가
+            if img is not None:
+                caption = f"{i+1}. {slide['title']} ({style_info['name']})"
+                images_for_gallery.append((img, caption))
+                
+                status_msg = f"\n### ✅ {slide_info} 완료!\n"
+            else:
+                status_msg = f"\n### ❌ {slide_info} 실패: {used_prompt}\n"
+            
+            # 즉시 업데이트
+            yield images_for_gallery, status_msg + format_results_status(results)
+    
+    # 최종 결과
+    progress(1.0, "완료!")
     successful = sum(1 for r in results if r["success"])
-    status = f"총 {len(results)}개 슬라이드 중 {successful}개 이미지 생성 완료"
+    final_status = f"\n## 🎉 생성 완료!\n총 {total_slides}개 슬라이드 중 {successful}개 성공\n\n"
+    final_status += format_results_status(results)
     
-    return results, status
+    yield images_for_gallery, final_status
+
+def format_results_status(results: List[Dict]) -> str:
+    """결과를 상태 메시지로 포맷"""
+    if not results:
+        return ""
+    
+    status_lines = ["### 📊 생성 결과:\n"]
+    for i, result in enumerate(results):
+        if result["success"]:
+            status_lines.append(f"✅ **슬라이드 {i+1}: {result['slide_title']}**")
+            status_lines.append(f"   - 스타일: {result['style'].split('(')[0].strip()}")
+            status_lines.append(f"   - 프롬프트: {result['prompt'][:60]}...\n")
+        else:
+            status_lines.append(f"❌ **슬라이드 {i+1}: {result['slide_title']}** - 실패")
+            status_lines.append(f"   - 오류: {result['used_prompt']}\n")
+    
+    return "\n".join(status_lines)
 
 def create_custom_slides_ui():
     """사용자 정의 슬라이드 구성 UI"""
     slides = []
-    for i in range(10):  # 최대 10개 슬라이드
+    for i in range(10):
         with gr.Row():
             with gr.Column(scale=2):
                 title = gr.Textbox(
                     label=f"슬라이드 {i+1} 제목",
                     placeholder="예: 표지, 목차, 현황 분석...",
-                    visible=(i < 3)  # 처음 3개만 보이기
+                    visible=(i < 3)
                 )
             with gr.Column(scale=3):
                 style = gr.Dropdown(
@@ -381,24 +441,6 @@ def create_custom_slides_ui():
         slides.append({"title": title, "style": style, "hint": hint})
     return slides
 
-def format_results_for_display(results: List[Dict]) -> Tuple[List[Tuple[Image.Image, str]], str]:
-    """결과를 갤러리 표시용으로 포맷"""
-    images = []
-    details = []
-    
-    for i, result in enumerate(results):
-        if result["success"] and result["image"]:
-            caption = f"슬라이드 {i+1}: {result['slide_title']} ({result['style'].split('(')[0].strip()})"
-            images.append((result["image"], caption))
-            details.append(f"**슬라이드 {i+1}: {result['slide_title']}**\n"
-                         f"스타일: {result['style']}\n"
-                         f"프롬프트: {result['prompt']}\n")
-        else:
-            details.append(f"**슬라이드 {i+1}: {result['slide_title']}** - 생성 실패\n")
-    
-    details_text = "\n---\n".join(details)
-    return images, details_text
-
 # Gradio 인터페이스 생성
 with gr.Blocks(title="PPT 이미지 생성기", theme=gr.themes.Soft()) as demo:
     gr.Markdown("""
@@ -407,6 +449,12 @@ with gr.Blocks(title="PPT 이미지 생성기", theme=gr.themes.Soft()) as demo:
     ### 전문적인 프레젠테이션을 위한 맞춤형 이미지를 한 번에 생성하세요!
     """)
     
+    # API 토큰 상태 확인
+    if not REPLICATE_API_TOKEN:
+        gr.Markdown("⚠️ **경고**: RAPI_TOKEN 환경 변수가 설정되지 않았습니다.")
+    if not FRIENDLI_TOKEN:
+        gr.Markdown("⚠️ **경고**: FRIENDLI_TOKEN 환경 변수가 설정되지 않았습니다.")
+    
     with gr.Row():
         with gr.Column(scale=1):
             # 기본 입력
@@ -442,10 +490,14 @@ with gr.Blocks(title="PPT 이미지 생성기", theme=gr.themes.Soft()) as demo:
             with gr.Accordion("📝 사용자 정의 슬라이드 구성", open=False) as custom_accordion:
                 gr.Markdown("템플릿을 사용하지 않고 직접 슬라이드를 구성하세요.")
                 custom_slides_components = create_custom_slides_ui()
-                add_slide_btn = gr.Button("슬라이드 추가", size="sm")
             
         with gr.Column(scale=2):
-            # 결과 표시
+            # 진행 상황 표시
+            status_output = gr.Markdown(
+                value="### 👆 템플릿을 선택하고 생성 버튼을 클릭하세요!\n\n생성 진행 상황이 실시간으로 표시됩니다."
+            )
+            
+            # 결과 갤러리
             output_gallery = gr.Gallery(
                 label="생성된 PPT 이미지",
                 show_label=True,
@@ -453,11 +505,7 @@ with gr.Blocks(title="PPT 이미지 생성기", theme=gr.themes.Soft()) as demo:
                 columns=3,
                 rows=3,
                 object_fit="contain",
-                height="600"
-            )
-            
-            details_output = gr.Markdown(
-                value="생성된 이미지의 상세 정보가 여기에 표시됩니다."
+                height="auto"
             )
     
     # 스타일 가이드
@@ -476,10 +524,8 @@ with gr.Blocks(title="PPT 이미지 생성기", theme=gr.themes.Soft()) as demo:
     
     1. **템플릿 활용**: 목적에 맞는 템플릿을 선택하면 최적화된 슬라이드 구성을 제공합니다
     2. **일관성**: 하나의 주제로 전체 슬라이드를 생성하여 시각적 일관성을 유지합니다
-    3. **커스터마이징**: 생성된 이미지 위에 텍스트와 로고를 추가하여 완성하세요
+    3. **실시간 확인**: 각 슬라이드가 생성될 때마다 진행 상황을 확인할 수 있습니다
     4. **고화질**: 모든 이미지는 프레젠테이션에 적합한 고해상도로 생성됩니다
-    
-    **추천 워크플로우**: 템플릿 선택 → 주제 입력 → 이미지 생성 → PPT에 삽입 → 텍스트 추가
     """)
     
     # 이벤트 핸들러
@@ -492,9 +538,10 @@ with gr.Blocks(title="PPT 이미지 생성기", theme=gr.themes.Soft()) as demo:
             return info
         return ""
     
-    def generate_ppt_images_handler(topic, template_name, seed, *custom_inputs):
+    def generate_ppt_images_handler(topic, template_name, seed, progress=gr.Progress(), *custom_inputs):
         if not topic.strip():
-            return [], "주제를 입력해주세요."
+            yield [], "❌ 주제를 입력해주세요."
+            return
         
         # 사용자 정의 슬라이드 처리
         custom_slides = []
@@ -511,13 +558,9 @@ with gr.Blocks(title="PPT 이미지 생성기", theme=gr.themes.Soft()) as demo:
                         "prompt_hint": hint
                     })
         
-        # 이미지 생성
-        results, status = generate_ppt_images(topic, template_name, custom_slides, seed)
-        
-        # 결과 포맷팅
-        images, details = format_results_for_display(results)
-        
-        return images, f"{status}\n\n{details}"
+        # 순차적으로 이미지 생성하며 진행 상황 표시
+        for gallery, status in generate_ppt_images_sequential(topic, template_name, custom_slides, seed, progress):
+            yield gallery, status
     
     # 이벤트 연결
     template_select.change(
@@ -538,23 +581,9 @@ with gr.Blocks(title="PPT 이미지 생성기", theme=gr.themes.Soft()) as demo:
     generate_btn.click(
         fn=generate_ppt_images_handler,
         inputs=[topic_input, template_select, seed_input] + all_custom_inputs,
-        outputs=[output_gallery, details_output]
+        outputs=[output_gallery, status_output]
     )
     
-    # 슬라이드 추가 버튼 (간단한 가시성 토글)
-    def show_more_slides(*current_values):
-        # 더 많은 슬라이드 입력 필드 표시 로직
-        updates = []
-        for i, val in enumerate(current_values):
-            if i % 3 == 0:  # title fields
-                if not val and i > 6:  # 처음 3개 이후
-                    updates.append(gr.update(visible=False))
-                else:
-                    updates.append(gr.update(visible=True))
-            else:
-                updates.append(gr.update(visible=updates[-3].visible if i % 3 == 1 else updates[-2].visible))
-        return updates
-    
     # 초기 템플릿 정보 표시
     demo.load(
         fn=update_template_info,
@@ -564,10 +593,21 @@ with gr.Blocks(title="PPT 이미지 생성기", theme=gr.themes.Soft()) as demo:
 
 # 앱 실행
 if __name__ == "__main__":
+    print("\n" + "="*50)
+    print("🚀 PPT 이미지 생성기 시작!")
+    print("="*50)
+    
     # 환경 변수 확인
     if not REPLICATE_API_TOKEN:
-        print("경고: RAPI_TOKEN 환경 변수가 설정되지 않았습니다.")
+        print("⚠️  경고: RAPI_TOKEN 환경 변수가 설정되지 않았습니다.")
+    else:
+        print("✅ RAPI_TOKEN 확인됨")
+        
     if not FRIENDLI_TOKEN:
-        print("경고: FRIENDLI_TOKEN 환경 변수가 설정되지 않았습니다.")
+        print("⚠️  경고: FRIENDLI_TOKEN 환경 변수가 설정되지 않았습니다.")
+    else:
+        print("✅ FRIENDLI_TOKEN 확인됨")
+    
+    print("="*50 + "\n")
     
     demo.launch()