prompty 0.1.1__tar.gz

prompty-0.1.1/PKG-INFO

@@ -0,0 +1,15 @@
+Metadata-Version: 2.1
+Name: prompty
+Version: 0.1.1
+Summary: Prompty is a new asset class and format for LLM prompts that aims to provide observability, understandability, and portability for developers. It includes spec, tooling, and a runtime. This Prompty runtime supports Python
+Author-Email: Seth Juarez <seth.juarez@microsoft.com>
+License: MIT
+Requires-Python: >=3.9
+Requires-Dist: pyyaml>=6.0.1
+Requires-Dist: pydantic>=2.8.2
+Requires-Dist: jinja2>=3.1.4
+Requires-Dist: openai>=1.35.10
+Requires-Dist: azure-identity>=1.17.1
+Description-Content-Type: text/markdown
+
+# prompty

prompty-0.1.1/README.md

@@ -0,0 +1 @@
+# prompty

prompty-0.1.1/prompty/__init__.py

@@ -0,0 +1,261 @@
+import json
+import traceback
+from pathlib import Path
+from typing import Dict, List, Union
+from .core import (
+    Frontmatter,
+    InvokerFactory,
+    ModelSettings,
+    Prompty,
+    PropertySettings,
+    TemplateSettings,
+    param_hoisting,
+)
+
+from .renderers import *
+from .parsers import *
+from .executors import *
+from .processors 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 {}
+
+
+def headless(
+    api: str,
+    content: str | List[str] | dict,
+    configuration: Dict[str, any] = {},
+    parameters: Dict[str, any] = {},
+    connection: str = "default",
+) -> Prompty:
+    # 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)
+
+
+def load(prompty_file: str, configuration: str = "default") -> Prompty:
+    p = Path(prompty_file)
+    if not p.is_absolute():
+        # get caller's path (take into account trace frame)
+        caller = Path(traceback.extract_stack()[-2].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
+
+
+def prepare(
+    prompt: Prompty,
+    inputs: Dict[str, any] = {},
+):
+    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
+
+
+def run(
+    prompt: Prompty,
+    content: dict | list | str,
+    configuration: Dict[str, any] = {},
+    parameters: Dict[str, any] = {},
+    raw: bool = False,
+):
+    # invoker = InvokerFactory()
+
+    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
+
+
+def execute(
+    prompt: Union[str, Prompty],
+    configuration: Dict[str, any] = {},
+    parameters: Dict[str, any] = {},
+    inputs: Dict[str, any] = {},
+    raw: bool = False,
+    connection: str = "default",
+):
+
+    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()[-2].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-0.1.1/prompty/core.py

@@ -0,0 +1,305 @@
+from __future__ import annotations
+
+import os
+import re
+import yaml
+import json
+import abc
+from pathlib import Path
+from pydantic import BaseModel, Field, FilePath
+from typing import List, Literal, Dict, Callable, TypeVar
+
+
+T = TypeVar("T")
+
+
+class PropertySettings(BaseModel):
+    type: Literal["string", "number", "array", "object", "boolean"]
+    default: str | int | float | List | dict | bool = Field(default=None)
+    description: str = Field(default="")
+
+
+class ModelSettings(BaseModel):
+    api: str = Field(default="")
+    configuration: dict = Field(default={})
+    parameters: dict = Field(default={})
+    response: dict = Field(default={})
+
+    def model_dump_safe(self) -> dict:
+        d = self.model_dump()
+        d["configuration"] = {
+            k: "*" * len(v) if "key" in k.lower() or "secret" in k.lower() else v
+            for k, v in d["configuration"].items()
+        }
+        return d
+
+
+class TemplateSettings(BaseModel):
+    type: str = Field(default="jinja2")
+    parser: str = Field(default="")
+
+
+class Prompty(BaseModel):
+    # metadata
+    name: str = Field(default="")
+    description: str = Field(default="")
+    authors: List[str] = Field(default=[])
+    tags: List[str] = Field(default=[])
+    version: str = Field(default="")
+    base: str = Field(default="")
+    basePrompty: Prompty | None = Field(default=None)
+    # model
+    model: ModelSettings = Field(default_factory=ModelSettings)
+
+    # sample
+    sample: dict = Field(default={})
+
+    # input / output
+    inputs: Dict[str, PropertySettings] = Field(default={})
+    outputs: Dict[str, PropertySettings] = Field(default={})
+
+    # template
+    template: TemplateSettings
+
+    file: FilePath = Field(default="")
+    content: str | List[str] | dict = Field(default="")
+
+    def to_safe_dict(self) -> Dict[str, any]:
+        d = {}
+        for k, v in self:
+            if v != "" and v != {} and v != [] and v != None:
+                if k == "model":
+                    d[k] = v.model_dump_safe()
+                elif k == "template":
+                    d[k] = v.model_dump()
+                elif k == "inputs" or k == "outputs":
+                    d[k] = {k: v.model_dump() for k, v in v.items()}
+                elif k == "file":
+                    d[k] = (
+                        str(self.file.as_posix())
+                        if isinstance(self.file, Path)
+                        else self.file
+                    )
+                elif k == "basePrompty":
+                    # no need to serialize basePrompty
+                    continue
+
+                else:
+                    d[k] = v
+        return d
+
+    # generate json representation of the prompty
+    def to_safe_json(self) -> str:
+        d = self.to_safe_dict()
+        return json.dumps(d)
+
+    @staticmethod
+    def _process_file(file: str, parent: Path) -> any:
+        file = Path(parent / Path(file)).resolve().absolute()
+        if file.exists():
+            with open(str(file), "r") as f:
+                items = json.load(f)
+                if isinstance(items, list):
+                    return [Prompty.normalize(value, parent) for value in items]
+                elif isinstance(items, dict):
+                    return {
+                        key: Prompty.normalize(value, parent)
+                        for key, value in items.items()
+                    }
+                else:
+                    return items
+        else:
+            raise FileNotFoundError(f"File {file} not found")
+
+    @staticmethod
+    def _process_env(variable: str, env_error=True) -> any:
+        if variable in os.environ.keys():
+            return os.environ[variable]
+        else:
+            if env_error:
+                raise ValueError(f"Variable {variable} not found in environment")
+            else:
+                return ""
+
+    @staticmethod
+    def normalize(attribute: any, parent: Path, env_error=True) -> any:
+        if isinstance(attribute, str):
+            attribute = attribute.strip()
+            if attribute.startswith("${") and attribute.endswith("}"):
+                # 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)
+                elif variable[0] == "file" and len(variable) > 1:
+                    return Prompty._process_file(variable[1], parent)
+                else:
+                    # old way of doing things for back compatibility
+                    v = Prompty._process_env(variable[0], False)
+                    if len(v) == 0:
+                        if len(variable) > 1:
+                            return variable[1]
+                        else:
+                            if env_error:
+                                raise ValueError(
+                                    f"Variable {variable[0]} not found in environment"
+                                )
+                            else:
+                                return v
+                    else:
+                        return v
+            elif (
+                attribute.startswith("file:")
+                and Path(parent / attribute.split(":")[1]).exists()
+            ):
+                # old way of doing things for back compatibility
+                return Prompty._process_file(attribute.split(":")[1], parent)
+            else:
+                return attribute
+        elif isinstance(attribute, list):
+            return [Prompty.normalize(value, parent) for value in attribute]
+        elif isinstance(attribute, dict):
+            return {
+                key: Prompty.normalize(value, parent)
+                for key, value in attribute.items()
+            }
+        else:
+            return attribute
+
+
+def param_hoisting(
+    top: Dict[str, any], bottom: Dict[str, any], top_key: str = None
+) -> Dict[str, any]:
+    if top_key:
+        new_dict = {**top[top_key]} if top_key in top else {}
+    else:
+        new_dict = {**top}
+    for key, value in bottom.items():
+        if not key in new_dict:
+            new_dict[key] = value
+    return new_dict
+
+
+class Invoker(abc.ABC):
+    def __init__(self, prompty: Prompty) -> None:
+        self.prompty = prompty
+
+    @abc.abstractmethod
+    def invoke(self, data: any) -> any:
+        pass
+
+    def __call__(self, data: any) -> any:
+        return self.invoke(data)
+
+
+class InvokerFactory:
+    _renderers: Dict[str, Invoker] = {}
+    _parsers: Dict[str, Invoker] = {}
+    _executors: Dict[str, Invoker] = {}
+    _processors: Dict[str, Invoker] = {}
+
+    @classmethod
+    def register_renderer(cls, name: str) -> Callable:
+        def inner_wrapper(wrapped_class: Invoker) -> Callable:
+            cls._renderers[name] = wrapped_class
+            return wrapped_class
+
+        return inner_wrapper
+
+    @classmethod
+    def register_parser(cls, name: str) -> Callable:
+        def inner_wrapper(wrapped_class: Invoker) -> Callable:
+            cls._parsers[name] = wrapped_class
+            return wrapped_class
+
+        return inner_wrapper
+
+    @classmethod
+    def register_executor(cls, name: str) -> Callable:
+        def inner_wrapper(wrapped_class: Invoker) -> Callable:
+            cls._executors[name] = wrapped_class
+            return wrapped_class
+
+        return inner_wrapper
+
+    @classmethod
+    def register_processor(cls, name: str) -> Callable:
+        def inner_wrapper(wrapped_class: Invoker) -> Callable:
+            cls._processors[name] = wrapped_class
+            return wrapped_class
+
+        return inner_wrapper
+
+    @classmethod
+    def create_renderer(cls, name: str, prompty: Prompty) -> Invoker:
+        if name not in cls._renderers:
+            raise ValueError(f"Renderer {name} not found")
+        return cls._renderers[name](prompty)
+
+    @classmethod
+    def create_parser(cls, name: str, prompty: Prompty) -> Invoker:
+        if name not in cls._parsers:
+            raise ValueError(f"Parser {name} not found")
+        return cls._parsers[name](prompty)
+
+    @classmethod
+    def create_executor(cls, name: str, prompty: Prompty) -> Invoker:
+        if name not in cls._executors:
+            raise ValueError(f"Executor {name} not found")
+        return cls._executors[name](prompty)
+
+    @classmethod
+    def create_processor(cls, name: str, prompty: Prompty) -> Invoker:
+        if name not in cls._processors:
+            raise ValueError(f"Processor {name} not found")
+        return cls._processors[name](prompty)
+
+
+@InvokerFactory.register_renderer("NOOP")
+@InvokerFactory.register_parser("NOOP")
+@InvokerFactory.register_executor("NOOP")
+@InvokerFactory.register_processor("NOOP")
+@InvokerFactory.register_parser("prompty.embedding")
+@InvokerFactory.register_parser("prompty.image")
+@InvokerFactory.register_parser("prompty.completion")
+class NoOp(Invoker):
+    def invoke(self, data: any) -> any:
+        return data
+
+
+class Frontmatter:
+    _yaml_delim = r"(?:---|\+\+\+)"
+    _yaml = r"(.*?)"
+    _content = r"\s*(.+)$"
+    _re_pattern = r"^\s*" + _yaml_delim + _yaml + _yaml_delim + _content
+    _regex = re.compile(_re_pattern, re.S | re.M)
+
+    @classmethod
+    def read_file(cls, path):
+        """Reads file at path and returns dict with separated frontmatter.
+        See read() for more info on dict return value.
+        """
+        with open(path, encoding="utf-8") as file:
+            file_contents = file.read()
+            return cls.read(file_contents)
+
+    @classmethod
+    def read(cls, string):
+        """Returns dict with separated frontmatter from string.
+
+        Returned dict keys:
+        attributes -- extracted YAML attributes in dict form.
+        body -- string contents below the YAML separators
+        frontmatter -- string representation of YAML
+        """
+        fmatter = ""
+        body = ""
+        result = cls._regex.search(string)
+
+        if result:
+            fmatter = result.group(1)
+            body = result.group(2)
+        return {
+            "attributes": yaml.load(fmatter, Loader=yaml.FullLoader),
+            "body": body,
+            "frontmatter": fmatter,
+        }

prompty-0.1.1/prompty/executors.py

@@ -0,0 +1,70 @@
+import azure.identity
+from openai import AzureOpenAI
+from .core import Invoker, InvokerFactory, Prompty
+from pathlib import Path
+
+
+@InvokerFactory.register_executor("azure")
+@InvokerFactory.register_executor("azure_openai")
+class AzureOpenAIExecutor(Invoker):
+    def __init__(self, prompty: Prompty) -> None:
+        self.prompty = 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": "prompty/0.1.0"},
+            **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:
+        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")
+
+        return response