prompty 0.1.24__tar.gz → 0.1.33__tar.gz

{prompty-0.1.24 → prompty-0.1.33}/PKG-INFO

@@ -1,20 +1,23 @@
 Metadata-Version: 2.1
 Name: prompty
-Version: 0.1.24
+Version: 0.1.33
 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: python-dotenv>=1.0.1
 Requires-Dist: click>=8.1.7
+Requires-Dist: aiofiles>=24.1.0
+Provides-Extra: azure
 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
+Requires-Dist: openai>=1.35.10; extra == "openai"
 Provides-Extra: serverless
+Requires-Dist: azure-ai-inference>=1.0.0b3; extra == "serverless"
 Description-Content-Type: text/markdown
 
 

{prompty-0.1.24 → prompty-0.1.33}/prompty/__init__.py

@@ -1,52 +1,26 @@
-import json
 import traceback
 from pathlib import Path
 from typing import Dict, List, Union
-
-from prompty.tracer import trace
-from prompty.core import (
-    Frontmatter,
-    InvokerException,
-    InvokerFactory,
+from .tracer import trace
+from .invoker import InvokerFactory, NoOp
+from .core import (
     ModelSettings,
     Prompty,
     PropertySettings,
     TemplateSettings,
     param_hoisting,
 )
+from .utils import (
+    load_global_config,
+    load_global_config_async,
+    load_prompty_async,
+    load_prompty,
+)
 
 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,
@@ -104,47 +78,65 @@ def headless(
     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.
+@trace(description="Create a headless prompty object for programmatic use.")
+async def headless_async(
+    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
     ----------
-    prompty_file : str
-        The path to the prompty file
-    configuration : str, optional
-        The configuration to use, by default "default"
+    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 loaded prompty object
+        The headless prompty object
 
     Example
     -------
     >>> import prompty
-    >>> p = prompty.load("prompts/basic.prompty")
-    >>> print(p)
-    """
+    >>> p = await prompty.headless_async(
+            api="embedding",
+            configuration={"type": "azure", "azure_deployment": "text-embedding-ada-002"},
+            content="hello world",
+        )
+    >>> emb = prompty.execute(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"]
+    # get caller's path (to get relative path for prompty.json)
+    caller = Path(traceback.extract_stack()[-2].filename)
+    templateSettings = TemplateSettings(type="NOOP", parser="NOOP")
 
-    # normalize attribute dictionary resolve keys and files
-    attributes = Prompty.normalize(attributes, p.parent)
+    global_config = await load_global_config_async(caller.parent, connection)
+    c = await Prompty.normalize_async(
+        param_hoisting(configuration, global_config), caller.parent
+    )
 
-    # load global configuration
-    global_config = Prompty.normalize(
-        load_global_config(p.parent, configuration), p.parent
+    modelSettings = ModelSettings(
+        api=api,
+        configuration=c,
+        parameters=parameters,
     )
+
+    return Prompty(model=modelSettings, template=templateSettings, content=content)
+
+
+def _load_raw_prompty(attributes: dict, content: str, p: Path, global_config: dict):
     if "model" not in attributes:
         attributes["model"] = {}
 
@@ -196,47 +188,132 @@ def load(prompty_file: str, configuration: str = "default") -> Prompty:
     else:
         outputs = {}
 
+    p = Prompty(
+        **attributes,
+        model=model,
+        inputs=inputs,
+        outputs=outputs,
+        template=template,
+        content=content,
+        file=p,
+    )
+
+    return p
+
+
+@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 = load_prompty(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
+    )
+
+    prompty = _load_raw_prompty(attributes, content, p, global_config)
+
     # 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
+        prompty = Prompty.hoist_base_prompty(prompty, base)
+
+    return prompty
+
+
+@trace(description="Load a prompty file.")
+async def load_async(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 = await load_prompty_async(p)
+
+    attributes = matter["attributes"]
+    content = matter["body"]
+
+    # normalize attribute dictionary resolve keys and files
+    attributes = await Prompty.normalize_async(attributes, p.parent)
+
+    # load global configuration
+    config = await load_global_config_async(p.parent, configuration)
+    global_config = await Prompty.normalize_async(config, p.parent)
+
+    prompty = _load_raw_prompty(attributes, content, p, global_config)
+
+    # recursive loading of base prompty
+    if "base" in attributes:
+        # load the base prompty from the same directory as the current prompty
+        base = await load_async(p.parent / attributes["base"])
+        prompty = Prompty.hoist_base_prompty(prompty, base)
+
+    return prompty
+
 
 @trace(description="Prepare the inputs for the prompt.")
 def prepare(
     prompt: Prompty,
     inputs: Dict[str, any] = {},
 ):
-    """ Prepare the inputs for the prompt.
+    """Prepare the inputs for the prompt.
 
     Parameters
     ----------
@@ -259,24 +336,46 @@ def prepare(
     """
     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)
+    render = InvokerFactory.run_renderer(prompt, inputs, prompt.content)
+    result = InvokerFactory.run_parser(prompt, render)
 
-    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="Prepare the inputs for the prompt.")
+async def prepare_async(
+    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 = await prompty.prepare_async(p, inputs)
+    """
+    inputs = param_hoisting(inputs, prompt.sample)
+
+    render = await InvokerFactory.run_renderer_async(prompt, inputs, prompt.content)
+    result = await InvokerFactory.run_parser_async(prompt, render)
 
     return result
 
+
 @trace(description="Run the prepared Prompty content against the model.")
 def run(
     prompt: Prompty,
@@ -322,32 +421,65 @@ def run(
     if parameters != {}:
         prompt.model.parameters = param_hoisting(parameters, prompt.model.parameters)
 
-    invoker_type = prompt.model.configuration["type"]
+    result = InvokerFactory.run_executor(prompt, content)
+    if not raw:
+        result = InvokerFactory.run_processor(prompt, result)
+
+    return result
+
+
+@trace(description="Run the prepared Prompty content against the model.")
+async def run_async(
+    prompt: Prompty,
+    content: dict | list | str,
+    configuration: Dict[str, any] = {},
+    parameters: Dict[str, any] = {},
+    raw: bool = False,
+):
+    """Run the prepared Prompty content.
 
-    # invoker registration check
-    if not InvokerFactory.has_invoker("executor", invoker_type):
-        raise InvokerException(
-            f"{invoker_type} Invoker has not been registered properly.", invoker_type
+    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 = await prompty.prepare_async(p, inputs)
+    >>> result = await prompty.run_async(p, content)
+    """
+
+    if configuration != {}:
+        prompt.model.configuration = param_hoisting(
+            configuration, prompt.model.configuration
         )
 
-    # execute
-    executor = InvokerFactory.create_executor(invoker_type, prompt)
-    result = executor(content)
+    if parameters != {}:
+        prompt.model.parameters = param_hoisting(parameters, prompt.model.parameters)
 
-    # skip?
+    result = await InvokerFactory.run_executor_async(prompt, content)
     if not raw:
-        # invoker registration check
-        if not InvokerFactory.has_invoker("processor", invoker_type):
-            raise InvokerException(
-                f"{invoker_type} Invoker has not been registered properly.", invoker_type
-            )
-        
-        # process
-        processor = InvokerFactory.create_processor(invoker_type, prompt)
-        result = processor(result)
+        result = await InvokerFactory.run_processor_async(prompt, result)
 
     return result
 
+
 @trace(description="Execute a prompty")
 def execute(
     prompt: Union[str, Prompty],
@@ -400,3 +532,57 @@ def execute(
     result = run(prompt, content, configuration, parameters, raw)
 
     return result
+
+
+@trace(description="Execute a prompty")
+async def execute_async(
+    prompt: Union[str, Prompty],
+    configuration: Dict[str, any] = {},
+    parameters: Dict[str, any] = {},
+    inputs: Dict[str, any] = {},
+    raw: bool = False,
+    config_name: 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 = await prompty.execute_async("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 = await load_async(path, config_name)
+
+    # prepare content
+    content = await prepare_async(prompt, inputs)
+
+    # run LLM model
+    result = await run_async(prompt, content, configuration, parameters, raw)
+
+    return result

{prompty-0.1.24 → prompty-0.1.33}/prompty/azure/__init__.py

@@ -1,5 +1,5 @@
 # __init__.py
-from prompty.core import InvokerException
+from prompty.invoker import InvokerException
 
 try:
     from .executor import AzureOpenAIExecutor

{prompty-0.1.24 → prompty-0.1.33}/prompty/azure/executor.py

@@ -1,10 +1,11 @@
 import azure.identity
 import importlib.metadata
-from typing import Iterator
-from openai import AzureOpenAI
+from typing import AsyncIterator, Iterator
+from openai import AzureOpenAI, AsyncAzureOpenAI
 
 from prompty.tracer import Tracer
-from ..core import Invoker, InvokerFactory, Prompty, PromptyStream
+from ..core import AsyncPromptyStream, Prompty, PromptyStream
+from ..invoker import Invoker, InvokerFactory
 
 VERSION = importlib.metadata.version("prompty")
 
@@ -130,3 +131,88 @@ class AzureOpenAIExecutor(Invoker):
                 return PromptyStream("AzureOpenAIExecutor", response)
         else:
             return response
+
+    async def invoke_async(self, data: str) -> str:
+        """Invoke the Prompty Chat Parser (Async)
+
+        Parameters
+        ----------
+        data : str
+            The data to parse
+
+        Returns
+        -------
+        str
+            The parsed data
+        """
+        with Tracer.start("AzureOpenAIAsync") as trace:
+            trace("type", "LLM")
+            trace("signature", "AzureOpenAIAsync.ctor")
+            trace("description", "Async Azure OpenAI Constructor")
+            trace("inputs", self.kwargs)
+            client = AsyncAzureOpenAI(
+                default_headers={
+                    "User-Agent": f"prompty/{VERSION}",
+                    "x-ms-useragent": f"prompty/{VERSION}",
+                },
+                **self.kwargs,
+            )
+            trace("result", client)
+
+        with Tracer.start("create") as trace:
+            trace("type", "LLM")
+            trace("description", "Azure OpenAI Client")
+
+            if self.api == "chat":
+                trace("signature", "AzureOpenAIAsync.chat.completions.create")
+                args = {
+                    "model": self.deployment,
+                    "messages": data if isinstance(data, list) else [data],
+                    **self.parameters,
+                }
+                trace("inputs", args)
+                response = await client.chat.completions.create(**args)
+                trace("result", response)
+
+            elif self.api == "completion":
+                trace("signature", "AzureOpenAIAsync.completions.create")
+                args = {
+                    "prompt": data,
+                    "model": self.deployment,
+                    **self.parameters,
+                }
+                trace("inputs", args)
+                response = await client.completions.create(**args)
+                trace("result", response)
+
+            elif self.api == "embedding":
+                trace("signature", "AzureOpenAIAsync.embeddings.create")
+                args = {
+                    "input": data if isinstance(data, list) else [data],
+                    "model": self.deployment,
+                    **self.parameters,
+                }
+                trace("inputs", args)
+                response = await client.embeddings.create(**args)
+                trace("result", response)
+
+            elif self.api == "image":
+                trace("signature", "AzureOpenAIAsync.images.generate")
+                args = {
+                    "prompt": data,
+                    "model": self.deployment,
+                    **self.parameters,
+                }
+                trace("inputs", args)
+                response = await client.images.generate.create(**args)
+                trace("result", response)
+
+        # stream response
+        if isinstance(response, AsyncIterator):
+            if self.api == "chat":
+                # TODO: handle the case where there might be no usage in the stream
+                return AsyncPromptyStream("AzureOpenAIExecutorAsync", response)
+            else:
+                return AsyncPromptyStream("AzureOpenAIExecutorAsync", response)
+        else:
+            return response