Regime-Filtered Risk-Adjusted Momentum Strategy with Inverse Volatility Weighting 12% to 655% Annual Returns

import requests
import pandas as pd
import yfinance as yf
import matplotlib.pyplot as plt

# --- Parameters ---
START_DATE = '2022-01-01'
END_DATE = '2023-01-01'  # You can change these dates to run the backtest for different years
LOOKBACK_DAYS = 30
HOLDING_DAYS = 7
N_TOP_ASSETS = 10
STOP_LOSS_THRESHOLD = -0.05  # The post-hoc analytical loss cap
MARKET_REGIME_MA_PERIOD = 50  # Moving Average period to filter the market regime
MARKET_REGIME_TICKER = 'BTC-USD'
TRANSACTION_COST_PER_ROUND_TRIP = 0.002  # 0.2% cost per weekly trade round-trip

print("Using placeholder ticker list. Replace with BinanceSymbols if needed.")
crypto_pairs_binance_format = ['BTCUSDC', 'ETHUSDC', 'BNBUSDC', 'ADAUSDC', 'SOLUSDC',
                               'XRPUSDC', 'DOTUSDC', 'DOGEUSDC', 'AVAXUSDC', 'LUNA1-USD',
                               'MATICUSDC', 'LTCUSDC', 'LINKUSDC', 'TRXUSDC', 'ATOMUSDC']
# Exclude the market regime ticker from the asset selection list.
tickers_to_trade = [pair[:-4] + '-USD' for pair in crypto_pairs_binance_format 
                    if pair[:-4] + '-USD' != MARKET_REGIME_TICKER]

# Ensure the market regime ticker is part of the download.
all_tickers_to_download = tickers_to_trade + [MARKET_REGIME_TICKER]

print(f"Downloading data for: {', '.join(all_tickers_to_download)}")
try:
    data = yf.download(all_tickers_to_download, start=START_DATE, end=END_DATE, progress=False)
    if data.empty:
        raise ValueError("No data downloaded. Check tickers and date range.")
    data = data['Close']  # Use closing prices
    data = data.sort_index()
    data = data.dropna(axis=1, how='all')  # Drop columns with no data
    tickers_to_trade = [t for t in tickers_to_trade if t in data.columns]
    if MARKET_REGIME_TICKER not in data.columns:
        raise ValueError(f"Market regime ticker {MARKET_REGIME_TICKER} could not be downloaded.")
    print(f"Successfully downloaded data for {len(data.columns)} tickers.")
except Exception as e:
    print(f"Error downloading data: {e}")
    exit()

data[f'{MARKET_REGIME_TICKER}_MA'] = data[MARKET_REGIME_TICKER].rolling(window=MARKET_REGIME_MA_PERIOD).mean()

# --- Backtesting ---
results = []
start_index = max(LOOKBACK_DAYS, MARKET_REGIME_MA_PERIOD)

