Automate Gold Futures Risk Control in 30 Minutes

# Personal note: Learned this after my broker disconnected mid-trade
# and I had no fallback connection monitoring

from ib_insync import IB, Future, MarketOrder
import pandas as pd
from datetime import datetime
import asyncio

# Connection with automatic reconnect
ib = IB()

def connect_with_retry(max_attempts=3):
    """Connect to TWS with retry logic"""
    for attempt in range(max_attempts):
        try:
            ib.connect('127.0.0.1', 7497, clientId=1)
            print(f"✓ Connected to TWS at {datetime.now()}")
            return True
        except Exception as e:
            print(f"✗ Attempt {attempt + 1} failed: {e}")
            if attempt < max_attempts - 1:
                asyncio.sleep(5)
    return False

# Watch out: Client ID must be unique if running multiple scripts
if not connect_with_retry():
    raise ConnectionError("Failed to connect after 3 attempts")

# Personal note: Check margin requirements BEFORE calculating position size
# Gold margin can spike 30% during FOMC announcements

def get_account_data():
    """Get real-time account equity and margin"""
    account_summary = ib.accountSummary()
    
    data = {}
    for item in account_summary:
        if item.tag == 'NetLiquidation':
            data['equity'] = float(item.value)
        elif item.tag == 'AvailableFunds':
            data['available'] = float(item.value)
        elif item.tag == 'InitMarginReq':
            data['margin_used'] = float(item.value)
    
    return data

def get_gc_contract():
    """Define GC futures contract with correct specs"""
    # Front month Gold futures
    gc = Future('GC', '20251226', 'COMEX')
    ib.qualifyContracts(gc)
    
    # Get current price
    ticker = ib.reqMktData(gc)
    ib.sleep(2)  # Wait for price data
    
    return {
        'contract': gc,
        'price': ticker.last,
        'point_value': 100,  # $100 per point for GC
        'tick_size': 0.1     # Minimum price fluctuation
    }

# Fetch data
account = get_account_data()
gc_data = get_gc_contract()

print(f"Account Equity: ${account['equity']:,.2f}")
print(f"GC Price: ${gc_data['price']:,.2f}")
print(f"Available Funds: ${account['available']:,.2f}")

# Watch out: ticker.last can be NaN if market is closed
# Add validation: if pd.isna(gc_data['price']): use ticker.close

def calculate_position_size(account_equity, risk_percent, stop_loss_points, 
                          gc_price, point_value):
    """
    Calculate max contracts without exceeding risk limit
    
    Example: $50k account, 2% risk, 10-point stop
    Max loss = $1,000
    Risk per contract = 10 points × $100 = $1,000
    Position size = 1 contract
    """
    max_risk_dollars = account_equity * (risk_percent / 100)
    risk_per_contract = stop_loss_points * point_value
    
    # Maximum contracts allowed
    max_contracts = int(max_risk_dollars / risk_per_contract)
    
    # Calculate margin requirement
    # Personal note: Use 1.5x initial margin as buffer
    # Learned this after getting margin call at 4 AM
    initial_margin = 8500  # Typical for GC, but check your broker
    required_margin = max_contracts * initial_margin * 1.5
    
    return {
        'max_contracts': max_contracts,
        'risk_dollars': max_risk_dollars,
        'risk_per_contract': risk_per_contract,
        'required_margin': required_margin,
        'position_value': max_contracts * gc_price * point_value
    }

# Example calculation
risk_config = {
    'account_equity': account['equity'],
    'risk_percent': 2.0,  # 2% max risk per trade
    'stop_loss_points': 12.5,  # Points, not ticks
    'gc_price': gc_data['price'],
    'point_value': gc_data['point_value']
}

position = calculate_position_size(**risk_config)

