synth-ai 0.2.4.dev6__py3-none-any.whl → 0.2.4.dev7__py3-none-any.whl

synth_ai/tracing_v3/turso/models.py

@@ -1,28 +1,25 @@
 """SQLAlchemy declarative models for tracing v3."""
 
-from datetime import datetime
-from typing import Optional
+import json
+
 from sqlalchemy import (
+    Boolean,
+    CheckConstraint,
     Column,
-    Integer,
-    String,
     DateTime,
-    JSON,
+    Float,
     ForeignKey,
     Index,
+    Integer,
+    String,
     Text,
-    Float,
-    Boolean,
-    UniqueConstraint,
-    CheckConstraint,
     TypeDecorator,
+    UniqueConstraint,
 )
 from sqlalchemy.ext.declarative import declarative_base
 from sqlalchemy.orm import relationship
 from sqlalchemy.sql import func
 from sqlalchemy.types import UserDefinedType
-import json
-
 
 Base = declarative_base()
 
@@ -81,10 +78,11 @@ class JSONText(TypeDecorator):
 
 class SessionTrace(Base):
     """Database model for session traces.
-    
+
     Stores high-level information about tracing sessions including
     metadata, statistics, and relationships to timesteps and events.
     """
+
     __tablename__ = "session_traces"
 
     session_id = Column(String, primary_key=True)
@@ -114,10 +112,11 @@ class SessionTrace(Base):
 
 class SessionTimestep(Base):
     """Database model for session timesteps.
-    
+
     Represents individual steps within a tracing session, with timing
     information and relationships to events and messages.
     """
+
     __tablename__ = "session_timesteps"
 
     id = Column(Integer, primary_key=True, autoincrement=True)
@@ -145,11 +144,12 @@ class SessionTimestep(Base):
 
 class Event(Base):
     """Database model for events.
-    
+
     Stores all types of events (LM CAIS, environment, runtime) with
     type-specific fields and common metadata. Supports vector embeddings
     for similarity search.
     """
+
     __tablename__ = "events"
 
     id = Column(Integer, primary_key=True, autoincrement=True)
@@ -209,10 +209,11 @@ class Event(Base):
 
 class Message(Base):
     """Database model for messages.
-    
+
     Stores conversational messages between users, assistants, and systems
     with support for embeddings and rich metadata.
     """
+
     __tablename__ = "messages"
 
     id = Column(Integer, primary_key=True, autoincrement=True)
@@ -247,10 +248,11 @@ class Message(Base):
 
 class Experiment(Base):
     """Database model for experiments.
-    
+
     Groups related sessions and systems for experimental evaluation
     and comparison. Supports rich configuration and metadata.
     """
+
     __tablename__ = "experiments"
 
     experiment_id = Column(String, primary_key=True)
@@ -277,10 +279,11 @@ class Experiment(Base):
 
 class System(Base):
     """Database model for systems.
-    
+
     Represents agents, environments, or runtime systems that participate
     in tracing sessions. Supports versioning and type classification.
     """
+
     __tablename__ = "systems"
 
     system_id = Column(String, primary_key=True)
@@ -302,10 +305,11 @@ class System(Base):
 
 class SystemVersion(Base):
     """Database model for system versions.
-    
+
     Tracks different versions of systems with commit hashes,
     configuration changes, and relationships to experiments.
     """
+
     __tablename__ = "system_versions"
 
     version_id = Column(String, primary_key=True)
@@ -329,10 +333,11 @@ class SystemVersion(Base):
 
 class ExperimentalSystem(Base):
     """Database model for experiment-system relationships.
-    
+
     Junction table linking experiments with specific system versions,
     allowing tracking of which systems participated in which experiments.
     """
+
     __tablename__ = "experimental_systems"
 
     id = Column(Integer, primary_key=True, autoincrement=True)

synth_ai/tracing_v3/utils.py

@@ -1,10 +1,10 @@
 """Utility functions for tracing v3."""
 
-import json
-from datetime import datetime
-from typing import Any, Dict, Optional
 import hashlib
+import json
 import uuid
+from datetime import datetime
+from typing import Any
 
 
 def iso_now() -> str:
@@ -36,7 +36,7 @@ def generate_experiment_id(name: str) -> str:
     return f"exp_{hash_obj.hexdigest()[:12]}"
 
 
-def detect_provider(model_name: Optional[str]) -> str:
+def detect_provider(model_name: str | None) -> str:
     """Detect LLM provider from model name."""
     if not model_name:
         return "unknown"
@@ -59,7 +59,7 @@ def detect_provider(model_name: Optional[str]) -> str:
         return "unknown"
 
 
