Update app-backup2.py

app-backup2.py

@@ -9,12 +9,83 @@ from requests.adapters import HTTPAdapter
 from requests.packages.urllib3.util.retry import Retry
 from openai import OpenAI
 from bs4 import BeautifulSoup
-import re  # re 모듈 추가
-import json
-import os
-from datetime import datetime
-import sqlite3
+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):
+    try:
+        # 입력된 시간을 naive datetime 객체로 변환
+        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):
+    try:
+        # 모든 기사의 제목과 내용을 하나의 텍스트로 결합
+        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():
@@ -30,16 +101,27 @@ def init_db():
     conn.commit()
     conn.close()
 
-# 검색 결과 저장 함수
+
 def save_to_db(keyword, country, results):
     conn = sqlite3.connect("search_results.db")
     c = conn.cursor()
-    c.execute("INSERT INTO searches (keyword, country, results) VALUES (?, ?, ?)",
-              (keyword, country, json.dumps(results)))
+    
+    # 현재 시간을 서울 시간으로 가져오기
+    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()
 
-# DB에서 검색 결과 불러오기 함수
+
 def load_from_db(keyword, country):
     conn = sqlite3.connect("search_results.db")
     c = conn.cursor()
@@ -48,25 +130,10 @@ def load_from_db(keyword, country):
     result = c.fetchone()
     conn.close()
     if result:
-        return json.loads(result[0]), result[1]
+        return json.loads(result[0]), convert_to_seoul_time(result[1])
     return None, None
 
-# 삼성/미국 검색 함수
-def search_samsung_us():
-    error_message, articles = serphouse_search("samsung", "United States")
-    if not error_message and articles:
-        save_to_db("samsung", "United States", articles)
-        return display_results(articles)
-    return "검색 결과가 없습니다."
 
-# DB에서 삼성/미국 결과 불러오기 함수
-def load_samsung_us():
-    results, timestamp = load_from_db("samsung", "United States")
-    if results:
-        return f"저장 시간: {timestamp}\n\n" + display_results(results)
-    return "저장된 결과가 없습니다."
-
-# 결과 표시 함수
 def display_results(articles):
     output = ""
     for idx, article in enumerate(articles, 1):
@@ -77,7 +144,109 @@ def display_results(articles):
         output += f"요약: {article['snippet']}\n\n"
     return output
 
