sigma-terminal 3.4.0__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()