freeplay 0.2.25__tar.gz → 0.2.30__tar.gz

freeplay-0.2.30/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 228Labs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

{freeplay-0.2.25 → freeplay-0.2.30}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: freeplay
-Version: 0.2.25
+Version: 0.2.30
 Summary: 
 License: MIT
 Author: FreePlay Engineering
@@ -12,10 +12,11 @@ Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
 Requires-Dist: anthropic (>=0.7.7,<0.8.0)
+Requires-Dist: click (==8.1.7)
 Requires-Dist: dacite (>=1.8.0,<2.0.0)
-Requires-Dist: openai (>=0.27.8,<0.28.0)
+Requires-Dist: openai (>=1,<2)
+Requires-Dist: pystache (>=0.6.5,<0.7.0)
 Requires-Dist: requests (>=2.20.0,<3.0.0dev)
 Description-Content-Type: text/markdown
 

{freeplay-0.2.25 → freeplay-0.2.30}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "freeplay"
-version = "0.2.25"
+version = "0.2.30"
 description = ""
 authors = ["FreePlay Engineering <engineering@freeplay.ai>"]
 license = "MIT"
@@ -11,9 +11,21 @@ python = ">=3.8, <4"
 requests = ">=2.20.0,<3.0.0dev"
 dacite = "^1.8.0"
 anthropic = "^0.7.7"
-openai = "^0.27.8"
+openai = "^1"
+click = "8.1.7"
+pystache = "^0.6.5"
 
+[tool.poetry.group.dev.dependencies]
+mypy = "^1"
+types-requests = "^2.31"
+
+[tool.poetry.group.test.dependencies]
+responses = "^0.23.1"
+respx = "^0.20.2"
 
 [build-system]
 requires = ["poetry-core"]
 build-backend = "poetry.core.masonry.api"
+
+[tool.poetry.scripts]
+freeplay = "freeplay.freeplay_cli:cli"

{freeplay-0.2.25 → freeplay-0.2.30/src}/freeplay/api_support.py

@@ -1,6 +1,7 @@
 import json
 import logging
 import typing as t
+from typing import Dict
 
 import dacite
 import requests
@@ -24,7 +25,7 @@ def try_decode(target_type: t.Type[T], data: bytes) -> t.Optional[T]:
         return None
 
 
