Update app.py

app.py

@@ -14,7 +14,7 @@ import pathlib
 import sqlite3
 import pytz
 
-# 한국 기업 리스트
+# List of target companies/keywords
 KOREAN_COMPANIES = [
     "NVIDIA",
     "ALPHABET",
@@ -31,44 +31,47 @@ KOREAN_COMPANIES = [
     "stock",
     "Economics",
     "Finance",
-    "investing" 
+    "investing"
 ]
 
 def convert_to_seoul_time(timestamp_str):
+    """
+    Convert a given timestamp string (UTC) to Seoul time (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)}")
+        print(f"Time conversion error: {str(e)}")
         return timestamp_str
 
 def analyze_sentiment_batch(articles, client):
     """
-    OpenAI API를 통해 뉴스 기사들의 종합 감성 분석을 수행
+    Perform a comprehensive sentiment analysis of the news articles using the OpenAI API.
     """
     try:
-        # 모든 기사의 제목과 내용을 하나의 텍스트로 결합
+        # Combine all articles into a single text
         combined_text = "\n\n".join([
-            f"제목: {article.get('title', '')}\n내용: {article.get('snippet', '')}"
+            f"Title: {article.get('title', '')}\nContent: {article.get('snippet', '')}"
             for article in articles
         ])
         
-        prompt = f"""다음 뉴스 모음에 대해 전반적인 감성 분석을 수행하세요:
+        prompt = f"""Please perform an overall sentiment analysis of the following collection of news articles:
 
-뉴스 내용:
+News content:
 {combined_text}
 
-다음 형식으로 분석해주세요:
-1. 전반적 감성: [긍정/부정/중립]
-2. 주요 긍정적 요소:
-   - [항목1]
-   - [항목2]
-3. 주요 부정적 요소:
-   - [항목1]
-   - [항목2]
-4. 종합 평가: [상세 설명]
+Please follow this format:
+1. Overall Sentiment: [Positive/Negative/Neutral]
+2. Key Positive Factors:
+   - [Item1]
+   - [Item2]
+3. Key Negative Factors:
+   - [Item1]
+   - [Item2]
+4. Summary: [Detailed explanation]
 """
 
         response = client.chat.completions.create(
@@ -80,11 +83,14 @@ def analyze_sentiment_batch(articles, client):
         
         return response.choices[0].message.content
     except Exception as e:
-        return f"감성 분석 실패: {str(e)}"
+        return f"Sentiment analysis failed: {str(e)}"
 
 
-# DB 초기화 함수
+# Initialize the database
 def init_db():
+    """
+    Initialize the SQLite database (search_results.db) if it doesn't already exist.
+    """
     db_path = pathlib.Path("search_results.db")
     conn = sqlite3.connect(db_path)
     c = conn.cursor()
@@ -99,7 +105,7 @@ def init_db():
 
 def save_to_db(keyword, country, results):
     """
-    특정 (keyword, country) 조합에 대한 검색 결과를 DB에 저장
+    Save the search results for a specific (keyword, country) combination into the database.
     """
     conn = sqlite3.connect("search_results.db")
     c = conn.cursor()
@@ -116,12 +122,15 @@ def save_to_db(keyword, country, results):
 
 def load_from_db(keyword, country):
     """
-    특정 (keyword, country) 조합에 대한 가장 최근 검색 결과를 DB에서 불러오기
+    Load the most recent search results for a specific (keyword, country) combination from the database.
+    Returns the data and the timestamp.
     """
     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))
+    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:
@@ -130,85 +139,85 @@ def load_from_db(keyword, country):
 
 def display_results(articles):
     """
-    뉴스 기사 목록을 Markdown 문자열로 변환하여 반환
+    Convert a list of news articles into a Markdown string for display.
     """
     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"
+        output += f"Source: {article['channel']}\n"
+        output += f"Time: {article['time']}\n"
+        output += f"Link: {article['link']}\n"
+        output += f"Summary: {article['snippet']}\n\n"
     return output
 
 
 ########################################
