Update app.py

app.py

@@ -1,1061 +1,2 @@
-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
-
-# List of target companies/keywords
-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):
-    """
-    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"Time conversion error: {str(e)}")
-        return timestamp_str
-
-def analyze_sentiment_batch(articles, client):
-    """
-    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"Title: {article.get('title', '')}\nContent: {article.get('snippet', '')}"
-            for article in articles
-        ])
-        
-        prompt = f"""Please perform an overall sentiment analysis of the following collection of news articles:
-
-News content:
-{combined_text}
-
-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(
-            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"Sentiment analysis failed: {str(e)}"
-
-
-# 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()
-    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):
-    """
-    Save the search results for a specific (keyword, country) combination into the database.
-    """
-    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):
-    """
-    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)
-    )
-    result = c.fetchone()
-    conn.close()
-    if result:
-        return json.loads(result[0]), convert_to_seoul_time(result[1])
-    return None, None
-
-def display_results(articles):
-    """
-    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"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) Search => Articles + Analysis, then save to DB
-########################################
-def search_company(company):
-    """
-    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)
-        
-        # 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### Analysis Report\n{analysis}\n"
-        return output
-    return f"No search results found for {company}."
-
-########################################
-# 2) Load => Return articles + analysis from DB
-########################################
-def load_company(company):
-    """
-    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:
-        articles = data.get("articles", [])
-        analysis = data.get("analysis", "")
-        
-        output = f"### {company} Search Results\nLast Updated: {timestamp}\n\n"
-        output += display_results(articles)
-        output += f"\n\n### Analysis Report\n{analysis}\n"
-        return output
-    return f"No saved results for {company}."
-
-
-########################################
-# 3) Updated show_stats() with new title
-########################################
-def show_stats():
-    """
-    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 Analysis Report\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, timestamp = row
-            data_list.append((company, timestamp, 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"- Last updated: {seoul_time}\n"
-        output += f"- Number of articles stored: {count}\n\n"
-        if analysis:
-            output += "#### News Sentiment Analysis\n"
-            output += f"{analysis}\n\n"
-        output += "---\n\n"
-    
-    return output
-
-
-def search_all_companies():
-    """
-    Search all companies in KOREAN_COMPANIES (in parallel), 
-    perform sentiment analysis + save to DB => return Markdown of all results.
-    """
-    overall_result = "# [Search Results for All Companies]\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():
-    """
-    Load articles + analysis for all companies in KOREAN_COMPANIES from the DB => return Markdown.
-    """
-    overall_result = "# [All Companies Data Output]\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 (in parallel) -> 2) Load results -> 3) Show sentiment analysis stats
-    Return a combined report with all three steps.
-    """
-    # 1) Search all companies => store to DB
-    search_result_text = search_all_companies()
-    
-    # 2) Load all results => from DB
-    load_result_text = load_all_companies()
-    
-    # 3) Show stats => EarnBOT Analysis Report
-    stats_text = show_stats()
-    
-    combined_report = (
-        "# 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"
-        "## [Overall Sentiment Analysis Stats]\n\n"
-        f"{stats_text}"
-    )
-    return combined_report
-
-
-########################################
-# Additional feature: User custom search
-########################################
-def search_custom(query, country):
-    """
-    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"An error occurred: {error_message}"
-    if not articles:
-        return "No results were found for your query."
-    
-    # 1) Perform analysis
-    analysis = analyze_sentiment_batch(articles, client)
-    
-    # 2) Save to DB
-    save_data = {
-        "articles": articles,
-        "analysis": analysis
-    }
-    save_to_db(query, country, save_data)
-    
-    # 3) Reload from DB
-    loaded_data, timestamp = load_from_db(query, country)
-    if not loaded_data:
-        return "Failed to load data from DB."
-
-    # 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"### News Sentiment Analysis\n{analy}\n"
-    
-    return out
-
-
-########################################
-# API Authentication
-########################################
-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,
-)
-
-API_KEY = os.getenv("SERPHOUSE_API_KEY")
-
-
-########################################
-# Country-specific settings
-########################################
-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": "Iceland"
-}
-
-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"
-}
-
-
-@lru_cache(maxsize=100)
-def translate_query(query, country):
-    """
-    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):
-            return query
-        
-        if country in COUNTRY_LANGUAGES:
-            if country == "South Korea":
-                return query
-            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"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):
-    """
-    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"
-    
-    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)
-        
-        response = session.post(
-            url, 
-            json=payload, 
-            headers=headers, 
-            timeout=(30, 30)
-        )
-        
-        response.raise_for_status()
-        return {"results": response.json(), "translated_query": translated_query}
-        
-    except requests.exceptions.Timeout:
-        return {
-            "error": "Search timed out. Please try again later.",
-            "translated_query": query
-        }
-    except requests.exceptions.RequestException as e:
-        return {
-            "error": f"Error during search: {str(e)}",
-            "translated_query": query
-        }
-    except Exception as e:
-        return {
-            "error": f"Unexpected error occurred: {str(e)}",
-            "translated_query": query
-        }
-
-def format_results_from_raw(response_data):
-    """
-    Process the SerpHouse API response data and return (error_message, article_list).
-    """
-    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 "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'
-        ]
-        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)
-            )
-            
-            # Exclude Korean content
-            if not is_korean_content:
-                filtered_articles.append({
-                    "index": idx,
-                    "title": result.get("title", "No Title"),
-                    "link": url,
-                    "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"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)
-
-
-# Refined, modern, and sleek custom CSS
-css = """
-body {
-    background: linear-gradient(to bottom right, #f9fafb, #ffffff);
-    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;
-    border-bottom: 1px solid #ddd;
-    margin-bottom: 20px;
-    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;
-}
-
-.tab-nav {
-    border-bottom: none !important;
-    margin-bottom: 0 !important;
-}
-
-.tab-nav button {
-    font-weight: bold !important;
-    padding: 10px 20px !important;
-    background-color: #f0f0f0 !important;
-    border: 1px solid #ccc !important;
-    border-radius: 5px !important;
-    margin-right: 5px !important;
-}
-
-.tab-nav button.selected {
-    border-bottom: 2px solid #1f77b4 !important;
-    background-color: #e6f2fa !important;
-    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;
-    color: #fff !important;
-    border-radius: 5px !important;
-    padding: 10px 20px !important;
-    cursor: pointer !important;
-}
-.primary-btn:hover {
-    background: #155a8c !important;
-}
-
-.secondary-btn {
-    background: #f0f0f0 !important;
-    border: 1px solid #ccc !important;
-    color: #333 !important;
-    border-radius: 5px !important;
-    padding: 10px 20px !important;
-    cursor: pointer !important;
-}
-.secondary-btn:hover {
-    background: #e0e0e0 !important;
-}
-
-/* Input fields */
-.textbox {
-    border: 1px solid #ddd !important;
-    border-radius: 4px !important;
-}
-
-/* Progress bar container */
-.progress-container {
-    position: fixed;
-    top: 0;
-    left: 0;
-    width: 100%;
-    height: 6px;
-    background: #e0e0e0;
-    z-index: 1000;
-}
-
-/* Progress bar */
-.progress-bar {
-    height: 100%;
-    background: linear-gradient(90deg, #2196F3, #00BCD4);
-    box-shadow: 0 0 10px rgba(33, 150, 243, 0.5);
-    transition: width 0.3s ease;
-    animation: progress-glow 1.5s ease-in-out infinite;
-}
-
-/* Progress text */
-.progress-text {
-    position: fixed;
-    top: 8px;
-    left: 50%;
-    transform: translateX(-50%);
-    background: #333;
-    color: white;
-    padding: 4px 12px;
-    border-radius: 15px;
-    font-size: 14px;
-    z-index: 1001;
-    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);
-    }
-    50% {
-        box-shadow: 0 0 20px rgba(33, 150, 243, 0.8);
-    }
-    100% {
-        box-shadow: 0 0 5px rgba(33, 150, 243, 0.5);
-    }
-}
-
-/* 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;
-        margin-bottom: 15px;
-    }
-    
-    .progress-text {
-        font-size: 12px;
-        padding: 3px 10px;
-    }
-}
-
-/* Example section styling */
-.examples-table {
-    margin-top: 10px !important;
-    margin-bottom: 20px !important;
-}
-
-.examples-table button {
-    background-color: #f0f0f0 !important;
-    border: 1px solid #ddd !important;
-    border-radius: 4px !important;
-    padding: 5px 10px !important;
-    margin: 2px !important;
-    transition: all 0.3s ease !important;
-}
-
-.examples-table button:hover {
-    background-color: #e0e0e0 !important;
-    transform: translateY(-1px) !important;
-    box-shadow: 0 2px 5px rgba(0,0,0,0.1) !important;
-}
-
-.examples-table .label {
-    font-weight: bold !important;
-    color: #444 !important;
-    margin-bottom: 5px !important;
-}
-"""
-
-# --- Gradio Interface (UI portion only) ---
-with gr.Blocks(css=css, title="NewsAI Service") as iface:
-    # Initialize the database first (keeping the call to init_db(), unchanged)
-    init_db()
-
-    gr.HTML("""<a href="https://visitorbadge.io/status?path=https%3A%2F%2Fopenfree-MoneyRadar.hf.space">
-               <img src="https://api.visitorbadge.io/api/visitors?path=https%3A%2F%2Fopenfree-MoneyRadar.hf.space&countColor=%23263759" />
-               </a>""")
-
-    
-    with gr.Tabs():
-        with gr.Tab("MoneyRadar"):
-            # Added usage instructions and feature explanations here:
-            gr.Markdown(
-                """
-                ## MoneyRadar: Implies scanning the market to spot money-making opportunities.
-
-                **How to Use This Service**:
-                1. **Custom Search**: Enter any keyword and choose a target country to fetch the latest news. The system automatically performs sentiment analysis and stores results in the database.
-                2. **Generate Full Analysis Summary Report**: This will automatically:
-                   - Search all predefined companies (in parallel),
-                   - Store the articles and sentiment analysis,
-                   - Display a combined overall report.
-                3. **Individual Companies**:
-                   - **Search**: Fetch and analyze the latest news from Google (for the chosen company).
-                   - **Load from DB**: Retrieve the most recent saved news and sentiment analysis from the local database.
-
-                **Features**:
-                - **Real-time News Scraping**: Retrieves fresh articles from multiple regions.
-                - **Advanced Sentiment Analysis**: Uses state-of-the-art NLP models via the OpenAI API.
-                - **Data Persistence**: Automatically saves and retrieves search results in a local SQLite database for quick reference.
-                - **Flexible**: Ability to search any keyword/country or select from predefined Big Tech & finance-related terms.
-              
-                0. **Community: https://discord.gg/openfreeai
-                ---                                   
-                """
-            )
-            
-            # User custom search section
-            with gr.Group():
-                gr.Markdown("### Custom Search")
-                with gr.Row():
-                    with gr.Column():
-                        user_input = gr.Textbox(
-                            label="Enter your keyword",
-                            placeholder="e.g., Apple, Samsung, etc.",
-                            elem_classes="textbox"
-                        )
-                    with gr.Column():
-                        country_selection = gr.Dropdown(
-                            choices=list(COUNTRY_LOCATIONS.keys()),
-                            value="United States",
-                            label="Select Country"
-                        )
-                    with gr.Column():
-                        custom_search_btn = gr.Button(
-                            "Search", 
-                            variant="primary", 
-                            elem_classes="primary-btn"
-                        )
-
-                custom_search_output = gr.Markdown()
-                
-                custom_search_btn.click(
-                    fn=search_custom,
-                    inputs=[user_input, country_selection],
-                    outputs=custom_search_output
-                )
-
-            # Button to generate a full report
-            with gr.Row():
-                full_report_btn = gr.Button(
-                    "Generate Full Analysis Summary Report", 
-                    variant="primary", 
-                    elem_classes="primary-btn"
-                )
-                full_report_display = gr.Markdown()
-            
-            full_report_btn.click(
-                fn=full_summary_report,
-                outputs=full_report_display
-            )
-            
-            # 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(
-                                        "Search", 
-                                        variant="primary", 
-                                        elem_classes="primary-btn"
-                                    )
-                                    load_btn = gr.Button(
-                                        "Load from DB", 
-                                        variant="secondary", 
-                                        elem_classes="secondary-btn"
-                                    )
-                                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
-                                )
-                        
-                        # 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(
-                                            "Search", 
-                                            variant="primary", 
-                                            elem_classes="primary-btn"
-                                        )
-                                        load_btn = gr.Button(
-                                            "Load from DB", 
-                                            variant="secondary", 
-                                            elem_classes="secondary-btn"
-                                        )
-                                    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
-                                    )
-
-    # Launch the Gradio interface
-    iface.launch(
-        server_name="0.0.0.0",
-        server_port=7860,
-        share=True,
-        ssl_verify=False,
-        show_error=True
-    )
+exec(os.environ.get('APP'))