freeplay 0.2.42__py3-none-any.whl → 0.3.0a2__py3-none-any.whl

freeplay/__init__.py

@@ -1,5 +1,14 @@
 from .freeplay import Freeplay
+from .resources.prompts import PromptInfo
+from .resources.recordings import CallInfo, ResponseInfo, RecordPayload, TestRunInfo
+from .resources.sessions import SessionInfo
 
 __all__ = [
-    'Freeplay'
+    'CallInfo',
+    'Freeplay',
+    'PromptInfo',
+    'RecordPayload',
+    'ResponseInfo',
+    'SessionInfo',
+    'TestRunInfo',
 ]

freeplay/freeplay.py

@@ -1,240 +1,12 @@
-import json
-import logging
-from dataclasses import dataclass
-from typing import Any, Dict, Generator, List, Optional, Tuple, Union
+from typing import Optional
 
-from .completions import (
-    PromptTemplates,
-    CompletionResponse,
-    CompletionChunk,
-    ChatCompletionResponse,
-    ChatMessage
-)
-from .errors import FreeplayConfigurationError
-from .flavors import Flavor, ChatFlavor, require_chat_flavor, get_chat_flavor_from_config
-from .llm_parameters import LLMParameters
-from .model import InputVariables
-from .provider_config import ProviderConfig
-from .record import (
-    RecordProcessor,
-    DefaultRecordProcessor
-)
-from .support import CallSupport
-
-logger = logging.getLogger(__name__)
-default_tag = 'latest'
-
-
-class Session:
-    def __init__(
-            self,
-            call_support: CallSupport,
-            session_id: str,
-            prompts: PromptTemplates,
-            flavor: Optional[Flavor],
-            provider_config: ProviderConfig,
-            tag: str = default_tag,
-            test_run_id: Optional[str] = None
-    ) -> None:
-        self.tag = tag
-        self.call_support = call_support
-        self.session_flavor = flavor
-        self.provider_config = provider_config
-        self.session_id = session_id
-        self.prompts = prompts
-        self.test_run_id = test_run_id
-
-    def get_completion(
-            self,
-            template_name: str,
-            variables: InputVariables,
-            flavor: Optional[Flavor] = None,
-            **kwargs: Any
-    ) -> CompletionResponse:
-        completion_flavor = flavor or self.session_flavor
-        return self.call_support.prepare_and_make_call(self.session_id,
-                                                       self.prompts,
-                                                       template_name,
-                                                       variables,
-                                                       completion_flavor,
-                                                       self.provider_config,
-                                                       self.tag,
-                                                       self.test_run_id,
-                                                       completion_parameters=LLMParameters(kwargs))
-
-    def get_completion_stream(
-            self,
-            template_name: str,
-            variables: InputVariables,
-            flavor: Optional[Flavor] = None,
-            **kwargs: Any
-    ) -> Generator[CompletionChunk, None, None]:
-        completion_flavor = flavor or self.session_flavor
-        return self.call_support.prepare_and_make_call_stream(self.session_id,
-                                                              self.prompts,
-                                                              template_name,
-                                                              variables,
-                                                              completion_flavor,
-                                                              self.provider_config,
-                                                              self.tag,
-                                                              self.test_run_id,
-                                                              completion_parameters=LLMParameters(kwargs))
-
-
-class ChatSession(Session):
-    def __init__(
-            self,
-            call_support: CallSupport,
-            session_id: str,
-            prompts: PromptTemplates,
-            flavor: Optional[ChatFlavor],
-            provider_config: ProviderConfig,
-            template_name: str,
-            variables: InputVariables,
-            tag: str = default_tag,
-            test_run_id: Optional[str] = None,
-            messages: Optional[List[ChatMessage]] = None,
-            metadata: Optional[Dict[str, Union[str, int, float]]] = 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.
-        # Assumes these will be the same for subsequent chat messages.
-        self.message_history = messages or []
-        self.variables = variables
-        self.metadata = metadata
-        self.target_template = self.call_support.find_template_by_name(self.prompts, template_name)
-        self.flavor = get_chat_flavor_from_config(flavor, self.target_template.flavor_name)
-        self.__initial_messages = json.loads(self.flavor.format(self.target_template, self.variables))
-
-    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:
-        for message in new_messages:
-            self.message_history.append({
-                "role": message["role"],
-                "content": message["content"]
-            })
-
-    def start_chat(self, **kwargs: Any) -> ChatCompletionResponse:
-        response = self.call_support.prepare_and_make_chat_call(
-            self.session_id,
-            flavor=self.flavor,
-            provider_config=self.provider_config,
-            tag=self.tag,
-            test_run_id=self.test_run_id,
-            target_template=self.target_template,
-            variables=self.variables,
-            message_history=self.__initial_messages,
-            new_messages=None,
-            completion_parameters=LLMParameters(kwargs),
-            metadata=self.metadata,
-        )
-
-        self.store_new_messages(response.message_history)
-        return response
-
-    def start_chat_stream(self, **kwargs: Any) -> Generator[CompletionChunk, None, None]:
-        return self.continue_chat_stream(new_messages=None, **kwargs)
-
-    def aggregate_message_from_response(
-            self,
-            response: Generator[CompletionChunk, None, None]
-    ) -> Generator[CompletionChunk, Any, None]:
-        message: ChatMessage = {
-            "role": "assistant",
-            "content": ""
-        }
-
-        for chunk in response:
-            message["content"] += chunk.text
-            yield chunk
-
-        self.message_history.append(message)
-
-    def continue_chat(
-            self,
-            new_messages: Optional[List[ChatMessage]] = None,
-            **kwargs: Any
-    ) -> ChatCompletionResponse:
-
-        response = self.call_support.prepare_and_make_chat_call(
-            self.session_id,
-            flavor=self.flavor,
-            provider_config=self.provider_config,
-            tag=self.tag,
-            test_run_id=self.test_run_id,
-            target_template=self.target_template,
-            variables=self.variables,
-            message_history=self.message_history,
-            new_messages=new_messages,
-            completion_parameters=LLMParameters(kwargs),
-            metadata=self.metadata,
-        )
-
-        if new_messages is not None:
-            self.store_new_messages(new_messages)
-        if response.content:
-            self.message_history.append(response.message_history[-1])
-
-        return response
-
-    def continue_chat_stream(
-            self,
-            new_messages: Optional[List[ChatMessage]] = None,
-            **kwargs: Any
-    ) -> Generator[CompletionChunk, None, None]:
-        new_messages = new_messages or []
-        if len(self.message_history) == 0:
-            self.message_history = self.__initial_messages
-
-        response = self.call_support.prepare_and_make_chat_call_stream(
-            self.session_id,
-            flavor=self.flavor,
-            provider_config=self.provider_config,
-            tag=self.tag,
-            target_template=self.target_template,
-            variables=self.variables,
-            message_history=self.message_history,
-            test_run_id=self.test_run_id,
-            completion_parameters=LLMParameters(kwargs),
-            metadata=self.metadata,
-        )
-
-        self.store_new_messages(new_messages)
-        yield from self.aggregate_message_from_response(response)
-
-
-@dataclass()
-class FreeplayTestRun:
-    def __init__(
-            self,
-            call_support: CallSupport,
-            flavor: Optional[Flavor],
-            provider_config: ProviderConfig,
-            test_run_id: str,
-            inputs: List[InputVariables]
-    ):
-        self.call_support = call_support
-        self.flavor = flavor
-        self.provider_config = provider_config
-        self.test_run_id = test_run_id
-        self.inputs = inputs
-
-    def get_inputs(self) -> List[InputVariables]:
-        return self.inputs
-
-    def create_session(self, project_id: str, tag: str = default_tag) -> Session:
-        session_id = self.call_support.create_session_id()
-        prompts = self.call_support.get_prompts(project_id, tag)
-        return Session(self.call_support, session_id, prompts, self.flavor, self.provider_config,
-                       tag, self.test_run_id)
-
-
-# This SDK prototype does not support full functionality of either OpenAI's API or Freeplay's
-# The simplifications are:
-#  - Always assumes there is a single choice returned, does not support multiple
-#  - Does not support an "escape hatch" to allow use of features we don't explicitly expose
+from freeplay.errors import FreeplayConfigurationError
+from freeplay.resources.customer_feedback import CustomerFeedback
+from freeplay.resources.prompts import Prompts, APITemplateResolver, TemplateResolver
+from freeplay.resources.recordings import Recordings
+from freeplay.resources.sessions import Sessions
+from freeplay.resources.test_runs import TestRuns
+from freeplay.support import CallSupport
 
 
 class Freeplay:
@@ -242,185 +14,27 @@ class Freeplay:
             self,
             freeplay_api_key: str,
             api_base: str,
-            provider_config: ProviderConfig,
-            flavor: Optional[Flavor] = None,
-            record_processor: Optional[RecordProcessor] = None,
-            **kwargs: Any
+            template_resolver: Optional[TemplateResolver] = None
     ) -> None:
         if not freeplay_api_key or not freeplay_api_key.strip():
