app.py

import gradio as gr
import cv2
import numpy as np
import pandas as pd
import json
import os
import threading
import gc
from datetime import datetime
try:
    from pyngrok import ngrok
    NGROK_AVAILABLE = True
except ImportError:
    NGROK_AVAILABLE = False
try:
    from skimage.metrics import structural_similarity as ssim
    from skimage.metrics import peak_signal_noise_ratio as psnr
except ImportError:
    # scikit-image가 없는 경우 대체 방법 사용
    def ssim(img1, img2):
        # 간단한 MSE 기반 유사도 계산
        mse = np.mean((img1 - img2) ** 2)
        return 1 / (1 + mse / 1000)
    
    def psnr(img1, img2):
        mse = np.mean((img1 - img2) ** 2)
        if mse == 0:
            return 100
        return 20 * np.log10(255.0 / np.sqrt(mse))
import io
from PIL import Image
import torch
import torchvision.models as models
import torchvision.transforms as transforms
import ssl

# Fix SSL error for model download (macOS specific)
ssl._create_default_https_context = ssl._create_unverified_context

# ========== 여기만 수정하면 탭이 동적으로 반영됩니다 ==========
# 예시: ["Response반", "Challenge반"]  → 연습 탭 + 2개 반 = 총 3개 탭
# 예시: ["206호", "207호", "305호"]    → 연습 탭 + 3개 반 = 총 4개 탭
# CLASSES = ["Respect반", "Challenge반", "Originality반", "BCE반"]
CLASSES = ["Respect반", "Challenge반", "Originality반", "BCE반"]
# ============================================================

# 탭 아이콘 자동 배정
_TAB_ICONS = ["🎯", "⚡", "🎨", "🔥", "💎", "🌟", "🚀", "💡", "🏅", "✨"]

def _class_key(name):
    """반 이름을 json 파일명/딕셔너리 키로 변환 (예: 'Respect반' → 'respect')"""
    # 한글 '반' 제거, 공백→언더스코어, 소문자
    return name.replace("반", "").replace("호", "").strip().lower().replace(" ", "_")


