prompty 0.1.10__py3-none-any.whl → 0.1.33__py3-none-any.whl

prompty/__init__.py

@@ -1,51 +1,24 @@
-import json
 import traceback
 from pathlib import Path
 from typing import Dict, List, Union
-
 from .tracer import trace
+from .invoker import InvokerFactory, NoOp
 from .core import (
-    Frontmatter,
-    InvokerFactory,
     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 *
-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 {}
 
 
 @trace(description="Create a headless prompty object for programmatic use.")
@@ -105,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"] = {}
 
@@ -197,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
     ----------
@@ -260,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,
@@ -323,22 +421,65 @@ def run(
     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?
+    result = InvokerFactory.run_executor(prompt, content)
     if not raw:
-        # process
-        processor = InvokerFactory.create_processor(
-            prompt.model.configuration["type"], prompt
+        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.
+
+    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
         )
-        result = processor(result)
+
+    if parameters != {}:
+        prompt.model.parameters = param_hoisting(parameters, prompt.model.parameters)
+
+    result = await InvokerFactory.run_executor_async(prompt, content)
+    if not raw:
+        result = await InvokerFactory.run_processor_async(prompt, result)
 
     return result
 
+
 @trace(description="Execute a prompty")
 def execute(
     prompt: Union[str, Prompty],
@@ -346,7 +487,7 @@ def execute(
     parameters: Dict[str, any] = {},
     inputs: Dict[str, any] = {},
     raw: bool = False,
-    connection: str = "default",
+    config_name: str = "default",
 ):
     """Execute a prompty.
 
@@ -382,7 +523,7 @@ def execute(
             # 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)
+        prompt = load(path, config_name)
 
     # prepare content
     content = prepare(prompt, inputs)
@@ -391,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/azure/__init__.py

@@ -0,0 +1,10 @@
+# __init__.py
+from prompty.invoker import InvokerException
+
+try:
+    from .executor import AzureOpenAIExecutor
+    from .processor import AzureOpenAIProcessor
+except ImportError:
+    raise InvokerException(
+        "Error registering AzureOpenAIExecutor and AzureOpenAIProcessor", "azure"
+    )