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

promptlayer/promptlayer_base.py

@@ -2,6 +2,7 @@ import datetime
 import inspect
 import re
 
+from promptlayer import exceptions as _exceptions
 from promptlayer.utils import async_wrapper, promptlayer_api_handler
 
 
@@ -13,47 +14,41 @@ class PromptLayerBase(object):
         "_provider_type",
         "_api_key",
         "_tracer",
+        "_base_url",
     ]
 
-    def __init__(
-        self, obj, function_name="", provider_type="openai", api_key=None, tracer=None
-    ):
+    def __init__(self, api_key: str, base_url: str, obj, function_name="", provider_type="openai", tracer=None):
         object.__setattr__(self, "_obj", obj)
         object.__setattr__(self, "_function_name", function_name)
         object.__setattr__(self, "_provider_type", provider_type)
         object.__setattr__(self, "_api_key", api_key)
         object.__setattr__(self, "_tracer", tracer)
+        object.__setattr__(self, "_base_url", base_url)
 
     def __getattr__(self, name):
         attr = getattr(object.__getattribute__(self, "_obj"), name)
 
         if (
             name != "count_tokens"  # fix for anthropic count_tokens
-            and not re.match(
-                r"<class 'anthropic\..*Error'>", str(attr)
-            )  # fix for anthropic errors
-            and not re.match(
-                r"<class 'openai\..*Error'>", str(attr)
-            )  # fix for openai errors
+            and not re.match(r"<class 'anthropic\..*Error'>", str(attr))  # fix for anthropic errors
+            and not re.match(r"<class 'openai\..*Error'>", str(attr))  # fix for openai errors
             and (
                 inspect.isclass(attr)
                 or inspect.isfunction(attr)
                 or inspect.ismethod(attr)
-                or str(type(attr))
-                == "<class 'anthropic.resources.completions.Completions'>"
-                or str(type(attr))
-                == "<class 'anthropic.resources.completions.AsyncCompletions'>"
-                or str(type(attr)) == "<class 'anthropic.resources.messages.Messages'>"
-                or str(type(attr))
-                == "<class 'anthropic.resources.messages.AsyncMessages'>"
+                or str(type(attr)) == "<class 'anthropic.resources.completions.Completions'>"
+                or str(type(attr)) == "<class 'anthropic.resources.completions.AsyncCompletions'>"
+                or str(type(attr)) == "<class 'anthropic.resources.messages.messages.Messages'>"
+                or str(type(attr)) == "<class 'anthropic.resources.messages.messages.AsyncMessages'>"
                 or re.match(r"<class 'openai\.resources.*'>", str(type(attr)))
             )
         ):
             return PromptLayerBase(
+                object.__getattribute__(self, "_api_key"),
+                object.__getattribute__(self, "_base_url"),
                 attr,
-                function_name=f'{object.__getattribute__(self, "_function_name")}.{name}',
+                function_name=f"{object.__getattribute__(self, '_function_name')}.{name}",
                 provider_type=object.__getattribute__(self, "_provider_type"),
-                api_key=object.__getattribute__(self, "_api_key"),
                 tracer=object.__getattribute__(self, "_tracer"),
             )
         return attr
@@ -67,7 +62,7 @@ class PromptLayerBase(object):
     def __call__(self, *args, **kwargs):
         tags = kwargs.pop("pl_tags", None)
         if tags is not None and not isinstance(tags, list):
-            raise Exception("pl_tags must be a list of strings.")
+            raise _exceptions.PromptLayerValidationError("pl_tags must be a list of strings.", response=None, body=None)
 
         return_pl_id = kwargs.pop("return_pl_id", False)
         request_start_time = datetime.datetime.now().timestamp()
@@ -77,23 +72,18 @@ class PromptLayerBase(object):
 
         if tracer:
             with tracer.start_as_current_span(function_name) as llm_request_span:
-                llm_request_span_id = hex(llm_request_span.context.span_id)[2:].zfill(
-                    16
-                )
-                llm_request_span.set_attribute(
-                    "provider", object.__getattribute__(self, "_provider_type")
-                )
+                llm_request_span_id = hex(llm_request_span.context.span_id)[2:].zfill(16)
+                llm_request_span.set_attribute("provider", object.__getattribute__(self, "_provider_type"))
                 llm_request_span.set_attribute("function_name", function_name)
