kalibr 1.1.2a0__py3-none-any.whl → 1.3.0__py3-none-any.whl

kalibr/cost_adapter.py

@@ -10,6 +10,8 @@ Supports:
 - OpenAI (GPT-4, GPT-3.5, etc.)
 - Anthropic (Claude models)
 - Extensible for other vendors
+
+Note: All adapters now use centralized pricing from kalibr.pricing module.
 """
 
 import json
@@ -17,6 +19,8 @@ import os
 from abc import ABC, abstractmethod
 from typing import Dict, Optional
 
+from kalibr.pricing import get_pricing, normalize_model_name
+
 
 class BaseCostAdapter(ABC):
     """Base class for vendor cost adapters."""
@@ -42,43 +46,27 @@ class BaseCostAdapter(ABC):
 
 
 class OpenAICostAdapter(BaseCostAdapter):
-    """Cost adapter for OpenAI models."""
-
-    # OpenAI pricing as of 2025 (per 1M tokens)
-    # Source: https://openai.com/pricing
-    PRICING = {
-        "gpt-4": {
-            "input": 30.00,  # $30/1M input tokens
-            "output": 60.00,  # $60/1M output tokens
-        },
-        "gpt-4-turbo": {
-            "input": 10.00,
-            "output": 30.00,
-        },
-        "gpt-4o": {
-            "input": 2.50,
-            "output": 10.00,
-        },
-        "gpt-3.5-turbo": {
-            "input": 0.50,
-            "output": 1.50,
-        },
-        "gpt-4o-mini": {
-            "input": 0.15,
-            "output": 0.60,
-        },
-    }
+    """Cost adapter for OpenAI models.
+    
+    Uses centralized pricing from kalibr.pricing module.
+    """
 
     def get_vendor_name(self) -> str:
         return "openai"
 
     def compute_cost(self, model_name: str, tokens_in: int, tokens_out: int) -> float:
-        """Compute cost for OpenAI models."""
-        # Normalize model name
-        model_key = self._normalize_model_name(model_name)
-
-        # Get pricing (default to gpt-4 if unknown)
-        pricing = self.PRICING.get(model_key, self.PRICING["gpt-4"])
+        """Compute cost for OpenAI models.
+        
+        Args:
+            model_name: Model identifier (e.g., "gpt-4o", "gpt-4")
+            tokens_in: Input token count
+            tokens_out: Output token count
+            
+        Returns:
+            Cost in USD (rounded to 6 decimal places)
+        """
+        # Get pricing from centralized module
+        pricing, _ = get_pricing("openai", model_name)
 
         # Calculate cost (pricing is per 1M tokens)
         input_cost = (tokens_in / 1_000_000) * pricing["input"]
@@ -86,64 +74,29 @@ class OpenAICostAdapter(BaseCostAdapter):
 
         return round(input_cost + output_cost, 6)
 
-    def _normalize_model_name(self, model_name: str) -> str:
-        """Normalize model name to match pricing table."""
-        model_lower = model_name.lower()
-
-        # Direct matches
-        if model_lower in self.PRICING:
-            return model_lower
-
-        # Fuzzy matches
-        if "gpt-4o-mini" in model_lower:
-            return "gpt-4o-mini"
-        elif "gpt-4o" in model_lower:
-            return "gpt-4o"
-        elif "gpt-4-turbo" in model_lower:
-            return "gpt-4-turbo"
-        elif "gpt-4" in model_lower:
-            return "gpt-4"
-        elif "gpt-3.5" in model_lower:
-            return "gpt-3.5-turbo"
-
-        # Default to gpt-4 for unknown models
-        return "gpt-4"
-
 
 class AnthropicCostAdapter(BaseCostAdapter):
-    """Cost adapter for Anthropic Claude models."""
-
-    # Anthropic pricing as of 2025 (per 1M tokens)
-    # Source: https://www.anthropic.com/pricing
-    PRICING = {
-        "claude-3-opus": {
-            "input": 15.00,
-            "output": 75.00,
-        },
-        "claude-3-sonnet": {
-            "input": 3.00,
-            "output": 15.00,
-        },
-        "claude-3-haiku": {
-            "input": 0.25,
-            "output": 1.25,
-        },
-        "claude-3.5-sonnet": {
-            "input": 3.00,
-            "output": 15.00,
-        },
-    }
+    """Cost adapter for Anthropic Claude models.
+    
+    Uses centralized pricing from kalibr.pricing module.
+    """
 
     def get_vendor_name(self) -> str:
         return "anthropic"
 
     def compute_cost(self, model_name: str, tokens_in: int, tokens_out: int) -> float:
-        """Compute cost for Anthropic models."""
-        # Normalize model name
-        model_key = self._normalize_model_name(model_name)
-
-        # Get pricing (default to opus if unknown)
-        pricing = self.PRICING.get(model_key, self.PRICING["claude-3-opus"])
+        """Compute cost for Anthropic models.
+        
+        Args:
+            model_name: Model identifier (e.g., "claude-3-opus", "claude-3-5-sonnet")
+            tokens_in: Input token count
+            tokens_out: Output token count
+            
+        Returns:
+            Cost in USD (rounded to 6 decimal places)
+        """
+        # Get pricing from centralized module
+        pricing, _ = get_pricing("anthropic", model_name)
 
         # Calculate cost (pricing is per 1M tokens)
         input_cost = (tokens_in / 1_000_000) * pricing["input"]
@@ -151,27 +104,6 @@ class AnthropicCostAdapter(BaseCostAdapter):
 
         return round(input_cost + output_cost, 6)
 
-    def _normalize_model_name(self, model_name: str) -> str:
-        """Normalize model name to match pricing table."""
-        model_lower = model_name.lower()
-
-        # Direct matches
-        if model_lower in self.PRICING:
-            return model_lower
-
-        # Fuzzy matches
-        if "claude-3.5-sonnet" in model_lower or "claude-3-5-sonnet" in model_lower:
-            return "claude-3.5-sonnet"
-        elif "claude-3-opus" in model_lower:
-            return "claude-3-opus"
-        elif "claude-3-sonnet" in model_lower:
-            return "claude-3-sonnet"
-        elif "claude-3-haiku" in model_lower:
-            return "claude-3-haiku"
-
-        # Default to opus for unknown models
-        return "claude-3-opus"
-
 
 class CostAdapterFactory:
     """Factory to get appropriate cost adapter for a vendor."""

kalibr/instrumentation/anthropic_instr.py

@@ -3,8 +3,11 @@ Anthropic SDK Instrumentation
 
 Monkey-patches the Anthropic SDK to automatically emit OpenTelemetry spans
 for all message API calls.
+
+Thread-safe singleton pattern using double-checked locking.
 """
 