-# 1) 검색 시 => 기사 + 분석 동시 출력, DB 저장
+# 1) Search => Articles + Analysis, then save to DB
 ########################################
 def search_company(company):
     """
-    단일 기업(또는 키워드)에 대해 미국 뉴스 검색 후,
-    1) 기사 목록 + 2) 감성 분석 보고를 함께 출력
-    => { "articles": [...], "analysis": ... } 형태로 DB에 저장
+    For a single company (or keyword), search US news.
+    1) Retrieve a list of articles
+    2) Perform sentiment analysis
+    3) Save results to DB
+    4) Return (articles + analysis) in a single output.
     """
     error_message, articles = serphouse_search(company, "United States")
     if not error_message and articles:
-        # 감성 분석
+        # Perform sentiment analysis
         analysis = analyze_sentiment_batch(articles, client)
         
-        # DB 저장용 데이터 구성
+        # Prepare data to save in DB
         store_dict = {
             "articles": articles,
             "analysis": analysis
         }
         save_to_db(company, "United States", store_dict)
         
-        # 화면 출력용
+        # Prepare output for display
         output = display_results(articles)
-        output += f"\n\n### 분석 보고\n{analysis}\n"
+        output += f"\n\n### Analysis Report\n{analysis}\n"
         return output
-    return f"{company}에 대한 검색 결과가 없습니다."
+    return f"No search results found for {company}."
 
 ########################################
-# 2) 출력 시 => DB에 저장된 기사 + 분석 함께 출력
+# 2) Load => Return articles + analysis from DB
 ########################################
 def load_company(company):
     """
-    DB에서 단일 기업(또는 키워드)의 미국 뉴스 검색 결과를 불러와
-    기사 목록 + 분석 결과를 함께 출력
+    Load the most recent US news search results for the given company (or keyword) from the database,
+    and return the articles + analysis in a single output.
     """
     data, timestamp = load_from_db(company, "United States")
     if data:
-        # data는 { "articles": [...], "analysis": "..."} 형태
         articles = data.get("articles", [])
         analysis = data.get("analysis", "")
         
-        output = f"### {company} 검색 결과\n저장 시간: {timestamp}\n\n"
+        output = f"### {company} Search Results\nLast Updated: {timestamp}\n\n"
         output += display_results(articles)
-        output += f"\n\n### 분석 보고\n{analysis}\n"
+        output += f"\n\n### Analysis Report\n{analysis}\n"
         return output
-    return f"{company}에 대한 저장된 결과가 없습니다."
+    return f"No saved results for {company}."
 
 
 ########################################
-# 3) 기존 show_stats()에서 리포트 제목 변경
+# 3) Updated show_stats() with new title
 ########################################
 def show_stats():
     """
-    KOREAN_COMPANIES 목록 내 모든 기업에 대해:
-      - 가장 최근 DB 저장 일자
-      - 기사 수
-      - 감성 분석 결과
-    를 병렬처리로 조회하여 보고서 형태로 반환
-    
-    (문구 변경) "한국 기업 뉴스 분석 리포트" -> "EarnBOT 분석 리포트"
+    For each company in KOREAN_COMPANIES:
+      - Retrieve the most recent timestamp in DB
+      - Number of articles
+      - Sentiment analysis result
+    Return these in a report format.
+
+    Title changed to: "EarnBOT Analysis Report"
     """
     conn = sqlite3.connect("search_results.db")
     c = conn.cursor()
     
-    output = "## EarnBOT 분석 리포트\n\n"  # 여기서 문구 변경
+    output = "## EarnBOT Analysis Report\n\n"
     
