Update app.py

app.py

@@ -8,7 +8,7 @@ import traceback
 import requests
 from PIL import Image
 import gradio as gr
-from gradio_client import Client
+from gradio_client import Client, handle_file
 from dotenv import load_dotenv
 
 # 환경변수 로드
@@ -23,7 +23,7 @@ logging.basicConfig(
         logging.StreamHandler(sys.stdout)
     ]
 )
-logger = logging.getLogger("image-enhancer-control-tower")
+logger = logging.getLogger("image-enhancer-app")
 
 # API 클라이언트 초기화 (환경변수에서)
 API_ENDPOINT = os.environ.get("API_ENDPOINT")
@@ -33,7 +33,7 @@ if not API_ENDPOINT:
 
 try:
     # 로그에 엔드포인트 정보 출력하지 않음
-    client = Client(API_ENDPOINT)
+    api_client = Client(API_ENDPOINT)
     logger.info("API client initialized successfully")
 except Exception as e:
     logger.error(f"Failed to initialize API client: {e}")
@@ -75,43 +75,114 @@ if not SIMPLE_BACKGROUNDS:
     SIMPLE_BACKGROUNDS = {
         "화이트 기본": "clean white background with soft lighting",
         "회색 투톤": "light gray background with minimal shadows",
-        "라이트 그레이": "soft light gray backdrop with even illumination"
+        "라이트 그레이": "soft light gray backdrop with even illumination",
+        "그레이 그라데이션 스포트라이트": "gray gradient with spotlight",
+        "프리미엄 드라마틱 블랙": "premium dramatic black background",
+        "딥블루 유리반사": "deep blue glass reflection",
+        "파스텔 그라데이션": "pastel gradient background",
+        "스카이블루 파스텔": "sky blue pastel",
+        "버터옐로우 파스텔": "butter yellow pastel",
+        "블루 원색": "pure blue background",
+        "레드 원색": "pure red background"
     }
 
 if not STUDIO_BACKGROUNDS:
     STUDIO_BACKGROUNDS = {
-        "연녹색 장미 정원": "soft green background with rose garden elements",
-        "연분홍 장미 대리석": "pink rose with marble surface backdrop"
+        "연녹색 장미 정원": "soft green rose garden",
+        "연분홍 장미 대리석": "pink rose with marble",
+        "파스텔 블루 수국": "pastel blue hydrangea",
+        "소프트 핑크 벚꽃": "soft pink cherry blossom",
+        "파스텔 옐로우 꽃봉오리": "pastel yellow buds",
+        "아이보리 로즈 심플": "ivory rose simple",
+        "심플 화이트 작은 화분": "simple white small pot",
+        "퍼플 장난스러운 심비로운 분위기": "purple playful mood",
+        "코지 데스크 플랜트": "cozy desk plant",
+        "연핑크 튤립 작은테이블": "light pink tulip small table",
+        "오크우드 튤립 샤워 푸프": "oak wood tulip shower puff",
+        "크림 코튼": "cream cotton",
+        "브라운 거친 페이퍼": "brown rough paper"
     }
 
 if not NATURE_BACKGROUNDS:
     NATURE_BACKGROUNDS = {
-        "작은 파도가 있는 해변": "serene beach with gentle waves",
-        "열대해변": "tropical beach setting with palm trees"
+        "작은 파도가 있는 해변": "beach with small waves",
+        "펭귄이 있는 빙산": "iceberg with penguin",
+        "눈내리는 산악 설원": "snowy mountain field",
+        "열대해변": "tropical beach",
+        "일출 직전의 바위산": "rocky mountain before sunrise",
+        "초근접 봄꽃 들판": "close-up spring flower field",
+        "물가 바위": "waterside rocks",
+        "작은 돌이 깔린 얕은 물가": "shallow water with small stones",
+        "나무 테이블 숲속 계곡": "wooden table forest valley",
+        "안개 낀 숲": "foggy forest",
+        "일몰 바다": "sunset sea",
+        "별이 빛나는 캠핑": "starry camping"
     }
 
 if not INDOOR_BACKGROUNDS:
     INDOOR_BACKGROUNDS = {
-        "기본 책상": "clean modern desk setup",
-        "빛이 비치는 거실": "bright living room with natural light"
+        "기본 책상": "basic desk",
+        "빛이 비치는 책상": "desk with light",
+        "빛이 비치는 거실": "living room with light",
+        "스튜디어 거실": "studio living room",
+        "화분이 있는 거실": "living room with plants",
+        "전체적인 거실모습": "overall living room view",
+        "포인트 거실": "point living room",
+        "중앙 거실": "central living room",
+        "서랍테이블": "drawer table",
+        "침실 탁자위": "bedroom table top",
+        "원목 테이블 블록": "wood table block",
+        "테이블 심플": "simple table",
+        "분위기 있는 침실": "atmospheric bedroom",
+        "나무테이블위": "on wooden table",
+        "책위 거실테이블": "living room table with books",
+        "유리테이블위": "on glass table",
+        "침실 옆 작은탁자": "small bedside table",
+        "분위기 있는 원형 테이블": "atmospheric round table",
+        "포커스 탁자": "focus table",
+        "투톤 벽면": "two-tone wall",
+        "아늑한 테이블위 액세서리": "cozy table accessories",
+        "아늑�� 테이블 보 위": "on cozy tablecloth",
+        "유리 바닥": "glass floor",
+        "빛치는 식탁위": "dining table with light",
+        "나늑한 식탁위 작업대": "cozy dining workspace"
     }
 
 if not SPECIAL_BACKGROUNDS:
     SPECIAL_BACKGROUNDS = {
-        "네이비 빈티지 플로럴 벽지": "navy vintage floral wallpaper background"
+        "네이비 빈티지 플로럴 벽지": "navy vintage floral wallpaper",
+        "빈티지 꽃무늬 패브릭 배경": "vintage floral fabric background",
+        "팝 도트와 과일": "pop dots and fruits",
+        "블루 마블 잉크 텍스처 배경": "blue marble ink texture",
+        "오렌지블루 워터컬러 배경": "orange blue watercolor",
+        "레드브러시 페인팅 아트 배경": "red brush painting art",
+        "블루오렌지 페인팅 아트": "blue orange painting art"
     }
 
 if not JEWELRY_BACKGROUNDS:
     JEWELRY_BACKGROUNDS = {
-        "화이트 미러 스팟 라이트": "white mirror surface with spotlight"
+        "화이트 미러 스팟 라이트": "white mirror spotlight",
+        "그레이 그라데이션 미러": "gray gradient mirror",
+        "네이비 벨벳": "navy velvet",
+        "블랙 미러 시네마틱": "black mirror cinematic",
+        "화이트 마블 프리미엄": "white marble premium",
+        "파스텔 블루 큐브 플랫폼": "pastel blue cube platform",
+        "내추럴 그라스": "natural grass",
+        "소프트 베이직 패브릭": "soft basic fabric",
+        "마이크로텍스쳐 프리미엄": "micro texture premium"
     }
 
 if not SPECIAL_EFFECTS_BACKGROUNDS:
     SPECIAL_EFFECTS_BACKGROUNDS = {
-        "블루블랙 큰 물방울 효과": "blue-black background with water droplet effects"
+        "블루블랙 큰 물방울 효과": "blue black water drop effect",
+        "크리스탈 버블 물속 장면": "crystal bubble underwater scene",
+        "잔 물결 수면 위 장면": "gentle ripple water surface scene",
+        "컬러 스모크 효과": "color smoke effect",
+        "자옥한 안개 효과": "dense fog effect",
+        "가습기 수중기 효과": "humidifier mist effect"
     }
 
