prompty 0.1.12__py2.py3-none-any.whl

prompty/__init__.py

@@ -0,0 +1,391 @@
+import json
+import traceback
+from pathlib import Path
+from typing import Dict, List, Union
+
+from prompty.tracer import trace
+from prompty.core import (
+    Frontmatter,
+    InvokerFactory,
+    ModelSettings,
+    Prompty,
+    PropertySettings,
+    TemplateSettings,
+    param_hoisting,
+)
+
+from .renderers import *
+from .parsers import *
+
+
+def load_global_config(
+    prompty_path: Path = Path.cwd(), configuration: str = "default"
+) -> Dict[str, any]:
+    # prompty.config laying around?
+    prompty_config = list(Path.cwd().glob("**/prompty.json"))
+
+    # if there is one load it
+    if len(prompty_config) > 0:
+        # pick the nearest prompty.json
+        config = sorted(
+            [
+                c
+                for c in prompty_config
+                if len(c.parent.parts) <= len(prompty_path.parts)
+            ],
+            key=lambda p: len(p.parts),
+        )[-1]
+
+        with open(config, "r") as f:
+            c = json.load(f)
+            if configuration in c:
+                return c[configuration]
+            else:
+                raise ValueError(f'Item "{configuration}" not found in "{config}"')
+
+    return {}
+
+
+@trace(description="Create a headless prompty object for programmatic use.")
+def headless(
+    api: str,
+    content: str | List[str] | dict,
+    configuration: Dict[str, any] = {},
+    parameters: Dict[str, any] = {},
+    connection: str = "default",
+) -> Prompty:
+    """Create a headless prompty object for programmatic use.
+
+    Parameters
+    ----------
+    api : str
+        The API to use for the model
+    content : str | List[str] | dict
+        The content to process
+    configuration : Dict[str, any], optional
+        The configuration to use, by default {}
+    parameters : Dict[str, any], optional
+        The parameters to use, by default {}
+    connection : str, optional
+        The connection to use, by default "default"
+
+    Returns
+    -------
+    Prompty
+        The headless prompty object
+
+    Example
+    -------
+    >>> import prompty
+    >>> p = prompty.headless(
+            api="embedding",
+            configuration={"type": "azure", "azure_deployment": "text-embedding-ada-002"},
+            content="hello world",
+        )
+    >>> emb = prompty.execute(p)
+
+    """
+
+    # get caller's path (to get relative path for prompty.json)
+    caller = Path(traceback.extract_stack()[-2].filename)
+    templateSettings = TemplateSettings(type="NOOP", parser="NOOP")
+    modelSettings = ModelSettings(
+        api=api,
+        configuration=Prompty.normalize(
+            param_hoisting(
+                configuration, load_global_config(caller.parent, connection)
+            ),
+            caller.parent,
+        ),
+        parameters=parameters,
+    )
+
+    return Prompty(model=modelSettings, template=templateSettings, content=content)
+
+
+@trace(description="Load a prompty file.")
+def load(prompty_file: str, configuration: str = "default") -> Prompty:
+    """Load a prompty file.
+
+    Parameters
+    ----------
+    prompty_file : str
+        The path to the prompty file
+    configuration : str, optional
+        The configuration to use, by default "default"
+
+    Returns
+    -------
+    Prompty
+        The loaded prompty object
+
+    Example
+    -------
+    >>> import prompty
+    >>> p = prompty.load("prompts/basic.prompty")
+    >>> print(p)
+    """
+
+    p = Path(prompty_file)
+    if not p.is_absolute():
+        # get caller's path (take into account trace frame)
+        caller = Path(traceback.extract_stack()[-3].filename)
+        p = Path(caller.parent / p).resolve().absolute()
+
+    # load dictionary from prompty file
+    matter = Frontmatter.read_file(p)
+    attributes = matter["attributes"]
+    content = matter["body"]
+
+    # normalize attribute dictionary resolve keys and files
+    attributes = Prompty.normalize(attributes, p.parent)
+
+    # load global configuration
+    global_config = Prompty.normalize(
+        load_global_config(p.parent, configuration), p.parent
+    )
+    if "model" not in attributes:
+        attributes["model"] = {}
+
+    if "configuration" not in attributes["model"]:
+        attributes["model"]["configuration"] = global_config
+    else:
+        attributes["model"]["configuration"] = param_hoisting(
+            attributes["model"]["configuration"],
+            global_config,
+        )
+
+    # pull model settings out of attributes
+    try:
+        model = ModelSettings(**attributes.pop("model"))
+    except Exception as e:
+        raise ValueError(f"Error in model settings: {e}")
+
+    # pull template settings
+    try:
+        if "template" in attributes:
+            t = attributes.pop("template")
+            if isinstance(t, dict):
+                template = TemplateSettings(**t)
+            # has to be a string denoting the type
+            else:
+                template = TemplateSettings(type=t, parser="prompty")
+        else:
+            template = TemplateSettings(type="jinja2", parser="prompty")
+    except Exception as e:
+        raise ValueError(f"Error in template loader: {e}")
+
+    # formalize inputs and outputs
+    if "inputs" in attributes:
+        try:
+            inputs = {
+                k: PropertySettings(**v) for (k, v) in attributes.pop("inputs").items()
+            }
+        except Exception as e:
+            raise ValueError(f"Error in inputs: {e}")
+    else:
+        inputs = {}
+    if "outputs" in attributes:
+        try:
+            outputs = {
+                k: PropertySettings(**v) for (k, v) in attributes.pop("outputs").items()
+            }
+        except Exception as e:
+            raise ValueError(f"Error in outputs: {e}")
+    else:
+        outputs = {}
+
+    # recursive loading of base prompty
+    if "base" in attributes:
+        # load the base prompty from the same directory as the current prompty
+        base = load(p.parent / attributes["base"])
+        # hoist the base prompty's attributes to the current prompty
+        model.api = base.model.api if model.api == "" else model.api
+        model.configuration = param_hoisting(
+            model.configuration, base.model.configuration
+        )
+        model.parameters = param_hoisting(model.parameters, base.model.parameters)
+        model.response = param_hoisting(model.response, base.model.response)
+        attributes["sample"] = param_hoisting(attributes, base.sample, "sample")
+
+        p = Prompty(
+            **attributes,
+            model=model,
+            inputs=inputs,
+            outputs=outputs,
+            template=template,
+            content=content,
+            file=p,
+            basePrompty=base,
+        )
+    else:
+        p = Prompty(
+            **attributes,
+            model=model,
+            inputs=inputs,
+            outputs=outputs,
+            template=template,
+            content=content,
+            file=p,
+        )
+    return p
+
+@trace(description="Prepare the inputs for the prompt.")
+def prepare(
+    prompt: Prompty,
+    inputs: Dict[str, any] = {},
+):
+    """ Prepare the inputs for the prompt.
+
+    Parameters
+    ----------
+    prompt : Prompty
+        The prompty object
+    inputs : Dict[str, any], optional
+        The inputs to the prompt, by default {}
+
+    Returns
+    -------
+    dict
+        The prepared and hidrated template shaped to the LLM model
+
+    Example
+    -------
+    >>> import prompty
+    >>> p = prompty.load("prompts/basic.prompty")
+    >>> inputs = {"name": "John Doe"}
+    >>> content = prompty.prepare(p, inputs)
+    """
+    inputs = param_hoisting(inputs, prompt.sample)
+
+    if prompt.template.type == "NOOP":
+        render = prompt.content
+    else:
+        # render
+        renderer = InvokerFactory.create_renderer(prompt.template.type, prompt)
+        render = renderer(inputs)
+
+    if prompt.template.parser == "NOOP":
+        result = render
+    else:
+        # parse [parser].[api]
+        parser = InvokerFactory.create_parser(
+            f"{prompt.template.parser}.{prompt.model.api}", prompt
+        )
+        result = parser(render)
+
+    return result
+
+@trace(description="Run the prepared Prompty content against the model.")
+def run(
+    prompt: Prompty,
+    content: dict | list | str,
+    configuration: Dict[str, any] = {},
+    parameters: Dict[str, any] = {},
+    raw: bool = False,
+):
+    """Run the prepared Prompty content.
+
+    Parameters
+    ----------
+    prompt : Prompty
+        The prompty object
+    content : dict | list | str
+        The content to process
+    configuration : Dict[str, any], optional
+        The configuration to use, by default {}
+    parameters : Dict[str, any], optional
+        The parameters to use, by default {}
+    raw : bool, optional
+        Whether to skip processing, by default False
+
+    Returns
+    -------
+    any
+        The result of the prompt
+
+    Example
+    -------
+    >>> import prompty
+    >>> p = prompty.load("prompts/basic.prompty")
+    >>> inputs = {"name": "John Doe"}
+    >>> content = prompty.prepare(p, inputs)
+    >>> result = prompty.run(p, content)
+    """
+
+    if configuration != {}:
+        prompt.model.configuration = param_hoisting(
+            configuration, prompt.model.configuration
+        )
+
+    if parameters != {}:
+        prompt.model.parameters = param_hoisting(parameters, prompt.model.parameters)
+
+    # execute
+    executor = InvokerFactory.create_executor(
+        prompt.model.configuration["type"], prompt
+    )
+    result = executor(content)
+
+    # skip?
+    if not raw:
+        # process
+        processor = InvokerFactory.create_processor(
+            prompt.model.configuration["type"], prompt
+        )
+        result = processor(result)
+
+    return result
+
+@trace(description="Execute a prompty")
+def execute(
+    prompt: Union[str, Prompty],
+    configuration: Dict[str, any] = {},
+    parameters: Dict[str, any] = {},
+    inputs: Dict[str, any] = {},
+    raw: bool = False,
+    connection: str = "default",
+):
+    """Execute a prompty.
+
+    Parameters
+    ----------
+    prompt : Union[str, Prompty]
+        The prompty object or path to the prompty file
+    configuration : Dict[str, any], optional
+        The configuration to use, by default {}
+    parameters : Dict[str, any], optional
+        The parameters to use, by default {}
+    inputs : Dict[str, any], optional
+        The inputs to the prompt, by default {}
+    raw : bool, optional
+        Whether to skip processing, by default False
+    connection : str, optional
+        The connection to use, by default "default"
+
+    Returns
+    -------
+    any
+        The result of the prompt
+
+    Example
+    -------
+    >>> import prompty
+    >>> inputs = {"name": "John Doe"}
+    >>> result = prompty.execute("prompts/basic.prompty", inputs=inputs)
+    """
+    if isinstance(prompt, str):
+        path = Path(prompt)
+        if not path.is_absolute():
+            # get caller's path (take into account trace frame)
+            caller = Path(traceback.extract_stack()[-3].filename)
+            path = Path(caller.parent / path).resolve().absolute()
+        prompt = load(path, connection)
+
+    # prepare content
+    content = prepare(prompt, inputs)
+
+    # run LLM model
+    result = run(prompt, content, configuration, parameters, raw)
+
+    return result

prompty/azure/__init__.py

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

prompty/azure/executor.py

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

prompty/azure/processor.py

@@ -0,0 +1,66 @@
+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("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, 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

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")