Update app.py

app.py

@@ -8,13 +8,12 @@ import traceback
 import requests
 from PIL import Image
 import gradio as gr
-from gradio_client import Client, handle_file
-from dotenv import load_dotenv
+from openai import OpenAI
+import replicate
+from google import genai
+from google.genai import types
 
-# 환경변수 로드
-load_dotenv()
-
-# 로깅 설정 (민감한 정보 제외)
+# 로깅 설정
 logging.basicConfig(
     level=logging.INFO,
     format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
@@ -25,164 +24,71 @@ logging.basicConfig(
 )
 logger = logging.getLogger("image-enhancer-app")
 
-# API 클라이언트 초기화 (환경변수에서)
-API_ENDPOINT = os.environ.get("API_ENDPOINT")
-if not API_ENDPOINT:
-    logger.error("API_ENDPOINT environment variable is not set")
-    sys.exit(1)
-
-try:
-    # 로그에 엔드포인트 정보 출력하지 않음
-    api_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)
-
-# 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")
-        return {}, {}, {}, {}, {}, {}, {}
+# 환경변수로부터 배경 설정 로드
+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:
-        # 환경변수에서 가져온 코드 실행하여 딕셔너리들 추출
-        local_vars = {}
-        exec(backgrounds_code, {}, local_vars)
-        
-        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"Failed to parse BACKGROUNDS_DATA: {e}")
-        return {}, {}, {}, {}, {}, {}, {}
-
-# 환경변수에서 배경 딕셔너리들 로드
-(SIMPLE_BACKGROUNDS, STUDIO_BACKGROUNDS, NATURE_BACKGROUNDS, 
- INDOOR_BACKGROUNDS, SPECIAL_BACKGROUNDS, JEWELRY_BACKGROUNDS, 
- SPECIAL_EFFECTS_BACKGROUNDS) = load_backgrounds_from_env()
+        backgrounds_data = json.loads(backgrounds_json)
+        logger.info("환경변수로부터 배경 설정을 성공적으로 로드했습니다.")
+        return backgrounds_data
+    except json.JSONDecodeError as e:
+        logger.error(f"배경 설정 JSON 파싱 오류: {e}")
+        return {}
 
-# 만약 환경변수가 비어있다면 기본값 사용
-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",
-        "그레이 그라데이션 스포트라이트": "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"
-    }
+# 배경 설정 로드
+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", {})
 
-if not STUDIO_BACKGROUNDS:
-    STUDIO_BACKGROUNDS = {
-        "연녹색 장미 정원": "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"
-    }
+# 환경변수로부터 모델 설정 로드
+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")
 
-if not NATURE_BACKGROUNDS:
-    NATURE_BACKGROUNDS = {
-        "작은 파도가 있는 해변": "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"
-    }
+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}")
 
-if not INDOOR_BACKGROUNDS:
-    INDOOR_BACKGROUNDS = {
-        "기본 책상": "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"
-    }
+# API 클라이언트 초기화 (안전하게)
+openai_client = OpenAI(api_key=os.environ.get("OPENAI_API_KEY", ""))
 
-if not SPECIAL_BACKGROUNDS:
-    SPECIAL_BACKGROUNDS = {
-        "네이비 빈티지 플로럴 벽지": "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 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 water drop effect",
-        "크리스탈 버블 물속 장면": "crystal bubble underwater scene",
-        "잔 물결 수면 위 장면": "gentle ripple water surface scene",
-        "컬러 스모크 효과": "color smoke effect",
-        "자옥한 안개 효과": "dense fog effect",
-        "가습기 수중기 효과": "humidifier mist effect"
-    }
+# Gemini 클라이언트 초기화 - API 키가 있을 때만
+gemini_api_key = os.environ.get("GEMINI_API_KEY")
+if gemini_api_key and gemini_api_key.strip():
+    try:
+        gemini_client = genai.Client(api_key=gemini_api_key)
+        logger.info("Gemini client initialized successfully")
+    except Exception as e:
+        logger.error(f"Failed to initialize Gemini client: {e}")
+        gemini_client = None
+else:
+    logger.warning("GEMINI_API_KEY not found or empty, Gemini client not initialized")
+    gemini_client = None
 