+import threading
 import time
 from functools import wraps
 from typing import Any, Dict, Optional
@@ -15,50 +18,34 @@ from .base import BaseCostAdapter, BaseInstrumentation
 
 
 class AnthropicCostAdapter(BaseCostAdapter):
-    """Cost calculation adapter for Anthropic models"""
-
-    # Pricing per 1K tokens (USD) - Updated November 2025
-    PRICING = {
-        # Claude 4 models
-        "claude-4-opus": {"input": 0.015, "output": 0.075},
-        "claude-4-sonnet": {"input": 0.003, "output": 0.015},
-        # Claude 3 models (Sonnet 4 is actually Claude 3.7)
-        "claude-sonnet-4": {"input": 0.003, "output": 0.015},
-        "claude-3-7-sonnet": {"input": 0.003, "output": 0.015},
-        "claude-3-5-sonnet": {"input": 0.003, "output": 0.015},
-        "claude-3-opus": {"input": 0.015, "output": 0.075},
-        "claude-3-sonnet": {"input": 0.003, "output": 0.015},
-        "claude-3-haiku": {"input": 0.00025, "output": 0.00125},
-        # Claude 2 models
-        "claude-2.1": {"input": 0.008, "output": 0.024},
-        "claude-2.0": {"input": 0.008, "output": 0.024},
-        "claude-instant-1.2": {"input": 0.0008, "output": 0.0024},
-    }
-
-    def calculate_cost(self, model: str, usage: Dict[str, int]) -> float:
-        """Calculate cost in USD for an Anthropic API call"""
-        # Normalize model name
-        base_model = model.lower()
+    """Cost calculation adapter for Anthropic models.
+    
+    Uses centralized pricing from kalibr.pricing module.
+    """
 
-        # Try exact match first
-        pricing = self.get_pricing(base_model)
+    def get_vendor_name(self) -> str:
+        """Return vendor name for Anthropic."""
+        return "anthropic"
 