-def post(target_type: t.Type[T], api_key: str, url: str, payload: t.Optional[dict[str, str]] = None) -> T:
+def post(target_type: t.Type[T], api_key: str, url: str, payload: t.Optional[Dict[str, str]] = None) -> T:
     response = requests.post(
         url=url,
         headers={'Authorization': f'Bearer {api_key}'},
@@ -41,7 +42,7 @@ def post(target_type: t.Type[T], api_key: str, url: str, payload: t.Optional[dic
     return maybe_object
 
 
-def post_raw(api_key: str, url: str, payload: t.Optional[dict[str, t.Any]] = None) -> Response:
+def post_raw(api_key: str, url: str, payload: t.Optional[Dict[str, t.Any]] = None) -> Response:
     return requests.post(
         url=url,
         headers={'Authorization': f'Bearer {api_key}'},

{freeplay-0.2.25 → freeplay-0.2.30/src}/freeplay/completions.py

@@ -1,33 +1,40 @@
 from dataclasses import dataclass
-from typing import Optional, Any
+from typing import Any, Dict, List, Optional, TypedDict
+
+from openai.types.chat.chat_completion_chunk import ChoiceDeltaFunctionCall
+from openai.types.chat.chat_completion_message import FunctionCall
 
 from .llm_parameters import LLMParameters
 
-ChatMessage = dict[str, str]
-OpenAIFunctionCall = dict[str, str]
+
+class ChatMessage(TypedDict):
+    role: str
+    content: str
 
 
 @dataclass
 class CompletionResponse:
     content: str
     is_complete: bool
-    openai_function_call: Optional[OpenAIFunctionCall] = None
+    openai_function_call: Optional[FunctionCall] = None
+
 
 @dataclass
 class ChatCompletionResponse:
     content: str
     is_complete: bool
-    message_history: list[ChatMessage]
+    message_history: List[ChatMessage]
 
 
 @dataclass
 class PromptTemplateWithMetadata:
-    project_version_id: str
     prompt_template_id: str
+    prompt_template_version_id: str
+
     name: str
     content: str
     flavor_name: Optional[str]
-    params: Optional[dict[str, Any]]
+    params: Optional[Dict[str, Any]]
 
     def get_params(self) -> LLMParameters:
         return LLMParameters.empty() if self.params is None else LLMParameters(self.params)
@@ -35,11 +42,11 @@ class PromptTemplateWithMetadata:
 
 @dataclass
 class PromptTemplates:
-    templates: list[PromptTemplateWithMetadata]
+    templates: List[PromptTemplateWithMetadata]
 
 
 @dataclass
 class CompletionChunk:
     text: str
     is_complete: bool
-    openai_function_call: Optional[OpenAIFunctionCall] = None
+    openai_function_call: Optional[ChoiceDeltaFunctionCall] = None

{freeplay-0.2.25 → freeplay-0.2.30/src}/freeplay/flavors.py

@@ -1,34 +1,34 @@
 import json
 from abc import abstractmethod, ABC
 from copy import copy
-from typing import Optional, Generator, Any
+from typing import cast, Any, Dict, Generator, List, Optional, Union
 
-import anthropic  # type: ignore
+import anthropic
 import openai
-from openai.error import AuthenticationError, InvalidRequestError
+from openai import AuthenticationError, BadRequestError, Stream
+from openai.types.chat import ChatCompletion, ChatCompletionChunk, ChatCompletionMessageParam
 
 from .completions import CompletionChunk, PromptTemplateWithMetadata, CompletionResponse, ChatCompletionResponse, \
     ChatMessage
 from .errors import FreeplayConfigurationError, LLMClientError, LLMServerError, FreeplayError
 from .llm_parameters import LLMParameters
-from .provider_config import ProviderConfig, OpenAIConfig, AnthropicConfig
+from .provider_config import AnthropicConfig, AzureConfig, OpenAIConfig, ProviderConfig
 from .utils import format_template_variables
 
 
 class Flavor(ABC):
     @classmethod
     def get_by_name(cls, flavor_name: str) -> 'Flavor':
-        match flavor_name:
-            case OpenAIChat.record_format_type:
-                return OpenAIChat()
-            case AzureOpenAIChat.record_format_type:
-                return AzureOpenAIChat()
-            case AnthropicClaudeChat.record_format_type:
-                return AnthropicClaudeChat()
-            case _:
-                raise FreeplayConfigurationError(
-                    'Configured flavor not found in SDK. Please update your SDK version or configure '
-                    'a different model in the Freeplay UI.')
+        if flavor_name == OpenAIChat.record_format_type:
+            return OpenAIChat()
+        elif flavor_name == AzureOpenAIChat.record_format_type:
+            return AzureOpenAIChat()
+        elif flavor_name == AnthropicClaudeChat.record_format_type:
+            return AnthropicClaudeChat()
+        else:
+            raise FreeplayConfigurationError(
+                'Configured flavor not found in SDK. Please update your SDK version or configure '
+                'a different model in the Freeplay UI.')
 
     @property
     @abstractmethod
@@ -45,7 +45,7 @@ class Flavor(ABC):
         return LLMParameters.empty()
 
     @abstractmethod
-    def format(self, prompt_template: PromptTemplateWithMetadata, variables: dict[str, str]) -> str:
+    def format(self, prompt_template: PromptTemplateWithMetadata, variables: Dict[str, str]) -> str:
         pass
 
     @abstractmethod
@@ -74,7 +74,7 @@ class ChatFlavor(Flavor, ABC):
     @abstractmethod
     def continue_chat(
             self,
-            messages: list[ChatMessage],
+            messages: List[ChatMessage],
             provider_config: ProviderConfig,
             llm_parameters: LLMParameters
     ) -> ChatCompletionResponse:
@@ -83,57 +83,29 @@ class ChatFlavor(Flavor, ABC):
     @abstractmethod
     def continue_chat_stream(
             self,
-            messages: list[ChatMessage],
+            messages: List[ChatMessage],
             provider_config: ProviderConfig,
             llm_parameters: LLMParameters
     ) -> Generator[CompletionChunk, None, None]:
         pass
 
 
-class OpenAI(Flavor, ABC):
-    def configure_openai(
-            self,
-            openai_config: Optional[OpenAIConfig],
-            api_base: Optional[str] = None,
-            api_version: Optional[str] = None,
-            api_type: Optional[str] = None,
-    ) -> None:
-        super().__init__()
-        if not openai_config:
-            raise FreeplayConfigurationError(
-                "Missing OpenAI key. Use a ProviderConfig to specify keys prior to getting completion.")
-
-        if api_base:
-            openai.api_base = api_base
-        elif openai_config.api_base:
-            openai.api_base = openai_config.api_base
-
-        if api_type:
-            openai.api_type = api_type
-
-        if api_version:
-            openai.api_version = api_version
+class OpenAIChatFlavor(ChatFlavor, ABC):
 
-        if not openai_config.api_key or not openai_config.api_key.strip():
-            raise FreeplayConfigurationError("OpenAI API key is not set. It must be set to make calls to the service.")
-
-        openai.api_key = openai_config.api_key
-
-    @property
-    def provider(self) -> str:
-        return "openai"
-
-
-class OpenAIChat(OpenAI, ChatFlavor):
-    record_format_type = "openai_chat"
-    _model_params_with_defaults = LLMParameters({
-        "model": "gpt-3.5-turbo"
-    })
+    @abstractmethod
+    def _call_openai(
+            self,
+            messages: List[ChatMessage],
+            provider_config: ProviderConfig,
+            llm_parameters: LLMParameters,
+            stream: bool
+    ) -> Union[ChatCompletion, openai.Stream[ChatCompletionChunk]]:
+        pass
 
-    def format(self, prompt_template: PromptTemplateWithMetadata, variables: dict[str, str]) -> str:
+    def format(self, prompt_template: PromptTemplateWithMetadata, variables: Dict[str, str]) -> str:
         # Extract messages JSON to enable formatting of individual content fields of each message. If we do not
         # extract the JSON, current variable interpolation will fail on JSON curly braces.
-        messages_as_json: list[dict[str, str]] = json.loads(prompt_template.content)
+        messages_as_json: List[Dict[str, str]] = json.loads(prompt_template.content)
         formatted_messages = [
             {
                 "content": format_template_variables(message['content'], variables), "role": message['role']
@@ -147,11 +119,12 @@ class OpenAIChat(OpenAI, ChatFlavor):
             llm_parameters: LLMParameters
     ) -> CompletionResponse:
         messages = json.loads(formatted_prompt)
-        completion = self._call_openai(messages, provider_config, llm_parameters, stream=False)
+        completion = cast(ChatCompletion, self._call_openai(messages, provider_config, llm_parameters, stream=False))
+
         return CompletionResponse(
             content=completion.choices[0].message.content or '',
             is_complete=completion.choices[0].finish_reason == 'stop',
-            openai_function_call=completion.choices[0].message.get('function_call')
+            openai_function_call=completion.choices[0].message.function_call,
         )
 
     def call_service_stream(
@@ -161,70 +134,129 @@ class OpenAIChat(OpenAI, ChatFlavor):
             llm_parameters: LLMParameters
     ) -> Generator[CompletionChunk, None, None]:
         messages = json.loads(formatted_prompt)
-        completion_stream = self._call_openai(messages, provider_config, llm_parameters, stream=True)
+        completion_stream = cast(Stream[ChatCompletionChunk],
+                                 self._call_openai(messages, provider_config, llm_parameters, stream=True))
         for chunk in completion_stream:
             yield CompletionChunk(
-                text=chunk.choices[0].delta.get('content') or '',
+                text=chunk.choices[0].delta.content or '',
                 is_complete=chunk.choices[0].finish_reason == 'stop',
-                openai_function_call=chunk.choices[0].delta.get('function_call')
+                openai_function_call=chunk.choices[0].delta.function_call
             )
 
     def continue_chat(
             self,
-            messages: list[ChatMessage],
+            messages: List[ChatMessage],
             provider_config: ProviderConfig,
             llm_parameters: LLMParameters
     ) -> ChatCompletionResponse:
-        completion = self._call_openai(messages, provider_config, llm_parameters, stream=False)
+        completion = cast(ChatCompletion, self._call_openai(messages, provider_config, llm_parameters, stream=False))
 
         message_history = copy(messages)
-        message_history.append(completion.choices[0].message.to_dict())
+        message = completion.choices[0].message
+        message_history.append({
+            "role": message.role or '',
+            "content": message.content or ''
+        })
         return ChatCompletionResponse(
-            content=completion.choices[0].message.content,
+            content=message.content or '',
             message_history=message_history,
             is_complete=completion.choices[0].finish_reason == "stop"
         )
 
     def continue_chat_stream(
             self,
-            messages: list[ChatMessage],
+            messages: List[ChatMessage],
             provider_config: ProviderConfig,
             llm_parameters: LLMParameters
     ) -> Generator[CompletionChunk, None, None]:
-        completion_stream = self._call_openai(messages, provider_config, llm_parameters, stream=True)
+        completion_stream = cast(Stream[ChatCompletionChunk],
+                                 self._call_openai(messages, provider_config, llm_parameters, stream=True))
         for chunk in completion_stream:
             yield CompletionChunk(
-                text=chunk.choices[0].delta.get('content', ''),
+                text=chunk.choices[0].delta.content or '',
                 is_complete=chunk.choices[0].finish_reason == "stop"
             )
 
+
+class OpenAIChat(OpenAIChatFlavor):
+    record_format_type = "openai_chat"
+    _model_params_with_defaults = LLMParameters({
+        "model": "gpt-3.5-turbo"
+    })
+
+    def __init__(self) -> None:
+        self.client: Optional[openai.OpenAI] = None
+
+    @property
+    def provider(self) -> str:
+        return "openai"
+
+    def get_openai_client(self, openai_config: Optional[OpenAIConfig]) -> openai.OpenAI:
+        if self.client:
+            return self.client
+
+        if not openai_config:
+            raise FreeplayConfigurationError(
+                "Missing OpenAI key. Use a ProviderConfig to specify keys prior to getting completion.")
+
+        self.client = openai.OpenAI(api_key=openai_config.api_key, base_url=openai_config.base_url)
+        return self.client
+
     def _call_openai(
             self,
-            messages: list[ChatMessage],
+            messages: List[ChatMessage],
             provider_config: ProviderConfig,
             llm_parameters: LLMParameters,
             stream: bool
-    ) -> Any:
-        self.configure_openai(provider_config.openai)
-        llm_parameters.pop('endpoint')
+    ) -> Union[ChatCompletion, openai.Stream[ChatCompletionChunk]]:
+        client = self.get_openai_client(provider_config.openai)
         try:
-            return openai.ChatCompletion.create(
-                messages=messages,
+            return client.chat.completions.create(
+                messages=cast(List[ChatCompletionMessageParam], messages),
                 **self.get_model_params(llm_parameters),
                 stream=stream,
-            )  # type: ignore
-        except (InvalidRequestError, AuthenticationError) as e:
+            )
+        except (BadRequestError, AuthenticationError) as e:
             raise LLMClientError("Unable to call OpenAI") from e
         except Exception as e:
             raise LLMServerError("Unable to call OpenAI") from e
 
 
-class AzureOpenAIChat(OpenAIChat):
+class AzureOpenAIChat(OpenAIChatFlavor):
     record_format_type = "azure_openai_chat"
 
+    def __init__(self) -> None:
+        self.client: Optional[openai.AzureOpenAI] = None
+
+    @property
+    def provider(self) -> str:
+        return "azure"
+
+    def get_azure_client(
+            self,
+            azure_config: Optional[AzureConfig],
+            api_version: Optional[str] = None,
+            endpoint: Optional[str] = None,
+            deployment: Optional[str] = None,
+    ) -> openai.AzureOpenAI:
+        if self.client:
+            return self.client
+
+        if not azure_config:
+            raise FreeplayConfigurationError(
+                "Missing Azure key. Use a ProviderConfig to specify keys prior to getting completion.")
+
+        self.client = openai.AzureOpenAI(
+            api_key=azure_config.api_key,
+            api_version=api_version,
+            azure_endpoint=endpoint or '',
+            azure_deployment=deployment,
+        )
+        return self.client
+
     def _call_openai(
             self,
-            messages: list[ChatMessage],
+            messages: List[ChatMessage],
             provider_config: ProviderConfig,
             llm_parameters: LLMParameters,
             stream: bool
@@ -233,28 +265,25 @@ class AzureOpenAIChat(OpenAIChat):
         deployment_id = llm_parameters.get('deployment_id')
         resource_name = llm_parameters.get('resource_name')
         endpoint = f'https://{resource_name}.openai.azure.com'
-        self.configure_openai(
-            provider_config.azure,
-            api_base=endpoint,
-            api_type='azure',
-            api_version=api_version
-        )
         llm_parameters.pop('resource_name')
+
+        client = self.get_azure_client(
+            azure_config=provider_config.azure,
+            api_version=api_version,
+            endpoint=endpoint,
+            deployment=deployment_id,
+        )
+
         try:
-            return openai.ChatCompletion.create(
-                messages=messages,
+            return client.chat.completions.create(
+                messages=cast(List[ChatCompletionMessageParam], messages),
                 **self.get_model_params(llm_parameters),
-                engine=deployment_id,
                 stream=stream,
-            )  # type: ignore
-        except (InvalidRequestError, AuthenticationError) as e:
-            raise LLMClientError("Unable to call OpenAI") from e
+            )
+        except (BadRequestError, AuthenticationError) as e:
+            raise LLMClientError("Unable to call Azure") from e
         except Exception as e:
-            raise LLMServerError("Unable to call OpenAI") from e
-
-    @property
-    def provider(self) -> str:
-        return "azure"
+            raise LLMServerError("Unable to call Azure") from e
 
 
 class AnthropicClaudeText(Flavor):
@@ -282,7 +311,7 @@ class AnthropicClaudeText(Flavor):
         self.client = anthropic.Client(api_key=anthropic_config.api_key)
         return self.client
 
-    def format(self, prompt_template: PromptTemplateWithMetadata, variables: dict[str, str]) -> str:
+    def format(self, prompt_template: PromptTemplateWithMetadata, variables: Dict[str, str]) -> str:
         interpolated_prompt = format_template_variables(prompt_template.content, variables)
         # Anthropic expects a specific Chat format "Human: $PROMPT_TEXT\n\nAssistant:". We add the wrapping for Text.
         chat_formatted_prompt = f"{anthropic.HUMAN_PROMPT} {interpolated_prompt} {anthropic.AI_PROMPT}"
@@ -361,10 +390,10 @@ class AnthropicClaudeChat(ChatFlavor):
 
     # This just formats the prompt for uploading to the record endpoint.
     # TODO: Move this to a base class.
-    def format(self, prompt_template: PromptTemplateWithMetadata, variables: dict[str, str]) -> str:
+    def format(self, prompt_template: PromptTemplateWithMetadata, variables: Dict[str, str]) -> str:
         # Extract messages JSON to enable formatting of individual content fields of each message. If we do not
         # extract the JSON, current variable interpolation will fail on JSON curly braces.
-        messages_as_json: list[dict[str, str]] = json.loads(prompt_template.content)
+        messages_as_json: List[Dict[str, str]] = json.loads(prompt_template.content)
         formatted_messages = [
             {
                 "content": format_template_variables(message['content'], variables),
@@ -383,7 +412,7 @@ class AnthropicClaudeChat(ChatFlavor):
             return 'Human'
 
     @staticmethod
-    def __to_anthropic_chat_format(messages: list[ChatMessage]) -> str:
+    def __to_anthropic_chat_format(messages: List[ChatMessage]) -> str:
         formatted_messages = []
         for message in messages:
             formatted_messages.append(f"{message['role']}: {message['content']}")
@@ -393,7 +422,7 @@ class AnthropicClaudeChat(ChatFlavor):
 
     def continue_chat(
             self,
-            messages: list[ChatMessage],
+            messages: List[ChatMessage],
             provider_config: ProviderConfig,
             llm_parameters: LLMParameters
     ) -> ChatCompletionResponse:
@@ -416,7 +445,7 @@ class AnthropicClaudeChat(ChatFlavor):
 
     def continue_chat_stream(
             self,
-            messages: list[ChatMessage],
+            messages: List[ChatMessage],
             provider_config: ProviderConfig,
             llm_parameters: LLMParameters
     ) -> Generator[CompletionChunk, None, None]:

{freeplay-0.2.25 → freeplay-0.2.30/src}/freeplay/freeplay.py

@@ -3,12 +3,18 @@ import logging
 import time
 from copy import copy
 from dataclasses import dataclass
-from typing import Optional, Generator, Any, cast, Tuple
+from typing import cast, Any, Dict, Generator, List, Optional, Tuple, Union
 
 from . import api_support
 from .api_support import try_decode
-from .completions import PromptTemplates, CompletionResponse, CompletionChunk, PromptTemplateWithMetadata, \
-    ChatCompletionResponse, ChatMessage
+from .completions import (
+    PromptTemplates,
+    CompletionResponse,
+    CompletionChunk,
+    PromptTemplateWithMetadata,
+    ChatCompletionResponse,
+    ChatMessage
+)
 from .errors import FreeplayConfigurationError, freeplay_response_error, FreeplayServerError
 from .flavors import Flavor, ChatFlavor
 from .llm_parameters import LLMParameters
@@ -19,8 +25,8 @@ from .record import (
     RecordCallFields
 )
 
-JsonDom = dict[str, Any]
-Variables = dict[str, str]
+JsonDom = Dict[str, Any]
+Variables = Dict[str, str]
 
 logger = logging.getLogger(__name__)
 default_tag = 'latest'
@@ -51,9 +57,9 @@ class CallSupport:
             project_id: str,
             tag: str,
             test_run_id: Optional[str] = None,
-            metadata: Optional[dict[str, str|int|float]] = None
+            metadata: Optional[Dict[str, Union[str,int,float]]] = None
         ) -> JsonDom:
-        request_body: dict[str, Any] = {}
+        request_body: Dict[str, Any] = {}
         if test_run_id is not None:
             request_body['test_run_id'] = test_run_id
         if metadata is not None:
@@ -65,7 +71,7 @@ class CallSupport:
                                         payload=request_body)
 
         if response.status_code == 201:
-            return cast(dict[str, Any], json.loads(response.content))
+            return cast(Dict[str, Any], json.loads(response.content))
         else:
             raise freeplay_response_error('Error while creating a session.', response)
 
@@ -93,8 +99,8 @@ class CallSupport:
             tag: str,
             target_template: PromptTemplateWithMetadata,
             variables: Variables,
-            message_history: list[ChatMessage],
-            new_messages: Optional[list[ChatMessage]],
+            message_history: List[ChatMessage],
+            new_messages: Optional[List[ChatMessage]],
             test_run_id: Optional[str] = None,
             completion_parameters: Optional[LLMParameters] = None) -> ChatCompletionResponse:
         # make call
@@ -142,7 +148,7 @@ class CallSupport:
             tag: str,
             target_template: PromptTemplateWithMetadata,
             variables: Variables,
-            message_history: list[ChatMessage],
+            message_history: List[ChatMessage],
             test_run_id: Optional[str] = None,
             completion_parameters: Optional[LLMParameters] = None
     ) -> Generator[CompletionChunk, None, None]:
@@ -189,7 +195,7 @@ class CallSupport:
             session_id: str,
             prompts: PromptTemplates,
             template_name: str,
-            variables: dict[str, str],
+            variables: Dict[str, str],
             flavor: Optional[Flavor],
             provider_config: ProviderConfig,
             tag: str,
@@ -239,7 +245,7 @@ class CallSupport:
             session_id: str,
             prompts: PromptTemplates,
             template_name: str,
-            variables: dict[str, str],
+            variables: Dict[str, str],
             flavor: Optional[Flavor],
             provider_config: ProviderConfig,
             tag: str,
@@ -310,7 +316,7 @@ class Session:
     def get_completion(
             self,
             template_name: str,
-            variables: dict[str, str],
+            variables: Dict[str, str],
             flavor: Optional[Flavor] = None,
             **kwargs: Any
     ) -> CompletionResponse:
@@ -328,7 +334,7 @@ class Session:
     def get_completion_stream(
             self,
             template_name: str,
-            variables: dict[str, str],
+            variables: Dict[str, str],
             flavor: Optional[Flavor] = None,
             **kwargs: Any
     ) -> Generator[CompletionChunk, None, None]:
@@ -356,7 +362,7 @@ class ChatSession(Session):
             variables: Variables,
             tag: str = default_tag,
             test_run_id: Optional[str] = None,
-            messages: Optional[list[ChatMessage]] = None
+            messages: Optional[List[ChatMessage]] = None
     ) -> None:
         super().__init__(call_support, session_id, prompts, flavor, provider_config, tag, test_run_id)
         # A Chat Session tracks the template_name and variables for a set of chat completions.
@@ -370,7 +376,7 @@ class ChatSession(Session):
     def last_message(self) -> Optional[ChatMessage]:
         return self.message_history[len(self.message_history) - 1]
 
-    def store_new_messages(self, new_messages: list[ChatMessage]) -> None:
+    def store_new_messages(self, new_messages: List[ChatMessage]) -> None:
         for message in new_messages:
             self.message_history.append({
                 "role": message["role"],
@@ -412,7 +418,7 @@ class ChatSession(Session):
 
     def continue_chat(
             self,
-            new_messages: Optional[list[ChatMessage]] = None,
+            new_messages: Optional[List[ChatMessage]] = None,
             **kwargs: Any
     ) -> ChatCompletionResponse:
 
@@ -438,7 +444,7 @@ class ChatSession(Session):
 
     def continue_chat_stream(
             self,
-            new_messages: Optional[list[ChatMessage]] = None,
+            new_messages: Optional[List[ChatMessage]] = None,
             **kwargs: Any
     ) -> Generator[CompletionChunk, None, None]:
         new_messages = new_messages or []
@@ -468,7 +474,7 @@ class FreeplayTestRun:
             flavor: Optional[Flavor],
             provider_config: ProviderConfig,
             test_run_id: str,
-            inputs: list[dict[str, str]]
+            inputs: List[Dict[str, str]]
     ):
         self.call_support = call_support
         self.flavor = flavor
@@ -476,7 +482,7 @@ class FreeplayTestRun:
         self.test_run_id = test_run_id
         self.inputs = inputs
 
-    def get_inputs(self) -> list[dict[str, str]]:
+    def get_inputs(self) -> List[Dict[str, str]]:
         return self.inputs
 
     def create_session(self, project_id: str, tag: str = default_tag) -> Session:
@@ -501,7 +507,7 @@ class Freeplay:
             **kwargs: Any
     ) -> None:
         if not freeplay_api_key or not freeplay_api_key.strip():
-            raise FreeplayConfigurationError("Freeplay API key not set. It must be set to the Freeplay API.")
+            raise FreeplayConfigurationError("Freeplay API key not set. It must be set to use the Freeplay API.")
         provider_config.validate()
 
         self.__record_processor = record_processor or DefaultRecordProcessor(freeplay_api_key, api_base)
@@ -522,7 +528,7 @@ class Freeplay:
             project_id: str,
             session_id: str,
             template_name: str,
-            variables: dict[str, str],
+            variables: Dict[str, str],
             tag: str = default_tag,
             flavor: Optional[Flavor] = None,
             **kwargs: Any
@@ -544,10 +550,10 @@ class Freeplay:
             self,
             project_id: str,
             template_name: str,
-            variables: dict[str, str],
+            variables: Dict[str, str],
             tag: str = default_tag,
             flavor: Optional[Flavor] = None,
-            metadata: Optional[dict[str, str|int|float]] = None,
+            metadata: Optional[Dict[str, Union[str,int,float]]] = None,
             **kwargs: Any
     ) -> CompletionResponse:
         project_session = self.call_support.create_session(project_id, tag, None, metadata)
@@ -567,10 +573,10 @@ class Freeplay:
             self,
             project_id: str,
             template_name: str,
-            variables: dict[str, str],
+            variables: Dict[str, str],
             tag: str = default_tag,
             flavor: Optional[Flavor] = None,
-            metadata: Optional[dict[str, str|int|float]] = None,
+            metadata: Optional[Dict[str, Union[str,int,float]]] = None,
             **kwargs: Any
     ) -> Generator[CompletionChunk, None, None]:
         project_session = self.call_support.create_session(project_id, tag, None, metadata)
