add a risk management module

.env.example

@@ -3,6 +3,7 @@ FINNHUB_API_TOKEN=
 SPACE_ID=
 GEMINI_API_TOKEN=
 OPENROUTER_API_TOKEN=
+OPENROUTER_API_TOKEN_2=
 GOOGLE_APPS_SCRIPT_URL=
 WEBHOOK_SECRET=
 SPACE_URL=

requirements.txt

@@ -4,9 +4,13 @@ fastapi==0.104.1
 uvicorn[standard]==0.24.0
 httpx>=0.25.0
 python-dotenv==1.0.0
-pydantic==2.5.0
+pydantic==2.11.7
 typing-extensions==4.8.0
 pytz==2025.2
 datasets
 huggingface_hub
-pandas
+numpy==1.24.3
+pandas==2.0.3
+yfinance==0.2.65
+google-genai==1.29.0
+TA-Lib==0.6.5

src/core/risk_management/risk_analyzer.py

@@ -0,0 +1,376 @@
+from datetime import datetime, timedelta
+import os
+from typing import Any
+import warnings
+import asyncio
+
+import yfinance as yf
+import numpy as np
+import pandas as pd
+from google import genai
+from google.genai import types
+import talib
+
+
+warnings.filterwarnings('ignore')
+
+
+class RiskAnalyzer:
+    def __init__(self, gemini_api_key: str):
+        self._model_name = 'gemini-2.0-flash-001'
+        self.client = genai.Client(
+            api_key=gemini_api_key,
+            http_options=types.HttpOptions(api_version='v1')
+        )
+
+    def get_stock_data(self, ticker: str, period: str = "3mo") -> pd.DataFrame:
+        try:
+            stock = yf.Ticker(ticker)
+            data = stock.history(period=period)
+            return data
+        except Exception as e:
+            raise Exception(f"Error retrieving data for {ticker}: {str(e)}")
+
+    def calculate_basic_metrics(self, data: pd.DataFrame) -> dict[str, float]:
+        """
+        Calculate basic risk metrics for the stock data.
+
+        Args:
+            data (pd.DataFrame): DataFrame with stock prices including 'Close' column.
+        Returns:
+            dict[str, float]: Dictionary with calculated risk metrics.
+        """
+        prices = data['Close']
+        returns = prices.pct_change().dropna()
+
+        # Calculate basic metrics
+        volatility = returns.std() * np.sqrt(252)
+        var_5 = np.percentile(returns, 5)
+        max_drawdown = self.calculate_max_drawdown(prices)
+        sharpe_ratio = self.calculate_sharpe_ratio(returns)
+        sortino_ratio = self.calculate_sortino_ratio(returns)
+        beta = self.calculate_beta(prices)
+
+        return {
+            'volatility': volatility,
+            'var_5': var_5,
+            'max_drawdown': max_drawdown,
+            'sharpe_ratio': sharpe_ratio,
+            'sortino_ratio': sortino_ratio,
+            'beta': beta
+        }
+
+    def calculate_technical_indicators(self, data: pd.DataFrame) -> dict[str, Any]:
+        """
+        Calculate technical indicators for the stock data.
+
+        Args:
+            data (pd.DataFrame): DataFrame with stock prices including 'High', 'Low', 'Close', and 'Volume' columns.
+        Returns:
+            dict[str, Any]: Dictionary with calculated technical indicators.
+        """
+        high = data['High'].values
+        low = data['Low'].values
+        close = data['Close'].values
+        volume = data['Volume'].values
+
+        # Calculate moving averages
+        ema_20 = talib.EMA(close, timeperiod=20)
+        ema_50 = talib.EMA(close, timeperiod=50)
+        ema_200 = talib.EMA(close, timeperiod=200)
+
+        # ATR (Average True Range) is a measure of volatility
+        atr = talib.ATR(high, low, close, timeperiod=14)
+
+        # RSI and Stochastic. RSI (Relative Strength Index) is a momentum oscillator that measures the speed and change of price movements.
+        # Stochastic Oscillator is a momentum indicator comparing a particular closing price of a security to a range of its prices over a certain period.
+        rsi = talib.RSI(close, timeperiod=14)
+        slowk, slowd = talib.STOCH(high, low, close)
+
+        # Bollinger Bands. Bollinger Bands consist of a middle band (SMA) and two outer bands (standard deviations).
+        upper_bb, middle_bb, lower_bb = talib.BBANDS(close)
+
+        # Volume indicators. On-Balance Volume (OBV) is a cumulative volume-based indicator that uses volume flow to predict changes in stock price.
+        obv = talib.OBV(close, volume)
+        vol_sma = talib.SMA(volume, timeperiod=20)
+
+        return {
+            'ema_20': ema_20[-1],
+            'ema_50': ema_50[-1],
+            'ema_200': ema_200[-1],
+            'atr': atr[-1],
+            'rsi': rsi[-1],
+            'stoch_k': slowk[-1],
+            'stoch_d': slowd[-1],
+            'bb_upper': upper_bb[-1],
+            'bb_lower': lower_bb[-1],
+            'obv': obv[-1],
+            'volume_ratio': volume[-1] / vol_sma[-1] if vol_sma[-1] > 0 else 1,
+            'current_price': close[-1]
+        }
+
+    def calculate_position_sizing(self, price: float, atr: float, account_capital: float = 10000,
+                                  risk_pct: float = 0.02, atr_multiplier: float = 2.0) -> dict[str, float]:
+        """
+        Calculate position sizing based on ATR and account capital.
+
+        Args:
+            price (float): Current stock price.
+            atr (float): Average True Range (ATR) of the stock.
+            account_capital (float): Total capital available for trading.
+            risk_pct (float): Percentage of capital to risk on a single trade.
+            atr_multiplier (float): Multiplier for ATR to determine stop distance.
+        Returns:
+            dict[str, float]: Dictionary with recommended shares, position value, stop loss price, actual risk in USD and percentage.
+        """
+        stop_distance = atr_multiplier * atr
+        risk_amount = account_capital * risk_pct
+        position_size = risk_amount / stop_distance
+
+        # Calculate shares and actual position value
+        shares = int(position_size / price)
+        actual_position_value = shares * price
+        actual_risk = shares * stop_distance
+
+        return {
+            'recommended_shares': shares,
+            'position_value': actual_position_value,
+            'stop_loss_price': price - stop_distance,
+            'actual_risk_usd': actual_risk,
+            'actual_risk_pct': (actual_risk / account_capital) * 100,
+            'atr_stop_distance': stop_distance
+        }
+
+    def calculate_risk_reward_levels(self, price: float, atr: float,
+                                     min_rr: float = 2.0) -> dict[str, float]:
+        """
+        Calculate risk/reward levels based on ATR and price.
+
+        Args:
+            price (float): Current stock price.
+            atr (float): Average True Range (ATR) of the stock.
+            min_rr (float): Minimum risk/reward ratio for the first take profit level.
+        Returns:
+            dict[str, float]: Dictionary with stop loss, take profit levels and risk/reward ratios.
+        """
+        stop_distance = 2 * atr
+        stop_loss = price - stop_distance
+        take_profit_1 = price + (stop_distance * min_rr)
+        take_profit_2 = price + (stop_distance * 3.0)
+
+        return {
+            'stop_loss': stop_loss,
+            'take_profit_1': take_profit_1,
+            'take_profit_2': take_profit_2,
+            'risk_reward_1': min_rr,
+            'risk_reward_2': 3.0
+        }
+
+    def analyze_trend_context(self, indicators: dict[str, Any]) -> dict[str, Any]:
+        """
+        Analyze the trend context based on technical indicators.
+
+        Args:
+            indicators (dict[str, Any]): Dictionary with technical indicators including current price, EMAs, and Bollinger Bands.
+        Returns:
+            dict[str, Any]: Dictionary with trend analysis and Bollinger Bands position.
+        """
+        price = indicators['current_price']
+        ema20 = indicators['ema_20']
+        ema50 = indicators['ema_50']
+        ema200 = indicators['ema_200']
+
+        # Determine trend based on EMAs
+        if price > ema20 > ema50 > ema200:
+            trend = "Strong uptrend"
+        elif price > ema20 > ema50:
+            trend = "Uptrend"
+        elif price < ema20 < ema50 < ema200:
+            trend = "Strong downtrend"
+        elif price < ema20 < ema50:
+            trend = "Downtrend"
+        else:
+            trend = "Sideways"
+
+        # Position in Bollinger Bands
+        bb_position = "Middle"
+        if price > indicators['bb_upper']:
+            bb_position = "Above upper band"
+        elif price < indicators['bb_lower']:
+            bb_position = "Below lower band"
+
+        return {
+            'trend': trend,
+            'bb_position': bb_position,
+            'price_vs_ema20': ((price / ema20) - 1) * 100,
+            'ema20_vs_ema50': ((ema20 / ema50) - 1) * 100
+        }
+
+    def calculate_max_drawdown(self, prices: pd.Series) -> float:
+        """
+        Calculate the maximum drawdown of a stock's price series.
+
+        Args:
+            prices (pd.Series): Series of stock prices.
+        Returns:
+            float: Maximum drawdown as a percentage.
+        """
+        cumulative = (1 + prices.pct_change()).cumprod()
+        running_max = cumulative.expanding().max()
+        drawdown = (cumulative - running_max) / running_max
+        return drawdown.min()
+
+    def calculate_sharpe_ratio(self, returns: pd.Series, risk_free_rate: float = 0.02) -> float:
+        """
+        Calculate the Sharpe ratio of a stock's returns.
+
+        Args:
+            returns (pd.Series): Series of stock returns.
+            risk_free_rate (float): Risk-free rate, default is 2%.
+        Returns:
+            float: Sharpe ratio.
+        """
+        excess_returns = returns.mean() * 252 - risk_free_rate
+        volatility = returns.std() * np.sqrt(252)
+        return excess_returns / volatility if volatility != 0 else 0
+
+    def calculate_sortino_ratio(self, returns: pd.Series, risk_free_rate: float = 0.02) -> float:
+        """
+        Calculate the Sortino ratio of a stock's returns.
+        Args:
+            returns (pd.Series): Series of stock returns.
+            risk_free_rate (float): Risk-free rate, default is 2%.
+        Returns:
+            float: Sortino ratio.
+        """
+        excess_returns = returns.mean() * 252 - risk_free_rate
+        downside_returns = returns[returns < 0]
+        downside_deviation = downside_returns.std() * np.sqrt(252)
+        return excess_returns / downside_deviation if downside_deviation != 0 else 0
+
+    def calculate_beta(self, stock_prices: pd.Series, market_ticker: str = "^GSPC") -> float:
+        """
+        Calculate the beta of a stock relative to a market index.
+
+        Args:
+            stock_prices (pd.Series): Series of stock prices.
+            market_ticker (str): Ticker symbol of the market index (default is S&P 500).
+        Returns:
+            float: Beta value of the stock.
+        """
+        try:
+            market_data = yf.Ticker(market_ticker).history(period="1y")
+            stock_returns = stock_prices.pct_change().dropna()
+            market_returns = market_data['Close'].pct_change().dropna()
+
+            common_dates = stock_returns.index.intersection(market_returns.index)
+            stock_returns_aligned = stock_returns.loc[common_dates]
+            market_returns_aligned = market_returns.loc[common_dates]
+
+            covariance = np.cov(stock_returns_aligned, market_returns_aligned)[0][1]
+            market_variance = np.var(market_returns_aligned)
+
+            return covariance / market_variance if market_variance != 0 else 1
+        except:
+            return 1.0
+
+    def analyze_risks(self, ticker: str, account_capital: float = 10000) -> dict[str, Any]:
+        """
+        Analyze risks for a given stock ticker and account capital.
+
+        Args:
+            ticker (str): Stock ticker symbol.
+            account_capital (float): Total capital available for trading, default is $10,000.
+        Returns:
+            Dict[str, Any]: Dictionary with analysis results including current price, price change, basic metrics,
+                            technical indicators, trend analysis, position sizing, and risk/reward levels.
+        """
+        try:
+            data = self.get_stock_data(ticker)
+            basic_metrics = self.calculate_basic_metrics(data)
+            technical_indicators = self.calculate_technical_indicators(data)
+            trend_analysis = self.analyze_trend_context(technical_indicators)
+            position_sizing = self.calculate_position_sizing(
+                technical_indicators['current_price'],
+                technical_indicators['atr'],
+                account_capital
+            )
+            risk_reward = self.calculate_risk_reward_levels(
+                technical_indicators['current_price'],
+                technical_indicators['atr']
+            )
+            current_price = technical_indicators['current_price']
+            prev_price = data['Close'].iloc[-2]
+            price_change = (current_price - prev_price) / prev_price * 100
+
+            return {
+                'ticker': ticker.upper(),
+                'success': True,
+                'current_price': current_price,
+                'price_change_pct': price_change,
+                'basic_metrics': basic_metrics,
+                'technical_indicators': technical_indicators,
+                'trend_analysis': trend_analysis,
+                'position_sizing': position_sizing,
+                'risk_reward': risk_reward
+            }
+
+        except Exception as e:
+            return {'success': False, 'error': str(e)}
+
+    async def generate_explanation(self, risk_data: dict[str, Any]) -> str:
+        """
+        Generate a comprehensive risk management analysis explanation in Russian based on the provided risk data.
+
+        Args:
+            risk_data (dict[str, Any]): Dictionary containing risk analysis data including ticker, current price,
+                                        basic metrics, technical indicators, trend analysis, position sizing, and risk/reward levels.
+        """
+        basic = risk_data['basic_metrics']
+        tech = risk_data['technical_indicators']
+        trend = risk_data['trend_analysis']
+        position = risk_data['position_sizing']
+        rr = risk_data['risk_reward']
+
+        prompt = f"""
+        Analyze the comprehensive risk management picture for the stock {risk_data['ticker']} in English.
+
+        Price: ${risk_data['current_price']:.2f} ({risk_data['price_change_pct']:+.2f}%)
+        
+        RISK METRICS:
+        - Volatility: {basic['volatility'] * 100:.1f}%
+        - Sharpe: {basic['sharpe_ratio']:.2f}
+        - Sortino: {basic['sortino_ratio']:.2f}
+        - Max drawdown: {basic['max_drawdown'] * 100:.1f}%
+        - Beta: {basic['beta']:.2f}
+        
+        TECHNICAL ANALYSIS:
+        - Trend: {trend['trend']}
+        - RSI: {tech['rsi']:.1f}
+        - ATR: ${tech['atr']:.2f}
+        - BB Position: {trend['bb_position']}
+        - Volume: {tech['volume_ratio']:.1f}x of average
+        
+        TRADING PLAN:
+        - Recommended size: {position['recommended_shares']} shares (${position['position_value']:.0f})
+        - Stop-loss: ${position['stop_loss_price']:.2f}
+        - Take-profit 1: ${rr['take_profit_1']:.2f} (R/R 2:1)
+        - Risk: ${position['actual_risk_usd']:.0f} ({position['actual_risk_pct']:.1f}%)
+        
+        Give a brief assessment:
+        1. Overall risk level (low/medium/high)
+        2. Is it a good time to enter now
+        3. What to pay attention to
+        
+        Maximum 200 words, concise and to the point.
+        """
+
+        try:
+            response = await asyncio.to_thread(
+                self.client.models.generate_content,
+                model=self._model_name,
+                contents=prompt
+            )
+            return response.text
+        except Exception as e:
+            return f"Failed to generate explanation: {str(e)}"

