Remove the populate_template utility to favor the API call /prompt/populate.Ï

Author: olehvell-h

src/humanloop/client.py

@@ -25,8 +25,6 @@
 from humanloop.otel import instrument_provider
 from humanloop.otel.exporter import HumanloopSpanExporter
 from humanloop.otel.processor import HumanloopSpanProcessor
-from humanloop.prompt_utils import populate_template
-from humanloop.prompts.client import PromptsClient
 from humanloop.requests.flow_kernel_request import FlowKernelRequestParams
 from humanloop.requests.tool_kernel_request import ToolKernelRequestParams
 
@@ -74,10 +72,6 @@ def run(
         )
 
 
-class ExtendedPromptsClient(PromptsClient):
-    populate_template = staticmethod(populate_template)
-
-
 class Humanloop(BaseHumanloop):
     """
     See docstring of :class:`BaseHumanloop`.
@@ -128,7 +122,6 @@ def __init__(
         )
         eval_client.client = self
         self.evaluations = eval_client
-        self.prompts = ExtendedPromptsClient(client_wrapper=self._client_wrapper)
 
         # Overload the .log method of the clients to be aware of Evaluation Context
         # TODO: Overload the log for Evaluators and Tools once run_id is added

src/humanloop/prompt_utils.py

@@ -1,14 +1,7 @@
 import copy
-from typing import Any, Dict, List, Optional, TypeVar, Sequence
+from typing import List
 import logging
 
-import re
-
-from .requests.chat_message import ChatMessageParams
-from .prompts.requests.prompt_request_template import (
-    PromptRequestTemplateParams,
-)
-
 
 logger = logging.getLogger(__name__)
 
@@ -21,138 +14,4 @@ class PromptVariablesNotFoundError(ValueError):
 
     def __init__(self, missing_variables: List[str]) -> None:
         self.missing_variables = missing_variables
-        super().__init__(f"Prompt requires inputs for the following " f"variables: {self.missing_variables}")
-
-
-def populate_prompt_template(
-    template: str,
-    inputs: Optional[Dict[str, Any]],
-) -> str:
-    """Interpolate a string template with kwargs, where template variables
-    are specified using double curly bracket syntax: {{variable}}.
-
-    args:
-        template: str - string template where template variables are specified
-        using double curly bracket syntax: {{variable}}.
-
-        inputs - represent the key, value string pairs to inject into the template
-        variables, where key corresponds to the template variable name and
-        value to the variable value to inject
-
-    return:
-        The interpolated template string
-
-    raises:
-        PromptVariablesNotFoundError - if any variables are missing from inputs
-    """
-    template_variables: List[str] = re.findall(
-        # Matching variables: `{{ variable_2 }}`
-        r"{{\s?([a-zA-Z_\d\.\[\]]+)\s?}}",
-        template,
-    ) + re.findall(
-        # Matching tools: `{{ tool_2("all characters$#@$!") }}`
-        # https://regexr.com/7nvrf
-        r"\{\{\s?([a-zA-Z_\-\d]+\([a-zA-Z_\-\d,\s\"]+\))\s?\}\}",
-        template,
-    )
-
-    # populate the template variables, tracking if any are missing
-    prompt = template
-    missing_vars = []
-
-    if inputs is None:
-        inputs = {}
-
-    # e.g. var: input_name, sig(input_name), sig(other_name), sig("string")
-    for var in template_variables:
-        text: Optional[str] = None
-
-        if var in inputs:
-            text = inputs[var]
-
-        if text is None:
-            missing_vars.append(var)
-        else:
-            if not isinstance(text, str):
-                logger.info(f"Converting input value for variable '{var}' to string for prompt template: " f"{text}")
-                text = str(text)
-            replacement = sanitize_prompt(prompt=text) if text else text
-            prompt = re.sub(
-                r"{{\s?" + re.escape(var) + r"\s?}}",
-                replacement,
-                prompt,
-            )
-
-    if missing_vars:
-        missing_vars.sort()
-        raise PromptVariablesNotFoundError(
-            missing_variables=missing_vars,
-        )
-
-    return prompt
-
-
-def sanitize_prompt(prompt: str):
-    return prompt.replace("\\", "\\\\")
-
-
-def populate_chat_template(
-    chat_template: Sequence[ChatMessageParams],
-    inputs: Optional[Dict[str, str]] = None,
-) -> List[ChatMessageParams]:
-    """Interpolate a chat template with kwargs, where template variables."""
-    messages = []
-    message: ChatMessageParams
-    for message in chat_template:
-        if "content" not in message:
-            messages.append(message)
-            continue
-
-        message_content = copy.deepcopy(message["content"])
-        if isinstance(message_content, str):
-            message_content = populate_prompt_template(
-                template=message_content,
-                inputs=inputs,
-            )
-        elif isinstance(message_content, list):
-            for j, content_item in enumerate(message_content):
-                if content_item["type"] == "text":
-                    content_item_text = content_item["text"]
-                    (content_item_text,) = populate_prompt_template(
-                        template=content_item_text,
-                        inputs=inputs,
-                    )
-                    content_item["text"] = content_item_text
-        messages.append(
-            ChatMessageParams(
-                role=message["role"],
-                content=message_content,
-            )
-        )
-    return messages
-
-
-T = TypeVar("T", bound=PromptRequestTemplateParams)
-
-
-def populate_template(template: T, inputs: Dict[str, str]) -> T:
-    """Populate a Prompt's template with the given inputs.
-
-    Humanloop supports insertion of variables of the form `{{variable}}` in
-    Prompt templates.
-    E.g. If you provide the template `Hello {{name}}` and the input
-    `{"name": "Alice"}`, the populated template will be `Hello Alice`.
-
-    This function supports both completion and chat models. For completion
-    models, provide template as a string. For chat models, provide template
-    as a list of messages.
-    """
-    if isinstance(template, str):
-        return populate_prompt_template(
-            template=template,
-            inputs=inputs,
-        )
-    return populate_chat_template(
-        chat_template=template,
-        inputs=inputs,
-    )
+        super().__init__(f"Prompt requires inputs for the following variables: {self.missing_variables}")