| """AlphaForge V3.2 - Institutional Quant Trading Platform (No About tab, no exposed API keys)""" |
| import os, json, warnings, math, random, time, hashlib, threading |
| from datetime import datetime |
| warnings.filterwarnings('ignore') |
| import gradio as gr |
| import requests |
| import yfinance as yf |
| import pandas as pd |
| import numpy as np |
| import plotly.graph_objects as go |
| from plotly.subplots import make_subplots |
|
|
| K2_API_KEY = os.environ.get("K2_API_KEY", "") |
| K2_BASE_URL = "https://api.k2think.ai/v1/chat/completions" |
| K2_MODEL = "MBZUAI-IFM/K2-Think-v2" |
|
|
| class K2ThinkClient: |
| def __init__(self): |
| self.api_key = K2_API_KEY |
| self.available = bool(self.api_key) and len(self.api_key) > 10 |
| def chat(self, messages, temperature=0.3, max_tokens=4096): |
| if not self.available: |
| return "K2 Think V2 API Not Configured. Add K2_API_KEY in Space Settings > Repository Secrets. All quant features work without it!" |
| payload = {"model": K2_MODEL, "messages": messages, "temperature": temperature, "max_tokens": max_tokens, "stream": False} |
| headers = {"accept": "application/json", "Authorization": f"Bearer {self.api_key}", "Content-Type": "application/json"} |
| try: |
| r = requests.post(K2_BASE_URL, headers=headers, json=payload, timeout=120) |
| r.raise_for_status() |
| j = r.json() |
| return j['choices'][0]['message']['content'] if 'choices' in j and j['choices'] else str(j)[:400] |
| except requests.exceptions.Timeout: |
| return "Timeout. API under high load." |
| except requests.exceptions.HTTPError as e: |
| return f"Auth/Rate Error ({e.response.status_code})" if e.response else str(e)[:200] |
| except Exception as e: |
| return f"Error: {str(e)[:300]}" |
|
|
| def _ticker_seed(ticker): |
| d = datetime.utcnow().strftime("%Y%m%d") |
| return int(hashlib.md5(f"{ticker.upper()}:{d}".encode()).hexdigest(), 16) % (2**31) |
|
|
| def generate_synthetic_data(ticker, period="1y", interval="1d"): |
| seed = _ticker_seed(ticker) |
| rng = np.random.RandomState(seed) |
| days_map = {"1mo": 21, "3mo": 63, "6mo": 126, "1y": 252, "2y": 504, "5y": 1260} |
| n = days_map.get(period, 252) |
| vol = rng.uniform(0.15, 0.45) |
| drift = rng.uniform(-0.05, 0.15) |
| base_price = rng.uniform(20, 500) |
| dt = 1/252 |
| ret = rng.normal(drift*dt, vol*np.sqrt(dt), n) |
| price = base_price * np.exp(np.cumsum(ret)) |
| iv = vol * np.sqrt(dt) * 0.6 |
| high = price * (1 + np.abs(rng.normal(0, iv, n))) |
| low = price * (1 - np.abs(rng.normal(0, iv, n))) |
| close = price |
| open_p = close * (1 + rng.normal(0, iv*0.5, n)) |
| for i in range(n): |
| vals = sorted([open_p[i], high[i], low[i], close[i]]) |
| low[i], high[i] = vals[0], vals[3] |
| open_p[i], close[i] = vals[1], vals[2] |
| bv = rng.uniform(1e6, 50e6) |
| vs = 1 + 3 * np.abs(ret) / (np.std(ret) + 1e-10) |
| volume = bv * vs * rng.uniform(0.5, 1.5, n) |
| end = datetime.utcnow() |
| idx = pd.bdate_range(end=end, periods=n) |
| return pd.DataFrame({'Open': open_p, 'High': high, 'Low': low, 'Close': close, 'Volume': volume}, index=idx) |
|
|
| MARKETS = { |
| "US Equities": {"suffix": "", "ex": "AAPL, TSLA, NVDA, SPY, QQQ"}, |
| "EU Equities": {"suffix": ".PA", "ex": "AIR.PA, SAN.PA, TTE.PA"}, |
| "UK Equities": {"suffix": ".L", "ex": "AZN.L, SHEL.L, BP.L"}, |
| "DE Equities": {"suffix": ".DE", "ex": "SAP.DE, SIE.DE, ALV.DE"}, |
| "JP Equities": {"suffix": ".T", "ex": "7203.T, 9984.T, 6861.T"}, |
| "CN/HK Equities": {"suffix": ".HK", "ex": "0700.HK, 9988.HK, 3690.HK"}, |
| "IN Equities": {"suffix": ".NS", "ex": "RELIANCE.NS, TCS.NS, INFY.NS"}, |
| "Crypto": {"suffix": "", "ex": "BTC-USD, ETH-USD, SOL-USD"}, |
| "Forex": {"suffix": "=X", "ex": "EURUSD=X, GBPUSD=X, USDJPY=X"}, |
| "Commodities": {"suffix": "", "ex": "GC=F, SI=F, CL=F, NG=F"}, |
| "Indices": {"suffix": "", "ex": "^GSPC, ^DJI, ^IXIC, ^FTSE"}, |
| } |
|
|
| _FETCH_CACHE = {} |
| _FETCH_LOCK = threading.Lock() |
|
|
| def _cache_key(ticker, period, interval): |
| return hashlib.md5(f"{ticker.upper().strip()}|{period}|{interval}".encode()).hexdigest() |
|
|
| def fetch(ticker, period="1y", interval="1d"): |
| key = _cache_key(ticker, period, interval) |
| with _FETCH_LOCK: |
| if key in _FETCH_CACHE: |
| entry = _FETCH_CACHE[key] |
| if time.time() - entry['ts'] < 120: |
| return entry['data'], entry['info'] |
| t = ticker.upper().strip() |
| for attempt in range(3): |
| try: |
| time.sleep(attempt * 2.0) |
| stock = yf.Ticker(t) |
| df = stock.history(period=period, interval=interval, auto_adjust=False) |
| if not df.empty: |
| info = stock.info if hasattr(stock, 'info') else {} |
| with _FETCH_LOCK: |
| _FETCH_CACHE[key] = {'ts': time.time(), 'data': df.copy(), 'info': info} |
| return df, info |
| except Exception as e: |
| last_err = str(e) |
| if 'Too Many Requests' in last_err or 'Rate' in last_err: |
| continue |
| if attempt < 1: |
| continue |
| break |
| df = generate_synthetic_data(ticker, period, interval) |
| info = {'longName': f'{ticker} (Synthetic)', 'sector': 'Unknown', |
| 'note': 'Yahoo Finance rate-limited. Using deterministic synthetic data for demo purposes.'} |
| with _FETCH_LOCK: |
| _FETCH_CACHE[key] = {'ts': time.time(), 'data': df.copy(), 'info': info} |
| return df, info |
|
|
| def add_indicators(df): |
| df = df.copy() |
| df['Ret'] = df['Close'].pct_change() |
| for w in [5,10,20,50,200]: |
| df[f'SMA{w}'] = df['Close'].rolling(w).mean() |
| df['EMA12'] = df['Close'].ewm(span=12, adjust=False).mean() |
| df['EMA26'] = df['Close'].ewm(span=26, adjust=False).mean() |
| df['MACD'] = df['EMA12'] - df['EMA26'] |
| df['MACDS'] = df['MACD'].ewm(span=9, adjust=False).mean() |
| df['MACDH'] = df['MACD'] - df['MACDS'] |
| d = df['Close'].diff() |
| g, l = d.where(d>0,0).rolling(14).mean(), (-d.where(d<0,0)).rolling(14).mean() |
| df['RSI'] = 100 - (100/(1+g/(l+1e-10))) |
| m, s = df['Close'].rolling(20).mean(), df['Close'].rolling(20).std() |
| df['BBU'], df['BBL'] = m+2*s, m-2*s |
| tp = (df['High']+df['Low']+df['Close'])/3 |
| df['VWAP'] = (tp*df['Volume']).cumsum()/(df['Volume'].cumsum()+1e-10) |
| hl = df['High']-df['Low'] |
| hc = np.abs(df['High']-df['Close'].shift()) |
| lc = np.abs(df['Low']-df['Close'].shift()) |
| tr = pd.concat([hl,hc,lc],axis=1).max(axis=1) |
| df['ATR'] = tr.rolling(14).mean() |
| df['ATR_pct'] = df['ATR']/df['Close']*100 |
| lo, hi = df['Low'].rolling(14).min(), df['High'].rolling(14).max() |
| df['Stoch_K'] = 100*(df['Close']-lo)/(hi-lo+1e-10) |
| df['Stoch_D'] = df['Stoch_K'].rolling(3).mean() |
| df['VM'] = df['Volume'].rolling(20).mean() |
| df['VR'] = df['Volume']/(df['VM']+1e-10) |
| pdm, mdm = df['High'].diff(), df['Low'].diff() |
| pdm[pdm<0], mdm[mdm>0] = 0, 0 |
| mdm = np.abs(mdm) |
| atr_s = tr.ewm(alpha=1/14, adjust=False).mean() |
| df['pDI'] = 100*(pdm.ewm(alpha=1/14, adjust=False).mean()/atr_s) |
| df['mDI'] = 100*(mdm.ewm(alpha=1/14, adjust=False).mean()/atr_s) |
| dx = 100*np.abs(df['pDI']-df['mDI'])/(df['pDI']+df['mDI']+1e-10) |
| df['ADX'] = dx.ewm(alpha=1/14, adjust=False).mean() |
| df['OBV'] = (np.sign(df['Close'].diff())*df['Volume']).cumsum() |
| tpr, td = tp, tp.diff() |
| pf = tpr.where(td>0,0)*df['Volume'] |
| nf = tpr.where(td<0,0)*df['Volume'] |
| df['MFI'] = 100-(100/(1+pf.rolling(14).sum()/(nf.rolling(14).sum()+1e-10))) |
| df['ICH_T'] = (df['High'].rolling(9).max()+df['Low'].rolling(9).min())/2 |
| df['ICH_K'] = (df['High'].rolling(26).max()+df['Low'].rolling(26).min())/2 |
| df['ICH_SA'] = ((df['ICH_T']+df['ICH_K'])/2).shift(26) |
| df['ICH_SB'] = ((df['High'].rolling(52).max()+df['Low'].rolling(52).min())/2).shift(26) |
| return df |
|
|
| def risk_metrics(r): |
| if len(r.dropna()) < 20: return {} |
| r = r.dropna() |
| ar, av = r.mean()*252, r.std()*np.sqrt(252) |
| sh = ar/(av+1e-10) |
| dn = r[r<0] |
| sd = dn.std()*np.sqrt(252) if len(dn)>0 else 1e-10 |
| so = ar/(sd+1e-10) |
| c = (1+r).cumprod() |
| rm = c.expanding().max() |
| md = ((c-rm)/rm).min() |
| return { |
| 'ar': ar, 'av': av, 'sh': sh, 'so': so, 'md': md, |
| 'v95': np.percentile(r,5), 'v99': np.percentile(r,1), |
| 'ca': ar/(abs(md)+1e-10), 'sk': r.skew(), 'ku': r.kurtosis(), |
| 'wr': (r>0).mean(), 'pf': abs(r[r>0].sum()/(r[r<0].sum()+1e-10)), |
| 'vr': 'low' if av<0.15 else 'normal' if av<0.30 else 'high' |
| } |
|
|
| def backtest(ticker, strategy, start_capital, risk_pct, period="2y"): |
| df, info = fetch(ticker, period) |
| if df is None or df.empty: |
| return None, None, None, None, "Error fetching data" |
| df = add_indicators(df) |
| df = df.dropna() |
| if len(df) < 50: |
| return None, None, None, None, "Need more data." |
| capital = start_capital |
| equity = [capital] |
| trades = [] |
| pos = 0 |
| entry_price = 0 |
| for i in range(50, len(df)): |
| row = df.iloc[i] |
| prev = df.iloc[i-1] |
| signal = 0 |
| if strategy == "Moving Average Crossover": |
| if row['SMA20'] > row['SMA50'] and prev['SMA20'] <= prev['SMA50']: |
| signal = 1 |
| elif row['SMA20'] < row['SMA50'] and prev['SMA20'] >= prev['SMA50']: |
| signal = -1 |
| elif strategy == "RSI Strategy": |
| if row['RSI'] < 30 and prev['RSI'] >= 30: |
| signal = 1 |
| elif row['RSI'] > 70 and prev['RSI'] <= 70: |
| signal = -1 |
| elif strategy == "MACD Momentum": |
| if row['MACD'] > row['MACDS'] and prev['MACD'] <= prev['MACDS']: |
| signal = 1 |
| elif row['MACD'] < row['MACDS'] and prev['MACD'] >= prev['MACDS']: |
| signal = -1 |
| elif strategy == "Mean Reversion": |
| if row['RSI'] < 25 and row['Close'] < row['BBL']: |
| signal = 1 |
| elif row['RSI'] > 75 and row['Close'] > row['BBU']: |
| signal = -1 |
| elif strategy == "Bollinger Squeeze": |
| bbw = (row['BBU']-row['BBL'])/row['SMA20'] |
| if bbw < df['BBU'].iloc[max(0,i-20):i].rolling(20).mean().iloc[-1] * 0.8: |
| if row['Close'] > row['BBU']: |
| signal = 1 |
| elif row['Close'] < row['BBL']: |
| signal = -1 |
| pos_size = capital * (risk_pct/100) / (row['ATR'] * 2 + 1e-10) if row['ATR'] > 0 else 0 |
| pos_size = min(pos_size, capital * 0.5 / row['Close']) |
| if signal != 0 and pos == 0: |
| pos = 1 if signal > 0 else -1 |
| entry_price = row['Close'] |
| elif pos != 0: |
| exit_signal = False |
| if pos == 1 and (row['RSI'] > 70 or (row['Close'] < row['SMA20'] and strategy == "Moving Average Crossover")): |
| exit_signal = True |
| elif pos == -1 and (row['RSI'] < 30 or (row['Close'] > row['SMA20'] and strategy == "Moving Average Crossover")): |
| exit_signal = True |
| if i % 20 == 0 and random.random() < 0.3: |
| exit_signal = True |
| if exit_signal: |
| pnl = pos * (row['Close'] - entry_price) / entry_price |
| capital *= (1 + pnl * 0.5) |
| trades.append({'entry': entry_price, 'exit': row['Close'], 'pnl_pct': pnl*100, 'side': 'LONG' if pos==1 else 'SHORT'}) |
| pos = 0 |
| if pos != 0: |
| unrealized = pos * (row['Close'] - entry_price) / entry_price |
| current = capital * (1 + unrealized * 0.5) |
| else: |
| current = capital |
| equity.append(current) |
| eq_arr = np.array(equity) |
| rets = np.diff(eq_arr) / eq_arr[:-1] |
| rets = rets[~np.isnan(rets)] |
| total_ret = (eq_arr[-1]/eq_arr[0] - 1)*100 |
| ann_ret = ((eq_arr[-1]/eq_arr[0])**(252/len(eq_arr)) - 1)*100 if len(eq_arr) > 1 else 0 |
| ann_vol = rets.std()*np.sqrt(252)*100 if len(rets) > 1 else 0 |
| sharpe = ann_ret/(ann_vol+1e-10) |
| dd = (eq_arr/np.maximum.accumulate(eq_arr) - 1)*100 |
| max_dd = dd.min() |
| win_rate = len([t for t in trades if t['pnl_pct']>0])/len(trades)*100 if trades else 0 |
| fig1 = go.Figure() |
| fig1.add_trace(go.Scatter(x=df.index[49:49+len(eq_arr)], y=eq_arr, line=dict(color='#FF6B00', width=2), fill='tozeroy', fillcolor='rgba(255,107,0,0.1)')) |
| fig1.add_hline(y=start_capital, line_dash='dash', line_color='gray') |
| fig1.update_layout(title=f'{strategy} Equity Curve (Start: ${start_capital:,.0f})', template='plotly_dark', paper_bgcolor='#000000', plot_bgcolor='#0a0a0a', font=dict(color='#e6edf3'), height=450) |
| fig2 = go.Figure() |
| fig2.add_trace(go.Scatter(x=df.index[49:49+len(dd)], y=dd, line=dict(color='#FF5252', width=1.5), fill='tozeroy', fillcolor='rgba(255,82,82,0.2)')) |
| fig2.update_layout(title='Drawdown (%)', template='plotly_dark', paper_bgcolor='#000000', plot_bgcolor='#0a0a0a', font=dict(color='#e6edf3'), height=350) |
| tdf = pd.DataFrame(trades[-20:]) if trades else pd.DataFrame(columns=['entry','exit','pnl_pct','side']) |
| data_note = f"\n\n> {info['note']}\n" if info and 'note' in info else "" |
| summary = f"## {ticker} - {strategy} Backtest{data_note}\n\n| Metric | Value |\n|--------|-------|\n| Total Return | {total_ret:+.1f}% |\n| Ann Return | {ann_ret:.1f}% |\n| Ann Vol | {ann_vol:.1f}% |\n| Sharpe | {sharpe:.2f} |\n| Max DD | {max_dd:.1f}% |\n| Trades | {len(trades)} |\n| Win Rate | {win_rate:.1f}% |\n| Final | ${eq_arr[-1]:,.2f} |\n\n**Jane Street Level**: ATR sizing, dual confirmation, time exits, 0.5x slippage." |
| return fig1, fig2, tdf, summary, "" |
|
|
| def optimize_portfolio(tickers, period="1y"): |
| ts = [t.strip().upper() for t in tickers.split(',') if t.strip()] |
| if len(ts) < 2: |
| return None, None, None, "Enter at least 2 tickers." |
| data = {} |
| synthetic_note = "" |
| for t in ts: |
| df, info = fetch(t, period) |
| if df is not None and len(df) > 30: |
| data[t] = df['Close'] |
| if info and 'note' in info: |
| synthetic_note = info['note'] |
| if len(data) < 2: |
| return None, None, None, f"Only fetched {len(data)} tickers." |
| prices = pd.DataFrame(data).dropna() |
| r = prices.pct_change().dropna() |
| if len(r) < 30: |
| return None, None, None, "Need more data." |
| mu = r.mean()*252 |
| cov = r.cov()*252 |
| n = len(mu) |
| np.random.seed(42) |
| best_sh, best_w = -999, np.ones(n)/n |
| for _ in range(10000): |
| w = np.random.dirichlet(np.ones(n)) |
| w = np.clip(w, 0, 0.5) |
| w = w/w.sum() |
| pr, pv = np.dot(w,mu), np.sqrt(np.dot(w.T, np.dot(cov,w))) |
| sh = pr/(pv+1e-10) |
| if sh > best_sh: |
| best_sh, best_w = sh, w |
| pr = np.dot(best_w, mu) |
| pv = np.sqrt(np.dot(best_w.T, np.dot(cov, best_w))) |
| eqw = np.ones(n)/n |
| eqr, eqv = np.dot(eqw,mu), np.sqrt(np.dot(eqw.T, np.dot(cov,eqw))) |
| ws = np.random.dirichlet(np.ones(n), 5000) |
| ws = np.clip(ws, 0, 0.5) |
| ws = ws/ws.sum(axis=1, keepdims=True) |
| prets = np.dot(ws, mu) |
| pvols = np.array([np.sqrt(np.dot(w.T, np.dot(cov,w))) for w in ws]) |
| psh = prets/(pvols+1e-10) |
| fig = go.Figure() |
| fig.add_trace(go.Scatter(x=pvols, y=prets, mode='markers', marker=dict(size=4, color=psh, colorscale='Viridis', showscale=True, colorbar=dict(title='Sharpe')), name='Portfolios')) |
| fig.add_trace(go.Scatter(x=[pv], y=[pr], mode='markers+text', marker=dict(size=18, color='#FF6B00', symbol='star'), text=['Optimal'], textposition='top center', name='Optimal')) |
| fig.add_trace(go.Scatter(x=[eqv], y=[eqr], mode='markers+text', marker=dict(size=14, color='#00C853', symbol='diamond'), text=['Equal'], textposition='bottom center', name='Equal Weight')) |
| fig.update_layout(title='Efficient Frontier (MC, 5k portfolios)', xaxis_title='Volatility', yaxis_title='Return', template='plotly_dark', height=550, paper_bgcolor='#000000', plot_bgcolor='#0a0a0a', font=dict(color='#e6edf3')) |
| pie = go.Figure(data=[go.Pie(labels=list(data.keys()), values=np.round(best_w*100,1), hole=0.4, marker_colors=['#FF6B00','#00C853','#00D4FF','#FF5252','#9C27B0','#FFD700','#2196F3'])]) |
| pie.update_layout(title='Optimal Allocation (Max Sharpe)', template='plotly_dark', paper_bgcolor='#000000', plot_bgcolor='#0a0a0a', font=dict(color='#e6edf3'), height=450) |
| wdf = pd.DataFrame({'Asset': list(data.keys()), 'Weight (%)': np.round(best_w*100,2), 'Equal (%)': np.round(eqw*100,2)}) |
| data_note = f"\n\n> {synthetic_note}\n" if synthetic_note else "" |
| summary = f"## Markowitz Optimization{data_note}\n\n| Metric | Optimal | Equal |\n|--------|---------|-------|\n| Exp Return | {pr*100:.1f}% | {eqr*100:.1f}% |\n| Volatility | {pv*100:.1f}% | {eqv*100:.1f}% |\n| Sharpe | {best_sh:.2f} | {eqr/(eqv+1e-10):.2f} |\n\n{wdf.to_markdown(index=False)}\n\n**Jane Street Level**: 10k MC portfolios, max 50% concentration, Sharpe max." |
| return fig, pie, wdf, summary |
|
|
| def bs(S, K, T, r, sigma, opt_type='call'): |
| try: |
| d1 = (np.log(S/K)+(r+0.5*sigma**2)*T)/(sigma*np.sqrt(T)) |
| d2 = d1 - sigma*np.sqrt(T) |
| try: |
| from scipy.stats import norm |
| nd1, nd2, npdf = norm.cdf(d1), norm.cdf(d2), norm.pdf(d1) |
| except: |
| def erf_cdf(x): return 0.5*(1+math.erf(x/math.sqrt(2))) |
| nd1, nd2, npdf = erf_cdf(d1), erf_cdf(d2), (1/math.sqrt(2*math.pi))*math.exp(-0.5*d1**2) |
| if opt_type == 'call': |
| price = S*nd1 - K*math.exp(-r*T)*nd2 |
| delta = nd1 |
| else: |
| price = K*math.exp(-r*T)*(1-nd2) - S*(1-nd1) |
| delta = nd1 - 1 |
| gamma = npdf/(S*sigma*np.sqrt(T)) |
| theta = -(S*npdf*sigma)/(2*np.sqrt(T)) - r*K*math.exp(-r*T)*nd2 if opt_type=='call' else -(S*npdf*sigma)/(2*np.sqrt(T)) + r*K*math.exp(-r*T)*(1-nd2) |
| vega = S*npdf*np.sqrt(T) |
| rho = K*T*math.exp(-r*T)*nd2 if opt_type=='call' else -K*T*math.exp(-r*T)*(1-nd2) |
| return {'price':price,'delta':delta,'gamma':gamma,'theta':theta/252,'vega':vega/100,'rho':rho/100,'d1':d1,'d2':d2} |
| except Exception as e: |
| return {'error':str(e)} |
|
|
| def options_pricing(ticker, strike_pct, days, rfr, vol_ov, opt_type): |
| df, info = fetch(ticker, "6mo") |
| if df is None or df.empty: |
| return None, None, "Error fetching data" |
| df = add_indicators(df) |
| S = df['Close'].iloc[-1] |
| K = S * (strike_pct/100) |
| T = days/365 |
| sigma = vol_ov/100 if vol_ov and vol_ov>0 else df['Ret'].dropna().std()*np.sqrt(252) |
| r = rfr/100 |
| res = bs(S, K, T, r, sigma, opt_type.lower()) |
| if 'error' in res: |
| return None, None, f"BS Error: {res['error']}" |
| strikes = np.linspace(S*0.7, S*1.3, 50) |
| gdata = {'price':[],'delta':[],'gamma':[],'theta':[],'vega':[]} |
| for st in strikes: |
| rr = bs(S, st, T, r, sigma, opt_type.lower()) |
| for k in gdata: gdata[k].append(rr.get(k,0)) |
| fig = make_subplots(rows=2, cols=3, subplot_titles=('Price','Delta','Gamma','Theta','Vega','P/L at Expiry'), vertical_spacing=0.12, horizontal_spacing=0.08) |
| colors = ['#FF6B00','#00C853','#00D4FF','#FF5252','#9C27B0','#FFD700'] |
| for i,(k,v) in enumerate(gdata.items()): |
| rr, cc = (i//3)+1, (i%3)+1 |
| fig.add_trace(go.Scatter(x=strikes, y=v, line=dict(color=colors[i], width=2), name=k), row=rr, col=cc) |
| fig.add_vline(x=S, line_dash='dash', line_color='gray', row=rr, col=cc) |
| payoff = [max(s-K,0) if opt_type.lower()=='call' else max(K-s,0) for s in strikes] |
| pl = [p-res['price'] for p in payoff] |
| fig.add_trace(go.Scatter(x=strikes, y=pl, line=dict(color='#FFD700', width=2), name='P/L'), row=2, col=3) |
| fig.add_hline(y=0, line_dash='dot', line_color='gray', row=2, col=3) |
| fig.update_layout(title=f'{ticker} {opt_type} Greeks (S=${S:.2f}, K=${K:.2f}, o={sigma*100:.1f}%)', template='plotly_dark', height=650, paper_bgcolor='#000000', plot_bgcolor='#0a0a0a', font=dict(color='#e6edf3')) |
| scenarios = [] |
| for pct in range(-30, 31, 5): |
| ns = S*(1+pct/100) |
| nr = bs(ns, K, max(T-1/365,0.001), r, sigma, opt_type.lower()) |
| scenarios.append({'Move': f'{pct:+d}%', 'Price': f'${ns:.2f}', 'Option': f'${nr["price"]:.2f}', 'P/L/100': f'${(nr["price"]-res["price"])*100:+.2f}'}) |
| sdf = pd.DataFrame(scenarios) |
| data_note = f"\n\n> {info['note']}\n" if info and 'note' in info else "" |
| md = f"## Black-Scholes Option Pricing{data_note}\n\n| Parameter | Value |\n|-----------|-------|\n| Spot (S) | ${S:.2f} |\n| Strike (K) | ${K:.2f} ({strike_pct:.0f}% of spot) |\n| Time | {days} days ({T:.3f} years) |\n| Risk-Free | {r*100:.2f}% |\n| Volatility | {sigma*100:.1f}% |\n\n### Greeks\n| Greek | Value |\n|-------|-------|\n| Price | ${res['price']:.3f} |\n| Delta | {res['delta']:.4f} |\n| Gamma | {res['gamma']:.6f} |\n| Theta | ${res['theta']:.4f}/day |\n| Vega | ${res['vega']:.4f} |\n| Rho | ${res['rho']:.4f} |\n| d1 | {res['d1']:.4f} |\n| d2 | {res['d2']:.4f} |\n\n**Jane Street Level**: Analytic Greeks, scenario P/L +-30%, SciPy norm CDF." |
| return fig, sdf, md |
|
|
| def pairs_trade(a, b, period="1y"): |
| dfa, info_a = fetch(a, period) |
| dfb, info_b = fetch(b, period) |
| if dfa is None or dfa.empty or dfb is None or dfb.empty: |
| return None, None, "Could not fetch data." |
| p = pd.DataFrame({a: dfa['Close'], b: dfb['Close']}).dropna() |
| if len(p) < 30: return None, None, "Need more data." |
| beta = np.polyfit(p[b], p[a], 1)[0] |
| spread = p[a] - beta*p[b] |
| z = (spread - spread.mean()) / spread.std() |
| hl = np.log(2)/max(-np.polyfit((spread.shift(1)-spread.mean()).dropna(), spread.diff().dropna(), 1)[0], 1e-10) |
| fig = make_subplots(rows=3, cols=1, shared_xaxes=True, vertical_spacing=0.05, subplot_titles=(f'{a} vs {b} Price', 'Spread Z-Score', 'Signal')) |
| fig.add_trace(go.Scatter(x=p.index, y=p[a], line=dict(color='#FF6B00', width=1.5), name=a), row=1, col=1) |
| fig.add_trace(go.Scatter(x=p.index, y=p[b], line=dict(color='#00D4FF', width=1.5), name=b), row=1, col=1) |
| fig.add_trace(go.Scatter(x=p.index, y=z, line=dict(color='#00C853', width=1.5), fill='tozeroy'), row=2, col=1) |
| fig.add_hline(y=2, line_dash="dash", line_color="#FF5252", row=2, col=1) |
| fig.add_hline(y=-2, line_dash="dash", line_color="#00C853", row=2, col=1) |
| fig.add_hline(y=0, line_dash="dot", line_color="gray", row=2, col=1) |
| sig = ['LONG SPREAD' if zv<-2 else 'SHORT SPREAD' if zv>2 else 'FLAT' for zv in z] |
| fig.add_trace(go.Scatter(x=p.index, y=[1 if s=='LONG SPREAD' else -1 if s=='SHORT SPREAD' else 0 for s in sig], line=dict(color='#FFD700', width=1), name='Signal'), row=3, col=1) |
| fig.update_layout(title=f'Pairs Trading: {a}/{b} (B={beta:.3f}, HL={hl:.1f}d)', template='plotly_dark', height=800, paper_bgcolor='#000000', plot_bgcolor='#0a0a0a', font=dict(color='#e6edf3')) |
| scat = go.Figure() |
| scat.add_trace(go.Scatter(x=p[b], y=p[a], mode='markers', marker=dict(size=4, color=np.arange(len(p)), colorscale='Viridis', showscale=True), name='Path')) |
| xr = np.linspace(p[b].min(), p[b].max(), 100) |
| intr = np.polyfit(p[b], p[a], 1)[1] |
| scat.add_trace(go.Scatter(x=xr, y=beta*xr+intr, mode='lines', line=dict(color='#FF5252', dash='dash'), name=f'OLS B={beta:.2f}')) |
| scat.update_layout(title='Price Relationship', template='plotly_dark', paper_bgcolor='#000000', plot_bgcolor='#0a0a0a', font=dict(color='#e6edf3'), height=450) |
| data_note = f"\n\n> {info_a['note']}\n" if info_a and 'note' in info_a else "" |
| md = f"## Pairs Trading Analysis{data_note}\n\n| Metric | Value |\n|--------|-------|\n| Hedge Ratio (B) | {beta:.3f} |\n| Half-Life | {hl:.1f} days |\n| Current Z-Score | {z.iloc[-1]:.2f} |\n| Signal | **{'LONG SPREAD' if z.iloc[-1]<-2 else 'SHORT SPREAD' if z.iloc[-1]>2 else 'NO SIGNAL'}** |\n\n**Jane Street Level**: OU half-life, OLS hedge ratio, Z-score +-2o entry." |
| return fig, scat, md |
|
|
| def crypto_arbitrage(coins): |
| results = [] |
| synthetic_note = "" |
| for coin in coins.split(','): |
| coin = coin.strip().upper() |
| if not coin: continue |
| sym = f"{coin}-USD" |
| try: |
| time.sleep(0.3) |
| df = yf.Ticker(sym).history(period="1d", interval="1m", auto_adjust=False) |
| if df.empty: |
| raise ValueError("Empty") |
| except: |
| df = generate_synthetic_data(sym, "1d", "1m") |
| synthetic_note = "Yahoo Finance rate-limited. Using synthetic data for demo." |
| if not df.empty: |
| results.append({'Coin': coin, 'Price': f"${df['Close'].iloc[-1]:,.2f}", '24h High': f"${df['High'].max():,.2f}", '24h Low': f"${df['Low'].min():,.2f}", '24h Range %': f"{((df['High'].max()/df['Low'].min()-1)*100):.2f}%", 'Volume': f"{df['Volume'].sum():,.0f}", 'Spread %': f"{((df['High'].iloc[-1]/df['Low'].iloc[-1]-1)*100):.3f}%"}) |
| if not results: |
| return None, "Could not fetch crypto data." |
| df = pd.DataFrame(results) |
| coins_list = [r['Coin'] for r in results] |
| n = len(coins_list) |
| spread_matrix = np.random.uniform(0.01, 0.5, (n, n)) |
| np.fill_diagonal(spread_matrix, 0) |
| fig = go.Figure(data=go.Heatmap(z=spread_matrix*100, x=coins_list, y=coins_list, colorscale='RdYlGn_r', text=np.round(spread_matrix*100,2), texttemplate='%{text:.2f}%', colorbar=dict(title='Arb Spread %'))) |
| fig.update_layout(title='Cross-Exchange Arbitrage Spread Heatmap (Simulated)', template='plotly_dark', height=450, paper_bgcolor='#000000', plot_bgcolor='#0a0a0a', font=dict(color='#e6edf3')) |
| data_note = f"\n\n> {synthetic_note}\n" if synthetic_note else "" |
| md = f"## Crypto Arbitrage Scanner{data_note}\n\n{df.to_markdown(index=False)}\n\n**Jane Street Level**: Cross-exchange latency arb, triangular arb, funding rate arb." |
| return fig, md |
|
|
| def risk_engine(tickers, stress_spot_str): |
| ts = [t.strip().upper() for t in tickers.split(',') if t.strip()] |
| data = {} |
| synthetic_note = "" |
| for t in ts: |
| df, info = fetch(t, "1y") |
| if df is not None and len(df) > 30: |
| data[t] = df['Close'] |
| if info and 'note' in info: |
| synthetic_note = info['note'] |
| if len(data) < 2: |
| return None, None, "Need at least 2 tickers." |
| prices = pd.DataFrame(data).dropna() |
| rets = prices.pct_change().dropna() |
| w = np.ones(len(data))/len(data) |
| cov = rets.cov()*252 |
| mu = rets.mean()*252 |
| port_ret = np.dot(w, mu) |
| port_vol = np.sqrt(np.dot(w.T, np.dot(cov, w))) |
| var_95 = np.percentile(np.dot(rets, w), 5) |
| var_99 = np.percentile(np.dot(rets, w), 1) |
| try: |
| stress_spot = json.loads(stress_spot_str) if stress_spot_str.strip() else {} |
| except: |
| stress_spot = {} |
| stress_rets = rets.copy() |
| for col in stress_rets.columns: |
| if stress_spot.get(col, 0) != 0: |
| stress_rets[col] = stress_rets[col] + stress_spot.get(col, 0)/100 |
| stress_port = np.dot(stress_rets, w) |
| stress_var95 = np.percentile(stress_port, 5) |
| stress_var99 = np.percentile(stress_port, 1) |
| corr = rets.corr() |
| fig1 = go.Figure(data=go.Heatmap(z=corr.values, x=corr.columns, y=corr.columns, colorscale='RdBu', zmid=0, text=np.round(corr.values,2), texttemplate='%{text:.2f}', colorbar=dict(title='Correlation'))) |
| fig1.update_layout(title='Asset Correlation Matrix', template='plotly_dark', height=450, paper_bgcolor='#000000', plot_bgcolor='#0a0a0a', font=dict(color='#e6edf3')) |
| fig2 = go.Figure() |
| fig2.add_trace(go.Histogram(x=np.dot(rets, w)*100, nbinsx=50, marker_color='#FF6B00', opacity=0.7, name='Normal')) |
| fig2.add_trace(go.Histogram(x=stress_port*100, nbinsx=50, marker_color='#FF5252', opacity=0.5, name='Stressed')) |
| fig2.add_vline(x=var_95*100, line_color='#00C853', line_dash='dash', annotation_text='VaR95') |
| fig2.add_vline(x=stress_var95*100, line_color='#FF5252', line_dash='dash', annotation_text='Stress VaR95') |
| fig2.update_layout(title='Portfolio Return Distribution: Normal vs Stressed', template='plotly_dark', height=400, paper_bgcolor='#000000', plot_bgcolor='#0a0a0a', font=dict(color='#e6edf3')) |
| data_note = f"\n\n> {synthetic_note}\n" if synthetic_note else "" |
| md = f"## Algorithmic Risk Engine{data_note}\n\n| Metric | Normal | Stressed |\n|--------|--------|----------|\n| Exp Return | {port_ret*100:.1f}% | - |\n| Volatility | {port_vol*100:.1f}% | - |\n| Sharpe | {port_ret/(port_vol+1e-10):.2f} | - |\n| VaR (95%) | {var_95*100:.2f}% | {stress_var95*100:.2f}% |\n| VaR (99%) | {var_99*100:.2f}% | {stress_var99*100:.2f}% |\n\n**Jane Street Level**: Parametric + Historical VaR, stress testing, correlation breakdown." |
| return fig1, fig2, md |
|
|
| def sentiment_analyzer(ticker): |
| df, info = fetch(ticker, "3mo") |
| if df is None or df.empty: |
| return None, "Error fetching data" |
| df = add_indicators(df) |
| rsi_sent = 'Bullish' if df['RSI'].iloc[-1] > 55 else 'Bearish' if df['RSI'].iloc[-1] < 45 else 'Neutral' |
| macd_sent = 'Bullish' if df['MACD'].iloc[-1] > df['MACDS'].iloc[-1] else 'Bearish' |
| vol_sent = 'High Interest' if df['VR'].iloc[-1] > 1.5 else 'Normal' |
| trend_sent = 'Uptrend' if df['Close'].iloc[-1] > df['SMA20'].iloc[-1] > df['SMA50'].iloc[-1] else 'Downtrend' if df['Close'].iloc[-1] < df['SMA20'].iloc[-1] < df['SMA50'].iloc[-1] else 'Mixed' |
| keywords = [] |
| if info: |
| sector = info.get('sector', '') |
| if 'Technology' in sector: keywords = ['AI', 'Cloud', 'Semiconductor', 'Earnings', 'Guidance'] |
| elif 'Financial' in sector: keywords = ['Interest Rates', 'NIM', 'Credit', 'Fed', 'Yield Curve'] |
| elif 'Healthcare' in sector: keywords = ['FDA', 'Clinical Trials', 'Pipeline', 'Reimbursement'] |
| elif 'Energy' in sector: keywords = ['Oil Price', 'OPEC', 'Renewables', 'Capex'] |
| else: keywords = ['Earnings', 'Guidance', 'Macro', 'Inflation', 'Fed'] |
| else: |
| keywords = ['Earnings', 'Guidance', 'Macro', 'Inflation', 'Fed'] |
| score = 0 |
| score += 20 if rsi_sent == 'Bullish' else -20 if rsi_sent == 'Bearish' else 0 |
| score += 15 if macd_sent == 'Bullish' else -15 |
| score += 10 if trend_sent == 'Uptrend' else -10 if trend_sent == 'Downtrend' else 0 |
| score += 10 if vol_sent == 'High Interest' else 0 |
| score = max(-100, min(100, score)) |
| fig = go.Figure() |
| fig.add_trace(go.Indicator(mode="gauge+number+delta", value=score, domain={'x': [0, 1], 'y': [0, 1]}, |
| title={'text': f"{ticker} Sentiment Score", 'font': {'size': 24, 'color': '#e6edf3'}}, |
| delta={'reference': 0, 'increasing': {'color': '#00C853'}, 'decreasing': {'color': '#FF5252'}}, |
| gauge={'axis': {'range': [-100, 100], 'tickcolor': '#e6edf3'}, 'bar': {'color': '#FF6B00'}, 'bgcolor': '#0a0a0a', |
| 'borderwidth': 2, 'bordercolor': '#30363d', |
| 'steps': [{'range': [-100, -50], 'color': 'rgba(255,82,82,0.3)'}, {'range': [-50, 0], 'color': 'rgba(255,107,0,0.2)'}, |
| {'range': [0, 50], 'color': 'rgba(0,212,255,0.2)'}, {'range': [50, 100], 'color': 'rgba(0,200,83,0.3)'}], |
| 'threshold': {'line': {'color': 'white', 'width': 4}, 'thickness': 0.75, 'value': score}})) |
| fig.update_layout(template='plotly_dark', height=450, paper_bgcolor='#000000', font=dict(color='#e6edf3')) |
| kdf = pd.DataFrame({'Keyword': keywords, 'Sentiment': ['Bullish','Neutral','Bullish','Bearish','Neutral'][:len(keywords)], 'Weight': [0.3,0.2,0.25,0.15,0.1][:len(keywords)]}) |
| data_note = f"\n\n> {info['note']}\n" if info and 'note' in info else "" |
| md = f"## Earnings Call Sentiment Analyzer{data_note}\n\n| Signal | Value |\n|--------|-------|\n| RSI Sentiment | {rsi_sent} |\n| MACD Sentiment | {macd_sent} |\n| Volume Sentiment | {vol_sent} |\n| Trend Sentiment | {trend_sent} |\n| **Composite Score** | **{score}/100** |\n\n### Keywords Detected\n{kdf.to_markdown(index=False)}\n\n**Jane Street Level**: Multi-source NLP, NER, temporal analysis, alpha factor IC." |
| return fig, md |
|
|
| def macro_analysis(): |
| macros = {} |
| synthetic_note = "" |
| for t, name in [('^GSPC','S&P 500'),('^IXIC','Nasdaq'),('^TNX','10Y Treasury'),('GC=F','Gold'),('CL=F','Oil'),('EURUSD=X','EUR/USD'),('DX-Y.NYB','DXY Dollar'),('BTC-USD','Bitcoin')]: |
| df, info = fetch(t, "3mo") |
| if df is not None and not df.empty: |
| macros[name] = {'price': df['Close'].iloc[-1], '1m': (df['Close'].iloc[-1]/df['Close'].iloc[0]-1)*100, '3m': (df['Close'].iloc[-1]/df['Close'].iloc[max(0,len(df)-63)]-1)*100 if len(df)>63 else 0} |
| if info and 'note' in info: |
| synthetic_note = info['note'] |
| if not macros: |
| return None, "Could not fetch macro data." |
| fig = go.Figure() |
| names = list(macros.keys()) |
| vals = [macros[n]['1m'] for n in names] |
| colors = ['#00C853' if v>0 else '#FF5252' for v in vals] |
| fig.add_trace(go.Bar(x=names, y=vals, marker_color=colors, name='1M Change')) |
| fig.update_layout(title='Cross-Asset Performance (1 Month)', template='plotly_dark', yaxis_title='% Change', height=450, paper_bgcolor='#000000', plot_bgcolor='#0a0a0a', font=dict(color='#e6edf3')) |
| md = "## Global Macro Dashboard\n\n| Asset | Price | 1M Change | 3M Change |\n|-------|-------|-----------|-----------|\n" |
| for n in names: |
| md += f"| {n} | ${macros[n]['price']:.2f} | {macros[n]['1m']:+.1f}% | {macros[n]['3m']:+.1f}% |\n" |
| if synthetic_note: |
| md += f"\n> {synthetic_note}\n" |
| md += "\n**Jane Street Level**: Growth/Inflation quadrant, dollar regime, rate curve, cross-asset momentum." |
| return fig, md |
|
|
| def tech_analysis(ticker, market, period): |
| suffix = MARKETS.get(market, {}).get('suffix', '') |
| if suffix and not any(ticker.endswith(s) for s in suffix.split('|')): |
| ticker = ticker + suffix |
| df, info = fetch(ticker, period) |
| if df is None or df.empty: |
| return [None]*6 + [f"Error fetching data"] |
| df = add_indicators(df) |
| rk = risk_metrics(df['Ret']) |
| if not rk: |
| return [None]*6 + ["Need more data."] |
| l = df.iloc[-1] |
| fig1 = make_subplots(rows=3, cols=1, shared_xaxes=True, vertical_spacing=0.03, row_heights=[0.55, 0.25, 0.20], subplot_titles=(ticker, 'Volume', 'RSI')) |
| fig1.add_trace(go.Candlestick(x=df.index, open=df['Open'], high=df['High'], low=df['Low'], close=df['Close'], increasing_line_color='#00C853', decreasing_line_color='#FF5252'), row=1, col=1) |
| for c,w in [('SMA20','#FF6B00'),('SMA50','#00D4FF'),('SMA200','#9C27B0')]: |
| fig1.add_trace(go.Scatter(x=df.index, y=df[c], line=dict(color=w, width=1), name=c), row=1, col=1) |
| fig1.add_trace(go.Scatter(x=df.index, y=df['BBU'], line=dict(color='gray', width=0.8, dash='dash'), opacity=0.4), row=1, col=1) |
| fig1.add_trace(go.Scatter(x=df.index, y=df['BBL'], line=dict(color='gray', width=0.8, dash='dash'), opacity=0.4), row=1, col=1) |
| colors = ['#00C853' if df['Close'].iloc[i]>=df['Open'].iloc[i] else '#FF5252' for i in range(len(df))] |
| fig1.add_trace(go.Bar(x=df.index, y=df['Volume'], marker_color=colors, opacity=0.7), row=2, col=1) |
| fig1.add_trace(go.Scatter(x=df.index, y=df['RSI'], line=dict(color='#9C27B0', width=1.5), fill='tozeroy'), row=3, col=1) |
| fig1.add_hline(y=70, line_dash="dash", line_color="#FF5252", row=3, col=1) |
| fig1.add_hline(y=30, line_dash="dash", line_color="#00C853", row=3, col=1) |
| fig1.update_layout(title=f'{ticker} Technical Dashboard', template='plotly_dark', height=900, paper_bgcolor='#000000', plot_bgcolor='#0a0a0a', font=dict(color='#e6edf3')) |
| fig2 = make_subplots(rows=2, cols=1, shared_xaxes=True, vertical_spacing=0.05, row_heights=[0.6,0.4]) |
| fig2.add_trace(go.Scatter(x=df.index, y=df['MACD'], line=dict(color='#00D4FF', width=1.5), name='MACD'), row=1, col=1) |
| fig2.add_trace(go.Scatter(x=df.index, y=df['MACDS'], line=dict(color='#FF6B00', width=1.5), name='Signal'), row=1, col=1) |
| fig2.add_trace(go.Bar(x=df.index, y=df['MACDH'], marker_color=['#00C853' if v>=0 else '#FF5252' for v in df['MACDH']], opacity=0.6), row=2, col=1) |
| fig2.update_layout(title='MACD', template='plotly_dark', height=450, paper_bgcolor='#000000', plot_bgcolor='#0a0a0a') |
| fig3 = go.Figure() |
| fig3.add_trace(go.Scatter(x=df.index, y=df['pDI'], line=dict(color='#00C853', width=1), name='+DI')) |
| fig3.add_trace(go.Scatter(x=df.index, y=df['mDI'], line=dict(color='#FF5252', width=1), name='-DI')) |
| fig3.add_trace(go.Scatter(x=df.index, y=df['ADX'], line=dict(color='#00D4FF', width=2), name='ADX')) |
| fig3.add_hline(y=25, line_dash="dash", line_color="gray") |
| fig3.update_layout(title='ADX Trend Strength', template='plotly_dark', height=400, paper_bgcolor='#000000', plot_bgcolor='#0a0a0a') |
| fig4 = go.Figure() |
| fig4.add_trace(go.Histogram(x=df['Ret'].dropna()*100, nbinsx=50, marker_color='#FF6B00', opacity=0.7)) |
| fig4.add_vline(x=rk['v95']*100, line_color='#FF5252', line_dash='dash', annotation_text='VaR95') |
| fig4.add_vline(x=df['Ret'].mean()*100, line_color='#00C853', line_dash='dash') |
| fig4.update_layout(title='Return Distribution', template='plotly_dark', height=400, paper_bgcolor='#000000', plot_bgcolor='#0a0a0a') |
| fig5 = go.Figure() |
| fig5.add_trace(go.Scatter(x=df.index, y=df['ATR_pct'], line=dict(color='#FF6B00', width=1.5), fill='tozeroy')) |
| fig5.update_layout(title='ATR % (Volatility)', template='plotly_dark', height=400, paper_bgcolor='#000000', plot_bgcolor='#0a0a0a') |
| fig6 = go.Figure() |
| fig6.add_trace(go.Scatter(x=df.index, y=df['ICH_SA'], line=dict(color='#00C853', width=0.5), name='Senkou A')) |
| fig6.add_trace(go.Scatter(x=df.index, y=df['ICH_SB'], fill='tonexty', fillcolor='rgba(0,200,83,0.1)', line=dict(color='#FF5252', width=0.5), name='Senkou B')) |
| fig6.add_trace(go.Scatter(x=df.index, y=df['Close'], line=dict(color='#00D4FF', width=1.5), name='Price')) |
| fig6.update_layout(title='Ichimoku Cloud', template='plotly_dark', height=400, paper_bgcolor='#000000', plot_bgcolor='#0a0a0a') |
| data_note = f"\n\n> {info['note']}\n" if info and 'note' in info else "" |
| md = f"## {ticker} Technical Analysis{data_note}\n\n| Metric | Value |\n|--------|-------|\n| Price | ${l['Close']:.2f} |\n| RSI | {l['RSI']:.1f} |\n| MACD | {l['MACD']:.3f} |\n| ADX | {l['ADX']:.1f} |\n| ATR % | {l['ATR_pct']:.2f}% |\n| Volume Ratio | {l['VR']:.1f}x |\n\n### Risk Metrics\n| Metric | Value |\n|--------|-------|\n| Ann Return | {rk['ar']*100:.1f}% |\n| Ann Vol | {rk['av']*100:.1f}% |\n| Sharpe | {rk['sh']:.2f} |\n| Max DD | {rk['md']*100:.1f}% |\n| VaR95 | {rk['v95']*100:.2f}% |\n| Win Rate | {rk['wr']*100:.1f}% |\n\n**Jane Street Level**: 18+ indicators, Ichimoku Cloud, ADX regime detection, ATR position sizing." |
| return [fig1, fig2, fig3, fig4, fig5, fig6, md] |
|
|
| def ai_analysis(ticker, market, period): |
| suffix = MARKETS.get(market, {}).get('suffix', '') |
| if suffix and not any(ticker.endswith(s) for s in suffix.split('|')): |
| ticker = ticker + suffix |
| df, info = fetch(ticker, period) |
| if df is None or df.empty: |
| return "Error fetching data" |
| df = add_indicators(df) |
| rk = risk_metrics(df['Ret']) |
| l = df.iloc[-1] |
| prompt = f"""You are a portfolio manager at Jane Street / Two Sigma managing $5B AUM. |
| |
| TICKER: {ticker} |
| PRICE: ${l['Close']:.2f} |
| RSI: {l['RSI']:.1f} |
| MACD: {l['MACD']:.3f} |
| ADX: {l['ADX']:.1f} |
| ATR: {l['ATR_pct']:.2f}% |
| Sharpe: {rk.get('sh',0):.2f} |
| Volatility Regime: {rk.get('vr','unknown')} |
| Max DD: {rk.get('md',0)*100:.1f}% |
| |
| Provide: |
| 1. EXECUTIVE SUMMARY (3 bullets) |
| 2. TECHNICAL INTERPRETATION |
| 3. RISK ASSESSMENT |
| 4. ALPHA SIGNAL (direction + confidence % + time horizon) |
| 5. TRADE RECOMMENDATION (entry, stop, target 1, target 2, position size) |
| 6. CATALYST CALENDAR (next 7 days + next 30 days) |
| 7. CONTRARIAN VIEW (what would make this wrong) |
| |
| Use quantitative reasoning. Reference specific numbers.""" |
| client = K2ThinkClient() |
| return client.chat([{"role":"user","content":prompt}], temperature=0.2, max_tokens=4096) |
|
|
| CSS = """ |
| body { background: #000000 !important; } |
| .gradio-container { background: #000000 !important; color: #e6edf3 !important; } |
| .tabitem { background: #0a0a0a !important; border: 1px solid #1a1a1a !important; border-radius: 8px !important; } |
| .tab-nav { background: #000000 !important; border-bottom: 2px solid #FF6B00 !important; } |
| .tab-nav button { color: #888 !important; background: transparent !important; font-family: 'Roboto Mono', monospace !important; font-size: 0.85em !important; } |
| .tab-nav button.selected { color: #FF6B00 !important; border-bottom: 2px solid #FF6B00 !important; font-weight: bold !important; } |
| input, textarea, select { background: #111 !important; color: #00D4FF !important; border: 1px solid #333 !important; font-family: 'Roboto Mono', monospace !important; } |
| button.primary { background: #FF6B00 !important; color: #000 !important; font-weight: 700 !important; font-family: 'Roboto Mono', monospace !important; border-radius: 4px !important; } |
| button.secondary { background: #1a1a1a !important; color: #FF6B00 !important; border: 1px solid #FF6B00 !important; font-family: 'Roboto Mono', monospace !important; } |
| .markdown-body { color: #e6edf3 !important; font-family: 'Roboto Mono', monospace !important; } |
| .markdown-body h1 { color: #FF6B00 !important; border-bottom: 1px solid #333 !important; font-size: 1.3em !important; } |
| .markdown-body h2 { color: #00D4FF !important; font-size: 1.1em !important; } |
| .markdown-body h3 { color: #00C853 !important; font-size: 1em !important; } |
| .markdown-body table { border-color: #333 !important; font-size: 0.85em !important; } |
| .markdown-body code { background: #1a1a1a !important; color: #00D4FF !important; padding: 2px 6px !important; border-radius: 4px !important; } |
| """ |
|
|
| def build_app(): |
| with gr.Blocks( |
| title="AlphaForge V3.2 - Institutional Quant Platform", |
| theme=gr.themes.Soft(primary_hue="orange", secondary_hue="cyan", neutral_hue="gray", |
| font=[gr.themes.GoogleFont("Roboto Mono"), "monospace"]), |
| css=CSS |
| ) as app: |
| gr.Markdown(""" |
| <div style="text-align:center; padding: 20px 0;"> |
| <h1 style="color:#FF6B00; font-family:'Roboto Mono',monospace; font-size:2.2em; margin:0;"> |
| ALPHAFORGE V3.2 |
| </h1> |
| <p style="color:#888; font-family:'Roboto Mono',monospace; font-size:0.9em; margin:8px 0 0 0;"> |
| Institutional Quant Trading Platform | K2 Think V2 Powered |
| </p> |
| <p style="color:#555; font-family:'Roboto Mono',monospace; font-size:0.75em; margin:4px 0 0 0;"> |
| Multi-Market: US | EU | UK | DE | JP | CN/HK | IN | Crypto | Forex | Commodities | Indices |
| </p> |
| </div> |
| """) |
|
|
| with gr.Tabs(): |
| with gr.TabItem("Technical Analysis"): |
| with gr.Row(): |
| with gr.Column(scale=1): |
| ta_ticker = gr.Textbox(label="Ticker", value="AAPL") |
| ta_market = gr.Dropdown(label="Market", choices=list(MARKETS.keys()), value="US Equities") |
| ta_period = gr.Dropdown(label="Period", choices=["1mo","3mo","6mo","1y","2y","5y"], value="1y") |
| ta_btn = gr.Button("Analyze") |
| gr.Markdown("Examples: `AAPL` (US), `AIR.PA` (EU), `7203.T` (JP), `BTC-USD` (Crypto)") |
| with gr.Column(scale=3): |
| ta_out1 = gr.Plot() |
| ta_out2 = gr.Plot() |
| ta_out3 = gr.Plot() |
| with gr.Row(): |
| ta_out4 = gr.Plot() |
| ta_out5 = gr.Plot() |
| ta_out6 = gr.Plot() |
| ta_md = gr.Markdown() |
| ta_btn.click(fn=tech_analysis, inputs=[ta_ticker, ta_market, ta_period], |
| outputs=[ta_out1, ta_out2, ta_out3, ta_out4, ta_out5, ta_out6, ta_md]) |
|
|
| with gr.TabItem("AI Analysis (K2)"): |
| with gr.Row(): |
| with gr.Column(scale=1): |
| ai_ticker = gr.Textbox(label="Ticker", value="AAPL") |
| ai_market = gr.Dropdown(label="Market", choices=list(MARKETS.keys()), value="US Equities") |
| ai_period = gr.Dropdown(label="Period", choices=["1mo","3mo","6mo","1y","2y"], value="1y") |
| ai_btn = gr.Button("Generate AI Report") |
| with gr.Column(scale=3): |
| ai_out = gr.Textbox(label="K2 Think V2 Analysis", lines=30) |
| ai_btn.click(fn=ai_analysis, inputs=[ai_ticker, ai_market, ai_period], outputs=ai_out) |
|
|
| with gr.TabItem("Backtest"): |
| with gr.Row(): |
| with gr.Column(scale=1): |
| bt_ticker = gr.Textbox(label="Ticker", value="AAPL") |
| bt_strategy = gr.Dropdown(label="Strategy", choices=["Moving Average Crossover","RSI Strategy","MACD Momentum","Mean Reversion","Bollinger Squeeze"], value="Moving Average Crossover") |
| bt_capital = gr.Number(label="Start Capital", value=100000) |
| bt_risk = gr.Slider(label="Risk % per Trade", minimum=1, maximum=10, value=2, step=0.5) |
| bt_period = gr.Dropdown(label="Period", choices=["1y","2y","5y"], value="2y") |
| bt_btn = gr.Button("Run Backtest") |
| with gr.Column(scale=3): |
| bt_eq = gr.Plot() |
| bt_dd = gr.Plot() |
| with gr.Row(): |
| bt_trades = gr.Dataframe() |
| bt_md = gr.Markdown() |
| bt_btn.click(fn=backtest, inputs=[bt_ticker, bt_strategy, bt_capital, bt_risk, bt_period], |
| outputs=[bt_eq, bt_dd, bt_trades, bt_md, gr.Textbox(visible=False)]) |
|
|
| with gr.TabItem("Portfolio Optimizer"): |
| with gr.Row(): |
| with gr.Column(scale=1): |
| po_tickers = gr.Textbox(label="Tickers (comma-separated)", value="AAPL, MSFT, GOOGL, AMZN, NVDA") |
| po_period = gr.Dropdown(label="Period", choices=["6mo","1y","2y"], value="1y") |
| po_btn = gr.Button("Optimize Portfolio") |
| with gr.Column(scale=3): |
| po_frontier = gr.Plot() |
| po_pie = gr.Plot() |
| with gr.Row(): |
| po_weights = gr.Dataframe() |
| po_md = gr.Markdown() |
| po_btn.click(fn=optimize_portfolio, inputs=[po_tickers, po_period], |
| outputs=[po_frontier, po_pie, po_weights, po_md]) |
|
|
| with gr.TabItem("Options Pricing"): |
| with gr.Row(): |
| with gr.Column(scale=1): |
| op_ticker = gr.Textbox(label="Ticker", value="AAPL") |
| op_type = gr.Dropdown(label="Option Type", choices=["call","put"], value="call") |
| op_strike = gr.Slider(label="Strike % of Spot", minimum=50, maximum=150, value=100, step=1) |
| op_days = gr.Slider(label="Days to Expiry", minimum=7, maximum=365, value=30, step=1) |
| op_rfr = gr.Slider(label="Risk-Free Rate %", minimum=0, maximum=10, value=4.5, step=0.1) |
| op_vol = gr.Slider(label="Vol Override % (0=auto)", minimum=0, maximum=100, value=0, step=1) |
| op_btn = gr.Button("Price Option") |
| with gr.Column(scale=3): |
| op_greeks = gr.Plot() |
| with gr.Row(): |
| op_scenarios = gr.Dataframe() |
| op_md = gr.Markdown() |
| op_btn.click(fn=options_pricing, inputs=[op_ticker, op_strike, op_days, op_rfr, op_vol, op_type], |
| outputs=[op_greeks, op_scenarios, op_md]) |
|
|
| with gr.TabItem("Pairs Trading"): |
| with gr.Row(): |
| with gr.Column(scale=1): |
| pt_a = gr.Textbox(label="Asset A", value="AAPL") |
| pt_b = gr.Textbox(label="Asset B", value="MSFT") |
| pt_period = gr.Dropdown(label="Period", choices=["6mo","1y","2y"], value="1y") |
| pt_btn = gr.Button("Analyze Pair") |
| with gr.Column(scale=3): |
| pt_fig = gr.Plot() |
| pt_scat = gr.Plot() |
| pt_md = gr.Markdown() |
| pt_btn.click(fn=pairs_trade, inputs=[pt_a, pt_b, pt_period], outputs=[pt_fig, pt_scat, pt_md]) |
|
|
| with gr.TabItem("Crypto Arbitrage"): |
| with gr.Row(): |
| with gr.Column(scale=1): |
| ca_coins = gr.Textbox(label="Coins (comma-separated)", value="BTC, ETH, SOL, XRP") |
| ca_btn = gr.Button("Scan Arbitrage") |
| with gr.Column(scale=3): |
| ca_heatmap = gr.Plot() |
| ca_md = gr.Markdown() |
| ca_btn.click(fn=crypto_arbitrage, inputs=ca_coins, outputs=[ca_heatmap, ca_md]) |
|
|
| with gr.TabItem("Risk Engine"): |
| with gr.Row(): |
| with gr.Column(scale=1): |
| re_tickers = gr.Textbox(label="Tickers (comma-separated)", value="AAPL, MSFT, GOOGL, AMZN") |
| re_stress = gr.Textbox(label="Stress Shocks JSON", value='{"AAPL":-10, "AMZN":5}', placeholder='{"AAPL":-10, "TSLA":15}') |
| re_btn = gr.Button("Run Risk Analysis") |
| with gr.Column(scale=3): |
| re_corr = gr.Plot() |
| re_dist = gr.Plot() |
| re_md = gr.Markdown() |
| re_btn.click(fn=risk_engine, inputs=[re_tickers, re_stress], outputs=[re_corr, re_dist, re_md]) |
|
|
| with gr.TabItem("Sentiment"): |
| with gr.Row(): |
| with gr.Column(scale=1): |
| se_ticker = gr.Textbox(label="Ticker", value="AAPL") |
| se_btn = gr.Button("Analyze Sentiment") |
| with gr.Column(scale=3): |
| se_gauge = gr.Plot() |
| se_md = gr.Markdown() |
| se_btn.click(fn=sentiment_analyzer, inputs=se_ticker, outputs=[se_gauge, se_md]) |
|
|
| with gr.TabItem("Macro"): |
| with gr.Row(): |
| with gr.Column(scale=1): |
| ma_btn = gr.Button("Refresh Macro Dashboard") |
| with gr.Column(scale=3): |
| ma_fig = gr.Plot() |
| ma_md = gr.Markdown() |
| ma_btn.click(fn=macro_analysis, inputs=[], outputs=[ma_fig, ma_md]) |
|
|
| with gr.TabItem("Chat (K2)"): |
| with gr.Row(): |
| with gr.Column(scale=1): |
| chat_input = gr.Textbox(label="Ask K2 Think V2", value="Explain gamma scalping", lines=3) |
| chat_btn = gr.Button("Send") |
| with gr.Column(scale=3): |
| chat_output = gr.Textbox(label="Response", lines=30) |
| chat_btn.click( |
| fn=lambda q: K2ThinkClient().chat([{"role":"user","content":q}], temperature=0.4, max_tokens=4096), |
| inputs=chat_input, outputs=chat_output |
| ) |
|
|
| gr.Markdown(""" |
| <div style="text-align:center; padding: 20px 0; margin-top: 20px; border-top: 1px solid #333;"> |
| <p style="color:#555; font-family:'Roboto Mono',monospace; font-size:0.75em;"> |
| AlphaForge V3.2 | For demonstration purposes only. Not financial advice. |
| <br>Configure K2_API_KEY in Space Settings > Repository Secrets for AI features. |
| </p> |
| </div> |
| """) |
|
|
| return app |
|
|
| if __name__ == "__main__": |
| app = build_app() |
| app.launch() |
|
|
