sigma-terminal 3.4.1__py3-none-any.whl → 3.5.0__py3-none-any.whl

sigma/llm/router.py

@@ -0,0 +1,122 @@
+from typing import Any, Callable, Dict, List, Optional, Union, AsyncIterator
+import logging
+
+from .providers.base import BaseLLM
+from .providers.openai_provider import OpenAIProvider
+from .providers.anthropic_provider import AnthropicProvider
+from .providers.google_provider import GoogleProvider
+from .providers.ollama_provider import OllamaProvider
+from .providers.sigma_cloud_provider import SigmaCloudProvider
+from .registry import REGISTRY
+from .rate_limit import RateLimiter
+
+logger = logging.getLogger(__name__)
+
+class LLMRouter:
+    def __init__(self, settings):
+        self.settings = settings
+        self.providers: Dict[str, BaseLLM] = {}
+        
+        # Initialize providers based on settings
+        self._init_providers()
+        
+    def _init_providers(self):
+        # Sigma Cloud (Default)
+        # Always available due to embedded key fallback in the provider itself
+        self.providers["sigma_cloud"] = SigmaCloudProvider(
+            api_key=self.settings.sigma_cloud_api_key,
+            rate_limiter=RateLimiter(60, 0.5)
+        )
+
+        # OpenAI
+        if self.settings.openai_api_key:
+            self.providers["openai"] = OpenAIProvider(
+                api_key=self.settings.openai_api_key,
+                rate_limiter=RateLimiter(60, 0.2)
+            )
+            
+        # Anthropic
+        if self.settings.anthropic_api_key:
+            self.providers["anthropic"] = AnthropicProvider(
+                api_key=self.settings.anthropic_api_key,
+                rate_limiter=RateLimiter(40, 0.5)
+            )
+            
+        # Google
+        if self.settings.google_api_key:
+            self.providers["google"] = GoogleProvider(
+                api_key=self.settings.google_api_key,
+                rate_limiter=RateLimiter(60, 0.2)
+            )
+            
+        # Ollama (always available usually)
+        self.providers["ollama"] = OllamaProvider(
+            base_url=getattr(self.settings, "ollama_url", "http://localhost:11434"),
+            rate_limiter=RateLimiter(100, 0.01)
+        )
+
+    async def chat(
+        self,
+        messages: List[Dict[str, str]],
+        model: Optional[str] = None,
+        tools: Optional[List[Dict[str, Any]]] = None,
+        on_tool_call: Optional[Callable] = None,
+        stream: bool = True,
+        json_mode: bool = False,
+        provider: Optional[str] = None
+    ) -> Union[str, AsyncIterator[str]]:
+        
+        # Determine model and provider
+        selected_model = model or self.settings.default_model
+        selected_provider = provider
+        
+        if not selected_provider:
+            selected_provider = REGISTRY.get_provider(selected_model)
+        
+        # Get client
+        client = self.providers.get(selected_provider)
+        if not client:
+             # Fallback logic
+             if "ollama" in self.providers:
+                 logger.warning(f"Provider {selected_provider} not available, falling back to Ollama")
+                 client = self.providers["ollama"]
+                 # Find a fallback model?
+                 selected_model = self.settings.default_fallback_model or "llama3.2"
+             else:
+                 raise ValueError(f"Provider {selected_provider} not configured and no fallback available.")
+        
+        # Execute
+        try:
+            return await client.generate(
+                messages=messages,
+                model=selected_model,
+                tools=tools,
+                on_tool_call=on_tool_call,
+                stream=stream,
+                json_mode=json_mode
+            )
+        except Exception as e:
+            logger.error(f"Error generation with {selected_provider}/{selected_model}: {e}")
+            # Circuit breaker / fallback could go here
+            if selected_provider != "ollama" and "ollama" in self.providers:
+                 logger.info("Falling back to Ollama due to error")
+                 return await self.providers["ollama"].generate(
+                     messages=messages,
+                     model="llama3.2", # Hardcoded fallback
+                     tools=tools,
+                     on_tool_call=on_tool_call,
+                     stream=stream,
+                     json_mode=json_mode
+                 )
+            raise
+
+_router_instance: Optional[LLMRouter] = None
+
+def get_router(settings: Any = None) -> LLMRouter:
+    global _router_instance
+    if not _router_instance:
+        if settings:
+            _router_instance = LLMRouter(settings)
+        else:
+            raise RuntimeError("LLM Router not initialized and no settings provided")
+    return _router_instance