-# 임시 파일 저장 함수 (원본과 동일)
+# 임시 파일 저장 함수
 def save_uploaded_file(uploaded_file, suffix='.png'):
     try:
         logger.info(f"Processing uploaded file: {type(uploaded_file)}")
@@ -224,7 +130,406 @@ def save_uploaded_file(uploaded_file, suffix='.png'):
         logger.error(traceback.format_exc())
         return None
 
-# Gradio 인터페이스 구성 (원본과 완전 동일)
+# 텍스트 번역 함수 (한국어 → 영어) - 환경변수 모델 사용
+def translate_to_english(text):
+    """한국어 텍스트를 영어로 번역 (환경변수 모델 사용)"""
+    try:
+        if not text or not text.strip():
+            return ""
+        
+        # Gemini 클라이언트가 초기화되었는지 확인
+        if gemini_client is None:
+            logger.warning("Gemini client not available, returning original text")
+            return text
+        
+        # 환경변수에서 설정된 번역 모델 사용
+        try:
+            response = gemini_client.models.generate_content(
+                model=TRANSLATION_MODEL,
+                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,
+                    temperature=0.1
+                ),
+                contents=[f"Translate this to English: {text}"]
+            )
+            
+            translated = response.text.strip()
+            logger.info(f"Translated '{text}' to '{translated}' using {TRANSLATION_MODEL}")
+            return translated
+            
+        except Exception as e:
+            logger.error(f"Translation error with {TRANSLATION_MODEL}: {e}")
+            logger.warning("Translation failed, returning original text")
+            return text
+            
+    except Exception as e:
+        logger.error(f"Translation error: {e}")
+        return text
+
+# 프롬프트 생성 함수 (종횡비와 요청사항 통합)
+def generate_prompt(background_type, background_name, user_request, aspect_ratio="1:1"):
+    # 기본 고정 프롬프트 (종횡비 정보 포함) - 영어로 변경
+    fixed_prompt = f"""
+## Fixed Prompt (Required)
+[Aspect Ratio: {aspect_ratio}]
+[Foreground: all uploaded product images, preserve their original proportions and clarity]
+[Preserve originals: keep the same random seed; maintain exact shape and aspect ratio; no vertical or horizontal scaling; do not alter any existing logos or text]
+[Product sizing: ensure product images maintain at least 50% of their height relative to the background]
+[Composition: products must be naturally composited with the background, maintain proper shadows aligned with lighting]
+[Product placement: if products already exist in the background prompt, follow their exact arrangement and positioning]
+"""
+    
+    # 배경 프롬프트 선택
+    if background_type == "심플 배경":
+        background_prompt = SIMPLE_BACKGROUNDS.get(background_name, "")
+    elif background_type == "스튜디오 배경":
+        background_prompt = STUDIO_BACKGROUNDS.get(background_name, "")
+    elif background_type == "자연 환경":
+        background_prompt = NATURE_BACKGROUNDS.get(background_name, "")
+    elif background_type == "실내 환경":
+        background_prompt = INDOOR_BACKGROUNDS.get(background_name, "")
+    elif background_type == "특수배경":
+        background_prompt = SPECIAL_BACKGROUNDS.get(background_name, "")
+    elif background_type == "주얼리":
+        background_prompt = JEWELRY_BACKGROUNDS.get(background_name, "")
+    elif background_type == "특수효과":
+        background_prompt = SPECIAL_EFFECTS_BACKGROUNDS.get(background_name, "")
+    else:
+        background_prompt = "clean white background with soft even lighting"
+    
+    # 사용자 요청사항 처리
+    if user_request and user_request.strip():
+        # 한국어 요청사항을 영어로 번역
+        translated_request = translate_to_english(user_request)
+        
+        # 번역된 요청사항을 배경 프롬프트에 통합
+        integrated_background = f"{background_prompt} Additionally, incorporate the following elements naturally into the scene: {translated_request}. Ensure these elements blend harmoniously with the existing background while maintaining the overall aesthetic and lighting."
+        
+        # 요청 프롬프트 섹션 (번역된 내용 사용)
+        request_prompt = f"""
+## Request Prompt
+{translated_request}
+"""
+        
+        # 배경 프롬프트 섹션
+        background_section = f"""
+## Background Prompt (Background Settings)
+{integrated_background}
+"""
+    else:
+        # 요청사항이 없는 경우
+        request_prompt = f"""
+## Request Prompt
+No specific request
+"""
+        
+        # 요청사항이 없는 경우 기본 배경만 사용
+        background_section = f"""
+## Background Prompt (Background Settings)
+{background_prompt}
+"""
+    
+    # 최종 프롬프트 조합
+    final_prompt = fixed_prompt + request_prompt + background_section
+    
+    return final_prompt
+
+# 이미지 편집 및 화질 개선 함수
+def edit_and_enhance_image(
+    prompt, 
+    image,
+    quality_level="gpt",
+    aspect_ratio="1:1",
+    output_format="jpg",
+    enable_enhancement=True,
+    enhancement_level=2
+):
+    try:
+        logger.info(f"Editing image with prompt: '{prompt[:50]}...' (truncated)")
+        logger.info(f"Parameters: quality_level={quality_level}, aspect_ratio={aspect_ratio}, output_format={output_format}")
+        logger.info(f"Enhancement requested: {enable_enhancement}, level: {enhancement_level}")
+        
+        if image is None:
+            logger.error("No image provided")
+            return None, None, None, "이미지를 업로드해야 합니다."
+        
+        # 이미지 처리
+        processed_image = None
+        temp_paths = []  # 나중에 정리할 경로 추적
+        
+        img_path = save_uploaded_file(image)
+        if img_path:
+            logger.info(f"Saved image to temp path: {img_path}")
+            processed_image = open(img_path, "rb")
+            temp_paths.append(img_path)
+        else:
+            logger.error("Failed to save image")
+            return None, None, None, "이미지 처리에 실패했습니다. 다른 이미지를 업로드해 보세요."
+        
+        # 모델 선택에 따른 처리
+        edited_images = []
+        usage_info = ""
+        error_msg = None
+        
+        try:
+            if quality_level == "gpt":
+                # GPT 모델 사용
+                if not openai_client.api_key:
+                    logger.error("OpenAI API key is not set")
+                    return None, None, None, "OpenAI API 키가 설정되지 않았습니다. API 키를 설정해주세요."
+                
+                # 종횡비를 크기로 변환
+                size_mapping = {
+                    "1:1": "1024x1024",
+                    "3:2": "1536x1024", 
+                    "2:3": "1024x1536"
+                }
+                size = size_mapping.get(aspect_ratio, "1024x1024")
+                
+                params = {
+                    "prompt": prompt,
+                    "model": IMAGE_EDIT_MODEL_GPT,
+                    "n": 1,
+                    "size": size,
+                    "image": processed_image
+                }
+                
+                logger.info(f"Calling OpenAI API for image editing with model: {IMAGE_EDIT_MODEL_GPT}")
+                response = openai_client.images.edit(**params)
+                logger.info("OpenAI API call successful")
+                
+                # 결과 처리
+                for i, data in enumerate(response.data):
+                    logger.info(f"Processing result image {i+1}/{len(response.data)}")
+                    
+                    if hasattr(data, 'b64_json') and data.b64_json:
+                        image_data = base64.b64decode(data.b64_json)
+                        image = Image.open(io.BytesIO(image_data))
+                    elif hasattr(data, 'url') and data.url:
+                        response_url = requests.get(data.url)
+                        image = Image.open(io.BytesIO(response_url.content))
+                    else:
+                        logger.warning(f"No image data found in response item {i+1}")
+                        continue
+                    
+                    # 이미지 형식 변환
+                    if output_format.lower() != "png" and image.mode == "RGBA":
+                        background = Image.new("RGB", image.size, (255, 255, 255))
+                        background.paste(image, mask=image.split()[3])
+                        image = background
+                    
+                    edited_images.append(image)
+                
+                usage_info = f"이미지 편집 완료 ({IMAGE_EDIT_MODEL_GPT} 모델 사용)"
+                
+            else:  # quality_level == "flux"
+                # Flux 모델 사용 (항상 기본 화질개선 1회 적용)
+                if not os.environ.get("REPLICATE_API_TOKEN"):
+                    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}")
+                
+                # Flux 모델로 이미지 생성
+                output = replicate.run(
+                    IMAGE_EDIT_MODEL_FLUX,
+                    input={
+                        "prompt": prompt,
+                        "input_image": processed_image,
+                        "output_format": output_format.lower(),
+                        "aspect_ratio": aspect_ratio,
+                        "safety_tolerance": 2
+                    }
+                )
+                
+                logger.info(f"Flux API response received")
+                
+                # Flux API 응답 처리
+                flux_image = None
+                if output:
+                    # output이 바이트 스트림인 경우
+                    if hasattr(output, 'read'):
+                        image_data = output.read()
+                        flux_image = Image.open(io.BytesIO(image_data))
+                    # output이 URL인 경우  
+                    elif isinstance(output, str) and output.startswith('http'):
+                        response_url = requests.get(output)
+                        flux_image = Image.open(io.BytesIO(response_url.content))
+                    # output이 바이너리 데이터인 경우
+                    else:
+                        flux_image = Image.open(io.BytesIO(output))
+                    
+                    # 이미지 형식 변환
+                    if output_format.lower() != "png" and flux_image.mode == "RGBA":
+                        background = Image.new("RGB", flux_image.size, (255, 255, 255))
+                        background.paste(flux_image, mask=flux_image.split()[3])
+                        flux_image = background
+                    
+                    # Flux 모델은 항상 첫 번째 화질 개선을 자동 적용
+                    try:
+                        logger.info(f"Applying automatic first enhancement for Flux model using: {ENHANCEMENT_MODEL}")
+                        
+                        # 임시 파일로 저장
+                        temp_flux_path = tempfile.mktemp(suffix='.png')
+                        flux_image.save(temp_flux_path)
+                        temp_paths.append(temp_flux_path)
+                        
+                        # 첫 번째 화질 향상 (Flux 모델 기본 적용)
+                        first_enhanced_output = replicate.run(
+                            ENHANCEMENT_MODEL,
+                            input={
+                                "image": open(temp_flux_path, "rb"),
+                                "scale_factor": 2,
+                                "resemblance": 0.8,
+                                "creativity": 0.2,
+                                "output_format": output_format.lower(),
+                                "prompt": prompt,
+                                "negative_prompt": "(worst quality, low quality, normal quality:2)"
+                            }
+                        )
+                        
+                        if first_enhanced_output and isinstance(first_enhanced_output, list) and len(first_enhanced_output) > 0:
+                            first_enhanced_url = first_enhanced_output[0]
+                            first_enhanced_response = requests.get(first_enhanced_url)
+                            
+                            if first_enhanced_response.status_code == 200:
+                                first_enhanced_image = Image.open(io.BytesIO(first_enhanced_response.content))
+                                
+                                # 이미지 형식 변환
+                                if output_format.lower() != "png" and first_enhanced_image.mode == "RGBA":
+                                    background = Image.new("RGB", first_enhanced_image.size, (255, 255, 255))
+                                    background.paste(first_enhanced_image, mask=first_enhanced_image.split()[3])
+                                    first_enhanced_image = background
+                                
+                                edited_images.append(first_enhanced_image)
+                                usage_info = f"이미지 편집 완료 ({IMAGE_EDIT_MODEL_FLUX} + 기본 화질개선 적용)"
+                                logger.info("First enhancement completed for Flux model")
+                            else:
+                                # 첫 번째 화질개선 실패 시 원본 사용
+                                edited_images.append(flux_image)
+                                usage_info = f"이미지 편집 완료 ({IMAGE_EDIT_MODEL_FLUX} 사용, 기본 화질개선 실패)"
+                        else:
+                            # 첫 번째 화질개선 실패 시 원본 사용
+                            edited_images.append(flux_image)
+                            usage_info = f"이미지 편집 완료 ({IMAGE_EDIT_MODEL_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)})"
+                        
+                else:
+                    logger.error("No output from Flux API")
+                    error_msg = "Flux API에서 응답을 받지 못했습니다."
+        
+        except Exception as e:
+            if quality_level == "gpt":
+                logger.error(f"OpenAI API call error: {e}")
+                error_msg = f"OpenAI API 호출 오류: {str(e)}"
+            else:
+                logger.error(f"Flux API call error: {e}")
+                error_msg = f"Flux API 호출 오류: {str(e)}"
+        
+        finally:
+            # 임시 파일 정리
+            if processed_image and hasattr(processed_image, 'close'):
+                processed_image.close()
+        
+        # 화질 향상 처리 (GPT 모델은 일반적인 화질개선, Flux 모델은 2차 화질개선)
+        enhanced_image = None
+        temp_image_path = None
+        
+        if enable_enhancement and edited_images and not error_msg:
+            try:
+                if quality_level == "gpt":
+                    # GPT 모델: 일반적인 화질 개선
+                    logger.info(f"Enhancing GPT image with {ENHANCEMENT_MODEL}, 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}")
+                    enhancement_info = "2차 화질 개선"
+                
+                if not os.environ.get("REPLICATE_API_TOKEN"):
+                    logger.error("Replicate API token is not set")
+                    usage_info += f" | {enhancement_info} 실패: Replicate API 토큰이 설정되지 않았습니다."
+                else:
+                    # 임시 파일로 저장
+                    temp_image_path = tempfile.mktemp(suffix='.png')
+                    edited_images[0].save(temp_image_path)
+                    temp_paths.append(temp_image_path)
+                    
+                    # Replicate API로 화질 향상
+                    output = replicate.run(
+                        ENHANCEMENT_MODEL,
+                        input={
+                            "image": open(temp_image_path, "rb"),
+                            "scale_factor": enhancement_level,
+                            "resemblance": 0.8,
+                            "creativity": 0.2,
+                            "output_format": output_format.lower(),
+                            "prompt": prompt,
+                            "negative_prompt": "(worst quality, low quality, normal quality:2)"
+                        }
+                    )
+                    
+                    logger.info(f"Enhancement API response: {output}")
+                    
+                    if output and isinstance(output, list) and len(output) > 0:
+                        enhanced_url = output[0]
+                        enhanced_response = requests.get(enhanced_url)
+                        if enhanced_response.status_code == 200:
+                            enhanced_image = Image.open(io.BytesIO(enhanced_response.content))
+                            
+                            if output_format.lower() != "png" and enhanced_image.mode == "RGBA":
+                                background = Image.new("RGB", enhanced_image.size, (255, 255, 255))
+                                background.paste(enhanced_image, mask=enhanced_image.split()[3])
+                                enhanced_image = background
+                            
+                            if quality_level == "gpt":
+                                usage_info += f" | {enhancement_info} 완료: {ENHANCEMENT_MODEL} 사용"
+                            else:
+                                usage_info += f" | {enhancement_info} 완료: 총 2회 화질개선 적용"
+                        else:
+                            usage_info += f" | {enhancement_info} 실패: 이미지 다운로드 오류"
+                    else:
+                        usage_info += f" | {enhancement_info} 실패: Enhancement API 응답 없음"
+                
+            except Exception as e:
+                logger.error(f"Error enhancing image: {e}")
+                if quality_level == "gpt":
+                    usage_info += f" | 화질 개선 실패: {str(e)}"
+                else:
+                    usage_info += f" | 2차 화질 개선 실패: {str(e)}"
+        
+        # 임시 파일 정리
+        for path in temp_paths:
+            if os.path.exists(path):
+                try:
+                    os.remove(path)
+                    logger.info(f"Removed temp file: {path}")
+                except Exception as e:
+                    logger.error(f"Error removing temp file {path}: {e}")
+        
+        # 결과 반환
+        if error_msg:
+            return None, None, None, error_msg
+        elif edited_images:
+            if enable_enhancement and enhanced_image:
+                return edited_images, [enhanced_image], usage_info, None
+            else:
+                return edited_images, None, usage_info, None
+        else:
+            return None, None, None, "이미지 편집에 실패했습니다."
+            
+    except Exception as e:
+        logger.error(f"Error in edit_and_enhance_image function: {e}")
+        logger.error(traceback.format_exc())
+        return None, None, None, f"에러 발생: {str(e)}\n\n{traceback.format_exc()}"
+
+# Gradio 인터페이스 구성
 def create_gradio_interface():
     try:
         logger.info("Creating Gradio interface")