class ImageSimilarityLeaderboard:
    def __init__(self, reference_image_path="label2.jpg", data_file="leaderboard.json"):
        self.reference_image_path = reference_image_path
        self.data_file = data_file
        self.admin_password = "9900"  # 관리자 비밀번호
        self.admin_authenticated = False  # 관리자 인증 상태
        
        # 메모리 최적화를 위한 캐시 및 락 (먼저 초기화)
        self._ref_image_cache = None
        self._ref_embedding = None # ResNet 임베딩 캐시
        self._cache_loaded = False
        self._file_lock = threading.Lock()  # 파일 I/O 동시성 제어
        self._processing_lock = threading.Lock()  # 처리 동시성 제어
        
        # 락 초기화 후 데이터 로드
        self.leaderboard_data = self.load_leaderboard()
        self.last_modified = self.get_file_modified_time()
        
        # ResNet 모델 초기화 (한 번만 로드)
        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
        try:
            # ResNet50 (ImageNet weights) - 마지막 FC 레이어 제외
            resnet = models.resnet50(weights=models.ResNet50_Weights.IMAGENET1K_V1)
            self.resnet_model = torch.nn.Sequential(*(list(resnet.children())[:-1])).to(self.device)
            self.resnet_model.eval()
            
            # 전처리 파이프라인
            self.preprocess = transforms.Compose([
                transforms.Resize(256),
                transforms.CenterCrop(224),
                transforms.ToTensor(),
                transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
            ])
            print(f"✅ ResNet 모델 로드 완료 (Device: {self.device})")
        except Exception as e:
            print(f"⚠️ ResNet 모델 로드 실패: {e}")
            self.resnet_model = None

        # macOS 호환성을 위한 경고 억제
        import warnings
        warnings.filterwarnings("ignore", category=UserWarning, module="cv2")
        
    def load_leaderboard(self):
        """리더보드 데이터를 로드합니다."""
        with self._file_lock:  # 파일 I/O 동시성 제어
            if os.path.exists(self.data_file):
                try:
                    with open(self.data_file, 'r', encoding='utf-8') as f:
                        return json.load(f)
                except:
                    return []
            return []
    
    def get_file_modified_time(self):
        """파일 수정 시간을 반환합니다."""
        if os.path.exists(self.data_file):
            return os.path.getmtime(self.data_file)
        return 0
    
    def save_leaderboard(self):
        """리더보드 데이터를 저장합니다."""
        with self._file_lock:  # 파일 I/O 동시성 제어
            with open(self.data_file, 'w', encoding='utf-8') as f:
                json.dump(self.leaderboard_data, f, ensure_ascii=False, indent=2)
            self.last_modified = self.get_file_modified_time()
    
    def check_for_updates(self):
        """리더보드 업데이트 확인"""
        current_modified = self.get_file_modified_time()
        if current_modified > self.last_modified:
            self.leaderboard_data = self.load_leaderboard()
            self.last_modified = current_modified
            return True
        return False
    
    def _load_reference_image(self):
        """참조 이미지를 한 번만 로드하고 캐시합니다."""
        if not self._cache_loaded:
            if os.path.exists(self.reference_image_path):
                ref_image = cv2.imread(self.reference_image_path)
                if ref_image is not None:
                    # macOS 메모리 최적화
                    if ref_image.shape[0] > 1024 or ref_image.shape[1] > 1024:
                        # 큰 이미지는 미리 리사이즈하여 메모리 사용량 감소
                        scale = min(1024 / ref_image.shape[0], 1024 / ref_image.shape[1])
                        if scale < 1:
                            new_width = int(ref_image.shape[1] * scale)
                            new_height = int(ref_image.shape[0] * scale)
                            ref_image = cv2.resize(ref_image, (new_width, new_height))

                    self._ref_image_cache = cv2.cvtColor(ref_image, cv2.COLOR_BGR2RGB)
                    
                    # ResNet 임베딩 계산 및 캐시
                    if self.resnet_model is not None:
                        try:
                            pil_img = Image.fromarray(self._ref_image_cache)
                            img_t = self.preprocess(pil_img).unsqueeze(0).to(self.device)
                            with torch.no_grad():
                                self._ref_embedding = self.resnet_model(img_t).flatten()
                        except Exception as e:
                            print(f"참조 이미지 임베딩 실패: {e}")

                    self._cache_loaded = True
                    # 메모리 정리
                    del ref_image
                    gc.collect()
        return self._ref_image_cache
    
    def _get_memory_usage(self):
        """현재 메모리 사용량을 반환합니다."""
        try:
            import psutil
            process = psutil.Process()
            memory_info = process.memory_info()
            return memory_info.rss / 1024 / 1024  # MB 단위
        except (ImportError, AttributeError):
            # macOS나 다른 환경에서 psutil이 없거나 동작하지 않는 경우
            try:
                import resource
                # getrusage를 통한 메모리 사용량 측정
                usage = resource.getrusage(resource.RUSAGE_SELF)
                return usage.ru_maxrss / 1024  # KB -> MB
            except:
                return 0
    
    def calculate_similarity(self, image1, image2):
        try:
            # 1) ResNet Feature Similarity (Semantic Similarity) - 가장 중요
            resnet_score = 0.0
            if self.resnet_model is not None and self._ref_embedding is not None:
                try:
                    # 사용자 이미지 전처리
                    pil_img = Image.fromarray(image2) # image2 is RGB numpy array
                    img_t = self.preprocess(pil_img).unsqueeze(0).to(self.device)
                    
                    with torch.no_grad():
                        user_emb = self.resnet_model(img_t).flatten()
                        
                    # Cosine Similarity
                    cos_sim = torch.nn.functional.cosine_similarity(
                        self._ref_embedding.unsqueeze(0), 
                        user_emb.unsqueeze(0)
                    ).item()
                    
                    # Sigmoid Scoring Formula
                    # Sim 0.61 (Bad) -> Score 14
                    # Sim 0.77 (Good) -> Score 80
                    # Sim 0.92 (Perfect) -> Score 99
                    # Formula: 100 / (1 + exp(-20 * (sim - 0.7)))
                    resnet_score = 100 / (1 + np.exp(-20 * (cos_sim - 0.7)))
                    
                except Exception as e:
                    print(f"ResNet 계산 오류: {e}")
                    resnet_score = 0.0

            # 2) 그레이스케일 변환 (기존 로직 유지)
            if image1.ndim == 3:
                gray1 = cv2.cvtColor(image1, cv2.COLOR_RGB2GRAY)
            else:
                gray1 = image1.copy()

            if image2.ndim == 3:
                gray2 = cv2.cvtColor(image2, cv2.COLOR_RGB2GRAY)
            else:
                gray2 = image2.copy()

            # 3) 각 이미지를 독립적으로 표준 크기로 리사이즈 (512x512)
            target_size = (512, 512)

            gray1 = cv2.resize(gray1, target_size, interpolation=cv2.INTER_LINEAR)
            gray2 = cv2.resize(gray2, target_size, interpolation=cv2.INTER_LINEAR)

            # 4) SSIM 계산 (구조적 유사도)
            try:
                ssim_score = ssim(gray1.astype(np.float32), gray2.astype(np.float32))
            except:
                # SSIM 계산 실패시 MSE 기반 대체
                mse = np.mean((gray1.astype(np.float32) - gray2.astype(np.float32)) ** 2)
                ssim_score = 1 / (1 + mse / 10000)

            # 5) PSNR 계산 (픽셀 단위 유사도)
            mse = np.mean((gray1.astype(np.float32) - gray2.astype(np.float32)) ** 2)
            if mse == 0:
                psnr_score = 1.0
            else:
                psnr_score = 20 * np.log10(255.0 / np.sqrt(mse))
                # PSNR을 0-1 범위로 더 관대하게 정규화 (보통 PSNR은 20-40 범위)
                psnr_score = min(psnr_score / 40.0, 1.0)

            # 6) 히스토그램 유사도
            hist1 = cv2.calcHist([gray1], [0], None, [256], [0, 256])
            hist2 = cv2.calcHist([gray2], [0], None, [256], [0, 256])
            hist_corr = cv2.compareHist(hist1, hist2, cv2.HISTCMP_CORREL)
            hist_score = (hist_corr + 1) / 2  # -1~1 → 0~1

            # 7) 최종 점수 계산 (ResNet 비중 대폭 강화)
            # ResNet 모델이 있으면 ResNet 80%, SSIM 10%, Hist 10%
            
            if self.resnet_model is not None:
                final_score = (resnet_score * 0.8) + (ssim_score * 100 * 0.1) + (hist_score * 100 * 0.1)
            else:
                print(f"ResNet 모델이 없어서 SSIM 70%, Hist 30%로 계산")
                final_score = (ssim_score * 0.7 + hist_score * 0.3) * 100

            # 8) PSNR이 높으면 약간의 보너스 (최대 5점)
            if psnr_score > 0.8:
                bonus = min((psnr_score - 0.8) * 25, 5)
                final_score = min(final_score + bonus, 100)

            return {
                'ssim': float(ssim_score),
                'psnr': float(psnr_score * 100),
                'histogram': float(hist_score),
                'resnet': float(resnet_score), # 결과에 포함
                'final_score': float(final_score)
            }
        except Exception as e:
            print(f"유사도 계산 오류: {e}")
            return {'ssim':0.0,'psnr':0.0,'histogram':0.0,'resnet':0.0,'final_score':0.0}
    
    def process_image(self, uploaded_image, username):
        """업로드된 이미지를 처리하고 점수를 계산합니다."""
        if uploaded_image is None:
            return "📤 이미지를 업로드해주세요.", self.get_leaderboard_df()
        
        # 사용자명 검증 제거 - 어떤 이름이든 허용
        if not username or not username.strip():
            return "❌ 사용자 이름을 입력해주세요.", self.get_leaderboard_df()
        
        username = username.strip()
        
        # 동시성 제어 - 한 번에 하나의 이미지만 처리
        with self._processing_lock:
            try:
                # 캐시된 참조 이미지 사용
                ref_image = self._load_reference_image()
                if ref_image is None:
                    return f"참조 이미지({self.reference_image_path})를 로드할 수 없습니다.", None
                
                # 업로드된 이미지를 numpy 배열로 변환
                if isinstance(uploaded_image, str):
                    # 파일 경로인 경우
                    user_image = cv2.imread(uploaded_image)
                    if user_image is None:
                        return "업로드된 이미지를 읽을 수 없습니다.", None
                    user_image = cv2.cvtColor(user_image, cv2.COLOR_BGR2RGB)
                else:
                    # PIL Image인 경우
                    user_image = np.array(uploaded_image)
                    if user_image is None or user_image.size == 0:
                        return "업로드된 이미지가 유효하지 않습니다.", None
                
                # 이미지 크기 확인
                if user_image.shape[0] < 10 or user_image.shape[1] < 10:
                    return "이미지가 너무 작습니다. 최소 10x10 픽셀 이상이어야 합니다.", None
                
                # 유사도 계산
                similarity_scores = self.calculate_similarity(ref_image, user_image)

                # 메모리 정리 (macOS 최적화)
                del user_image
                if 'ref_image' in locals():
                    del ref_image
                gc.collect()

                # macOS에서 메모리 강제 정리
                import platform
                if platform.system() == 'Darwin':  # macOS
                    import ctypes
                    try:
                        libc = ctypes.CDLL('libc.dylib')
                        libc.malloc_trim(0)
                    except:
                        pass
                
                # 리더보드에 추가 (JSON 직렬화를 위해 float로 변환)
                entry = {
                    'username': username,
                    'score': float(round(similarity_scores['final_score'], 2)),
                    'date': datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
                    'ssim': float(round(similarity_scores['ssim'], 4)),
                    'psnr': float(round(similarity_scores['psnr'], 2)),
                    'histogram': float(round(similarity_scores['histogram'], 4)),
                    'resnet': float(round(similarity_scores.get('resnet', 0.0), 2))
                }
                
                # 같은 이름의 기존 기록이 있는지 확인하고, 더 높은 점수만 유지
                existing_indices = [i for i, data in enumerate(self.leaderboard_data) if data['username'] == username]
                
                if existing_indices:
                    # 기존 기록 중 가장 높은 점수 찾기
                    existing_scores = [self.leaderboard_data[i]['score'] for i in existing_indices]
                    max_existing_score = max(existing_scores)
                    
                    # 새 점수가 더 높으면 기존 기록들을 모두 제거하고 새 기록 추가
                    if entry['score'] > max_existing_score:
                        # 기존 기록들을 역순으로 제거 (인덱스 변경 방지)
                        for i in sorted(existing_indices, reverse=True):
                            del self.leaderboard_data[i]
                        self.leaderboard_data.append(entry)
                        self.save_leaderboard()
                        
                        # 갱신된 경우의 메시지
                        result_message = f"""🎉 대단해요! 새로운 최고 기록입니다!

👤 {username}님
🏆 점수: {entry['score']:.0f}점
📈 이전 최고: {max_existing_score:.0f}점

✅ 리더보드에 등록되었습니다!
📅 {entry['date']}"""
                    else:
                        # 새 점수가 더 낮거나 같으면 리더보드는 업데이트하지 않음
                        result_message = f"""🎯 점수가 계산되었습니다!

👤 {username}님
🏆 현재 점수: {entry['score']:.0f}점
📈 최고 점수: {max_existing_score:.0f}점

💪 조금만 더 노력하면 최고 기록을 갱신할 수 있을 것 같아요!
다시 시도해보세요!"""
                else:
                    # 기존 기록이 없으면 새로 추가
                    self.leaderboard_data.append(entry)
                    self.save_leaderboard()
                    
                    # 새로 등록된 경우의 메시지
                    result_message = f"""🎉 첫 등록을 축하합니다!

👤 {username}님
🏆 점수: {entry['score']:.0f}점

✅ 리더보드에 등록되었습니다!
📅 {entry['date']}"""
                
                return result_message, self.get_leaderboard_df()
                
            except Exception as e:
                import traceback
                error_msg = f"오류가 발생했습니다: {str(e)}\n\n상세 정보:\n{traceback.format_exc()}"
                return error_msg, None
    
    def get_leaderboard_df(self):
        """리더보드를 DataFrame으로 반환합니다."""
        if not self.leaderboard_data:
            return pd.DataFrame(columns=['순위', '사용자명', '점수', '날짜'])
        
        # 점수 기준으로 정렬
        sorted_data = sorted(self.leaderboard_data, key=lambda x: x['score'], reverse=True)
        
        # DataFrame 생성
        df_data = []
        for i, entry in enumerate(sorted_data, 1):
            df_data.append({
                '순위': i,
                '사용자명': entry['username'],
                '점수': entry['score'],
                '날짜': entry['date']
            })
        
        return pd.DataFrame(df_data)
    
    def authenticate_admin(self, password):
        """관리자 인증"""
        if password == self.admin_password:
            self.admin_authenticated = True
            return "✅ 관리자 인증이 완료되었습니다.", True
        else:
            self.admin_authenticated = False
            return "❌ 잘못된 비밀번호입니다.", False
    
    def update_reference_image(self, new_image):
        """참조 이미지 업데이트"""
        if not self.admin_authenticated:
            return "❌ 관리자 인증이 필요합니다."
        
        try:
            if new_image is None:
                return "❌ 이미지를 업로드해주세요."
            
            # 이미지를 저장
            new_image.save(self.reference_image_path)
            return f"✅ 참조 이미지가 업데이트되었습니다. ({self.reference_image_path})"
        except Exception as e:
            return f"❌ 이미지 저장 중 오류가 발생했습니다: {str(e)}"
    
    def clear_leaderboard(self):
        """리더보드를 초기화합니다."""
        if not self.admin_authenticated:
            return "❌ 관리자 인증이 필요합니다.", self.get_leaderboard_df()
        
        self.leaderboard_data = []
        self.save_leaderboard()
        return "✅ 리더보드가 초기화되었습니다.", pd.DataFrame(columns=['순위', '사용자명', '점수', '날짜'])


