promptlayer 1.0.11__py3-none-any.whl → 1.0.13__py3-none-any.whl

promptlayer/__init__.py

@@ -1,171 +1,4 @@
-import datetime
-import os
-from copy import deepcopy
-from typing import Any, Dict, List, Literal, Union
+from .promptlayer import PromptLayer
 
-from promptlayer.groups import GroupManager
-from promptlayer.promptlayer import PromptLayerBase
-from promptlayer.templates import TemplateManager
-from promptlayer.track import TrackManager
-from promptlayer.types.prompt_template import GetPromptTemplate
-from promptlayer.utils import (
-    anthropic_request,
-    anthropic_stream_completion,
-    anthropic_stream_message,
-    openai_request,
-    openai_stream_chat,
-    openai_stream_completion,
-    stream_response,
-    track_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,
-        },
-    },
-}
-
-MAP_PROVIDER_TO_FUNCTION = {
-    "openai": openai_request,
-    "anthropic": anthropic_request,
-}
-
-
-class PromptLayer:
-    def __init__(self, api_key: str = None):
-        if api_key is None:
-            api_key = os.environ.get("PROMPTLAYER_API_KEY")
-        if api_key is None:
-            raise ValueError(
-                "PromptLayer API key not provided. Please set the PROMPTLAYER_API_KEY environment variable or pass the api_key parameter."
-            )
-        self.api_key = api_key
-        self.templates = TemplateManager(api_key)
-        self.group = GroupManager(api_key)
-        self.track = TrackManager(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}")
-
-    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,
-        tags: Union[List[str], None] = None,
-        metadata: Union[Dict[str, str], None] = None,
-        group_id: Union[int, None] = None,
-        stream=False,
-    ):
-        template_get_params: GetPromptTemplate = {}
-        if prompt_version:
-            template_get_params["version"] = prompt_version
-        if prompt_release_label:
-            template_get_params["label"] = prompt_release_label
-        if input_variables:
-            template_get_params["input_variables"] = input_variables
-        if metadata:
-            template_get_params["metadata_filters"] = metadata
-        prompt_blueprint = self.templates.get(prompt_name, template_get_params)
-        prompt_template = prompt_blueprint["prompt_template"]
-        if not prompt_blueprint["llm_kwargs"]:
-            raise Exception(
-                f"Prompt '{prompt_name}' does not have any LLM kwargs associated with it."
-            )
-        prompt_blueprint_metadata = prompt_blueprint.get("metadata", None)
-        if prompt_blueprint_metadata is None:
-            raise Exception(
-                f"Prompt '{prompt_name}' does not have any metadata associated with it."
-            )
-        prompt_blueprint_model = prompt_blueprint_metadata.get("model", None)
-        if prompt_blueprint_model is None:
-            raise Exception(
-                f"Prompt '{prompt_name}' does not have a model parameters associated with it."
-            )
-        provider = prompt_blueprint_model["provider"]
-        request_start_time = datetime.datetime.now(datetime.timezone.utc).timestamp()
-        kwargs = deepcopy(prompt_blueprint["llm_kwargs"])
-        config = MAP_PROVIDER_TO_FUNCTION_NAME[provider][prompt_template["type"]]
-        function_name = config["function_name"]
-        stream_function = config["stream_function"]
-        request_function = MAP_PROVIDER_TO_FUNCTION[provider]
-        provider_base_url = prompt_blueprint.get("provider_base_url", None)
-        if provider_base_url:
-            kwargs["base_url"] = provider_base_url["url"]
-        kwargs["stream"] = stream
-        if stream and provider == "openai":
-            kwargs["stream_options"] = {"include_usage": True}
-        response = request_function(prompt_blueprint, **kwargs)
-
-        def _track_request(**body):
-            request_end_time = datetime.datetime.now(datetime.timezone.utc).timestamp()
-            return track_request(
-                function_name=function_name,
-                provider_type=provider,
-                args=[],
-                kwargs=kwargs,
-                tags=tags,
-                request_start_time=request_start_time,
-                request_end_time=request_end_time,
-                api_key=self.api_key,
-                metadata=metadata,
-                prompt_id=prompt_blueprint["id"],
-                prompt_version=prompt_blueprint["version"],
-                prompt_input_variables=input_variables,
-                group_id=group_id,
-                return_prompt_blueprint=True,
-                **body,
-            )
-
-        if stream:
-            return stream_response(response, _track_request, stream_function)
-        request_log = _track_request(request_response=response.model_dump())
-        data = {
-            "request_id": request_log.get("request_id", None),
-            "raw_response": response,
-            "prompt_blueprint": request_log.get("prompt_blueprint", None),
-        }
-        return data
-
-
-__version__ = "1.0.11"
+__version__ = "1.0.13"
 __all__ = ["PromptLayer", "__version__"]