@@ -310,29 +615,22 @@ def create_gradio_interface():
                                 interactive=True
                             )
                             
-                            # 드롭다운 변경 함수 (원본과 동일, API 엔드포인트 생성)
+                            # 드롭다운 변경 함수
                             def update_dropdowns(bg_type):
-                                try:
-                                    # API 호출
-                                    result = api_client.predict(bg_type=bg_type, api_name="/update_dropdowns")
-                                    return result
-                                except:
-                                    # 백업용 로컬 로직
-                                    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"
+                                outputs=[simple_dropdown, studio_dropdown, nature_dropdown, indoor_dropdown, special_dropdown, jewelry_dropdown, special_effects_dropdown]
                             )
                     
                     # 요청사항 입력
@@ -347,7 +645,7 @@ def create_gradio_interface():
                         label="품질 레벨", 
                         choices=["gpt", "flux"],
                         value="flux",
-                        info="GPT: GPT 모델 (고품질), 일반: Flux 모델 (빠른 처리 + 기본 화질개선)"
+                        info="GPT: GPT 모델 (고품질), Flux: Flux 모델 (빠른 처리 + 기본 화질개선)"
                     )
                     
                     aspect_ratio = gr.Dropdown(
@@ -393,190 +691,118 @@ 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):
-                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)}"
+                # 비밀번호 확인
+                if password != "1089":
+                    return "비밀번호가 틀렸습니다. 올바른 비밀번호를 입력해주세요."
+                
+                # 배경 선택
+                background_name = ""
+                if bg_type == "심플 배경":
+                    background_name = simple
+                elif bg_type == "스튜디오 배경":
+                    background_name = studio
+                elif bg_type == "자연 환경":
+                    background_name = nature
+                elif bg_type == "실내 환경":
+                    background_name = indoor
+                elif bg_type == "특수배경":
+                    background_name = special
+                elif bg_type == "주얼리":
+                    background_name = jewelry
+                elif bg_type == "특수효과":
+                    background_name = special_effects
+                
+                # 프롬프트 생성 (종횡비 포함)
+                prompt = generate_prompt(bg_type, background_name, request_text, aspect_ratio)
+                return prompt
             
