promptlayer 1.0.16__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

@@ -0,0 +1,460 @@
+import asyncio
+import datetime
+from copy import deepcopy
+from functools import wraps
+from typing import Any, Dict, Union
+
+from opentelemetry.sdk.resources import Resource
+from opentelemetry.sdk.trace import TracerProvider
+from opentelemetry.sdk.trace.export import BatchSpanProcessor
+from opentelemetry.semconv.resource import ResourceAttributes
+
+from promptlayer.span_exporter import PromptLayerSpanExporter
+from promptlayer.streaming import (
+    aanthropic_stream_completion,
+    aanthropic_stream_message,
+    abedrock_stream_message,
+    agoogle_stream_chat,
+    agoogle_stream_completion,
+    amistral_stream_chat,
+    anthropic_stream_completion,
+    anthropic_stream_message,
+    aopenai_responses_stream_chat,
+    aopenai_stream_chat,
+    aopenai_stream_completion,
+    bedrock_stream_message,
+    google_stream_chat,
+    google_stream_completion,
+    mistral_stream_chat,
+    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:chat-completions": {
+        "chat": {
+            "function_name": "openai.chat.completions.create",
+            "stream_function": openai_stream_chat,
+        },
+        "completion": {
+            "function_name": "openai.completions.create",
+            "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",
+            "stream_function": anthropic_stream_message,
+        },
+        "completion": {
+            "function_name": "anthropic.completions.create",
+            "stream_function": anthropic_stream_completion,
+        },
+    },
+    "openai.azure:chat-completions": {
+        "chat": {
+            "function_name": "openai.AzureOpenAI.chat.completions.create",
+            "stream_function": openai_stream_chat,
+        },
+        "completion": {
+            "function_name": "openai.AzureOpenAI.completions.create",
+            "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",
+            "stream_function": mistral_stream_chat,
+        },
+        "completion": {
+            "function_name": None,
+            "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 = {
+    "anthropic": anthropic_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:chat-completions": {
+        "chat": {
+            "function_name": "openai.chat.completions.create",
+            "stream_function": aopenai_stream_chat,
+        },
+        "completion": {
+            "function_name": "openai.completions.create",
+            "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",
+            "stream_function": aanthropic_stream_message,
+        },
+        "completion": {
+            "function_name": "anthropic.completions.create",
+            "stream_function": aanthropic_stream_completion,
+        },
+    },
+    "openai.azure:chat-completions": {
+        "chat": {
+            "function_name": "openai.AzureOpenAI.chat.completions.create",
+            "stream_function": aopenai_stream_chat,
+        },
+        "completion": {
+            "function_name": "openai.AzureOpenAI.completions.create",
+            "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",
+            "stream_function": amistral_stream_chat,
+        },
+        "completion": {
+            "function_name": None,
+            "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 = {
+    "anthropic": aanthropic_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, base_url: str, throw_on_error: bool, enable_tracing: bool = False):
+        if enable_tracing:
+            resource = Resource(attributes={ResourceAttributes.SERVICE_NAME: "prompt-layer-library"})
+            tracer_provider = TracerProvider(resource=resource)
+            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__)
+            return tracer_provider, tracer
+        else:
+            return None, None
+
+    @staticmethod
+    def _prepare_get_prompt_template_params(
+        *,
+        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:
+            params["version"] = prompt_version
+        if prompt_release_label:
+            params["label"] = prompt_release_label
+        if input_variables:
+            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_data(
+        *,
+        prompt_blueprint,
+        prompt_template,
+        prompt_blueprint_model,
+        stream,
+        is_async=False,
+    ):
+        client_kwargs = {}
+        function_kwargs = deepcopy(prompt_blueprint["llm_kwargs"])
+        function_kwargs["stream"] = stream
+        provider = prompt_blueprint_model["provider"]
+        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_function_name][prompt_template["type"]]
+            request_function = AMAP_PROVIDER_TO_FUNCTION[provider]
+        else:
+            config = MAP_PROVIDER_TO_FUNCTION_NAME[provider_function_name][prompt_template["type"]]
+            request_function = MAP_PROVIDER_TO_FUNCTION[provider]
+
+        return {
+            "provider": provider,
+            "function_name": config["function_name"],
+            "stream_function": config["stream_function"],
+            "request_function": request_function,
+            "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):
+        if not prompt_blueprint["llm_kwargs"]:
+            raise ValueError(
+                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.")
+
+        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.")
+
+        return prompt_blueprint_model
+
+    @staticmethod
+    def _prepare_track_request_kwargs(
+        api_key,
+        request_params,
+        tags,
+        input_variables,
+        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["function_kwargs"],
+            "tags": tags,
+            "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 or {},
+            "group_id": group_id,
+            "return_prompt_blueprint": True,
+            "span_id": pl_run_span_id,
+            **body,
+        }
+
+    def traceable(self, attributes=None, name=None):
+        def decorator(func):
+            @wraps(func)
+            def sync_wrapper(*args, **kwargs):
+                if self.tracer:
+                    span_name = name or func.__name__
+                    with self.tracer.start_as_current_span(span_name) as span:
+                        if attributes:
+                            for key, value in attributes.items():
+                                span.set_attribute(key, value)
+
+                        span.set_attribute("function_input", str({"args": args, "kwargs": kwargs}))
+                        result = func(*args, **kwargs)
+                        span.set_attribute("function_output", str(result))
+
+                        return result
+                else:
+                    return func(*args, **kwargs)
+
+            @wraps(func)
+            async def async_wrapper(*args, **kwargs):
+                if self.tracer:
+                    span_name = name or func.__name__
+                    with self.tracer.start_as_current_span(span_name) as span:
+                        if attributes:
+                            for key, value in attributes.items():
+                                span.set_attribute(key, value)
+
+                        span.set_attribute("function_input", str({"args": args, "kwargs": kwargs}))
+                        result = await func(*args, **kwargs)
+                        span.set_attribute("function_output", str(result))
+
+                        return result
+                else:
+                    return await func(*args, **kwargs)
+
+            return async_wrapper if asyncio.iscoroutinefunction(func) else sync_wrapper
+
+        return decorator