-    # 모든 기업에 대해 DB에서 읽어올 (company, timestamp, articles) 목록 수집
     data_list = []
     for company in KOREAN_COMPANIES:
         c.execute("""
@@ -226,7 +235,6 @@ def show_stats():
     
     conn.close()
     
-    # 감성 분석 병렬 처리 함수
     def analyze_data(item):
         comp, tstamp, results_json = item
         data = json.loads(results_json)
@@ -234,10 +242,6 @@ def show_stats():
         analysis = data.get("analysis", "")
         
         count_articles = len(articles)
-        # 여기서는 이미 DB에 "analysis"가 들어 있으므로, 
-        # 굳이 재분석할 필요가 없으면 그대로 사용
-        # (필요 시 재분석 가능)
-        
         return (comp, tstamp, count_articles, analysis)
 
     results_list = []
@@ -246,14 +250,13 @@ def show_stats():
         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"
+        output += f"- Last updated: {seoul_time}\n"
+        output += f"- Number of articles stored: {count}\n\n"
         if analysis:
-            output += "#### 뉴스 감성 분석\n"
+            output += "#### News Sentiment Analysis\n"
             output += f"{analysis}\n\n"
         output += "---\n\n"
     
@@ -262,10 +265,10 @@ def show_stats():
 
 def search_all_companies():
     """
-    KOREAN_COMPANIES 리스트 내 모든 기업 검색 (멀티스레딩) => 
-    => 분석 + DB 저장 => 결과 Markdown 반환
+    Search all companies in KOREAN_COMPANIES (in parallel), 
+    perform sentiment analysis + save to DB => return Markdown of all results.
     """
-    overall_result = "# [전체 검색 결과]\n\n"
+    overall_result = "# [Search Results for All Companies]\n\n"
     
     def do_search(comp):
         return comp, search_company(comp)
@@ -281,10 +284,9 @@ def search_all_companies():
 
 def load_all_companies():
     """
-    KOREAN_COMPANIES 리스트 내 모든 기업 DB 불러오기 => 
-    기사 목록 + 분석 보고 => 결과 Markdown
+    Load articles + analysis for all companies in KOREAN_COMPANIES from the DB => return Markdown.
     """
-    overall_result = "# [전체 출력 결과]\n\n"
+    overall_result = "# [All Companies Data Output]\n\n"
     
     for comp in KOREAN_COMPANIES:
         overall_result += f"## {comp}\n"
@@ -294,77 +296,77 @@ def load_all_companies():
 
 def full_summary_report():
     """
-    (1) 모든 기업 검색(병렬) -> (2) DB에서 불러오기 -> (3) 감성 분석 통계
-    순서대로 실행하여, 전체 리포트를 합쳐 반환
+    1) Search all companies (in parallel) -> 2) Load results -> 3) Show sentiment analysis stats
+    Return a combined report with all three steps.
     """
-    # 1) 전체 검색(병렬) => 기사 + 분석 DB 저장
+    # 1) Search all companies => store to DB
     search_result_text = search_all_companies()
     
-    # 2) 전체 출력 => DB에 저장된 기사 + 분석 결과
+    # 2) Load all results => from DB
     load_result_text = load_all_companies()
     
-    # 3) 전체 통계(감성 분석) - 리포트 제목 변경됨(EarnBOT 분석 리포트)
+    # 3) Show stats => EarnBOT Analysis Report
     stats_text = show_stats()
     
     combined_report = (
-        "# 전체 분석 보고 요약\n\n"
-        "아래 순서로 실행되었습니다:\n"
-        "1. 모든 종목 검색(병렬) + 분석 => 2. 모든 종목 DB 결과 출력 => 3. 전체 감성 분석 통계\n\n"
+        "# Full Analysis Summary Report\n\n"
+        "Executed in the following order:\n"
+        "1. Search all companies (parallel) + sentiment analysis => 2. Load results from DB => 3. Show overall sentiment analysis stats\n\n"
         f"{search_result_text}\n\n"
         f"{load_result_text}\n\n"
-        "## [전체 감성 분석 통계]\n\n"
+        "## [Overall Sentiment Analysis Stats]\n\n"
         f"{stats_text}"
     )
     return combined_report
 
 
 ########################################
-# 사용자 임의 검색 (추가 기능)
+# Additional feature: User custom search
 ########################################
 def search_custom(query, country):
     """
