prompty 1.0.0a2__py3-none-any.whl → 1.0.0b2__py3-none-any.whl

prompty/_version.py

@@ -1 +1 @@
-VERSION = "1.0.0a2"
+VERSION = "1.0.0b2"

prompty/azure/executor.py

@@ -1,16 +1,17 @@
+import inspect
 import json
 import typing
 from collections.abc import AsyncIterator, Iterator
 
 import azure.identity
-from openai import APIResponse, AsyncAzureOpenAI, AzureOpenAI
+from openai import AsyncAzureOpenAI, AzureOpenAI
 from openai.types.chat.chat_completion import ChatCompletion
 
 from prompty.tracer import Tracer
 
 from .._version import VERSION
 from ..common import convert_function_tools, convert_output_props
-from ..core import AsyncPromptyStream, Prompty, PromptyStream
+from ..core import AsyncPromptyStream, InputProperty, Prompty, PromptyStream, ToolProperty
 from ..invoker import Invoker, InvokerFactory
 
 
@@ -146,6 +147,22 @@ class AzureOpenAIExecutor(Invoker):
 
         return args
 
+    def _execute_chat_completion(self, client: AzureOpenAI, args: dict, trace) -> typing.Any:
+        if "stream" in args and args["stream"]:
+            response = client.chat.completions.create(**args)
+        else:
+            raw = client.chat.completions.with_raw_response.create(**args)
+
+            response = ChatCompletion.model_validate_json(raw.text)
+
+            for k, v in raw.headers.raw:
+                trace(k.decode("utf-8"), v.decode("utf-8"))
+
+            trace("request_id", raw.request_id)
+            trace("retries_taken", raw.retries_taken)
+
+        return response
+
     def _create_chat(self, client: AzureOpenAI, data: typing.Any, ignore_thread_content=False) -> typing.Any:
         with Tracer.start("create") as trace:
             trace("type", "LLM")
@@ -153,20 +170,25 @@ class AzureOpenAIExecutor(Invoker):
             trace("signature", "AzureOpenAI.chat.completions.create")
             args = self._resolve_chat_args(data, ignore_thread_content)
             trace("inputs", args)
-            if "stream" in args and args["stream"]:
-                response = client.chat.completions.create(**args)
-            else:
-                raw = client.chat.completions.with_raw_response.create(**args)
+            response = self._execute_chat_completion(client, args, trace)
+            trace("result", response)
+            return response
 
-                response = ChatCompletion.model_validate_json(raw.text)
+    async def _execute_chat_completion_async(self, client: AsyncAzureOpenAI, args: dict, trace) -> typing.Any:
+        if "stream" in args and args["stream"]:
+            response = await client.chat.completions.create(**args)
+        else:
+            raw = await client.chat.completions.with_raw_response.create(**args)
 
-                for k, v in raw.headers.raw:
-                    trace(k.decode("utf-8"), v.decode("utf-8"))
+            response = ChatCompletion.model_validate_json(raw.text)
 
