mcli-framework 7.2.0__py3-none-any.whl → 7.3.1__py3-none-any.whl

mcli/ml/trading/paper_trading.py

@@ -0,0 +1,326 @@
+"""Paper trading implementation for testing portfolios without real money"""
+
+import logging
+from datetime import datetime, timedelta
+from decimal import Decimal
+from typing import Dict, List, Optional, Tuple
+from uuid import UUID
+
+import pandas as pd
+import yfinance as yf
+from sqlalchemy.orm import Session
+
+from mcli.ml.trading.models import (
+    Portfolio, Position, TradingOrder, OrderStatus, OrderType, OrderSide, PositionSide
+)
+from mcli.ml.trading.trading_service import TradingService
+
+logger = logging.getLogger(__name__)
+
+
+class PaperTradingEngine:
+    """Paper trading engine for testing strategies without real money"""
+    
+    def __init__(self, trading_service: TradingService):
+        self.trading_service = trading_service
+        self.db = trading_service.db
+    
+    def execute_paper_order(self, order: TradingOrder) -> bool:
+        """Execute a paper trade order"""
+        try:
+            # Get current market price
+            current_price = self._get_current_price(order.symbol)
+            if current_price is None:
+                logger.error(f"Could not get current price for {order.symbol}")
+                return False
+            
+            # Calculate execution details
+            if order.order_type == OrderType.MARKET:
+                execution_price = current_price
+            elif order.order_type == OrderType.LIMIT:
+                if order.side == OrderSide.BUY and order.limit_price >= current_price:
+                    execution_price = current_price
+                elif order.side == OrderSide.SELL and order.limit_price <= current_price:
+                    execution_price = current_price
+                else:
+                    # Order not executed
+                    order.status = OrderStatus.CANCELLED
+                    order.cancelled_at = datetime.utcnow()
+                    self.db.commit()
+                    return False
+            else:
+                logger.error(f"Unsupported order type for paper trading: {order.order_type}")
+                return False
+            
+            # Execute the order
+            order.status = OrderStatus.FILLED
+            order.filled_at = datetime.utcnow()
+            order.filled_quantity = order.quantity
+            order.remaining_quantity = 0
+            order.average_fill_price = Decimal(str(execution_price))
+            
+            # Update portfolio and positions
+            self._update_portfolio_positions(order, execution_price)
+            
+            self.db.commit()
+            logger.info(f"Paper trade executed: {order.symbol} {order.side.value} {order.quantity} @ ${execution_price}")
+            return True
+            
+        except Exception as e:
+            logger.error(f"Failed to execute paper order: {e}")
+            self.db.rollback()
+            return False
+    
+    def _get_current_price(self, symbol: str) -> Optional[float]:
+        """Get current market price for a symbol"""
+        try:
+            ticker = yf.Ticker(symbol)
+            data = ticker.history(period="1d", interval="1m")
+            if not data.empty:
+                return float(data["Close"].iloc[-1])
+            return None
+        except Exception as e:
+            logger.error(f"Failed to get price for {symbol}: {e}")
+            return None
+    
+    def _update_portfolio_positions(self, order: TradingOrder, execution_price: float):
+        """Update portfolio positions after order execution"""
+        try:
+            portfolio = self.trading_service.get_portfolio(order.portfolio_id)
+            if not portfolio:
+                return
+            
+            # Calculate trade value
+            trade_value = execution_price * order.quantity
+            
+            if order.side == OrderSide.BUY:
+                # Buying shares
+                portfolio.cash_balance -= Decimal(str(trade_value))
+                
+                # Update or create position
+                position = self.db.query(Position).filter(
+                    Position.portfolio_id == order.portfolio_id,
+                    Position.symbol == order.symbol
+                ).first()
+                
+                if position:
+                    # Update existing position
+                    total_quantity = position.quantity + order.quantity
+                    total_cost = (position.cost_basis * position.quantity) + trade_value
+                    new_avg_price = total_cost / total_quantity
+                    
+                    position.quantity = total_quantity
+                    position.average_price = new_avg_price
+                    position.cost_basis = total_cost
+                    position.current_price = Decimal(str(execution_price))
+                    position.market_value = total_quantity * execution_price
+                    position.unrealized_pnl = position.market_value - total_cost
+                    position.unrealized_pnl_pct = float(position.unrealized_pnl / total_cost * 100)
+                else:
+                    # Create new position
+                    position = Position(
+                        portfolio_id=order.portfolio_id,
+                        symbol=order.symbol,
+                        quantity=order.quantity,
+                        side=PositionSide.LONG,
+                        average_price=Decimal(str(execution_price)),
+                        current_price=Decimal(str(execution_price)),
+                        market_value=Decimal(str(trade_value)),
+                        cost_basis=Decimal(str(trade_value)),
+                        unrealized_pnl=Decimal("0"),
+                        unrealized_pnl_pct=0.0,
+                        realized_pnl=Decimal("0"),
+                        position_size_pct=0.0,
+                        weight=0.0,
+                    )
+                    self.db.add(position)
+            
+            else:  # SELL
+                # Selling shares
+                portfolio.cash_balance += Decimal(str(trade_value))
+                
+                # Update position
+                position = self.db.query(Position).filter(
+                    Position.portfolio_id == order.portfolio_id,
+                    Position.symbol == order.symbol
+                ).first()
+                
+                if position and position.quantity >= order.quantity:
+                    # Calculate realized P&L
+                    cost_basis = position.cost_basis * (order.quantity / position.quantity)
+                    realized_pnl = trade_value - float(cost_basis)
+                    
+                    # Update position
+                    position.quantity -= order.quantity
+                    position.cost_basis -= cost_basis
+                    position.realized_pnl += Decimal(str(realized_pnl))
+                    
+                    if position.quantity == 0:
+                        # Remove position if fully sold
+                        self.db.delete(position)
+                    else:
+                        # Update remaining position
+                        position.current_price = Decimal(str(execution_price))
+                        position.market_value = position.quantity * execution_price
+                        position.unrealized_pnl = position.market_value - position.cost_basis
+                        if position.cost_basis > 0:
+                            position.unrealized_pnl_pct = float(position.unrealized_pnl / position.cost_basis * 100)
+            
+            # Update portfolio value
+            self._update_portfolio_value(portfolio)
+            
+        except Exception as e:
+            logger.error(f"Failed to update portfolio positions: {e}")
+            raise
+    
+    def _update_portfolio_value(self, portfolio: Portfolio):
+        """Update portfolio value and metrics"""
+        try:
+            # Get all positions
+            positions = self.db.query(Position).filter(Position.portfolio_id == portfolio.id).all()
+            
+            # Calculate total market value
+            total_market_value = sum(float(pos.market_value) for pos in positions)
+            portfolio.current_value = Decimal(str(total_market_value + float(portfolio.cash_balance)))
+            
+            # Calculate returns
+            if portfolio.initial_capital > 0:
+                total_return = portfolio.current_value - portfolio.initial_capital
+                portfolio.total_return = float(total_return)
+                portfolio.total_return_pct = float(total_return / portfolio.initial_capital * 100)
+            
+            # Update position weights
+            for position in positions:
+                if portfolio.current_value > 0:
+                    position.weight = float(position.market_value / portfolio.current_value)
+                    position.position_size_pct = position.weight * 100
+            
+        except Exception as e:
+            logger.error(f"Failed to update portfolio value: {e}")
+            raise
+    
+    def simulate_market_movement(self, portfolio_id: UUID, days: int = 1):
+        """Simulate market movement for paper trading"""
+        try:
+            portfolio = self.trading_service.get_portfolio(portfolio_id)
+            if not portfolio:
+                return
+            
+            positions = self.db.query(Position).filter(Position.portfolio_id == portfolio_id).all()
+            
+            for position in positions:
+                # Get historical data for the symbol
+                ticker = yf.Ticker(position.symbol)
+                end_date = datetime.now()
+                start_date = end_date - timedelta(days=days + 5)  # Get extra days for weekend handling
+                
+                data = ticker.history(start=start_date, end=end_date)
+                if not data.empty:
+                    # Get the most recent price
+                    new_price = float(data["Close"].iloc[-1])
+                    
+                    # Update position
+                    position.current_price = Decimal(str(new_price))
+                    position.market_value = position.quantity * new_price
+                    position.unrealized_pnl = position.market_value - position.cost_basis
+                    if position.cost_basis > 0:
+                        position.unrealized_pnl_pct = float(position.unrealized_pnl / position.cost_basis * 100)
+            
+            # Update portfolio value
+            self._update_portfolio_value(portfolio)
+            self.db.commit()
+            
+            logger.info(f"Simulated market movement for portfolio {portfolio_id}")
+            
+        except Exception as e:
+            logger.error(f"Failed to simulate market movement: {e}")
+            self.db.rollback()
+    
+    def create_test_portfolio(
+        self, 
+        user_id: UUID, 
+        name: str = "Test Portfolio",
+        initial_capital: float = 100000.0
+    ) -> Portfolio:
+        """Create a test portfolio for paper trading"""
+        try:
+            # Create trading account
+            from mcli.ml.trading.models import TradingAccountCreate
+            account_data = TradingAccountCreate(
+                account_name="Test Account",
+                account_type="test",
+                paper_trading=True
+            )
+            account = self.trading_service.create_trading_account(user_id, account_data)
+            
+            # Create portfolio
+            portfolio_data = PortfolioCreate(
+                name=name,
+                description="Test portfolio for paper trading",
+                initial_capital=initial_capital
+            )
+            portfolio = self.trading_service.create_portfolio(account.id, portfolio_data)
+            
+            logger.info(f"Created test portfolio {portfolio.id} for user {user_id}")
+            return portfolio
+            
+        except Exception as e:
+            logger.error(f"Failed to create test portfolio: {e}")
+            raise
+    
+    def run_backtest(
+        self, 
+        portfolio_id: UUID, 
+        start_date: datetime, 
+        end_date: datetime,
+        initial_capital: float = 100000.0
+    ) -> Dict:
+        """Run a backtest on historical data"""
+        try:
+            portfolio = self.trading_service.get_portfolio(portfolio_id)
+            if not portfolio:
+                raise ValueError("Portfolio not found")
+            
+            # Reset portfolio to initial state
+            portfolio.current_value = Decimal(str(initial_capital))
+            portfolio.cash_balance = Decimal(str(initial_capital))
+            portfolio.total_return = 0.0
+            portfolio.total_return_pct = 0.0
+            
+            # Clear existing positions
+            self.db.query(Position).filter(Position.portfolio_id == portfolio_id).delete()
+            
+            # Get historical data for the period
+            date_range = pd.date_range(start=start_date, end=end_date, freq='D')
+            
+            # This is a simplified backtest - in practice you'd want to:
+            # 1. Get historical signals
+            # 2. Execute trades based on signals
+            # 3. Track performance over time
+            
+            backtest_results = {
+                "start_date": start_date,
+                "end_date": end_date,
+                "initial_capital": initial_capital,
+                "final_value": float(portfolio.current_value),
+                "total_return": float(portfolio.total_return),
+                "total_return_pct": portfolio.total_return_pct,
+                "trades_executed": 0,
+                "max_drawdown": 0.0,
+                "sharpe_ratio": 0.0,
+            }
+            
+            self.db.commit()
+            logger.info(f"Backtest completed for portfolio {portfolio_id}")
+            return backtest_results
+            
+        except Exception as e:
+            logger.error(f"Failed to run backtest: {e}")
+            self.db.rollback()
+            raise
+
+
+def create_paper_trading_engine(db_session: Session) -> PaperTradingEngine:
+    """Create a paper trading engine"""
+    trading_service = TradingService(db_session)
+    return PaperTradingEngine(trading_service)

