[fix]

app.py

@@ -3,19 +3,24 @@ import time
 import base64
 import json
 import traceback
-import asyncio
+import threading
 from typing import Tuple, Optional
 import gradio as gr
 import anthropic
-from playwright.async_api import async_playwright
+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, WebDriverException
 from concurrent.futures import ThreadPoolExecutor
-import threading
+from datetime import datetime
 
 # Hugging Face Space 환경 확인
 IS_HUGGINGFACE = os.getenv("SPACE_ID") is not None
 print(f'IS_HUGGINGFACE = {IS_HUGGINGFACE}')
 
-# Claude API 설정 (Hugging Face Secrets에서 가져오기)
+# Claude API 설정
 ANTHROPIC_API_KEY = os.getenv("ANTHROPIC_API_KEY")
 
 if not ANTHROPIC_API_KEY:
@@ -23,34 +28,6 @@ if not ANTHROPIC_API_KEY:
 else:
     print("Claude API 키 확인 완료")
 
-# Playwright 브라우저 설치 (최초 1회)
-async def install_playwright_browsers():
-    if IS_HUGGINGFACE:
-        try:
-            print("Playwright 브라우저 설치 중...")
-            import subprocess
-            result = subprocess.run(["playwright", "install", "chromium"], capture_output=True, text=True)
-            if result.returncode == 0:
-                print("Playwright Chromium 설치 완료")
-                return True
-            else:
-                print(f"Playwright 설치 실패: {result.stderr}")
-                return False
-        except Exception as e:
-            print(f"Playwright 설치 중 오류: {e}")
-            return False
-    return True
-
-# 시작 시 Playwright 브라우저 설치
-if IS_HUGGINGFACE:
-    try:
-        browser_installed = asyncio.run(install_playwright_browsers())
-        if not browser_installed:
-            print("Playwright 브라우저 설치에 실패했지만 계속 진행합니다...")
-    except Exception as e:
-        print(f"Playwright 초기화 오류: {e}")
-
-# Claude 클라이언트를 생성
 def create_claude_client():
     try:
         client = anthropic.Anthropic(api_key=ANTHROPIC_API_KEY)
@@ -60,81 +37,290 @@ def create_claude_client():
         print(f"Claude API 클라이언트 생성 실패: {e}")
         return None
 
-# Google Trends 자동화 클래스 (Playwright 사용)
-class GoogleTrendsAutomator:
+class PersistentGoogleTrendsAutomator:
+    """브라우저를 계속 유지하는 Google Trends 자동화 클래스"""
+    
+    _instance = None
+    _lock = threading.Lock()
+    
+    def __new__(cls):
+        if cls._instance is None:
+            with cls._lock:
+                if cls._instance is None:
+                    cls._instance = super(PersistentGoogleTrendsAutomator, cls).__new__(cls)
+                    cls._instance._initialized = False
+        return cls._instance
+    
     def __init__(self):
-        self.browser = None
-        self.page = None
+        if not self._initialized:
+            self.driver = None
+            self.is_browser_ready = False
+            self.last_used = time.time()
+            self.browser_lock = threading.Lock()
+            self.initialization_lock = threading.Lock()
+            self._initialized = True
+            print("PersistentGoogleTrendsAutomator 싱글톤 인스턴스 생성")
+    
+    def setup_driver(self):
+        """브라우저 드라이버 설정 (최초 1회만)"""
+        with self.initialization_lock:
+            if self.driver is not None and self.is_browser_ready:
+                print("기존 브라우저 재사용")
+                return True
+            
+            print("새 브라우저 인스턴스 생성 중...")
+            
+            options = Options()
+            
+            # Hugging Face Space 환경 설정
+            if IS_HUGGINGFACE:
+                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")
+            
+            # 성능 최적화 설정
+            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=2048")
+            
+            # 이미지/CSS 비활성화
+            prefs = {
+                "profile.managed_default_content_settings.images": 2,
+                "profile.default_content_setting_values.notifications": 2,
+            }
+            options.add_experimental_option("prefs", prefs)
+            
+            # 봇 감지 회피
+            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)
+            
+            # 언어 설정
+            options.add_argument("--lang=ko")
+            options.add_argument("--accept-lang=ko-KR,ko;q=0.9,en;q=0.8")
+            
+            try:
+                # 드라이버 생성
+                if IS_HUGGINGFACE:
+                    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 Exception as e:
+                        print(f"webdriver-manager 실패: {e}")
+                        self.driver = webdriver.Chrome(options=options)
+                        print("시스템 ChromeDriver 사용")
+                else:
+                    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)
+                    except:
+                        self.driver = webdriver.Chrome(options=options)
+                
+                # 타임아웃 설정
+                self.driver.set_page_load_timeout(20)
+                self.driver.implicitly_wait(3)
+                
+                # Google Trends 페이지 최초 로딩
+                print("Google Trends 페이지 최초 로딩 중...")
+                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"))
+                )
+                
+                # 봇 감지 방지 스크립트
+                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}")
+                
+                self.is_browser_ready = True
+                self.last_used = time.time()
+                print("브라우저 초기화 완료 및 페이지 로딩 성공")
+                return True
+                
+            except Exception as e:
+                print(f"드라이버 설정 실패: {e}")
+                self.cleanup_driver()
+                return False
+    
+    def cleanup_driver(self):
+        """브라우저 정리"""
+        try:
+            if self.driver:
+                self.driver.quit()
+                print("브라우저 종료")
+        except:
+            pass
+        finally:
+            self.driver = None
+            self.is_browser_ready = False
     
-    # Playwright 브라우저 설정
-    async def setup_browser(self, progress_callback=None):
+    def check_browser_health(self):
+        """브라우저 상태 확인 및 필요시 복구"""
         try:
-            if progress_callback:
-                progress_callback("Playwright 브라우저 초기화 중...")
+            if not self.driver:
+                return False
             
-            self.playwright = await async_playwright().start()
+            # 간단한 상태 체크
+            current_url = self.driver.current_url
+            if "trends.google.com" not in current_url:
+                print("브라우저가 잘못된 페이지에 있음, 복구 중...")
+                self.driver.get("https://trends.google.com/trending?geo=KR&hl=ko")
+                time.sleep(2)
             
