prompty 0.1.33__tar.gz → 0.1.36__tar.gz

{prompty-0.1.33 → prompty-0.1.36}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: prompty
-Version: 0.1.33
+Version: 0.1.36
 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>
 License: MIT
@@ -13,10 +13,11 @@ Requires-Dist: click>=8.1.7
 Requires-Dist: aiofiles>=24.1.0
 Provides-Extra: azure
 Requires-Dist: azure-identity>=1.17.1; extra == "azure"
-Requires-Dist: openai>=1.35.10; extra == "azure"
+Requires-Dist: openai>=1.43.0; extra == "azure"
 Provides-Extra: openai
-Requires-Dist: openai>=1.35.10; extra == "openai"
+Requires-Dist: openai>=1.43.0; extra == "openai"
 Provides-Extra: serverless
+Requires-Dist: azure-identity>=1.17.1; extra == "serverless"
 Requires-Dist: azure-ai-inference>=1.0.0b3; extra == "serverless"
 Description-Content-Type: text/markdown
 

{prompty-0.1.33 → prompty-0.1.36}/prompty/azure/processor.py

@@ -9,6 +9,8 @@ from openai.types.create_embedding_response import CreateEmbeddingResponse
 
 @InvokerFactory.register_processor("azure")
 @InvokerFactory.register_processor("azure_openai")
+@InvokerFactory.register_processor("azure_beta")
+@InvokerFactory.register_processor("azure_openai_beta")
 class AzureOpenAIProcessor(Invoker):
     """Azure OpenAI Processor"""
 

prompty-0.1.36/prompty/azure_beta/__init__.py

@@ -0,0 +1,11 @@
+# __init__.py
+from prompty.invoker import InvokerException
+
+try:
+    from .executor import AzureOpenAIBetaExecutor
+    # Reuse the common Azure OpenAI Processor
+    from ..azure.processor import AzureOpenAIProcessor
+except ImportError:
+    raise InvokerException(
+        "Error registering AzureOpenAIBetaExecutor and AzureOpenAIProcessor", "azure_beta"
+    )

prompty-0.1.36/prompty/azure_beta/executor.py