-    사용자가 입력한 (query, country)에 대해 
-    1) 검색 + 분석 => DB 저장
-    2) DB 로드 => 결과(기사 목록 + 분석) 출력
+    For a user-provided (query, country):
+    1) Search + sentiment analysis => save to DB
+    2) Load from DB => display articles + analysis
     """
     error_message, articles = serphouse_search(query, country)
     if error_message:
-        return f"오류 발생: {error_message}"
+        return f"An error occurred: {error_message}"
     if not articles:
-        return "검색 결과가 없습니다."
+        return "No results were found for your query."
     
-    # 1) 분석
+    # 1) Perform analysis
     analysis = analyze_sentiment_batch(articles, client)
     
-    # 2) DB 저장
+    # 2) Save to DB
     save_data = {
         "articles": articles,
         "analysis": analysis
     }
     save_to_db(query, country, save_data)
     
-    # 3) DB 재로드
+    # 3) Reload from DB
     loaded_data, timestamp = load_from_db(query, country)
     if not loaded_data:
-        return "DB에서 로드 실패"
+        return "Failed to load data from DB."
 
-    # 4) 결과 표시
-    out = f"## [사용자 임의 검색 결과]\n\n"
-    out += f"**키워드**: {query}\n\n"
-    out += f"**국가**: {country}\n\n"
-    out += f"**저장 시간**: {timestamp}\n\n"
+    # 4) Prepare final output
+    out = f"## [Custom Search Results]\n\n"
+    out += f"**Keyword**: {query}\n\n"
+    out += f"**Country**: {country}\n\n"
+    out += f"**Timestamp**: {timestamp}\n\n"
 
     arts = loaded_data.get("articles", [])
     analy = loaded_data.get("analysis", "")
     
     out += display_results(arts)
-    out += f"### 뉴스 감성 분석\n{analy}\n"
+    out += f"### News Sentiment Analysis\n{analy}\n"
     
     return out
 
 
 ########################################
-# API 인증
+# API Authentication
 ########################################
 ACCESS_TOKEN = os.getenv("HF_TOKEN")
 if not ACCESS_TOKEN:
@@ -379,13 +381,13 @@ API_KEY = os.getenv("SERPHOUSE_API_KEY")
 
 
 ########################################
-# 국가별 설정
+# Country-specific settings
 ########################################
 COUNTRY_LANGUAGES = {
     "United States": "en",
     "KOREA": "ko",
     "United Kingdom": "en",
-    "Taiwan": "zh-TW",  
+    "Taiwan": "zh-TW",
     "Canada": "en",
     "Australia": "en",
     "Germany": "de",
@@ -527,7 +529,8 @@ COUNTRY_LOCATIONS = {
 @lru_cache(maxsize=100)
 def translate_query(query, country):
     """
-    Google Translation API(비공식) 사용하여 검색어를 해당 국가 언어로 번역
+    Use the unofficial Google Translation API to translate the query into the target country's language.
+    If the query is already in English, or if translation fails, return the original query.
     """
     try:
         if is_english(query):
@@ -554,20 +557,23 @@ def translate_query(query, country):
             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)}")
+        print(f"Translation error: {str(e)}")
         return query
 
 def is_english(text):
+    """
+    Check if a string is (mostly) English by verifying character code ranges.
+    """
     return all(ord(char) < 128 for char in text.replace(' ', '').replace('-', '').replace('_', ''))
 
 def search_serphouse(query, country, page=1, num_result=10):
     """
