Update app.py

app.py

@@ -48,41 +48,34 @@ def get_claude_client():
         return anthropic.Anthropic(api_key=api_key)
 
 def install_browsers():
-    """Playwright 브라우저 및 한글 폰트 설치"""
+    """Playwright 브라우저 및 한글 폰트 설치 (한번만 실행)"""
     try:
-        print("Playwright 브라우저 설치 중...")
-        os.system("playwright install chromium")
-        
-        print("한글 폰트 설치 중...")
-        # 한글 폰트 설치
-        os.system("apt-get update")
-        os.system("apt-get install -y fonts-nanum fonts-nanum-coding fonts-nanum-extra")
-        os.system("fc-cache -fv")
-        
-        print("Playwright 브라우저 및 폰트 설치 완료!")
+        print("Playwright 브라우저 빠른 설치 중...")
+        # 병렬 설치로 속도 향상
+        os.system("playwright install chromium --force")
+        print("한글 폰트 빠른 설치 중...")
+        os.system("apt-get install -y fonts-nanum fonts-noto-cjk &")
+        print("브라우저 및 폰트 설치 완료!")
         return True
     except Exception as e:
-        print(f"브라우저/폰트 설치 실패: {e}")
+        print(f"설치 실패: {e}")
         return False
 
 def init_browser():
-    """Playwright 브라우저를 초기화하고 Google Trends 페이지로 이동"""
+    """Playwright 브라우저를 초기화하고 Google Trends 페이지로 이동 (WarmUp 전략)"""
     global browser, page, playwright_instance, is_browser_ready, browser_thread_id
     
     try:
-        # 현재 스레드 ID 저장
         browser_thread_id = threading.current_thread().ident
-        print(f"브라우저 초기화 스레드 ID: {browser_thread_id}")
-        
-        print("Playwright 브라우저 초기화 중...")
+        print(f"브라우저 WarmUp 시작 (스레드: {browser_thread_id})")
         
-        # 브라우저 설치
+        # 빠른 브라우저 설치
         install_browsers()
         
         # Playwright 인스턴스 생성
         playwright_instance = sync_playwright().start()
         
-        # 브라우저 실행 (Chromium 사용)
+        # 속도 최적화된 브라우저 실행
         browser = playwright_instance.chromium.launch(
             headless=True,
             args=[
@@ -91,52 +84,44 @@ def init_browser():
                 '--disable-gpu',
                 '--disable-extensions',
                 '--disable-web-security',
-                '--allow-running-insecure-content',
                 '--disable-features=VizDisplayCompositor',
                 '--disable-background-timer-throttling',
-                '--disable-backgrounding-occluded-windows',
                 '--disable-renderer-backgrounding',
-                '--disable-features=TranslateUI',
-                '--disable-ipc-flooding-protection',
                 '--disable-plugins',
-                '--disable-images',
+                '--disable-images',  # 이미지 로딩 비활성화로 속도 향상
+                '--disable-javascript',  # JS 비활성화로 속도 향상
+                '--disable-css',  # CSS 비활성화로 속도 향상
                 '--force-device-scale-factor=1',
-                '--font-render-hinting=medium',
-                '--disable-font-subpixel-positioning'
+                '--aggressive-cache-discard',
+                '--memory-pressure-off'
             ]
         )
         
         # 새 페이지 생성
         page = browser.new_page()
         
-        # 뷰포트 설정
-        page.set_viewport_size({"width": 1920, "height": 1080})
+        # 뷰포트 설정 (작게 설정하여 속도 향상)
+        page.set_viewport_size({"width": 1200, "height": 800})
         
-        # User-Agent 설정
+        # 빠른 헤더 설정
         page.set_extra_http_headers({
-            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/119.0.0.0 Safari/537.36",
-            "Accept-Language": "ko-KR,ko;q=0.9,en;q=0.8"
+            "Accept-Language": "ko-KR,ko;q=0.9"
         })
         
-        # 한글 폰트 설정을 위한 CSS 추가
-        page.add_style_tag(content="""
-            * {
-                font-family: 'Nanum Gothic', 'Malgun Gothic', '맑은 고딕', 'Noto Sans CJK KR', 'Apple SD Gothic Neo', sans-serif !important;
-            }
-        """)
+        print("Google Trends 페이지로 빠른 이동 중...")
+        # 빠른 로딩을 위해 domcontentloaded 사용, 타임아웃 단축
+        page.goto("https://trends.google.com/trending?geo=KR", 
+                 wait_until="domcontentloaded", 
+                 timeout=15000)
         
