Update app.py

app.py

@@ -2,80 +2,63 @@ import os
 import time
 import base64
 import io
-import traceback
 import threading
 import atexit
-import asyncio
+import traceback
 from datetime import datetime
-from typing import Optional, Tuple
+from typing import Optional, Dict, Any
 
 import gradio as gr
 import anthropic
-from playwright.async_api import async_playwright
-from playwright.sync_api import sync_playwright, Browser, Page
+from playwright.sync_api import sync_playwright
 from PIL import Image
-import requests
 from dotenv import load_dotenv
 
 # 환경변수 로드
 load_dotenv()
 
-# 전역 변수
-browser = None
-page = None
-playwright_instance = None
-browser_lock = threading.Lock()
-is_browser_ready = False
-browser_thread_id = None
+# 분석 데이터 저장소
+analyzed_data = {}
+last_update_time = None
+update_thread = None
+is_updating = False
 
-# Claude API 클라이언트 초기화
 def get_claude_client():
+    """Claude API 클라이언트 초기화"""
     api_key = os.getenv("ANTHROPIC_API_KEY")
     if not api_key:
         raise ValueError("ANTHROPIC_API_KEY 환경변수가 설정되지 않았습니다.")
     
-    try:
-        # 더 안전한 클라이언트 초기화
-        client = anthropic.Anthropic(
-            api_key=api_key,
-            max_retries=2,
-            timeout=60.0
-        )
-        return client
-    except Exception as e:
-        print(f"Claude 클라이언트 초기화 오류: {e}")
-        # 기본 초기화 방식으로 재시도
-        return anthropic.Anthropic(api_key=api_key)
+    return anthropic.Anthropic(
+        api_key=api_key,
+        max_retries=3,
+        timeout=60.0
+    )
 
 def install_browsers():
-    """Playwright 브라우저 및 한글 폰트 설치 (한번만 실행)"""
+    """Playwright 브라우저 설치"""
     try:
-        print("Playwright 브라우저 빠른 설치 중...")
-        # 병렬 설치로 속도 향상
+        print("Playwright 브라우저 설치 중...")
         os.system("playwright install chromium --force")
-        print("한글 폰트 빠른 설치 중...")
-        os.system("apt-get install -y fonts-nanum fonts-noto-cjk &")
-        print("브라우저 및 폰트 설치 완료!")
+        print("브라우저 설치 완료!")
         return True
     except Exception as e:
-        print(f"설치 실패: {e}")
+        print(f"브라우저 설치 실패: {e}")
         return False
 
-def init_browser():
-    """Playwright 브라우저를 초기화하고 Google Trends 페이지로 이동 (WarmUp 전략)"""
-    global browser, page, playwright_instance, is_browser_ready, browser_thread_id
+def capture_trends_screenshot() -> Optional[Image.Image]:
+    """실시간 Google Trends 스크린샷 캡처 (독립 브라우저 세션)"""
+    playwright_instance = None
+    browser = None
+    page = None
     
     try:
-        browser_thread_id = threading.current_thread().ident
-        print(f"브라우저 WarmUp 시작 (스레드: {browser_thread_id})")
-        
-        # 빠른 브라우저 설치
-        install_browsers()
+        print("새 브라우저 세션 시작...")
         
-        # Playwright 인스턴스 생성
+        # 독립적인 Playwright 인스턴스 생성
         playwright_instance = sync_playwright().start()
         
-        # 속도 최적화된 브라우저 실행
+        # 브라우저 실행
         browser = playwright_instance.chromium.launch(
             headless=True,
             args=[
@@ -84,159 +67,77 @@ def init_browser():
                 '--disable-gpu',
                 '--disable-extensions',
                 '--disable-web-security',
-                '--disable-features=VizDisplayCompositor',
-                '--disable-background-timer-throttling',
-                '--disable-renderer-backgrounding',
-                '--disable-plugins',
-                '--disable-images',  # 이미지 로딩 비활성화로 속도 향상
-                '--disable-javascript',  # JS 비활성화로 속도 향상
-                '--disable-css',  # CSS 비활성화로 속도 향상
-                '--force-device-scale-factor=1',
-                '--aggressive-cache-discard',
-                '--memory-pressure-off'
+                '--disable-blink-features=AutomationControlled'
             ]
         )
         
         # 새 페이지 생성
         page = browser.new_page()