promptlayer/promptlayer.py

@@ -1,96 +1,417 @@
+import asyncio
 import datetime
-import inspect
-import re
-
-from promptlayer.utils import async_wrapper, promptlayer_api_handler
-
-
-class PromptLayerBase(object):
-    __slots__ = ["_obj", "__weakref__", "_function_name", "_provider_type", "_api_key"]
-
-    def __init__(self, obj, function_name="", provider_type="openai", api_key=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)
-
-    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 (
-                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 re.match(r"<class 'openai\.resources.*'>", str(type(attr)))
+import os
+from copy import deepcopy
+from functools import wraps
+from typing import Any, Dict, List, Literal, Union
+
+from opentelemetry import trace
+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 GroupManager
+from promptlayer.promptlayer_base import PromptLayerBase
+from promptlayer.span_exporter import PromptLayerSpanExporter
+from promptlayer.templates import TemplateManager
+from promptlayer.track import TrackManager
+from promptlayer.utils import (
+    anthropic_request,
+    anthropic_stream_completion,
+    anthropic_stream_message,
+    openai_request,
+    openai_stream_chat,
+    openai_stream_completion,
+    stream_response,
+    track_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,
+        },
+    },
+}
+
+MAP_PROVIDER_TO_FUNCTION = {
+    "openai": openai_request,
+    "anthropic": anthropic_request,
+}
+
+
+class PromptLayer:
+    def __init__(
+        self,
+        api_key: str = None,
+        enable_tracing: bool = False,
+        workspace_id: int = None,
+    ):
+        if api_key is None:
+            api_key = os.environ.get("PROMPTLAYER_API_KEY")
+
+        if api_key is None:
+            raise ValueError(
+                "PromptLayer API key not provided. "
+                "Please set the PROMPTLAYER_API_KEY environment variable or pass the api_key parameter."
             )
-        ):
-            return PromptLayerBase(
-                attr,
-                function_name=f'{object.__getattribute__(self, "_function_name")}.{name}',
-                provider_type=object.__getattribute__(self, "_provider_type"),
-                api_key=object.__getattribute__(self, "_api_key"),
+
+        if enable_tracing and not workspace_id:
+            raise ValueError("Please set a workspace_id to enable tracing.")
+
+        self.api_key = api_key
+        self.templates = TemplateManager(api_key)
+        self.group = GroupManager(api_key)
+        self.tracer = self._initialize_tracer(api_key, enable_tracing, workspace_id)
+        self.track = TrackManager(api_key)
+        self.workspace_id = workspace_id
+
+    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,
+                tracer=self.tracer,
             )
