promptlayer 1.0.25__tar.gz → 1.0.27__tar.gz

{promptlayer-1.0.25 → promptlayer-1.0.27}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: promptlayer
-Version: 1.0.25
+Version: 1.0.27
 Summary: PromptLayer is a platform for prompt engineering and tracks your LLM requests.
 License: Apache-2.0
 Author: Magniv
@@ -14,6 +14,8 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Requires-Dist: ably (>=2.0.6,<3.0.0)
+Requires-Dist: aiohttp (>=3.10.10,<4.0.0)
+Requires-Dist: httpx (>=0.27.2,<0.28.0)
 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)

promptlayer-1.0.27/promptlayer/__init__.py

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

promptlayer-1.0.27/promptlayer/groups/__init__.py

@@ -0,0 +1,20 @@
+from promptlayer.groups.groups import acreate, create
+
+
+class GroupManager:
+    def __init__(self, api_key: str):
+        self.api_key = api_key
+
+    def create(self):
+        return create(self.api_key)
+
+
+class AsyncGroupManager:
+    def __init__(self, api_key: str):
+        self.api_key = api_key
+
+    async def create(self) -> str:
+        return await acreate(self.api_key)
+
+
+__all__ = ["GroupManager", "AsyncGroupManager"]

promptlayer-1.0.27/promptlayer/groups/groups.py

@@ -0,0 +1,11 @@
+from promptlayer.utils import apromptlayer_create_group, promptlayer_create_group
+
+
+def create(api_key: str = None):
+    """Create a new group."""
+    return promptlayer_create_group(api_key)
+
+
+async def acreate(api_key: str = None) -> str:
+    """Asynchronously create a new group."""
+    return await apromptlayer_create_group(api_key)

{promptlayer-1.0.25 → promptlayer-1.0.27}/promptlayer/promptlayer.py

@@ -10,16 +10,17 @@ 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.groups import AsyncGroupManager, 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.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,
+    autil_log_request,
     azure_openai_request,
     openai_request,
     openai_stream_chat,
@@ -481,3 +482,65 @@ class PromptLayer:
             function_name=function_name,
             score=score,
         )
+
+
+class AsyncPromptLayer:
+    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 = AsyncTemplateManager(api_key)
+        self.group = AsyncGroupManager(api_key)
+        self.track = AsyncTrackManager(api_key)
+
+    async def log_request(
+        self,
+        *,
+        provider: str,
+        model: str,
+        input: PromptTemplate,
+        output: PromptTemplate,
+        request_start_time: float,
+        request_end_time: float,
+        parameters: Dict[str, Any] = {},
+        tags: List[str] = [],
+        metadata: Dict[str, str] = {},
+        prompt_name: Union[str, None] = None,
+        prompt_version_number: Union[int, None] = None,
+        prompt_input_variables: Dict[str, Any] = {},
+        input_tokens: int = 0,
+        output_tokens: int = 0,
+        price: float = 0.0,
+        function_name: str = "",
+        score: int = 0,
+    ):
+        return await autil_log_request(
+            self.api_key,
+            provider=provider,
+            model=model,
+            input=input,
+            output=output,
+            request_start_time=request_start_time,
+            request_end_time=request_end_time,
+            parameters=parameters,
+            tags=tags,
+            metadata=metadata,
+            prompt_name=prompt_name,
+            prompt_version_number=prompt_version_number,
+            prompt_input_variables=prompt_input_variables,
+            input_tokens=input_tokens,
+            output_tokens=output_tokens,
+            price=price,
+            function_name=function_name,
+            score=score,
+        )

{promptlayer-1.0.25 → promptlayer-1.0.27}/promptlayer/templates.py

