promptlayer 1.0.30__py3-none-any.whl → 1.0.32__py3-none-any.whl

promptlayer/__init__.py

@@ -1,4 +1,4 @@
 from .promptlayer import AsyncPromptLayer, PromptLayer
 
-__version__ = "1.0.30"
+__version__ = "1.0.32"
 __all__ = ["PromptLayer", "AsyncPromptLayer", "__version__"]

promptlayer/promptlayer.py

@@ -1,78 +1,27 @@
 import asyncio
-import datetime
 import os
-from copy import deepcopy
-from functools import wraps
 from typing import Any, Dict, List, Literal, Optional, Union
 
 import nest_asyncio
-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.groups import AsyncGroupManager, GroupManager
 from promptlayer.promptlayer_base import PromptLayerBase
-from promptlayer.span_exporter import PromptLayerSpanExporter
+from promptlayer.promptlayer_mixins import PromptLayerMixin
 from promptlayer.templates import AsyncTemplateManager, TemplateManager
 from promptlayer.track import AsyncTrackManager, TrackManager
 from promptlayer.types.prompt_template import PromptTemplate
 from promptlayer.utils import (
-    anthropic_request,
-    anthropic_stream_completion,
-    anthropic_stream_message,
     arun_workflow_request,
+    astream_response,
+    atrack_request,
     autil_log_request,
-    azure_openai_request,
-    openai_request,
-    openai_stream_chat,
-    openai_stream_completion,
     stream_response,
     track_request,
     util_log_request,
 )
 
-MAP_PROVIDER_TO_FUNCTION_NAME = {
-    "openai": {
-        "chat": {
-            "function_name": "openai.chat.completions.create",
-            "stream_function": openai_stream_chat,
-        },
-        "completion": {
-            "function_name": "openai.completions.create",
-            "stream_function": openai_stream_completion,
-        },
-    },
-    "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": {
-            "function_name": "openai.AzureOpenAI.chat.completions.create",
-            "stream_function": openai_stream_chat,
-        },
-        "completion": {
-            "function_name": "openai.AzureOpenAI.completions.create",
-            "stream_function": openai_stream_completion,
-        },
-    },
-}
-
-MAP_PROVIDER_TO_FUNCTION = {
-    "openai": openai_request,
-    "anthropic": anthropic_request,
-    "openai.azure": azure_openai_request,
-}
-
-
-class PromptLayer:
+
+class PromptLayer(PromptLayerMixin):
     def __init__(
         self,
         api_key: str = None,
@@ -134,109 +83,18 @@ class PromptLayer:
     ):
         def _track_request(**body):
             track_request_kwargs = self._prepare_track_request_kwargs(
-                request_params, tags, input_variables, group_id, pl_run_span_id, **body
+                self.api_key,
+                request_params,
+                tags,
+                input_variables,
+                group_id,
+                pl_run_span_id,
+                **body,
             )
             return track_request(**track_request_kwargs)
 
         return _track_request
 
