opik 1.9.5__py3-none-any.whl → 1.9.39__py3-none-any.whl

opik/api_objects/prompt/chat_prompt_template.py

@@ -1,164 +0,0 @@
-"""
-Tools for rendering chat-style prompts with multimodal content.
-
-The template mirrors :class:`PromptTemplate` but works on a list of OpenAI-like
-messages. Rendering is handled by a registry of part renderers so additional
-modalities can be plugged in without changing the core implementation.
-"""
-
-from __future__ import annotations
-
-from typing import Any, Dict, List, Optional, Union, cast
-
-from .prompt_template import PromptTemplate
-from .types import (
-    PromptType,
-    MessageContent,
-    ContentPart,
-    SupportedModalities,
-    ModalitySet,
-)
-from .chat_content_renderer_registry import (
-    ChatContentRendererRegistry,
-    DEFAULT_CHAT_RENDERER_REGISTRY,
-    register_default_chat_part_renderer,
-)
-
-
-class ChatPromptTemplate:
-    """
-    Prompt template for chat-style prompts with multimodal content.
-    """
-
-    def __init__(
-        self,
-        messages: List[Dict[str, MessageContent]],
-        template_type: PromptType = PromptType.MUSTACHE,
-        *,
-        registry: Optional[ChatContentRendererRegistry] = None,
-    ) -> None:
-        self._messages = messages
-        self._template_type = template_type
-        self._registry = registry or DEFAULT_CHAT_RENDERER_REGISTRY
-
-    @property
-    def messages(self) -> List[Dict[str, MessageContent]]:
-        return self._messages
-
-    def required_modalities(self) -> ModalitySet:
-        """
-        Return the union of modalities referenced across all template messages.
-        """
-        required: ModalitySet = set()
-        for message in self._messages:
-            content = cast(MessageContent, message.get("content", ""))
-            required.update(self._registry.infer_modalities(content))
-        return required
-
-    def format(
-        self,
-        variables: Dict[str, Any],
-        supported_modalities: Optional[SupportedModalities] = None,
-        *,
-        template_type: Optional[Union[str, PromptType]] = None,
-    ) -> List[Dict[str, MessageContent]]:
-        """
-        Render the template messages with the provided variables.
-
-        When a part declares a modality that is not supported, the registry replaces
-        it with the configured placeholder pair (for example ``<<<image>>>``) so
-        downstream consumers receive a textual anchor while unsupported structured
-        content is gracefully elided.
-        """
-        resolved_template_type = self._registry.normalize_template_type(
-            template_type or self._template_type
-        )
-        rendered_messages: List[Dict[str, MessageContent]] = []
-
-        for message in self._messages:
-            role = message.get("role")
-            if role is None:
-                continue
-
-            content = cast(MessageContent, message.get("content", ""))
-            rendered_content: MessageContent
-            if isinstance(content, str):
-                rendered_content = _render_template_string(
-                    content, variables, resolved_template_type
-                )
-            else:
-                rendered_content = self._registry.render_content(
-                    content=cast(MessageContent, content),
-                    variables=variables,
-                    template_type=resolved_template_type,
-                    supported_modalities=supported_modalities,
-                )
-            rendered_messages.append(
-                {
-                    "role": role,
-                    "content": rendered_content,
-                }
-            )
-
-        return rendered_messages
-
-
-def _render_template_string(
-    template: str,
-    variables: Dict[str, Any],
-    template_type: PromptType,
-) -> str:
-    if not template:
-        return ""
-
-    try:
-        return PromptTemplate(
-            template,
-            validate_placeholders=False,
-            type=template_type,
-        ).format(**variables)
-    except Exception:
-        # Fall back to the raw template if formatting fails so evaluation keeps running.
-        return template
-
-
-def render_text_part(
-    part: ContentPart, variables: Dict[str, Any], template_type: PromptType
-) -> Optional[ContentPart]:
-    text_template = part.get("text", "")
-    rendered_text = _render_template_string(text_template, variables, template_type)
-    return {"type": "text", "text": rendered_text}
-
-
-def render_image_url_part(
-    part: ContentPart, variables: Dict[str, Any], template_type: PromptType
-) -> Optional[ContentPart]:
-    image_dict = part.get("image_url", {})
-    if not isinstance(image_dict, dict):
-        return None
-
-    url_template = image_dict.get("url", "")
-    rendered_url = _render_template_string(url_template, variables, template_type)
-    if not rendered_url:
-        return None
-
-    rendered_image: Dict[str, Any] = {"url": rendered_url}
-    if "detail" in image_dict:
-        rendered_image["detail"] = image_dict["detail"]
-
-    return {"type": "image_url", "image_url": rendered_image}
-
-
-register_default_chat_part_renderer("text", render_text_part)
-register_default_chat_part_renderer(
-    "image_url",
-    render_image_url_part,
-    modality="vision",
-    placeholder=("<<<image>>>", "<<</image>>>"),
-)
-
-
-__all__ = [
-    "ChatPromptTemplate",
-    "register_default_chat_part_renderer",
-]

