Update app.py

app.py

@@ -1,449 +1,197 @@
 import os
 import time
 import base64
-import json
+import io
 import traceback
-from typing import Tuple, Optional
+import threading
+import atexit
+from datetime import datetime
+from typing import Optional, Tuple
+
 import gradio as gr
 import anthropic
 from selenium import webdriver
 from selenium.webdriver.chrome.options import Options
+from selenium.webdriver.chrome.service import Service
 from selenium.webdriver.common.by import By
-from selenium.webdriver.support.ui import WebDriverWait
+from selenium.webdriver.support.ui import WebDriverWait, Select
 from selenium.webdriver.support import expected_conditions as EC
-from selenium.common.exceptions import TimeoutException, NoSuchElementException
-from concurrent.futures import ThreadPoolExecutor
-import threading
+from selenium.common.exceptions import TimeoutException, WebDriverException
+from webdriver_manager.chrome import ChromeDriverManager
+from PIL import Image
+import requests
 
-# .env 파일 로드 (있는 경우)
-try:
-    from dotenv import load_dotenv
-    load_dotenv()
-    print(".env 파일 로드 완료")
-except ImportError:
-    print("python-dotenv가 설치되지 않았습니다. 환경변수를 수동으로 설정해주세요.")
-except Exception as e:
-    print(f".env 파일 로드 중 오류: {e}")
+# 전역 변수
+driver = None
+driver_lock = threading.Lock()
+is_browser_ready = False
 
-# Claude API 설정
-ANTHROPIC_API_KEY = os.getenv("ANTHROPIC_API_KEY")
-
-def create_claude_client():
-    """Claude 클라이언트를 생성하는 함수 (빠른 버전)"""
-    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
+# Claude API 클라이언트 초기화
+def get_claude_client():
+    api_key = os.getenv("ANTHROPIC_API_KEY")
+    if not api_key:
+        raise ValueError("ANTHROPIC_API_KEY 환경변수가 설정되지 않았습니다.")
+    return anthropic.Anthropic(api_key=api_key)
 
-class GoogleTrendsAutomator:
-    """최적화된 Google Trends 자동화 클래스"""
+def init_browser():
+    """브라우저를 초기화하고 Google Trends 페이지로 이동"""
+    global driver, is_browser_ready
     
-    def __init__(self):
-        self.driver = None
-        
-    def setup_driver(self):
-        """초고속 Chrome 드라이버 설정"""
-        options = Options()
-        
-        # 환경별 설정
-        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")
-        
-        # 이미지/CSS 비활성화로 로딩 속도 향상
-        prefs = {
-            "profile.managed_default_content_settings.images": 2,  # 이미지 차단
-            "profile.default_content_setting_values.notifications": 2,  # 알림 차단
-        }
-        options.add_experimental_option("prefs", prefs)
+    try:
+        print("Chrome 브라우저 초기화 중...")
+        
+        # Chrome 옵션 설정 (Hugging Face Space 최적화)
+        chrome_options = Options()
+        chrome_options.add_argument("--headless")
+        chrome_options.add_argument("--no-sandbox")
+        chrome_options.add_argument("--disable-dev-shm-usage")
+        chrome_options.add_argument("--disable-gpu")
+        chrome_options.add_argument("--disable-extensions")
+        chrome_options.add_argument("--disable-web-security")
+        chrome_options.add_argument("--allow-running-insecure-content")
+        chrome_options.add_argument("--disable-blink-features=AutomationControlled")
+        chrome_options.add_argument("--disable-features=VizDisplayCompositor")
+        chrome_options.add_argument("--window-size=1920,1080")
+        chrome_options.add_argument("--user-agent=Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36")
+        
+        # ChromeDriver 서비스 설정
+        service = Service(ChromeDriverManager().install())
+        
+        # 브라우저 인스턴스 생성
+        driver = webdriver.Chrome(service=service, options=chrome_options)
+        driver.set_page_load_timeout(30)
+        driver.implicitly_wait(10)
+        
+        print("Google Trends 페이지로 이동 중...")
+        driver.get("https://trends.google.com/trending?geo=KR")
+        
+        # 페이지 로딩 대기
+        WebDriverWait(driver, 20).until(
+            EC.presence_of_element_located((By.TAG_NAME, "body"))
+        )
         
-        # 봇 감지 회피
-        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)
+        # 추가 로딩 시간
+        time.sleep(3)
         