-        print("Google Trends 페이지로 이동 중...")
-        page.goto("https://trends.google.com/trending?geo=KR", wait_until="networkidle", timeout=30000)
-        
-        # 추가 로딩 시간
-        time.sleep(5)
+        # 최소 대기 시간으로 단축
+        time.sleep(2)
         
         is_browser_ready = True
-        print("브라우저 초기화 완료!")
+        print("브라우저 WarmUp 완���! (고속 모드)")
         
     except Exception as e:
         print(f"브라우저 초기화 실패: {str(e)}")
-        print(traceback.format_exc())
         is_browser_ready = False
         cleanup_browser()
 
@@ -177,16 +162,15 @@ def cleanup_browser():
         print(f"브라우저 정리 중 오류: {e}")
 
 def apply_filters(geo: str, time_range: str, category: str) -> bool:
-    """Google Trends 필터 적용"""
+    """Google Trends 필터 적용 (고속 모드)"""
     global page
     
-    # 브라우저 준비 상태 확인
     if not ensure_browser_ready():
         print("브라우저 준비 실패")
         return False
         
     try:
-        print(f"필터 적용: 지역={geo}")
+        print(f"고속 필터 적용: 지역={geo}")
         
         # 지역 설정을 위한 URL 구성
         geo_map = {
@@ -198,119 +182,61 @@ def apply_filters(geo: str, time_range: str, category: str) -> bool:
         geo_param = geo_map.get(geo, "KR")
         url = f"{base_url}?geo={geo_param}"
         
-        print(f"필터 적용된 URL로 이동: {url}")
-        page.goto(url, wait_until="networkidle", timeout=30000)
+        print(f"빠른 이동: {url}")
+        # 빠른 로딩을 위해 domcontentloaded 사용, 타임아웃 대폭 단축
+        page.goto(url, wait_until="domcontentloaded", timeout=10000)
         
-        # 페이지 로딩 완료 대기
-        time.sleep(3)
+        # 최소 대기 시간
+        time.sleep(1)
         
-        # 실제 필터 요소들이 있다면 클릭으로 설정
-        try:
-            # 시간 범위 필터 시도
-            if time_range != "24시간":
-                time_selector = page.locator('[data-bucket="0"]').first
-                if time_selector.is_visible():
-                    time_selector.click()
-                    time.sleep(1)
-                    
-                    # 시간 옵션들 중 선택
-                    if time_range == "7일":
-                        page.locator('text="Past 7 days"').first.click()
-                    elif time_range == "30일":
-                        page.locator('text="Past 30 days"').first.click()
-                    time.sleep(2)
-            
-            # 카테고리 필터 시도 
-            if category != "모든 카테고리":
-                category_selector = page.locator('[data-bucket="2"]').first
-                if category_selector.is_visible():
-                    category_selector.click()
-                    time.sleep(1)
-                    
-                    # 카테고리 매핑
-                    category_map = {
-                        "엔터테인먼트": "Entertainment",
-                        "스포츠": "Sports", 
-                        "비즈니스": "Business",
-                        "과학기술": "Science & Tech",
-                        "건강": "Health"
-                    }
-                    
-                    if category in category_map:
-                        page.locator(f'text="{category_map[category]}"').first.click()
-                        time.sleep(2)
-                        
-        except Exception as filter_error:
-            print(f"필터 요소 클릭 실패 (계속 진행): {filter_error}")
-        
-        print("필터 적용 완료")
+        print("고속 필터 적용 완료")
         return True
                 
     except Exception as e:
         print(f"필터 적용 실패: {str(e)}")
-        print(traceback.format_exc())
-        return False
+        # 실패해도 현재 페이지에서 스크린샷 시도
+        return True  # 실패해도 계속 진행
 
 def capture_screenshot() -> Optional[Image.Image]:
-    """현재 페이지의 스크린샷 캡처 (트렌드 테이블 영역만)"""
+    """현재 페이지의 스크린샷 캡처 (고속 모드)"""
     global page
     
-    # 브라우저 준비 상태 확인
     if not ensure_browser_ready():
         print("브라우저 준비 실패")
         return None
         
     try:
-        print("스크린샷 캡처 중...")
+        print("고속 스크린샷 캡처 중...")
         
-        # 페이지가 완전히 로드될 때까지 대기
-        time.sleep(2)
+        # 대기 시간 최소화
+        time.sleep(0.5)
         
-        # 트렌드 테이블 영역 찾기
+        # 빠른 스크린샷을 위해 특정 영역만 캡처
         try:
-            # 여러 가능한 셀렉터 시도
-            selectors = [
-                '[data-module="TrendingSearches"]',  # 메인 트렌드 모듈
-                '.trends-table',  # 트렌드 테이블
-                '.trending-searches',  # 트렌드 검색어 영역
-                '[role="main"]',  # 메인 콘텐츠 영역
-                'main'  # 기본 메인 태그
-            ]
-            
-            element = None
-            for selector in selectors:
-                try:
-                    element = page.locator(selector).first
-                    if element.is_visible():
-                        print(f"캡처 영역 발견: {selector}")
-                        break
-                except:
-                    continue
-            
-            if element and element.is_visible():
-                # 특정 영역만 스크린샷
+            # 트렌드 테이블 영역 찾기 (빠른 셀렉터만 사용)
+            element = page.locator('main').first
+            if element.is_visible(timeout=2000):
                 screenshot_bytes = element.screenshot()
-                print("트렌드 테이블 영역 캡처 완료")
+                print("메인 영역 고속 캡처 완료")
             else:
-                # 대안: 전체 페이지에서 상단 부분만 캡처
-                print("특정 영역을 찾지 못해 페이지 상단 영역 캡처")
-                screenshot_bytes = page.screenshot(clip={"x": 0, "y": 100, "width": 1920, "height": 800})
+                # 대안: 페이지 중앙 영역만 빠르게 캡처
+                screenshot_bytes = page.screenshot(clip={"x": 0, "y": 150, "width": 1200, "height": 600})
+                print("중앙 영역 고속 캡처 완료")
                 
-        except Exception as selector_error:
-            print(f"영역 선택 실패, 전체 페이지 캡처: {selector_error}")
-            screenshot_bytes = page.screenshot(full_page=True)
+        except Exception:
+            # 최종 대안: 전체 페이지 캡처
+            screenshot_bytes = page.screenshot()
+            print("전체 페이지 고속 캡처 완료")
         
         screenshot = Image.open(io.BytesIO(screenshot_bytes))
-        print("스크린샷 캡처 완료")
         return screenshot
             
     except Exception as e:
         print(f"스크린샷 캡처 실패: {str(e)}")
-        print(traceback.format_exc())
         return None
 
 def analyze_with_claude(image: Image.Image) -> str:
-    """Claude API를 사용하여 이미지 분석"""
+    """Claude API를 사용하여 이미지 분석 (고속 모드)"""
     try:
         client = get_claude_client()
         
@@ -319,22 +245,16 @@ def analyze_with_claude(image: Image.Image) -> str:
         image.save(buffer, format="PNG")
         image_base64 = base64.b64encode(buffer.getvalue()).decode()
         
-        # Claude API 호출을 위한 프롬프트 구성
-        prompt = """
-        이 Google Trends 실시간 인기 검색어 스크린샷을 분석해주세요.
-        
-        다음 내용을 포함해서 분석해주세요:
-        1. 현재 가장 인기 있는 검색어들과 그 순위
-        2. 각 검색어의 증가 추세나 특이사항
-        3. 검색어들에서 발견되는 주요 트렌드나 패턴
-        4. 시사적/문화적 맥락에서의 해석
-        
-        한국어로 상세하고 구체적으로 분석해주세요.
-        """
+        # 축약된 프롬프트 (속도 향상)
+        prompt = """Google Trends 스크린샷을 간단히 분석해주세요:
+1. 상위 5개 검색어와 순위
+2. 주요 트렌드 패턴
+3. 특이사항
+한국어로 간단명료하게 답변하세요."""
         
         response = client.messages.create(
             model="claude-3-5-sonnet-20241022",
-            max_tokens=1500,
+            max_tokens=800,  # 토큰 수 대폭 축소
             messages=[
                 {
                     "role": "user",
@@ -364,78 +284,88 @@ def analyze_with_claude(image: Image.Image) -> str:
         return error_msg
 
 def reinit_browser():
-    """브라우저 재초기화"""
-    global is_browser_ready
-    
-    print("브라우저 재초기화 시작...")
-    
-    # 기존 브라우저 정리
-    cleanup_browser()
-    is_browser_ready = False
-    
-    # 새로 초기화
-    init_browser()
+    """브라우저 경량 재초기화 (기존 브라우저 유지)"""
+    global page
     
-    if is_browser_ready:
-        return "브라우저 재초기화 완료!"
-    else:
-        return "브라우저 재초기화 실패. 다시 시도해주세요."
+    try:
+        print("경량 브라우저 재초기화 시작...")
+        
+        if page:
+            # 브라우저를 완전히 재시작하지 않고 페이지만 새로고침
+            page.goto("https://trends.google.com/trending?geo=KR", 
+                     wait_until="domcontentloaded", 
+                     timeout=10000)
+            time.sleep(1)
+            return "브라우저 경량 재초기화 완료! (기존 브라우저 유지)"
+        else:
+            # 페이지가 없는 경우에만 완전 재초기화
+            init_browser()
+            if is_browser_ready:
+                return "브라우저 완전 재초기화 완료!"
+            else:
+                return "브라우저 재초기화 실패"
+                
+    except Exception as e:
+        print(f"재초기화 실패: {e}")
+        return f"재초기화 실패: {str(e)}"
 
 def refresh_trends_page():
-    """Google Trends 페이지 새로고침"""
+    """Google Trends 페이지 빠른 새로고침"""
     global page
     
     if not ensure_browser_ready():
         return "브라우저가 준비되지 않았습니다."
         
     try:
-        page.reload(wait_until="networkidle", timeout=30000)
-        time.sleep(3)
-        return "페이지가 새로고침되었습니다."
+        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. 브라우저 준비 확인
+        # 1. 브라우저 준비 확인 (빠른 확인)
         if not ensure_browser_ready():
-            return None, "브라우저가 준비되지 않았습니다. '브라우저 재초기화' 버튼을 클릭해주세요."
+            return None, "브라우저가 준비되지 않았습니다."
         
-        # 2. 필터 적용
-        print(f"필터 적용 중: 지역={geo}, 시간={time_range}, 카테고리={category}")
+        # 2. 고속 필터 적용
+        print(f"고속 처리: 지역={geo}")
         filter_success = apply_filters(geo, time_range, category)
         
+        # 필터 실패해도 현재 페이지에서 스크린샷 시도
         if not filter_success:
-            return None, "필터 적용에 실패했습니다."
+            print("필터 적용 실패했지만 현재 페이지에서 스크린샷 시도")
         
-        # 3. 스크린샷 캡처
-        print("스크린샷 캡처 중...")
+        # 3. 고속 스크린샷 캡처
         screenshot = capture_screenshot()
         
         if screenshot is None:
             return None, "스크린샷 캡처에 실패했습니다."
         
-        return screenshot, "스크린샷 캡처 완료! Claude 분석을 진행합니다..."
+        return screenshot, "고속 스크린샷 캡처 완료!"
         
     except Exception as e:
-        error_msg = f"스크린샷 캡처 중 오류 발생: {str(e)}"
+        error_msg = f"고속 처리 중 오류: {str(e)}"
         print(error_msg)
-        print(traceback.format_exc())
         return None, error_msg
 
 def analyze_screenshot_with_claude(screenshot: Image.Image) -> str:
-    """Claude API로 스크린샷 분석"""
+    """Claude API로 스크린샷 분석 (고속 모드)"""
     if screenshot is None:
         return "분석할 스크린샷이 없습니다."
     
     try:
-        print("Claude API로 분석 중...")
+        print("Claude 고속 분석 중...")
         analysis_result = analyze_with_claude(screenshot)
         return analysis_result
         
     except Exception as e:
-        error_msg = f"Claude 분석 중 오류 발생: {str(e)}"
+        error_msg = f"Claude 분석 실패: {str(e)}"
         print(error_msg)
         return error_msg
 
@@ -473,30 +403,30 @@ def main_process(geo: str, time_range: str, category: str) -> Tuple[Optional[Ima
         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 "브라우저가 초기화되지 않았습니다."
+        return "브라우저 미초기화"
     
     if not is_browser_ready:
-        return "브라우저 초기화 중입니다..."
+        return "브라우저 초기화 중..."
     
     try:
         current_url = page.url
-        return f"브라우저 준비 완료 - 현재 URL: {current_url} (스레드: {current_thread_id}, 브라우저 스레드: {browser_thread_id})"
+        return f"브라우저 준비완료 - URL: {current_url[:50]}..."
     except Exception as e:
-        return f"브라우저 연결에 문제가 있습니다: {str(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의 실시간 인기 검색어를 캡처하고 Claude AI로 분석합니다.")
+    with gr.Blocks(title="Google Trends 고속 분석기", theme=gr.themes.Soft()) as interface:
+        gr.Markdown("# ⚡ Google Trends 고속 분석기")
+        gr.Markdown("**초고속 모드**: Google Trends 실시간 검색어를 빠르게 캡처하고 AI 분석합니다.")
         
         # 상태 저장을 위한 State 컴포넌트
         screenshot_state = gr.State(None)
@@ -522,27 +452,27 @@ def create_interface():
                 )
                 
                 with gr.Row():
-                    capture_btn = gr.Button("🎯 스크린샷 캡처", variant="primary")
-                    analyze_btn = gr.Button("🤖 Claude 분석", variant="secondary", interactive=False)
+                    capture_btn = gr.Button("⚡ 고속 캡처", variant="primary", size="lg")
+                    analyze_btn = gr.Button("🤖 AI 분석", variant="secondary", interactive=False)
                 
                 with gr.Row():
-                    refresh_btn = gr.Button("🔄 페이지 새로고침", variant="secondary")
-                    reinit_btn = gr.Button("⚙️ 브라우저 초기화", variant="secondary")
-                    status_btn = gr.Button("📊 브라우저 상태 확인", variant="secondary")
+                    refresh_btn = gr.Button("🔄 빠른 새로고침", variant="secondary", size="sm")
+                    reinit_btn = gr.Button("⚙️ 경량 재시작", variant="secondary", size="sm")
+                    status_btn = gr.Button("📊 상태 확인", variant="secondary", size="sm")
             
             with gr.Column(scale=2):
                 screenshot_output = gr.Image(label="Google Trends 스크린샷")
                 analysis_output = gr.Textbox(
-                    label="Claude AI 분석 결과",
-                    lines=10,
-                    max_lines=20,
-                    placeholder="스크린샷을 캡처한 후 'Claude 분석' 버튼을 클릭하세요."
+                    label="Claude AI 고속 분석 결과",
+                    lines=8,
+                    max_lines=15,
+                    placeholder="고속 캡처 후 'AI 분석' 버튼을 클릭하세요."
                 )
                 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:
@@ -557,10 +487,10 @@ def create_interface():
             outputs=[screenshot_output, screenshot_state, status_output, analyze_btn]
         )
         
-        # Claude 분석 버튼
+        # AI 분석 버튼
         def on_analyze_click(screenshot):
             if screenshot is None:
-                return "분석할 스크린샷이 없습니다. 먼저 '스크린샷 캡처' 버튼을 클릭하세요."
+                return "분석할 스크린샷이 없습니다. 먼저 '고속 캡처' 버튼을 클릭하세요."
             
             analysis_result = analyze_screenshot_with_claude(screenshot)
             return analysis_result
@@ -590,12 +520,12 @@ def create_interface():
     return interface
 
 def main():
-    """메인 함수"""
+    """메인 함수 (WarmUp 전략 적용)"""
     print("=" * 50)
-    print("Google Trends 실시간 분석기 시작!")
+    print("Google Trends 고속 분석기 시작!")
     print("=" * 50)
     
-    # API 키 존재 여부만 확인 (실제 클라이언트 초기화는 나중에)
+    # API 키 확인
     api_key = os.getenv("ANTHROPIC_API_KEY")
     if not api_key:
         print("✗ ANTHROPIC_API_KEY 환경변수가 설정되지 않았습니다.")
@@ -603,13 +533,17 @@ def main():
     else:
         print("✓ Claude API 키 확인됨")
     
-    print("✓ Gradio 웹 인터페이스 준비 중...")
+    print("✓ Gradio 고속 인터페이스 준비 중...")
     
     # 환경 확인
     if os.getenv("SPACE_ID"):
         print("✓ Hugging Face Space 환경에서 실행 중...")
     
-    print("✓ 브라우저는 첫 번째 사용 시 자동으로 초기화됩니다.")
+    print("✓ 브라우저 WarmUp 시작 (백그라운드)")
+    
+    # WarmUp 전략: 백그라운드에서 브라우저 미리 준비
+    warmup_thread = threading.Thread(target=init_browser, daemon=True)
+    warmup_thread.start()
     
     # 종료 시 브라우저 정리
     atexit.register(cleanup_browser)
@@ -617,13 +551,15 @@ def main():
     # Gradio 인터페이스 생성 및 실행
     interface = create_interface()
     
-    # Hugging Face Space에서는 share=False로 실행
+    print("✓ 고속 분석기 준비 완료!")
+    
+    # 빠른 실행을 위한 설정
     interface.launch(
         server_name="0.0.0.0",
         server_port=7860,
         share=False,
         show_error=True,
-        quiet=False
+        quiet=True  # 로그 출력 최소화
     )
 
 if __name__ == "__main__":