prompty 0.1.10__py3-none-any.whl → 0.1.33__py3-none-any.whl

prompty/azure/executor.py

@@ -0,0 +1,218 @@
+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
+
+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,
+                    "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("AzureOpenAIExecutor", response)
+            else:
+                return PromptyStream("AzureOpenAIExecutor", 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("AzureOpenAIExecutorAsync", response)
+            else:
+                return AsyncPromptyStream("AzureOpenAIExecutorAsync", response)
+        else:
+            return response

prompty/azure/processor.py

@@ -0,0 +1,142 @@
+from typing import AsyncIterator, Iterator
+from openai.types.completion import Completion
+from openai.types.images_response import ImagesResponse
+from openai.types.chat.chat_completion import ChatCompletion
+from ..core import AsyncPromptyStream, Prompty, PromptyStream, ToolCall
+from ..invoker import Invoker, InvokerFactory
+from openai.types.create_embedding_response import CreateEmbeddingResponse
+
+
+@InvokerFactory.register_processor("azure")
+@InvokerFactory.register_processor("azure_openai")
+class AzureOpenAIProcessor(Invoker):
+    """Azure OpenAI Processor"""
+
+    def __init__(self, prompty: Prompty) -> None:
+        super().__init__(prompty)
+
+    def invoke(self, data: any) -> any:
+        """Invoke the OpenAI/Azure API
+
+        Parameters
+        ----------
+        data : any
+            The data to send to the OpenAI/Azure API
+
+        Returns
+        -------
+        any
+            The response from the OpenAI/Azure API
+        """
+        if isinstance(data, ChatCompletion):
+            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, Completion):
+            return data.choices[0].text
+        elif isinstance(data, CreateEmbeddingResponse):
+            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, ImagesResponse):
+            self.prompty.model.parameters
+            item: ImagesResponse = data
+
+            if len(data.data) == 0:
+                raise ValueError("Invalid data")
+            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]
+
+        elif isinstance(data, Iterator):
+
+            def generator():
+                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 PromptyStream("AzureOpenAIProcessor", generator())
+        else:
+            return data
+
+    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
+        """
+        if isinstance(data, ChatCompletion):
+            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, Completion):
+            return data.choices[0].text
+        elif isinstance(data, CreateEmbeddingResponse):
+            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, ImagesResponse):
+            self.prompty.model.parameters
+            item: ImagesResponse = data
+
+            if len(data.data) == 0:
+                raise ValueError("Invalid data")
+            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]
+
+        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("AsyncAzureOpenAIProcessor", generator())
+        else:
+            return data

prompty/cli.py

@@ -1,17 +1,15 @@
 import os
 import json
 import click
-
+import importlib
 
 from pathlib import Path
 from pydantic import BaseModel
 
-from . import load, execute
-from .tracer import trace, Trace, PromptyTracer
+import prompty
+from prompty.tracer import trace, PromptyTracer, console_tracer, Tracer
 from dotenv import load_dotenv
 
-load_dotenv()
-Trace.add_tracer("prompty", PromptyTracer())
 
 def normalize_path(p, create_dir=False) -> Path:
     path = Path(p)
@@ -28,57 +26,105 @@ def normalize_path(p, create_dir=False) -> Path:
     return path
 
 
+def dynamic_import(module: str):
+    # built in modules
+    if module == "azure" or module == "azure_openai":
+        t = "prompty.azure"
+    elif module == "serverless":
+        t = "prompty.serverless"
+    else:
+        t = module
+
+    print(f"Loading invokers from {t}")
+    importlib.import_module(t)
+
+
 @trace
 def chat_mode(prompt_path: str):
-    W = "\033[0m"   # white (normal)
+    W = "\033[0m"  # white (normal)
     R = "\033[31m"  # red
     G = "\033[32m"  # green
     O = "\033[33m"  # orange
     B = "\033[34m"  # blue
     P = "\033[35m"  # purple
     print(f"Executing {str(prompt_path)} in chat mode...")
-    prompty = load(str(prompt_path))
-    if "chat_history" not in prompty.sample:
+    p = prompty.load(str(prompt_path))
+    if "chat_history" not in p.sample:
         print(
             f"{R}{str(prompt_path)} needs to have a chat_history input to work in chat mode{W}"
         )
         return
     else:
-        chat_history = prompty.sample["chat_history"]
-        while True:
-            user_input = input(f"{B}User:{W} ")
-            if user_input == "exit":
-                break
-            chat_history.append({"role": "user", "content": user_input})
-            # reloadable prompty file
-            result = execute(prompt_path, inputs={"chat_history": chat_history})
-            print(f"\n{G}Assistant:{W} {result}\n")
-            chat_history.append({"role": "assistant", "content": result})
-    print("Goodbye!")
+
+        try:
+            # load executor / processor types
+            dynamic_import(p.model.configuration["type"])
+            chat_history = p.sample["chat_history"]
+            while True:
+                user_input = input(f"\n{B}User:{W} ")
+                if user_input == "exit":
+                    break
+                # reloadable prompty file
+                chat_history.append({"role": "user", "content": user_input})
+                result = prompty.execute(
+                    prompt_path, inputs={"chat_history": chat_history}
+                )
+                print(f"\n{G}Assistant:{W} {result}")
+                chat_history.append({"role": "assistant", "content": result})
+        except Exception as e:
+            print(f"{type(e).__qualname__}: {e}")
+
+    print(f"\n{R}Goodbye!{W}\n")
+
+
+@trace
+def execute(prompt_path: str, raw=False):
+    p = prompty.load(prompt_path)
+
+    try:
+        # load executor / processor types
+        dynamic_import(p.model.configuration["type"])
+
+        result = prompty.execute(p, raw=raw)
+        if issubclass(type(result), BaseModel):
+            print("\n", json.dumps(result.model_dump(), indent=4), "\n")
+        elif isinstance(result, list):
+            print(
+                "\n", json.dumps([item.model_dump() for item in result], indent=4), "\n"
+            )
+        else:
+            print("\n", result, "\n")
+    except Exception as e:
+        print(f"{type(e).__qualname__}: {e}", "\n")
 
 
 @click.command()
 @click.option("--source", "-s", required=True)
+@click.option("--env", "-e", required=False)
 @click.option("--verbose", "-v", is_flag=True)
 @click.option("--chat", "-c", is_flag=True)
 @click.version_option()
-@trace
-def run(source, verbose, chat):
+def run(source, env, verbose, chat):
+    # load external env file
+    if env:
+        print(f"Loading environment variables from {env}")
+        load_dotenv(env)
+
     prompt_path = normalize_path(source)
     if not prompt_path.exists():
         print(f"{str(prompt_path)} does not exist")
         return
 
+    if verbose:
+        Tracer.add("console", console_tracer)
+
+    ptrace = PromptyTracer()
+    Tracer.add("prompty", ptrace.tracer)
+
     if chat:
         chat_mode(str(prompt_path))
     else:
-        result = execute(str(prompt_path), raw=verbose)
-        if issubclass(type(result), BaseModel):
-            print(json.dumps(result.model_dump(), indent=4))
-        elif isinstance(result, list):
-            print(json.dumps([item.model_dump() for item in result], indent=4))
-        else:
-            print(result)
+        execute(str(prompt_path), raw=verbose)
 
 
 if __name__ == "__main__":