-def calculate_cost(model_name: str, input_tokens: int, output_tokens: int) -> Optional[float]:
+def calculate_cost(model_name: str, input_tokens: int, output_tokens: int) -> float | None:
     """Calculate cost in USD based on model and token counts."""
     # This is a simplified version - in production you'd want a proper pricing table
     pricing = {

synth_ai/tui/__main__.py

@@ -10,4 +10,4 @@ Usage:
 from .dashboard import main
 
 if __name__ == "__main__":
-    main()
+    main()

synth_ai/tui/cli/query_experiments.py

@@ -5,9 +5,8 @@ Query experiments and sessions from Turso/sqld using v3 tracing.
 
 import argparse
 import asyncio
-from typing import Optional
+
 from synth_ai.tracing_v3.turso.manager import AsyncSQLTraceManager
-import pandas as pd
 
 
 async def list_experiments(db_url: str):
@@ -119,7 +118,7 @@ async def show_experiment_details(db_url: str, experiment_id: str):
         await db.close()
 
 
-async def show_model_usage(db_url: str, model_name: Optional[str] = None):
+async def show_model_usage(db_url: str, model_name: str | None = None):
     """Show model usage statistics."""
     db = AsyncSQLTraceManager(db_url)
     await db.initialize()

synth_ai/tui/cli/query_experiments_v3.py

@@ -5,9 +5,8 @@ Query experiments and sessions from Turso/sqld using v3 tracing.
 
 import argparse
 import asyncio
-from typing import Optional
+
 from synth_ai.tracing_v3.turso.manager import AsyncSQLTraceManager
-import pandas as pd
 
 
 async def list_experiments(db_url: str):
@@ -119,7 +118,7 @@ async def show_experiment_details(db_url: str, experiment_id: str):
         await db.close()
 
 
-async def show_model_usage(db_url: str, model_name: Optional[str] = None):
+async def show_model_usage(db_url: str, model_name: str | None = None):
     """Show model usage statistics."""
     db = AsyncSQLTraceManager(db_url)
     await db.initialize()

synth_ai/tui/dashboard.py

@@ -5,68 +5,77 @@ Interactive TUI Dashboard for Synth AI experiments.
 Launch with: python -m synth_ai.tui.dashboard
 """
 
-import asyncio
 import logging
 from datetime import datetime
-from typing import List, Optional, Dict, Any
 from urllib.parse import urlparse
 
+from textual import on
 from textual.app import App, ComposeResult
-from textual.containers import Container, Horizontal, Vertical
-from textual.widgets import (
-    Header, Footer, DataTable, Static, Input, Button, 
-    TabbedContent, TabPane, Label, ProgressBar
-)
-from textual.reactive import reactive
 from textual.binding import Binding
-from textual import on
+from textual.containers import Container
+from textual.reactive import reactive
 from textual.timer import Timer
+from textual.widgets import (
+    DataTable,
+    Footer,
+    Header,
+    Static,
+)
 
 from ..tracing_v3.turso.manager import AsyncSQLTraceManager
 
+
 class ExperimentRow:
     """Data structure for experiment display."""
-    def __init__(self, exp_id: str, name: str, description: str, 
-                 created_at: datetime, sessions: int, events: int, 
-                 messages: int, cost: float, tokens: int):
+
+    def __init__(
+        self,
+        exp_id: str,
+        name: str,
+        description: str,
+        created_at: datetime,
+        sessions: int,
+        events: int,
+        messages: int,
+        cost: float,
+        tokens: int,
+    ):
         self.exp_id = exp_id
         self.name = name or "Unnamed"
         self.description = description or ""
         self.created_at = created_at
         self.sessions = sessions
-        self.events = events  
+        self.events = events
         self.messages = messages
         self.cost = cost
         self.tokens = tokens
-        
-    def to_row(self) -> List[str]:
+
+    def to_row(self) -> list[str]:
         """Convert to table row format."""
         return [
             self.exp_id[:8],  # Shortened ID
-            self.name[:20],   # Truncated name
+            self.name[:20],  # Truncated name
             str(self.sessions),
             str(self.events),
             str(self.messages),
             f"${self.cost:.4f}",
             f"{self.tokens:,}",
-            self.created_at.strftime("%H:%M")
+            self.created_at.strftime("%H:%M"),
         ]
 
+
 class ExperimentTable(DataTable):
     """Custom DataTable for experiments with refresh capability."""
-    
+
     def __init__(self, **kwargs):
         super().__init__(**kwargs)
-        self.experiments: List[ExperimentRow] = []
-        self.selected_exp_id: Optional[str] = None
-        
+        self.experiments: list[ExperimentRow] = []
+        self.selected_exp_id: str | None = None
+
     def setup_table(self):
         """Initialize table columns."""
-        self.add_columns(
-            "ID", "Name", "Sessions", "Events", 
-            "Messages", "Cost", "Tokens", "Time"
-        )
-        
+        self.add_columns("ID", "Name", "Sessions", "Events", "Messages", "Cost", "Tokens", "Time")
+
     async def refresh_data(self, db_manager: AsyncSQLTraceManager):
         """Refresh experiment data from database."""
         try:
@@ -89,50 +98,51 @@ class ExperimentTable(DataTable):
                 GROUP BY e.experiment_id, e.name, e.description, e.created_at
                 ORDER BY e.created_at DESC
             """)