-# 임시 파일 저장 함수
+# 임시 파일 저장 함수 (원본과 동일)
 def save_uploaded_file(uploaded_file, suffix='.png'):
     try:
         logger.info(f"Processing uploaded file: {type(uploaded_file)}")
@@ -153,76 +224,7 @@ def save_uploaded_file(uploaded_file, suffix='.png'):
         logger.error(traceback.format_exc())
         return None
 
-# API 호출 함수들 (클라이언트를 통해 원본 API 호출)
-def api_update_dropdowns(bg_type):
-    """드롭다운 업데이트 API 호출"""
-    try:
-        result = client.predict(bg_type=bg_type, api_name="/update_dropdowns")
-        return result
-    except Exception as e:
-        logger.error(f"Error calling update_dropdowns API: {e}")
-        return None
-
-def api_generate_prompt_with_password_check(password, bg_type, simple, studio, nature, indoor, special, jewelry, special_effects, request_text, aspect_ratio):
-    """프롬프트 생성 API 호출"""
-    try:
-        result = 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,
-            api_name="/generate_prompt_with_password_check"
-        )
-        return result
-    except Exception as e:
-        logger.error(f"Error calling generate_prompt API: {e}")
-        return f"API 호출 오류: {str(e)}"
-
-def api_check_password(password, image_file, bg_type, simple, studio, nature, indoor, special, jewelry, special_effects, request_text, quality_level, aspect_ratio, output_format, enable_enhancement):
-    """이미지 처리 API 호출"""
-    try:
-        # 이미지 파일을 gradio_client의 handle_file로 처리
-        from gradio_client import handle_file
-        
-        # 파일이 경로인 경우 handle_file로 래핑
-        if isinstance(image_file, str):
-            image_handle = handle_file(image_file)
-        else:
-            image_handle = image_file
-            
-        result = client.predict(
-            password=password,
-            param_1=image_handle,  # handle_file로 처리된 이미지
-            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,
-            api_name="/check_password"
-        )
-        return result
-    except Exception as e:
-        logger.error(f"Error calling check_password API: {e}")
-        # 더 자세한 오류 정보 로깅
-        logger.error(f"Full error details: {traceback.format_exc()}")
-        return [], None, [], None, "", "", f"API 호출 오류: {str(e)}"
-
-# Gradio 인터페이스 구성 (완전히 동일한 UI)
+# Gradio 인터페이스 구성 (원본과 완전 동일)
 def create_gradio_interface():
     try:
         logger.info("Creating Gradio interface")
