Update app.py

app.py

@@ -7,79 +7,109 @@ from typing import List, Tuple, Optional, Any
 import gradio as gr
 from gradio_client import Client, handle_file
 from dotenv import load_dotenv
+import time
 
 # .env 파일 로드
 load_dotenv()
 
 # 로깅 설정 (API 엔드포인트 정보는 로그에 남기지 않음)
-logging.basicConfig(
-    level=logging.INFO,
-    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
-    handlers=[
-        logging.FileHandler("app.log"),
-        logging.StreamHandler(sys.stdout)
-    ]
-)
+class SafeFormatter(logging.Formatter):
+    """API 엔드포인트 정보를 로그에서 제거하는 안전한 포매터"""
+    def format(self, record):
+        # API_ENDPOINT 관련 정보 필터링
+        msg = super().format(record)
+        # 민감한 정보가 포함된 경우 마스킹
+        if "API_ENDPOINT" in msg or "happydoggg" in msg or "49493h" in msg:
+            return msg.replace(os.environ.get("API_ENDPOINT", ""), "[API_ENDPOINT_HIDDEN]")
+        return msg
+
+# 로그 핸들러 설정
+file_handler = logging.FileHandler("app.log")
+console_handler = logging.StreamHandler(sys.stdout)
+formatter = SafeFormatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+file_handler.setFormatter(formatter)
+console_handler.setFormatter(formatter)
+
 logger = logging.getLogger("image-enhancer-control-tower")
+logger.setLevel(logging.INFO)
+logger.addHandler(file_handler)
+logger.addHandler(console_handler)
 
 class GradioClientController:
     """허깅페이스 그라디오 API 클라이언트 컨트롤러"""
     
     def __init__(self):
         self.client = None
+        self.api_endpoint = None
         self._initialize_client()
         
     def _initialize_client(self):
         """클라이언트 초기화 (엔드포인트 정보는 로그에 남기지 않음)"""
         try:
-            api_endpoint = os.environ.get("API_ENDPOINT")
-            if not api_endpoint:
+            self.api_endpoint = os.environ.get("API_ENDPOINT")
+            if not self.api_endpoint:
                 logger.error("API_ENDPOINT 환경 변수가 설정되지 않았습니다.")
                 raise ValueError("API_ENDPOINT 환경 변수가 필요합니다.")
             
-            self.client = Client(api_endpoint)
-            logger.info("API 클라이언트가 성공적으로 초기화되었습니다.")
-            
+            # 클라이언트 초기화 시도 (재시도 로직 포함)
+            max_retries = 3
+            for attempt in range(max_retries):
+                try:
+                    self.client = Client(self.api_endpoint)
+                    logger.info("API 클라이언트가 성공적으로 초기화되었습니다.")
+                    return
+                except Exception as e:
+                    if attempt < max_retries - 1:
+                        logger.warning(f"클라이언트 초기화 재시도 {attempt + 1}/{max_retries}")
+                        time.sleep(2)
+                    else:
+                        raise e
+                        
         except Exception as e:
-            logger.error(f"클라이언트 초기화 실패: {e}")
+            logger.error(f"클라이언트 초기화 실패: {str(e)}")
             self.client = None
     
+    def _ensure_client(self) -> bool:
+        """클라이언트 연결 상태 확인 및 재연결"""
+        if self.client is None:
+            logger.info("클라이언트 재연결 시도")
+            self._initialize_client()
+        return self.client is not None
+    
     def update_dropdowns(self, bg_type: str) -> Tuple:
         """배경 유형에 따른 드롭다운 업데이트"""
         try:
-            if not self.client:
-                logger.error("클라이언트가 초기화되지 않았습니다.")
+            if not self._ensure_client():
+                logger.error("클라이언트 연결 실패")
                 return tuple([gr.update() for _ in range(7)])
             
             result = self.client.predict(
-                bg_type=bg_type,
+                bg_type,
                 api_name="/update_dropdowns"
             )
             
             logger.info(f"드롭다운 업데이트 완료: {bg_type}")
             
             # 결과를 Gradio 업데이트 형식으로 변환
