7 Aturan Manajemen Risiko Esensial untuk Trading Bots

def calculate_position_size(account_balance, risk_percent, stop_loss_pips, pip_value):
    """Hitung position size berdasarkan risk per trade."""
    risk_amount = account_balance * (risk_percent / 100)
    position_size = risk_amount / (stop_loss_pips * pip_value)
    return position_size

# Example:
account = 10000  # USD
risk = 1.0  # 1%
stop_loss = 20  # pips
pip_value = 10  # USD per pip per standard lot

lots = calculate_position_size(account, risk, stop_loss, pip_value)
print(f"Position size: {lots:.2f} lots")  # 0.50 lots

def place_order(symbol, side, lot_size, stop_loss_pips):
    """Wrapper yang memaksa stop loss di setiap order."""
    if stop_loss_pips is None or stop_loss_pips <= 0:
        raise ValueError("Stop loss MANDATORY untuk setiap trade!")
    
    # Calculate stop loss price
    if side == "BUY":
        sl_price = current_price - (stop_loss_pips * pip_size)
    else:
        sl_price = current_price + (stop_loss_pips * pip_size)
    
    # Place order with SL
    order_result = broker.place_order(
        symbol=symbol,
        side=side,
        size=lot_size,
        stop_loss=sl_price
    )
    return order_result

import datetime

class RiskManager:
    def __init__(self, account_balance, daily_loss_limit_pct=3.0):
        self.starting_balance = account_balance
        self.current_balance = account_balance
        self.daily_loss_limit = daily_loss_limit_pct
        self.day_start_balance = account_balance
        self.day_start_date = datetime.date.today()
    
    def check_daily_loss(self):
        """Reset jika hari baru, check limit untuk hari ini."""
        today = datetime.date.today()
        if today != self.day_start_date:
            self.day_start_balance = self.current_balance
            self.day_start_date = today
        
        daily_pnl_pct = ((self.current_balance - self.day_start_balance) 
                        / self.day_start_balance * 100)
        
        if daily_pnl_pct <= -self.daily_loss_limit:
            return False  # STOP TRADING
        return True
    
    def can_trade(self):
        if not self.check_daily_loss():
            print("⛔ Daily loss limit hit. No more trades hari ini.")
            return False
        return True

def can_open_new_position(open_positions, max_positions=5):
    if len(open_positions) >= max_positions:
        return False, "Max concurrent positions reached"
    
    # Check correlation (basic)
    currencies_exposed = set()
    for pos in open_positions:
        for currency in pos['pair'].split('/'):
            currencies_exposed.add(currency)
    
    # If new position would over-expose to single currency
    new_pair_currencies = set(new_pair.split('/'))
    overlap = currencies_exposed & new_pair_currencies
    if len(overlap) >= 2:
        return False, "Too much correlation"
    
    return True, "OK"

def calculate_atr_stop_loss(prices, atr_period=14, atr_multiplier=2.0):
    """Stop loss berdasarkan ATR (volatility-adjusted)."""
    import pandas as pd
    
    df = pd.DataFrame(prices)
    df['tr'] = pd.concat([
        df['high'] - df['low'],
        abs(df['high'] - df['close'].shift()),
        abs(df['low'] - df['close'].shift())
    ], axis=1).max(axis=1)
    df['atr'] = df['tr'].rolling(atr_period).mean()
    
    current_atr = df['atr'].iloc[-1]
    stop_distance_pips = current_atr * atr_multiplier / pip_size
    return stop_distance_pips

# Lebih aman dari fixed 20 pip stop

class BlackSwanProtection:
    def __init__(self):
        self.normal_volatility = None
        self.max_drawdown_pct = 10.0
    
    def check_volatility(self, current_atr, normal_atr):
        if current_atr > normal_atr * 3:
            print("⚠️ Extreme volatility detected. Halting new trades.")
            return False
        return True
    
    def check_drawdown(self, current_balance, day_start_balance):
        drawdown = ((current_balance - day_start_balance) 
                   / day_start_balance * 100)
        if drawdown <= -self.max_drawdown_pct:
            print("🚨 KILL SWITCH: Drawdown limit. Closing all.")
            return "EMERGENCY_CLOSE_ALL"
        return "OK"

class TradingBotRiskManager:
    def __init__(self, account_balance):
        self.account = account_balance
        self.day_start_balance = account_balance
        self.max_risk_per_trade = 1.0  # %
        self.daily_loss_limit = 3.0  # %
        self.max_concurrent_positions = 5
        self.max_intraday_drawdown = 10.0  # %
    
    def can_open_trade(self, current_positions):
        # Rule 1 & 4: Position limits
        if len(current_positions) >= self.max_concurrent_positions:
            return False, "Max positions reached"
        
        # Rule 3: Daily loss limit
        daily_pnl = ((self.account - self.day_start_balance) 
                    / self.day_start_balance * 100)
        if daily_pnl <= -self.daily_loss_limit:
            return False, "Daily loss limit hit"
        
        # Rule 6: Black swan
        if daily_pnl <= -self.max_intraday_drawdown:
            return False, "KILL SWITCH activated"
        
        return True, "OK"
    
    def calculate_position(self, stop_loss_pips, pip_value):
        # Rule 1: 1% maximum
        risk_amount = self.account * (self.max_risk_per_trade / 100)
        position_size = risk_amount / (stop_loss_pips * pip_value)
        return position_size
    
    def update_account(self, new_balance):
        self.account = new_balance