src/telegram_bot/config.py

@@ -15,6 +15,7 @@ class Config:
     HF_TOKEN = os.getenv('HF_TOKEN', '')
     HF_DATASET_REPO = os.getenv('HF_DATASET_REPO', '')
     OPENROUTER_API_KEY_2 = os.getenv('OPENROUTER_API_TOKEN_2', '')
+    GEMINI_API_KEY = os.getenv('GEMINI_API_TOKEN', '')
 
     @classmethod
     def validate(cls) -> bool:

src/telegram_bot/telegram_bot_service.py

@@ -15,6 +15,7 @@ from src.api.finnhub.financial_news_requester import fetch_comp_financial_news
 from src.api.openrouter.openrouter_client import OpenRouterClient
 from src.api.openrouter.prompt_generator import PromptGenerator
 from src.services.news_pooling_service import NewsPollingService
+from src.core.risk_management.risk_analyzer import RiskAnalyzer
 
 
 class TelegramBotService:
@@ -125,9 +126,10 @@ class TelegramBotService:
 
     async def _handle_command(self, chat_id: int, command: str, user_name: str) -> None:
         """Handle bot commands"""
-        command = command.lower().strip()
+        command_parts = command.lower().strip().split()
+        base_command = command_parts[0]
 
-        if command in ["/start", "/hello"]:
+        if base_command in ["/start", "/hello"]:
             response = f"👋 Hello, {user_name}! Welcome to the Financial News Bot!\n\n"
             response += "Available commands:\n"
             response += "/hello - Say hello\n"