-            updates = []
-            for i, choices in enumerate(result):
-                if i == 0:  # 심플 배경
-                    updates.append(gr.update(visible=(bg_type == "심플 배경"), choices=choices, value=choices[0] if choices else None))
-                elif i == 1:  # 스튜디오 배경
-                    updates.append(gr.update(visible=(bg_type == "스튜디오 배경"), choices=choices, value=choices[0] if choices else None))
-                elif i == 2:  # 자연 환경
-                    updates.append(gr.update(visible=(bg_type == "자연 환경"), choices=choices, value=choices[0] if choices else None))
-                elif i == 3:  # 실내 환경
-                    updates.append(gr.update(visible=(bg_type == "실내 환���"), choices=choices, value=choices[0] if choices else None))
-                elif i == 4:  # 특수배경
-                    updates.append(gr.update(visible=(bg_type == "특수배경"), choices=choices, value=choices[0] if choices else None))
-                elif i == 5:  # 주얼리
-                    updates.append(gr.update(visible=(bg_type == "주얼리"), choices=choices, value=choices[0] if choices else None))
-                elif i == 6:  # 특수효과
-                    updates.append(gr.update(visible=(bg_type == "특수효과"), choices=choices, value=choices[0] if choices else None))
-            
-            return tuple(updates)
+            if isinstance(result, (list, tuple)) and len(result) >= 7:
+                updates = []
+                visibility_map = ["심플 배경", "스튜디오 배경", "자연 환경", "실내 환경", "특수배경", "주얼리", "특수효과"]
+                
+                for i, choices in enumerate(result[:7]):
+                    is_visible = (bg_type == visibility_map[i])
+                    updates.append(gr.update(
+                        visible=is_visible, 
+                        choices=choices if choices else [], 
+                        value=choices[0] if choices and len(choices) > 0 else None
+                    ))
+                
+                return tuple(updates)
+            else:
+                logger.warning("API에서 예상과 다른 형식의 결과를 반환했습니다.")
+                return tuple([gr.update() for _ in range(7)])
             
         except Exception as e:
-            logger.error(f"드롭다운 업데이트 오류: {e}")
+            logger.error(f"드롭다운 업데이트 오류: {str(e)}")
             return tuple([gr.update() for _ in range(7)])
     
     def generate_prompt_only(self, password: str, bg_type: str, simple: str, studio: str, 
@@ -87,30 +117,29 @@ class GradioClientController:
                            special_effects: str, request_text: str, aspect_ratio: str) -> str:
         """프롬프트만 생성"""
         try:
-            if not self.client:
-                logger.error("클라이언트가 초기화되지 않았습니다.")
-                return "클라이언트 연결 오류"
+            if not self._ensure_client():
+                return "클라이언트 연결 오류가 발생했습니다. 잠시 후 다시 시도해주세요."
             
             result = self.client.predict(
-                password=password,
-                bg_type=bg_type,
-                simple=simple,
-                studio=studio,
-                nature=nature,
-                indoor=indoor,
-                special=special,
-                jewelry=jewelry,
-                special_effects=special_effects,
-                request_text=request_text,
-                aspect_ratio=aspect_ratio,
+                password,
+                bg_type,
+                simple or "",
+                studio or "",
+                nature or "",
+                indoor or "",
+                special or "",
+                jewelry or "",
+                special_effects or "",
+                request_text or "",
+                aspect_ratio,
                 api_name="/generate_prompt_with_password_check"
             )
             
             logger.info("프롬프트 생성 완료")
-            return result
+            return result if result else "프롬프트 생성에 실패했습니다."
             
         except Exception as e:
-            logger.error(f"프롬프트 생성 오류: {e}")
+            logger.error(f"프롬프트 생성 오류: {str(e)}")
             return f"프롬프트 생성 오류: {str(e)}"
     
     def process_image(self, password: str, image, bg_type: str, simple: str, studio: str,
@@ -118,58 +147,66 @@ class GradioClientController:
                      request_text: str, quality_level: str, aspect_ratio: str, 
                      output_format: str, enable_enhancement: bool) -> Tuple:
         """이미지 처리 (편집 및 화질 개선)"""
+        temp_path = None
         try:
-            if not self.client:
-                logger.error("클라이언트가 초기화되지 않았습니다.")
-                return ([], None, [], None, "", "", "클라이언트 연결 오류")
+            if not self._ensure_client():
+                return ([], None, [], None, "", "", "클라이언트 연결 오류가 발생했습니다. 잠시 후 다시 시도해주세요.")
+            
+            # 이미지 검증
+            if image is None:
+                return ([], None, [], None, "", "", "이미지를 업로드해주세요.")
             
             # 이미지를 임시 파일로 저장