-            
+
             self.experiments.clear()
             self.clear()
-            
+
             if not df.empty:
                 for _, row in df.iterrows():
                     exp_row = ExperimentRow(
-                        exp_id=row['experiment_id'],
-                        name=row['name'],
-                        description=row['description'],
-                        created_at=row['created_at'],
-                        sessions=int(row['num_sessions'] or 0),
-                        events=int(row['num_events'] or 0),
-                        messages=int(row['num_messages'] or 0),
-                        cost=float(row['total_cost'] or 0.0),
-                        tokens=int(row['total_tokens'] or 0)
+                        exp_id=row["experiment_id"],
+                        name=row["name"],
+                        description=row["description"],
+                        created_at=row["created_at"],
+                        sessions=int(row["num_sessions"] or 0),
+                        events=int(row["num_events"] or 0),
+                        messages=int(row["num_messages"] or 0),
+                        cost=float(row["total_cost"] or 0.0),
+                        tokens=int(row["total_tokens"] or 0),
                     )
                     self.experiments.append(exp_row)
                     self.add_row(*exp_row.to_row(), key=exp_row.exp_id)
-                
+
         except Exception as e:
             logging.error(f"Failed to refresh experiments: {e}")
-            
-    def get_selected_experiment(self) -> Optional[ExperimentRow]:
+
+    def get_selected_experiment(self) -> ExperimentRow | None:
         """Get currently selected experiment."""
         if self.cursor_row >= 0 and self.cursor_row < len(self.experiments):
             return self.experiments[self.cursor_row]
         return None
 
+
 class ExperimentDetail(Static):
     """Detailed view of selected experiment."""
-    
+
     def __init__(self, **kwargs):
         super().__init__(**kwargs)
-        self.current_experiment: Optional[ExperimentRow] = None
-        
-    def update_experiment(self, experiment: Optional[ExperimentRow]):
+        self.current_experiment: ExperimentRow | None = None
+
+    def update_experiment(self, experiment: ExperimentRow | None):
         """Update the displayed experiment details."""
         self.current_experiment = experiment
         if experiment:
             details = f"""
 🔬 **{experiment.name}**
 ID: {experiment.exp_id}
-Description: {experiment.description or 'No description'}
+Description: {experiment.description or "No description"}
 
 📊 **Statistics**
 Sessions: {experiment.sessions}
@@ -141,36 +151,38 @@ Messages: {experiment.messages}
 Cost: ${experiment.cost:.4f}
 Tokens: {experiment.tokens:,}
 
-🕒 **Created**: {experiment.created_at.strftime('%Y-%m-%d %H:%M:%S')}
+🕒 **Created**: {experiment.created_at.strftime("%Y-%m-%d %H:%M:%S")}
             """.strip()
         else:
             details = "Select an experiment to view details"
-            
+
         self.update(details)
 
+
 class DatabaseStatus(Static):
     """Display database connection status."""
-    
+
     connection_status = reactive("🔴 Disconnected")
-    
+
     def __init__(self, **kwargs):
         super().__init__(**kwargs)
-        
+
     def render(self) -> str:
         return f"Database: {self.connection_status}"
-        
+
     def set_connected(self, url: str):
         parsed = urlparse(url)
         host_info = f"{parsed.hostname}:{parsed.port}" if parsed.port else str(parsed.hostname)
         self.connection_status = f"🟢 Connected ({host_info})"
-        
+
     def set_disconnected(self, error: str = ""):
         error_text = f" - {error}" if error else ""
         self.connection_status = f"🔴 Disconnected{error_text}"
 
+
 class SynthDashboard(App):
     """Main Synth AI TUI Dashboard application."""
