Create app.py

app.py

@@ -0,0 +1,332 @@
+import gradio as gr
+import pandas as pd
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import requests
+import os
+import time
+import plotly.graph_objects as go
+from plotly.subplots import make_subplots
+from sklearn.preprocessing import StandardScaler
+
+# --- 1. CONFIG & SECRETS ---
+API_KEY = os.getenv("TWELVEDATA_KEY")
+NTFY_TOPIC = os.getenv("NTFY_TOPIC")
+
+# The Constellation Basket
+TARGET_PAIR = "EUR/USD"
+SYMBOLS = ["EUR/USD", "GBP/USD", "USD/JPY", "XAU/USD"] 
+TIMEFRAME = "15min"
+LOOKBACK = 30 
+
+# Global State
+GLOBAL_STATE = {
+    "model": None,
+    "last_trade": None,
+    "scaler": None,
+    "is_trained": False
+}
+
+# --- 2. THE MODEL: CONSTELLATION TRANSFORMER ---
+class PositionalEncoding(nn.Module):
+    def __init__(self, d_model, max_len=5000):
+        super(PositionalEncoding, self).__init__()
+        # Simple learnable positional encoding
+        self.encoding = nn.Parameter(torch.zeros(1, max_len, d_model))
+    
+    def forward(self, x):
+        # x: [Batch, Seq, Dim]
+        seq_len = x.size(1)
+        return x + self.encoding[:, :seq_len, :]
+
+class ConstellationTransformer(nn.Module):
+    def __init__(self, input_dim, d_model=64, nhead=4, num_layers=2, num_gaussians=3):
+        super(ConstellationTransformer, self).__init__()
+        
+        # 1. Embedding: Project 6 features (4 Pairs + 2 News) -> 64 Dim
+        self.embedding = nn.Linear(input_dim, d_model)
+        self.pos_encoder = PositionalEncoding(d_model)
+        
+        # 2. Transformer Encoder: The "Graph" Brain
+        encoder_layer = nn.TransformerEncoderLayer(d_model=d_model, nhead=nhead, batch_first=True, dropout=0.1)
+        self.transformer = nn.TransformerEncoder(encoder_layer, num_layers=num_layers)
+        
+        # 3. MDN Head
+        self.z_pi = nn.Linear(d_model, num_gaussians)
+        self.z_sigma = nn.Linear(d_model, num_gaussians)
+        self.z_mu = nn.Linear(d_model, num_gaussians)
+        
+        # Init Sigma to be tight/confident
+        nn.init.constant_(self.z_sigma.bias, -2.0)
+
+    def forward(self, x):
+        # x: [Batch, Seq_Len, Features]
+        x = self.embedding(x)
+        x = self.pos_encoder(x)
+        
+        # Attention Magic
+        x = self.transformer(x)
+        
+        # Take the context from the last time step
+        context = x[:, -1, :] 
+        
+        pi = F.softmax(self.z_pi(context), dim=1)
+        sigma = F.softplus(self.z_sigma(context)) + 1e-6
+        mu = self.z_mu(context)
+        return pi, sigma, mu
+
+def mdn_loss(pi, sigma, mu, y):
+    if y.dim() == 1: y = y.unsqueeze(1)
+    dist = torch.distributions.Normal(loc=mu, scale=sigma)
+    log_prob = dist.log_prob(y)
+    loss = -torch.logsumexp(torch.log(pi + 1e-8) + log_prob, dim=1)
+    return torch.mean(loss)
+
+# --- 3. DATA PIPELINE (MULTI-PAIR) ---
+def get_constellation_data():
+    if not API_KEY: return None, "❌ Error: TWELVEDATA_KEY missing."
+    
+    dfs = []
+    # Fetch all pairs
+    for sym in SYMBOLS:
+        url = f"https://api.twelvedata.com/time_series?symbol={sym}&interval={TIMEFRAME}&outputsize=500&apikey={API_KEY}"
+        try:
+            r = requests.get(url).json()
+            if 'values' not in r: continue
+            
+            df = pd.DataFrame(r['values'])
+            df['datetime'] = pd.to_datetime(df['datetime'])
+            df = df.sort_values('datetime').set_index('datetime')
+            df = df[['close']].astype(float)
+            df.rename(columns={'close': sym}, inplace=True) # Rename 'close' to 'EUR/USD'
+            dfs.append(df)
+            time.sleep(0.2) # Avoid rate limits
+        except: pass
+    
+    if not dfs: return None, "❌ Failed to fetch data."
+    
+    # Merge and Fill
+    master_df = pd.concat(dfs, axis=1).fillna(method='ffill').dropna()
+    return master_df, "✅ Constellation Aligned"
+
+def get_events_data():
+    try:
+        url = "https://nfs.faireconomy.media/ff_calendar_thisweek.json"
+        r = requests.get(url, headers={"User-Agent": "V23/1.0"}, timeout=5)
+        data = r.json()
+        parsed = []
+        impact_map = {'Low': 1, 'Medium': 2, 'High': 3}
+        for i in data:
+            if i.get('country') in ['EUR', 'USD']:
+                dt = pd.to_datetime(i.get('date'), utc=True).tz_localize(None)
+                imp = impact_map.get(i.get('impact'), 0)
+                parsed.append({'DateTime': dt, 'Impact_Score': imp})
+        df = pd.DataFrame(parsed)
+        if not df.empty: df = df.sort_values('DateTime').set_index('DateTime')
+        return df
+    except: return pd.DataFrame()
+
+def prepare_tensors(master_df, event_df):
+    # 1. Merge Events
+    if not event_df.empty:
+        merged = pd.merge_asof(master_df, event_df, left_index=True, right_index=True, direction='backward', tolerance=pd.Timedelta('4 hours')).fillna(0)
+    else:
+        merged = master_df.copy()
+        merged['Impact_Score'] = 0
+    merged['Surprise'] = 0.0
+
+    # 2. Calculate Returns for ALL Pairs
+    feature_cols = []
+    for sym in SYMBOLS:
+        col_name = f"{sym}_ret"
+        merged[col_name] = merged[sym].pct_change().fillna(0)
+        feature_cols.append(col_name)
+    
+    # Add News
+    feature_cols.extend(['Surprise', 'Impact_Score'])
+    
+    # 3. Scale
+    scaler = StandardScaler()
+    data_scaled = scaler.fit_transform(merged[feature_cols].values)
+    
+    # 4. Windows
+    X_data = []
+    for i in range(LOOKBACK, len(data_scaled)):
+        X_data.append(data_scaled[i-LOOKBACK:i])
+    
+    X_tensor = torch.FloatTensor(np.array(X_data))
+    
+    # Metadata for reconstruction
+    # Target is EUR/USD (Index 0 in SYMBOLS list, so Index 0 in feature_cols)
+    # We need stats to unscale the Target Return
+    target_idx = 0 
+    ret_mean = scaler.mean_[target_idx]
+    ret_scale = scaler.scale_[target_idx]
+    
+    # Reference Prices for EUR/USD
+    ref_prices = merged[TARGET_PAIR].values[LOOKBACK:]
+    
+    return X_tensor, merged.index[LOOKBACK:], ref_prices, ret_mean, ret_scale
+
+# --- 4. CORE LOGIC ---
+def send_ntfy(message):
+    if not NTFY_TOPIC: return
+    try:
+        requests.post(f"https://ntfy.sh/{NTFY_TOPIC}", data=message.encode('utf-8'), headers={"Title": "Holographic V4", "Priority": "high"})
+    except: pass
+
+def hard_reset():
+    GLOBAL_STATE["model"] = None
+    GLOBAL_STATE["is_trained"] = False
+    return None, "<div>♻️ MEMORY WIPED. Click Refresh.</div>", "Reset."
+
+def run_analysis():
+    log_buffer = []
+    
+    # Init V4 Model
+    # Input Dim = 4 Pairs + 2 News = 6
+    if GLOBAL_STATE["model"] is None:
+        GLOBAL_STATE["model"] = ConstellationTransformer(input_dim=6, d_model=64, num_layers=2)
+        log_buffer.append("🧠 Constellation Transformer Initialized")
+    
+    model = GLOBAL_STATE["model"]
+    
+    # Get Data
+    master_df, msg = get_constellation_data()
+    if master_df is None: return None, msg, msg
+    
+    event_df = get_events_data()
+    
+    X_tensor, dates, ref_prices, ret_mean, ret_std = prepare_tensors(master_df, event_df)
+    
+    # --- CALIBRATION ---
+    if not GLOBAL_STATE["is_trained"]:
+        log_buffer.append("⚙️ Learning Correlations...")
+        optimizer = torch.optim.Adam(model.parameters(), lr=0.005)
+        model.train()
+        
+        train_X = X_tensor[:-1]
+        
+        # Target: Return of EUR/USD (Target Pair)
+        # Calculate actual returns from reference prices
+        actual_returns = np.diff(ref_prices) / ref_prices[:-1]
+        actual_returns_scaled = (actual_returns - ret_mean) / ret_std
+        train_y = torch.FloatTensor(actual_returns_scaled).unsqueeze(1)
+        
+        train_X = train_X[:len(train_y)]
+
+        dataset = torch.utils.data.TensorDataset(train_X, train_y)
+        loader = torch.utils.data.DataLoader(dataset, batch_size=32, shuffle=True)
+        
+        for epoch in range(50):
+            for batch_X, batch_y in loader:
+                optimizer.zero_grad()
+                pi, sigma, mu = model(batch_X)
+                loss = mdn_loss(pi, sigma, mu, batch_y)
+                loss.backward()
+                optimizer.step()
+                
+        GLOBAL_STATE["is_trained"] = True
+        log_buffer.append("✅ V4 Calibration Complete.")
+
+    # --- INFERENCE ---
+    model.eval()
+    with torch.no_grad():
+        pi, sigma, mu = model(X_tensor)
+    
+    max_idx = torch.argmax(pi, dim=1)
+    pred_mu = mu[torch.arange(len(mu)), max_idx].numpy()
+    pred_sigma = sigma[torch.arange(len(sigma)), max_idx].numpy()
+    
+    # Reconstruction
+    pred_ret = (pred_mu * ret_std) + ret_mean
+    pred_ret_sigma = pred_sigma * ret_std
+    
+    prev_prices = ref_prices
+    pred_prices = prev_prices * (1 + pred_ret)
+    upper_band = prev_prices * (1 + pred_ret + (2 * pred_ret_sigma))
+    lower_band = prev_prices * (1 + pred_ret - (2 * pred_ret_sigma))
+    
+    # Prepare Plot Data
+    dates = dates[1:]
+    plot_actual = ref_prices[1:]
+    plot_pred = pred_prices[:-1]
+    plot_upper = upper_band[:-1]
+    plot_lower = lower_band[:-1]
+    plot_sigma = pred_ret_sigma[:-1]
+
+    df = pd.DataFrame({
+        'Close': plot_actual,
+        'Pred': plot_pred,
+        'Upper': plot_upper,
+        'Lower': plot_lower,
+        'Sigma': plot_sigma
+    }, index=dates)
+
+    # Z-Score
+    df['Gap'] = df['Pred'] - df['Close']
+    df['Price_Sigma'] = df['Close'] * df['Sigma']
+    df['Raw_Z'] = df['Gap'] / (df['Price_Sigma'] + 1e-9)
+    df['Rolling_Z'] = df['Raw_Z'] - df['Raw_Z'].rolling(window=50, min_periods=1).mean()
+    
+    if len(df) > 0:
+        last_z = df['Rolling_Z'].iloc[-1]
+        last_price = df['Close'].iloc[-1]
+        
+        status = "WAIT"
+        color = "gray"
+        if last_z > 1.8:
+            status = "BUY SIGNAL"
+            color = "green"
+            if GLOBAL_STATE["last_trade"] != "BUY":
+                send_ntfy(f"BUY EURUSD | Z: {last_z:.2f} | Price: {last_price}")
+                GLOBAL_STATE["last_trade"] = "BUY"
+        elif last_z < -1.8:
+            status = "SELL SIGNAL"
+            color = "red"
+            if GLOBAL_STATE["last_trade"] != "SELL":
+                send_ntfy(f"SELL EURUSD | Z: {last_z:.2f} | Price: {last_price}")
+                GLOBAL_STATE["last_trade"] = "SELL"
+        
+        # PLOTTING (Dual Subplot)
+        fig = make_subplots(rows=2, cols=1, shared_xaxes=True, 
+                            vertical_spacing=0.1, 
+                            row_heights=[0.7, 0.3],
+                            subplot_titles=("Holographic Price Cloud", "Market Divergence (Z-Score)"))
+
+        # Chart 1: Price
+        fig.add_trace(go.Scatter(x=df.index, y=df['Close'], mode='lines', name='Price', line=dict(color='rgba(255, 255, 255, 0.5)')), row=1, col=1)
+        fig.add_trace(go.Scatter(x=df.index, y=df['Upper'], mode='lines', line=dict(width=0), showlegend=False), row=1, col=1)
+        fig.add_trace(go.Scatter(x=df.index, y=df['Lower'], mode='lines', line=dict(width=0), fill='tonexty', fillcolor='rgba(0, 255, 255, 0.1)', name='Cloud'), row=1, col=1)
+        fig.add_trace(go.Scatter(x=df.index, y=df['Pred'], mode='lines', name='Transformer Path', line=dict(color='#00ffff', width=2)), row=1, col=1)
+
+        # Chart 2: Divergence
+        fig.add_trace(go.Bar(x=df.index, y=df['Rolling_Z'], name='Divergence', marker_color=df['Rolling_Z'].apply(lambda x: 'green' if x>0 else 'red')), row=2, col=1)
+        fig.add_hline(y=1.8, line_dash="dot", line_color="green", row=2, col=1)
+        fig.add_hline(y=-1.8, line_dash="dot", line_color="red", row=2, col=1)
+
+        fig.update_layout(template="plotly_dark", height=800, title=f"V4 Constellation: {status}")
+        
+        info_html = f"""<div style="text-align: center; padding: 10px; background-color: {color}; color: white;"><h3>{status}</h3><p>Z: {last_z:.3f} | Price: {last_price}</p></div>"""
+        return fig, info_html, "\n".join(log_buffer)
+    else:
+        return None, "No Data", "Wait..."
+
+# --- 5. UI ---
+with gr.Blocks(title="Holographic FX V4", theme=gr.themes.Monochrome()) as app:
+    gr.Markdown("# 👁️ V4 Constellation Transformer (Multi-Pair)")
+    with gr.Row():
+        refresh_btn = gr.Button("🔄 Refresh / Scan Basket", variant="primary")
+        reset_btn = gr.Button("⚠️ HARD RESET", variant="stop")
+    with gr.Row(): status_box = gr.HTML()
+    plot = gr.Plot()
+    logs = gr.Textbox(label="Logs")
+    
+    refresh_btn.click(fn=run_analysis, outputs=[plot, status_box, logs])
+    reset_btn.click(fn=hard_reset, outputs=[plot, status_box, logs])
+    app.load(fn=run_analysis, outputs=[plot, status_box, logs])
+
+if __name__ == "__main__":
+    app.launch()