Update app.py

app.py

@@ -148,7 +148,8 @@ from concurrent.futures import ThreadPoolExecutor
 
 # ────────────────────────────────────────────────────────────
 
-
+import httpx
+from datetime import datetime
 
 
 # 환경 변수 설정으로 torch.load 체크 우회 (임시 해결책)
@@ -206,8 +207,12 @@ TRANSLATOR = None
 # API URLs
 TEXT2IMG_API_URL = "http://211.233.58.201:7896"
 VIDEO_API_URL = "http://211.233.58.201:7875"
-AVATAR_API_URL = "http://211.233.58.201:7862"
 
+ANIM_API_URL = os.getenv("ANIM_API_URL", "http://211.233.58.201:7862/")
+
+# HTTP 타임아웃 설정
+ANIM_TIMEOUT = httpx.Timeout(connect=30.0, read=120.0, write=120.0, pool=30.0
+                             
 # Image size presets
 IMAGE_PRESETS = {
     "커스텀": {"width": 1024, "height": 1024},
@@ -988,130 +993,83 @@ def merge_videos_with_audio(video_files, audio_file, audio_mode, audio_volume, o
         traceback.print_exc()
         return None, f"❌ 오류 발생: {str(e)}"
 
-@spaces.GPU(duration=180)
-def generate_avatar_animation(portrait_image, driving_audio, guidance_scale, inference_steps):
+
+def test_anim_api_connection():
+    """애니메이션 서버 연결 테스트"""
+    now = datetime.now().strftime("%H:%M:%S")
+    try:
+        resp = httpx.get(f"{ANIM_API_URL.rstrip('/')}/healthz", timeout=ANIM_TIMEOUT)
+        ready = resp.json().get("ready", False)
+        msg = f"[{now}] 애니메이션 서버 연결 성공 ✅ (ready={ready})"
+        logging.info(msg)
+        return True, msg
+    except Exception as e:
+        msg = f"[{now}] 애니메이션 서버 연결 실패 ❌ : {e}"
+        logging.error(msg)
+        return False, msg
+
+def generate_avatar_animation(image, audio, guidance_scale, steps, progress=gr.Progress()):
     """이미지와 오디오로 아바타 애니메이션 생성"""
-    if portrait_image is None:
-        return None, None, "초상화 이미지를 업로드해주세요."
-    
-    if driving_audio is None:
-        return None, None, "오디오 파일을 업로드해주세요."
+    start = datetime.now().strftime("%H:%M:%S")
+    logs = [f"[{start}] 요청 시작"]
     
     try:
-        # 상태 업데이트
-        status = "아바타 생성 시작..."
-        
-        # 이미지 처리 - filepath로 받으므로 직접 사용
-        portrait_path = portrait_image
-        
-        # 이미지가 실제로 존재하는지 확인
-        if not os.path.exists(portrait_path):
-            # 만약 numpy array나 PIL 이미지로 왔다면 저장
-            with tempfile.NamedTemporaryFile(suffix=".png", delete=False) as fp:
-                temp_portrait_path = fp.name
-                if isinstance(portrait_image, np.ndarray):
-                    Image.fromarray(portrait_image).save(temp_portrait_path)
-                elif isinstance(portrait_image, Image.Image):
-                    portrait_image.save(temp_portrait_path)
-                else:
-                    return None, None, "❌ 이미지 형식을 인식할 수 없습니다."
-                portrait_path = temp_portrait_path
-        
-        # 오디오 경로 확인
-        audio_path = driving_audio
-        
-        # 경로 로깅
-        logging.info(f"Portrait path: {portrait_path}")
-        logging.info(f"Audio path: {audio_path}")
-        logging.info(f"Guidance Scale: {guidance_scale}")
-        logging.info(f"Inference Steps: {inference_steps}")
+        if image is None or audio is None:
+            raise ValueError("이미지와 오디오를 모두 업로드하세요.")
         
-        # 파일 존재 확인
-        if not os.path.exists(portrait_path):
-            return None, None, f"❌ 이미지 파일을 찾을 수 없습니다: {portrait_path}"
+        progress(0.05, desc="파일 준비")
+        client = Client(ANIM_API_URL)
         
-        if not os.path.exists(audio_path):
-            return None, None, f"❌ 오디오 파일을 찾을 수 없습니다: {audio_path}"
-        
-        # API 연결 재시도 로직
-        max_retries = 3
-        retry_delay = 5  # 초
+        progress(0.15, desc="서버 호출 중… (수 분 소요 가능)")
+        result = client.predict(
+            image_path=handle_file(image),
+            audio_path=handle_file(audio),
+            guidance_scale=guidance_scale,
+            steps=steps,
+            api_name="/generate_animation"
+        )
         
-        for attempt in range(max_retries):
-            try:
-                logging.info(f"API 연결 시도 {attempt + 1}/{max_retries}")
-                
-                # 간단한 Client 생성 (timeout 매개변수 없이)
-                client = Client(AVATAR_API_URL)
-                
-                logging.info("API 클라이언트 생성 성공")
-                
-                # API 호출
-                result = client.predict(
-                    portrait_path,  # 직접 경로 전달
-                    audio_path,     # 직접 경로 전달
-                    float(guidance_scale),
-                    float(inference_steps),
-                    api_name="/generate_animation"
-                )
-                
-                # 성공하면 루프 종료
-                break
-                
-            except Exception as e:
-                logging.warning(f"API 호출 오류 (시도 {attempt + 1}/{max_retries}): {str(e)}")
-                if "Connection" in str(e) or "Timeout" in str(e):
-                    if attempt < max_retries - 1:
-                        logging.info(f"{retry_delay}초 후 재시도...")
-                        time.sleep(retry_delay)
-                    else:
-                        return None, None, "❌ API 서버에 연결할 수 없습니다. 잠시 후 다시 시도해주세요."
+        progress(0.95, desc="결과 정리")
+        
+        # 결과 처리 - dict 형태 처리 추가
+        def extract_video_path(obj):
+            """비디오 객체에서 경로 추출"""
+            if isinstance(obj, str):
+                return obj
+            elif isinstance(obj, dict):
+                # Gradio의 FileData dict 처리
+                if 'video' in obj:
+                    return obj['video']  # {'video': '경로', 'subtitles': None} 형태 처리
+                elif 'path' in obj:
+                    return obj['path']
+                elif 'url' in obj:
+                    return obj['url']
+                elif 'name' in obj:
+                    return obj['name']
                 else:
-                    # 다른 예외는 즉시 처리
-                    raise e
-        
-        # 임시 파일 삭제 (있는 경우)
-        if 'temp_portrait_path' in locals() and os.path.exists(temp_portrait_path):
-            os.unlink(temp_portrait_path)
-        
-        # 결과 처리
-        if result and len(result) >= 2:
-            animation_result = result[0]
-            comparison_result = result[1]
-            
-            # 결과가 dict인지 직접 경로인지 확인
-            if isinstance(animation_result, dict):
-                animation_video = animation_result.get("video")
-            else:
-                animation_video = animation_result
-                
-            if isinstance(comparison_result, dict):
-                comparison_video = comparison_result.get("video")
+                    logging.warning(f"Unexpected dict structure: {obj.keys()}")
+                    return None
             else:
-                comparison_video = comparison_result
+                logging.warning(f"Unexpected type: {type(obj)}")
+                return None
+        
+        if isinstance(result, (list, tuple)) and len(result) >= 2:
+            anim_path = extract_video_path(result[0])
+            comp_path = extract_video_path(result[1])
             
-            # 비디오 파일 존재 확인
-            if animation_video and os.path.exists(str(animation_video)):
-                logging.info(f"Animation video created: {animation_video}")
-            else:
-                logging.warning(f"Animation video not found or invalid: {animation_video}")
-                
-            if comparison_video and os.path.exists(str(comparison_video)):
-                logging.info(f"Comparison video created: {comparison_video}")
+            if anim_path and comp_path:
+                logs.append(f"[{datetime.now().strftime('%H:%M:%S')}] 성공")
+                return anim_path, comp_path, "\n".join(logs)
             else:
-                logging.warning(f"Comparison video not found or invalid: {comparison_video}")
-            
-            return animation_video, comparison_video, "✅ 아바타 애니메이션 생성 완료!"
+                raise RuntimeError(f"비디오 경로 추출 실패: {result}")
         else:
-            logging.error(f"Unexpected API response: {result}")
-            return None, None, "❌ API 응답이 예상과 다릅니다."
-            
+            raise RuntimeError(f"예상치 못한 반환 형식: {type(result)}")
+    
     except Exception as e:
-        logging.error(f"Avatar generation error: {str(e)}")
-        import traceback
-        traceback.print_exc()
-        return None, None, f"❌ 오류 발생: {str(e)}"
-
+        logs.append(f"[{datetime.now().strftime('%H:%M:%S')}] 오류: {e}")
+        logging.error(f"Avatar animation generation error: {e}", exc_info=True)
+        return None, None, "\n".join(logs)
+        
 # CSS
 css = """
 :root {
@@ -1137,13 +1095,16 @@ css = """
     padding: 20px !important;
     margin-bottom: 20px !important;
 }
-#generate-btn, #video-btn, #outpaint-btn, #preview-btn, #audio-btn, #bg-remove-btn, #merge-btn, #avatar-btn {
+#generate-btn, #video-btn, #outpaint-btn, #preview-btn, #audio-btn, #bg-remove-btn, #merge-btn, #avatar-btn, #test-connection-btn {
     background: linear-gradient(135deg, #ff9a9e, #fad0c4) !important;
     font-size: 1.1rem !important;
     padding: 12px 24px !important;
     margin-top: 10px !important;
     width: 100% !important;
 }
+#avatar-btn, #test-connection-btn {
+    background: linear-gradient(135deg, #667eea, #764ba2) !important;
+}
 .tabitem {
     min-height: 700px !important;
 }
@@ -1543,74 +1504,229 @@ with demo:
                         **참고**: GPU 제한으로 한 번에 약 200프레임까지 처리 가능합니다.
                         긴 비디오는 작은 조각으로 나누어 처리하세요.
                         """)
-    
+
+
+
         # 여섯 번째 탭: 이미지to아바타
         with gr.Tab("이미지to아바타", elem_classes="tabitem"):
             with gr.Row(equal_height=True):
                 # 입력 컬럼
                 with gr.Column(scale=1):
                     with gr.Group(elem_classes="panel-box"):
-                        gr.Markdown("### 🖼️ 초상화 이미지 업로드")
+                        gr.Markdown("### 🎭 아바타 애니메이션 생성")
+                        gr.Markdown("""
+                        포트레이트 이미지와 오디오를 업로드하면 말하는 아바타 애니메이션을 생성합니다.
+                        
+                        **권장 사항**:
+                        - 이미지: 정면을 보고 있는 얼굴 사진
+                        - 오디오: 명확한 음성이 담긴 오디오 파일
+                        """)
                         
-                        avatar_portrait = gr.Image(
-                            label="초상화 이미지 (아무 비율 가능)",
+                        avatar_image = gr.Image(
+                            label="포트레이트 이미지",
                             type="filepath",
-                            sources=["upload"]
+                            elem_classes="panel-box"
                         )
                         
+                        avatar_audio = gr.Audio(
+                            label="드라이빙 오디오",
+                            type="filepath",
+                            elem_classes="panel-box"
+                        )
+                    
                     with gr.Group(elem_classes="panel-box"):
-                        gr.Markdown("### 🎵 오디오 업로드")
+                        gr.Markdown("### ⚙️ 생성 설정")
                         
-                        avatar_audio = gr.Audio(
-                            label="구동 오디오",
+                        guidance_scale = gr.Slider(
+                            minimum=1.0,
+                            maximum=10.0,
+                            value=3.0,
+                            step=0.1,
+                            label="가이던스 스케일",
+                            info="높을수록 오디오에 더 충실한 움직임 생성"
+                        )
+                        
+                        inference_steps = gr.Slider(
+                            minimum=5,
+                            maximum=30,
+                            value=10,
+                            step=1,
+                            label="추론 스텝",
+                            info="높을수록 품질이 좋아지지만 생성 시간이 증가"
+                        )
+                        
+                        # 서버 상태 체크
+                        with gr.Row():
+                            test_connection_btn = gr.Button(
+                                "🔌 서버 연결 테스트",
+                                elem_id="test-connection-btn",
+                                scale=1
+                            )
+                        
+                        anim_status = gr.Textbox(
+                            label="서버 상태",
+                            interactive=False,
+                            elem_classes="panel-box"
+                        )
+                        
+                        generate_avatar_btn = gr.Button(
+                            "🎬 아바타 생성",
+                            variant="primary",
+                            elem_id="avatar-btn"
+                        )
+                
+                # 출력 컬럼
+                with gr.Column(scale=1):
+                    with gr.Group(elem_classes="panel-box"):
+                        gr.Markdown("### 🎭 생성 결과")
+                        
+                        avatar_result = gr.Video(
+                            label="애니메이션 결과",
+                            elem_classes="panel-box"
+                        )
+                        
+                        avatar_comparison = gr.Video(
+                            label="원본 대비 결과 (Side-by-Side)",
+                            elem_classes="panel-box"
+                        )
+                        
+                        with gr.Accordion("실행 로그", open=False):
+                            avatar_logs = gr.Textbox(
+                                label="로그",
+                                lines=10,
+                                max_lines=20,
+                                interactive=False,
+                                elem_classes="panel-box"
+                            )
+                        
+                        gr.Markdown("""
+                        ### ℹ️ 사용 안내
+                        
+                        1. **포트레이트 이미지 업로드**: 정면을 보고 있는 선명한 얼굴 사진
+                        2. **오디오 업로드**: 애니메이션에 사용할 음성 파일
+                        3. **설정 조정**: 가이던스 스케일과 추론 스텝 조정
+                        4. **생성 시작**: '아바타 생성' 버튼 클릭
+                        
+                        **처리 시간**: 
+                        - 일반적으로 2-5분 소요
+                        - 긴 오디오일수록 처리 시간 증가
+                        
+                        **팁**:
+                        - 배경이 단순한 이미지가 더 좋은 결과를 생성합니다
+                        - 오디오의 음성이 명확할수록 립싱크가 정확합니다
+                        """)
+
+        # 여섯 번째 탭: 이미지to아바타
+        with gr.Tab("이미지to아바타", elem_classes="tabitem"):
+            with gr.Row(equal_height=True):
+                # 입력 컬럼
+                with gr.Column(scale=1):
+                    with gr.Group(elem_classes="panel-box"):
+                        gr.Markdown("### 🎭 아바타 애니메이션 생성")
+                        gr.Markdown("""
+                        포트레이트 이미지와 오디오를 업로드하면 말하는 아바타 애니메이션을 생성합니다.
+                        
+                        **권장 사항**:
+                        - 이미지: 정면을 보고 있는 얼굴 사진
+                        - 오디오: 명확한 음성이 담긴 오디오 파일
+                        """)
+                        
+                        avatar_image = gr.Image(
+                            label="포트레이트 이미지",
                             type="filepath",
-                            sources=["upload"]
+                            elem_classes="panel-box"
                         )
                         
+                        avatar_audio = gr.Audio(
+                            label="드라이빙 오디오",
+                            type="filepath",
+                            elem_classes="panel-box"
+                        )
+                    
                     with gr.Group(elem_classes="panel-box"):
                         gr.Markdown("### ⚙️ 생성 설정")
                         
-                        avatar_guidance = gr.Slider(
+                        guidance_scale = gr.Slider(
                             minimum=1.0,
-                            maximum=7.0,
-                            value=2.5,
+                            maximum=10.0,
+                            value=3.0,
                             step=0.1,
                             label="가이던스 스케일",
-                            info="값이 높을수록 더 강한 가이드"
+                            info="높을수록 오디오에 더 충실한 움직임 생성"
                         )
                         
-                        avatar_steps = gr.Slider(
+                        inference_steps = gr.Slider(
                             minimum=5,
                             maximum=30,
-                            value=15,
+                            value=10,
                             step=1,
                             label="추론 스텝",
-                            info="스텝이 많을수록 품질 향상"
+                            info="높을수록 품질이 좋아지지만 생성 시간이 증가"
+                        )
+                        
+                        # 서버 상태 체크
+                        with gr.Row():
+                            test_connection_btn = gr.Button(
+                                "🔌 서버 연결 테스트",
+                                elem_id="test-connection-btn",
+                                scale=1
+                            )
+                        
+                        anim_status = gr.Textbox(
+                            label="서버 상태",
+                            interactive=False,
+                            elem_classes="panel-box"
                         )
                         
-                        avatar_btn = gr.Button("🎭 아바타 생성", variant="primary", elem_id="avatar-btn")
+                        generate_avatar_btn = gr.Button(
+                            "🎬 아바타 생성",
+                            variant="primary",
+                            elem_id="avatar-btn"
+                        )
                 
                 # 출력 컬럼
                 with gr.Column(scale=1):
                     with gr.Group(elem_classes="panel-box"):
-                        gr.Markdown("### 🎬 생성 결과")
+                        gr.Markdown("### 🎭 생성 결과")
+                        
+                        avatar_result = gr.Video(
+                            label="애니메이션 결과",
+                            elem_classes="panel-box"
+                        )
                         
-                        avatar_status = gr.Textbox(label="처리 상태", interactive=False)
-                        avatar_result = gr.Video(label="애니메이션 결과")
-                        avatar_comparison = gr.Video(label="원본-애니메이션 비교")
+                        avatar_comparison = gr.Video(
+                            label="원본 대비 결과 (Side-by-Side)",
+                            elem_classes="panel-box"
+                        )
+                        
+                        with gr.Accordion("실행 로그", open=False):
+                            avatar_logs = gr.Textbox(
+                                label="로그",
+                                lines=10,
+                                max_lines=20,
+                                interactive=False,
+                                elem_classes="panel-box"
+                            )
                         
                         gr.Markdown("""
-                        ### ℹ️ 사용 방법
-                        1. 정면을 보고 있는 초상화 이미지를 업로드하세요
-                        2. 음성이나 음악 오디오 파일을 업로드하세요
-                        3. 가이던스와 스텝 설정을 조정하세요
-                        4. '아바타 생성' 버튼을 클릭하세요
+                        ### ℹ️ 사용 안내
+                        
+                        1. **포트레이트 이미지 업로드**: 정면을 보고 있는 선명한 얼굴 사진
+                        2. **오디오 업로드**: 애니메이션에 사용할 음성 파일
+                        3. **설정 조정**: 가이던스 스케일과 추론 스텝 조정
+                        4. **생성 시작**: '아바타 생성' 버튼 클릭
+                        
+                        **처리 시간**: 
+                        - 일반적으로 2-5분 소요
+                        - 긴 오디오일수록 처리 시간 증가
                         
                         **팁**:
-                        - 정면 얼굴 이미지가 가장 좋은 결과를 만듭니다
+                        - 배경이 단순한 이미지가 더 좋은 결과를 생성합니다
                         - 오디오의 음성이 명확할수록 립싱크가 정확합니다
-                        - 가이던스를 높이면 움직임이 강해집니다
                         """)
+
+
+
     
     # 모델 로드 함수 실행
     def on_demo_load():
@@ -1700,13 +1816,18 @@ with demo:
                 fps_slider, video_handling_radio, fast_mode_checkbox, max_workers_slider],
         outputs=[stream_image, output_bg_video, time_textbox]
     )
+
+    test_connection_btn.click(
+        test_anim_api_connection,
+        outputs=[anim_status, anim_status]
+    )
     
-    # 이벤트 연결 - 여섯 번째 탭 (이미지to아바타)
-    avatar_btn.click(
+    generate_avatar_btn.click(
         generate_avatar_animation,
-        inputs=[avatar_portrait, avatar_audio, avatar_guidance, avatar_steps],
-        outputs=[avatar_result, avatar_comparison, avatar_status]
+        inputs=[avatar_image, avatar_audio, guidance_scale, inference_steps],
+        outputs=[avatar_result, avatar_comparison, avatar_logs]
     )
+
     
     # 데모 로드 시 실행
     demo.load(on_demo_load, outputs=model_status)