edit

app.py

@@ -5,8 +5,10 @@ import io
 import threading
 import atexit
 import traceback
+import asyncio
+import concurrent.futures
 from datetime import datetime
-from typing import Optional, Dict, Any
+from typing import Optional, Dict, Any, Tuple
 
 import gradio as gr
 import anthropic
@@ -23,6 +25,10 @@ last_update_time = None
 update_thread = None
 is_updating = False
 
+# 전역 브라우저 인스턴스
+global_playwright = None
+global_browser = None
+
 def get_claude_client():
     """Claude API 클라이언트 초기화"""
     api_key = os.getenv("ANTHROPIC_API_KEY")
@@ -46,44 +52,113 @@ def install_browsers():
         print(f"브라우저 설치 실패: {e}")
         return False
 
-def capture_trends_screenshot() -> Optional[Image.Image]:
-    """실시간 Google Trends 스크린샷 캡처 (독립 브라우저 세션)"""
-    playwright_instance = None
-    browser = None
-    page = None
+def get_shared_browser():
+    """공유 브라우저 인스턴스 반환 (재사용 최적화 + 안정성 강화)"""
+    global global_playwright, global_browser
     
     try:
-        print("새 브라우저 세션 시작...")
-        
-        # 독립적인 Playwright 인스턴스 생성
-        playwright_instance = sync_playwright().start()
+        # Playwright 인스턴스 초기화
+        if global_playwright is None:
+            print("Playwright 인스턴스 초기화...")
+            global_playwright = sync_playwright().start()
+            print("Playwright 초기화 완료")
         
-        # 브라우저 실행
-        browser = playwright_instance.chromium.launch(
-            headless=True,
-            args=[
+        # 브라우저 인스턴스 확인 및 생성
+        if global_browser is None or not global_browser.is_connected():
+            print("브라우저 인스턴스 생성 중...")
+            
+            # 브라우저 실행 옵션
+            browser_args = [
                 '--no-sandbox',
                 '--disable-dev-shm-usage',
                 '--disable-gpu',
                 '--disable-extensions',
                 '--disable-web-security',
-                '--disable-blink-features=AutomationControlled'
+                '--disable-blink-features=AutomationControlled',
+                '--disable-background-timer-throttling',
+                '--disable-backgrounding-occluded-windows',
+                '--disable-renderer-backgrounding',
+                '--disable-features=TranslateUI',
+                '--disable-ipc-flooding-protection'
             ]
-        )
+            
+            global_browser = global_playwright.chromium.launch(
+                headless=True,
+                args=browser_args
+            )
+            print("브라우저 인스턴스 생성 완료")
+        
+        # 연결 상태 재확인
+        if global_browser.is_connected():
+            print("브라우저 연결 상태 양호")
+            return global_browser
+        else:
+            print("브라우저 연결 상태 불량, 재생성 시도")
+            global_browser = None
+            return get_shared_browser()  # 재귀 호출로 재생성
+        
+    except Exception as e:
+        print(f"브라우저 인스턴스 생성 실패: {str(e)}")
+        print(f"상세 오류: {traceback.format_exc()}")
+        
+        # 실패시 정리하고 None 반환
+        try:
+            if global_browser:
+                global_browser.close()
+            if global_playwright:
+                global_playwright.stop()
+        except:
+            pass
+        
+        global_browser = None
+        global_playwright = None
+        return None
+
+def cleanup_browser():
+    """브라우저 정리"""
+    global global_playwright, global_browser
+    try:
+        if global_browser:
+            global_browser.close()
+            global_browser = None
+        if global_playwright:
+            global_playwright.stop()
+            global_playwright = None
+    except:
+        pass
+
+def capture_google_trends() -> Optional[Image.Image]:
+    """Google Trends 스크린샷 캡처 (동적 로딩 대응)"""
+    page = None
+    
+    try:
+        print("Google Trends 스크린샷 시작...")
+        browser = get_shared_browser()
+        if not browser:
+            print("브라우저 초기화 실패")
+            return None
         
-        # 새 페이지 생성
         page = browser.new_page()
         page.set_viewport_size({"width": 1400, "height": 900})
         page.set_extra_http_headers({
             "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"
+            "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",
+            "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8"
         })
         
-        # Google Trends 실시간 페이지 로드
         url = "https://trends.google.co.kr/trending?geo=KR"
-        print(f"페이지 로드: {url}")
+        print(f"페이지 접속: {url}")
+        
+        # 페이지 로딩 (networkidle로 JavaScript 완료까지 대기)
+        try:
+            page.goto(url, wait_until="networkidle", timeout=45000)
+            print("페이지 로딩 완료")
+        except:
+            # networkidle 실패시 domcontentloaded로 재시도
+            page.goto(url, wait_until="domcontentloaded", timeout=30000)
+            print("기본 페이지 로딩 완료")
         
-        page.goto(url, wait_until="domcontentloaded", timeout=30000)
+        # 초기 대기
         time.sleep(5)
         
         # 쿠키 팝업 처리
@@ -91,62 +166,133 @@ def capture_trends_screenshot() -> Optional[Image.Image]:
             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)
