Update app.py

app.py

@@ -18,6 +18,8 @@ import torch.nn.functional as F
 from sentence_transformers import SentenceTransformer
 from sklearn.preprocessing import StandardScaler
 import gradio as gr
+from twelvedata import TDClient
+import matplotlib
 
 # --- Configuration ---
 DEVICE = 'cpu'
@@ -26,15 +28,15 @@ VQ_DIM = 64
 REGIME_EMBED_DIM = 8
 EVENT_EMBED_DIM = 384
 BASE_JSON_WEEK = "https://nfs.faireconomy.media/ff_calendar_thisweek.json"
-CACHE_DURATION_SECONDS = 600 # Cache data for 10 minutes
+CACHE_DURATION_SECONDS = 600 # Cache event data for 10 minutes
 
 BASE_CHANNELS = ['open', 'high', 'low', 'close']
 DERIVED_CHANNELS = ['Volume', 'VolMissing', 'Logclose', 'Return']
 ALL_CHANNELS = BASE_CHANNELS + DERIVED_CHANNELS
 IMPACT_MAP = {"High": 3, "Medium": 2, "Low": 1, "Holiday": 0}
 
-# --- Simple In-Memory Cache ---
-_CACHE = {"data": None, "timestamp": 0}
+# --- Simple In-Memory Cache for Events ---
+_EVENT_CACHE = {"data": None, "timestamp": 0}
 
 # --- Model Architecture Definitions ---
 class SmallTCN(nn.Module):
@@ -78,24 +80,36 @@ class ModelSingleton:
 
 # --- Data Fetching and Processing Functions ---
 def fetch_week_json_with_cache():
-    """Fetches data from the API, using a time-based cache to avoid rate limits."""
     current_time = time.time()
-    # Check if cache is valid
-    if _CACHE["data"] and (current_time - _CACHE["timestamp"] < CACHE_DURATION_SECONDS):
+    if _EVENT_CACHE["data"] and (current_time - _EVENT_CACHE["timestamp"] < CACHE_DURATION_SECONDS):
         print("Using cached event data.")
-        return _CACHE["data"]
-
+        return _EVENT_CACHE["data"]
     print("Fetching live economic events (cache was stale)...")
     try:
         response = requests.get(BASE_JSON_WEEK, headers={"User-Agent": "kairos-demo/1.0"}, timeout=10)
         response.raise_for_status()
         data = response.json()
-        # Update cache
-        _CACHE["data"] = data
-        _CACHE["timestamp"] = current_time
+        _EVENT_CACHE["data"], _EVENT_CACHE["timestamp"] = data, current_time
         return data
-    except requests.RequestException as e:
-        raise gr.Error(f"Failed to fetch data. Error: {e}")
+    except requests.RequestException as e: raise gr.Error(f"Failed to fetch event data. Error: {e}")
+
+def fetch_twelvedata(api_key, symbol, interval, output_size):
+    try:
+        td = TDClient(apikey=api_key)
+        ts = td.time_series(symbol=symbol, interval=interval, outputsize=output_size)
+        df = ts.as_pandas()
+        df.reset_index(inplace=True) 
+        df = df.sort_values(by='datetime').reset_index(drop=True)
+        df.columns = [c.lower() for c in df.columns]
+        return df
+    except Exception as e: raise gr.Error(f"Failed to fetch price data. Error: {e}")
+
+def preprocess_price_df(df):
+    if df is None: return None
+    df['Volume'], df['VolMissing'] = 0.0, 1.0
+    df['Logclose'] = np.log(df['close'].astype(float) + 1e-12)
+    df['Return'] = df['Logclose'].diff().fillna(0.0)
+    return df
 
 def parse_financial_number(s: str) -> float:
     if not isinstance(s, str) or not s: return np.nan
@@ -113,53 +127,78 @@ def format_events_for_kairos(events: list, encoder: SentenceTransformer) -> torc
         features.append(torch.cat((embedding, nums)))
     return torch.nan_to_num(torch.stack(features))
 
+def get_regime(price_slice):
+    log_return = np.log(price_slice['close'] + 1e-9).diff().dropna()
+    volatility = log_return.std()
+    if volatility > 0.0008: return 0
+    if volatility > 0.0004: return 1
+    return 2
+
 # --- Main Prediction Function ---
 @torch.no_grad()
 def predict_action():
+    # 1. Load Models and API Key
     models = ModelSingleton()
     kairos_model, sentence_encoder = models.kairos_model, models.sentence_encoder
-    
+    api_key = os.environ.get('TWELVE_DATA_API_KEY')
+    if not api_key: raise gr.Error("TWELVE_DATA_API_KEY not found. Please set it in Space secrets.")
+
+    # 2. Fetch Live Events and Prices
     live_events = fetch_week_json_with_cache()
+    price_data_store = {res: preprocess_price_df(fetch_twelvedata(api_key, 'EUR/USD', res, HISTORY_LEN)) for res in ['15min', '30min', '1h']}
+
+    # 3. Prepare Inputs for the Model
     event_tensor = format_events_for_kairos(live_events, sentence_encoder)
     if event_tensor.numel() > 0: event_tensor = event_tensor.unsqueeze(0)
 
