Update app.py

app.py

@@ -1,320 +1,147 @@
 import os
 import sys
+import base64
+import io
 import logging
 import tempfile
 import traceback
-from typing import List, Tuple, Optional, Any
+import requests
+from PIL import Image
 import gradio as gr
-from gradio_client import Client, handle_file
+from gradio_client import Client
 from dotenv import load_dotenv
-import time
 
-# .env 파일 로드
+# 환경변수 로드
 load_dotenv()
 
-# 로깅 설정 (API 엔드포인트 정보는 로그에 남기지 않음)
-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
+# 로깅 설정 (민감한 정보 제외)
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.FileHandler("app.log"),
+        logging.StreamHandler(sys.stdout)
+    ]
+)
+logger = logging.getLogger("image-enhancer-control-tower")
 
-# 로그 핸들러 설정
-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)
+# API 클라이언트 초기화 (환경변수에서)
+API_ENDPOINT = os.environ.get("API_ENDPOINT")
+if not API_ENDPOINT:
+    logger.error("API_ENDPOINT environment variable is not set")
+    sys.exit(1)
 
-logger = logging.getLogger("image-enhancer-control-tower")
-logger.setLevel(logging.INFO)
-logger.addHandler(file_handler)
-logger.addHandler(console_handler)
+try:
+    # 로그에 엔드포인트 정보 출력하지 않음
+    client = Client(API_ENDPOINT)
+    logger.info("API client initialized successfully")
+except Exception as e:
+    logger.error(f"Failed to initialize API client: {e}")
+    sys.exit(1)
 
-class GradioClientController:
-    """허깅페이스 그라디오 API 클라이언트 컨트롤러"""
-    
-    def __init__(self):
-        self.client = None
-        self.api_endpoint = None
-        self.background_options = {}  # 캐시된 배경 옵션
-        self._initialize_client()
+# backgrounds.py 전체 내용을 환경변수에서 가져오기
+def load_backgrounds_from_env():
+    """환경변수에서 backgrounds.py 전체 내용 로드"""
+    backgrounds_code = os.environ.get("BACKGROUNDS_DATA", "")
+    if not backgrounds_code:
+        logger.warning("BACKGROUNDS_DATA environment variable is empty")
         
-    def _initialize_client(self):
-        """클라이언트 초기화 (엔드포인트 정보는 로그에 남기지 않음)"""
-        try:
-            self.api_endpoint = os.environ.get("API_ENDPOINT")
-            if not self.api_endpoint:
-                logger.error("API_ENDPOINT 환경 변수가 설정되지 않았습니다.")
-                raise ValueError("API_ENDPOINT 환경 변수가 필요합니다.")
-            
-            # 클라이언트 초기화 시도 (재시도 로직 포함)
-            max_retries = 3
-            for attempt in range(max_retries):
-                try:
-                    self.client = Client(self.api_endpoint)
-                    logger.info("API 클라이언트가 성공적으로 초기화되었습니다.")
-                    # 초기화 성공 시 심플 배경 옵션 먼저 로드
-                    self._load_simple_background()
-                    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"클라이언트 초기화 실패: {str(e)}")
-            self.client = None
-    
-    def _load_simple_background(self):
-        """심플 배경 옵션만 먼저 로드"""
-        try:
-            if self.client:
-                result = self.client.predict("심플 배경", api_name="/update_dropdowns")
-                if isinstance(result, (list, tuple)) and len(result) >= 7:
-                    self.background_options["심플 배경"] = result
-                    logger.info("심플 배경 옵션 로드 완료")
-                    return result[0]  # 심플 배경 선택지 반환
-        except Exception as e:
-            logger.warning(f"심플 배경 옵션 로드 실패: {str(e)}")
-        return []
-    def get_initial_dropdown_data(self, bg_type: str = "심플 배경") -> Tuple:
-        """초기 드롭다운 데이터 가져오기"""
-        try:
-            # 캐시된 데이터 먼저 ��인
-            if bg_type in self.background_options:
-                result = self.background_options[bg_type]
-                logger.info(f"캐시에서 초기 드롭다운 데이터 로드: {bg_type}")
-            else:
-                # API 호출로 데이터 가져오기
-                if self.client:
-                    result = self.client.predict(bg_type, api_name="/update_dropdowns")
-                    self.background_options[bg_type] = result  # 캐시에 저장
-                    logger.info(f"API에서 초기 드롭다운 데이터 로드: {bg_type}")
-                else:
-                    logger.error("클라이언트가 초기화되지 않음")
-                    return tuple([[] for _ in range(7)])
-            
-            # 결과 반환 (실제 선택지만)
-            if isinstance(result, (list, tuple)) and len(result) >= 7:
-                return result[:7]
-            else:
-                return tuple([[] for _ in range(7)])
-                
-        except Exception as e:
-            logger.error(f"초기 드롭다운 데이터 로드 실패: {str(e)}")
-            return tuple([[] for _ in range(7)])
+        with tempfile.NamedTemporaryFile(delete=False, suffix=suffix) as temp_file:
+            temp_filename = temp_file.name
+            logger.info(f"Created temporary file: {temp_filename}")
+        
+        # Gradio 업로드 파일 처리
+        if isinstance(uploaded_file, str):  # 이미 파일 경로인 경우
+            logger.info(f"Uploaded file is already a path: {uploaded_file}")
+            return uploaded_file
+        
+        # PIL Image 처리
+        if isinstance(uploaded_file, Image.Image):
+            logger.info("Uploaded file is a PIL Image")
+            uploaded_file.save(temp_filename, format="PNG")
+            return temp_filename
+        
+        # 바이너리 데이터 처리
+        with open(temp_filename, "wb") as f:
+            if hasattr(uploaded_file, "read"):  # 파일 객체인 경우
+                logger.info("Processing file object")
+                content = uploaded_file.read()
+                f.write(content)
+                logger.info(f"Wrote {len(content)} bytes to {temp_filename}")
+            else:  # 바이너리 데이터인 경우
+                logger.info("Processing binary data")
+                f.write(uploaded_file)
+                logger.info(f"Wrote data to {temp_filename}")
+        
+        return temp_filename
+    except Exception as e:
+        logger.error(f"Error saving uploaded file: {e}")
+        logger.error(traceback.format_exc())
+        return None
 
