freeplay 0.2.23__tar.gz → 0.2.25__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: freeplay
-Version: 0.2.23
+Version: 0.2.25
 Summary: 
 License: MIT
 Author: FreePlay Engineering
@@ -12,7 +12,8 @@ Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
-Requires-Dist: anthropic (>=0.2.10,<0.3.0)
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: anthropic (>=0.7.7,<0.8.0)
 Requires-Dist: dacite (>=1.8.0,<2.0.0)
 Requires-Dist: openai (>=0.27.8,<0.28.0)
 Requires-Dist: requests (>=2.20.0,<3.0.0dev)

{freeplay-0.2.23 → freeplay-0.2.25}/freeplay/flavors.py

@@ -19,12 +19,8 @@ class Flavor(ABC):
     @classmethod
     def get_by_name(cls, flavor_name: str) -> 'Flavor':
         match flavor_name:
-            case OpenAIText.record_format_type:
-                return OpenAIText()
             case OpenAIChat.record_format_type:
                 return OpenAIChat()
-            case AnthropicClaudeText.record_format_type:
-                return AnthropicClaudeText()
             case AzureOpenAIChat.record_format_type:
                 return AzureOpenAIChat()
             case AnthropicClaudeChat.record_format_type:
@@ -128,61 +124,6 @@ class OpenAI(Flavor, ABC):
         return "openai"
 
 
-class OpenAIText(OpenAI):
-    record_format_type = "openai_text"
-    _model_params_with_defaults = LLMParameters({
-        "model": "text-davinci-003"
-    })
-
-    def format(self, prompt_template: PromptTemplateWithMetadata, variables: dict[str, str]) -> str:
-        return format_template_variables(prompt_template.content, variables)
-
-    def call_service(
-            self,
-            formatted_prompt: str,
-            provider_config: ProviderConfig,
-            llm_parameters: LLMParameters
-    ) -> CompletionResponse:
-        completion = self._call_openai(formatted_prompt, provider_config, llm_parameters, stream=False)
-        return CompletionResponse(
-            content=completion.choices[0].text,
-            is_complete=completion.choices[0].finish_reason == "stop"
-        )
-
-    def call_service_stream(
-            self,
-            formatted_prompt: str,
-            provider_config: ProviderConfig,
-            llm_parameters: LLMParameters
-    ) -> Generator[CompletionChunk, None, None]:
-        completion = self._call_openai(formatted_prompt, provider_config, llm_parameters, stream=True)
-
-        for chunk in completion:
-            yield CompletionChunk(
-                text=chunk.choices[0].text,
-                is_complete=chunk.choices[0].finish_reason == "stop"
-            )
-
-    def _call_openai(
-            self,
-            prompt: str,
-            provider_config: ProviderConfig,
-            llm_parameters: LLMParameters,
-            stream: bool
-    ) -> Any:
-        self.configure_openai(provider_config.openai)
-        try:
-            return openai.Completion.create(
-                prompt=prompt,
-                stream=stream,
-                **self.get_model_params(llm_parameters)
-            )  # type: ignore
-        except (InvalidRequestError, AuthenticationError) as e:
-            raise LLMClientError("Unable to call OpenAI") from e
-        except Exception as e:
-            raise LLMServerError("Unable to call OpenAI") from e
-
-
 class OpenAIChat(OpenAI, ChatFlavor):
     record_format_type = "openai_chat"
     _model_params_with_defaults = LLMParameters({
@@ -324,7 +265,7 @@ class AnthropicClaudeText(Flavor):
     })
 
     def __init__(self) -> None:
-        self.client = None
+        self.client: Optional[anthropic.Client] = None
 
     @property
     def provider(self) -> str:
@@ -338,7 +279,7 @@ class AnthropicClaudeText(Flavor):
             raise FreeplayConfigurationError(
                 "Missing Anthropic key. Use a ProviderConfig to specify keys prior to getting completion.")
 
-        self.client = anthropic.Client(anthropic_config.api_key)
+        self.client = anthropic.Client(api_key=anthropic_config.api_key)
         return self.client
 
     def format(self, prompt_template: PromptTemplateWithMetadata, variables: dict[str, str]) -> str:
@@ -359,7 +300,7 @@ class AnthropicClaudeText(Flavor):
                 content=anthropic_response['completion'],
                 is_complete=anthropic_response['stop_reason'] == 'stop_sequence'
             )
-        except anthropic.ApiException as e:
+        except anthropic.APIError as e:
             raise FreeplayError("Error calling Anthropic") from e
 
     def call_service_stream(
@@ -389,7 +330,7 @@ class AnthropicClaudeText(Flavor):
                     text=incremental_new_text,
                     is_complete=chunk['stop_reason'] == 'stop_sequence'
                 )
-        except anthropic.ApiException as e:
+        except anthropic.APIError as e:
             raise FreeplayError("Error calling Anthropic") from e
 
 
@@ -401,13 +342,13 @@ class AnthropicClaudeChat(ChatFlavor):
     })
 
     def __init__(self) -> None:
-        self.client = None
+        self.client: Optional[anthropic.Anthropic] = None
 
     @property
     def provider(self) -> str:
         return "anthropic"
 
-    def get_anthropic_client(self, anthropic_config: Optional[AnthropicConfig]) -> Any:
+    def get_anthropic_client(self, anthropic_config: Optional[AnthropicConfig]) -> anthropic.Client:
         if self.client:
             return self.client
 
@@ -415,7 +356,7 @@ class AnthropicClaudeChat(ChatFlavor):
             raise FreeplayConfigurationError(
                 "Missing Anthropic key. Use a ProviderConfig to specify keys prior to getting completion.")
 
-        self.client = anthropic.Client(anthropic_config.api_key)
+        self.client = anthropic.Client(api_key=anthropic_config.api_key)
         return self.client
 
     # This just formats the prompt for uploading to the record endpoint.
@@ -459,18 +400,18 @@ class AnthropicClaudeChat(ChatFlavor):
         formatted_prompt = self.__to_anthropic_chat_format(messages)
         try:
             client = self.get_anthropic_client(provider_config.anthropic)