-        # Try fuzzy matching for versioned models
-        if not pricing:
-            for known_model in self.PRICING.keys():
-                if known_model in base_model or base_model in known_model:
-                    pricing = self.PRICING[known_model]
-                    break
-
-        if not pricing:
-            # Default to Claude 3 Sonnet pricing if unknown
-            pricing = {"input": 0.003, "output": 0.015}
+    def calculate_cost(self, model: str, usage: Dict[str, int]) -> float:
+        """Calculate cost in USD for an Anthropic API call.
+        
+        Args:
+            model: Model identifier (e.g., "claude-3-opus", "claude-3-5-sonnet-20240620")
+            usage: Token usage dict with input_tokens and output_tokens
+            
+        Returns:
+            Cost in USD (rounded to 6 decimal places)
+        """
+        # Get pricing from centralized module (handles normalization)
+        pricing = self.get_pricing_for_model(model)
 
         input_tokens = usage.get("input_tokens", 0)
         output_tokens = usage.get("output_tokens", 0)
 
-        input_cost = (input_tokens / 1000) * pricing["input"]
-        output_cost = (output_tokens / 1000) * pricing["output"]
+        # Calculate cost (pricing is per 1M tokens)
+        input_cost = (input_tokens / 1_000_000) * pricing["input"]
+        output_cost = (output_tokens / 1_000_000) * pricing["output"]
 
         return round(input_cost + output_cost, 6)
 
@@ -262,13 +249,20 @@ class AnthropicInstrumentation(BaseInstrumentation):
 
 # Singleton instance
 _anthropic_instrumentation = None
+_anthropic_lock = threading.Lock()
 
 
 def get_instrumentation() -> AnthropicInstrumentation:
-    """Get or create the Anthropic instrumentation singleton"""
+    """Get or create the Anthropic instrumentation singleton.
+    
+    Thread-safe singleton pattern using double-checked locking.
+    """
     global _anthropic_instrumentation
     if _anthropic_instrumentation is None:
-        _anthropic_instrumentation = AnthropicInstrumentation()
+        with _anthropic_lock:
+            # Double-check inside lock to prevent race condition
+            if _anthropic_instrumentation is None:
+                _anthropic_instrumentation = AnthropicInstrumentation()
     return _anthropic_instrumentation
 
 

kalibr/instrumentation/base.py

@@ -3,6 +3,8 @@ Base instrumentation class for LLM SDKs
 
 Provides common functionality for monkey-patching LLM SDKs and
 emitting OpenTelemetry-compatible spans.
+
+Note: Cost adapters now use centralized pricing from kalibr.pricing module.
 """
 
 import time
@@ -13,6 +15,8 @@ from typing import Any, Dict, Optional
 from opentelemetry import trace
 from opentelemetry.trace import SpanKind, Status, StatusCode
 
+from kalibr.pricing import get_pricing
+
 
 class BaseInstrumentation(ABC):
     """Base class for LLM SDK instrumentation"""
@@ -76,9 +80,11 @@ class BaseInstrumentation(ABC):
 
 
 class BaseCostAdapter(ABC):
-    """Base class for cost calculation adapters"""
-
-    PRICING: Dict[str, Dict[str, float]] = {}
+    """Base class for cost calculation adapters.
+    
+    Uses centralized pricing from kalibr.pricing module.
+    All subclasses must implement get_vendor_name() to specify their vendor.
+    """
 
     @abstractmethod
     def calculate_cost(self, model: str, usage: Dict[str, int]) -> float:
@@ -87,22 +93,34 @@ class BaseCostAdapter(ABC):
 
         Args:
             model: Model identifier (e.g., "gpt-4")
-            usage: Token usage dictionary with prompt_tokens, completion_tokens
+            usage: Token usage dictionary with prompt_tokens, completion_tokens,
+                   input_tokens, or output_tokens
 
         Returns:
             Cost in USD (rounded to 6 decimal places)
         """
         pass
 
-    def get_pricing(self, model: str) -> Optional[Dict[str, float]]:
+    @abstractmethod
+    def get_vendor_name(self) -> str:
+        """
+        Get the vendor name for this adapter.
+        
+        Returns:
+            Vendor name (e.g., "openai", "anthropic", "google")
+        """
+        pass
+
+    def get_pricing_for_model(self, model: str) -> Dict[str, float]:
         """
-        Get pricing for a specific model
+        Get pricing for a specific model using centralized pricing.
 
         Args:
             model: Model identifier
 
         Returns:
-            Dictionary with "input" and "output" prices per 1K tokens,
-            or None if model not found
+            Dictionary with "input" and "output" prices per 1M tokens
         """