@@ -0,0 +1,281 @@
+import azure.identity
+import importlib.metadata
+from typing import AsyncIterator, Iterator
+from openai import AzureOpenAI, AsyncAzureOpenAI
+
+from prompty.tracer import Tracer
+from ..core import AsyncPromptyStream, Prompty, PromptyStream
+from ..invoker import Invoker, InvokerFactory
+import re
+from datetime import datetime
+
+def extract_date(data: str) -> datetime:
+    """Extract date from a string
+
+    Parameters
+    ----------
+    data : str
+        The string containing the date
+
+    Returns
+    -------
+    datetime
+        The extracted date as a datetime object
+    """
+
+    # Regular expression to find dates in the format YYYY-MM-DD
+    date_pattern = re.compile(r'\b\d{4}-\d{2}-\d{2}\b')
+    match = date_pattern.search(data)
+    if match:
+        date_str = match.group(0)
+        # Validate the date format
+        try:
+            return datetime.strptime(date_str, '%Y-%m-%d')
+        except ValueError:
+            pass
+    return None
+
+def is_structured_output_available(api_version: str) -> bool:
+    """Check if the structured output API is available for the given API version
+
+    Parameters
+    ----------
+    api_version : datetime
+        The API version
+
+    Returns
+    -------
+    bool
+        True if the structured output API is available, False otherwise
+    """
+
+    # Define the threshold date
+    threshold_api_version_date = datetime(2024, 8, 1)
+
+    api_version_date = extract_date(api_version)
+
+    # Check if the API version are on or after the threshold date
+    if api_version_date >= threshold_api_version_date:
+        return True
+    return False
+
+VERSION = importlib.metadata.version("prompty")
+
+
+@InvokerFactory.register_executor("azure_beta")
+@InvokerFactory.register_executor("azure_openai_beta")
+class AzureOpenAIBetaExecutor(Invoker):
+    """Azure OpenAI Beta 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.api_version = self.prompty.model.configuration["api_version"]
+        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":
+                # We can only verify the API version as the model and its version are not part of prompty configuration
+                # Should be gpt-4o and 2024-08-06 or later    
+                choose_beta = is_structured_output_available(self.api_version)
+                if choose_beta:
+                    trace("signature", "AzureOpenAI.beta.chat.completions.parse")
+                else:
+                    trace("signature", "AzureOpenAI.chat.completions.create")
+                
+                args = {
+                    "model": self.deployment,
+                    "messages": data if isinstance(data, list) else [data],
+                    **self.parameters,
+                }
+                trace("inputs", args)
+                if choose_beta:
+                    response = client.beta.chat.completions.parse(**args)
+                else:
+                    response = client.chat.completions.create(**args)
+                trace("result", response)
+
+            elif self.api == "completion":
+                trace("signature", "AzureOpenAI.completions.create")
+                args = {
+                    "prompt": data,
+                    "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":
+                trace("signature", "AzureOpenAI.images.generate")
+                args = {
+                    "prompt": data,
+                    "model": self.deployment,
+                    **self.parameters,
+                }
+                trace("inputs", args)
+                response = client.images.generate.create(**args)
+                trace("result", response)
+
+        # stream response
+        if isinstance(response, Iterator):
+            if self.api == "chat":
+                # TODO: handle the case where there might be no usage in the stream
+                return PromptyStream("AzureOpenAIBetaExecutor", response)
+            else:
+                return PromptyStream("AzureOpenAIBetaExecutor", response)
+        else:
+            return response
+
+    async def invoke_async(self, data: str) -> str:
+        """Invoke the Prompty Chat Parser (Async)
+
+        Parameters
+        ----------
+        data : str
+            The data to parse
+
+        Returns
+        -------
+        str
+            The parsed data
+        """
+        with Tracer.start("AzureOpenAIAsync") as trace:
+            trace("type", "LLM")
+            trace("signature", "AzureOpenAIAsync.ctor")
+            trace("description", "Async Azure OpenAI Constructor")
+            trace("inputs", self.kwargs)
+            client = AsyncAzureOpenAI(
+                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", "AzureOpenAIAsync.chat.completions.create")
+                args = {
+                    "model": self.deployment,
+                    "messages": data if isinstance(data, list) else [data],
+                    **self.parameters,
+                }
+                trace("inputs", args)
+                response = await client.chat.completions.create(**args)
+                trace("result", response)
+
+            elif self.api == "completion":
+                trace("signature", "AzureOpenAIAsync.completions.create")
+                args = {
+                    "prompt": data,
+                    "model": self.deployment,
+                    **self.parameters,
+                }
+                trace("inputs", args)
+                response = await client.completions.create(**args)
+                trace("result", response)
+
+            elif self.api == "embedding":
+                trace("signature", "AzureOpenAIAsync.embeddings.create")
+                args = {
+                    "input": data if isinstance(data, list) else [data],
+                    "model": self.deployment,
+                    **self.parameters,
+                }
+                trace("inputs", args)
+                response = await client.embeddings.create(**args)
+                trace("result", response)
+
+            elif self.api == "image":
+                trace("signature", "AzureOpenAIAsync.images.generate")
+                args = {
+                    "prompt": data,
+                    "model": self.deployment,
+                    **self.parameters,
+                }
+                trace("inputs", args)
+                response = await client.images.generate.create(**args)
+                trace("result", response)
+
+        # stream response
+        if isinstance(response, AsyncIterator):
+            if self.api == "chat":
+                # TODO: handle the case where there might be no usage in the stream
+                return AsyncPromptyStream("AzureOpenAIBetaExecutorAsync", response)
+            else:
+                return AsyncPromptyStream("AzureOpenAIBetaExecutorAsync", response)
+        else:
+            return response

{prompty-0.1.33 → prompty-0.1.36}/prompty/serverless/executor.py

@@ -1,3 +1,4 @@
+import azure.identity
 import importlib.metadata
 from typing import Iterator
 from azure.core.credentials import AzureKeyCredential
@@ -5,6 +6,11 @@ from azure.ai.inference import (
     ChatCompletionsClient,
     EmbeddingsClient,
 )
+
+from azure.ai.inference.aio import (
+    ChatCompletionsClient as AsyncChatCompletionsClient,
+    EmbeddingsClient as AsyncEmbeddingsClient,
+)
 from azure.ai.inference.models import (
     StreamingChatCompletions,
     AsyncStreamingChatCompletions,
@@ -24,10 +30,18 @@ class ServerlessExecutor(Invoker):
     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"]
+
+        # no key, use default credentials
+        if "key" not in self.kwargs:
+            self.credential = azure.identity.DefaultAzureCredential(
+                exclude_shared_token_cache_credential=True
+            )
+        else:
+            self.credential = AzureKeyCredential(
+                self.prompty.model.configuration["key"]
+            )
 
         # api type
         self.api = self.prompty.model.api
@@ -64,7 +78,7 @@ class ServerlessExecutor(Invoker):
 
         cargs = {
             "endpoint": self.endpoint,
-            "credential": AzureKeyCredential(self.key),
+            "credential": self.credential,
         }
 
         if self.api == "chat":
@@ -150,4 +164,77 @@ class ServerlessExecutor(Invoker):
         str
             The parsed data
         """