-            # 비밀번호 확인 함수 (원본과 동일한 엔드포인트, API 호출)
+            # 비밀번호 확인 함수
             def check_password(password, *args):
-                try:
-                    image, bg_type, simple, studio, nature, indoor, special, jewelry, special_effects, request_text, quality_level, aspect_ratio, output_format, enable_enhancement = args
-                    
-                    if image is None:
-                        return ([], None, [], None, "", "", "이미지를 업로드해야 합니다.")
+                if password != "1089":
+                    return (
+                        [],  # original_output
+                        None,  # original_download
+                        [],  # enhanced_output
+                        None,  # enhanced_download
+                        "",  # prompt_output
+                        "",  # info
+                        "비밀번호가 틀렸습니다. 올바른 비밀번호를 입력해주세요."  # error
+                    )
+                
+                # 이미지 편집 요청 처리
+                image, bg_type, simple, studio, nature, indoor, special, jewelry, special_effects, request_text, quality_level, aspect_ratio, output_format, enable_enhancement = args
+                
+                # 배경 선택
+                background_name = ""
+                if bg_type == "심플 배경":
+                    background_name = simple
+                elif bg_type == "스튜디오 배경":
+                    background_name = studio
+                elif bg_type == "자연 환경":
+                    background_name = nature
+                elif bg_type == "실내 환경":
+                    background_name = indoor
+                elif bg_type == "특수배경":
+                    background_name = special
+                elif bg_type == "주얼리":
+                    background_name = jewelry
+                elif bg_type == "특수효과":
+                    background_name = special_effects
+                
+                # 프롬프트 생성
+                prompt = generate_prompt(bg_type, background_name, request_text, aspect_ratio)
+                
+                # 이미지 편집 및 화질 개선 실행
+                original_images, enhanced_images, usage_info, error_msg = edit_and_enhance_image(
+                    prompt, image, quality_level, aspect_ratio, output_format, enable_enhancement, 2
+                )
+                
+                # 이미지 저장 및 다운로드 파일 준비
+                original_path = None
+                enhanced_path = None
+                
+                if error_msg:
+                    logger.error(f"Error returned from edit_and_enhance_image: {error_msg}")
+                    return (
+                        [],  # original_output
+                        None,  # original_download
+                        [],  # enhanced_output
+                        None,  # enhanced_download
+                        prompt,  # prompt_output
+                        "",  # info
+                        error_msg  # error
+                    )
+                else:
+                    # 원본 편집 이미지 저장
+                    if original_images and len(original_images) > 0:
+                        try:
+                            original_path = f"original_image.{output_format}"
+                            original_images[0].save(original_path)
+                            logger.info(f"Saved original image to {original_path}")
+                        except Exception as e:
+                            logger.error(f"Error saving original image: {e}")
                     
