Update app.py

app.py

@@ -1,4 +1,3 @@
-import os
 import sys
 import base64
 import io
@@ -6,6 +5,7 @@ import logging
 import tempfile
 import traceback
 import requests
+import json
 from PIL import Image
 import gradio as gr
 from openai import OpenAI
@@ -24,54 +24,6 @@ logging.basicConfig(
 )
 logger = logging.getLogger("image-enhancer-app")
 
-# 환경변수로부터 배경 설정 로드
-def load_backgrounds():
-    """환경변수 BACKGROUNDS_CONFIG로부터 배경 설정을 로드합니다."""
-    import json
-    
-    backgrounds_json = os.environ.get("BACKGROUNDS_CONFIG", "")
-    
-    if not backgrounds_json:
-        logger.warning("BACKGROUNDS_CONFIG 환경변수가 설정되지 않았습니다. 기본값을 사용합니다.")
-        return {
-            "SIMPLE_BACKGROUNDS": {"기본 화이트": "clean white background"},
-            "STUDIO_BACKGROUNDS": {"기본 스튜디오": "studio background"},
-            "NATURE_BACKGROUNDS": {"기본 자연": "nature background"},
-            "INDOOR_BACKGROUNDS": {"기본 실내": "indoor background"},
-            "SPECIAL_BACKGROUNDS": {"기본 특수": "special background"},
-            "JEWELRY_BACKGROUNDS": {"기본 주얼리": "jewelry background"},
-            "SPECIAL_EFFECTS_BACKGROUNDS": {"기본 효과": "special effects background"}
-        }
-    
-    try:
-        backgrounds_data = json.loads(backgrounds_json)
-        logger.info("환경변수로부터 배경 설정을 성공적으로 로드했습니다.")
-        return backgrounds_data
-    except json.JSONDecodeError as e:
-        logger.error(f"배경 설정 JSON 파싱 오류: {e}")
-        return {}
-
-# 배경 설정 로드
-backgrounds_data = load_backgrounds()
-SIMPLE_BACKGROUNDS = backgrounds_data.get("SIMPLE_BACKGROUNDS", {})
-STUDIO_BACKGROUNDS = backgrounds_data.get("STUDIO_BACKGROUNDS", {})
-NATURE_BACKGROUNDS = backgrounds_data.get("NATURE_BACKGROUNDS", {})
-INDOOR_BACKGROUNDS = backgrounds_data.get("INDOOR_BACKGROUNDS", {})
-SPECIAL_BACKGROUNDS = backgrounds_data.get("SPECIAL_BACKGROUNDS", {})
-JEWELRY_BACKGROUNDS = backgrounds_data.get("JEWELRY_BACKGROUNDS", {})
-SPECIAL_EFFECTS_BACKGROUNDS = backgrounds_data.get("SPECIAL_EFFECTS_BACKGROUNDS", {})
-
-# 환경변수로부터 모델 설정 로드
-IMAGE_EDIT_MODEL_GPT = os.environ.get("IMAGE_EDIT_MODEL_GPT", "gpt-image-1")
-IMAGE_EDIT_MODEL_FLUX = os.environ.get("IMAGE_EDIT_MODEL_FLUX", "black-forest-labs/flux-kontext-pro")
-TRANSLATION_MODEL = os.environ.get("TRANSLATION_MODEL", "gemini-2.0-flash")
-ENHANCEMENT_MODEL = os.environ.get("ENHANCEMENT_MODEL", "philz1337x/clarity-upscaler:dfad41707589d68ecdccd1dfa600d55a208f9310748e44bfe35b4a6291453d5e")
-
-logger.info(f"이미지 편집 모델 (GPT): {IMAGE_EDIT_MODEL_GPT}")
-logger.info(f"이미지 편집 모델 (Flux): {IMAGE_EDIT_MODEL_FLUX}")
-logger.info(f"번역 모델: {TRANSLATION_MODEL}")
-logger.info(f"화질 개선 모델: {ENHANCEMENT_MODEL}")
-
 # API 클라이언트 초기화 (안전하게)
 openai_client = OpenAI(api_key=os.environ.get("OPENAI_API_KEY", ""))
 
@@ -88,6 +40,148 @@ else:
     logger.warning("GEMINI_API_KEY not found or empty, Gemini client not initialized")
     gemini_client = None
 