-    def _parse_dropdown_result(self, result):
-        """API 응답에서 실제 선택지 데이터만 추출 - 단순화"""
-        try:
-            logger.info(f"응답 파싱: {result}")
-            
-            # API 문서에 따르면 tuple of 7 elements를 반환
-            # 각 요소는 Literal 타입의 리스트여야 함
-            if isinstance(result, (list, tuple)) and len(result) >= 7:
-                # 결과를 그대로 반환 (API가 이미 올바른 형식으로 반환한다고 가정)
-                return result[:7]
-            else:
-                logger.warning(f"예상하지 못한 응답 형식: {type(result)}, length={len(result) if hasattr(result, '__len__') else 'N/A'}")
-                return [[] for _ in range(7)]
-                
-        except Exception as e:
-            logger.error(f"드롭다운 결과 파싱 오류: {str(e)}")
-            return [[] for _ in range(7)]
+# 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 get_initial_simple_choices(self) -> list:
-        """심플 배경 초기 선택지 - 하드코딩으로 테스트"""
-        # API 문서에서 확인된 실제 선택지들
-        return [
-            '화이트 기본', '회색 투톤', '라이트 그레이', '그레이 그라데이션 스포트라이트', 
-            '프리미엄 드라마틱 블랙', '딥블루 유리반사', '파스텔 그라데이션', '스카이블루 파스텔', 
-            '버터옐로우 파스텔', '블루 원색', '레드 원색'
-        ]
-    
-    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:
-            logger.info(f"드롭다운 업데이트: {bg_type}")
-            
-            if not self._ensure_client():
-                logger.error("클��이언트 연결 실패")
-                return tuple([gr.update(visible=False) for _ in range(7)])
-            
-            # API 호출
-            result = self.client.predict(bg_type, api_name="/update_dropdowns")
-            logger.info(f"API 응답: {result}")
-            
-            # API 응답을 그대로 사용
-            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])
-                    
-                    if is_visible and isinstance(choices, list) and len(choices) > 0:
-                        logger.info(f"{visibility_map[i]} 드롭다운: {len(choices)}개 선택지")
-                        updates.append(gr.update(
-                            visible=True, 
-                            choices=choices, 
-                            value=choices[0],  # 첫 번째 항목 선택
-                            interactive=True
-                        ))
-                    else:
-                        updates.append(gr.update(visible=False))
-                
-                return tuple(updates)
-            else:
-                logger.error(f"잘못된 API 응답: {result}")
-                return tuple([gr.update(visible=False) for _ in range(7)])
-            
-        except Exception as e:
-            logger.error(f"드롭다운 업데이트 오류: {str(e)}")
-            return tuple([gr.update(visible=False) for _ in range(7)])
-    
-    def generate_prompt_only(self, password: str, bg_type: str, simple: str, studio: str, 
-                           nature: str, indoor: str, special: str, jewelry: str, 
-                           special_effects: str, request_text: str, aspect_ratio: str) -> str:
-        """프롬프트만 생성"""
-        try:
-            if not self._ensure_client():
-                return "클라이언트 연결 오류가 발생했습니다. 잠시 후 다시 시도해주세요."
-            
-            result = self.client.predict(
-                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 if result else "프롬프트 생성에 실패했습니다."
-            
-        except Exception as e:
-            logger.error(f"프롬프트 생성 오류: {str(e)}")
-            return f"프롬프트 생성 오류: {str(e)}"
-    
-    def process_image(self, password: str, image, bg_type: str, simple: str, studio: str,
-                     nature: str, indoor: str, special: str, jewelry: str, special_effects: str,
-                     request_text: str, quality_level: str, aspect_ratio: str, 
-                     output_format: str, enable_enhancement: bool) -> Tuple:
-        """이미지 처리 (편집 및 화질 개선) - API 문서와 정확히 매칭"""
-        temp_path = None
-        try:
-            if not self._ensure_client():
-                return ([], None, [], None, "", "", "클라이언트 연결 오류가 발생했습니다. 잠시 후 다시 시도해주세요.")
-            
-            # 이미지 검증
-            if image is None:
-                return ([], None, [], None, "", "", "이미지를 업로드해주세요.")
-            
-            # 이미지를 임시 파일로 저장
-            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 호출 - 매개변수 순서를 API 문서와 정확히 맞춤
-            logger.info("이미지 처리 API 호출 시작")
-            result = self.client.predict(
-                password,                    # password (str)
-                handle_file(temp_path),      # param_1 (image file)
-                bg_type,                     # param_2 (배경 유형)
-                simple or "",                # param_3 (심플 배경)
-                studio or "",                # param_4 (스튜디오 배경)
-                nature or "",                # param_5 (자연 환경)
-                indoor or "",                # param_6 (실내 환경)
-                special or "",               # param_7 (특수배경)
-                jewelry or "",               # param_8 (주얼리)
-                special_effects or "",       # param_9 (특수효과)
-                request_text or "",          # param_10 (요청사항)
-                quality_level,               # param_11 (품질 레벨)
-                aspect_ratio,                # param_12 (종횡비)
-                output_format,               # param_13 (이미지 형식)
-                enable_enhancement,          # param_14 (추가 화질 개선)
-                api_name="/check_password"
-            )
-            
-            logger.info("이미지 처리 API 호출 완료")
-            
-            # 결과 검증 및 반환 - API 문서에 따르면 tuple of 7 elements
-            if isinstance(result, (list, tuple)) and len(result) >= 7:
-                # [0] original_gallery, [1] original_file, [2] enhanced_gallery, 
-                # [3] enhanced_file, [4] prompt_text, [5] info_text, [6] error_text
-                return result[:7]  # 정확히 7개 요소만 반환
-            else:
-                logger.warning(f"API 응답 형식 이상: type={type(result)}, length={len(result) if hasattr(result, '__len__') else 'N/A'}")
-                return ([], None, [], None, "", "", "API에서 올바르지 않은 응답을 받았습니다.")
-            
-        except Exception as e:
-            error_msg = str(e)
-            logger.error(f"이미지 처리 오류: {error_msg}")
-            
-            # 일반적인 오류 메시지 개선
-            if "timeout" in error_msg.lower():
-                user_error = "요청 처리 시간이 초과되었습니다. 잠시 후 다시 시도해주세요."
-            elif "connection" in error_msg.lower():
-                user_error = "서버 연결에 문제가 있습니다. 네트워크 상태를 확인해주세요."
-            elif "unauthorized" in error_msg.lower() or "password" in error_msg.lower():
-                user_error = "인증에 실패했습니다. 비밀번호를 확인해주세요."
-            else:
-                user_error = f"이미지 처리 중 오류가 발생했습니다: {error_msg}"
-                
-            return ([], None, [], None, "", "", user_error)
-        
-        finally:
-            # 임시 파일 정리
-            if temp_path and os.path.exists(temp_path):
-                try:
-                    os.remove(temp_path)
-                    logger.info("임시 파일 정리 완료")
-                except Exception as e:
-                    logger.warning(f"임시 파일 정리 실패: {str(e)}")
+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)}"
 