-        return self.PRICING.get(model)
+        vendor = self.get_vendor_name()
+        pricing, _ = get_pricing(vendor, model)
+        return pricing

kalibr/instrumentation/google_instr.py

@@ -3,8 +3,11 @@ Google Generative AI SDK Instrumentation
 
 Monkey-patches the Google Generative AI SDK to automatically emit OpenTelemetry spans
 for all content generation API calls.
+
+Thread-safe singleton pattern using double-checked locking.
 """
 
+import threading
 import time
 from functools import wraps
 from typing import Any, Dict, Optional
@@ -15,49 +18,34 @@ from .base import BaseCostAdapter, BaseInstrumentation
 
 
 class GoogleCostAdapter(BaseCostAdapter):
-    """Cost calculation adapter for Google Generative AI models"""
-
-    # Pricing per 1K tokens (USD) - Updated November 2025
-    PRICING = {
-        # Gemini 2.5 models
-        "gemini-2.5-pro": {"input": 0.00125, "output": 0.005},
-        "gemini-2.5-flash": {"input": 0.000075, "output": 0.0003},
-        # Gemini 2.0 models
-        "gemini-2.0-flash": {"input": 0.000075, "output": 0.0003},
-        "gemini-2.0-flash-thinking": {"input": 0.000075, "output": 0.0003},
-        # Gemini 1.5 models
-        "gemini-1.5-pro": {"input": 0.00125, "output": 0.005},
-        "gemini-1.5-flash": {"input": 0.000075, "output": 0.0003},
-        "gemini-1.5-flash-8b": {"input": 0.0000375, "output": 0.00015},
-        # Gemini 1.0 models
-        "gemini-1.0-pro": {"input": 0.0005, "output": 0.0015},
-        "gemini-pro": {"input": 0.0005, "output": 0.0015},  # Alias
-    }
-
-    def calculate_cost(self, model: str, usage: Dict[str, int]) -> float:
-        """Calculate cost in USD for a Google Generative AI API call"""
-        # Normalize model name
-        base_model = model.lower()
+    """Cost calculation adapter for Google Generative AI models.
+    
+    Uses centralized pricing from kalibr.pricing module.
+    """
 
-        # Try exact match first
-        pricing = self.get_pricing(base_model)
+    def get_vendor_name(self) -> str:
+        """Return vendor name for Google."""
+        return "google"
 
-        # Try fuzzy matching for versioned models
-        if not pricing:
-            for known_model in self.PRICING.keys():
-                if known_model in base_model or base_model in known_model:
-                    pricing = self.PRICING[known_model]
-                    break
-
-        if not pricing:
-            # Default to Gemini 1.5 Pro pricing if unknown
-            pricing = {"input": 0.00125, "output": 0.005}
+    def calculate_cost(self, model: str, usage: Dict[str, int]) -> float:
+        """Calculate cost in USD for a Google Generative AI API call.
+        
+        Args:
+            model: Model identifier (e.g., "gemini-1.5-pro", "gemini-2.0-flash")
+            usage: Token usage dict with prompt_tokens and completion_tokens
+            
+        Returns:
+            Cost in USD (rounded to 6 decimal places)
+        """
+        # Get pricing from centralized module (handles normalization)
+        pricing = self.get_pricing_for_model(model)
 
         prompt_tokens = usage.get("prompt_tokens", 0)
         completion_tokens = usage.get("completion_tokens", 0)
 
-        input_cost = (prompt_tokens / 1000) * pricing["input"]
-        output_cost = (completion_tokens / 1000) * pricing["output"]
+        # Calculate cost (pricing is per 1M tokens)
+        input_cost = (prompt_tokens / 1_000_000) * pricing["input"]
+        output_cost = (completion_tokens / 1_000_000) * pricing["output"]
 
         return round(input_cost + output_cost, 6)
 
@@ -261,13 +249,20 @@ class GoogleInstrumentation(BaseInstrumentation):
 
 # Singleton instance
 _google_instrumentation = None
+_google_lock = threading.Lock()
 
 
 def get_instrumentation() -> GoogleInstrumentation:
-    """Get or create the Google instrumentation singleton"""
+    """Get or create the Google instrumentation singleton.
+    
+    Thread-safe singleton pattern using double-checked locking.
+    """
     global _google_instrumentation
     if _google_instrumentation is None:
-        _google_instrumentation = GoogleInstrumentation()
+        with _google_lock:
+            # Double-check inside lock to prevent race condition
+            if _google_instrumentation is None:
+                _google_instrumentation = GoogleInstrumentation()
     return _google_instrumentation
 
 

kalibr/instrumentation/openai_instr.py

@@ -3,8 +3,11 @@ OpenAI SDK Instrumentation
 
 Monkey-patches the OpenAI SDK to automatically emit OpenTelemetry spans
 for all chat completion API calls.
+
+Thread-safe singleton pattern using double-checked locking.
 """
 
