sigma-terminal 2.0.2__py3-none-any.whl → 3.3.0__py3-none-any.whl

sigma/core/agent.py

@@ -1,205 +0,0 @@
-"""Sigma Research Agent."""
-
-import asyncio
-import time
-from datetime import datetime
-from typing import Any, Callable, Optional
-
-from sigma.core.config import LLMProvider, get_settings
-from sigma.core.llm import get_llm, BaseLLM
-from sigma.core.models import Message, MessageRole, ToolCall, ToolResult
-from sigma.tools.financial import get_all_tools, execute_tool
-
-
-SYSTEM_PROMPT = """You are Sigma, an elite quantitative financial research analyst and AI-powered trading strategist. You have institutional-grade expertise in markets, securities analysis, algorithmic trading, and investment research.
-
-CRITICAL CONSTRAINT: You ONLY respond to finance, investing, trading, and market-related queries.
-- If a user asks about non-financial topics, politely redirect them to financial topics
-- Example: "I specialize in financial analysis. I can help you with stock analysis, market research, portfolio optimization, or trading strategies. What financial topic would you like to explore?"
-
-Your capabilities include:
-
-MARKET DATA & ANALYSIS
-- Real-time stock quotes and market data
-- Historical price analysis and charting
-- Sector performance and market indices
-- Options chain analysis
-
-TECHNICAL ANALYSIS
-- Price charts (line, candle, area)
-- Moving averages (SMA, EMA)
-- RSI, MACD, Bollinger Bands
-- Support/resistance levels
-- Technical signals and patterns
-
-FUNDAMENTAL ANALYSIS
-- Financial statements (income, balance sheet, cash flow)
-- Valuation metrics (P/E, P/B, PEG, EV/EBITDA)
-- Earnings and revenue analysis
-- Profitability ratios (ROE, ROA, margins)
-
-PREDICTIONS & FORECASTING
-- Price predictions using multiple models
-- Sentiment analysis
-- Risk assessment
-- Monte Carlo simulations
-
-INSTITUTIONAL FEATURES
-- Analyst recommendations and price targets
-- Insider trading activity
-- Institutional holdings
-- Short interest data
-
-ALGORITHMIC TRADING
-- Generate LEAN engine backtests
-- Strategy templates (SMA crossover, RSI mean reversion, MACD momentum, etc.)
-- Custom strategy builder
-- Backtest parameter optimization
-
-When answering:
-1. ALWAYS use tools to get real, current data - never make up numbers
-2. Provide specific metrics and data points
-3. Present analysis in clear, structured formats
-4. Include risk factors and caveats
-5. Give actionable insights with reasoning
-6. Use charts when visualizing would help
-7. Compare to benchmarks and peers when relevant
-
-For comprehensive analysis, use multiple tools:
-1. get_stock_quote → Current price and key metrics
-2. get_company_info → Business context and fundamentals
-3. get_analyst_recommendations → Wall Street sentiment
-4. technical_analysis → Price action and signals
-5. get_financial_statements → Deep fundamental analysis
-6. sentiment_analysis → Multi-factor sentiment
-7. price_forecast → Forward-looking projections
-
-For charts and visualization:
-- generate_price_chart → Beautiful terminal price charts
-- generate_comparison_chart → Compare multiple stocks
-- generate_rsi_chart → Price with RSI indicator
-- generate_sector_chart → Sector performance overview
-
-For backtesting and strategy:
-- list_backtest_strategies → Available strategies
-- generate_backtest → Create LEAN algorithm
-- generate_custom_backtest → Custom strategy builder
-
-Your analysis should match the quality of Goldman Sachs, Morgan Stanley, and Citadel research."""
-
-
-class SigmaAgent:
-    """Financial research agent."""
-    
-    def __init__(
-        self,
-        provider: Optional[LLMProvider] = None,
-        model: Optional[str] = None,
-    ):
-        self.settings = get_settings()
-        self.provider = provider or self.settings.default_provider
-        self.llm: BaseLLM = get_llm(self.provider, model)
-        self.messages: list[Message] = []
-        self.tools = get_all_tools()
-        self.tool_results: list[ToolResult] = []
-        self._reset()
-    
-    def _reset(self):
-        """Reset conversation."""
-        self.messages = [
-            Message(role=MessageRole.SYSTEM, content=SYSTEM_PROMPT)
-        ]
-        self.tool_results = []
-    
-    async def run(
-        self,
-        query: str,
-        on_tool_start: Optional[Callable[[str, dict], None]] = None,
-        on_tool_end: Optional[Callable[[str, Any, float], None]] = None,
-        on_thinking: Optional[Callable[[str], None]] = None,
-        on_response: Optional[Callable[[str], None]] = None,
-    ) -> str:
-        """Run the agent on a query."""
-        self.messages.append(Message(role=MessageRole.USER, content=query))
-        self.tool_results = []
-        
-        iteration = 0
-        start_time = time.time()
-        
-        while iteration < self.settings.max_iterations:
-            iteration += 1
-            
-            # Get LLM response
-            try:
-                content, tool_calls = await self.llm.generate(
-                    messages=self.messages,
-                    tools=self.tools,
-                )
-            except Exception as e:
-                return f"Error: {str(e)}"
-            
-            # If no tool calls, we're done
-            if not tool_calls:
-                if content:
-                    self.messages.append(Message(role=MessageRole.ASSISTANT, content=content))
-                    if on_response:
-                        on_response(content)
-                    return content
-                continue
-            
-            # Record assistant message with tool calls
-            self.messages.append(Message(
-                role=MessageRole.ASSISTANT,
-                content=content,
-                tool_calls=tool_calls,
-            ))
-            
-            if on_thinking and content:
-                on_thinking(content)
-            
-            # Execute tools
-            for tc in tool_calls:
-                tool_start = time.time()
-                
-                if on_tool_start:
-                    on_tool_start(tc.name, tc.arguments)
-                
-                result = await execute_tool(tc.name, tc.arguments)
-                
-                duration_ms = (time.time() - tool_start) * 1000
-                
-                tool_result = ToolResult(
-                    tool_name=tc.name,
-                    tool_call_id=tc.id,
-                    success="error" not in str(result).lower(),
-                    result=result,
-                    duration_ms=duration_ms,
-                )
-                self.tool_results.append(tool_result)
-                
-                if on_tool_end:
-                    on_tool_end(tc.name, result, duration_ms)
-                
-                # Add tool result message
-                self.messages.append(Message(
-                    role=MessageRole.TOOL,
-                    content=str(result),
-                    tool_call_id=tc.id,
-                    name=tc.name,
-                ))
-        
-        return "Max iterations reached. Please try a simpler query."
-    
-    def get_stats(self) -> dict[str, Any]:
-        """Get execution statistics."""
-        total_time = sum(r.duration_ms for r in self.tool_results)
-        return {
-            "tools_called": len(self.tool_results),
-            "total_time_ms": total_time,
-            "successful": sum(1 for r in self.tool_results if r.success),
-            "failed": sum(1 for r in self.tool_results if not r.success),
-        }
-    
-    def clear(self):
-        """Clear conversation history."""
-        self._reset()