@@ -611,7 +617,7 @@ class Freeplay:
             template_name: str,
             variables: Variables,
             tag: str = default_tag,
-            metadata: Optional[dict[str, str|int|float]] = None,
+            metadata: Optional[Dict[str, Union[str,int,float]]] = None,
             **kwargs: Any
     ) -> Tuple[ChatSession, ChatCompletionResponse]:
         session = self.__create_chat_session(project_id, tag, template_name, variables, metadata)
@@ -625,7 +631,7 @@ class Freeplay:
             session_id: str,
             variables: Variables,
             tag: str = default_tag,
-            messages: Optional[list[ChatMessage]] = None,
+            messages: Optional[List[ChatMessage]] = None,
             flavor: Optional[ChatFlavor] = None) -> ChatSession:
         prompts = self.call_support.get_prompts(project_id, tag)
         chat_flavor = flavor or require_chat_flavor(self.client_flavor) if self.client_flavor else None
@@ -647,7 +653,7 @@ class Freeplay:
             template_name: str,
             variables: Variables,
             tag: str = default_tag,
-            metadata: Optional[dict[str, str|int|float]] = None,
+            metadata: Optional[Dict[str, Union[str,int,float]]] = None,
             **kwargs: Any
     ) -> Tuple[ChatSession, Generator[CompletionChunk, None, None]]:
         """Returns a chat session, the base prompt template messages, and a streamed response from the LLM."""
