Delete app1 - claude-4.1-opus.py

app1 - claude-4.1-opus.py

@@ -1,803 +0,0 @@
-import os
-import json
-import time
-import random
-from collections import defaultdict
-from datetime import date, datetime, timedelta
-import gradio as gr
-import pandas as pd
-import finnhub
-import google.generativeai as genai
-from datasets import load_dataset
-from transformers import AutoTokenizer, AutoModelForCausalLM
-from peft import PeftModel
-from io import StringIO
-import requests
-from requests.adapters import HTTPAdapter
-from urllib3.util.retry import Retry
-from transformers import AutoModel, AutoTokenizer, AutoModelForCausalLM, LlamaForCausalLM, LlamaTokenizerFast
-from peft import PeftModel  # 0.5.0
-import torch
-
-# Suppress Google Cloud warnings
-os.environ['GRPC_VERBOSITY'] = 'ERROR'
-os.environ['GRPC_TRACE'] = ''
-
-# Suppress other warnings
-import warnings
-warnings.filterwarnings('ignore', category=UserWarning)
-warnings.filterwarnings('ignore', category=FutureWarning)
-
-# ---------- CẤU HÌNH ---------------------------------------------------------
-
-GEMINI_MODEL = "gemini-2.5-pro"  # legacy, no longer used for generation
-FIN_MODEL_ID = "TheFinAI/Fin-o1-14B"
-USE_LOCAL_FIN_MODEL = os.getenv("USE_LOCAL_FIN_MODEL", "0").strip() in {"1", "true", "True", "YES", "yes"}
-
-# RapidAPI Configuration
-RAPIDAPI_HOST = "alpha-vantage.p.rapidapi.com"
-
-# Load Finnhub API keys from single secret (multiple keys separated by newlines)
-FINNHUB_KEYS_RAW = os.getenv("FINNHUB_KEYS", "")
-if FINNHUB_KEYS_RAW:
-    FINNHUB_KEYS = [key.strip() for key in FINNHUB_KEYS_RAW.split('\n') if key.strip()]
-else:
-    FINNHUB_KEYS = []
-
-# Load RapidAPI keys from single secret (multiple keys separated by newlines)
-RAPIDAPI_KEYS_RAW = os.getenv("RAPIDAPI_KEYS", "")
-if RAPIDAPI_KEYS_RAW:
-    RAPIDAPI_KEYS = [key.strip() for key in RAPIDAPI_KEYS_RAW.split('\n') if key.strip()]
-else:
-    RAPIDAPI_KEYS = []
-
-# Load Google API keys from single secret (multiple keys separated by newlines)
-GOOGLE_API_KEYS_RAW = os.getenv("GOOGLE_API_KEYS", "")
-if GOOGLE_API_KEYS_RAW:
-    GOOGLE_API_KEYS = [key.strip() for key in GOOGLE_API_KEYS_RAW.split('\n') if key.strip()]
-else:
-    GOOGLE_API_KEYS = []
-
-# Hugging Face Inference token
-HF_TOKEN = os.getenv("HUGGINGFACEHUB_API_TOKEN", "").strip()
-
-# Filter out empty keys
-FINNHUB_KEYS = [key for key in FINNHUB_KEYS if key.strip()]
-GOOGLE_API_KEYS = [key for key in GOOGLE_API_KEYS if key.strip()]
-
-# Validate that we have at least one key for each service
-if not FINNHUB_KEYS:
-    print("⚠️ Warning: No Finnhub API keys found in secrets")
-if not RAPIDAPI_KEYS:
-    print("⚠️ Warning: No RapidAPI keys found in secrets")
-if not GOOGLE_API_KEYS:
-    print("⚠️ Warning: No Google API keys found in secrets")
-
-# Chọn ngẫu nhiên một khóa API để bắt đầu (if available)
-GOOGLE_API_KEY = random.choice(GOOGLE_API_KEYS) if GOOGLE_API_KEYS else None
-
-print("=" * 50)
-print("🚀 FinRobot Forecaster Starting Up...")
-print("=" * 50)
-if FINNHUB_KEYS:
-    print(f"📊 Finnhub API: {len(FINNHUB_KEYS)} keys loaded")
-else:
-    print("📊 Finnhub API: Not configured")
-if RAPIDAPI_KEYS:
-    print(f"📈 RapidAPI Alpha Vantage: {RAPIDAPI_HOST} ({len(RAPIDAPI_KEYS)} keys loaded)")
-else:
-    print("📈 RapidAPI Alpha Vantage: Not configured")
-if HF_TOKEN:
-    print("🤖 HF Inference API: Token detected for Fin-o1-14B")
-else:
-    print("🤖 HF Inference API: No token found (set HUGGINGFACEHUB_API_TOKEN)")
-print(f"🦙 LLM Model: {FIN_MODEL_ID} via HF Inference API")
-if USE_LOCAL_FIN_MODEL and torch.cuda.is_available():
-    print("🧩 Local GPU mode requested and CUDA detected; will try local load of Fin-o1-14B")
-else:
-    if USE_LOCAL_FIN_MODEL:
-        print("🧩 Local mode requested but CUDA not available; falling back to HF Inference API")
-print("✅ Application started successfully!")
-print("=" * 50)
-
-# (Legacy) Google Generative AI configuration retained for backward compatibility
-if GOOGLE_API_KEYS:
-    try:
-        genai.configure(api_key=GOOGLE_API_KEYS[0])
-    except Exception:
-        pass
-
-# Cấu hình Finnhub client (if keys available)
-if FINNHUB_KEYS:
-    # Configure with first key for initial setup
-    finnhub_client = finnhub.Client(api_key=FINNHUB_KEYS[0])
-    print(f"✅ Finnhub configured with {len(FINNHUB_KEYS)} keys")
-else:
-    finnhub_client = None
-    print("⚠️ Finnhub not configured - will use mock news data")
-
-# Tạo session với retry strategy cho requests
-def create_session():
-    session = requests.Session()
-    retry_strategy = Retry(
-        total=3,
-        backoff_factor=1,
-        status_forcelist=[429, 500, 502, 503, 504],
-    )
-    adapter = HTTPAdapter(max_retries=retry_strategy)
-    session.mount("http://", adapter)
-    session.mount("https://", adapter)
-    return session
-
-# Tạo session global
-requests_session = create_session()
-
-SYSTEM_PROMPT = (
-    "You are a seasoned stock-market analyst. "
-    "Given recent company news and optional basic financials, "
-    "return:\n"
-    "[Positive Developments] – 2-4 bullets\n"
-    "[Potential Concerns] – 2-4 bullets\n"
-    "[Prediction & Analysis] – a one-week price outlook with rationale."
-)
-
-# ---------- UTILITY HELPERS ----------------------------------------
-
-def today() -> str:
-    return date.today().strftime("%Y-%m-%d")
-
-def n_weeks_before(date_string: str, n: int) -> str:
-    return (datetime.strptime(date_string, "%Y-%m-%d") -
-            timedelta(days=7 * n)).strftime("%Y-%m-%d")
-
-# ---------- DATA FETCHING --------------------------------------------------
-
-def get_stock_data(symbol: str, steps: list[str]) -> pd.DataFrame:
-    # Thử tất cả RapidAPI Alpha Vantage keys
-    for rapidapi_key in RAPIDAPI_KEYS:
-        try:
-            print(f"📈 Fetching stock data for {symbol} via RapidAPI (key: {rapidapi_key[:8]}...)")
-            
-            # RapidAPI Alpha Vantage endpoint
-            url = f"https://{RAPIDAPI_HOST}/query"
-            
-            headers = {
-                "X-RapidAPI-Host": RAPIDAPI_HOST,
-                "X-RapidAPI-Key": rapidapi_key
-            }
-        
-            params = {
-                "function": "TIME_SERIES_DAILY",
-                "symbol": symbol,
-                "outputsize": "full",
-                "datatype": "csv"
-            }
-            
-            # Thử lại 3 lần với RapidAPI key hiện tại
-            for attempt in range(3):
-                try:
-                    resp = requests_session.get(url, headers=headers, params=params, timeout=30)
-                    if not resp.ok:
-                        print(f"RapidAPI HTTP error {resp.status_code} with key {rapidapi_key[:8]}..., attempt {attempt + 1}")
-                        time.sleep(2 ** attempt)
-                        continue
-                        
-                    text = resp.text.strip()
-                    if text.startswith("{"):
-                        info = resp.json()
-                        msg = info.get("Note") or info.get("Error Message") or info.get("Information") or str(info)
-                        if "rate limit" in msg.lower() or "quota" in msg.lower():
-                            print(f"RapidAPI rate limit hit with key {rapidapi_key[:8]}..., trying next key")
-                            break  # Thử key tiếp theo
-                        raise RuntimeError(f"RapidAPI Alpha Vantage Error: {msg}")
-                    
-                    # Parse CSV data
-                    df = pd.read_csv(StringIO(text))
-                    date_col = "timestamp" if "timestamp" in df.columns else df.columns[0]
-                    df[date_col] = pd.to_datetime(df[date_col])
-                    df = df.sort_values(date_col).set_index(date_col)
-
-                    data = {"Start Date": [], "End Date": [], "Start Price": [], "End Price": []}
-                    for i in range(len(steps) - 1):
-                        s_date = pd.to_datetime(steps[i])
-                        e_date = pd.to_datetime(steps[i+1])
-                        seg = df.loc[s_date:e_date]
-                        if seg.empty:
-                            raise RuntimeError(
-                                f"RapidAPI Alpha Vantage cannot get {symbol} data for {steps[i]} – {steps[i+1]}"
-                            )
-                        data["Start Date"].append(seg.index[0])
-                        data["Start Price"].append(seg["close"].iloc[0])
-                        data["End Date"].append(seg.index[-1])
-                        data["End Price"].append(seg["close"].iloc[-1])
-                        time.sleep(1)  # RapidAPI has higher limits
-
-                    print(f"✅ Successfully retrieved {symbol} data via RapidAPI (key: {rapidapi_key[:8]}...)")
-                    return pd.DataFrame(data)
-                    
-                except requests.exceptions.Timeout:
-                    print(f"RapidAPI timeout with key {rapidapi_key[:8]}..., attempt {attempt + 1}")
-                    if attempt < 2:
-                        time.sleep(5 * (attempt + 1))
-                        continue
-                    else:
-                        break
-                except requests.exceptions.RequestException as e:
-                    print(f"RapidAPI request error with key {rapidapi_key[:8]}..., attempt {attempt + 1}: {e}")
-                    if attempt < 2:
-                        time.sleep(3)
-                        continue
-                    else:
-                        break
-                        
-        except Exception as e:
-            print(f"RapidAPI Alpha Vantage failed with key {rapidapi_key[:8]}...: {e}")
-            continue  # Thử key tiếp theo
-    
-    # Fallback: Tạo mock data nếu tất cả RapidAPI keys đều fail
-    print("⚠️ All RapidAPI keys failed, using mock data for demonstration...")
-    return create_mock_stock_data(symbol, steps)
-
-def create_mock_stock_data(symbol: str, steps: list[str]) -> pd.DataFrame:
-    """Tạo mock data để demo khi API không hoạt động"""
-    import numpy as np
-    
-    data = {"Start Date": [], "End Date": [], "Start Price": [], "End Price": []}
-    
-    # Giá cơ bản khác nhau cho các symbol khác nhau
-    base_prices = {
-        "AAPL": 180.0, "MSFT": 350.0, "GOOGL": 140.0, 
-        "TSLA": 200.0, "NVDA": 450.0, "AMZN": 150.0
-    }
-    base_price = base_prices.get(symbol.upper(), 150.0)
-    
-    for i in range(len(steps) - 1):
-        s_date = pd.to_datetime(steps[i])
-        e_date = pd.to_datetime(steps[i+1])
-        
-        # Tạo giá ngẫu nhiên với xu hướng tăng nhẹ
-        start_price = base_price + np.random.normal(0, 5)
-        end_price = start_price + np.random.normal(2, 8)  # Xu hướng tăng nhẹ
-        
-        data["Start Date"].append(s_date)
-        data["Start Price"].append(round(start_price, 2))
-        data["End Date"].append(e_date)
-        data["End Price"].append(round(end_price, 2))
-        
-        base_price = end_price  # Cập nhật giá cơ bản cho tuần tiếp theo
-    
-    return pd.DataFrame(data)
-
-def current_basics(symbol: str, curday: str) -> dict:
-    # Check if Finnhub is configured
-    if not FINNHUB_KEYS:
-        print(f"⚠️ Finnhub not configured, skipping financial basics for {symbol}")
-        return {}
-    
-    # Thử với tất cả các Finnhub API keys
-    for api_key in FINNHUB_KEYS:
-        try:
-            client = finnhub.Client(api_key=api_key)
-            # Thêm timeout cho Finnhub client
-            raw = client.company_basic_financials(symbol, "all")
-            if not raw["series"]:
-                continue
-            merged = defaultdict(dict)
-            for metric, vals in raw["series"]["quarterly"].items():
-                for v in vals:
-                    merged[v["period"]][metric] = v["v"]
-
-            latest = max((p for p in merged if p <= curday), default=None)
-            if latest is None:
-                continue
-            d = dict(merged[latest])
-            d["period"] = latest
-            return d
-        except Exception as e:
-            print(f"Error getting basics for {symbol} with key {api_key[:8]}...: {e}")
-            time.sleep(2)  # Thêm delay trước khi thử key tiếp theo
-            continue
-    return {}
-
-def attach_news(symbol: str, df: pd.DataFrame) -> pd.DataFrame:
-    news_col = []
-    for _, row in df.iterrows():
-        start = row["Start Date"].strftime("%Y-%m-%d")
-        end   = row["End Date"].strftime("%Y-%m-%d")
-        time.sleep(2)  # Tăng delay để tránh rate limit
-        
-        # Check if Finnhub is configured
-        if not FINNHUB_KEYS:
-            print(f"⚠️ Finnhub not configured, using mock news for {symbol}")
-            news_data = create_mock_news(symbol, start, end)
-            news_col.append(json.dumps(news_data))
-            continue
-        
-        # Thử với tất cả các Finnhub API keys
-        news_data = []
-        for api_key in FINNHUB_KEYS:
-            try:
-                client = finnhub.Client(api_key=api_key)
-                weekly = client.company_news(symbol, _from=start, to=end)
-                weekly_fmt = [
-                    {
-                        "date"    : datetime.fromtimestamp(n["datetime"]).strftime("%Y%m%d%H%M%S"),
-                        "headline": n["headline"],
-                        "summary" : n["summary"],
-                    }
-                    for n in weekly
-                ]
-                weekly_fmt.sort(key=lambda x: x["date"])
-                news_data = weekly_fmt
-                break  # Thành công, thoát khỏi loop
-            except Exception as e:
-                print(f"Error with Finnhub key {api_key[:8]}... for {symbol} from {start} to {end}: {e}")
-                time.sleep(3)  # Thêm delay trước khi thử key tiếp theo
-                continue
-        
-        # Nếu không có news data, tạo mock news
-        if not news_data:
-            news_data = create_mock_news(symbol, start, end)
-        
-        news_col.append(json.dumps(news_data))
-    df["News"] = news_col
-    return df
-
-def create_mock_news(symbol: str, start: str, end: str) -> list:
-    """Tạo mock news data khi API không hoạt động"""
-    mock_news = [
-        {
-            "date": f"{start}120000",
-            "headline": f"{symbol} Shows Strong Performance in Recent Trading",
-            "summary": f"Company {symbol} has demonstrated resilience in the current market conditions with positive investor sentiment."
-        },
-        {
-            "date": f"{end}090000", 
-            "headline": f"Analysts Maintain Positive Outlook for {symbol}",
-            "summary": f"Financial analysts continue to recommend {symbol} based on strong fundamentals and growth prospects."
-        }
-    ]
-    return mock_news
-
-# ---------- PROMPT CONSTRUCTION -------------------------------------------
-
-def sample_news(news: list[str], k: int = 5) -> list[str]:
-    if len(news) <= k: 
-        return news
-    return [news[i] for i in sorted(random.sample(range(len(news)), k))]
-
-def make_prompt(symbol: str, df: pd.DataFrame, curday: str, use_basics=False) -> str:
-    # Thử với tất cả các Finnhub API keys để lấy company profile
-    company_blurb = f"[Company Introduction]:\n{symbol} is a publicly traded company.\n"
-    
-    if FINNHUB_KEYS:
-        for api_key in FINNHUB_KEYS:
-            try:
-                client = finnhub.Client(api_key=api_key)
-                prof = client.company_profile2(symbol=symbol)
-                company_blurb = (
-                    f"[Company Introduction]:\n{prof['name']} operates in the "
-                    f"{prof['finnhubIndustry']} sector ({prof['country']}). "
-                    f"Founded {prof['ipo']}, market cap {prof['marketCapitalization']:.1f} "
-                    f"{prof['currency']}; ticker {symbol} on {prof['exchange']}.\n"
-                )
-                break  # Thành công, thoát khỏi loop
-            except Exception as e:
-                print(f"Error getting company profile for {symbol} with key {api_key[:8]}...: {e}")
-                time.sleep(2)  # Thêm delay trước khi thử key tiếp theo
-                continue
-    else:
-        print(f"⚠️ Finnhub not configured, using basic company info for {symbol}")
-
-    # Past weeks block
-    past_block = ""
-    for _, row in df.iterrows():
-        term = "increased" if row["End Price"] > row["Start Price"] else "decreased"
-        head = (f"From {row['Start Date']:%Y-%m-%d} to {row['End Date']:%Y-%m-%d}, "
-                f"{symbol}'s stock price {term} from "
-                f"{row['Start Price']:.2f} to {row['End Price']:.2f}.")
-        news_items = json.loads(row["News"])
-        summaries  = [
-            f"[Headline] {n['headline']}\n[Summary] {n['summary']}\n"
-            for n in news_items
-            if not n["summary"].startswith("Looking for stock market analysis")
-        ]
-        past_block += "\n" + head + "\n" + "".join(sample_news(summaries, 5))
-
-    # Optional basic financials
-    if use_basics:
-        basics = current_basics(symbol, curday)
-        if basics:
-            basics_txt = "\n".join(f"{k}: {v}" for k, v in basics.items() if k != "period")
-            basics_block = (f"\n[Basic Financials] (reported {basics['period']}):\n{basics_txt}\n")
-        else:
-            basics_block = "\n[Basic Financials]: not available\n"
-    else:
-        basics_block = "\n[Basic Financials]: not requested\n"
-
-    horizon = f"{curday} to {n_weeks_before(curday, -1)}"
-    final_user_msg = (
-        company_blurb
-        + past_block
-        + basics_block
-        + f"\nBased on all information before {curday}, analyse positive "
-          "developments and potential concerns for {symbol}, then predict its "
-          f"price movement for next week ({horizon})."
-    )
-    return final_user_msg
-
-# ---------- LLM CALL -------------------------------------------------------
-
-def chat_completion(prompt: str,
-                    model: str = FIN_MODEL_ID,
-                    temperature: float = 0.2,
-                    stream: bool = False,
-                    symbol: str = "STOCK") -> str:
-    # Prefer local GPU inference if requested and available
-    if USE_LOCAL_FIN_MODEL and torch.cuda.is_available():
-        try:
-            text = _local_generate_with_fin_model(prompt, model, temperature)
-            if isinstance(text, str) and text.strip():
-                return text.strip()
-        except Exception as e:
-            print(f"Local GPU inference failed: {e}. Falling back to HF Inference API...")
-
-    # Use Hugging Face Inference API for Fin-o1-14B
-    if not HF_TOKEN:
-        print(f"⚠️ HF token missing, using mock response for {symbol}")
-        return create_mock_ai_response(symbol)
-
-    full_prompt = f"{SYSTEM_PROMPT}\n\n{prompt}"
-    url = f"https://api-inference.huggingface.co/models/{model}"
-    headers = {
-        "Authorization": f"Bearer {HF_TOKEN}",
-        "Accept": "application/json",
-        "Content-Type": "application/json",
-    }
-    payload = {
-        "inputs": full_prompt,
-        "parameters": {
-            "max_new_tokens": 1024,
-            "temperature": max(0.0, min(1.0, float(temperature))),
-            "top_p": 0.9,
-            "repetition_penalty": 1.05,
-            "return_full_text": False
-        },
-        "options": {"use_cache": True, "wait_for_model": True}
-    }
-
-    # Retry logic including model loading 503
-    for attempt in range(4):
-        try:
-            resp = requests_session.post(url, headers=headers, data=json.dumps(payload), timeout=120)
-            if resp.status_code == 503:
-                try:
-                    info = resp.json()
-                    wait_s = float(info.get("estimated_time", 5.0))
-                except Exception:
-                    wait_s = 5.0
-                print(f"Model loading (503). Waiting {wait_s:.1f}s before retry...")
-                time.sleep(min(wait_s + attempt, 15))
-                continue
-            if not resp.ok:
-                print(f"HF API error {resp.status_code}: {resp.text[:200]}")
-                time.sleep(1 + attempt)
-                continue
-
-            data = resp.json()
-            # Possible shapes: [{"generated_text": "..."}], {"generated_text": "..."}, or text
-            if isinstance(data, list) and data and isinstance(data[0], dict) and "generated_text" in data[0]:
-                return data[0]["generated_text"].strip()
-            if isinstance(data, dict) and "generated_text" in data:
-                return str(data["generated_text"]).strip()
-            # Some pipelines return token sequence under 'outputs'
-            text = None
-            if isinstance(data, list) and data and isinstance(data[0], dict):
-                text = data[0].get("text") or data[0].get("generated_text")
-            if isinstance(data, dict):
-                text = text or data.get("text") or data.get("data")
-            if isinstance(text, str):
-                return text.strip()
-            # Fallback stringify
-            return str(data)
-        except requests.exceptions.RequestException as e:
-            print(f"HF request error (attempt {attempt+1}): {e}")
-            time.sleep(1 + attempt)
-            continue
-        except Exception as e:
-            print(f"HF unknown error: {e}")
-            break
-
-    print("⚠️ All HF attempts failed, using mock AI response for demonstration...")
-    return create_mock_ai_response(symbol)
-
-
-# ---------- LOCAL GPU INFERENCE (optional) ---------------------------------
-
-_LOCAL_FIN_TOKENIZER = None
-_LOCAL_FIN_MODEL = None
-
-def _load_local_fin_model(model_id: str):
-    global _LOCAL_FIN_TOKENIZER, _LOCAL_FIN_MODEL
-    if _LOCAL_FIN_MODEL is not None and _LOCAL_FIN_TOKENIZER is not None:
-        return _LOCAL_FIN_TOKENIZER, _LOCAL_FIN_MODEL
-
-    print(f"Loading local model {model_id} ...")
-    from transformers import AutoTokenizer, AutoModelForCausalLM, BitsAndBytesConfig
-
-    quant_config = None
-    try:
-        import bitsandbytes as bnb  # noqa: F401
-        quant_config = BitsAndBytesConfig(
-            load_in_4bit=True,
-            bnb_4bit_use_double_quant=True,
-            bnb_4bit_quant_type="nf4",
-            bnb_4bit_compute_dtype=torch.bfloat16,
-        )
-        print("Using 4-bit quantization via bitsandbytes")
-    except Exception:
-        print("bitsandbytes not available; trying bf16 with accelerate device_map=auto")
-
-    _LOCAL_FIN_TOKENIZER = AutoTokenizer.from_pretrained(model_id, use_fast=True)
-    if quant_config is not None:
-        _LOCAL_FIN_MODEL = AutoModelForCausalLM.from_pretrained(
-            model_id,
-            quantization_config=quant_config,
-            device_map="auto",
-            trust_remote_code=True,
-        )
-    else:
-        _LOCAL_FIN_MODEL = AutoModelForCausalLM.from_pretrained(
-            model_id,
-            torch_dtype=torch.bfloat16,
-            device_map="auto",
-            trust_remote_code=True,
-        )
-
-    try:
-        _LOCAL_FIN_MODEL.eval()
-    except Exception:
-        pass
-    return _LOCAL_FIN_TOKENIZER, _LOCAL_FIN_MODEL
-
-
-def _local_generate_with_fin_model(user_prompt: str, model_id: str, temperature: float) -> str:
-    tokenizer, model = _load_local_fin_model(model_id)
-    full_prompt = f"{SYSTEM_PROMPT}\n\n{user_prompt}"
-    inputs = tokenizer(full_prompt, return_tensors="pt").to(model.device)
-    with torch.no_grad():
-        output_ids = model.generate(
-            **inputs,
-            max_new_tokens=1024,
-            do_sample=True,
-            temperature=float(max(0.0, min(1.0, temperature))),
-            top_p=0.9,
-            repetition_penalty=1.05,
-            eos_token_id=tokenizer.eos_token_id,
-            pad_token_id=tokenizer.eos_token_id,
-        )
-    generated = output_ids[0][inputs["input_ids"].shape[-1]:]
-    text = tokenizer.decode(generated, skip_special_tokens=True)
-    return text
-
-def create_mock_ai_response(symbol: str) -> str:
-    """Tạo mock AI response khi Google API không hoạt động"""
-    return f"""
-[Positive Developments]
-• Strong market position and brand recognition for {symbol}
-• Recent quarterly earnings showing growth potential
-• Positive analyst sentiment and institutional investor interest
-• Technological innovation and market expansion opportunities
-
-[Potential Concerns]
-• Market volatility and economic uncertainty
-• Competitive pressures in the industry
-• Regulatory changes that may impact operations
-• Global economic factors affecting stock performance
-
-[Prediction & Analysis]
-Based on the current market conditions and company fundamentals, {symbol} is expected to show moderate growth over the next week. The stock may experience some volatility but should maintain an upward trend with a potential price increase of 2-5%. This prediction is based on current market sentiment and technical analysis patterns.
-
-Note: This is a demonstration response using mock data. For real investment decisions, please consult with qualified financial professionals.
-"""
-
-# ---------- MAIN PREDICTION FUNCTION -----------------------------------------
-
-def predict(symbol: str = "AAPL",
-            curday: str = today(),
-            n_weeks: int = 3,
-            use_basics: bool = False,
-            stream: bool = False) -> tuple[str, str]:
-    try:
-        steps = [n_weeks_before(curday, n) for n in range(n_weeks + 1)][::-1]
-        df    = get_stock_data(symbol, steps)
-        df    = attach_news(symbol, df)
-
-        prompt_info = make_prompt(symbol, df, curday, use_basics)
-        answer      = chat_completion(prompt_info, stream=stream, symbol=symbol)
-
-        return prompt_info, answer
-    except Exception as e:
-        error_msg = f"Error in prediction: {str(e)}"
-        print(f"Prediction error: {e}")  # Log the error for debugging
-        return error_msg, error_msg
-
-# ---------- HUGGINGFACE SPACES INTERFACE -----------------------------------------
-
-def hf_predict(symbol, n_weeks, use_basics):
-    # 1. get curday
-    curday = date.today().strftime("%Y-%m-%d")
-    # 2. call predict
-    prompt, answer = predict(
-        symbol=symbol.upper(),
-        curday=curday,
-        n_weeks=int(n_weeks),
-        use_basics=bool(use_basics),
-        stream=False
-    )
-    return prompt, answer
-
-# ---------- GRADIO INTERFACE -----------------------------------------
-
-def create_interface():
-    with gr.Blocks(
-        title="FinRobot Forecaster",
-        theme=gr.themes.Soft(),
-        css="""
-        .gradio-container {
-            max-width: 1200px !important;
-            margin: auto !important;
-        }
-        #model_prompt_textbox textarea {
-            overflow-y: auto !important;
-            max-height: none !important;
-            min-height: 400px !important;
-            resize: vertical !important;
-            white-space: pre-wrap !important;
-            word-wrap: break-word !important;
-            height: auto !important;
-        }
-        #model_prompt_textbox {
-            height: auto !important;
-        }
-        #analysis_results_textbox textarea {
-            overflow-y: auto !important;
-            max-height: none !important;
-            min-height: 400px !important;
-            resize: vertical !important;
-            white-space: pre-wrap !important;
-            word-wrap: break-word !important;
-            height: auto !important;
-        }
-        #analysis_results_textbox {
-            height: auto !important;
-        }
-        .textarea textarea {
-            overflow-y: auto !important;
-            max-height: 500px !important;
-            resize: vertical !important;
-        }
-        .textarea {
-            height: auto !important;
-            min-height: 300px !important;
-        }
-        .gradio-textbox {
-            height: auto !important;
-            max-height: none !important;
-        }
-        .gradio-textbox textarea {
-            height: auto !important;
-            max-height: none !important;
-            overflow-y: auto !important;
-        }
-        """
-    ) as demo:
-        gr.Markdown("""
-        # 🤖 FinRobot Forecaster
-        
-        **AI-powered stock market analysis and prediction using Fin-o1-14B**
-        
-        This application analyzes stock market data, company news, and financial metrics to provide comprehensive market insights and predictions.
-        
-        • Model: **TheFinAI/Fin-o1-14B** (Qwen3-14B finetune) via Hugging Face Inference API  
-        • Set secret **HUGGINGFACEHUB_API_TOKEN** in your Space for real responses  
-        
-        ⚠️ **Note**: Free data APIs have daily rate limits. If you encounter errors, the app may use mock data for demonstration purposes.
-        """)
-        
-        with gr.Row():
-            with gr.Column(scale=1):
-                symbol = gr.Textbox(
-                    label="Stock Symbol", 
-                    value="AAPL",
-                    placeholder="Enter stock symbol (e.g., AAPL, MSFT, GOOGL)",
-                    info="Enter the ticker symbol of the stock you want to analyze"
-                )
-                n_weeks = gr.Slider(
-                    1, 6, 
-                    value=3, 
-                    step=1, 
-                    label="Historical Weeks to Analyze",
-                    info="Number of weeks of historical data to include in analysis"
-                )
-                use_basics = gr.Checkbox(
-                    label="Include Basic Financials", 
-                    value=True,
-                    info="Include basic financial metrics in the analysis"
-                )
-                btn = gr.Button(
-                    "🚀 Run Analysis", 
-                    variant="primary"
-                )
-            
-            with gr.Column(scale=2):
-                with gr.Tabs():
-                    with gr.Tab("📊 Analysis Results"):
-                        gr.Markdown("**AI Analysis & Prediction**")
-                        output_answer = gr.Textbox(
-                            label="", 
-                            lines=40,
-                            show_copy_button=True,
-                            interactive=False,
-                            placeholder="AI analysis and predictions will appear here...",
-                            container=True,
-                            scale=1,
-                            elem_id="analysis_results_textbox"
-                        )
-                    with gr.Tab("🔍 Model Prompt"):
-                        gr.Markdown("**Generated Prompt**")
-                        output_prompt = gr.Textbox(
-                            label="", 
-                            lines=40,
-                            show_copy_button=True,
-                            interactive=False,
-                            placeholder="Generated prompt will appear here...",
-                            container=True,
-                            scale=1,
-                            elem_id="model_prompt_textbox"
-                        )
-        
-        # Examples
-        gr.Examples(
-            examples=[
-                ["AAPL", 3, False],
-                ["MSFT", 4, True],
-                ["GOOGL", 2, False],
-                ["TSLA", 5, True],
-                ["NVDA", 3, True]
-            ],
-            inputs=[symbol, n_weeks, use_basics],
-            label="💡 Try these examples"
-        )
-        
-        # Event handlers
-        btn.click(
-            fn=hf_predict,
-            inputs=[symbol, n_weeks, use_basics],
-            outputs=[output_prompt, output_answer],
-            show_progress=True
-        )
-        
-        
-        # Footer
-        gr.Markdown("""
-        ---
-        **Disclaimer**: This application is for educational and research purposes only. 
-        The predictions and analysis provided should not be considered as financial advice. 
-        Always consult with qualified financial professionals before making investment decisions.
-        """)
-    
-    return demo
-
-# ---------- MAIN EXECUTION -----------------------------------------
-
-if __name__ == "__main__":
-    demo = create_interface()
-    demo.launch(
-        server_name="0.0.0.0",
-        server_port=7860,
-        share=False,
-        show_error=True,
-        debug=False,
-        quiet=True
-    )