-        # 언어 설정
-        options.add_argument("--lang=ko")
-        options.add_argument("--accept-lang=ko-KR,ko;q=0.9,en;q=0.8")
+        is_browser_ready = True
+        print("브라우저 초기화 완료!")
         
-        try:
-            # 여러 방법으로 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
-    
-    def safe_find_element(self, selectors: list, timeout: int = 3):
-        """초고속 요소 찾기 (타임아웃 단축)"""
-        for selector_type, selector in selectors:
+    except Exception as e:
+        print(f"브라우저 초기화 실패: {str(e)}")
+        print(traceback.format_exc())
+        is_browser_ready = False
+        if driver:
             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
+                driver.quit()
             except:
-                continue
-        return None
+                pass
+            driver = None
+
+def cleanup_browser():
+    """브라우��� 정리"""
+    global driver
+    if driver:
+        try:
+            driver.quit()
+            print("브라우저 정리 완료")
+        except:
+            pass
+        driver = None
+
+def apply_filters(geo: str, time_range: str, category: str) -> bool:
+    """Google Trends 필터 적용"""
+    global driver
     
-    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
+    if not driver or not is_browser_ready:
         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
+    try:
+        with driver_lock:
+            # 필터 버튼들을 찾고 클릭
+            try:
+                # 지역 설정
+                if geo != "KR":  # 기본값이 아닌 경우
+                    geo_elements = driver.find_elements(By.XPATH, f"//div[contains(text(), '{geo}')]")
+                    if geo_elements:
+                        driver.execute_script("arguments[0].click();", geo_elements[0])
+                        time.sleep(1)
                 
-            if period != "지난 24시간":
-                if progress_callback:
-                    progress_callback("기간 설정 변경 중...")
-                results['period'] = self.change_time_period(period)
-                time.sleep(0.5)  # 최소 대기
-            else:
-                results['period'] = True
+                # 시간 범위 설정
+                if time_range != "24시간":
+                    time_elements = driver.find_elements(By.XPATH, f"//div[contains(text(), '{time_range}')]")
+                    if time_elements:
+                        driver.execute_script("arguments[0].click();", time_elements[0])
+                        time.sleep(1)
                 
-            if category != "모든 카테고리":
-                if progress_callback:
-                    progress_callback("카테고리 설정 변경 중...")
-                results['category'] = self.change_category(category)
-                time.sleep(0.5)  # 최소 대기
-            else:
-                results['category'] = True
+                # 카테고리 설정  
+                if category != "모든 카테고리":
+                    category_elements = driver.find_elements(By.XPATH, f"//div[contains(text(), '{category}')]")
+                    if category_elements:
+                        driver.execute_script("arguments[0].click();", category_elements[0])
+                        time.sleep(1)
                 
-        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(3)
+                return True
                 
-            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
+            except Exception as filter_error:
+                print(f"필터 적용 중 오류: {filter_error}")
+                return True  # 필터 적용 실패해도 스크린샷은 찍을 수 있음
                 
-            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
+    except Exception as e:
+        print(f"필터 적용 실패: {str(e)}")
+        return False
+
+def capture_screenshot() -> Optional[Image.Image]:
+    """현재 페이지의 스크린샷 캡처"""
+    global driver
     
-    def capture_trends(self, region: str, period: str, category: str, progress_callback=None) -> Tuple[Optional[str], bool, str]:
-        """Google Trends 캡처 (최적화된 버전)"""
-        error_msg = ""
+    if not driver or not is_browser_ready:
+        return None
         
-        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 '기본 설정 사용'}"
+    try:
+        with driver_lock:
+            # 페이지가 완전히 로드될 때까지 대기
+            time.sleep(2)
             
-            return screenshot_b64, True, success_msg + ("\n" + error_msg if error_msg else "")
+            # 스크린샷 캡처
+            screenshot_data = driver.get_screenshot_as_png()
+            screenshot = Image.open(io.BytesIO(screenshot_data))
             
-        except Exception as e:
-            error_msg = f"오류 발생: {str(e)}"
-            return None, False, error_msg
+            return screenshot
             
-        finally:
-            if self.driver:
-                self.driver.quit()
+    except Exception as e:
+        print(f"스크린샷 캡처 실패: {str(e)}")
+        return None
 