mcli/ml/trading/risk_management.py

@@ -0,0 +1,370 @@
+"""Risk management module for trading portfolios"""
+
+import logging
+from datetime import datetime, timedelta
+from typing import Dict, List, Optional, Tuple
+from uuid import UUID
+
+import numpy as np
+import pandas as pd
+from sqlalchemy.orm import Session
+
+from mcli.ml.trading.models import Portfolio, Position, TradingOrder, RiskLevel
+from mcli.ml.trading.trading_service import TradingService
+
+logger = logging.getLogger(__name__)
+
+
+class RiskManager:
+    """Risk management system for trading portfolios"""
+    
+    def __init__(self, trading_service: TradingService):
+        self.trading_service = trading_service
+        self.db = trading_service.db
+    
+    def calculate_portfolio_risk(self, portfolio_id: UUID) -> Dict:
+        """Calculate comprehensive risk metrics for a portfolio"""
+        try:
+            portfolio = self.trading_service.get_portfolio(portfolio_id)
+            if not portfolio:
+                return {}
+            
+            positions = self.trading_service.get_portfolio_positions(portfolio_id)
+            
+            if not positions:
+                return {
+                    "total_risk": 0.0,
+                    "concentration_risk": 0.0,
+                    "var_95": 0.0,
+                    "cvar_95": 0.0,
+                    "max_position_risk": 0.0,
+                    "portfolio_beta": 1.0,
+                    "risk_score": 0.0,
+                }
+            
+            # Calculate individual position risks
+            position_risks = []
+            total_market_value = sum(pos.market_value for pos in positions)
+            
+            for position in positions:
+                position_risk = self._calculate_position_risk(position, total_market_value)
+                position_risks.append(position_risk)
+            
+            # Calculate portfolio-level risk metrics
+            portfolio_risk = self._calculate_portfolio_risk_metrics(positions, position_risks)
+            
+            return portfolio_risk
+            
+        except Exception as e:
+            logger.error(f"Failed to calculate portfolio risk: {e}")
+            return {}
+    
+    def _calculate_position_risk(self, position: Position, total_market_value: float) -> Dict:
+        """Calculate risk metrics for an individual position"""
+        try:
+            # Position size as percentage of portfolio
+            position_size_pct = (position.market_value / total_market_value) * 100
+            
+            # Volatility estimate (simplified - in practice, use historical data)
+            volatility = self._estimate_volatility(position.symbol)
+            
+            # Value at Risk (simplified calculation)
+            var_95 = position.market_value * volatility * 1.645  # 95% VaR
+            
+            # Position risk score (combination of size and volatility)
+            risk_score = position_size_pct * volatility * 100
+            
+            return {
+                "symbol": position.symbol,
+                "position_size_pct": position_size_pct,
+                "volatility": volatility,
+                "var_95": var_95,
+                "risk_score": risk_score,
+                "market_value": position.market_value,
+            }
+            
+        except Exception as e:
+            logger.error(f"Failed to calculate position risk for {position.symbol}: {e}")
+            return {}
+    
+    def _estimate_volatility(self, symbol: str, days: int = 30) -> float:
+        """Estimate volatility for a symbol (simplified)"""
+        try:
+            # In practice, you would calculate historical volatility
+            # For now, use a simplified approach based on market cap and sector
+            import yfinance as yf
+            
+            ticker = yf.Ticker(symbol)
+            data = ticker.history(period=f"{days}d")
+            
+            if not data.empty and len(data) > 1:
+                returns = data["Close"].pct_change().dropna()
+                volatility = returns.std() * np.sqrt(252)  # Annualized
+                return min(volatility, 1.0)  # Cap at 100%
+            
+            # Default volatility based on symbol characteristics
+            if symbol in ["AAPL", "MSFT", "GOOGL", "AMZN"]:
+                return 0.25  # Large cap tech
+            elif symbol in ["TSLA", "NVDA", "AMD"]:
+                return 0.45  # High volatility tech
+            else:
+                return 0.30  # Default
+            
+        except Exception as e:
+            logger.error(f"Failed to estimate volatility for {symbol}: {e}")
+            return 0.30  # Default volatility
+    
+    def _calculate_portfolio_risk_metrics(self, positions: List, position_risks: List[Dict]) -> Dict:
+        """Calculate portfolio-level risk metrics"""
+        try:
+            if not positions or not position_risks:
+                return {}
+            
+            # Total portfolio risk (sum of individual position risks)
+            total_risk = sum(risk["risk_score"] for risk in position_risks)
+            
+            # Concentration risk (Herfindahl-Hirschman Index)
+            weights = [pos.weight for pos in positions]
+            concentration_risk = sum(w**2 for w in weights) * 100
+            
+            # Portfolio Value at Risk (simplified)
+            portfolio_var = sum(risk["var_95"] for risk in position_risks)
+            
+            # Conditional Value at Risk (simplified)
+            portfolio_cvar = portfolio_var * 1.3  # Rough approximation
+            
+            # Maximum position risk
+            max_position_risk = max(risk["risk_score"] for risk in position_risks) if position_risks else 0
+            
+            # Portfolio beta (simplified - assume equal weight)
+            portfolio_beta = np.mean([self._estimate_beta(pos.symbol) for pos in positions])
+            
+            # Overall risk score (0-100)
+            risk_score = min(total_risk + concentration_risk, 100)
+            
+            return {
+                "total_risk": total_risk,
+                "concentration_risk": concentration_risk,
+                "var_95": portfolio_var,
+                "cvar_95": portfolio_cvar,
+                "max_position_risk": max_position_risk,
+                "portfolio_beta": portfolio_beta,
+                "risk_score": risk_score,
+                "num_positions": len(positions),
+            }
+            
+        except Exception as e:
+            logger.error(f"Failed to calculate portfolio risk metrics: {e}")
+            return {}
+    
+    def _estimate_beta(self, symbol: str) -> float:
+        """Estimate beta for a symbol (simplified)"""
+        try:
+            # In practice, calculate beta against market index
+            # For now, use simplified estimates
+            beta_estimates = {
+                "AAPL": 1.2, "MSFT": 1.1, "GOOGL": 1.3, "AMZN": 1.4,
+                "TSLA": 2.0, "NVDA": 1.8, "AMD": 1.6, "META": 1.5,
+                "JPM": 1.3, "BAC": 1.4, "WMT": 0.5, "JNJ": 0.7,
+            }
+            return beta_estimates.get(symbol, 1.0)
+        except Exception as e:
+            logger.error(f"Failed to estimate beta for {symbol}: {e}")
+            return 1.0
+    
+    def check_risk_limits(self, portfolio_id: UUID, new_order: Dict) -> Tuple[bool, List[str]]:
+        """Check if a new order would violate risk limits"""
+        try:
+            portfolio = self.trading_service.get_portfolio(portfolio_id)
+            if not portfolio:
+                return False, ["Portfolio not found"]
+            
+            warnings = []
+            
+            # Get current positions
+            positions = self.trading_service.get_portfolio_positions(portfolio_id)
+            
+            # Calculate new position size
+            symbol = new_order["symbol"]
+            quantity = new_order["quantity"]
+            side = new_order["side"]
+            
+            # Estimate order value (simplified)
+            order_value = self._estimate_order_value(symbol, quantity)
+            new_position_size_pct = (order_value / float(portfolio.current_value)) * 100
+            
+            # Check position size limits
+            max_position_size = 10.0  # 10% default
+            if new_position_size_pct > max_position_size:
+                warnings.append(f"Position size ({new_position_size_pct:.1f}%) exceeds limit ({max_position_size}%)")
+            
+            # Check if adding to existing position
+            existing_position = next((pos for pos in positions if pos.symbol == symbol), None)
+            if existing_position:
+                if side == "buy":
+                    new_total_size = ((existing_position.market_value + order_value) / float(portfolio.current_value)) * 100
+                    if new_total_size > max_position_size:
+                        warnings.append(f"Total position size ({new_total_size:.1f}%) would exceed limit")
+            
+            # Check portfolio concentration
+            if len(positions) >= 10:  # Max 10 positions
+                warnings.append("Portfolio already has maximum number of positions")
+            
+            # Check buying power
+            if side == "buy" and order_value > float(portfolio.cash_balance):
+                warnings.append("Insufficient buying power for this order")
+            
+            # Check risk level compliance
+            risk_level = getattr(portfolio, 'risk_level', RiskLevel.MODERATE)
+            if risk_level == RiskLevel.CONSERVATIVE and new_position_size_pct > 5.0:
+                warnings.append("Position size too large for conservative risk level")
+            elif risk_level == RiskLevel.AGGRESSIVE and new_position_size_pct > 20.0:
+                warnings.append("Position size too large for aggressive risk level")
+            
+            return len(warnings) == 0, warnings
+            
+        except Exception as e:
+            logger.error(f"Failed to check risk limits: {e}")
+            return False, [f"Risk check failed: {e}"]
+    
+    def _estimate_order_value(self, symbol: str, quantity: int) -> float:
+        """Estimate the value of an order"""
+        try:
+            import yfinance as yf
+            ticker = yf.Ticker(symbol)
+            data = ticker.history(period="1d")
+            if not data.empty:
+                price = float(data["Close"].iloc[-1])
+                return price * quantity
+            return 0.0
+        except Exception as e:
+            logger.error(f"Failed to estimate order value for {symbol}: {e}")
+            return 0.0
+    
+    def calculate_position_size(
+        self, 
+        portfolio_id: UUID, 
+        symbol: str, 
+        signal_strength: float,
+        risk_level: RiskLevel = RiskLevel.MODERATE
+    ) -> float:
+        """Calculate recommended position size based on signal strength and risk level"""
+        try:
+            portfolio = self.trading_service.get_portfolio(portfolio_id)
+            if not portfolio:
+                return 0.0
+            
+            # Base position size based on risk level
+            base_sizes = {
+                RiskLevel.CONSERVATIVE: 0.02,  # 2%
+                RiskLevel.MODERATE: 0.05,      # 5%
+                RiskLevel.AGGRESSIVE: 0.10,    # 10%
+            }
+            base_size = base_sizes.get(risk_level, 0.05)
+            
+            # Adjust based on signal strength
+            signal_multiplier = min(signal_strength * 2, 2.0)  # Cap at 2x
+            
+            # Calculate recommended position size
+            recommended_size = base_size * signal_multiplier
+            
+            # Cap at maximum position size
+            max_position_size = 0.20  # 20% max
+            recommended_size = min(recommended_size, max_position_size)
+            
+            # Convert to dollar amount
+            position_value = float(portfolio.current_value) * recommended_size
+            
+            return position_value
+            
+        except Exception as e:
+            logger.error(f"Failed to calculate position size: {e}")
+            return 0.0
+    
+    def generate_risk_report(self, portfolio_id: UUID) -> Dict:
+        """Generate comprehensive risk report for a portfolio"""
+        try:
+            portfolio = self.trading_service.get_portfolio(portfolio_id)
+            if not portfolio:
+                return {}
+            
+            # Get risk metrics
+            risk_metrics = self.calculate_portfolio_risk(portfolio_id)
+            
+            # Get performance data
+            performance_df = self.trading_service.get_portfolio_performance(portfolio_id, days=30)
+            
+            # Calculate additional metrics
+            max_drawdown = 0.0
+            if not performance_df.empty:
+                cumulative_returns = (1 + performance_df["daily_return_pct"] / 100).cumprod()
+                running_max = cumulative_returns.expanding().max()
+                drawdown = (cumulative_returns - running_max) / running_max
+                max_drawdown = abs(drawdown.min()) * 100
+            
+            # Risk assessment
+            risk_level = "LOW"
+            if risk_metrics.get("risk_score", 0) > 70:
+                risk_level = "HIGH"
+            elif risk_metrics.get("risk_score", 0) > 40:
+                risk_level = "MEDIUM"
+            
+            # Generate recommendations
+            recommendations = self._generate_risk_recommendations(risk_metrics, max_drawdown)
+            
+            return {
+                "portfolio_id": str(portfolio_id),
+                "risk_level": risk_level,
+                "risk_score": risk_metrics.get("risk_score", 0),
+                "max_drawdown": max_drawdown,
+                "concentration_risk": risk_metrics.get("concentration_risk", 0),
+                "var_95": risk_metrics.get("var_95", 0),
+                "cvar_95": risk_metrics.get("cvar_95", 0),
+                "portfolio_beta": risk_metrics.get("portfolio_beta", 1.0),
+                "num_positions": risk_metrics.get("num_positions", 0),
+                "recommendations": recommendations,
+                "generated_at": datetime.utcnow().isoformat(),
+            }
+            
+        except Exception as e:
+            logger.error(f"Failed to generate risk report: {e}")
+            return {}
+    
+    def _generate_risk_recommendations(self, risk_metrics: Dict, max_drawdown: float) -> List[str]:
+        """Generate risk management recommendations"""
+        recommendations = []
+        
+        # Concentration risk
+        if risk_metrics.get("concentration_risk", 0) > 50:
+            recommendations.append("Consider diversifying portfolio - concentration risk is high")
+        
+        # Position count
+        if risk_metrics.get("num_positions", 0) < 5:
+            recommendations.append("Consider adding more positions for better diversification")
+        elif risk_metrics.get("num_positions", 0) > 15:
+            recommendations.append("Consider reducing number of positions for better focus")
+        
+        # Risk score
+        if risk_metrics.get("risk_score", 0) > 70:
+            recommendations.append("Portfolio risk is high - consider reducing position sizes")
+        
+        # Drawdown
+        if max_drawdown > 20:
+            recommendations.append("Maximum drawdown is high - consider risk management strategies")
+        
+        # Beta
+        if risk_metrics.get("portfolio_beta", 1.0) > 1.5:
+            recommendations.append("Portfolio beta is high - consider adding defensive positions")
+        elif risk_metrics.get("portfolio_beta", 1.0) < 0.5:
+            recommendations.append("Portfolio beta is low - consider adding growth positions")
+        
+        if not recommendations:
+            recommendations.append("Portfolio risk profile looks good - no immediate concerns")
+        
+        return recommendations
+
+
+def create_risk_manager(db_session: Session) -> RiskManager:
+    """Create a risk manager instance"""
+    trading_service = TradingService(db_session)
+    return RiskManager(trading_service)