-                trace("request_id", raw.request_id)
-                trace("retries_taken", raw.retries_taken)
-            trace("result", response)
-            return response
+            for k, v in raw.headers.raw:
+                trace(k.decode("utf-8"), v.decode("utf-8"))
+
+            trace("request_id", raw.request_id)
+            trace("retries_taken", raw.retries_taken)
+
+        return response
 
     async def _create_chat_async(
         self, client: AsyncAzureOpenAI, data: typing.Any, ignore_thread_content=False
@@ -178,82 +200,130 @@ class AzureOpenAIExecutor(Invoker):
             trace("signature", "AzureOpenAIAsync.chat.completions.create")
             args = self._resolve_chat_args(data, ignore_thread_content)
             trace("inputs", args)
-            if "stream" in args and args["stream"]:
-                response = await client.chat.completions.create(**args)
-            else:
-                raw: APIResponse = await client.chat.completions.with_raw_response.create(**args)
-                if raw is not None and raw.text is not None and isinstance(raw.text, str):
-                    response = ChatCompletion.model_validate_json(raw.text)
-
-                for k, v in raw.headers.raw:
-                    trace(k.decode("utf-8"), v.decode("utf-8"))
-
-                trace("request_id", raw.request_id)
-                trace("retries_taken", raw.retries_taken)
+            response = await self._execute_chat_completion_async(client, args, trace)
             trace("result", response)
 
             return response
 
+    def _get_thread(self) -> InputProperty:
+        thread = self.prompty.get_input("thread")
+        if thread is None:
+            raise ValueError("thread requires thread input")
+
+        return thread
+
+    def _retrieve_tool(self, tool_name: str) -> ToolProperty:
+        tool = self.prompty.get_tool(tool_name)
+        if tool is None:
+            raise ValueError(f"Tool {tool_name} does not exist")
+
+        if tool.type != "function":
+            raise ValueError(f"Server tool ({tool_name}) is currently not supported")
+
+        if tool.value is None:
+            raise ValueError(f"Tool {tool_name} has not been initialized")
+
+        return tool
+
     def _execute_agent(self, client: AzureOpenAI, data: typing.Any) -> typing.Any:
-        with Tracer.start("create") as trace:
-            trace("type", "LLM")
+        with Tracer.start("AgentLoop") as trace:
+            trace("type", "agent")
             trace("description", "Azure OpenAI Client")
+            trace("signature", "prompty.azure.AzureOpenAIExecutor.AgentLoop")
 
-            trace("signature", "AzureOpenAI.chat.agent.create")
             trace("inputs", data)
 
             response = self._create_chat(client, data)
-            if isinstance(response, ChatCompletion):
-                message = response.choices[0].message
-                if message.tool_calls:
-                    thread = self.prompty.get_input("thread")
-                    if thread is None:
-                        raise ValueError("thread requires thread input")
+
+            # execute tool calls if any (until no more tool calls)
+            while (
+                isinstance(response, ChatCompletion)
+                and response.choices[0].finish_reason == "tool_calls"
+                and response.choices[0].message.tool_calls is not None
+                and len(response.choices[0].message.tool_calls) > 0
+            ):
+
+                tool_calls = response.choices[0].message.tool_calls
+                thread = self._get_thread()
+                thread.value.append(
+                    {
+                        "role": "assistant",
+                        "tool_calls": [t.model_dump() for t in tool_calls],
+                    }
+                )
+
+                for tool_call in tool_calls:
+                    tool = self._retrieve_tool(tool_call.function.name)
+                    function_args = json.loads(tool_call.function.arguments)
+
+                    if inspect.iscoroutinefunction(tool.value):
+                        raise ValueError("Cannot execute async tool in sync mode")
+
+                    r = tool.value(**function_args)
 
                     thread.value.append(
                         {
-                            "role": "assistant",
-                            "tool_calls": [t.model_dump() for t in message.tool_calls],
+                            "role": "tool",
+                            "tool_call_id": tool_call.id,
+                            "name": tool_call.function.name,
+                            "content": r,
                         }
                     )
 
-                    for tool_call in message.tool_calls:
-                        tool = self.prompty.get_tool(tool_call.function.name)
-                        if tool is None:
-                            raise ValueError(f"Tool {tool_call.function.name} does not exist")
+                response = self._create_chat(client, data, True)
 
-                        function_args = json.loads(tool_call.function.arguments)
+            trace("result", response)
+            return response
 
-                        if tool.value is None:
-                            raise ValueError(f"Tool {tool_call.function.name} does not have a value")
+    async def _execute_agent_async(self, client: AsyncAzureOpenAI, data: typing.Any) -> typing.Any:
+        with Tracer.start("AgentLoopAsync") as trace:
+            trace("type", "agent")
+            trace("description", "Azure OpenAI Client")
+            trace("signature", "prompty.azure.AzureOpenAIExecutor.AgentLoopAsync")
 
-                        r = tool.value(**function_args)
+            trace("inputs", data)
 
-                        thread.value.append(
-                            {
-                                "role": "tool",
-                                "tool_call_id": tool_call.id,
-                                "name": tool_call.function.name,
-                                "content": r,
-                            }
-                        )
-                else:
-                    trace("result", response)
-                    return response
+            response = await self._create_chat_async(client, data)
 
-            response = self._create_chat(client, data, True)
-            trace("result", response)
+            # execute tool calls if any (until no more tool calls)
+            while (
+                isinstance(response, ChatCompletion)
+                and response.choices[0].finish_reason == "tool_calls"
+                and response.choices[0].message.tool_calls is not None
+                and len(response.choices[0].message.tool_calls) > 0
+            ):
+
+                tool_calls = response.choices[0].message.tool_calls
+                thread = self._get_thread()
+                thread.value.append(
+                    {
+                        "role": "assistant",
+                        "tool_calls": [t.model_dump() for t in tool_calls],
+                    }
+                )
 
-            return response
+                for tool_call in tool_calls:
+                    tool = self._retrieve_tool(tool_call.function.name)
+                    function_args = json.loads(tool_call.function.arguments)
+
+                    if inspect.iscoroutinefunction(tool.value):
+                        # if the tool is async, we need to await it
+                        r = await tool.value(**function_args)
+                    else:
+                        # if the tool is not async, we can call it directly
+                        r = tool.value(**function_args)
+
+                    thread.value.append(
+                        {
+                            "role": "tool",
+                            "tool_call_id": tool_call.id,
+                            "name": tool_call.function.name,
+                            "content": r,
+                        }
+                    )
+
+                response = await self._create_chat_async(client, data, True)
 
-    async def _execute_agent_async(self, client: AsyncAzureOpenAI, data: typing.Any) -> typing.Any:
-        with Tracer.start("create") as trace:
-            trace("type", "LLM")
-            trace("description", "Azure OpenAI Client")
-            trace("signature", "AzureOpenAI.chat.agent.create")
-            args = self._resolve_chat_args(data)
-            trace("inputs", args)
-            response = 5
             trace("result", response)
             return response
 
@@ -358,7 +428,7 @@ class AzureOpenAIExecutor(Invoker):
 
             return response
 
-    def invoke(self, data: typing.Any) -> typing.Union[str, PromptyStream]:
+    def invoke(self, data: typing.Any) -> typing.Any:
         """Invoke the Azure OpenAI API
 
         Parameters
@@ -374,28 +444,29 @@ class AzureOpenAIExecutor(Invoker):
 
         client = self._get_ctor()
 
+        r = None
         if self.api == "chat":
-            response = self._create_chat(client, data)
+            r = self._create_chat(client, data)
         elif self.api == "agent":
-            response = self._execute_agent(client, data)
+            r = self._execute_agent(client, data)
         elif self.api == "completion":
-            response = self._create_completion(client, data)
+            r = self._create_completion(client, data)
         elif self.api == "embedding":
-            response = self._create_embedding(client, data)
+            r = self._create_embedding(client, data)
         elif self.api == "image":
-            response = self._create_image(client, data)
+            r = self._create_image(client, data)
 
         # stream response
-        if isinstance(response, Iterator):
+        if isinstance(r, Iterator):
             if self.api == "chat":
                 # TODO: handle the case where there might be no usage in the stream
-                return PromptyStream("AzureOpenAIExecutor", response)
+                return PromptyStream("AzureOpenAIExecutor", r)
             else:
-                return PromptyStream("AzureOpenAIExecutor", response)
+                return PromptyStream("AzureOpenAIExecutor", r)
         else:
-            return response
+            return r
 
-    async def invoke_async(self, data: str) -> typing.Union[str, AsyncPromptyStream]:
+    async def invoke_async(self, data: str) -> typing.Any:
         """Invoke the Prompty Chat Parser (Async)
 
         Parameters
@@ -410,23 +481,24 @@ class AzureOpenAIExecutor(Invoker):
         """
         client = self._get_async_ctor()
 
+        r = None
         if self.api == "chat":
-            response = await self._create_chat_async(client, data)
+            r = await self._create_chat_async(client, data)
         elif self.api == "agent":
-            response = await self._execute_agent_async(client, data)
+            r = await self._execute_agent_async(client, data)
         elif self.api == "completion":
-            response = await self._create_completion_async(client, data)
+            r = await self._create_completion_async(client, data)
         elif self.api == "embedding":
-            response = await self._create_embedding_async(client, data)
+            r = await self._create_embedding_async(client, data)
         elif self.api == "image":
-            response = await self._create_image_async(client, data)
+            r = await self._create_image_async(client, data)
 
         # stream response
-        if isinstance(response, AsyncIterator):
+        if isinstance(r, AsyncIterator):
             if self.api == "chat":
                 # TODO: handle the case where there might be no usage in the stream
-                return AsyncPromptyStream("AzureOpenAIExecutorAsync", response)
+                return AsyncPromptyStream("AzureOpenAIExecutorAsync", r)
             else:
-                return AsyncPromptyStream("AzureOpenAIExecutorAsync", response)
+                return AsyncPromptyStream("AzureOpenAIExecutorAsync", r)
         else:
-            return response
+            return r

prompty/azure/processor.py

@@ -42,13 +42,6 @@ class AzureOpenAIProcessor(Invoker):
         any
             The response from the OpenAI/Azure API
         """
-        # agent invocations return the thread
-        # and the last message is the response
-        if self.prompty.model.api == "agent" and isinstance(data, list):
-            if isinstance(data[-1], dict):
-                return data[-1]["content"]
-            else:
-                return data
 
         if isinstance(data, ChatCompletion):
             response = data.choices[0].message
@@ -113,7 +106,7 @@ class AzureOpenAIProcessor(Invoker):
         else:
             return data
 
-    async def invoke_async(self, data: str) -> typing.Union[str, AsyncPromptyStream]:
+    async def invoke_async(self, data: str) -> typing.Any:
         """Invoke the Prompty Chat Parser (Async)
 
         Parameters
@@ -126,13 +119,6 @@ class AzureOpenAIProcessor(Invoker):
         str
             The parsed data
         """
-        # agent invocations return the thread
-        # and the last message is the response
-        if self.prompty.model.api == "agent" and isinstance(data, list):
-            if isinstance(data[-1], dict):
-                return data[-1]["content"]
-            else:
-                return data
 
         if isinstance(data, ChatCompletion):
             response = data.choices[0].message
@@ -179,7 +165,7 @@ class AzureOpenAIProcessor(Invoker):
             elif len(data.data) == 1:
                 return data.data[0].url if item.data[0].url else item.data[0].b64_json
             else:
-                return [item.url if item.url else item.b64_json for item in data.data]
+                return [str(item.url) if item.url else item.b64_json for item in data.data]
 
         elif isinstance(data, AsyncIterator):
 

prompty/common.py

@@ -60,15 +60,39 @@ def convert_output_props(name: str, outputs: list[OutputProperty]) -> dict[str,
                 "strict": True,
                 "schema": {
                     "type": "object",
-                    "properties": {
-                        p.name: {
-                            "type": p.type,
-                        }
-                        for p in outputs
-                    },
-                    "required": [p.name for p in outputs],
+                    "properties": {p.name: _convert_output_object(p) for p in outputs},
+                    "required": [p.name for p in outputs if p.required],
                     "additionalProperties": False,
                 },
             },
         }
     return {}
