quantalogic 0.35.0__py3-none-any.whl → 0.40.0__py3-none-any.whl

quantalogic/tools/finance/finance_llm_tool.py

@@ -0,0 +1,387 @@
+"""Advanced Financial Analysis LLM Tool combining market data with AI insights."""
+
+import json
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Any, Callable, ClassVar, Dict, List, Optional, Union
+
+import pandas as pd
+import ta
+from loguru import logger
+from pydantic import ConfigDict, Field
+
+from quantalogic.agent import Agent
+from quantalogic.event_emitter import EventEmitter
+from quantalogic.generative_model import GenerativeModel, Message
+from quantalogic.tools.finance.alpha_vantage_tool import AlphaVantageTool
+from quantalogic.tools.finance.ccxt_tool import CCXTTool
+from quantalogic.tools.tool import Tool, ToolArgument
+
+
+@dataclass
+class StrategyResult:
+    """Container for strategy analysis results."""
+    name: str
+    signals: Dict[str, str]  # buy/sell/hold signals
+    confidence: float
+    reasoning: str
+    metrics: Dict[str, float]
+    timestamp: datetime
+
+@dataclass
+class MarketAnalysis:
+    """Container for comprehensive market analysis."""
+    symbol: str
+    asset_type: str
+    timeframe: str
+    current_price: float
+    analysis_timestamp: datetime
+    technical_signals: Dict[str, Dict[str, Union[str, float]]]
+    fundamental_data: Optional[Dict[str, Any]] = None
+    market_sentiment: Optional[Dict[str, float]] = None
+    strategy_results: List[StrategyResult] = None
+    ai_insights: Optional[Dict[str, Any]] = None
+
+class FinanceLLMTool(Tool):
+    """Advanced financial analysis tool combining market data with AI insights."""
+
+    model_config = ConfigDict(arbitrary_types_allowed=True, extra="allow")
+
+    name: str = Field(default="finance_llm_tool")
+    description: str = Field(
+        default=(
+            "Advanced financial analysis tool that combines real-time market data, "
+            "technical analysis, fundamental analysis, and AI-powered insights for "
+            "stocks, cryptocurrencies, and indices. Provides detailed strategy analysis "
+            "and market insights using state-of-the-art language models."
+        )
+    )
+
+    STRATEGIES: ClassVar[List[str]] = [
+        "trend_following",
+        "mean_reversion",
+        "breakout",
+        "momentum",
+        "volume_analysis",
+        "sentiment_based",
+        "multi_timeframe",
+        "adaptive_momentum",
+        "volatility_based",
+        "correlation_based"
+    ]
+
+    TIMEFRAMES: ClassVar[List[str]] = [
+        "1m", "5m", "15m", "30m", "1h", "4h", "1d", "1w", "1M"
+    ]
+
+    arguments: list = Field(
+        default=[
+            ToolArgument(
+                name="symbols",
+                arg_type="list",
+                description="List of trading symbols to analyze",
+                required=True,
+                example="['BTC/USDT', 'AAPL', 'SPY']"
+            ),
+            ToolArgument(
+                name="asset_types",
+                arg_type="list",
+                description="List of asset types (crypto/stock/index)",
+                required=True,
+                example="['crypto', 'stock', 'index']"
+            ),
+            ToolArgument(
+                name="strategies",
+                arg_type="list",
+                description="List of trading strategies to analyze",
+                required=False,
+                default="['trend_following', 'momentum', 'multi_timeframe']"
+            ),
+            ToolArgument(
+                name="timeframes",
+                arg_type="list",
+                description="List of timeframes to analyze",
+                required=False,
+                default="['1h', '4h', '1d']"
+            ),
+            ToolArgument(
+                name="analysis_types",
+                arg_type="list",
+                description="Types of analysis to perform (technical/fundamental/sentiment/ai)",
+                required=False,
+                default="['technical', 'sentiment', 'ai']"
+            ),
+            ToolArgument(
+                name="temperature",
+                arg_type="string",
+                description="LLM temperature for analysis generation",
+                required=False,
+                default="0.3"
+            )
+        ]
+    )
+
+    model_name: str = Field(..., description="The name of the language model to use")
+    system_prompt: str = Field(
+        default=(
+            "You are an expert financial analyst and trading strategist with deep knowledge of:"
+            "\n- Technical Analysis and Chart Patterns"
+            "\n- Fundamental Analysis and Valuation Methods"
+            "\n- Market Psychology and Sentiment Analysis"
+            "\n- Risk Management and Position Sizing"
+            "\n- Multi-Timeframe Analysis"
+            "\n- Inter-market Analysis and Correlations"
+            "\n- Machine Learning in Trading"
+            "\nYour role is to analyze market data and provide detailed, actionable insights while:"
+            "\n- Maintaining objectivity and avoiding bias"
+            "\n- Providing clear reasoning for all conclusions"
+            "\n- Highlighting potential risks and limitations"
+            "\n- Considering multiple timeframes and perspectives"
+            "\n- Adapting analysis to market conditions"
+            "\n- Following proper risk management principles"
+        )
+    )
+
+    def __init__(
+        self,
+        model_name: str,
+        system_prompt: str | None = None,
+        on_token: Callable | None = None,
+        name: str = "finance_llm_tool",
+        generative_model: GenerativeModel | None = None,
+        event_emitter: EventEmitter | None = None,
+    ):
+        """Initialize the Finance LLM tool."""
+        super().__init__(
+            **{
+                "model_name": model_name,
+                "system_prompt": system_prompt or self.system_prompt,
+                "on_token": on_token,
+                "name": name,
+                "generative_model": generative_model,
+                "event_emitter": event_emitter,
+            }
+        )
+        
+        # Initialize market data tools
+        self.ccxt_tool = CCXTTool()
+        self.alpha_vantage_tool = AlphaVantageTool()
+        
+        # Initialize the generative model
+        self.model_post_init(None)
+
+    async def _analyze_technical_indicators(self, df: pd.DataFrame) -> Dict[str, Dict[str, Union[str, float]]]:
+        """Analyze technical indicators and generate signals."""
+        signals = {}
+        
+        try:
+            # Calculate indicators
+            df['sma_20'] = ta.trend.sma_indicator(df['close'], 20)
+            df['sma_50'] = ta.trend.sma_indicator(df['close'], 50)
+            df['sma_200'] = ta.trend.sma_indicator(df['close'], 200)
+            df['rsi'] = ta.momentum.rsi(df['close'])
+            df['macd'] = ta.trend.macd_diff(df['close'])
+            df['bbands_upper'] = ta.volatility.bollinger_hband(df['close'])
+            df['bbands_lower'] = ta.volatility.bollinger_lband(df['close'])
+            
+            # Generate signals
+            signals['trend'] = {
+                'signal': 'buy' if df['sma_20'].iloc[-1] > df['sma_50'].iloc[-1] else 'sell',
+                'strength': abs(df['sma_20'].iloc[-1] - df['sma_50'].iloc[-1]) / df['close'].iloc[-1]
+            }
+            
+            signals['momentum'] = {
+                'signal': 'buy' if df['rsi'].iloc[-1] < 30 else 'sell' if df['rsi'].iloc[-1] > 70 else 'hold',
+                'strength': abs(50 - df['rsi'].iloc[-1]) / 50
+            }
+            
+            signals['macd'] = {
+                'signal': 'buy' if df['macd'].iloc[-1] > 0 else 'sell',
+                'strength': abs(df['macd'].iloc[-1])
+            }
+            
+            return signals
+            
+        except Exception as e:
+            logger.error(f"Error analyzing technical indicators: {e}")
+            raise
+
+    async def _analyze_strategy(
+        self,
+        df: pd.DataFrame,
+        strategy: str,
+        timeframe: str
+    ) -> StrategyResult:
+        """Analyze market data using a specific strategy."""
+        try:
+            # Prepare strategy prompt
+            strategy_prompt = self._get_strategy_prompt(strategy, df, timeframe)
+            
+            # Get AI analysis
+            response = await self.generative_model.chat_completion(
+                messages=[
+                    Message(role="system", content=self.system_prompt),
+                    Message(role="user", content=strategy_prompt)
+                ],
+                temperature=0.3
+            )
+            
+            # Parse response
+            analysis = json.loads(response.content)
+            
+            return StrategyResult(
+                name=strategy,
+                signals=analysis['signals'],
+                confidence=analysis['confidence'],
+                reasoning=analysis['reasoning'],
+                metrics=analysis['metrics'],
+                timestamp=datetime.now()
+            )
+            
+        except Exception as e:
+            logger.error(f"Error analyzing strategy {strategy}: {e}")
+            raise
+
+    def _get_strategy_prompt(self, strategy: str, df: pd.DataFrame, timeframe: str) -> str:
+        """Generate strategy-specific analysis prompt."""
+        base_prompt = (
+            f"Analyze the following market data using the {strategy} strategy on {timeframe} timeframe. "
+            "Provide analysis in JSON format with the following structure:\n"
+            "{\n"
+            '  "signals": {"primary": "buy/sell/hold", "secondary": "string"},\n'
+            '  "confidence": float between 0 and 1,\n'
+            '  "reasoning": "detailed explanation",\n'
+            '  "metrics": {"risk_reward": float, "probability": float}\n'
+            "}\n\n"
+            "Market Data Summary:\n"
+        )
+        
+        # Add strategy-specific data points
+        if strategy == "trend_following":
+            base_prompt += (
+                f"Current Price: {df['close'].iloc[-1]}\n"
+                f"SMA20: {df['sma_20'].iloc[-1]}\n"
+                f"SMA50: {df['sma_50'].iloc[-1]}\n"
+                f"SMA200: {df['sma_200'].iloc[-1]}\n"
+            )
+        elif strategy == "momentum":
+            base_prompt += (
+                f"RSI: {df['rsi'].iloc[-1]}\n"
+                f"MACD: {df['macd'].iloc[-1]}\n"
+                f"Recent Price Change: {(df['close'].iloc[-1] / df['close'].iloc[-5] - 1) * 100}%\n"
+            )
+        
+        return base_prompt
+
+    async def execute(self, agent: Agent, **kwargs) -> Dict[str, MarketAnalysis]:
+        """Execute comprehensive financial analysis."""
+        try:
+            symbols = kwargs['symbols']
+            asset_types = kwargs['asset_types']
+            strategies = kwargs.get('strategies', ['trend_following', 'momentum'])
+            timeframes = kwargs.get('timeframes', ['1h', '4h', '1d'])
+            analysis_types = kwargs.get('analysis_types', ['technical', 'sentiment', 'ai'])
+            
+            results = {}
+            
+            for symbol, asset_type in zip(symbols, asset_types):
+                # Fetch market data
+                if asset_type == 'crypto':
+                    market_data = await self.ccxt_tool.execute(
+                        agent=agent,
+                        symbols=[symbol],
+                        exchanges=['binance'],
+                        timeframe='1h'
+                    )
+                else:
+                    market_data = await self.alpha_vantage_tool.execute(
+                        agent=agent,
+                        symbols=[symbol],
+                        asset_types=[asset_type],
+                        data_types=['daily', 'fundamental']
+                    )
+                
+                # Process each timeframe
+                for timeframe in timeframes:
+                    df = pd.DataFrame(market_data[symbol]['market_data'])
+                    
+                    # Technical Analysis
+                    if 'technical' in analysis_types:
+                        technical_signals = await self._analyze_technical_indicators(df)
+                    else:
+                        technical_signals = None
+                    
+                    # Strategy Analysis
+                    strategy_results = []
+                    for strategy in strategies:
+                        result = await self._analyze_strategy(df, strategy, timeframe)
+                        strategy_results.append(result)
+                    
+                    # AI Insights
+                    if 'ai' in analysis_types:
+                        ai_prompt = (
+                            f"Analyze {symbol} on {timeframe} timeframe considering:\n"
+                            f"1. Current market conditions\n"
+                            f"2. Technical signals: {technical_signals}\n"
+                            f"3. Strategy results: {strategy_results}\n"
+                            "Provide insights in JSON format with:\n"
+                            "- Overall market outlook\n"
+                            "- Key levels to watch\n"
+                            "- Risk factors\n"
+                            "- Trading opportunities"
+                        )
+                        
+                        ai_response = await self.generative_model.chat_completion(
+                            messages=[
+                                Message(role="system", content=self.system_prompt),
+                                Message(role="user", content=ai_prompt)
+                            ],
+                            temperature=float(kwargs.get('temperature', 0.3))
+                        )
+                        
+                        ai_insights = json.loads(ai_response.content)
+                    else:
+                        ai_insights = None
+                    
+                    # Combine all analysis
+                    results[f"{symbol}_{timeframe}"] = MarketAnalysis(
+                        symbol=symbol,
+                        asset_type=asset_type,
+                        timeframe=timeframe,
+                        current_price=df['close'].iloc[-1],
+                        analysis_timestamp=datetime.now(),
+                        technical_signals=technical_signals,
+                        fundamental_data=market_data[symbol].get('fundamental_data'),
+                        market_sentiment=market_data[symbol].get('news_sentiment'),
+                        strategy_results=strategy_results,
+                        ai_insights=ai_insights
+                    )
+            
+            return results
+            
+        except Exception as e:
+            logger.error(f"Error executing financial analysis: {e}")
+            raise
+
+    def validate_arguments(self, **kwargs) -> bool:
+        """Validate the provided arguments."""
+        try:
+            required_args = [arg.name for arg in self.arguments if arg.required]
+            for arg in required_args:
+                if arg not in kwargs:
+                    raise ValueError(f"Missing required argument: {arg}")
+
+            if 'strategies' in kwargs:
+                invalid_strategies = set(kwargs['strategies']) - set(self.STRATEGIES)
+                if invalid_strategies:
+                    raise ValueError(f"Invalid strategies: {invalid_strategies}")
+
+            if 'timeframes' in kwargs:
+                invalid_timeframes = set(kwargs['timeframes']) - set(self.TIMEFRAMES)
+                if invalid_timeframes:
+                    raise ValueError(f"Invalid timeframes: {invalid_timeframes}")
+
+            return True
+        except Exception as e:
+            logger.error(f"Argument validation error: {e}")
+            return False