+                print("쿠키 팝업 처리됨")
+                time.sleep(3)
+        except Exception as e:
+            print(f"쿠키 팝업 처리 실패 (무시): {e}")
+        
+        # 트렌드 데이터 로딩 대기
+        try:
+            # 트렌드 컨텐츠가 로드될 때까지 대기
+            page.wait_for_selector("main, .trending-content, .trends-wrapper, [data-topic]", timeout=15000)
+            print("트렌드 컨텐츠 로딩 확인됨")
         except:
-            pass
+            print("트렌드 요소를 찾을 수 없음, 계속 진행")
         
-        # 페이지 완전 로드 대기
-        time.sleep(3)
+        # 추가 대기 (동적 컨텐츠 완전 로딩)
+        time.sleep(5)
         
-        # 스크린샷 캡처
+        # 핵심 영역 스크린샷
+        print("스크린샷 캡처 시작...")
         try:
             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("메인 컨텐츠 스크린샷 캡처 완료")
+                screenshot_bytes = main_content.first.screenshot(timeout=15000)
+                print("메인 컨텐츠 스크린샷 캡처됨")
             else:
-                screenshot_bytes = page.screenshot(full_page=True, timeout=15000)
-                print("전체 페이지 스크린샷 캡처 완료")
+                screenshot_bytes = page.screenshot(timeout=20000)
+                print("전체 페이지 스크린샷 캡처됨")
         except Exception as e:
             print(f"스크린샷 캡처 재시도: {e}")
-            screenshot_bytes = page.screenshot(timeout=15000)
+            screenshot_bytes = page.screenshot(timeout=20000)
             print("재시도 스크린샷 캡처 완료")
         
-        # 이미지 객체 생성
         screenshot = Image.open(io.BytesIO(screenshot_bytes))
-        print("스크린샷 처리 완료")
+        print("Google Trends 스크린샷 완료")
         return screenshot
         
     except Exception as e:
-        print(f"스크린샷 캡처 실패: {str(e)}")
+        print(f"Google Trends 스크린샷 실패: {str(e)}")
+        print(f"상세 오류: {traceback.format_exc()}")
         return None
     finally:
-        # 브라우저 정리
-        try:
-            if page:
+        if page:
+            try:
                 page.close()