@@ -135,9 +137,12 @@ class TelegramBotService:
             response += "/status - Check bot status\n"
             response += "/news - Show all today's news\n"
             response += "/run - News feed analysis by ticker (NVDA)\n\n"
-            response += "/pooling - News feed pooling by ticker (NVDA)\n\n"
+            response += "/pooling - News feed pooling by ticker (NVDA) 🧪 (not working properly, testing)\n\n"
+            response += "🆕 <b>Risk Analysis Commands:</b> 🧪 (testing)\n"
+            response += "/risk TICKER - Full risk analysis (e.g., /risk AAPL)\n"
+            response += "/risk TICKER 25000 - Risk analysis with custom capital\n"
 
-        elif command == "/help":
+        elif base_command == "/help":
             response = "🤖 <b>Financial News Bot Help</b>\n\n"
             response += "<b>Commands:</b>\n"
             response += "/start or /hello - Get started\n"
@@ -145,27 +150,41 @@ class TelegramBotService:
             response += "/status - Check bot status\n\n"
             response += "<b>About:</b>\n"
             response += "This bot provides financial news and sentiment analysis."
-
-        elif command == "/status":
+            response += "<b>Risk Analysis Commands:</b>\n"
+            response += "/risk TICKER - Complete risk analysis\n"
+            response += "/risk AAPL - Apple analysis with $10,000 capital\n"
+            response += "/risk TSLA 50000 - Tesla analysis with $50,000 capital\n\n"
+            response += "<b>What Risk Analysis Includes:</b>\n"
+            response += "📊 Risk metrics (volatility, Sharpe, Sortino)\n"
+            response += "📈 Technical indicators (RSI, ATR, EMA, Bollinger)\n"
+            response += "💰 Position sizing and trade plan\n"
+            response += "🎯 Stop-loss and take-profit levels\n"
+            response += "🤖 AI-powered trading insights\n"
+
+        elif base_command == "/status":
             response = "✅ <b>Bot Status: Online</b>\n\n"
             response += "🔧 System: Running on HuggingFace Spaces\n"
             response += "🌐 Proxy: Google Apps Script\n"
             response += "📊 Status: All systems operational"
 
