freeplay 0.2.42__tar.gz → 0.3.0a2__tar.gz

{freeplay-0.2.42 → freeplay-0.3.0a2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: freeplay
-Version: 0.2.42
+Version: 0.3.0a2
 Summary: 
 License: MIT
 Author: FreePlay Engineering
@@ -13,10 +13,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.20.0,<0.21.0)
 Requires-Dist: click (==8.1.7)
 Requires-Dist: dacite (>=1.8.0,<2.0.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.42 → freeplay-0.3.0a2}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "freeplay"
-version = "0.2.42"
+version = "0.3.0-alpha.2"
 description = ""
 authors = ["FreePlay Engineering <engineering@freeplay.ai>"]
 license = "MIT"
@@ -10,8 +10,6 @@ readme = "README.md"
 python = ">=3.8, <4"
 requests = ">=2.20.0,<3.0.0dev"
 dacite = "^1.8.0"
-anthropic = "^0.20.0"
-openai = "^1"
 click = "8.1.7"
 pystache = "^0.6.5"
 
@@ -19,6 +17,7 @@ pystache = "^0.6.5"
 mypy = "^1"
 types-requests = "^2.31"
 anthropic = { version="^0.20.0", extras = ["bedrock"] }
+openai = "^1"
 
 [tool.poetry.group.test.dependencies]
 responses = "^0.23.1"

{freeplay-0.2.42/src/freeplay/thin → freeplay-0.3.0a2/src/freeplay}/__init__.py

@@ -1,11 +1,11 @@
-from .freeplay_thin import Freeplay
+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',

freeplay-0.2.42/src/freeplay/thin/freeplay_thin.py → freeplay-0.3.0a2/src/freeplay/freeplay.py

@@ -1,13 +1,12 @@
 from typing import Optional
 
 from freeplay.errors import FreeplayConfigurationError
-from freeplay.record import DefaultRecordProcessor
+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
-from freeplay.thin.resources.customer_feedback import CustomerFeedback
-from freeplay.thin.resources.prompts import Prompts, APITemplateResolver, TemplateResolver
-from freeplay.thin.resources.recordings import Recordings
-from freeplay.thin.resources.sessions import Sessions
-from freeplay.thin.resources.test_runs import TestRuns
 
 
 class Freeplay:
@@ -22,8 +21,7 @@ class Freeplay:
 
         self.call_support = CallSupport(
             freeplay_api_key,
-            api_base,
-            DefaultRecordProcessor(freeplay_api_key, api_base)
+            api_base
         )
         self.freeplay_api_key = freeplay_api_key
         self.api_base = api_base

{freeplay-0.2.42 → freeplay-0.3.0a2}/src/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-0.3.0a2/src/freeplay/model.py

@@ -0,0 +1,17 @@
+from dataclasses import dataclass
+from typing import List, Union, Any, Dict, Mapping, TypedDict
+
+InputValue = Union[str, int, bool, Dict[str, Any], List[Any]]
+InputVariables = Mapping[str, InputValue]
+TestRunInput = Mapping[str, InputValue]
+
+
+@dataclass
+class TestRun:
+    id: str
+    inputs: List[TestRunInput]
+
+
+class OpenAIFunctionCall(TypedDict):
+    name: str
+    arguments: str

{freeplay-0.2.42/src/freeplay/thin → freeplay-0.3.0a2/src/freeplay}/resources/prompts.py

@@ -4,15 +4,22 @@ from dataclasses import dataclass
 from pathlib import Path
 from typing import Dict, Optional, List, Union, cast, Any
 
-from freeplay.completions import PromptTemplates, ChatMessage, PromptTemplateWithMetadata
 from freeplay.errors import FreeplayConfigurationError, FreeplayClientError
-from freeplay.flavors import Flavor
 from freeplay.llm_parameters import LLMParameters
 from freeplay.model import InputVariables
-from freeplay.support import CallSupport, PromptTemplate, PromptTemplateMetadata
+from freeplay.support import PromptTemplate, PromptTemplates, PromptTemplateMetadata
+from freeplay.support import CallSupport
 from freeplay.utils import bind_template_variables
 
 