+
+
+def _convert_output_object(output: OutputProperty) -> dict[str, typing.Any]:
+    """Convert an OutputProperty to a dictionary"""
+    if output.type == "array":
+        if output.items is None:
+            raise ValueError("Array type must have items defined")
+
+        o = _convert_output_object(output.items)
+        if "name" in o:
+            o.pop("name")
+
+        return {
+            "type": "array",
+            "items": o,
+        }
+    elif output.type == "object":
+        return {
+            "type": "object",
+            "properties": {prop.name: _convert_output_object(prop) for prop in output.properties},
+            "required": [prop.name for prop in output.properties if prop.required],
+            "additionalProperties": False,
+        }
+    else:
+        return {
+            "type": output.type,
+            "description": output.description,
+            **({"enum": output.enum} if output.enum else {}),
+        }

prompty/core.py

@@ -71,10 +71,13 @@ class OutputProperty:
     type: Literal["string", "number", "array", "object", "boolean"]
     name: str = field(default="")
     description: str = field(default="")
-    # only for array type - need to update schema
-    items: list["OutputProperty"] = field(default_factory=list)
+    required: bool = field(default=True)
+    enum: list[typing.Any] = field(default_factory=list)
 
-    json_schema: Optional[dict] = field(default_factory=dict)
+    # for array types, items is a type of OutputProperty
+    items: Optional["OutputProperty"] = field(default=None)
+    # for object types, properties is a list of OutputProperty
+    properties: list["OutputProperty"] = field(default_factory=list)
 
 
 @dataclass
