prompty 0.1.17__tar.gz → 0.1.19__tar.gz

{prompty-0.1.17 → prompty-0.1.19}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: prompty
-Version: 0.1.17
+Version: 0.1.19
 Summary: Prompty is a new asset class and format for LLM prompts that aims to provide observability, understandability, and portability for developers. It includes spec, tooling, and a runtime. This Prompty runtime supports Python
 Author-Email: Seth Juarez <seth.juarez@microsoft.com>
 Requires-Dist: pyyaml>=6.0.1

prompty-0.1.19/prompty/azure/executor.py

@@ -0,0 +1,120 @@
+import azure.identity
+import importlib.metadata
+from typing import Iterator
+from openai import AzureOpenAI
+
+from prompty.tracer import Tracer
+from ..core import Invoker, InvokerFactory, Prompty, PromptyStream
+
+VERSION = importlib.metadata.version("prompty")
+
+
+@InvokerFactory.register_executor("azure")
+@InvokerFactory.register_executor("azure_openai")
+class AzureOpenAIExecutor(Invoker):
+    """Azure OpenAI Executor"""
+
+    def __init__(self, prompty: Prompty) -> None:
+        super().__init__(prompty)
+        self.kwargs = {
+            key: value
+            for key, value in self.prompty.model.configuration.items()
+            if key != "type"
+        }
+
+        # no key, use default credentials
+        if "api_key" not in self.kwargs:
+            # managed identity if client id
+            if "client_id" in self.kwargs:
+                default_credential = azure.identity.ManagedIdentityCredential(
+                    client_id=self.kwargs.pop("client_id"),
+                )
+            # default credential
+            else:
+                default_credential = azure.identity.DefaultAzureCredential(
+                    exclude_shared_token_cache_credential=True
+                )
+
+            self.kwargs["azure_ad_token_provider"] = (
+                azure.identity.get_bearer_token_provider(
+                    default_credential, "https://cognitiveservices.azure.com/.default"
+                )
+            )
+
+        self.api = self.prompty.model.api
+        self.deployment = self.prompty.model.configuration["azure_deployment"]
+        self.parameters = self.prompty.model.parameters
+
+    def invoke(self, data: any) -> any:
+        """Invoke the Azure OpenAI API
+
+        Parameters
+        ----------
+        data : any
+            The data to send to the Azure OpenAI API
+
+        Returns
+        -------
+        any
+            The response from the Azure OpenAI API
+        """
+
+        with Tracer.start("AzureOpenAI") as trace:
+            trace("type", "LLM")
+            trace("signature", "AzureOpenAI.ctor")
+            trace("description", "Azure OpenAI Constructor")
+            trace("inputs", self.kwargs)
+            client = AzureOpenAI(
+                default_headers={
+                    "User-Agent": f"prompty/{VERSION}",
+                    "x-ms-useragent": f"prompty/{VERSION}",
+                },
+                **self.kwargs,
+            )
+            trace("result", client)
+
+        with Tracer.start("create") as trace:
+            trace("type", "LLM")
+            trace("description", "Azure OpenAI Client")
+
+            if self.api == "chat":
+                trace("signature", "AzureOpenAI.chat.completions.create")
+                args = {
+                    "model": self.deployment,
+                    "messages": data if isinstance(data, list) else [data],
+                    **self.parameters,
+                }
+                trace("inputs", args)
+                response = client.chat.completions.create(**args)
+                trace("result", response)
+
+            elif self.api == "completion":
+                trace("signature", "AzureOpenAI.completions.create")
+                args = {
+                    "prompt": data.item,
+                    "model": self.deployment,
+                    **self.parameters,
+                }
+                trace("inputs", args)
+                response = client.completions.create(**args)
+                trace("result", response)
+
+            elif self.api == "embedding":
+                trace("signature", "AzureOpenAI.embeddings.create")
+                args = {
+                    "input": data if isinstance(data, list) else [data],
+                    "model": self.deployment,
+                    **self.parameters,
+                }
+                trace("inputs", args)
+                response = client.embeddings.create(**args)
+                trace("result", response)
+
+            elif self.api == "image":
+                raise NotImplementedError("Azure OpenAI Image API is not implemented yet")
+
+        # stream response
+        if isinstance(response, Iterator):
+            return PromptyStream("AzureOpenAIExecutor", response)
+        else:
+            return response