-    @staticmethod
-    def _initialize_tracer(api_key: str = None, 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)
-            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, prompt_release_label, input_variables, metadata
-    ):
-        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
-
-        return params
-
-    @staticmethod
-    def _prepare_llm_request_params(
-        *,
-        prompt_blueprint,
-        prompt_template,
-        prompt_blueprint_model,
-        model_parameter_overrides,
-        stream,
-    ):
-        provider = prompt_blueprint_model["provider"]
-        kwargs = deepcopy(prompt_blueprint["llm_kwargs"])
-        config = MAP_PROVIDER_TO_FUNCTION_NAME[provider][prompt_template["type"]]
-
-        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": MAP_PROVIDER_TO_FUNCTION[provider],
-            "kwargs": kwargs,
-            "prompt_blueprint": prompt_blueprint,
-        }
-
-    def _prepare_track_request_kwargs(
-        self,
-        request_params,
-        tags,
-        input_variables,
-        group_id,
-        pl_run_span_id: Union[str, None] = None,
-        metadata: Union[Dict[str, str], None] = None,
-        **body,
-    ):
-        return {
-            "function_name": request_params["function_name"],
-            "provider_type": request_params["provider"],
-            "args": [],
-            "kwargs": request_params["kwargs"],
-            "tags": tags,
-            "request_start_time": datetime.datetime.now(
-                datetime.timezone.utc
-            ).timestamp(),
-            "request_end_time": datetime.datetime.now(
-                datetime.timezone.utc
-            ).timestamp(),
-            "api_key": self.api_key,
-            "metadata": metadata,
-            "prompt_id": request_params["prompt_blueprint"]["id"],
-            "prompt_version": request_params["prompt_blueprint"]["version"],
-            "prompt_input_variables": input_variables,
-            "group_id": group_id,
-            "return_prompt_blueprint": True,
-            "span_id": pl_run_span_id,
-            **body,
-        }
-
     def _run_internal(
         self,
         *,
@@ -313,6 +171,7 @@ class PromptLayer:
         **body,
     ):
         track_request_kwargs = self._prepare_track_request_kwargs(
+            self.api_key,
             request_params,
             tags,
             input_variables,
@@ -323,31 +182,6 @@ class PromptLayer:
         )
         return track_request(**track_request_kwargs)
 
