freeplay 0.2.30__py3-none-any.whl → 0.2.32__py3-none-any.whl

freeplay/api_support.py

@@ -7,6 +7,8 @@ import dacite
 import requests
 from requests import Response
 
+from freeplay.utils import build_request_header
+
 T = t.TypeVar("T")
 
 logger = logging.getLogger(__name__)
@@ -28,7 +30,7 @@ def try_decode(target_type: t.Type[T], data: bytes) -> t.Optional[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}'},
+        headers=build_request_header(api_key),
         json=payload
     )
 
@@ -45,7 +47,7 @@ def post(target_type: t.Type[T], api_key: str, url: str, payload: t.Optional[Dic
 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}'},
+        headers=build_request_header(api_key),
         json=payload
     )
 
@@ -53,7 +55,7 @@ def post_raw(api_key: str, url: str, payload: t.Optional[Dict[str, t.Any]] = Non
 def get(target_type: t.Type[T], api_key: str, url: str) -> T:
     response = requests.get(
         url=url,
-        headers={'Authorization': f'Bearer {api_key}'}
+        headers=build_request_header(api_key),
     )
 
     if response.status_code != 200:
@@ -69,5 +71,5 @@ def get(target_type: t.Type[T], api_key: str, url: str) -> T:
 def get_raw(api_key: str, url: str) -> Response:
     return requests.get(
         url=url,
-        headers={'Authorization': f'Bearer {api_key}'}
+        headers=build_request_header(api_key),
     )

freeplay/completions.py

@@ -2,7 +2,6 @@ from dataclasses import dataclass
 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
 
@@ -12,11 +11,16 @@ class ChatMessage(TypedDict):
     content: str
 
 
+class OpenAIFunctionCall(TypedDict):
+    name: str
+    arguments: str
+
+
 @dataclass
 class CompletionResponse:
     content: str
     is_complete: bool
-    openai_function_call: Optional[FunctionCall] = None
+    openai_function_call: Optional[OpenAIFunctionCall] = None
 
 
 @dataclass

freeplay/flavors.py

@@ -9,11 +9,12 @@ from openai import AuthenticationError, BadRequestError, Stream
 from openai.types.chat import ChatCompletion, ChatCompletionChunk, ChatCompletionMessageParam
 
 from .completions import CompletionChunk, PromptTemplateWithMetadata, CompletionResponse, ChatCompletionResponse, \
-    ChatMessage
+    ChatMessage, OpenAIFunctionCall
 from .errors import FreeplayConfigurationError, LLMClientError, LLMServerError, FreeplayError
 from .llm_parameters import LLMParameters
+from .model import InputVariables
 from .provider_config import AnthropicConfig, AzureConfig, OpenAIConfig, ProviderConfig
-from .utils import format_template_variables
+from .utils import bind_template_variables
 
 
 class Flavor(ABC):
@@ -45,9 +46,13 @@ 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: InputVariables) -> str:
         pass
 
+    @abstractmethod
+    def to_llm_syntax(self, messages: List[ChatMessage]) -> str | List[ChatMessage]:
+        raise NotImplementedError()
+
     @abstractmethod
     def call_service(
             self,
@@ -102,16 +107,19 @@ class OpenAIChatFlavor(ChatFlavor, ABC):
     ) -> Union[ChatCompletion, openai.Stream[ChatCompletionChunk]]:
         pass
 
-    def format(self, prompt_template: PromptTemplateWithMetadata, variables: Dict[str, str]) -> str:
+    def format(self, prompt_template: PromptTemplateWithMetadata, variables: InputVariables) -> 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)
         formatted_messages = [
             {
-                "content": format_template_variables(message['content'], variables), "role": message['role']
+                "content": bind_template_variables(message['content'], variables), "role": message['role']
             } for message in messages_as_json]
         return json.dumps(formatted_messages)
 