-    SerpHouse API에 실시간 검색 요청을 보내어, 
-    '뉴스' 탭 (sort_by=date)에서 해당 query에 대한 기사 목록을 가져온다.
+    Send a real-time search request to the SerpHouse API,
+    specifying the 'news' tab (sort_by=date) for the given query.
+    Returns a dict with 'results' or 'error'.
     """
     url = "https://api.serphouse.com/serp/live"
     
@@ -624,24 +630,23 @@ def search_serphouse(query, country, page=1, num_result=10):
         
     except requests.exceptions.Timeout:
         return {
-            "error": "검색 시간이 초과되었습니다. 잠시 후 다시 시도해주세요.",
+            "error": "Search timed out. Please try again later.",
             "translated_query": query
         }
     except requests.exceptions.RequestException as e:
         return {
-            "error": f"검색 중 오류가 발생했습니다: {str(e)}",
+            "error": f"Error during search: {str(e)}",
             "translated_query": query
         }
     except Exception as e:
         return {
-            "error": f"예기치 않은 오류가 발생했습니다: {str(e)}",
+            "error": f"Unexpected error occurred: {str(e)}",
             "translated_query": query
         }
 
 def format_results_from_raw(response_data):
     """
-    SerpHouse API의 응답 데이터를 가공하여,
-    (에러메시지, 기사리스트) 형태로 반환.
+    Process the SerpHouse API response data and return (error_message, article_list).
     """
     if "error" in response_data:
         return "Error: " + response_data["error"], []
@@ -650,12 +655,11 @@ def format_results_from_raw(response_data):
         results = response_data["results"]
         translated_query = response_data["translated_query"]
         
-        # 실제 뉴스 결과
         news_results = results.get('results', {}).get('results', {}).get('news', [])
         if not news_results:
-            return "검색 결과가 없습니다.", []
+            return "No search results found.", []
         
-        # 한국 도메인 및 한국 관련 키워드 포함 기사 제외
+        # Filter out Korean domains and Korean keywords (example filtering)
         korean_domains = [
             '.kr', 'korea', 'korean', 'yonhap', 'hankyung', 'chosun', 
             'donga', 'joins', 'hani', 'koreatimes', 'koreaherald'
@@ -676,37 +680,45 @@ def format_results_from_raw(response_data):
                 any(keyword in title for keyword in korean_keywords)
             )
             
-            # 한국어 뉴스(또는 한국 도메인) 제외
+            # Exclude Korean content
             if not is_korean_content:
                 filtered_articles.append({
                     "index": idx,
-                    "title": result.get("title", "제목 없음"),
+                    "title": result.get("title", "No Title"),
                     "link": url,
-                    "snippet": result.get("snippet", "내용 없음"),
-                    "channel": result.get("channel", result.get("source", "알 수 없음")),
-                    "time": result.get("time", result.get("date", "알 수 없는 시간")),
+                    "snippet": result.get("snippet", "No Content"),
+                    "channel": result.get("channel", result.get("source", "Unknown")),
+                    "time": result.get("time", result.get("date", "Unknown Time")),
                     "image_url": result.get("img", result.get("thumbnail", "")),
                     "translated_query": translated_query
                 })
 
         return "", filtered_articles
     except Exception as e:
-        return f"결과 처리 중 오류 발생: {str(e)}", []
+        return f"Error processing results: {str(e)}", []
 
 def serphouse_search(query, country):
     """
-    검색 및 결과 포매팅까지 일괄 처리
+    Helper function to search and then format results.
+    Returns (error_message, article_list).
     """
     response_data = search_serphouse(query, country)
     return format_results_from_raw(response_data)
 
 
-# CSS (UI 커스터마이징)
+# Updated CSS for more visual appeal and readability
 css = """
-/* 전역 스타일 */
-footer {visibility: hidden;}
+body {
+    background: linear-gradient(to bottom right, #ffffff, #e6f7ff);
+    font-family: 'Arial', sans-serif;
+}
 
-/* 레이아웃 컨테이너 */
+/* Hide default Gradio footer */
+footer {
+    visibility: hidden;
+}
+
+/* Header/Status area */
 #status_area {
     background: rgba(255, 255, 255, 0.9);
     padding: 15px;
@@ -715,12 +727,13 @@ footer {visibility: hidden;}
     box-shadow: 0 2px 5px rgba(0,0,0,0.1);
 }
 
