promptlayer 1.0.70__tar.gz → 1.0.72__tar.gz

{promptlayer-1.0.70 → promptlayer-1.0.72}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: promptlayer
-Version: 1.0.70
+Version: 1.0.72
 Summary: PromptLayer is a platform for prompt engineering and tracks your LLM requests.
 License: Apache-2.0
 License-File: LICENSE
@@ -17,6 +17,7 @@ Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
 Requires-Dist: ably (>=2.0.11,<3.0.0)
 Requires-Dist: aiohttp (>=3.10.10,<4.0.0)
+Requires-Dist: centrifuge-python (>=0.4.1,<0.5.0)
 Requires-Dist: httpx (>=0.28.1,<0.29.0)
 Requires-Dist: nest-asyncio (>=1.6.0,<2.0.0)
 Requires-Dist: opentelemetry-api (>=1.26.0,<2.0.0)

{promptlayer-1.0.70 → promptlayer-1.0.72}/promptlayer/__init__.py

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

promptlayer-1.0.72/promptlayer/groups/__init__.py

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

promptlayer-1.0.72/promptlayer/groups/groups.py

@@ -0,0 +1,9 @@
+from promptlayer.utils import apromptlayer_create_group, promptlayer_create_group
+
+
+def create(api_key: str, base_url: str):
+    return promptlayer_create_group(api_key, base_url)
+
+
+async def acreate(api_key: str, base_url: str):
+    return await apromptlayer_create_group(api_key, base_url)

{promptlayer-1.0.70 → promptlayer-1.0.72}/promptlayer/promptlayer.py

@@ -26,6 +26,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
@@ -49,9 +53,7 @@ def is_workflow_results_dict(obj: Any) -> bool:
 
 class PromptLayer(PromptLayerMixin):
     def __init__(
-        self,
-        api_key: str = None,
-        enable_tracing: bool = False,
+        self, api_key: Union[str, None] = None, enable_tracing: bool = False, base_url: Union[str, None] = None
     ):
         if api_key is None:
             api_key = os.environ.get("PROMPTLAYER_API_KEY")
@@ -62,11 +64,12 @@ 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.templates = TemplateManager(api_key, self.base_url)
+        self.group = GroupManager(api_key, self.base_url)
+        self.tracer_provider, self.tracer = self._initialize_tracer(api_key, self.base_url, enable_tracing)
+        self.track = TrackManager(api_key, self.base_url)
 
     def __getattr__(
         self,
@@ -75,15 +78,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:
@@ -212,7 +218,7 @@ class PromptLayer(PromptLayerMixin):
             metadata=metadata,
             **body,
         )
-        return track_request(**track_request_kwargs)
+        return track_request(self.base_url, **track_request_kwargs)
 
     def run(
         self,
@@ -277,12 +283,13 @@ class PromptLayer(PromptLayerMixin):
 
             results = asyncio.run(
                 arun_workflow_request(
+                    api_key=self.api_key,
+                    base_url=self.base_url,
                     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,
                 )
             )
@@ -330,6 +337,7 @@ class PromptLayer(PromptLayerMixin):
     ):
         return util_log_request(
             self.api_key,
+            self.base_url,
             provider=provider,
             model=model,
             input=input,
@@ -354,9 +362,7 @@ class PromptLayer(PromptLayerMixin):
 
 class AsyncPromptLayer(PromptLayerMixin):
     def __init__(
-        self,
-        api_key: str = None,
-        enable_tracing: bool = False,
+        self, api_key: Union[str, None] = None, enable_tracing: bool = False, base_url: Union[str, None] = None
     ):
         if api_key is None:
             api_key = os.environ.get("PROMPTLAYER_API_KEY")
@@ -367,31 +373,30 @@ 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.templates = AsyncTemplateManager(api_key, self.base_url)
+        self.group = AsyncGroupManager(api_key, self.base_url)
+        self.tracer_provider, self.tracer = self._initialize_tracer(api_key, self.base_url, enable_tracing)
+        self.track = AsyncTrackManager(api_key, self.base_url)
 
     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 +418,13 @@ class AsyncPromptLayer(PromptLayerMixin):
     ) -> Union[Dict[str, Any], Any]:
         try:
             return await arun_workflow_request(
+                api_key=self.api_key,
+                base_url=self.base_url,
                 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:
@@ -491,6 +497,7 @@ class AsyncPromptLayer(PromptLayerMixin):
     ):
         return await autil_log_request(
             self.api_key,
+            self.base_url,
             provider=provider,
             model=model,
             input=input,
@@ -530,7 +537,7 @@ class AsyncPromptLayer(PromptLayerMixin):
                 pl_run_span_id,
                 **body,
             )
