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

promptlayer/__init__.py

@@ -1,4 +1,39 @@
+from .exceptions import (
+    PromptLayerAPIConnectionError,
+    PromptLayerAPIError,
+    PromptLayerAPIStatusError,
+    PromptLayerAPITimeoutError,
+    PromptLayerAuthenticationError,
+    PromptLayerBadRequestError,
+    PromptLayerConflictError,
+    PromptLayerError,
+    PromptLayerInternalServerError,
+    PromptLayerNotFoundError,
+    PromptLayerPermissionDeniedError,
+    PromptLayerRateLimitError,
+    PromptLayerUnprocessableEntityError,
+    PromptLayerValidationError,
+)
 from .promptlayer import AsyncPromptLayer, PromptLayer
 
-__version__ = "1.0.71"
-__all__ = ["PromptLayer", "AsyncPromptLayer", "__version__"]
+__version__ = "1.0.73"
+__all__ = [
+    "PromptLayer",
+    "AsyncPromptLayer",
+    "__version__",
+    # Exceptions
+    "PromptLayerError",
+    "PromptLayerAPIError",
+    "PromptLayerBadRequestError",
+    "PromptLayerAuthenticationError",
+    "PromptLayerPermissionDeniedError",
+    "PromptLayerNotFoundError",
+    "PromptLayerConflictError",
+    "PromptLayerUnprocessableEntityError",
+    "PromptLayerRateLimitError",
+    "PromptLayerInternalServerError",
+    "PromptLayerAPIStatusError",
+    "PromptLayerAPIConnectionError",
+    "PromptLayerAPITimeoutError",
+    "PromptLayerValidationError",
+]

promptlayer/exceptions.py

@@ -0,0 +1,119 @@
+class PromptLayerError(Exception):
+    """Base exception for all PromptLayer SDK errors."""
+
+    def __init__(self, message: str, response=None, body=None):
+        super().__init__(message)
+        self.message = message
+        self.response = response
+        self.body = body
+
+    def __str__(self):
+        return self.message
+
+
+class PromptLayerAPIError(PromptLayerError):
+    """Base exception for API-related errors."""
+
+    pass
+
+
+class PromptLayerBadRequestError(PromptLayerAPIError):
+    """Exception raised for 400 Bad Request errors.
+
+    Indicates that the request was malformed or contained invalid parameters.
+    """
+
+    pass
+
+
+class PromptLayerAuthenticationError(PromptLayerAPIError):
+    """Exception raised for 401 Unauthorized errors.
+
+    Indicates that the API key is missing, invalid, or expired.
+    """
+
+    pass
+
+
+class PromptLayerPermissionDeniedError(PromptLayerAPIError):
+    """Exception raised for 403 Forbidden errors.
+
+    Indicates that the API key doesn't have permission to perform the requested operation.
+    """
+
+    pass
+
+
+class PromptLayerNotFoundError(PromptLayerAPIError):
+    """Exception raised for 404 Not Found errors.
+
+    Indicates that the requested resource (e.g., prompt template) was not found.
+    """
+
+    pass
+
+
+class PromptLayerConflictError(PromptLayerAPIError):
+    """Exception raised for 409 Conflict errors.
+
+    Indicates that the request conflicts with the current state of the resource.
+    """
+
+    pass
+
+
+class PromptLayerUnprocessableEntityError(PromptLayerAPIError):
+    """Exception raised for 422 Unprocessable Entity errors.
+
+    Indicates that the request was well-formed but contains semantic errors.
+    """
+
+    pass
+
+
+class PromptLayerRateLimitError(PromptLayerAPIError):
+    """Exception raised for 429 Too Many Requests errors.
+
+    Indicates that the API rate limit has been exceeded.
+    """
+
+    pass
+
+
+class PromptLayerInternalServerError(PromptLayerAPIError):
+    """Exception raised for 500+ Internal Server errors.
+
+    Indicates that the PromptLayer API encountered an internal error.
+    """
+
+    pass
+
+
+class PromptLayerAPIStatusError(PromptLayerAPIError):
+    """Exception raised for other API errors not covered by specific exception classes."""
+
+    pass
+
+
+class PromptLayerAPIConnectionError(PromptLayerError):
+    """Exception raised when unable to connect to the API.
+
+    This can be due to network issues, timeouts, or connection errors.
+    """
+
+    pass
+
+
+class PromptLayerAPITimeoutError(PromptLayerError):
+    """Exception raised when an API request times out."""
+
+    pass
+
+
+class PromptLayerValidationError(PromptLayerError):
+    """Exception raised when input validation fails.
+
+    This can be due to invalid types, out of range values, or malformed data.
+    """
+
+    pass