@@ -661,7 +667,7 @@ class Freeplay:
             tag: str,
             template_name: str,
             variables: Variables,
-            metadata: Optional[dict[str, str|int|float]] = None) -> ChatSession:
+            metadata: Optional[Dict[str, Union[str,int,float]]] = None) -> ChatSession:
         chat_flavor = require_chat_flavor(self.client_flavor) if self.client_flavor else None
 
         project_session = self.call_support.create_session(project_id, tag, None, metadata)
@@ -700,7 +706,8 @@ def require_chat_flavor(flavor: Flavor) -> ChatFlavor:
 
     return flavor
 
-def check_all_values_string_or_number(metadata: Optional[dict[str, str|int|float]]) -> None:
+
+def check_all_values_string_or_number(metadata: Optional[Dict[str, Union[str,int,float]]]) -> None:
     if metadata:
         for key, value in metadata.items():
             if not isinstance(value, (str, int, float)):

freeplay-0.2.30/src/freeplay/freeplay_cli.py

@@ -0,0 +1,106 @@
+import dataclasses
+import json
+import os
+import sys
+from pathlib import Path
+from stat import S_IREAD, S_IRGRP, S_IROTH, S_IWUSR
+
+import click
+
+from .completions import PromptTemplates, PromptTemplateWithMetadata
+from .errors import FreeplayClientError, FreeplayServerError
+from .freeplay_thin import FreeplayThin
+
+
+@click.group()
+def cli() -> None:
+    pass
+
+
+@cli.command()
+@click.option("--project-id", required=True, help="The Freeplay project ID.")
+@click.option("--environment", required=True, help="The environment from which the prompts will be pulled.")
+@click.option("--output-dir", required=True, help="The directory where the prompts will be saved.")
+def download(project_id: str, environment: str, output_dir: str) -> None:
+    if "FREEPLAY_API_KEY" not in os.environ:
+        print("FREEPLAY_API_KEY is not set. It is required to run the freeplay command.", file=sys.stderr)
+        exit(4)
+
+    if "FREEPLAY_SUBDOMAIN" not in os.environ:
+        print("FREEPLAY_SUBDOMAIN is not set. It is required to run the freeplay command.", file=sys.stderr)
+        exit(4)
+
+    FREEPLAY_API_KEY = os.environ["FREEPLAY_API_KEY"]
+    freeplay_api_url = f'https://{os.environ["FREEPLAY_SUBDOMAIN"]}.freeplay.ai/api'
+
+    if "FREEPLAY_API_URL" in os.environ:
+        freeplay_api_url = f'{os.environ["FREEPLAY_API_URL"]}/api'
+        click.echo("Using URL override for Freeplay specified in the FREEPLAY_API_URL environment variable")
+
+    click.echo("Downloading prompts for project %s, environment %s, to directory %s from %s" %
+               (project_id, environment, output_dir, freeplay_api_url))
+
+    fp_client = FreeplayThin(
+        freeplay_api_key=FREEPLAY_API_KEY,
+        api_base=freeplay_api_url
+    )
+
+    try:
+        prompts: PromptTemplates = fp_client.get_prompts(project_id, tag=environment)
+        click.echo("Found %s prompt templates" % len(prompts.templates))
+
+        for prompt in prompts.templates:
+            __write_single_file(environment, output_dir, project_id, prompt)
+    except FreeplayClientError as e:
+        print("Error downloading templates: %s.\nIs your project ID correct?" % e, file=sys.stderr)
+        exit(1)
+    except FreeplayServerError as e:
+        print("Error on Freeplay's servers downloading templates: %s.\nTry again after a short wait." % e,
+              file=sys.stderr)
+        exit(2)
+    except Exception as e:
+        print("Error downloading templates: %s" % e, file=sys.stderr)
+        exit(3)
+
+
+def __write_single_file(
+        environment: str,
+        output_dir: str,
+        project_id: str,
+        prompt: PromptTemplateWithMetadata
+) -> None:
+    directory = __root_dir(environment, output_dir, project_id)
+    basename = f'{prompt.name}'
+    prompt_path = directory / f'{basename}.json'
+    click.echo("Writing prompt file: %s" % prompt_path)
+
+    full_dict = dataclasses.asdict(prompt)
+    del full_dict['prompt_template_id']
+    del full_dict['prompt_template_version_id']
+    del full_dict['name']
+    del full_dict['content']
+
+    output_dict = {
+        'prompt_template_id': prompt.prompt_template_id,
+        'prompt_template_version_id': prompt.prompt_template_version_id,
+        'name': prompt.name,
+        'content': prompt.content,
+        'metadata': full_dict
+    }
+
+    # Make sure it's owner writable if it already exists
+    if prompt_path.is_file():
+        os.chmod(prompt_path, S_IWUSR | S_IREAD)
+
+    with prompt_path.open(mode='w') as f:
+        f.write(json.dumps(output_dict, sort_keys=True, indent=4))
+        f.write('\n')
+
+    # Make the file read-only to discourage local changes
+    os.chmod(prompt_path, S_IREAD | S_IRGRP | S_IROTH)
+
+
+def __root_dir(environment: str, output_dir: str, project_id: str) -> Path:
+    directory = Path(output_dir) / "freeplay" / "prompts" / project_id / environment
+    os.makedirs(directory, exist_ok=True)
+    return directory