-def analyze_with_claude(screenshot_b64: str, region: str, period: str, category: str) -> str:
-    """Claude API로 스크린샷 분석 (최적화된 버전)"""
+def analyze_with_claude(image: Image.Image, user_prompt: 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>
-            </div>
-            """
+        client = get_claude_client()
         
-        # Claude 클라이언트 생성
-        claude_client = create_claude_client()
+        # 이미지를 base64로 인코딩
+        buffer = io.BytesIO()
+        image.save(buffer, format="PNG")
+        image_base64 = base64.b64encode(buffer.getvalue()).decode()
         
-        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>
-            """
+        # Claude API 호출을 위한 프롬프트 구성
+        default_prompt = """
+        이 Google Trends 실시간 인기 검색어 스크린샷을 분석해주세요.
         
-        # 간결한 프롬프트 (속도 최적화)
-        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,  # 토큰 수 줄여서 속도 향상
+        다음 내용을 포함해서 분석해주세요:
+        1. 현재 가장 인기 있는 검색어들과 그 순위
+        2. 각 검색어의 증가 추세나 특이사항
+        3. 검색어들에서 발견되는 주요 트렌드나 패턴
+        4. 시사적/문화적 맥락에서의 해석
+        
+        한국어로 상세하고 구체적으로 분석해주세요.
+        """
+        
+        prompt = user_prompt if user_prompt.strip() else default_prompt
+        
+        response = client.messages.create(
+            model="claude-3-sonnet-20240229",
+            max_tokens=1500,
             messages=[
                 {
                     "role": "user",
@@ -457,7 +205,7 @@ HTML 형태로 깔끔하게 정리하고, 이모지를 사용하지 않고 시
                             "source": {
                                 "type": "base64",
                                 "media_type": "image/png",
-                                "data": screenshot_b64
+                                "data": image_base64
                             }
                         }
                     ]
@@ -465,377 +213,181 @@ HTML 형태로 깔끔하게 정리하고, 이모지를 사용하지 않고 시
             ]
         )
         
-        return message.content[0].text
+        return response.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>
-        """
+        error_msg = f"Claude API 분석 실패: {str(e)}"
+        print(error_msg)
+        return error_msg
 
-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 refresh_trends_page():
+    """Google Trends 페이지 새로고침"""
+    global driver
     
-    def progress_callback(message):
-        progress_status["current"] = message
+    if not driver or not is_browser_ready:
+        return "브라우저가 준비되지 않았습니다."
+        
+    try:
+        with driver_lock:
+            driver.refresh()
+            time.sleep(3)
+            return "페이지가 새로고침되었습니다."
+    except Exception as e:
+        return f"페이지 새로고침 실패: {str(e)}"
+
+def main_process(geo: str, time_range: str, category: str, user_prompt: str) -> Tuple[Optional[Image.Image], str]:
+    """메인 처리 함수"""
+    if not is_browser_ready:
+        return None, "브라우저가 준비되지 않았습니다. 페이지를 새로고침해주세요."
     
     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
+        # 1. 필터 적용
+        print(f"필터 적용 중: 지역={geo}, 시간={time_range}, 카테고리={category}")
+        filter_success = apply_filters(geo, time_range, category)
         
-        # 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>
+        if not filter_success:
+            return None, "필터 적용에 실패했습니다."
         
-        <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>
+        # 2. 스크린샷 캡처
+        print("스크린샷 캡처 중...")
+        screenshot = capture_screenshot()
         
-        {analysis_result}
+        if screenshot is None:
+            return None, "스크린샷 캡처에 실패했습니다."
         
-        <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>
-        """
+        # 3. Claude API로 분석
+        print("Claude API로 분석 중...")
+        analysis_result = analyze_with_claude(screenshot, user_prompt)
         
-        print("전체 분석 프로세스 완료!")
+        return screenshot, analysis_result
         
     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>