-            temp_path = None
-            if image is not None:
-                temp_path = tempfile.mktemp(suffix='.png')
-                image.save(temp_path)
+            temp_path = tempfile.mktemp(suffix='.png')
+            try:
+                image.save(temp_path, format='PNG')
+                logger.info(f"이미지를 임시 파일로 저장: {os.path.basename(temp_path)}")
+            except Exception as e:
+                logger.error(f"이미지 저장 실패: {str(e)}")
+                return ([], None, [], None, "", "", "이미지 저장에 실패했습니다. 다른 이미지를 시도해보세요.")
             
             # API 호출
+            logger.info("이미지 처리 API 호출 시작")
             result = self.client.predict(
-                password=password,
-                param_1=handle_file(temp_path) if temp_path else None,
-                param_2=bg_type,
-                param_3=simple,
-                param_4=studio,
-                param_5=nature,
-                param_6=indoor,
-                param_7=special,
-                param_8=jewelry,
-                param_9=special_effects,
-                param_10=request_text,
-                param_11=quality_level,
-                param_12=aspect_ratio,
-                param_13=output_format,
-                param_14=enable_enhancement,
+                password,
+                handle_file(temp_path),
+                bg_type,
+                simple or "",
+                studio or "",
+                nature or "",
+                indoor or "",
+                special or "",
+                jewelry or "",
+                special_effects or "",
+                request_text or "",
+                quality_level,
+                aspect_ratio,
+                output_format,
+                enable_enhancement,
                 api_name="/check_password"
             )
             
-            # 임시 파일 정리
-            if temp_path and os.path.exists(temp_path):
-                try:
-                    os.remove(temp_path)
-                except:
-                    pass
+            logger.info("이미지 처리 API 호출 완료")
             
-            logger.info("이미지 처리 완료")
-            
-            # 결과 반환: (original_output, original_download, enhanced_output, enhanced_download, prompt_output, info, error)
-            return result
+            # 결과 검증 및 반환
+            if isinstance(result, (list, tuple)) and len(result) >= 7:
+                return result
+            else:
+                logger.warning("API에서 예상과 다른 형식의 결과를 반환했습니다.")
+                return ([], None, [], None, "", "", "API에서 올바르지 않은 응답을 받았습니다.")
             
         except Exception as e:
-            logger.error(f"이미지 처리 오류: {e}")
+            logger.error(f"이미지 처리 오류: {str(e)}")
+            return ([], None, [], None, "", "", f"이미지 처리 중 오류가 발생했습니다: {str(e)}")
+        
+        finally:
             # 임시 파일 정리
-            if 'temp_path' in locals() and temp_path and os.path.exists(temp_path):
+            if temp_path and os.path.exists(temp_path):
                 try:
                     os.remove(temp_path)
-                except:
-                    pass
-            return ([], None, [], None, "", "", f"이미지 처리 오류: {str(e)}")
+                    logger.info("임시 파일 정리 완료")
+                except Exception as e:
+                    logger.warning(f"임시 파일 정리 실패: {str(e)}")
 
 # 전역 클라이언트 컨트롤러 인스턴스
 controller = GradioClientController()
@@ -179,10 +216,17 @@ def create_gradio_interface():
     try:
         logger.info("Gradio 인터페이스 생성 시작")
         
-        # 배경 유형 선택지 (하드코딩)
+        # 배경 유형 선택지
         background_types = ["심플 배경", "스튜디오 배경", "자연 환경", "실내 환경", "특수배경", "주얼리", "특수효과"]
         
-        with gr.Blocks(title="AI 이미지 편집 및 화질 개선") as app:
+        # 커스텀 CSS 추가 (원본과 동일한 스타일 유지)
+        css = """
+        .gradio-container {
+            max-width: 1200px !important;
+        }
+        """
+        
+        with gr.Blocks(title="AI 이미지 편집 및 화질 개선", css=css, theme=gr.themes.Soft()) as app:
             gr.Markdown("# AI 이미지 편집 및 화질 개선 도구")
             
             # 비밀번호 입력 필드