{prompty-0.1.17 → prompty-0.1.19}/prompty/core.py

@@ -529,7 +529,9 @@ class PromptyStream(Iterator):
             # StopIteration is raised
             # contents are exhausted
             if len(self.items) > 0:
-                with Tracer.start(f"{self.name}.PromptyStream") as trace:
+                with Tracer.start("PromptyStream") as trace:
+                    trace("signature", f"{self.name}.PromptyStream")
+                    trace("inputs", "None")
                     trace("result", [to_dict(s) for s in self.items])
 
             raise StopIteration

prompty-0.1.19/prompty/openai/executor.py

@@ -0,0 +1,98 @@
+import importlib.metadata
+from openai import OpenAI
+from typing import Iterator
+
+from prompty.tracer import Tracer
+from ..core import Invoker, InvokerFactory, Prompty, PromptyStream
+
+VERSION = importlib.metadata.version("prompty")
+
+
+@InvokerFactory.register_executor("openai")
+class OpenAIExecutor(Invoker):
+    """OpenAI Executor"""
+
+    def __init__(self, prompty: Prompty) -> None:
+        super().__init__(prompty)
+        self.kwargs = {
+            key: value
+            for key, value in self.prompty.model.configuration.items()
+            if key != "type"
+        }
+
+        self.api = self.prompty.model.api
+        self.deployment = self.prompty.model.configuration["azure_deployment"]
+        self.parameters = self.prompty.model.parameters
+
+    def invoke(self, data: any) -> any:
+        """Invoke the OpenAI API
+
+        Parameters
+        ----------
+        data : any
+            The data to send to the OpenAI API
+
+        Returns
+        -------
+        any
+            The response from the OpenAI API
+        """
+        with Tracer.start("OpenAI") as trace:
+            trace("type", "LLM")
+            trace("signature", "OpenAI.ctor")
+            trace("description", "OpenAI Constructor")
+            trace("inputs", self.kwargs)
+            client = OpenAI(
+                default_headers={
+                    "User-Agent": f"prompty/{VERSION}",
+                    "x-ms-useragent": f"prompty/{VERSION}",
+                },
+                **self.kwargs,
+            )
+            trace("result", client)
+
+        with Tracer.start("create") as trace:
+            trace("type", "LLM")
+            trace("description", "OpenAI Prompty Execution Invoker")
+
+            if self.api == "chat":
+                trace("signature", "OpenAI.chat.completions.create")
+                args = {
+                    "model": self.deployment,
+                    "messages": data if isinstance(data, list) else [data],
+                    **self.parameters,
+                }
+                trace("inputs", args)
+                response = client.chat.completions.create(**args)
+
+            elif self.api == "completion":
+                trace("signature", "OpenAI.completions.create")
+                args = {
+                    "prompt": data.item,
+                    "model": self.deployment,
+                    **self.parameters,
+                }
+                trace("inputs", args)
+                response = client.completions.create(**args)
+
+            elif self.api == "embedding":
+                trace("signature", "OpenAI.embeddings.create")
+                args = {
+                    "input": data if isinstance(data, list) else [data],
+                    "model": self.deployment,
+                    **self.parameters,
+                }
+                trace("inputs", args)
+                response = client.embeddings.create(**args)
+
+            elif self.api == "image":
+                raise NotImplementedError("OpenAI Image API is not implemented yet")
+
+            # stream response
+            if isinstance(response, Iterator):
+                stream = PromptyStream("AzureOpenAIExecutor", response)
+                trace("result", stream)
+                return stream
+            else:
+                trace("result", response)
+                return response

prompty-0.1.19/prompty/serverless/executor.py