promptlayer/groups/__init__.py

@@ -2,19 +2,23 @@ from promptlayer.groups.groups import acreate, create
 
 
 class GroupManager:
-    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 create(self):
-        return create(self.api_key)
+        return create(self.api_key, self.base_url, self.throw_on_error)
 
 
 class AsyncGroupManager:
-    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 create(self) -> str:
-        return await acreate(self.api_key)
+    async def create(self):
+        return await acreate(self.api_key, self.base_url, self.throw_on_error)
 
 
 __all__ = ["GroupManager", "AsyncGroupManager"]

promptlayer/groups/groups.py

@@ -1,11 +1,9 @@
 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)
+def create(api_key: str, base_url: str, throw_on_error: bool):
+    return promptlayer_create_group(api_key, base_url, throw_on_error)
 
 
-async def acreate(api_key: str = None) -> str:
-    """Asynchronously create a new group."""
-    return await apromptlayer_create_group(api_key)
+async def acreate(api_key: str, base_url: str, throw_on_error: bool):
+    return await apromptlayer_create_group(api_key, base_url, throw_on_error)

promptlayer/promptlayer.py

@@ -6,6 +6,7 @@ from typing import Any, Dict, List, Literal, Optional, Union
 
 import nest_asyncio
 
+from promptlayer import exceptions as _exceptions
 from promptlayer.groups import AsyncGroupManager, GroupManager
 from promptlayer.promptlayer_base import PromptLayerBase
 from promptlayer.promptlayer_mixins import PromptLayerMixin
@@ -26,6 +27,10 @@ from promptlayer.utils import (
 logger = logging.getLogger(__name__)
 
 
+def get_base_url(base_url: Union[str, None]):
+    return base_url or os.environ.get("PROMPTLAYER_BASE_URL", "https://api.promptlayer.com")
+
+
 def is_workflow_results_dict(obj: Any) -> bool:
     if not isinstance(obj, dict):
         return False
@@ -50,8 +55,10 @@ def is_workflow_results_dict(obj: Any) -> bool:
 class PromptLayer(PromptLayerMixin):
     def __init__(
         self,
-        api_key: str = None,
+        api_key: Union[str, None] = None,
         enable_tracing: bool = False,
+        base_url: Union[str, None] = None,
+        throw_on_error: bool = True,
     ):
         if api_key is None:
             api_key = os.environ.get("PROMPTLAYER_API_KEY")
@@ -62,11 +69,15 @@ class PromptLayer(PromptLayerMixin):
                 "Please set the PROMPTLAYER_API_KEY environment variable or pass the api_key parameter."
             )
 
+        self.base_url = get_base_url(base_url)
         self.api_key = api_key
-        self.templates = TemplateManager(api_key)
-        self.group = GroupManager(api_key)
-        self.tracer_provider, self.tracer = self._initialize_tracer(api_key, enable_tracing)
-        self.track = TrackManager(api_key)
+        self.throw_on_error = throw_on_error
+        self.templates = TemplateManager(api_key, self.base_url, self.throw_on_error)
+        self.group = GroupManager(api_key, self.base_url, self.throw_on_error)
+        self.tracer_provider, self.tracer = self._initialize_tracer(
+            api_key, self.base_url, self.throw_on_error, enable_tracing
+        )
+        self.track = TrackManager(api_key, self.base_url, self.throw_on_error)
 
     def __getattr__(
         self,
@@ -75,15 +86,18 @@ class PromptLayer(PromptLayerMixin):
         if name == "openai":
             import openai as openai_module
 
-            return PromptLayerBase(openai_module, function_name="openai", api_key=self.api_key, tracer=self.tracer)
+            return PromptLayerBase(
+                self.api_key, self.base_url, openai_module, function_name="openai", tracer=self.tracer
+            )
         elif name == "anthropic":
             import anthropic as anthropic_module
 
             return PromptLayerBase(
+                self.api_key,
+                self.base_url,
                 anthropic_module,
                 function_name="anthropic",
                 provider_type="anthropic",
-                api_key=self.api_key,
                 tracer=self.tracer,
             )
         else:
@@ -108,7 +122,7 @@ class PromptLayer(PromptLayerMixin):
                 pl_run_span_id,
                 **body,
             )