-            # Chromium 브라우저 실행
-            self.browser = await self.playwright.chromium.launch(
-                headless=True,
-                args=[
-                    "--no-sandbox",
-                    "--disable-dev-shm-usage",
-                    "--disable-gpu",
-                    "--disable-software-rasterizer",
-                    "--memory-pressure-off",
-                    "--disable-background-timer-throttling",
-                    "--disable-backgrounding-occluded-windows",
-                    "--disable-renderer-backgrounding",
-                    "--disable-features=TranslateUI",
-                    "--disable-ipc-flooding-protection",
-                    "--disable-web-security",
-                    "--lang=ko",
-                    "--accept-lang=ko-KR,ko;q=0.9,en"
-                ]
-            )
+            return True
             
-            # 새 페이지 생성
-            self.page = await self.browser.new_page()
+        except WebDriverException as e:
+            print(f"브라우저 상태 확인 실패: {e}")
+            return False
+    
+    def refresh_and_wait(self):
+        """페이지 새로고침 및 대기 (빠른 데이터 갱신)"""
+        try:
+            print("페이지 새로고침으로 최신 데이터 갱신...")
+            self.driver.refresh()
             
-            # 이미지 차단으로 속도 향상
-            await self.page.route("**/*.{png,jpg,jpeg,gif,webp,svg,ico}", lambda route: route.abort())
+            # 최소한의 로딩 대기
+            time.sleep(2)
             
-            # User Agent 설정
-            await self.page.set_extra_http_headers({
-                "Accept-Language": "ko-KR,ko;q=0.9,en;q=0.8"
-            })
+            # 페이지 준비 확인
+            WebDriverWait(self.driver, 5).until(
+                EC.presence_of_element_located((By.TAG_NAME, "button"))
+            )
             
-            print("Playwright 브라우저 초기화 성공")
             return True
             
         except Exception as e:
-            print(f"Playwright 브라우저 설정 실패: {e}")
+            print(f"페이지 새로고침 실패: {e}")
             return False
     
-    # 안전한 클릭
-    async def safe_click(self, selectors: list, timeout: int = 3000) -> bool:
-        for selector in selectors:
+    def safe_find_element(self, selectors: list, timeout: int = 3):
+        """안전한 요소 찾기"""
+        for selector_type, selector in selectors:
             try:
-                await self.page.click(selector, timeout=timeout)
-                return True
+                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:
+                self.driver.execute_script("arguments[0].click();", element)
+                return True
+            except:
+                try:
+                    element.click()
+                    return True
+                except:
+                    return False
         return False
     
-    # 지역 변경
-    async def change_region(self, target_region: str) -> bool:
+    def change_settings_fast(self, region: str, period: str, category: str, progress_callback=None) -> dict:
+        """빠른 설정 변경 (기존 브라우저 활용)"""
+        results = {
+            'region': False,
+            'period': False, 
+            'category': False,
+            'errors': []
+        }
+        
+        try:
+            # 설정 변경 전 페이지 새로고침으로 최신 상태 확보
+            self.refresh_and_wait()
+            
+            if region != "대한민국":
+                if progress_callback:
+                    progress_callback(f"지역을 {region}으로 변경 중...")
+                results['region'] = self.change_region(region)
+                time.sleep(0.5)
+            else:
+                results['region'] = True
+                
+            if period != "지난 24시간":
+                if progress_callback:
+                    progress_callback(f"기간을 {period}로 변경 중...")
+                results['period'] = self.change_time_period(period)
+                time.sleep(0.5)
+            else:
+                results['period'] = True
+                
+            if category != "모든 카테고리":
+                if progress_callback:
+                    progress_callback(f"카테고리를 {category}로 변경 중...")
+                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 change_region(self, target_region: str) -> bool:
+        """지역 변경"""
         try:
             region_selectors = [
-                "button[aria-label*='위치 선택']",
-                "button[aria-label*='대한민국']",
-                "span:has-text('대한민국') >> xpath=.."
+                ("xpath", "//button[@aria-label='대한민국, 위치 선택']"),
+                ("xpath", "//button[contains(@aria-label, '위치 선택')]"),
+                ("xpath", "//span[contains(text(), '대한민국')]//parent::button"),
             ]
             
-            if not await self.safe_click(region_selectors):
+            if not self.safe_click(region_selectors):
                 return False
             