-    
+
     CSS = """
     Screen {
         layout: grid;
@@ -211,73 +223,73 @@ class SynthDashboard(App):
         padding: 0 1;
     }
     """
-    
+
     BINDINGS = [
         Binding("q", "quit", "Quit"),
         Binding("r", "refresh", "Refresh"),
         Binding("d", "toggle_debug", "Debug"),
         ("ctrl+c", "quit", "Quit"),
     ]
-    
+
     def __init__(self, db_url: str = "sqlite+aiosqlite:///./synth_ai.db/dbs/default/data"):
         super().__init__()
         self.db_url = db_url
-        self.db_manager: Optional[AsyncSQLTraceManager] = None
-        self.refresh_timer: Optional[Timer] = None
-        
+        self.db_manager: AsyncSQLTraceManager | None = None
+        self.refresh_timer: Timer | None = None
+
     def compose(self) -> ComposeResult:
         """Create the UI layout."""
         yield Header(show_clock=True)
-        
+
         with Container(id="experiments-table"):
             yield Static("🧪 Experiments", classes="section-title")
             yield ExperimentTable(id="experiments")
-            
+
         with Container(id="experiment-detail"):
-            yield Static("📋 Details", classes="section-title")  
+            yield Static("📋 Details", classes="section-title")
             yield ExperimentDetail(id="detail")
-            
+
         with Container(id="status-bar"):
             yield DatabaseStatus(id="db-status")
             yield Footer()
-            
+
     async def on_mount(self) -> None:
         """Initialize the app when mounted."""
         # Setup database connection
         try:
             self.db_manager = AsyncSQLTraceManager(self.db_url)
             await self.db_manager.initialize()
-            
+
             db_status = self.query_one("#db-status", DatabaseStatus)
             db_status.set_connected(self.db_url)
-            
+
         except Exception as e:
             logging.error(f"Failed to connect to database: {e}")
             db_status = self.query_one("#db-status", DatabaseStatus)
             db_status.set_disconnected(str(e))
-            
+
         # Setup experiment table
         exp_table = self.query_one("#experiments", ExperimentTable)
         exp_table.setup_table()
-        
+
         # Initial data load
         await self.action_refresh()
-        
+
         # Start auto-refresh timer (every 5 seconds)
         self.refresh_timer = self.set_interval(5.0, self._auto_refresh)
-        
+
     async def _auto_refresh(self) -> None:
         """Auto-refresh data periodically."""
         if self.db_manager:
             exp_table = self.query_one("#experiments", ExperimentTable)
             await exp_table.refresh_data(self.db_manager)
-            
+
     async def action_refresh(self) -> None:
         """Manual refresh action."""
         if self.db_manager:
             exp_table = self.query_one("#experiments", ExperimentTable)
             await exp_table.refresh_data(self.db_manager)
-            
+
     async def action_quit(self) -> None:
         """Quit the application."""
         if self.refresh_timer:
@@ -285,45 +297,44 @@ class SynthDashboard(App):
         if self.db_manager:
             await self.db_manager.close()
         self.exit()
-        
+
     def action_toggle_debug(self) -> None:
         """Toggle debug mode."""
         # Could add debug panel or logging level toggle
         pass
-        
+
     @on(DataTable.RowHighlighted, "#experiments")
     def on_experiment_selected(self, event: DataTable.RowHighlighted) -> None:
         """Handle experiment selection."""
         exp_table = self.query_one("#experiments", ExperimentTable)
         selected_exp = exp_table.get_selected_experiment()
-        
+
         detail_panel = self.query_one("#detail", ExperimentDetail)
         detail_panel.update_experiment(selected_exp)
 
+
 def main():
     """Main entry point for the dashboard."""
     import argparse
-    
+
     parser = argparse.ArgumentParser(description="Synth AI Interactive Dashboard")
     parser.add_argument(
-        "-u", "--url", 
+        "-u",
+        "--url",
         default="sqlite+libsql://http://127.0.0.1:8080",
-        help="Database URL (default: sqlite+libsql://http://127.0.0.1:8080)"
+        help="Database URL (default: sqlite+libsql://http://127.0.0.1:8080)",
     )
-    parser.add_argument(
-        "--debug",
-        action="store_true",
-        help="Enable debug logging"
-    )
-    
+    parser.add_argument("--debug", action="store_true", help="Enable debug logging")
+
     args = parser.parse_args()
-    
+
     if args.debug:
         logging.basicConfig(level=logging.DEBUG)
-        
+
     # Run the dashboard
     app = SynthDashboard(db_url=args.url)
     app.run()
 
+
 if __name__ == "__main__":
-    main()
+    main()