@@ -253,88 +255,84 @@ def create_gradio_interface():
                             
                             # 드롭다운 컴포넌트들
                             simple_dropdown = gr.Dropdown(
-                                choices=list(SIMPLE_BACKGROUNDS.keys()) if SIMPLE_BACKGROUNDS else ["화이트 기본"],
-                                value=list(SIMPLE_BACKGROUNDS.keys())[0] if SIMPLE_BACKGROUNDS else "화이트 기본",
+                                choices=list(SIMPLE_BACKGROUNDS.keys()),
+                                value=list(SIMPLE_BACKGROUNDS.keys())[0] if SIMPLE_BACKGROUNDS else None,
                                 label="심플 배경 선택",
                                 visible=True,
                                 interactive=True
                             )
                             
                             studio_dropdown = gr.Dropdown(
-                                choices=list(STUDIO_BACKGROUNDS.keys()) if STUDIO_BACKGROUNDS else ["연녹색 장미 정원"],
-                                value=list(STUDIO_BACKGROUNDS.keys())[0] if STUDIO_BACKGROUNDS else "연녹색 장미 정원",
+                                choices=list(STUDIO_BACKGROUNDS.keys()),
+                                value=list(STUDIO_BACKGROUNDS.keys())[0] if STUDIO_BACKGROUNDS else None,
                                 label="스튜디오 배경 선택",
                                 visible=False,
                                 interactive=True
                             )
                             
                             nature_dropdown = gr.Dropdown(
-                                choices=list(NATURE_BACKGROUNDS.keys()) if NATURE_BACKGROUNDS else ["작은 파도가 있는 해변"],
-                                value=list(NATURE_BACKGROUNDS.keys())[0] if NATURE_BACKGROUNDS else "작은 파도가 있는 해변",
+                                choices=list(NATURE_BACKGROUNDS.keys()),
+                                value=list(NATURE_BACKGROUNDS.keys())[0] if NATURE_BACKGROUNDS else None,
                                 label="자연 환경 선택",
                                 visible=False,
                                 interactive=True
                             )
                             
                             indoor_dropdown = gr.Dropdown(
-                                choices=list(INDOOR_BACKGROUNDS.keys()) if INDOOR_BACKGROUNDS else ["기본 책상"],
-                                value=list(INDOOR_BACKGROUNDS.keys())[0] if INDOOR_BACKGROUNDS else "기본 책상",
+                                choices=list(INDOOR_BACKGROUNDS.keys()),
+                                value=list(INDOOR_BACKGROUNDS.keys())[0] if INDOOR_BACKGROUNDS else None,
                                 label="실내 환경 선택",
                                 visible=False,
                                 interactive=True
                             )
                             
                             special_dropdown = gr.Dropdown(
-                                choices=list(SPECIAL_BACKGROUNDS.keys()) if SPECIAL_BACKGROUNDS else ["네이비 빈티지 플로럴 벽지"],
-                                value=list(SPECIAL_BACKGROUNDS.keys())[0] if SPECIAL_BACKGROUNDS else "네이비 빈티지 플로럴 벽지",
+                                choices=list(SPECIAL_BACKGROUNDS.keys()),
+                                value=list(SPECIAL_BACKGROUNDS.keys())[0] if SPECIAL_BACKGROUNDS else None,
                                 label="특수배경 선택",
                                 visible=False,
                                 interactive=True
                             )
                             
                             jewelry_dropdown = gr.Dropdown(
-                                choices=list(JEWELRY_BACKGROUNDS.keys()) if JEWELRY_BACKGROUNDS else ["화이트 미러 스팟 라이트"],
-                                value=list(JEWELRY_BACKGROUNDS.keys())[0] if JEWELRY_BACKGROUNDS else "화이트 미러 스팟 라이트",
+                                choices=list(JEWELRY_BACKGROUNDS.keys()),
+                                value=list(JEWELRY_BACKGROUNDS.keys())[0] if JEWELRY_BACKGROUNDS else None,
                                 label="주얼리 배경 선택",
                                 visible=False,
                                 interactive=True
                             )
                             
                             special_effects_dropdown = gr.Dropdown(
-                                choices=list(SPECIAL_EFFECTS_BACKGROUNDS.keys()) if SPECIAL_EFFECTS_BACKGROUNDS else ["블루블랙 큰 물방울 효과"],
-                                value=list(SPECIAL_EFFECTS_BACKGROUNDS.keys())[0] if SPECIAL_EFFECTS_BACKGROUNDS else "블루블랙 큰 물방울 효과",
+                                choices=list(SPECIAL_EFFECTS_BACKGROUNDS.keys()),
+                                value=list(SPECIAL_EFFECTS_BACKGROUNDS.keys())[0] if SPECIAL_EFFECTS_BACKGROUNDS else None,
                                 label="특수효과 배경 선택",
                                 visible=False,
                                 interactive=True
                             )
                             