-    @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."
-            )
-
-        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
-
     def run(
         self,
         prompt_name: str,
@@ -433,50 +267,6 @@ class PromptLayer:
         except Exception as e:
             raise Exception(f"Error running workflow: {str(e)}")
 
-    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
-
     def log_request(
         self,
         *,
@@ -520,10 +310,11 @@ class PromptLayer:
         )
 
 
-class AsyncPromptLayer:
+class AsyncPromptLayer(PromptLayerMixin):
     def __init__(
         self,
         api_key: str = None,
+        enable_tracing: bool = False,
     ):
         if api_key is None:
             api_key = os.environ.get("PROMPTLAYER_API_KEY")
@@ -537,8 +328,36 @@ class AsyncPromptLayer:
         self.api_key = api_key
         self.templates = AsyncTemplateManager(api_key)
         self.group = AsyncGroupManager(api_key)
+        self.tracer_provider, self.tracer = self._initialize_tracer(
+            api_key, enable_tracing
+        )
         self.track = AsyncTrackManager(api_key)
 
+    def __getattr__(
+        self, name: Union[Literal["openai"], Literal["anthropic"], Literal["prompts"]]
+    ):
+        if name == "openai":
+            import openai as openai_module
+
+            openai = PromptLayerBase(
+                openai_module,
+                function_name="openai",
+                api_key=self.api_key,
+            )
+            return openai
+        elif name == "anthropic":
+            import anthropic as anthropic_module
+
+            anthropic = PromptLayerBase(
+                anthropic_module,
+                function_name="anthropic",
+                provider_type="anthropic",
+                api_key=self.api_key,
+            )
+            return anthropic
+        else:
+            raise AttributeError(f"module {__name__} has no attribute {name}")
+
     async def run_workflow(
         self,
         workflow_name: str,
@@ -564,6 +383,43 @@ class AsyncPromptLayer:
         except Exception as e:
             raise Exception(f"Error running workflow: {str(e)}")
 
+    async def run(
+        self,
+        prompt_name: str,
+        prompt_version: Union[int, None] = None,
+        prompt_release_label: Union[str, None] = None,
+        input_variables: Union[Dict[str, Any], None] = None,
+        model_parameter_overrides: Union[Dict[str, Any], None] = None,
+        tags: Union[List[str], None] = None,
+        metadata: Union[Dict[str, str], None] = None,
+        group_id: Union[int, None] = None,
+        stream: bool = False,
+    ) -> Dict[str, Any]:
+        _run_internal_kwargs = {
+            "prompt_name": prompt_name,
+            "prompt_version": prompt_version,
+            "prompt_release_label": prompt_release_label,
+            "input_variables": input_variables,
+            "model_parameter_overrides": model_parameter_overrides,
+            "tags": tags,
+            "metadata": metadata,
+            "group_id": group_id,
+            "stream": stream,
+        }
+
+        if self.tracer:
+            with self.tracer.start_as_current_span("PromptLayer Run") as span:
+                span.set_attribute("prompt_name", prompt_name)
+                span.set_attribute("function_input", str(_run_internal_kwargs))
+                pl_run_span_id = hex(span.context.span_id)[2:].zfill(16)
+                result = await self._run_internal(
+                    **_run_internal_kwargs, pl_run_span_id=pl_run_span_id
+                )
+                span.set_attribute("function_output", str(result))
+                return result
+        else:
+            return await self._run_internal(**_run_internal_kwargs)
+
     async def log_request(
         self,
         *,
@@ -605,3 +461,116 @@ class AsyncPromptLayer:
             function_name=function_name,
             score=score,
         )
+
+    async def _create_track_request_callable(
+        self,
+        *,
+        request_params,
+        tags,
+        input_variables,
+        group_id,
+        pl_run_span_id: Union[str, None] = None,
+    ):
+        async def _track_request(**body):
+            track_request_kwargs = self._prepare_track_request_kwargs(
+                self.api_key,
+                request_params,
+                tags,
+                input_variables,
+                group_id,
+                pl_run_span_id,
+                **body,
+            )
+            return await atrack_request(**track_request_kwargs)
+
+        return await _track_request
+
+    async def _track_request_log(
+        self,
+        request_params,
+        tags,
+        input_variables,
+        group_id,
+        pl_run_span_id: Union[str, None] = None,
+        metadata: Union[Dict[str, str], None] = None,
+        **body,
+    ):
+        track_request_kwargs = self._prepare_track_request_kwargs(
+            self.api_key,
+            request_params,
+            tags,
+            input_variables,
+            group_id,
+            pl_run_span_id,
+            metadata=metadata,
+            **body,
+        )
+        return await atrack_request(**track_request_kwargs)
+
+    async def _run_internal(
+        self,
+        *,
+        prompt_name: str,
+        prompt_version: Union[int, None] = None,
+        prompt_release_label: Union[str, None] = None,
+        input_variables: Union[Dict[str, Any], None] = None,
+        model_parameter_overrides: Union[Dict[str, Any], None] = None,
+        tags: Union[List[str], None] = None,
+        metadata: Union[Dict[str, str], None] = None,
+        group_id: Union[int, None] = None,
+        stream: bool = False,
+        pl_run_span_id: Union[str, None] = None,
+    ) -> Dict[str, Any]:
+        get_prompt_template_params = self._prepare_get_prompt_template_params(
+            prompt_version=prompt_version,
+            prompt_release_label=prompt_release_label,
+            input_variables=input_variables,
+            metadata=metadata,
+        )
+        prompt_blueprint = await self.templates.get(
+            prompt_name, get_prompt_template_params
+        )
+        prompt_blueprint_model = self._validate_and_extract_model_from_prompt_blueprint(
+            prompt_blueprint=prompt_blueprint, prompt_name=prompt_name
+        )
+        llm_request_params = self._prepare_llm_request_params(
+            prompt_blueprint=prompt_blueprint,
+            prompt_template=prompt_blueprint["prompt_template"],
+            prompt_blueprint_model=prompt_blueprint_model,
+            model_parameter_overrides=model_parameter_overrides,
+            stream=stream,
+            is_async=True,
+        )
+
+        response = await llm_request_params["request_function"](
+            llm_request_params["prompt_blueprint"], **llm_request_params["kwargs"]
+        )
+
+        if stream:
+            return astream_response(
+                response,
+                self._create_track_request_callable(
+                    request_params=llm_request_params,
+                    tags=tags,
+                    input_variables=input_variables,
+                    group_id=group_id,
+                    pl_run_span_id=pl_run_span_id,
+                ),
+                llm_request_params["stream_function"],
+            )
+
+        request_log = await self._track_request_log(
+            llm_request_params,
+            tags,
+            input_variables,
+            group_id,
+            pl_run_span_id,
+            metadata=metadata,
+            request_response=response.model_dump(),
+        )
+
+        return {
+            "request_id": request_log.get("request_id", None),
+            "raw_response": response,
+            "prompt_blueprint": request_log.get("prompt_blueprint", None),
+        }

promptlayer/promptlayer_mixins.py

@@ -0,0 +1,283 @@
+import asyncio
+import datetime
+from copy import deepcopy
+from functools import wraps
+from typing import 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.utils import (
+    aanthropic_request,
+    aanthropic_stream_completion,
+    aanthropic_stream_message,
+    aazure_openai_request,
+    anthropic_request,
+    anthropic_stream_completion,
+    anthropic_stream_message,
+    aopenai_request,
+    aopenai_stream_chat,
+    aopenai_stream_completion,
+    azure_openai_request,
+    openai_request,
+    openai_stream_chat,
+    openai_stream_completion,
+)
+
+MAP_PROVIDER_TO_FUNCTION_NAME = {
+    "openai": {
+        "chat": {
+            "function_name": "openai.chat.completions.create",
+            "stream_function": openai_stream_chat,
+        },
+        "completion": {
+            "function_name": "openai.completions.create",
+            "stream_function": openai_stream_completion,
+        },
+    },
+    "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": {
+            "function_name": "openai.AzureOpenAI.chat.completions.create",
+            "stream_function": openai_stream_chat,
+        },
+        "completion": {
+            "function_name": "openai.AzureOpenAI.completions.create",
+            "stream_function": openai_stream_completion,
+        },
+    },
+}
+
+
+MAP_PROVIDER_TO_FUNCTION = {
+    "openai": openai_request,
+    "anthropic": anthropic_request,
+    "openai.azure": azure_openai_request,
+}
+
+AMAP_PROVIDER_TO_FUNCTION_NAME = {
+    "openai": {
+        "chat": {
+            "function_name": "openai.chat.completions.create",
+            "stream_function": aopenai_stream_chat,
+        },
+        "completion": {
+            "function_name": "openai.completions.create",
+            "stream_function": aopenai_stream_completion,
+        },
+    },
+    "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": {
+            "function_name": "openai.AzureOpenAI.chat.completions.create",
+            "stream_function": aopenai_stream_chat,
+        },
+        "completion": {
+            "function_name": "openai.AzureOpenAI.completions.create",
+            "stream_function": aopenai_stream_completion,
+        },
+    },
+}
+
+
+AMAP_PROVIDER_TO_FUNCTION = {
+    "openai": aopenai_request,
+    "anthropic": aanthropic_request,
+    "openai.azure": aazure_openai_request,
+}
+
+
+class PromptLayerMixin:
+    @staticmethod
+    def _initialize_tracer(api_key: str = None, 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)
+            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, prompt_release_label, input_variables, metadata
+    ):
+        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
+
+        return params
+
+    @staticmethod
+    def _prepare_llm_request_params(
+        *,
+        prompt_blueprint,
+        prompt_template,
+        prompt_blueprint_model,
+        model_parameter_overrides,
+        stream,
+        is_async=False,
+    ):
+        provider = prompt_blueprint_model["provider"]
+        kwargs = deepcopy(prompt_blueprint["llm_kwargs"])
+        if is_async:
+            config = AMAP_PROVIDER_TO_FUNCTION_NAME[provider][prompt_template["type"]]
+            request_function = AMAP_PROVIDER_TO_FUNCTION[provider]
+        else:
+            config = MAP_PROVIDER_TO_FUNCTION_NAME[provider][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,
+            "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."
+            )
+
+        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,
+        **body,
+    ):
+        return {
+            "function_name": request_params["function_name"],
+            "provider_type": request_params["provider"],
+            "args": [],
+            "kwargs": request_params["kwargs"],
+            "tags": tags,
+            "request_start_time": datetime.datetime.now(
+                datetime.timezone.utc
+            ).timestamp(),
+            "request_end_time": datetime.datetime.now(
+                datetime.timezone.utc
+            ).timestamp(),
+            "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,
+            "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

promptlayer/types/prompt_template.py

@@ -28,7 +28,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, ImageContent, MediaContnt, MediaVariable]
 
 
 class Function(TypedDict, total=False):