-        return attr
-
-    def __delattr__(self, name):
-        delattr(object.__getattribute__(self, "_obj"), name)
-
-    def __setattr__(self, name, value):
-        setattr(object.__getattribute__(self, "_obj"), name, value)
-
-    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.")
-        return_pl_id = kwargs.pop("return_pl_id", False)
-        request_start_time = datetime.datetime.now().timestamp()
-        function_object = object.__getattribute__(self, "_obj")
-        if inspect.isclass(function_object):
-            return PromptLayerBase(
-                function_object(*args, **kwargs),
-                function_name=object.__getattribute__(self, "_function_name"),
-                provider_type=object.__getattribute__(self, "_provider_type"),
-                api_key=object.__getattribute__(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,
+                tracer=self.tracer,
             )
-        function_response = function_object(*args, **kwargs)
-        if inspect.iscoroutinefunction(function_object) or inspect.iscoroutine(
-            function_response
-        ):
-            return async_wrapper(
-                function_response,
-                return_pl_id,
-                request_start_time,
-                object.__getattribute__(self, "_function_name"),
-                object.__getattribute__(self, "_provider_type"),
-                tags,
-                api_key=object.__getattribute__(self, "_api_key"),
-                *args,
-                **kwargs,
+            return anthropic
+        else:
+            raise AttributeError(f"module {__name__} has no attribute {name}")
+
+    def _create_track_request_callable(
+        self, request_params, tags, input_variables, group_id, span_id
+    ):
+        def _track_request(**body):
+            track_request_kwargs = self._prepare_track_request_kwargs(
+                request_params, tags, input_variables, group_id, span_id, **body
             )
-        request_end_time = datetime.datetime.now().timestamp()
-        return promptlayer_api_handler(
-            object.__getattribute__(self, "_function_name"),
-            object.__getattribute__(self, "_provider_type"),
-            args,
-            kwargs,
+            if self.tracer:
+                with self.tracer.start_as_current_span("track_request"):
+                    return track_request(**track_request_kwargs)
+            return track_request(**track_request_kwargs)
+
+        return _track_request
+
+    def _fetch_prompt_blueprint(self, *, prompt_name, template_params):
+        if self.tracer:
+            with self.tracer.start_as_current_span("fetch_prompt_template") as span:
+                span.set_attribute("prompt_name", prompt_name)
+                span.set_attribute(
+                    "function_input",
+                    str(
+                        {"prompt_name": prompt_name, "template_params": template_params}
+                    ),
+                )
+                result = self.templates.get(prompt_name, template_params)
+                span.set_attribute("function_output", str(result))
+                return result
+        return self.templates.get(prompt_name, template_params)
+
+    @staticmethod
+    def _initialize_tracer(
+        api_key: str = None, enable_tracing: bool = False, workspace_id: int = None
+    ):
+        if enable_tracing:
+            resource = Resource(
+                attributes={ResourceAttributes.SERVICE_NAME: "prompt-layer-library"}
+            )
+            tracer_provider = TracerProvider(resource=resource)
+            promptlayer_exporter = PromptLayerSpanExporter(
+                api_key=api_key, workspace_id=workspace_id
+            )
+            span_processor = BatchSpanProcessor(promptlayer_exporter)
+            tracer_provider.add_span_processor(span_processor)
+            trace.set_tracer_provider(tracer_provider)
+            return trace.get_tracer(__name__)
+        else:
+            return None
+
+    def _make_llm_request(self, request_params):
+        span_id = None
+
+        if self.tracer:
+            with self.tracer.start_as_current_span("llm_request") as span:
+                span.set_attribute("provider", request_params["provider"])
+                span.set_attribute("function_name", request_params["function_name"])
+                span.set_attribute("function_input", str(request_params))
+                span_id = hex(span.context.span_id)[2:].zfill(16)
+                response = request_params["request_function"](
+                    request_params["prompt_blueprint"], **request_params["kwargs"]
+                )
+                span.set_attribute("function_output", str(response))
+        else:
+            response = request_params["request_function"](
+                request_params["prompt_blueprint"], **request_params["kwargs"]
+            )
+
+        return response, span_id
+
+    @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, 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"]
+
+        kwargs["stream"] = stream
+        if stream and provider == "openai":
+            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, span_id, **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": request_params.get("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": span_id,
+            **body,
+        }
+
+    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,
+        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]:
+        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 = self._fetch_prompt_blueprint(
+            prompt_name=prompt_name, template_params=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,
+            stream=stream,
+        )
+
+        response, span_id = self._make_llm_request(llm_request_params)
+
+        if stream:
+            return stream_response(
+                response,
+                self._create_track_request_callable(
+                    llm_request_params, tags, input_variables, group_id, span_id
+                ),
+                llm_request_params["stream_function"],
+            )
+
+        request_log = self._track_request_log(
+            llm_request_params,
             tags,
-            function_response,
-            request_start_time,
-            request_end_time,
-            object.__getattribute__(self, "_api_key"),
-            return_pl_id=return_pl_id,
+            input_variables,
+            group_id,
+            span_id,
+            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),
+        }
+
+    def _track_request_log(
+        self, request_params, tags, input_variables, group_id, span_id, **body
+    ):
+        track_request_kwargs = self._prepare_track_request_kwargs(
+            request_params, tags, input_variables, group_id, span_id, **body
+        )
+        if self.tracer:
+            with self.tracer.start_as_current_span("track_request") as span:
+                span.set_attribute("function_input", str(track_request_kwargs))
+                result = track_request(**track_request_kwargs)
+                span.set_attribute("function_output", str(result))
+                return result
+        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,
+        prompt_version: Union[int, None] = None,
+        prompt_release_label: Union[str, None] = None,
+        input_variables: 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,
+            "tags": tags,
+            "metadata": metadata,
+            "group_id": group_id,
+            "stream": stream,
+        }
+
+        if self.tracer:
+            with self.tracer.start_as_current_span("PromptLayer.run") as main_span:
+                main_span.set_attribute("prompt_name", prompt_name)
+                main_span.set_attribute("stream", stream)
+                main_span.set_attribute("function_input", str(_run_internal_kwargs))
+                result = self._run_internal(**_run_internal_kwargs)
+                main_span.set_attribute("function_output", str(result))
+                return result
+        else:
+            return self._run_internal(**_run_internal_kwargs)
+
+    def traceable(self, metadata=None):
+        def decorator(func):
+            @wraps(func)
+            def sync_wrapper(*args, **kwargs):
+                if self.tracer:
+                    with self.tracer.start_as_current_span(func.__name__) as span:
+                        if metadata:
+                            for key, value in metadata.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:
+                    with self.tracer.start_as_current_span(func.__name__) as span:
+                        if metadata:
+                            for key, value in metadata.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/promptlayer_base.py