-            return await atrack_request(**track_request_kwargs)
+            return await atrack_request(self.base_url, **track_request_kwargs)
 
         return _track_request
 
@@ -554,7 +561,7 @@ class AsyncPromptLayer(PromptLayerMixin):
             metadata=metadata,
             **body,
         )
-        return await atrack_request(**track_request_kwargs)
+        return await atrack_request(self.base_url, **track_request_kwargs)
 
     async def _run_internal(
         self,
@@ -631,6 +638,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-1.0.70 → promptlayer-1.0.72}/promptlayer/promptlayer_base.py

@@ -13,14 +13,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 +43,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
@@ -75,10 +78,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 +92,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 +108,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 +118,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 +127,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 +162,5 @@ class PromptLayerBase(object):
                 function_response,
                 request_start_time,
                 request_end_time,
-                object.__getattribute__(self, "_api_key"),
                 return_pl_id=return_pl_id,
             )

{promptlayer-1.0.70 → promptlayer-1.0.72}/promptlayer/promptlayer_mixins.py

@@ -262,11 +262,11 @@ 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, 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)
             span_processor = BatchSpanProcessor(promptlayer_exporter)
             tracer_provider.add_span_processor(span_processor)
             tracer = tracer_provider.get_tracer(__name__)
@@ -317,7 +317,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"]

{promptlayer-1.0.70 → promptlayer-1.0.72}/promptlayer/span_exporter.py

@@ -4,13 +4,11 @@ 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):
+    def __init__(self, api_key: str, base_url: str):
         self.api_key = api_key
-        self.url = f"{URL_API_PROMPTLAYER}/spans-bulk"
+        self.url = f"{base_url}/spans-bulk"
 
     def export(self, spans: Sequence[ReadableSpan]) -> SpanExportResult:
         request_data = []

{promptlayer-1.0.70 → promptlayer-1.0.72}/promptlayer/templates.py

@@ -11,25 +11,27 @@ from promptlayer.utils import (
 
 
 class TemplateManager:
-    def __init__(self, api_key: str):
+    def __init__(self, api_key: str, base_url: str):
         self.api_key = api_key
+        self.base_url = base_url
 
     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, 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, 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, page, per_page, label)
 
 
 class AsyncTemplateManager:
-    def __init__(self, api_key: str):
+    def __init__(self, api_key: str, base_url: str):
         self.api_key = api_key
+        self.base_url = base_url
 
     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, 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, page, per_page, label)

{promptlayer-1.0.70 → promptlayer-1.0.72}/promptlayer/track/__init__.py

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

{promptlayer-1.0.70 → promptlayer-1.0.72}/promptlayer/track/track.py

@@ -11,72 +11,78 @@ from promptlayer.utils import (
 
 
 def prompt(
+    api_key: str,
+    base_url: str,
     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)
+    return promptlayer_track_prompt(
+        api_key, base_url, 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, request_id, metadata):
     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)
+    return promptlayer_track_metadata(api_key, base_url, request_id, metadata)
 
 
-def score(request_id, score, score_name=None, api_key: str = None):
+def score(api_key: str, base_url: str, request_id, score, score_name=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)
+    return promptlayer_track_score(api_key, base_url, 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, request_id, group_id):
+    return promptlayer_track_group(api_key, base_url, request_id, group_id)
 
 
 async def aprompt(
+    api_key: str,
+    base_url: str,
     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)
+    return await apromptlayer_track_prompt(
+        api_key, base_url, 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, request_id, metadata):
     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)
+    return await apromptlayer_track_metadata(api_key, base_url, 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, request_id, score, score_name=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)
+    return await apromptlayer_track_score(api_key, base_url, 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, request_id, group_id):
+    return await apromptlayer_track_group(api_key, base_url, request_id, group_id)