promptlayer 1.0.50__tar.gz → 1.0.52__tar.gz

{promptlayer-1.0.50 → promptlayer-1.0.52}/PKG-INFO

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

{promptlayer-1.0.50 → promptlayer-1.0.52}/promptlayer/__init__.py

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

{promptlayer-1.0.50 → promptlayer-1.0.52}/promptlayer/promptlayer.py

@@ -137,7 +137,7 @@ class PromptLayer(PromptLayerMixin):
         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(
+        llm_data = self._prepare_llm_data(
             prompt_blueprint=prompt_blueprint,
             prompt_template=prompt_blueprint["prompt_template"],
             prompt_blueprint_model=prompt_blueprint_model,
@@ -145,24 +145,30 @@ class PromptLayer(PromptLayerMixin):
             stream=stream,
         )
 
-        response = llm_request_params["request_function"](
-            llm_request_params["prompt_blueprint"], **llm_request_params["kwargs"]
+        # response is just whatever the LLM call returns
+        # streaming=False > Pydantic model instance
+        # streaming=True > generator that yields ChatCompletionChunk pieces as they arrive
+        response = llm_data["request_function"](
+            prompt_blueprint=llm_data["prompt_blueprint"],
+            client_kwargs=llm_data["client_kwargs"],
+            function_kwargs=llm_data["function_kwargs"],
         )
 
         if stream:
             return stream_response(
-                response,
-                self._create_track_request_callable(
-                    request_params=llm_request_params,
+                generator=response,
+                after_stream=self._create_track_request_callable(
+                    request_params=llm_data,
                     tags=tags,
                     input_variables=input_variables,
                     group_id=group_id,
                     pl_run_span_id=pl_run_span_id,
                 ),
-                llm_request_params["stream_function"],
+                map_results=llm_data["stream_function"],
             )
+
         request_log = self._track_request_log(
-            llm_request_params,
+            llm_data,
             tags,
             input_variables,
             group_id,
@@ -387,7 +393,7 @@ class AsyncPromptLayer(PromptLayerMixin):
         # Allows `workflow_name` to be passed both as keyword and positional argument
         # (virtually identical to `workflow_id_or_name`)
         workflow_name: Optional[str] = None,
-    ) -> Dict[str, Any]:
+    ) -> Union[Dict[str, Any], Any]:
         try:
             return await arun_workflow_request(
                 workflow_id_or_name=_get_workflow_workflow_id_or_name(workflow_id_or_name, workflow_name),
@@ -551,7 +557,7 @@ class AsyncPromptLayer(PromptLayerMixin):
         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(
+        llm_data = self._prepare_llm_data(
             prompt_blueprint=prompt_blueprint,
             prompt_template=prompt_blueprint["prompt_template"],
             prompt_blueprint_model=prompt_blueprint_model,
@@ -560,13 +566,15 @@ class AsyncPromptLayer(PromptLayerMixin):
             is_async=True,
         )
 
-        response = await llm_request_params["request_function"](
-            llm_request_params["prompt_blueprint"], **llm_request_params["kwargs"]
+        response = await llm_data["request_function"](
+            prompt_blueprint=llm_data["prompt_blueprint"],
+            client_kwargs=llm_data["client_kwargs"],
+            function_kwargs=llm_data["function_kwargs"],
         )
 
         if stream:
             track_request_callable = await self._create_track_request_callable(
-                request_params=llm_request_params,
+                request_params=llm_data,
                 tags=tags,
                 input_variables=input_variables,
                 group_id=group_id,
@@ -575,11 +583,11 @@ class AsyncPromptLayer(PromptLayerMixin):
             return astream_response(
                 response,
                 track_request_callable,
-                llm_request_params["stream_function"],
+                llm_data["stream_function"],
             )
 
         request_log = await self._track_request_log(
-            llm_request_params,
+            llm_data,
             tags,
             input_variables,
             group_id,

{promptlayer-1.0.50 → promptlayer-1.0.52}/promptlayer/promptlayer_mixins.py

@@ -2,7 +2,7 @@ import asyncio
 import datetime
 from copy import deepcopy
 from functools import wraps
-from typing import Dict, Union
+from typing import Any, Dict, Union
 
 from opentelemetry.sdk.resources import Resource
 from opentelemetry.sdk.trace import TracerProvider
@@ -92,11 +92,11 @@ MAP_PROVIDER_TO_FUNCTION_NAME = {
 
 
 MAP_PROVIDER_TO_FUNCTION = {
-    "openai": openai_request,
     "anthropic": anthropic_request,
-    "openai.azure": azure_openai_request,
-    "mistral": mistral_request,
     "google": google_request,
+    "mistral": mistral_request,
+    "openai": openai_request,
+    "openai.azure": azure_openai_request,
 }
 
 AMAP_PROVIDER_TO_FUNCTION_NAME = {
@@ -154,11 +154,11 @@ AMAP_PROVIDER_TO_FUNCTION_NAME = {
 
 
 AMAP_PROVIDER_TO_FUNCTION = {
-    "openai": aopenai_request,
     "anthropic": aanthropic_request,
-    "openai.azure": aazure_openai_request,
-    "mistral": amistral_request,
     "google": agoogle_request,
+    "mistral": amistral_request,
+    "openai": aopenai_request,
+    "openai.azure": aazure_openai_request,
 }
 
 
@@ -177,7 +177,13 @@ class PromptLayerMixin:
             return None, None
 
     @staticmethod
-    def _prepare_get_prompt_template_params(*, prompt_version, prompt_release_label, input_variables, metadata):
+    def _prepare_get_prompt_template_params(
+        *,
+        prompt_version: Union[int, None],
+        prompt_release_label: Union[str, None],
+        input_variables: Union[Dict[str, Any], None],
+        metadata: Union[Dict[str, str], None],
+    ) -> Dict[str, Any]:
         params = {}
 
         if prompt_version:
@@ -192,7 +198,7 @@ class PromptLayerMixin:
         return params
 
     @staticmethod
-    def _prepare_llm_request_params(
+    def _prepare_llm_data(
         *,
         prompt_blueprint,
         prompt_template,
@@ -201,8 +207,26 @@ class PromptLayerMixin:
         stream,
         is_async=False,
     ):
+        client_kwargs = {}
+        function_kwargs = deepcopy(prompt_blueprint["llm_kwargs"])
+        function_kwargs["stream"] = stream
         provider = prompt_blueprint_model["provider"]
-        kwargs = deepcopy(prompt_blueprint["llm_kwargs"])
+
+        if custom_provider := prompt_blueprint.get("custom_provider"):
+            provider = custom_provider["client"]
+            client_kwargs = {
+                "api_key": custom_provider["api_key"],
+                "base_url": custom_provider["base_url"],
+            }
+        elif provider_base_url := prompt_blueprint.get("provider_base_url"):
+            client_kwargs["base_url"] = provider_base_url["url"]
+
+        if model_parameter_overrides:
+            function_kwargs.update(model_parameter_overrides)
+
+        if stream and provider in ["openai", "openai.azure"]:
+            function_kwargs["stream_options"] = {"include_usage": True}
+
         if is_async:
             config = AMAP_PROVIDER_TO_FUNCTION_NAME[provider][prompt_template["type"]]
             request_function = AMAP_PROVIDER_TO_FUNCTION[provider]
@@ -210,22 +234,13 @@ class PromptLayerMixin:
             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,
+            "client_kwargs": client_kwargs,
+            "function_kwargs": function_kwargs,
             "prompt_blueprint": prompt_blueprint,
         }
 
@@ -263,7 +278,7 @@ class PromptLayerMixin:
             "function_name": request_params["function_name"],
             "provider_type": request_params["provider"],
             "args": [],
-            "kwargs": request_params["kwargs"],
+            "kwargs": request_params["function_kwargs"],
             "tags": tags,
             "request_start_time": datetime.datetime.now(datetime.timezone.utc).timestamp(),
             "request_end_time": datetime.datetime.now(datetime.timezone.utc).timestamp(),

{promptlayer-1.0.50 → promptlayer-1.0.52}/promptlayer/utils.py

@@ -1485,7 +1485,7 @@ async def aanthropic_stream_completion(generator: AsyncIterable[Any]) -> Any:
     return response
 
 
-def stream_response(generator: Generator, after_stream: Callable, map_results: Callable):
+def stream_response(*, generator: Generator, after_stream: Callable, map_results: Callable):
     data = {
         "request_id": None,
         "raw_response": None,
@@ -1544,12 +1544,12 @@ MAP_TYPE_TO_OPENAI_FUNCTION = {
 }
 
 
-def openai_request(prompt_blueprint: GetPromptTemplateResponse, **kwargs):
+def openai_request(prompt_blueprint: GetPromptTemplateResponse, client_kwargs: dict, function_kwargs: dict):
     from openai import OpenAI
 
-    client = OpenAI(base_url=kwargs.pop("base_url", None))
+    client = OpenAI(**client_kwargs)
     request_to_make = MAP_TYPE_TO_OPENAI_FUNCTION[prompt_blueprint["prompt_template"]["type"]]
-    return request_to_make(client, **kwargs)
+    return request_to_make(client, **function_kwargs)
 
 
 async def aopenai_chat_request(client, **kwargs):
@@ -1566,28 +1566,30 @@ AMAP_TYPE_TO_OPENAI_FUNCTION = {
 }
 
 
-async def aopenai_request(prompt_blueprint: GetPromptTemplateResponse, **kwargs):
+async def aopenai_request(prompt_blueprint: GetPromptTemplateResponse, client_kwargs: dict, function_kwargs: dict):
     from openai import AsyncOpenAI
 
-    client = AsyncOpenAI(base_url=kwargs.pop("base_url", None))
+    client = AsyncOpenAI(**client_kwargs)
     request_to_make = AMAP_TYPE_TO_OPENAI_FUNCTION[prompt_blueprint["prompt_template"]["type"]]
-    return await request_to_make(client, **kwargs)
+    return await request_to_make(client, **function_kwargs)
 
 
-def azure_openai_request(prompt_blueprint: GetPromptTemplateResponse, **kwargs):
+def azure_openai_request(prompt_blueprint: GetPromptTemplateResponse, client_kwargs: dict, function_kwargs: dict):
     from openai import AzureOpenAI
 
-    client = AzureOpenAI(azure_endpoint=kwargs.pop("base_url", None))
+    client = AzureOpenAI(azure_endpoint=client_kwargs.pop("base_url", None))
     request_to_make = MAP_TYPE_TO_OPENAI_FUNCTION[prompt_blueprint["prompt_template"]["type"]]
-    return request_to_make(client, **kwargs)
+    return request_to_make(client, **function_kwargs)
 
 
-async def aazure_openai_request(prompt_blueprint: GetPromptTemplateResponse, **kwargs):
+async def aazure_openai_request(
+    prompt_blueprint: GetPromptTemplateResponse, client_kwargs: dict, function_kwargs: dict
+):
     from openai import AsyncAzureOpenAI
 
-    client = AsyncAzureOpenAI(azure_endpoint=kwargs.pop("base_url", None))
+    client = AsyncAzureOpenAI(azure_endpoint=client_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)
+    return await request_to_make(client, **function_kwargs)
 
 
 def anthropic_chat_request(client, **kwargs):
@@ -1604,12 +1606,12 @@ MAP_TYPE_TO_ANTHROPIC_FUNCTION = {
 }
 
 
-def anthropic_request(prompt_blueprint: GetPromptTemplateResponse, **kwargs):
+def anthropic_request(prompt_blueprint: GetPromptTemplateResponse, client_kwargs: dict, function_kwargs: dict):
     from anthropic import Anthropic
 
-    client = Anthropic(base_url=kwargs.pop("base_url", None))
+    client = Anthropic(**client_kwargs)
     request_to_make = MAP_TYPE_TO_ANTHROPIC_FUNCTION[prompt_blueprint["prompt_template"]["type"]]
-    return request_to_make(client, **kwargs)
+    return request_to_make(client, **function_kwargs)
 
 
 async def aanthropic_chat_request(client, **kwargs):
@@ -1626,12 +1628,12 @@ AMAP_TYPE_TO_ANTHROPIC_FUNCTION = {
 }
 
 
-async def aanthropic_request(prompt_blueprint: GetPromptTemplateResponse, **kwargs):
+async def aanthropic_request(prompt_blueprint: GetPromptTemplateResponse, client_kwargs: dict, function_kwargs: dict):
     from anthropic import AsyncAnthropic
 
-    client = AsyncAnthropic(base_url=kwargs.pop("base_url", None))
+    client = AsyncAnthropic(**client_kwargs)
     request_to_make = AMAP_TYPE_TO_ANTHROPIC_FUNCTION[prompt_blueprint["prompt_template"]["type"]]
-    return await request_to_make(client, **kwargs)
+    return await request_to_make(client, **function_kwargs)
 
 
 # do not remove! This is used in the langchain integration.
@@ -1690,31 +1692,29 @@ async def autil_log_request(api_key: str, **kwargs) -> Union[RequestLog, None]:
         return None
 
 
-def mistral_request(
-    prompt_blueprint: GetPromptTemplateResponse,
-    **kwargs,
-):
+def mistral_request(prompt_blueprint: GetPromptTemplateResponse, client_kwargs: dict, function_kwargs: dict):
     from mistralai import Mistral
 
     client = Mistral(api_key=os.environ.get("MISTRAL_API_KEY"))
-    if "stream" in kwargs and kwargs["stream"]:
-        kwargs.pop("stream")
-        return client.chat.stream(**kwargs)
-    if "stream" in kwargs:
-        kwargs.pop("stream")
-    return client.chat.complete(**kwargs)
+    if "stream" in function_kwargs and function_kwargs["stream"]:
+        function_kwargs.pop("stream")
+        return client.chat.stream(**function_kwargs)
+    if "stream" in function_kwargs:
+        function_kwargs.pop("stream")
+    return client.chat.complete(**function_kwargs)
 
 
 async def amistral_request(
     prompt_blueprint: GetPromptTemplateResponse,
-    **kwargs,
+    _: dict,
+    function_kwargs: dict,
 ):
     from mistralai import Mistral
 
     client = Mistral(api_key=os.environ.get("MISTRAL_API_KEY"))
-    if "stream" in kwargs and kwargs["stream"]:
-        return await client.chat.stream_async(**kwargs)
-    return await client.chat.complete_async(**kwargs)
+    if "stream" in function_kwargs and function_kwargs["stream"]:
+        return await client.chat.stream_async(**function_kwargs)
+    return await client.chat.complete_async(**function_kwargs)
 
 
 def mistral_stream_chat(results: list):
@@ -1898,12 +1898,12 @@ MAP_TYPE_TO_GOOGLE_FUNCTION = {
 }
 
 
-def google_request(request: GetPromptTemplateResponse, **kwargs):
+def google_request(request: GetPromptTemplateResponse, _: dict, function_kwargs: dict):
     from google import genai
 
     client = genai.Client()
     request_to_make = MAP_TYPE_TO_GOOGLE_FUNCTION[request["prompt_template"]["type"]]
-    return request_to_make(client, **kwargs)
+    return request_to_make(client, **function_kwargs)
 
 
 async def agoogle_chat_request(client, **kwargs):
@@ -1936,12 +1936,12 @@ AMAP_TYPE_TO_GOOGLE_FUNCTION = {
 }
 
 
-async def agoogle_request(request: GetPromptTemplateResponse, **kwargs):
+async def agoogle_request(request: GetPromptTemplateResponse, _: dict, function_kwargs: dict):
     from google import genai
 
     client = genai.Client()
     request_to_make = AMAP_TYPE_TO_GOOGLE_FUNCTION[request["prompt_template"]["type"]]
-    return await request_to_make(client, **kwargs)
+    return await request_to_make(client, **function_kwargs)
 
 
 async def amap_google_stream_response(generator: AsyncIterable[Any]):

{promptlayer-1.0.50 → promptlayer-1.0.52}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "promptlayer"
-version = "1.0.50"
+version = "1.0.52"
 description = "PromptLayer is a platform for prompt engineering and tracks your LLM requests."
 authors = ["Magniv <hello@magniv.io>"]
 license = "Apache-2.0"