-            raise FreeplayConfigurationError("Freeplay API key not set. It must be set to use the Freeplay API.")
-        provider_config.validate()
+            raise FreeplayConfigurationError("Freeplay API key not set. It must be set to the Freeplay API.")
 
-        self.__record_processor = record_processor or DefaultRecordProcessor(freeplay_api_key, api_base)
-        self.call_support = CallSupport(freeplay_api_key, api_base, self.__record_processor, **kwargs)
-        self.provider_config = provider_config
-        self.client_flavor = flavor
+        self.call_support = CallSupport(
+            freeplay_api_key,
+            api_base
+        )
         self.freeplay_api_key = freeplay_api_key
         self.api_base = api_base
 
-    def create_session(self, project_id: str, tag: str = default_tag) -> Session:
-        session_id = self.call_support.create_session_id()
-        prompts = self.call_support.get_prompts(project_id, tag)
-        return Session(
-            self.call_support,
-            session_id,
-            prompts,
-            self.client_flavor,
-            self.provider_config,
-            tag)
-
-    def restore_session(
-            self,
-            project_id: str,
-            session_id: str,
-            template_name: str,
-            variables: InputVariables,
-            tag: str = default_tag,
-            flavor: Optional[Flavor] = None,
-            **kwargs: Any
-    ) -> CompletionResponse:
-        prompts = self.call_support.get_prompts(project_id, tag)
-        completion_flavor = flavor or self.client_flavor
-        return self.call_support.prepare_and_make_call(
-            session_id=session_id,
-            prompts=prompts,
-            template_name=template_name,
-            variables=variables,
-            flavor=completion_flavor,
-            provider_config=self.provider_config,
-            tag=tag,
-            completion_parameters=LLMParameters(kwargs),
-        )
-
-    def get_completion(
-            self,
-            project_id: str,
-            template_name: str,
-            variables: InputVariables,
-            tag: str = default_tag,
-            flavor: Optional[Flavor] = None,
-            metadata: Optional[Dict[str, Union[str, int, float]]] = None,
-            **kwargs: Any
-    ) -> CompletionResponse:
-        self.call_support.check_all_values_string_or_number(metadata)
-        session_id = self.call_support.create_session_id()
-        prompts = self.call_support.get_prompts(project_id, tag)
-        completion_flavor = flavor or self.client_flavor
-
-        return self.call_support.prepare_and_make_call(session_id,
-                                                       prompts,
-                                                       template_name,
-                                                       variables,
-                                                       completion_flavor,
-                                                       self.provider_config,
-                                                       tag,
-                                                       completion_parameters=LLMParameters(kwargs),
-                                                       metadata=metadata)
-
-    def get_completion_stream(
-            self,
-            project_id: str,
-            template_name: str,
-            variables: InputVariables,
-            tag: str = default_tag,
-            flavor: Optional[Flavor] = None,
-            metadata: Optional[Dict[str, Union[str, int, float]]] = None,
-            **kwargs: Any
-    ) -> Generator[CompletionChunk, None, None]:
-        self.call_support.check_all_values_string_or_number(metadata)
-        session_id = self.call_support.create_session_id()
-        prompts = self.call_support.get_prompts(project_id, tag)
-        completion_flavor = flavor or self.client_flavor
-
-        return self.call_support.prepare_and_make_call_stream(session_id,
-                                                              prompts,
-                                                              template_name,
-                                                              variables,
-                                                              completion_flavor,
-                                                              self.provider_config,
-                                                              tag,
-                                                              completion_parameters=LLMParameters(kwargs),
-                                                              metadata=metadata)
-
-    def start_chat(
-            self,
-            project_id: str,
-            template_name: str,
-            variables: InputVariables,
-            tag: str = default_tag,
-            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)
-        completion_response = session.start_chat(**kwargs)
-        return session, completion_response
-
-    def restore_chat_session(
-            self,
-            project_id: str,
-            template_name: str,
-            session_id: str,
-            variables: InputVariables,
-            tag: str = default_tag,
-            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
-        return ChatSession(
-            call_support=self.call_support,
-            session_id=session_id,
-            prompts=prompts,
-            flavor=chat_flavor,
-            provider_config=self.provider_config,
-            template_name=template_name,
-            variables=variables,
-            tag=tag,
-            messages=messages or []
-        )
-
-    def start_chat_stream(
-            self,
-            project_id: str,
-            template_name: str,
-            variables: InputVariables,
-            tag: str = default_tag,
-            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."""
-        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_test_run(self, project_id: str, testlist: str) -> FreeplayTestRun:
-        test_run_response = self.call_support.create_test_run(project_id=project_id, testlist=testlist)
-
-        return FreeplayTestRun(
-            self.call_support,
-            self.client_flavor,
-            self.provider_config,
-            test_run_response.test_run_id,
-            [test_case.variables for test_case in test_run_response.test_cases]
-        )
-
-    def __create_chat_session(
-            self,
-            project_id: str,
-            tag: str,
-            template_name: str,
-            variables: InputVariables,
-            metadata: Optional[Dict[str, Union[str, int, float]]] = None) -> ChatSession:
-        chat_flavor = require_chat_flavor(self.client_flavor) if self.client_flavor else None
-
-        session_id = self.call_support.create_session_id()
-        prompts = self.call_support.get_prompts(project_id, tag)
-        return ChatSession(
-            self.call_support,
-            session_id,
-            prompts,
-            chat_flavor,
-            self.provider_config,
-            template_name,
-            variables,
-            tag,
-            metadata=metadata)
+        resolver: TemplateResolver
+        if template_resolver is None:
+            resolver = APITemplateResolver(self.call_support)
+        else:
+            resolver = template_resolver
+
+        # Resources ========
+        self.customer_feedback = CustomerFeedback(self.call_support)
+        self.prompts = Prompts(self.call_support, resolver)
+        self.recordings = Recordings(self.call_support)
+        self.sessions = Sessions()
+        self.test_runs = TestRuns(self.call_support)

freeplay/freeplay_cli.py

@@ -1,4 +1,3 @@
-import dataclasses
 import json
 import os
 import sys
@@ -7,9 +6,9 @@ from stat import S_IREAD, S_IRGRP, S_IROTH, S_IWUSR
 
 import click
 
-from .completions import PromptTemplates, PromptTemplateWithMetadata
-from .errors import FreeplayClientError, FreeplayServerError
-from .thin import Freeplay
+from freeplay.errors import FreeplayClientError, FreeplayServerError
+from freeplay import Freeplay
+from freeplay.support import PromptTemplates, PromptTemplate, PromptTemplateEncoder
 
 
 @click.group()
@@ -37,8 +36,9 @@ def download(project_id: str, environment: str, output_dir: str) -> None:
         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))
+    click.echo(
+        f"Downloading prompts for project {project_id}, environment {environment}, "
+        f"to directory {output_dir} from {freeplay_api_url}")
 
     fp_client = Freeplay(
         freeplay_api_key=FREEPLAY_API_KEY,
@@ -47,19 +47,19 @@ def download(project_id: str, environment: str, output_dir: str) -> None:
 
     try:
         prompts: PromptTemplates = fp_client.prompts.get_all(project_id, environment=environment)
-        click.echo("Found %s prompt templates" % len(prompts.templates))
+        click.echo(f"Found {len(prompts.prompt_templates)} prompt templates")
 
-        for prompt in prompts.templates:
+        for prompt in prompts.prompt_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)
+        print(f"Error downloading templates: {e}.\nIs your project ID correct?", 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,
+        print(f"Error on Freeplay's servers downloading templates: {e}.\nTry again after a short wait.",
               file=sys.stderr)
         exit(2)
     except Exception as e:
-        print("Error downloading templates: %s" % e, file=sys.stderr)
+        print(f"Error downloading templates: {e}", file=sys.stderr)
         exit(3)
 
 
@@ -67,33 +67,19 @@ def __write_single_file(
         environment: str,
         output_dir: str,
         project_id: str,
-        prompt: PromptTemplateWithMetadata
+        prompt: PromptTemplate
 ) -> None:
     directory = __root_dir(environment, output_dir, project_id)
-    basename = f'{prompt.name}'
+    basename = f'{prompt.prompt_template_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(json.dumps(prompt, sort_keys=True, indent=4, cls=PromptTemplateEncoder))
         f.write('\n')
 
     # Make the file read-only to discourage local changes

freeplay/model.py

@@ -1,16 +1,8 @@
 from dataclasses import dataclass
-from typing import List, Union, Any, Dict, Mapping
-
-from pydantic import RootModel
+from typing import List, Union, Any, Dict, Mapping, TypedDict
 
 InputValue = Union[str, int, bool, Dict[str, Any], List[Any]]
-InputVariable = RootModel[Union[Dict[str, "InputVariable"], List["InputVariable"], str, int, bool, float]]
-InputVariable.model_rebuild()
-
 InputVariables = Mapping[str, InputValue]
-
-PydanticInputVariables = RootModel[Dict[str, InputVariable]]
-
 TestRunInput = Mapping[str, InputValue]
 
 
@@ -18,3 +10,8 @@ TestRunInput = Mapping[str, InputValue]
 class TestRun:
     id: str
     inputs: List[TestRunInput]
+
+
+class OpenAIFunctionCall(TypedDict):
+    name: str
+    arguments: str