fix

app.py

@@ -3,20 +3,23 @@ import time
 import base64
 import json
 import traceback
-import threading
-import subprocess
-import sys
 from typing import Tuple, Optional
 import gradio as gr
 import anthropic
+from selenium import webdriver
+from selenium.webdriver.chrome.options import Options
+from selenium.webdriver.common.by import By
+from selenium.webdriver.support.ui import WebDriverWait
+from selenium.webdriver.support import expected_conditions as EC
+from selenium.common.exceptions import TimeoutException, NoSuchElementException
 from concurrent.futures import ThreadPoolExecutor
-from datetime import datetime
+import threading
 
 # Hugging Face Space 환경 확인
 IS_HUGGINGFACE = os.getenv("SPACE_ID") is not None
 print(f'IS_HUGGINGFACE = {IS_HUGGINGFACE}')
 
-# Claude API 설정
+# Claude API 설정 (Hugging Face Secrets에서 가져오기)
 ANTHROPIC_API_KEY = os.getenv("ANTHROPIC_API_KEY")
 
 if not ANTHROPIC_API_KEY:
@@ -24,6 +27,7 @@ if not ANTHROPIC_API_KEY:
 else:
     print("Claude API 키 확인 완료")
 
+# Claude 클라이언트를 생성
 def create_claude_client():
     try:
         client = anthropic.Anthropic(api_key=ANTHROPIC_API_KEY)
@@ -33,438 +37,439 @@ def create_claude_client():
         print(f"Claude API 클라이언트 생성 실패: {e}")
         return None
 
-def install_system_dependencies():
-    """시스템 의존성 설치 시도"""
-    try:
-        print("시스템 의존성 설치 시도 중...")
-        
-        # 필수 패키지 목록
-        packages = [
-            "libnss3",
-            "libnspr4", 
-            "libatk1.0-0",
-            "libatk-bridge2.0-0",
-            "libcups2",
-            "libatspi2.0-0",
-            "libxcomposite1",
-            "libxdamage1",
-            "libxrandr2",
-            "libgconf-2-4",
-            "libxss1",
-            "libgtk-3-0",
-            "libasound2"
-        ]
-        
-        # 패키지 설치 시도 (권한이 있는 경우)
-        if not IS_HUGGINGFACE:
-            try:
-                subprocess.run(["sudo", "apt-get", "update"], check=True, capture_output=True)
-                subprocess.run(["sudo", "apt-get", "install", "-y"] + packages, check=True, capture_output=True)
-                print("시스템 의존성 설치 완료")
-                return True
-            except subprocess.CalledProcessError as e:
-                print(f"시스템 패키지 설치 실패: {e}")
+# Google Trends 자동화 클래스
+class GoogleTrendsAutomator:
+    def __init__(self):
+        self.driver = None
+    
+    # Chrome 드라이버 설정
+    def setup_driver(self):
+        options = Options()
         
-        # Hugging Face Space에서는 다른 방법 시도
+        # Hugging Face Space 환경 설정
         if IS_HUGGINGFACE:
-            print("Hugging Face Space: 시스템 패키지 설치 권한 없음")
-            return False
-            
-    except Exception as e:
-        print(f"의존성 설치 중 오류: {e}")
-        return False
-
-def install_playwright_with_deps():
-    """Playwright와 의존성 설치"""
-    try:
-        print("Playwright 설치 시작...")
-        
-        # Playwright 설치
-        result = subprocess.run([
-            sys.executable, "-m", "pip", "install", "playwright==1.40.0"
-        ], capture_output=True, text=True, timeout=300)
+            print("Hugging Face Space 환경, 헤드리스 모드로 실행")
+            options.add_argument("--headless=new")  # 새로운 헤드리스 모드
+            options.add_argument("--no-sandbox")
+            options.add_argument("--disable-dev-shm-usage")
+            options.add_argument("--disable-gpu")
+            options.add_argument("--disable-software-rasterizer")
+            options.add_argument("--remote-debugging-port=9222")
+        else:
+            options.add_argument("--headless")
         
-        if result.returncode != 0:
-            print(f"Playwright pip 설치 실패: {result.stderr}")
-            return False
+        # # 환경별 설정
+        # if os.getenv("SPACE_ID"):  # Hugging Face Space
+        #     options.add_argument("--headless")
+        #     options.add_argument("--no-sandbox")
+        #     options.add_argument("--disable-dev-shm-usage")
+        #     options.add_argument("--disable-gpu")
+        # else:  # 로컬 환경
+        #     options.add_argument("--headless")
+        
+        # 속도 최적화 설정
+        options.add_argument("--window-size=1280,720")  # 해상도 줄임
+        options.add_argument("--disable-blink-features=AutomationControlled")
+        options.add_argument("--disable-extensions")
+        options.add_argument("--disable-web-security")
+        options.add_argument("--allow-running-insecure-content")
+        options.add_argument("--disable-background-timer-throttling")
+        options.add_argument("--disable-backgrounding-occluded-windows")
+        options.add_argument("--disable-renderer-backgrounding")
+        options.add_argument("--disable-features=TranslateUI")
+        options.add_argument("--disable-ipc-flooding-protection")
+        
+        # 네트워크 최적화
+        options.add_argument("--aggressive-cache-discard")
+        options.add_argument("--disable-background-networking")
+        
+        # 메모리 최적화
+        options.add_argument("--memory-pressure-off")
+        # options.add_argument("--max_old_space_size=4096")
+        options.add_argument("--max_old_space_size=2048")# 메모리 제한
+        
+        # 이미지/CSS 비활성화로 로딩 속도 향상
+        prefs = {
+            "profile.managed_default_content_settings.images": 2,  # 이미지 차단
+            "profile.default_content_setting_values.notifications": 2,  # 알림 차단
+        }
+        options.add_experimental_option("prefs", prefs)
         
-        # 브라우저 설치
-        result = subprocess.run([
-            sys.executable, "-m", "playwright", "install", "chromium"
-        ], capture_output=True, text=True, timeout=300)
+        # 봇 감지 회피
+        options.add_argument("--user-agent=Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36")
+        options.add_experimental_option("excludeSwitches", ["enable-automation"])
+        options.add_experimental_option('useAutomationExtension', False)
         
-        if result.returncode != 0:
-            print(f"Playwright 브라우저 설치 실패: {result.stderr}")
-            return False
+        # 언어 설정
+        options.add_argument("--lang=ko")
+        options.add_argument("--accept-lang=ko-KR,ko;q=0.9,en;q=0.8")
         
-        # 시스템 의존성 설치 시도
         try:
-            result = subprocess.run([
-                sys.executable, "-m", "playwright", "install-deps", "chromium"
-            ], capture_output=True, text=True, timeout=300)
-            
-            if result.returncode == 0:
-                print("Playwright 의존성 설치 완료")
-                return True
+            # Hugging Face 환경에서는 webdriver-manager 우선 사용
+            if IS_HUGGINGFACE:
+                try:
+                    from webdriver_manager.chrome import ChromeDriverManager
+                    from selenium.webdriver.chrome.service import Service
+                    
+                    print("ChromeDriver 자동 설치 중...")
+                    service = Service(ChromeDriverManager().install())
+                    self.driver = webdriver.Chrome(service=service, options=options)
+                    print("ChromeDriver 설치 및 초기화 성공")
+                    
+                except Exception as e:
+                    print(f"webdriver-manager 설치 실패: {e}")
+                    # 시스템 ChromeDriver 시도
+                    try:
+                        self.driver = webdriver.Chrome(options=options)
+                        print("시스템 ChromeDriver 사용 성공")
+                    except Exception as sys_e:
+                        print(f"시스템 ChromeDriver도 실패: {sys_e}")
+                        return False
             else:
-                print(f"Playwright 의존성 설치 실패: {result.stderr}")
-                print("수동 의존성 설치 시도...")
-                return install_system_dependencies()
+                # 로컬 환경
+                try:
+                    from webdriver_manager.chrome import ChromeDriverManager
+                    from selenium.webdriver.chrome.service import Service
+                    
+                    service = Service(ChromeDriverManager().install())
+                    self.driver = webdriver.Chrome(service=service, options=options)
+                    print("로컬 ChromeDriver 설치 성공")
+                except:
+                    self.driver = webdriver.Chrome(options=options)
+                    print("로컬 시스템 ChromeDriver 사용")
+            # # 여러 방법으로 ChromeDriver 시도
+            # driver_created = False
+            
+            # # 방법 1: webdriver-manager 사용
+            # try:
+            #     from webdriver_manager.chrome import ChromeDriverManager
+            #     from selenium.webdriver.chrome.service import Service
+                
+            #     service = Service(ChromeDriverManager().install())
+            #     self.driver = webdriver.Chrome(service=service, options=options)
+            #     print("webdriver-manager로 ChromeDriver 자동 설치 성공")
+            #     driver_created = True
                 
-        except subprocess.CalledProcessError:
-            print("Playwright install-deps 실패, 수동 설치 시도")
-            return install_system_dependencies()
+            # except Exception as wm_error:
+            #     print(f"webdriver-manager 실패: {wm_error}")
+            
+            # # 방법 2: 시스템 ChromeDriver 사용
+            # if not driver_created:
+            #     try:
+            #         self.driver = webdriver.Chrome(options=options)
+            #         print("시스템 ChromeDriver 사용 ���공")
+            #         driver_created = True
+            #     except Exception as sys_error:
+            #         print(f"시스템 ChromeDriver 실패: {sys_error}")
+            
+            # if not driver_created:
+            #     print("모든 ChromeDriver 초기화 방법 실패")
+            #     return False
+            
+            # 타임아웃 설정 (속도 최적화)
+            self.driver.set_page_load_timeout(15)  # 페이지 로딩 타임아웃 15초
+            self.driver.implicitly_wait(2)  # 요소 대기 시간 2초로 단축
+            
+            # 봇 감지 방지 스크립트
+            try:
+                self.driver.execute_script("""
+                    Object.defineProperty(navigator, 'webdriver', {get: () => undefined});
+                    Object.defineProperty(navigator, 'plugins', {get: () => [1, 2, 3, 4, 5]});
+                    Object.defineProperty(navigator, 'languages', {get: () => ['ko-KR', 'ko', 'en']});
+                """)
+            except Exception as script_error:
+                print(f"봇 감지 방지 스크립트 실패 (무시): {script_error}")
             
-    except Exception as e:
-        print(f"Playwright 설치 중 오류: {e}")
+            return True
+            
+        except Exception as e:
+            print(f"드라이버 설정 최종 실패: {e}")
+            return False
+    
+    # 빠르게 Element 찾기, Timeout 단축 고려
+    def safe_find_element(self, selectors: list, timeout: int = 3):
+        for selector_type, selector in selectors:
+            try:
+                if selector_type == "xpath":
+                    element = WebDriverWait(self.driver, timeout).until(
+                        EC.presence_of_element_located((By.XPATH, selector))
+                    )
+                elif selector_type == "css":
+                    element = WebDriverWait(self.driver, timeout).until(
+                        EC.presence_of_element_located((By.CSS_SELECTOR, selector))
+                    )
+                elif selector_type == "text":
+                    element = WebDriverWait(self.driver, timeout).until(
+                        EC.presence_of_element_located((By.XPATH, f"//*[contains(text(), '{selector}')]"))
+                    )
+                
+                if element:
+                    return element
+            except:
+                continue
+        return None
+    
+    # 즉시 클릭
+    def safe_click(self, selectors: list, timeout: int = 3) -> bool:
+        element = self.safe_find_element(selectors, timeout)
+        if element:
+            try:
+                # JavaScript 클릭 우선 시도 (더 빠름)
+                self.driver.execute_script("arguments[0].click();", element)
+                return True
+            except:
+                try:
+                    element.click()
+                    return True
+                except:
+                    return False
         return False
-
-class SmartGoogleTrendsAutomator:
-    """스마트 Google Trends 자동화 (여러 방법 시도)"""
     
-    def __init__(self):
-        self.method = None
-        self.browser = None
-        self.page = None
-        self.driver = None
-        self.is_ready = False
-        self.lock = threading.Lock()
+    # 병렬로 설정 변경 시도
+    def parallel_change_settings(self, region: str, period: str, category: str, progress_callback=None) -> dict:
+        results = {
+            'region': False,
+            'period': False, 
+            'category': False,
+            'errors': []
+        }
         
-    def initialize_browser(self):
-        """브라우저 초기화 (여러 방법 시도)"""
-        with self.lock:
-            if self.is_ready:
-                return True
-            
-            # 방법 1: Playwright 시도
-            if self.try_playwright():
-                self.method = "playwright"
-                self.is_ready = True
-                return True
-            
-            # 방법 2: Selenium 시도
-            if self.try_selenium():
-                self.method = "selenium"
-                self.is_ready = True
-                return True
-            
-            # 방법 3: 대체 방법 (API 기반)
-            if self.try_alternative():
-                self.method = "alternative"
-                self.is_ready = True
-                return True
-            
-            return False
+        # 순차적으로 변경 (병렬은 selenium에서 안전하지 않음)
+        try:
+            if region != "대한민국":
+                if progress_callback:
+                    progress_callback("지역 설정 변경 중...")
+                results['region'] = self.change_region(region)
+                time.sleep(0.5)  # 최소 대기
+            else:
+                results['region'] = True
+                
+            if period != "지난 24시간":
+                if progress_callback:
+                    progress_callback("기간 설정 변경 중...")
+                results['period'] = self.change_time_period(period)
+                time.sleep(0.5)  # 최소 대기
+            else:
+                results['period'] = True
+                
+            if category != "모든 카테고리":
+                if progress_callback:
+                    progress_callback("카테고리 설정 변경 중...")
+                results['category'] = self.change_category(category)
+                time.sleep(0.5)  # 최소 대기
+            else:
+                results['category'] = True
+                
+        except Exception as e:
+            results['errors'].append(str(e))
+        
+        return results
     
-    def try_playwright(self):
-        """Playwright 초기화 시도"""
+    # 지역 변경
+    def change_region(self, target_region: str) -> bool:
         try:
-            print("Playwright 방법 시도 중...")
+            region_selectors = [
+                ("xpath", "//button[@aria-label='대한민국, 위치 선택']"),
+                ("xpath", "//button[contains(@aria-label, '위치 선택')]"),
+                ("xpath", "//span[contains(text(), '대한민국')]//parent::button"),
+            ]
             
-            # 의존성 설치
-            if not install_playwright_with_deps():
-                print("Playwright 의존성 설치 실패")
+            if not self.safe_click(region_selectors):
                 return False
             
