Building Crypto Trading Bot with Ollama DeepSeek-R1: Complete Python Tutorial 2025

# Hardware requirements
- RAM: 8GB minimum (16GB recommended for DeepSeek-R1)
- Storage: 10GB free space
- CPU: 4+ cores for optimal performance
- Internet: Stable connection for market data

# requirements.txt
requests==2.31.0
websocket-client==1.6.4
pandas==2.1.4
numpy==1.25.2
python-binance==1.0.19
ccxt==4.1.77
ollama==0.1.7
schedule==1.2.0
logging==0.4.9.6
python-dotenv==1.0.0

pip install -r requirements.txt

# Example: DeepSeek-R1 market analysis prompt
analysis_prompt = """
Analyze this Bitcoin market data:
- Current Price: $43,250
- 24h Volume: $28.5B (+15%)
- RSI: 68.5
- MACD: Bullish crossover
- News: Federal Reserve hints at rate cuts
- Fear/Greed Index: 72 (Greed)

Provide:
1. Market direction probability (next 4 hours)
2. Risk assessment (1-10)
3. Recommended position size (% of portfolio)
4. Entry/exit strategy
5. Stop-loss placement reasoning
"""

# Download from official website
Invoke-WebRequest -Uri "https://ollama.ai/download/windows" -OutFile "ollama-setup.exe"
./ollama-setup.exe

# Using Homebrew
brew install ollama

# Or download from website
curl -fsSL https://ollama.ai/install.sh | sh

# Ubuntu/Debian
curl -fsSL https://ollama.ai/install.sh | sh

# Verify installation
ollama --version

# Pull DeepSeek-R1 model (requires ~14GB)
ollama pull deepseek-r1:7b

# For better performance with more RAM
ollama pull deepseek-r1:32b

# Verify model installation
ollama list

# test_deepseek.py
import ollama

def test_deepseek_connection():
    """Test DeepSeek-R1 model connection"""
    try:
        response = ollama.chat(
            model='deepseek-r1:7b',
            messages=[{
                'role': 'user',
                'content': 'Analyze Bitcoin at $43,000 with RSI at 70. Bullish or bearish for next 4 hours?'
            }]
        )
        print("✅ DeepSeek-R1 connected successfully")
        print(f"Response: {response['message']['content'][:200]}...")
        return True
    except Exception as e:
        print(f"❌ Connection failed: {e}")
        return False

if __name__ == "__main__":
    test_deepseek_connection()

# bot_architecture.py
class CryptoTradingBot:
    """Main trading bot class with DeepSeek-R1 integration"""
    
    def __init__(self, config):
        self.config = config
        self.market_data = MarketDataManager()
        self.analyzer = DeepSeekAnalyzer()
        self.risk_manager = RiskManager()
        self.executor = OrderExecutor()
        self.portfolio = PortfolioTracker()
        
    def run_trading_cycle(self):
        """Execute one complete trading cycle"""
        # 1. Fetch market data
        market_data = self.market_data.get_current_data()
        
        # 2. Analyze with DeepSeek-R1
        analysis = self.analyzer.analyze_market(market_data)
        
        # 3. Apply risk management
        trade_signal = self.risk_manager.validate_signal(analysis)
        
        # 4. Execute trades if signal is valid
        if trade_signal.is_valid:
            self.executor.place_order(trade_signal)
            
        # 5. Update portfolio tracking
        self.portfolio.update_positions()

# config/settings.py
import os
from dataclasses import dataclass
from typing import List, Dict

@dataclass
class TradingConfig:
    """Centralized bot configuration"""
    
    # Exchange settings
    exchange_name: str = "binance"
    api_key: str = os.getenv("BINANCE_API_KEY")
    api_secret: str = os.getenv("BINANCE_API_SECRET")
    testnet: bool = True  # Use testnet for practice
    
    # Trading pairs
    trading_pairs: List[str] = ("BTC/USDT", "ETH/USDT", "ADA/USDT")
    base_currency: str = "USDT"
    
    # DeepSeek-R1 settings
    model_name: str = "deepseek-r1:7b"
    max_tokens: int = 1000
    temperature: float = 0.3  # Lower for consistent analysis
    
    # Risk management
    max_portfolio_risk: float = 0.02  # 2% max risk per trade
    max_drawdown: float = 0.10        # 10% max portfolio drawdown
    stop_loss_percent: float = 0.03   # 3% stop loss
    take_profit_percent: float = 0.06 # 6% take profit
    
    # Trading schedule
    trading_hours_utc: tuple = (0, 24)  # 24/7 trading
    analysis_interval: int = 300        # 5 minutes between analyses
    
    # Portfolio allocation
    max_positions: int = 5
    position_size_percent: float = 0.20  # 20% max per position

# Load configuration
config = TradingConfig()

# data/market_data.py
import ccxt
import pandas as pd
import websocket
import json
from datetime import datetime, timedelta
from typing import Dict, List, Optional