-# 전역 클라이언트 컨트롤러 인스턴스
-controller = GradioClientController()
+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:
+        result = client.predict(
+            password=password,
+            param_1=image_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}")
+        return None, None, None, None, "", "", f"API 호출 오류: {str(e)}"
 
+# Gradio 인터페이스 구성 (완전히 동일한 UI)
 def create_gradio_interface():
-    """Gradio 인터페이스 생성"""
     try:
-        logger.info("Gradio 인터페이스 생성 시작")
-        
-        # 배경 유형 선택지
-        background_types = ["심플 배경", "스튜디오 배경", "자연 환경", "실내 환경", "특수배경", "주얼리", "특수효과"]
-        
-        # 커스텀 CSS 추가 (원본과 동일한 스��일 유지)
-        css = """
-        .gradio-container {
-            max-width: 1200px !important;
-        }
-        """
-        
-        with gr.Blocks(title="AI 이미지 편집 및 화질 개선", css=css, theme=gr.themes.Soft()) as app:
+        logger.info("Creating Gradio interface")
+        with gr.Blocks(title="AI 이미지 편집 및 화질 개선") as app:
             gr.Markdown("# AI 이미지 편집 및 화질 개선 도구")
             
             # 비밀번호 입력 필드
@@ -334,61 +161,85 @@ def create_gradio_interface():
                     with gr.Row():
                         with gr.Column():
                             background_type = gr.Radio(
-                                choices=background_types,
+                                choices=["심플 배경", "스튜디오 배경", "자연 환경", "실내 환경", "특수배경", "주얼리", "특수효과"],
                                 label="배경 유형",
                                 value="심플 배경"
                             )
                             