-        elif command == "/news":
+        elif base_command == "/news":
             await self.news_feed_analysing(chat_id, command, user_name)
             return
 
-        elif command == "/run":
+        elif base_command == "/run":
             await self.news_feed_analysing_by_ticker(ticker="NVDA", chat_id=chat_id,
                                                      text=None, user_name=user_name)
             return
 
-        elif command == "/pooling":
+        elif base_command == "/pooling":
             await self.news_feed_pooling_by_ticker(ticker="NVDA", chat_id=chat_id,
                                                    text=None, user_name=user_name)
             return
 
+        elif base_command == "/risk":
+            await self._handle_risk_command(chat_id, command_parts, user_name)
+            return
+
         else:
             response = f"❓ Unknown command: {command}\n\n"
             response += "Type /help to see available commands."
@@ -293,3 +312,161 @@ class TelegramBotService:
         except Exception as e:
             main_logger.error(f"Error in news_feed_analysing_by_ticker: {e}")
             await self.send_message_via_proxy(chat_id, f"Sorry, there was an error fetching news: {str(e)}")
+
+    async def get_risk_analysis(
+            self, ticker: str, chat_id: int, text: str | None, user_name: str
+    ) -> None:
+        await self.send_message_via_proxy(chat_id, f"Fetching latest financial data for ticker {ticker} ...")
+        analyzer = RiskAnalyzer(self.config.GEMINI_API_KEY)
+        try:
+            risk_analysis = await analyzer.analyze_risk(ticker)
+            if risk_analysis:
+                response = f"Risk analysis for {ticker}:\n\n{risk_analysis}"
+            else:
+                response = f"No risk analysis available for {ticker}."
+        except Exception as e:
+            main_logger.error(f"Error in get_risk_analysis: {e}")
+            response = f"Sorry, there was an error fetching risk analysis: {str(e)}"
+        await self.send_message_via_proxy(chat_id, response)
+
+    async def _handle_risk_command(self, chat_id: int, command_parts: list[str],
+                                   user_name: str) -> None:
+        """Handle risk analysis command"""
+        try:
+            risk_analyzer = RiskAnalyzer(self.config.GEMINI_API_KEY)
+            if not risk_analyzer:
+                await self.send_message_via_proxy(
+                    chat_id,
+                    "❌ Risk analysis is currently unavailable. Please try again later."
+                )
+                return
+            if len(command_parts) < 2:
+                await self.send_message_via_proxy(
+                    chat_id,
+                    "❌ Please specify a ticker: /risk AAPL [capital]\n\n"
+                    "Examples:\n• /risk AAPL\n• /risk TSLA 25000"
+                )
+                return
+            ticker = command_parts[1].upper()
+            await self.send_message_via_proxy(chat_id, f"Fetching latest financial data for ticker {ticker} ...")
+            try:
+                capital = float(command_parts[2]) if len(command_parts) > 2 else 10000
+            except (ValueError, IndexError):
+                capital = 10000
+
+            if capital < 1000:
+                await self.send_message_via_proxy(
+                    chat_id,
+                    "❌ Minimum capital is $1,000"
+                )
+                return
+
+            # Send loading message
+            loading_message = f"⏳ Analyzing {ticker} with ${capital:,.0f} capital...\n\n"
+            loading_message += "📊 Fetching market data...\n"
+            loading_message += "🔢 Calculating risk metrics...\n"
+            loading_message += "📈 Analyzing technical indicators...\n"
+            loading_message += "💼 Generating trade plan..."
+
+            await self.send_message_via_proxy(chat_id, loading_message)
+
+            # Perform analysis
+            risk_data = await risk_analyzer.analyze_risks(ticker, capital)
+
+            if not risk_data['success']:
+                await self.send_message_via_proxy(
+                    chat_id,
+                    f"❌ Analysis failed for {ticker}: {risk_data['error']}"
+                )
+                return
+            # Format and send main results
+            result_text = self._format_risk_analysis_results(risk_data)
+            await self.send_message_via_proxy(chat_id, result_text)
+
+            # Generate and send AI explanation
+            ai_loading = "🤖 Generating AI analysis..."
+            await self.send_message_via_proxy(chat_id, ai_loading)
+
+            explanation = await risk_analyzer.generate_explanation(risk_data)
+            ai_response = f"🤖 <b>AI Trading Analysis:</b>\n\n{explanation}"
+
+            await self.send_message_via_proxy(chat_id, ai_response)
+
+        except Exception as e:
+            main_logger.error(f"Error in risk command handler: {e}")
+            await self.send_message_via_proxy(
+                chat_id,
+                f"❌ An error occurred during analysis: {str(e)}"
+            )
+
+    def _format_risk_analysis_results(self, data: dict[str, Any]) -> str:
+        """Format comprehensive risk analysis results"""
+        try:
+            basic = data['basic_metrics']
+            tech = data['technical_indicators']
+            trend = data['trend_analysis']
+            position = data['position_sizing']
+            rr = data['risk_reward']
+
+            change_emoji = "📈" if data['price_change_pct'] >= 0 else "📉"
+
+            # RSI signals
+            rsi_value = tech['rsi']
+            if rsi_value > 70:
+                rsi_emoji = "🔴"
+                rsi_signal = "Overbought"
+            elif rsi_value < 30:
+                rsi_emoji = "🟢"
+                rsi_signal = "Oversold"
+            else:
+                rsi_emoji = "🟡"
+                rsi_signal = "Neutral"
+
+            # Volume signal
+            vol_emoji = "🔥" if tech['volume_ratio'] > 1.5 else "📊"
+
+            # Risk level based on volatility
+            vol_pct = basic['volatility'] * 100
+            if vol_pct < 20:
+                risk_level = "🟢 Low"
+            elif vol_pct < 40:
+                risk_level = "🟡 Medium"
+            else:
+                risk_level = "🔴 High"
+
+            return f"""
+    📊 <b>Risk Analysis: {data['ticker']}</b>
+
+    💰 <b>Current Price:</b> ${data['current_price']:.2f} ({data['price_change_pct']:+.2f}%) {change_emoji}
+
+    🎯 <b>Risk Metrics:</b>
+    • Volatility: {vol_pct:.1f}% ({risk_level})
+    • Sharpe Ratio: {basic['sharpe_ratio']:.2f}
+    • Sortino Ratio: {basic['sortino_ratio']:.2f}  
+    • VaR (5%): {basic['var_5'] * 100:.1f}%
+    • Max Drawdown: {basic['max_drawdown'] * 100:.1f}%
+    • Beta: {basic['beta']:.2f}
+
+    📈 <b>Technical Analysis:</b>
+    • Trend: <b>{trend['trend']}</b>
+    • RSI: {rsi_value:.0f} {rsi_emoji} ({rsi_signal})
+    • ATR: ${tech['atr']:.2f}
+    • Volume: {tech['volume_ratio']:.1f}x avg {vol_emoji}
+    • BB Position: {trend['bb_position']}
+
+    💼 <b>Trading Plan:</b>
+    • Position Size: <b>{position['recommended_shares']} shares</b>
+    • Investment: ${position['position_value']:,.0f}
+    • Stop Loss: ${position['stop_loss_price']:.2f}
+    • Take Profit 1: ${rr['take_profit_1']:.2f} (R/R 2:1)
+    • Take Profit 2: ${rr['take_profit_2']:.2f} (R/R 3:1)
+    • Risk Amount: ${position['actual_risk_usd']:.0f} ({position['actual_risk_pct']:.1f}%)
+
+    📊 <b>Moving Averages:</b>
+    • EMA 20: ${tech['ema_20']:.2f}
+    • EMA 50: ${tech['ema_50']:.2f}  
+    • EMA 200: ${tech['ema_200']:.2f}
+                """
+        except Exception as e:
+            main_logger.error(f"Error formatting risk results: {e}")
+            return f"❌ Error formatting analysis results: {str(e)}"