Update backtest.py

backtest.py

@@ -1,5 +1,5 @@
 import matplotlib
-matplotlib.use('Agg')  # Force headless mode for Spaces
+matplotlib.use('Agg')  # Force headless mode
 
 import yfinance as yf
 import pandas as pd
@@ -7,164 +7,88 @@ import numpy as np
 import matplotlib.pyplot as plt
 import os
 
-# --- CONFIGURATION ---
-START_DATE = "2008-01-01"  # Start from 2008 to ensure all commodities have data
+START_DATE = "2008-01-01"
 INITIAL_CAPITAL = 100000
 
-# --- THE ASSET BASKET ---
 ASSETS = {
-    "NIFTY": "^NSEI",    # Indian Equity
-    "GOLD": "GC=F",      # Gold Futures
-    "SILVER": "SI=F",    # Silver Futures
-    "OIL": "CL=F",       # Crude Oil Futures
-    "BONDS": "^TNX"      # Risk-Free Proxy (10Y Yield)
+    "NIFTY": "^NSEI",
+    "GOLD": "GC=F",
+    "SILVER": "SI=F",
+    "OIL": "CL=F",
+    "BONDS": "^TNX"
 }
 
-def fetch_data():
-    print(f"📥 Fetching Multi-Asset Basket from {START_DATE}...")
+def backtest_engine():
+    print("⚙️ Fetching Multi-Asset Basket...")
     try:
-        # 1. Download all assets
-        tickers = list(ASSETS.values())
-        data = yf.download(tickers, start=START_DATE, progress=False)['Close']
-        
-        # 2. Fix Column Names
+        data = yf.download(list(ASSETS.values()), start=START_DATE, progress=False)['Close']
+        if data.empty: return None
+
+        # Clean Headers
         if isinstance(data.columns, pd.MultiIndex):
             data.columns = [col[0] for col in data.columns]
         
-        # Map tickers back to readable names (e.g., ^NSEI -> NIFTY)
-        # Invert the dictionary for mapping
-        ticker_to_name = {v: k for k, v in ASSETS.items()}
-        data = data.rename(columns=ticker_to_name)
-        
-        # 3. Clean Data
-        # Forward fill to handle different market holidays (US vs India)
+        mapping = {v: k for k, v in ASSETS.items()}
+        data = data.rename(columns=mapping)
         data = data.ffill().bfill()
         
-        # Resample to Monthly for robust signals (less noise than daily)
-        # We take the last price of each month
+        # Strategy: Monthly Momentum Rotation
         monthly_data = data.resample('M').last()
+        momentum = monthly_data.pct_change(6) # 6-month momentum
         
-        return data, monthly_data
+        # Rank assets
+        tradeable = ["NIFTY", "GOLD", "SILVER", "OIL"]
+        ranks = momentum[tradeable].rank(axis=1)
+        
+        # Top 2 get 50% each
+        target_weights = (ranks >= 3).astype(float) * 0.5
+        
+        # Shift to avoid look-ahead bias and align to daily
+        daily_weights = target_weights.reindex(data.index).ffill().shift(1)
+        
+        # Trend Filter (Price > 200 SMA)
+        sma_200 = data[tradeable].rolling(200).mean()
+        trend_filter = (data[tradeable] > sma_200).astype(int)
+        
+        # Final Allocation
+        final_weights = daily_weights * trend_filter
+        cash_weight = 1.0 - final_weights.sum(axis=1)
+        
+        # Returns
+        port_ret = (final_weights * data[tradeable].pct_change()).sum(axis=1)
+        # Add small risk-free rate for cash
+        port_ret += cash_weight * (0.04/252) 
+        
+        # Wealth
+        data['Strategy'] = INITIAL_CAPITAL * (1 + port_ret).cumprod()
+        data['Nifty_BuyHold'] = INITIAL_CAPITAL * (1 + data['NIFTY'].pct_change()).cumprod()
+        
+        # Plot
+        output_file = "backtest_result.png"
+        if os.path.exists(output_file): os.remove(output_file)
         