-        return self.invoke(data)
+        cargs = {
+            "endpoint": self.endpoint,
+            "credential": self.credential,
+        }
+
+        if self.api == "chat":
+            with Tracer.start("ChatCompletionsClient") as trace:
+                trace("type", "LLM")
+                trace("signature", "azure.ai.inference.aio.ChatCompletionsClient.ctor")
+                trace(
+                    "description", "Azure Unified Inference SDK Async Chat Completions Client"
+                )
+                trace("inputs", cargs)
+                client = AsyncChatCompletionsClient(
+                    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 Async Chat Completions Client"
+                )
+                eargs = {
+                    "model": self.model,
+                    "messages": data if isinstance(data, list) else [data],
+                    **self.prompty.model.parameters,
+                }
+                trace("inputs", eargs)
+                r = await 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.aio.EmbeddingsClient.ctor")
+                trace("description", "Azure Unified Inference SDK Async Embeddings Client")
+                trace("inputs", cargs)
+                client = AsyncEmbeddingsClient(
+                    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 = await 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.33 → prompty-0.1.36}/prompty/serverless/processor.py

@@ -1,6 +1,6 @@
-from typing import Iterator
+from typing import AsyncIterator, Iterator
 from ..invoker import Invoker, InvokerFactory
-from ..core import Prompty, PromptyStream, ToolCall
+from ..core import AsyncPromptyStream, Prompty, PromptyStream, ToolCall
 
 from azure.ai.inference.models import ChatCompletions, EmbeddingsResult
 
