promptlayer 1.0.71__py3-none-any.whl → 1.0.73__py3-none-any.whl

promptlayer/span_exporter.py

@@ -4,13 +4,25 @@ import requests
 from opentelemetry.sdk.trace import ReadableSpan
 from opentelemetry.sdk.trace.export import SpanExporter, SpanExportResult
 
-from promptlayer.utils import URL_API_PROMPTLAYER
+from promptlayer.utils import raise_on_bad_response, retry_on_api_error
 
 
 class PromptLayerSpanExporter(SpanExporter):
-    def __init__(self, api_key: str = None):
+    def __init__(self, api_key: str, base_url: str, throw_on_error: bool):
         self.api_key = api_key
-        self.url = f"{URL_API_PROMPTLAYER}/spans-bulk"
+        self.url = f"{base_url}/spans-bulk"
+        self.throw_on_error = throw_on_error
+
+    @retry_on_api_error
+    def _post_spans(self, request_data):
+        response = requests.post(
+            self.url,
+            headers={"X-Api-Key": self.api_key, "Content-Type": "application/json"},
+            json={"spans": request_data},
+        )
+        if response.status_code not in (200, 201):
+            raise_on_bad_response(response, "PromptLayer had the following error while exporting spans")
+        return response
 
     def export(self, spans: Sequence[ReadableSpan]) -> SpanExportResult:
         request_data = []
@@ -49,12 +61,7 @@ class PromptLayerSpanExporter(SpanExporter):
             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},
-            )
-            response.raise_for_status()
+            self._post_spans(request_data)
             return SpanExportResult.SUCCESS
         except requests.RequestException:
             return SpanExportResult.FAILURE

promptlayer/templates.py