# ── 전역 리더보드 인스턴스 (CLASSES 기반 동적 생성 + 연습) ──
leaderboards = {}
for _cls in CLASSES:
    leaderboards[_class_key(_cls)] = ImageSimilarityLeaderboard("label2.jpg", f"{_class_key(_cls)}.json")
leaderboards['practice'] = ImageSimilarityLeaderboard("label2.jpg", "practice.json")


# ── 범용 처리 함수 ──
def process_user_image(class_key, image, username):
    """이미지 처리 (모든 반 공용)"""
    return leaderboards[class_key].process_image(image, username)

def get_current_leaderboard(class_key):
    """현재 리더보드 반환 (모든 반 공용)"""
    return leaderboards[class_key].get_leaderboard_df()

def check_and_update_leaderboard(class_key):
    """리더보드 업데이트 확인 및 반환 (모든 반 공용)"""
    leaderboards[class_key].check_for_updates()
    return leaderboards[class_key].get_leaderboard_df()


def create_interface():
    """Gradio 인터페이스 생성 (CLASSES 기반 동적 탭)"""
    with gr.Blocks(title="비슷한 이미지를 만들어주세요!", theme=gr.themes.Soft()) as demo:
        gr.Markdown("""
        # 🏆 롯데 비전 스튜디오 리더보드
        """)
        
        # 모든 리더보드 출력 위젯을 모아둘 딕셔너리
        leaderboard_outputs = {}
        
        # 탭 생성
        with gr.Tabs():
            # ── 연습 탭 (항상 첫 번째) ──
            with gr.Tab("🎓 연습"):
                gr.Markdown("### 💡 연습용 탭 (메인)")
                gr.Markdown("업로드 및 이미지 유사도를 테스트해볼 수 있는 연습 공간입니다.")
                gr.Markdown("---")

                with gr.Row():
                    with gr.Column(scale=1):
                        gr.Markdown("### 📤 이미지 업로드 (연습)")
                        image_input_practice = gr.Image(
                            label="비교할 이미지를 업로드하세요",
                            type="pil",
                            height=300
                        )
                        username_input_practice = gr.Textbox(
                            label="사용자 이름 (연습용)",
                            placeholder="이름을 입력하세요",
                            max_lines=1
                        )
                        submit_btn_practice = gr.Button("🚀 유사도 테스트", variant="primary", size="lg")

                    with gr.Column(scale=1):
                        gr.Markdown("### 📊 테스트 결과")
                        result_output_practice = gr.Textbox(
                            label="유사도 분석 결과",
                            lines=12,
                            interactive=False
                        )

                        gr.Markdown("### 🏅 연습 리더보드")
                        leaderboard_output_practice = gr.Dataframe(
                            headers=["순위", "사용자명", "점수", "날짜"],
                            datatype=["number", "str", "number", "str"],
                            interactive=False
                        )

                leaderboard_outputs['practice'] = leaderboard_output_practice

                # 연습 탭 이벤트 핸들러
                submit_btn_practice.click(
                    fn=lambda img, name: process_user_image('practice', img, name),
                    inputs=[image_input_practice, username_input_practice],
                    outputs=[result_output_practice, leaderboard_output_practice]
                )

            # ── 반별 탭 (CLASSES 기반 동적 생성) ──
            for idx, class_name in enumerate(CLASSES):
                icon = _TAB_ICONS[idx % len(_TAB_ICONS)]
                key = _class_key(class_name)

                with gr.Tab(f"{icon} {class_name}"):
                    with gr.Row():
                        with gr.Column(scale=1):
                            gr.Markdown(f"### 📤 이미지 업로드 ({class_name})")
                            image_input = gr.Image(
                                label="비교할 이미지를 업로드하세요",
                                type="pil",
                                height=300
                            )
                            username_input = gr.Textbox(
                                label="사용자 이름",
                                placeholder="이름을 입력하세요",
                                max_lines=1
                            )
                            submit_btn = gr.Button("🚀 점수 계산 및 등록", variant="primary", size="lg")

                        with gr.Column(scale=1):
                            gr.Markdown(f"### 📊 결과 ({class_name})")
                            result_output = gr.Textbox(
                                label="계산 결과",
                                lines=10,
                                interactive=False
                            )

                            gr.Markdown(f"### 🏅 {class_name} 리더보드")
                            leaderboard_output = gr.Dataframe(
                                headers=["순위", "사용자명", "점수", "날짜"],
                                datatype=["number", "str", "number", "str"],
                                interactive=False
                            )

                    leaderboard_outputs[key] = leaderboard_output

                    # 클로저에서 key 값을 캡처하기 위해 default argument 사용
                    submit_btn.click(
                        fn=lambda img, name, k=key: process_user_image(k, img, name),
                        inputs=[image_input, username_input],
                        outputs=[result_output, leaderboard_output]
                    )

        # ── 모든 키 순서 (practice 먼저, 이후 CLASSES 순서) ──
        all_keys = ['practice'] + [_class_key(c) for c in CLASSES]
        all_outputs = [leaderboard_outputs[k] for k in all_keys]

        # 페이지 로드 시 모든 리더보드 표시
        demo.load(
            fn=lambda: tuple(get_current_leaderboard(k) for k in all_keys),
            outputs=all_outputs
        )

        # 실시간 업데이트 (10초마다 - 모든 탭 업데이트)
        timer = gr.Timer(value=10)
        timer.tick(
            fn=lambda: tuple(check_and_update_leaderboard(k) for k in all_keys),
            outputs=all_outputs
        )
    
    return demo