-            return track_request(**track_request_kwargs)
+            return track_request(self.base_url, self.throw_on_error, **track_request_kwargs)
 
         return _track_request
 
@@ -138,6 +152,12 @@ class PromptLayer(PromptLayerMixin):
             model_parameter_overrides=model_parameter_overrides,
         )
         prompt_blueprint = self.templates.get(prompt_name, get_prompt_template_params)
+        if not prompt_blueprint:
+            raise _exceptions.PromptLayerNotFoundError(
+                f"Prompt template '{prompt_name}' not found.",
+                response=None,
+                body=None,
+            )
         prompt_blueprint_model = self._validate_and_extract_model_from_prompt_blueprint(
             prompt_blueprint=prompt_blueprint, prompt_name=prompt_name
         )
@@ -212,7 +232,7 @@ class PromptLayer(PromptLayerMixin):
             metadata=metadata,
             **body,
         )
-        return track_request(**track_request_kwargs)
+        return track_request(self.base_url, self.throw_on_error, **track_request_kwargs)
 
     def run(
         self,
@@ -277,12 +297,14 @@ class PromptLayer(PromptLayerMixin):
 
             results = asyncio.run(
                 arun_workflow_request(
+                    api_key=self.api_key,
+                    base_url=self.base_url,
+                    throw_on_error=self.throw_on_error,
                     workflow_id_or_name=_get_workflow_workflow_id_or_name(workflow_id_or_name, workflow_name),
                     input_variables=input_variables or {},
                     metadata=metadata,
                     workflow_label_name=workflow_label_name,
                     workflow_version_number=workflow_version,
-                    api_key=self.api_key,
                     return_all_outputs=return_all_outputs,
                 )
             )
@@ -290,10 +312,16 @@ class PromptLayer(PromptLayerMixin):
             if not return_all_outputs and is_workflow_results_dict(results):
                 output_nodes = [node_data for node_data in results.values() if node_data.get("is_output_node")]
                 if not output_nodes:
-                    raise Exception("Output nodes not found: %S", json.dumps(results, indent=4))
+                    raise _exceptions.PromptLayerNotFoundError(
+                        f"Output nodes not found: {json.dumps(results, indent=4)}", response=None, body=results
+                    )
 
                 if not any(node.get("status") == "SUCCESS" for node in output_nodes):
-                    raise Exception("None of the output nodes have succeeded", json.dumps(results, indent=4))
+                    raise _exceptions.PromptLayerAPIError(
+                        f"None of the output nodes have succeeded: {json.dumps(results, indent=4)}",
+                        response=None,
+                        body=results,
+                    )
 
             return results
         except Exception as ex:
@@ -301,7 +329,9 @@ class PromptLayer(PromptLayerMixin):
             if RERAISE_ORIGINAL_EXCEPTION:
                 raise
             else:
-                raise Exception(f"Error running workflow: {str(ex)}") from ex
+                raise _exceptions.PromptLayerAPIError(
+                    f"Error running workflow: {str(ex)}", response=None, body=None
+                ) from ex
 
     def log_request(
         self,
@@ -330,6 +360,8 @@ class PromptLayer(PromptLayerMixin):
     ):
         return util_log_request(
             self.api_key,
+            self.base_url,
+            throw_on_error=self.throw_on_error,
             provider=provider,
             model=model,
             input=input,
@@ -355,8 +387,10 @@ class PromptLayer(PromptLayerMixin):
 class AsyncPromptLayer(PromptLayerMixin):
     def __init__(
         self,
-        api_key: str = None,
+        api_key: Union[str, None] = None,
         enable_tracing: bool = False,
+        base_url: Union[str, None] = None,
+        throw_on_error: bool = True,
     ):
         if api_key is None:
             api_key = os.environ.get("PROMPTLAYER_API_KEY")
@@ -367,31 +401,33 @@ class AsyncPromptLayer(PromptLayerMixin):
                 "Please set the PROMPTLAYER_API_KEY environment variable or pass the api_key parameter."
             )
 
+        self.base_url = get_base_url(base_url)
         self.api_key = api_key
-        self.templates = AsyncTemplateManager(api_key)
-        self.group = AsyncGroupManager(api_key)
-        self.tracer_provider, self.tracer = self._initialize_tracer(api_key, enable_tracing)
-        self.track = AsyncTrackManager(api_key)
+        self.throw_on_error = throw_on_error
+        self.templates = AsyncTemplateManager(api_key, self.base_url, self.throw_on_error)
+        self.group = AsyncGroupManager(api_key, self.base_url, self.throw_on_error)
+        self.tracer_provider, self.tracer = self._initialize_tracer(
+            api_key, self.base_url, self.throw_on_error, enable_tracing
+        )
+        self.track = AsyncTrackManager(api_key, self.base_url, self.throw_on_error)
 
     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,
+                self.api_key, self.base_url, openai_module, function_name="openai", tracer=self.tracer
             )
             return openai
         elif name == "anthropic":
             import anthropic as anthropic_module
 
             anthropic = PromptLayerBase(
+                self.api_key,
+                self.base_url,
                 anthropic_module,
                 function_name="anthropic",
                 provider_type="anthropic",
-                api_key=self.api_key,
                 tracer=self.tracer,
             )
             return anthropic
