prompty 0.1.9__tar.gz → 0.1.12__tar.gz

prompty-0.1.12/PKG-INFO

@@ -0,0 +1,17 @@
+Metadata-Version: 2.1
+Name: prompty
+Version: 0.1.12
+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
+Requires-Dist: pydantic>=2.8.2
+Requires-Dist: jinja2>=3.1.4
+Requires-Dist: python-dotenv>=1.0.1
+Requires-Dist: click>=8.1.7
+Requires-Dist: azure-identity>=1.17.1; extra == "azure"
+Requires-Dist: openai>=1.35.10; extra == "azure"
+Requires-Dist: openai>=1.35.10; extra == "openai"
+Requires-Dist: azure-ai-inference>=1.0.0b3; extra == "serverless"
+Provides-Extra: azure
+Provides-Extra: openai
+Provides-Extra: serverless

{prompty-0.1.9 → prompty-0.1.12}/prompty/__init__.py

@@ -3,8 +3,8 @@ import traceback
 from pathlib import Path
 from typing import Dict, List, Union
 
-from .tracer import trace
-from .core import (
+from prompty.tracer import trace
+from prompty.core import (
     Frontmatter,
     InvokerFactory,
     ModelSettings,
@@ -16,8 +16,6 @@ from .core import (
 
 from .renderers import *
 from .parsers import *
-from .executors import *
-from .processors import *
 
 
 def load_global_config(

prompty-0.1.12/prompty/azure/__init__.py

@@ -0,0 +1,3 @@
+# __init__.py
+from .executor import AzureOpenAIExecutor
+from .processor import AzureOpenAIProcessor

prompty-0.1.9/prompty/executors.py → prompty-0.1.12/prompty/azure/executor.py

@@ -2,7 +2,7 @@ import azure.identity
 import importlib.metadata
 from typing import Iterator
 from openai import AzureOpenAI
-from .core import Invoker, InvokerFactory, Prompty, PromptyStream
+from ..core import Invoker, InvokerFactory, Prompty, PromptyStream
 
 VERSION = importlib.metadata.version("prompty")
 
@@ -10,7 +10,8 @@ VERSION = importlib.metadata.version("prompty")
 @InvokerFactory.register_executor("azure")
 @InvokerFactory.register_executor("azure_openai")
 class AzureOpenAIExecutor(Invoker):
-    """ Azure OpenAI Executor  """
+    """Azure OpenAI Executor"""
+
     def __init__(self, prompty: Prompty) -> None:
         super().__init__(prompty)
         kwargs = {
@@ -40,7 +41,7 @@ class AzureOpenAIExecutor(Invoker):
 
         self.client = AzureOpenAI(
             default_headers={
-                "User-Agent": f"prompty{VERSION}",
+                "User-Agent": f"prompty/{VERSION}",
                 "x-ms-useragent": f"prompty/{VERSION}",
             },
             **kwargs,
@@ -51,7 +52,7 @@ class AzureOpenAIExecutor(Invoker):
         self.parameters = self.prompty.model.parameters
 
     def invoke(self, data: any) -> any:
-        """ Invoke the Azure OpenAI API
+        """Invoke the Azure OpenAI API
 
         Parameters
         ----------

prompty-0.1.9/prompty/processors.py → prompty-0.1.12/prompty/azure/processor.py

@@ -1,22 +1,14 @@
 from typing import Iterator
-from pydantic import BaseModel
 from openai.types.completion import Completion
 from openai.types.chat.chat_completion import ChatCompletion
-from .core import Invoker, InvokerFactory, Prompty, PromptyStream
+from ..core import Invoker, InvokerFactory, Prompty, PromptyStream, ToolCall
 from openai.types.create_embedding_response import CreateEmbeddingResponse
 
 
-class ToolCall(BaseModel):
-    id: str
-    name: str
-    arguments: str
-
-
-@InvokerFactory.register_processor("openai")
 @InvokerFactory.register_processor("azure")
 @InvokerFactory.register_processor("azure_openai")
-class OpenAIProcessor(Invoker):
-    """OpenAI/Azure Processor"""
+class AzureOpenAIProcessor(Invoker):
+    """Azure OpenAI Processor"""
 
     def __init__(self, prompty: Prompty) -> None:
         super().__init__(prompty)
@@ -62,10 +54,13 @@ class OpenAIProcessor(Invoker):
 
             def generator():
                 for chunk in data:
-                    if len(chunk.choices) == 1 and chunk.choices[0].delta.content != None:
+                    if (
+                        len(chunk.choices) == 1
+                        and chunk.choices[0].delta.content != None
+                    ):
                         content = chunk.choices[0].delta.content
                         yield content
 
-            return PromptyStream("OpenAIProcessor", generator())
+            return PromptyStream("AzureOpenAIProcessor", generator())
         else:
             return data

prompty-0.1.12/prompty/cli.py

@@ -0,0 +1,117 @@
+import os
+import json
+import click
+import importlib
+
+from pathlib import Path
+from pydantic import BaseModel
+
+import prompty
+from prompty.tracer import trace, PromptyTracer, console_tracer, Tracer
+from dotenv import load_dotenv
+
+load_dotenv()
+
+
+def normalize_path(p, create_dir=False) -> Path:
+    path = Path(p)
+    if not path.is_absolute():
+        path = Path(os.getcwd()).joinpath(path).absolute().resolve()
+    else:
+        path = path.absolute().resolve()
+
+    if create_dir:
+        if not path.exists():
+            print(f"Creating directory {str(path)}")
+            os.makedirs(str(path))
+
+    return path
+
+def dynamic_import(module: str):
+    t = module if "." in module else f"prompty.{module}"
+    print(f"Loading invokers from {t}")
+    importlib.import_module(t)
+
+
+@trace
+def chat_mode(prompt_path: str):
+    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...")
+    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:
+
+        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("--verbose", "-v", is_flag=True)
+@click.option("--chat", "-c", is_flag=True)
+@click.version_option()
+def run(source, verbose, chat):
+    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:
+        execute(str(prompt_path), raw=verbose)
+
+
+if __name__ == "__main__":
+    chat_mode(source="./tests/prompts/basic.prompt")

{prompty-0.1.9 → prompty-0.1.12}/prompty/core.py

@@ -8,7 +8,13 @@ import abc
 from pathlib import Path
 from .tracer import Tracer, trace, to_dict
 from pydantic import BaseModel, Field, FilePath
-from typing import Iterator, List, Literal, Dict, Callable, Set
+from typing import AsyncIterator, Iterator, List, Literal, Dict, Callable, Set
+
+
+class ToolCall(BaseModel):
+    id: str
+    name: str
+    arguments: str
 
 
 class PropertySettings(BaseModel):
@@ -207,14 +213,16 @@ class Prompty(BaseModel):
             raise FileNotFoundError(f"File {file} not found")
 
     @staticmethod
-    def _process_env(variable: str, env_error=True) -> any:
+    def _process_env(variable: str, env_error=True, default: str = None) -> any:
         if variable in os.environ.keys():
             return os.environ[variable]
         else:
+            if default:
+                return default
             if env_error:
                 raise ValueError(f"Variable {variable} not found in environment")
-            else:
-                return ""
+
+            return ""
 
     @staticmethod
     def normalize(attribute: any, parent: Path, env_error=True) -> any:
@@ -224,7 +232,11 @@ class Prompty(BaseModel):
                 # check if env or file
                 variable = attribute[2:-1].split(":")
                 if variable[0] == "env" and len(variable) > 1:
-                    return Prompty._process_env(variable[1], env_error)
+                    return Prompty._process_env(
+                        variable[1],
+                        env_error,
+                        variable[2] if len(variable) > 2 else None,
+                    )
                 elif variable[0] == "file" and len(variable) > 1:
                     return Prompty._process_file(variable[1], parent)
                 else:
@@ -331,6 +343,22 @@ class InvokerFactory:
     _executors: Dict[str, Invoker] = {}
     _processors: Dict[str, Invoker] = {}
 
+    @classmethod
+    def add_renderer(cls, name: str, invoker: Invoker) -> None:
+        cls._renderers[name] = invoker
+
+    @classmethod
+    def add_parser(cls, name: str, invoker: Invoker) -> None:
+        cls._parsers[name] = invoker
+
+    @classmethod
+    def add_executor(cls, name: str, invoker: Invoker) -> None:
+        cls._executors[name] = invoker
+
+    @classmethod
+    def add_processor(cls, name: str, invoker: Invoker) -> None:
+        cls._processors[name] = invoker
+
     @classmethod
     def register_renderer(cls, name: str) -> Callable:
         def inner_wrapper(wrapped_class: Invoker) -> Callable:
@@ -474,8 +502,38 @@ class PromptyStream(Iterator):
         except StopIteration:
             # StopIteration is raised
             # contents are exhausted
-            if len(self.items) > 0:     
+            if len(self.items) > 0:
                 with Tracer.start(f"{self.name}.PromptyStream") as trace:
-                    trace("items", [to_dict(s) for s in self.items])
+                    trace("result", [to_dict(s) for s in self.items])
+
+            raise StopIteration
+
+
+class AsyncPromptyStream(AsyncIterator):
+    """AsyncPromptyStream class to iterate over LLM stream.
+    Necessary for Prompty to handle streaming data when tracing."""
+
+    def __init__(self, name: str, iterator: AsyncIterator):
+        self.name = name
+        self.iterator = iterator
+        self.items: List[any] = []
+        self.__name__ = "AsyncPromptyStream"
+
+    def __aiter__(self):
+        return self
+
+    async def __anext__(self):
+        try:
+            # enumerate but add to list
+            o = await self.iterator.__anext__()
+            self.items.append(o)
+            return o
+
+        except StopIteration:
+            # StopIteration is raised
+            # contents are exhausted
+            if len(self.items) > 0:
+                with Tracer.start(f"{self.name}.AsyncPromptyStream") as trace:
+                    trace("result", [to_dict(s) for s in self.items])
 
             raise StopIteration

prompty-0.1.12/prompty/openai/__init__.py

@@ -0,0 +1,3 @@
+# __init__.py
+from .executor import AzureOpenAIExecutor
+from .processor import AzureOpenAIProcessor

prompty-0.1.12/prompty/openai/executor.py

@@ -0,0 +1,74 @@
+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 AzureOpenAIExecutor(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.12/prompty/openai/processor.py

@@ -0,0 +1,65 @@
+from typing import Iterator
+from openai.types.completion import Completion
+from openai.types.chat.chat_completion import ChatCompletion
+from ..core import Invoker, InvokerFactory, Prompty, PromptyStream, ToolCall
+from openai.types.create_embedding_response import CreateEmbeddingResponse
+
+
+@InvokerFactory.register_processor("openai")
+class AzureOpenAIProcessor(Invoker):
+    """OpenAI Processor"""
+
+    def __init__(self, prompty: Prompty) -> None:
+        super().__init__(prompty)
+
+    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 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, 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("OpenAIProcessor", generator())
+        else:
+            return data

prompty-0.1.12/prompty/serverless/__init__.py

@@ -0,0 +1,3 @@
+# __init__.py
+from .executor import ServerlessExecutor
+from .processor import ServerlessProcessor

prompty-0.1.12/prompty/serverless/executor.py

@@ -0,0 +1,82 @@
+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),
+            ).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),
+            ).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

prompty-0.1.12/prompty/serverless/processor.py

@@ -0,0 +1,62 @@
+from typing import Iterator
+from ..core import Invoker, InvokerFactory, Prompty, PromptyStream, ToolCall
+
+from azure.ai.inference.models import ChatCompletions, EmbeddingsResult
+
+
+@InvokerFactory.register_processor("serverless")
+class ServerlessProcessor(Invoker):
+    """OpenAI Processor"""
+
+    def __init__(self, prompty: Prompty) -> None:
+        super().__init__(prompty)
+
+    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 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, 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("ServerlessProcessor", generator())
+        else:
+            return data