opik/api_objects/prompt/prompt.py

@@ -1,131 +0,0 @@
-import copy
-from typing import Any, Dict, Optional
-
-from opik.rest_api.types import PromptVersionDetail
-from .prompt_template import PromptTemplate
-from .types import PromptType
-from opik.api_objects.prompt import client as prompt_client
-
-
-class Prompt:
-    """
-    Prompt class represents a prompt with a name, prompt text/template and commit hash.
-    """
-
-    def __init__(
-        self,
-        name: str,
-        prompt: str,
-        metadata: Optional[Dict[str, Any]] = None,
-        type: PromptType = PromptType.MUSTACHE,
-    ) -> None:
-        """
-        Initializes a new instance of the class with the given parameters.
-        Creates a new prompt using the opik client and sets the initial state of the instance attributes based on the created prompt.
-
-        Parameters:
-            name: The name for the prompt.
-            prompt: The template for the prompt.
-        """
-
-        self._template = PromptTemplate(template=prompt, type=type)
-        self._name = name
-        self._metadata = metadata
-        self._type = type
-
-        self._sync_with_backend()
-
-    def _sync_with_backend(self) -> None:
-        from opik.api_objects import opik_client
-
-        opik_client_ = opik_client.get_client_cached()
-        prompt_client_ = prompt_client.PromptClient(opik_client_.rest_client)
-        prompt_version = prompt_client_.create_prompt(
-            name=self._name,
-            prompt=self._template.text,
-            metadata=self._metadata,
-            type=self._type,
-        )
-
-        self._commit = prompt_version.commit
-        self.__internal_api__prompt_id__ = prompt_version.prompt_id
-        self.__internal_api__version_id__ = prompt_version.id
-
-    @property
-    def name(self) -> str:
-        """The name of the prompt."""
-        return self._name
-
-    @property
-    def prompt(self) -> str:
-        """The latest template of the prompt."""
-        return str(self._template)
-
-    @property
-    def commit(self) -> Optional[str]:
-        """The commit hash of the prompt."""
-        return self._commit
-
-    @property
-    def metadata(self) -> Optional[Dict[str, Any]]:
-        """The metadata dictionary associated with the prompt"""
-        return copy.deepcopy(self._metadata)
-
-    @property
-    def type(self) -> PromptType:
-        """The prompt type of the prompt."""
-        return self._type
-
-    def format(self, **kwargs: Any) -> str:
-        """
-        Replaces placeholders in the template with provided keyword arguments.
-
-        Args:
-            **kwargs: Arbitrary keyword arguments where the key represents the placeholder
-                      in the template and the value is the value to replace the placeholder with.
-
-        Returns:
-            A string with all placeholders replaced by their corresponding values from kwargs.
-        """
-        return self._template.format(**kwargs)
-
-    @classmethod
-    def from_fern_prompt_version(
-        cls,
-        name: str,
-        prompt_version: PromptVersionDetail,
-    ) -> "Prompt":
-        # will not call __init__ to avoid API calls, create new instance with __new__
-        prompt = cls.__new__(cls)
-
-        prompt.__internal_api__version_id__ = prompt_version.id
-        prompt.__internal_api__prompt_id__ = prompt_version.prompt_id
-
-        prompt._name = name
-        prompt._template = PromptTemplate(
-            template=prompt_version.template,
-            type=PromptType(prompt_version.type) or PromptType.MUSTACHE,
-        )
-        prompt._commit = prompt_version.commit
-        prompt._metadata = prompt_version.metadata
-        prompt._type = prompt_version.type
-        return prompt
-
-
-def to_info_dict(prompt: Prompt) -> Dict[str, Any]:
-    info_dict: Dict[str, Any] = {
-        "name": prompt.name,
-        "version": {
-            "template": prompt.prompt,
-        },
-    }
-    if prompt.__internal_api__prompt_id__ is not None:
-        info_dict["id"] = prompt.__internal_api__prompt_id__
-
-    if prompt.commit is not None:
-        info_dict["version"]["commit"] = prompt.commit
-
-    if prompt.__internal_api__version_id__ is not None:
-        info_dict["version"]["id"] = prompt.__internal_api__version_id__
-
-    return info_dict