-            if browser:
-                browser.close()
-            if playwright_instance:
-                playwright_instance.stop()
-            print("브라우저 세션 정리 완료")
+            except:
+                pass
+
+def capture_ezme_trends() -> Optional[Image.Image]:
+    """rank.ezme.net 스크린샷 캡처 (동적 로딩 대응)"""
+    page = None
+    
+    try:
+        print("rank.ezme.net 스크린샷 시작...")
+        browser = get_shared_browser()
+        if not browser:
+            print("브라우저 초기화 실패")
+            return None
+        
+        page = browser.new_page()
+        page.set_viewport_size({"width": 1400, "height": 1200})
+        page.set_extra_http_headers({
+            "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",
+            "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8"
+        })
+        
+        url = "https://rank.ezme.net/diff/"
+        print(f"페이지 접속: {url}")
+        
+        # 페이지 로딩 (networkidle 대기로 JavaScript 로딩 완료까지 대기)
+        try:
+            page.goto(url, wait_until="networkidle", timeout=45000)
+            print("페이지 로딩 완료")
+        except:
+            # networkidle 실패시 domcontentloaded로 재시도
+            page.goto(url, wait_until="domcontentloaded", timeout=30000)
+            print("기본 페이지 로딩 완료")
+        
+        # JavaScript 실행 및 데이터 로딩 대기
+        print("동적 컨텐츠 로딩 대기중...")
+        time.sleep(8)  # 더 긴 대기 시간
+        
+        # 테이블 데이터가 로드되었는지 확인
+        try:
+            # 시간별 데이터 테이블 요소 대기
+            page.wait_for_selector("table, .table, td", timeout=10000)
+            print("테이블 데이터 로딩 확인됨")
+        except:
+            print("테이블 요소를 찾을 수 없음, 계속 진행")
+        
+        # 페이지 중간으로 스크롤 (시간별 검색어 데이터 영역)
+        try:
+            page.evaluate("window.scrollTo(0, document.body.scrollHeight * 0.4)")
+            time.sleep(3)
+            print("스크롤 완료")
         except Exception as e:
-            print(f"브라우저 정리 중 오류: {e}")
+            print(f"스크롤 실패: {e}")
+        
+        # 전체 페이지 스크린샷
+        print("스크린샷 캡처 시작...")
+        screenshot_bytes = page.screenshot(full_page=True, timeout=20000)
+        screenshot = Image.open(io.BytesIO(screenshot_bytes))
+        print("rank.ezme.net 스크린샷 완료")
+        return screenshot
+        
+    except Exception as e:
+        print(f"rank.ezme.net 스크린샷 실패: {str(e)}")
+        print(f"상세 오류: {traceback.format_exc()}")
+        return None
+    finally:
+        if page:
+            try:
+                page.close()
+            except:
+                pass
 
-def analyze_with_claude(image: Image.Image) -> str:
-    """Claude API로 이미지 분석"""
+def analyze_google_trends_with_claude(image: Image.Image) -> str:
+    """Google Trends 이미지 Claude 분석"""
     if image is None:
-        return "분석할 이미지가 없습니다."
+        return "Google Trends 분석할 이미지가 없습니다."
     
     try:
         client = get_claude_client()
         
-        # 이미지를 base64로 인코딩
         buffer = io.BytesIO()
         image.save(buffer, format="PNG")
         image_base64 = base64.b64encode(buffer.getvalue()).decode()
         