@@ -413,12 +449,14 @@ class AsyncPromptLayer(PromptLayerMixin):
     ) -> Union[Dict[str, Any], Any]:
         try:
             return await arun_workflow_request(
+                api_key=self.api_key,
+                base_url=self.base_url,
+                throw_on_error=self.throw_on_error,
                 workflow_id_or_name=_get_workflow_workflow_id_or_name(workflow_id_or_name, workflow_name),
                 input_variables=input_variables or {},
                 metadata=metadata,
                 workflow_label_name=workflow_label_name,
                 workflow_version_number=workflow_version,
-                api_key=self.api_key,
                 return_all_outputs=return_all_outputs,
             )
         except Exception as ex:
@@ -426,7 +464,9 @@ class AsyncPromptLayer(PromptLayerMixin):
             if RERAISE_ORIGINAL_EXCEPTION:
                 raise
             else:
-                raise Exception(f"Error running workflow: {str(ex)}")
+                raise _exceptions.PromptLayerAPIError(
+                    f"Error running workflow: {str(ex)}", response=None, body=None
+                ) from ex
 
     async def run(
         self,
@@ -491,6 +531,8 @@ class AsyncPromptLayer(PromptLayerMixin):
     ):
         return await autil_log_request(
             self.api_key,
+            self.base_url,
+            throw_on_error=self.throw_on_error,
             provider=provider,
             model=model,
             input=input,
@@ -530,7 +572,7 @@ class AsyncPromptLayer(PromptLayerMixin):
                 pl_run_span_id,
                 **body,
             )
-            return await atrack_request(**track_request_kwargs)
+            return await atrack_request(self.base_url, self.throw_on_error, **track_request_kwargs)
 
         return _track_request
 
@@ -554,7 +596,7 @@ class AsyncPromptLayer(PromptLayerMixin):
             metadata=metadata,
             **body,
         )
-        return await atrack_request(**track_request_kwargs)
+        return await atrack_request(self.base_url, self.throw_on_error, **track_request_kwargs)
 
     async def _run_internal(
         self,
@@ -582,6 +624,12 @@ class AsyncPromptLayer(PromptLayerMixin):
             model_parameter_overrides=model_parameter_overrides,
         )
         prompt_blueprint = await self.templates.get(prompt_name, get_prompt_template_params)
+        if not prompt_blueprint:
+            raise _exceptions.PromptLayerNotFoundError(
+                f"Prompt template '{prompt_name}' not found.",
+                response=None,
+                body=None,
+            )
         prompt_blueprint_model = self._validate_and_extract_model_from_prompt_blueprint(
             prompt_blueprint=prompt_blueprint, prompt_name=prompt_name
         )
@@ -631,6 +679,6 @@ class AsyncPromptLayer(PromptLayerMixin):
 
         return {
             "request_id": request_log.get("request_id", None),
-            "raw_response": request_response,
+            "raw_response": response,
             "prompt_blueprint": request_log.get("prompt_blueprint", None),
         }

promptlayer/promptlayer_base.py

@@ -2,6 +2,7 @@ import datetime
 import inspect
 import re
 
+from promptlayer import exceptions as _exceptions
 from promptlayer.utils import async_wrapper, promptlayer_api_handler
 
 
@@ -13,14 +14,16 @@ class PromptLayerBase(object):
         "_provider_type",
         "_api_key",
         "_tracer",
