Delete app.py

app.py

@@ -1,971 +0,0 @@
-import gradio as gr
-import requests
-import json
-import os
-from datetime import datetime, timedelta
-from concurrent.futures import ThreadPoolExecutor, as_completed
-from functools import lru_cache
-from requests.adapters import HTTPAdapter
-from requests.packages.urllib3.util.retry import Retry
-from openai import OpenAI
-from bs4 import BeautifulSoup
-import re
-import pathlib
-import sqlite3
-import pytz
-
-
-#########################################################
-# 한국 기업 리스트
-#########################################################
-KOREAN_COMPANIES = [
-    "NVIDIA",
-    "ALPHABET",
-    "APPLE",
-    "TESLA",
-    "AMAZON",
-    "MICROSOFT", 
-    "META", 
-    "INTEL",
-    "SAMSUNG",
-    "HYNIX",
-    "BITCOIN",   
-    "crypto",
-    "stock",
-    "Economics",
-    "Finance",
-    "investing" 
-]
-
-
-#########################################################
-# 공통 함수
-#########################################################
-
-def convert_to_seoul_time(timestamp_str):
-    """
-    주어진 'YYYY-MM-DD HH:MM:SS' 형태의 UTC 시각을 서울 시간(KST)으로 변환하여
-    'YYYY-MM-DD HH:MM:SS KST' 형태의 문자열로 반환.
-    """
-    try:
-        dt = datetime.strptime(timestamp_str, '%Y-%m-%d %H:%M:%S')
-        seoul_tz = pytz.timezone('Asia/Seoul')
-        seoul_time = seoul_tz.localize(dt)
-        return seoul_time.strftime('%Y-%m-%d %H:%M:%S KST')
-    except Exception as e:
-        print(f"시간 변환 오류: {str(e)}")
-        return timestamp_str
-
-
-def analyze_sentiment_batch(articles, client):
-    """
-    OpenAI API를 통해 뉴스 기사들(articles)의 제목/내용을 종합하여
-    감성 분석(긍정/부정/중립 등)을 수행하고, 요약된 결과를 문자열로 반환.
-    """
-    try:
-        # 모든 기사(제목, snippet)을 합쳐 하나의 텍스트로 만든다.
-        combined_text = "\n\n".join([
-            f"제목: {article.get('title', '')}\n내용: {article.get('snippet', '')}"
-            for article in articles
-        ])
-        
-        # 감성 분석을 요청하는 프롬프트
-        prompt = f"""다음 뉴스 모음에 대해 전반적인 감성 분석을 수행하세요:
-
-뉴스 내용:
-{combined_text}
-
-다음 형식으로 분석해주세요:
-1. 전반적 감성: [긍정/부정/중립]
-2. 주요 긍정적 요소:
-   - [항목1]
-   - [항목2]
-3. 주요 부정적 요소:
-   - [항목1]
-   - [항목2]
-4. 종합 평가: [상세 설명]
-"""
-
-        response = client.chat.completions.create(
-            model="CohereForAI/c4ai-command-r-plus-08-2024",
-            messages=[{"role": "user", "content": prompt}],
-            temperature=0.3,
-            max_tokens=1000
-        )
-        
-        return response.choices[0].message.content
-
-    except Exception as e:
-        return f"감성 분석 실패: {str(e)}"
-
-
-#########################################################
-# DB 초기화 및 입출력 함수
-#########################################################
-
-def init_db():
-    """
-    SQLite DB 파일(search_results.db)이 없다면 생성하고,
-    'searches' 테이블이 없다면 생성한다.
-    """
-    db_path = pathlib.Path("search_results.db")
-    conn = sqlite3.connect(db_path)
-    c = conn.cursor()
-    c.execute('''CREATE TABLE IF NOT EXISTS searches
-                 (id INTEGER PRIMARY KEY AUTOINCREMENT,
-                  keyword TEXT,
-                  country TEXT,
-                  results TEXT,
-                  timestamp DATETIME DEFAULT CURRENT_TIMESTAMP)''')
-    conn.commit()
-    conn.close()
-
-
-def save_to_db(keyword, country, results):
-    """
-    특정 (keyword, country)에 대한 검색 결과(results: JSON 형태)를 DB에 저장.
-    """
-    conn = sqlite3.connect("search_results.db")
-    c = conn.cursor()
-    seoul_tz = pytz.timezone('Asia/Seoul')
-    now = datetime.now(seoul_tz)
-    timestamp = now.strftime('%Y-%m-%d %H:%M:%S')
-    
-    c.execute("""INSERT INTO searches 
-                 (keyword, country, results, timestamp) 
-                 VALUES (?, ?, ?, ?)""",
-              (keyword, country, json.dumps(results), timestamp))
-    conn.commit()
-    conn.close()
-
-
-def load_from_db(keyword, country):
-    """
-    DB에서 (keyword, country)에 해당하는 가장 최근 검색 결과를 불러온다.
-    결과가 있으면 (JSON 디코딩된 값, 'YYYY-MM-DD HH:MM:SS KST' 형태의 저장 시각) 반환.
-    없으면 (None, None) 반환.
-    """
-    conn = sqlite3.connect("search_results.db")
-    c = conn.cursor()
-    c.execute("""SELECT results, timestamp 
-                 FROM searches 
-                 WHERE keyword=? AND country=?
-                 ORDER BY timestamp DESC 
-                 LIMIT 1""",
-              (keyword, country))
-    result = c.fetchone()
-    conn.close()
-    if result:
-        return json.loads(result[0]), convert_to_seoul_time(result[1])
-    return None, None
-
-
-def load_by_id(search_id):
-    """
-    DB의 PRIMARY KEY(id)로 특정 검색 기록을 불러온다.
-    - keyword, country, results, timestamp
-    - results를 JSON 디코딩한 뒤 'data'로서 반환.
-    """
-    conn = sqlite3.connect("search_results.db")
-    c = conn.cursor()
-    c.execute("SELECT keyword, country, results, timestamp FROM searches WHERE id=?",
-              (search_id,))
-    row = c.fetchone()
-    conn.close()
-    
-    if row:
-        keyword, country, results_json, ts = row
-        data = json.loads(results_json)
-        return {
-            "keyword": keyword,
-            "country": country,
-            "data": data,
-            "timestamp": convert_to_seoul_time(ts)
-        }
-    return None
-
-
-#########################################################
-# 결과 표시
-#########################################################
-
-def display_results(articles):
-    """
-    기사 목록(articles)을 Markdown 형식으로 예쁘게 정리.
-    """
-    output = ""
-    for idx, article in enumerate(articles, 1):
-        output += f"### {idx}. {article['title']}\n"
-        output += f"출처: {article['channel']}\n"
-        output += f"시간: {article['time']}\n"
-        output += f"링크: {article['link']}\n"
-        output += f"요약: {article['snippet']}\n\n"
-    return output
-
-
-#########################################################
-# SerpHouse API: 번역 / 요청 / 응답 가공
-#########################################################
-
-API_KEY = os.getenv("SERPHOUSE_API_KEY")  # SERPHOUSE_API_KEY 환경변수
-
-def is_english(text):
-    """
-    text가 모두 ASCII 범위 내에 있으면 True, 아니면 False.
-    """
-    return all(ord(char) < 128 for char in text.replace(' ', '').replace('-', '').replace('_', ''))
-
-
-@lru_cache(maxsize=100)
-def translate_query(query, country):
-    """
-    검색어(query)를 해당 country 언어로 번역.
-    (단, is_english(query)가 True이거나, country가 특정 조건이면 그대로 리턴)
-    """
-    try:
-        if is_english(query):
-            return query
-        
-        if country in COUNTRY_LANGUAGES:
-            target_lang = COUNTRY_LANGUAGES[country]
-            
-            url = "https://translate.googleapis.com/translate_a/single"
-            params = {
-                "client": "gtx",
-                "sl": "auto",
-                "tl": target_lang,
-                "dt": "t",
-                "q": query
-            }
-            
-            session = requests.Session()
-            retries = Retry(total=3, backoff_factor=0.5)
-            session.mount('https://', HTTPAdapter(max_retries=retries))
-            
-            response = session.get(url, params=params, timeout=(5, 10))
-            translated_text = response.json()[0][0][0]
-            return translated_text
-            
-        return query
-        
-    except Exception as e:
-        print(f"번역 오류: {str(e)}")
-        return query
-
-
-def serphouse_search(query, country, page=1, num_result=10):
-    """
-    SerpHouse API에 실시간 'news' 검색 요청을 보내고,
-    결과를 특정 형식(오류 메시지 or 기사 목록)으로 반환한다.
-    """
-    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)
-    
-    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": str(page),
-            "num": "100",
-            "date_range": date_range,
-            "sort_by": "date"
-        }
-    }
-
-    headers = {
-        "accept": "application/json",
-        "content-type": "application/json",
-        "authorization": f"Bearer {API_KEY}"
-    }
-
-    try:
-        session = requests.Session()
-        
-        retries = Retry(
-            total=5,
-            backoff_factor=1,
-            status_forcelist=[500, 502, 503, 504, 429],
-            allowed_methods=["POST"]
-        )
-        
-        adapter = HTTPAdapter(max_retries=retries)
-        session.mount('http://', adapter)
-        session.mount('https://', adapter)
-        
-        # API 호출
-        response = session.post(
-            url,
-            json=payload,
-            headers=headers,
-            timeout=(30, 30)
-        )
-        
-        response.raise_for_status()
-        response_data = response.json()
-        
-        # 응답 데이터에서 기사 부분만 추출
-        return format_results_from_raw({
-            "results": response_data,
-            "translated_query": translated_query
-        })
-        
-    except requests.exceptions.Timeout:
-        return ("검색 시간이 초과되었습니다. 잠시 후 다시 시도해주세요.", [])
-    except requests.exceptions.RequestException as e:
-        return (f"검색 중 오류가 발생했습니다: {str(e)}", [])
-    except Exception as e:
-        return (f"예기치 않은 오류가 발생했습니다: {str(e)}", [])
-
-
-def format_results_from_raw(response_data):
-    """
-    SerpHouse API raw 데이터(response_data)에서
-    - error 가 있으면 ("Error: ...", [])
-    - 정상인 경우 ("", [기사1, 기사2, ...]) 형태로 반환
-    - 또한 한국 도메인/키워드를 가진 기사 제외 (필터링)
-    """
-    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 ("검색 결과가 없습니다.", [])
-        
-        # 한국 도메인 / 한국 키워드 기사 제외
-        korean_domains = [
-            '.kr', 'korea', 'korean', 'yonhap', 'hankyung', 'chosun', 
-            'donga', 'joins', 'hani', 'koreatimes', 'koreaherald'
-        ]
-        korean_keywords = [
-            'korea', 'korean', 'seoul', 'busan', 'incheon', 'daegu', 
-            'gwangju', 'daejeon', 'ulsan', 'sejong'
-        ]
-
-        filtered_articles = []
-        for idx, result in enumerate(news_results, 1):
-            url = result.get("url", result.get("link", "")).lower()
-            title = result.get("title", "").lower()
-            channel = result.get("channel", result.get("source", "")).lower()
-            
-            # 한국 관련 기사 필터
-            is_korean_content = (
-                any(domain in url or domain in channel for domain in korean_domains) or
-                any(keyword in title for keyword in korean_keywords)
-            )
-            
-            if not is_korean_content:
-                filtered_articles.append({
-                    "index": idx,
-                    "title": result.get("title", "제목 없음"),
-                    "link": url,
-                    "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 ("", filtered_articles)
-
-    except Exception as e:
-        return (f"결과 처리 중 오류 발생: {str(e)}", [])
-
-
-#########################################################
-# 국가 설정
-#########################################################
-
-COUNTRY_LANGUAGES = {
-    "United States": "en",
-    "KOREA": "ko",
-    "United Kingdom": "en",
-    "Taiwan": "zh-TW",
-    "Canada": "en",
-    "Australia": "en",
-    "Germany": "de",
-    "France": "fr",
-    "Japan": "ja",
-    "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": "Luxembourg",
-    "Malta": "Malta",
-    "Cyprus": "Cyprus",
-    "Iceland": "is"
-}
-
-COUNTRY_LOCATIONS = {
-    "United States": "United States",
-    "KOREA": "kr",
-    "United Kingdom": "United Kingdom",
-    "Taiwan": "Taiwan",
-    "Canada": "Canada",
-    "Australia": "Australia",
-    "Germany": "Germany",
-    "France": "France",
-    "Japan": "Japan",
-    "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": "et",
-    "Latvia": "lv",
-    "Lithuania": "lt",
-    "Slovenia": "sl",
-    "Luxembourg": "Luxembourg",
-    "Malta": "Malta",
-    "Cyprus": "Cyprus",
-    "Iceland": "Iceland"
-}
-
-
-#########################################################
-# 검색/출력 함수 (기업 검색, 로드)
-#########################################################
-
-def search_company(company):
-    """
-    KOREAN_COMPANIES에 있는 company를 미국(United States) 기준으로 검색 + 감성 분석
-    DB에 저장 후 기사 목록 + 분석 결과를 markdown으로 반환.
-    """
-    error_message, articles = serphouse_search(company, "United States")
-    if not error_message and articles:
-        analysis = analyze_sentiment_batch(articles, client)
-        store_dict = {
-            "articles": articles,
-            "analysis": analysis
-        }
-        # DB 저장
-        save_to_db(company, "United States", store_dict)
-
-        # 결과 출력
-        output = display_results(articles)
-        output += f"\n\n### 분석 보고\n{analysis}\n"
-        return output
-    else:
-        if error_message:
-            return error_message
-        return f"{company}에 대한 검색 결과가 없습니다."
-
-
-def load_company(company):
-    """
-    DB에 저장된 (company, United States) 검색 결과를 불러와 기사+분석 을 반환.
-    """
-    data, timestamp = load_from_db(company, "United States")
-    if data:
-        articles = data.get("articles", [])
-        analysis = data.get("analysis", "")
-        
-        output = f"### {company} 검색 결과\n저장 시간: {timestamp}\n\n"
-        output += display_results(articles)
-        output += f"\n\n### 분석 보고\n{analysis}\n"
-        return output
-    return f"{company}에 대한 저장된 결과가 없습니다."
-
-
-#########################################################
-# 전체 통계
-#########################################################
-
-def show_stats():
-    """
-    (기존 "한국 기업 뉴스 분석 리포트") -> "EarnBOT 분석 리포트" 로 명칭 변경
-    각 기업의 최신 DB 기록(기사+분석) 수를 표시하고,
-    감성 분석 결과를 함께 출력.
-    """
-    conn = sqlite3.connect("search_results.db")
-    c = conn.cursor()
-    
-    output = "## EarnBOT 분석 리포트\n\n"
-    
-    data_list = []
-    for company in KOREAN_COMPANIES:
-        c.execute("""
-            SELECT results, timestamp 
-            FROM searches 
-            WHERE keyword = ? 
-            ORDER BY timestamp DESC 
-            LIMIT 1
-        """, (company,))
-        
-        row = c.fetchone()
-        if row:
-            results_json, tstamp = row
-            data_list.append((company, tstamp, results_json))
-    
-    conn.close()
-    
-    def analyze_data(item):
-        comp, tstamp, results_json = item
-        data = json.loads(results_json)
-        articles = data.get("articles", [])
-        analysis = data.get("analysis", "")
-        count_articles = len(articles)
-        return (comp, tstamp, count_articles, analysis)
-
-    results_list = []
-    with ThreadPoolExecutor(max_workers=5) as executor:
-        futures = [executor.submit(analyze_data, dl) for dl in data_list]
-        for future in as_completed(futures):
-            results_list.append(future.result())
-    
-    for comp, tstamp, count, analysis in results_list:
-        seoul_time = convert_to_seoul_time(tstamp)
-        output += f"### {comp}\n"
-        output += f"- 마지막 업데이트: {seoul_time}\n"
-        output += f"- 저장된 기사 수: {count}건\n\n"
-        if analysis:
-            output += "#### 뉴스 감성 분석\n"
-            output += f"{analysis}\n\n"
-        output += "---\n\n"
-    
-    return output
-
-
-#########################################################
-# 전체 검색/출력 + 종합 보고
-#########################################################
-
-def search_all_companies():
-    """
-    KOREAN_COMPANIES 리스트에 대해 병렬 검색 + 분석
-    """
-    overall_result = "# [전체 검색 결과]\n\n"
-    
-    def do_search(comp):
-        return comp, search_company(comp)
-    
-    with ThreadPoolExecutor(max_workers=5) as executor:
-        futures = [executor.submit(do_search, c) for c in KOREAN_COMPANIES]
-        for future in as_completed(futures):
-            comp, res_text = future.result()
-            overall_result += f"## {comp}\n"
-            overall_result += res_text + "\n\n"
-    
-    return overall_result
-
-
-def load_all_companies():
-    """
-    KOREAN_COMPANIES 리스트에 대해 DB에 저장된 값(기사+분석) 일괄 출력
-    """
-    overall_result = "# [전체 출력 결과]\n\n"
-    for comp in KOREAN_COMPANIES:
-        overall_result += f"## {comp}\n"
-        overall_result += load_company(comp)
-        overall_result += "\n"
-    return overall_result
-
-
-def full_summary_report():
-    """
-    1) search_all_companies => 기사+분석 => DB 저장
-    2) load_all_companies => DB 로드
-    3) show_stats => 종합 감성 분석
-    """
-    search_result_text = search_all_companies()
-    load_result_text = load_all_companies()
-    stats_text = show_stats()
-    
-    combined_report = (
-        "# 전체 분석 보고 요약\n\n"
-        "아래 순서로 실행되었습니다:\n"
-        "1. 모든 종목 검색(병렬) + 분석 => 2. 모든 종목 DB 결과 출력 => 3. 전체 감성 분석 통계\n\n"
-        f"{search_result_text}\n\n"
-        f"{load_result_text}\n\n"
-        "## [전체 감성 분석 통계]\n\n"
-        f"{stats_text}"
-    )
-    return combined_report
-
-
-#########################################################
-# (추가) 사용자 임의 검색 + 분석
-#########################################################
-
-def search_custom(query, country):
-    """
-    1) query & country에 대해 검색 + 분석 => DB저장
-    2) DB에서 다시 로딩 => 기사 + 분석 결과 표시
-    """
-    error_message, articles = serphouse_search(query, country)
-    if error_message:
-        return f"오류 발생: {error_message}"
-    if not articles:
-        return "검색 결과가 없습니다."
-    
-    analysis = analyze_sentiment_batch(articles, client)
-    save_data = {
-        "articles": articles,
-        "analysis": analysis
-    }
-    save_to_db(query, country, save_data)
-    
-    loaded_data, timestamp = load_from_db(query, country)
-    if not loaded_data:
-        return "DB에서 로드 실패"
-
-    arts = loaded_data.get("articles", [])
-    analy = loaded_data.get("analysis", "")
-    
-    out = f"## [사용자 임의 검색 결과]\n\n"
-    out += f"**키워드**: {query}\n\n"
-    out += f"**국가**: {country}\n\n"
-    out += f"**저장 시간**: {timestamp}\n\n"
-
-    out += display_results(arts)
-    out += f"### 뉴스 감성 분석\n{analy}\n"
-    
-    return out
-
-
-#########################################################
-# (추가) 히스토리 함수
-#########################################################
-
-def get_custom_search_history():
-    """
-    KOREAN_COMPANIES 목록에 없는 keyword로 검색된 기록만 (id, label) 리스트로 반환.
-    label 예: "12 | 2025-01-22 10:23:00 KST | Apple (United States)"
-    """
-    company_set = set(k.lower() for k in KOREAN_COMPANIES)
-    
-    conn = sqlite3.connect("search_results.db")
-    c = conn.cursor()
-    c.execute("""SELECT id, keyword, country, timestamp
-                 FROM searches
-                 ORDER BY timestamp DESC""")
-    rows = c.fetchall()
-    conn.close()
-    
-    history_list = []
-    for sid, kw, cty, ts in rows:
-        if kw.lower() not in company_set:
-            display_time = convert_to_seoul_time(ts)
-            label = f"{sid} | {display_time} | {kw} ({cty})"
-            history_list.append((str(sid), label))
-    return history_list
-
-
-def view_history_record(record_id):
-    """
-    주어진 record_id 로부터 load_by_id() 로 로드한 기사+분석 결과를 Markdown 표시
-    """
-    if not record_id:
-        return "기록이 없습니다."
-    
-    data = load_by_id(int(record_id))
-    if not data:
-        return "해당 ID의 기록이 없습니다."
-    
-    keyword = data["keyword"]
-    country = data["country"]
-    timestamp = data["timestamp"]
-    stored = data["data"]  # {"articles": [...], "analysis": ...}
-    
-    articles = stored.get("articles", [])
-    analysis = stored.get("analysis", "")
-    
-    out = f"### [히스토리 검색 결과]\n\n"
-    out += f"- ID: {record_id}\n"
-    out += f"- 키워드: {keyword}\n"
-    out += f"- 국가: {country}\n"
-    out += f"- 저장 시간: {timestamp}\n\n"
-    out += display_results(articles)
-    out += f"\n\n### 분석 보고\n{analysis}\n"
-    return out
-
-
-#########################################################
-# Gradio 인터페이스
-#########################################################
-
-ACCESS_TOKEN = os.getenv("HF_TOKEN")
-if not ACCESS_TOKEN:
-    raise ValueError("HF_TOKEN environment variable is not set")
-
-client = OpenAI(
-    base_url="https://api-inference.huggingface.co/v1/",
-    api_key=ACCESS_TOKEN,
-)
-
-css = """
-/* 전역 스타일 */
-footer {visibility: hidden;}
-
-/* 기타 CSS 등... (이하 동일) */
-"""
-
-with gr.Blocks(theme="Yntec/HaleyCH_Theme_Orange", css=css, title="NewsAI 서비스") as iface:
-    init_db()
-    
-    # 원하는 탭들 구성
-    with gr.Tabs():
-        with gr.Tab("지정 자동 검색/분석"):
-            gr.Markdown("## EarnBot: 글로벌 빅테크 기업 및 투자 전망 AI 자동 분석")
-            gr.Markdown("- '전체 분석 보고 요약' 클릭 시 전체 자동 보고 생성.\n"
-                        "- 아래 개별 종목의 '검색(DB 자동 저장)'과 '출력(DB 자동 호출)'도 가능.\n"
-                        "- 하단 '수동 검색 히스토리'에서 이전에 수동 입력한 검색어 기록을 확인 가능.")
-            
-            with gr.Row():
-                full_report_btn = gr.Button("전체 분석 보고 요약", variant="primary")
-                full_report_display = gr.Markdown()
-            full_report_btn.click(fn=full_summary_report, outputs=full_report_display)
-            
-            # 개별 종목 검색/출력
-            with gr.Column():
-                for i in range(0, len(KOREAN_COMPANIES), 2):
-                    with gr.Row():
-                        # 왼쪽 열
-                        with gr.Column():
-                            company = KOREAN_COMPANIES[i]
-                            with gr.Group():
-                                gr.Markdown(f"### {company}")
-                                with gr.Row():
-                                    search_btn = gr.Button("검색", variant="primary")
-                                    load_btn = gr.Button("출력", variant="secondary")
-                                result_display = gr.Markdown()
-                                
-                                search_btn.click(
-                                    fn=lambda c=company: search_company(c),
-                                    inputs=[],
-                                    outputs=result_display
-                                )
-                                load_btn.click(
-                                    fn=lambda c=company: load_company(c),
-                                    inputs=[],
-                                    outputs=result_display
-                                )
-                        
-                        # 오른쪽 열
-                        if i + 1 < len(KOREAN_COMPANIES):
-                            with gr.Column():
-                                company = KOREAN_COMPANIES[i + 1]
-                                with gr.Group():
-                                    gr.Markdown(f"### {company}")
-                                    with gr.Row():
-                                        search_btn = gr.Button("검색", variant="primary")
-                                        load_btn = gr.Button("출력", variant="secondary")
-                                    result_display = gr.Markdown()
-                                    
-                                    search_btn.click(
-                                        fn=lambda c=company: search_company(c),
-                                        inputs=[],
-                                        outputs=result_display
-                                    )
-                                    load_btn.click(
-                                        fn=lambda c=company: load_company(c),
-                                        inputs=[],
-                                        outputs=result_display
-                                    )
-            
-            gr.Markdown("---")
-            gr.Markdown("### 수동 검색 히스토리")
-
-            with gr.Row():
-                refresh_hist_btn = gr.Button("히스토리 갱신", variant="secondary")
-            
-            history_dropdown = gr.Dropdown(label="검색 기록 목록", choices=[], value=None)
-            hist_view_btn = gr.Button("보기", variant="primary")
-            hist_result_display = gr.Markdown()
-
-            def update_history_dropdown():
-                history_list = get_custom_search_history()
-                choice_list = []
-                for (id_val, label) in history_list:
-                    choice_list.append(label)
-                return gr.update(choices=choice_list, value=None)
-            
-            refresh_hist_btn.click(
-                fn=update_history_dropdown,
-                inputs=[],
-                outputs=history_dropdown
-            )
-            
-            def show_history_record(selected_label):
-                if not selected_label:
-                    return "히스토리가 선택되지 않았습니다."
-                splitted = selected_label.split("|")
-                if len(splitted) < 2:
-                    return "형식 오류"
-                record_id = splitted[0].strip()
-                return view_history_record(record_id)
-            
-            hist_view_btn.click(
-                fn=show_history_record,
-                inputs=[history_dropdown],
-                outputs=hist_result_display
-            )
-
-        # 두 번째 탭: "수동 검색/분석"
-        with gr.Tab("수동 검색/분석"):
-            gr.Markdown("## 사용자 임의 키워드 + 국가 검색/분석")
-            gr.Markdown("검색 결과가 DB에 저장되며, 아래 '수동 검색 히스토리'에서도 확인 가능합니다.")
-            
-            with gr.Row():
-                with gr.Column():
-                    user_input = gr.Textbox(
-                        label="검색어 입력",
-                        placeholder="예) Apple, Samsung 등 자유롭게"
-                    )
-                with gr.Column():
-                    country_selection = gr.Dropdown(
-                        choices=list(COUNTRY_LOCATIONS.keys()),
-                        value="United States",
-                        label="국가 선택"
-                    )
-                with gr.Column():
-                    custom_search_btn = gr.Button("실행", variant="primary")
-
-            custom_search_output = gr.Markdown()
-            
-            custom_search_btn.click(
-                fn=search_custom,
-                inputs=[user_input, country_selection],
-                outputs=custom_search_output
-            )
-            
-            gr.Markdown("---")
-            gr.Markdown("### 수동 검색 히스토리 (두 번째 탭)")
-            
-            with gr.Row():
-                refresh_hist_btn2 = gr.Button("히스토리 갱신", variant="secondary")
-            
-            history_dropdown2 = gr.Dropdown(label="검색 기록 목록", choices=[], value=None)
-            hist_view_btn2 = gr.Button("보기", variant="primary")
-            hist_result_display2 = gr.Markdown()
-
-            refresh_hist_btn2.click(
-                fn=update_history_dropdown,
-                inputs=[],
-                outputs=history_dropdown2
-            )
-            
-            hist_view_btn2.click(
-                fn=show_history_record,
-                inputs=[history_dropdown2],
-                outputs=hist_result_display2
-            )
-
-
-iface.launch(
-    server_name="0.0.0.0",
-    server_port=7860,
-    share=True,
-    ssl_verify=False,
-    show_error=True
-)