Feature: Banker's Advisor Upgrade (V2)

main.py

@@ -34,6 +34,11 @@ BENCHMARK = '^GSPC'
 # FINANCIAL LOGIC (Ported from Streamlit App)
 # ==============================================================================
 
+
+# ==============================================================================
+# FINANCIAL LOGIC
+# ==============================================================================
+
 def get_session():
     import requests
     session = requests.Session()
@@ -42,32 +47,37 @@ def get_session():
     })
     return session
 
+def fetch_macro_data():
+    """Fetches VIX and 10Y Treasury Yield"""
+    try:
+        # ^VIX: Volatility, ^TNX: 10Y Yield
+        macro = yf.download(['^VIX', '^TNX'], period="5d", progress=False)
+        if macro.empty: return {'vix': 15.0, 'tnx': 4.0} # Fallback
+        
+        # Handle MultiIndex columns if present
+        if isinstance(macro.columns, pd.MultiIndex):
+            vix = macro['Adj Close']['^VIX'].iloc[-1] if '^VIX' in macro['Adj Close'] else 15.0
+            tnx = macro['Adj Close']['^TNX'].iloc[-1] if '^TNX' in macro['Adj Close'] else 4.0
+        else:
+            # Fallback for flat structure/failures
+            vix = macro['Adj Close'].iloc[-1] if 'Adj Close' in macro else 15.0
+            tnx = 4.0
+            
+        return {'vix': float(vix), 'tnx': float(tnx)}
+    except:
+        return {'vix': 18.5, 'tnx': 4.2} # Safe defaults
+
 def fetch_market_data(tickers):
     try:
         all_tickers = tickers + [BENCHMARK]
-        # yfinance download with session
-        # Use simple separate fetching if bulk fails, but bulk is better.
-        # We need to monkeypatch or use the session parameter if available in newer yf
-        # For compatibility with 0.2.x, we assume yf handles requests internally or we just retry.
-        
-        # NOTE: yfinance 0.2+ is strict. We use a context manager or explicit overrides if needed.
-        # But for 'download', it uses shared session. We can try setting it globally if needed, 
-        # but passing it to Ticker is easier. for download(), it's harder.
-        
-        # Workaround: Use Ticker cluster or just standard download but catch empty.
-        # The best fix for HF Spaces is usually just a user agent.
-        
-        # Let's try requests_cache or just standard requests patch if yf exposes it.
-        # yf.download doesn't accept 'session' directly in all versions.
-        # We will try to rely on the library's default behavior but with a retry/fallback.
-        
-        # FALLBACK STRATEGY: Fetch individually if bulk fails
         data = yf.download(all_tickers, period="6mo", progress=False)
         
-        if data.empty:
-            raise ValueError("Empty data returned")
+        if data.empty: raise ValueError("Empty data returned")
 
-        if 'Adj Close' in data.columns:
+        # Handle yfinance 0.2+ MultiIndex columns
+        if isinstance(data.columns, pd.MultiIndex):
+             prices = data['Adj Close']
+        elif 'Adj Close' in data.columns:
             prices = data['Adj Close']
         elif 'Close' in data.columns:
             prices = data['Close']
@@ -76,78 +86,75 @@ def fetch_market_data(tickers):
         return prices
     except Exception as e:
         print(f"Error fetching data: {e}")
-        # Panic Fallback: Generate dummy data if real data fails (to prevent app crash on demo)
-        # This keeps the UI alive ("Show must go on")
+        # Panic Fallback
         dates = pd.date_range(end=datetime.today(), periods=120)
         dummy_data = {}
         for t in tickers + [BENCHMARK]:
-            # Random walk
             start = 150 if t == BENCHMARK else 100
             returns = np.random.normal(0.001, 0.02, 120)
-            price_path = start * (1 + returns).cumprod()
-            dummy_data[t] = price_path
-        
+            dummy_data[t] = start * (1 + returns).cumprod()
         return pd.DataFrame(dummy_data, index=dates)
 
 def get_fundamentals(tickers):
     metrics = []
     