-                            # 드롭다운 변경 함수 (원본과 동일한 엔드포인트)
+                            # 드롭다운 변경 함수 (원본과 동일, API 엔드포인트 생성)
                             def update_dropdowns(bg_type):
-                                # API 호출하여 원본 동작 유지
                                 try:
-                                    result = api_update_dropdowns(bg_type)
-                                    if result:
-                                        return result
+                                    # API 호출
+                                    result = api_client.predict(bg_type=bg_type, api_name="/update_dropdowns")
+                                    return result
                                 except:
-                                    pass
-                                
-                                # 백업용 로컬 로직
-                                return {
-                                    simple_dropdown: gr.update(visible=(bg_type == "심플 배경")),
-                                    studio_dropdown: gr.update(visible=(bg_type == "스튜디오 배경")),
-                                    nature_dropdown: gr.update(visible=(bg_type == "자연 환경")),
-                                    indoor_dropdown: gr.update(visible=(bg_type == "실내 환경")),
-                                    special_dropdown: gr.update(visible=(bg_type == "특수배경")),
-                                    jewelry_dropdown: gr.update(visible=(bg_type == "주얼리")),
-                                    special_effects_dropdown: gr.update(visible=(bg_type == "특수효과"))
-                                }
+                                    # 백업용 로컬 로직
+                                    return {
+                                        simple_dropdown: gr.update(visible=(bg_type == "심플 배경")),
+                                        studio_dropdown: gr.update(visible=(bg_type == "스튜디오 배경")),
+                                        nature_dropdown: gr.update(visible=(bg_type == "자연 환경")),
+                                        indoor_dropdown: gr.update(visible=(bg_type == "실내 환경")),
+                                        special_dropdown: gr.update(visible=(bg_type == "특수배경")),
+                                        jewelry_dropdown: gr.update(visible=(bg_type == "주얼리")),
+                                        special_effects_dropdown: gr.update(visible=(bg_type == "특수효과"))
+                                    }
                             
-                            # 원본과 동일한 엔드포인트 생성
                             background_type.change(
                                 fn=update_dropdowns,
                                 inputs=[background_type],
                                 outputs=[simple_dropdown, studio_dropdown, nature_dropdown, indoor_dropdown, special_dropdown, jewelry_dropdown, special_effects_dropdown],
-                                api_name="update_dropdowns"  # 원본과 동일한 API 이름
+                                api_name="update_dropdowns"
                             )
                     
                     # 요청사항 입력
@@ -395,55 +393,73 @@ def create_gradio_interface():
                     info = gr.Textbox(label="처리 정보", interactive=False)
                     error = gr.Textbox(label="오류 메시지", interactive=False, visible=True)
             
-            # 프롬프트만 생성하는 함수 (원본과 동일한 엔드포인트)
+            # 프롬프트만 생성하는 함수 (원본과 동일한 엔드포인트, API 호출)
             def generate_prompt_with_password_check(password, bg_type, simple, studio, nature, indoor, special, jewelry, special_effects, request_text, aspect_ratio):
-                return api_generate_prompt_with_password_check(
-                    password, bg_type, simple, studio, nature, indoor, special, jewelry, special_effects, request_text, aspect_ratio
-                )
+                try:
+                    return api_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,
+                        api_name="/generate_prompt_with_password_check"
+                    )
+                except Exception as e:
+                    return f"API 호출 오류: {str(e)}"
             