@@ -266,25 +269,6 @@ class Prompty:
 
         raise ValueError(f"Tool {name} not found")
 
-    def get_output(self, name: str) -> OutputProperty:
-        """Get the output property of the prompty
-
-        Parameters
-        ----------
-        name : str
-            The name of the property
-
-        Returns
-        -------
-        OutputProperty
-            The property of the prompty
-        """
-
-        for i in self.outputs:
-            if i.name == name:
-                return i
-        raise ValueError(f"Property {name} not found")
-
     def to_safe_dict(self) -> dict[str, typing.Any]:
         d: dict[str, typing.Any] = {}
         for items in fields(self):
@@ -598,13 +582,35 @@ class Prompty:
 
         return {**attributes, **prompty, "content": content}
 
+    @staticmethod
+    def _load_output(attributes: dict) -> OutputProperty:
+        if "type" in attributes and attributes["type"] == "array":
+            items = attributes.pop("items", [])
+            attributes["items"] = Prompty._load_output({"name": "item", **items})
+
+        elif "type" in attributes and attributes["type"] == "object":
+            p = attributes.pop("properties", [])
+            if isinstance(p, dict):
+                p = [{"name": k, **v} for k, v in p.items()]
+
+            properties = [Prompty._load_output(i) for i in p]
+            attributes["properties"] = properties
+
+        return OutputProperty(**attributes)
+
     @staticmethod
     def load_raw(attributes: dict, file: Path) -> "Prompty":