-    # Backup data for demo purposes (Snapshot as of late 2025/early 2026)
-    # This ensures the table looks professional even if yfinance 'info' is blocked in the cloud
+    # ADVANCED BACKUP DATA (Rule of 40, EV/Rev included)
     BACKUP_DATA = {
-        'CRM':  {'marketCap': 280e9, 'forwardPE': 28.5, 'revenueGrowth': 0.11, 'beta': 1.05},
-        'SNOW': {'marketCap': 55e9,  'forwardPE': 45.2, 'revenueGrowth': 0.22, 'beta': 1.45},
-        'HUBS': {'marketCap': 32e9,  'forwardPE': 65.0, 'revenueGrowth': 0.18, 'beta': 1.25},
-        'NET':  {'marketCap': 35e9,  'forwardPE': 85.5, 'revenueGrowth': 0.28, 'beta': 1.35},
-        'DDOG': {'marketCap': 42e9,  'forwardPE': 55.8, 'revenueGrowth': 0.21, 'beta': 1.40},
-        'SQ':   {'marketCap': 45e9,  'forwardPE': 25.0, 'revenueGrowth': 0.12, 'beta': 1.60},
-        'PYPL': {'marketCap': 70e9,  'forwardPE': 14.5, 'revenueGrowth': 0.08, 'beta': 1.15},
-        'NVDA': {'marketCap': 2500e9,'forwardPE': 35.0, 'revenueGrowth': 0.90, 'beta': 1.70},
+        'CRM':  {'marketCap': 280e9, 'forwardPE': 28.5, 'revenueGrowth': 0.11, 'margins': 0.18, 'evToRev': 6.5, 'beta': 1.05},
+        'SNOW': {'marketCap': 55e9,  'forwardPE': 45.2, 'revenueGrowth': 0.22, 'margins': -0.05, 'evToRev': 12.0, 'beta': 1.45},
+        'HUBS': {'marketCap': 32e9,  'forwardPE': 65.0, 'revenueGrowth': 0.18, 'margins': -0.02, 'evToRev': 9.5, 'beta': 1.25},
+        'NET':  {'marketCap': 35e9,  'forwardPE': 85.5, 'revenueGrowth': 0.28, 'margins': -0.03, 'evToRev': 14.2, 'beta': 1.35},
+        'DDOG': {'marketCap': 42e9,  'forwardPE': 55.8, 'revenueGrowth': 0.21, 'margins': 0.02, 'evToRev': 11.5, 'beta': 1.40},
+        'SQ':   {'marketCap': 45e9,  'forwardPE': 25.0, 'revenueGrowth': 0.12, 'margins': 0.05, 'evToRev': 3.5, 'beta': 1.60},
+        'PYPL': {'marketCap': 70e9,  'forwardPE': 14.5, 'revenueGrowth': 0.08, 'margins': 0.16, 'evToRev': 2.8, 'beta': 1.15},
+        'NVDA': {'marketCap': 2500e9,'forwardPE': 35.0, 'revenueGrowth': 0.90, 'margins': 0.55, 'evToRev': 25.0, 'beta': 1.70},
     }
 
     for t in tickers:
         try:
-            # Try fetching live
             info = yf.Ticker(t).info
             
-            # Helper to safely get value or fallback
-            def get_val(key, fallback_key=None):
+            def get_val(key, default=0.0):
                 val = info.get(key)
                 if val is None and t in BACKUP_DATA:
-                    return BACKUP_DATA[t].get(fallback_key or key)
-                return val
+                    return BACKUP_DATA[t].get(key, default)
+                return val if val is not None else default
 
             m_cap = get_val('marketCap')
-            pe = get_val('forwardPE', 'forwardPE') # Fallback if None
-            # If PE is still None, try trailing
-            if pe is None: pe = get_val('trailingPE')
-            
+            pe = get_val('forwardPE') or get_val('trailingPE')
             growth = get_val('revenueGrowth')
