app.py

import gradio as gr
import requests
import json
import os
from datetime import datetime, timedelta
from huggingface_hub import InferenceClient

MAX_COUNTRY_RESULTS = 100    # 국가별 최대 결과 수
MAX_GLOBAL_RESULTS = 1000    # 전세계 최대 결과 수

def create_article_components(max_results):
    article_components = []
    for i in range(max_results):
        with gr.Group(visible=False) as article_group:
            title = gr.Markdown()
            image = gr.Image(width=200, height=150)
            snippet = gr.Markdown()
            info = gr.Markdown()
            
            article_components.append({
                'group': article_group,
                'title': title,
                'image': image,
                'snippet': snippet,
                'info': info,
                'index': i,
            })
    return article_components
    
API_KEY = os.getenv("SERPHOUSE_API_KEY")
# hf_client = InferenceClient("CohereForAI/c4ai-command-r-plus-08-2024", token=os.getenv("HF_TOKEN"))

# 국가별 언어 코드 매핑
COUNTRY_LANGUAGES = {
    "United States": "en",
    "United Kingdom": "en",
    "Taiwan": "zh-TW",  # 대만어(번체 중국어)
    "Canada": "en",
    "Australia": "en",
    "Germany": "de",
    "France": "fr",
    "Japan": "ja",
    "South Korea": "ko",
    "China": "zh",
    "India": "hi",
    "Brazil": "pt",
    "Mexico": "es",
    "Russia": "ru",
    "Italy": "it",
    "Spain": "es",
    "Netherlands": "nl",
    "Singapore": "en",
    "Hong Kong": "zh-HK",
    "Indonesia": "id",
    "Malaysia": "ms",
    "Philippines": "tl",
    "Thailand": "th",
    "Vietnam": "vi",
    "Belgium": "nl",
    "Denmark": "da",
    "Finland": "fi",
    "Ireland": "en",
    "Norway": "no",
    "Poland": "pl",
    "Sweden": "sv",
    "Switzerland": "de",
    "Austria": "de",
    "Czech Republic": "cs",
    "Greece": "el",
    "Hungary": "hu",
    "Portugal": "pt",
    "Romania": "ro",
    "Turkey": "tr",
    "Israel": "he",
    "Saudi Arabia": "ar",
    "United Arab Emirates": "ar",
    "South Africa": "en",
    "Argentina": "es",
    "Chile": "es",
    "Colombia": "es",
    "Peru": "es",
    "Venezuela": "es",
    "New Zealand": "en",
    "Bangladesh": "bn",
    "Pakistan": "ur",
    "Egypt": "ar",
    "Morocco": "ar",
    "Nigeria": "en",
    "Kenya": "sw",
    "Ukraine": "uk",
    "Croatia": "hr",
    "Slovakia": "sk",
    "Bulgaria": "bg",
    "Serbia": "sr",
    "Estonia": "et",
    "Latvia": "lv",
    "Lithuania": "lt",
    "Slovenia": "sl",
    "Luxembourg": "fr",
    "Malta": "mt",
    "Cyprus": "el",
    "Iceland": "is"
}

