auditi 0.1.0__py3-none-any.whl

auditi/__init__.py

@@ -0,0 +1,47 @@
+"""
+Auditi - AI/LLM Evaluation and Monitoring SDK
+
+This package provides decorators and utilities for tracing AI agent
+interactions and sending them to the Auditi platform for evaluation.
+"""
+
+from .client import init, get_client, AuditiClient
+from .decorators import trace_agent, trace_tool, trace_llm, trace_embedding, trace_retrieval
+from .evaluator import BaseEvaluator
+from .context import get_current_trace, set_current_trace, set_context, get_context
+from .client import get_client
+from .evaluator import BaseEvaluator
+from .transport import BaseTransport, SyncHttpTransport, DebugTransport
+from .types import TraceInput, SpanInput, EvaluationResult
+from .events import EventType, StreamEvent
+
+__version__ = "0.1.0"
+
+__all__ = [
+    # Client
+    "init",
+    "get_client",
+    "AuditiClient",
+    # Context
+    "set_context",
+    "get_context",
+    # Decorators
+    "trace_agent",
+    "trace_tool",
+    "trace_llm",
+    "trace_embedding",
+    "trace_retrieval",
+    # Evaluator
+    "BaseEvaluator",
+    # Transport
+    "BaseTransport",
+    "SyncHttpTransport",
+    "DebugTransport",
+    # Types
+    "TraceInput",
+    "SpanInput",
+    "EvaluationResult",
+    # Events
+    "EventType",
+    "StreamEvent",
+]

auditi/client.py

@@ -0,0 +1,76 @@
+"""
+Auditi SDK Client
+
+Manages SDK initialization and provides access to the transport layer.
+"""
+from typing import Optional
+from .transport import BaseTransport, SyncHttpTransport
+
+
+class AuditiClient:
+    """
+    Main client for the Auditi SDK.
+    Manages the transport layer for sending traces to the Auditi platform.
+    """
+    
+    def __init__(
+        self, 
+        api_key: Optional[str] = None, 
+        base_url: str = "http://localhost:8000",
+        transport: Optional[BaseTransport] = None
+    ):
+        """
+        Initialize the Auditi client.
+        
+        Args:
+            api_key: API key for authentication (optional for local development)
+            base_url: Base URL of the Auditi API
+            transport: Custom transport implementation (optional)
+        """
+        if transport:
+            self.transport = transport
+        else:
+            self.transport = SyncHttpTransport(base_url, api_key)
+
+
+# Global client instance
+_client_instance: Optional[AuditiClient] = None
+
+
+def init(
+    api_key: Optional[str] = None, 
+    base_url: str = "http://localhost:8000",
+    transport: Optional[BaseTransport] = None
+) -> AuditiClient:
+    """
+    Initialize the Auditi SDK with the given configuration.
+    
+    Args:
+        api_key: API key for authentication
+        base_url: Base URL of the Auditi API (default: localhost:8000)
+        transport: Custom transport implementation
+        
+    Returns:
+        The initialized AuditiClient instance
+        
+    Example:
+        >>> import auditi
+        >>> auditi.init(api_key="your-key", base_url="https://api.auditi.dev")
+    """
+    global _client_instance
+    _client_instance = AuditiClient(api_key, base_url, transport)
+    return _client_instance
+
+
+def get_client() -> AuditiClient:
+    """
+    Get the current Auditi client instance.
+    If not initialized, creates a default client for local development.
+    
+    Returns:
+        The current AuditiClient instance
+    """
+    global _client_instance
+    if _client_instance is None:
+        _client_instance = AuditiClient()
+    return _client_instance

auditi/context.py

@@ -0,0 +1,71 @@
+"""
+Context management for trace and span tracking.
+
+Uses Python's contextvars for thread-safe context propagation.
+"""
+from contextvars import ContextVar
+from typing import Optional, List
+from .types import TraceInput, SpanInput
+
+# Context variables for thread-safe trace tracking
+_current_trace: ContextVar[Optional[TraceInput]] = ContextVar("current_trace", default=None)
+_span_stack: ContextVar[List[SpanInput]] = ContextVar("span_stack", default=[])
+_global_context: ContextVar[dict] = ContextVar("global_context", default={})
+
+
+def get_current_trace() -> Optional[TraceInput]:
+    """Get the current active trace, if any."""
+    return _current_trace.get()
+
+
+def set_current_trace(trace: TraceInput) -> None:
+    """Set the current active trace."""
+    _current_trace.set(trace)
+
+
+def clear_current_trace() -> None:
+    """Clear the current trace context."""
+    _current_trace.set(None)
+    _span_stack.set([])
+
+
+def get_current_span() -> Optional[SpanInput]:
+    """Get the current (innermost) span, if any."""
+    stack = _span_stack.get()
+    if stack:
+        return stack[-1]
+    return None
+
+
+def push_span(span: SpanInput) -> None:
+    """Push a new span onto the stack."""
+    stack = _span_stack.get()
+    new_stack = stack.copy()
+    new_stack.append(span)
+    _span_stack.set(new_stack)
+
+
+def pop_span() -> Optional[SpanInput]:
+    """Pop the current span from the stack."""
+    stack = _span_stack.get()
+    if not stack:
+        return None
+    new_stack = stack.copy()
+    span = new_stack.pop()
+    _span_stack.set(new_stack)
+    return span
+
+
+def set_context(user_id: str = None, session_id: str = None) -> None:
+    """Set global context for the current execution context."""
+    ctx = _global_context.get().copy()
+    if user_id:
+        ctx["user_id"] = user_id
+    if session_id:
+        ctx["session_id"] = session_id
+    _global_context.set(ctx)
+
+
+def get_context() -> dict:
+    """Get the current global context."""
+    return _global_context.get()