-        
-        # 뷰포트 설정 (작게 설정하여 속도 향상)
-        page.set_viewport_size({"width": 1200, "height": 800})
-        
-        # 빠른 헤더 설정
+        page.set_viewport_size({"width": 1400, "height": 900})
         page.set_extra_http_headers({
-            "Accept-Language": "ko-KR,ko;q=0.9"
+            "Accept-Language": "ko-KR,ko;q=0.9,en;q=0.8",
+            "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"
         })
         
-        print("Google Trends 페이지로 빠른 이동 중...")
-        # 빠른 로딩을 위해 domcontentloaded 사용, 타임아웃 단축
-        page.goto("https://trends.google.com/trending?geo=KR", 
-                 wait_until="domcontentloaded", 
-                 timeout=15000)
+        # Google Trends 실시간 페이지 로드
+        url = "https://trends.google.co.kr/trending?geo=KR"
+        print(f"페이지 로드: {url}")
         
-        # 최소 대기 시간으로 단축
-        time.sleep(2)
+        page.goto(url, wait_until="domcontentloaded", timeout=30000)
+        time.sleep(5)
         
-        is_browser_ready = True
-        print("브라우저 WarmUp 완료! (고속 모드)")
-        
-    except Exception as e:
-        print(f"브라우저 초기화 실패: {str(e)}")
-        is_browser_ready = False
-        cleanup_browser()
-
-def ensure_browser_ready():
-    """브라우저가 준비되어 있는지 확인하고, 필요시 초기화"""
-    global is_browser_ready, browser, page, browser_thread_id
-    
-    current_thread_id = threading.current_thread().ident
-    
-    # 브라우저가 준비되지 않았거나 다른 스레드에서 생성된 경우
-    if not is_browser_ready or browser_thread_id != current_thread_id or not browser or not page:
-        print(f"브라우저 재초기화 필요 (현재 스레드: {current_thread_id}, 브라우저 스레드: {browser_thread_id})")
-        
-        # 기존 브라우저 정리
-        cleanup_browser()
-        
-        # 현재 스레드에서 새로 초기화
-        init_browser()
-        
-    return is_browser_ready
-
-def cleanup_browser():
-    """브라우저 정리"""
-    global browser, page, playwright_instance
-    
-    try:
-        if page:
-            page.close()
-            page = None
-        if browser:
-            browser.close()
-            browser = None
-        if playwright_instance:
-            playwright_instance.stop()
-            playwright_instance = None
-        print("브라우저 정리 완료")
-    except Exception as e:
-        print(f"브라우저 정리 중 오류: {e}")
-
-def apply_filters(geo: str, time_range: str, category: str) -> bool:
-    """Google Trends 필터 적용 (고속 모드)"""
-    global page
-    
-    if not ensure_browser_ready():
-        print("브라우저 준비 실패")
-        return False
-        
-    try:
-        print(f"고속 필터 적용: 지역={geo}")
-        
-        # 지역 설정을 위한 URL 구성
-        geo_map = {
-            "KR": "KR", "US": "US", "JP": "JP", 
-            "GB": "GB", "DE": "DE", "FR": "FR"
-        }
-        
-        base_url = "https://trends.google.com/trending"
-        geo_param = geo_map.get(geo, "KR")
-        url = f"{base_url}?geo={geo_param}"
-        
-        print(f"빠른 이동: {url}")
-        # 빠른 로딩을 위해 domcontentloaded 사용, 타임아웃 대폭 단축
-        page.goto(url, wait_until="domcontentloaded", timeout=10000)
-        
-        # 최소 대기 시간
-        time.sleep(1)
-        
-        print("고속 필터 적용 완료")
-        return True
-                
-    except Exception as e:
-        print(f"필터 적용 실패: {str(e)}")
-        # 실패해도 현재 페이지에서 스크린샷 시도
-        return True  # 실패해도 계속 진행
-
-def capture_screenshot() -> Optional[Image.Image]:
-    """현재 페이지의 스크린샷 캡처 (고속 모드)"""
-    global page
-    
-    if not ensure_browser_ready():
-        print("브라우저 준비 실패")
-        return None
-        
-    try:
-        print("고속 스크린샷 캡처 중...")
+        # 쿠키 팝업 처리
+        try:
+            accept_button = page.locator('button:has-text("모두 수락"), button:has-text("Accept all"), button:has-text("수락")')
+            if accept_button.count() > 0:
+                accept_button.first.click(timeout=3000)
+                time.sleep(2)
+        except:
+            pass
         