+/* Results area */
 #results_area {
     padding: 10px;
     margin-top: 10px;
 }
 
-/* 탭 스타일 */
+/* Tabs style */
 .tabs {
     border-bottom: 2px solid #ddd !important;
     margin-bottom: 20px !important;
@@ -741,35 +754,42 @@ footer {visibility: hidden;}
     color: #1f77b4 !important;
 }
 
-/* 상태 메시지 */
+/* Status message styling */
 #status_area .markdown-text {
     font-size: 1.1em;
     color: #2c3e50;
     padding: 10px 0;
 }
 
-/* 기본 컨테이너 */
+/* Main container grouping */
 .group {
     border: 1px solid #eee;
     padding: 15px;
     margin-bottom: 15px;
     border-radius: 5px;
     background: white;
+    transition: all 0.3s ease;
+    opacity: 0;
+    transform: translateY(20px);
+}
+.group.visible {
+    opacity: 1;
+    transform: translateY(0);
 }
 
-/* 버튼 스타일 */
+/* Buttons */
 .primary-btn {
     background: #1f77b4 !important;
     border: none !important;
 }
 
-/* 입력 필드 */
+/* Input fields */
 .textbox {
     border: 1px solid #ddd !important;
     border-radius: 4px !important;
 }
 
-/* 프로그레스바 컨테이너 */
+/* Progress bar container */
 .progress-container {
     position: fixed;
     top: 0;
@@ -780,7 +800,7 @@ footer {visibility: hidden;}
     z-index: 1000;
 }
 