freeplay-0.2.30/src/freeplay/freeplay_thin.py

@@ -0,0 +1,21 @@
+from .completions import PromptTemplates
+from .errors import FreeplayConfigurationError
+from .freeplay import CallSupport
+from .record import DefaultRecordProcessor
+
+
+class FreeplayThin:
+    def __init__(
+            self,
+            freeplay_api_key: str,
+            api_base: str
+    ) -> None:
+        if not freeplay_api_key or not freeplay_api_key.strip():
+            raise FreeplayConfigurationError("Freeplay API key not set. It must be set to the Freeplay API.")
+
+        self.call_support = CallSupport(freeplay_api_key, api_base, DefaultRecordProcessor(freeplay_api_key, api_base))
+        self.freeplay_api_key = freeplay_api_key
+        self.api_base = api_base
+
+    def get_prompts(self, project_id: str, tag: str) -> PromptTemplates:
+        return self.call_support.get_prompts(project_id=project_id, tag=tag)

{freeplay-0.2.25 → freeplay-0.2.30/src}/freeplay/llm_parameters.py

@@ -1,14 +1,12 @@
 import copy
 import logging
-from dataclasses import dataclass
-from typing import Any, Optional
+from typing import Any, Dict, Optional
 
 logger = logging.getLogger(__name__)
 
 