+    def to_llm_syntax(self, messages: List[ChatMessage]) -> List[ChatMessage]:
+        return messages
+
     def call_service(
             self,
             formatted_prompt: str,
@@ -124,9 +132,19 @@ class OpenAIChatFlavor(ChatFlavor, ABC):
         return CompletionResponse(
             content=completion.choices[0].message.content or '',
             is_complete=completion.choices[0].finish_reason == 'stop',
-            openai_function_call=completion.choices[0].message.function_call,
+            openai_function_call=self.__maybe_function_call(completion),
         )
 
+    # noinspection PyMethodMayBeStatic
+    def __maybe_function_call(self, completion: ChatCompletion) -> Optional[OpenAIFunctionCall]:
+        maybe_function_call = completion.choices[0].message.function_call
+        if maybe_function_call:
+            return OpenAIFunctionCall(
+                name=maybe_function_call.name,
+                arguments=maybe_function_call.arguments
+            )
+        return None
+
     def call_service_stream(
             self,
             formatted_prompt: str,
@@ -153,10 +171,10 @@ class OpenAIChatFlavor(ChatFlavor, ABC):
 
         message_history = copy(messages)
         message = completion.choices[0].message
-        message_history.append({
-            "role": message.role or '',
-            "content": message.content or ''
-        })
+        message_history.append(ChatMessage(
+            role=message.role or '',
+            content=message.content or ''
+        ))
         return ChatCompletionResponse(
             content=message.content or '',
             message_history=message_history,
@@ -286,83 +304,6 @@ class AzureOpenAIChat(OpenAIChatFlavor):
             raise LLMServerError("Unable to call Azure") from e
 
 
-class AnthropicClaudeText(Flavor):
-    record_format_type = "anthropic_text"
-    _model_params_with_defaults = LLMParameters({
-        "model": "claude-v1",
-        "max_tokens_to_sample": 100
-    })
-
-    def __init__(self) -> None:
-        self.client: Optional[anthropic.Client] = None
-
-    @property
-    def provider(self) -> str:
-        return "anthropic"
-
-    def get_anthropic_client(self, anthropic_config: Optional[AnthropicConfig]) -> Any:
-        if self.client:
-            return self.client
-
-        if not anthropic_config:
-            raise FreeplayConfigurationError(
-                "Missing Anthropic key. Use a ProviderConfig to specify keys prior to getting completion.")
-
-        self.client = anthropic.Client(api_key=anthropic_config.api_key)
-        return self.client
-
-    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}"
-        return chat_formatted_prompt
-
-    def call_service(self, formatted_prompt: str, provider_config: ProviderConfig,
-                     llm_parameters: LLMParameters) -> CompletionResponse:
-        try:
-            client = self.get_anthropic_client(provider_config.anthropic)
-            anthropic_response = client.completion(
-                prompt=formatted_prompt,
-                **self.get_model_params(llm_parameters)
-            )
-            return CompletionResponse(
-                content=anthropic_response['completion'],
-                is_complete=anthropic_response['stop_reason'] == 'stop_sequence'
-            )
-        except anthropic.APIError as e:
-            raise FreeplayError("Error calling Anthropic") from e
-
-    def call_service_stream(
-            self,
-            formatted_prompt: str,
-            provider_config: ProviderConfig,
-            llm_parameters: LLMParameters
-    ) -> Generator[CompletionChunk, None, None]:
-        try:
-            client = self.get_anthropic_client(provider_config.anthropic)
-            anthropic_response = client.completion_stream(
-                prompt=formatted_prompt,
-                **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'
-                )
-        except anthropic.APIError as e:
-            raise FreeplayError("Error calling Anthropic") from e
-
-
 class AnthropicClaudeChat(ChatFlavor):
     record_format_type = "anthropic_chat"
     _model_params_with_defaults = LLMParameters({
@@ -390,17 +331,26 @@ 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: InputVariables) -> 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)
         formatted_messages = [
             {
-                "content": format_template_variables(message['content'], variables),
+                "content": bind_template_variables(message['content'], variables),
                 "role": self.__to_anthropic_role(message['role'])
             } for message in messages_as_json]
         return json.dumps(formatted_messages)
 
+    def to_llm_syntax(self, messages: List[ChatMessage]) -> str:
+        formatted_messages = [
+            ChatMessage(
+                content=message['content'],
+                role=self.__to_anthropic_role(message['role'])
+            ) for message in messages
+        ]
+        return self.__to_anthropic_chat_format(formatted_messages)
+
     @staticmethod
     def __to_anthropic_role(role: str) -> str:
         if role == 'Human':
@@ -483,3 +433,27 @@ class AnthropicClaudeChat(ChatFlavor):
     ) -> Generator[CompletionChunk, None, None]:
         messages = json.loads(formatted_prompt)
         return self.continue_chat_stream(messages, provider_config, llm_parameters)
+
+
+def pick_flavor_from_config(completion_flavor: Optional[Flavor], ui_flavor_name: Optional[str]) -> Flavor:
+    ui_flavor = Flavor.get_by_name(ui_flavor_name) if ui_flavor_name else None
+    flavor = completion_flavor or ui_flavor
+
+    if flavor is None:
+        raise FreeplayConfigurationError(
+            "Flavor must be configured on either the Freeplay client, completion call, "
+            "or in the Freeplay UI. Unable to fulfill request.")
+
+    return flavor
+
+
+def get_chat_flavor_from_config(completion_flavor: Optional[Flavor], ui_flavor_name: Optional[str]) -> ChatFlavor:
+    flavor = pick_flavor_from_config(completion_flavor, ui_flavor_name)
+    return require_chat_flavor(flavor)
+
+
+def require_chat_flavor(flavor: Flavor) -> ChatFlavor:
+    if not isinstance(flavor, ChatFlavor):
+        raise FreeplayConfigurationError('A Chat flavor is required to start a chat session.')
+
+    return flavor