sigma/setup_agent.py

@@ -0,0 +1,188 @@
+import sys
+import os
+import subprocess
+import platform
+import shutil
+import time
+from rich.console import Console
+from rich.prompt import Prompt, Confirm
+from rich.panel import Panel
+from rich.progress import Progress, SpinnerColumn, TextColumn
+from rich.markdown import Markdown
+
+from .config import get_settings, save_api_key, save_setting, mark_first_run_complete
+from .llm.registry import REGISTRY
+
+console = Console()
+
+class SetupAgent:
+    def __init__(self):
+        self.os_type = platform.system().lower()
+        self.lean_ok = False
+        self.ollama_ok = False
+        
+    def run(self):
+        console.clear()
+        console.print(Panel.fit("[bold blue]Welcome to Sigma Setup Agent[/bold blue]", border_style="blue"))
+        console.print("[dim]Initializing your financial research environment...[/dim]\n")
+        
+        self.check_environment()
+        self.install_lean()
+        self.install_ollama()
+        self.configure_ollama_model()
+        self.configure_api_tools()
+        
+        mark_first_run_complete()
+        console.print("\n[bold green]Setup Complete![/bold green] Launching Sigma...")
+        time.sleep(2)
+
+    def check_environment(self):
+        console.print("[bold]1. Checking Environment[/bold]")
+        
+        # Python
+        py_ver = sys.version.split()[0]
+        console.print(f"  ✓ Python {py_ver}")
+        
+        # OS
+        console.print(f"  ✓ OS: {self.os_type}")
+
+    def install_lean(self):
+        console.print("\n[bold]2. Setting up LEAN Engine[/bold]")
+        
+        # Check if lean is installed
+        if shutil.which("lean"):
+            console.print("  ✓ LEAN CLI found")
+            self.lean_ok = True
+            return
+
+        if Confirm.ask("  [yellow]LEAN CLI not found. Install it now?[/yellow] (Required for backtesting)"):
+            with Progress(SpinnerColumn(), TextColumn("[progress.description]{task.description}")) as progress:
+                task = progress.add_task("Installing LEAN CLI...", total=None)
+                try:
+                    # Attempt pipx first
+                    if shutil.which("pipx"):
+                        subprocess.run(["pipx", "install", "lean-cli"], check=True, capture_output=True)
+                    else:
+                        subprocess.check_call([sys.executable, "-m", "pip", "install", "lean-cli"])
+                    progress.update(task, completed=True)
+                    console.print("  ✓ LEAN CLI installed successfully")
+                    self.lean_ok = True
+                    
+                    # Should run lean init? Might require user interaction. 
+                    # Providing basic config is safer.
+                    self._create_minimal_lean_config()
+                    
+                except Exception as e:
+                    console.print(f"  [red]Failed to install LEAN: {e}[/red]")
+                    console.print("  Please install manually: `pip install lean-cli`")
+
+    def _create_minimal_lean_config(self):
+        # Create a directory for lean data
+        lean_dir = os.path.expanduser("~/.sigma/lean_data")
+        os.makedirs(lean_dir, exist_ok=True)
+        # We might need to run `lean init` eventually, but for now just ensure folder exists.
+
+    def install_ollama(self):
+        console.print("\n[bold]3. Setting up Ollama[/bold]")
+        
+        if shutil.which("ollama"):
+            console.print("  ✓ Ollama binary found")
+            self.ollama_ok = True
+        else:
+            console.print("  [yellow]Ollama not found.[/yellow]")
+            if self.os_type == "darwin" and shutil.which("brew"):
+                if Confirm.ask("  Install via Homebrew?"):
+                    subprocess.run(["brew", "install", "ollama"], check=True)
+                    self.ollama_ok = True
+            elif self.os_type == "linux":
+                console.print("  Please install Ollama: curl -fsSL https://ollama.com/install.sh | sh")
+                Confirm.ask("  Press Enter once installed")
+            
+            # Verify again
+            if shutil.which("ollama"):
+                 self.ollama_ok = True
+        
+        if self.ollama_ok:
+            # Check if running
+            try:
+                subprocess.run(["ollama", "list"], check=True, capture_output=True)
+                console.print("  ✓ Ollama daemon is running")
+            except subprocess.CalledProcessError:
+                console.print("  [yellow]Ollama daemon not running. Attempting to start...[/yellow]")
+                # Attempt start (background)
+                if self.os_type == "darwin":
+                    subprocess.Popen(["open", "-a", "Ollama"])
+                elif self.os_type == "linux":
+                    subprocess.Popen(["ollama", "serve"], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+                
+                time.sleep(5) # Wait for start
+                console.print("  ✓ Attempted start. Please verify in taskbar if needed.")
+
+    def configure_ollama_model(self):
+        console.print("\n[bold]4. Configuring AI Models[/bold]")
+        
+        if not self.ollama_ok:
+            console.print("  [dim]Skipping Ollama model setup (Ollama not available)[/dim]")
+            return
+
+        choices = ["llama3.2", "mistral", "phi3", "custom"]
+        console.print("Select a default local model:")
+        for i, m in enumerate(choices):
+            console.print(f"  {i+1}) {m}")
+        
+        selection = Prompt.ask("Choose [1-4]", choices=["1", "2", "3", "4"], default="1")
+        model = choices[int(selection)-1]
+        
+        if model == "custom":
+            model = Prompt.ask("Enter model name (e.g. deepseek-coder)")
+            
+        console.print(f"  Selected: [bold]{model}[/bold]")
+        
+        # Check if pulled
+        try:
+            result = subprocess.run(["ollama", "list"], capture_output=True, text=True)
+            if model not in result.stdout:
+                if Confirm.ask(f"  Pull {model} now? (Required to use it)"):
+                    with Progress(SpinnerColumn(), TextColumn("[progress.description]{task.description}")) as progress:
+                         task = progress.add_task(f"Pulling {model}...", total=None)
+                         subprocess.run(["ollama", "pull", model], check=True)
+        except Exception as e:
+            console.print(f"  [red]Error checking/pulling model: {e}[/red]")
+
+        save_setting("default_model", model)
+        save_setting("ollama_url", "http://localhost:11434")
+
+    def configure_api_tools(self):
+        console.print("\n[bold]5. Enabling Data Providers[/bold]")
+        
+        providers = [
+            ("Alpha Vantage", "alpha_vantage_key"),
+            ("Polygon.io", "polygon_api_key"),
+            ("Financial Modeling Prep", "fmp_api_key"),
+            ("Exa Search", "exa_api_key"),
+            ("Massive", "massive_api_key"),
+            ("OpenAI", "openai_api_key"),
+            ("Anthropic", "anthropic_api_key"),
+            ("Google Gemini", "google_api_key"),
+        ]
+        
+        for name, key_id in providers:
+            settings = get_settings()
+            existing = getattr(settings, key_id, None)
+            
+            if not existing:
+                if Confirm.ask(f"  Configure {name}?"):
+                    key = Prompt.ask(f"    Enter API Key for {name}", password=True)
+                    if key:
+                        save_api_key(key_id, key)
+                        console.print(f"    ✓ Saved {name}")
+            else:
+                console.print(f"  ✓ {name} configured")
+
+def run_setup():
+    agent = SetupAgent()
+    agent.run()
+    return True
+
+if __name__ == "__main__":
+    run_setup()

sigma/tools/__init__.py

@@ -0,0 +1,23 @@
+from .registry import TOOL_REGISTRY, ToolDefinition
+from .adapter import register_legacy_tools
+from .library import *
+
+# Ensure legacy tools are registered
+register_legacy_tools()
+
+# Expose execute_tool for backward compatibility if needed, using the registry
+def execute_tool(name: str, args: dict):
+    # Registry doesn't have sync execute exposed directly? 
+    # But library functions are sync.
+    # Check definition.
+    tool = TOOL_REGISTRY.get_tool(name)
+    if tool:
+        try:
+            return tool.func(**args)
+        except Exception as e:
+            return {"error": str(e)}
+    return {"error": "Tool not found"}
+
+# Helpers
+def get_tools_for_llm():
+    return TOOL_REGISTRY.to_llm_format()

sigma/tools/adapter.py

@@ -0,0 +1,38 @@
+from typing import Any, Dict
+from .registry import TOOL_REGISTRY, ToolDefinition
+from .library import TOOLS, TOOL_FUNCTIONS
+
+def register_legacy_tools():
+    """Import tools from the legacy library defined in library.py"""
+    
+    # Map from TOOLS list (which has schema) to TOOL_FUNCTIONS (which has implementation)
+    
+    for tool_def in TOOLS:
+        if tool_def["type"] != "function": continue
+        
+        func_def = tool_def["function"]
+        name = func_def["name"]
+        description = func_def.get("description", "")
+        parameters = func_def.get("parameters", {})
+        
+        func = TOOL_FUNCTIONS.get(name)
+        if not func:
+            continue
+            
+        # Determine provider based on name prefix or guess
+        provider = "yfinance"
+        if name.startswith("polygon"): provider = "polygon"
+        if name.startswith("alpha"): provider = "alpha_vantage" 
+        # etc...
+        
+        # Register manually to bypass decorator
+        TOOL_REGISTRY._tools[name] = ToolDefinition(
+            name=name,
+            description=description,
+            input_schema=parameters,
+            func=func,
+            provider=provider
+        )
+
+# Run registration
+register_legacy_tools()

sigma/{tools.py → tools/library.py}

@@ -1450,7 +1450,8 @@ TOOLS = [
                 "type": "object",
                 "properties": {
                     "symbol": {"type": "string", "description": "Stock ticker symbol"},
-                    "period": {"type": "string", "description": "Time period: 1d, 5d, 1mo, 3mo, 6mo, 1y, 2y, 5y, max", "default": "3mo"}
+                    "period": {"type": "string", "description": "Time period: 1d, 5d, 1mo, 3mo, 6mo, 1y, 2y, 5y, max", "default": "3mo"},
+                    "interval": {"type": "string", "description": "Data interval: 1m, 2m, 5m, 15m, 30m, 60m, 90m, 1h, 1d, 5d, 1wk, 1mo, 3mo", "default": "1d"}
                 },
                 "required": ["symbol"]
             }

sigma/tools/registry.py

@@ -0,0 +1,108 @@
+from typing import Any, Callable, Dict, List, Optional
+from pydantic import BaseModel
+import inspect
+
+class ToolDefinition(BaseModel):
+    name: str
+    description: str
+    input_schema: Dict[str, Any]
+    output_schema: Optional[Dict[str, Any]] = None
+    func: Callable
+    enabled: bool = True
+    provider: str = "internal" # yfinance, polygon, etc.
+
+class ToolRegistry:
+    def __init__(self):
+        self._tools: Dict[str, ToolDefinition] = {}
+
+    def register(self, name: str, description: str, provider: str = "internal"):
+        def decorator(func):
+            # Extract schema from type hints (simplified)
+            # In a real impl, utilize pydantic.TypeAdapter or similar if args are models.
+            # Here we assume simple args or we use a manual schema if provided?
+            # For now, let's keep it simple: no schema auto-extraction in this snippet 
+            # unless we implement a Schema generator.
+            # But the prompt says "typed tool registry... input_schema (pydantic)".
+            
+            # minimal schema generation
+            sig = inspect.signature(func)
+            params = {}
+            required = []
+            for pname, p in sig.parameters.items():
+                if pname == "self": continue
+                p_type = "string"
+                if p.annotation == int: p_type = "integer"
+                if p.annotation == float: p_type = "number"
+                if p.annotation == bool: p_type = "boolean"
+                
+                params[pname] = {"type": p_type}
+                if p.default == inspect.Parameter.empty:
+                    required.append(pname)
+            
+            schema = {
+                "type": "object",
+                "properties": params,
+                "required": required
+            }
+            
+            self._tools[name] = ToolDefinition(
+                name=name,
+                description=description,
+                input_schema=schema,
+                func=func,
+                provider=provider
+            )
+            return func
+        return decorator
+
+    def get_tool(self, name: str) -> Optional[ToolDefinition]:
+        return self._tools.get(name)
+
+    def list_tools(self) -> List[ToolDefinition]:
+        return [t for t in self._tools.values() if t.enabled]
+
+    def to_llm_format(self) -> List[Dict[str, Any]]:
+        tools_list = []
+        for t in self.list_tools():
+            # Clone schema to avoid mutating original
+            import copy
+            schema = copy.deepcopy(t.input_schema)
+            
+            # Inject thought parameter for Gemini/HackClub compatibility
+            # Some providers like Gemini via proxies require a "thought" field in tool calls
+            if "properties" in schema:
+                schema["properties"]["thought_signature"] = {
+                    "type": "string", 
+                    "description": "Internal reasoning for why this tool is being called. MUST be provided."
+                }
+                # Force model to use it
+                if "required" in schema and isinstance(schema["required"], list):
+                    schema["required"].append("thought_signature")
+                else:
+                    schema["required"] = ["thought_signature"]
+                
+            tools_list.append({
+                "type": "function",
+                "function": {
+                    "name": t.name,
+                    "description": t.description,
+                    "parameters": schema
+                }
+            })
+        return tools_list
+
+    async def execute(self, name: str, args: Dict[str, Any]) -> Any:
+        tool = self.get_tool(name)
+        if not tool:
+            raise ValueError(f"Tool {name} not found")
+        
+        # Remove provider-specific fields if present
+        args.pop("thought", None)
+        args.pop("thought_signature", None)
+        
+        if inspect.iscoroutinefunction(tool.func):
+            return await tool.func(**args)
+        else:
+            return tool.func(**args)
+
+TOOL_REGISTRY = ToolRegistry()

sigma/utils/extraction.py

@@ -0,0 +1,83 @@
+import re
+from datetime import datetime, timedelta
+from typing import List, Optional, Tuple
+
+COMMON_TICKERS = {
+    # Ticker map for normalization if needed
+    "APPLE": "AAPL",
+    "GOOGLE": "GOOGL",
+    "MICROSOFT": "MSFT",
+    "AMAZON": "AMZN",
+    "TESLA": "TSLA",
+    "NVIDIA": "NVDA",
+    "META": "META",
+    "FACEBOOK": "META",
+    "NETFLIX": "NFLX",
+    "S&P 500": "SPY",
+    "SP500": "SPY",
+    "S&P": "SPY",
+    "NASDAQ": "QQQ",
+    "DOW": "DIA",
+    "DOW JONES": "DIA",
+    "BITCOIN": "BTC-USD",
+    "ETHEREUM": "ETH-USD",
+}
+
+def extract_tickers(text: str) -> List[str]:
+    """Extract and normalize tickers from text."""
+    found = []
+    
+    # Check known names first (case insensitive bounds)
+    upper_text = text.upper()
+    for name, ticker in COMMON_TICKERS.items():
+        # Simple word boundary check
+        if re.search(r'\b' + re.escape(name) + r'\b', upper_text):
+            found.append(ticker)
+            
+    # Regex for standard tickers (capitals, 1-5 chars)
+    # Exclude common words like I, A, AM, PM, IS, AT, VS, OR, AND...
+    # Strict mode: must be uppercase in original text? The prompt implies natural language which might be mixed.
+    # But usually users type tickers in caps or "Apple".
+    
+    # For simplicity, extract probable tickers
+    matches = re.findall(r'\b[A-Z]{2,5}\b', text)
+    stopwords = {"AND", "OR", "THE", "FOR", "GET", "SET", "NOT", "BUT", "BY", "OF", "AT", "IN", "ON", "TO", "FROM", "VS", "GDP", "CPI", "USD", "YTD", "CEO", "CFO", "SEC", "API", "LLM", "AI"}
+    
+    for m in matches:
+        if m not in stopwords and m not in found:
+            found.append(m)
+            
+    return list(set(found))
+
+def extract_timeframe(text: str) -> Tuple[str, Optional[str], Optional[str]]:
+    """Extract timeframe description, start date, end date."""
+    
+    today = datetime.now()
+    
+    # "5y", "10 years", "start of 2020"
+    
+    # Simple regex for periods
+    match_years = re.search(r'\b(\d+)\s*y(ears?)?\b', text)
+    if match_years:
+        years = int(match_years.group(1))
+        start_date = (today - timedelta(days=years*365)).strftime("%Y-%m-%d")
+        return f"{years}y", start_date, None
+        
+    match_months = re.search(r'\b(\d+)\s*m(onths?)?\b', text)
+    if match_months:
+        months = int(match_months.group(1))
+        start_date = (today - timedelta(days=months*30)).strftime("%Y-%m-%d")
+        return f"{months}m", start_date, None
+        
+    # "Since 2021"
+    match_since = re.search(r'\bsince\s+(\d{4})\b', text)
+    if match_since:
+        year = int(match_since.group(1))
+        return f"since {year}", f"{year}-01-01", None
+        
+    # "YTD"
+    if "YTD" in text.upper():
+        start_date = f"{today.year}-01-01"
+        return "YTD", start_date, None
+        
+    return "default", None, None