@@ -0,0 +1,131 @@
+import importlib.metadata
+from typing import Iterator
+from azure.core.credentials import AzureKeyCredential
+from azure.ai.inference import (
+    ChatCompletionsClient,
+    EmbeddingsClient,
+)
+from azure.ai.inference.models import (
+    StreamingChatCompletions,
+    AsyncStreamingChatCompletions,
+)
+
+from prompty.tracer import Tracer
+from ..core import Invoker, InvokerFactory, Prompty, PromptyStream, AsyncPromptyStream
+
+VERSION = importlib.metadata.version("prompty")
+
+
+@InvokerFactory.register_executor("serverless")
+class ServerlessExecutor(Invoker):
+    """Azure OpenAI Executor"""
+
+    def __init__(self, prompty: Prompty) -> None:
+        super().__init__(prompty)
+
+        # serverless configuration
+        self.endpoint = self.prompty.model.configuration["endpoint"]
+        self.model = self.prompty.model.configuration["model"]
+        self.key = self.prompty.model.configuration["key"]
+
+        # api type
+        self.api = self.prompty.model.api
+
+    def _response(self, response: any) -> any:
+        # stream response
+        if isinstance(response, Iterator):
+            if isinstance(response, StreamingChatCompletions):
+                stream = PromptyStream("ServerlessExecutor", response)
+                return stream
+            elif isinstance(response, AsyncStreamingChatCompletions):
+                stream = AsyncPromptyStream("ServerlessExecutor", response)
+                return stream
+            else:
+                stream = PromptyStream("ServerlessExecutor", response)
+
+            return stream
+        else:
+            return response
+
+    def invoke(self, data: any) -> any:
+        """Invoke the Serverless SDK
+
+        Parameters
+        ----------
+        data : any
+            The data to send to the Serverless SDK
+
+        Returns
+        -------
+        any
+            The response from the Serverless SDK
+        """
+
+        cargs = {
+            "endpoint": self.endpoint,
+            "credential": AzureKeyCredential(self.key),
+        }
+
+        if self.api == "chat":
+            with Tracer.start("ChatCompletionsClient") as trace:
+                trace("type", "LLM")
+                trace("signature", "azure.ai.inference.ChatCompletionsClient.ctor")
+                trace("description", "Azure Unified Inference SDK Chat Completions Client")
+                trace("inputs", cargs)
+                client = ChatCompletionsClient(
+                    user_agent=f"prompty/{VERSION}",
+                    **cargs,
+                )
+                trace("result", client)
+
+            with Tracer.start("complete") as trace:
+                trace("type", "LLM")
+                trace("signature", "azure.ai.inference.ChatCompletionsClient.complete")
+                trace("description", "Azure Unified Inference SDK Chat Completions Client")
+                eargs = {
+                    "model": self.model,
+                    "messages": data if isinstance(data, list) else [data],
+                    **self.prompty.model.parameters,
+                }
+                trace("inputs", eargs)
+                r = client.complete(**eargs)
+                trace("result", r)
+
+            response = self._response(r)
+
+        elif self.api == "completion":
+            raise NotImplementedError(
+                "Serverless Completions API is not implemented yet"
+            )
+
+        elif self.api == "embedding":
+            with Tracer.start("EmbeddingsClient") as trace:
+                trace("type", "LLM")
+                trace("signature", "azure.ai.inference.EmbeddingsClient.ctor")
+                trace("description", "Azure Unified Inference SDK Embeddings Client")
+                trace("inputs", cargs)
+                client = EmbeddingsClient(
+                    user_agent=f"prompty/{VERSION}",
+                    **cargs,
+                )
+                trace("result", client)
+
+            with Tracer.start("complete") as trace:
+                trace("type", "LLM")
+                trace("signature", "azure.ai.inference.ChatCompletionsClient.complete")
+                trace("description", "Azure Unified Inference SDK Chat Completions Client")
+                eargs = {
+                    "model": self.model,
+                    "input": data if isinstance(data, list) else [data],
+                    **self.prompty.model.parameters,
+                }
+                trace("inputs", eargs)
+                r = client.complete(**eargs)
+                trace("result", r)
+
+            response = self._response(r)
+
+        elif self.api == "image":
+            raise NotImplementedError("Azure OpenAI Image API is not implemented yet")
+
+        return response

{prompty-0.1.17 → prompty-0.1.19}/prompty/tracer.py

@@ -11,6 +11,18 @@ from functools import wraps, partial
 from typing import Any, Callable, Dict, Iterator, List
 
 
+# clean up key value pairs for sensitive values
+def sanitize(key: str, value: Any) -> Any:
+    if isinstance(value, str) and any(
+        [s in key.lower() for s in ["key", "token", "secret", "password", "credential"]]
+    ):
+        return len(str(value)) * "*"
+    elif isinstance(value, dict):
+        return {k: sanitize(k, v) for k, v in value.items()}
+    else:
+        return value
+
+
 class Tracer:
     _tracers: Dict[str, Callable[[str], Iterator[Callable[[str, Any], None]]]] = {}
 