-        # 분석 프롬프트
         prompt = """Google Trends 실시간 인기 검색어 스크린샷을 분석해주세요.
 
 다음 항목들을 중심으로 한국어로 분석해주세요:
@@ -174,12 +320,87 @@ def analyze_with_claude(image: Image.Image) -> str:
 - 마크다운 형식을 사용하여 **굵은 글씨**, *기울임*, `코드` 등으로 중요한 내용을 강조해주세요
 - 검색어명, 수치, 카테고리명 등 핵심 정보는 **굵은 글씨**로 표시
 - 급상승률이나 특별한 수치는 `백틱`으로 감싸서 강조
-- 상위 검색어는 반드시 검색량 순서대로 1위부터 10위까지 정렬
-- ### 헤딩은 이미 제공되니 내용만 작성해주세요"""
+- 상위 검색어는 반드시 검색량 순서대로 1위부터 10위까지 정렬"""
+
+        response = client.messages.create(
+            model="claude-3-5-sonnet-20241022",
+            max_tokens=1200,
+            messages=[
+                {
+                    "role": "user",
+                    "content": [
+                        {
+                            "type": "text",
+                            "text": prompt
+                        },
+                        {
+                            "type": "image",
+                            "source": {
+                                "type": "base64",
+                                "media_type": "image/png",
+                                "data": image_base64
+                            }
+                        }
+                    ]
+                }
+            ]
+        )
+        
+        return response.content[0].text
+        
+    except Exception as e:
+        return f"Google Trends Claude 분석 실패: {str(e)}"
+
+def analyze_ezme_trends_with_claude(image: Image.Image) -> str:
+    """rank.ezme.net 이미지 Claude 분석"""
+    if image is None:
+        return "rank.ezme.net 분석할 이미지가 없습니다."
+    
+    try:
+        client = get_claude_client()
+        
+        buffer = io.BytesIO()
+        image.save(buffer, format="PNG")
+        image_base64 = base64.b64encode(buffer.getvalue()).decode()
+        
+        prompt = """한국 포털사이트별 시간별 실시간 검색어 데이터를 분석해주세요.
+
+다음 항목들을 중심으로 한국어로 분석해주세요:
+
+### A. 도메인별 주요 검색어
+**Zum (줌) 주요 검색어:**
+- 상위 검색어와 진입 횟수
+- 주요 관심 분야
+
+**Nate (네이트) 주요 검색어:**
+- 상위 검색어와 진입 횟수
+- 주요 관심 분야
+
+**Google 한국 주요 검색어:**
+- 상위 검색어와 진입 횟수
+- 주요 관심 분야
+
+### B. 시간대별 트렌드 변화
+- 최근 몇 시간 동안의 변화 패턴
+- 시간대별 주요 이슈 변화
+
+### C. 검색어 진입 횟수 분석
+- 가장 높은 진�� 횟수를 기록한 검색어들
+- 지속적으로 상위권을 유지하는 검색어들
+
+### D. 포털별 관심사 차이점
+- 각 포털사이트별 특성 분석
+- 사용자층별 관심사 차이
+
+**중요 지시사항:**
+- 마크다운 형식을 사용하여 **굵은 글씨**로 검색어명 강조
+- 진입 횟수는 `백틱`으로 감싸서 표시 (예: `진입횟수: 15회`)
+- 시간별 데이터가 있다면 구체적으로 언급
+- 각 포털의 특징을 명확히 구분하여 분석"""
 
         response = client.messages.create(
             model="claude-3-5-sonnet-20241022",
-            max_tokens=1500,
+            max_tokens=1200,
             messages=[
                 {
                     "role": "user",
@@ -201,54 +422,155 @@ def analyze_with_claude(image: Image.Image) -> str:
             ]
         )
         
-        analysis_result = response.content[0].text
-        print("Claude 분석 완료")
-        return analysis_result
+        return response.content[0].text
         
     except Exception as e:
-        error_msg = f"Claude API 분석 실패: {str(e)}"
-        print(error_msg)
-        return error_msg
+        return f"rank.ezme.net Claude 분석 실패: {str(e)}"
+
+def combine_analysis_results(google_analysis: str, ezme_analysis: str) -> str:
+    """Google Trends와 ezme 분석 결과 통합 (오류 상황 대응)"""
+    timestamp = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
+    
+    # 성공/실패 상태 확인
+    google_failed = "분석할 이미지가 없습니다" in google_analysis or "캡처에 실패" in google_analysis
+    ezme_failed = "분석할 이미지가 없습니다" in ezme_analysis or "캡처에 실패" in ezme_analysis
+    
+    # 상태 메시지 생성
+    if google_failed and ezme_failed:
+        status_msg = "**모든 데이터 소스의 수집에 실패했습니다.** 잠시 후 다시 시도해주세요."
+    elif google_failed:
+        status_msg = "**Google Trends 데이터 수집에 실패했습니다.** 한국 포털 데이터만 제공됩니다."
+    elif ezme_failed:
+        status_msg = "**한국 포털 데이터 수집에 실패했습니다.** Google Trends 데이터만 제공됩니다."
+    else:
+        status_msg = "**모든 데이터 소스를 성공적으로 수집했습니다.**"
+    
+    combined_result = f"""# 실시간 검색어 통합 분석
+
+**최종 업데이트:** {timestamp}
+
+{status_msg}
 