-                            # 드롭다운 컴포넌트들 - 심플 배경은 하드코딩된 선택지로 시작
+                            # 드롭다운 컴포넌트들
                             simple_dropdown = gr.Dropdown(
-                                choices=controller.get_initial_simple_choices(),
-                                value="화이트 기본",  # 기본값 설정
+                                choices=list(SIMPLE_BACKGROUNDS.keys()) if SIMPLE_BACKGROUNDS else ["화이트 기본"],
+                                value=list(SIMPLE_BACKGROUNDS.keys())[0] if SIMPLE_BACKGROUNDS else "화이트 기본",
                                 label="심플 배경 선택",
                                 visible=True,
                                 interactive=True
                             )
                             
                             studio_dropdown = gr.Dropdown(
-                                choices=[],
+                                choices=list(STUDIO_BACKGROUNDS.keys()) if STUDIO_BACKGROUNDS else ["연녹색 장미 정원"],
+                                value=list(STUDIO_BACKGROUNDS.keys())[0] if STUDIO_BACKGROUNDS else "연녹색 장미 정원",
                                 label="스튜디오 배경 선택",
                                 visible=False,
                                 interactive=True
                             )
                             
                             nature_dropdown = gr.Dropdown(
-                                choices=[],
+                                choices=list(NATURE_BACKGROUNDS.keys()) if NATURE_BACKGROUNDS else ["작은 파도가 있는 해변"],
+                                value=list(NATURE_BACKGROUNDS.keys())[0] if NATURE_BACKGROUNDS else "작은 파도가 있는 해변",
                                 label="자연 환경 선택",
                                 visible=False,
                                 interactive=True
                             )
                             
                             indoor_dropdown = gr.Dropdown(
-                                choices=[],
+                                choices=list(INDOOR_BACKGROUNDS.keys()) if INDOOR_BACKGROUNDS else ["기본 책상"],
+                                value=list(INDOOR_BACKGROUNDS.keys())[0] if INDOOR_BACKGROUNDS else "기본 책상",
                                 label="실내 환경 선택",
                                 visible=False,
                                 interactive=True
                             )
                             
                             special_dropdown = gr.Dropdown(
-                                choices=[],
+                                choices=list(SPECIAL_BACKGROUNDS.keys()) if SPECIAL_BACKGROUNDS else ["네이비 빈티지 플로럴 벽지"],
+                                value=list(SPECIAL_BACKGROUNDS.keys())[0] if SPECIAL_BACKGROUNDS else "네이비 빈티지 플로럴 벽지",
                                 label="특수배경 선택",
                                 visible=False,
                                 interactive=True
                             )
                             
                             jewelry_dropdown = gr.Dropdown(
-                                choices=[],
+                                choices=list(JEWELRY_BACKGROUNDS.keys()) if JEWELRY_BACKGROUNDS else ["화이트 미러 스팟 라이트"],
+                                value=list(JEWELRY_BACKGROUNDS.keys())[0] if JEWELRY_BACKGROUNDS else "화이트 미러 스팟 라이트",
                                 label="주얼리 배경 선택",
                                 visible=False,
                                 interactive=True
                             )
                             
                             special_effects_dropdown = gr.Dropdown(
-                                choices=[],
+                                choices=list(SPECIAL_EFFECTS_BACKGROUNDS.keys()) if SPECIAL_EFFECTS_BACKGROUNDS else ["블루블랙 큰 물방울 효과"],
+                                value=list(SPECIAL_EFFECTS_BACKGROUNDS.keys())[0] if SPECIAL_EFFECTS_BACKGROUNDS else "블루블랙 큰 물방울 효과",
                                 label="특수효과 배경 선택",
                                 visible=False,
                                 interactive=True
                             )
