basic functionality

Author: Daniel OBrien

ldotel/__init__.py renamed to ldai/__init__.py

@@ -0,0 +1,60 @@
+import json
+from typing import Any, Dict, Optional
+from ldclient import Context
+#from config import LDAIConfig, LDAIConfigTracker
+from ldclient.client import LDClient
+import chevron
+
+from ldai.tracker import LDAIConfigTracker
+
+class LDAIClient:
+    """The LaunchDarkly AI SDK client object."""
+
+    def __init__(self, client: LDClient):
+        self.client = client
+
+    def model_config(self, key: str, context: Context, default_value: str, variables: Optional[Dict[str, Any]] = None) -> Any:
+        """Get the value of a model configuration asynchronously.
+
+        Args:
+            key: The key of the model configuration.
+            context: The context to evaluate the model configuration in.
+            default_value: The default value of the model configuration.
+            variables: Additional variables for the model configuration.
+
+        Returns:
+            The value of the model configuration.
+        """
+        variation = self.client.variation(key, context, default_value)
+
+        all_variables = {'ldctx': context}
+        if variables:
+            all_variables.update(variables)
+
+        print(variation)
+        variation['prompt'] = [
+            {
+                **entry,
+                'content': self.interpolate_template(entry['content'], all_variables)
+            }
+            for entry in variation['prompt']
+        ]
+
+        #return detail.value,
+
+        return {
+            'config': variation,
+            'tracker': LDAIConfigTracker(self.client, variation['_ldMeta']['variationId'], key, context)
+        }
+
+    def interpolate_template(self, template: str, variables: Dict[str, Any]) -> str:
+        """Interpolate the template with the given variables.
+
+        Args:
+            template: The template string.
+            variables: The variables to interpolate into the template.
+
+        Returns:
+            The interpolated string.
+        """
+        return chevron.render(template, variables)

ldai/client.py

@@ -0,0 +1,41 @@
+from typing import Dict, Union
+from ldclient import Context, LDClient
+from ldai.tracking_utils import usage_to_token_metrics
+from ldai.types import BedrockTokenUsage, FeedbackKind, TokenUsage, UnderscoreTokenUsage
+
+class LDAIConfigTracker:
+    def __init__(self, ld_client: LDClient, variation_id: str, config_key: str, context: Context):
+        self.ld_client = ld_client
+        self.variation_id = variation_id
+        self.config_key = config_key
+        self.context = context
+
+    def get_track_data(self):
+        return {
+            'variationId': self.variation_id,
+            'configKey': self.config_key,
+        }
+    
+    def track_duration(self, duration: int) -> None:
+        self.ld_client.track('$ld:ai:duration:total', self.context, self.get_track_data(), duration)
+
+    def track_tokens(self, tokens: Union[TokenUsage, UnderscoreTokenUsage, BedrockTokenUsage]) -> None:
+        token_metrics = usage_to_token_metrics(tokens)
+        if token_metrics['total'] > 0:
+            self.ld_client.track('$ld:ai:tokens:total', self.context, self.get_track_data(), token_metrics['total'])
+        if token_metrics['input'] > 0:
+            self.ld_client.track('$ld:ai:tokens:input', self.context, self.get_track_data(), token_metrics['input'])
+        if token_metrics['output'] > 0:
+            self.ld_client.track('$ld:ai:tokens:output', self.context, self.get_track_data(), token_metrics['output'])
+
+    def track_error(self, error: int) -> None:
+        self.ld_client.track('$ld:ai:error', self.context, self.get_track_data(), error)
+
+    def track_generation(self, generation: int) -> None:
+        self.ld_client.track('$ld:ai:generation', self.context, self.get_track_data(), generation)
+
+    def track_feedback(self, feedback: Dict[str, FeedbackKind]) -> None:
+        if feedback['kind'] == FeedbackKind.Positive:
+            self.ld_client.track('$ld:ai:feedback:user:positive', self.context, self.get_track_data(), 1)
+        elif feedback['kind'] == FeedbackKind.Negative:
+            self.ld_client.track('$ld:ai:feedback:user:negative', self.context, self.get_track_data(), 1)

ldotel/testing/__init__.py renamed to ldai/testing/__init__.py

@@ -0,0 +1,23 @@
+from typing import Union
+from ldai.types import BedrockTokenUsage, TokenMetrics, TokenUsage, UnderscoreTokenUsage
+
+def usage_to_token_metrics(usage: Union[TokenUsage, UnderscoreTokenUsage, BedrockTokenUsage]) -> TokenMetrics:
+    def get_attr(obj, attr, default=0):
+        if isinstance(obj, dict):
+            return obj.get(attr, default)
+        return getattr(obj, attr, default)
+
+    if 'inputTokens' in usage and 'outputTokens' in usage:
+        # Bedrock usage
+        return {
+            'total': get_attr(usage, 'totalTokens'),
+            'input': get_attr(usage, 'inputTokens'),
+            'output': get_attr(usage, 'outputTokens'),
+        }
+
+    # OpenAI usage (both camelCase and snake_case)
+    return {
+        'total': get_attr(usage, 'total_tokens', get_attr(usage, 'totalTokens', 0)),
+        'input': get_attr(usage, 'prompt_tokens', get_attr(usage, 'promptTokens', 0)),
+        'output': get_attr(usage, 'completion_tokens', get_attr(usage, 'completionTokens', 0)),
+    }

ldai/tracker.py

@@ -0,0 +1,26 @@
+from enum import Enum
+from typing import TypedDict
+
+class FeedbackKind(Enum):
+    Positive = "positive"
+    Negative = "negative"
+
+class TokenUsage(TypedDict):
+    total_tokens: int
+    prompt_tokens: int
+    completion_tokens: int
+
+class UnderscoreTokenUsage(TypedDict):
+    total_tokens: int
+    prompt_tokens: int
+    completion_tokens: int
+
+class BedrockTokenUsage(TypedDict):
+    totalTokens: int
+    inputTokens: int
+    outputTokens: int
+
+class TokenMetrics(TypedDict):
+    total: int
+    input: int
+    output: int # type: ignore

ldai/tracking_utils.py

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "launchdarkly-server-sdk-ai"
-version = "0.0.1"
+version = "0.0.14"
 description = "LaunchDarkly SDK for AI"
 authors = ["LaunchDarkly <[email protected]>"]
 license = "Apache-2.0"
@@ -29,6 +29,7 @@ exclude = [
 [tool.poetry.dependencies]
 python = ">=3.8"
 launchdarkly-server-sdk = ">=9.4.0"
+chevron = "=0.14.0"
 
 
 [tool.poetry.group.dev.dependencies]