promptlayer 1.0.16__py3-none-any.whl → 1.0.78__py3-none-any.whl

promptlayer/streaming/stream_processor.py

@@ -0,0 +1,106 @@
+from typing import Any, AsyncGenerator, AsyncIterable, Callable, Dict, Generator
+
+from .blueprint_builder import (
+    build_prompt_blueprint_from_anthropic_event,
+    build_prompt_blueprint_from_bedrock_event,
+    build_prompt_blueprint_from_google_event,
+    build_prompt_blueprint_from_openai_chunk,
+    build_prompt_blueprint_from_openai_responses_event,
+)
+
+
+def _build_stream_blueprint(result: Any, metadata: Dict) -> Any:
+    model_info = metadata.get("model", {}) if metadata else {}
+    provider = model_info.get("provider", "")
+    model_name = model_info.get("name", "")
+
+    if provider == "openai" or provider == "openai.azure":
+        api_type = model_info.get("api_type", "chat-completions") if metadata else "chat-completions"
+        if api_type == "chat-completions":
+            return build_prompt_blueprint_from_openai_chunk(result, metadata)
+        elif api_type == "responses":
+            return build_prompt_blueprint_from_openai_responses_event(result, metadata)
+
+    elif provider == "google" or (provider == "vertexai" and model_name.startswith("gemini")):
+        return build_prompt_blueprint_from_google_event(result, metadata)
+
+    elif provider in ("anthropic", "anthropic.bedrock") or (provider == "vertexai" and model_name.startswith("claude")):
+        return build_prompt_blueprint_from_anthropic_event(result, metadata)
+
+    elif provider == "mistral":
+        return build_prompt_blueprint_from_openai_chunk(result.data, metadata)
+
+    elif provider == "amazon.bedrock":
+        return build_prompt_blueprint_from_bedrock_event(result, metadata)
+
+    return None
+
+
+def _build_stream_data(result: Any, stream_blueprint: Any, request_id: Any = None) -> Dict[str, Any]:
+    return {
+        "request_id": request_id,
+        "raw_response": result,
+        "prompt_blueprint": stream_blueprint,
+    }
+
+
+def stream_response(*, generator: Generator, after_stream: Callable, map_results: Callable, metadata: Dict):
+    results = []
+    provider = metadata.get("model", {}).get("provider", "")
+    if provider == "amazon.bedrock":
+        response_metadata = generator.get("ResponseMetadata", {})
+        generator = generator.get("stream", generator)
+
+    for result in generator:
+        results.append(result)
+
+        stream_blueprint = _build_stream_blueprint(result, metadata)
+        data = _build_stream_data(result, stream_blueprint)
+        yield data
+
+    request_response = map_results(results)
+    if provider == "amazon.bedrock":
+        request_response["ResponseMetadata"] = response_metadata
+    else:
+        request_response = request_response.model_dump(mode="json")
+
+    response = after_stream(request_response=request_response)
+    data["request_id"] = response.get("request_id")
+    data["prompt_blueprint"] = response.get("prompt_blueprint")
+    yield data
+
+
+async def astream_response(
+    generator: AsyncIterable[Any],
+    after_stream: Callable[..., Any],
+    map_results: Callable[[Any], Any],
+    metadata: Dict[str, Any] = None,
+) -> AsyncGenerator[Dict[str, Any], None]:
+    results = []
+    provider = metadata.get("model", {}).get("provider", "")
+    if provider == "amazon.bedrock":
+        response_metadata = generator.get("ResponseMetadata", {})
+        generator = generator.get("stream", generator)
+
+    async for result in generator:
+        results.append(result)
+
+        stream_blueprint = _build_stream_blueprint(result, metadata)
+        data = _build_stream_data(result, stream_blueprint)
+        yield data
+
+    async def async_generator_from_list(lst):
+        for item in lst:
+            yield item
+
+    request_response = await map_results(async_generator_from_list(results))
+
+    if provider == "amazon.bedrock":
+        request_response["ResponseMetadata"] = response_metadata
+    else:
+        request_response = request_response.model_dump(mode="json")
+
+    after_stream_response = await after_stream(request_response=request_response)
+    data["request_id"] = after_stream_response.get("request_id")
+    data["prompt_blueprint"] = after_stream_response.get("prompt_blueprint")
+    yield data

promptlayer/templates.py