-@dataclass
-class LLMParameters(dict[str, Any]):
-    def __init__(self, members: dict[str, Any]) -> None:
+class LLMParameters(Dict[str, Any]):
+    def __init__(self, members: Dict[str, Any]) -> None:
         super().__init__(members)
 
     @classmethod

{freeplay-0.2.25 → freeplay-0.2.30/src}/freeplay/provider_config.py

@@ -7,15 +7,7 @@ from .errors import FreeplayConfigurationError
 @dataclass
 class OpenAIConfig:
     api_key: str
-    api_base: Optional[str]
-
-    def __init__(
-            self,
-            api_key: str,
-            api_base: Optional[str] = None,
-    ) -> None:
-        self.api_key = api_key
-        self.api_base = api_base
+    base_url: Optional[str] = None
 
     def validate(self) -> None:
         if not self.api_key or not self.api_key.strip():
@@ -24,19 +16,8 @@ class OpenAIConfig:
 
 @dataclass
 class AzureConfig(OpenAIConfig):
-    engine: Optional[str]
-    api_version: Optional[str]
-
-    def __init__(
-            self,
-            api_key: str,
-            api_base: Optional[str] = None,
-            engine: Optional[str] = None,
-            api_version: Optional[str] = None
-    ):
-        super().__init__(api_key, api_base)
-        self.api_version = api_version
-        self.engine = engine
+    engine: Optional[str] = None
+    api_version: Optional[str] = None
 
     def validate(self) -> None:
         super().validate()