@@ -11,25 +11,29 @@ from promptlayer.utils import (
 
 
 class TemplateManager:
-    def __init__(self, api_key: str):
+    def __init__(self, api_key: str, base_url: str, throw_on_error: bool):
         self.api_key = api_key
+        self.base_url = base_url
+        self.throw_on_error = throw_on_error
 
     def get(self, prompt_name: str, params: Union[GetPromptTemplate, None] = None):
-        return get_prompt_template(prompt_name, params, self.api_key)
+        return get_prompt_template(self.api_key, self.base_url, self.throw_on_error, prompt_name, params)
 
     def publish(self, body: PublishPromptTemplate):
-        return publish_prompt_template(body, self.api_key)
+        return publish_prompt_template(self.api_key, self.base_url, self.throw_on_error, body)
 
     def all(self, page: int = 1, per_page: int = 30, label: str = None):
-        return get_all_prompt_templates(page, per_page, self.api_key, label)
+        return get_all_prompt_templates(self.api_key, self.base_url, self.throw_on_error, page, per_page, label)
 
 
 class AsyncTemplateManager:
-    def __init__(self, api_key: str):
+    def __init__(self, api_key: str, base_url: str, throw_on_error: bool):
         self.api_key = api_key
+        self.base_url = base_url
+        self.throw_on_error = throw_on_error
 
     async def get(self, prompt_name: str, params: Union[GetPromptTemplate, None] = None):
-        return await aget_prompt_template(prompt_name, params, self.api_key)
+        return await aget_prompt_template(self.api_key, self.base_url, self.throw_on_error, prompt_name, params)
 
     async def all(self, page: int = 1, per_page: int = 30, label: str = None):
-        return await aget_all_prompt_templates(page, per_page, self.api_key, label)
+        return await aget_all_prompt_templates(self.api_key, self.base_url, self.throw_on_error, page, per_page, label)

promptlayer/track/__init__.py

@@ -13,51 +13,59 @@ from promptlayer.track.track import (
 
 
 class TrackManager:
-    def __init__(self, api_key: str):
+    def __init__(self, api_key: str, base_url: str, throw_on_error: bool):
         self.api_key = api_key
+        self.base_url = base_url
+        self.throw_on_error = throw_on_error
 
     def group(self, request_id, group_id):
-        return group(request_id, group_id, self.api_key)
+        return group(self.api_key, self.base_url, self.throw_on_error, request_id, group_id)
 
     def metadata(self, request_id, metadata):
-        return metadata_(request_id, metadata, self.api_key)
+        return metadata_(self.api_key, self.base_url, self.throw_on_error, request_id, metadata)
 
     def prompt(self, request_id, prompt_name, prompt_input_variables, version=None, label=None):
         return prompt(
+            self.api_key,
+            self.base_url,
+            self.throw_on_error,
             request_id,
             prompt_name,
             prompt_input_variables,
             version,
             label,
-            self.api_key,
         )
 
     def score(self, request_id, score, score_name=None):
-        return score_(request_id, score, score_name, self.api_key)
+        return score_(self.api_key, self.base_url, self.throw_on_error, request_id, score, score_name)
 
 
 class AsyncTrackManager:
-    def __init__(self, api_key: str):
+    def __init__(self, api_key: str, base_url: str, throw_on_error: bool):
         self.api_key = api_key
+        self.base_url = base_url
+        self.throw_on_error = throw_on_error
 
     async def group(self, request_id, group_id):
-        return await agroup(request_id, group_id, self.api_key)
+        return await agroup(self.api_key, self.base_url, self.throw_on_error, request_id, group_id)
 
     async def metadata(self, request_id, metadata):
-        return await ametadata(request_id, metadata, self.api_key)
+        return await ametadata(self.api_key, self.base_url, self.throw_on_error, request_id, metadata)
 
     async def prompt(self, request_id, prompt_name, prompt_input_variables, version=None, label=None):
         return await aprompt(
+            self.api_key,
+            self.base_url,
+            self.throw_on_error,
             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)
+        return await ascore(self.api_key, self.base_url, self.throw_on_error, request_id, score, score_name)
 
 
 __all__ = ["TrackManager"]

promptlayer/track/track.py

@@ -1,3 +1,4 @@
+from promptlayer import exceptions as _exceptions
 from promptlayer.utils import (
     apromptlayer_track_group,
     apromptlayer_track_metadata,
@@ -11,72 +12,96 @@ from promptlayer.utils import (
 
 
 def prompt(
+    api_key: str,
+    base_url: str,
+    throw_on_error: bool,
     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)
+        raise _exceptions.PromptLayerValidationError(
+            "Please provide a dictionary of input variables.", response=None, body=None
+        )
+    return promptlayer_track_prompt(
+        api_key, base_url, throw_on_error, request_id, prompt_name, prompt_input_variables, api_key, version, label
+    )
 
 
-def metadata(request_id, metadata, api_key: str = None):
+def metadata(api_key: str, base_url: str, throw_on_error: bool, request_id, metadata):
     if not isinstance(metadata, dict):
-        raise Exception("Please provide a dictionary of metadata.")
+        raise _exceptions.PromptLayerValidationError(
+            "Please provide a dictionary of metadata.", response=None, body=None
+        )
     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)
+            raise _exceptions.PromptLayerValidationError(
+                "Please provide a dictionary of metadata with key value pair of strings.", response=None, body=None
+            )
+    return promptlayer_track_metadata(api_key, base_url, throw_on_error, request_id, metadata)
 
 
-def score(request_id, score, score_name=None, api_key: str = None):
+def score(api_key: str, base_url: str, throw_on_error: bool, request_id, score, score_name=None):
     if not isinstance(score, int):
-        raise Exception("Please provide a int score.")
+        raise _exceptions.PromptLayerValidationError("Please provide a int score.", response=None, body=None)
     if not isinstance(score_name, str) and score_name is not None:
-        raise Exception("Please provide a string as score name.")
+        raise _exceptions.PromptLayerValidationError("Please provide a string as score name.", response=None, body=None)
     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)
+        raise _exceptions.PromptLayerValidationError(
+            "Please provide a score between 0 and 100.", response=None, body=None
+        )
+    return promptlayer_track_score(api_key, base_url, throw_on_error, request_id, score, score_name)
 
 
-def group(request_id, group_id, api_key: str = None):
-    return promptlayer_track_group(request_id, group_id, api_key)
+def group(api_key: str, base_url: str, throw_on_error: bool, request_id, group_id):
+    return promptlayer_track_group(api_key, base_url, throw_on_error, request_id, group_id)
 
 
 async def aprompt(
+    api_key: str,
+    base_url: str,
+    throw_on_error: bool,
     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)
+        raise _exceptions.PromptLayerValidationError(
+            "Please provide a dictionary of input variables.", response=None, body=None
+        )
+    return await apromptlayer_track_prompt(
+        api_key, base_url, throw_on_error, request_id, prompt_name, prompt_input_variables, version, label
+    )
 
 
-async def ametadata(request_id, metadata, api_key: str = None):
+async def ametadata(api_key: str, base_url: str, throw_on_error: bool, request_id, metadata):
     if not isinstance(metadata, dict):
-        raise Exception("Please provide a dictionary of metadata.")
+        raise _exceptions.PromptLayerValidationError(
+            "Please provide a dictionary of metadata.", response=None, body=None
+        )
     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)
+            raise _exceptions.PromptLayerValidationError(
+                "Please provide a dictionary of metadata with key-value pairs of strings.", response=None, body=None
+            )
+    return await apromptlayer_track_metadata(api_key, base_url, throw_on_error, request_id, metadata)
 
 
-async def ascore(request_id, score, score_name=None, api_key: str = None):
+async def ascore(api_key: str, base_url: str, throw_on_error: bool, request_id, score, score_name=None):
     if not isinstance(score, int):
-        raise Exception("Please provide an integer score.")
+        raise _exceptions.PromptLayerValidationError("Please provide an integer score.", response=None, body=None)
     if not isinstance(score_name, str) and score_name is not None:
-        raise Exception("Please provide a string as score name.")
+        raise _exceptions.PromptLayerValidationError("Please provide a string as score name.", response=None, body=None)
     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)
+        raise _exceptions.PromptLayerValidationError(
+            "Please provide a score between 0 and 100.", response=None, body=None
+        )
+    return await apromptlayer_track_score(api_key, base_url, throw_on_error, request_id, score, score_name)
 
 
-async def agroup(request_id, group_id, api_key: str = None):
-    return await apromptlayer_track_group(request_id, group_id, api_key)
+async def agroup(api_key: str, base_url: str, throw_on_error: bool, request_id, group_id):
+    return await apromptlayer_track_group(api_key, base_url, throw_on_error, request_id, group_id)