+        "_base_url",
     ]
 
-    def __init__(self, obj, function_name="", provider_type="openai", api_key=None, tracer=None):
+    def __init__(self, api_key: str, base_url: str, obj, function_name="", provider_type="openai", 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)
+        object.__setattr__(self, "_base_url", base_url)
 
     def __getattr__(self, name):
         attr = getattr(object.__getattribute__(self, "_obj"), name)
@@ -41,10 +44,11 @@ class PromptLayerBase(object):
             )
         ):
             return PromptLayerBase(
+                object.__getattribute__(self, "_api_key"),
+                object.__getattribute__(self, "_base_url"),
                 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
@@ -58,7 +62,7 @@ class PromptLayerBase(object):
     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.")
+            raise _exceptions.PromptLayerValidationError("pl_tags must be a list of strings.", response=None, body=None)
 
         return_pl_id = kwargs.pop("return_pl_id", False)
         request_start_time = datetime.datetime.now().timestamp()
@@ -75,10 +79,11 @@ class PromptLayerBase(object):
 
                 if inspect.isclass(function_object):
                     result = PromptLayerBase(
+                        object.__getattribute__(self, "_api_key"),
+                        object.__getattribute__(self, "_base_url"),
                         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))
@@ -88,13 +93,14 @@ class PromptLayerBase(object):
 
                 if inspect.iscoroutinefunction(function_object) or inspect.iscoroutine(function_response):
                     return async_wrapper(
+                        object.__getattribute__(self, "_api_key"),
+                        object.__getattribute__(self, "_base_url"),
                         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,
@@ -103,6 +109,8 @@ class PromptLayerBase(object):
 
                 request_end_time = datetime.datetime.now().timestamp()
                 result = promptlayer_api_handler(
+                    object.__getattribute__(self, "_api_key"),
+                    object.__getattribute__(self, "_base_url"),
                     function_name,
                     object.__getattribute__(self, "_provider_type"),
                     args,
@@ -111,7 +119,6 @@ class PromptLayerBase(object):
                     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,
                 )
@@ -121,29 +128,33 @@ class PromptLayerBase(object):
             # Without tracing
             if inspect.isclass(function_object):
                 return PromptLayerBase(
+                    object.__getattribute__(self, "_api_key"),
+                    object.__getattribute__(self, "_base_url"),
                     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(
+                    object.__getattribute__(self, "_api_key"),
+                    object.__getattribute__(self, "_base_url"),
                     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(
+                object.__getattribute__(self, "_api_key"),
+                object.__getattribute__(self, "_base_url"),
                 function_name,
                 object.__getattribute__(self, "_provider_type"),
                 args,
@@ -152,6 +163,5 @@ class PromptLayerBase(object):
                 function_response,
                 request_start_time,
                 request_end_time,
-                object.__getattribute__(self, "_api_key"),
                 return_pl_id=return_pl_id,
             )

promptlayer/promptlayer_mixins.py

@@ -262,11 +262,13 @@ AMAP_PROVIDER_TO_FUNCTION = {
 
 class PromptLayerMixin:
     @staticmethod
-    def _initialize_tracer(api_key: str = None, enable_tracing: bool = False):
+    def _initialize_tracer(api_key: str, base_url: str, throw_on_error: bool, enable_tracing: bool = False):
         if enable_tracing:
             resource = Resource(attributes={ResourceAttributes.SERVICE_NAME: "prompt-layer-library"})
             tracer_provider = TracerProvider(resource=resource)
-            promptlayer_exporter = PromptLayerSpanExporter(api_key=api_key)
+            promptlayer_exporter = PromptLayerSpanExporter(
+                api_key=api_key, base_url=base_url, throw_on_error=throw_on_error
+            )
             span_processor = BatchSpanProcessor(promptlayer_exporter)
             tracer_provider.add_span_processor(span_processor)
             tracer = tracer_provider.get_tracer(__name__)
@@ -317,7 +319,7 @@ class PromptLayerMixin:
         function_kwargs = deepcopy(prompt_blueprint["llm_kwargs"])
         function_kwargs["stream"] = stream
         provider = prompt_blueprint_model["provider"]
-        api_type = prompt_blueprint_model["api_type"]
+        api_type = prompt_blueprint_model.get("api_type", "chat-completions")
 
         if custom_provider := prompt_blueprint.get("custom_provider"):
             provider = custom_provider["client"]