fix

app.py

@@ -4,15 +4,11 @@ import base64
 import json
 import traceback
 import threading
+import asyncio
 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, WebDriverException
+from playwright.async_api import async_playwright, Browser, Page
 from concurrent.futures import ThreadPoolExecutor
 from datetime import datetime
 
@@ -37,8 +33,8 @@ def create_claude_client():
         print(f"Claude API 클라이언트 생성 실패: {e}")
         return None
 
-class PersistentGoogleTrendsAutomator:
-    """브라우저를 계속 유지하는 Google Trends 자동화 클래스"""
+class PlaywrightGoogleTrendsAutomator:
+    """Playwright 기반 Google Trends 자동화 클래스 (브라우저 재사용)"""
     
     _instance = None
     _lock = threading.Lock()
@@ -47,281 +43,182 @@ class PersistentGoogleTrendsAutomator:
         if cls._instance is None:
             with cls._lock:
                 if cls._instance is None:
-                    cls._instance = super(PersistentGoogleTrendsAutomator, cls).__new__(cls)
+                    cls._instance = super(PlaywrightGoogleTrendsAutomator, cls).__new__(cls)
                     cls._instance._initialized = False
         return cls._instance
     
     def __init__(self):
         if not self._initialized:
-            self.driver = None
+            self.playwright = None
+            self.browser = None
+            self.page = 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)
+            print("PlaywrightGoogleTrendsAutomator 싱글톤 인스턴스 생성")
+    
+    async def setup_browser(self):
+        """브라우저 설정 (최초 1회만)"""
+        if self.browser is not None and self.is_browser_ready:
+            print("기존 Playwright 브라우저 재사용")
+            return True
+        
+        print("새 Playwright 브라우저 인스턴스 생성 중...")
+        
+        try:
+            # Playwright 시작
+            self.playwright = await async_playwright().start()
             
-            # 봇 감지 회피
-            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)
+            # 브라우저 실행 옵션
+            browser_args = [
+                '--no-sandbox',
+                '--disable-dev-shm-usage',
+                '--disable-gpu',
+                '--disable-software-rasterizer',
+                '--disable-background-timer-throttling',
+                '--disable-backgrounding-occluded-windows',
+                '--disable-renderer-backgrounding',
+                '--disable-features=TranslateUI',
+                '--disable-extensions',
+                '--disable-web-security',
+                '--allow-running-insecure-content',
+                '--memory-pressure-off',
+                '--max_old_space_size=2048',
+                '--lang=ko',
+                '--accept-lang=ko-KR,ko;q=0.9,en;q=0.8'
+            ]
             
-            # 언어 설정
-            options.add_argument("--lang=ko")
-            options.add_argument("--accept-lang=ko-KR,ko;q=0.9,en;q=0.8")
+            # Hugging Face Space 환경에서는 headless 모드
+            headless = IS_HUGGINGFACE
             
-            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
+            # Chromium 브라우저 실행
+            self.browser = await self.playwright.chromium.launch(
+                headless=headless,
+                args=browser_args
+            )
+            
+            # 새 페이지 생성
+            self.page = await self.browser.new_page()
+            
+            # User Agent 설정
+            await 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'
+            )
+            
+            # 뷰포트 설정
+            await self.page.set_viewport_size({"width": 1280, "height": 720})
+            
+            # Google Trends 페이지 최초 로딩
+            print("Google Trends 페이지 최초 로딩 중...")
+            await self.page.goto("https://trends.google.com/trending?geo=KR&hl=ko", 
+                                wait_until='domcontentloaded', timeout=30000)
+            
+            # 페이지 로딩 완료 대기
+            await self.page.wait_for_load_state('networkidle', timeout=15000)
+            
+            # 봇 감지 방지 스크립트
+            await self.page.evaluate("""
+                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']});
+            """)
+            
+            self.is_browser_ready = True
+            self.last_used = time.time()
+            print("Playwright 브라우저 초기화 완료")
+            return True
+            
+        except Exception as e:
+            print(f"Playwright 브라우저 설정 실패: {e}")
+            await self.cleanup_browser()
+            return False
     
-    def cleanup_driver(self):
+    async def cleanup_browser(self):
         """브라우저 정리"""
         try:
-            if self.driver:
-                self.driver.quit()
-                print("브라우저 종료")
-        except:
-            pass
+            if self.page:
+                await self.page.close()
+            if self.browser:
+                await self.browser.close()
+            if self.playwright:
+                await self.playwright.stop()
+            print("Playwright 브라우저 종료")
+        except Exception as e:
+            print(f"브라우저 정리 중 오류: {e}")
         finally:
-            self.driver = None
+            self.page = None
+            self.browser = None
+            self.playwright = None
             self.is_browser_ready = False
     
-    def check_browser_health(self):
-        """브라우저 상태 확인 및 필요시 복구"""
+    async def check_browser_health(self):
+        """브라우저 상태 확인"""
         try:
-            if not self.driver:
+            if not self.page or not self.browser:
                 return False
             
-            # 간단한 상태 체크
-            current_url = self.driver.current_url
+            # 현재 URL 확인
+            current_url = self.page.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)
+                await self.page.goto("https://trends.google.com/trending?geo=KR&hl=ko", 
+                                   wait_until='domcontentloaded')
+                await self.page.wait_for_load_state('networkidle', timeout=10000)
             
             return True
             
-        except WebDriverException as e:
+        except Exception as e:
             print(f"브라우저 상태 확인 실패: {e}")
             return False
     
-    def refresh_and_wait(self):
-        """페이지 새로고침 및 대기 (빠른 데이터 갱신)"""
+    async def refresh_and_wait(self):
+        """페이지 새로고침 및 대기"""
         try:
             print("페이지 새로고침으로 최신 데이터 갱신...")
-            self.driver.refresh()
-            
-            # 최소한의 로딩 대기
-            time.sleep(2)
-            
-            # 페이지 준비 확인
-            WebDriverWait(self.driver, 5).until(
-                EC.presence_of_element_located((By.TAG_NAME, "button"))
-            )
-            
+            await self.page.reload(wait_until='domcontentloaded')
+            await self.page.wait_for_load_state('networkidle', timeout=10000)
             return True
-            
         except Exception as e:
             print(f"페이지 새로고침 실패: {e}")
             return False
     
-    def safe_find_element(self, selectors: list, timeout: int = 3):
-        """안전한 요소 찾기"""
+    async def safe_click(self, selectors: list, timeout: int = 3000) -> bool:
+        """안전한 클릭"""
         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))
-                    )
+                    element = await self.page.wait_for_selector(f"xpath={selector}", timeout=timeout)
                 elif selector_type == "css":
-                    element = WebDriverWait(self.driver, timeout).until(
-                        EC.presence_of_element_located((By.CSS_SELECTOR, selector))
-                    )
+                    element = await self.page.wait_for_selector(selector, timeout=timeout)
                 elif selector_type == "text":
-                    element = WebDriverWait(self.driver, timeout).until(
-                        EC.presence_of_element_located((By.XPATH, f"//*[contains(text(), '{selector}')]"))
-                    )
+                    element = await self.page.wait_for_selector(f"text={selector}", timeout=timeout)
                 
                 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()
+                    await element.click()
                     return True
-                except:
-                    return False
+            except Exception as e:
+                print(f"클릭 시도 실패 ({selector_type}: {selector}): {e}")
+                continue
         return False
     
-    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:
+    async 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"),
+                ("css", "button[aria-label*='위치 선택']"),
             ]
             
-            if not self.safe_click(region_selectors):
+            if not await self.safe_click(region_selectors):
                 return False
             
-            time.sleep(1)
+            await asyncio.sleep(1)
             