+                            
+                            # 드롭다운 변경 함수
+                            def update_dropdowns(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]
+                            )
                     
                     # 요청사항 입력
                     request_text = gr.Textbox(
@@ -402,7 +253,7 @@ def create_gradio_interface():
                         label="품질 레벨", 
                         choices=["gpt", "flux"],
                         value="flux",
-                        info="GPT: GPT 모델 (고품질), Flux: Flux 모델 (빠른 처리 + 기본 화질개선)"
+                        info="GPT: GPT 모델 (고품질), 일반: Flux 모델 (빠른 처리 + 기본 화질개선)"
                     )
                     
                     aspect_ratio = gr.Dropdown(
@@ -423,12 +274,13 @@ def create_gradio_interface():
                         value=False,
                         info="GPT: 1회 화질개선, Flux: 2차 화질개선 (기본 1회 + 추가 1회)"
                     )
+                    enhancement_level = gr.Slider(label="화질 개선 레벨", minimum=1, maximum=4, value=2, step=1, visible=False)
                     
                     # 프롬프트 생성 버튼
-                    generate_prompt_btn = gr.Button("프롬프트만 생성", variant="secondary")
+                    generate_prompt_btn = gr.Button("프롬프트만 생성")
                     
                     # 편집 버튼
-                    edit_btn = gr.Button("이미지 편집 및 화질 개선", variant="primary")
+                    edit_btn = gr.Button("이미지 편집 및 화질 개선")
                 
                 with gr.Column():
                     with gr.Row():