+class MissingFlavorError(FreeplayConfigurationError):
+    def __init__(self, flavor_name: str):
+        super().__init__(
+            f'Configured flavor ({flavor_name}) not found in SDK. Please update your SDK version or configure '
+            'a different model in the Freeplay UI.'
+        )
+
+
 # SDK-Exposed Classes
 @dataclass
 class PromptInfo:
@@ -54,18 +61,40 @@ class BoundPrompt:
         self.prompt_info = prompt_info
         self.messages = messages
 
+    @staticmethod
+    def __to_anthropic_role(role: str) -> str:
+        if role == 'assistant' or role == 'Assistant':
+            return 'Assistant'
+        else:
+            # Anthropic does not support system role for now.
+            return 'Human'
+
+    @staticmethod
+    def __format_messages_for_flavor(flavor_name: str, messages: List[Dict[str, str]]) -> Union[
+        str, List[Dict[str, str]]]:
+        if flavor_name == 'azure_openai_chat' or flavor_name == 'openai_chat':
+            return messages
+        elif flavor_name == 'anthropic_chat':
+            formatted_messages = []
+            for message in messages:
+                role = BoundPrompt.__to_anthropic_role(message['role'])
+                formatted_messages.append(f"{role}: {message['content']}")
+            formatted_messages.append('Assistant:')
+
+            return "\n\n" + "\n\n".join(formatted_messages)
+        raise MissingFlavorError(flavor_name)
+
     def format(
             self,
             flavor_name: Optional[str] = None
     ) -> FormattedPrompt:
         final_flavor = flavor_name or self.prompt_info.flavor_name
-        flavor = Flavor.get_by_name(final_flavor)
-        llm_format = flavor.to_llm_syntax(cast(List[ChatMessage], self.messages))
+        llm_format = BoundPrompt.__format_messages_for_flavor(final_flavor, self.messages)
 
         return FormattedPrompt(
             self.prompt_info,
             self.messages,
-            cast(Union[str, List[Dict[str, str]]], llm_format)
+            llm_format,
         )
 
 
@@ -120,15 +149,7 @@ class FilesystemTemplateResolver(TemplateResolver):
         prompt_list = []
         for prompt_file_path in prompt_file_paths:
             json_dom = json.loads(prompt_file_path.read_text())
-
-            prompt_list.append(PromptTemplateWithMetadata(
-                prompt_template_id=json_dom.get('prompt_template_id'),
-                prompt_template_version_id=json_dom.get('prompt_template_version_id'),
-                name=json_dom.get('name'),
-                content=json_dom.get('content'),
-                flavor_name=json_dom.get('metadata').get('flavor_name'),
-                params=json_dom.get('metadata').get('params')
-            ))
+            prompt_list.append(self.__render_into_v2(json_dom))
 
         return PromptTemplates(prompt_list)
 
@@ -144,38 +165,59 @@ class FilesystemTemplateResolver(TemplateResolver):
             )
 
         json_dom = json.loads(expected_file.read_text())
+        return self.__render_into_v2(json_dom)
 
+    @staticmethod
+    def __render_into_v2(json_dom: Dict[str, Any]) -> PromptTemplate:
         format_version = json_dom.get('format_version')
 
         if format_version == 2:
-            raise NotImplementedError("Cannot yet handle new format bundled prompts")
-
-        flavor_name = json_dom.get('metadata').get('flavor_name')
-        flavor = Flavor.get_by_name(flavor_name)
-
-        params = json_dom.get('metadata').get('params')
-        model = params.pop('model') if 'model' in params else None
-
-        return PromptTemplate(
-            format_version=2,
-            prompt_template_id=json_dom.get('prompt_template_id'),
-            prompt_template_version_id=json_dom.get('prompt_template_version_id'),
-            prompt_template_name=json_dom.get('name'),
-            content=FilesystemTemplateResolver.__normalize_roles(json.loads(json_dom.get('content'))),  # type: ignore
-            metadata=PromptTemplateMetadata(
-                provider=flavor.provider,
-                flavor=flavor_name,
-                model=model,
-                params=params
+            metadata = json_dom['metadata']
+            flavor_name = metadata.get('flavor')
+            model = metadata.get('model')
+
+            return PromptTemplate(
+                format_version=2,
+                prompt_template_id=json_dom.get('prompt_template_id'),  # type: ignore
+                prompt_template_version_id=json_dom.get('prompt_template_version_id'),  # type: ignore
+                prompt_template_name=json_dom.get('prompt_template_name'),  # type: ignore
+                content=FilesystemTemplateResolver.__normalize_roles(json_dom['content']),
+                metadata=PromptTemplateMetadata(
+                    provider=FilesystemTemplateResolver.__flavor_to_provider(flavor_name),
+                    flavor=flavor_name,
+                    model=model,
+                    params=metadata.get('params'),
+                    provider_info=metadata.get('provider_info')
+                )
+            )
+        else:
+            metadata = json_dom['metadata']
+
+            flavor_name = metadata.get('flavor_name')
+            params = metadata.get('params')
+            model = params.pop('model') if 'model' in params else None
+
+            return PromptTemplate(
+                format_version=2,
+                prompt_template_id=json_dom.get('prompt_template_id'),  # type: ignore
+                prompt_template_version_id=json_dom.get('prompt_template_version_id'),  # type: ignore
+                prompt_template_name=json_dom.get('name'),  # type: ignore
+                content=FilesystemTemplateResolver.__normalize_roles(json.loads(str(json_dom['content']))),
+                metadata=PromptTemplateMetadata(
+                    provider=FilesystemTemplateResolver.__flavor_to_provider(flavor_name),
+                    flavor=flavor_name,
+                    model=model,
+                    params=params,
+                    provider_info=None
+                )
             )
-        )
 
     @staticmethod
-    def __normalize_roles(messages: List[ChatMessage]) -> List[ChatMessage]:
+    def __normalize_roles(messages: List[Dict[str, str]]) -> List[Dict[str, str]]:
         normalized = []
         for message in messages:
             role = FilesystemTemplateResolver.__role_translations.get(message['role']) or message['role']
-            normalized.append(ChatMessage(role=role, content=message['content']))
+            normalized.append({'role': role, 'content': message['content']})
         return normalized
 
     @staticmethod
@@ -200,6 +242,18 @@ class FilesystemTemplateResolver(TemplateResolver):
                 (project_id, environment)
             )
 
+    @staticmethod
+    def __flavor_to_provider(flavor: str) -> str:
+        flavor_provider = {
+            'azure_openai_chat': 'azure',
+            'anthropic_chat': 'anthropic',
+            'openai_chat': 'openai',
+        }
+        provider = flavor_provider.get(flavor)
+        if not provider:
+            raise MissingFlavorError(flavor)
+        return provider
+
 
 class APITemplateResolver(TemplateResolver):
 
@@ -209,7 +263,7 @@ class APITemplateResolver(TemplateResolver):
     def get_prompts(self, project_id: str, environment: str) -> PromptTemplates:
         return self.call_support.get_prompts(
             project_id=project_id,
-            tag=environment
+            environment=environment
         )
 
     def get_prompt(self, project_id: str, template_name: str, environment: str) -> PromptTemplate:
@@ -226,7 +280,7 @@ class Prompts:
         self.template_resolver = template_resolver
 
     def get_all(self, project_id: str, environment: str) -> PromptTemplates:
-        return self.call_support.get_prompts(project_id=project_id, tag=environment)
+        return self.call_support.get_prompts(project_id=project_id, environment=environment)
 
     def get(self, project_id: str, template_name: str, environment: str) -> TemplatePrompt:
         prompt = self.template_resolver.get_prompt(project_id, template_name, environment)
@@ -242,7 +296,9 @@ class Prompts:
             raise FreeplayConfigurationError(
                 "Flavor must be configured in the Freeplay UI. Unable to fulfill request.")
 