+            # 지역 매핑
             region_mapping = {
                 "전세계": ["전 세계", "Worldwide"],
                 "미국": ["미국", "United States"],
@@ -331,12 +228,12 @@ class PersistentGoogleTrendsAutomator:
             
             if target_region in region_mapping:
                 for region_text in region_mapping[target_region]:
-                    region_option_selectors = [
+                    region_selectors = [
+                        ("text", region_text),
                         ("xpath", f"//span[contains(text(), '{region_text}')]"),
-                        ("xpath", f"//*[contains(text(), '{region_text}')]"),
                     ]
                     
-                    if self.safe_click(region_option_selectors, timeout=2):
+                    if await self.safe_click(region_selectors, timeout=2000):
                         return True
             
             return False
@@ -345,18 +242,18 @@ class PersistentGoogleTrendsAutomator:
             print(f"지역 변경 실패: {e}")
             return False
     
-    def change_time_period(self, target_period: str) -> bool:
+    async def change_time_period(self, target_period: str) -> bool:
         """기간 변경"""
         try:
             period_selectors = [
                 ("xpath", "//button[contains(@aria-label, '기간 선택')]"),
-                ("xpath", "//span[contains(text(), '지난 24시간')]//parent::button"),
+                ("css", "button[aria-label*='기간 선택']"),
             ]
             
-            if not self.safe_click(period_selectors):
+            if not await self.safe_click(period_selectors):
                 return False
                 
-            time.sleep(1)
+            await asyncio.sleep(1)
             
             period_mapping = {
                 "지난 1시간": ["지난 1시간"],
@@ -367,12 +264,12 @@ class PersistentGoogleTrendsAutomator:
             
             if target_period in period_mapping:
                 for period_text in period_mapping[target_period]:
-                    period_option_selectors = [
+                    period_selectors = [
+                        ("text", period_text),
                         ("xpath", f"//span[contains(text(), '{period_text}')]"),
-                        ("xpath", f"//*[contains(text(), '{period_text}')]"),
                     ]
                     
-                    if self.safe_click(period_option_selectors, timeout=2):
+                    if await self.safe_click(period_selectors, timeout=2000):
                         return True
             
             return False
@@ -381,18 +278,18 @@ class PersistentGoogleTrendsAutomator:
             print(f"기간 변경 실패: {e}")
             return False
     
-    def change_category(self, target_category: str) -> bool:
+    async def change_category(self, target_category: str) -> bool:
         """카테고리 변경"""
         try:
             category_selectors = [
                 ("xpath", "//button[contains(@aria-label, '카테고리 선택')]"),
-                ("xpath", "//span[contains(text(), '모든 카테고리')]//parent::button"),
+                ("css", "button[aria-label*='카테고리 선택']"),
             ]
             
-            if not self.safe_click(category_selectors):
+            if not await self.safe_click(category_selectors):
                 return False
                 
-            time.sleep(1)
+            await asyncio.sleep(1)
             
             category_mapping = {
                 "게임": ["게임"],
@@ -406,12 +303,12 @@ class PersistentGoogleTrendsAutomator:
             
             if target_category in category_mapping:
                 for category_text in category_mapping[target_category]:
-                    category_option_selectors = [
+                    category_selectors = [
+                        ("text", category_text),
                         ("xpath", f"//span[contains(text(), '{category_text}')]"),
-                        ("xpath", f"//*[contains(text(), '{category_text}')]"),
                     ]
                     
-                    if self.safe_click(category_option_selectors, timeout=2):
+                    if await self.safe_click(category_selectors, timeout=2000):
                         return True
             
             return False
@@ -420,76 +317,137 @@ class PersistentGoogleTrendsAutomator:
             print(f"카테고리 변경 실패: {e}")
             return False
     
-    def capture_trends_fast(self, region: str, period: str, category: str, progress_callback=None) -> Tuple[Optional[str], bool, str]:
-        """빠른 트렌드 캡처 (브라우저 재사용)"""
+    async def change_settings_fast(self, region: str, period: str, category: str, progress_callback=None) -> dict:
+        """빠른 설정 변경"""
+        results = {
+            'region': False,
+            'period': False, 
+            'category': False,
+            'errors': []
+        }
         
-        with self.browser_lock:  # 동시 접근 방지
-            error_msg = ""
+        try:
+            # 페이지 새로고침
+            await self.refresh_and_wait()
             
-            try:
-                # 브라우저 상태 확인
-                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:
-                    if progress_callback:
-                        progress_callback("기존 브라우저 재사용 중...")
-                
-                # 설정 변경
+            if region != "대한민국":
                 if progress_callback:
-                    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}")
-                if settings_result['category']:
-                    changes_made.append(f"카테고리: {category}")
-                
-                if settings_result['errors']:
-                    error_msg = "\n".join(settings_result['errors'])
+                    progress_callback(f"지역을 {region}으로 변경 중...")
+                results['region'] = await self.change_region(region)
+                await asyncio.sleep(0.5)
+            else:
+                results['region'] = True
                 
+            if period != "지난 24시간":
                 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()
+                    progress_callback(f"기간을 {period}로 변경 중...")
+                results['period'] = await self.change_time_period(period)
+                await asyncio.sleep(0.5)
+            else:
+                results['period'] = True
                 
-                success_msg = f"설정 완료: {', '.join(changes_made) if changes_made else '기본 설정 사용'}"
+            if category != "모든 카테고리":
+                if progress_callback:
+                    progress_callback(f"카테고리를 {category}로 변경 중...")
+                results['category'] = await self.change_category(category)
+                await asyncio.sleep(0.5)
+            else:
+                results['category'] = True
                 
-                return screenshot_b64, True, success_msg + ("\n" + error_msg if error_msg else "")
+        except Exception as e:
+            results['errors'].append(str(e))
+        
+        return results
+    
+    async def capture_trends_fast(self, region: str, period: str, category: str, progress_callback=None) -> Tuple[Optional[str], bool, str]:
+        """빠른 트렌드 캡처"""
+        error_msg = ""
+        
+        try:
+            # 브라우저 상태 확인
+            if not self.is_browser_ready or not await self.check_browser_health():
+                if progress_callback:
+                    progress_callback("Playwright 브라우저 초기화 중... (최초 실행시만)")
                 
-            except Exception as e:
-                error_msg = f"오류 발생: {str(e)}"
-                # 오류 발생시 브라우저 재시작 시도
-                print(f"오류로 인한 브라우저 재시작: {e}")
-                self.cleanup_driver()
-                return None, False, error_msg
+                if not await self.setup_browser():
+                    return None, False, "Playwright 브라우저 설정 실패"
+            else:
+                if progress_callback:
+                    progress_callback("기존 Playwright 브라우저 재사용 중...")
+            
+            # 설정 변경
+            if progress_callback:
+                progress_callback("설정 변경 및 데이터 갱신 중...")
+            
+            settings_result = await 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}")
+            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("최신 데이터 로딩 완료, 스크린샷 캡처 중...")
+            
+            # 최종 데이터 로딩 대기
+            await asyncio.sleep(1)
+            
+            # 스크린샷 캡처
+            screenshot_bytes = await self.page.screenshot(full_page=False)
+            screenshot_b64 = base64.b64encode(screenshot_bytes).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}")
+            await self.cleanup_browser()
+            return None, False, error_msg
 
-# 글로벌 자동화 인스턴스 (싱글톤)
+# 글로벌 자동화 인스턴스
 automator_instance = None
 
 def get_automator():
     """자동화 인스턴스 가져오기"""
     global automator_instance
     if automator_instance is None:
-        automator_instance = PersistentGoogleTrendsAutomator()
+        automator_instance = PlaywrightGoogleTrendsAutomator()
     return automator_instance
 
+# 비동기 함수를 동기 환경에서 실행하기 위한 래퍼
+def run_async_capture(region: str, period: str, category: str, progress_callback=None):
+    """비동기 캡처 함수를 동기 환경에서 실행"""
+    automator = get_automator()
+    
+    try:
+        # 새로운 이벤트 루프 생성 및 실행
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+        result = loop.run_until_complete(
+            automator.capture_trends_fast(region, period, category, progress_callback)
+        )
+        return result
+    except Exception as e:
+        print(f"비동기 실행 오류: {e}")
+        return None, False, f"비동기 실행 오류: {str(e)}"
+    finally:
+        try:
+            loop.close()
+        except:
+            pass
+
 def analyze_with_claude(screenshot_b64: str, region: str, period: str, category: str) -> str:
     """Claude API로 스크린샷 분석"""
     try:
@@ -558,16 +516,16 @@ HTML 형태로 깔끔하게 정리하고, 시각적으로 만들어주세요.
         </div>
         """
 
-def persistent_browser_analysis(region: str, period: str, category: str):
-    """브라우저 재사용 분석 함수"""
+def playwright_browser_analysis(region: str, period: str, category: str):
+    """Playwright 브라우저 재사용 분석 함수"""
     
     start_time = time.time()
     
     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>Playwright Google Trends 분석</h3>
         <p><strong>설정:</strong> {region} | {period} | {category}</p>
-        <p>첫 실행: 15-20초 | 이후 실행: 5-10초</p>
+        <p>Chrome 설치 없이 Playwright로 안정적 실행</p>
     </div>
     """
     
@@ -588,21 +546,19 @@ def persistent_browser_analysis(region: str, period: str, category: str):
         
         # 자동화 인스턴스 가져오기
         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단계: {"브라우저 초기화" if is_first_run else "기존 브라우저 재사용"}</h4>
-            <p>{"최초 실행이므로 브라우저를 새로 시작합니다" if is_first_run else "이미 실행 중인 브라우저를 재사용합니다"}</p>
+            <h4>1단계: {"Playwright 브라우저 초기화" if is_first_run else "기존 Playwright 브라우저 재사용"}</h4>
+            <p>{"Chromium 브라우저를 자동 다운로드하고 시작합니다" if is_first_run else "이미 실행 중인 브라우저를 재사용합니다"}</p>
         </div>
         """
         
-        # 브라우저 작업을 별도 스레드에서 실행
+        # 브라우저 작업 실행
         with ThreadPoolExecutor(max_workers=1) as executor:
             future = executor.submit(
-                automator.capture_trends_fast, 
+                run_async_capture, 
                 region, period, category, progress_callback
             )
             
@@ -613,7 +569,7 @@ def persistent_browser_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>1단계: {"브라우저 초기화" if is_first_run else "기존 브라우저 재사용"}</h4>
+                        <h4>1단계: {"Playwright 브라우저 초기화" if is_first_run else "기존 Playwright 브라우저 재사용"}</h4>
                         <p>{current_progress}</p>
                         <p>경과 시간: {elapsed:.1f}초</p>
                     </div>
@@ -639,7 +595,7 @@ def persistent_browser_analysis(region: str, period: str, category: str):
         # 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>1단계 완료: 스크린샷 캡처 성공 ({browser_time:.1f}초)</h4>
+            <h4>1단계 완료: Playwright 스크린샷 캡처 성공 ({browser_time:.1f}초)</h4>
             <p>{status_msg}</p>
         </div>
         
@@ -663,7 +619,7 @@ def persistent_browser_analysis(region: str, period: str, category: str):
                 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>
+                    <h4>1단계 완료: Playwright 스크린샷 캡처 성공 ({browser_time:.1f}초)</h4>
                     <p>{status_msg}</p>
                 </div>
                 
@@ -681,35 +637,35 @@ def persistent_browser_analysis(region: str, period: str, category: str):
         # 최종 결과
         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> {"첫 실행" if is_first_run else "브라우저 재사용"} | <strong>설정:</strong> {region} | {period} | {category}</p>
+            <h3>Playwright 분석 완료 ({total_time:.1f}초)</h3>
+            <p><strong>엔진:</strong> Playwright Chromium | <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>
-                브라우저가 이미 실행 중이므로 5-10초만에 완료됩니다
+                <strong>Playwright의 장점</strong><br>
+                Chrome 설치 불필요, 자동 브라우저 관리, Hugging Face Space 완벽 호환
             </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> {"새로 시작됨" if is_first_run else "재사용됨"}</p>
+            <p style="margin: 5px 0;"><strong>브라우저:</strong> Playwright Chromium {"(새로 시작됨)" 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>
+            <p style="margin: 5px 0;"><strong>환경:</strong> {"Hugging Face Space" if IS_HUGGINGFACE else "로컬"}</p>
         </div>
         """
         
-        print(f"브라우저 재사용 분석 완료: {total_time:.1f}초")
+        print(f"Playwright 분석 완료: {total_time:.1f}초")
         
     except Exception as e:
         error_details = traceback.format_exc()
-        print(f"분석 중 예외 발생: {e}")
+        print(f"Playwright 분석 중 예외 발생: {e}")
         
         yield f"""
         <div style="color: red; padding: 20px; border: 1px solid red; border-radius: 5px;">
-            <h3>오류 발생</h3>
+            <h3>Playwright 오류 발생</h3>
             <p><strong>오류:</strong> {str(e)}</p>
             <details>
                 <summary>상세 오류 정보</summary>
@@ -721,12 +677,12 @@ def persistent_browser_analysis(region: str, period: str, category: str):
         </div>
         """
 
-def create_persistent_interface():
-    """브라우저 재사용 Gradio 인터페이스"""
+def create_playwright_interface():
+    """Playwright Gradio 인터페이스"""
     
     with gr.Blocks(
         theme=gr.themes.Soft(),
-        title="브라우저 재사용 Google Trends 분석기",
+        title="Playwright Google Trends 분석기",
         css="""
         .gradio-container {
             max-width: 1200px !important;
@@ -739,9 +695,9 @@ def create_persistent_interface():
         
         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> 브라우저를 계속 켜두고 재사용하여 속도 향상</p>
-            <p style="font-size: 14px; opacity: 0.9;">첫 실행: 15-20초 | 이후 실행: 5-10초</p>
+            <h1>Playwright Google Trends 분석기</h1>
+            <p><strong>Chrome 설치 불필요:</strong> Playwright가 브라우저를 자동으로 관리합니다</p>
+            <p style="font-size: 14px; opacity: 0.9;">Hugging Face Space 완벽 호환 | 안정적 브라우저 재사용</p>
         </div>
         """)
         
@@ -768,7 +724,7 @@ def create_persistent_interface():
                 )
         
         analyze_btn = gr.Button(
-            "브라우저 재사용 분석 시작", 
+            "Playwright 분석 시작 (Chrome 설치 불필요)", 
             variant="primary",
             size="lg"
         )
@@ -777,16 +733,16 @@ def create_persistent_interface():
             label="실시간 분석 결과",
             value="""
             <div style="text-align: center; padding: 20px; border: 2px dashed #ccc; border-radius: 10px; color: #666;">
-                <h3>브라우저 재사용 분석기 대기 중</h3>
-                <p><strong>첫 실행:</strong> 브라우저 초기화로 15-20초 소요</p>
-                <p><strong>이후 실행:</strong> 브라우저 재사용으로 5-10초 완료</p>
+                <h3>Playwright 분석기 대기 중</h3>
+                <p><strong>Chrome 설치 불필요:</strong> Playwright가 Chromium을 자동으로 다운로드</p>
+                <p><strong>Hugging Face Space:</strong> 완벽 호환</p>
                 <p style="font-size: 14px;">위의 설정을 선택하고 버튼을 클릭하세요!</p>
             </div>
             """
         )
         
         analyze_btn.click(
-            fn=persistent_browser_analysis,
+            fn=playwright_browser_analysis,
             inputs=[region_input, period_input, category_input],
             outputs=output,
             show_progress="hidden"
@@ -794,22 +750,22 @@ def create_persistent_interface():
         
         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;">Playwright의 장점</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>두 번째부터 8-15초 단축</li>
-                        <li>브라우저 초기화 시간 제거</li>
-                        <li>페이지 로딩 시간 최소화</li>
+                        <li>Chrome 수동 설치 불필요</li>
+                        <li>브라우저 자동 다운로드</li>
+                        <li>버전 호환성 자동 관리</li>
                     </ul>
                 </div>
                 <div>
-                    <h4>자원 효율성</h4>
+                    <h4>안정성</h4>
                     <ul style="margin: 0; padding-left: 20px;">
-                        <li>메모리 사용량 최적화</li>
-                        <li>CPU 부하 감소</li>
-                        <li>안정적인 세션 유지</li>
+                        <li>Hugging Face Space 완벽 지원</li>
+                        <li>브라우저 크래시 자동복구</li>
+                        <li>메모리 효율적 관리</li>
                     </ul>
                 </div>
             </div>
@@ -825,23 +781,63 @@ def cleanup_on_exit():
     """앱 종료시 브라우저 정리"""
     global automator_instance
     if automator_instance:
-        automator_instance.cleanup_driver()
-        print("앱 종료: 브라우저 정리 완료")
+        try:
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+            loop.run_until_complete(automator_instance.cleanup_browser())
+            loop.close()
+            print("앱 종료: Playwright 브라우저 정리 완료")
+        except Exception as e:
+            print(f"브라우저 정리 중 오류: {e}")
 
 atexit.register(cleanup_on_exit)
 
+# Playwright 브라우저 자동 설치
+def install_playwright_browsers():
+    """Playwright 브라우저 자동 설치"""
+    try:
+        import subprocess
+        import sys
+        
+        print("Playwright 브라우저 설치 확인 중...")
+        
+        # Chromium 설치
+        result = subprocess.run([
+            sys.executable, "-m", "playwright", "install", "chromium"
+        ], capture_output=True, text=True, timeout=300)
+        
+        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
+
 if __name__ == "__main__":
     print("=" * 50)
-    print("브라우저 재사용 Google Trends 분석기 시작")
+    print("Playwright Google Trends 분석기 시작")
     print("=" * 50)
     
+    # Playwright 브라우저 설치 (최초 1회)
+    if IS_HUGGINGFACE:
+        print("Hugging Face Space 환경: Playwright 브라우저 설치 중...")
+        if not install_playwright_browsers():
+            print("경고: Playwright 브라우저 설치 실패, 런타임 설치 시도됩니다")
+    else:
+        print("로컬 환경: Playwright 브라우저 확인")
+        install_playwright_browsers()
+    
     if not ANTHROPIC_API_KEY or ANTHROPIC_API_KEY == "your_api_key_here":
         print("ANTHROPIC_API_KEY 미설정 - 스크린샷만 캡처")
     else:
         print("Claude API 키 확인됨")
     
-    print("브라우저 재사용 Gradio 인터페이스 준비 중...")
-    app = create_persistent_interface()
+    print("Playwright Gradio 인터페이스 준비 중...")
+    app = create_playwright_interface()
     
     if os.getenv("SPACE_ID"):
         print("Hugging Face Space 환경에서 실행")
@@ -860,4 +856,875 @@ if __name__ == "__main__":
             show_api=False,
             share=False,
             inbrowser=True
-        )
+        )
+
+
+
+
+
+
+
+
+# import os
+# import time
+# import base64
+# import json
+# import traceback
+# import threading
+# 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, WebDriverException
+# from concurrent.futures import ThreadPoolExecutor
+# from datetime import datetime
+
+# # Hugging Face Space 환경 확인
+# IS_HUGGINGFACE = os.getenv("SPACE_ID") is not None
+# print(f'IS_HUGGINGFACE = {IS_HUGGINGFACE}')
+
+# # Claude API 설정
+# ANTHROPIC_API_KEY = os.getenv("ANTHROPIC_API_KEY")
+
+# if not ANTHROPIC_API_KEY:
+#     print("ANTHROPIC_API_KEY가 설정되지 않음, Secret 확인 필요")
+# else:
+#     print("Claude API 키 확인 완료")
+
+# 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
+
+# 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):
+#         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
+    
+#     def check_browser_health(self):
+#         """브라우저 상태 확인 및 필요시 복구"""
+#         try:
+#             if not self.driver:
+#                 return False
+            
+#             # 간단한 상태 체크
+#             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)
+            
+#             return True
+            
+#         except WebDriverException as e:
+#             print(f"브라우저 상태 확인 실패: {e}")
+#             return False
+    
+#     def refresh_and_wait(self):
+#         """페이지 새로고침 및 대기 (빠른 데이터 갱신)"""
+#         try:
+#             print("페이지 새로고침으로 최신 데이터 갱신...")
+#             self.driver.refresh()
+            
+#             # 최소한의 로딩 대기
+#             time.sleep(2)
+            
+#             # 페이지 준비 확인
+#             WebDriverWait(self.driver, 5).until(
+#                 EC.presence_of_element_located((By.TAG_NAME, "button"))
+#             )
+            
+#             return True
+            
+#         except Exception as e:
+#             print(f"페이지 새로고침 실패: {e}")
+#             return False
+    
+#     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:
+#                 self.driver.execute_script("arguments[0].click();", element)
+#                 return True
+#             except:
+#                 try:
+#                     element.click()
+#                     return True
+#                 except:
+#                     return False
+#         return False
+    
+#     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 = [
+#                 ("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
+    
+#     def capture_trends_fast(self, region: str, period: str, category: str, progress_callback=None) -> Tuple[Optional[str], bool, str]:
+#         """빠른 트렌드 캡처 (브라우저 재사용)"""
+        
+#         with self.browser_lock:  # 동시 접근 방지
+#             error_msg = ""
+            
+#             try:
+#                 # 브라우저 상태 확인
+#                 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:
+#                     if progress_callback:
+#                         progress_callback("기존 브라우저 재사용 중...")
+                
+#                 # 설정 변경
+#                 if progress_callback:
+#                     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}")
+#                 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("최신 데이터 로딩 완료, 스크린샷 캡처 중...")
+                
+#                 # 최종 데이터 로딩 대기
+#                 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
+
+# def analyze_with_claude(screenshot_b64: str, region: str, period: str, category: str) -> str:
+#     """Claude API로 스크린샷 분석"""
+#     try:
+#         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_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 형태로 깔끔하게 정리하고, 시각적으로 만들어주세요.
+# 한글 텍스트를 정확히 읽어서 분석해주세요.
+# """
+
+#         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 persistent_browser_analysis(region: str, period: str, category: str):
+#     """브라우저 재사용 분석 함수"""
+    
+#     start_time = time.time()
+    
+#     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>첫 실행: 15-20초 | 이후 실행: 5-10초</p>
+#     </div>
+#     """
+    
+#     progress_status = {"current": ""}
+    
+#     def progress_callback(message):
+#         progress_status["current"] = message
+    
+#     try:
+#         # API 키 확인
+#         if not ANTHROPIC_API_KEY or ANTHROPIC_API_KEY == "your_api_key_here":
+#             yield """
+#             <div style="color: orange; padding: 20px; border: 1px solid orange; border-radius: 5px;">
+#                 <h3>API 키 누락 - 스크린샷만 캡처</h3>
+#                 <p><strong>ANTHROPIC_API_KEY가 설정되지 않았습니다!</strong></p>
+#             </div>
+#             """
+        
+#         # 자동화 인스턴스 가져오기
+#         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단계: {"브라우저 초기화" if is_first_run else "기존 브라우저 재사용"}</h4>
+#             <p>{"최초 실행이므로 브라우저를 새로 시작합니다" if is_first_run else "이미 실행 중인 브라우저를 재사용합니다"}</p>
+#         </div>
+#         """
+        
+#         # 브라우저 작업을 별도 스레드에서 실행
+#         with ThreadPoolExecutor(max_workers=1) as executor:
+#             future = executor.submit(
+#                 automator.capture_trends_fast, 
+#                 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>1단계: {"브라우저 초기화" if is_first_run else "기존 브라우저 재사용"}</h4>
+#                         <p>{current_progress}</p>
+#                         <p>경과 시간: {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>
+#             </div>
+#             """
+#             return
+        
+#         # 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>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 분석 중...</h4>
+#             <p>트렌드 데이터를 분석하고 있습니다</p>
+#         </div>
+#         """
+        
+#         # 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>분석 완료 ({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>
+#                 브라우저가 이미 실행 중이므로 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> {"새로 시작됨" 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}초")
+        
+#     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>
+#         """
+
+# def create_persistent_interface():
+#     """브라우저 재사용 Gradio 인터페이스"""
+    
+#     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:
+        
+#         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> 브라우저를 계속 켜두고 재사용하여 속도 향상</p>
+#             <p style="font-size: 14px; opacity: 0.9;">첫 실행: 15-20초 | 이후 실행: 5-10초</p>
+#         </div>
+#         """)
+        
+#         with gr.Row():
+#             with gr.Column(scale=1):
+#                 region_input = gr.Dropdown(
+#                     choices=["대한민국", "전세계", "미국", "일본", "중국"],
+#                     value="대한민국",
+#                     label="지역 선택"
+#                 )
+                
+#             with gr.Column(scale=1):
+#                 period_input = gr.Dropdown(
+#                     choices=["지난 24시간", "지난 1시간", "지난 4시간", "지난 1일", "지난 7일"],
+#                     value="지난 7일", 
+#                     label="기간 선택"
+#                 )
+                
+#             with gr.Column(scale=1):
+#                 category_input = gr.Dropdown(
+#                     choices=["모든 카테고리", "게임", "건강", "기술", "스포츠", "엔터테인먼트", "뉴스", "비즈니스"],
+#                     value="모든 카테고리",
+#                     label="카테고리 선택"
+#                 )
+        
+#         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> 브라우저 초기화로 15-20초 소요</p>
+#                 <p><strong>이후 실행:</strong> 브라우저 재사용으로 5-10초 완료</p>
+#                 <p style="font-size: 14px;">위의 설정을 선택하고 버튼을 클릭하세요!</p>
+#             </div>
+#             """
+#         )
+        
+#         analyze_btn.click(
+#             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>
+#             <div style="display: grid; grid-template-columns: 1fr 1fr; gap: 20px; color: #555;">
+#                 <div>
+#                     <h4>성능 향상</h4>
+#                     <ul style="margin: 0; padding-left: 20px;">
+#                         <li>두 번째부터 8-15초 단축</li>
+#                         <li>브라우저 초기화 시간 제거</li>
+#                         <li>페이지 로딩 시간 최소화</li>
+#                     </ul>
+#                 </div>
+#                 <div>
+#                     <h4>자원 효율성</h4>
+#                     <ul style="margin: 0; padding-left: 20px;">
+#                         <li>메모리 사용량 최적화</li>
+#                         <li>CPU 부하 감소</li>
+#                         <li>안정적인 세션 유지</li>
+#                     </ul>
+#                 </div>
+#             </div>
+#         </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("=" * 50)
+    
+#     if not ANTHROPIC_API_KEY or ANTHROPIC_API_KEY == "your_api_key_here":
+#         print("ANTHROPIC_API_KEY 미설정 - 스크린샷만 캡처")
+#     else:
+#         print("Claude API 키 확인됨")
+    
+#     print("브라우저 재사용 Gradio 인터페이스 준비 중...")
+#     app = create_persistent_interface()
+    
+#     if os.getenv("SPACE_ID"):
+#         print("Hugging Face Space 환경에서 실행")
+#         app.launch(
+#             server_name="0.0.0.0",
+#             server_port=7860,
+#             show_error=True,
+#             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
+#         )