@@ -31,7 +43,11 @@ class Tracer:
             traces = [
                 stack.enter_context(tracer(name)) for tracer in cls._tracers.values()
             ]
-            yield lambda key, value: [trace(key, value) for trace in traces]
+            yield lambda key, value: [
+                # normalize and sanitize any trace values
+                trace(key, sanitize(key, to_dict(value)))
+                for trace in traces
+            ]
 
 
 def to_dict(obj: Any) -> Dict[str, Any]:
@@ -94,7 +110,9 @@ def _results(result: Any) -> dict:
     return to_dict(result) if result is not None else "None"
 
 
-def _trace_sync(func: Callable = None, *, description: str = None) -> Callable:
+def _trace_sync(
+    func: Callable = None, *, description: str = None, type: str = None
+) -> Callable:
     description = description or ""
 
     @wraps(func)
@@ -105,18 +123,36 @@ def _trace_sync(func: Callable = None, *, description: str = None) -> Callable:
             if description and description != "":
                 trace("description", description)
 
+            if type and type != "":
+                trace("type", type)
+
             inputs = _inputs(func, args, kwargs)
             trace("inputs", inputs)
 
-            result = func(*args, **kwargs)
-            trace("result", _results(result))
+            try:
+                result = func(*args, **kwargs)
+                trace("result", _results(result))
+            except Exception as e:
+                trace(
+                    "result",
+                    {
+                        "exception": {
+                            "type": type(e).__name__,
+                            "message": str(e),
+                            "args": to_dict(e.args),
+                        }
+                    },
+                )
+                raise e
 
             return result
 
     return wrapper
 
 
-def _trace_async(func: Callable = None, *, description: str = None) -> Callable:
+def _trace_async(
+    func: Callable = None, *, description: str = None, type: str = None
+) -> Callable:
     description = description or ""
 
     @wraps(func)
@@ -127,24 +163,41 @@ def _trace_async(func: Callable = None, *, description: str = None) -> Callable:
             if description and description != "":
                 trace("description", description)
 
+            if type and type != "":
+                trace("type", type)
+
             inputs = _inputs(func, args, kwargs)
             trace("inputs", inputs)
-
-            result = await func(*args, **kwargs)
-            trace("result", _results(result))
+            try:
+                result = await func(*args, **kwargs)
+                trace("result", _results(result))
+            except Exception as e:
+                trace(
+                    "result",
+                    {
+                        "exception": {
+                            "type": type(e).__name__,
+                            "message": str(e),
+                            "args": to_dict(e.args),
+                        }
+                    },
+                )
+                raise e
 
             return result
 
     return wrapper
 
 
-def trace(func: Callable = None, *, description: str = None) -> Callable:
+def trace(
+    func: Callable = None, *, description: str = None, type: str = None
+) -> Callable:
     if func is None:
-        return partial(trace, description=description)
+        return partial(trace, description=description, type=type)
 
     wrapped_method = _trace_async if inspect.iscoroutinefunction(func) else _trace_sync
 
-    return wrapped_method(func, description=description)
+    return wrapped_method(func, description=description, type=type)
 
 
 class PromptyTracer:
@@ -255,6 +308,8 @@ class PromptyTracer:
 def console_tracer(name: str) -> Iterator[Callable[[str, Any], None]]:
     try:
         print(f"Starting {name}")
-        yield lambda key, value: print(f"{key}:\n{json.dumps(value, indent=4)}")
+        yield lambda key, value: print(
+            f"{key}:\n{json.dumps(to_dict(value), indent=4)}"
+        )
     finally:
         print(f"Ending {name}")

{prompty-0.1.17 → prompty-0.1.19}/pyproject.toml

@@ -13,7 +13,7 @@ dependencies = [
     "python-dotenv>=1.0.1",
     "click>=8.1.7",
 ]