class MarketDataManager:
    """Handles real-time and historical market data"""
    
    def __init__(self, exchange_name: str = "binance"):
        self.exchange = getattr(ccxt, exchange_name)({
            'apiKey': config.api_key,
            'secret': config.api_secret,
            'sandbox': config.testnet,
            'enableRateLimit': True,
        })
        self.ws_connections = {}
        self.current_prices = {}
        
    def get_current_price(self, symbol: str) -> float:
        """Get current market price for symbol"""
        try:
            ticker = self.exchange.fetch_ticker(symbol)
            return ticker['last']
        except Exception as e:
            print(f"Error fetching price for {symbol}: {e}")
            return None
            
    def get_ohlcv_data(self, symbol: str, timeframe: str = '5m', limit: int = 100) -> pd.DataFrame:
        """Fetch OHLCV candlestick data"""
        try:
            ohlcv = self.exchange.fetch_ohlcv(symbol, timeframe, limit=limit)
            df = pd.DataFrame(ohlcv, columns=['timestamp', 'open', 'high', 'low', 'close', 'volume'])
            df['timestamp'] = pd.to_datetime(df['timestamp'], unit='ms')
            df.set_index('timestamp', inplace=True)
            return df
        except Exception as e:
            print(f"Error fetching OHLCV for {symbol}: {e}")
            return pd.DataFrame()
            
    def get_market_data_summary(self, symbol: str) -> Dict:
        """Get comprehensive market data for analysis"""
        try:
            # Current price and 24h stats
            ticker = self.exchange.fetch_ticker(symbol)
            
            # OHLCV data for technical analysis
            ohlcv_5m = self.get_ohlcv_data(symbol, '5m', 50)
            ohlcv_1h = self.get_ohlcv_data(symbol, '1h', 24)
            ohlcv_1d = self.get_ohlcv_data(symbol, '1d', 30)
            
            # Calculate technical indicators
            indicators = self.calculate_indicators(ohlcv_5m, ohlcv_1h)
            
            return {
                'symbol': symbol,
                'current_price': ticker['last'],
                'price_change_24h': ticker['percentage'],
                'volume_24h': ticker['baseVolume'],
                'high_24h': ticker['high'],
                'low_24h': ticker['low'],
                'timestamp': datetime.now(),
                'indicators': indicators,
                'ohlcv_5m': ohlcv_5m,
                'ohlcv_1h': ohlcv_1h,
                'ohlcv_1d': ohlcv_1d
            }
        except Exception as e:
            print(f"Error getting market summary for {symbol}: {e}")
            return None

    def calculate_indicators(self, df_5m: pd.DataFrame, df_1h: pd.DataFrame) -> Dict:
        """Calculate technical indicators for analysis"""
        indicators = {}
        
        if not df_5m.empty:
            # RSI (Relative Strength Index)
            indicators['rsi_5m'] = self.calculate_rsi(df_5m['close'])
            
            # MACD
            macd_data = self.calculate_macd(df_5m['close'])
            indicators.update(macd_data)
            
            # Bollinger Bands
            bb_data = self.calculate_bollinger_bands(df_5m['close'])
            indicators.update(bb_data)
            
            # Volume analysis
            indicators['volume_sma_20'] = df_5m['volume'].rolling(20).mean().iloc[-1]
            indicators['volume_ratio'] = df_5m['volume'].iloc[-1] / indicators['volume_sma_20']
            
        if not df_1h.empty:
            # Longer timeframe RSI
            indicators['rsi_1h'] = self.calculate_rsi(df_1h['close'])
            
            # EMA trends
            indicators['ema_12_1h'] = df_1h['close'].ewm(span=12).mean().iloc[-1]
            indicators['ema_26_1h'] = df_1h['close'].ewm(span=26).mean().iloc[-1]
            
        return indicators
    
    def calculate_rsi(self, prices: pd.Series, period: int = 14) -> float:
        """Calculate RSI indicator"""
        delta = prices.diff()
        gain = (delta.where(delta > 0, 0)).rolling(window=period).mean()
        loss = (-delta.where(delta < 0, 0)).rolling(window=period).mean()
        rs = gain / loss
        rsi = 100 - (100 / (1 + rs))
        return rsi.iloc[-1] if not rsi.empty else 50.0
    
    def calculate_macd(self, prices: pd.Series) -> Dict:
        """Calculate MACD indicator"""
        ema_12 = prices.ewm(span=12).mean()
        ema_26 = prices.ewm(span=26).mean()
        macd = ema_12 - ema_26
        signal = macd.ewm(span=9).mean()
        histogram = macd - signal
        
        return {
            'macd': macd.iloc[-1] if not macd.empty else 0,
            'macd_signal': signal.iloc[-1] if not signal.empty else 0,
            'macd_histogram': histogram.iloc[-1] if not histogram.empty else 0
        }
    
    def calculate_bollinger_bands(self, prices: pd.Series, period: int = 20) -> Dict:
        """Calculate Bollinger Bands"""
        sma = prices.rolling(window=period).mean()
        std = prices.rolling(window=period).std()
        upper_band = sma + (std * 2)
        lower_band = sma - (std * 2)
        
        current_price = prices.iloc[-1]
        bb_position = (current_price - lower_band.iloc[-1]) / (upper_band.iloc[-1] - lower_band.iloc[-1])
        
        return {
            'bb_upper': upper_band.iloc[-1] if not upper_band.empty else current_price * 1.02,
            'bb_middle': sma.iloc[-1] if not sma.empty else current_price,
            'bb_lower': lower_band.iloc[-1] if not lower_band.empty else current_price * 0.98,
            'bb_position': bb_position if not pd.isna(bb_position) else 0.5
        }

# Initialize market data manager
market_data = MarketDataManager()

# data/websocket_client.py
import websocket
import json
import threading
from typing import Callable, Dict