COUNTRY_LOCATIONS = {
    "United States": "United States",
    "United Kingdom": "United Kingdom",
    "Taiwan": "Taiwan",  # 국가명 사용
    "Canada": "Canada",
    "Australia": "Australia",
    "Germany": "Germany",
    "France": "France",
    "Japan": "Japan",
    "South Korea": "South Korea",
    "China": "China",
    "India": "India",
    "Brazil": "Brazil",
    "Mexico": "Mexico",
    "Russia": "Russia",
    "Italy": "Italy",
    "Spain": "Spain",
    "Netherlands": "Netherlands",
    "Singapore": "Singapore",
    "Hong Kong": "Hong Kong",
    "Indonesia": "Indonesia",
    "Malaysia": "Malaysia",
    "Philippines": "Philippines",
    "Thailand": "Thailand",
    "Vietnam": "Vietnam",
    "Belgium": "Belgium",
    "Denmark": "Denmark",
    "Finland": "Finland",
    "Ireland": "Ireland",
    "Norway": "Norway",
    "Poland": "Poland",
    "Sweden": "Sweden",
    "Switzerland": "Switzerland",
    "Austria": "Austria",
    "Czech Republic": "Czech Republic",
    "Greece": "Greece",
    "Hungary": "Hungary",
    "Portugal": "Portugal",
    "Romania": "Romania",
    "Turkey": "Turkey",
    "Israel": "Israel",
    "Saudi Arabia": "Saudi Arabia",
    "United Arab Emirates": "United Arab Emirates",
    "South Africa": "South Africa",
    "Argentina": "Argentina",
    "Chile": "Chile",
    "Colombia": "Colombia",
    "Peru": "Peru",
    "Venezuela": "Venezuela",
    "New Zealand": "New Zealand",
    "Bangladesh": "Bangladesh",
    "Pakistan": "Pakistan",
    "Egypt": "Egypt",
    "Morocco": "Morocco",
    "Nigeria": "Nigeria",
    "Kenya": "Kenya",
    "Ukraine": "Ukraine",
    "Croatia": "Croatia",
    "Slovakia": "Slovakia",
    "Bulgaria": "Bulgaria",
    "Serbia": "Serbia",
    "Estonia": "Estonia",
    "Latvia": "Latvia",
    "Lithuania": "Lithuania",
    "Slovenia": "Slovenia",
    "Luxembourg": "Luxembourg",
    "Malta": "Malta",
    "Cyprus": "Cyprus",
    "Iceland": "Iceland"
}

MAJOR_COUNTRIES = list(COUNTRY_LOCATIONS.keys())

def translate_query(query, country):
    try:
        # 영어 입력 확인
        if is_english(query):
            print(f"영어 검색어 감지 - 원본 사용: {query}")
            return query
            
        # 선택된 국가가 번역 지원 국가인 경우    
        if country in COUNTRY_LANGUAGES:
            # South Korea 선택시 한글 입력은 그대로 사용    
            if country == "South Korea":
                print(f"한국 선택 - 원본 사용: {query}")
                return query
                
            target_lang = COUNTRY_LANGUAGES[country]
            print(f"번역 시도: {query} -> {country}({target_lang})")
            
            url = f"https://translate.googleapis.com/translate_a/single"
            params = {
                "client": "gtx",
                "sl": "auto",
                "tl": target_lang,
                "dt": "t",
                "q": query
            }
            
            response = requests.get(url, params=params)
            translated_text = response.json()[0][0][0]
            print(f"번역 완료: {query} -> {translated_text} ({country})")
            return translated_text
            
        return query
        
    except Exception as e:
        print(f"번역 오류: {str(e)}")
        return query

def translate_to_korean(text):
    try:
        url = "https://translate.googleapis.com/translate_a/single"
        params = {
            "client": "gtx",
            "sl": "auto",
            "tl": "ko",
            "dt": "t",
            "q": text
        }
        
        response = requests.get(url, params=params)
        translated_text = response.json()[0][0][0]
        return translated_text
    except Exception as e:
        print(f"한글 번역 오류: {str(e)}")
        return text

def is_english(text):
    return all(ord(char) < 128 for char in text.replace(' ', '').replace('-', '').replace('_', ''))
    
def is_korean(text):
    return any('\uAC00' <= char <= '\uD7A3' for char in text)
    
