prompty 0.1.47__py3-none-any.whl → 0.1.49__py3-none-any.whl

prompty/__init__.py

@@ -12,7 +12,7 @@ from .core import (
 )
 from .invoker import InvokerFactory
 from .parsers import PromptyChatParser
-from .renderers import Jinja2Renderer
+from .renderers import Jinja2Renderer, MustacheRenderer
 from .tracer import trace
 from .utils import (
     load_global_config,
@@ -22,6 +22,7 @@ from .utils import (
 )
 
 InvokerFactory.add_renderer("jinja2", Jinja2Renderer)
+InvokerFactory.add_renderer("mustache", MustacheRenderer)
 InvokerFactory.add_parser("prompty.chat", PromptyChatParser)
 
 

prompty/cli.py

@@ -6,7 +6,7 @@ from typing import Any, Optional
 
 import click
 from dotenv import load_dotenv
-from pydantic import BaseModel
+from dataclasses import asdict, is_dataclass
 
 import prompty
 from prompty.tracer import PromptyTracer, Tracer, console_tracer, trace
@@ -91,11 +91,11 @@ def execute(prompt_path: str, inputs: Optional[dict[str, Any]] = None, raw=False
         dynamic_import(p.model.configuration["type"])
 
         result = prompty.execute(p, inputs=inputs, raw=raw)
-        if issubclass(type(result), BaseModel):
-            print("\n", json.dumps(result.model_dump(), indent=4), "\n")
+        if is_dataclass(result) and not isinstance(result, type):
+            print("\n", json.dumps(asdict(result), indent=4), "\n")
         elif isinstance(result, list):
             print(
-                "\n", json.dumps([item.model_dump() for item in result], indent=4), "\n"
+                "\n", json.dumps([asdict(item) for item in result], indent=4), "\n"
             )
         else:
             print("\n", result, "\n")

prompty/core.py

@@ -1,23 +1,23 @@
+import copy
 import os
 import typing
 from collections.abc import AsyncIterator, Iterator
+from dataclasses import dataclass, field, fields, asdict
 from pathlib import Path
-from typing import Literal, Union
-
-from pydantic import BaseModel, Field, FilePath
-from pydantic.main import IncEx
-
-from .tracer import Tracer, sanitize, to_dict
+from typing import Any, Dict, List, Literal, Union
+from .tracer import Tracer, to_dict
 from .utils import load_json, load_json_async
 
 
-class ToolCall(BaseModel):
+@dataclass
+class ToolCall:
     id: str
     name: str
     arguments: str
 
 
-class PropertySettings(BaseModel):
+@dataclass
+class PropertySettings:
     """PropertySettings class to define the properties of the model
 
     Attributes
@@ -31,11 +31,12 @@ class PropertySettings(BaseModel):
     """
 
     type: Literal["string", "number", "array", "object", "boolean"]
-    default: Union[str, int, float, list, dict, bool, None] = Field(default=None)
-    description: str = Field(default="")
+    default: Union[str, int, float, list, dict, bool, None] = field(default=None)
+    description: str = field(default="")
 
 
-class ModelSettings(BaseModel):
+@dataclass
+class ModelSettings:
     """ModelSettings class to define the model of the prompty
 
     Attributes
@@ -50,48 +51,14 @@ class ModelSettings(BaseModel):
         The response of the model
     """
 
-    api: str = Field(default="")
-    configuration: dict = Field(default={})
-    parameters: dict = Field(default={})
-    response: dict = Field(default={})
-
-    def model_dump(
-        self,
-        *,
-        mode: str = "python",
-        include: Union[IncEx, None] = None,
-        exclude: Union[IncEx, None] = None,
-        context: Union[typing.Any, None] = None,
-        by_alias: bool = False,
-        exclude_unset: bool = False,
-        exclude_defaults: bool = False,
-        exclude_none: bool = False,
-        round_trip: bool = False,
-        warnings: Union[
-            bool, Literal["none"], Literal["warn"], Literal["error"]
-        ] = True,
-        serialize_as_any: bool = False,
-    ) -> dict[str, typing.Any]:
-        """Method to dump the model in a safe way"""
-        d = super().model_dump(
-            mode=mode,
-            include=include,
-            exclude=exclude,
-            context=context,
-            by_alias=by_alias,
-            exclude_unset=exclude_unset,
-            exclude_defaults=exclude_defaults,
-            exclude_none=exclude_none,
-            round_trip=round_trip,
-            warnings=warnings,
-            serialize_as_any=serialize_as_any,
-        )
-
-        d["configuration"] = {k: sanitize(k, v) for k, v in d["configuration"].items()}
-        return d
+    api: str = field(default="")
+    configuration: dict = field(default_factory=dict)
+    parameters: dict = field(default_factory=dict)
+    response: dict = field(default_factory=dict)
 
 
-class TemplateSettings(BaseModel):
+@dataclass
+class TemplateSettings:
     """TemplateSettings class to define the template of the prompty
 
     Attributes
@@ -102,11 +69,12 @@ class TemplateSettings(BaseModel):
         The parser of the template
     """
 
-    type: str = Field(default="jinja2")
-    parser: str = Field(default="")
+    type: str = field(default="mustache")
+    parser: str = field(default="")
 
 
-class Prompty(BaseModel):
+@dataclass
+class Prompty:
     """Prompty class to define the prompty
 
     Attributes
@@ -115,9 +83,9 @@ class Prompty(BaseModel):
         The name of the prompty
     description : str
         The description of the prompty
-    authors : List[str]
+    authors : list[str]
         The authors of the prompty
-    tags : List[str]
+    tags : list[str]
         The tags of the prompty
     version : str
         The version of the prompty
@@ -129,52 +97,54 @@ class Prompty(BaseModel):
         The model of the prompty
     sample : dict
         The sample of the prompty
-    inputs : Dict[str, PropertySettings]
+    inputs : dict[str, PropertySettings]
         The inputs of the prompty
-    outputs : Dict[str, PropertySettings]
+    outputs : dict[str, PropertySettings]
         The outputs of the prompty
     template : TemplateSettings
         The template of the prompty
     file : FilePath
         The file of the prompty
-    content : str | List[str] | dict
+    content : Union[str, list[str], dict]
         The content of the prompty
     """
 
     # 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: Union["Prompty", None] = Field(default=None)
+    name: str = field(default="")
+    description: str = field(default="")
+    authors: List[str] = field(default_factory=list)
+    tags: List[str] = field(default_factory=list)
+    version: str = field(default="")
+    base: str = field(default="")
+    basePrompty: Union["Prompty", None] = field(default=None)
     # model
-    model: ModelSettings = Field(default_factory=ModelSettings)
+    model: ModelSettings = field(default_factory=ModelSettings)
 
     # sample
-    sample: dict = Field(default={})
+    sample: dict = field(default_factory=dict)
 
     # input / output
-    inputs: dict[str, PropertySettings] = Field(default={})
-    outputs: dict[str, PropertySettings] = Field(default={})
+    inputs: dict[str, PropertySettings] = field(default_factory=dict)
+    outputs: dict[str, PropertySettings] = field(default_factory=dict)
 
     # template
-    template: TemplateSettings
+    template: TemplateSettings = field(default_factory=TemplateSettings)
 
-    file: Union[str, FilePath] = Field(default="")
-    content: Union[str, list[str], dict] = Field(default="")
+    file: Union[str, Path] = field(default="")
+    content: Union[str, list[str], dict] = field(default="")
 
     def to_safe_dict(self) -> dict[str, typing.Any]:
-        d = {}
-        for k, v in self:
+        d: dict[str, typing.Any] = {}
+        for field in fields(self):
+            k = field.name
+            v = getattr(self, field.name)
             if v != "" and v != {} and v != [] and v is not None:
                 if k == "model":
-                    d[k] = v.model_dump()
+                    d[k] = asdict(self.model)
                 elif k == "template":
-                    d[k] = v.model_dump()
+                    d[k] = asdict(self.template)
                 elif k == "inputs" or k == "outputs":
-                    d[k] = {k: v.model_dump() for k, v in v.items()}
+                    d[k] = copy.deepcopy(v)
                 elif k == "file":
                     d[k] = (
                         str(self.file.as_posix())
@@ -217,7 +187,7 @@ class Prompty(BaseModel):
         f = Path(parent / Path(file)).resolve().absolute()
         if f.exists():
             items = load_json(f)
-            if isinstance(items, list):
+            if isinstance(items, List):
                 return [Prompty.normalize(value, parent) for value in items]
             elif isinstance(items, dict):
                 return {
@@ -325,7 +295,7 @@ def param_hoisting(
     top: dict[str, typing.Any],
     bottom: dict[str, typing.Any],
     top_key: Union[str, None] = None,
-) -> dict[str, typing.Any]:
+) -> Dict[str, typing.Any]:
     if top_key:
         new_dict = {**top[top_key]} if top_key in top else {}
     else:

prompty/mustache.py

@@ -0,0 +1,666 @@
+from __future__ import annotations
+import logging
+from collections.abc import Iterator, Sequence
+from types import MappingProxyType
+from typing import (
+    Any,
+    Dict,
+    List,
+    Literal,
+    Mapping,
+    Optional,
+    Union,
+    cast,
+)
+from typing_extensions import TypeAlias
+
+logger = logging.getLogger(__name__)
+
+
+Scopes: TypeAlias = List[Union[Literal[False, 0], Mapping[str, Any]]]
+
+
+# Globals
+_CURRENT_LINE = 1
+_LAST_TAG_LINE = None
+
+
+class ChevronError(SyntaxError):
+    """Custom exception for Chevron errors."""
+
+
+#
+# Helper functions
+#
+
+
+def grab_literal(template: str, l_del: str) -> tuple[str, str]:
+    """Parse a literal from the template.
+
+    Args:
+        template: The template to parse.
+        l_del: The left delimiter.
+
+    Returns:
+        Tuple[str, str]: The literal and the template.
+    """
+
+    global _CURRENT_LINE
+
+    try:
+        # Look for the next tag and move the template to it
+        literal, template = template.split(l_del, 1)
+        _CURRENT_LINE += literal.count("\n")
+        return (literal, template)
+
+    # There are no more tags in the template?
+    except ValueError:
+        # Then the rest of the template is a literal
+        return (template, "")
+
+
+def l_sa_check(template: str, literal: str, is_standalone: bool) -> bool:
+    """Do a preliminary check to see if a tag could be a standalone.
+
+    Args:
+        template: The template. (Not used.)
+        literal: The literal.
+        is_standalone: Whether the tag is standalone.
+
+    Returns:
+        bool: Whether the tag could be a standalone.
+    """
+
+    # If there is a newline, or the previous tag was a standalone
+    if literal.find("\n") != -1 or is_standalone:
+        padding = literal.split("\n")[-1]
+
+        # If all the characters since the last newline are spaces
+        # Then the next tag could be a standalone
+        # Otherwise it can't be
+        return padding.isspace() or padding == ""
+    else:
+        return False
+
+
+def r_sa_check(template: str, tag_type: str, is_standalone: bool) -> bool:
+    """Do a final check to see if a tag could be a standalone.
+
+    Args:
+        template: The template.
+        tag_type: The type of the tag.
+        is_standalone: Whether the tag is standalone.
+
+    Returns:
+        bool: Whether the tag could be a standalone.
+    """
+
+    # Check right side if we might be a standalone
+    if is_standalone and tag_type not in ["variable", "no escape"]:
+        on_newline = template.split("\n", 1)
+
+        # If the stuff to the right of us are spaces we're a standalone
+        return on_newline[0].isspace() or not on_newline[0]
+
+    # If we're a tag can't be a standalone
+    else:
+        return False
+
+
+def parse_tag(template: str, l_del: str, r_del: str) -> tuple[tuple[str, str], str]:
+    """Parse a tag from a template.
+
+    Args:
+        template: The template.
+        l_del: The left delimiter.
+        r_del: The right delimiter.
+
+    Returns:
+        Tuple[Tuple[str, str], str]: The tag and the template.
+
+    Raises:
+        ChevronError: If the tag is unclosed.
+        ChevronError: If the set delimiter tag is unclosed.
+    """
+    global _CURRENT_LINE
+    global _LAST_TAG_LINE
+
+    tag_types = {
+        "!": "comment",
+        "#": "section",
+        "^": "inverted section",
+        "/": "end",
+        ">": "partial",
+        "=": "set delimiter?",
+        "{": "no escape?",
+        "&": "no escape",
+    }
+
+    # Get the tag
+    try:
+        tag, template = template.split(r_del, 1)
+    except ValueError as e:
+        msg = "unclosed tag " f"at line {_CURRENT_LINE}"
+        raise ChevronError(msg) from e
+
+    # Find the type meaning of the first character
+    tag_type = tag_types.get(tag[0], "variable")
+
+    # If the type is not a variable
+    if tag_type != "variable":
+        # Then that first character is not needed
+        tag = tag[1:]
+
+    # If we might be a set delimiter tag
+    if tag_type == "set delimiter?":
+        # Double check to make sure we are
+        if tag.endswith("="):
+            tag_type = "set delimiter"
+            # Remove the equal sign
+            tag = tag[:-1]
+
+        # Otherwise we should complain
+        else:
+            msg = "unclosed set delimiter tag\n" f"at line {_CURRENT_LINE}"
+            raise ChevronError(msg)
+
+    elif (
+        # If we might be a no html escape tag
+        tag_type == "no escape?"
+        # And we have a third curly brace
+        # (And are using curly braces as delimiters)
+        and l_del == "{{"
+        and r_del == "}}"
+        and template.startswith("}")
+    ):
+        # Then we are a no html escape tag
+        template = template[1:]
+        tag_type = "no escape"
+
+    # Strip the whitespace off the key and return
+    return ((tag_type, tag.strip()), template)
+
+
+#
+# The main tokenizing function
+#
+
+
+def tokenize(template: str, def_ldel: str = "{{", def_rdel: str = "}}") -> Iterator[tuple[str, str]]:
+    """Tokenize a mustache template.
+
+    Tokenizes a mustache template in a generator fashion,
+    using file-like objects. It also accepts a string containing
+    the template.
+
+
+    Arguments:
+
+    template -- a file-like object, or a string of a mustache template
+
+    def_ldel -- The default left delimiter
+                ("{{" by default, as in spec compliant mustache)
+
+    def_rdel -- The default right delimiter
+                ("}}" by default, as in spec compliant mustache)
+
+
+    Returns:
+
+    A generator of mustache tags in the form of a tuple
+
+    -- (tag_type, tag_key)
+
+    Where tag_type is one of:
+     * literal
+     * section
+     * inverted section
+     * end
+     * partial
+     * no escape
+
+    And tag_key is either the key or in the case of a literal tag,
+    the literal itself.
+    """
+
+    global _CURRENT_LINE, _LAST_TAG_LINE
+    _CURRENT_LINE = 1
+    _LAST_TAG_LINE = None
+
+    is_standalone = True
+    open_sections = []
+    l_del = def_ldel
+    r_del = def_rdel
+
+    while template:
+        literal, template = grab_literal(template, l_del)
+
+        # If the template is completed
+        if not template:
+            # Then yield the literal and leave
+            yield ("literal", literal)
+            break
+
+        # Do the first check to see if we could be a standalone
+        is_standalone = l_sa_check(template, literal, is_standalone)
+
+        # Parse the tag
+        tag, template = parse_tag(template, l_del, r_del)
+        tag_type, tag_key = tag
+
+        # Special tag logic
+
+        # If we are a set delimiter tag
+        if tag_type == "set delimiter":
+            # Then get and set the delimiters
+            dels = tag_key.strip().split(" ")
+            l_del, r_del = dels[0], dels[-1]
+
+        # If we are a section tag
+        elif tag_type in ["section", "inverted section"]:
+            # Then open a new section
+            open_sections.append(tag_key)
+            _LAST_TAG_LINE = _CURRENT_LINE
+
+        # If we are an end tag
+        elif tag_type == "end":
+            # Then check to see if the last opened section
+            # is the same as us
+            try:
+                last_section = open_sections.pop()
+            except IndexError as e:
+                msg = f'Trying to close tag "{tag_key}"\n' "Looks like it was not opened.\n" f"line {_CURRENT_LINE + 1}"
+                raise ChevronError(msg) from e
+            if tag_key != last_section:
+                # Otherwise we need to complain
+                msg = (
+                    f'Trying to close tag "{tag_key}"\n'
+                    f'last open tag is "{last_section}"\n'
+                    f"line {_CURRENT_LINE + 1}"
+                )
+                raise ChevronError(msg)
+
+        # Do the second check to see if we're a standalone
+        is_standalone = r_sa_check(template, tag_type, is_standalone)
+
+        # Which if we are
+        if is_standalone:
+            # Remove the stuff before the newline
+            template = template.split("\n", 1)[-1]
+
+            # Partials need to keep the spaces on their left
+            if tag_type != "partial":
+                # But other tags don't
+                literal = literal.rstrip(" ")
+
+        # Start yielding
+        # Ignore literals that are empty
+        if literal != "":
+            yield ("literal", literal)
+
+        # Ignore comments and set delimiters
+        if tag_type not in ["comment", "set delimiter?"]:
+            yield (tag_type, tag_key)
+
+    # If there are any open sections when we're done
+    if open_sections:
+        # Then we need to complain
+        msg = (
+            "Unexpected EOF\n"
+            f'the tag "{open_sections[-1]}" was never closed\n'
+            f"was opened at line {_LAST_TAG_LINE}"
+        )
+        raise ChevronError(msg)
+
+
+#
+# Helper functions
+#
+
+
+def _html_escape(string: str) -> str:
+    """HTML escape all of these " & < >"""
+
+    html_codes = {
+        '"': "&quot;",
+        "<": "&lt;",
+        ">": "&gt;",
+    }
+
+    # & must be handled first
+    string = string.replace("&", "&amp;")
+    for char in html_codes:
+        string = string.replace(char, html_codes[char])
+    return string
+
+
+def _get_key(
+    key: str,
+    scopes: Scopes,
+    warn: bool,
+    keep: bool,
+    def_ldel: str,
+    def_rdel: str,
+) -> Any:
+    """Get a key from the current scope"""
+
+    # If the key is a dot
+    if key == ".":
+        # Then just return the current scope
+        return scopes[0]
+
+    # Loop through the scopes
+    for scope in scopes:
+        try:
+            # Return an empty string if falsy, with two exceptions
+            # 0 should return 0, and False should return False
+            if scope in (0, False):
+                return scope
+
+            # For every dot separated key
+            for child in key.split("."):
+                # Return an empty string if falsy, with two exceptions
+                # 0 should return 0, and False should return False
+                if scope in (0, False):
+                    return scope
+                # Move into the scope
+                try:
+                    # Try subscripting (Normal dictionaries)
+                    scope = cast(Dict[str, Any], scope)[child]
+                except (TypeError, AttributeError):
+                    try:
+                        scope = getattr(scope, child)
+                    except (TypeError, AttributeError):
+                        # Try as a list
+                        scope = scope[int(child)]  # type: ignore
+
+            try:
+                # This allows for custom falsy data types
+                # https://github.com/noahmorrison/chevron/issues/35
+                if scope._CHEVRON_return_scope_when_falsy:  # type: ignore
+                    return scope
+            except AttributeError:
+                if scope in (0, False):
+                    return scope
+                return scope or ""
+        except (AttributeError, KeyError, IndexError, ValueError):
+            # We couldn't find the key in the current scope
+            # We'll try again on the next pass
+            pass
+
+    # We couldn't find the key in any of the scopes
+
+    if warn:
+        logger.warn(f"Could not find key '{key}'")
+
+    if keep:
+        return f"{def_ldel} {key} {def_rdel}"
+
+    return ""
+
+
+def _get_partial(name: str, partials_dict: Mapping[str, str]) -> str:
+    """Load a partial"""
+    try:
+        # Maybe the partial is in the dictionary
+        return partials_dict[name]
+    except KeyError:
+        return ""
+
+
+#
+# The main rendering function
+#
+g_token_cache: Dict[str, List[tuple[str, str]]] = {}
+
+EMPTY_DICT: MappingProxyType[str, str] = MappingProxyType({})
+
+
+def render(
+    template: Union[str, List[tuple[str, str]]] = "",
+    data: Mapping[str, Any] = EMPTY_DICT,
+    partials_dict: Mapping[str, str] = EMPTY_DICT,
+    padding: str = "",
+    def_ldel: str = "{{",
+    def_rdel: str = "}}",
+    scopes: Optional[Scopes] = None,
+    warn: bool = False,
+    keep: bool = False,
+) -> str:
+    """Render a mustache template.
+
+    Renders a mustache template with a data scope and inline partial capability.
+
+    Arguments:
+
+    template      -- A file-like object or a string containing the template.
+
+    data          -- A python dictionary with your data scope.
+
+    partials_path -- The path to where your partials are stored.
+                     If set to None, then partials won't be loaded from the file system
+                     (defaults to '.').
+
+    partials_ext  -- The extension that you want the parser to look for
+                     (defaults to 'mustache').
+
+    partials_dict -- A python dictionary which will be search for partials
+                     before the filesystem is. {'include': 'foo'} is the same
+                     as a file called include.mustache
+                     (defaults to {}).
+
+    padding       -- This is for padding partials, and shouldn't be used
+                     (but can be if you really want to).
+
+    def_ldel      -- The default left delimiter
+                     ("{{" by default, as in spec compliant mustache).
+
+    def_rdel      -- The default right delimiter
+                     ("}}" by default, as in spec compliant mustache).
+
+    scopes        -- The list of scopes that get_key will look through.
+
+    warn          -- Log a warning when a template substitution isn't found in the data
+
+    keep          -- Keep unreplaced tags when a substitution isn't found in the data.
+
+
+    Returns:
+
+    A string containing the rendered template.
+    """
+
+    # If the template is a sequence but not derived from a string
+    if isinstance(template, Sequence) and not isinstance(template, str):
+        # Then we don't need to tokenize it
+        # But it does need to be a generator
+        tokens: Iterator[tuple[str, str]] = (token for token in template)
+    else:
+        if template in g_token_cache:
+            tokens = (token for token in g_token_cache[template])
+        else:
+            # Otherwise make a generator
+            tokens = tokenize(template, def_ldel, def_rdel)
+
+    output = ""
+
+    if scopes is None:
+        scopes = [data]
+
+    # Run through the tokens
+    for tag, key in tokens:
+        # Set the current scope
+        current_scope = scopes[0]
+
+        # If we're an end tag
+        if tag == "end":
+            # Pop out of the latest scope
+            del scopes[0]
+
+        # If the current scope is falsy and not the only scope
+        elif not current_scope and len(scopes) != 1:
+            if tag in ["section", "inverted section"]:
+                # Set the most recent scope to a falsy value
+                scopes.insert(0, False)
+
+        # If we're a literal tag
+        elif tag == "literal":
+            # Add padding to the key and add it to the output
+            output += key.replace("\n", "\n" + padding)
+
+        # If we're a variable tag
+        elif tag == "variable":
+            # Add the html escaped key to the output
+            thing = _get_key(key, scopes, warn=warn, keep=keep, def_ldel=def_ldel, def_rdel=def_rdel)
+            if thing is True and key == ".":
+                # if we've coerced into a boolean by accident
+                # (inverted tags do this)
+                # then get the un-coerced object (next in the stack)
+                thing = scopes[1]
+            if not isinstance(thing, str):
+                thing = str(thing)
+            output += _html_escape(thing)
+
+        # If we're a no html escape tag
+        elif tag == "no escape":
+            # Just lookup the key and add it
+            thing = _get_key(key, scopes, warn=warn, keep=keep, def_ldel=def_ldel, def_rdel=def_rdel)
+            if not isinstance(thing, str):
+                thing = str(thing)
+            output += thing
+
+        # If we're a section tag
+        elif tag == "section":
+            # Get the sections scope
+            scope = _get_key(key, scopes, warn=warn, keep=keep, def_ldel=def_ldel, def_rdel=def_rdel)
+
+            # If the scope is a callable (as described in
+            # https://mustache.github.io/mustache.5.html)
+            if callable(scope):
+                # Generate template text from tags
+                text = ""
+                tags: List[tuple[str, str]] = []
+                for token in tokens:
+                    if token == ("end", key):
+                        break
+
+                    tags.append(token)
+                    tag_type, tag_key = token
+                    if tag_type == "literal":
+                        text += tag_key
+                    elif tag_type == "no escape":
+                        text += f"{def_ldel}& {tag_key} {def_rdel}"
+                    else:
+                        text += "{}{} {}{}".format(
+                            def_ldel,
+                            {
+                                "comment": "!",
+                                "section": "#",
+                                "inverted section": "^",
+                                "end": "/",
+                                "partial": ">",
+                                "set delimiter": "=",
+                                "no escape": "&",
+                                "variable": "",
+                            }[tag_type],
+                            tag_key,
+                            def_rdel,
+                        )
+
+                g_token_cache[text] = tags
+
+                rend = scope(
+                    text,
+                    lambda template, data=None: render(
+                        template,
+                        data={},
+                        partials_dict=partials_dict,
+                        padding=padding,
+                        def_ldel=def_ldel,
+                        def_rdel=def_rdel,
+                        scopes=data and [data] + scopes or scopes,
+                        warn=warn,
+                        keep=keep,
+                    ),
+                )
+
+                output += rend  # type: ignore[reportOperatorIssue]
+
+            # If the scope is a sequence, an iterator or generator but not
+            # derived from a string
+            elif isinstance(scope, (Sequence, Iterator)) and not isinstance(scope, str):
+                # Then we need to do some looping
+
+                # Gather up all the tags inside the section
+                # (And don't be tricked by nested end tags with the same key)
+                # TODO: This feels like it still has edge cases, no?
+                tags = []
+                tags_with_same_key = 0
+                for token in tokens:
+                    if token == ("section", key):
+                        tags_with_same_key += 1
+                    if token == ("end", key):
+                        tags_with_same_key -= 1
+                        if tags_with_same_key < 0:
+                            break
+                    tags.append(token)
+
+                # For every item in the scope
+                for thing in scope:
+                    # Append it as the most recent scope and render
+                    new_scope = [thing] + scopes
+                    rend = render(
+                        template=tags,
+                        scopes=new_scope,
+                        padding=padding,
+                        partials_dict=partials_dict,
+                        def_ldel=def_ldel,
+                        def_rdel=def_rdel,
+                        warn=warn,
+                        keep=keep,
+                    )
+
+                    output += rend
+
+            else:
+                # Otherwise we're just a scope section
+                scopes.insert(0, scope)  # type: ignore[reportArgumentType]
+
+        # If we're an inverted section
+        elif tag == "inverted section":
+            # Add the flipped scope to the scopes
+            scope = _get_key(key, scopes, warn=warn, keep=keep, def_ldel=def_ldel, def_rdel=def_rdel)
+            scopes.insert(0, cast(Literal[False], not scope))
+
+        # If we're a partial
+        elif tag == "partial":
+            # Load the partial
+            partial = _get_partial(key, partials_dict)
+
+            # Find what to pad the partial with
+            left = output.rpartition("\n")[2]
+            part_padding = padding
+            if left.isspace():
+                part_padding += left
+
+            # Render the partial
+            part_out = render(
+                template=partial,
+                partials_dict=partials_dict,
+                def_ldel=def_ldel,
+                def_rdel=def_rdel,
+                padding=part_padding,
+                scopes=scopes,
+                warn=warn,
+                keep=keep,
+            )
+
+            # If the partial was indented
+            if left.isspace():
+                # then remove the spaces from the end
+                part_out = part_out.rstrip(" \t")
+
+            # Add the partials output to the output
+            output += part_out
+
+    return output

prompty/renderers.py

@@ -2,6 +2,7 @@ import typing
 from pathlib import Path
 
 from jinja2 import DictLoader, Environment
+from .mustache import render
 
 from .core import Prompty
 from .invoker import Invoker
@@ -49,3 +50,35 @@ class Jinja2Renderer(Invoker):
             The parsed data
         """
         return self.invoke(data)
+
+
+class MustacheRenderer(Invoker):
+    """Render a mustache template."""
+
+    def __init__(self, prompty: Prompty) -> None:
+        super().__init__(prompty)
+        self.templates = {}
+        cur_prompt: typing.Union[Prompty, None] = self.prompty
+        while cur_prompt:
+            self.templates[Path(cur_prompt.file).name] = cur_prompt.content
+            cur_prompt = cur_prompt.basePrompty
+        self.name = Path(self.prompty.file).name
+
+    def invoke(self, data: str) -> str:
+        generated = render(self.prompty.content, data)  # type: ignore
+        return generated
+
+    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
+        """
+        return self.invoke(data)

prompty/tracer.py

@@ -5,14 +5,13 @@ import json
 import os
 import traceback
 from collections.abc import Iterator
+from dataclasses import asdict, is_dataclass
 from datetime import datetime
 from functools import partial, wraps
 from numbers import Number
 from pathlib import Path
 from typing import Any, Callable, Union
 
-from pydantic import BaseModel
-
 
 # clean up key value pairs for sensitive values
 def sanitize(key: str, value: Any) -> Any:
@@ -83,15 +82,17 @@ def to_dict(obj: Any) -> Any:
         return obj.isoformat()
     # safe Prompty obj serialization
     elif type(obj).__name__ == "Prompty":
-        return obj.to_safe_dict()
+        obj_dict = asdict(obj)
+        if "model" in obj_dict and "configuration" in obj_dict["model"]:
+            obj_dict["model"]["configuration"] = sanitize("configuration", obj_dict["model"]["configuration"])
+        return obj_dict
     # safe PromptyStream obj serialization
     elif type(obj).__name__ == "PromptyStream":
         return "PromptyStream"
+    elif is_dataclass(obj) and not isinstance(obj, type):
+        return asdict(obj)
     elif type(obj).__name__ == "AsyncPromptyStream":
         return "AsyncPromptyStream"
-    # pydantic models have their own json serialization
-    elif isinstance(obj, BaseModel):
-        return obj.model_dump()
     # recursive list and dict
     elif isinstance(obj, list):
         return [to_dict(item) for item in obj]

prompty/utils.py

@@ -37,14 +37,15 @@ def _find_global_config(prompty_path: Path = Path.cwd()) -> typing.Union[Path, N
     prompty_config = list(Path.cwd().glob("**/prompty.json"))
 
     if len(prompty_config) > 0:
-        return sorted(
+        sorted_list = sorted(
             [
                 c
                 for c in prompty_config
                 if len(c.parent.parts) <= len(prompty_path.parts)
             ],
             key=lambda p: len(p.parts),
-        )[-1]
+        )
+        return sorted_list[-1] if len(sorted_list) > 0 else None
     else:
         return None
 

{prompty-0.1.47.dist-info → prompty-0.1.49.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: prompty
-Version: 0.1.47
+Version: 0.1.49
 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
@@ -9,7 +9,6 @@ Project-URL: Documentation, https://prompty.ai/docs
 Project-URL: Issues, https://github.com/microsoft/prompty/issues
 Requires-Python: >=3.9
 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
@@ -38,16 +37,17 @@ Examples prompty file:
 ```markdown
 ---
 name: Basic Prompt
-description: A basic prompt that uses the GPT-3 chat API to answer questions
+description: A basic prompt that uses the gpt-3.5-turbo chat API to answer questions
 authors:
   - sethjuarez
   - jietong
 model:
   api: chat
   configuration:
-    api_version: 2023-12-01-preview
+    api_version: 2024-10-21
     azure_endpoint: ${env:AZURE_OPENAI_ENDPOINT}
     azure_deployment: ${env:AZURE_OPENAI_DEPLOYMENT:gpt-35-turbo}
+    type: azure_openai
 sample:
   firstName: Jane
   lastName: Doe
@@ -77,7 +77,7 @@ Download the [VS Code extension here](https://marketplace.visualstudio.com/items
 The Python runtime is a simple way to run your prompts in Python. The runtime is available as a Python package and can be installed using pip. Depending on the type of prompt you are running, you may need to install additional dependencies. The runtime is designed to be extensible and can be customized to fit your needs.
 
 ```bash
-pip install prompty[azure]
+pip install "prompty[azure]"
 ```
 
 Simple usage example:

{prompty-0.1.47.dist-info → prompty-0.1.49.dist-info}/RECORD

@@ -1,25 +1,26 @@
-prompty-0.1.47.dist-info/METADATA,sha256=y57CPZ76O6m2Z2mDU-eM9iY_5fI6nCXTqoKQ3gZFHAE,9343
-prompty-0.1.47.dist-info/WHEEL,sha256=thaaA2w1JzcGC48WYufAs8nrYZjJm8LqNfnXFOFyCC4,90
-prompty-0.1.47.dist-info/entry_points.txt,sha256=a3i7Kvf--3DOkkv9VQpstwaNKgsnXwDGaPL18lPpKeI,60
-prompty-0.1.47.dist-info/licenses/LICENSE,sha256=KWSC4z9cfML_t0xThoQYjzTdcZQj86Y_mhXdatzU-KM,1052
-prompty/__init__.py,sha256=geIhhprDhbqqkj5jQhy3Nv_b83T38VhleEUfB7Xkd4U,16861
+prompty-0.1.49.dist-info/METADATA,sha256=me6Z8gphAgWMs0lfuSOjf7E2afCeNCI_y_-5mkxO_9k,9337
+prompty-0.1.49.dist-info/WHEEL,sha256=thaaA2w1JzcGC48WYufAs8nrYZjJm8LqNfnXFOFyCC4,90
+prompty-0.1.49.dist-info/entry_points.txt,sha256=a3i7Kvf--3DOkkv9VQpstwaNKgsnXwDGaPL18lPpKeI,60
+prompty-0.1.49.dist-info/licenses/LICENSE,sha256=KWSC4z9cfML_t0xThoQYjzTdcZQj86Y_mhXdatzU-KM,1052
+prompty/__init__.py,sha256=Nq49LsDwe8smD51MLsjGDlk6soc3knKoXkAmdUJNibA,16937
 prompty/azure/__init__.py,sha256=zBxzOMQCwtiz2CsI8gNWzr7T2ZJHF3TZNIUtvfuaEQI,309
 prompty/azure/executor.py,sha256=MWeBwprLY2NmPySoOq-K3qMui5lPlMYMh5ktb3S7mgo,9367
 prompty/azure/processor.py,sha256=gNmUkPBoSLPE0t7IVJUxGdwZ2otiycDE4Fu6L1vurZI,5330
 prompty/azure_beta/__init__.py,sha256=-LPrqoAv2UGI29SUjiZCkPlAGARvixlYe2IW1edswWo,375
 prompty/azure_beta/executor.py,sha256=bARyO2k42ZQfd5NrNKyMUd7JZ2Rcm8urUP0sJ1P1Qxk,10157
-prompty/cli.py,sha256=7aDL8Lup5EONizwn1zQUhGq9vk6z62EA0lpdf80Ybdk,4836
-prompty/core.py,sha256=kAREbThLiVUikvikZX27riW0jJKIldkLusidzmdOftg,13070
+prompty/cli.py,sha256=x4t5pkjLmSppxbwHmv0WZ5OMJ8hz6z48RuahMF9WDQc,4858
+prompty/core.py,sha256=cy2KoQgruk01Aaz34pUxJz4qLJOAt_1CLhU7-PhxhhU,12118
 prompty/invoker.py,sha256=ARmyVkinm_Nk91k8mRlsDffox7MtGSVLpwNycavMSSI,9028
+prompty/mustache.py,sha256=VSo9zlMlbOPIa5TSH7MKRQi7i67SgeHz0-ymFrHubaA,20751
 prompty/openai/__init__.py,sha256=aRdXZ5pL4tURFqRwVX7gNdVy3PPWE6BvUbK1o73AqQc,303
 prompty/openai/executor.py,sha256=v5K8kDpGUsbtTpCb1hOVxPt7twX2p-a5yL2iC3Xm8TQ,3752
 prompty/openai/processor.py,sha256=X6yfSlHoTgXxCfGvUwADACjNtzLMNumcn0SX3U4T9as,2542
 prompty/parsers.py,sha256=ptET4j8Rf55Ob0uOx6A41nlQ6cwo1CHRytSjeMIp6JE,5083
 prompty/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-prompty/renderers.py,sha256=UMgJOjcAWd8LXX1ynXEdT4i9bqEAaJkeFp6KOD74lqU,1453
+prompty/renderers.py,sha256=jidLNr85HRPyevCi7ObTZvsIcLmZ_CB0NTGDNqf1SdU,2376
 prompty/serverless/__init__.py,sha256=ILtbqhy6E-wWodbnq-_aftruTGk1Z0EI9zURFH4FECM,297
 prompty/serverless/executor.py,sha256=QZXeFTXv_aT22rbBBgBFLtdAJqGp4W8GS3H3Rtoy8bE,8936
 prompty/serverless/processor.py,sha256=d42MalWRf8RUpHRiueqAPAj_nGmJSMUE2yL-Tgxrss4,3754
-prompty/tracer.py,sha256=jM2nQ7Cb-tSb7wog9w9QzhmB1IGwYb0B0-TBClZOn_A,11980
-prompty/utils.py,sha256=P9nW0QfY1F5PM4pLxsFVlnul1BaRBatmvC2tpqydPKQ,2836
-prompty-0.1.47.dist-info/RECORD,,
+prompty/tracer.py,sha256=GYJsFfsF5uexv1RANENX_Xm5sOnIcQHT_LLAtr6JocU,12158
+prompty/utils.py,sha256=0EmzWgRWPe6IgHOzoIy0k4_BMDUN4FHo0iITD-g1Ny8,2904
+prompty-0.1.49.dist-info/RECORD,,