class CryptoWebSocketClient:
    """WebSocket client for real-time price updates"""
    
    def __init__(self, on_message_callback: Callable):
        self.on_message = on_message_callback
        self.ws = None
        self.is_connected = False
        
    def connect_binance_stream(self, symbols: List[str]):
        """Connect to Binance WebSocket stream"""
        # Convert symbols to Binance format
        streams = [f"{symbol.lower().replace('/', '')}@ticker" for symbol in symbols]
        stream_names = "/".join(streams)
        
        url = f"wss://stream.binance.com:9443/ws/{stream_names}"
        
        self.ws = websocket.WebSocketApp(
            url,
            on_open=self.on_open,
            on_message=self.on_ws_message,
            on_error=self.on_error,
            on_close=self.on_close
        )
        
        # Start WebSocket in separate thread
        ws_thread = threading.Thread(target=self.ws.run_forever)
        ws_thread.daemon = True
        ws_thread.start()
        
    def on_open(self, ws):
        """Handle WebSocket connection open"""
        print("✅ WebSocket connected")
        self.is_connected = True
        
    def on_ws_message(self, ws, message):
        """Handle incoming WebSocket messages"""
        try:
            data = json.loads(message)
            self.on_message(data)
        except Exception as e:
            print(f"Error processing WebSocket message: {e}")
            
    def on_error(self, ws, error):
        """Handle WebSocket errors"""
        print(f"❌ WebSocket error: {error}")
        self.is_connected = False
        
    def on_close(self, ws, close_status_code, close_msg):
        """Handle WebSocket connection close"""
        print("🔌 WebSocket disconnected")
        self.is_connected = False

# Example usage
def handle_price_update(data):
    """Process real-time price updates"""
    symbol = data.get('s', '').replace('USDT', '/USDT')
    price = float(data.get('c', 0))
    change_24h = float(data.get('P', 0))
    
    print(f"{symbol}: ${price:,.2f} ({change_24h:+.2f}%)")

# Initialize WebSocket client
ws_client = CryptoWebSocketClient(handle_price_update)

# analysis/deepseek_analyzer.py
import ollama
import json
from datetime import datetime
from typing import Dict, List, Optional
from dataclasses import dataclass

@dataclass
class MarketAnalysis:
    """Structure for DeepSeek-R1 analysis results"""
    symbol: str
    direction: str  # 'bullish', 'bearish', 'neutral'
    confidence: float  # 0.0 to 1.0
    entry_price: float
    target_price: float
    stop_loss: float
    position_size: float  # Percentage of portfolio
    reasoning: str
    risk_score: int  # 1-10
    timeframe: str  # '5m', '1h', '4h', '1d'
    timestamp: datetime

class DeepSeekAnalyzer:
    """DeepSeek-R1 powered market analysis"""
    
    def __init__(self, model_name: str = "deepseek-r1:7b"):
        self.model_name = model_name
        self.analysis_history = []
        
    def analyze_market(self, market_data: Dict) -> MarketAnalysis:
        """Perform comprehensive market analysis using DeepSeek-R1"""
        
        # Prepare analysis prompt
        prompt = self.create_analysis_prompt(market_data)
        
        try:
            # Get analysis from DeepSeek-R1
            response = ollama.chat(
                model=self.model_name,
                messages=[{
                    'role': 'system',
                    'content': self.get_system_prompt()
                }, {
                    'role': 'user',
                    'content': prompt
                }]
            )
            
            # Parse response into structured analysis
            analysis = self.parse_analysis_response(response['message']['content'], market_data)
            
            # Store in history for pattern recognition
            self.analysis_history.append(analysis)
            
            return analysis
            
        except Exception as e:
            print(f"Error in DeepSeek analysis: {e}")
            return self.create_neutral_analysis(market_data)
    
    def get_system_prompt(self) -> str:
        """System prompt for DeepSeek-R1 trading analysis"""
        return """You are an expert cryptocurrency trading analyst with deep knowledge of:
        - Technical analysis and chart patterns
        - Market psychology and sentiment analysis
        - Risk management and position sizing
        - Macroeconomic factors affecting crypto markets
        - Quantitative trading strategies

        Your analysis must be:
        1. Data-driven and objective
        2. Risk-aware with clear stop-loss levels
        3. Specific with exact entry and exit prices
        4. Confident but realistic about probabilities
        5. Focused on practical trading decisions

        Always provide your analysis in this JSON format:
        {
            "direction": "bullish|bearish|neutral",
            "confidence": 0.0-1.0,
            "entry_price": number,
            "target_price": number,
            "stop_loss": number,
            "position_size": 0.0-1.0,
            "risk_score": 1-10,
            "timeframe": "5m|1h|4h|1d",
            "reasoning": "detailed explanation"
        }"""
    
    def create_analysis_prompt(self, market_data: Dict) -> str:
        """Create detailed analysis prompt for DeepSeek-R1"""
        indicators = market_data.get('indicators', {})
        
        prompt = f"""
        Analyze {market_data['symbol']} for trading opportunities:

        ## Current Market Data
        - Price: ${market_data['current_price']:,.2f}
        - 24h Change: {market_data['price_change_24h']:+.2f}%
        - 24h Volume: ${market_data['volume_24h']:,.0f}
        - 24h High: ${market_data['high_24h']:,.2f}
        - 24h Low: ${market_data['low_24h']:,.2f}

        ## Technical Indicators
        - RSI (5m): {indicators.get('rsi_5m', 50):.1f}
        - RSI (1h): {indicators.get('rsi_1h', 50):.1f}
        - MACD: {indicators.get('macd', 0):.4f}
        - MACD Signal: {indicators.get('macd_signal', 0):.4f}
        - MACD Histogram: {indicators.get('macd_histogram', 0):.4f}
        - Bollinger Band Position: {indicators.get('bb_position', 0.5):.2f}
        - Volume Ratio: {indicators.get('volume_ratio', 1.0):.2f}

        ## Market Context
        - Current Time: {datetime.now().strftime('%Y-%m-%d %H:%M UTC')}
        - Trading Session: {"US" if 13 <= datetime.now().hour <= 22 else "Asian"}

        Provide a trading recommendation with specific entry/exit levels and reasoning.
        Consider current market volatility and risk factors.
        """
        
        return prompt
    
    def parse_analysis_response(self, response: str, market_data: Dict) -> MarketAnalysis:
        """Parse DeepSeek-R1 response into structured analysis"""
        try:
            # Extract JSON from response
            json_start = response.find('{')
            json_end = response.rfind('}') + 1
            json_str = response[json_start:json_end]
            
            analysis_data = json.loads(json_str)
            
            return MarketAnalysis(
                symbol=market_data['symbol'],
                direction=analysis_data.get('direction', 'neutral'),
                confidence=float(analysis_data.get('confidence', 0.5)),
                entry_price=float(analysis_data.get('entry_price', market_data['current_price'])),
                target_price=float(analysis_data.get('target_price', market_data['current_price'])),
                stop_loss=float(analysis_data.get('stop_loss', market_data['current_price'] * 0.97)),
                position_size=float(analysis_data.get('position_size', 0.1)),
                reasoning=analysis_data.get('reasoning', 'No specific reasoning provided'),
                risk_score=int(analysis_data.get('risk_score', 5)),
                timeframe=analysis_data.get('timeframe', '1h'),
                timestamp=datetime.now()
            )
            
        except Exception as e:
            print(f"Error parsing analysis response: {e}")
            return self.create_neutral_analysis(market_data)
    
    def create_neutral_analysis(self, market_data: Dict) -> MarketAnalysis:
        """Create neutral analysis as fallback"""
        return MarketAnalysis(
            symbol=market_data['symbol'],
            direction='neutral',
            confidence=0.1,
            entry_price=market_data['current_price'],
            target_price=market_data['current_price'],
            stop_loss=market_data['current_price'] * 0.97,
            position_size=0.0,
            reasoning='Analysis unavailable - staying neutral',
            risk_score=10,
            timeframe='1h',
            timestamp=datetime.now()
        )
    
    def get_market_sentiment(self, symbols: List[str]) -> Dict:
        """Analyze overall market sentiment across multiple assets"""
        sentiments = []
        
        for symbol in symbols:
            market_data = market_data_manager.get_market_data_summary(symbol)
            if market_data:
                analysis = self.analyze_market(market_data)
                sentiments.append({
                    'symbol': symbol,
                    'direction': analysis.direction,
                    'confidence': analysis.confidence,
                    'risk_score': analysis.risk_score
                })
        
        # Calculate overall market sentiment
        bullish_count = sum(1 for s in sentiments if s['direction'] == 'bullish')
        bearish_count = sum(1 for s in sentiments if s['direction'] == 'bearish')
        avg_confidence = sum(s['confidence'] for s in sentiments) / len(sentiments) if sentiments else 0
        avg_risk = sum(s['risk_score'] for s in sentiments) / len(sentiments) if sentiments else 5
        
        return {
            'overall_sentiment': 'bullish' if bullish_count > bearish_count else 'bearish' if bearish_count > bullish_count else 'neutral',
            'sentiment_strength': avg_confidence,
            'market_risk': avg_risk,
            'individual_analysis': sentiments,
            'timestamp': datetime.now()
        }