-            beta = get_val('beta')
+            margins = get_val('profitMargins')
+            ev_rev = get_val('enterpriseToRevenue')
+            beta = get_val('beta', 1.0)
+            
+            # Rule of 40: Growth % + Margin % (e.g., 0.20 + 0.10 => 30)
+            rule_40 = (growth + margins) * 100
 
             metrics.append({
                 'ticker': t,
-                'market_cap': m_cap if m_cap else 0,
-                'pe': pe if pe else 0,
-                'growth': growth if growth else 0,
-                'beta': beta if beta else 1.0
+                'market_cap': m_cap,
+                'pe': pe,
+                'ev_rev': ev_rev,
+                'rule_40': rule_40,
+                'growth': growth,
+                'beta': beta
             })
-        except Exception as e:
-            # Use full backup if fetch fails
+        except Exception:
+            # Fallback
             if t in BACKUP_DATA:
                 bk = BACKUP_DATA[t]
+                rule_40 = (bk['revenueGrowth'] + bk['margins']) * 100
                 metrics.append({
                     'ticker': t,
                     'market_cap': bk['marketCap'],
                     'pe': bk['forwardPE'],
+                    'ev_rev': bk['evToRev'],
+                    'rule_40': rule_40,
                     'growth': bk['revenueGrowth'],
                     'beta': bk['beta']
                 })
             else:
-                metrics.append({
-                    'ticker': t,
-                    'market_cap': 0, 'pe': 0, 'growth': 0, 'beta': 1.0
-                })
+                metrics.append({'ticker': t, 'market_cap': 0, 'pe': 0, 'ev_rev': 0, 'rule_40': 0, 'growth': 0, 'beta': 1.0})
                 
     return metrics
 
@@ -155,24 +162,19 @@ def calculate_signals(prices_df, sector_tickers):
     signals = {}
     returns = prices_df.pct_change().dropna()
     
-    # Check data sufficiency
-    if len(prices_df) < 30:
-        return {}
+    if len(prices_df) < 30: return {}
 
     # Benchmark returns
     sp500_ret = returns[BENCHMARK] if BENCHMARK in returns.columns else pd.Series(0, index=returns.index)
     momentum_spx = (prices_df[BENCHMARK].iloc[-1] / prices_df[BENCHMARK].iloc[-30] - 1) * 100 if BENCHMARK in prices_df.columns else 0
 
-    # Volatility
+    # Volatility & Momentum
     volatility = returns.rolling(window=30).std() * np.sqrt(252) * 100
     current_vol = volatility.iloc[-1]
-    
-    # Momentum 30d
     momentum = (prices_df.iloc[-1] / prices_df.iloc[-30] - 1) * 100
     
     for t in sector_tickers:
         if t in returns.columns:
-            # Beta
             cov = returns[t].cov(sp500_ret)
             var = sp500_ret.var()
             beta = cov / var if var != 0 else 1.0
@@ -185,19 +187,59 @@ def calculate_signals(prices_df, sector_tickers):
             }
     return signals
 
-def generate_recommendation(signals):
-    if not signals:
-        return 28.0, 32.0, "NEUTRAL"
-        
+def generate_advisory(signals, macro, fundamentals, last_private_price):
+    """
+    The Brain: Generates the Executive Commentary and Pricing Advice
+    """
+    if not signals: return {}
+
     avg_mom = np.mean([v['momentum'] for v in signals.values()])
     avg_vol = np.mean([v['volatility'] for v in signals.values()])
+    avg_ev_rev = np.mean([f['ev_rev'] for f in fundamentals if f['ev_rev'] > 0])
+    
+    # 1. PRICING LOGIC
+    # Base multiple derived from average peer EV/Rev with a hairut
+    # Rough calc: If market expects x10, IPO discount is usually 10-15%
+    # This is a synthetic range for demo
+    base_price = 30.0 # Anchor
+    
+    if avg_mom > 5: base_price += 4.0
+    if avg_vol > 40: base_price -= 3.0
+    if macro['vix'] > 20: base_price -= 3.0
+    if macro['tnx'] > 4.5: base_price -= 2.0
+    
+    low_px = base_price - 2.0
+    high_px = base_price + 2.0
     
