Update app.py

app.py

@@ -48,14 +48,21 @@ 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("Playwright 브라우저 설치 완료!")
+        
+        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 브라우저 및 폰트 설치 완료!")
         return True
     except Exception as e:
-        print(f"브라우저 설치 실패: {e}")
+        print(f"브라우저/폰트 설치 실패: {e}")
         return False
 
 def init_browser():
@@ -92,7 +99,10 @@ def init_browser():
                 '--disable-features=TranslateUI',
                 '--disable-ipc-flooding-protection',
                 '--disable-plugins',
-                '--disable-images'
+                '--disable-images',
+                '--force-device-scale-factor=1',
+                '--font-render-hinting=medium',
+                '--disable-font-subpixel-positioning'
             ]
         )
         
@@ -104,9 +114,17 @@ def init_browser():
         
         # 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"
+            "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"
         })
         
+        # 한글 폰트 설정을 위한 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 페이지로 이동 중...")
         page.goto("https://trends.google.com/trending?geo=KR", wait_until="networkidle", timeout=30000)
         
@@ -170,25 +188,61 @@ def apply_filters(geo: str, time_range: str, category: str) -> bool:
     try:
         print(f"필터 적용: 지역={geo}")
         
-        # 페이지 새로고침으로 시작
-        page.reload(wait_until="networkidle", timeout=30000)
-        time.sleep(3)
-        
-        # 필터 적용은 URL 파라미터로 처리
+        # 지역 설정을 위한 URL 구성
         geo_map = {
             "KR": "KR", "US": "US", "JP": "JP", 
             "GB": "GB", "DE": "DE", "FR": "FR"
         }
         
-        # URL 구성
         base_url = "https://trends.google.com/trending"
         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)
+        
+        # 페이지 로딩 완료 대기
         time.sleep(3)
         
+        # 실제 필터 요소들이 있다면 클릭으로 설정
+        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("필터 적용 완료")
         return True
                 
@@ -198,7 +252,7 @@ def apply_filters(geo: str, time_range: str, category: str) -> bool:
         return False
 
 def capture_screenshot() -> Optional[Image.Image]:
-    """현재 페이지의 스크린샷 캡처"""
+    """현재 페이지의 스크린샷 캡처 (트렌드 테이블 영역만)"""
     global page
     
     # 브라우저 준비 상태 확인
@@ -212,10 +266,41 @@ def capture_screenshot() -> Optional[Image.Image]:
         # 페이지가 완전히 로드될 때까지 대기
         time.sleep(2)
         
-        # 스크린샷 캡처
-        screenshot_bytes = page.screenshot(full_page=True)
-        screenshot = Image.open(io.BytesIO(screenshot_bytes))
+        # 트렌드 테이블 영역 찾기
+        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():
+                # 특정 영역만 스크린샷
+                screenshot_bytes = element.screenshot()
+                print("트렌드 테이블 영역 캡처 완료")
+            else:
+                # 대안: 전체 페이지에서 상단 부분만 캡처
+                print("특정 영역을 찾지 못해 페이지 상단 영역 캡처")
+                screenshot_bytes = page.screenshot(clip={"x": 0, "y": 100, "width": 1920, "height": 800})
+                
+        except Exception as selector_error:
+            print(f"영역 선택 실패, 전체 페이지 캡처: {selector_error}")
+            screenshot_bytes = page.screenshot(full_page=True)
         
+        screenshot = Image.open(io.BytesIO(screenshot_bytes))
         print("스크린샷 캡처 완료")
         return screenshot
             
@@ -310,8 +395,52 @@ def refresh_trends_page():
     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}, 시간={time_range}, 카테고리={category}")
+        filter_success = apply_filters(geo, time_range, category)
+        
+        if not filter_success:
+            return None, "필터 적용에 실패했습니다."
+        
+        # 3. 스크린샷 캡처
+        print("스크린샷 캡처 중...")
+        screenshot = capture_screenshot()
+        
+        if screenshot is None:
+            return None, "스크린샷 캡처에 실패했습니다."
+        
+        return screenshot, "스크린샷 캡처 완료! Claude 분석을 진행합니다..."
+        
+    except Exception as 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로 스크린샷 분석"""
+    if screenshot is None:
+        return "분석할 스크린샷이 없습니다."
+    
+    try:
+        print("Claude API로 분석 중...")
+        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():
@@ -369,6 +498,9 @@ def create_interface():
         gr.Markdown("# Google Trends 실시간 인기 검색어 분석기")
         gr.Markdown("Google Trends의 실시간 인기 검색어를 캡처하고 Claude AI로 분석합니다.")
         
+        # 상태 저장을 위한 State 컴포넌트
+        screenshot_state = gr.State(None)
+        
         with gr.Row():
             with gr.Column(scale=1):
                 geo_dropdown = gr.Dropdown(
@@ -389,27 +521,57 @@ def create_interface():
                     label="카테고리 선택"
                 )
                 
-                analyze_btn = gr.Button("분석 시작", variant="primary")
-                refresh_btn = gr.Button("페이지 새로고침", variant="secondary")
-                reinit_btn = gr.Button("브라우저 재초기화", variant="secondary")
-                status_btn = gr.Button("브라우저 상태 확인", variant="secondary")
+                with gr.Row():
+                    capture_btn = gr.Button("🎯 스크린샷 캡처", variant="primary")
+                    analyze_btn = gr.Button("🤖 Claude 분석", 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")
             
             with gr.Column(scale=2):
                 screenshot_output = gr.Image(label="Google Trends 스크린샷")
                 analysis_output = gr.Textbox(
                     label="Claude AI 분석 결과",
                     lines=10,
-                    max_lines=20
+                    max_lines=20,
+                    placeholder="스크린샷을 캡처한 후 'Claude 분석' 버튼을 클릭하세요."
                 )
                 status_output = gr.Textbox(label="상태 메시지")
         
         # 이벤트 핸들러
-        analyze_btn.click(
-            fn=main_process,
+        
+        # 스크린샷 캡처 버튼
+        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, analysis_output]
+            outputs=[screenshot_output, screenshot_state, status_output, analyze_btn]
+        )
+        
+        # Claude 분석 버튼
+        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