promptlayer/utils.py

@@ -2,13 +2,24 @@ import asyncio
 import contextvars
 import datetime
 import functools
+import inspect
 import json
 import os
 import sys
 import types
 from copy import deepcopy
 from enum import Enum
-from typing import Any, Callable, Dict, Generator, List, Optional, Union
+from typing import (
+    Any,
+    AsyncGenerator,
+    AsyncIterable,
+    Callable,
+    Dict,
+    Generator,
+    List,
+    Optional,
+    Union,
+)
 
 import httpx
 import requests
@@ -311,6 +322,27 @@ def track_request(**body):
         return {}
 
 
+async def atrack_request(**body: Any) -> Dict[str, Any]:
+    try:
+        async with httpx.AsyncClient() as client:
+            response = await client.post(
+                f"{URL_API_PROMPTLAYER}/track-request",
+                json=body,
+            )
+        if response.status_code != 200:
+            warn_on_bad_response(
+                response,
+                f"PromptLayer had the following error while tracking your request: {response.text}",
+            )
+        return response.json()
+    except httpx.RequestError as e:
+        print(
+            f"WARNING: While logging your request PromptLayer had the following error: {e}",
+            file=sys.stderr,
+        )
+        return {}
+
+
 def promptlayer_api_request_async(
     function_name,
     provider_type,
@@ -1136,6 +1168,81 @@ def openai_stream_chat(results: list):
     return response
 
 
+async def aopenai_stream_chat(generator: AsyncIterable[Any]) -> Any:
+    from openai.types.chat import (
+        ChatCompletion,
+        ChatCompletionChunk,
+        ChatCompletionMessage,
+        ChatCompletionMessageToolCall,
+    )
+    from openai.types.chat.chat_completion import Choice
+    from openai.types.chat.chat_completion_message_tool_call import Function
+
+    chat_completion_chunks: List[ChatCompletionChunk] = []
+    response: ChatCompletion = ChatCompletion(
+        id="",
+        object="chat.completion",
+        choices=[
+            Choice(
+                finish_reason="stop",
+                index=0,
+                message=ChatCompletionMessage(role="assistant"),
+            )
+        ],
+        created=0,
+        model="",
+    )
+    content = ""
+    tool_calls: Union[List[ChatCompletionMessageToolCall], None] = None
+
+    async for result in generator:
+        chat_completion_chunks.append(result)
+        choices = result.choices
+        if len(choices) == 0:
+            continue
+        if choices[0].delta.content:
+            content = f"{content}{choices[0].delta.content}"
+
+        delta = choices[0].delta
+        if delta.tool_calls:
+            tool_calls = tool_calls or []
+            last_tool_call = None
+            if len(tool_calls) > 0:
+                last_tool_call = tool_calls[-1]
+            tool_call = delta.tool_calls[0]
+            if not tool_call.function:
+                continue
+            if not last_tool_call or tool_call.id:
+                tool_calls.append(
+                    ChatCompletionMessageToolCall(
+                        id=tool_call.id or "",
+                        function=Function(
+                            name=tool_call.function.name or "",
+                            arguments=tool_call.function.arguments or "",
+                        ),
+                        type=tool_call.type or "function",
+                    )
+                )
+                continue
+            last_tool_call.function.name = (
+                f"{last_tool_call.function.name}{tool_call.function.name or ''}"
+            )
+            last_tool_call.function.arguments = f"{last_tool_call.function.arguments}{tool_call.function.arguments or ''}"
+
+    # After collecting all chunks, set the response attributes
+    if chat_completion_chunks:
+        last_result = chat_completion_chunks[-1]
+        response.id = last_result.id
+        response.created = last_result.created
+        response.model = last_result.model
+        response.system_fingerprint = getattr(last_result, "system_fingerprint", None)
+        response.usage = last_result.usage
+
+    response.choices[0].message.content = content
+    response.choices[0].message.tool_calls = tool_calls
+    return response
+
+
 def openai_stream_completion(results: list):
     from openai.types.completion import Completion, CompletionChoice
 
@@ -1162,6 +1269,41 @@ def openai_stream_completion(results: list):
     return response
 
 
+async def aopenai_stream_completion(generator: AsyncIterable[Any]) -> Any:
+    from openai.types.completion import Completion, CompletionChoice
+
+    completions: List[Completion] = []
+    text = ""
+    response = Completion(
+        id="",
+        created=0,
+        model="",
+        object="text_completion",
+        choices=[CompletionChoice(finish_reason="stop", index=0, text="")],
+    )
+
+    async for completion in generator:
+        completions.append(completion)
+        usage = completion.usage
+        system_fingerprint = getattr(completion, "system_fingerprint", None)
+        if len(completion.choices) > 0 and completion.choices[0].text:
+            text = f"{text}{completion.choices[0].text}"
+        if usage:
+            response.usage = usage
+        if system_fingerprint:
+            response.system_fingerprint = system_fingerprint
+
+    # After collecting all completions, set the response attributes
+    if completions:
+        last_chunk = completions[-1]
+        response.id = last_chunk.id
+        response.created = last_chunk.created
+        response.model = last_chunk.model
+
+    response.choices[0].text = text
+    return response
+
+
 def anthropic_stream_message(results: list):
     from anthropic.types import Message, MessageStreamEvent, TextBlock, Usage
 
@@ -1192,6 +1334,39 @@ def anthropic_stream_message(results: list):
     return response
 
 
+async def aanthropic_stream_message(generator: AsyncIterable[Any]) -> Any:
+    from anthropic.types import Message, MessageStreamEvent, TextBlock, Usage
+
+    message_stream_events: List[MessageStreamEvent] = []
+    response: Message = Message(
+        id="",
+        model="",
+        content=[],
+        role="assistant",
+        type="message",
+        stop_reason="stop_sequence",
+        stop_sequence=None,
+        usage=Usage(input_tokens=0, output_tokens=0),
+    )
+    content = ""
+
+    async for result in generator:
+        message_stream_events.append(result)
+        if result.type == "message_start":
+            response = result.message
+        elif result.type == "content_block_delta":
+            if result.delta.type == "text_delta":
+                content = f"{content}{result.delta.text}"
+        elif result.type == "message_delta":
+            if hasattr(result, "usage"):
+                response.usage.output_tokens = result.usage.output_tokens
+            if hasattr(result.delta, "stop_reason"):
+                response.stop_reason = result.delta.stop_reason
+
+    response.content.append(TextBlock(type="text", text=content))
+    return response
+
+
 def anthropic_stream_completion(results: list):
     from anthropic.types import Completion
 
@@ -1212,6 +1387,33 @@ def anthropic_stream_completion(results: list):
     return response
 
 
+async def aanthropic_stream_completion(generator: AsyncIterable[Any]) -> Any:
+    from anthropic.types import Completion
+
+    completions: List[Completion] = []
+    text = ""
+    response = Completion(
+        id="",
+        completion="",
+        model="",
+        stop_reason="stop",
+        type="completion",
+    )
+
+    async for completion in generator:
+        completions.append(completion)
+        text = f"{text}{completion.completion}"
+
+    # After collecting all completions, set the response attributes
+    if completions:
+        last_chunk = completions[-1]
+        response.id = last_chunk.id
+        response.model = last_chunk.model
+
+    response.completion = text
+    return response
+
+
 def stream_response(
     generator: Generator, after_stream: Callable, map_results: Callable
 ):
@@ -1232,6 +1434,33 @@ def stream_response(
     yield data
 
 
+async def astream_response(
+    generator: AsyncIterable[Any],
+    after_stream: Callable[..., Any],
+    map_results: Callable[[Any], Any],
+) -> AsyncGenerator[Dict[str, Any], None]:
+    data = {
+        "request_id": None,
+        "raw_response": None,
+        "prompt_blueprint": None,
+    }
+    results = []
+    async for result in generator:
+        results.append(result)
+        data["raw_response"] = result
+        yield data
+    request_response = await map_results(results)
+    if inspect.iscoroutinefunction(after_stream):
+        # after_stream is an async function
+        response = await after_stream(request_response=request_response.model_dump())
+    else:
+        # after_stream is synchronous
+        response = after_stream(request_response=request_response.model_dump())
+    data["request_id"] = response.get("request_id")
+    data["prompt_blueprint"] = response.get("prompt_blueprint")
+    yield data
+
+
 def openai_chat_request(client, **kwargs):
     return client.chat.completions.create(**kwargs)
 
@@ -1256,6 +1485,30 @@ def openai_request(prompt_blueprint: GetPromptTemplateResponse, **kwargs):
     return request_to_make(client, **kwargs)
 
 
+async def aopenai_chat_request(client, **kwargs):
+    return await client.chat.completions.create(**kwargs)
+
+
+async def aopenai_completions_request(client, **kwargs):
+    return await client.completions.create(**kwargs)
+
+
+AMAP_TYPE_TO_OPENAI_FUNCTION = {
+    "chat": aopenai_chat_request,
+    "completion": aopenai_completions_request,
+}
+
+
+async def aopenai_request(prompt_blueprint: GetPromptTemplateResponse, **kwargs):
+    from openai import AsyncOpenAI
+
+    client = AsyncOpenAI(base_url=kwargs.pop("base_url", None))
+    request_to_make = AMAP_TYPE_TO_OPENAI_FUNCTION[
+        prompt_blueprint["prompt_template"]["type"]
+    ]
+    return await request_to_make(client, **kwargs)
+
+
 def azure_openai_request(prompt_blueprint: GetPromptTemplateResponse, **kwargs):
     from openai import AzureOpenAI
 
@@ -1266,6 +1519,16 @@ def azure_openai_request(prompt_blueprint: GetPromptTemplateResponse, **kwargs):
     return request_to_make(client, **kwargs)
 
 
+async def aazure_openai_request(prompt_blueprint: GetPromptTemplateResponse, **kwargs):
+    from openai import AsyncAzureOpenAI
+
+    client = AsyncAzureOpenAI(azure_endpoint=kwargs.pop("base_url", None))
+    request_to_make = AMAP_TYPE_TO_OPENAI_FUNCTION[
+        prompt_blueprint["prompt_template"]["type"]
+    ]
+    return await request_to_make(client, **kwargs)
+
+
 def anthropic_chat_request(client, **kwargs):
     return client.messages.create(**kwargs)
 
@@ -1290,6 +1553,30 @@ def anthropic_request(prompt_blueprint: GetPromptTemplateResponse, **kwargs):
     return request_to_make(client, **kwargs)
 
 
+async def aanthropic_chat_request(client, **kwargs):
+    return await client.messages.create(**kwargs)
+
+
+async def aanthropic_completions_request(client, **kwargs):
+    return await client.completions.create(**kwargs)
+
+
+AMAP_TYPE_TO_ANTHROPIC_FUNCTION = {
+    "chat": aanthropic_chat_request,
+    "completion": aanthropic_completions_request,
+}
+
+
+async def aanthropic_request(prompt_blueprint: GetPromptTemplateResponse, **kwargs):
+    from anthropic import AsyncAnthropic
+
+    client = AsyncAnthropic(base_url=kwargs.pop("base_url", None))
+    request_to_make = AMAP_TYPE_TO_ANTHROPIC_FUNCTION[
+        prompt_blueprint["prompt_template"]["type"]
+    ]
+    return await request_to_make(client, **kwargs)
+
+
 # do not remove! This is used in the langchain integration.
 def get_api_key():
     # raise an error if the api key is not set

{promptlayer-1.0.30.dist-info → promptlayer-1.0.32.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: promptlayer
-Version: 1.0.30
+Version: 1.0.32
 Summary: PromptLayer is a platform for prompt engineering and tracks your LLM requests.
 License: Apache-2.0
 Author: Magniv

{promptlayer-1.0.30.dist-info → promptlayer-1.0.32.dist-info}/RECORD

@@ -1,17 +1,18 @@
-promptlayer/__init__.py,sha256=fuJ1VN-onPtkPxiHDIBM5mPIVoy0iIbjGZtsmmfxo24,140
+promptlayer/__init__.py,sha256=ZWwec3lasIs6PTQi77sYwX746yWKAQc2p8Lg8fLZrO4,140
 promptlayer/groups/__init__.py,sha256=xhOAolLUBkr76ZHvJr29OwjCIk1V9qKQXjZCuyTJUIY,429
 promptlayer/groups/groups.py,sha256=YPROicy-TzpkrpA8vOpZS2lwvJ6VRtlbQ1S2oT1N0vM,338
-promptlayer/promptlayer.py,sha256=O_jMhe3ha6l_hudHry6gsEAAKn6Vx6mfjogWBRpFcqo,21314
+promptlayer/promptlayer.py,sha256=ZzHLMwbF-qq9SXNb610tmAOnGzOEvugGjHp3MtGWMGA,20083
 promptlayer/promptlayer_base.py,sha256=sev-EZehRXJSZSmJtMkqmAUK1345pqbDY_lNjPP5MYA,7158
+promptlayer/promptlayer_mixins.py,sha256=CZRX-kjd067JLzxd0qOWBnOCHdC5CZ4bXFDs7CDMplg,9572
 promptlayer/span_exporter.py,sha256=zIJNsb3Fe6yb5wKLDmkoPF2wqFjk1p39E0jWHD2plzI,2658
 promptlayer/templates.py,sha256=bdX8ZxydWwF9QMF1UBD-qoYqYRPrUSTAt88r2D8ws7c,1193
 promptlayer/track/__init__.py,sha256=8J258daTXb_P8eHRbYR2Au1lJzTh_92UkOHf7q0NpKs,1757
 promptlayer/track/track.py,sha256=UdkCxhWUvhvPdhsoHj4qmeiRq6xLcWmeIdYXrgZph04,3252
 promptlayer/types/__init__.py,sha256=xJcvQuOk91ZBBePb40-1FDNDKYrZoH5lPE2q6_UhprM,111
-promptlayer/types/prompt_template.py,sha256=TUXLXvuvew0EBLfTMBa2LhFeQoF7R-tcFKg7_UUtHMQ,4433
+promptlayer/types/prompt_template.py,sha256=sv5iMV8Iix2LCMUSMTkfb8PohfKp-vR9hRMck8OXSVc,4728
 promptlayer/types/request_log.py,sha256=xU6bcxQar6GaBOJlgZTavXUV3FjE8sF_nSjPu4Ya_00,174
-promptlayer/utils.py,sha256=s_7XMGRjuqTJjPDArixBahsGVlO7xcerxgcVijd12BQ,44690
-promptlayer-1.0.30.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-promptlayer-1.0.30.dist-info/METADATA,sha256=c8OnSggb12m8MlEp2QKVR0uYl_GpHZAmqontn3OaU5M,4824
-promptlayer-1.0.30.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-promptlayer-1.0.30.dist-info/RECORD,,
+promptlayer/utils.py,sha256=yPEzt3JZT7rbVch39Gv8Uk0-CR8Ih5Ym9iIfS0VEEH8,53960
+promptlayer-1.0.32.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+promptlayer-1.0.32.dist-info/METADATA,sha256=5TUZRxITDb2RVq9j9xdHlK8BHTFzp6_HNJjPhK3uKk8,4824
+promptlayer-1.0.32.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+promptlayer-1.0.32.dist-info/RECORD,,