@@ -2,6 +2,8 @@ from typing import Union
 
 from promptlayer.types.prompt_template import GetPromptTemplate, PublishPromptTemplate
 from promptlayer.utils import (
+    aget_all_prompt_templates,
+    aget_prompt_template,
     get_all_prompt_templates,
     get_prompt_template,
     publish_prompt_template,
@@ -9,14 +11,29 @@ from promptlayer.utils import (
 
 
 class TemplateManager:
-    def __init__(self, api_key: str):
+    def __init__(self, api_key: str, base_url: str, throw_on_error: bool):
         self.api_key = api_key
+        self.base_url = base_url
+        self.throw_on_error = throw_on_error
 
     def get(self, prompt_name: str, params: Union[GetPromptTemplate, None] = None):
-        return get_prompt_template(prompt_name, params, self.api_key)
+        return get_prompt_template(self.api_key, self.base_url, self.throw_on_error, prompt_name, params)
 
     def publish(self, body: PublishPromptTemplate):
-        return publish_prompt_template(body, self.api_key)
+        return publish_prompt_template(self.api_key, self.base_url, self.throw_on_error, body)
 
-    def all(self, page: int = 1, per_page: int = 30):
-        return get_all_prompt_templates(page, per_page, self.api_key)
+    def all(self, page: int = 1, per_page: int = 30, label: str = None):
+        return get_all_prompt_templates(self.api_key, self.base_url, self.throw_on_error, page, per_page, label)
+
+
+class AsyncTemplateManager:
+    def __init__(self, api_key: str, base_url: str, throw_on_error: bool):
+        self.api_key = api_key
+        self.base_url = base_url
+        self.throw_on_error = throw_on_error
+
+    async def get(self, prompt_name: str, params: Union[GetPromptTemplate, None] = None):
+        return await aget_prompt_template(self.api_key, self.base_url, self.throw_on_error, prompt_name, params)
+
+    async def all(self, page: int = 1, per_page: int = 30, label: str = None):
+        return await aget_all_prompt_templates(self.api_key, self.base_url, self.throw_on_error, page, per_page, label)

promptlayer/track/__init__.py

@@ -1,33 +1,71 @@
-from promptlayer.track.track import group
-from promptlayer.track.track import metadata as metadata_
-from promptlayer.track.track import prompt
-from promptlayer.track.track import score as score_
+from promptlayer.track.track import (
+    agroup,
+    ametadata,
+    aprompt,
+    ascore,
+    group,
+    metadata as metadata_,
+    prompt,
+    score as score_,
+)
+
+# TODO(dmu) LOW: Move this code to another file
 
 
 class TrackManager:
-    def __init__(self, api_key: str):
+    def __init__(self, api_key: str, base_url: str, throw_on_error: bool):
         self.api_key = api_key
+        self.base_url = base_url
+        self.throw_on_error = throw_on_error
 
     def group(self, request_id, group_id):
-        return group(request_id, group_id, self.api_key)
+        return group(self.api_key, self.base_url, self.throw_on_error, request_id, group_id)
 
     def metadata(self, request_id, metadata):
-        return metadata_(request_id, metadata, self.api_key)
+        return metadata_(self.api_key, self.base_url, self.throw_on_error, request_id, metadata)
 
-    def prompt(
-        self, request_id, prompt_name, prompt_input_variables, version=None, label=None
-    ):
+    def prompt(self, request_id, prompt_name, prompt_input_variables, version=None, label=None):
         return prompt(
+            self.api_key,
+            self.base_url,
+            self.throw_on_error,
             request_id,
             prompt_name,
             prompt_input_variables,
             version,
             label,
-            self.api_key,
         )
 
     def score(self, request_id, score, score_name=None):
-        return score_(request_id, score, score_name, self.api_key)
+        return score_(self.api_key, self.base_url, self.throw_on_error, request_id, score, score_name)
+
+
+class AsyncTrackManager:
+    def __init__(self, api_key: str, base_url: str, throw_on_error: bool):
+        self.api_key = api_key
+        self.base_url = base_url
+        self.throw_on_error = throw_on_error
+
+    async def group(self, request_id, group_id):
+        return await agroup(self.api_key, self.base_url, self.throw_on_error, request_id, group_id)
+
+    async def metadata(self, request_id, metadata):
+        return await ametadata(self.api_key, self.base_url, self.throw_on_error, request_id, metadata)
+
+    async def prompt(self, request_id, prompt_name, prompt_input_variables, version=None, label=None):
+        return await aprompt(
+            self.api_key,
+            self.base_url,
+            self.throw_on_error,
+            request_id,
+            prompt_name,
+            prompt_input_variables,
+            version,
+            label,
+        )
+
+    async def score(self, request_id, score, score_name=None):
+        return await ascore(self.api_key, self.base_url, self.throw_on_error, request_id, score, score_name)
 
 
 __all__ = ["TrackManager"]

promptlayer/track/track.py

@@ -1,4 +1,9 @@
+from promptlayer import exceptions as _exceptions
 from promptlayer.utils import (
+    apromptlayer_track_group,
+    apromptlayer_track_metadata,
+    apromptlayer_track_prompt,
+    apromptlayer_track_score,
     promptlayer_track_group,
     promptlayer_track_metadata,
     promptlayer_track_prompt,
@@ -7,40 +12,96 @@ from promptlayer.utils import (
 
 
 def prompt(
+    api_key: str,
+    base_url: str,
+    throw_on_error: bool,
     request_id,
     prompt_name,
     prompt_input_variables,
     version=None,
     label=None,
-    api_key: str = None,
 ):
     if not isinstance(prompt_input_variables, dict):
-        raise Exception("Please provide a dictionary of input variables.")
+        raise _exceptions.PromptLayerValidationError(
+            "Please provide a dictionary of input variables.", response=None, body=None
+        )
     return promptlayer_track_prompt(
-        request_id, prompt_name, prompt_input_variables, api_key, version, label
+        api_key, base_url, throw_on_error, request_id, prompt_name, prompt_input_variables, api_key, version, label
     )
 
 
-def metadata(request_id, metadata, api_key: str = None):
+def metadata(api_key: str, base_url: str, throw_on_error: bool, request_id, metadata):
     if not isinstance(metadata, dict):
-        raise Exception("Please provide a dictionary of metadata.")
+        raise _exceptions.PromptLayerValidationError(
+            "Please provide a dictionary of metadata.", response=None, body=None
+        )
     for key, value in metadata.items():
         if not isinstance(key, str) or not isinstance(value, str):
-            raise Exception(
-                "Please provide a dictionary of metadata with key value pair of strings."
+            raise _exceptions.PromptLayerValidationError(
+                "Please provide a dictionary of metadata with key value pair of strings.", response=None, body=None
             )
-    return promptlayer_track_metadata(request_id, metadata, api_key)
+    return promptlayer_track_metadata(api_key, base_url, throw_on_error, request_id, metadata)
 
 
-def score(request_id, score, score_name=None, api_key: str = None):
+def score(api_key: str, base_url: str, throw_on_error: bool, request_id, score, score_name=None):
     if not isinstance(score, int):
-        raise Exception("Please provide a int score.")
+        raise _exceptions.PromptLayerValidationError("Please provide a int score.", response=None, body=None)
     if not isinstance(score_name, str) and score_name is not None:
-        raise Exception("Please provide a string as score name.")
+        raise _exceptions.PromptLayerValidationError("Please provide a string as score name.", response=None, body=None)
     if score < 0 or score > 100:
-        raise Exception("Please provide a score between 0 and 100.")
-    return promptlayer_track_score(request_id, score, score_name, api_key)
+        raise _exceptions.PromptLayerValidationError(
+            "Please provide a score between 0 and 100.", response=None, body=None
+        )
+    return promptlayer_track_score(api_key, base_url, throw_on_error, request_id, score, score_name)
 
 
-def group(request_id, group_id, api_key: str = None):
-    return promptlayer_track_group(request_id, group_id, api_key)
+def group(api_key: str, base_url: str, throw_on_error: bool, request_id, group_id):
+    return promptlayer_track_group(api_key, base_url, throw_on_error, request_id, group_id)
+
+
+async def aprompt(
+    api_key: str,
+    base_url: str,
+    throw_on_error: bool,
+    request_id,
+    prompt_name,
+    prompt_input_variables,
+    version=None,
+    label=None,
+):
+    if not isinstance(prompt_input_variables, dict):
+        raise _exceptions.PromptLayerValidationError(
+            "Please provide a dictionary of input variables.", response=None, body=None
+        )
+    return await apromptlayer_track_prompt(
+        api_key, base_url, throw_on_error, request_id, prompt_name, prompt_input_variables, version, label
+    )
+
+
+async def ametadata(api_key: str, base_url: str, throw_on_error: bool, request_id, metadata):
+    if not isinstance(metadata, dict):
+        raise _exceptions.PromptLayerValidationError(
+            "Please provide a dictionary of metadata.", response=None, body=None
+        )
+    for key, value in metadata.items():
+        if not isinstance(key, str) or not isinstance(value, str):
+            raise _exceptions.PromptLayerValidationError(
+                "Please provide a dictionary of metadata with key-value pairs of strings.", response=None, body=None
+            )
+    return await apromptlayer_track_metadata(api_key, base_url, throw_on_error, request_id, metadata)
+
+
+async def ascore(api_key: str, base_url: str, throw_on_error: bool, request_id, score, score_name=None):
+    if not isinstance(score, int):
+        raise _exceptions.PromptLayerValidationError("Please provide an integer score.", response=None, body=None)
+    if not isinstance(score_name, str) and score_name is not None:
+        raise _exceptions.PromptLayerValidationError("Please provide a string as score name.", response=None, body=None)
+    if score < 0 or score > 100:
+        raise _exceptions.PromptLayerValidationError(
+            "Please provide a score between 0 and 100.", response=None, body=None
+        )
+    return await apromptlayer_track_score(api_key, base_url, throw_on_error, request_id, score, score_name)
+
+
+async def agroup(api_key: str, base_url: str, throw_on_error: bool, request_id, group_id):
+    return await apromptlayer_track_group(api_key, base_url, throw_on_error, request_id, group_id)

promptlayer/types/__init__.py

@@ -1,3 +1,4 @@
 from . import prompt_template
+from .request_log import RequestLog
 
-__all__ = ["prompt_template"]
+__all__ = ["prompt_template", "RequestLog"]

promptlayer/types/prompt_template.py

@@ -18,9 +18,40 @@ class ImageUrl(TypedDict, total=False):
     url: str
 
 
+class WebAnnotation(TypedDict, total=False):
+    type: Literal["web_annotation"]
+    title: str
+    url: str
+    start_index: int
+    end_index: int
+
+
+class FileAnnotation(TypedDict, total=False):
+    type: Literal["file_annotation"]
+    index: int
+    file_id: str
+    filename: str
+
+
 class TextContent(TypedDict, total=False):
     type: Literal["text"]
     text: str
+    id: Union[str, None]
+    annotations: Union[List[Union[WebAnnotation, FileAnnotation]], None]
+
+
+class CodeContent(TypedDict, total=False):
+    type: Literal["code"]
+    code: str
+    id: Union[str, None]
+    container_id: Union[str, None]
+
+
+class ThinkingContent(TypedDict, total=False):
+    signature: Union[str, None]
+    type: Literal["thinking"]
+    thinking: str
+    id: Union[str, None]
 
 
 class ImageContent(TypedDict, total=False):
@@ -28,7 +59,23 @@ class ImageContent(TypedDict, total=False):
     image_url: ImageUrl
 
 
-Content = Union[TextContent, ImageContent]
+class Media(TypedDict, total=False):
+    title: str
+    type: str
+    url: str
+
+
+class MediaContnt(TypedDict, total=False):
+    type: Literal["media"]
+    media: Media
+
+
+class MediaVariable(TypedDict, total=False):
+    type: Literal["media_variable"]
+    name: str
+
+
+Content = Union[TextContent, ThinkingContent, CodeContent, ImageContent, MediaContnt, MediaVariable]
 
 
 class Function(TypedDict, total=False):
@@ -65,6 +112,7 @@ class UserMessage(TypedDict, total=False):
 
 class ToolCall(TypedDict, total=False):
     id: str
+    tool_id: Union[str, None]
     type: Literal["function"]
     function: FunctionCall
 
@@ -101,6 +149,13 @@ class PlaceholderMessage(TypedDict, total=False):
     name: str
 
 
+class DeveloperMessage(TypedDict, total=False):
+    role: Literal["developer"]
+    input_variables: List[str]
+    template_format: TemplateFormat
+    content: Sequence[Content]
+
+
 class ChatFunctionCall(TypedDict, total=False):
     name: str
 
@@ -119,6 +174,7 @@ Message = Union[
     FunctionMessage,
     ToolMessage,
     PlaceholderMessage,
+    DeveloperMessage,
 ]
 
 
@@ -157,13 +213,13 @@ class BasePromptTemplate(TypedDict, total=False):
     tags: List[str]
 
 
-class PromptVersion(TypedDict, total=False):
+class PromptBlueprint(TypedDict, total=False):
     prompt_template: PromptTemplate
     commit_message: str
     metadata: Metadata
 
 
-class PublishPromptTemplate(BasePromptTemplate, PromptVersion, total=False):
+class PublishPromptTemplate(BasePromptTemplate, PromptBlueprint, total=False):
     release_labels: Optional[List[str]] = None
 
 

promptlayer/types/request_log.py

@@ -0,0 +1,8 @@
+from typing import TypedDict, Union
+
+from .prompt_template import PromptBlueprint
+
+
+class RequestLog(TypedDict):
+    id: int
+    prompt_version: Union[PromptBlueprint, None]