def search_serphouse(query, country, page=1, num_result=10):
    url = "https://api.serphouse.com/serp/live"
    
    now = datetime.utcnow()
    yesterday = now - timedelta(days=1)
    date_range = f"{yesterday.strftime('%Y-%m-%d')},{now.strftime('%Y-%m-%d')}"
    
    translated_query = translate_query(query, country)
    print(f"Original query: {query}")
    print(f"Translated query: {translated_query}")
    
    payload = {
        "data": {
            "q": translated_query,
            "domain": "google.com",
            "loc": COUNTRY_LOCATIONS.get(country, "United States"),
            "lang": COUNTRY_LANGUAGES.get(country, "en"),
            "device": "desktop",
            "serp_type": "news",
            "page": "1",
            "num": "10",
            "date_range": date_range,
            "sort_by": "date"
        }
    }

    headers = {
        "accept": "application/json",
        "content-type": "application/json",
        "authorization": f"Bearer {API_KEY}"
    }

    try:
        response = requests.post(url, json=payload, headers=headers)
        print("Request payload:", json.dumps(payload, indent=2, ensure_ascii=False))
        print("Response status:", response.status_code)
        
        response.raise_for_status()
        return {"results": response.json(), "translated_query": translated_query}
    except requests.RequestException as e:
        return {"error": f"Error: {str(e)}", "translated_query": query}

def format_results_from_raw(response_data):
    if "error" in response_data:
        return "Error: " + response_data["error"], []

    try:
        results = response_data["results"]
        translated_query = response_data["translated_query"]
        
        news_results = results.get('results', {}).get('results', {}).get('news', [])
        if not news_results:
            return "검색 결과가 없습니다.", []

        articles = []
        for idx, result in enumerate(news_results, 1):
            articles.append({
                "index": idx,
                "title": result.get("title", "제목 없음"),
                "link": result.get("url", result.get("link", "#")),
                "snippet": result.get("snippet", "내용 없음"),
                "channel": result.get("channel", result.get("source", "알 수 없음")),
                "time": result.get("time", result.get("date", "알 수 없는 시간")),
                "image_url": result.get("img", result.get("thumbnail", "")),
                "translated_query": translated_query
            })
        return "", articles
    except Exception as e:
        return f"결과 처리 중 오류 발생: {str(e)}", []

def serphouse_search(query, country):
    response_data = search_serphouse(query, country)
    return format_results_from_raw(response_data)

css = """
footer {visibility: hidden;}
"""