quantalogic/tools/finance/google_finance.py

@@ -0,0 +1,192 @@
+from datetime import datetime
+from typing import ClassVar, Dict
+
+import pandas as pd
+import requests
+from loguru import logger
+
+from quantalogic.tools import Tool, ToolArgument
+
+
+class GFinanceTool(Tool):
+    """Enhanced Google Finance data retrieval and analysis tool."""
+
+    name: str = "gfinance_tool"
+    description: str = "Advanced financial data and analysis tool using Google Finance"
+    arguments: list[ToolArgument] = [
+        ToolArgument(name="ticker", arg_type="string", description="Stock symbol (e.g., GOOGL)", required=True),
+        ToolArgument(name="start_date", arg_type="string", description="Start date (YYYY-MM-DD)", required=True),
+        ToolArgument(name="end_date", arg_type="string", description="End date (YYYY-MM-DD)", required=True),
+        ToolArgument(
+            name="interval",
+            arg_type="string",
+            description="Data interval (1d/1wk/1mo)",
+            required=False,
+            default="1d"
+        ),
+        ToolArgument(
+            name="analysis_type",
+            arg_type="string",
+            description="Type of analysis to perform (technical/fundamental/all)",
+            required=False,
+            default="all"
+        )
+    ]
+
+    INTERVAL_MAPPING: ClassVar[Dict[str, int]] = {
+        '1d': 86400,    # 1 day in seconds
+        '1wk': 604800,  # 1 week in seconds
+        '1mo': 2592000  # 1 month in seconds (30 days)
+    }
+
+    BASE_URL = "https://www.google.com/finance/quote"
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.cache = {}
+
+    def _validate_dates(self, start_date: str, end_date: str) -> tuple[datetime, datetime]:
+        """Validate and convert date strings to datetime objects."""
+        try:
+            start = datetime.strptime(start_date, "%Y-%m-%d")
+            end = datetime.strptime(end_date, "%Y-%m-%d")
+            if start > end:
+                raise ValueError("Start date must be before end date")
+            return start, end
+        except ValueError as e:
+            logger.error(f"Date validation error: {e}")
+            raise
+
+    def _fetch_data(self, ticker: str, start_date: datetime, end_date: datetime, interval: str) -> pd.DataFrame:
+        """Fetch financial data from Google Finance."""
+        try:
+            # Construct the URL
+            params = {
+                'period': self.INTERVAL_MAPPING.get(interval, self.INTERVAL_MAPPING['1d']),
+                'window': int((end_date - start_date).total_seconds())
+            }
+            url = f"{self.BASE_URL}/{ticker}/historical"
+            
+            # Make the request
+            response = requests.get(url, params=params)
+            response.raise_for_status()
+            
+            # Parse the response and convert to DataFrame
+            data = response.json()
+            df = pd.DataFrame(data['prices'])
+            df['timestamp'] = pd.to_datetime(df['timestamp'], unit='s')
+            df.set_index('timestamp', inplace=True)
+            
+            return df
+            
+        except requests.RequestException as e:
+            logger.error(f"Error fetching data from Google Finance: {e}")
+            raise
+
+    def _calculate_technical_indicators(self, df: pd.DataFrame) -> pd.DataFrame:
+        """Calculate technical indicators."""
+        if len(df) < 50:
+            logger.warning("Not enough data points for technical analysis")
+            return df
+
+        # Moving Averages
+        df['SMA_20'] = df['close'].rolling(window=20).mean()
+        df['SMA_50'] = df['close'].rolling(window=50).mean()
+        df['EMA_12'] = df['close'].ewm(span=12, adjust=False).mean()
+        df['EMA_26'] = df['close'].ewm(span=26, adjust=False).mean()
+        
+        # MACD
+        df['MACD'] = df['EMA_12'] - df['EMA_26']
+        df['MACD_Signal'] = df['MACD'].ewm(span=9, adjust=False).mean()
+        
+        # RSI
+        delta = df['close'].diff()
+        gain = (delta.where(delta > 0, 0)).rolling(window=14).mean()
+        loss = (-delta.where(delta < 0, 0)).rolling(window=14).mean()
+        rs = gain / loss
+        df['RSI'] = 100 - (100 / (1 + rs))
+        
+        # Bollinger Bands
+        df['BB_middle'] = df['close'].rolling(window=20).mean()
+        std = df['close'].rolling(window=20).std()
+        df['BB_upper'] = df['BB_middle'] + (std * 2)
+        df['BB_lower'] = df['BB_middle'] - (std * 2)
+        
+        return df
+
+    def _get_fundamental_data(self, ticker: str) -> Dict:
+        """Fetch fundamental data from Google Finance."""
+        try:
+            url = f"{self.BASE_URL}/{ticker}"
+            response = requests.get(url)
+            response.raise_for_status()
+            
+            # Parse the response to extract fundamental data
+            data = response.json()
+            return {
+                'market_cap': data.get('marketCap'),
+                'pe_ratio': data.get('peRatio'),
+                'dividend_yield': data.get('dividendYield'),
+                'eps': data.get('eps'),
+                'high_52week': data.get('high52Week'),
+                'low_52week': data.get('low52Week')
+            }
+            
+        except requests.RequestException as e:
+            logger.error(f"Error fetching fundamental data: {e}")
+            return {}
+
+    def execute(self,  **kwargs) -> Dict:
+        """Execute the Google Finance tool with the provided parameters."""
+        ticker = kwargs.get('ticker')
+        start_date = kwargs.get('start_date')
+        end_date = kwargs.get('end_date')
+        interval = kwargs.get('interval', '1d')
+        analysis_type = kwargs.get('analysis_type', 'all')
+
+        try:
+            # Validate dates
+            start_dt, end_dt = self._validate_dates(start_date, end_date)
+            
+            # Fetch historical data
+            df = self._fetch_data(ticker, start_dt, end_dt, interval)
+            
+            result = {
+                'historical_data': df.to_dict(orient='records'),
+                'metadata': {
+                    'ticker': ticker,
+                    'start_date': start_date,
+                    'end_date': end_date,
+                    'interval': interval
+                }
+            }
+
+            # Add technical analysis if requested
+            if analysis_type in ['technical', 'all']:
+                df = self._calculate_technical_indicators(df)
+                result['technical_indicators'] = df.to_dict(orient='records')
+
+            # Add fundamental analysis if requested
+            if analysis_type in ['fundamental', 'all']:
+                fundamental_data = self._get_fundamental_data(ticker)
+                result['fundamental_data'] = fundamental_data
+
+            return result
+
+        except Exception as e:
+            logger.error(f"Error executing Google Finance tool: {e}")
+            raise
+
+    def validate_arguments(self, **kwargs) -> bool:
+        """Validate the provided arguments."""
+        required_args = [arg.name for arg in self.arguments if arg.required]
+        for arg in required_args:
+            if arg not in kwargs:
+                logger.error(f"Missing required argument: {arg}")
+                return False
+
+        if 'interval' in kwargs and kwargs['interval'] not in self.INTERVAL_MAPPING:
+            logger.error(f"Invalid interval: {kwargs['interval']}")
+            return False
+
+        return True