-    if avg_mom > 5 and avg_vol < 40:
-        return 32.0, 36.0, "BULLISH"
-    elif avg_mom < -5:
-        return 24.0, 28.0, "BEARISH"
+    # 2. MARKET WINDOW LOGIC
+    window_status = "OPEN"
+    window_color = "green"
+    
+    if macro['vix'] > 25:
+        window_status = "CLOSED"
+        window_color = "red"
+        advice_text = "Market volatility (VIX > 25) indicates a closed issuance window. Severe price dislocation risk."
+    elif avg_mom < -5 or macro['vix'] > 20:
+        window_status = "CAUTION"
+        window_color = "orange"
+        advice_text = "Headwinds present. Buy-side demand is highly selective. Recommend widening the price talk."
     else:
-        return 28.0, 32.0, "NEUTRAL"
+        advice_text = "Constructive backdrop. Strong peer momentum and stable volatility support a premium valuation."
+
+    # 3. DOWN-ROUND DETECTOR
+    down_round_alert = False
+    if last_private_price and float(last_private_price) > high_px:
+        down_round_alert = True
+        advice_text += f"<br><br><b>⚠️ DOWN-ROUND RISK:</b> Implied range (${low_px}-${high_px}) is below last private mark (${last_private_price}). Expect significant cap table friction."
+
+    return {
+        'low': round(low_px, 2),
+        'high': round(high_px, 2),
+        'sentiment': window_status,
+        'color': window_color,
+        'commentary': advice_text,
+        'avg_ev_rev': avg_ev_rev
+    }
 
 # ==============================================================================
 # ROUTES
@@ -212,7 +254,9 @@ async def health_check():
     return {"status": "ok"}
 
 @app.post("/analyze")
-async def analyze(request: Request, query: str = Form(...), sector_override: str = Form(None)):
+async def analyze(request: Request, 
+                  query: str = Form(...), 
+                  last_private: str = Form(None)):
     
     # 1. Determine Sector
     sector_key = 'SaaS'
@@ -223,20 +267,22 @@ async def analyze(request: Request, query: str = Form(...), sector_override: str
     
     target_tickers = SECTOR_PROXIES.get(sector_key, SECTOR_PROXIES['SaaS'])
     
-    # 2. Fetch Data
+    # 2. Fetch Data (Market + Macro)
     prices = fetch_market_data(target_tickers)
+    macro = fetch_macro_data()
+    
     if prices.empty:
         return JSONResponse(status_code=500, content={"error": "Failed to fetch market data"})
         
-    # 3. Calculations
+    # 3. Core Calculations
     signals = calculate_signals(prices, target_tickers)
-    low, high, sentiment = generate_recommendation(signals)
     fundamentals = get_fundamentals(target_tickers)
     
-    # 4. Prepare Chart Data (Time Series)
-    # Normalize to 100
-    normalized = prices / prices.iloc[0] * 100
+    # 4. The Advisor Engine
+    advisory = generate_advisory(signals, macro, fundamentals, last_private)
     
+    # 5. Chart Data
+    normalized = prices / prices.iloc[0] * 100
     chart_data = []
     for col in normalized.columns:
         if col in target_tickers or col == BENCHMARK:
@@ -248,21 +294,20 @@ async def analyze(request: Request, query: str = Form(...), sector_override: str
                 'mode': 'lines'
             })
             
-    # 5. Prepare Response
+    # 6. Response
     response_data = {
         'sector': sector_key,
-        'recommendation': {
-            'low': low,
-            'high': high,
-            'sentiment': sentiment
-        },
-        'metrics': { # Averages for cards
+        'advisory': advisory,
+        'macro': macro,
+        'metrics': { 
             'avg_momentum': np.mean([s['momentum'] for s in signals.values()]) if signals else 0,
             'avg_beta': np.mean([s['beta'] for s in signals.values()]) if signals else 0,
-            'avg_vol': np.mean([s['volatility'] for s in signals.values()]) if signals else 0
+            'avg_vol': np.mean([s['volatility'] for s in signals.values()]) if signals else 0,
+            'avg_ev_rev': advisory['avg_ev_rev'],
+            'avg_rule_40': np.mean([f['rule_40'] for f in fundamentals]) if fundamentals else 0
         },
-        'chart_json': chart_data, # Passed raw to Plotly.js
-        'comparables': fundamentals, # Table data
+        'chart_json': chart_data,
+        'comparables': fundamentals,
         'signals': signals 
     }