+# 설정값들을 환경변수에서 로드하는 함수들
+def get_app_password():
+    """환경변수에서 앱 비밀번호를 가져옵니다."""
+    password = os.environ.get("APP_PASSWORD")
+    if password:
+        logger.info("App password loaded from environment variable")
+        return password
+    else:
+        logger.warning("APP_PASSWORD environment variable not found, using default password")
+        return "1089"  # 기본 비밀번호
+
+# 배경 데이터를 환경변수에서 로드하는 함수
+def load_backgrounds_from_env():
+    """환경변수에서 배경 데이터를 로드합니다."""
+    try:
+        # 환경변수에서 JSON 문자열로 저장된 배경 데이터 로드
+        backgrounds_data = os.environ.get("BACKGROUNDS_DATA")
+        if backgrounds_data:
+            logger.info("Loading backgrounds data from environment variable")
+            return json.loads(backgrounds_data)
+        else:
+            logger.warning("BACKGROUNDS_DATA environment variable not found, using default backgrounds")
+            return get_default_backgrounds()
+    except Exception as e:
+        logger.error(f"Error loading backgrounds from environment: {e}")
+        logger.info("Falling back to default backgrounds")
+        return get_default_backgrounds()
+
+def get_default_backgrounds():
+    """기본 배경 데이터를 반환합니다."""
+    return {
+        "SIMPLE_BACKGROUNDS": {
+            "화이트 기본": "A clean, minimalistic digital background scene featuring a seamless pure white backdrop and a smooth white surface. The lighting is bright and evenly diffused from above, eliminating harsh shadows and creating a crisp, studio-lit environment. There are no products or objects present — only the empty background remains. The composition is ultra-clean and modern, ideal for overlaying lifestyle or hydration-related products. The mood is fresh, light, and professional. Ultra-sharp, studio-quality, high resolution, photo-realistic",
+            "회색 투톤": "A clean and minimal product photography background featuring a seamless, near-white light gray tone across both the backdrop and surface. The entire scene is evenly lit with bright, diffused lighting from above, eliminating harsh shadows and producing a calm, sophisticated atmosphere. The composition remains empty — with no products or objects present — offering a soft and airy visual ideal for modern lifestyle, wellness, or eco-friendly branding. The lighting gently enhances spatial depth without creating reflections. Ultra-clear, studio-quality, photo-realistic"
+        },
+        "STUDIO_BACKGROUNDS": {
+            "연녹색 장미 정원": "A high-resolution, commercial-style digital photograph of a sophisticated background setup designed for a luxury product shoot. The scene features soft green tones with lush fern leaves and creamy pastel roses (white, peach, blush pink) artfully arranged. The flowers are placed on a white polished marble platform with soft veining, surrounded by elegant foliage. The lighting is natural and diffused from the top left, producing soft shadows and a serene mood. There is no product in the scene — only the floral arrangement and surface remain, creating a refined, editorial-quality backdrop suitable for overlaying product photography. No object should be centered; the composition should remain balanced and inviting. ultra-detailed, 8K quality, photo-realistic studio setting."
+        },
+        "NATURE_BACKGROUNDS": {
+            "작은 파도가 있는 해변": "A serene and natural beach-themed product photography scene. The background features warm golden sand and gentle turquoise waves softly rolling onto the shore, with white foam catching the golden light of a late afternoon sun. Around the edges of the frame — but not overlapping the center foreground — small natural elements like seashells, conch shells, and bits of coral are randomly scattered with varied sizes, positions, and quantities to evoke a natural, organic arrangement. The product area remains clean and visually unobstructed to maintain focus. Lighting is soft and ambient with subtle natural shadows to highlight the uploaded product. The overall atmosphere is peaceful, sunlit, and summer-inspired. Ultra photo-realistic, studio-quality"
+        },
+        "INDOOR_BACKGROUNDS": {
+            "기본 책상": "A bright, Scandinavian-inspired home office featuring a matte white desk with crisp edges placed against a soft sage green wall. Natural daylight gently enters from the side, casting diffused shadows across the surface and enhancing the calm, focused atmosphere. On the desk are neatly arranged everyday essentials like a few colorful pens, a potted plant, and an open notebook. A neutral-toned ergonomic chair is tucked under the desk, and the surrounding area is intentionally minimal to emphasize clarity and productivity. The entire setting evokes a modern, clutter-free work environment., photo-realistic, high-resolution."
+        },
+        "SPECIAL_BACKGROUNDS": {
+            "네이비 빈티지 플로럴 벽지": "A richly detailed studio photography background featuring an ornate, vintage-inspired floral wallpaper design. The backdrop showcases vibrant red, pink, yellow, and green botanical motifs intricately woven across a deep navy blue base. The floral pattern is symmetrical and bold, giving the composition an artistic, maximalist aesthetic. The floor is a clean, solid blue surface, providing visual contrast and modern balance. Lighting is bright and evenly diffused, emphasizing both the product and the intricate details of the wallpaper. Ideal for showcasing creative, lifestyle, or design-forward products. Ultra-detailed, high-resolution, ."
+        },
+        "JEWELRY_BACKGROUNDS": {
+            "화이트 미러 스팟 라이트": "A luxury jewelry product photoshoot featuring a soft white backdrop and a polished white mirrored surface. A single focused overhead light beam softly illuminates the center of the scene, fading smoothly toward the edges with a clean gradient. The glossy white surface reflects the jewelry item with crystal clarity — capturing the shape, facets, and symmetry of the design in perfect mirror-like detail. The reflection appears sharp, clean, and vertically aligned beneath the product, enhancing the sense of luxury and balance. The atmosphere is premium, minimal, and luminous — ideal for high-end diamond earrings or bridal jewelry. Ultra-detailed, studio-quality, photo-realistic"
+        },
+        "SPECIAL_EFFECTS_BACKGROUNDS": {
+            "블루블랙 큰 물방울 효과": "A deep black and vivid cobalt blue gradient backdrop with a reflective surface splashed by crystalline water droplets frozen mid-air. Backlighting enhances shimmer and motion, creating a sense of waterproof resilience. High-impact, ultra-detailed."
+        }
+    }
+
+# 배경 데이터 로드
+backgrounds_data = load_backgrounds_from_env()
+SIMPLE_BACKGROUNDS = backgrounds_data.get("SIMPLE_BACKGROUNDS", {})
+STUDIO_BACKGROUNDS = backgrounds_data.get("STUDIO_BACKGROUNDS", {})
+NATURE_BACKGROUNDS = backgrounds_data.get("NATURE_BACKGROUNDS", {})
+INDOOR_BACKGROUNDS = backgrounds_data.get("INDOOR_BACKGROUNDS", {})
+SPECIAL_BACKGROUNDS = backgrounds_data.get("SPECIAL_BACKGROUNDS", {})
+JEWELRY_BACKGROUNDS = backgrounds_data.get("JEWELRY_BACKGROUNDS", {})
+SPECIAL_EFFECTS_BACKGROUNDS = backgrounds_data.get("SPECIAL_EFFECTS_BACKGROUNDS", {})
+
+# 앱 비밀번호 로드
+APP_PASSWORD = get_app_password()
+
+# 환경변수 검증 함수
+def validate_environment_variables():
+    """필수 환경변수가 설정되었는지 확인합니다."""
+    logger.info("=== 환경변수 검증 시작 ===")
+    
+    # 비밀번호 검증
+    logger.info(f"APP_PASSWORD: {'설정됨' if os.environ.get('APP_PASSWORD') else '기본값 사용 (1089)'}")
+    
+    # API 키 검증
+    openai_key = os.environ.get("OPENAI_API_KEY")
+    replicate_token = os.environ.get("REPLICATE_API_TOKEN") 
+    gemini_key = os.environ.get("GEMINI_API_KEY")
+    
+    logger.info(f"OPENAI_API_KEY: {'설정됨' if openai_key else '설정되지 않음'}")
+    logger.info(f"REPLICATE_API_TOKEN: {'설정됨' if replicate_token else '설정되지 않음'}")
+    logger.info(f"GEMINI_API_KEY: {'설정됨' if gemini_key else '설정되지 않음'}")
+    
+    # 배경 데이터 검증
+    backgrounds_data_env = os.environ.get("BACKGROUNDS_DATA")
+    if backgrounds_data_env:
+        logger.info("BACKGROUNDS_DATA: 환경변수에서 설정됨")
+        try:
+            parsed_data = json.loads(backgrounds_data_env)
+            bg_counts = {
+                category: len(backgrounds) 
+                for category, backgrounds in parsed_data.items()
+            }
+            logger.info(f"배경 데이터 로드 성공: {bg_counts}")
+            
+            # 각 카테고리별 상세 정보
+            for category, backgrounds in parsed_data.items():
+                if backgrounds:
+                    sample_keys = list(backgrounds.keys())[:3]  # 처음 3개만 표시
+                    logger.info(f"  {category}: {len(backgrounds)}개 - 예시: {sample_keys}")
+                else:
+                    logger.warning(f"  {category}: 비어있음")
+                    
+        except Exception as e:
+            logger.error(f"BACKGROUNDS_DATA JSON 파싱 오류: {e}")
+            logger.error("배경 데이터 형식이 올바른지 확인해주세요.")
+    else:
+        logger.info("BACKGROUNDS_DATA: 환경변수 없음 (기본값 사용)")
+        
+    # 실제 로드된 배경 데이터 확인
+    actual_bg_counts = {
+        "SIMPLE_BACKGROUNDS": len(SIMPLE_BACKGROUNDS),
+        "STUDIO_BACKGROUNDS": len(STUDIO_BACKGROUNDS),
+        "NATURE_BACKGROUNDS": len(NATURE_BACKGROUNDS),
+        "INDOOR_BACKGROUNDS": len(INDOOR_BACKGROUNDS),
+        "SPECIAL_BACKGROUNDS": len(SPECIAL_BACKGROUNDS),
+        "JEWELRY_BACKGROUNDS": len(JEWELRY_BACKGROUNDS),
+        "SPECIAL_EFFECTS_BACKGROUNDS": len(SPECIAL_EFFECTS_BACKGROUNDS)
+    }
+    logger.info(f"실제 로드된 배경 데이터: {actual_bg_counts}")
+    
+    # 경고 메시지
+    missing_apis = []
+    if not openai_key:
+        missing_apis.append("OpenAI (GPT 모델 사용 불가)")
+    if not replicate_token:
+        missing_apis.append("Replicate (Flux 모델 및 화질개선 사용 불가)")
+    if not gemini_key:
+        missing_apis.append("Gemini (번역 기능 사용 불가)")
+    
+    if missing_apis:
+        logger.warning(f"누락된 API 키로 인해 다음 기능이 제한됩니다: {', '.join(missing_apis)}")
+    else:
+        logger.info("모든 API 키가 설정되어 전체 기능 사용 가능합니다.")
+    
+    logger.info("=== 환경변수 검증 완료 ===")
+
+# 환경변수 검증 실행
+validate_environment_variables()
+
 # 임시 파일 저장 함수
 def save_uploaded_file(uploaded_file, suffix='.png'):
     try:
@@ -130,9 +224,9 @@ def save_uploaded_file(uploaded_file, suffix='.png'):
         logger.error(traceback.format_exc())
         return None
 
-# 텍스트 번역 함수 (한국어 → 영어) - 환경변수 모델 사용
+# 텍스트 번역 함수 (한국어 → 영어) - Gemini 2.0 Flash 전용
 def translate_to_english(text):
-    """한국어 텍스트를 영어로 번역 (환경변수 모델 사용)"""
+    """한국어 텍스트를 영어로 번역 (Gemini 2.0 Flash 사용)"""
     try:
         if not text or not text.strip():
             return ""
@@ -142,10 +236,10 @@ def translate_to_english(text):
             logger.warning("Gemini client not available, returning original text")
             return text
         
-        # 환경변수에서 설정된 번역 모델 사용
+        # Gemini 2.0 Flash를 사용한 번역
         try:
             response = gemini_client.models.generate_content(
-                model=TRANSLATION_MODEL,
+                model="gemini-2.0-flash",
                 config=types.GenerateContentConfig(
                     system_instruction="You are a professional translator. Translate the given Korean text to English. Keep the translation natural and contextually appropriate for image generation prompts. If the text is already in English, return it as is. Only return the translated text without any additional explanation.",
                     max_output_tokens=200,
@@ -155,11 +249,11 @@ def translate_to_english(text):
             )
             
             translated = response.text.strip()
-            logger.info(f"Translated '{text}' to '{translated}' using {TRANSLATION_MODEL}")
+            logger.info(f"Translated '{text}' to '{translated}' using Gemini 2.0 Flash")
             return translated
             
         except Exception as e:
-            logger.error(f"Translation error with {TRANSLATION_MODEL}: {e}")
+            logger.error(f"Gemini translation error: {e}")
             logger.warning("Translation failed, returning original text")
             return text
             
@@ -200,7 +294,7 @@ def generate_prompt(background_type, background_name, user_request, aspect_ratio
     
     # 사용자 요청사항 처리
     if user_request and user_request.strip():
-        # 한국어 요청사항을 영어로 번역
+        # 한국어 요청사항을 영어로 번역 (Gemini 2.0 Flash 사용)
         translated_request = translate_to_english(user_request)
         
         # 번역된 요청사항을 배경 프롬프트에 통합
@@ -289,13 +383,13 @@ def edit_and_enhance_image(
                 
                 params = {
                     "prompt": prompt,
-                    "model": IMAGE_EDIT_MODEL_GPT,
+                    "model": "gpt-image-1",
                     "n": 1,
                     "size": size,
                     "image": processed_image
                 }
                 
-                logger.info(f"Calling OpenAI API for image editing with model: {IMAGE_EDIT_MODEL_GPT}")
+                logger.info(f"Calling OpenAI API for image editing")
                 response = openai_client.images.edit(**params)
                 logger.info("OpenAI API call successful")
                 
@@ -321,7 +415,7 @@ def edit_and_enhance_image(
                     
                     edited_images.append(image)
                 
-                usage_info = f"이미지 편집 완료 ({IMAGE_EDIT_MODEL_GPT} 모델 사용)"
+                usage_info = "이미지 편집 완료 (GPT 모델 사용)"
                 
             else:  # quality_level == "flux"
                 # Flux 모델 사용 (항상 기본 화질개선 1회 적용)
@@ -329,11 +423,11 @@ def edit_and_enhance_image(
                     logger.error("Replicate API token is not set")
                     return None, None, None, "Replicate API 토큰이 설정되지 않았습니다. API 토큰을 설정해주세요."
                 
-                logger.info(f"Using Flux model for image editing: {IMAGE_EDIT_MODEL_FLUX}")
+                logger.info(f"Using Flux model for image editing")
                 
                 # Flux 모델로 이미지 생성
                 output = replicate.run(
-                    IMAGE_EDIT_MODEL_FLUX,
+                    "black-forest-labs/flux-kontext-pro",
                     input={
                         "prompt": prompt,
                         "input_image": processed_image,
@@ -368,7 +462,7 @@ def edit_and_enhance_image(
                     
                     # Flux 모델은 항상 첫 번째 화질 개선을 자동 적용
                     try:
-                        logger.info(f"Applying automatic first enhancement for Flux model using: {ENHANCEMENT_MODEL}")
+                        logger.info("Applying automatic first enhancement for Flux model")
                         
                         # 임시 파일로 저장
                         temp_flux_path = tempfile.mktemp(suffix='.png')
@@ -377,7 +471,7 @@ def edit_and_enhance_image(
                         
                         # 첫 번째 화질 향상 (Flux 모델 기본 적용)
                         first_enhanced_output = replicate.run(
-                            ENHANCEMENT_MODEL,
+                            "philz1337x/clarity-upscaler:dfad41707589d68ecdccd1dfa600d55a208f9310748e44bfe35b4a6291453d5e",
                             input={
                                 "image": open(temp_flux_path, "rb"),
                                 "scale_factor": 2,
@@ -403,22 +497,22 @@ def edit_and_enhance_image(
                                     first_enhanced_image = background
                                 
                                 edited_images.append(first_enhanced_image)
-                                usage_info = f"이미지 편집 완료 ({IMAGE_EDIT_MODEL_FLUX} + 기본 화질개선 적용)"
+                                usage_info = "이미지 편집 완료 (Flux 모델 + 기본 화질개선 적용)"
                                 logger.info("First enhancement completed for Flux model")
                             else:
                                 # 첫 번째 화질개선 실패 시 원본 사용
                                 edited_images.append(flux_image)
-                                usage_info = f"이미지 편집 완료 ({IMAGE_EDIT_MODEL_FLUX} 사용, 기본 화질개선 실패)"
+                                usage_info = "이미지 편집 완료 (Flux 모델 사용, 기본 화질개선 실패)"
                         else:
                             # 첫 번째 화질개선 실패 시 원본 사용
                             edited_images.append(flux_image)
-                            usage_info = f"이미지 편집 완료 ({IMAGE_EDIT_MODEL_FLUX} 사용, 기본 화질개선 실패)"
+                            usage_info = "이미지 편집 완료 (Flux 모델 사용, 기본 화질개선 실패)"
                             
                     except Exception as e:
                         logger.error(f"Error in first enhancement for Flux: {e}")
                         # 첫 번째 화질개선 실패 시 원본 사용
                         edited_images.append(flux_image)
-                        usage_info = f"이미지 편집 완료 ({IMAGE_EDIT_MODEL_FLUX} 사용, 기본 화질개선 오류: {str(e)})"
+                        usage_info = f"이미지 편집 완료 (Flux 모델 사용, 기본 화질개선 오류: {str(e)})"
                         
                 else:
                     logger.error("No output from Flux API")
@@ -445,11 +539,11 @@ def edit_and_enhance_image(
             try:
                 if quality_level == "gpt":
                     # GPT 모델: 일반적인 화질 개선
-                    logger.info(f"Enhancing GPT image with {ENHANCEMENT_MODEL}, enhancement level: {enhancement_level}")
+                    logger.info(f"Enhancing GPT image with Replicate API, enhancement level: {enhancement_level}")
                     enhancement_info = "화질 개선"
                 else:
                     # Flux 모델: 2차 화질 개선 (이미 1차는 적용됨)
-                    logger.info(f"Applying second enhancement for Flux image with {ENHANCEMENT_MODEL}, enhancement level: {enhancement_level}")
+                    logger.info(f"Applying second enhancement for Flux image, enhancement level: {enhancement_level}")
                     enhancement_info = "2차 화질 개선"
                 
                 if not os.environ.get("REPLICATE_API_TOKEN"):
@@ -463,7 +557,7 @@ def edit_and_enhance_image(
                     
                     # Replicate API로 화질 향상
                     output = replicate.run(
-                        ENHANCEMENT_MODEL,
+                        "philz1337x/clarity-upscaler:dfad41707589d68ecdccd1dfa600d55a208f9310748e44bfe35b4a6291453d5e",
                         input={
                             "image": open(temp_image_path, "rb"),
                             "scale_factor": enhancement_level,
@@ -475,7 +569,7 @@ def edit_and_enhance_image(
                         }
                     )
                     
-                    logger.info(f"Enhancement API response: {output}")
+                    logger.info(f"Replicate API response: {output}")
                     
                     if output and isinstance(output, list) and len(output) > 0:
                         enhanced_url = output[0]
@@ -489,13 +583,13 @@ def edit_and_enhance_image(
                                 enhanced_image = background
                             
                             if quality_level == "gpt":
-                                usage_info += f" | {enhancement_info} 완료: {ENHANCEMENT_MODEL} 사용"
+                                usage_info += f" | {enhancement_info} 완료: Replicate Clarity Upscaler 사용"
                             else:
                                 usage_info += f" | {enhancement_info} 완료: 총 2회 화질개선 적용"
                         else:
                             usage_info += f" | {enhancement_info} 실패: 이미지 다운로드 오류"
                     else:
-                        usage_info += f" | {enhancement_info} 실패: Enhancement API 응답 없음"
+                        usage_info += f" | {enhancement_info} 실패: Replicate API 응답 없음"
                 
             except Exception as e:
                 logger.error(f"Error enhancing image: {e}")
@@ -558,58 +652,70 @@ def create_gradio_interface():
                                 value="심플 배경"
                             )
                             
-                            # 드롭다운 컴포넌트들
+                            # 드롭다운 컴포넌트들 - 환경변수에서 로드된 데이터 사용
+                            simple_choices = list(SIMPLE_BACKGROUNDS.keys()) if SIMPLE_BACKGROUNDS else []
+                            studio_choices = list(STUDIO_BACKGROUNDS.keys()) if STUDIO_BACKGROUNDS else []
+                            nature_choices = list(NATURE_BACKGROUNDS.keys()) if NATURE_BACKGROUNDS else []
+                            indoor_choices = list(INDOOR_BACKGROUNDS.keys()) if INDOOR_BACKGROUNDS else []
+                            special_choices = list(SPECIAL_BACKGROUNDS.keys()) if SPECIAL_BACKGROUNDS else []
+                            jewelry_choices = list(JEWELRY_BACKGROUNDS.keys()) if JEWELRY_BACKGROUNDS else []
+                            special_effects_choices = list(SPECIAL_EFFECTS_BACKGROUNDS.keys()) if SPECIAL_EFFECTS_BACKGROUNDS else []
+                            
+                            # 환경변수가 없어서 배경 데이터가 비어있는 경우 경고
+                            if not any([simple_choices, studio_choices, nature_choices, indoor_choices, special_choices, jewelry_choices, special_effects_choices]):
+                                logger.error("모든 배경 카테고리가 비어있습니다. BACKGROUNDS_DATA 환경변수를 설정해주세요.")
+                            
                             simple_dropdown = gr.Dropdown(
-                                choices=list(SIMPLE_BACKGROUNDS.keys()),
-                                value=list(SIMPLE_BACKGROUNDS.keys())[0] if SIMPLE_BACKGROUNDS else None,
+                                choices=simple_choices,
+                                value=simple_choices[0] if simple_choices else None,
                                 label="심플 배경 선택",
                                 visible=True,
                                 interactive=True
                             )
                             
                             studio_dropdown = gr.Dropdown(
-                                choices=list(STUDIO_BACKGROUNDS.keys()),
-                                value=list(STUDIO_BACKGROUNDS.keys())[0] if STUDIO_BACKGROUNDS else None,
+                                choices=studio_choices,
+                                value=studio_choices[0] if studio_choices else None,
                                 label="스튜디오 배경 선택",
                                 visible=False,
                                 interactive=True
                             )
                             
                             nature_dropdown = gr.Dropdown(
-                                choices=list(NATURE_BACKGROUNDS.keys()),
-                                value=list(NATURE_BACKGROUNDS.keys())[0] if NATURE_BACKGROUNDS else None,
+                                choices=nature_choices,
+                                value=nature_choices[0] if nature_choices else None,
                                 label="자연 환경 선택",
                                 visible=False,
                                 interactive=True
                             )
                             
                             indoor_dropdown = gr.Dropdown(
-                                choices=list(INDOOR_BACKGROUNDS.keys()),
-                                value=list(INDOOR_BACKGROUNDS.keys())[0] if INDOOR_BACKGROUNDS else None,
+                                choices=indoor_choices,
+                                value=indoor_choices[0] if indoor_choices else None,
                                 label="실내 환경 선택",
                                 visible=False,
                                 interactive=True
                             )
                             
                             special_dropdown = gr.Dropdown(
-                                choices=list(SPECIAL_BACKGROUNDS.keys()),
-                                value=list(SPECIAL_BACKGROUNDS.keys())[0] if SPECIAL_BACKGROUNDS else None,
+                                choices=special_choices,
+                                value=special_choices[0] if special_choices else None,
                                 label="특수배경 선택",
                                 visible=False,
                                 interactive=True
                             )
                             
                             jewelry_dropdown = gr.Dropdown(
-                                choices=list(JEWELRY_BACKGROUNDS.keys()),
-                                value=list(JEWELRY_BACKGROUNDS.keys())[0] if JEWELRY_BACKGROUNDS else None,
+                                choices=jewelry_choices,
+                                value=jewelry_choices[0] if jewelry_choices else None,
                                 label="주얼리 배경 선택",
                                 visible=False,
                                 interactive=True
                             )
                             
                             special_effects_dropdown = gr.Dropdown(
-                                choices=list(SPECIAL_EFFECTS_BACKGROUNDS.keys()),
-                                value=list(SPECIAL_EFFECTS_BACKGROUNDS.keys())[0] if SPECIAL_EFFECTS_BACKGROUNDS else None,
+                                choices=special_effects_choices,
+                                value=special_effects_choices[0] if special_effects_choices else None,
                                 label="특수효과 배경 선택",
                                 visible=False,
                                 interactive=True
@@ -617,14 +723,58 @@ def create_gradio_interface():
                             
                             # 드롭다운 변경 함수
                             def update_dropdowns(bg_type):
+                                """배경 유형에 따라 드롭다운을 업데이트합니다."""
+                                logger.info(f"Updating dropdowns for background type: {bg_type}")
+                                
+                                # 각 배경 카테고리의 키 목록 가져오기
+                                simple_choices = list(SIMPLE_BACKGROUNDS.keys()) if SIMPLE_BACKGROUNDS else []
+                                studio_choices = list(STUDIO_BACKGROUNDS.keys()) if STUDIO_BACKGROUNDS else []
+                                nature_choices = list(NATURE_BACKGROUNDS.keys()) if NATURE_BACKGROUNDS else []
+                                indoor_choices = list(INDOOR_BACKGROUNDS.keys()) if INDOOR_BACKGROUNDS else []
+                                special_choices = list(SPECIAL_BACKGROUNDS.keys()) if SPECIAL_BACKGROUNDS else []
+                                jewelry_choices = list(JEWELRY_BACKGROUNDS.keys()) if JEWELRY_BACKGROUNDS else []
+                                special_effects_choices = list(SPECIAL_EFFECTS_BACKGROUNDS.keys()) if SPECIAL_EFFECTS_BACKGROUNDS else []
+                                
+                                # 디버깅 정보 로깅
+                                logger.info(f"Available choices - Simple: {len(simple_choices)}, Studio: {len(studio_choices)}, Nature: {len(nature_choices)}")
+                                logger.info(f"Indoor: {len(indoor_choices)}, Special: {len(special_choices)}, Jewelry: {len(jewelry_choices)}, Effects: {len(special_effects_choices)}")
+                                
                                 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 == "특수효과"))
+                                    simple_dropdown: gr.update(
+                                        visible=(bg_type == "심플 배경"), 
+                                        choices=simple_choices,
+                                        value=simple_choices[0] if simple_choices else None
+                                    ),
+                                    studio_dropdown: gr.update(
+                                        visible=(bg_type == "스튜디오 배경"),
+                                        choices=studio_choices,
+                                        value=studio_choices[0] if studio_choices else None
+                                    ),
+                                    nature_dropdown: gr.update(
+                                        visible=(bg_type == "자연 환경"),
+                                        choices=nature_choices,
+                                        value=nature_choices[0] if nature_choices else None
+                                    ),
+                                    indoor_dropdown: gr.update(
+                                        visible=(bg_type == "실내 환경"),
+                                        choices=indoor_choices,
+                                        value=indoor_choices[0] if indoor_choices else None
+                                    ),
+                                    special_dropdown: gr.update(
+                                        visible=(bg_type == "특수배경"),
+                                        choices=special_choices,
+                                        value=special_choices[0] if special_choices else None
+                                    ),
+                                    jewelry_dropdown: gr.update(
+                                        visible=(bg_type == "주얼리"),
+                                        choices=jewelry_choices,
+                                        value=jewelry_choices[0] if jewelry_choices else None
+                                    ),
+                                    special_effects_dropdown: gr.update(
+                                        visible=(bg_type == "특수효과"),
+                                        choices=special_effects_choices,
+                                        value=special_effects_choices[0] if special_effects_choices else None
+                                    )
                                 }
                             
                             background_type.change(
@@ -645,7 +795,7 @@ def create_gradio_interface():
                         label="품질 레벨", 
                         choices=["gpt", "flux"],
                         value="flux",
-                        info="GPT: GPT 모델 (고품질), Flux: Flux 모델 (빠른 처리 + 기본 화질개선)"
+                        info="GPT: GPT 모델 (고품질), 일반: Flux 모델 (빠른 처리 + 기본 화질개선)"
                     )
                     
                     aspect_ratio = gr.Dropdown(
@@ -693,8 +843,8 @@ def create_gradio_interface():
             
             # 프롬프트만 생성하는 함수 (비밀번호 체크 포함)
             def generate_prompt_with_password_check(password, bg_type, simple, studio, nature, indoor, special, jewelry, special_effects, request_text, aspect_ratio):
-                # 비밀번호 확인
-                if password != "1089":
+                # 비밀번호 확인 - 환경변수에서 가져온 비밀번호와 비교
+                if password != APP_PASSWORD:
                     return "비밀번호가 틀렸습니다. 올바른 비밀번호를 입력해주세요."
                 
                 # 배경 선택
@@ -720,7 +870,7 @@ def create_gradio_interface():
             
             # 비밀번호 확인 함수
             def check_password(password, *args):
-                if password != "1089":
+                if password != APP_PASSWORD:
                     return (
                         [],  # original_output
                         None,  # original_download
@@ -844,15 +994,30 @@ def create_gradio_interface():
 # 앱 실행
 if __name__ == "__main__":
     try:
-        logger.info("Starting application")
+        logger.info("=== AI 이미지 편집 및 화질 개선 애플리케이션 시작 ===")
         
         # imgs 디렉토리 확인/생성
         os.makedirs("imgs", exist_ok=True)
         logger.info("이미지 디렉토리 준비 완료")
         
+        # 환경변수 재검증 (앱 시작 시)
+        logger.info("앱 시작 전 환경변수 최종 확인")
+        if not APP_PASSWORD:
+            logger.warning("비밀번호가 설정되지 않았습니다. 기본 비밀번호(1089)를 사용합니다.")
+        
+        if not any([
+            os.environ.get("OPENAI_API_KEY"),
+            os.environ.get("REPLICATE_API_TOKEN"),
+            os.environ.get("GEMINI_API_KEY")
+        ]):
+            logger.warning("API 키가 하나도 설정되지 않았습니다. 기능이 제한될 수 있습니다.")
+        
+        # Gradio 인터페이스 생성 및 실행
         app = create_gradio_interface()
-        logger.info("Launching Gradio app")
+        logger.info("Gradio 인터페이스 생성 완료")
+        logger.info("애플리케이션을 시작합니다...")
         app.launch(share=True)
+        
     except Exception as e:
-        logger.error(f"Error running app: {e}")
+        logger.error(f"애플리케이션 실행 중 오류 발생: {e}")
         logger.error(traceback.format_exc())