# Initialize analyzer
analyzer = DeepSeekAnalyzer()

# analysis/signal_generator.py
from dataclasses import dataclass
from typing import List, Optional
from datetime import datetime, timedelta

@dataclass
class TradingSignal:
    """Trading signal with validation"""
    symbol: str
    signal_type: str  # 'buy', 'sell', 'hold'
    strength: float  # 0.0 to 1.0
    price: float
    quantity: float
    stop_loss: float
    take_profit: float
    confidence: float
    analysis: MarketAnalysis
    is_valid: bool = True
    timestamp: datetime = None

class SignalGenerator:
    """Generates and validates trading signals"""
    
    def __init__(self, analyzer: DeepSeekAnalyzer):
        self.analyzer = analyzer
        self.signal_history = []
        
    def generate_signal(self, market_data: Dict) -> Optional[TradingSignal]:
        """Generate trading signal from market analysis"""
        
        # Get DeepSeek-R1 analysis
        analysis = self.analyzer.analyze_market(market_data)
        
        # Convert analysis to trading signal
        signal = self.create_signal_from_analysis(analysis, market_data)
        
        # Validate signal
        if signal:
            signal.is_valid = self.validate_signal(signal, market_data)
            
        # Store signal history
        if signal:
            self.signal_history.append(signal)
            
        return signal
    
    def create_signal_from_analysis(self, analysis: MarketAnalysis, market_data: Dict) -> Optional[TradingSignal]:
        """Convert analysis to actionable trading signal"""
        
        # Minimum confidence threshold
        if analysis.confidence < 0.6:
            return None
            
        # Determine signal type
        signal_type = 'hold'
        if analysis.direction == 'bullish' and analysis.confidence > 0.7:
            signal_type = 'buy'
        elif analysis.direction == 'bearish' and analysis.confidence > 0.7:
            signal_type = 'sell'
            
        if signal_type == 'hold':
            return None
            
        # Calculate position size based on confidence and risk
        base_position_size = config.position_size_percent
        risk_adjustment = (10 - analysis.risk_score) / 10  # Lower risk = higher size
        confidence_adjustment = analysis.confidence
        
        adjusted_position_size = base_position_size * risk_adjustment * confidence_adjustment
        adjusted_position_size = min(adjusted_position_size, config.position_size_percent)
        
        # Calculate quantity based on current price and position size
        current_price = market_data['current_price']
        account_balance = self.get_account_balance()  # Implement this based on your exchange
        quantity = (account_balance * adjusted_position_size) / current_price
        
        return TradingSignal(
            symbol=analysis.symbol,
            signal_type=signal_type,
            strength=analysis.confidence,
            price=analysis.entry_price,
            quantity=quantity,
            stop_loss=analysis.stop_loss,
            take_profit=analysis.target_price,
            confidence=analysis.confidence,
            analysis=analysis,
            timestamp=datetime.now()
        )
    
    def validate_signal(self, signal: TradingSignal, market_data: Dict) -> bool:
        """Validate trading signal against multiple criteria"""
        
        validation_checks = []
        
        # Check 1: Price proximity (entry price should be close to current price)
        current_price = market_data['current_price']
        price_diff_percent = abs(signal.price - current_price) / current_price
        validation_checks.append(price_diff_percent < 0.02)  # Within 2%
        
        # Check 2: Risk-reward ratio
        if signal.signal_type == 'buy':
            potential_profit = signal.take_profit - signal.price
            potential_loss = signal.price - signal.stop_loss
        else:  # sell
            potential_profit = signal.price - signal.take_profit
            potential_loss = signal.stop_loss - signal.price
            
        risk_reward_ratio = potential_profit / potential_loss if potential_loss > 0 else 0
        validation_checks.append(risk_reward_ratio >= 1.5)  # Minimum 1.5:1 ratio
        
        # Check 3: Market conditions
        indicators = market_data.get('indicators', {})
        rsi = indicators.get('rsi_5m', 50)
        
        if signal.signal_type == 'buy':
            validation_checks.append(rsi < 80)  # Not overbought
        else:
            validation_checks.append(rsi > 20)  # Not oversold
            
        # Check 4: Volume confirmation
        volume_ratio = indicators.get('volume_ratio', 1.0)
        validation_checks.append(volume_ratio > 1.2)  # Above average volume
        
        # Check 5: Recent signal frequency (avoid overtrading)
        recent_signals = [s for s in self.signal_history 
                         if s.symbol == signal.symbol 
                         and s.timestamp > datetime.now() - timedelta(hours=1)]
        validation_checks.append(len(recent_signals) < 3)  # Max 3 signals per hour
        
        # Signal is valid if all checks pass
        return all(validation_checks)
    
    def get_account_balance(self) -> float:
        """Get available account balance for trading"""
        # This should be implemented based on your exchange
        # For demo purposes, returning a fixed amount
        return 10000.0  # $10,000 USD equivalent