-            response = client.completion(
+            completion = client.completions.create(
                 prompt=formatted_prompt,
                 **self.get_model_params(llm_parameters)
             )
-            content = response['completion']
+            content = completion.completion
             message_history = messages + [{"role": "assistant", "content": content}]
             return ChatCompletionResponse(
                 content=content,
-                is_complete=response['stop_reason'] == 'stop_sequence',
+                is_complete=completion.stop_reason == 'stop_sequence',
                 message_history=message_history,
             )
-        except anthropic.ApiException as e:
+        except anthropic.APIError as e:
             raise FreeplayError("Error calling Anthropic") from e
 
     def continue_chat_stream(
@@ -482,26 +423,18 @@ class AnthropicClaudeChat(ChatFlavor):
         formatted_prompt = self.__to_anthropic_chat_format(messages)
         try:
             client = self.get_anthropic_client(provider_config.anthropic)
-            anthropic_response = client.completion_stream(
+            anthropic_response = client.completions.create(
                 prompt=formatted_prompt,
+                stream=True,
                 **self.get_model_params(llm_parameters)
             )
 
-            # Yield incremental text completions. Claude returns the full text output in every chunk.
-            # We want to predictably return a stream like we do for OpenAI.
-            prev_chunk = ''
             for chunk in anthropic_response:
-                if len(prev_chunk) != 0:
-                    incremental_new_text = chunk['completion'].split(prev_chunk)[1]
-                else:
-                    incremental_new_text = chunk['completion']
-
-                prev_chunk = chunk['completion']
                 yield CompletionChunk(
-                    text=incremental_new_text,
-                    is_complete=chunk['stop_reason'] == 'stop_sequence'
+                    text=chunk.completion,
+                    is_complete=chunk.stop_reason == 'stop_sequence'
                 )
-        except anthropic.ApiException as e:
+        except anthropic.APIError as e:
             raise FreeplayError("Error calling Anthropic") from e
 
     def call_service(self, formatted_prompt: str, provider_config: ProviderConfig,

{freeplay-0.2.23 → freeplay-0.2.25}/freeplay/freeplay.py

@@ -46,8 +46,20 @@ class CallSupport:
             raise FreeplayConfigurationError(f'Could not find template with name "{template_name}"')
         return templates[0]
 
-    def create_session(self, project_id: str, tag: str, test_run_id: Optional[str] = None) -> JsonDom:
-        request_body = {'test_run_id': test_run_id} if test_run_id is not None else None
+    def create_session(
+            self,
+            project_id: str,
+            tag: str,
+            test_run_id: Optional[str] = None,
+            metadata: Optional[dict[str, str|int|float]] = None
+        ) -> JsonDom:
+        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:
+            check_all_values_string_or_number(metadata)
+            request_body['metadata'] = metadata
+
         response = api_support.post_raw(api_key=self.freeplay_api_key,
                                         url=f'{self.api_base}/projects/{project_id}/sessions/tag/{tag}',
                                         payload=request_body)
@@ -535,9 +547,10 @@ class Freeplay:
             variables: dict[str, str],
             tag: str = default_tag,
             flavor: Optional[Flavor] = None,
+            metadata: Optional[dict[str, str|int|float]] = None,
             **kwargs: Any
     ) -> CompletionResponse:
-        project_session = self.call_support.create_session(project_id, tag)
+        project_session = self.call_support.create_session(project_id, tag, None, metadata)
         prompts = self.call_support.get_prompts(project_id, tag)
         completion_flavor = flavor or self.client_flavor
 
@@ -557,9 +570,10 @@ class Freeplay:
             variables: dict[str, str],
             tag: str = default_tag,
             flavor: Optional[Flavor] = None,
+            metadata: Optional[dict[str, str|int|float]] = None,
             **kwargs: Any
     ) -> Generator[CompletionChunk, None, None]:
-        project_session = self.call_support.create_session(project_id, tag)
+        project_session = self.call_support.create_session(project_id, tag, None, metadata)
         prompts = self.call_support.get_prompts(project_id, tag)
         completion_flavor = flavor or self.client_flavor
 
@@ -597,9 +611,10 @@ class Freeplay:
             template_name: str,
             variables: Variables,
             tag: str = default_tag,
+            metadata: Optional[dict[str, str|int|float]] = None,
             **kwargs: Any
     ) -> Tuple[ChatSession, ChatCompletionResponse]:
-        session = self.__create_chat_session(project_id, tag, template_name, variables)
+        session = self.__create_chat_session(project_id, tag, template_name, variables, metadata)
         completion_response = session.start_chat(**kwargs)
         return session, completion_response
 
@@ -632,17 +647,24 @@ class Freeplay:
             template_name: str,
             variables: Variables,
             tag: str = default_tag,
+            metadata: Optional[dict[str, 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."""
-        session = self.__create_chat_session(project_id, tag, template_name, variables)
+        session = self.__create_chat_session(project_id, tag, template_name, variables, metadata)
         completion_response = session.start_chat_stream(**kwargs)
         return session, completion_response
 
-    def __create_chat_session(self, project_id: str, tag: str, template_name: str, variables: Variables) -> ChatSession:
+    def __create_chat_session(
+            self,
+            project_id: str,
+            tag: str,
+            template_name: str,
+            variables: Variables,
+            metadata: Optional[dict[str, 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)
+        project_session = self.call_support.create_session(project_id, tag, None, metadata)
         prompts = self.call_support.get_prompts(project_id, tag)
         return ChatSession(
             self.call_support,
@@ -677,3 +699,9 @@ def require_chat_flavor(flavor: Flavor) -> ChatFlavor:
         raise FreeplayConfigurationError('A Chat flavor is required to start a chat session.')
 
     return flavor
+
+def check_all_values_string_or_number(metadata: Optional[dict[str, str|int|float]]) -> None:
+    if metadata:
+        for key, value in metadata.items():
+            if not isinstance(value, (str, int, float)):
+                raise FreeplayConfigurationError(f"Invalid value for key {key}: Value must be a string or number.")

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

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "freeplay"
-version = "0.2.23"
+version = "0.2.25"
 description = ""
 authors = ["FreePlay Engineering <engineering@freeplay.ai>"]
 license = "MIT"
@@ -10,7 +10,7 @@ readme = "README.md"
 python = ">=3.8, <4"
 requests = ">=2.20.0,<3.0.0dev"
 dacite = "^1.8.0"
-anthropic = "^0.2.10"
+anthropic = "^0.7.7"
 openai = "^0.27.8"