-        """
+        error_msg = f"처리 중 오류 발생: {str(e)}"
+        print(error_msg)
+        print(traceback.format_exc())
+        return None, error_msg
+
+def check_browser_status():
+    """브라우저 상태 확인"""
+    global is_browser_ready, driver
+    
+    if not driver:
+        return "브라우저가 초기화되지 않았습니다."
+    
+    if not is_browser_ready:
+        return "브라우저 초기화 중입니다..."
+    
+    try:
+        with driver_lock:
+            current_url = driver.current_url
+            return f"브라우저 준비 완료 - 현재 URL: {current_url}"
+    except:
+        return "브라우저 연결에 문제가 있습니다."
 
-# Gradio 인터페이스 (실시간 스트리밍 형태로)
+# Gradio 인터페이스 생성
 def create_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:
+    with gr.Blocks(title="Google Trends 실시간 분석기", theme=gr.themes.Soft()) as interface:
+        gr.Markdown("# Google Trends 실시간 인기 검색어 분석기")
+        gr.Markdown("Google Trends의 실시간 인기 검색어를 캡처하고 Claude AI로 분석합니다.")
         
-        # 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="분석할 지역을 선택하세요"
+                geo_dropdown = gr.Dropdown(
+                    choices=["KR", "US", "JP", "GB", "DE", "FR"],
+                    value="KR",
+                    label="지역 선택"
                 )
                 
-            with gr.Column(scale=1):
-                period_input = gr.Dropdown(
-                    choices=["지난 24시간", "지난 1시간", "지난 4시간", "지난 1일", "지난 7일"],
-                    value="지난 7일", 
-                    label="기간 선택",
-                    info="트렌드 분석 기간을 선택하세요"
+                time_dropdown = gr.Dropdown(
+                    choices=["24시간", "7일", "30일", "90일", "12개월"],
+                    value="24시간", 
+                    label="기간 선택"
                 )
                 
-            with gr.Column(scale=1):
-                category_input = gr.Dropdown(
-                    choices=["모든 카테고리", "게임", "건강", "기술", "스포츠", "엔터테인먼트", "뉴스", "비즈니스"],
+                category_dropdown = gr.Dropdown(
+                    choices=["모든 카테고리", "엔터테인먼트", "스포츠", "비즈니스", "과학기술", "건강"],
                     value="모든 카테고리",
-                    label="카테고리 선택", 
-                    info="관심 분야를 선택하세요"
+                    label="카테고리 선택"
+                )
+                
+                user_prompt = gr.Textbox(
+                    label="분석 요청사항 (선택사항)",
+                    placeholder="특별히 분석하고 싶은 내용이 있다면 입력하세요...",
+                    lines=3
+                )
+                
+                analyze_btn = gr.Button("분석 시작", variant="primary")
+                refresh_btn = gr.Button("페이지 새로고침", variant="secondary")
+                status_btn = gr.Button("브라우저 상태 확인", variant="secondary")
+            
+            with gr.Column(scale=2):
+                screenshot_output = gr.Image(label="Google Trends 스크린샷")
+                analysis_output = gr.Textbox(
+                    label="Claude AI 분석 결과",
+                    lines=10,
+                    max_lines=20
                 )
+                status_output = gr.Textbox(label="상태 메시지")
         
-        # 분석 버튼
-        analyze_btn = gr.Button(
-            "실시간 트렌드 분석 시작 (빠른 스트리밍 모드)", 
-            variant="primary",
-            size="lg"
+        # 이벤트 핸들러
+        analyze_btn.click(
+            fn=main_process,
+            inputs=[geo_dropdown, time_dropdown, category_dropdown, user_prompt],
+            outputs=[screenshot_output, analysis_output]
         )
         
-        # 진행 상황 및 결과 출력
-        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>
-            """
+        refresh_btn.click(
+            fn=refresh_trends_page,
+            outputs=status_output
         )
         
-        # 이벤트 연결 (Generator 함수로 실시간 스트리밍)
-        analyze_btn.click(
-            fn=main_analysis,
-            inputs=[region_input, period_input, category_input],
-            outputs=output,
-            show_progress="hidden"  # 내장 진행률 표시 숨김 (자체 스트리밍 사용)
+        status_btn.click(
+            fn=check_browser_status,
+            outputs=status_output
         )
-        
-        # 사용법 안내
-        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__":
+def 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 키 확인됨")
+    try:
+        get_claude_client()
+        print("✓ Claude API 키 확인됨")
+    except ValueError as e:
+        print(f"✗ {e}")
+        return
     
-    # 인터페이스 생성 및 실행
-    print(" Gradio 웹 인터페이스 준비 중...")
-    app = create_interface()
+    print("✓ Gradio 웹 인터페이스 준비 중...")
     
-    # 환경별 실행 설정
+    # 환경 확인
     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("✓ Hugging Face Space 환경에서 실행 중...")
+    
+    # 브라우저 초기화 (백그라운드에서)
+    init_thread = threading.Thread(target=init_browser, daemon=True)
+    init_thread.start()
+    
+    # 종료 시 브라우저 정리
+    atexit.register(cleanup_browser)
+    
+    # Gradio 인터페이스 생성 및 실행
+    interface = create_interface()
+    
+    # Hugging Face Space에서는 share=False로 실행
+    interface.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=False,
+        show_error=True,
+        quiet=False
+    )
+
+if __name__ == "__main__":
+    main()