# Initialize signal generator
signal_generator = SignalGenerator(analyzer)

# trading/risk_manager.py
from dataclasses import dataclass
from typing import Dict, List, Optional
from datetime import datetime, timedelta
import pandas as pd

@dataclass
class RiskMetrics:
    """Portfolio risk metrics"""
    total_exposure: float
    max_single_position: float
    current_drawdown: float
    var_95: float  # Value at Risk (95% confidence)
    sharpe_ratio: float
    win_rate: float
    profit_factor: float

class RiskManager:
    """Comprehensive risk management system"""
    
    def __init__(self):
        self.max_portfolio_risk = config.max_portfolio_risk
        self.max_drawdown = config.max_drawdown
        self.position_history = []
        self.daily_pnl = []
        
    def validate_signal(self, signal: TradingSignal) -> TradingSignal:
        """Apply risk management rules to trading signal"""
        
        if not signal or not signal.is_valid:
            return signal
            
        # Risk check 1: Portfolio exposure limit
        signal = self.check_portfolio_exposure(signal)
        
        # Risk check 2: Position sizing
        signal = self.adjust_position_size(signal)
        
        # Risk check 3: Drawdown protection
        signal = self.check_drawdown_limit(signal)
        
        # Risk check 4: Correlation limits
        signal = self.check_correlation_limits(signal)
        
        # Risk check 5: Volatility adjustment
        signal = self.adjust_for_volatility(signal)
        
        return signal
    
    def check_portfolio_exposure(self, signal: TradingSignal) -> TradingSignal:
        """Ensure total portfolio exposure stays within limits"""
        
        # Calculate current portfolio exposure
        current_exposure = self.calculate_current_exposure()
        
        # Calculate new exposure if signal is executed
        signal_value = signal.quantity * signal.price
        new_exposure = current_exposure + signal_value
        
        # Get total portfolio value
        portfolio_value = self.get_portfolio_value()
        exposure_ratio = new_exposure / portfolio_value
        
        # Check if exposure exceeds limit
        if exposure_ratio > 0.8:  # Max 80% portfolio exposure
            # Reduce position size to stay within limit
            max_signal_value = (0.8 * portfolio_value) - current_exposure
            if max_signal_value > 0:
                signal.quantity = max_signal_value / signal.price
            else:
                signal.is_valid = False
                
        return signal
    
    def adjust_position_size(self, signal: TradingSignal) -> TradingSignal:
        """Adjust position size based on risk and confidence"""
        
        # Base position size from configuration
        base_size = config.position_size_percent
        
        # Adjust for signal confidence
        confidence_multiplier = signal.confidence ** 2  # Square for more conservative scaling
        
        # Adjust for volatility
        volatility_adjustment = self.get_volatility_adjustment(signal.symbol)
        
        # Adjust for recent performance
        performance_adjustment = self.get_performance_adjustment()
        
        # Calculate final position size
        adjusted_size = base_size * confidence_multiplier * volatility_adjustment * performance_adjustment
        
        # Ensure within maximum limits
        max_position = config.position_size_percent
        adjusted_size = min(adjusted_size, max_position)
        
        # Update signal quantity
        portfolio_value = self.get_portfolio_value()
        signal_value = portfolio_value * adjusted_size
        signal.quantity = signal_value / signal.price
        
        return signal
    
    def check_drawdown_limit(self, signal: TradingSignal) -> TradingSignal:
        """Check if current drawdown allows new positions"""
        
        current_drawdown = self.calculate_current_drawdown()
        
        # If drawdown is too high, reduce or stop new positions
        if current_drawdown >= config.max_drawdown * 0.8:  # 80% of max drawdown
            # Reduce position size by half
            signal.quantity *= 0.5
            
        if current_drawdown >= config.max_drawdown:
            # Stop all new positions
            signal.is_valid = False
            
        return signal
    
    def check_correlation_limits(self, signal: TradingSignal) -> TradingSignal:
        """Prevent overexposure to correlated assets"""
        
        # Get current positions
        current_positions = self.get_current_positions()
        
        # Calculate correlation with existing positions
        correlations = self.calculate_asset_correlations(signal.symbol, current_positions)
        
        # Check for high correlation exposure
        high_correlation_exposure = sum(
            pos['value'] for pos in current_positions 
            if correlations.get(pos['symbol'], 0) > 0.7
        )
        
        portfolio_value = self.get_portfolio_value()
        correlation_ratio = high_correlation_exposure / portfolio_value
        
        # Limit correlated exposure to 40% of portfolio
        if correlation_ratio > 0.4:
            reduction_factor = 0.4 / correlation_ratio
            signal.quantity *= reduction_factor
            
        return signal
    
    def adjust_for_volatility(self, signal: TradingSignal) -> TradingSignal:
        """Adjust position size based on asset volatility"""
        
        # Get historical volatility
        volatility = self.calculate_volatility(signal.symbol)
        
        # Adjust position size inversely to volatility
        # Higher volatility = smaller position
        volatility_adjustment = min(1.0, 0.2 / volatility) if volatility > 0 else 1.0
        
        signal.quantity *= volatility_adjustment
        
        return signal
    
    def calculate_current_exposure(self) -> float:
        """Calculate total current portfolio exposure"""
        positions = self.get_current_positions()
        return sum(pos['value'] for pos in positions)
    
    def calculate_current_drawdown(self) -> float:
        """Calculate current portfolio drawdown"""
        if not self.daily_pnl:
            return 0.0
            
        # Calculate running maximum
        cumulative_pnl = pd.Series(self.daily_pnl).cumsum()
        running_max = cumulative_pnl.expanding().max()
        drawdown = (cumulative_pnl - running_max) / running_max.abs()
        
        return abs(drawdown.iloc[-1]) if not drawdown.empty else 0.0
    
    def get_volatility_adjustment(self, symbol: str) -> float:
        """Calculate volatility adjustment factor"""
        try:
            # Get recent price data
            market_data_manager = MarketDataManager()
            df = market_data_manager.get_ohlcv_data(symbol, '1h', 168)  # 1 week
            
            if df.empty:
                return 1.0
                
            # Calculate 24-hour volatility
            df['returns'] = df['close'].pct_change()
            volatility = df['returns'].std() * (24 ** 0.5)  # Annualized
            
            # Adjust: lower volatility = higher multiplier
            return min(1.0, 0.02 / volatility) if volatility > 0 else 1.0
            
        except Exception as e:
            print(f"Error calculating volatility for {symbol}: {e}")
            return 1.0
    
    def get_performance_adjustment(self) -> float:
        """Adjust position size based on recent performance"""
        if len(self.daily_pnl) < 10:
            return 1.0
            
        # Calculate recent win rate
        recent_pnl = self.daily_pnl[-10:]  # Last 10 trades
        wins = sum(1 for pnl in recent_pnl if pnl > 0)
        win_rate = wins / len(recent_pnl)
        
        # Adjust based on performance
        if win_rate > 0.7:
            return 1.2  # Increase size for good performance
        elif win_rate < 0.3:
            return 0.6  # Decrease size for poor performance
        else:
            return 1.0
    
    def calculate_asset_correlations(self, symbol: str, positions: List[Dict]) -> Dict[str, float]:
        """Calculate correlations between assets"""
        correlations = {}
        
        try:
            # Get price data for symbol
            market_data_manager = MarketDataManager()
            df_main = market_data_manager.get_ohlcv_data(symbol, '1d', 30)
            
            for position in positions:
                pos_symbol = position['symbol']
                df_pos = market_data_manager.get_ohlcv_data(pos_symbol, '1d', 30)
                
                if not df_main.empty and not df_pos.empty:
                    # Calculate correlation of returns
                    returns_main = df_main['close'].pct_change().dropna()
                    returns_pos = df_pos['close'].pct_change().dropna()
                    
                    # Align data
                    aligned_data = pd.concat([returns_main, returns_pos], axis=1).dropna()
                    if len(aligned_data) > 10:
                        correlation = aligned_data.iloc[:, 0].corr(aligned_data.iloc[:, 1])
                        correlations[pos_symbol] = correlation if not pd.isna(correlation) else 0.0
                        
        except Exception as e:
            print(f"Error calculating correlations: {e}")
            
        return correlations
    
    def calculate_volatility(self, symbol: str, days: int = 30) -> float:
        """Calculate historical volatility"""
        try:
            market_data_manager = MarketDataManager()
            df = market_data_manager.get_ohlcv_data(symbol, '1d', days)
            
            if df.empty:
                return 0.02  # Default 2% daily volatility
                
            returns = df['close'].pct_change().dropna()
            return returns.std() if not returns.empty else 0.02
            
        except Exception as e:
            print(f"Error calculating volatility for {symbol}: {e}")
            return 0.02
    
    def get_current_positions(self) -> List[Dict]:
        """Get current trading positions"""
        # This should be implemented based on your exchange
        # For demo purposes, returning empty list
        return []
    
    def get_portfolio_value(self) -> float:
        """Get total portfolio value"""
        # This should be implemented based on your exchange
        # For demo purposes, returning fixed value
        return 10000.0
    
    def calculate_risk_metrics(self) -> RiskMetrics:
        """Calculate comprehensive risk metrics"""
        
        total_exposure = self.calculate_current_exposure()
        current_drawdown = self.calculate_current_drawdown()
        
        # Calculate additional metrics if we have enough data
        if len(self.daily_pnl) >= 30:
            pnl_series = pd.Series(self.daily_pnl)
            
            # Win rate
            wins = (pnl_series > 0).sum()
            win_rate = wins / len(pnl_series)
            
            # Profit factor
            gross_profit = pnl_series[pnl_series > 0].sum()
            gross_loss = abs(pnl_series[pnl_series < 0].sum())
            profit_factor = gross_profit / gross_loss if gross_loss > 0 else float('inf')
            
            # Sharpe ratio (simplified)
            avg_return = pnl_series.mean()
            return_std = pnl_series.std()
            sharpe_ratio = (avg_return / return_std) * (252 ** 0.5) if return_std > 0 else 0
            
            # Value at Risk (95% confidence)
            var_95 = pnl_series.quantile(0.05)
            
        else:
            win_rate = 0.5
            profit_factor = 1.0
            sharpe_ratio = 0.0
            var_95 = 0.0
        
        return RiskMetrics(
            total_exposure=total_exposure,
            max_single_position=max(pos['value'] for pos in self.get_current_positions()) if self.get_current_positions() else 0,
            current_drawdown=current_drawdown,
            var_95=var_95,
            sharpe_ratio=sharpe_ratio,
            win_rate=win_rate,
            profit_factor=profit_factor
        )