-                    # 이미지를 임시 파일로 저장
-                    temp_path = save_uploaded_file(image)
-                    if temp_path is None:
-                        return ([], None, [], None, "", "", "이미지 처리에 실패했습니다.")
+                    # 화질 개선 이미지 저장
+                    if enhanced_images and len(enhanced_images) > 0:
+                        try:
+                            enhanced_path = f"enhanced_image.{output_format}"
+                            enhanced_images[0].save(enhanced_path)
+                            logger.info(f"Saved enhanced image to {enhanced_path}")
+                        except Exception as e:
+                            logger.error(f"Error saving enhanced image: {e}")
                     
-                    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"
-                        )
-                        
-                        # API 응답 처리 - 딕셔너리를 원본처럼 PIL Image로 변환
-                        if result and len(result) >= 7:
-                            original_output, original_download, enhanced_output, enhanced_download, prompt_output, info, error = result
-                            
-                            # 디버깅: API 응답 구조 로깅
-                            logger.info(f"Original output type: {type(original_output)}")
-                            logger.info(f"Enhanced output type: {type(enhanced_output)}")
-                            if original_output:
-                                logger.info(f"Original output first item: {type(original_output[0]) if original_output else 'Empty'}")
-                                if original_output and isinstance(original_output[0], dict):
-                                    logger.info(f"Original output keys: {list(original_output[0].keys())}")
-                            
-                            # Gallery 데이터를 PIL Image 리스트로 변환
-                            def convert_gallery_to_images(gallery_data):
-                                if not gallery_data:
-                                    return []
-                                
-                                images = []
-                                logger.info(f"Converting gallery data, length: {len(gallery_data)}")
-                                
-                                for i, item in enumerate(gallery_data):
-                                    try:
-                                        logger.info(f"Processing gallery item {i}: {type(item)}")
-                                        
-                                        img_url = None
-                                        if isinstance(item, dict):
-                                            # 여러 가지 가능한 구조 시도
-                                            if 'image' in item:
-                                                if isinstance(item['image'], dict):
-                                                    img_url = item['image'].get('url') or item['image'].get('path')
-                                                else:
-                                                    img_url = item['image']
-                                            elif 'url' in item:
-                                                img_url = item['url']
-                                            elif 'path' in item:
-                                                img_url = item['path']
-                                            
-                                            logger.info(f"Extracted URL from dict: {img_url}")
-                                        elif isinstance(item, str):
-                                            # 직접 URL인 경우
-                                            img_url = item
-                                            logger.info(f"Direct URL: {img_url}")
-                                        
-                                        if img_url:
-                                            # URL이 상대 경로인 경우 절대 경로로 변환
-                                            if img_url.startswith('/'):
-                                                img_url = f"https://happydoggg-49493h.hf.space/gradio_api/file={img_url}"
-                                            elif not img_url.startswith('http'):
-                                                img_url = f"https://happydoggg-49493h.hf.space/gradio_api/file={img_url}"
-                                            
-                                            logger.info(f"Final URL: {img_url}")
-                                            
-                                            # URL에서 이미지 다운로드하여 PIL Image로 변환
-                                            response = requests.get(img_url)
-                                            if response.status_code == 200:
-                                                pil_image = Image.open(io.BytesIO(response.content))
-                                                images.append(pil_image)
-                                                logger.info(f"Successfully converted image {i}")
-                                            else:
-                                                logger.warning(f"Failed to download image from {img_url}, status: {response.status_code}")
-                                        else:
-                                            logger.warning(f"No URL found in item {i}: {item}")
-                                            
-                                    except Exception as e:
-                                        logger.error(f"Failed to convert gallery item {i}: {e}")
-                                        logger.error(f"Item content: {item}")
-                                        continue
-                                
-                                logger.info(f"Converted {len(images)} images from gallery data")
-                                return images
-                            
-                            # Gallery 데이터 변환
-                            converted_original = convert_gallery_to_images(original_output)
-                            converted_enhanced = convert_gallery_to_images(enhanced_output)
-                            
-                            # 변환된 이미지가 없는 경우, 원본 데이터를 그대로 반환 시도
-                            if not converted_original and original_output:
-                                logger.info("No converted original images, trying to use original data directly")
-                                converted_original = original_output
-                            
-                            if not converted_enhanced and enhanced_output:
-                                logger.info("No converted enhanced images, trying to use enhanced data directly")
-                                converted_enhanced = enhanced_output
-                            
-                            # 다운로드 파일 처리 - 원본 그대로 전달
-                            original_file = None
-                            enhanced_file = None
-                            
-                            # 원본 이미지 파일 생성
-                            if converted_original:
-                                try:
-                                    original_file_path = f"original_image.{output_format}"
-                                    converted_original[0].save(original_file_path, format=output_format.upper())
-                                    original_file = original_file_path
-                                except Exception as e:
-                                    logger.error(f"Error saving original image: {e}")
-                            
-                            # 개선된 이미지 파일 생성
-                            if converted_enhanced:
-                                try:
-                                    enhanced_file_path = f"enhanced_image.{output_format}"
-                                    converted_enhanced[0].save(enhanced_file_path, format=output_format.upper())
-                                    enhanced_file = enhanced_file_path
-                                except Exception as e:
-                                    logger.error(f"Error saving enhanced image: {e}")
-                            
-                            return (
-                                converted_original,  # PIL Image 리스트
-                                original_file,       # 다운로드 파일 경로
-                                converted_enhanced,  # PIL Image 리스트
-                                enhanced_file,       # 다운로드 파일 경로
-                                prompt_output,       # 프롬프트 텍스트
-                                info,               # 처리 정보
-                                error               # 오류 메시지
-                            )
-                        else:
-                            return ([], None, [], None, "", "", "API 응답이 올바르지 않습니다.")
-                            
-                    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: {e}")
-                    logger.error(f"Full traceback: {traceback.format_exc()}")
-                    return ([], None, [], None, "", "", f"오류 발생: {str(e)}")
+                    # 결과 반환
+                    return (
+                        original_images if original_images else [],  # original_output
+                        original_path,  # original_download
+                        enhanced_images if enhanced_images else [],  # enhanced_output
+                        enhanced_path,  # enhanced_download
+                        prompt,  # prompt_output
+                        usage_info,  # info
+                        ""  # error (빈 문자열로 설정)
+                    )
             
             # 프롬프트 생성 버튼 클릭 이벤트
             generate_prompt_btn.click(
@@ -588,8 +814,7 @@ def create_gradio_interface():
                     jewelry_dropdown, special_effects_dropdown,
                     request_text, aspect_ratio
                 ],
-                outputs=[prompt_output],
-                api_name="generate_prompt_with_password_check"
+                outputs=[prompt_output]
             )
             
             # 편집 버튼 클릭 이벤트
@@ -606,8 +831,7 @@ def create_gradio_interface():
                     original_output, original_download, 
                     enhanced_output, enhanced_download,
                     prompt_output, info, error
-                ],
-                api_name="check_password"
+                ]
             )
         
         logger.info("Gradio interface created successfully")