+
+def search_company(company):
+    error_message, articles = serphouse_search(company, "United States")
+    if not error_message and articles:
+        save_to_db(company, "United States", articles)
+        return display_results(articles)
+    return f"{company}에 대한 검색 결과가 없습니다."
+
+
+def load_company(company):
+    results, timestamp = load_from_db(company, "United States")
+    if results:
+        return f"### {company} 검색 결과\n저장 시간: {timestamp}\n\n" + display_results(results)
+    return f"{company}에 대한 저장된 결과가 없습니다."
+
+
+def show_stats():
+    conn = sqlite3.connect("search_results.db")
+    c = conn.cursor()
+    
+    output = "## 한국 기업 뉴스 분석 리포트\n\n"
+    
+    for company in KOREAN_COMPANIES:
+        c.execute("""
+            SELECT results, timestamp 
+            FROM searches 
+            WHERE keyword = ? 
+            ORDER BY timestamp DESC 
+            LIMIT 1
+        """, (company,))
+        
+        result = c.fetchone()
+        if result:
+            results_json, timestamp = result
+            articles = json.loads(results_json)
+            seoul_time = convert_to_seoul_time(timestamp)
+            
+            output += f"### {company}\n"
+            output += f"- 마지막 업데이트: {seoul_time}\n"
+            output += f"- 저장된 기사 수: {len(articles)}건\n\n"
+            
+            if articles:
+                # 전체 기사에 대한 감성 분석
+                sentiment_analysis = analyze_sentiment_batch(articles, client)
+                output += "#### 뉴스 감성 분석\n"
+                output += f"{sentiment_analysis}\n\n"
+            
+            output += "---\n\n"
+    
+    conn.close()
+    return output
+
+
+def search_all_companies():
+    """
+    등록된 모든 기업에 대해 순차적으로 검색 수행 후 결과를 합쳐서 반환
+    """
+    overall_result = "# [전체 검색 결과]\n\n"
+    for comp in KOREAN_COMPANIES:
+        overall_result += f"## {comp}\n"
+        overall_result += search_company(comp)
+        overall_result += "\n"
+    return overall_result
+
+def load_all_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) 전체 검색 -> 2) 전체 출력 -> 3) 전체 통계(감성 분석)
+    순으로 실행하고 그 결과를 한 번에 리턴
+    """
+    # 1) 전체 검색
+    search_result_text = search_all_companies()
+    
+    # 2) 전체 출력
+    load_result_text = load_all_companies()
+    
+    # 3) 전체 통계
+    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
+
+
 ACCESS_TOKEN = os.getenv("HF_TOKEN")
 if not ACCESS_TOKEN:
     raise ValueError("HF_TOKEN environment variable is not set")
@@ -87,31 +256,10 @@ client = OpenAI(
     api_key=ACCESS_TOKEN,
 )
 
-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")
 
-# 국가별 언어 코드 매핑
+
+# 국가별 언어 코드 매핑 (첫 번째 탭에서는 'United States'만 주로 사용)
 COUNTRY_LANGUAGES = {
     "United States": "en",
     "KOREA": "ko",
@@ -244,193 +392,16 @@ COUNTRY_LOCATIONS = {
     "Slovakia": "Slovakia",
     "Bulgaria": "Bulgaria",
     "Serbia": "Serbia",
-    "Estonia": "Estonia",
-    "Latvia": "Latvia",
-    "Lithuania": "Lithuania",
-    "Slovenia": "Slovenia",
-    "Luxembourg": "Luxembourg",
-    "Malta": "Malta",
-    "Cyprus": "Cyprus",
-    "Iceland": "Iceland"
-}
-
-# 지역 정의
-# 동아시아 지역
-COUNTRY_LANGUAGES_EAST_ASIA = {
-    "KOREA": "ko",    
-    "Taiwan": "zh-TW",  
-    "Japan": "ja",
-    "China": "zh",
-    "Hong Kong": "zh-HK"
-}
-
-COUNTRY_LOCATIONS_EAST_ASIA = {
-    "KOREA": "KOREA",    
-    "Taiwan": "Taiwan",  
-    "Japan": "Japan",
-    "China": "China",
-    "Hong Kong": "Hong Kong"
-}
-
-# 동남아시아/오세아니아 지역
-COUNTRY_LANGUAGES_SOUTHEAST_ASIA_OCEANIA = {
-    "Indonesia": "id",
-    "Malaysia": "ms",
-    "Philippines": "tl",
-    "Thailand": "th",
-    "Vietnam": "vi",
-    "Singapore": "en",
-    "Papua New Guinea": "en",
-    "Australia": "en",
-    "New Zealand": "en"
-}
-
-COUNTRY_LOCATIONS_SOUTHEAST_ASIA_OCEANIA = {
-    "Indonesia": "Indonesia",
-    "Malaysia": "Malaysia",
-    "Philippines": "Philippines",
-    "Thailand": "Thailand",
-    "Vietnam": "Vietnam",
-    "Singapore": "Singapore",
-    "Papua New Guinea": "Papua New Guinea",
-    "Australia": "Australia",
-    "New Zealand": "New Zealand"
-}
-
-# 동유럽 지역
-COUNTRY_LANGUAGES_EAST_EUROPE = {
-    "Poland": "pl",
-    "Czech Republic": "cs",
-    "Greece": "el",
-    "Hungary": "hu",
-    "Romania": "ro",
-    "Ukraine": "uk",
-    "Croatia": "hr",
-    "Slovakia": "sk",
-    "Bulgaria": "bg",
-    "Serbia": "sr",
     "Estonia": "et",
     "Latvia": "lv",
     "Lithuania": "lt",
     "Slovenia": "sl",
-    "Malta": "mt",
-    "Cyprus": "el",
-    "Iceland": "is",
-    "Russia": "ru"
-}
-
-COUNTRY_LOCATIONS_EAST_EUROPE = {
-    "Poland": "Poland",
-    "Czech Republic": "Czech Republic",
-    "Greece": "Greece",
-    "Hungary": "Hungary",
-    "Romania": "Romania",
-    "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",
-    "Russia": "Russia"
-}
-
-# 서유럽 지역
-COUNTRY_LANGUAGES_WEST_EUROPE = {
-    "Germany": "de",
-    "France": "fr",
-    "Italy": "it",
-    "Spain": "es",
-    "Netherlands": "nl",
-    "Belgium": "nl",
-    "Ireland": "en",
-    "Sweden": "sv",
-    "Switzerland": "de",
-    "Austria": "de",
-    "Portugal": "pt",
-    "Luxembourg": "fr",
-    "United Kingdom": "en"
-}
-
-COUNTRY_LOCATIONS_WEST_EUROPE = {
-    "Germany": "Germany",
-    "France": "France",
-    "Italy": "Italy",
-    "Spain": "Spain",
-    "Netherlands": "Netherlands",
-    "Belgium": "Belgium",
-    "Ireland": "Ireland",
-    "Sweden": "Sweden",
-    "Switzerland": "Switzerland",
-    "Austria": "Austria",
-    "Portugal": "Portugal",
-    "Luxembourg": "Luxembourg",
-    "United Kingdom": "United Kingdom"
-}
-
-# 중동/아프리카 지역
-COUNTRY_LANGUAGES_ARAB_AFRICA = {
-    "South Africa": "en",
-    "Nigeria": "en",
-    "Kenya": "sw",
-    "Egypt": "ar",
-    "Morocco": "ar",
-    "Saudi Arabia": "ar",
-    "United Arab Emirates": "ar",
-    "Israel": "he"
-}
-
-COUNTRY_LOCATIONS_ARAB_AFRICA = {
-    "South Africa": "South Africa",
-    "Nigeria": "Nigeria",
-    "Kenya": "Kenya",
-    "Egypt": "Egypt",
-    "Morocco": "Morocco",
-    "Saudi Arabia": "Saudi Arabia",
-    "United Arab Emirates": "United Arab Emirates",
-    "Israel": "Israel"
-}
-
-# 아메리카 지역
-COUNTRY_LANGUAGES_AMERICA = {
-    "United States": "en",
-    "Canada": "en",
-    "Mexico": "es",
-    "Brazil": "pt",
-    "Argentina": "es",
-    "Chile": "es",
-    "Colombia": "es",
-    "Peru": "es",
-    "Venezuela": "es"
-}
-
-COUNTRY_LOCATIONS_AMERICA = {
-    "United States": "United States",
-    "Canada": "Canada",
-    "Mexico": "Mexico",
-    "Brazil": "Brazil",
-    "Argentina": "Argentina",
-    "Chile": "Chile",
-    "Colombia": "Colombia",
-    "Peru": "Peru",
-    "Venezuela": "Venezuela"
+    "Iceland": "Iceland"
 }
 
-# 지역 선택 리스트
-REGIONS = [
-    "동아시아",
-    "동남아시아/오세아니아",
-    "동유럽",
-    "서유럽",
-    "중동/아프리카",
-    "아메리카"
-]
-
 
 @lru_cache(maxsize=100)
 def translate_query(query, country):
@@ -468,35 +439,10 @@ def translate_query(query, country):
         return query
 
 
-@lru_cache(maxsize=200)
-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
-        }
-        
-        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
-    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"
     
@@ -528,28 +474,24 @@ def search_serphouse(query, country, page=1, num_result=10):
     }
 
     try:
-        # 세션 설정 개선
         session = requests.Session()
         
-        # 재시도 설정 강화
         retries = Retry(
-            total=5,  # 최대 재시도 횟수 증가
-            backoff_factor=1,  # 재시도 간격 증가
-            status_forcelist=[500, 502, 503, 504, 429],  # 재시도할 HTTP 상태 코드
-            allowed_methods=["POST"]  # POST 요청에 대한 재시도 허용
+            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)
         
-        # 타임아웃 값 증가 (connect timeout, read timeout)
         response = session.post(
             url, 
             json=payload, 
             headers=headers, 
-            timeout=(30, 30)  # 연결 타임아웃 30초, 읽기 타임아웃 30초
+            timeout=(30, 30)
         )
         
         response.raise_for_status()
@@ -571,6 +513,7 @@ def search_serphouse(query, country, page=1, num_result=10):
             "translated_query": query
         }
 
+
 def format_results_from_raw(response_data):
     if "error" in response_data:
         return "Error: " + response_data["error"], []
@@ -584,10 +527,14 @@ def format_results_from_raw(response_data):
             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']
+        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):
@@ -596,8 +543,10 @@ def format_results_from_raw(response_data):
             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.lower() for keyword in korean_keywords)
+            is_korean_content = (
+                any(domain in url or domain in channel for domain in korean_domains) or
+                any(keyword in title.lower() for keyword in korean_keywords)
+            )
             
             if not is_korean_content:
                 filtered_articles.append({
@@ -615,180 +564,12 @@ def format_results_from_raw(response_data):
     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)
 
 
-def search_and_display(query, country, articles_state, progress=gr.Progress()):
-    with ThreadPoolExecutor(max_workers=3) as executor:
-        progress(0, desc="검색어 번역 중...")
-        future_translation = executor.submit(translate_query, query, country)
-        translated_query = future_translation.result()
-        translated_display = f"**원본 검색어:** {query}\n**번역된 검색어:** {translated_query}" if translated_query != query else f"**검색어:** {query}"
-        
-        progress(0.3, desc="검색 중...")
-        response_data = search_serphouse(query, country)
-        
-        progress(0.6, desc="결과 처리 중...")
-        error_message, articles = format_results_from_raw(response_data)
-        
-        outputs = []
-        outputs.append(gr.update(value="검색을 진행중입니다...", 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))
-            if not error_message and articles:
-                futures = []
-                for article in articles:
-                    future = executor.submit(translate_to_korean, article['snippet'])
-                    futures.append((article, future))
-                
-                progress(0.8, desc="번역 처리 중...")
-                for article, future in futures:
-                    article['korean_summary'] = future.result()
-                
-                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)
-                        
-                        outputs.extend([
-                            gr.update(visible=True),
-                            gr.update(value=f"### [{article['title']}]({article['link']})"),
-                            image_update,
-                            gr.update(value=f"**요약:** {article['snippet']}\n\n**한글 요약:** {article['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 get_region_countries(region):
-    """선택된 지역의 국가 및 언어 정보 반환"""
-    if region == "동아시아":
-        return COUNTRY_LOCATIONS_EAST_ASIA, COUNTRY_LANGUAGES_EAST_ASIA
-    elif region == "동남아시아/오세아니아":
-        return COUNTRY_LOCATIONS_SOUTHEAST_ASIA_OCEANIA, COUNTRY_LANGUAGES_SOUTHEAST_ASIA_OCEANIA
-    elif region == "동유럽":
-        return COUNTRY_LOCATIONS_EAST_EUROPE, COUNTRY_LANGUAGES_EAST_EUROPE
-    elif region == "서유럽":
-        return COUNTRY_LOCATIONS_WEST_EUROPE, COUNTRY_LANGUAGES_WEST_EUROPE
-    elif region == "중동/아프리카":
-        return COUNTRY_LOCATIONS_ARAB_AFRICA, COUNTRY_LANGUAGES_ARAB_AFRICA
-    elif region == "아메리카":
-        return COUNTRY_LOCATIONS_AMERICA, COUNTRY_LANGUAGES_AMERICA
-    return {}, {}
-
-def search_global(query, region, articles_state_global):
-    """지역별 검색 함수"""
-    status_msg = f"{region} 지역 검색을 시작합니다..."
-    all_results = []
-
-    outputs = [
-        gr.update(value=status_msg, visible=True),
-        gr.update(value=f"**검색어:** {query}", visible=True),
-    ]
-    
-    for _ in global_article_components:
-        outputs.extend([
-            gr.update(visible=False), gr.update(), gr.update(),
-            gr.update(), gr.update()
-        ])
-    outputs.append([])
-        
-    yield outputs
-    
-    # 선택된 지역의 국가 정보 가져오기
-    locations, languages = get_region_countries(region)
-    total_countries = len(locations)
-
-    for idx, (country, location) in enumerate(locations.items(), 1):
-        try:
-            status_msg = f"{region} - {country} 검색 중... ({idx}/{total_countries} 국가)"
-            outputs[0] = gr.update(value=status_msg, visible=True)
-            yield outputs
-            
-            error_message, articles = serphouse_search(query, country)
-            if not error_message and articles:
-                for article in articles:
-                    article['source_country'] = country
-                    article['region'] = region
-                
-                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)
-            
-                unique_results = unique_results[:MAX_GLOBAL_RESULTS]
-            
-                outputs = [
-                    gr.update(value=f"{region} - {idx}/{total_countries} 국가 검색 완료\n현재까지 발견된 뉴스: {len(unique_results)}건", visible=True),
-                    gr.update(value=f"**검색어:** {query} | **지역:** {region}", 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['region']} | **시간:** {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"{region} 검색 완료! 총 {len(unique_results)}개의 뉴스가 발견되었습니다."
-    outputs[0] = gr.update(value=final_status, visible=True)
-    yield outputs
-
 css = """
 /* 전역 스타일 */
 footer {visibility: hidden;}