# Initialize risk manager
risk_manager = RiskManager()

# trading/order_executor.py
import ccxt
import time
from datetime import datetime, timedelta
from typing import Dict, List, Optional
from dataclasses import dataclass
from enum import Enum

class OrderStatus(Enum):
    PENDING = "pending"
    OPEN = "open"
    FILLED = "filled"
    CANCELLED = "cancelled"
    FAILED = "failed"

@dataclass
class Order:
    """Order tracking structure"""
    id: str
    symbol: str
    side: str  # 'buy' or 'sell'
    amount: float
    price: float
    order_type: str  # 'market', 'limit', 'stop_loss'
    status: OrderStatus
    filled_amount: float = 0.0
    average_price: float = 0.0
    timestamp: datetime = None
    exchange_order_id: str = None

@dataclass
class Position:
    """Trading position tracking"""
    symbol: str
    side: str
    size: float
    entry_price: float
    current_price: float
    unrealized_pnl: float
    realized_pnl: float
    stop_loss: float
    take_profit: float
    timestamp: datetime

class OrderExecutor:
    """Handles order execution and position management"""
    
    def __init__(self, exchange_name: str = "binance"):
        self.exchange = getattr(ccxt, exchange_name)({
            'apiKey': config.api_key,
            'secret': config.api_secret,
            'sandbox': config.testnet,
            'enableRateLimit': True,
        })
        
        self.orders = {}  # order_id -> Order
        self.positions = {}  # symbol -> Position
        self.order_counter = 0
        
    def place_order(self, signal: TradingSignal) -> Optional[Order]:
        """Place order based on trading signal"""
        
        if not signal.is_valid:
            print(f"❌ Invalid signal for {signal.symbol}")
            return None
            
        try:
            # Create order object
            order = self.create_order_from_signal(signal)
            
            # Execute on exchange
            exchange_order = self.execute_market_order(order)
            
            if exchange_order:
                order.exchange_order_id = exchange_order['id']
                order.status = OrderStatus.OPEN
                self.orders[order.id] = order
                
                # Set stop-loss and take-profit orders
                self.set_protective_orders(order, signal)
                
                print(f"✅ Order placed: {order.side.upper()} {order.amount:.6f} {order.symbol} at {order.price:.2f}")
                return order
            else:
                order.status = OrderStatus.FAILED
                print(f"❌ Failed to place order for {signal.symbol}")
                return None
                
        except Exception as e:
            print(f"❌ Error placing order for {signal.symbol}: {e}")
            return None
    
    def create_order_from_signal(self, signal: TradingSignal) -> Order:
        """Create order object from trading signal"""
        
        self.order_counter += 1
        
        return Order(
            id=f"order_{self.order_counter:06d}",
            symbol=signal.symbol,
            side=signal.signal_type,  # 'buy' or 'sell'
            amount=signal.quantity,
            price=signal.price,
            order_type='market',
            status=OrderStatus.PENDING,
            timestamp=datetime.now()
        )
    
    def execute_market_order(self, order: Order) -> Optional[Dict]:
        """Execute market order on exchange"""
        
        try:
            # Place market order
            exchange_order = self.exchange.create_market_order(
                symbol=order.symbol,
                side=order.side,
                amount=order.amount
            )
            
            # Update order with execution details
            if exchange_order['status'] == 'closed':
                order.status = OrderStatus.FILLED
                order.filled_amount = exchange_order['filled']
                order.average_price = exchange_order['average'] or exchange_order['price']
                
                # Update position
                self.update_position(order)
                
            return exchange_order
            
        except Exception as e:
            print(f"Error executing market order: {e}")
            return None
    
    def set_protective_orders(self, order: Order, signal: TradingSignal):
        """Set stop-loss and take-profit orders"""
        
        if order.status != OrderStatus.FILLED:
            return
            
        try:
            # Stop-loss order
            if signal.stop_loss and signal.stop_loss != order.average_price:
                stop_loss_side = 'sell' if order.side == 'buy' else 'buy'
                
                stop_order = self.exchange.create_order(
                    symbol=order.symbol,
                    type='stop_loss',
                    side=stop_loss_side,
                    amount=order.filled_amount,
                    price=signal.stop_loss,
                    params={'stopPrice': signal.stop_loss}
                )
                
                print(f"📍 Stop-loss set at ${signal.stop_loss:.2f}")
            
            # Take-profit order
            if signal.take_profit and signal.take_profit != order.average_price:
                take_profit_side = 'sell' if order.side == 'buy' else 'buy'
                
                limit_order = self.exchange.create_limit_order(
                    symbol=order.symbol,
                    side=take_profit_side,
                    amount=order.filled_amount,
                    price=signal.take_profit
                )
                
                print(f"🎯 Take-profit set at ${signal.take_profit:.2f}")
                
        except Exception as e:
            print(f"Error setting protective orders: {e}")
    
    def update_position(self, order: Order):
        """Update position tracking"""
        
        symbol = order.symbol
        
        if symbol not in self.positions:
            # Create new position
            self.positions[symbol] = Position(
                symbol=symbol,
                side=order.side,
                size=order.filled_amount,
                entry_price=order.average_price,
                current_price=order.average_price,
                unrealized_pnl=0.0,
                realized_pnl=0.0,
                stop_loss=0.0,
                take_profit=0.0,
                timestamp=order.timestamp
            )
        else:
            # Update existing position
            position = self.positions[symbol]
            
            if position.side == order.side:
                # Add to position
                total_cost = (position.size * position.entry_price) + (order.filled_amount * order.average_price)
                total_size = position.size + order.filled_amount
                position.entry_price = total_cost / total_size
                position.size = total_size
            else:
                # Close or reduce position
                if order.filled_amount >= position.size:
                    # Close position completely
                    self.close_position(symbol, order.average_price)
                else:
                    # Reduce position
                    position.size -= order.filled_amount
    
    def close_position(self, symbol: str, exit_price: float):
        """Close position and calculate P&L"""
        
        if symbol not in self.positions:
            return
            
        position = self.positions[symbol]
        
        # Calculate realized P&L
        if position.side == 'buy':
            pnl = (exit_price - position.entry_price) * position.size
        else:
            pnl = (position.entry_price - exit_price) * position.size
            
        position.realized_pnl += pnl
        
        print(f"📊 Position closed: {symbol} P&L: ${pnl:+.2f}")
        
        # Remove position
        del self.positions[symbol]
        
        # Log to risk manager
        risk_manager.daily_pnl.append(pnl)
    
    def update_positions_prices(self):
        """Update current prices and unrealized P&L for all positions"""
        
        for symbol, position in self.positions.items():
            try:
                # Get current market price
                ticker = self.exchange.fetch_ticker(symbol)
                current_price = ticker['last']
                
                position.current_price = current_price
                
                # Calculate unrealized P&L
                if position.side == 'buy':
                    position.unrealized_pnl = (current_price - position.entry_price) * position.size
                else:
                    position.unrealized_pnl = (position.entry_price - current_price) * position.size
                    
            except Exception as e:
                print(f"Error updating price for {symbol}: {e}")
    
    def check_open_orders(self):
        """Check status of open orders"""
        
        for order_id, order in self.orders.items():
            if order.status in [OrderStatus.OPEN, OrderStatus.PENDING]:
                try:
                    # Fetch order status from exchange
                    exchange_order = self.exchange.fetch_order(order.exchange_order_id, order.symbol)
                    
                    # Update order status
                    if exchange_order['status'] == 'closed':
                        order.status = OrderStatus.FILLED
                        order.filled_amount = exchange_order['filled']
                        order.average_price = exchange_order['average']
                        
                        # Update position
                        self.update_position(order)
                        
                    elif exchange_order['status'] == 'canceled':
                        order.status = OrderStatus.CANCELLED
                        
                except Exception as e:
                    print(f"Error checking order {order_id}: {e}")
    
    def cancel_order(self, order_id: str) -> bool:
        """Cancel open order"""
        
        if order_id not in self.orders:
            return False
            
        order = self.orders[order_id]
        
        try:
            self.exchange.cancel_order(order.exchange_order_id, order.symbol)
            order.status = OrderStatus.CANCELLED
            print(f"❌ Order cancelled: {order_id}")
            return True
            
        except Exception as e:
            print(f"Error cancelling order {order_id}: {e}")
            return False
    
    def get_portfolio_summary(self) -> Dict:
        """Get comprehensive portfolio summary"""
        
        # Update all position prices
        self.update_positions_prices()
        
        total_value = 0.0
        total_pnl = 0.0
        
        position_details = []
        
        for symbol, position in self.positions.items():
            position_value = position.size * position.current_price
            total_value += position_value
            total_pnl += position.unrealized_pnl + position.realized_pnl
            
            position_details.append({
                'symbol': symbol,
                'side': position.side,
                'size': position.size,
                'entry_price': position.entry_price,
                'current_price': position.current_price,
                'value': position_value,
                'unrealized_pnl': position.unrealized_pnl,
                'pnl_percent': (position.unrealized_pnl / (position.size * position.entry_price)) * 100
            })
        
        return {
            'total_positions': len(self.positions),
            'total_value': total_value,
            'total_pnl': total_pnl,
            'positions': position_details,
            'timestamp': datetime.now()
        }

# Initialize order executor
order_executor = OrderExecutor()