-        # 대기 시간 최소화
-        time.sleep(0.5)
+        # 페이지 완전 로드 대기
+        time.sleep(3)
         
-        # 빠른 스크린샷을 위해 특정 영역만 캡처
+        # 스크린샷 캡처
         try:
-            # 트렌드 테이블 영역 찾기 (빠른 셀렉터만 사용)
-            element = page.locator('main').first
-            if element.is_visible(timeout=2000):
-                screenshot_bytes = element.screenshot()
-                print("메인 영역 고속 캡처 완료")
+            main_content = page.locator('main, .main-content, [data-ve-type="main"], .trends-wrapper')
+            if main_content.count() > 0 and main_content.first.is_visible():
+                screenshot_bytes = main_content.first.screenshot(timeout=10000)
+                print("메인 컨텐츠 스크린샷 캡처 완료")
             else:
-                # 대안: 페이지 중앙 영역만 빠르게 캡처
-                screenshot_bytes = page.screenshot(clip={"x": 0, "y": 150, "width": 1200, "height": 600})
-                print("중앙 영역 고속 캡처 완료")
-                
-        except Exception:
-            # 최종 대안: 전��� 페이지 캡처
-            screenshot_bytes = page.screenshot()
-            print("전체 페이지 고속 캡처 완료")
-        
+                screenshot_bytes = page.screenshot(full_page=True, timeout=15000)
+                print("전체 페이지 스크린샷 캡처 완료")
+        except Exception as e:
+            print(f"스크린샷 캡처 재시도: {e}")
+            screenshot_bytes = page.screenshot(timeout=15000)
+            print("재시도 스크린샷 캡처 완료")
+        
+        # 이미지 객체 생성
         screenshot = Image.open(io.BytesIO(screenshot_bytes))
+        print("스크린샷 처리 완료")
         return screenshot
-            
+        
     except Exception as e:
         print(f"스크린샷 캡처 실패: {str(e)}")
         return None
+    finally:
+        # 브라우저 정리
+        try:
+            if page:
+                page.close()
+            if browser:
+                browser.close()
+            if playwright_instance:
+                playwright_instance.stop()
+            print("브라우저 세션 정리 완료")
+        except Exception as e:
+            print(f"브라우저 정리 중 오류: {e}")
 
 def analyze_with_claude(image: Image.Image) -> str:
-    """Claude API를 사용하여 이미지 분석 (고속 모드)"""
+    """Claude API로 이미지 분석"""
+    if image is None:
+        return "분석할 이미지가 없습니다."
+    
     try:
         client = get_claude_client()
         
@@ -245,16 +146,40 @@ def analyze_with_claude(image: Image.Image) -> str:
         image.save(buffer, format="PNG")
         image_base64 = base64.b64encode(buffer.getvalue()).decode()
         