-            # 이미지 처리 함수 (원본과 동일한 엔드포인트)
-            def check_password(password, image, bg_type, simple, studio, nature, indoor, special, jewelry, special_effects, request_text, quality_level, aspect_ratio, output_format, enable_enhancement):
-                if image is None:
-                    return [], None, [], None, "", "", "이미지를 업로드해야 합니다."
-                
-                temp_path = None
+            # 비밀번호 확인 함수 (원본과 동일한 엔드포인트, API 호출)
+            def check_password(password, *args):
                 try:
-                    # PIL Image를 임시 파일로 저장
-                    if isinstance(image, Image.Image):
-                        temp_path = tempfile.mktemp(suffix='.png')
-                        image.save(temp_path, format='PNG')
-                        logger.info(f"Saved PIL image to temporary file: {temp_path}")
-                    else:
-                        temp_path = save_uploaded_file(image)
+                    image, bg_type, simple, studio, nature, indoor, special, jewelry, special_effects, request_text, quality_level, aspect_ratio, output_format, enable_enhancement = args
                     
-                    if temp_path is None:
-                        return [], None, [], None, "", "", "이미지 처리에 실패했습니다."
-                    
-                    # API 호출 전 파라미터 로깅 (민감한 정보 제외)
-                    logger.info(f"Calling API with bg_type: {bg_type}, quality_level: {quality_level}")
+                    if image is None:
+                        return ([], None, [], None, "", "", "이미지를 업로드해야 합니다.")
                     
-                    # API 호출
-                    result = api_check_password(
-                        password, temp_path, bg_type, simple, studio, nature, indoor, special, jewelry, special_effects, 
-                        request_text, quality_level, aspect_ratio, output_format, enable_enhancement
-                    )
-                    return result
+                    # 이미지를 임시 파일로 저장
+                    temp_path = save_uploaded_file(image)
+                    if temp_path is None:
+                        return ([], None, [], None, "", "", "이미지 처리에 실패했습니다.")
                     
+                    try:
+                        # API 호출 (원본과 동일한 파라미터)
+                        result = api_client.predict(
+                            password=password,
+                            param_1=handle_file(temp_path),
+                            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,
+                            api_name="/check_password"
+                        )
+                        return result
+                    finally:
+                        # 임시 파일 정리
+                        if os.path.exists(temp_path):
+                            try:
+                                os.remove(temp_path)
+                            except:
+                                pass
+                                
                 except Exception as e:
-                    logger.error(f"Error in check_password wrapper: {e}")
-                    logger.error(f"Full error: {traceback.format_exc()}")
-                    return [], None, [], None, "", "", f"처리 중 오류 발생: {str(e)}"
-                    
-                finally:
-                    # 임시 파일 정리
-                    if temp_path and os.path.exists(temp_path):
-                        try:
-                            os.remove(temp_path)
-                            logger.info(f"Cleaned up temporary file: {temp_path}")
-                        except Exception as cleanup_error:
-                            logger.warning(f"Failed to cleanup temp file {temp_path}: {cleanup_error}")
+                    logger.error(f"Error in check_password: {e}")
+                    return ([], None, [], None, "", "", f"오류 발생: {str(e)}")
             
-            # 프롬프트 생성 버튼 클릭 이벤트 (원본과 동일한 API 이름)
+            # 프롬프트 생성 버튼 클릭 이벤트
             generate_prompt_btn.click(
                 fn=generate_prompt_with_password_check,
                 inputs=[
@@ -454,10 +470,10 @@ def create_gradio_interface():
                     request_text, aspect_ratio
                 ],
                 outputs=[prompt_output],
-                api_name="generate_prompt_with_password_check"  # 원본과 동일한 API 이름
+                api_name="generate_prompt_with_password_check"
             )
             
-            # 편집 버튼 클릭 이벤트 (원본과 동일한 API 이름)
+            # 편집 버튼 클릭 이벤트
             edit_btn.click(
                 fn=check_password,
                 inputs=[
@@ -472,7 +488,7 @@ def create_gradio_interface():
                     enhanced_output, enhanced_download,
                     prompt_output, info, error
                 ],
-                api_name="check_password"  # 원본과 동일한 API 이름
+                api_name="check_password"
             )
         
         logger.info("Gradio interface created successfully")
@@ -485,7 +501,7 @@ def create_gradio_interface():
 # 앱 실행
 if __name__ == "__main__":
     try:
-        logger.info("Starting control tower application")
+        logger.info("Starting application")
         
         # imgs 디렉토리 확인/생성
         os.makedirs("imgs", exist_ok=True)