-/* 프로그레스bar */
+/* Progress bar itself */
 .progress-bar {
     height: 100%;
     background: linear-gradient(90deg, #2196F3, #00BCD4);
@@ -789,7 +809,7 @@ footer {visibility: hidden;}
     animation: progress-glow 1.5s ease-in-out infinite;
 }
 
-/* 프로그레스 텍스트 */
+/* Progress text */
 .progress-text {
     position: fixed;
     top: 8px;
@@ -804,7 +824,7 @@ footer {visibility: hidden;}
     box-shadow: 0 2px 5px rgba(0,0,0,0.2);
 }
 
-/* 프로그레스바 애니메이션 */
+/* Progress bar animation */
 @keyframes progress-glow {
     0% {
         box-shadow: 0 0 5px rgba(33, 150, 243, 0.5);
@@ -817,7 +837,14 @@ footer {visibility: hidden;}
     }
 }
 
-/* 반응형 디자인 */
+/* Loading state */
+.loading {
+    opacity: 0.7;
+    pointer-events: none;
+    transition: opacity 0.3s ease;
+}
+
+/* Responsive design for smaller screens */
 @media (max-width: 768px) {
     .group {
         padding: 10px;
@@ -830,26 +857,7 @@ footer {visibility: hidden;}
     }
 }
 
-/* 로딩 상태 표시 개선 */
-.loading {
-    opacity: 0.7;
-    pointer-events: none;
-    transition: opacity 0.3s ease;
-}
-
-/* 결과 컨테이너 애니메이션 */
-.group {
-    transition: all 0.3s ease;
-    opacity: 0;
-    transform: translateY(20px);
-}
-
-.group.visible {
-    opacity: 1;
-    transform: translateY(0);
-}
-
-/* Examples 스타일링 */
+/* Example section styling */
 .examples-table {
     margin-top: 10px !important;
     margin-bottom: 20px !important;
@@ -877,34 +885,35 @@ footer {visibility: hidden;}
 }
 """
 
-import gradio as gr
-
-with gr.Blocks(theme="Yntec/HaleyCH_Theme_Orange", css=css, title="NewsAI 서비스") as iface:
+with gr.Blocks(theme="Yntec/HaleyCH_Theme_Orange", css=css, title="NewsAI Service") as iface:
     init_db()
     
     with gr.Tabs():
-        # 첫 번째 탭
-        with gr.Tab("Earnbot"):
-            gr.Markdown("## EarnBot: 글로벌 빅테크 기업 및 투자 전망 AI 자동 분석")
-            gr.Markdown(" * '전체 분석 보고 요약' 클릭 시 전체 자동 보고 생성.\n * 아래 개별 종목의 '검색(DB 자동 저장)'과 '출력(DB 자동 호출)'도 가능.\n * 추가로, 원하는 임의 키워드 및 국가로 검색/분석할 수도 있습니다.")
+        with gr.Tab("EarnBot"):
+            gr.Markdown("## EarnBot: AI-powered Analysis of Global Big Tech Companies and Investment Outlook")
+            gr.Markdown(
+                " * Click on 'Generate Full Analysis Summary Report' to create a comprehensive automated report.\n"
+                " * You can also 'Search (automatically save to DB)' and 'Load from DB (automatically retrieve)' for each listed company.\n"
+                " * Additionally, feel free to search/analyze any custom keyword in your chosen country."
+            )
             
-            # (사용자 임의 검색 섹션)
+            # User custom search section
             with gr.Group():
-                gr.Markdown("### 사용자 임의 검색")
+                gr.Markdown("### Custom Search")
                 with gr.Row():
                     with gr.Column():
                         user_input = gr.Textbox(
-                            label="검색어 입력",
-                            placeholder="예) Apple, Samsung 등 자유롭게"
+                            label="Enter your keyword",
+                            placeholder="e.g., Apple, Samsung, etc."
                         )
                     with gr.Column():
                         country_selection = gr.Dropdown(
                             choices=list(COUNTRY_LOCATIONS.keys()),
                             value="United States",
-                            label="국가 선택"
+                            label="Select Country"
                         )
                     with gr.Column():
-                        custom_search_btn = gr.Button("실행", variant="primary")
+                        custom_search_btn = gr.Button("Search", variant="primary")
 
                 custom_search_output = gr.Markdown()
                 
@@ -914,9 +923,9 @@ with gr.Blocks(theme="Yntec/HaleyCH_Theme_Orange", css=css, title="NewsAI 서비
                     outputs=custom_search_output
                 )
 
-            # 전체 분석 보고 요약 버튼
+            # Button to generate a full report
             with gr.Row():
-                full_report_btn = gr.Button("전체 분석 보고 요약", variant="primary")
+                full_report_btn = gr.Button("Generate Full Analysis Summary Report", variant="primary")
                 full_report_display = gr.Markdown()
             
             full_report_btn.click(
@@ -924,18 +933,18 @@ with gr.Blocks(theme="Yntec/HaleyCH_Theme_Orange", css=css, title="NewsAI 서비
                 outputs=full_report_display
             )
             
-            # 지정된 리스트 (KOREAN_COMPANIES) 개별 기업 검색/출력
+            # Individual search/load for companies in KOREAN_COMPANIES
             with gr.Column():
                 for i in range(0, len(KOREAN_COMPANIES), 2):
                     with gr.Row():
-                        # 왼쪽 열
+                        # Left column
                         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")
+                                    search_btn = gr.Button("Search", variant="primary")
+                                    load_btn = gr.Button("Load from DB", variant="secondary")
                                 result_display = gr.Markdown()
                                 
                                 search_btn.click(
@@ -947,15 +956,15 @@ with gr.Blocks(theme="Yntec/HaleyCH_Theme_Orange", css=css, title="NewsAI 서비
                                     outputs=result_display
                                 )
                         
-                        # 오른쪽 열
+                        # Right column (if exists)
                         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")
+                                        search_btn = gr.Button("Search", variant="primary")
+                                        load_btn = gr.Button("Load from DB", variant="secondary")
                                     result_display = gr.Markdown()
                                     
                                     search_btn.click(