+import threading
 import time
 from functools import wraps
 from typing import Any, Dict, Optional
@@ -15,38 +18,34 @@ from .base import BaseCostAdapter, BaseInstrumentation
 
 
 class OpenAICostAdapter(BaseCostAdapter):
-    """Cost calculation adapter for OpenAI models"""
-
-    # Pricing per 1K tokens (USD) - Updated November 2025
-    PRICING = {
-        # GPT-5 models
-        "gpt-5": {"input": 0.005, "output": 0.015},
-        "gpt-5-turbo": {"input": 0.0025, "output": 0.0075},
-        # GPT-4 models
-        "gpt-4": {"input": 0.03, "output": 0.06},
-        "gpt-4-turbo": {"input": 0.01, "output": 0.03},
-        "gpt-4o": {"input": 0.0025, "output": 0.01},
-        "gpt-4o-mini": {"input": 0.00015, "output": 0.0006},
-        # GPT-3.5 models
-        "gpt-3.5-turbo": {"input": 0.0005, "output": 0.0015},
-        "gpt-3.5-turbo-16k": {"input": 0.001, "output": 0.002},
-    }
+    """Cost calculation adapter for OpenAI models.
+    
+    Uses centralized pricing from kalibr.pricing module.
+    """
 
-    def calculate_cost(self, model: str, usage: Dict[str, int]) -> float:
-        """Calculate cost in USD for an OpenAI API call"""
-        # Normalize model name (remove version suffixes)
-        base_model = model.split("-2")[0]  # Remove date suffixes like -20240101
+    def get_vendor_name(self) -> str:
+        """Return vendor name for OpenAI."""
+        return "openai"
 
-        pricing = self.get_pricing(base_model)
-        if not pricing:
-            # Default to GPT-4 pricing if unknown
-            pricing = {"input": 0.03, "output": 0.06}
+    def calculate_cost(self, model: str, usage: Dict[str, int]) -> float:
+        """Calculate cost in USD for an OpenAI API call.
+        
+        Args:
+            model: Model identifier (e.g., "gpt-4o", "gpt-4o-2024-05-13")
+            usage: Token usage dict with prompt_tokens and completion_tokens
+            
+        Returns:
+            Cost in USD (rounded to 6 decimal places)
+        """
+        # Get pricing from centralized module (handles normalization)
+        pricing = self.get_pricing_for_model(model)
 
         prompt_tokens = usage.get("prompt_tokens", 0)
         completion_tokens = usage.get("completion_tokens", 0)
 
-        input_cost = (prompt_tokens / 1000) * pricing["input"]
-        output_cost = (completion_tokens / 1000) * pricing["output"]
+        # Calculate cost (pricing is per 1M tokens)
+        input_cost = (prompt_tokens / 1_000_000) * pricing["input"]
+        output_cost = (completion_tokens / 1_000_000) * pricing["output"]
 
         return round(input_cost + output_cost, 6)
 
@@ -245,13 +244,20 @@ class OpenAIInstrumentation(BaseInstrumentation):
 
 # Singleton instance
 _openai_instrumentation = None
+_openai_lock = threading.Lock()
 
 
 def get_instrumentation() -> OpenAIInstrumentation:
-    """Get or create the OpenAI instrumentation singleton"""
+    """Get or create the OpenAI instrumentation singleton.
+    
+    Thread-safe singleton pattern using double-checked locking.
+    """
     global _openai_instrumentation
     if _openai_instrumentation is None:
-        _openai_instrumentation = OpenAIInstrumentation()
+        with _openai_lock:
+            # Double-check inside lock to prevent race condition
+            if _openai_instrumentation is None:
+                _openai_instrumentation = OpenAIInstrumentation()
     return _openai_instrumentation