-def perform_analysis():
-    """실시간 트렌드 분석 수행"""
+---
+
+## Google Trends 글로벌 동향
+
+{google_analysis}
+
+---
+
+## 한국 포털 실시간 검색어
+
+{ezme_analysis}
+
+---
+
+## 종합 분석 및 인사이트
+
+### 주요 공통 이슈
+- Google Trends와 한국 포털에서 공통적으로 상위권에 나타나는 검색어들을 통해 현재 가장 뜨거운 이슈를 파악할 수 있습니다.
+
+### 플랫폼별 특성
+- **Google Trends**: 전세계적 관심사와 장기적 트렌드 반영
+- **한국 포털 (Zum, Nate, Google)**: 한국 사용자의 실시간 관심사와 즉시성 있는 이슈 반영
+
+### 시간대별 검색 패턴
+- 각 시간대별로 나타나는 검색어 변화를 통해 한국 사용자들의 일상 패턴과 관심사 변화를 관찰할 수 있습니다.
+
+### 데이터 수집 정보
+- **수집 방식**: Playwright를 통한 스크린샷 + Claude AI 분석
+- **업데이트 주기**: 1시간마다 자동 업데이트
+- **분석 범위**: Google Trends(글로벌) + rank.ezme.net(한국 포털 3곳)
+"""
+    
+    return combined_result
+
+def perform_parallel_analysis() -> Tuple[bool, str]:
+    """병렬 처리로 통합 분석 수행 (개선된 오류 처리)"""
     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"[{datetime.now().strftime('%Y-%m-%d %H:%M:%S')}] 통합 실시간 트렌드 분석 시작")
     print(f"{'='*60}")
     
     try:
         # 브라우저 설치 확인
+        print("1. 브라우저 설치 확인...")
         install_browsers()
         
-        # 스크린샷 캡처
-        print("스크린샷 캡처 중...")
-        screenshot = capture_trends_screenshot()
+        # 병렬 스크린샷 캡처
+        print("2. 병렬 스크린샷 캡처 시작...")
         
-        if screenshot:
-            print("Claude 분석 중...")
-            # Claude 분석
-            analysis = analyze_with_claude(screenshot)
+        with concurrent.futures.ThreadPoolExecutor(max_workers=2) as executor:
+            print("   - Google Trends 스크린샷 작업 시작")
+            google_future = executor.submit(capture_google_trends)
             
-            # 결과 저장
-            analyzed_data["실시간"] = {
-                'analysis': analysis,
-                'timestamp': datetime.now().strftime('%Y-%m-%d %H:%M:%S')
-            }
+            print("   - rank.ezme.net 스크린샷 작업 시작")
+            ezme_future = executor.submit(capture_ezme_trends)
             
-            last_update_time = datetime.now()
-            print(f"분석 완료 - {last_update_time.strftime('%Y-%m-%d %H:%M:%S')}")
-            return True
+            print("   - 두 작업 완료 대기 중...")
+            google_screenshot = google_future.result()
+            ezme_screenshot = ezme_future.result()
+        
+        # 스크린샷 결과 확인
+        print("3. 스크린샷 결과 확인...")
+        google_success = google_screenshot is not None
+        ezme_success = ezme_screenshot is not None
+        
+        print(f"   - Google Trends 스크린샷: {'성공' if google_success else '실패'}")
+        print(f"   - rank.ezme.net 스크린샷: {'성공' if ezme_success else '실패'}")
+        
+        if not google_success and not ezme_success:
+            error_msg = "모든 스크린샷 캡처에 실패했습니다."
+            print(f"   ERROR: {error_msg}")
+            return False, error_msg
+        
+        print("4. Claude 분석 시작...")
+        
+        # Claude 분석 (순차 처리 - API 제한)
+        if google_success:
+            print("   - Google Trends 분석 중...")
+            google_analysis = analyze_google_trends_with_claude(google_screenshot)
+            print("   - Google Trends 분석 완료")
         else:
-            print("스크린샷 캡처 실패")
-            return False
+            google_analysis = "Google Trends 스크린샷 캡처에 실패하여 분석할 수 없습니다."
             
+        if ezme_success:
+            print("   - rank.ezme.net 분석 중...")
+            ezme_analysis = analyze_ezme_trends_with_claude(ezme_screenshot)
+            print("   - rank.ezme.net 분석 완료")
+        else:
+            ezme_analysis = "rank.ezme.net 스크린샷 캡처에 실패하여 분석할 수 없습니다."
+        
+        print("5. 통합 분석 결과 생성...")
+        
+        # 통합 분석 결과 생성
+        combined_analysis = combine_analysis_results(google_analysis, ezme_analysis)
+        
+        # 결과 저장
+        analyzed_data["통합실시간"] = {
+            'analysis': combined_analysis,
+            'timestamp': datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
+            'google_analysis': google_analysis,
+            'ezme_analysis': ezme_analysis,
+            'google_success': google_success,
+            'ezme_success': ezme_success
+        }
+        
+        last_update_time = datetime.now()
+        
+        success_count = sum([google_success, ezme_success])
+        print(f"통합 분석 완료 - {last_update_time.strftime('%Y-%m-%d %H:%M:%S')}")
+        print(f"성공률: {success_count}/2 소스")
+        
+        return True, combined_analysis
+        
     except Exception as e:
-        print(f"분석 중 오류: {str(e)}")
+        error_msg = f"통합 분석 중 예상치 못한 오류: {str(e)}"
+        print(f"ERROR: {error_msg}")
         print(f"상세 오류: {traceback.format_exc()}")
-        return False
+        return False, error_msg
     finally:
         is_updating = False
         print(f"{'='*60}\n")
@@ -262,7 +584,7 @@ def auto_update_scheduler():
             
             if not is_updating:
                 print(f"[스케줄러] 자동 업데이트 시작")
-                perform_analysis()
+                perform_parallel_analysis()
             else:
                 print(f"[스케줄러] 이미 업데이트 중이므로 건너뜀")
                 
@@ -270,12 +592,12 @@ def auto_update_scheduler():
             print(f"[스케줄러] 오류: {e}")
             time.sleep(300)  # 5분 후 재시도
 
-def get_analysis_result() -> tuple:
-    """저장된 분석 결과 반환"""
+def get_cached_analysis_result() -> tuple:
+    """저장된 통합 분석 결과 반환"""
     global analyzed_data, last_update_time
     
-    if "실시간" in analyzed_data:
-        data = analyzed_data["실시간"]
+    if "통합실시간" in analyzed_data:
+        data = analyzed_data["통합실시간"]
         status = f"최신 데이터 (업데이트: {data['timestamp']})"
         return data['analysis'], status
     else:
@@ -284,16 +606,16 @@ def get_analysis_result() -> tuple:
         else:
             status = "아직 분석 데이터가 준비되지 않았습니다."
         
-        return "**분석 데이터가 아직 준비되지 않았습니다.**", status
+        return "**분석 데이터가 아직 준비되지 않았습니다.**\n\n잠시 후 다시 시도해주세요.", status
 
 def create_interface():
     """Gradio 인터페이스 생성"""
     
     def show_cached_analysis():
-        """저장된 분석 결과 표시"""
-        if "실시간" in analyzed_data:
-            data = analyzed_data["실시간"]
-            status = f"캐시된 분석 결과 (업데이트: {data['timestamp']})"
+        """저장된 통합 분석 결과 표시"""
+        if "통합실시간" in analyzed_data:
+            data = analyzed_data["통합실시간"]
+            status = f"���시된 통합 분석 결과 (업데이트: {data['timestamp']})"
             return data['analysis'], status
         else:
             if last_update_time:
@@ -301,25 +623,25 @@ def create_interface():
             else:
                 status = "아직 분석 데이터가 준비되지 않았습니다. 잠시 후 다시 시도해주세요."
             
-            return "**저장된 분석 데이터가 없습니다.**\n\n'실시간 업데이트' 버튼을 눌러주세요.", status
+            return "**저장된 통합 분석 데이터가 없습니다.**\n\n'실시간 업데이트' 버튼을 눌러주세요.", status
     
     def perform_live_update():
         """실시간 업데이트 수행"""
         if is_updating:
             return "**현재 업데이트가 진행 중입니다.**\n\n잠시 후 다시 시도해주세요.", "업데이트 진행 중..."
         
-        print("실시간 업데이트 요청됨")
-        success = perform_analysis()
+        print("실시간 통합 업데이트 요청됨")
+        success, result = perform_parallel_analysis()
         
-        if success and analyzed_data:
-            data = analyzed_data["실시간"]
+        if success and "통합실시간" in 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 인기 검색어", 
+        title="통합 실시간 검색어 분석", 
         theme=gr.themes.Soft(),
         css="""
         @import url('https://fonts.googleapis.com/css2?family=Noto+Sans+KR:wght@300;400;500;700&display=swap');