-    except Exception as e:
-        print(f"❌ Data Fetch Error: {e}")
-        return None, None
-
-def strategy_momentum_rotation(daily_data, monthly_data):
-    """
-    Logic:
-    1. Calculate 6-Month Returns (Momentum) for all assets.
-    2. Rank them.
-    3. Pick Top 2 Winners every month.
-    4. Trend Filter: Only buy if Price > 200 Day SMA (Daily check).
-    """
-    print("⚙️ Running Momentum Rotation Engine...")
-    
-    # --- STEP 1: MOMENTUM CALCULATION (Monthly) ---
-    # Calculate 6-month rolling return
-    momentum = monthly_data.pct_change(6)
-    
-    # We exclude 'BONDS' from the momentum race (it's just a fallback)
-    tradeable_assets = ["NIFTY", "GOLD", "SILVER", "OIL"]
-    mom_scores = momentum[tradeable_assets]
-
-    # --- STEP 2: RANKING ---
-    # Rank assets 1 to 4 (4 is best, 1 is worst)
-    ranks = mom_scores.rank(axis=1, ascending=True)
-    
-    # Create Weights: Top 2 assets get 50% each (0.5), others 0
-    # Logic: If Rank >= 3 (Top 2 out of 4), Weight = 0.5
-    target_weights = (ranks >= 3).astype(float) * 0.5
-    
-    # --- STEP 3: APPLY TO DAILY DATA (Rebalance) ---
-    # We align monthly weights to daily data
-    # .shift(1) prevents look-ahead bias (we use last month's data to trade this month)
-    daily_weights = target_weights.reindex(daily_data.index).ffill().shift(1)
-    
-    # --- STEP 4: TREND FILTER (Safety Check) ---
-    # Calculate 200-day SMA on daily data
-    sma_200 = daily_data[tradeable_assets].rolling(200).mean()
-    
-    # Trend Rule: If Price < SMA200, Force Weight to 0 (Move that portion to Cash/Bonds)
-    trend_filter = (daily_data[tradeable_assets] > sma_200).astype(int)
-    
-    # Final Weights = Momentum Weight * Trend Filter
-    final_weights = daily_weights * trend_filter
-    
-    # Whatever is not invested goes to BONDS/CASH
-    # Ex: If we only hold 1 asset (0.5), remainder (0.5) goes to Bonds.
-    invested_sum = final_weights.sum(axis=1)
-    cash_weight = 1.0 - invested_sum
-    
-    return final_weights, cash_weight
-
-def backtest_engine():
-    # 1. Get Data
-    daily_df, monthly_df = fetch_data()
-    if daily_df is None: return "Error: No Data"
-    
-    # 2. Run Strategy
-    asset_weights, cash_weight = strategy_momentum_rotation(daily_df, monthly_df)
-    
-    # 3. Calculate Portfolio Returns
-    # Asset Returns
-    asset_rets = daily_df[asset_weights.columns].pct_change()
-    
-    # Weighted Returns (Asset W * Asset Ret)
-    port_asset_ret = (asset_weights * asset_rets).sum(axis=1)
-    
-    # Cash/Bond Return (Assume flat 4% annual risk-free if Bonds drop, or use Bond ETF return)
-    # Using small constant return for cash component to simplify
-    risk_free_daily = 0.04 / 252 
-    port_cash_ret = cash_weight * risk_free_daily
-    
-    # Total Strategy Return
-    strategy_ret = port_asset_ret + port_cash_ret
-    
-    # Benchmark Return (Nifty Buy & Hold)
-    benchmark_ret = daily_df['NIFTY'].pct_change()
-    
-    # 4. Wealth Index
-    daily_df['Strategy_Wealth'] = INITIAL_CAPITAL * (1 + strategy_ret).cumprod()
-    daily_df['Benchmark_Wealth'] = INITIAL_CAPITAL * (1 + benchmark_ret).cumprod()
-    
-    # 5. Plotting
-    output_file = "backtest_result.png"
-    try:
         fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(10, 8), gridspec_kw={'height_ratios': [2, 1]})
         
-        # Plot 1: Wealth Curve
-        ax1.plot(daily_df.index, daily_df['Strategy_Wealth'], label='Momentum Rotation (Equity+Comm)', color='blue', linewidth=2)
-        ax1.plot(daily_df.index, daily_df['Benchmark_Wealth'], label='Nifty 50 Buy & Hold', color='gray', linestyle='--', alpha=0.6)
-        ax1.set_title("Strategy vs Benchmark (2008-Present)")
-        ax1.set_ylabel("Wealth (INR)")
+        ax1.plot(data.index, data['Strategy'], label='Momentum Rotation', color='blue')
+        ax1.plot(data.index, data['Nifty_BuyHold'], label='Nifty Only', color='grey', linestyle='--')
         ax1.set_yscale('log')
         ax1.legend()
-        ax1.grid(True, which="both", alpha=0.3)
+        ax1.set_title("Strategy vs Benchmark")
         
-        # Plot 2: Asset Allocation (Stacked)
-        # We plot the weights to show when we switched to Gold/Oil
-        ax2.stackplot(asset_weights.index, 
-                      asset_weights['NIFTY'], asset_weights['GOLD'], 
-                      asset_weights['SILVER'], asset_weights['OIL'], 
-                      cash_weight,
-                      labels=['Nifty', 'Gold', 'Silver', 'Oil', 'Cash'],
-                      alpha=0.6)
-        ax2.set_title("Dynamic Asset Allocation")
-        ax2.set_ylabel("Weight")
+        ax2.stackplot(data.index, final_weights['NIFTY'], final_weights['GOLD'], 
+                      final_weights['SILVER'], final_weights['OIL'], cash_weight,
+                      labels=['Nifty', 'Gold', 'Silver', 'Oil', 'Cash'], alpha=0.6)
         ax2.legend(loc='upper left', fontsize='small')
+        ax2.set_title("Asset Allocation")
         
         plt.tight_layout()
-        
-        # Save
-        if os.path.exists(output_file): os.remove(output_file)
-        plt.savefig(output_file, bbox_inches='tight')
+        plt.savefig(output_file)
         plt.close()
         
         return output_file
-        
+
     except Exception as e:
-        print(f"❌ Plotting Error: {e}")
+        print(f"Backtest Error: {e}")
         return None
 
 if __name__ == "__main__":