print(f"\n--- POSITION SIZE CALCULATION ---")
print(f"Max Risk: ${position['risk_dollars']:,.2f}")
print(f"Risk per Contract: ${position['risk_per_contract']:,.2f}")
print(f"Recommended Contracts: {position['max_contracts']}")
print(f"Required Margin: ${position['required_margin']:,.2f}")
print(f"Position Value: ${position['position_value']:,.2f}")

# Safety check
if position['required_margin'] > account['available']:
    print(f"\n⚠️  WARNING: Insufficient margin!")
    print(f"Need ${position['required_margin'] - account['available']:,.2f} more")
    safe_contracts = int(account['available'] / (8500 * 1.5))
    print(f"Safe position: {safe_contracts} contracts")

# Watch out: Don't forget stop_loss_points uses points, not ticks
# 125 ticks = 12.5 points for GC (tick_size = 0.1)

import time
from datetime import datetime

class RiskMonitor:
    def __init__(self, ib_connection, alert_threshold=0.8):
        self.ib = ib_connection
        self.alert_threshold = alert_threshold  # Alert at 80% margin usage
        self.last_alert = None
        
    def check_risk_status(self):
        """Monitor real-time risk metrics"""
        account = get_account_data()
        positions = self.ib.positions()
        
        # Find GC positions
        gc_positions = [p for p in positions if 'GC' in p.contract.symbol]
        
        if not gc_positions:
            return {'status': 'NO_POSITION', 'contracts': 0}
        
        total_contracts = sum(p.position for p in gc_positions)
        gc_price = get_gc_contract()['price']
        
        # Calculate current exposure
        position_value = abs(total_contracts) * gc_price * 100
        margin_usage = account['margin_used'] / account['equity']
        
        status = {
            'timestamp': datetime.now(),
            'contracts': total_contracts,
            'position_value': position_value,
            'margin_usage_pct': margin_usage * 100,
            'equity': account['equity'],
            'available': account['available']
        }
        
        # Alert logic
        if margin_usage >= self.alert_threshold:
            self._send_alert(status)
        
        return status
    
    def _send_alert(self, status):
        """Send margin warning"""
        # Personal note: I send these to Telegram and email
        # SMS woke me up at 3 AM once - now I use smart routing
        alert_msg = f"""
        🚨 MARGIN ALERT - {status['timestamp'].strftime('%H:%M:%S')}
        
        Margin Usage: {status['margin_usage_pct']:.1f}%
        Contracts: {status['contracts']}
        Available: ${status['available']:,.2f}
        
        ACTION: Consider reducing position or adding funds
        """
        
        # Prevent spam - only alert once per 15 minutes
        now = datetime.now()
        if self.last_alert is None or (now - self.last_alert).seconds > 900:
            print(alert_msg)
            self.last_alert = now
            # Add your notification system here:
            # send_telegram_message(alert_msg)
            # send_email_alert(alert_msg)

# Run monitor
monitor = RiskMonitor(ib, alert_threshold=0.75)

def monitor_loop(duration_minutes=60):
    """Run monitoring for specified duration"""
    end_time = time.time() + (duration_minutes * 60)
    
    print(f"Starting risk monitor for {duration_minutes} minutes...")
    print("Press Ctrl+C to stop\n")
    
    while time.time() < end_time:
        try:
            status = monitor.check_risk_status()
            
            if status['status'] != 'NO_POSITION':
                print(f"[{status['timestamp'].strftime('%H:%M:%S')}] "
                      f"Contracts: {status['contracts']} | "
                      f"Margin: {status['margin_usage_pct']:.1f}% | "
                      f"Available: ${status['available']:,.0f}")
            
            time.sleep(30)  # Check every 30 seconds
            
        except KeyboardInterrupt:
            print("\n✓ Monitor stopped by user")
            break
        except Exception as e:
            print(f"✗ Monitor error: {e}")
            time.sleep(5)

# Watch out: ib.positions() can lag by 1-2 seconds after fills
# Add ib.reqPositions() before the call if you need instant updates