-        flavor = Flavor.get_by_name(prompt.metadata.flavor)
+        if not prompt.metadata.provider:
+            raise FreeplayConfigurationError(
+                "Provider must be configured in the Freeplay UI. Unable to fulfill request.")
 
         prompt_info = PromptInfo(
             prompt_template_id=prompt.prompt_template_id,
@@ -250,7 +306,7 @@ class Prompts:
             template_name=prompt.prompt_template_name,
             environment=environment,
             model_parameters=cast(LLMParameters, params) or LLMParameters({}),
-            provider=flavor.provider,
+            provider=prompt.metadata.provider,
             model=model,
             flavor_name=prompt.metadata.flavor,
             provider_info=prompt.metadata.provider_info

{freeplay-0.2.42/src/freeplay/thin → freeplay-0.3.0a2/src/freeplay}/resources/recordings.py

@@ -6,13 +6,12 @@ from typing import Dict, Optional, List
 from requests import HTTPError
 
 from freeplay import api_support
-from freeplay.completions import PromptTemplateWithMetadata, OpenAIFunctionCall
 from freeplay.errors import FreeplayClientError, FreeplayError
 from freeplay.llm_parameters import LLMParameters
-from freeplay.model import InputVariables
+from freeplay.model import InputVariables, OpenAIFunctionCall
+from freeplay.resources.prompts import PromptInfo
+from freeplay.resources.sessions import SessionInfo
 from freeplay.support import CallSupport
-from freeplay.thin.resources.prompts import PromptInfo
-from freeplay.thin.resources.sessions import SessionInfo
 
 logger = logging.getLogger(__name__)
 
@@ -79,19 +78,10 @@ class Recordings:
         completion = record_payload.all_messages[-1]
         history_as_string = json.dumps(record_payload.all_messages[0:-1])
 
-        template = PromptTemplateWithMetadata(
-            prompt_template_id=record_payload.prompt_info.prompt_template_id,
-            prompt_template_version_id=record_payload.prompt_info.prompt_template_version_id,
-            name=record_payload.prompt_info.template_name,
-            content=history_as_string,
-            flavor_name=record_payload.prompt_info.flavor_name,
-            params=record_payload.prompt_info.model_parameters
-        )
-
         record_api_payload = {
             "session_id": record_payload.session_info.session_id,
-            "project_version_id": template.prompt_template_version_id,
-            "prompt_template_id": template.prompt_template_id,
+            "prompt_template_id": record_payload.prompt_info.prompt_template_id,
+            "project_version_id": record_payload.prompt_info.prompt_template_version_id,
             "start_time": record_payload.call_info.start_time,
             "end_time": record_payload.call_info.end_time,
             "tag": record_payload.prompt_info.environment,

{freeplay-0.2.42/src/freeplay/thin → freeplay-0.3.0a2/src/freeplay}/resources/test_runs.py

@@ -2,8 +2,8 @@ from dataclasses import dataclass
 from typing import List, Optional
 
 from freeplay.model import InputVariables
+from freeplay.resources.recordings import TestRunInfo
 from freeplay.support import CallSupport
-from freeplay.thin.resources.recordings import TestRunInfo
 
 
 @dataclass

freeplay-0.3.0a2/src/freeplay/support.py

@@ -0,0 +1,142 @@
+from dataclasses import dataclass
+from json import JSONEncoder
+from typing import Optional, Dict, Any, List, Union
+
+from freeplay import api_support
+from freeplay.api_support import try_decode
+from freeplay.errors import freeplay_response_error, FreeplayServerError
+from freeplay.model import InputVariables
+
+
+@dataclass
+class PromptTemplateMetadata:
+    provider: Optional[str]
+    flavor: Optional[str]
+    model: Optional[str]
+    params: Optional[Dict[str, Any]] = None
+    provider_info: Optional[Dict[str, Any]] = None
+
+
+@dataclass
+class PromptTemplate:
+    prompt_template_id: str
+    prompt_template_version_id: str
+    prompt_template_name: str
+    content: List[Dict[str, str]]
+    metadata: PromptTemplateMetadata
+    format_version: int
+
+
+@dataclass
+class PromptTemplates:
+    prompt_templates: List[PromptTemplate]
+
+
+class PromptTemplateEncoder(JSONEncoder):
+    def default(self, prompt_template: PromptTemplate) -> Dict[str, Any]:
+        return prompt_template.__dict__
+
+
+class TestCaseTestRunResponse:
+    def __init__(self, test_case: Dict[str, Any]):
+        self.variables: InputVariables = test_case['variables']
+        self.id: str = test_case['id']
+        self.output: Optional[str] = test_case.get('output')
+
+
+class TestRunResponse:
+    def __init__(
+            self,
+            test_run_id: str,
+            test_cases: List[Dict[str, Any]]
+    ):
+        self.test_cases = [
+            TestCaseTestRunResponse(test_case)
+            for test_case in test_cases
+        ]
+        self.test_run_id = test_run_id
+
+
+class CallSupport:
+    def __init__(
+            self,
+            freeplay_api_key: str,
+            api_base: str
+    ) -> None:
+        self.api_base = api_base
+        self.freeplay_api_key = freeplay_api_key
+
+    def get_prompts(self, project_id: str, environment: str) -> PromptTemplates:
+        response = api_support.get_raw(
+            api_key=self.freeplay_api_key,
+            url=f'{self.api_base}/v2/projects/{project_id}/prompt-templates/all/{environment}'
+        )
+
+        if response.status_code != 200:
+            raise freeplay_response_error("Error getting prompt templates", response)
+
+        maybe_prompts = try_decode(PromptTemplates, response.content)
+        if maybe_prompts is None:
+            raise FreeplayServerError('Failed to parse prompt templates from server')
+
+        return maybe_prompts
+
+    def get_prompt(self, project_id: str, template_name: str, environment: str) -> PromptTemplate:
+        response = api_support.get_raw(
+            api_key=self.freeplay_api_key,
+            url=f'{self.api_base}/v2/projects/{project_id}/prompt-templates/name/{template_name}',
+            params={
+                'environment': environment
+            }
+        )
+
+        if response.status_code != 200:
+            raise freeplay_response_error(
+                f"Error getting prompt template {template_name} in project {project_id} "
+                f"and environment {environment}",
+                response
+            )
+
+        maybe_prompt = try_decode(PromptTemplate, response.content)
+        if maybe_prompt is None:
+            raise FreeplayServerError(
+                f"Error handling prompt {template_name} in project {project_id} "
+                f"and environment {environment}"
+            )
+
+        return maybe_prompt
+
+    def update_customer_feedback(
+            self,
+            completion_id: str,
+            feedback: Dict[str, Union[bool, str, int, float]]
+    ) -> None:
+        response = api_support.put_raw(
+            self.freeplay_api_key,
+            f'{self.api_base}/v1/completion_feedback/{completion_id}',
+            feedback
+        )
+        if response.status_code != 201:
+            raise freeplay_response_error("Error updating customer feedback", response)
+
+    def create_test_run(
+            self,
+            project_id: str,
+            testlist: str,
+            include_test_case_outputs: bool = False
+    ) -> TestRunResponse:
+        response = api_support.post_raw(
+            api_key=self.freeplay_api_key,
+            url=f'{self.api_base}/projects/{project_id}/test-runs-cases',
+            payload={
+                'testlist_name': testlist,
+                'include_test_case_outputs': include_test_case_outputs,
+            },
+        )
+
+        if response.status_code != 201:
+            raise freeplay_response_error('Error while creating a test run.', response)
+
+        json_dom = response.json()
+
+        return TestRunResponse(json_dom['test_run_id'], json_dom['test_cases'])

{freeplay-0.2.42 → freeplay-0.3.0a2}/src/freeplay/utils.py

@@ -1,19 +1,27 @@
-from typing import Dict, Union, Optional
+from typing import Dict, Union, Optional, Any
 import importlib.metadata
 import platform
 
 import pystache  # type: ignore
-from pydantic import ValidationError
 
 from .errors import FreeplayError, FreeplayConfigurationError
-from .model import PydanticInputVariables, InputVariables
+from .model import InputVariables
+
+
+# Validate that the variables are of the correct type, and do not include functions, dates, classes or None values.
+def all_valid(obj: Any) -> bool:
+    if isinstance(obj, (int, str, bool)):
+        return True
+    elif isinstance(obj, list):
+        return all(all_valid(item) for item in obj)
+    elif isinstance(obj, dict):
+        return all(isinstance(key, str) and all_valid(value) for key, value in obj.items())
+    else:
+        return False
 
 
 def bind_template_variables(template: str, variables: InputVariables) -> 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:
+    if not all_valid(variables):
         raise FreeplayError(
             'Variables must be a string, number, bool, or a possibly nested'
             ' list or dict of strings, numbers and booleans.'

freeplay-0.2.42/src/freeplay/__init__.py

@@ -1,5 +0,0 @@
-from .freeplay import Freeplay
-
-__all__ = [
-    'Freeplay'
-]