-    dummy_price = torch.randn(1, HISTORY_LEN, len(ALL_CHANNELS), device=DEVICE)
-    dummy_aligned = {res: torch.randn(1, HISTORY_LEN, len(ALL_CHANNELS), device=DEVICE) for res in ['15min', '30min', '1h']}
-    dummy_regime = torch.tensor([1], device=DEVICE)
+    base_df = price_data_store['15min']
+    hist_slice = base_df.iloc[-HISTORY_LEN:]
+    
+    scaler = StandardScaler()
+    price_history_tensor = torch.tensor(scaler.fit_transform(hist_slice[ALL_CHANNELS].values), dtype=torch.float32).unsqueeze(0).to(DEVICE)
+    aligned_tensors = {res: torch.tensor(pd.merge_asof(hist_slice['datetime'].to_frame(), price_data_store[res][['datetime'] + ALL_CHANNELS], on='datetime', direction='backward')[ALL_CHANNELS].ffill().bfill().fillna(0.0).values, dtype=torch.float32).unsqueeze(0).to(DEVICE) for res in ['15min', '30min', '1h']}
+    
+    regime = get_regime(hist_slice)
+    regime_tensor = torch.tensor([regime], device=DEVICE)
 
-    print("Running model inference...")
-    _, _, tokens, _ = kairos_model.forward_encode(dummy_price, dummy_aligned)
-    regime_emb = kairos_model.regime_embedding(dummy_regime)
+    # 4. Run Model Inference
+    print("Running model inference with live prices and events...")
+    _, _, tokens, _ = kairos_model.forward_encode(price_history_tensor, aligned_tensors)
+    regime_emb = kairos_model.regime_embedding(regime_tensor)
     log_probs = kairos_model.reasoner(tokens=tokens, regime_emb=regime_emb, event_features=event_tensor, memory_features=None)
     
+    # 5. Interpret and Return Results
     probs = torch.exp(log_probs).squeeze().cpu().numpy()
     action_map = {0: "BUY", 1: "SELL", 2: "HOLD"}
     prediction = action_map[np.argmax(probs)]
     confidences = {action_map[i]: f"{p:.2%}" for i, p in enumerate(probs)}
     timestamp = pd.Timestamp.now(tz=pytz.UTC).strftime('%Y-%m-%d %H:%M:%S %Z')
-    print(f"Prediction based on events up to {timestamp}: {prediction}")
+    print(f"Prediction for {timestamp}: {prediction}")
     
     events_df = pd.DataFrame(live_events)
     events_df['currency'] = events_df.get('currency', events_df.get('country', 'N/A'))
     events_df['event'] = events_df.get('title', events_df.get('event', 'No Title'))
     display_df = events_df[['date', 'currency', 'impact', 'event']]
     
-    return prediction, confidences, display_df, f"Prediction based on events up to: {timestamp}"
+    return prediction, confidences, hist_slice, display_df, f"Analysis based on data up to: {timestamp}"
 
 # --- Gradio Interface ---
-with gr.Blocks(css="footer {display: none !important}", title="Kairos Live Event Analyzer") as demo:
-    gr.Markdown("# Kairos Live Economic Event Analyzer")
-    gr.Markdown("This demo fetches the latest economic calendar from Forex Factory. It then uses the **Kairos AI model** to analyze the *meaning* of these events and recommend a trading action for **EUR/USD** based on the current news context. **Data is cached for 10 minutes.**")
+with gr.Blocks(css="footer {display: none !important}", title="Kairos Live AI") as demo:
+    gr.Markdown("# Kairos Live Trading AI")
+    gr.Markdown("This interface fetches **live price data** (from `twelvedata`) and **live economic events** (from `Forex Factory`). The Kairos AI analyzes both to generate a real-time trading signal for **EUR/USD**.")
+    with gr.Accordion("⚠️ How to Use", open=False):
+        gr.Markdown("1. **Get a free API key** from [twelvedata.com](https://twelvedata.com/apikey).\n2. On this Space, go to **Settings** > **Repository secrets**.\n3. Create a new secret named `TWELVE_DATA_API_KEY` and paste your key as the value.")
     with gr.Row():
-        predict_btn = gr.Button("Analyze Live Events", variant="primary")
+        predict_btn = gr.Button("Get Live Signal", variant="primary")
     with gr.Row():
         action_label = gr.Label(label="Recommended Action")
         timestamp_label = gr.Textbox(label="Analysis Timestamp", interactive=False)
     confidence_json = gr.JSON(label="Confidence Scores")
-    events_table = gr.DataFrame(label="Events Considered in This Analysis", interactive=False)
-    predict_btn.click(fn=predict_action, inputs=[], outputs=[action_label, confidence_json, events_table, timestamp_label])
-    gr.Markdown("--- \n *Model: Kairos Stage 4 Policy Model. Not financial advice. For educational purposes only.*")
+    price_plot = gr.LinePlot(label="Live Market Data Used for Prediction", x="datetime", y="close")
+    events_table = gr.DataFrame(label="Live Events Considered in This Analysis", interactive=False)
+    predict_btn.click(fn=predict_action, inputs=[], outputs=[action_label, confidence_json, price_plot, events_table, timestamp_label])
+    gr.Markdown("--- \n *Model: Kairos Stage 4 Policy Model. Not financial advice.*")
 
 if __name__ == "__main__":
-    ModelSingleton() 
+    ModelSingleton()
     demo.launch()