-                llm_request_span.set_attribute(
-                    "function_input", str({"args": args, "kwargs": kwargs})
-                )
+                llm_request_span.set_attribute("function_input", str({"args": args, "kwargs": kwargs}))
 
                 if inspect.isclass(function_object):
                     result = PromptLayerBase(
+                        object.__getattribute__(self, "_api_key"),
+                        object.__getattribute__(self, "_base_url"),
                         function_object(*args, **kwargs),
                         function_name=function_name,
                         provider_type=object.__getattribute__(self, "_provider_type"),
-                        api_key=object.__getattribute__(self, "_api_key"),
                         tracer=tracer,
                     )
                     llm_request_span.set_attribute("function_output", str(result))
@@ -101,17 +91,16 @@ class PromptLayerBase(object):
 
                 function_response = function_object(*args, **kwargs)
 
-                if inspect.iscoroutinefunction(function_object) or inspect.iscoroutine(
-                    function_response
-                ):
+                if inspect.iscoroutinefunction(function_object) or inspect.iscoroutine(function_response):
                     return async_wrapper(
+                        object.__getattribute__(self, "_api_key"),
+                        object.__getattribute__(self, "_base_url"),
                         function_response,
                         return_pl_id,
                         request_start_time,
                         function_name,
                         object.__getattribute__(self, "_provider_type"),
                         tags,
-                        api_key=object.__getattribute__(self, "_api_key"),
                         llm_request_span_id=llm_request_span_id,
                         tracer=tracer,  # Pass the tracer to async_wrapper
                         *args,
@@ -120,6 +109,8 @@ class PromptLayerBase(object):
 
                 request_end_time = datetime.datetime.now().timestamp()
                 result = promptlayer_api_handler(
+                    object.__getattribute__(self, "_api_key"),
+                    object.__getattribute__(self, "_base_url"),
                     function_name,
                     object.__getattribute__(self, "_provider_type"),
                     args,
@@ -128,7 +119,6 @@ class PromptLayerBase(object):
                     function_response,
                     request_start_time,
                     request_end_time,
-                    object.__getattribute__(self, "_api_key"),
                     return_pl_id=return_pl_id,
                     llm_request_span_id=llm_request_span_id,
                 )
@@ -138,31 +128,33 @@ class PromptLayerBase(object):
             # Without tracing
             if inspect.isclass(function_object):
                 return PromptLayerBase(
+                    object.__getattribute__(self, "_api_key"),
+                    object.__getattribute__(self, "_base_url"),
                     function_object(*args, **kwargs),
                     function_name=function_name,
                     provider_type=object.__getattribute__(self, "_provider_type"),
-                    api_key=object.__getattribute__(self, "_api_key"),
                 )
 
             function_response = function_object(*args, **kwargs)
 
-            if inspect.iscoroutinefunction(function_object) or inspect.iscoroutine(
-                function_response
-            ):
+            if inspect.iscoroutinefunction(function_object) or inspect.iscoroutine(function_response):
                 return async_wrapper(
+                    object.__getattribute__(self, "_api_key"),
+                    object.__getattribute__(self, "_base_url"),
                     function_response,
                     return_pl_id,
                     request_start_time,
                     function_name,
                     object.__getattribute__(self, "_provider_type"),
                     tags,
-                    api_key=object.__getattribute__(self, "_api_key"),
                     *args,
                     **kwargs,
                 )
 
             request_end_time = datetime.datetime.now().timestamp()
             return promptlayer_api_handler(
+                object.__getattribute__(self, "_api_key"),
+                object.__getattribute__(self, "_base_url"),
                 function_name,
                 object.__getattribute__(self, "_provider_type"),
                 args,
@@ -171,6 +163,5 @@ class PromptLayerBase(object):
                 function_response,
                 request_start_time,
                 request_end_time,
-                object.__getattribute__(self, "_api_key"),
                 return_pl_id=return_pl_id,
             )

promptlayer/promptlayer_mixins.py

@@ -2,7 +2,7 @@ import asyncio
 import datetime
 from copy import deepcopy
 from functools import wraps
-from typing import Dict, Union
+from typing import Any, Dict, Union
 
 from opentelemetry.sdk.resources import Resource
 from opentelemetry.sdk.trace import TracerProvider
@@ -10,29 +10,47 @@ from opentelemetry.sdk.trace.export import BatchSpanProcessor
 from opentelemetry.semconv.resource import ResourceAttributes
 
 from promptlayer.span_exporter import PromptLayerSpanExporter
-from promptlayer.utils import (
-    aanthropic_request,
+from promptlayer.streaming import (
     aanthropic_stream_completion,
     aanthropic_stream_message,
-    aazure_openai_request,
-    amistral_request,
+    abedrock_stream_message,
+    agoogle_stream_chat,
+    agoogle_stream_completion,
     amistral_stream_chat,
-    anthropic_request,
     anthropic_stream_completion,
     anthropic_stream_message,
-    aopenai_request,
+    aopenai_responses_stream_chat,
     aopenai_stream_chat,
     aopenai_stream_completion,
-    azure_openai_request,
-    mistral_request,
+    bedrock_stream_message,
+    google_stream_chat,
+    google_stream_completion,
     mistral_stream_chat,
-    openai_request,
+    openai_responses_stream_chat,
     openai_stream_chat,
     openai_stream_completion,
 )
+from promptlayer.utils import (
+    aamazon_bedrock_request,
+    aanthropic_bedrock_request,
+    aanthropic_request,
+    aazure_openai_request,
+    agoogle_request,
+    amazon_bedrock_request,
+    amistral_request,
+    anthropic_bedrock_request,
+    anthropic_request,
+    aopenai_request,
+    avertexai_request,
+    azure_openai_request,
+    google_request,
+    mistral_request,
+    openai_request,
+    vertexai_request,
+)
 
 MAP_PROVIDER_TO_FUNCTION_NAME = {
-    "openai": {
+    "openai:chat-completions": {
         "chat": {
             "function_name": "openai.chat.completions.create",
             "stream_function": openai_stream_chat,
@@ -42,6 +60,16 @@ MAP_PROVIDER_TO_FUNCTION_NAME = {
             "stream_function": openai_stream_completion,
         },
     },
+    "openai:responses": {
+        "chat": {
+            "function_name": "openai.responses.create",
+            "stream_function": openai_responses_stream_chat,
+        },
+        "completion": {
+            "function_name": "openai.responses.create",
+            "stream_function": openai_responses_stream_chat,
+        },
+    },
     "anthropic": {
         "chat": {
             "function_name": "anthropic.messages.create",
@@ -52,7 +80,7 @@ MAP_PROVIDER_TO_FUNCTION_NAME = {
             "stream_function": anthropic_stream_completion,
         },
     },
-    "openai.azure": {
+    "openai.azure:chat-completions": {
         "chat": {
             "function_name": "openai.AzureOpenAI.chat.completions.create",
             "stream_function": openai_stream_chat,
@@ -62,6 +90,16 @@ MAP_PROVIDER_TO_FUNCTION_NAME = {
             "stream_function": openai_stream_completion,
         },
     },
+    "openai.azure:responses": {
+        "chat": {
+            "function_name": "openai.AzureOpenAI.responses.create",
+            "stream_function": openai_responses_stream_chat,
+        },
+        "completion": {
+            "function_name": "openai.AzureOpenAI.responses.create",
+            "stream_function": openai_responses_stream_chat,
+        },
+    },
     "mistral": {
         "chat": {
             "function_name": "mistral.client.chat",
@@ -72,18 +110,52 @@ MAP_PROVIDER_TO_FUNCTION_NAME = {
             "stream_function": None,
         },
     },
+    "google": {
+        "chat": {
+            "function_name": "google.convo.send_message",
+            "stream_function": google_stream_chat,
+        },
+        "completion": {
+            "function_name": "google.model.generate_content",
+            "stream_function": google_stream_completion,
+        },
+    },
+    "amazon.bedrock": {
+        "chat": {
+            "function_name": "boto3.bedrock-runtime.converse",
+            "stream_function": bedrock_stream_message,
+        },
+        "completion": {
+            "function_name": "boto3.bedrock-runtime.converse",
+            "stream_function": bedrock_stream_message,
+        },
+    },
+    "anthropic.bedrock": {
+        "chat": {
+            "function_name": "anthropic.messages.create",
+            "stream_function": anthropic_stream_message,
+        },
+        "completion": {
+            "function_name": "anthropic.completions.create",
+            "stream_function": anthropic_stream_completion,
+        },
+    },
 }
 
 
 MAP_PROVIDER_TO_FUNCTION = {
-    "openai": openai_request,
     "anthropic": anthropic_request,
-    "openai.azure": azure_openai_request,
+    "google": google_request,
     "mistral": mistral_request,
+    "openai": openai_request,
+    "openai.azure": azure_openai_request,
+    "vertexai": vertexai_request,
+    "amazon.bedrock": amazon_bedrock_request,
+    "anthropic.bedrock": anthropic_bedrock_request,
 }
 
 AMAP_PROVIDER_TO_FUNCTION_NAME = {
-    "openai": {
+    "openai:chat-completions": {
         "chat": {
             "function_name": "openai.chat.completions.create",
             "stream_function": aopenai_stream_chat,
@@ -93,6 +165,16 @@ AMAP_PROVIDER_TO_FUNCTION_NAME = {
             "stream_function": aopenai_stream_completion,
         },
     },
+    "openai:responses": {
+        "chat": {
+            "function_name": "openai.responses.create",
+            "stream_function": aopenai_responses_stream_chat,
+        },
+        "completion": {
+            "function_name": "openai.responses.create",
+            "stream_function": aopenai_responses_stream_chat,
+        },
+    },
     "anthropic": {
         "chat": {
             "function_name": "anthropic.messages.create",
@@ -103,7 +185,7 @@ AMAP_PROVIDER_TO_FUNCTION_NAME = {
             "stream_function": aanthropic_stream_completion,
         },
     },
-    "openai.azure": {
+    "openai.azure:chat-completions": {
         "chat": {
             "function_name": "openai.AzureOpenAI.chat.completions.create",
             "stream_function": aopenai_stream_chat,
@@ -113,6 +195,16 @@ AMAP_PROVIDER_TO_FUNCTION_NAME = {
             "stream_function": aopenai_stream_completion,
         },
     },
+    "openai.azure:responses": {
+        "chat": {
+            "function_name": "openai.AzureOpenAI.responses.create",
+            "stream_function": aopenai_responses_stream_chat,
+        },
+        "completion": {
+            "function_name": "openai.AzureOpenAI.responses.create",
+            "stream_function": aopenai_responses_stream_chat,
+        },
+    },
     "mistral": {
         "chat": {
             "function_name": "mistral.client.chat",
@@ -123,26 +215,60 @@ AMAP_PROVIDER_TO_FUNCTION_NAME = {
             "stream_function": None,
         },
     },
+    "google": {
+        "chat": {
+            "function_name": "google.convo.send_message",
+            "stream_function": agoogle_stream_chat,
+        },
+        "completion": {
+            "function_name": "google.model.generate_content",
+            "stream_function": agoogle_stream_completion,
+        },
+    },
+    "amazon.bedrock": {
+        "chat": {
+            "function_name": "boto3.bedrock-runtime.converse",
+            "stream_function": abedrock_stream_message,
+        },
+        "completion": {
+            "function_name": "boto3.bedrock-runtime.converse",
+            "stream_function": abedrock_stream_message,
+        },
+    },
+    "anthropic.bedrock": {
+        "chat": {
+            "function_name": "anthropic.messages.create",
+            "stream_function": aanthropic_stream_message,
+        },
+        "completion": {
+            "function_name": "anthropic.completions.create",
+            "stream_function": aanthropic_stream_completion,
+        },
+    },
 }
 
 
 AMAP_PROVIDER_TO_FUNCTION = {
-    "openai": aopenai_request,
     "anthropic": aanthropic_request,
-    "openai.azure": aazure_openai_request,
+    "google": agoogle_request,
     "mistral": amistral_request,
+    "openai": aopenai_request,
+    "openai.azure": aazure_openai_request,
+    "vertexai": avertexai_request,
+    "amazon.bedrock": aamazon_bedrock_request,
+    "anthropic.bedrock": aanthropic_bedrock_request,
 }
 
 
 class PromptLayerMixin:
     @staticmethod
-    def _initialize_tracer(api_key: str = None, enable_tracing: bool = False):
+    def _initialize_tracer(api_key: str, base_url: str, throw_on_error: bool, enable_tracing: bool = False):
         if enable_tracing:
-            resource = Resource(
-                attributes={ResourceAttributes.SERVICE_NAME: "prompt-layer-library"}
-            )
+            resource = Resource(attributes={ResourceAttributes.SERVICE_NAME: "prompt-layer-library"})
             tracer_provider = TracerProvider(resource=resource)
-            promptlayer_exporter = PromptLayerSpanExporter(api_key=api_key)
+            promptlayer_exporter = PromptLayerSpanExporter(
+                api_key=api_key, base_url=base_url, throw_on_error=throw_on_error
+            )
             span_processor = BatchSpanProcessor(promptlayer_exporter)
             tracer_provider.add_span_processor(span_processor)
             tracer = tracer_provider.get_tracer(__name__)
@@ -152,8 +278,15 @@ class PromptLayerMixin:
 
     @staticmethod
     def _prepare_get_prompt_template_params(
-        *, prompt_version, prompt_release_label, input_variables, metadata
-    ):
+        *,
+        prompt_version: Union[int, None],
+        prompt_release_label: Union[str, None],
+        input_variables: Union[Dict[str, Any], None],
+        metadata: Union[Dict[str, str], None],
+        provider: Union[str, None] = None,
+        model: Union[str, None] = None,
+        model_parameter_overrides: Union[Dict[str, Any], None] = None,
+    ) -> Dict[str, Any]:
         params = {}
 
         if prompt_version:
@@ -164,69 +297,86 @@ class PromptLayerMixin:
             params["input_variables"] = input_variables
         if metadata:
             params["metadata_filters"] = metadata
+        if provider:
+            params["provider"] = provider
+        if model:
+            params["model"] = model
+        if model_parameter_overrides:
+            params["model_parameter_overrides"] = model_parameter_overrides
 
         return params
 
     @staticmethod
-    def _prepare_llm_request_params(
+    def _prepare_llm_data(
         *,
         prompt_blueprint,
         prompt_template,
         prompt_blueprint_model,
-        model_parameter_overrides,
         stream,
         is_async=False,
     ):
+        client_kwargs = {}
+        function_kwargs = deepcopy(prompt_blueprint["llm_kwargs"])
+        function_kwargs["stream"] = stream
         provider = prompt_blueprint_model["provider"]
-        kwargs = deepcopy(prompt_blueprint["llm_kwargs"])
+        api_type = prompt_blueprint_model.get("api_type", "chat-completions")
+
+        if custom_provider := prompt_blueprint.get("custom_provider"):
+            provider = custom_provider["client"]
+            client_kwargs = {
+                "api_key": custom_provider["api_key"],
+                "base_url": custom_provider["base_url"],
+            }
+        elif provider_base_url := prompt_blueprint.get("provider_base_url"):
+            client_kwargs["base_url"] = provider_base_url["url"]
+
+        if stream and provider in ["openai", "openai.azure"] and api_type == "chat-completions":
+            function_kwargs["stream_options"] = {"include_usage": True}
+
+        provider_function_name = provider
+        if provider_function_name == "vertexai":
+            if "gemini" in prompt_blueprint_model["name"]:
+                provider_function_name = "google"
+            elif "claude" in prompt_blueprint_model["name"]:
+                provider_function_name = "anthropic"
+
+        if provider_function_name in ("openai", "openai.azure"):
+            api = api_type if api_type is not None else "chat-completions"
+            provider_function_name = f"{provider_function_name}:{api}"
+
         if is_async:
-            config = AMAP_PROVIDER_TO_FUNCTION_NAME[provider][prompt_template["type"]]
+            config = AMAP_PROVIDER_TO_FUNCTION_NAME[provider_function_name][prompt_template["type"]]
             request_function = AMAP_PROVIDER_TO_FUNCTION[provider]
         else:
-            config = MAP_PROVIDER_TO_FUNCTION_NAME[provider][prompt_template["type"]]
+            config = MAP_PROVIDER_TO_FUNCTION_NAME[provider_function_name][prompt_template["type"]]
             request_function = MAP_PROVIDER_TO_FUNCTION[provider]
 
-        if provider_base_url := prompt_blueprint.get("provider_base_url"):
-            kwargs["base_url"] = provider_base_url["url"]
-
-        if model_parameter_overrides:
-            kwargs.update(model_parameter_overrides)
-
-        kwargs["stream"] = stream
-        if stream and provider in ["openai", "openai.azure"]:
-            kwargs["stream_options"] = {"include_usage": True}
-
         return {
             "provider": provider,
             "function_name": config["function_name"],
             "stream_function": config["stream_function"],
             "request_function": request_function,
-            "kwargs": kwargs,
+            "client_kwargs": client_kwargs,
+            "function_kwargs": function_kwargs,
             "prompt_blueprint": prompt_blueprint,
         }
 
     @staticmethod
-    def _validate_and_extract_model_from_prompt_blueprint(
-        *, prompt_blueprint, prompt_name
-    ):
+    def _validate_and_extract_model_from_prompt_blueprint(*, prompt_blueprint, prompt_name):
         if not prompt_blueprint["llm_kwargs"]:
             raise ValueError(
-                f"Prompt '{prompt_name}' does not have any LLM kwargs associated with it."
+                f"Prompt '{prompt_name}' does not have any LLM kwargs associated with it. Please set your model parameters in the registry in the PromptLayer dashbaord."
             )
 
         prompt_blueprint_metadata = prompt_blueprint.get("metadata")
 
         if not prompt_blueprint_metadata:
-            raise ValueError(
-                f"Prompt '{prompt_name}' does not have any metadata associated with it."
-            )
+            raise ValueError(f"Prompt '{prompt_name}' does not have any metadata associated with it.")
 
         prompt_blueprint_model = prompt_blueprint_metadata.get("model")
 
         if not prompt_blueprint_model:
-            raise ValueError(
-                f"Prompt '{prompt_name}' does not have a model parameters associated with it."
-            )
+            raise ValueError(f"Prompt '{prompt_name}' does not have a model parameters associated with it.")
 
         return prompt_blueprint_model
 
@@ -239,25 +389,30 @@ class PromptLayerMixin:
         group_id,
         pl_run_span_id: Union[str, None] = None,
         metadata: Union[Dict[str, str], None] = None,
+        request_start_time: Union[float, None] = None,
+        request_end_time: Union[float, None] = None,
         **body,
     ):
+        # If timestamps are not provided, generate them (for backward compatibility)
+        # But note that this is the old buggy behavior
+        if request_start_time is None:
+            request_start_time = datetime.datetime.now(datetime.timezone.utc).timestamp()
+        if request_end_time is None:
+            request_end_time = datetime.datetime.now(datetime.timezone.utc).timestamp()
+
         return {
             "function_name": request_params["function_name"],
             "provider_type": request_params["provider"],
             "args": [],
-            "kwargs": request_params["kwargs"],
+            "kwargs": request_params["function_kwargs"],
             "tags": tags,
-            "request_start_time": datetime.datetime.now(
-                datetime.timezone.utc
-            ).timestamp(),
-            "request_end_time": datetime.datetime.now(
-                datetime.timezone.utc
-            ).timestamp(),
+            "request_start_time": request_start_time,
+            "request_end_time": request_end_time,
             "api_key": api_key,
             "metadata": metadata,
             "prompt_id": request_params["prompt_blueprint"]["id"],
             "prompt_version": request_params["prompt_blueprint"]["version"],
-            "prompt_input_variables": input_variables,
+            "prompt_input_variables": input_variables or {},
             "group_id": group_id,
             "return_prompt_blueprint": True,
             "span_id": pl_run_span_id,
@@ -275,9 +430,7 @@ class PromptLayerMixin:
                             for key, value in attributes.items():
                                 span.set_attribute(key, value)
 
-                        span.set_attribute(
-                            "function_input", str({"args": args, "kwargs": kwargs})
-                        )
+                        span.set_attribute("function_input", str({"args": args, "kwargs": kwargs}))
                         result = func(*args, **kwargs)
                         span.set_attribute("function_output", str(result))
 
@@ -294,9 +447,7 @@ class PromptLayerMixin:
                             for key, value in attributes.items():
                                 span.set_attribute(key, value)
 
-                        span.set_attribute(
-                            "function_input", str({"args": args, "kwargs": kwargs})
-                        )
+                        span.set_attribute("function_input", str({"args": args, "kwargs": kwargs}))
                         result = await func(*args, **kwargs)
                         span.set_attribute("function_output", str(result))