@@ -867,7 +648,7 @@ footer {visibility: hidden;}
     z-index: 1000;
 }
 
-/* 프로그레스바 */
+/* 프로그레스bar */
 .progress-bar {
     height: 100%;
     background: linear-gradient(90deg, #2196F3, #00BCD4);
@@ -965,454 +746,73 @@ footer {visibility: hidden;}
 """
 
 
-def get_article_content(url):
-    try:
-        headers = {
-            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36'
-        }
-        session = requests.Session()
-        retries = Retry(total=3, backoff_factor=0.5)
-        session.mount('https://', HTTPAdapter(max_retries=retries))
-        
-        response = session.get(url, headers=headers, timeout=30)
-        response.raise_for_status()
-        soup = BeautifulSoup(response.content, 'html.parser')
-        
-        # 메타 데이터 추출
-        title = soup.find('meta', property='og:title') or soup.find('title')
-        title = title.get('content', '') if hasattr(title, 'get') else title.string if title else ''
-        
-        description = soup.find('meta', property='og:description') or soup.find('meta', {'name': 'description'})
-        description = description.get('content', '') if description else ''
-        
-        # 본문 추출 개선
-        article_content = ''
-        
-        # 일반적인 기사 본문 컨테이너 검색
-        content_selectors = [
-            'article', '.article-body', '.article-content', '#article-body',
-            '.story-body', '.post-content', '.entry-content', '.content-body',
-            '[itemprop="articleBody"]', '.story-content'
-        ]
-        
-        for selector in content_selectors:
-            content = soup.select_one(selector)
-            if content:
-                # 불필요한 요소 제거
-                for tag in content.find_all(['script', 'style', 'nav', 'header', 'footer', 'aside']):
-                    tag.decompose()
-                
-                # 단락 추출
-                paragraphs = content.find_all(['p', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6'])
-                if paragraphs:
-                    article_content = '\n\n'.join([p.get_text().strip() for p in paragraphs if p.get_text().strip()])
-                    break
-        
-        # 백업 방법: 모든 단락 추출
-        if not article_content:
-            paragraphs = soup.find_all('p')
-            article_content = '\n\n'.join([p.get_text().strip() for p in paragraphs if len(p.get_text().strip()) > 50])
-        
-        # 최종 콘텐츠 구성
-        full_content = f"Title: {title}\n\nDescription: {description}\n\nContent:\n{article_content}"
-        
-        # 텍스트 정제
-        full_content = re.sub(r'\s+', ' ', full_content)  # 연속된 공백 제거
-        full_content = re.sub(r'\n\s*\n', '\n\n', full_content)  # 연속된 빈 줄 제거
-        
-        return full_content.strip()
-        
-    except Exception as e:
-        print(f"Crawling error details: {str(e)}")  # 디버깅을 위한 상세 에러 출력
-        return f"Error crawling content: {str(e)}"
-
-def respond(url, history, system_message, max_tokens, temperature, top_p):
-    if not url.startswith('http'):
-        history.append((url, "올바른 URL을 입력해주세요."))
-        return history
-
-    try:
-        article_content = get_article_content(url)
-        
-        translation_prompt = f"""다음 영문 기사를 한국어로 번역하고 기사를 작성해주세요.
-
-1단계: 전문 번역
-===번역 시작===
-{article_content}
-===번역 끝===
-
-2단계: 기사 작성 가이드라인
-다음 요구사항에 따라 한국어 기사를 작성하세요:
-
-1. 구조
-- 헤드라인: 핵심 내용을 담은 강력한 제목
-- 부제목: 헤드라인 보완 설명
-- 리드문: 기사의 핵심을 요약한 첫 문단
-- 본문: 상세 내용 전개
-
-2. ���성 규칙
-- 객관적이고 정확한 사실 전달
-- 문장은 '다.'로 종결
-- 단락 간 자연스러운 흐름
-- 인용구는 따옴표 처리
-- 핵심 정보를 앞부분에 배치
-- 전문 용어는 적절한 설명 추가
-
-3. 형식
-- 적절한 단락 구분
-- 읽기 쉬운 문장 길이
-- 논리적인 정보 구성
-
-각 단계는 '===번역===', '===기사==='로 명확히 구분하여 출력하세요.
-"""
-
-        messages = [
-            {
-                "role": "system",
-                "content": system_message
-            },
-            {"role": "user", "content": translation_prompt}
-        ]
-
-        history.append((url, "번역 및 기사 작성을 시작합니다..."))
-        
-        full_response = ""
-        for message in client.chat.completions.create(
-            model="CohereForAI/c4ai-command-r-plus-08-2024",
-            max_tokens=max_tokens,
-            stream=True,
-            temperature=temperature,
-            top_p=top_p,
-            messages=messages,
-        ):
-            if hasattr(message.choices[0].delta, 'content'):
-                token = message.choices[0].delta.content
-                if token:
-                    full_response += token
-                    history[-1] = (url, full_response)
-                    yield history
-
-    except Exception as e:
-        error_message = f"처리 중 오류가 발생했습니다: {str(e)}"
-        history.append((url, error_message))
-        yield history
-
-    return history
-
-
-def continue_writing(history, system_message, max_tokens, temperature, top_p):
-    if not history:
-        return history
-    
-    last_response = history[-1][1] if history else ""
-    continue_prompt = f"""이전 내용을 이어서 계속 작성해주세요. 
-    마지막 응답: {last_response}
-    
-    추가 지침:
-    1. 이전 내용의 맥락을 유지하며 자연스럽게 이어서 작성
-    2. 새로운 정보나 상세 설명을 추가
-    3. 필요한 경우 보충 설명이나 분석 제공
-    4. 기사 형식과 스타일 유지
-    5. 필요한 경우 추가적인 이미지 프롬프트 생성
-    """
-
-    # 메시지 구조 수정
-    messages = [
-        {"role": "system", "content": system_message},
-        {"role": "user", "content": continue_prompt}  # 사용자 메시지로 시작
-    ]
-
-    try:
-        full_response = ""
-        for message in client.chat.completions.create(
-            model="CohereForAI/c4ai-command-r-plus-08-2024",
-            max_tokens=max_tokens,
-            stream=True,
-            temperature=temperature,
-            top_p=top_p,
-            messages=messages,
-        ):
-            if hasattr(message.choices[0].delta, 'content'):
-                token = message.choices[0].delta.content
-                if token:
-                    full_response += token
-                    # 이전 대화 기록을 유지하면서 새로운 응답 추가
-                    new_history = history.copy()
-                    new_history.append(("계속 작성", full_response))
-                    yield new_history
-
-    except Exception as e:
-        error_message = f"계속 작성 중 오류가 발생했습니다: {str(e)}"
-        new_history = history.copy()
-        new_history.append(("오류", error_message))
-        yield new_history
-
-    return history
-
 with gr.Blocks(theme="Yntec/HaleyCH_Theme_Orange", css=css, title="NewsAI 서비스") as iface:
-    init_db()  # DB 초기화
+    init_db()
     
     with gr.Tabs():
-        # DB 저장/불러오기 탭
+        # 첫 번째 탭 (DB 검색)
         with gr.Tab("DB 검색"):
-            gr.Markdown("삼성/미국 검색 결과를 DB에 저장하고 불러옵니다.")
+            gr.Markdown("## 한국 주요 기업 미국 뉴스 DB")
+            gr.Markdown("각 기업의 미국 뉴스를 검색하여 DB에 저장하고 불러올 수 있습니다.")
             
+            # (수정) 상단에 '전체 분석 보고 요약' 버튼을 배치
             with gr.Row():
-                search_button = gr.Button("검색: samsung/미국", variant="primary")
-                load_button = gr.Button("출력: samsung/미국", variant="secondary")
-            
-            results_display = gr.Markdown()
+                full_report_btn = gr.Button("전체 분석 보고 요약", variant="primary")
+                full_report_display = gr.Markdown()
             
-            # 버튼 이벤트 연결
-            search_button.click(
-                fn=search_samsung_us,
-                outputs=results_display
+            # 버튼 클릭 시 full_summary_report() 실행
+            full_report_btn.click(
+                fn=full_summary_report,
+                outputs=full_report_display
             )
             
-            load_button.click(
-                fn=load_samsung_us,
-                outputs=results_display
-            )
-
-        with gr.Tab("국가별"):
-            gr.Markdown("검색어를 입력하고 원하는 국가(한국 제외)를를 선택하면, 검색어와 일치하는 24시간 이내 뉴스를 최대 100개 출력합니다.")
-            gr.Markdown("국가 선택후 검색어에 '한글'을 입력하면 현지 언어로 번역되어 검색합니다. 예: 'Taiwan' 국가 선택후 '삼성' 입력시 '三星'으로 자동 검색")
-            
-            with gr.Column():
-                with gr.Row():
-                    query = gr.Textbox(label="검색어")
-                    country = gr.Dropdown(
-                        choices=sorted(list(COUNTRY_LOCATIONS.keys())),
-                        label="국가",
-                        value="United States"
-                    )
-                
-                # Examples 추가
-                gr.Examples(
-                    examples=[
-                        "artificial intelligence",
-                        "NVIDIA",
-                        "OPENAI",
-                        "META LLAMA",
-                        "black forest labs",
-                        "GOOGLE gemini",
-                        "anthropic Claude",
-                        "X.AI",
-                        "HUGGINGFACE",
-                        "HYNIX",
-                        "Large Language model",
-                        "CHATGPT",
-                        "StabilityAI",
-                        "MISTRALAI",
-                        "QWEN",                        
-                        "MIDJOURNEY",
-                        "GPU"
-                    ],
-                    inputs=query,
-                    label="자주 사용되는 검색어"
-                )
-                
-                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("대륙별로 24시간 이내 뉴스를 검색합니다.")
-            
+            # 이후 개별 기업 검색/출력 UI
             with gr.Column():
-                with gr.Column(elem_id="status_area"):
+                for i in range(0, len(KOREAN_COMPANIES), 2):
                     with gr.Row():
-                        query_global = gr.Textbox(label="검색어")
-                        region_select = gr.Dropdown(
-                            choices=REGIONS,
-                            label="지역 선택",
-                            value="동아시아"
-                        )
-                        search_button_global = gr.Button("검색", variant="primary")
-                    
-                    status_message_global = gr.Markdown("")
-                    translated_query_display_global = gr.Markdown("")
-                
-                with gr.Column(elem_id="results_area"):
-                    articles_state_global = gr.State([])
-                    global_article_components = []
-                    for i in range(MAX_GLOBAL_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()
-                            
-                            global_article_components.append({
-                                'group': article_group,
-                                'title': title,
-                                'image': image,
-                                'snippet': snippet,
-                                'info': info,
-                                'index': i,
-                            })
-
-        # AI 번역 탭
-        with gr.Tab("AI 기사 생성"):
-            gr.Markdown("뉴스 URL을 입력하면 AI가 한국어로 번역하여 기사 형식으로 작성합니다.")
-            gr.Markdown("이미지 생성: https://huggingface.co/spaces/ginipick/FLUXllama ")
-            
-            with gr.Column():
-                chatbot = gr.Chatbot(height=600)
-            
-                with gr.Row():
-                    url_input = gr.Textbox(
-                        label="뉴스 URL",
-                        placeholder="https://..."
-                    )
-
-                with gr.Row():
-                    translate_button = gr.Button("기사 생성", variant="primary")
-                    continue_button = gr.Button("계속 이어서 작성", variant="secondary")
-
-                with gr.Accordion("고급 설정", open=False):
-                    system_message = gr.Textbox(
-                        value="""You are a professional translator and journalist. Follow these steps strictly:
-                         1. TRANSLATION
-                         - Start with ===번역=== marker
-                         - Provide accurate Korean translation
-                         - Maintain original meaning and context
-                         2. ARTICLE WRITING
-                         - Start with ===기사=== marker
-                         - Write a new Korean news article based on the translation
-                         - Follow newspaper article format
-                         - Use formal news writing style
-                         - End sentences with '다.'
-                         - Include headline and subheadline
-                         - Organize paragraphs clearly
-                         - Put key information first
-                         - Use quotes appropriately
-                         
-                         3. IMAGE PROMPT GENERATION
-                         - Start with ===이미지 프롬프트=== marker
-                         - Create detailed Korean prompts for image generation
-                         - Prompts should reflect the article's main theme and content
-                         - Include key visual elements mentioned in the article
-                         - Specify style, mood, and composition
-                         - Format: "이미지 설명: [상세 설명]"
-                         - Add style keywords: "스타일: [관련 키워드들]"
-                         - Add mood keywords: "분위기: [관련 키워드들]"
-                         IMPORTANT:
-                         - Must complete all three steps in order
-                         - Clearly separate each section with markers
-                         - Never skip or combine steps
-                         - Ensure image prompts align with article content""",
-                        label="System message"
-                    )
-                    
-                    max_tokens = gr.Slider(
-                        minimum=1,
-                        maximum=7800,
-                        value=7624,
-                        step=1,
-                        label="Max new tokens"
-                    )
-                    temperature = gr.Slider(
-                        minimum=0.1,
-                        maximum=4.0,
-                        value=0.7,
-                        step=0.1,
-                        label="Temperature"
-                    )
-                    top_p = gr.Slider(
-                        minimum=0.1,
-                        maximum=1.0,
-                        value=0.95,
-                        step=0.05,
-                        label="Top-P"
-                    )
-
-    # 이벤트 연결 부분
-    # 국가별 탭 이벤트
-    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(
-        fn=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(
-        fn=search_global,
-        inputs=[query_global, region_select, articles_state_global],
-        outputs=global_search_outputs,
-        show_progress=True
-    )
-
-    # AI 번역 탭 이벤트
-    translate_button.click(
-        fn=respond,
-        inputs=[
-            url_input,
-            chatbot,
-            system_message,
-            max_tokens,
-            temperature,
-            top_p,
-        ],
-        outputs=chatbot
-    )
-
-    # 계속 작성 버튼 이벤트
-    continue_button.click(
-        fn=continue_writing,
-        inputs=[
-            chatbot,
-            system_message,
-            max_tokens,
-            temperature,
-            top_p,
-        ],
-        outputs=chatbot
-    )
+                        # 왼쪽 열
+                        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),
+                                    outputs=result_display
+                                )
+                                load_btn.click(
+                                    fn=lambda c=company: load_company(c),
+                                    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),
+                                        outputs=result_display
+                                    )
+                                    load_btn.click(
+                                        fn=lambda c=company: load_company(c),
+                                        outputs=result_display
+                                    )
 
 iface.launch(
     server_name="0.0.0.0",
     server_port=7860,
     share=True,
-    auth=("gini","pick"),
     ssl_verify=False,
     show_error=True
-)         
+)