+        # normalize outputs
+        outputs = []
+        if "outputs" in attributes:
+            outputs = attributes.pop("outputs")
+            if isinstance(outputs, dict):
+                outputs = [{"name": k, **v} for k, v in outputs.items()]
 
         prompty = Prompty(
             model=ModelProperty(**attributes.pop("model")),
             inputs=[InputProperty(**i) for i in attributes.pop("inputs", [])],
-            outputs=[OutputProperty(**i) for i in attributes.pop("outputs", [])],
+            outputs=[Prompty._load_output(i) for i in outputs],
             tools=Prompty.load_tools(attributes.pop("tools", [])),
             template=TemplateProperty(**attributes.pop("template")),
             file=file,

prompty/invoker.py

@@ -270,6 +270,7 @@ class Parser(Invoker):
         """
         pass
 
+    @trace
     def run(self, data: typing.Any) -> typing.Any:
         """Method to run the invoker
 
@@ -287,6 +288,7 @@ class Parser(Invoker):
         parsed = self.invoke(data)
         return self.process(parsed)
 
+    @trace
     async def run_async(self, data: typing.Any) -> typing.Any:
         """Method to run the invoker asynchronously
 
@@ -304,6 +306,9 @@ class Parser(Invoker):
         return self.process(parsed)
 
 
+InvokerTypes = Literal["renderer", "parser", "executor", "processor"]
+
+
 class InvokerFactory:
     """Factory class for Invoker"""
 
@@ -367,7 +372,7 @@ class InvokerFactory:
     @classmethod
     def _get_name(
         cls,
-        type: Literal["renderer", "parser", "executor", "processor"],
+        type: InvokerTypes,
         prompty: Prompty,
     ) -> str:
         if type == "renderer":
@@ -384,7 +389,7 @@ class InvokerFactory:
     @classmethod
     def _get_invoker(
         cls,
-        type: Literal["renderer", "parser", "executor", "processor"],
+        type: InvokerTypes,
         prompty: Prompty,
     ) -> Invoker:
         if type == "renderer":
@@ -421,7 +426,7 @@ class InvokerFactory:
     @classmethod
     def run(
         cls,
-        type: Literal["renderer", "parser", "executor", "processor"],
+        type: InvokerTypes,
         prompty: Prompty,
         data: typing.Any,
         default: typing.Any = None,
@@ -439,7 +444,7 @@ class InvokerFactory:
     @classmethod
     async def run_async(
         cls,
-        type: Literal["renderer", "parser", "executor", "processor"],
+        type: InvokerTypes,
         prompty: Prompty,
         data: typing.Any,
         default: typing.Any = None,

prompty/openai/executor.py

@@ -55,6 +55,8 @@ class OpenAIExecutor(Invoker):
         any
             The response from the OpenAI API
         """
+
+        response = None
         with Tracer.start("OpenAI") as trace:
             trace("type", "LLM")
             trace("signature", "OpenAI.ctor")

{prompty-1.0.0a2.dist-info → prompty-1.0.0b2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: prompty
-Version: 1.0.0a2
+Version: 1.0.0b2
 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-Python: >=3.9

{prompty-1.0.0a2.dist-info → prompty-1.0.0b2.dist-info}/RECORD

@@ -1,27 +1,25 @@
 prompty/__init__.py,sha256=v7ggLd334vKzxPcxf55DZolz3FuOmcoaK5dStcTrJ1Y,16617
-prompty/_version.py,sha256=hyATfK79pCyCZzz-IcAnlwvGTRpaZYpynyocFUoRWAM,20
+prompty/_version.py,sha256=6DOdjA8Flc2av1WYSDfNW5sNH1CmHEzYM3zJdb1qVwE,20
 prompty/cli.py,sha256=v6JJsxsAREu660PleFIosY9LUYfzKR7lXgr9aMTYnPU,5110
-prompty/common.py,sha256=wfLLN3cIgODEFjxnWFAwno5v5iobJsW9_M5m_cWqBik,2224
-prompty/core.py,sha256=MtOOmeG9ZmsHdW6EceXuIH4B6crn42kZR7x-Owc8bKc,27673
-prompty/invoker.py,sha256=sd1tCWO41_ILqmD2g9wRhVWyTN0w9yfuy0T01eGuh5w,14879
+prompty/common.py,sha256=l9uYeJWwobinjcoubtUKZUGiVjBTiDuo0IjOJU5Zy4w,3061
+prompty/core.py,sha256=6hq_jGlvYssCLxOXP72Q5mGIPxuU7IGCzGBofR6EelM,28271
+prompty/invoker.py,sha256=M5jzIuxpaSaHw8aIXqfRMnpjv6OVZyBEqba2_BsdmKU,14805
 prompty/parsers.py,sha256=SiffgiCZw1PGA5g5cgrILKEesST3XtDwajm7kGDJkww,9049
 prompty/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 prompty/renderers.py,sha256=JQR_Z_IxrdLM7OfBwXL1mOFP81CQ6wYJXhLVO80Uj94,2457
 prompty/tracer.py,sha256=BBZTNElCjIJP_RipVav36ym-l9K2NNRrCoJHQMS6lmQ,11650
 prompty/utils.py,sha256=_SY0sdfrWJjsEq34HchlJ6cwUXIzkO4w00tq9txSh0M,3711
 prompty/azure/__init__.py,sha256=6WFrY3uaaK4bNki4WKhR-s3aK3IOfxZdQAKDWXiHZi0,297
-prompty/azure/executor.py,sha256=DRWhPhLzgXbH6WryfP2pwlna2RE3daSw4WCxywUyp-s,16493
-prompty/azure/processor.py,sha256=tVQRuaZVxNpJ_mQ4EKrNlpwashl66Bi5-l0TNzdRxCw,7095
-prompty/azure_beta/__init__.py,sha256=C7yLNTg3GSACbn87remrnEf5nYlBI6LF1WRqaTQlKdI,363
-prompty/azure_beta/executor.py,sha256=0Gq4R6L61sXY7YdNdNwtJZwa1W8bbNkC_FdBkODVW6o,10544
+prompty/azure/executor.py,sha256=NoHlPGkT9s0pqLISleslvZPb7aYxPtwnXqGdxhXGkRY,18796
+prompty/azure/processor.py,sha256=xgkxBBxZHxe8XHowsHgAvPYDuNRHisHvOQ9be_KYIoI,6477
 prompty/openai/__init__.py,sha256=ahW5UM56rFpRZ0EWYRE34cKUy9GKD8zWdMsMlataCdg,289
-prompty/openai/executor.py,sha256=qREvJZaYW-nf32lgTD-DI-Chr8K7Ktz7IVDyw7_NKkE,4255
+prompty/openai/executor.py,sha256=-nPhUkAwJlNfzaQXn_61VpCiZJckUP_6O4XvsU4D-G4,4280
 prompty/openai/processor.py,sha256=oG7E7lFbWw9p6A7YWt7U3NmyGmkoW0vghYX2ekBejSw,2470
 prompty/serverless/__init__.py,sha256=szklP_c9ppNHITAngE-oFdd5BbAiyF2LZgg6J5sBjmc,298
 prompty/serverless/executor.py,sha256=eb1a_onIwf4gj_HflnKzWwzlj-50iJZiWYiMs24yMXs,9058
 prompty/serverless/processor.py,sha256=-XJScOBbKTnt_sJI_B4bMYaiKW3AI4Zgpo06e4MdM0s,3596
-prompty-1.0.0a2.dist-info/entry_points.txt,sha256=USBrLTMgXA_8CPMTAmqnD4uCCLTd0ZTOusmWipnLe7w,43
-prompty-1.0.0a2.dist-info/licenses/LICENSE,sha256=KWSC4z9cfML_t0xThoQYjzTdcZQj86Y_mhXdatzU-KM,1052
-prompty-1.0.0a2.dist-info/WHEEL,sha256=G2gURzTEtmeR8nrdXUJfNiB3VYVxigPQ-bEQujpNiNs,82
-prompty-1.0.0a2.dist-info/METADATA,sha256=8xFFSwB_hSPkEcwkMXhYiL_X324tH8Veavvm4saUnS0,9956
-prompty-1.0.0a2.dist-info/RECORD,,
+prompty-1.0.0b2.dist-info/entry_points.txt,sha256=USBrLTMgXA_8CPMTAmqnD4uCCLTd0ZTOusmWipnLe7w,43
+prompty-1.0.0b2.dist-info/licenses/LICENSE,sha256=KWSC4z9cfML_t0xThoQYjzTdcZQj86Y_mhXdatzU-KM,1052
+prompty-1.0.0b2.dist-info/WHEEL,sha256=G2gURzTEtmeR8nrdXUJfNiB3VYVxigPQ-bEQujpNiNs,82
+prompty-1.0.0b2.dist-info/METADATA,sha256=_Hnxy484gn-WP6f-Km0xo_PL_84uk4FW_P1GP_kFlMI,9956
+prompty-1.0.0b2.dist-info/RECORD,,

prompty/azure_beta/__init__.py

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

prompty/azure_beta/executor.py

@@ -1,296 +0,0 @@
-import re
-import typing
-from collections.abc import AsyncIterator, Iterator
-from datetime import datetime
-
-import azure.identity
-from openai import AsyncAzureOpenAI, AzureOpenAI
-
-from prompty.tracer import Tracer
-
-from .._version import VERSION
-from ..core import AsyncPromptyStream, Prompty, PromptyStream
-from ..invoker import Invoker, InvokerFactory
-
-
-def extract_date(data: str) -> typing.Union[datetime, None]:
-    """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 is not None and api_version_date >= threshold_api_version_date:
-        return True
-    return False
-
-
-@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.connection.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: typing.Union[
-                    azure.identity.ManagedIdentityCredential,
-                    azure.identity.DefaultAzureCredential,
-                ] = 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.connection["api_version"]
-        self.deployment = self.prompty.model.connection["azure_deployment"]
-        self.options = self.prompty.model.options
-
-    def _sanitize_messages(self, data: typing.Any) -> list[dict[str, str]]:
-        messages = data if isinstance(data, list) else [data]
-
-        if self.prompty.template.strict:
-            if not all([msg["nonce"] == self.prompty.template.nonce for msg in messages]):
-                raise ValueError("Nonce mismatch in messages array (strict mode)")
-
-        messages = [
-            {
-                **{"role": msg["role"], "content": msg["content"]},
-                **({"name": msg["name"]} if "name" in msg else {}),
-            }
-            for msg in messages
-        ]
-
-        return messages
-
-    def invoke(self, data: typing.Any) -> typing.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.options,
-                }
-                trace("inputs", args)
-                if choose_beta:
-                    response: typing.Any = 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.options,
-                }
-                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.options,
-                }
-                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.options,
-                }
-                trace("inputs", args)
-                response = client.images.generate(**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) -> typing.Union[str, AsyncPromptyStream]:
-        """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": self._sanitize_messages(data),
-                    **self.options,
-                }
-                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.options,
-                }
-                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.options,
-                }
-                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.options,
-                }
-                trace("inputs", args)
-                response = await client.images.generate(**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