@@ -256,14 +300,6 @@ def create_gradio_interface():
                                 visible=False,
                                 interactive=True
                             )
-                            
-                            # 드롭다운 변경 이벤트
-                            background_type.change(
-                                fn=controller.update_dropdowns,
-                                inputs=[background_type],
-                                outputs=[simple_dropdown, studio_dropdown, nature_dropdown, 
-                                        indoor_dropdown, special_dropdown, jewelry_dropdown, special_effects_dropdown]
-                            )
                     
                     # 요청사항 입력
                     request_text = gr.Textbox(
@@ -277,7 +313,7 @@ def create_gradio_interface():
                         label="품질 레벨", 
                         choices=["gpt", "flux"],
                         value="flux",
-                        info="GPT: GPT 모델 (고품질), 일반: Flux 모델 (빠른 처리 + 기본 화질개선)"
+                        info="GPT: GPT 모델 (고품질), Flux: Flux 모델 (빠른 처리 + 기본 화질개선)"
                     )
                     
                     aspect_ratio = gr.Dropdown(
@@ -300,10 +336,10 @@ def create_gradio_interface():
                     )
                     
                     # 프롬프트 생성 버튼
-                    generate_prompt_btn = gr.Button("프롬프트만 생성")
+                    generate_prompt_btn = gr.Button("프롬프트만 생성", variant="secondary")
                     
                     # 편집 버튼
-                    edit_btn = gr.Button("이미지 편집 및 화질 개선")
+                    edit_btn = gr.Button("이미지 편집 및 화질 개선", variant="primary")
                 
                 with gr.Column():
                     with gr.Row():
@@ -322,6 +358,14 @@ def create_gradio_interface():
                     info = gr.Textbox(label="처리 정보", interactive=False)
                     error = gr.Textbox(label="오류 메시지", interactive=False, visible=True)
             
+            # 드롭다운 변경 이벤트
+            background_type.change(
+                fn=controller.update_dropdowns,
+                inputs=[background_type],
+                outputs=[simple_dropdown, studio_dropdown, nature_dropdown, 
+                        indoor_dropdown, special_dropdown, jewelry_dropdown, special_effects_dropdown]
+            )
+            
             # 프롬프트 생성 버튼 클릭 이벤트
             generate_prompt_btn.click(
                 fn=controller.generate_prompt_only,
@@ -352,7 +396,7 @@ def create_gradio_interface():
                 ]
             )
             
-            # 초기 드롭다운 로드
+            # 앱 로드 시 초기 드롭다운 설정
             app.load(
                 fn=controller.update_dropdowns,
                 inputs=[background_type],
@@ -364,7 +408,7 @@ def create_gradio_interface():
         return app
         
     except Exception as e:
-        logger.error(f"Gradio 인터페이스 생성 오류: {e}")
+        logger.error(f"Gradio 인터페이스 생성 오류: {str(e)}")
         logger.error(traceback.format_exc())
         raise
 
@@ -377,10 +421,27 @@ if __name__ == "__main__":
         os.makedirs("imgs", exist_ok=True)
         logger.info("이미지 디렉토리 준비 완료")
         
+        # API 엔드포인트 확인
+        if not os.environ.get("API_ENDPOINT"):
+            logger.error("API_ENDPOINT 환경 변수가 설정되지 않았습니다.")
+            print("\n❌ 오류: API_ENDPOINT 환경 변수가 설정되지 않았습니다.")
+            print("환경 변수를 설정하거나 .env 파일에 API_ENDPOINT를 추가해주세요.")
+            sys.exit(1)
+        
         app = create_gradio_interface()
         logger.info("Gradio 앱 시작")
-        app.launch(share=True)
+        app.launch(
+            share=True,
+            server_name="0.0.0.0",
+            server_port=7860,
+            show_error=True,
+            quiet=False
+        )
         
+    except KeyboardInterrupt:
+        logger.info("사용자에 의해 애플리케이션이 중단되었습니다.")
     except Exception as e:
-        logger.error(f"앱 실행 오류: {e}")
-        logger.error(traceback.format_exc())
+        logger.error(f"앱 실행 오류: {str(e)}")
+        logger.error(traceback.format_exc())
+        print(f"\n❌ 심각한 오류가 발생했습니다: {str(e)}")
+        print("자세한 내용은 app.log 파일을 확인해주세요.")