sigma/core/config.py

@@ -1,119 +0,0 @@
-"""Configuration for Sigma."""
-
-from enum import Enum
-from pathlib import Path
-from typing import Optional
-
-from pydantic import Field, SecretStr
-from pydantic_settings import BaseSettings, SettingsConfigDict
-
-
-class LLMProvider(str, Enum):
-    """LLM providers."""
-    OPENAI = "openai"
-    ANTHROPIC = "anthropic"
-    GOOGLE = "google"
-    OLLAMA = "ollama"
-    XAI = "xai"
-    GROQ = "groq"
-
-
-class Settings(BaseSettings):
-    """Application settings."""
-    
-    model_config = SettingsConfigDict(
-        env_file=".env",
-        env_file_encoding="utf-8",
-        extra="ignore",
-    )
-    
-    # App
-    app_name: str = "Sigma"
-    debug: bool = False
-    
-    # LLM
-    default_provider: LLMProvider = LLMProvider.GOOGLE
-    
-    # API Keys
-    openai_api_key: Optional[SecretStr] = Field(default=None, alias="OPENAI_API_KEY")
-    anthropic_api_key: Optional[SecretStr] = Field(default=None, alias="ANTHROPIC_API_KEY")
-    google_api_key: Optional[SecretStr] = Field(default=None, alias="GOOGLE_API_KEY")
-    xai_api_key: Optional[SecretStr] = Field(default=None, alias="XAI_API_KEY")
-    groq_api_key: Optional[SecretStr] = Field(default=None, alias="GROQ_API_KEY")
-    
-    # Models
-    openai_model: str = "gpt-4o"
-    anthropic_model: str = "claude-sonnet-4-20250514"
-    google_model: str = "gemini-2.0-flash"
-    ollama_model: str = "llama3.2"
-    xai_model: str = "grok-beta"
-    groq_model: str = "llama-3.3-70b-versatile"
-    
-    # Ollama
-    ollama_base_url: str = "http://127.0.0.1:11434"
-    
-    # Search
-    exa_api_key: Optional[SecretStr] = Field(default=None, alias="EXASEARCH_API_KEY")
-    tavily_api_key: Optional[SecretStr] = Field(default=None, alias="TAVILY_API_KEY")
-    serper_api_key: Optional[SecretStr] = Field(default=None, alias="SERPER_API_KEY")
-    
-    # Financial
-    financial_datasets_api_key: Optional[SecretStr] = Field(default=None, alias="FINANCIAL_DATASETS_API_KEY")
-    fmp_api_key: Optional[SecretStr] = Field(default=None, alias="FMP_API_KEY")
-    polygon_api_key: Optional[SecretStr] = Field(default=None, alias="POLYGON_API_KEY")
-    alpha_vantage_api_key: Optional[SecretStr] = Field(default=None, alias="ALPHA_VANTAGE_API_KEY")
-    
-    # Agent
-    max_iterations: int = 25
-    max_tokens: int = 8192
-    temperature: float = 0.1
-    
-    # Storage
-    cache_dir: Path = Path.home() / ".sigma" / "cache"
-    db_path: Path = Path.home() / ".sigma" / "sigma.db"
-    
-    def get_api_key(self, provider: LLMProvider) -> Optional[str]:
-        """Get API key for provider."""
-        keys = {
-            LLMProvider.OPENAI: self.openai_api_key,
-            LLMProvider.ANTHROPIC: self.anthropic_api_key,
-            LLMProvider.GOOGLE: self.google_api_key,
-            LLMProvider.XAI: self.xai_api_key,
-            LLMProvider.GROQ: self.groq_api_key,
-        }
-        key = keys.get(provider)
-        return key.get_secret_value() if key else None
-    
-    def get_model(self, provider: Optional[LLMProvider] = None) -> str:
-        """Get model for provider."""
-        provider = provider or self.default_provider
-        models = {
-            LLMProvider.OPENAI: self.openai_model,
-            LLMProvider.ANTHROPIC: self.anthropic_model,
-            LLMProvider.GOOGLE: self.google_model,
-            LLMProvider.OLLAMA: self.ollama_model,
-            LLMProvider.XAI: self.xai_model,
-            LLMProvider.GROQ: self.groq_model,
-        }
-        return models.get(provider, self.google_model)
-    
-    def get_available_providers(self) -> list[LLMProvider]:
-        """Get providers with API keys."""
-        available = []
-        for p in LLMProvider:
-            if p == LLMProvider.OLLAMA:
-                available.append(p)
-            elif self.get_api_key(p):
-                available.append(p)
-        return available
-
-
-_settings: Optional[Settings] = None
-
-
-def get_settings() -> Settings:
-    """Get settings singleton."""
-    global _settings
-    if _settings is None:
-        _settings = Settings()
-    return _settings