@@ -61,7 +42,7 @@ class ProviderConfig:
     azure: Optional[AzureConfig] = None
 
     def validate(self) -> None:
-        if self.anthropic is None and self.openai is None:
+        if all(config is None for config in [self.anthropic, self.openai, self.azure]):
             FreeplayConfigurationError("At least one provider key must be set in ProviderConfig.")
 
         if self.openai is not None:

{freeplay-0.2.25 → freeplay-0.2.30/src}/freeplay/record.py

@@ -1,6 +1,6 @@
 import logging
 from dataclasses import dataclass
-from typing import Optional, Any
+from typing import Any, Dict, Optional
 from abc import abstractmethod, ABC
 
 from .llm_parameters import LLMParameters
@@ -18,7 +18,7 @@ class RecordCallFields:
     session_id: str
     start: float
     target_template: PromptTemplateWithMetadata
-    variables: dict[str, str]
+    variables: Dict[str, str]
     tag: str
     test_run_id: Optional[str]
     record_format_type: Optional[str]
@@ -60,7 +60,7 @@ class DefaultRecordProcessor(RecordProcessor):
     ) -> None:
         record_payload = {
             "session_id": record_call.session_id,
-            "project_version_id": record_call.target_template.project_version_id,
+            "project_version_id": record_call.target_template.prompt_template_version_id,
             "prompt_template_id": record_call.target_template.prompt_template_id,
             "start_time": record_call.start,
             "end_time": record_call.end,

freeplay-0.2.30/src/freeplay/utils.py

@@ -0,0 +1,21 @@
+import pystache  # type: ignore
+from pydantic import RootModel, ValidationError
+from typing import Any, Dict, List, Union
+
+from .errors import FreeplayError
+
+InputVariable = RootModel[Union[Dict[str, "InputVariable"], List["InputVariable"], str, int, bool, float]]
+InputVariable.model_rebuild()
+InputVariables = Dict[str, Union[str, int, bool, Dict[str, Any], List[Any]]]
+PydanticInputVariables = RootModel[Dict[str, InputVariable]]
+
+def format_template_variables(template: str, variables: Any) -> str:
+    # Validate that the variables are of the correct type, and do not include functions or None values.
+    try:
+        PydanticInputVariables.model_validate(variables)
+    except ValidationError as err:
+        raise FreeplayError('Variables must be a string, number, bool, or a possibly nested list or dict of strings, numbers and booleans.')
+
+    # When rendering mustache, do not escape HTML special characters.
+    rendered: str = pystache.Renderer(escape=lambda s: s).render(template, variables)
+    return rendered

freeplay-0.2.25/freeplay/utils.py

@@ -1,11 +0,0 @@
-import re
-
-from .errors import FreeplayError
-
-variable_regex = re.compile(r"{{(\w+)}}")
-
-def format_template_variables(template_content: str, variables: dict[str, str]) -> str:
-    try:
-        return variable_regex.sub(lambda match: variables[match.group(1)], template_content)
-    except KeyError as e:
-        raise FreeplayError(f"Missing variable with key: {e}.")