@@ -447,18 +299,40 @@ 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],
-                queue=False  # 큐를 사용하지 않아 더 빠른 응답
-            )
+            # 프롬프트만 생성하는 함수 (API 호출)
+            def generate_prompt_wrapper(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
+                )
+            
+            # 이미지 처리 함수 (API 호출)
+            def process_image_wrapper(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 = save_uploaded_file(image)
+                if temp_path is None:
+                    return [], None, [], None, "", "", "이미지 처리에 실패했습니다."
+                
+                try:
+                    # 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
+                finally:
+                    # 임시 파일 정리
+                    if os.path.exists(temp_path):
+                        try:
+                            os.remove(temp_path)
+                        except:
+                            pass
             
             # 프롬프트 생성 버튼 클릭 이벤트
             generate_prompt_btn.click(
-                fn=controller.generate_prompt_only,
+                fn=generate_prompt_wrapper,
                 inputs=[
                     password_box,
                     background_type,
@@ -471,7 +345,7 @@ def create_gradio_interface():
             
             # 편집 버튼 클릭 이벤트
             edit_btn.click(
-                fn=controller.process_image,
+                fn=process_image_wrapper,
                 inputs=[
                     password_box, 
                     image, background_type, 
@@ -485,63 +359,99 @@ def create_gradio_interface():
                     prompt_output, info, error
                 ]
             )
-            
-            # 앱 로드 시 모든 드롭다운 초기 설정 (더 강력한 초기화)
-            def initialize_all_dropdowns():
-                """모든 드롭다운을 초기화하는 함수"""
-                try:
-                    logger.info("드롭다운 초기화 시작")
-                    updates = controller.update_dropdowns("심플 배경")
-                    logger.info("드롭다운 초기화 완료")
-                    return updates
-                except Exception as e:
-                    logger.error(f"드롭다운 초기화 실패: {str(e)}")
-                    return tuple([gr.update() for _ in range(7)])
-            
-            app.load(
-                fn=initialize_all_dropdowns,
-                outputs=[simple_dropdown, studio_dropdown, nature_dropdown, 
-                        indoor_dropdown, special_dropdown, jewelry_dropdown, special_effects_dropdown]
-            )
         
-        logger.info("Gradio 인터페이스 생성 완료")
+        logger.info("Gradio interface created successfully")
         return app
-        
     except Exception as e:
-        logger.error(f"Gradio 인터페이스 생성 오류: {str(e)}")
+        logger.error(f"Error creating Gradio interface: {e}")
         logger.error(traceback.format_exc())
         raise
 
 # 앱 실행
 if __name__ == "__main__":
     try:
-        logger.info("애플리케이션 시작")
+        logger.info("Starting control tower application")
         
         # imgs 디렉토리 확인/생성
         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,
-            server_name="0.0.0.0",
-            server_port=7860,
-            show_error=True,
-            quiet=False
-        )
+        logger.info("Launching Gradio app")
+        app.launch(share=True)
+    except Exception as e:
+        logger.error(f"Error running app: {e}")
+        logger.error(traceback.format_exc()), None, None, None, None, None, None
+    
+    try:
+        # 환경변수에서 가져온 코드 실행하여 딕셔너리들 추출
+        local_vars = {}
+        exec(backgrounds_code, {}, local_vars)
         
-    except KeyboardInterrupt:
-        logger.info("사용자에 의해 애플리케이션이 중단되었습니다.")
+        return (
+            local_vars.get("SIMPLE_BACKGROUNDS", {}),
+            local_vars.get("STUDIO_BACKGROUNDS", {}),
+            local_vars.get("NATURE_BACKGROUNDS", {}),
+            local_vars.get("INDOOR_BACKGROUNDS", {}),
+            local_vars.get("SPECIAL_BACKGROUNDS", {}),
+            local_vars.get("JEWELRY_BACKGROUNDS", {}),
+            local_vars.get("SPECIAL_EFFECTS_BACKGROUNDS", {})
+        )
     except Exception as e:
-        logger.error(f"앱 실행 오류: {str(e)}")
-        logger.error(traceback.format_exc())
-        print(f"\n❌ 심각한 오류가 발생했습니다: {str(e)}")
-        print("자세한 내용은 app.log 파일을 확인해주세요.")
+        logger.error(f"Failed to parse BACKGROUNDS_DATA: {e}")
+        return None, None, None, None, None, None, None
+
+# 환경변수에서 배경 딕셔너리들 로드
+(SIMPLE_BACKGROUNDS, STUDIO_BACKGROUNDS, NATURE_BACKGROUNDS, 
+ INDOOR_BACKGROUNDS, SPECIAL_BACKGROUNDS, JEWELRY_BACKGROUNDS, 
+ SPECIAL_EFFECTS_BACKGROUNDS) = load_backgrounds_from_env()
+
+# 만약 환경변수가 비어있다면 기본값 사용
+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"
+    }
+
+if not STUDIO_BACKGROUNDS:
+    STUDIO_BACKGROUNDS = {
+        "연녹색 장미 정원": "soft green background with rose garden elements",
+        "연분홍 장미 대리석": "pink rose with marble surface backdrop"
+    }
+
+if not NATURE_BACKGROUNDS:
+    NATURE_BACKGROUNDS = {
+        "작은 파도가 있는 해변": "serene beach with gentle waves",
+        "열대해변": "tropical beach setting with palm trees"
+    }
+
+if not INDOOR_BACKGROUNDS:
+    INDOOR_BACKGROUNDS = {
+        "기본 책상": "clean modern desk setup",
+        "빛이 비치는 거실": "bright living room with natural light"
+    }
+
+if not SPECIAL_BACKGROUNDS:
+    SPECIAL_BACKGROUNDS = {
+        "네이비 빈티지 플로럴 벽지": "navy vintage floral wallpaper background"
+    }
+
+if not JEWELRY_BACKGROUNDS:
+    JEWELRY_BACKGROUNDS = {
+        "화이트 미러 스팟 라이트": "white mirror surface with spotlight"
+    }
+
+if not SPECIAL_EFFECTS_BACKGROUNDS:
+    SPECIAL_EFFECTS_BACKGROUNDS = {
+        "블루블랙 큰 물방울 효과": "blue-black background with water droplet effects"
+    }
+
+# 임시 파일 저장 함수
+def save_uploaded_file(uploaded_file, suffix='.png'):
+    try:
+        logger.info(f"Processing uploaded file: {type(uploaded_file)}")
+        
+        if uploaded_file is None:
+            logger.warning("Uploaded file is None")
+            return