-        # 축약된 프롬프트 (속도 향상)
-        prompt = """Google Trends 스크린샷을 간단히 분석해주세요:
-1. 상위 5개 검색어와 순위
-2. 주요 트렌드 패턴
-3. 특이사항
-한국어로 간단명료하게 답변하세요."""
-        
+        # 분석 프롬프트
+        prompt = """Google Trends 실시간 인기 검색어 스크린샷을 분석해주세요.
+
+다음 항목들을 중심으로 한국어로 분석해주세요:
+
+### A. 상위 검색어 순위 (검색량 기준)
+검색량이 높은 순서대로 정렬하여 나열:
+**1위.** 검색어명 (검색량)
+**2위.** 검색어명 (검색량)
+**3위.** 검색어명 (검색량)
+(이런 식으로 10위까지)
+
+### B. 주요 트렌드 키워드
+- 특히 주목할 만한 검색어들
+- 검색량 증가 패턴
+
+### C. 카테고리별 특징
+- 엔터테인먼트, 뉴스, 스포츠 등 분야별 동향
+
+### D. 특이사항 및 분석
+- 급상승 키워드
+- 시기적/사회적 배경 추측
+- 전체적인 관심사 패턴
+
+**중요 지시사항:**
+- 마크다운 형식을 사용하여 **굵은 글씨**, *기울임*, `코드` 등으로 중요한 내용을 강조해주세요
+- 검색어명, 수치, 카테고리명 등 핵심 정보는 **굵은 글씨**로 표시
+- 급상승률이나 특별한 수치는 `백틱`으로 감싸서 강조
+- 상위 검색어는 반드시 검색량 순서대로 1위부터 10위까지 정렬
+- ### 헤딩은 이미 제공되니 내용만 작성해주세요"""
+
         response = client.messages.create(
             model="claude-3-5-sonnet-20241022",
-            max_tokens=800,  # 토큰 수 대폭 축소
+            max_tokens=1500,
             messages=[
                 {
                     "role": "user",
@@ -276,291 +201,253 @@ def analyze_with_claude(image: Image.Image) -> str:
             ]
         )
         
-        return response.content[0].text
+        analysis_result = response.content[0].text
+        print("Claude 분석 완료")
+        return analysis_result
         
     except Exception as e:
         error_msg = f"Claude API 분석 실패: {str(e)}"
         print(error_msg)
         return error_msg
 
-def reinit_browser():
-    """브라우저 경량 재초기화 (기존 브라우저 유지)"""
-    global page
+def perform_analysis():
+    """실시간 트렌드 분석 수행"""
+    global analyzed_data, last_update_time, is_updating
+    
+    is_updating = True
+    print(f"\n{'='*60}")
+    print(f"[{datetime.now().strftime('%Y-%m-%d %H:%M:%S')}] 실시간 트렌드 분석 시작")
+    print(f"{'='*60}")
     
     try:
-        print("경량 브라우저 재초기화 시작...")
+        # 브라우저 설치 확인
+        install_browsers()
         
-        if page:
-            # 브라우저를 완전히 재시작하지 않고 페이지만 새로고침
-            page.goto("https://trends.google.com/trending?geo=KR", 
-                     wait_until="domcontentloaded", 
-                     timeout=10000)
-            time.sleep(1)
-            return "브라우저 경량 재초기화 완료! (기존 브라우저 유지)"
+        # 스크린샷 캡처
+        print("스크린샷 캡처 중...")
+        screenshot = capture_trends_screenshot()
+        
+        if screenshot:
+            print("Claude 분석 중...")
+            # Claude 분석
+            analysis = analyze_with_claude(screenshot)
+            
+            # 결과 저장
+            analyzed_data["실시간"] = {
+                'analysis': analysis,
+                'timestamp': datetime.now().strftime('%Y-%m-%d %H:%M:%S')
+            }
+            
+            last_update_time = datetime.now()
+            print(f"분석 완료 - {last_update_time.strftime('%Y-%m-%d %H:%M:%S')}")
+            return True
         else:
-            # 페이지가 없는 경우에만 완전 재초기화
-            init_browser()
-            if is_browser_ready:
-                return "브라우저 완전 재초기화 완료!"
+            print("스크린샷 캡처 실패")
+            return False
+            
+    except Exception as e:
+        print(f"분석 중 오류: {str(e)}")
+        print(f"상세 오류: {traceback.format_exc()}")
+        return False
+    finally:
+        is_updating = False
+        print(f"{'='*60}\n")
+
+def auto_update_scheduler():
+    """1시간마다 자동 업데이트"""
+    while True:
+        try:
+            print(f"[스케줄러] 다음 업데이트까지 1시간 대기 중...")
+            time.sleep(3600)  # 1시간 대기
+            
+            if not is_updating:
+                print(f"[스케줄러] 자동 업데이트 시작")
+                perform_analysis()
             else:
-                return "브라우저 재초기화 실패"
+                print(f"[스케줄러] 이미 업데이트 중이므로 건너뜀")
                 
-    except Exception as e:
-        print(f"재초기화 실패: {e}")
-        return f"재초기화 실패: {str(e)}"
+        except Exception as e:
+            print(f"[스케줄러] 오류: {e}")
+            time.sleep(300)  # 5분 후 재시도
 
-def refresh_trends_page():
-    """Google Trends 페이지 빠른 새로고침"""
-    global page
+def get_analysis_result() -> tuple:
+    """저장된 분석 결과 반환"""
+    global analyzed_data, last_update_time
     
-    if not ensure_browser_ready():
-        return "브라우저가 준비되지 않았습니다."
-        
-    try:
-        print("빠른 페이지 새로고침...")
-        # reload() 대신 현재 URL로 빠르게 이동
-        current_url = page.url
-        page.goto(current_url, wait_until="domcontentloaded", timeout=8000)
-        time.sleep(0.5)
-        return "페이지 빠른 새로고침 완료!"
-    except Exception as e:
-        return f"페이지 새로고침 실패: {str(e)}"
-
-def main_process_screenshot(geo: str, time_range: str, category: str) -> Tuple[Optional[Image.Image], str]:
-    """스크린샷 캡처만 수행하는 함수 (고속 모드)"""
-    try:
-        # 1. 브라우저 준비 확인 (빠른 확인)
-        if not ensure_browser_ready():
-            return None, "브라우저가 준비되지 않았습니다."
-        
-        # 2. 고속 필터 적용
-        print(f"고속 처리: 지역={geo}")
-        filter_success = apply_filters(geo, time_range, category)
-        
-        # 필터 실패해도 현재 페이지에서 스크린샷 시도
-        if not filter_success:
-            print("필터 적용 실패했지만 현재 페이지에서 스크린샷 시도")
-        
-        # 3. 고속 스크린샷 캡처
-        screenshot = capture_screenshot()
-        
-        if screenshot is None:
-            return None, "스크린샷 캡처에 실패했습니다."
-        
-        return screenshot, "고속 스크린샷 캡처 완료!"
+    if "실시간" in analyzed_data:
+        data = analyzed_data["실시간"]
+        status = f"최신 데이터 (업데이트: {data['timestamp']})"
+        return data['analysis'], status
+    else:
+        if last_update_time:
+            status = f"데이터 없음 (마지막 업데이트: {last_update_time.strftime('%H:%M:%S')})"
+        else:
+            status = "아직 분석 데이터가 준비되지 않았습니다."
         
-    except Exception as e:
-        error_msg = f"고속 처리 중 오류: {str(e)}"
-        print(error_msg)
-        return None, error_msg
+        return "**분석 데이터가 아직 준비되지 않았습니다.**", status
 
-def analyze_screenshot_with_claude(screenshot: Image.Image) -> str:
-    """Claude API로 스크린샷 분석 (고속 모드)"""
-    if screenshot is None:
-        return "분석할 스크린샷이 없습니다."
+def create_interface():
+    """Gradio 인터페이스 생성"""
     
-    try:
-        print("Claude 고속 분석 중...")
-        analysis_result = analyze_with_claude(screenshot)
-        return analysis_result
-        
-    except Exception as e:
-        error_msg = f"Claude 분석 실패: {str(e)}"
-        print(error_msg)
-        return error_msg
-
-def main_process(geo: str, time_range: str, category: str) -> Tuple[Optional[Image.Image], str]:
-    """전체 프로세스 (호환성을 위해 유지)"""
-    try:
-        # 1. 브라우저 준비 확인
-        if not ensure_browser_ready():
-            return None, "브라우저가 준비���지 않았습니다. '브라우저 재초기화' 버튼을 클릭해주세요."
-        
-        # 2. 필터 적용
-        print(f"필터 적용 중: 지역={geo}, 시간={time_range}, 카테고리={category}")
-        filter_success = apply_filters(geo, time_range, category)
-        
-        if not filter_success:
-            return None, "필터 적용에 실패했습니다."
+    def show_cached_analysis():
+        """저장된 분석 결과 표시"""
+        if "실시간" in analyzed_data:
+            data = analyzed_data["실시간"]
+            status = f"캐시된 분석 결과 (업데이트: {data['timestamp']})"
+            return data['analysis'], status
+        else:
+            if last_update_time:
+                status = f"저장된 데이터 없음 (마지막 업데이트: {last_update_time.strftime('%H:%M:%S')})"
+            else:
+                status = "아직 분석 데이터가 준비되지 않았습니다. 잠시 후 다시 시도해주세요."
+            
+            return "**저장된 분석 데이터가 없습니다.**\n\n'실시간 업데이트' 버튼을 눌러주세요.", status
+    
+    def perform_live_update():
+        """실시간 업데이트 수행"""
+        if is_updating:
+            return "**현재 업데이트가 진행 중입니다.**\n\n잠시 후 다시 시도해주세요.", "업데이트 진행 중..."
         
-        # 3. 스크린샷 캡처
-        print("스크린샷 캡처 중...")
-        screenshot = capture_screenshot()
+        print("실시간 업데이트 요청됨")
+        success = perform_analysis()
         
-        if screenshot is None:
-            return None, "스크린샷 캡처에 실패했습니다."
+        if success and analyzed_data:
+            data = analyzed_data["실시간"]
+            return data['analysis'], f"실시간 업데이트 완료 - {datetime.now().strftime('%H:%M:%S')}"
+        else:
+            return "**업데이트에 실패했습니다.**\n\n잠시 후 다시 시도해주세요.", f"업데이트 실패 - {datetime.now().strftime('%H:%M:%S')}"
+    
+    # Gradio 인터페이스 구성
+    with gr.Blocks(
+        title="Google Trends 인기 검색어", 
+        theme=gr.themes.Soft(),
+        css="""
+        @import url('https://fonts.googleapis.com/css2?family=Noto+Sans+KR:wght@300;400;500;700&display=swap');
+        
+        * {
+            font-family: 'Noto Sans KR', sans-serif !important;
+        }
         
-        # 4. Claude API로 분석
-        print("Claude API로 분석 중...")
-        analysis_result = analyze_with_claude(screenshot)
+        .markdown-content {
+            font-size: 14px;
+            line-height: 1.6;
+            background: #f8f9fa;
+            padding: 20px;
+            border-radius: 8px;
+            border: 1px solid #e9ecef;
+        }
         
-        return screenshot, analysis_result
+        .markdown-content h3 {
+            color: #2563eb;
+            margin-top: 20px;
+            margin-bottom: 10px;
+        }
         
-    except Exception as e:
-        error_msg = f"처리 중 오류 발생: {str(e)}"
-        print(error_msg)
-        print(traceback.format_exc())
-        return None, error_msg
-
-def check_browser_status():
-    """브라우저 상태 확인 (고속)"""
-    global is_browser_ready, page, browser_thread_id
-    
-    current_thread_id = threading.current_thread().ident
-    
-    if not page:
-        return "브라우저 미초기화"
-    
-    if not is_browser_ready:
-        return "브라우저 초기화 중..."
-    
-    try:
-        current_url = page.url
-        return f"브라우저 준비완료 - URL: {current_url[:50]}..."
-    except Exception as e:
-        return f"브라우저 연결 문제: {str(e)[:30]}..."
-
-# Gradio 인터페이스 생성
-def create_interface():
-    """Gradio 인터페이스 생성"""
-    
-    with gr.Blocks(title="Google Trends 고속 분석기", theme=gr.themes.Soft()) as interface:
-        gr.Markdown("# ⚡ Google Trends 고속 분석기")
-        gr.Markdown("**초고속 모드**: Google Trends 실시간 검색어를 빠르게 캡처하고 AI 분석합니다.")
+        .markdown-content strong {
+            color: #1d4ed8;
+            font-weight: 600;
+        }
+        """
+    ) as interface:
         
-        # 상태 저장을 위한 State 컴포넌트
-        screenshot_state = gr.State(None)
+        gr.Markdown("# Google Trends 인기 검색어")
         
         with gr.Row():
             with gr.Column(scale=1):
-                geo_dropdown = gr.Dropdown(
-                    choices=["KR", "US", "JP", "GB", "DE", "FR"],
-                    value="KR",
-                    label="지역 선택"
-                )
+                gr.Markdown("### 분석 옵션")
                 
-                time_dropdown = gr.Dropdown(
-                    choices=["24시간", "7일", "30일", "90일", "12개월"],
-                    value="24시간", 
-                    label="기간 선택"
-                )
+                with gr.Column():
+                    cached_btn = gr.Button("실시간 검색어 분석", variant="primary", size="lg")
                 
-                category_dropdown = gr.Dropdown(
-                    choices=["모든 카테고리", "엔터테인먼트", "스포츠", "비즈니스", "과학기술", "건강"],
-                    value="모든 카테고리",
-                    label="카테고리 선택"
-                )
+                gr.Markdown("---")
+                
+                with gr.Column():
+                    live_btn = gr.Button("실시간 업데이트", variant="secondary", size="lg")
                 
-                with gr.Row():
-                    capture_btn = gr.Button("⚡ 고속 캡처", variant="primary", size="lg")
-                    analyze_btn = gr.Button("🤖 AI 분석", variant="secondary", interactive=False)
+                gr.Markdown("---")
                 
-                with gr.Row():
-                    refresh_btn = gr.Button("🔄 빠른 새로고침", variant="secondary", size="sm")
-                    reinit_btn = gr.Button("⚙️ 경량 재시작", variant="secondary", size="sm")
-                    status_btn = gr.Button("📊 상태 확인", variant="secondary", size="sm")
+                status_output = gr.Textbox(
+                    label="상태",
+                    value="분석할 옵션을 선택해주세요.",
+                    interactive=False
+                )
+                
+                # Apeach 이미지 표시
+                gr.Image(
+                    value="apeach.png",
+                    label=None,
+                    show_label=False,
+                    interactive=False,
+                    height=200,
+                    width=200
+                )
             
             with gr.Column(scale=2):
-                screenshot_output = gr.Image(label="Google Trends 스크린샷")
-                analysis_output = gr.Textbox(
-                    label="Claude AI 고속 분석 결과",
-                    lines=8,
-                    max_lines=15,
-                    placeholder="고속 캡처 후 'AI 분석' 버튼을 클릭하세요."
+                analysis_output = gr.Markdown(
+                    value="**분석 버튼을 눌러주세요.**",
+                    elem_classes=["markdown-content"],
+                    height=600
                 )
-                status_output = gr.Textbox(label="상태 메시지")
-        
-        # 이벤트 핸들러
         
-        # 고속 캡처 버튼
-        def on_capture_click(geo, time_range, category):
-            screenshot, message = main_process_screenshot(geo, time_range, category)
-            if screenshot is not None:
-                # 분석 버튼 활성화
-                return screenshot, screenshot, message, gr.update(interactive=True)
-            else:
-                return None, None, message, gr.update(interactive=False)
-        
-        capture_btn.click(
-            fn=on_capture_click,
-            inputs=[geo_dropdown, time_dropdown, category_dropdown],
-            outputs=[screenshot_output, screenshot_state, status_output, analyze_btn]
-        )
-        
-        # AI 분석 버튼
-        def on_analyze_click(screenshot):
-            if screenshot is None:
-                return "분석할 스크린샷이 없습니다. 먼저 '고속 캡처' 버튼을 클릭하세요."
-            
-            analysis_result = analyze_screenshot_with_claude(screenshot)
-            return analysis_result
-        
-        analyze_btn.click(
-            fn=on_analyze_click,
-            inputs=[screenshot_state],
-            outputs=[analysis_output]
-        )
-        
-        # 기타 버튼들
-        refresh_btn.click(
-            fn=refresh_trends_page,
-            outputs=status_output
-        )
-        
-        reinit_btn.click(
-            fn=reinit_browser,
-            outputs=status_output
+        # 이벤트 연결
+        cached_btn.click(
+            fn=show_cached_analysis,
+            outputs=[analysis_output, status_output]
         )
         
-        status_btn.click(
-            fn=check_browser_status,
-            outputs=status_output
+        live_btn.click(
+            fn=perform_live_update,
+            outputs=[analysis_output, status_output]
         )
     
     return interface
 
 def main():
-    """메인 함수 (WarmUp 전략 적용)"""
-    print("=" * 50)
-    print("Google Trends 고속 분석기 시작!")
-    print("=" * 50)
+    """메인 함수"""
+    print("=" * 60)
+    print("Google Trends 인기 검색어 시작!")
+    print("=" * 60)
     
     # API 키 확인
     api_key = os.getenv("ANTHROPIC_API_KEY")
     if not api_key:
-        print("✗ ANTHROPIC_API_KEY 환경변수가 설정되지 않았습니다.")
+        print("ANTHROPIC_API_KEY 환경변수가 설정되지 않았습니다.")
+        print("  .env 파일에 ANTHROPIC_API_KEY=your_key_here 를 추가하세요.")
         return
     else:
-        print("✓ Claude API 키 확인됨")
-    
-    print("✓ Gradio 고속 인터페이스 준비 중...")
-    
-    # 환경 확인
-    if os.getenv("SPACE_ID"):
-        print("✓ Hugging Face Space 환경에서 실행 중...")
+        print("Claude API 키 확인됨")
     
-    print("✓ 브라우저 WarmUp 시작 (백그라운드)")
+    # 초기 분석 수행
+    print("초기 분석 시작...")
+    initial_success = perform_analysis()
     
-    # WarmUp 전략: 백그라운드에서 브라우저 미리 준비
-    warmup_thread = threading.Thread(target=init_browser, daemon=True)
-    warmup_thread.start()
-    
-    # 종료 시 브라우저 정리
-    atexit.register(cleanup_browser)
+    if initial_success:
+        print("초기 분석 완료")
+    else:
+        print("초기 분석 실패, 서비스는 계속 진행됩니다.")
     
-    # Gradio 인터페이스 생성 및 실행
-    interface = create_interface()
+    # 자동 업데이트 스케줄러 시작
+    print("자동 업데이트 스케줄러 시작 (1시간 간격)")
+    global update_thread
+    update_thread = threading.Thread(target=auto_update_scheduler, daemon=True)
+    update_thread.start()
     
-    print("✓ 고속 분석기 준비 완료!")
+    print("모든 준비 완료!")
+    print("=" * 60)
     
-    # 빠른 실행을 위한 설정
-    interface.launch(
-        server_name="0.0.0.0",
-        server_port=7860,
-        share=False,
-        show_error=True,
-        quiet=True  # 로그 출력 최소화
-    )
+    # Gradio 인터페이스 실행
+    try:
+        interface = create_interface()
+        interface.launch(
+            server_name="0.0.0.0",
+            server_port=7860,
+            share=False,
+            show_error=True,
+            quiet=False
+        )
+    except Exception as e:
+        print(f"인터페이스 시작 실패: {e}")
+        print(f"상세 오류: {traceback.format_exc()}")
 
 if __name__ == "__main__":
     main()