def main():
    """메인 함수"""
    print("🏆 이미지 유사도 리더보드 시스템을 시작합니다...")
    print("📁 참조 이미지: label2.jpg")
    print("💾 데이터 파일:")
    for cls in CLASSES:
        key = _class_key(cls)
        print(f"   • {cls}: {key}.json")
    print(f"   • 연습: practice.json")

    # 각 반별 메모리 사용량 체크
    for class_name, lb in leaderboards.items():
        initial_memory = lb._get_memory_usage()
        print(f"💾 {class_name} 초기 메모리 사용량: {initial_memory:.1f}MB")

    if not os.path.exists("label2.jpg"):
        print("⚠️  경고: 참조 이미지(label2.jpg)를 찾을 수 없습니다!")
        print("   label2.jpg 파일을 프로젝트 루트에 배치해주세요.")
    
    # Gradio 인터페이스 생성 및 실행
    demo = create_interface()
    print("🚀 서버를 시작합니다...")
    print("📊 최적화 사항:")
    print("   • 참조 이미지 캐싱 활성화")
    print("   • 이미지 크기 제한: 512x512")
    print("   • 동시성 제어 활성화")
    print("   • 메모리 정리 자동화")
    print("   • 실시간 업데이트: 10초 간격")
    print(f"   • {len(CLASSES)+1}개 탭별 독립 리더보드 운영 ({len(CLASSES)}개 반 + 연습)")
    
    # 외부 공유 우선 시도
    print("\n🌐 외부 접근 시도 중...")
    try:
        demo.launch(
            # server_name="0.0.0.0",
            # server_port=9900,
            # share=False,  # 로컬에서 share=True는 불필요한 경고를 유발하므로 False로 변경
            # show_error=False,
            # quiet=False,
            # ssr_mode=False  # SSR 모드 비활성화로 실험적 기능 경고 제거
        )
    except Exception as e:
        print(f"❌ 외부 공유 실패: {e}")
        print("🔄 로컬 네트워크 모드로 전환...")
        demo.launch(
            server_name="0.0.0.0",
            server_port=9900,
            share=False,  # 로컬 환경에서는 share=False로 유지
            show_error=True,
            quiet=False,
            ssr_mode=False  # SSR 모드 비활성화
        )

if __name__ == "__main__":
    main()