@@ -75,4 +75,39 @@ class ServerlessProcessor(Invoker):
         str
             The parsed data
         """
-        return self.invoke(data)
+        if isinstance(data, ChatCompletions):
+            response = data.choices[0].message
+            # tool calls available in response
+            if response.tool_calls:
+                return [
+                    ToolCall(
+                        id=tool_call.id,
+                        name=tool_call.function.name,
+                        arguments=tool_call.function.arguments,
+                    )
+                    for tool_call in response.tool_calls
+                ]
+            else:
+                return response.content
+
+        elif isinstance(data, EmbeddingsResult):
+            if len(data.data) == 0:
+                raise ValueError("Invalid data")
+            elif len(data.data) == 1:
+                return data.data[0].embedding
+            else:
+                return [item.embedding for item in data.data]
+        elif isinstance(data, AsyncIterator):
+
+            async def generator():
+                async for chunk in data:
+                    if (
+                        len(chunk.choices) == 1
+                        and chunk.choices[0].delta.content != None
+                    ):
+                        content = chunk.choices[0].delta.content
+                        yield content
+
+            return AsyncPromptyStream("ServerlessProcessor", generator())
+        else:
+            return data

{prompty-0.1.33 → prompty-0.1.36}/prompty/tracer.py

@@ -93,7 +93,9 @@ def _name(func: Callable, args):
     if core_invoker:
         name = type(args[0]).__name__
         if signature.endswith("async"):
-            signature = f"{args[0].__module__}.{args[0].__class__.__name__}.invoke_async"
+            signature = (
+                f"{args[0].__module__}.{args[0].__class__.__name__}.invoke_async"
+            )
         else:
             signature = f"{args[0].__module__}.{args[0].__class__.__name__}.invoke"
     else:
@@ -116,20 +118,19 @@ def _results(result: Any) -> dict:
 
 
 def _trace_sync(
-    func: Callable = None, *, description: str = None, itemtype: str = None
+    func: Callable = None, **okwargs: Any
 ) -> Callable:
-    description = description or ""
 
     @wraps(func)
     def wrapper(*args, **kwargs):
         name, signature = _name(func, args)
         with Tracer.start(name) as trace:
             trace("signature", signature)
-            if description and description != "":
-                trace("description", description)
 
-            if itemtype and itemtype != "":
-                trace("type", itemtype)
+            # support arbitrary keyword
+            # arguments for trace decorator
+            for k, v in okwargs.items():
+                trace(k, to_dict(v))
 
             inputs = _inputs(func, args, kwargs)
             trace("inputs", inputs)
@@ -161,20 +162,19 @@ def _trace_sync(
 
 
 def _trace_async(
-    func: Callable = None, *, description: str = None, itemtype: str = None
+    func: Callable = None, **okwargs: Any
 ) -> Callable:
-    description = description or ""
 
     @wraps(func)
     async def wrapper(*args, **kwargs):
         name, signature = _name(func, args)
         with Tracer.start(name) as trace:
             trace("signature", signature)
-            if description and description != "":
-                trace("description", description)
 
-            if itemtype and itemtype != "":
-                trace("type", itemtype)
+            # support arbitrary keyword 
+            # arguments for trace decorator
+            for k, v in okwargs.items():
+                trace(k, to_dict(v))
 
             inputs = _inputs(func, args, kwargs)
             trace("inputs", inputs)
@@ -204,15 +204,11 @@ def _trace_async(
     return wrapper
 
 
-def trace(
-    func: Callable = None, *, description: str = None, itemtype: str = None
-) -> Callable:
+def trace(func: Callable = None, **kwargs: Any) -> Callable:
     if func is None:
-        return partial(trace, description=description, itemtype=itemtype)
-
+        return partial(trace, **kwargs)
     wrapped_method = _trace_async if inspect.iscoroutinefunction(func) else _trace_sync
-
-    return wrapped_method(func, description=description, itemtype=itemtype)
+    return wrapped_method(func, **kwargs)
 
 
 class PromptyTracer:

{prompty-0.1.33 → prompty-0.1.36}/pyproject.toml

@@ -15,7 +15,7 @@ dependencies = [
     "click>=8.1.7",
     "aiofiles>=24.1.0",
 ]
-version = "0.1.33"
+version = "0.1.36"
 
 [project.license]
 text = "MIT"
@@ -23,12 +23,13 @@ text = "MIT"
 [project.optional-dependencies]
 azure = [
     "azure-identity>=1.17.1",
-    "openai>=1.35.10",
+    "openai>=1.43.0",
 ]
 openai = [
-    "openai>=1.35.10",
+    "openai>=1.43.0",
 ]
 serverless = [
+    "azure-identity>=1.17.1",
     "azure-ai-inference>=1.0.0b3",
 ]
 
@@ -41,11 +42,10 @@ distribution = true
 [tool.pdm.dev-dependencies]
 dev = [
     "pytest>=8.2.2",
-    "openai>=1.35.10",
+    "openai>=1.43.0",
     "azure-ai-inference>=1.0.0b3",
     "pytest-asyncio>=0.24.0",
     "azure-identity>=1.17.1",
-    "openai>=1.35.10",
 ]
 
 [tool.pdm.version]

prompty-0.1.36/tests/prompts/structured_output.prompty

@@ -0,0 +1,24 @@
+---
+name: Structured Output Prompt
+description: A prompt that uses the GPT-4o chat API to answer questions in a structured format.
+authors:
+  - vgiraud
+model:
+  api: chat
+  configuration:
+    # Minimal model version required for structured output
+    azure_deployment: gpt-4o-2024-08-06
+    # Minimal API version required for structured output
+    api_version: 2024-08-01-preview
+    # OpenAI beta API required for structured output
+    type: azure_openai_beta
+  parameters:
+    response_format: ${file:structured_output_schema.json}
+sample:
+  statement: Alice and Bob are going to a science fair on Friday.
+---
+system:
+Extract the event information.
+
+user:
+{{statement}}

prompty-0.1.36/tests/prompts/structured_output.prompty.execution.json

@@ -0,0 +1,68 @@
+{
+    "choices": [
+        {
+            "content_filter_results": {
+                "hate": {
+                    "filtered": false,
+                    "severity": "safe"
+                },
+                "self_harm": {
+                    "filtered": false,
+                    "severity": "safe"
+                },
+                "sexual": {
+                    "filtered": false,
+                    "severity": "safe"
+                },
+                "violence": {
+                    "filtered": false,
+                    "severity": "safe"
+                }
+            },
+            "finish_reason": "stop",
+            "index": 0,
+            "logprobs": null,
+            "message": {
+                "content": "{\"name\":\"Science Fair\",\"date\":\"Friday\",\"participants\":[\"Alice\",\"Bob\"]}",
+                "role": "assistant"
+            }
+        }
+    ],
+    "created": 1728500899,
+    "id": "chatcmpl-AGWKhgl9bSoQffPMuWjT6JojCKVVs",
+    "model": "gpt-4o-2024-08-06",
+    "object": "chat.completion",
+    "prompt_filter_results": [
+        {
+            "prompt_index": 0,
+            "content_filter_results": {
+                "hate": {
+                    "filtered": false,
+                    "severity": "safe"
+                },
+                "jailbreak": {
+                    "filtered": false,
+                    "detected": false
+                },
+                "self_harm": {
+                    "filtered": false,
+                    "severity": "safe"
+                },
+                "sexual": {
+                    "filtered": false,
+                    "severity": "safe"
+                },
+                "violence": {
+                    "filtered": false,
+                    "severity": "safe"
+                }
+            }
+        }
+    ],
+    "system_fingerprint": "fp_67802d9a6d",
+    "usage": {
+        "completion_tokens": 17,
+        "prompt_tokens": 74,
+        "total_tokens": 91
+    }
+}

prompty-0.1.36/tests/prompts/structured_output_schema.json

@@ -0,0 +1,29 @@
+{
+    "type": "json_schema",
+    "json_schema": {
+        "name": "calendar_event",
+        "schema": {
+            "type": "object",
+            "properties": {
+                "name": {
+                    "type": "string"
+                },
+                "date": {
+                    "type": "string",
+                    "format": "date-time"
+                },
+                "participants": {
+                    "type": "array",
+                    "items": {
+                        "type": "string"
+                    }
+                }
+            },
+            "required": [
+                "name",
+                "date",
+                "participants"
+            ]
+        }
+    }
+}

{prompty-0.1.33 → prompty-0.1.36}/tests/test_common.py

@@ -15,6 +15,7 @@ import prompty
         "prompts/faithfulness.prompty",
         "prompts/funcfile.prompty",
         "prompts/functions.prompty",
+        "prompts/structured_output.prompty",
         "prompts/groundedness.prompty",
         "prompts/sub/basic.prompty",
         "prompts/sub/sub/basic.prompty",

{prompty-0.1.33 → prompty-0.1.36}/tests/test_execute.py

@@ -13,12 +13,17 @@ from dotenv import load_dotenv
 load_dotenv()
 
 
+
 @pytest.fixture(scope="module", autouse=True)
 def fake_azure_executor():
     InvokerFactory.add_executor("azure", FakeAzureExecutor)
     InvokerFactory.add_executor("azure_openai", FakeAzureExecutor)
+    InvokerFactory.add_executor("azure_beta", FakeAzureExecutor)
+    InvokerFactory.add_executor("azure_openai_beta", FakeAzureExecutor)
     InvokerFactory.add_processor("azure", AzureOpenAIProcessor)
     InvokerFactory.add_processor("azure_openai", AzureOpenAIProcessor)
+    InvokerFactory.add_executor("azure_beta", AzureOpenAIProcessor)
+    InvokerFactory.add_executor("azure_openai_beta", AzureOpenAIProcessor)
     InvokerFactory.add_executor("serverless", FakeServerlessExecutor)
     InvokerFactory.add_processor("serverless", ServerlessProcessor)
 
@@ -217,6 +222,11 @@ def test_function_calling():
     )
     print(result)
 
+def test_structured_output():
+    result = prompty.execute(
+        "prompts/structured_output.prompty",
+    )
+    print(result)
 
 @pytest.mark.asyncio
 async def test_function_calling_async():

{prompty-0.1.33 → prompty-0.1.36}/tests/test_tracing.py

@@ -1,19 +1,27 @@
 from typing import AsyncIterator
 import pytest
 import prompty
+from prompty.serverless.processor import ServerlessProcessor
 from prompty.tracer import trace, Tracer, console_tracer, PromptyTracer
 
 from prompty.invoker import InvokerFactory
 from tests.fake_azure_executor import FakeAzureExecutor
 from prompty.azure import AzureOpenAIProcessor
+from tests.fake_serverless_executor import FakeServerlessExecutor
 
 
 @pytest.fixture(scope="module", autouse=True)
 def setup_module():
     InvokerFactory.add_executor("azure", FakeAzureExecutor)
     InvokerFactory.add_executor("azure_openai", FakeAzureExecutor)
+    InvokerFactory.add_executor("azure_beta", FakeAzureExecutor)
+    InvokerFactory.add_executor("azure_openai_beta", FakeAzureExecutor)
     InvokerFactory.add_processor("azure", AzureOpenAIProcessor)
     InvokerFactory.add_processor("azure_openai", AzureOpenAIProcessor)
+    InvokerFactory.add_executor("azure_beta", AzureOpenAIProcessor)
+    InvokerFactory.add_executor("azure_openai_beta", AzureOpenAIProcessor)
+    InvokerFactory.add_executor("serverless", FakeServerlessExecutor)
+    InvokerFactory.add_processor("serverless", ServerlessProcessor)
 
     Tracer.add("console", console_tracer)
     json_tracer = PromptyTracer()
@@ -238,10 +246,36 @@ async def test_function_calling_async():
     print(result)
 
 
+@trace
+def test_structured_output():
+    result = prompty.execute(
+        "prompts/structured_output.prompty",
+    )
+    print(result)
+
+
+@pytest.mark.asyncio
+@trace
+async def test_structured_output_async():
+    result = await prompty.execute_async(
+        "prompts/structured_output.prompty",
+    )
+    print(result)
+
+
+@pytest.mark.asyncio
+@trace
+async def test_function_calling_async():
+    result = await prompty.execute_async(
+        "prompts/functions.prompty",
+    )
+    print(result)
+
+
 # need to add trace attribute to
 # materialize stream into the function
 # trace decorator
-@trace
+@trace(streaming=True, other="test")
 def test_streaming():
     result = prompty.execute(
         "prompts/streaming.prompty",
@@ -254,7 +288,7 @@ def test_streaming():
 
 
 @pytest.mark.asyncio
-@trace
+@trace(streaming=True)
 async def test_streaming_async():
     result = await prompty.execute_async(
         "prompts/streaming.prompty",