@@ -2,6 +2,8 @@ from typing import Union
 
 from promptlayer.types.prompt_template import GetPromptTemplate, PublishPromptTemplate
 from promptlayer.utils import (
+    aget_all_prompt_templates,
+    aget_prompt_template,
     get_all_prompt_templates,
     get_prompt_template,
     publish_prompt_template,
@@ -20,3 +22,16 @@ class TemplateManager:
 
     def all(self, page: int = 1, per_page: int = 30):
         return get_all_prompt_templates(page, per_page, self.api_key)
+
+
+class AsyncTemplateManager:
+    def __init__(self, api_key: str):
+        self.api_key = api_key
+
+    async def get(
+        self, prompt_name: str, params: Union[GetPromptTemplate, None] = None
+    ):
+        return await aget_prompt_template(prompt_name, params, self.api_key)
+
+    async def all(self, page: int = 1, per_page: int = 30):
+        return await aget_all_prompt_templates(page, per_page, self.api_key)

{promptlayer-1.0.25 → promptlayer-1.0.27}/promptlayer/track/__init__.py

@@ -1,4 +1,4 @@
-from promptlayer.track.track import group
+from promptlayer.track.track import agroup, ametadata, aprompt, ascore, group
 from promptlayer.track.track import metadata as metadata_
 from promptlayer.track.track import prompt
 from promptlayer.track.track import score as score_
@@ -30,4 +30,30 @@ class TrackManager:
         return score_(request_id, score, score_name, self.api_key)
 
 
+class AsyncTrackManager:
+    def __init__(self, api_key: str):
+        self.api_key = api_key
+
+    async def group(self, request_id, group_id):
+        return await agroup(request_id, group_id, self.api_key)
+
+    async def metadata(self, request_id, metadata):
+        return await ametadata(request_id, metadata, self.api_key)
+
+    async def prompt(
+        self, request_id, prompt_name, prompt_input_variables, version=None, label=None
+    ):
+        return await aprompt(
+            request_id,
+            prompt_name,
+            prompt_input_variables,
+            version,
+            label,
+            self.api_key,
+        )
+
+    async def score(self, request_id, score, score_name=None):
+        return await ascore(request_id, score, score_name, self.api_key)
+
+
 __all__ = ["TrackManager"]

promptlayer-1.0.27/promptlayer/track/track.py

@@ -0,0 +1,90 @@
+from promptlayer.utils import (
+    apromptlayer_track_group,
+    apromptlayer_track_metadata,
+    apromptlayer_track_prompt,
+    apromptlayer_track_score,
+    promptlayer_track_group,
+    promptlayer_track_metadata,
+    promptlayer_track_prompt,
+    promptlayer_track_score,
+)
+
+
+def prompt(
+    request_id,
+    prompt_name,
+    prompt_input_variables,
+    version=None,
+    label=None,
+    api_key: str = None,
+):
+    if not isinstance(prompt_input_variables, dict):
+        raise Exception("Please provide a dictionary of input variables.")
+    return promptlayer_track_prompt(
+        request_id, prompt_name, prompt_input_variables, api_key, version, label
+    )
+
+
+def metadata(request_id, metadata, api_key: str = None):
+    if not isinstance(metadata, dict):
+        raise Exception("Please provide a dictionary of metadata.")
+    for key, value in metadata.items():
+        if not isinstance(key, str) or not isinstance(value, str):
+            raise Exception(
+                "Please provide a dictionary of metadata with key value pair of strings."
+            )
+    return promptlayer_track_metadata(request_id, metadata, api_key)
+
+
+def score(request_id, score, score_name=None, api_key: str = None):
+    if not isinstance(score, int):
+        raise Exception("Please provide a int score.")
+    if not isinstance(score_name, str) and score_name is not None:
+        raise Exception("Please provide a string as score name.")
+    if score < 0 or score > 100:
+        raise Exception("Please provide a score between 0 and 100.")
+    return promptlayer_track_score(request_id, score, score_name, api_key)
+
+
+def group(request_id, group_id, api_key: str = None):
+    return promptlayer_track_group(request_id, group_id, api_key)
+
+
+async def aprompt(
+    request_id,
+    prompt_name,
+    prompt_input_variables,
+    version=None,
+    label=None,
+    api_key: str = None,
+):
+    if not isinstance(prompt_input_variables, dict):
+        raise Exception("Please provide a dictionary of input variables.")
+    return await apromptlayer_track_prompt(
+        request_id, prompt_name, prompt_input_variables, api_key, version, label
+    )
+
+
+async def ametadata(request_id, metadata, api_key: str = None):
+    if not isinstance(metadata, dict):
+        raise Exception("Please provide a dictionary of metadata.")
+    for key, value in metadata.items():
+        if not isinstance(key, str) or not isinstance(value, str):
+            raise Exception(
+                "Please provide a dictionary of metadata with key-value pairs of strings."
+            )
+    return await apromptlayer_track_metadata(request_id, metadata, api_key)
+
+
+async def ascore(request_id, score, score_name=None, api_key: str = None):
+    if not isinstance(score, int):
+        raise Exception("Please provide an integer score.")
+    if not isinstance(score_name, str) and score_name is not None:
+        raise Exception("Please provide a string as score name.")
+    if score < 0 or score > 100:
+        raise Exception("Please provide a score between 0 and 100.")
+    return await apromptlayer_track_score(request_id, score, score_name, api_key)
+
+
+async def agroup(request_id, group_id, api_key: str = None):
+    return await apromptlayer_track_group(request_id, group_id, api_key)

{promptlayer-1.0.25 → promptlayer-1.0.27}/promptlayer/utils.py

@@ -11,6 +11,7 @@ from enum import Enum
 from typing import Any, Callable, Dict, Generator, List, Optional, Union
 
 import aiohttp
+import httpx
 import requests
 from ably import AblyRealtime
 from opentelemetry import context, trace
@@ -429,6 +430,42 @@ def promptlayer_track_prompt(
     return True
 
 
+async def apromptlayer_track_prompt(
+    request_id: str,
+    prompt_name: str,
+    input_variables: Dict[str, Any],
+    api_key: Optional[str] = None,
+    version: Optional[int] = None,
+    label: Optional[str] = None,
+) -> bool:
+    url = f"{URL_API_PROMPTLAYER}/library-track-prompt"
+    payload = {
+        "request_id": request_id,
+        "prompt_name": prompt_name,
+        "prompt_input_variables": input_variables,
+        "api_key": api_key,
+        "version": version,
+        "label": label,
+    }
+    try:
+        async with httpx.AsyncClient() as client:
+            response = await client.post(url, json=payload)
+        if response.status_code != 200:
+            warn_on_bad_response(
+                response,
+                "WARNING: While tracking your prompt, PromptLayer had the following error",
+            )
+            return False
+    except httpx.RequestError as e:
+        print(
+            f"WARNING: While tracking your prompt PromptLayer had the following error: {e}",
+            file=sys.stderr,
+        )
+        return False
+
+    return True
+
+
 def promptlayer_track_metadata(request_id, metadata, api_key):
     try:
         request_response = requests.post(
@@ -454,6 +491,34 @@ def promptlayer_track_metadata(request_id, metadata, api_key):
     return True
 
 
+async def apromptlayer_track_metadata(
+    request_id: str, metadata: Dict[str, Any], api_key: Optional[str] = None
+) -> bool:
+    url = f"{URL_API_PROMPTLAYER}/library-track-metadata"
+    payload = {
+        "request_id": request_id,
+        "metadata": metadata,
+        "api_key": api_key,
+    }
+    try:
+        async with httpx.AsyncClient() as client:
+            response = await client.post(url, json=payload)
+        if response.status_code != 200:
+            warn_on_bad_response(
+                response,
+                "WARNING: While tracking your metadata, PromptLayer had the following error",
+            )
+            return False
+    except httpx.RequestError as e:
+        print(
+            f"WARNING: While tracking your metadata PromptLayer had the following error: {e}",
+            file=sys.stderr,
+        )
+        return False
+
+    return True
+
+
 def promptlayer_track_score(request_id, score, score_name, api_key):
     try:
         data = {"request_id": request_id, "score": score, "api_key": api_key}
@@ -478,6 +543,39 @@ def promptlayer_track_score(request_id, score, score_name, api_key):
     return True
 
 
+async def apromptlayer_track_score(
+    request_id: str,
+    score: float,
+    score_name: Optional[str],
+    api_key: Optional[str] = None,
+) -> bool:
+    url = f"{URL_API_PROMPTLAYER}/library-track-score"
+    data = {
+        "request_id": request_id,
+        "score": score,
+        "api_key": api_key,
+    }
+    if score_name is not None:
+        data["name"] = score_name
+    try:
+        async with httpx.AsyncClient() as client:
+            response = await client.post(url, json=data)
+        if response.status_code != 200:
+            warn_on_bad_response(
+                response,
+                "WARNING: While tracking your score, PromptLayer had the following error",
+            )
+            return False
+    except httpx.RequestError as e:
+        print(
+            f"WARNING: While tracking your score PromptLayer had the following error: {str(e)}",
+            file=sys.stderr,
+        )
+        return False
+
+    return True
+
+
 class GeneratorProxy:
     def __init__(self, generator, api_request_arguments, api_key):
         self.generator = generator
@@ -735,6 +833,28 @@ def promptlayer_create_group(api_key: str = None):
     return request_response.json()["id"]
 
 
+async def apromptlayer_create_group(api_key: Optional[str] = None) -> str:
+    try:
+        async with httpx.AsyncClient() as client:
+            response = await client.post(
+                f"{URL_API_PROMPTLAYER}/create-group",
+                json={
+                    "api_key": api_key,
+                },
+            )
+        if response.status_code != 200:
+            warn_on_bad_response(
+                response,
+                "WARNING: While creating your group, PromptLayer had the following error",
+            )
+            return False
+        return response.json()["id"]
+    except httpx.RequestError as e:
+        raise Exception(
+            f"PromptLayer had the following error while creating your group: {str(e)}"
+        ) from e
+
+
 def promptlayer_track_group(request_id, group_id, api_key: str = None):
     try:
         request_response = requests.post(
@@ -759,6 +879,35 @@ def promptlayer_track_group(request_id, group_id, api_key: str = None):
     return True
 
 
+async def apromptlayer_track_group(request_id, group_id, api_key: str = None):
+    try:
+        payload = {
+            "api_key": api_key,
+            "request_id": request_id,
+            "group_id": group_id,
+        }
+        async with httpx.AsyncClient() as client:
+            response = await client.post(
+                f"{URL_API_PROMPTLAYER}/track-group",
+                headers={"X-API-KEY": api_key},
+                json=payload,
+            )
+        if response.status_code != 200:
+            warn_on_bad_response(
+                response,
+                "WARNING: While tracking your group, PromptLayer had the following error",
+            )
+            return False
+    except httpx.RequestError as e:
+        print(
+            f"WARNING: While tracking your group PromptLayer had the following error: {e}",
+            file=sys.stderr,
+        )
+        return False
+
+    return True
+
+
 def get_prompt_template(
     prompt_name: str, params: Union[GetPromptTemplate, None] = None, api_key: str = None
 ) -> GetPromptTemplateResponse:
@@ -789,6 +938,39 @@ def get_prompt_template(
         )
 
 
+async def aget_prompt_template(
+    prompt_name: str,
+    params: Union[GetPromptTemplate, None] = None,
+    api_key: str = None,
+) -> GetPromptTemplateResponse:
+    try:
+        json_body = {"api_key": api_key}
+        if params:
+            json_body.update(params)
+        async with httpx.AsyncClient() as client:
+            response = await client.post(
+                f"{URL_API_PROMPTLAYER}/prompt-templates/{prompt_name}",
+                headers={"X-API-KEY": api_key},
+                json=json_body,
+            )
+        response.raise_for_status()
+        warning = response.json().get("warning", None)
+        if warning:
+            warn_on_bad_response(
+                warning,
+                "WARNING: While getting your prompt template",
+            )
+        return response.json()
+    except httpx.HTTPStatusError as e:
+        raise Exception(
+            f"PromptLayer had the following error while getting your prompt template: {e.response.text}"
+        ) from e
+    except httpx.RequestError as e:
+        raise Exception(
+            f"PromptLayer had the following error while getting your prompt template: {str(e)}"
+        ) from e
+
+
 def publish_prompt_template(
     body: PublishPromptTemplate,
     api_key: str = None,
@@ -814,6 +996,37 @@ def publish_prompt_template(
         )
 
 
+async def apublish_prompt_template(
+    body: PublishPromptTemplate,
+    api_key: str = None,
+) -> PublishPromptTemplateResponse:
+    try:
+        async with httpx.AsyncClient() as client:
+            response = await client.post(
+                f"{URL_API_PROMPTLAYER}/rest/prompt-templates",
+                headers={"X-API-KEY": api_key},
+                json={
+                    "prompt_template": {**body},
+                    "prompt_version": {**body},
+                    "release_labels": body.get("release_labels"),
+                },
+            )
+        if response.status_code == 400:
+            raise Exception(
+                f"PromptLayer had the following error while publishing your prompt template: {response.text}"
+            )
+        response.raise_for_status()
+        return response.json()
+    except httpx.HTTPStatusError as e:
+        raise Exception(
+            f"PromptLayer had the following error while publishing your prompt template: {e.response.text}"
+        ) from e
+    except httpx.RequestError as e:
+        raise Exception(
+            f"PromptLayer had the following error while publishing your prompt template: {str(e)}"
+        ) from e
+
+
 def get_all_prompt_templates(
     page: int = 1, per_page: int = 30, api_key: str = None
 ) -> List[ListPromptTemplateResponse]:
@@ -835,6 +1048,29 @@ def get_all_prompt_templates(
         )
 
 
+async def aget_all_prompt_templates(
+    page: int = 1, per_page: int = 30, api_key: str = None
+) -> List[ListPromptTemplateResponse]:
+    try:
+        async with httpx.AsyncClient() as client:
+            response = await client.get(
+                f"{URL_API_PROMPTLAYER}/prompt-templates",
+                headers={"X-API-KEY": api_key},
+                params={"page": page, "per_page": per_page},
+            )
+        response.raise_for_status()
+        items = response.json().get("items", [])
+        return items
+    except httpx.HTTPStatusError as e:
+        raise Exception(
+            f"PromptLayer had the following error while getting all your prompt templates: {e.response.text}"
+        ) from e
+    except httpx.RequestError as e:
+        raise Exception(
+            f"PromptLayer had the following error while getting all your prompt templates: {str(e)}"
+        ) from e
+
+
 def openai_stream_chat(results: list):
     from openai.types.chat import (
         ChatCompletion,
@@ -1090,3 +1326,26 @@ def util_log_request(api_key: str, **kwargs) -> Union[RequestLog, None]:
             file=sys.stderr,
         )
         return None
+
+
+async def autil_log_request(api_key: str, **kwargs) -> Union[RequestLog, None]:
+    try:
+        async with httpx.AsyncClient() as client:
+            response = await client.post(
+                f"{URL_API_PROMPTLAYER}/log-request",
+                headers={"X-API-KEY": api_key},
+                json=kwargs,
+            )
+        if response.status_code != 201:
+            warn_on_bad_response(
+                response,
+                "WARNING: While logging your request PromptLayer had the following error",
+            )
+            return None
+        return response.json()
+    except Exception as e:
+        print(
+            f"WARNING: While tracking your prompt PromptLayer had the following error: {e}",
+            file=sys.stderr,
+        )
+        return None

{promptlayer-1.0.25 → promptlayer-1.0.27}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "promptlayer"
-version = "1.0.25"
+version = "1.0.27"
 description = "PromptLayer is a platform for prompt engineering and tracks your LLM requests."
 authors = ["Magniv <hello@magniv.io>"]
 license = "Apache-2.0"
@@ -12,6 +12,8 @@ requests = "^2.31.0"
 opentelemetry-api = "^1.26.0"
 opentelemetry-sdk = "^1.26.0"
 ably = "^2.0.6"
+aiohttp = "^3.10.10"
+httpx = "^0.27.2"
 
 [tool.poetry.group.dev.dependencies]
 langchain = "^0.0.260"

promptlayer-1.0.25/promptlayer/__init__.py

@@ -1,4 +0,0 @@
-from .promptlayer import PromptLayer
-
-__version__ = "1.0.25"
-__all__ = ["PromptLayer", "__version__"]

promptlayer-1.0.25/promptlayer/groups/__init__.py

@@ -1,12 +0,0 @@
-from promptlayer.groups.groups import create
-
-
-class GroupManager:
-    def __init__(self, api_key: str):
-        self.api_key = api_key
-
-    def create(self):
-        return create(self.api_key)
-
-
-__all__ = ["GroupManager"]

promptlayer-1.0.25/promptlayer/groups/groups.py

@@ -1,6 +0,0 @@
-from promptlayer.utils import promptlayer_create_group
-
-
-def create(api_key: str = None):
-    """Create a new group."""
-    return promptlayer_create_group(api_key)

promptlayer-1.0.25/promptlayer/track/track.py

@@ -1,46 +0,0 @@
-from promptlayer.utils import (
-    promptlayer_track_group,
-    promptlayer_track_metadata,
-    promptlayer_track_prompt,
-    promptlayer_track_score,
-)
-
-
-def prompt(
-    request_id,
-    prompt_name,
-    prompt_input_variables,
-    version=None,
-    label=None,
-    api_key: str = None,
-):
-    if not isinstance(prompt_input_variables, dict):
-        raise Exception("Please provide a dictionary of input variables.")
-    return promptlayer_track_prompt(
-        request_id, prompt_name, prompt_input_variables, api_key, version, label
-    )
-
-
-def metadata(request_id, metadata, api_key: str = None):
-    if not isinstance(metadata, dict):
-        raise Exception("Please provide a dictionary of metadata.")
-    for key, value in metadata.items():
-        if not isinstance(key, str) or not isinstance(value, str):
-            raise Exception(
-                "Please provide a dictionary of metadata with key value pair of strings."
-            )
-    return promptlayer_track_metadata(request_id, metadata, api_key)
-
-
-def score(request_id, score, score_name=None, api_key: str = None):
-    if not isinstance(score, int):
-        raise Exception("Please provide a int score.")
-    if not isinstance(score_name, str) and score_name is not None:
-        raise Exception("Please provide a string as score name.")
-    if score < 0 or score > 100:
-        raise Exception("Please provide a score between 0 and 100.")
-    return promptlayer_track_score(request_id, score, score_name, api_key)
-
-
-def group(request_id, group_id, api_key: str = None):
-    return promptlayer_track_group(request_id, group_id, api_key)