with gr.Blocks(theme="Nymbo/Nymbo_Theme", css=css, title="NewsAI 서비스") as iface:
    with gr.Tabs():
        # 국가별 탭
        with gr.Tab("국가별"):
            gr.Markdown("검색어를 입력하고 원하는 국가(67개국)를 선택하면, 검색어와 일치하는 24시간 이내 뉴스를 최대 100개 출력합니다.")
            gr.Markdown("국가 선택후 검색어에 '한글'을 입력하면 현지 언어로 번역되어 검색합니다. 예: 'Taiwan' 국가 선택후 '삼성' 입력시 '三星'으로 자동 검색")
            
            with gr.Column():
                with gr.Row():
                    query = gr.Textbox(label="검색어")
                    country = gr.Dropdown(MAJOR_COUNTRIES, label="국가", value="South Korea")
                
                # 검색 상태 메시지    
                status_message = gr.Markdown("", visible=True)
                
                # 번역 결과를 보여주는 컴포넌트
                translated_query_display = gr.Markdown(visible=False)
                
                search_button = gr.Button("검색", variant="primary")
                
                progress = gr.Progress()
                articles_state = gr.State([])

                article_components = []
                for i in range(100):
                    with gr.Group(visible=False) as article_group:
                        title = gr.Markdown()
                        image = gr.Image(width=200, height=150)
                        snippet = gr.Markdown()
                        info = gr.Markdown()
                        
                        article_components.append({
                            'group': article_group,
                            'title': title,
                            'image': image,
                            'snippet': snippet,
                            'info': info,
                            'index': i,
                        })

        # 전세계 탭
        with gr.Tab("전세계"):
            gr.Markdown("검색어를 입력하면 67개국의 24시간 이내 뉴스를 최대 1000개 출력합니다.")
            
            with gr.Column():
                query_global = gr.Textbox(label="검색어")
                status_message_global = gr.Markdown("", visible=True)
                translated_query_display_global = gr.Markdown(visible=False)
                search_button_global = gr.Button("전세계 검색", variant="primary")
                
                progress_global = gr.Progress()
                articles_state_global = gr.State([])

                global_article_components = []
                for i in range(1000):
                    with gr.Group(visible=False) as article_group:
                        title = gr.Markdown()
                        image = gr.Image(width=200, height=150)
                        snippet = gr.Markdown()
                        info = gr.Markdown()
                        
                        global_article_components.append({
                            'group': article_group,
                            'title': title,
                            'image': image,
                            'snippet': snippet,
                            'info': info,
                            'index': i,
                        })

    def search_and_display(query, country, articles_state, progress=gr.Progress()):
        # 검색 상태 메시지 업데이트
        status_msg = "검색을 진행중입니다. 잠시만 기다리세요..."
        
        progress(0, desc="검색어 번역 중...")
        
        # 검색어 번역
        translated_query = translate_query(query, country)
        translated_display = f"**원본 검색어:** {query}\n**번역된 검색어:** {translated_query}" if translated_query != query else f"**검색어:** {query}"
        
        progress(0.2, desc="검색 시작...")
        error_message, articles = serphouse_search(query, country)
        progress(0.5, desc="결과 처리 중...")
        
        outputs = []
        outputs.append(gr.update(value=status_msg, visible=True))  # 상태 메시지
        outputs.append(gr.update(value=translated_display, visible=True))  # 번역 결과
        
        if error_message:
            outputs.append(gr.update(value=error_message, visible=True))
            for comp in article_components:
                outputs.extend([
                    gr.update(visible=False), gr.update(), gr.update(),
                    gr.update(), gr.update()
                ])
            articles_state = []
        else:
            outputs.append(gr.update(value="", visible=False))
            total_articles = len(articles)
            for idx, comp in enumerate(article_components):
                progress((idx + 1) / total_articles, desc=f"결과 표시 중... {idx + 1}/{total_articles}")
                if idx < len(articles):
                    article = articles[idx]
                    image_url = article['image_url']
                    image_update = gr.update(value=image_url, visible=True) if image_url and not image_url.startswith('data:image') else gr.update(value=None, visible=False)
                    
                    # 요약 내용 한글 번역
                    korean_summary = translate_to_korean(article['snippet'])
                    
                    outputs.extend([
                        gr.update(visible=True),
                        gr.update(value=f"### [{article['title']}]({article['link']})"),
                        image_update,
                        gr.update(value=f"**요약:** {article['snippet']}\n\n**한글 요약:** {korean_summary}"),
                        gr.update(value=f"**출처:** {article['channel']} | **시간:** {article['time']}")
                    ])
                else:
                    outputs.extend([
                        gr.update(visible=False), gr.update(), gr.update(),
                        gr.update(), gr.update()
                    ])
            articles_state = articles

        progress(1.0, desc="완료!")
        outputs.append(articles_state)
        
        # 검색 완료 후 상태 메시지 숨김
        outputs[0] = gr.update(value="", visible=False)
        
        return outputs

    def search_global(query, articles_state_global, progress=gr.Progress()):
        status_msg = "전세계 검색을 진행중입니다. 실시간으로 결과가 출력됩니다..."
        all_results = []
        displayed_count = 0
        
        # 초기 출력 설정
        outputs = []
        outputs.append(gr.update(value=status_msg, visible=True))
        outputs.append(gr.update(value=f"**검색어:** {query}", visible=True))
        
        # 1000개의 결과 컴포넌트를 초기에 모두 숨김 처리
        for _ in global_article_components:
            outputs.extend([
                gr.update(visible=False), gr.update(), gr.update(),
                gr.update(), gr.update()
            ])
        outputs.append([])  # articles_state_global
        
        yield outputs  # 초기 상태 출력
        
        # 국가별 검색 및 실시간 결과 출력
        for idx, (country, location) in enumerate(COUNTRY_LOCATIONS.items()):
            progress(idx / len(COUNTRY_LOCATIONS), f"{country} 검색 중... ({idx + 1}/{len(COUNTRY_LOCATIONS)})")
            
            try:
                error_message, articles = serphouse_search(query, country)
                if not error_message and articles:
                    # 해당 국가의 결과에 국가 정보 추가
                    for article in articles:
                        article['source_country'] = country
                    
                    # 새로운 결과 추가 및 정렬
                    all_results.extend(articles)
                    sorted_results = sorted(all_results, key=lambda x: x.get('time', ''), reverse=True)
                    
                    # 중복 제거
                    seen_urls = set()
                    unique_results = []
                    for article in sorted_results:
                        url = article.get('link', '')
                        if url not in seen_urls:
                            seen_urls.add(url)
                            unique_results.append(article)
                    
                    # 최대 1000개까지만 유지
                    unique_results = unique_results[:1000]
                    
                    # 새로운 결과 출력
                    outputs = []
                    outputs.append(gr.update(value=f"전세계 검색 진행 중... ({idx + 1}/{len(COUNTRY_LOCATIONS)} 국가 완료)", visible=True))
                    outputs.append(gr.update(value=f"**검색어:** {query}\n**현재까지 발견된 뉴스:** {len(unique_results)}건", visible=True))
                    
                    # 결과 컴포넌트 업데이트
                    for idx, comp in enumerate(global_article_components):
                        if idx < len(unique_results):
                            article = unique_results[idx]
                            image_url = article.get('image_url', '')
                            image_update = gr.update(value=image_url, visible=True) if image_url and not image_url.startswith('data:image') else gr.update(value=None, visible=False)
                            
                            korean_summary = translate_to_korean(article['snippet'])
                            
                            outputs.extend([
                                gr.update(visible=True),
                                gr.update(value=f"### [{article['title']}]({article['link']})"),
                                image_update,
                                gr.update(value=f"**요약:** {article['snippet']}\n\n**한글 요약:** {korean_summary}"),
                                gr.update(value=f"**출처:** {article['channel']} | **국가:** {article['source_country']} | **시간:** {article['time']}")
                            ])
                        else:
                            outputs.extend([
                                gr.update(visible=False), gr.update(), gr.update(),
                                gr.update(), gr.update()
                            ])
                    
                    outputs.append(unique_results)
                    yield outputs
                    
            except Exception as e:
                print(f"Error searching {country}: {str(e)}")
                continue
        
        # 최종 상태 업데이트
        final_status = f"검색 완료! 총 {len(unique_results)}개의 뉴스가 발견되었습니다."
        outputs[0] = gr.update(value=final_status, visible=True)
        yield outputs

    search_outputs = [
        status_message,
        translated_query_display,
        gr.Markdown(visible=False)
    ]
    
    for comp in article_components:
        search_outputs.extend([
            comp['group'], comp['title'], comp['image'],
            comp['snippet'], comp['info']
        ])
    search_outputs.append(articles_state)

    search_button.click(
        search_and_display,
        inputs=[query, country, articles_state],
        outputs=search_outputs,
        show_progress=True
    )

    # 전세계 검색 이벤트 연결
    global_search_outputs = [
        status_message_global,
        translated_query_display_global,
    ]
    
    for comp in global_article_components:
        global_search_outputs.extend([
            comp['group'], comp['title'], comp['image'],
            comp['snippet'], comp['info']
        ])
    global_search_outputs.append(articles_state_global)

    search_button_global.click(
        search_global,
        inputs=[query_global, articles_state_global],
        outputs=global_search_outputs,
        show_progress=True
    )

iface.launch(auth=("it1","chosun1"))