@@ -0,0 +1,176 @@
+import datetime
+import inspect
+import re
+
+from promptlayer.utils import async_wrapper, promptlayer_api_handler
+
+
+class PromptLayerBase(object):
+    __slots__ = [
+        "_obj",
+        "__weakref__",
+        "_function_name",
+        "_provider_type",
+        "_api_key",
+        "_tracer",
+    ]
+
+    def __init__(
+        self, obj, function_name="", provider_type="openai", api_key=None, 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)
+
+    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 (
+                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 re.match(r"<class 'openai\.resources.*'>", str(type(attr)))
+            )
+        ):
+            return PromptLayerBase(
+                attr,
+                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
+
+    def __delattr__(self, name):
+        delattr(object.__getattribute__(self, "_obj"), name)
+
+    def __setattr__(self, name, value):
+        setattr(object.__getattribute__(self, "_obj"), name, value)
+
+    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.")
+
+        return_pl_id = kwargs.pop("return_pl_id", False)
+        request_start_time = datetime.datetime.now().timestamp()
+        function_object = object.__getattribute__(self, "_obj")
+        tracer = object.__getattribute__(self, "_tracer")
+        function_name = object.__getattribute__(self, "_function_name")
+
+        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.set_attribute("function_name", function_name)
+                llm_request_span.set_attribute(
+                    "function_input", str({"args": args, "kwargs": kwargs})
+                )
+
+                if inspect.isclass(function_object):
+                    result = PromptLayerBase(
+                        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))
+                    return result
+
+                function_response = function_object(*args, **kwargs)
+
+                if inspect.iscoroutinefunction(function_object) or inspect.iscoroutine(
+                    function_response
+                ):
+                    return async_wrapper(
+                        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,
+                        **kwargs,
+                    )
+
+                request_end_time = datetime.datetime.now().timestamp()
+                result = promptlayer_api_handler(
+                    function_name,
+                    object.__getattribute__(self, "_provider_type"),
+                    args,
+                    kwargs,
+                    tags,
+                    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,
+                )
+                llm_request_span.set_attribute("function_output", str(result))
+                return result
+        else:
+            # Without tracing
+            if inspect.isclass(function_object):
+                return PromptLayerBase(
+                    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
+            ):
+                return async_wrapper(
+                    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(
+                function_name,
+                object.__getattribute__(self, "_provider_type"),
+                args,
+                kwargs,
+                tags,
+                function_response,
+                request_start_time,
+                request_end_time,
+                object.__getattribute__(self, "_api_key"),
+                return_pl_id=return_pl_id,
+            )

promptlayer/span_exporter.py

@@ -0,0 +1,77 @@
+from typing import Sequence
+
+import requests
+from opentelemetry.sdk.trace import ReadableSpan
+from opentelemetry.sdk.trace.export import SpanExporter, SpanExportResult
+
+from promptlayer.utils import URL_API_PROMPTLAYER
+
+
+class PromptLayerSpanExporter(SpanExporter):
+    def __init__(self, api_key: str = None, workspace_id: int = None):
+        self.api_key = api_key
+        self.url = f"{URL_API_PROMPTLAYER}/spans-bulk"
+        self.workspace_id = workspace_id
+
+    def export(self, spans: Sequence[ReadableSpan]) -> SpanExportResult:
+        request_data = []
+
+        for span in spans:
+            span_info = {
+                "name": span.name,
+                "context": {
+                    "trace_id": hex(span.context.trace_id)[2:].zfill(
+                        32
+                    ),  # Ensure 32 characters
+                    "span_id": hex(span.context.span_id)[2:].zfill(
+                        16
+                    ),  # Ensure 16 characters
+                    "trace_state": str(span.context.trace_state),
+                },
+                "kind": str(span.kind),
+                "parent_id": hex(span.parent.span_id)[2:] if span.parent else None,
+                "start_time": span.start_time,
+                "end_time": span.end_time,
+                "status": {
+                    "status_code": str(span.status.status_code),
+                    "description": span.status.description,
+                },
+                "attributes": dict(span.attributes),
+                "events": [
+                    {
+                        "name": event.name,
+                        "timestamp": event.timestamp,
+                        "attributes": dict(event.attributes),
+                    }
+                    for event in span.events
+                ],
+                "links": [
+                    {"context": link.context, "attributes": dict(link.attributes)}
+                    for link in span.links
+                ],
+                "resource": {
+                    "attributes": dict(span.resource.attributes),
+                    "schema_url": span.resource.schema_url,
+                },
+            }
+            request_data.append(span_info)
+
+        try:
+            response = requests.post(
+                self.url,
+                headers={
+                    "X-Api-Key": self.api_key,
+                    "Content-Type": "application/json",
+                },
+                json={
+                    "spans": request_data,
+                    "workspace_id": self.workspace_id,
+                },
+            )
+            response.raise_for_status()
+            return SpanExportResult.SUCCESS
+        except requests.RequestException:
+            return SpanExportResult.FAILURE
+
+    def shutdown(self):
+        pass

promptlayer/utils.py

@@ -11,6 +11,7 @@ from enum import Enum
 from typing import Callable, Generator, List, Union
 
 import requests
+from opentelemetry import context, trace
 
 from promptlayer.types.prompt_template import (
     GetPromptTemplate,
@@ -36,6 +37,7 @@ def promptlayer_api_handler(
     request_end_time,
     api_key,
     return_pl_id=False,
+    llm_request_span_id=None,
 ):
     if (
         isinstance(response, types.GeneratorType)
@@ -49,8 +51,8 @@ def promptlayer_api_handler(
         ]
     ):
         return GeneratorProxy(
-            response,
-            {
+            generator=response,
+            api_request_arguments={
                 "function_name": function_name,
                 "provider_type": provider_type,
                 "args": args,
@@ -59,21 +61,23 @@ def promptlayer_api_handler(
                 "request_start_time": request_start_time,
                 "request_end_time": request_end_time,
                 "return_pl_id": return_pl_id,
+                "llm_request_span_id": llm_request_span_id,
             },
-            api_key,
+            api_key=api_key,
         )
     else:
         request_id = promptlayer_api_request(
-            function_name,
-            provider_type,
-            args,
-            kwargs,
-            tags,
-            response,
-            request_start_time,
-            request_end_time,
-            api_key,
+            function_name=function_name,
+            provider_type=provider_type,
+            args=args,
+            kwargs=kwargs,
+            tags=tags,
+            response=response,
+            request_start_time=request_start_time,
+            request_end_time=request_end_time,
+            api_key=api_key,
             return_pl_id=return_pl_id,
+            llm_request_span_id=llm_request_span_id,
         )
         if return_pl_id:
             return response, request_id
@@ -91,6 +95,7 @@ async def promptlayer_api_handler_async(
     request_end_time,
     api_key,
     return_pl_id=False,
+    llm_request_span_id=None,
 ):
     return await run_in_thread_async(
         None,
@@ -105,6 +110,7 @@ async def promptlayer_api_handler_async(
         request_end_time,
         api_key,
         return_pl_id=return_pl_id,
+        llm_request_span_id=llm_request_span_id,
     )
 
 
@@ -124,6 +130,7 @@ def convert_native_object_to_dict(native_object):
 
 
 def promptlayer_api_request(
+    *,
     function_name,
     provider_type,
     args,
@@ -135,6 +142,7 @@ def promptlayer_api_request(
     api_key,
     return_pl_id=False,
     metadata=None,
+    llm_request_span_id=None,
 ):
     if isinstance(response, dict) and hasattr(response, "to_dict_recursive"):
         response = response.to_dict_recursive()
@@ -157,6 +165,7 @@ def promptlayer_api_request(
                 "request_end_time": request_end_time,
                 "metadata": metadata,
                 "api_key": api_key,
+                "span_id": llm_request_span_id,
             },
         )
         if not hasattr(request_response, "status_code"):
@@ -178,6 +187,26 @@ def promptlayer_api_request(
         return request_response.json().get("request_id")
 
 
+def track_request(**body):
+    try:
+        response = requests.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 requests.exceptions.RequestException 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,
@@ -193,15 +222,15 @@ def promptlayer_api_request_async(
     return run_in_thread_async(
         None,
         promptlayer_api_request,
-        function_name,
-        provider_type,
-        args,
-        kwargs,
-        tags,
-        response,
-        request_start_time,
-        request_end_time,
-        api_key,
+        function_name=function_name,
+        provider_type=provider_type,
+        args=args,
+        kwargs=kwargs,
+        tags=tags,
+        response=response,
+        request_start_time=request_start_time,
+        request_end_time=request_end_time,
+        api_key=api_key,
         return_pl_id=return_pl_id,
     )
 
@@ -396,6 +425,7 @@ class GeneratorProxy:
         self.results.append(result)
         provider_type = self.api_request_arugments["provider_type"]
         end_anthropic = False
+
         if provider_type == "anthropic":
             if hasattr(result, "stop_reason"):
                 end_anthropic = result.stop_reason
@@ -403,6 +433,7 @@ class GeneratorProxy:
                 end_anthropic = result.message.stop_reason
             elif hasattr(result, "type") and result.type == "message_stop":
                 end_anthropic = True
+
         end_openai = provider_type == "openai" and (
             result.choices[0].finish_reason == "stop"
             or result.choices[0].finish_reason == "length"
@@ -410,21 +441,27 @@ class GeneratorProxy:
 
         if end_anthropic or end_openai:
             request_id = promptlayer_api_request(
-                self.api_request_arugments["function_name"],
-                self.api_request_arugments["provider_type"],
-                self.api_request_arugments["args"],
-                self.api_request_arugments["kwargs"],
-                self.api_request_arugments["tags"],
-                self.cleaned_result(),
-                self.api_request_arugments["request_start_time"],
-                self.api_request_arugments["request_end_time"],
-                self.api_key,
+                function_name=self.api_request_arugments["function_name"],
+                provider_type=self.api_request_arugments["provider_type"],
+                args=self.api_request_arugments["args"],
+                kwargs=self.api_request_arugments["kwargs"],
+                tags=self.api_request_arugments["tags"],
+                response=self.cleaned_result(),
+                request_start_time=self.api_request_arugments["request_start_time"],
+                request_end_time=self.api_request_arugments["request_end_time"],
+                api_key=self.api_key,
                 return_pl_id=self.api_request_arugments["return_pl_id"],
+                llm_request_span_id=self.api_request_arugments.get(
+                    "llm_request_span_id"
+                ),
             )
+
             if self.api_request_arugments["return_pl_id"]:
                 return result, request_id
+
         if self.api_request_arugments["return_pl_id"]:
             return result, None
+
         return result
 
     def cleaned_result(self):
@@ -531,23 +568,39 @@ async def async_wrapper(
     provider_type,
     tags,
     api_key: str = None,
+    llm_request_span_id: str = None,
+    tracer=None,
     *args,
     **kwargs,
 ):
-    response = await coroutine_obj
-    request_end_time = datetime.datetime.now().timestamp()
-    return await promptlayer_api_handler_async(
-        function_name,
-        provider_type,
-        args,
-        kwargs,
-        tags,
-        response,
-        request_start_time,
-        request_end_time,
-        api_key,
-        return_pl_id=return_pl_id,
-    )
+    current_context = context.get_current()
+    token = context.attach(current_context)
+
+    try:
+        response = await coroutine_obj
+        request_end_time = datetime.datetime.now().timestamp()
+        result = await promptlayer_api_handler_async(
+            function_name,
+            provider_type,
+            args,
+            kwargs,
+            tags,
+            response,
+            request_start_time,
+            request_end_time,
+            api_key,
+            return_pl_id=return_pl_id,
+            llm_request_span_id=llm_request_span_id,
+        )
+
+        if tracer:
+            current_span = trace.get_current_span()
+            if current_span:
+                current_span.set_attribute("function_output", str(result))
+
+        return result
+    finally:
+        context.detach(token)
 
 
 def promptlayer_create_group(api_key: str = None):
@@ -665,26 +718,6 @@ def get_all_prompt_templates(
         )
 
 
-def track_request(**body):
-    try:
-        response = requests.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 requests.exceptions.RequestException as e:
-        print(
-            f"WARNING: While logging your request PromptLayer had the following error: {e}",
-            file=sys.stderr,
-        )
-        return {}
-
-
 def openai_stream_chat(results: list):
     from openai.types.chat import (
         ChatCompletion,

{promptlayer-1.0.11.dist-info → promptlayer-1.0.13.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: promptlayer
-Version: 1.0.11
+Version: 1.0.13
 Summary: PromptLayer is a platform for prompt engineering and tracks your LLM requests.
 License: Apache-2.0
 Author: Magniv
@@ -12,6 +12,8 @@ Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: opentelemetry-api (>=1.26.0,<2.0.0)
+Requires-Dist: opentelemetry-sdk (>=1.26.0,<2.0.0)
 Requires-Dist: requests (>=2.31.0,<3.0.0)
 Description-Content-Type: text/markdown
 

promptlayer-1.0.13.dist-info/RECORD

@@ -0,0 +1,16 @@
+promptlayer/__init__.py,sha256=n3ZkXiXzVzdqDwSJz8GiMPtZkRoDHGzQ4IlBKuCY2h4,102
+promptlayer/groups/__init__.py,sha256=-xs-2cn0nc0D_5YxZr3nC86iTdRVZmBhEpOKDJXE-sQ,224
+promptlayer/groups/groups.py,sha256=yeO6T0TM3qB0ondZRiHhcH8G06YygrpFoM8b9RmoIao,165
+promptlayer/promptlayer.py,sha256=Qi0-rrEsmVhT-VtBm5MtKKVI6mOpO39YvFlLppMdGP4,15519
+promptlayer/promptlayer_base.py,sha256=sev-EZehRXJSZSmJtMkqmAUK1345pqbDY_lNjPP5MYA,7158
+promptlayer/span_exporter.py,sha256=b8sn9bJIUbYDmme5Md3g2K3X62RGDPMDYdkk_8ZETbk,2780
+promptlayer/templates.py,sha256=aY_-BCrL0AgIdYEUE28pi0AP_avTVAgwv5hgzrh75vo,717
+promptlayer/track/__init__.py,sha256=VheO_Au0lffGlPKYYPQwkv8ci16wSXABCVSNRoFWu_w,945
+promptlayer/track/track.py,sha256=XNEZT9yNiRBPp9vaDZo_f0dP_ldOu8q1qafpVfS5Ze8,1610
+promptlayer/types/__init__.py,sha256=ulWSyCrk5hZ_PI-nKGpd6GPcRaK8lqP4wFl0LPNUYWk,61
+promptlayer/types/prompt_template.py,sha256=QbxYSeIubrwp8KmDKdt9syAwzONFPh_So9yr4H73ANQ,4429
+promptlayer/utils.py,sha256=-p0qapUvkZYJd_Dfat3c8LANXWU1JN0bJB91IyjB8iA,29656
+promptlayer-1.0.13.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+promptlayer-1.0.13.dist-info/METADATA,sha256=fasBS56ZGwGFuoCtHb57dPiq6S1alUnptzyg0dBrE-o,4609
+promptlayer-1.0.13.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+promptlayer-1.0.13.dist-info/RECORD,,

promptlayer-1.0.11.dist-info/RECORD

@@ -1,14 +0,0 @@
-promptlayer/__init__.py,sha256=Nk_YAsoldO0cNy-KQ9rlsdzRryWr9oEJMjqAIlXiOvs,6379
-promptlayer/groups/__init__.py,sha256=-xs-2cn0nc0D_5YxZr3nC86iTdRVZmBhEpOKDJXE-sQ,224
-promptlayer/groups/groups.py,sha256=yeO6T0TM3qB0ondZRiHhcH8G06YygrpFoM8b9RmoIao,165
-promptlayer/promptlayer.py,sha256=1q1cZOBt27Luzu3aRWcYUjQiKbmwrF9R62Uw95Ryqqc,4035
-promptlayer/templates.py,sha256=aY_-BCrL0AgIdYEUE28pi0AP_avTVAgwv5hgzrh75vo,717
-promptlayer/track/__init__.py,sha256=VheO_Au0lffGlPKYYPQwkv8ci16wSXABCVSNRoFWu_w,945
-promptlayer/track/track.py,sha256=XNEZT9yNiRBPp9vaDZo_f0dP_ldOu8q1qafpVfS5Ze8,1610
-promptlayer/types/__init__.py,sha256=ulWSyCrk5hZ_PI-nKGpd6GPcRaK8lqP4wFl0LPNUYWk,61
-promptlayer/types/prompt_template.py,sha256=QbxYSeIubrwp8KmDKdt9syAwzONFPh_So9yr4H73ANQ,4429
-promptlayer/utils.py,sha256=AgzU6dcqUNkek_iH5Gh8nR8YiLOMiah3ejnC9l2Y9XE,28335
-promptlayer-1.0.11.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-promptlayer-1.0.11.dist-info/METADATA,sha256=SYsOwgSi9oSzv36_4s3uEHjQ9kFJ6C9SZfx9LcTF3y0,4507
-promptlayer-1.0.11.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-promptlayer-1.0.11.dist-info/RECORD,,