print("Starting backtest...")
for i in range(start_index, len(data) - HOLDING_DAYS, HOLDING_DAYS):
    current_date = data.index[i]

    # Check market regime: Only trade when BTC-USD is above its moving average
    try:
        is_bull_market = data[MARKET_REGIME_TICKER].iloc[i] > data[f'{MARKET_REGIME_TICKER}_MA'].iloc[i]
    except IndexError:
        print(f"Warning: Market regime check failed for {current_date}. Skipping week.")
        is_bull_market = False

    weekly_return = 0.0

    if is_bull_market:
        # Define the lookback period for calculating momentum and volatility
        current_prices = data.iloc[i]
        lookback_start_prices = data.iloc[i - LOOKBACK_DAYS]

        # Only consider assets with valid price data over the lookback period
        valid_tickers = lookback_start_prices[tickers_to_trade].dropna().index
        valid_tickers = current_prices[valid_tickers].dropna().index

        if len(valid_tickers) >= N_TOP_ASSETS:
            # Calculate return over the lookback period
            lookback_returns = (current_prices[valid_tickers] / lookback_start_prices[valid_tickers]) - 1

            # Calculate volatility over the lookback period (daily standard deviation)
            daily_returns = data[valid_tickers].iloc[i - LOOKBACK_DAYS : i].pct_change().dropna(how='all')
            volatilities = daily_returns.std().replace(0, 1e-9)

            # Calculate risk-adjusted returns as the ratio of return to volatility
            risk_adjusted = lookback_returns.loc[volatilities.index] / volatilities
            valid_risk_adjusted = risk_adjusted.dropna()

            # Select the top N assets based on the risk-adjusted metric
            if len(valid_risk_adjusted) >= N_TOP_ASSETS:
                topN_tickers = valid_risk_adjusted.nlargest(N_TOP_ASSETS).index

                # Check that the required prices exist for the holding period
                if not current_prices[topN_tickers].isnull().any() and not data.iloc[i + HOLDING_DAYS][topN_tickers].isnull().any():
                    # Weight allocation: Inverse volatility weighting
                    selected_vols = volatilities[topN_tickers]
                    inv_vols = 1 / selected_vols
                    weights = inv_vols / inv_vols.sum()

                    next_week_prices = data.iloc[i + HOLDING_DAYS][topN_tickers]
                    individual_returns = (next_week_prices / current_prices[topN_tickers]) - 1

                    # Re-align weights if some data is missing (should rarely happen given previous checks)
                    individual_returns = individual_returns.dropna()
                    weights = weights.loc[individual_returns.index]
                    weights = weights / weights.sum()

                    gross_return = (individual_returns * weights).sum()
                    weekly_return = gross_return - TRANSACTION_COST_PER_ROUND_TRIP
                else:
                    pass  # Missing price data for selected tickers; skip the week.
            else:
                pass  # Not enough assets with valid risk-adjusted scores; skip the week.

    # Apply the stop-loss cap to manage downside risk
    capped_return = max(weekly_return, STOP_LOSS_THRESHOLD)
    results.append((current_date, capped_return))

print("Backtest finished.")

# --- Post-Processing & Plotting ---
df_results = pd.DataFrame(results, columns=['Week Start', 'Avg 1 Week Return'])
df_results['Cumulative Return'] = (df_results['Avg 1 Week Return'] + 1).cumprod() - 1
df_results = df_results.set_index('Week Start')

plt.figure(figsize=(14, 7))
plt.plot(df_results.index, df_results['Cumulative Return'], label=f'Strategy')

# Optional: Buy & Hold Benchmark for BTC-USD
if MARKET_REGIME_TICKER in data.columns:
     btc_buy_hold = data[MARKET_REGIME_TICKER].iloc[start_index:]
     btc_cum_ret = (btc_buy_hold / btc_buy_hold.iloc[0]) - 1
     plt.plot(btc_cum_ret.index, btc_cum_ret, label=f'{MARKET_REGIME_TICKER} Buy & Hold', linestyle='--', alpha=0.7)

plt.xlabel('Date')
plt.ylabel('Cumulative Return')
plt.title('Inverse Volatility Weight with Regime Filter')
plt.legend()
plt.grid(True)
plt.tight_layout()
plt.show()

# --- Performance Metrics ---
print("\n--- Results ---")
print(f"Final Cumulative Return: {df_results['Cumulative Return'].iloc[-1]:.2%}")

# Annualized Sharpe Ratio (using weekly returns, 52 weeks per year)
sharpe_ratio = (df_results['Avg 1 Week Return'].mean() / df_results['Avg 1 Week Return'].std()) * (52**0.5)
print(f"Annualized Sharpe Ratio: {sharpe_ratio:.2f}")

# Maximum Drawdown Calculation
def calculate_max_drawdown(cum_returns):
    roll_max = (cum_returns + 1).cummax()
    drawdown = (cum_returns + 1) / roll_max - 1
    return drawdown.min()

max_drawdown = calculate_max_drawdown(df_results['Cumulative Return'])
print(f"Maximum Drawdown: {max_drawdown:.2%}")