@@ -337,8 +659,19 @@ def create_interface():
             border: 1px solid #e9ecef;
         }
         
-        .markdown-content h3 {
+        .markdown-content h1 {
+            color: #1d4ed8;
+            margin-bottom: 15px;
+        }
+        
+        .markdown-content h2 {
             color: #2563eb;
+            margin-top: 25px;
+            margin-bottom: 12px;
+        }
+        
+        .markdown-content h3 {
+            color: #3b82f6;
             margin-top: 20px;
             margin-bottom: 10px;
         }
@@ -350,19 +683,22 @@ def create_interface():
         """
     ) as interface:
         
-        gr.Markdown("# Google Trends 인기 검색어")
+        gr.Markdown("# 통합 실시간 검색어 분석")
+        gr.Markdown("Google Trends와 한국 포털사이트 검색어를 통합 분석합니다.")
         
         with gr.Row():
             with gr.Column(scale=1):
                 gr.Markdown("### 분석 옵션")
                 
                 with gr.Column():
-                    cached_btn = gr.Button("실시간 검색어 분석", variant="primary", size="lg")
+                    cached_btn = gr.Button("통합 검색어 분석", variant="primary", size="lg")
+                    gr.Markdown("저장된 통합 분석 결과를 즉시 표시합니다.")
                 
                 gr.Markdown("---")
                 
                 with gr.Column():
                     live_btn = gr.Button("실시간 업데이트", variant="secondary", size="lg")
+                    gr.Markdown("Google Trends + 한국 포털 최신 데이터로 업데이트합니다. (약 1분 소요)")
                 
                 gr.Markdown("---")
                 
@@ -373,20 +709,23 @@ def create_interface():
                 )
                 
                 # Apeach 이미지 표시
-                gr.Image(
-                    value="apeach.png",
-                    label=None,
-                    show_label=False,
-                    interactive=False,
-                    height=200,
-                    width=200
-                )
+                try:
+                    gr.Image(
+                        value="apeach.png",
+                        label=None,
+                        show_label=False,
+                        interactive=False,
+                        height=200,
+                        width=200
+                    )
+                except:
+                    pass
             
             with gr.Column(scale=2):
                 analysis_output = gr.Markdown(
-                    value="**분석 버튼을 눌러주세요.**",
+                    value="**분석 버튼을 눌러주세요.**\n\n- **통합 검색어 분석**: 저장된 결과 즉시 확인\n- **실시간 업데이트**: 최신 데이터로 새로 분석",
                     elem_classes=["markdown-content"],
-                    height=600
+                    height=700
                 )
         
         # 이벤트 연결
@@ -405,7 +744,7 @@ def create_interface():
 def main():
     """메인 함수"""
     print("=" * 60)
-    print("Google Trends 인기 검색어 시작!")
+    print("통합 실시간 검색어 분석 서비스 시작!")
     print("=" * 60)
     
     # API 키 확인
@@ -417,12 +756,15 @@ def main():
     else:
         print("Claude API 키 확인됨")
     
-    # 초기 분석 수행
-    print("초기 분석 시작...")
-    initial_success = perform_analysis()
+    # 종료시 브라우저 정리
+    atexit.register(cleanup_browser)
+    
+    # 초기 통합 분석 수행
+    print("초기 통합 분석 시작...")
+    initial_success, _ = perform_parallel_analysis()
     
     if initial_success:
-        print("초기 분석 완료")
+        print("초기 통합 분석 완료")
     else:
         print("초기 분석 실패, 서비스는 계속 진행됩니다.")
     
@@ -448,6 +790,8 @@ def main():
     except Exception as e:
         print(f"인터페이스 시작 실패: {e}")
         print(f"상세 오류: {traceback.format_exc()}")
+    finally:
+        cleanup_browser()
 
 if __name__ == "__main__":
     main()