-            await self.page.wait_for_timeout(1000)
+            time.sleep(1)
             
             region_mapping = {
                 "전세계": ["전 세계", "Worldwide"],
@@ -146,12 +332,11 @@ class GoogleTrendsAutomator:
             if target_region in region_mapping:
                 for region_text in region_mapping[target_region]:
                     region_option_selectors = [
-                        f"span:has-text('{region_text}')",
-                        f"text={region_text}",
-                        f"*:has-text('{region_text}')"
+                        ("xpath", f"//span[contains(text(), '{region_text}')]"),
+                        ("xpath", f"//*[contains(text(), '{region_text}')]"),
                     ]
                     
-                    if await self.safe_click(region_option_selectors, timeout=2000):
+                    if self.safe_click(region_option_selectors, timeout=2):
                         return True
             
             return False
@@ -160,18 +345,18 @@ class GoogleTrendsAutomator:
             print(f"지역 변경 실패: {e}")
             return False
     
-    # 기간 변경
-    async def change_time_period(self, target_period: str) -> bool:
+    def change_time_period(self, target_period: str) -> bool:
+        """기간 변경"""
         try:
             period_selectors = [
-                "button[aria-label*='기간 선택']",
-                "span:has-text('지난 24시간') >> xpath=.."
+                ("xpath", "//button[contains(@aria-label, '기간 선택')]"),
+                ("xpath", "//span[contains(text(), '지난 24시간')]//parent::button"),
             ]
             
-            if not await self.safe_click(period_selectors):
+            if not self.safe_click(period_selectors):
                 return False
                 
-            await self.page.wait_for_timeout(1000)
+            time.sleep(1)
             
             period_mapping = {
                 "지난 1시간": ["지난 1시간"],
@@ -183,12 +368,11 @@ class GoogleTrendsAutomator:
             if target_period in period_mapping:
                 for period_text in period_mapping[target_period]:
                     period_option_selectors = [
-                        f"span:has-text('{period_text}')",
-                        f"text={period_text}",
-                        f"*:has-text('{period_text}')"
+                        ("xpath", f"//span[contains(text(), '{period_text}')]"),
+                        ("xpath", f"//*[contains(text(), '{period_text}')]"),
                     ]
                     
-                    if await self.safe_click(period_option_selectors, timeout=2000):
+                    if self.safe_click(period_option_selectors, timeout=2):
                         return True
             
             return False
@@ -197,18 +381,18 @@ class GoogleTrendsAutomator:
             print(f"기간 변경 실패: {e}")
             return False
     
-    # 카테고리 변경
-    async def change_category(self, target_category: str) -> bool:
+    def change_category(self, target_category: str) -> bool:
+        """카테고리 변경"""
         try:
             category_selectors = [
-                "button[aria-label*='카테고리 선택']",
-                "span:has-text('모든 카테고리') >> xpath=.."
+                ("xpath", "//button[contains(@aria-label, '카테고리 선택')]"),
+                ("xpath", "//span[contains(text(), '모든 카테고리')]//parent::button"),
             ]
             
-            if not await self.safe_click(category_selectors):
+            if not self.safe_click(category_selectors):
                 return False
                 
-            await self.page.wait_for_timeout(1000)
+            time.sleep(1)
             
             category_mapping = {
                 "게임": ["게임"],
@@ -223,12 +407,11 @@ class GoogleTrendsAutomator:
             if target_category in category_mapping:
                 for category_text in category_mapping[target_category]:
                     category_option_selectors = [
-                        f"span:has-text('{category_text}')",
-                        f"text={category_text}",
-                        f"*:has-text('{category_text}')"
+                        ("xpath", f"//span[contains(text(), '{category_text}')]"),
+                        ("xpath", f"//*[contains(text(), '{category_text}')]"),
                     ]
                     
-                    if await self.safe_click(category_option_selectors, timeout=2000):
+                    if self.safe_click(category_option_selectors, timeout=2):
                         return True
             
             return False
@@ -237,107 +420,87 @@ class GoogleTrendsAutomator:
             print(f"카테고리 변경 실패: {e}")
             return False
     
-    # Google Trends 캡처
-    async def capture_trends(self, region: str, period: str, category: str, progress_callback=None) -> Tuple[Optional[str], bool, str]:
-        error_msg = ""
+    def capture_trends_fast(self, region: str, period: str, category: str, progress_callback=None) -> Tuple[Optional[str], bool, str]:
+        """빠른 트렌드 캡처 (브라우저 재사용)"""
         
-        try:
-            if progress_callback:
-                progress_callback("브라우저 초기화 중...")
-            
-            # 브라우저 설정
-            if not await self.setup_browser(progress_callback):
-                return None, False, "브라우저 설정 실패"
-            
-            if progress_callback:
-                progress_callback("Google Trends 페이지 접속 중...")
-            
-            # Google Trends 접속
-            await self.page.goto("https://trends.google.com/trending?geo=KR&hl=ko", wait_until="domcontentloaded")
-            
-            # 로딩 대기
-            wait_time = 4000 if IS_HUGGINGFACE else 2000
-            await self.page.wait_for_timeout(wait_time)
-            
-            if progress_callback:
-                progress_callback("페이지 로딩 완료, 설정 변경 시작...")
+        with self.browser_lock:  # 동시 접근 방지
+            error_msg = ""
             
-            # 페이지 준비 확인
             try:
-                await self.page.wait_for_selector("button", timeout=10000)
-            except:
-                pass
-            
-            # 설정 변경
-            changes_made = []
-            
-            if region != "대한민국":
-                if progress_callback:
-                    progress_callback(f"지역을 {region}으로 변경 중...")
-                if await self.change_region(region):
-                    changes_made.append(f"지역: {region}")
-                    await self.page.wait_for_timeout(500)
+                # 브라우저 상태 확인
+                if not self.is_browser_ready or not self.check_browser_health():
+                    if progress_callback:
+                        progress_callback("브라우저 초기화 중... (최초 실행시만)")
+                    
+                    if not self.setup_driver():
+                        return None, False, "브라우저 드라이버 설정 실패"
                 else:
-                    error_msg += f"지역 변경 실패 ({region})\n"
-            
-            if period != "지난 24시간":
+                    if progress_callback:
+                        progress_callback("기존 브라우저 재사용 중...")
+                
+                # 설정 변경
                 if progress_callback:
-                    progress_callback(f"기간을 {period}으로 변경 중...")
-                if await self.change_time_period(period):
+                    progress_callback("설정 변경 및 데이터 갱신 중...")
+                
+                settings_result = self.change_settings_fast(region, period, category, progress_callback)
+                
+                # 결과 확인
+                changes_made = []
+                if settings_result['region']:
+                    changes_made.append(f"지역: {region}")
+                if settings_result['period']:
                     changes_made.append(f"기간: {period}")
-                    await self.page.wait_for_timeout(500)
-                else:
-                    error_msg += f"기간 변경 실패 ({period})\n"
-            
-            if category != "모든 ���테고리":
-                if progress_callback:
-                    progress_callback(f"카테고리를 {category}로 변경 중...")
-                if await self.change_category(category):
+                if settings_result['category']:
                     changes_made.append(f"카테고리: {category}")
-                    await self.page.wait_for_timeout(500)
-                else:
-                    error_msg += f"카테고리 변경 실패 ({category})\n"
-            
-            if progress_callback:
-                progress_callback("설정 변경 완료, 스크린샷 촬영 중...")
-            
-            # 최종 로딩 대기
-            await self.page.wait_for_timeout(2000 if IS_HUGGINGFACE else 1000)
-            
-            # 스크린샷 촬영
-            screenshot = await self.page.screenshot(full_page=False)
-            screenshot_b64 = base64.b64encode(screenshot).decode()
-            
-            success_msg = f"설정 완료: {', '.join(changes_made) if changes_made else '기본 설정 사용'}"
-            
-            return screenshot_b64, True, success_msg + ("\n" + error_msg if error_msg else "")
-            
-        except Exception as e:
-            error_msg = f"오류 발생: {str(e)}"
-            return None, False, error_msg
-            
-        finally:
-            if self.browser:
-                try:
-                    await self.browser.close()
-                    await self.playwright.stop()
-                except:
-                    pass
+                
+                if settings_result['errors']:
+                    error_msg = "\n".join(settings_result['errors'])
+                
+                if progress_callback:
+                    progress_callback("최신 데이터 로딩 완료, 스크린샷 캡처 중...")
+                
+                # 최종 데이터 로딩 대기
+                time.sleep(1)
+                
+                # 스크린샷 촬영
+                screenshot = self.driver.get_screenshot_as_png()
+                screenshot_b64 = base64.b64encode(screenshot).decode()
+                
+                # 사용 시간 업데이트
+                self.last_used = time.time()
+                
+                success_msg = f"설정 완료: {', '.join(changes_made) if changes_made else '기본 설정 사용'}"
+                
+                return screenshot_b64, True, success_msg + ("\n" + error_msg if error_msg else "")
+                
+            except Exception as e:
+                error_msg = f"오류 발생: {str(e)}"
+                # 오류 발생시 브라우저 재시작 시도
+                print(f"오류로 인한 브라우저 재시작: {e}")
+                self.cleanup_driver()
+                return None, False, error_msg
+
+# 글로벌 자동화 인스턴스 (싱글톤)
+automator_instance = None
+
+def get_automator():
+    """자동화 인스턴스 가져오기"""
+    global automator_instance
+    if automator_instance is None:
+        automator_instance = PersistentGoogleTrendsAutomator()
+    return automator_instance
 
-# 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 """
             <div style="color: red; padding: 20px; border: 1px solid red; border-radius: 5px;">
                 <h3>API 키 오류</h3>
                 <p><strong>ANTHROPIC_API_KEY가 설정되지 않았습니다!</strong></p>
-                <p>Hugging Face Space Settings에서 Secret을 추가해주세요.</p>
             </div>
             """
         
-        # Claude 클라이언트 생성
         claude_client = create_claude_client()
         
         if claude_client is None:
@@ -348,7 +511,6 @@ def analyze_with_claude(screenshot_b64: str, region: str, period: str, category:
             </div>
             """
         
-        # 간결한 프롬프트 (속도 최적화)
         prompt = f"""
 이 Google Trends 스크린샷을 분석해주세요.
 설정: {region} | {period} | {category}
@@ -358,11 +520,10 @@ 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,
@@ -397,23 +558,16 @@ HTML 형태로 깔끔하게 정리하고, 이모지를 사용하지 않고 시
         </div>
         """
 
-# 동기 래퍼 함수
-def run_async_capture(region: str, period: str, category: str, progress_callback=None):
-    automator = GoogleTrendsAutomator()
-    return asyncio.run(automator.capture_trends(region, period, category, progress_callback))
-
-def main_analysis(region: str, period: str, category: str):
-    # 실시간 스트리밍 분석 함수 (Generator)
+def persistent_browser_analysis(region: str, period: str, category: str):
+    """브라우저 재사용 분석 함수"""
     
     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 style="font-size: 12px; opacity: 0.8;">Hugging Face Space 환경에서 실행 중</p>' if IS_HUGGINGFACE else ''}
+        <p>첫 실행: 15-20초 | 이후 실행: 5-10초</p>
     </div>
     """
     
@@ -423,37 +577,32 @@ def main_analysis(region: str, period: str, category: str):
         progress_status["current"] = message
     
     try:
-        # 2단계: API 키 확인
+        # 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>
+            <div style="color: orange; padding: 20px; border: 1px solid orange; border-radius: 5px;">
+                <h3>API 키 누락 - 스크린샷만 캡처</h3>
                 <p><strong>ANTHROPIC_API_KEY가 설정되지 않았습니다!</strong></p>
-                <p><strong>해결 방법:</strong> Hugging Face Space Settings에서 Secret을 추가해주세요.</p>
             </div>
             """
-            return
         
-        # 3단계: 브라우저 실행 알림
+        # 자동화 인스턴스 가져오기
+        automator = get_automator()
+        
+        # 첫 실행인지 확인
+        is_first_run = not automator.is_browser_ready
+        
         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>Connect Start...</p>
-        </div>
-        
-        <div style="padding: 15px; background-color: #f8f9fa; border-radius: 5px; margin-bottom: 15px;">
-            <p><strong>진행 중:</strong> 브라우저 드라이버 설정 및 페이지 로딩...</p>
-            {'<p style="font-size: 12px; color: #666;">Playwright 브라우저 초기화 중...</p>' if IS_HUGGINGFACE else ''}
+            <h4>1단계: {"브라우저 초기화" if is_first_run else "기존 브라우저 재사용"}</h4>
+            <p>{"최초 실행이므로 브라우저를 새로 시작합니다" if is_first_run else "이미 실행 중인 브라우저를 재사용합니다"}</p>
         </div>
         """
         
-        # 4단계: Google Trends 자동화 실행
-        print(f"분석 시작: {region} | {period} | {category}")
-        
         # 브라우저 작업을 별도 스레드에서 실행
         with ThreadPoolExecutor(max_workers=1) as executor:
             future = executor.submit(
-                run_async_capture, 
+                automator.capture_trends_fast, 
                 region, period, category, progress_callback
             )
             
@@ -464,13 +613,9 @@ def main_analysis(region: str, period: str, category: str):
                     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>Playwright 브라우저에서 Google Trends 데이터 수집 중...</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>
+                        <h4>1단계: {"브라우저 초기화" if is_first_run else "기존 브라우저 재사용"}</h4>
+                        <p>{current_progress}</p>
+                        <p>경과 시간: {elapsed:.1f}초</p>
                     </div>
                     """
                 time.sleep(0.5)
@@ -483,90 +628,105 @@ def main_analysis(region: str, period: str, category: str):
         if not success:
             yield f"""
             <div style="color: red; padding: 20px; border: 1px solid red; border-radius: 5px;">
-                <h3>Google Trends 접속 실패</h3>
+                <h3>Google Trends 캡처 실패</h3>
                 <pre style="background-color: #fff5f5; padding: 15px; border-radius: 5px; margin: 15px 0;">
 {status_msg}
                 </pre>
-                <p><strong>해결 방법:</strong></p>
-                <ul>
-                    <li>Playwright 브라우저 설치 확인</li>
-                    <li>Space를 재시작해보세요</li>
-                    <li>잠시 후 다시 시도해보세요</li>
-                </ul>
             </div>
             """
             return
         
-        # AI 분석 시작
+        # 2단계: 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단계: 입력하신 데이터를 확인했고, 조건에 맞는 데이터를 가져옵니다...</h4>
-            <p>Google Trends 데이터를 성공적으로 캡처했습니다. ({browser_time:.1f}초)</p>
+            <h4>1단계 완료: 스크린샷 캡처 성공 ({browser_time:.1f}초)</h4>
+            <p>{status_msg}</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>3단계: AI 분석 진행 중...</h4>
-            <p>Claude AI가 트렌드 데이터를 분석하고 있습니다.</p>
-            <p style="font-size: 14px; opacity: 0.9;">약 10-20초 소요 예상</p>
+            <h4>2단계: Claude AI 분석 중...</h4>
+            <p>트렌드 데이터를 분석하고 있습니다</p>
         </div>
         """
         
-        # Claude 분석
-        print("실시간 인기 검색어 데이터를 가져왔고, Claude 분석 시작합니다...")
-        analysis_result = analyze_with_claude(screenshot_b64, region, period, category)
+        # AI 분석 실행
+        ai_start_time = time.time()
+        
+        with ThreadPoolExecutor(max_workers=1) as executor:
+            ai_future = executor.submit(
+                analyze_with_claude, 
+                screenshot_b64, region, period, category
+            )
+            
+            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>1단계 완료: 스크린샷 캡처 성공 ({browser_time:.1f}초)</h4>
+                    <p>{status_msg}</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단계: Claude AI 분석 중... ({ai_elapsed:.1f}초)</h4>
+                    <p>총 경과 시간: {total_elapsed:.1f}초</p>
+                </div>
+                """
+                time.sleep(0.5)
+            
+            analysis_result = ai_future.result()
         
         total_time = 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: 20px;">
-            <h3>분석 완료!</h3>
-            <p><strong>설정:</strong> {region} | {period} | {category}</p>
-            <p><strong>총 소요 시간:</strong> {total_time:.1f}초</p>
+            <h3>분석 완료 ({total_time:.1f}초)</h3>
+            <p><strong>성능:</strong> {"첫 실행" if is_first_run else "브라우저 재사용"} | <strong>설정:</strong> {region} | {period} | {category}</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>
+                브라우저가 이미 실행 중이므로 5-10초만에 완료됩니다
             </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> {'Hugging Face Space (Playwright)' if IS_HUGGINGFACE else 'Local'}</p>
-            <p style="margin: 5px 0;"><strong>AI 엔진:</strong> Claude 3.5 Sonnet</p>
-            <p style="margin: 5px 0;"><strong>데이터 출처:</strong> Google Trends 실시간 스크린샷</p>
+            <p style="margin: 5px 0;"><strong>브라우저 상태:</strong> {"새로 시작됨" if is_first_run else "재사용됨"}</p>
+            <p style="margin: 5px 0;"><strong>분석 시간:</strong> {total_time:.1f}초</p>
+            <p style="margin: 5px 0;"><strong>다음 예상 시간:</strong> 5-10초</p>
         </div>
         """
         
-        print(f"전체 분석 프로세스 완료! 총 {total_time:.1f}초")
+        print(f"브라우저 재사용 분석 완료: {total_time:.1f}초")
         
     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>
             <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>
             </details>
-            <p><strong>해결 방법:</strong> Space를 재시작하고 다시 시도하세요.</p>
+            <p><strong>해결 방법:</strong> 페이지를 새로고침하고 다시 시도하세요.</p>
         </div>
         """
 
-# Gradio 인터페이스 (실시간 스트리밍 형태로)
-def create_interface():
+def create_persistent_interface():
+    """브라우저 재사용 Gradio 인터페이스"""
     
     with gr.Blocks(
         theme=gr.themes.Soft(),
-        title="Google Trends 실시간 분석기",
+        title="브라우저 재사용 Google Trends 분석기",
         css="""
         .gradio-container {
             max-width: 1200px !important;
@@ -577,142 +737,114 @@ def create_interface():
         """
     ) as interface:
         
-        # Header
-        gr.HTML(f"""
+        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>Google Trends의 실시간 인기 검색어를 AI가 자동으로 분석합니다</p>
-            <p style="font-size: 14px; opacity: 0.9;">개선된 방식으로 단계별 진행상황을 확인할 수 있습니다.</p>
-            {'<p style="font-size: 12px; opacity: 0.7;">Hugging Face Space (Playwright 브라우저)</p>' if IS_HUGGINGFACE else ''}
+            <h1>브라우저 재사용 Google Trends 분석기</h1>
+            <p><strong>혁신적 성능 개선:</strong> 브라우저를 계속 켜두고 재사용하여 속도 향상</p>
+            <p style="font-size: 14px; opacity: 0.9;">첫 실행: 15-20초 | 이후 실행: 5-10초</p>
         </div>
         """)
         
-        # API 키 상태 표시
-        if not ANTHROPIC_API_KEY:
-            gr.HTML("""
-            <div style="color: red; padding: 15px; border: 1px solid red; border-radius: 5px; margin-bottom: 20px;">
-                <h3>설정 필요</h3>
-                <p><strong>ANTHROPIC_API_KEY가 설정되지 않았습니다!</strong></p>
-                <p>Hugging Face Space Settings에서 Secret을 추가해주세요.</p>
-            </div>
-            """)
-        
-        # 입력 섹션
         with gr.Row():
             with gr.Column(scale=1):
                 region_input = gr.Dropdown(
                     choices=["대한민국", "전세계", "미국", "일본", "중국"],
                     value="대한민국",
-                    label="지역 선택",
-                    info="분석할 지역을 선택하세요"
+                    label="지역 선택"
                 )
                 
             with gr.Column(scale=1):
                 period_input = gr.Dropdown(
                     choices=["지난 24시간", "지난 1시간", "지난 4시간", "지난 1일", "지난 7일"],
                     value="지난 7일", 
-                    label="기간 선택",
-                    info="트렌드 분석 기간을 선택하세요"
+                    label="기간 선택"
                 )
                 
             with gr.Column(scale=1):
                 category_input = gr.Dropdown(
                     choices=["모든 카테고리", "게임", "건강", "기술", "스포츠", "엔터테인먼트", "뉴스", "비즈니스"],
                     value="모든 카테고리",
-                    label="카테고리 선택", 
-                    info="관심 분야를 선택하세요"
+                    label="카테고리 선택"
                 )
         
-        # 분석 버튼
         analyze_btn = gr.Button(
-            "실시간 트렌드 분석 시작 (빠른 스트리밍 모드)", 
+            "브라우저 재사용 분석 시작", 
             variant="primary",
             size="lg"
         )
         
-        # 결과 출력
         output = gr.HTML(
             label="실시간 분석 결과",
-            value=f"""
+            value="""
             <div style="text-align: center; padding: 20px; border: 2px dashed #ccc; border-radius: 10px; color: #666;">
-                <h3>분석 대기 중</h3>
-                <p>위의 설정을 선택하고 '실시간 트렌드 분석 시작' 버튼을 클릭하세요!</p>
-                <p style="font-size: 14px;">개선된 방식으로 <strong>15-30초</strong>만에 분석이 완료됩니다.</p>
-                {'<p style="font-size: 12px; color: #666;">Playwright 브라우저 환경</p>' if IS_HUGGINGFACE else ''}
+                <h3>브라우저 재사용 분석기 대기 중</h3>
+                <p><strong>첫 실행:</strong> 브라우저 초기화로 15-20초 소요</p>
+                <p><strong>이후 실행:</strong> 브라우저 재사용으로 5-10초 완료</p>
+                <p style="font-size: 14px;">위의 설정을 선택하고 버튼을 클릭하세요!</p>
             </div>
             """
         )
         
-        # 이벤트 연결
         analyze_btn.click(
-            fn=main_analysis,
+            fn=persistent_browser_analysis,
             inputs=[region_input, period_input, category_input],
             outputs=output,
             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>브라우저 실행 상태 실시간 표시</li>
-                        <li>설정 변경 과정 단계별 확인</li>
-                        <li>AI 분석 진행상황 표시</li>
+                        <li>두 번째부터 8-15초 단축</li>
+                        <li>브라우저 초기화 시간 제거</li>
+                        <li>페이지 로딩 시간 최소화</li>
                     </ul>
                 </div>
                 <div>
-                    <h4>속도 최적화</h4>
+                    <h4>자원 효율성</h4>
                     <ul style="margin: 0; padding-left: 20px;">
-                        <li>대기 시간 단축</li>
-                        <li>불필요한 로딩 시간 제거</li>
-                        <li>효율적인 데이터 처리</li>
+                        <li>메모리 사용량 최적화</li>
+                        <li>CPU 부하 감소</li>
+                        <li>안정적인 세션 유지</li>
                     </ul>
                 </div>
             </div>
         </div>
         """)
-        
-        # Footer
-        gr.HTML(f"""
-        <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>
-            {'<p style="font-size: 12px;">Running on Hugging Face Spaces with Playwright Browser</p>' if IS_HUGGINGFACE else ''}
-        </div>
-        """)
     
     return interface
 
-# 메인 실행
+# 앱 종료시 브라우저 정리
+import atexit
+
+def cleanup_on_exit():
+    """앱 종료시 브라우저 정리"""
+    global automator_instance
+    if automator_instance:
+        automator_instance.cleanup_driver()
+        print("앱 종료: 브라우저 정리 완료")
+
+atexit.register(cleanup_on_exit)
+
 if __name__ == "__main__":
     print("=" * 50)
-    print("Google Trends 실시간 분석기 시작!")
-    print(f"실행 환경: {'Hugging Face Space' if IS_HUGGINGFACE else 'Local'}")
+    print("브라우저 재사용 Google Trends 분석기 시작")
     print("=" * 50)
     
-    # API 키 확인
     if not ANTHROPIC_API_KEY or ANTHROPIC_API_KEY == "your_api_key_here":
-        print("ANTHROPIC_API_KEY가 설정되지 않음")
-        if IS_HUGGINGFACE:
-            print("Hugging Face Space Settings에서 Secret을 추가해주세요!")
-        print("이 상태로도 앱은 실행되지만, 분석 기능은 작동하지 않습니다.")
-        print("=" * 50)
+        print("ANTHROPIC_API_KEY 미설정 - 스크린샷만 캡처")
     else:
         print("Claude API 키 확인됨")
     
-    # 인터페이스 생성 및 실행
-    print("Gradio 웹 인터페이스 준비 중...")
-    app = create_interface()
+    print("브라우저 재사용 Gradio 인터페이스 준비 중...")
+    app = create_persistent_interface()
     
-    # 환경별 실행 설정
     if os.getenv("SPACE_ID"):
-        # Hugging Face Space 환경
-        print("Hugging Face Space 환경에서 실행 중...")
+        print("Hugging Face Space 환경에서 실행")
         app.launch(
             server_name="0.0.0.0",
             server_port=7860,
@@ -720,914 +852,12 @@ if __name__ == "__main__":
             show_api=False
         )
     else:
-        # 로컬 환경
-        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이 이미 사용 중인지 확인")
-
-
-
-
-
-# import os
-# import time
-# import base64
-# import json
-# import traceback
-# 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
-# import threading
-
-# # Hugging Face Space 환경 확인
-# IS_HUGGINGFACE = os.getenv("SPACE_ID") is not None
-# print(f'IS_HUGGINGFACE = {IS_HUGGINGFACE}')
-
-# # Claude API 설정 (Hugging Face Secrets에서 가져오기)
-# ANTHROPIC_API_KEY = os.getenv("ANTHROPIC_API_KEY")
-
-# if not ANTHROPIC_API_KEY:
-#     print("ANTHROPIC_API_KEY가 설정되지 않음, Secret 확인 필요")
-# else:
-#     print("Claude API 키 확인 완료")
-
-# # Claude 클라이언트를 생성
-# def create_claude_client():
-#     try:
-#         client = anthropic.Anthropic(api_key=ANTHROPIC_API_KEY)
-#         print("Claude API 클라이언트 생성 성공")
-#         return client
-#     except Exception as e:
-#         print(f"Claude API 클라이언트 생성 실패: {e}")
-#         return None
-
-# # Google Trends 자동화 클래스
-# class GoogleTrendsAutomator:
-#     def __init__(self):
-#         self.driver = None
-    
-#     # Chrome 드라이버 설정
-#     def setup_driver(self):
-#         options = Options()
-        
-#         # Hugging Face Space 환경 설정
-#         if IS_HUGGINGFACE:
-#             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 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)
-        
-#         # 봇 감지 회피
-#         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)
-        
-#         # 언어 설정
-#         options.add_argument("--lang=ko")
-#         options.add_argument("--accept-lang=ko-KR,ko;q=0.9,en;q=0.8")
-        
-#         try:
-#             # 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:
-#                 # 로컬 환경
-#                 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 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}")
-            
-#             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
-    
-#     # 병렬로 설정 변경 시도
-#     def parallel_change_settings(self, region: str, period: str, category: str, progress_callback=None) -> dict:
-#         results = {
-#             'region': False,
-#             'period': False, 
-#             'category': False,
-#             'errors': []
-#         }
-        
-#         # 순차적으로 변경 (병렬은 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 change_region(self, target_region: str) -> bool:
-#         try:
-#             region_selectors = [
-#                 ("xpath", "//button[@aria-label='대한민국, 위치 선택']"),
-#                 ("xpath", "//button[contains(@aria-label, '위치 선택')]"),
-#                 ("xpath", "//span[contains(text(), '대한민국')]//parent::button"),
-#             ]
-            
-#             if not self.safe_click(region_selectors):
-#                 return False
-            
-#             time.sleep(1)  # 대기 시간 단축
-            
-#             region_mapping = {
-#                 "전세계": ["전 세계", "Worldwide"],
-#                 "미국": ["미국", "United States"],
-#                 "일본": ["일본", "Japan"],
-#                 "중국": ["중국", "China"]
-#             }
-            
-#             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
-            
-#             return False
-            
-#         except Exception as e:
-#             print(f"지역 변경 실패: {e}")
-#             return False
-    
-#     # 기간 변경
-#     def change_time_period(self, target_period: str) -> bool:
-#         try:
-#             period_selectors = [
-#                 ("xpath", "//button[contains(@aria-label, '기간 선택')]"),
-#                 ("xpath", "//span[contains(text(), '지난 24시간')]//parent::button"),
-#             ]
-            
-#             if not self.safe_click(period_selectors):
-#                 return False
-                
-#             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
-            
-#             return False
-            
-#         except Exception as e:
-#             print(f"기간 변경 실패: {e}")
-#             return False
-    
-#     # 카테고리 변경
-#     def change_category(self, target_category: str) -> bool:
-#         try:
-#             category_selectors = [
-#                 ("xpath", "//button[contains(@aria-label, '카테고리 선택')]"),
-#                 ("xpath", "//span[contains(text(), '모든 카테고리')]//parent::button"),
-#             ]
-            
-#             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}")
-#             return 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 progress_callback:
-#                 progress_callback("브라우저 드라이버 초기화 중...")
-            
-#             # 드라이버 설정
-#             if not self.setup_driver():
-#                 return None, False, "브라우저 드라이버 설정 실패"
-            
-#             if progress_callback:
-#                 progress_callback("Google Trends 페이지 접속 중...")
-            
-#             # Google Trends 접속 (한국어 직접 URL)
-#             self.driver.get("https://trends.google.com/trending?geo=KR&hl=ko")
-            
-#             # 최소한의 로딩 대기 (1초로 단축)
-#             time.sleep(1)
-            
-#             if progress_callback:
-#                 progress_callback("페이지 로딩 완료, 설정 변경 시작...")
-            
-#             # 페이지 준비 확인 (빠른 체크)
-#             try:
-#                 WebDriverWait(self.driver, 5).until(
-#                     EC.presence_of_element_located((By.TAG_NAME, "button"))
-#                 )
-#             except TimeoutException:
-#                 pass  # 계속 진행
-            
-#             # 설정 변경 (병렬 처리)
-#             settings_result = self.parallel_change_settings(region, period, category, progress_callback)
-            
-#             # 결과 확인
-#             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}")
-            
-#             if settings_result['errors']:
-#                 error_msg = "\n".join(settings_result['errors'])
-            
-#             if progress_callback:
-#                 progress_callback("설정 변경 완료, 데이터 가져오는중...")
-            
-#             # 최종 데이터 로딩 대기 (1초로 단축)
-#             time.sleep(1)
-            
-#             # 스크린샷 촬영 (필요한 영역만)
-#             screenshot = self.driver.get_screenshot_as_png()
-#             screenshot_b64 = base64.b64encode(screenshot).decode()
-            
-#             success_msg = f"설정 완료: {', '.join(changes_made) if changes_made else '기본 설정 사용'}"
-            
-#             return screenshot_b64, True, success_msg + ("\n" + error_msg if error_msg else "")
-            
-#         except Exception as e:
-#             error_msg = f"오류 발생: {str(e)}"
-#             return None, False, error_msg
-            
-#         finally:
-#             if self.driver:
-#                 self.driver.quit()
-
-# # Claude API로 스크린샷 분석
-# def analyze_with_claude(screenshot_b64: str, region: str, period: str, category: str) -> str:
-#     try:
-#         # API 키 체크
-#         if not ANTHROPIC_API_KEY or ANTHROPIC_API_KEY == "your_api_key_here":
-#             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 """
-#             <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}
-
-# 다음을 HTML 표 형태로 정확하게 정리해주세요:
-# 1. 실시간 인기 검색어 상위 10개 (순위, 검색어, 검색량, 상승률)
-# 2. 주요 트렌드 키워드 3-5개의 특징 설명
-# 3. 카테고리별 특이사항 (있는 경우)
-
-# HTML 형태로 깔끔하게 정리하고, 이모지를 사용하지 않고 시각적으로 만들어주세요.
-# 한글 텍스트를 정확히 읽어서 분석해주세요.
-# """
-
-#         # Claude API 호출 (빠른 설정)
-#         message = claude_client.messages.create(
-#             model="claude-3-5-sonnet-20241022",
-#             max_tokens=1000,  # 토큰 수 줄여서 속도 향상
-#             messages=[
-#                 {
-#                     "role": "user",
-#                     "content": [
-#                         {
-#                             "type": "text",
-#                             "text": prompt
-#                         },
-#                         {
-#                             "type": "image",
-#                             "source": {
-#                                 "type": "base64",
-#                                 "media_type": "image/png",
-#                                 "data": screenshot_b64
-#                             }
-#                         }
-#                     ]
-#                 }
-#             ]
-#         )
-        
-#         return message.content[0].text
-        
-#     except Exception as e:
-#         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>
-#         """
-
-# 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>
-#         <p><strong>설정:</strong> {region} | {period} | {category}</p>
-#         <p>실시간으로 진행 상황을 업데이트합니다...</p>
-#     </div>
-#     """
-    
-#     progress_status = {"current": ""}
-    
-#     def progress_callback(message):
-#         progress_status["current"] = message
-    
-#     try:
-#         # 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>Connect Start...</p>
-#         </div>
-        
-#         <div style="padding: 15px; background-color: #f8f9fa; border-radius: 5px; margin-bottom: 15px;">
-#             <p> <strong>진행 중:</strong> 브라우저 드라이버 설정 및 페이지 로딩...</p>
-#         </div>
-#         """
-        
-#         # 4단계: Google Trends 자동화 실행
-#         print(f" 분석 시작: {region} | {period} | {category}")
-#         automator = GoogleTrendsAutomator()
-        
-#         # 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>자동화 시작</h4>
-#                 <p>In Running...</p>
-#             </div>
-            
-#             <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>
-#             """
-        
-#         # 브라우저 작업을 별도 스레드에서 실행
-#         with ThreadPoolExecutor(max_workers=1) as executor:
-#             future = executor.submit(
-#                 automator.capture_trends, 
-#                 region, period, category, progress_callback
-#             )
-            
-#             # 진행 상황 업데이트
-#             while not future.done():
-#                 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()
-        
-#         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
-        
-#         # 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단계: 입력하신 데이터를 확인했고, 조건에 맞는 데이터를 가져옵니다...</h4>
-#             <p>Google Trends 데이터를 성공적으로 캡처했습니다.</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>3단계: AI 분석 진행 중...</h4>
-#             <p>Claude AI가 트렌드 데이터를 분석하고 있습니다.</p>
-#             <p style="font-size: 14px; opacity: 0.9;">약 10-20초 소요 예상</p>
-#         </div>
-#         """
-        
-#         # 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단계: 입력하신 데이터를 확인했고, 조건에 맞는 데이터를 가져옵니다...</h4>
-#                     <p>Google Trends 데이터를 성공적으로 캡처했습니다.</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>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> 분석 완료!</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>
-#                 위의 설정을 변경하고 다시 버튼을 클릭하세요!
-#             </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> 약 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("전체 분석 프로세스 완료!")
-        
-#     except Exception as e:
-#         error_details = traceback.format_exc()
-#         print(f"메인 분석 중 예외 발생: {e}")
-        
-#         yield f"""
-#         <div style="color: red; padding: 20px; border: 1px solid red; border-radius: 5px;">
-#             <h3>오류 발생</h3>
-#             <p><strong>오류:</strong> {str(e)}</p>
-#             <details>
-#                 <summary>상세 오류 정보 (클릭하여 펼치기)</summary>
-#                 <pre style="background-color: #f5f5f5; padding: 10px; margin-top: 10px; overflow-x: auto; font-size: 11px;">
-# {error_details}
-#                 </pre>
-#             </details>
-#             <p><strong>해결 방법:</strong> 페이지를 새로고침하고 다시 시도하세요.</p>
-#         </div>
-#         """
-
-# # Gradio 인터페이스 (실시간 스트리밍 형태로)
-# def create_interface():
-    
-#     with gr.Blocks(
-#         theme=gr.themes.Soft(),
-#         title="Google Trends 실시간 분석기",
-#         css="""
-#         .gradio-container {
-#             max-width: 1200px !important;
-#         }
-#         .output-html {
-#             max-height: none !important;
-#         }
-#         """
-#     ) 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>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="지역 선택",
-#                     info="분석할 지역을 선택하세요"
-#                 )
-                
-#             with gr.Column(scale=1):
-#                 period_input = gr.Dropdown(
-#                     choices=["지난 24시간", "지난 1시간", "지난 4시간", "지난 1일", "지난 7일"],
-#                     value="지난 7일", 
-#                     label="기간 선택",
-#                     info="트렌드 분석 기간을 선택하세요"
-#                 )
-                
-#             with gr.Column(scale=1):
-#                 category_input = gr.Dropdown(
-#                     choices=["모든 카테고리", "게임", "건강", "기술", "스포츠", "엔터테인먼트", "뉴스", "비즈니스"],
-#                     value="모든 카테고리",
-#                     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>위의 설정을 선택하고 '실시간 트렌드 분석 시작' 버튼을 클릭하세요!</p>
-#                 <p style="font-size: 14px;">개선된 방식으로 <strong>15-30초</strong>만에 분석이 완료됩니다.</p>
-#             </div>
-#             """
-#         )
-        
-#         # 이벤트 연결 (Generator 함수로 실시간 스트리밍)
-#         analyze_btn.click(
-#             fn=main_analysis,
-#             inputs=[region_input, period_input, category_input],
-#             outputs=output,
-#             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>
-#             <div style="display: grid; grid-template-columns: 1fr 1fr; gap: 20px; color: #555;">
-#                 <div>
-#                     <h4> 실시간 스트리밍</h4>
-#                     <ul style="margin: 0; padding-left: 20px;">
-#                         <li>브라우저 실행 상태 실시간 표시</li>
-#                         <li>설정 변경 과정 단계별 확인</li>
-#                         <li>AI 분석 진행상황 표시</li>
-#                     </ul>
-#                 </div>
-#                 <div>
-#                     <h4> 속도 최적화</h4>
-#                     <ul style="margin: 0; padding-left: 20px;">
-#                         <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
-
-# # 메인 실행
-# if __name__ == "__main__":
-#     print("=" * 50)
-#     print("Google Trends 실시간 분석기 시작!")
-#     print("=" * 50)
-    
-#     # API 키 확인
-#     if not ANTHROPIC_API_KEY or ANTHROPIC_API_KEY == "your_api_key_here":
-#         print(" ANTHROPIC_API_KEY가 설정되지 않음")
-#         print("\n 이 상태로도 앱은 실행되지만, 분석 기능은 작동하지 않는다.")
-#         print("=" * 50)
-#     else:
-#         print(" Claude API 키 확인됨")
-    
-#     # 인터페이스 생성 및 실행
-#     print(" Gradio ��� 인터페이스 준비 중...")
-#     app = create_interface()
-    
-#     # 환경별 실행 설정
-#     if os.getenv("SPACE_ID"):
-#         # Hugging Face Space 환경
-#         print(" Hugging Face Space 환경에서 실행 중...")
-#         app.launch(
-#             server_name="0.0.0.0",
-#             server_port=7860,
-#             show_error=True,
-#             show_api=False
-#         )
-#     else:
-#         # 로컬 환경
-#         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이 이미 사용 중인지 확인")
+        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
+        )

requirements.txt

@@ -1,5 +1,6 @@
 gradio==4.44.0
 anthropic==0.34.0
-playwright==1.40.0
+selenium==4.15.0
+webdriver-manager==4.0.1
 python-dotenv==1.0.0
 Pillow==10.4.0