-            # Playwright 임포트
-            from playwright.sync_api import sync_playwright
-            
-            # 브라우저 시작
-            self.playwright = sync_playwright().start()
-            self.browser = self.playwright.chromium.launch(
-                headless=True,
-                args=[
-                    '--no-sandbox',
-                    '--disable-dev-shm-usage',
-                    '--disable-gpu',
-                    '--disable-software-rasterizer',
-                    '--disable-web-security',
-                    '--disable-features=VizDisplayCompositor'
-                ]
-            )
+            time.sleep(1)  # 대기 시간 단축
             
-            self.page = self.browser.new_page()
-            self.page.set_user_agent(
-                'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36'
-            )
+            region_mapping = {
+                "전세계": ["전 세계", "Worldwide"],
+                "미국": ["미국", "United States"],
+                "일본": ["일본", "Japan"],
+                "중국": ["중국", "China"]
+            }
             
-            # 테스트 페이지 로드
-            self.page.goto("https://trends.google.com/trending?geo=KR&hl=ko", timeout=30000)
-            self.page.wait_for_load_state('networkidle', timeout=15000)
+            if target_region in region_mapping:
+                for region_text in region_mapping[target_region]:
+                    region_option_selectors = [
+                        ("xpath", f"//span[contains(text(), '{region_text}')]"),
+                        ("xpath", f"//*[contains(text(), '{region_text}')]"),
+                    ]
+                    
+                    if self.safe_click(region_option_selectors, timeout=2):
+                        return True
             
-            print("Playwright 초기화 성공")
-            return True
+            return False
             
         except Exception as e:
-            print(f"Playwright 초기화 실패: {e}")
-            self.cleanup_playwright()
+            print(f"지역 변경 실패: {e}")
             return False
     
-    def try_selenium(self):
-        """Selenium 초기화 시도"""
+    # 기간 변경
+    def change_time_period(self, target_period: str) -> bool:
         try:
-            print("Selenium 방법 시도 중...")
-            
-            from selenium import webdriver
-            from selenium.webdriver.chrome.options import Options
-            from selenium.webdriver.common.by import By
-            from selenium.webdriver.support.ui import WebDriverWait
-            from selenium.webdriver.support import expected_conditions as EC
-            
-            options = Options()
-            options.add_argument("--headless")
-            options.add_argument("--no-sandbox")
-            options.add_argument("--disable-dev-shm-usage")
-            options.add_argument("--disable-gpu")
-            options.add_argument("--disable-software-rasterizer")
-            
-            # Chrome 바이너리 경로 수동 설정 시도
-            chrome_paths = [
-                "/usr/bin/google-chrome",
-                "/usr/bin/google-chrome-stable", 
-                "/usr/bin/chromium-browser",
-                "/usr/bin/chromium",
-                "/opt/google/chrome/google-chrome"
+            period_selectors = [
+                ("xpath", "//button[contains(@aria-label, '기간 선택')]"),
+                ("xpath", "//span[contains(text(), '지난 24시간')]//parent::button"),
             ]
             
-            for chrome_path in chrome_paths:
-                if os.path.exists(chrome_path):
-                    options.binary_location = chrome_path
-                    print(f"Chrome 바이너리 발견: {chrome_path}")
-                    break
-            
-            # webdriver-manager 시도
-            try:
-                from webdriver_manager.chrome import ChromeDriverManager
-                from selenium.webdriver.chrome.service import Service
-                
-                service = Service(ChromeDriverManager().install())
-                self.driver = webdriver.Chrome(service=service, options=options)
+            if not self.safe_click(period_selectors):
+                return False
                 
-            except Exception as wm_error:
-                print(f"webdriver-manager 실패: {wm_error}")
-                # 시스템 chromedriver 시도
-                self.driver = webdriver.Chrome(options=options)
-            
-            # 테스트 페이지 로드
-            self.driver.get("https://trends.google.com/trending?geo=KR&hl=ko")
-            WebDriverWait(self.driver, 10).until(
-                EC.presence_of_element_located((By.TAG_NAME, "body"))
-            )
+            time.sleep(1)  # 대기 시간 단축
+            
+            period_mapping = {
+                "지난 1시간": ["지난 1시간"],
+                "지난 4시간": ["지난 4시간"], 
+                "지난 1일": ["지난 1일"],
+                "지난 7일": ["지난 7일", "지난 주"]
+            }
+            
+            if target_period in period_mapping:
+                for period_text in period_mapping[target_period]:
+                    period_option_selectors = [
+                        ("xpath", f"//span[contains(text(), '{period_text}')]"),
+                        ("xpath", f"//*[contains(text(), '{period_text}')]"),
+                    ]
+                    
+                    if self.safe_click(period_option_selectors, timeout=2):
+                        return True
             
-            print("Selenium 초기화 성공")
-            return True
+            return False
             
         except Exception as e:
-            print(f"Selenium 초기화 실패: {e}")
-            self.cleanup_selenium()
+            print(f"기간 변경 실패: {e}")
             return False
     
-    def try_alternative(self):
-        """대체 방법 (API/스크래핑 기반)"""
+    # 카테고리 변경
+    def change_category(self, target_category: str) -> bool:
         try:
-            print("대체 방법 시도 중...")
-            
-            import requests
-            from bs4 import BeautifulSoup
-            
-            # Google Trends RSS 시도
-            rss_url = "https://trends.google.com/trending/rss?geo=KR"
-            
-            session = requests.Session()
-            session.headers.update({
-                'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36'
-            })
-            
-            response = session.get(rss_url, timeout=10)
-            response.raise_for_status()
-            
-            # RSS 파싱 테스트
-            from xml.etree import ElementTree as ET
-            root = ET.fromstring(response.content)
+            category_selectors = [
+                ("xpath", "//button[contains(@aria-label, '카테고리 선택')]"),
+                ("xpath", "//span[contains(text(), '모든 카테고리')]//parent::button"),
+            ]
             
-            # 트렌드 데이터 확인
-            items = root.findall('.//item')
-            if len(items) > 0:
-                print(f"대체 방법 성공: {len(items)}개 트렌드 발견")
-                self.session = session
-                return True
+            if not self.safe_click(category_selectors):
+                return False
+                
+            time.sleep(1)  # 대기 시간 단축
+            
+            category_mapping = {
+                "게임": ["게임"],
+                "건강": ["건강"],
+                "기술": ["컴퓨터 및 전자제품", "기술"],
+                "스포츠": ["스포츠"],
+                "엔터테인먼트": ["예술 및 엔터테인먼트", "엔터테인먼트"],
+                "뉴스": ["뉴스"],
+                "비즈니스": ["비즈니스"]
+            }
+            
+            if target_category in category_mapping:
+                for category_text in category_mapping[target_category]:
+                    category_option_selectors = [
+                        ("xpath", f"//span[contains(text(), '{category_text}')]"),
+                        ("xpath", f"//*[contains(text(), '{category_text}')]"),
+                    ]
+                    
+                    if self.safe_click(category_option_selectors, timeout=2):
+                        return True
             
             return False
             
         except Exception as e:
-            print(f"대체 방법 실패: {e}")
+            print(f"카테고리 변경 실패: {e}")
             return False
     
-    def capture_screenshot(self, region: str, period: str, category: str) -> Tuple[Optional[str], bool, str]:
-        """선택된 방법으로 스크린샷 캡처"""
-        
-        if not self.is_ready:
-            if not self.initialize_browser():
-                return None, False, "모든 브라우저 초기화 방법 실패"
+    # Google Trends 캡처
+    def capture_trends(self, region: str, period: str, category: str, progress_callback=None) -> Tuple[Optional[str], bool, str]:
+        error_msg = ""
         
         try:
-            if self.method == "playwright":
-                return self.capture_with_playwright(region, period, category)
-            elif self.method == "selenium":
-                return self.capture_with_selenium(region, period, category)
-            elif self.method == "alternative":
-                return self.capture_with_alternative(region, period, category)
-            else:
-                return None, False, "알 수 없는 방법"
-                
-        except Exception as e:
-            return None, False, f"캡처 중 오류: {str(e)}"
-    
-    def capture_with_playwright(self, region: str, period: str, category: str) -> Tuple[Optional[str], bool, str]:
-        """Playwright로 캡처"""
-        try:
-            # 페이지 새로고침
-            self.page.reload(wait_until='domcontentloaded')
-            self.page.wait_for_load_state('networkidle', timeout=10000)
-            
-            # 설정 변경 (간단한 버전)
-            time.sleep(2)
-            
-            # 스크린샷 캡처
-            screenshot_bytes = self.page.screenshot(full_page=False)
-            screenshot_b64 = base64.b64encode(screenshot_bytes).decode()
+            if progress_callback:
+                progress_callback("브라우저 드라이버 초기화 중...")
             
-            return screenshot_b64, True, f"Playwright 캡처 성공: {region}"
+            # 드라이버 설정
+            if not self.setup_driver():
+                return None, False, "브라우저 드라이버 설정 실패"
             
-        except Exception as e:
-            return None, False, f"Playwright 캡처 실패: {str(e)}"
-    
-    def capture_with_selenium(self, region: str, period: str, category: str) -> Tuple[Optional[str], bool, str]:
-        """Selenium으로 캡처"""
-        try:
-            # 페이지 새로고침
-            self.driver.refresh()
-            time.sleep(3)
-            
-            # 스크린샷 캡처
-            screenshot = self.driver.get_screenshot_as_png()
-            screenshot_b64 = base64.b64encode(screenshot).decode()
+            if progress_callback:
+                progress_callback("Google Trends 페이지 접속 중...")
             
-            return screenshot_b64, True, f"Selenium 캡처 성공: {region}"
-            
-        except Exception as e:
-            return None, False, f"Selenium 캡처 실패: {str(e)}"
-    
-    def capture_with_alternative(self, region: str, period: str, category: str) -> Tuple[Optional[str], bool, str]:
-        """대체 방법으로 데이터 수집"""
-        try:
-            # RSS 데이터 수집
-            rss_url = f"https://trends.google.com/trending/rss?geo=KR"
+            # Google Trends 접속 (한국어 직접 URL)
+            self.driver.get("https://trends.google.com/trending?geo=KR&hl=ko")
             
-            response = self.session.get(rss_url, timeout=10)
-            response.raise_for_status()
+            # 최소한의 로딩 대기 (1초로 단축)
+            time.sleep(1)
             
-            # 가짜 스크린샷 생성 (실제로는 HTML 기반 시각화)
-            fake_screenshot = self.generate_fake_screenshot(response.content, region)
+            if progress_callback:
+                progress_callback("페이지 로딩 완료, 설정 변경 시작...")
             
-            return fake_screenshot, True, f"대체 방법 성공: {region}"
+            # 페이지 준비 확인 (빠른 체크)
+            try:
+                WebDriverWait(self.driver, 5).until(
+                    EC.presence_of_element_located((By.TAG_NAME, "button"))
+                )
+            except TimeoutException:
+                pass  # 계속 진행
             
-        except Exception as e:
-            return None, False, f"대체 방법 실패: {str(e)}"
-    
-    def generate_fake_screenshot(self, rss_content: bytes, region: str) -> str:
-        """RSS 데이터를 기반으로 가짜 스크린샷 생성"""
-        try:
-            from xml.etree import ElementTree as ET
-            import matplotlib.pyplot as plt
-            import matplotlib.font_manager as fm
-            from io import BytesIO
+            # 설정 변경 (병렬 처리)
+            settings_result = self.parallel_change_settings(region, period, category, progress_callback)
             
-            # RSS 파싱
-            root = ET.fromstring(rss_content)
-            trends = []
+            # 결과 확인
+            changes_made = []
+            if settings_result['region']:
+                changes_made.append(f"지역: {region}")
+            if settings_result['period']:
+                changes_made.append(f"기간: {period}")
+            if settings_result['category']:
+                changes_made.append(f"카테고리: {category}")
             
-            for item in root.findall('.//item')[:10]:
-                title = item.find('title')
-                if title is not None:
-                    trends.append(title.text)
+            if settings_result['errors']:
+                error_msg = "\n".join(settings_result['errors'])
             
-            # 차트 생성
-            fig, ax = plt.subplots(figsize=(12, 8))
-            fig.patch.set_facecolor('white')
+            if progress_callback:
+                progress_callback("설정 변경 완료, 데이터 가져오는중...")
             
-            # 한글 폰트 설정 시도
-            try:
-                plt.rcParams['font.family'] = 'DejaVu Sans'
-            except:
-                pass
+            # 최종 데이터 로딩 대기 (1초로 단축)
+            time.sleep(1)
             
-            # 트렌드 차트
-            y_pos = range(len(trends))
-            values = [100 - i*10 for i in range(len(trends))]
-            
-            bars = ax.barh(y_pos, values, color='#4285f4')
-            ax.set_yticks(y_pos)
-            ax.set_yticklabels(trends[::-1])  # 역순으로 표시
-            ax.set_xlabel('검색 관심도')
-            ax.set_title(f'{region} 실시간 인기 검색어')
-            
-            # 그래프를 이미지로 변환
-            buffer = BytesIO()
-            plt.savefig(buffer, format='png', dpi=100, bbox_inches='tight', 
-                       facecolor='white', edgecolor='none')
-            buffer.seek(0)
+            # 스크린샷 촬영 (필요한 영역만)
+            screenshot = self.driver.get_screenshot_as_png()
+            screenshot_b64 = base64.b64encode(screenshot).decode()
             
-            screenshot_b64 = base64.b64encode(buffer.getvalue()).decode()
+            success_msg = f"설정 완료: {', '.join(changes_made) if changes_made else '기본 설정 사용'}"
             
-            plt.close(fig)
-            return screenshot_b64
+            return screenshot_b64, True, success_msg + ("\n" + error_msg if error_msg else "")
             
         except Exception as e:
-            print(f"가짜 스크린샷 생성 실패: {e}")
-            # 빈 이미지 반환
-            return ""
-    
-    def cleanup_playwright(self):
-        """Playwright 정리"""
-        try:
-            if hasattr(self, 'page') and self.page:
-                self.page.close()
-            if hasattr(self, 'browser') and self.browser:
-                self.browser.close()
-            if hasattr(self, 'playwright') and self.playwright:
-                self.playwright.stop()
-        except:
-            pass
-    
-    def cleanup_selenium(self):
-        """Selenium 정리"""
-        try:
-            if hasattr(self, 'driver') and self.driver:
+            error_msg = f"오류 발생: {str(e)}"
+            return None, False, error_msg
+            
+        finally:
+            if self.driver:
                 self.driver.quit()
-        except:
-            pass
-    
-    def cleanup(self):
-        """모든 리소스 정리"""
-        self.cleanup_playwright()
-        self.cleanup_selenium()
-        self.is_ready = False
-
-# 글로벌 자동화 인스턴스
-automator = SmartGoogleTrendsAutomator()
 
+# Claude API로 스크린샷 분석
 def analyze_with_claude(screenshot_b64: str, region: str, period: str, category: str) -> str:
-    """Claude API로 스크린샷 분석"""
     try:
+        # API 키 체크
         if not ANTHROPIC_API_KEY or ANTHROPIC_API_KEY == "your_api_key_here":
-            return generate_fallback_analysis(region, period, category)
+            return """
+            <div style="color: red; padding: 20px; border: 1px solid red; border-radius: 5px;">
+                <h3>API 키 오류</h3>
+                <p><strong>ANTHROPIC_API_KEY가 설정되지 않았습니다!</strong></p>
+            </div>
+            """
         
+        # Claude 클라이언트 생성
         claude_client = create_claude_client()
         
         if claude_client is None:
-            return generate_fallback_analysis(region, period, category)
-        
-        # 빈 스크린샷인 경우 텍스트 분석만
-        if not screenshot_b64:
-            return generate_fallback_analysis(region, period, category)
+            return """
+            <div style="color: red; padding: 20px; border: 1px solid red; border-radius: 5px;">
+                <h3>Claude API 연결 실패</h3>
+                <p>API 연결에 문제가 있습니다. 잠시 후 다시 시도해주세요.</p>
+            </div>
+            """
         
+        # 간결한 프롬프트 (속��� 최적화)
         prompt = f"""
 이 Google Trends 스크린샷을 분석해주세요.
 설정: {region} | {period} | {category}
@@ -474,13 +479,14 @@ def analyze_with_claude(screenshot_b64: str, region: str, period: str, category:
 2. 주요 트렌드 키워드 3-5개의 특징 설명
 3. 카테고리별 특이사항 (있는 경우)
 
-HTML 형태로 깔끔하게 정리하고, 시각적으로 만들어주세요.
+HTML 형태로 깔끔하게 정리하고, 이모지를 사용하지 않고 시각적으로 만들어주세요.
 한글 텍스트를 정확히 읽어서 분석해주세요.
 """
 
+        # Claude API 호출 (빠른 설정)
         message = claude_client.messages.create(
             model="claude-3-5-sonnet-20241022",
-            max_tokens=1000,
+            max_tokens=1000,  # 토큰 수 줄여서 속도 향상
             messages=[
                 {
                     "role": "user",
@@ -505,230 +511,204 @@ HTML 형태로 깔끔하게 정리하고, 시각적으로 만들어주세요.
         return message.content[0].text
         
     except Exception as e:
-        return generate_fallback_analysis(region, period, category, str(e))
-
-def generate_fallback_analysis(region: str, period: str, category: str, error: str = None) -> str:
-    """대체 분석 결과 생성"""
-    
-    timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-    
-    html = f"""
-    <div style="font-family: 'Segoe UI', sans-serif; max-width: 1000px; margin: 0 auto;">
-        <div style="background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); color: white; padding: 20px; border-radius: 10px; margin-bottom: 20px;">
-            <h2>{region} 실시간 트렌드 분석 (대체 모드)</h2>
-            <p>분석 시각: {timestamp}</p>
-            <p>설정: {region} | {period} | {category}</p>
-        </div>
-        
-        <div style="background-color: #fff3cd; border: 1px solid #ffeaa7; padding: 15px; border-radius: 5px; margin-bottom: 20px;">
-            <h4>알림: 대체 분석 모드</h4>
-            <p>브라우저 기반 캡처가 불가능하여 대체 방법으로 분석을 진행했습니다.</p>
-            {f"<p><strong>오류 정보:</strong> {error}</p>" if error else ""}
+        return f"""
+        <div style="color: red; padding: 20px; border: 1px solid red; border-radius: 5px;">
+            <h3>Claude API 분석 실패</h3>
+            <p><strong>오류:</strong> {str(e)}</p>
         </div>
-        
-        <h3>예상 인기 검색어 (참고용)</h3>
-        <table style="width: 100%; border-collapse: collapse; margin-bottom: 30px;">
-            <thead>
-                <tr style="background-color: #f8f9fa;">
-                    <th style="border: 1px solid #dee2e6; padding: 12px; text-align: left;">순위</th>
-                    <th style="border: 1px solid #dee2e6; padding: 12px; text-align: left;">검색어</th>
-                    <th style="border: 1px solid #dee2e6; padding: 12px; text-align: left;">예상 관심도</th>
-                    <th style="border: 1px solid #dee2e6; padding: 12px; text-align: left;">카테고리</th>
-                </tr>
-            </thead>
-            <tbody>
-    """
-    
-    # 샘플 데이터 생성
-    sample_trends = [
-        ("뉴스 이슈", "높음", "뉴스"),
-        ("연예계 소식", "높음", "엔터테인먼트"),
-        ("스포츠 경기", "중간", "스포츠"),
-        ("기술 뉴스", "중간", "기술"),
-        ("건강 정보", "낮음", "건강"),
-    ]
-    
-    for i, (keyword, interest, cat) in enumerate(sample_trends, 1):
-        html += f"""
-            <tr>
-                <td style="border: 1px solid #dee2e6; padding: 12px;">{i}</td>
-                <td style="border: 1px solid #dee2e6; padding: 12px; font-weight: bold;">{keyword}</td>
-                <td style="border: 1px solid #dee2e6; padding: 12px;">{interest}</td>
-                <td style="border: 1px solid #dee2e6; padding: 12px;">{cat}</td>
-            </tr>
         """
-    
-    html += """
-            </tbody>
-        </table>
-        
-        <h3>분석 참고사항</h3>
-        <div style="background-color: #f8f9fa; padding: 20px; border-radius: 8px;">
-            <ul>
-                <li><strong>데이터 한계:</strong> 실제 Google Trends 데이터가 아닌 예상 데이터입니다.</li>
-                <li><strong>브라우저 이슈:</strong> 시스템 환경에서 브라우저 실행이 제한되어 있습니다.</li>
-                <li><strong>권장사항:</strong> 로컬 환경에서 테스트하거나 다른 방법을 시도해보세요.</li>
-            </ul>
-        </div>
-    </div>
-    """
-    
-    return html
 
-def smart_analysis(region: str, period: str, category: str):
-    """스마트 분석 함수 (여러 방법 시도)"""
+def main_analysis(region: str, period: str, category: str):
+    """실시간 스트리밍 분석 함수 (Generator)"""
     
     start_time = time.time()
     
+    # 1단계: 시작 메시지
     yield f"""
     <div style="text-align: center; padding: 20px; background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); color: white; border-radius: 10px; margin-bottom: 20px;">
-        <h3>스마트 Google Trends 분석</h3>
+        <h3>Google Trends 분석 시작!</h3>
         <p><strong>설정:</strong> {region} | {period} | {category}</p>
-        <p>여러 방법을 시도하여 최적의 결과를 제공합니다</p>
+        <p>실시간으로 진행 상황을 업데이트합니다...</p>
     </div>
     """
     
+    progress_status = {"current": ""}
+    
+    def progress_callback(message):
+        progress_status["current"] = message
+    
     try:
-        # 1단계: 브라우저 초기화
+        # 2단계: API 키 확인
+        if not ANTHROPIC_API_KEY or ANTHROPIC_API_KEY == "your_api_key_here":
+            yield """
+            <div style="color: red; padding: 20px; border: 1px solid red; border-radius: 5px;">
+                <h3> API 키 누락</h3>
+                <p><strong>ANTHROPIC_API_KEY가 설정되지 않았습니다!</strong></p>
+                <p><strong>해결 방법:</strong> .env 파일에 API 키를 설정하고 앱을 재시작하세요.</p>
+            </div>
+            """
+            return
+        
+        # 3단계: 브라우저 실행 알림
         yield f"""
         <div style="text-align: center; padding: 15px; background: linear-gradient(135deg, #4CAF50 0%, #45a049 100%); color: white; border-radius: 10px; margin-bottom: 15px;">
-            <h4>1단계: 브라우저 초기화 중...</h4>
-            <p>Playwright → Selenium → 대체 방법 순서로 시도</p>
+            <h4> 1단계: 시작합니다! 입력하신 조건을 확인합니다...</h4>
+             <p>Connect Start...</p>
+        </div>
+        
+        <div style="padding: 15px; background-color: #f8f9fa; border-radius: 5px; margin-bottom: 15px;">
+            <p> <strong>진행 중:</strong> 브라우저 드라이버 설정 및 페이지 로딩...</p>
         </div>
         """
         
-        # 브라우저 초기화
-        init_success = automator.initialize_browser()
-        init_time = time.time() - start_time
+        # 4단계: Google Trends 자동화 실행
+        print(f" 분석 시작: {region} | {period} | {category}")
+        automator = GoogleTrendsAutomator()
         
-        if init_success:
+        # 5단계: 설정 변경 알림
+        if region != "대한민국" or period != "지난 24시간" or category != "모든 카테고리":
             yield f"""
             <div style="text-align: center; padding: 15px; background: linear-gradient(135deg, #4CAF50 0%, #45a049 100%); color: white; border-radius: 10px; margin-bottom: 15px;">
-                <h4>1단계 완료: {automator.method.upper()} 초기화 성공 ({init_time:.1f}초)</h4>
-                <p>선택된 방법으로 데이터 수집을 진행합니다</p>
-            </div>
-            
-            <div style="text-align: center; padding: 15px; background: linear-gradient(135deg, #FF6B6B 0%, #FF8E8E 100%); color: white; border-radius: 10px; margin-bottom: 15px;">
-                <h4>2단계: 데이터 수집 중...</h4>
-                <p>Google Trends에서 {region} 지역의 데이터를 가져오고 있습니다</p>
-            </div>
-            """
-        else:
-            yield f"""
-            <div style="text-align: center; padding: 15px; background: linear-gradient(135deg, #FFA500 0%, #FF8C00 100%); color: white; border-radius: 10px; margin-bottom: 15px;">
-                <h4>1단계: 브라우저 초기화 실패 ({init_time:.1f}초)</h4>
-                <p>대체 방법으로 분석을 진행합니다</p>
+                <h4>자동화 시작</h4>
+                <p>In Running...</p>
             </div>
             
-            <div style="text-align: center; padding: 15px; background: linear-gradient(135deg, #FF6B6B 0%, #FF8E8E 100%); color: white; border-radius: 10px; margin-bottom: 15px;">
-                <h4>2단계: 대체 분석 중...</h4>
-                <p>브라우저 없이 가능한 범위에서 분석합니다</p>
+            <div style="padding: 15px; background-color: #e3f2fd; border-radius: 5px; margin-bottom: 15px;">
+                <p><strong>설정 변경 중:</strong></p>
+                <ul style="margin: 10px 0;">
+                    {"<li>지역: " + region + "</li>" if region != "대한민국" else ""}
+                    {"<li>기간: " + period + "</li>" if period != "지난 24시간" else ""}
+                    {"<li>카테고리: " + category + "</li>" if category != "모든 카테고리" else ""}
+                </ul>
             </div>
             """
         
-        # 2단계: 데이터 캡처
+        # 브라우저 작업을 별도 스레드에서 실행
         with ThreadPoolExecutor(max_workers=1) as executor:
             future = executor.submit(
-                automator.capture_screenshot, 
-                region, period, category
+                automator.capture_trends, 
+                region, period, category, progress_callback
             )
             
-            # 진행 상황 표시
+            # 진행 상황 업데이트
             while not future.done():
-                elapsed = time.time() - start_time
-                yield f"""
-                <div style="text-align: center; padding: 15px; background: linear-gradient(135deg, #4CAF50 0%, #45a049 100%); color: white; border-radius: 10px; margin-bottom: 15px;">
-                    <h4>1단계 완료: {automator.method.upper() if automator.method else '대체방법'} ({init_time:.1f}초)</h4>
-                </div>
-                
-                <div style="text-align: center; padding: 15px; background: linear-gradient(135deg, #FF6B6B 0%, #FF8E8E 100%); color: white; border-radius: 10px; margin-bottom: 15px;">
-                    <h4>2단계: 데이터 수집 중... ({elapsed:.1f}초)</h4>
-                    <p>트렌드 데이터를 처리하고 있습니다</p>
-                </div>
-                """
+                current_progress = progress_status["current"]
+                if current_progress:
+                    elapsed = time.time() - start_time
+                    yield f"""
+                    <div style="text-align: center; padding: 15px; background: linear-gradient(135deg, #4CAF50 0%, #45a049 100%); color: white; border-radius: 10px; margin-bottom: 15px;">
+                        <h4>자동화 시작</h4>
+                        <p>In Running...</p>
+                    </div>
+                    
+                    <div style="padding: 15px; background-color: #f8f9fa; border-radius: 5px; margin-bottom: 15px;">
+                        <p><strong>진행 중:</strong> {current_progress}</p>
+                        <p><strong>경과 시간:</strong> {elapsed:.1f}초</p>
+                    </div>
+                    """
                 time.sleep(0.5)
             
+            # 결과 받기
             screenshot_b64, success, status_msg = future.result()
         
-        capture_time = time.time() - start_time
+        browser_time = time.time() - start_time
+        
+        if not success:
+            yield f"""
+            <div style="color: red; padding: 20px; border: 1px solid red; border-radius: 5px;">
+                <h3>Google Trends 접속 실패</h3>
+                <pre style="background-color: #fff5f5; padding: 15px; border-radius: 5px; margin: 15px 0;">
+{status_msg}
+                </pre>
+                <p><strong>해결 방법:</strong> Chrome 브라우저와 ChromeDriver를 설치하고 다시 시도하세요.</p>
+            </div>
+            """
+            return
         
-        # 3단계: AI 분석
+        # 6단계: 스크린샷 완료 및 AI 분석 시작
         yield f"""
         <div style="text-align: center; padding: 15px; background: linear-gradient(135deg, #4CAF50 0%, #45a049 100%); color: white; border-radius: 10px; margin-bottom: 15px;">
-            <h4>2단계 완료: 데이터 수집 {"성공" if success else "부분 성공"} ({capture_time:.1f}초)</h4>
-            <p>{status_msg}</p>
+            <h4>2단계: 입력하신 데이터를 확인했고, 조건에 맞는 데이터를 가져옵니다...</h4>
+            <p>Google Trends 데이터를 성공적으로 캡처했습니다.</p>
         </div>
         
-        <div style="text-align: center; padding: 15px; background: linear-gradient(135deg, #9C27B0 0%, #8E24AA 100%); color: white; border-radius: 10px; margin-bottom: 15px;">
-            <h4>3단계: AI 분석 중...</h4>
-            <p>Claude AI가 수집된 데이터를 분석하고 있습니다</p>
+        <div style="text-align: center; padding: 15px; background: linear-gradient(135deg, #FF6B6B 0%, #FF8E8E 100%); color: white; border-radius: 10px; margin-bottom: 15px;">
+            <h4>3단계: AI 분석 진행 중...</h4>
+            <p>Claude AI가 트렌드 데이터를 분석하고 있습니다.</p>
+            <p style="font-size: 14px; opacity: 0.9;">약 10-20초 소요 예상</p>
         </div>
         """
         
-        # AI 분석 실행
+        # 7단계: Claude API 분석
         ai_start_time = time.time()
+        print("실시간 인기 검색어 데이터를 가져왔고, Claude 분석 시작합니다...")
         
+        # AI 분석을 별도 스레드에서 실행
         with ThreadPoolExecutor(max_workers=1) as executor:
             ai_future = executor.submit(
                 analyze_with_claude, 
                 screenshot_b64, region, period, category
             )
             
+            # AI 분석 진행 상황 표시
             while not ai_future.done():
                 ai_elapsed = time.time() - ai_start_time
                 total_elapsed = time.time() - start_time
                 yield f"""
                 <div style="text-align: center; padding: 15px; background: linear-gradient(135deg, #4CAF50 0%, #45a049 100%); color: white; border-radius: 10px; margin-bottom: 15px;">
-                    <h4>2단계 완료: 데이터 수집 {"성공" if success else "부분 성공"} ({capture_time:.1f}초)</h4>
-                    <p>{status_msg}</p>
+                    <h4>📸 2단계: 입력하신 데이터를 확인했고, 조건에 맞는 데이터를 가져옵니다...</h4>
+                    <p>Google Trends 데이터를 성공적으로 캡처했습니다.</p>
                 </div>
                 
-                <div style="text-align: center; padding: 15px; background: linear-gradient(135deg, #9C27B0 0%, #8E24AA 100%); color: white; border-radius: 10px; margin-bottom: 15px;">
-                    <h4>3단계: AI 분석 중... ({ai_elapsed:.1f}초)</h4>
-                    <p>총 경과 시간: {total_elapsed:.1f}초</p>
+                <div style="text-align: center; padding: 15px; background: linear-gradient(135deg, #FF6B6B 0%, #FF8E8E 100%); color: white; border-radius: 10px; margin-bottom: 15px;">
+                    <h4>3단계: AI 분석 진행 중...</h4>
+                    <p>Claude AI가 트렌드 데이터를 분석하고 있습니다. ({ai_elapsed:.1f}초)</p>
+                    <p style="font-size: 14px; opacity: 0.9;">총 경과 시간: {total_elapsed:.1f}초</p>
                 </div>
                 """
                 time.sleep(0.5)
             
             analysis_result = ai_future.result()
         
+        ai_time = time.time() - ai_start_time
         total_time = time.time() - start_time
         
-        # 최종 결과
+        # 8단계: 최종 결과 출력
         yield f"""
         <div style="text-align: center; padding: 15px; background: linear-gradient(135deg, #4CAF50 0%, #45a049 100%); color: white; border-radius: 10px; margin-bottom: 20px;">
-            <h3>스마트 분석 완료 ({total_time:.1f}초)</h3>
-            <p><strong>사용 방법:</strong> {automator.method.upper() if automator.method else '대체방법'} | <strong>설정:</strong> {region} | {period} | {category}</p>
+            <h3> 분석 완료!</h3>
+            <p><strong>설정:</strong> {region} | {period} | {category}</p>
+            <p>모든 단계가 성공적으로 완료되었습니다.</p>
         </div>
         
         {analysis_result}
         
         <div style="margin-top: 20px; padding: 15px; background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); color: white; border-radius: 10px; text-align: center;">
             <p style="margin: 0; font-size: 14px;">
-                <strong>스마트 분석의 장점</strong><br>
-                여러 방법을 자동으로 시도하여 환경에 관계없이 최적의 결과 제공
+                 <strong>다른 설정으로 다시 분석하시겠습니까?</strong><br>
+                위의 설정을 변경하고 다시 버튼을 클릭하세요!
             </p>
         </div>
         
         <div style="margin-top: 15px; padding: 10px; background-color: #f9f9f9; border-radius: 5px; font-size: 12px; color: #666; text-align: center;">
-            <p style="margin: 5px 0;"><strong>사용된 방법:</strong> {automator.method.upper() if automator.method else '대체방법'}</p>
-            <p style="margin: 5px 0;"><strong>총 분석 시간:</strong> {total_time:.1f}초</p>
-            <p style="margin: 5px 0;"><strong>환경:</strong> {"Hugging Face Space" if IS_HUGGINGFACE else "로컬"}</p>
+            <p style="margin: 5px 0;"> <strong>분석 완료 시간:</strong> 약 15-30초</p>
+            <p style="margin: 5px 0;"> <strong>AI 엔진:</strong> Claude 3.5 Sonnet</p>
+            <p style="margin: 5px 0;"> <strong>데이터 출처:</strong> Google Trends 실시간 스크린샷</p>
         </div>
         """
         
-        print(f"스마트 분석 완료: {total_time:.1f}초, 방법: {automator.method}")
+        print("전체 분석 프로세스 완료!")
         
     except Exception as e:
         error_details = traceback.format_exc()
-        print(f"스마트 분석 중 예외 발생: {e}")
+        print(f"메인 분석 중 예외 발생: {e}")
         
         yield f"""
         <div style="color: red; padding: 20px; border: 1px solid red; border-radius: 5px;">
-            <h3>스마트 분석 오류</h3>
+            <h3>오류 발생</h3>
             <p><strong>오류:</strong> {str(e)}</p>
             <details>
-                <summary>상세 오류 정보</summary>
+                <summary>상세 오류 정보 (클릭하여 펼치기)</summary>
                 <pre style="background-color: #f5f5f5; padding: 10px; margin-top: 10px; overflow-x: auto; font-size: 11px;">
 {error_details}
                 </pre>
@@ -737,12 +717,12 @@ def smart_analysis(region: str, period: str, category: str):
         </div>
         """
 
-def create_smart_interface():
-    """스마트 Gradio 인터페이스"""
+# Gradio 인터페이스 (실시간 스트리밍 형태로)
+def create_interface():
     
     with gr.Blocks(
         theme=gr.themes.Soft(),
-        title="스마트 Google Trends 분석기",
+        title="Google Trends 실시간 분석기",
         css="""
         .gradio-container {
             max-width: 1200px !important;
@@ -753,114 +733,126 @@ def create_smart_interface():
         """
     ) as interface:
         
+        # Header
         gr.HTML("""
         <div style="text-align: center; padding: 20px; background: linear-gradient(90deg, #667eea 0%, #764ba2 100%); color: white; border-radius: 10px; margin-bottom: 20px;">
-            <h1>스마트 Google Trends 분석기</h1>
-            <p><strong>다중 방법 지원:</strong> Playwright → Selenium → 대체 방법 자동 선택</p>
-            <p style="font-size: 14px; opacity: 0.9;">환경에 관계없이 최적의 결과를 제공합니다</p>
+            <h1>Google Trends 실시간 분석기</h1>
+            <p>Google Trends의 실시간 인기 검색어를 AI가 자동으로 분석합니다</p>
+            <p style="font-size: 14px; opacity: 0.9;">개선된 방식으로 단계별 진행상황을 확인할 수 있습니다.</p>
         </div>
         """)
         
+        # 입력 섹션
         with gr.Row():
             with gr.Column(scale=1):
                 region_input = gr.Dropdown(
                     choices=["대한민국", "전세계", "미국", "일본", "중국"],
                     value="대한민국",
-                    label="지역 선택"
+                    label="지역 선택",
+                    info="분석할 지역을 선택하세요"
                 )
                 
             with gr.Column(scale=1):
                 period_input = gr.Dropdown(
                     choices=["지난 24시간", "지난 1시간", "지난 4시간", "지난 1일", "지난 7일"],
                     value="지난 7일", 
-                    label="기간 선택"
+                    label="기간 선택",
+                    info="트렌드 분석 기간을 선택하세요"
                 )
                 
             with gr.Column(scale=1):
                 category_input = gr.Dropdown(
                     choices=["모든 카테고리", "게임", "건강", "기술", "스포츠", "엔터테인먼트", "뉴스", "비즈니스"],
                     value="모든 카테고리",
-                    label="카테고리 선택"
+                    label="카테고리 선택", 
+                    info="관심 분야를 선택하세요"
                 )
         
+        # 분석 버튼
         analyze_btn = gr.Button(
-            "스마트 분석 시작 (자동 방법 선택)", 
+            "실시간 트렌드 분석 시작 (빠른 스트리밍 모드)", 
             variant="primary",
             size="lg"
         )
         
+        # 진행 상황 및 결과 출력
         output = gr.HTML(
             label="실시간 분석 결과",
             value="""
             <div style="text-align: center; padding: 20px; border: 2px dashed #ccc; border-radius: 10px; color: #666;">
-                <h3>스마트 분석기 대기 중</h3>
-                <p><strong>자동 방법 선택:</strong> 환경에 맞는 최적의 방법을 자동으로 선택</p>
-                <p><strong>지원 방법:</strong> Playwright, Selenium, 대체 방법</p>
-                <p style="font-size: 14px;">위의 설정을 선택하고 버튼을 클릭하세요!</p>
+                <h3>분석 대기 중</h3>
+                <p>위의 설정을 선택하고 '실시간 트렌드 분석 시작' 버튼을 클릭하세요!</p>
+                <p style="font-size: 14px;">개선된 방식으로 <strong>15-30초</strong>만에 분석이 완료됩니다.</p>
             </div>
             """
         )
         
+        # 이벤트 연결 (Generator 함수로 실시간 스트리밍)
         analyze_btn.click(
-            fn=smart_analysis,
+            fn=main_analysis,
             inputs=[region_input, period_input, category_input],
             outputs=output,
-            show_progress="hidden"
+            show_progress="hidden"  # 내장 진행률 표시 숨김 (자체 스트리밍 사용)
         )
         
+        # 사용법 안내
         gr.HTML("""
         <div style="margin-top: 30px; padding: 20px; background: linear-gradient(135deg, #a8edea 0%, #fed6e3 100%); border-radius: 10px;">
-            <h3 style="margin-top: 0; color: #333;">스마트 분석기의 특징</h3>
+            <h3 style="margin-top: 0; color: #333;"> 새로운 기능!</h3>
             <div style="display: grid; grid-template-columns: 1fr 1fr; gap: 20px; color: #555;">
                 <div>
-                    <h4>자동 방법 선택</h4>
+                    <h4> 실시간 스트리밍</h4>
                     <ul style="margin: 0; padding-left: 20px;">
-                        <li>Playwright 우선 시도</li>
-                        <li>실패시 Selenium 시도</li>
-                        <li>최종적으로 대체 방법 사용</li>
+                        <li>브라우저 실행 상태 실시간 표시</li>
+                        <li>설정 변경 과정 단계별 확인</li>
+                        <li>AI 분석 진행상황 표시</li>
                     </ul>
                 </div>
                 <div>
-                    <h4>환경 호환성</h4>
+                    <h4> 속도 최적화</h4>
                     <ul style="margin: 0; padding-left: 20px;">
-                        <li>Hugging Face Space 완벽 지원</li>
-                        <li>로컬 환경 최적화</li>
-                        <li>시스템 제약 자동 해결</li>
+                        <li>대기 시간 단축 </li>
+                        <li>불필요한 로딩 시간 제거</li>
+                        <li>효율적인 데이터 처리</li>
                     </ul>
                 </div>
             </div>
         </div>
         """)
+        
+        # footer
+        gr.HTML("""
+        <div style="text-align: center; margin-top: 20px; padding: 15px; color: #666; border-top: 1px solid #eee;">
+            <p> <strong>사용법:</strong> 원하는 설정을 선택하고 분석 버튼을 클릭하세요</p>
+            <p> <strong>속도:</strong> 점차적으로 개선 예정입니다.</p>
+            <p> <strong>Powered by:</strong> Google Trends + Claude AI + 실시간 스트리밍</p>
+        </div>
+        """)
     
     return interface
 
-# 앱 종료시 리소스 정리
-import atexit
-
-def cleanup_on_exit():
-    """앱 종료시 리소스 정리"""
-    global automator
-    if automator:
-        automator.cleanup()
-        print("앱 종료: 모든 브라우저 리소스 정리 완료")
-
-atexit.register(cleanup_on_exit)
-
+# 메인 실행
 if __name__ == "__main__":
     print("=" * 50)
-    print("스마트 Google Trends 분석기 시작")
+    print("Google Trends 실시간 분석기 시작!")
     print("=" * 50)
     
+    # API 키 확인
     if not ANTHROPIC_API_KEY or ANTHROPIC_API_KEY == "your_api_key_here":
-        print("ANTHROPIC_API_KEY 미설정 - 대체 분석 모드")
+        print(" ANTHROPIC_API_KEY가 설정되지 않음")
+        print("\n 이 상태로도 앱은 실행되지만, 분석 기능은 작동하지 않는다.")
+        print("=" * 50)
     else:
-        print("Claude API 키 확인됨")
+        print(" Claude API 키 확인됨")
     
-    print("스마트 Gradio 인터페이스 준비 중...")
-    app = create_smart_interface()
+    # 인터페이스 생성 및 실행
+    print(" Gradio 웹 인터페이스 준비 중...")
+    app = create_interface()
     
+    # 환경별 실행 설정
     if os.getenv("SPACE_ID"):
-        print("Hugging Face Space 환경에서 실행")
+        # Hugging Face Space 환경
+        print(" Hugging Face Space 환경에서 실행 중...")
         app.launch(
             server_name="0.0.0.0",
             server_port=7860,
@@ -868,12 +860,25 @@ if __name__ == "__main__":
             show_api=False
         )
     else:
-        print("로컬 서버 시작: http://localhost:7860")
-        app.launch(
-            server_name="127.0.0.1",
-            server_port=7860,
-            show_error=True,
-            show_api=False,
-            share=False,
-            inbrowser=True
-        )
+        # 로컬 환경
+        print(" 로컬 서버 시작 중...")
+        print(" 브라우저에서 http://localhost:7860 으로 접속")
+        print(" 종료하려면 Ctrl+C")
+        print("=" * 50)
+        
+        try:
+            app.launch(
+                server_name="127.0.0.1",
+                server_port=7860,
+                show_error=True,
+                show_api=False,
+                share=False,  # 로컬에서는 공개 링크 비활성화
+                inbrowser=True,  # 자동으로 브라우저 열기
+                quiet=False  # 상세 로그 표시
+            )
+        except KeyboardInterrupt:
+            print("\n\nGoogle Trends 분석기가 종료")
+            print("감사합니다! ")
+        except Exception as e:
+            print(f"\n 서버 실행 중 오류: {e}")
+            print("포트 7860이 이미 사용 중인지 확인")