import pandas as pd
import numpy as np
from datetime import datetime, timedelta
import yfinance as yf
class ForexMeanReversionAnalyzer:
    def __init__(self):
        self.interest_rates = {
            'USD': 0.0525,  # Federal Funds Rate
            'EUR': 0.0350,  # ECB Rate
            'GBP': 0.0475,  # BoE Rate
            'JPY': -0.0010, # BoJ Rate
            'AUD': 0.0425   # RBA Rate
        }
def calculate_carry(self, pair):
        """Interest rate carry on currency pair"""
        quote_ccy = pair[3:6]  # Last 3 chars (e.g., EUR in EURUSD)
        base_ccy = pair[0:3]   # First 3 chars (USD in EURUSD)
carry = self.interest_rates[quote_ccy] - self.interest_rates[base_ccy]
        return carry
def identify_mean_reversion_candidates(self):
        """Pairs with high carry show stronger reversion to PPP"""
        pairs = ['EURUSD', 'GBPUSD', 'NZDUSD', 'AUDUSD', 'USDCAD',
                 'USDJPY', 'EURGBP', 'EURJPY', 'GBPJPY', 'AUDJPY']
carry_data = []
        for pair in pairs:
            carry = self.calculate_carry(pair)
            carry_data.append({'pair': pair, 'carry': carry})
# High positive/negative carry indicates stronger reversion
        return sorted(carry_data, key=lambda x: abs(x['carry']), reverse=True)
analyzer = ForexMeanReversionAnalyzer()
candidates = analyzer.identify_mean_reversion_candidates()
print("Top mean reversion candidates:", candidates[:5])

def forex_mean_reversion_system(pair, price_feed, lookback=100, vol_window=30):
    """
    Volatility-adjusted mean reversion for forex
    Tighter bands during low volatility, wider during high volatility
    """
prices = price_feed[pair]
    simple_ma = prices.rolling(window=lookback).mean()
    deviation = prices - simple_ma
# Historical volatility
    log_returns = np.log(prices / prices.shift(1))
    volatility = log_returns.rolling(window=vol_window).std()
# Normalized deviation (std units from mean)
    zscore = deviation / (volatility * lookback)
# Dynamic thresholds based on volatility regime
    vol_percentile = volatility.rolling(window=252).apply(
        lambda x: (x[-1] - x.min()) / (x.max() - x.min())
    )
entry_threshold = np.where(vol_percentile > 0.75, 2.5, 2.0)  # Higher vol = tighter triggers
    exit_threshold = np.where(vol_percentile > 0.75, 0.75, 0.5)
# Generate signals
    signals = np.zeros(len(prices))
    signals[zscore < -entry_threshold] = 1   # Buy oversold
    signals[zscore > entry_threshold] = -1   # Sell overbought
    signals[abs(zscore) < exit_threshold] = 0  # Exit mean reversion
return {
        'prices': prices,
        'ma': simple_ma,
        'zscore': zscore,
        'volatility': volatility,
        'signals': signals
    }

def multi_timeframe_forex_strategy(symbol, data_dict):
    """
    Requires confirmation across 4 timeframes:
Daily (position entry/exit)
4-hour (trade momentum)
1-hour (exact entry point)
15-minute (precise timing)
    """
# Get mean reversion signals across timeframes
    daily_mr = forex_mean_reversion_system(symbol, data_dict['daily'])
    h4_mr = forex_mean_reversion_system(symbol, data_dict['4h'])
    h1_mr = forex_mean_reversion_system(symbol, data_dict['1h'])
    m15_mr = forex_mean_reversion_system(symbol, data_dict['15m'])
# Calculate confluence score
    daily_signal = daily_mr['signals'][-1]
    h4_signal = h4_mr['signals'][-1]
    h1_signal = h1_mr['signals'][-1]
    m15_signal = m15_mr['signals'][-1]
# Confluence rules
    if daily_signal == 1 and h4_signal == 1 and h1_signal == 1:
        confluence = 3  # Strong buy signal
    elif h4_signal == 1 and h1_signal == 1 and m15_signal == 1:
        confluence = 2  # Medium buy signal
    elif h4_signal == 1 and h1_signal == 1:
        confluence = 1  # Weak buy signal
    else:
        confluence = 0
return confluence, {
        'daily': daily_signal,
        '4h': h4_signal,
        '1h': h1_signal,
        '15m': m15_signal
    }

class ForexRiskManager:
    def __init__(self, account_balance, risk_per_trade=0.01, leverage=20):
        self.balance = account_balance
        self.risk_per_trade = risk_per_trade
        self.leverage = leverage
        self.max_spread_threshold = 5  # Max 5 pip spread to trade
def calculate_position_size(self, entry_price, stop_loss_pips, pair):
        """Calculate position size in standard lots"""
        # Standard lot = 100,000 units
        # Micro lot = 1,000 units
risk_amount = self.balance * self.risk_per_trade
        pip_value = 10 if pair.endswith('JPY') else 0.0001
stop_loss_amount = stop_loss_pips * pip_value
        position_size = risk_amount / stop_loss_amount
# Convert to standard lots (100,000 units)
        standard_lots = position_size / 100000
return max(0.01, standard_lots)  # Minimum 0.01 standard lots
def validate_trade(self, pair, spread_pips, volatility, atr):
        """Pre-trade validation checks"""
checks = {
            'spread_ok': spread_pips <= self.max_spread_threshold,
            'volatility_ok': volatility < 0.015,  # Max 1.5% daily vol
            'liquidity_ok': atr > 20,  # Minimum 20 pips ATR
            'time_ok': self.check_trading_hours(pair)
        }
return all(checks.values()), checks
def check_trading_hours(self, pair):
        """Avoid low liquidity hours"""
        from datetime import datetime
        hour = datetime.utcnow().hour
# Avoid 22:00-02:00 UTC (lowest liquidity)
        if 22 <= hour or hour <= 2:
            return False
        return True

def carry_adjusted_mean_reversion(pair, current_price, ma, volatility):
    """
    Adjust mean reversion target for interest rate carry
    EURUSD with 1.75% annual carry should revert to slightly higher MA
    """
carry_rate = get_forward_carry(pair)
    days_to_maturity = 365
# Theoretical forward price
    forward_price = ma * (1 + carry_rate / days_to_maturity)
# Mean reversion target
    deviation = current_price - forward_price
    zscore = deviation / (volatility * 100)
# Overbought/oversold relative to carry-adjusted mean
    if zscore < -2.0:
        return 'BUY', abs(zscore)
    elif zscore > 2.0:
        return 'SELL', zscore
    else:
        return 'HOLD', 0