-version = "0.1.17"
+version = "0.1.19"
 
 [project.optional-dependencies]
 azure = [

{prompty-0.1.17 → prompty-0.1.19}/tests/test_execute.py

@@ -3,7 +3,6 @@ import pytest
 import prompty
 from prompty.core import InvokerFactory
 
-
 from tests.fake_azure_executor import FakeAzureExecutor
 from tests.fake_serverless_executor import FakeServerlessExecutor
 from prompty.azure import AzureOpenAIProcessor
@@ -24,6 +23,7 @@ def fake_azure_executor():
     InvokerFactory.add_processor("serverless", ServerlessProcessor)
 
 
+
 @pytest.mark.parametrize(
     "prompt",
     [
@@ -151,6 +151,7 @@ def test_streaming():
 
 
 def test_serverless():
+    
     result = prompty.execute(
         "prompts/serverless.prompty",
         configuration={"key": os.environ.get("SERVERLESS_KEY", "key")},

prompty-0.1.17/prompty/azure/executor.py

@@ -1,95 +0,0 @@
-import azure.identity
-import importlib.metadata
-from typing import Iterator
-from openai import AzureOpenAI
-from ..core import Invoker, InvokerFactory, Prompty, PromptyStream
-
-VERSION = importlib.metadata.version("prompty")
-
-
-@InvokerFactory.register_executor("azure")
-@InvokerFactory.register_executor("azure_openai")
-class AzureOpenAIExecutor(Invoker):
-    """Azure OpenAI Executor"""
-
-    def __init__(self, prompty: Prompty) -> None:
-        super().__init__(prompty)
-        kwargs = {
-            key: value
-            for key, value in self.prompty.model.configuration.items()
-            if key != "type"
-        }
-
-        # no key, use default credentials
-        if "api_key" not in kwargs:
-            # managed identity if client id
-            if "client_id" in kwargs:
-                default_credential = azure.identity.ManagedIdentityCredential(
-                    client_id=kwargs.pop("client_id"),
-                )
-            # default credential
-            else:
-                default_credential = azure.identity.DefaultAzureCredential(
-                    exclude_shared_token_cache_credential=True
-                )
-
-            kwargs["azure_ad_token_provider"] = (
-                azure.identity.get_bearer_token_provider(
-                    default_credential, "https://cognitiveservices.azure.com/.default"
-                )
-            )
-
-        self.client = AzureOpenAI(
-            default_headers={
-                "User-Agent": f"prompty/{VERSION}",
-                "x-ms-useragent": f"prompty/{VERSION}",
-            },
-            **kwargs,
-        )
-
-        self.api = self.prompty.model.api
-        self.deployment = self.prompty.model.configuration["azure_deployment"]
-        self.parameters = self.prompty.model.parameters
-
-    def invoke(self, data: any) -> any:
-        """Invoke the Azure OpenAI API
-
-        Parameters
-        ----------
-        data : any
-            The data to send to the Azure OpenAI API
-
-        Returns
-        -------
-        any
-            The response from the Azure OpenAI API
-        """
-        if self.api == "chat":
-            response = self.client.chat.completions.create(
-                model=self.deployment,
-                messages=data if isinstance(data, list) else [data],
-                **self.parameters,
-            )
-
-        elif self.api == "completion":
-            response = self.client.completions.create(
-                prompt=data.item,
-                model=self.deployment,
-                **self.parameters,
-            )
-
-        elif self.api == "embedding":
-            response = self.client.embeddings.create(
-                input=data if isinstance(data, list) else [data],
-                model=self.deployment,
-                **self.parameters,
-            )
-
-        elif self.api == "image":
-            raise NotImplementedError("Azure OpenAI Image API is not implemented yet")
-
-        # stream response
-        if isinstance(response, Iterator):
-            return PromptyStream("AzureOpenAIExecutor", response)
-        else:
-            return response

prompty-0.1.17/prompty/openai/executor.py

@@ -1,74 +0,0 @@
-import importlib.metadata
-from openai import OpenAI
-from typing import Iterator
-from ..core import Invoker, InvokerFactory, Prompty, PromptyStream
-
-VERSION = importlib.metadata.version("prompty")
-
-
-@InvokerFactory.register_executor("openai")
-class OpenAIExecutor(Invoker):
-    """OpenAI Executor"""
-
-    def __init__(self, prompty: Prompty) -> None:
-        super().__init__(prompty)
-        kwargs = {
-            key: value
-            for key, value in self.prompty.model.configuration.items()
-            if key != "type"
-        }
-
-        self.client = OpenAI(
-            default_headers={
-                "User-Agent": f"prompty/{VERSION}",
-                "x-ms-useragent": f"prompty/{VERSION}",
-            },
-            **kwargs,
-        )
-
-        self.api = self.prompty.model.api
-        self.deployment = self.prompty.model.configuration["azure_deployment"]
-        self.parameters = self.prompty.model.parameters
-
-    def invoke(self, data: any) -> any:
-        """Invoke the OpenAI API
-
-        Parameters
-        ----------
-        data : any
-            The data to send to the OpenAI API
-
-        Returns
-        -------
-        any
-            The response from the OpenAI API
-        """
-        if self.api == "chat":
-            response = self.client.chat.completions.create(
-                model=self.deployment,
-                messages=data if isinstance(data, list) else [data],
-                **self.parameters,
-            )
-
-        elif self.api == "completion":
-            response = self.client.completions.create(
-                prompt=data.item,
-                model=self.deployment,
-                **self.parameters,
-            )
-
-        elif self.api == "embedding":
-            response = self.client.embeddings.create(
-                input=data if isinstance(data, list) else [data],
-                model=self.deployment,
-                **self.parameters,
-            )
-
-        elif self.api == "image":
-            raise NotImplementedError("OpenAI Image API is not implemented yet")
-
-        # stream response
-        if isinstance(response, Iterator):
-            return PromptyStream("OpenAIExecutor", response)
-        else:
-            return response

prompty-0.1.17/prompty/serverless/executor.py

@@ -1,84 +0,0 @@
-import importlib.metadata
-from typing import Iterator
-from azure.core.credentials import AzureKeyCredential
-from azure.ai.inference import (
-    ChatCompletionsClient,
-    EmbeddingsClient,
-)
-from azure.ai.inference.models import (
-    StreamingChatCompletions,
-    AsyncStreamingChatCompletions,
-)
-from ..core import Invoker, InvokerFactory, Prompty, PromptyStream, AsyncPromptyStream
-
-VERSION = importlib.metadata.version("prompty")
-
-
-@InvokerFactory.register_executor("serverless")
-class ServerlessExecutor(Invoker):
-    """Azure OpenAI Executor"""
-
-    def __init__(self, prompty: Prompty) -> None:
-        super().__init__(prompty)
-
-        # serverless configuration
-        self.endpoint = self.prompty.model.configuration["endpoint"]
-        self.model = self.prompty.model.configuration["model"]
-        self.key = self.prompty.model.configuration["key"]
-
-        # api type
-        self.api = self.prompty.model.api
-
-    def invoke(self, data: any) -> any:
-        """Invoke the Serverless SDK
-
-        Parameters
-        ----------
-        data : any
-            The data to send to the Serverless SDK
-
-        Returns
-        -------
-        any
-            The response from the Serverless SDK
-        """
-        if self.api == "chat":
-            response = ChatCompletionsClient(
-                endpoint=self.endpoint,
-                credential=AzureKeyCredential(self.key),
-                user_agent=f"prompty/{VERSION}"
-            ).complete(
-                model=self.model,
-                messages=data if isinstance(data, list) else [data],
-                **self.prompty.model.parameters,
-            )
-
-        elif self.api == "completion":
-            raise NotImplementedError(
-                "Serverless Completions API is not implemented yet"
-            )
-
-        elif self.api == "embedding":
-            response = EmbeddingsClient(
-                endpoint=self.endpoint,
-                credential=AzureKeyCredential(self.key),
-                user_agent=f"prompty/{VERSION}",
-            ).complete(
-                model=self.model,
-                input=data if isinstance(data, list) else [data],
-                **self.prompty.model.parameters,
-            )
-
-        elif self.api == "image":
-            raise NotImplementedError("Azure OpenAI Image API is not implemented yet")
-
-        # stream response
-        if isinstance(response, Iterator):
-            if isinstance(response, StreamingChatCompletions):
-                return PromptyStream("ServerlessExecutor", response)
-            elif isinstance(response, AsyncStreamingChatCompletions):
-                return AsyncPromptyStream("ServerlessExecutor", response)
-            return PromptyStream("ServerlessExecutor", response)
-        else:
-
-            return response