prompty 0.1.40__py3-none-any.whl → 0.1.45__py3-none-any.whl

prompty/core.py

@@ -1,12 +1,13 @@
-from __future__ import annotations
-
 import os
+import typing
+from collections.abc import AsyncIterator, Iterator
 from pathlib import Path
+from typing import Literal, Union
 
-from .tracer import Tracer, to_dict, sanitize
 from pydantic import BaseModel, Field, FilePath
-from typing import AsyncIterator, Iterator, List, Literal, Dict, Callable, Set, Tuple
+from pydantic.main import IncEx
 
+from .tracer import Tracer, sanitize, to_dict
 from .utils import load_json, load_json_async
 
 
@@ -30,7 +31,7 @@ class PropertySettings(BaseModel):
     """
 
     type: Literal["string", "number", "array", "object", "boolean"]
-    default: str | int | float | List | dict | bool = Field(default=None)
+    default: Union[str, int, float, list, dict, bool, None] = Field(default=None)
     description: str = Field(default="")
 
 
@@ -58,21 +59,19 @@ class ModelSettings(BaseModel):
         self,
         *,
         mode: str = "python",
-        include: (
-            Set[int] | Set[str] | Dict[int, os.Any] | Dict[str, os.Any] | None
-        ) = None,
-        exclude: (
-            Set[int] | Set[str] | Dict[int, os.Any] | Dict[str, os.Any] | None
-        ) = None,
-        context: os.Any | None = None,
+        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: bool | Literal["none"] | Literal["warn"] | Literal["error"] = True,
+        warnings: Union[
+            bool, Literal["none"], Literal["warn"], Literal["error"]
+        ] = True,
         serialize_as_any: bool = False,
-    ) -> Dict[str, os.Any]:
+    ) -> dict[str, typing.Any]:
         """Method to dump the model in a safe way"""
         d = super().model_dump(
             mode=mode,
@@ -145,11 +144,11 @@ class Prompty(BaseModel):
     # metadata
     name: str = Field(default="")
     description: str = Field(default="")
-    authors: List[str] = Field(default=[])
-    tags: List[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)
+    basePrompty: Union["Prompty", None] = Field(default=None)
     # model
     model: ModelSettings = Field(default_factory=ModelSettings)
 
@@ -157,19 +156,19 @@ class Prompty(BaseModel):
     sample: dict = Field(default={})
 
     # input / output
-    inputs: Dict[str, PropertySettings] = Field(default={})
-    outputs: Dict[str, PropertySettings] = Field(default={})
+    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="")
+    file: Union[str, FilePath] = Field(default="")
+    content: Union[str, list[str], dict] = Field(default="")
 
-    def to_safe_dict(self) -> Dict[str, any]:
+    def to_safe_dict(self) -> dict[str, typing.Any]:
         d = {}
         for k, v in self:
-            if v != "" and v != {} and v != [] and v != None:
+            if v != "" and v != {} and v != [] and v is not None:
                 if k == "model":
                     d[k] = v.model_dump()
                 elif k == "template":
@@ -191,7 +190,7 @@ class Prompty(BaseModel):
         return d
 
     @staticmethod
-    def hoist_base_prompty(top: Prompty, base: Prompty) -> Prompty:
+    def hoist_base_prompty(top: "Prompty", base: "Prompty") -> "Prompty":
         top.name = base.name if top.name == "" else top.name
         top.description = base.description if top.description == "" else top.description
         top.authors = list(set(base.authors + top.authors))
@@ -214,10 +213,10 @@ class Prompty(BaseModel):
         return top
 
     @staticmethod
-    def _process_file(file: str, parent: Path) -> any:
-        file = Path(parent / Path(file)).resolve().absolute()
-        if file.exists():
-            items = load_json(file)
+    def _process_file(file: str, parent: Path) -> typing.Any:
+        f = Path(parent / Path(file)).resolve().absolute()
+        if f.exists():
+            items = load_json(f)
             if isinstance(items, list):
                 return [Prompty.normalize(value, parent) for value in items]
             elif isinstance(items, dict):
@@ -231,10 +230,10 @@ class Prompty(BaseModel):
             raise FileNotFoundError(f"File {file} not found")
 
     @staticmethod
-    async def _process_file_async(file: str, parent: Path) -> any:
-        file = Path(parent / Path(file)).resolve().absolute()
-        if file.exists():
-            items = await load_json_async(file)
+    async def _process_file_async(file: str, parent: Path) -> typing.Any:
+        f = Path(parent / Path(file)).resolve().absolute()
+        if f.exists():
+            items = await load_json_async(f)
             if isinstance(items, list):
                 return [Prompty.normalize(value, parent) for value in items]
             elif isinstance(items, dict):
@@ -248,7 +247,9 @@ class Prompty(BaseModel):
             raise FileNotFoundError(f"File {file} not found")
 
     @staticmethod
-    def _process_env(variable: str, env_error=True, default: str = None) -> any:
+    def _process_env(
+        variable: str, env_error=True, default: Union[str, None] = None
+    ) -> typing.Any:
         if variable in os.environ.keys():
             return os.environ[variable]
         else:
@@ -260,7 +261,7 @@ class Prompty(BaseModel):
             return ""
 
     @staticmethod
-    def normalize(attribute: any, parent: Path, env_error=True) -> any:
+    def normalize(attribute: typing.Any, parent: Path, env_error=True) -> typing.Any:
         if isinstance(attribute, str):
             attribute = attribute.strip()
             if attribute.startswith("${") and attribute.endswith("}"):
@@ -289,7 +290,9 @@ class Prompty(BaseModel):
             return attribute
 
     @staticmethod
-    async def normalize_async(attribute: any, parent: Path, env_error=True) -> any:
+    async def normalize_async(
+        attribute: typing.Any, parent: Path, env_error=True
+    ) -> typing.Any:
         if isinstance(attribute, str):
             attribute = attribute.strip()
             if attribute.startswith("${") and attribute.endswith("}"):
@@ -319,14 +322,16 @@ class Prompty(BaseModel):
 
 
 def param_hoisting(
-    top: Dict[str, any], bottom: Dict[str, any], top_key: str = None
-) -> Dict[str, any]:
+    top: dict[str, typing.Any],
+    bottom: dict[str, typing.Any],
+    top_key: Union[str, None] = None,
+) -> dict[str, typing.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:
+        if key not in new_dict:
             new_dict[key] = value
     return new_dict
 
@@ -338,7 +343,7 @@ class PromptyStream(Iterator):
     def __init__(self, name: str, iterator: Iterator):
         self.name = name
         self.iterator = iterator
-        self.items: List[any] = []
+        self.items: list[typing.Any] = []
         self.__name__ = "PromptyStream"
 
     def __iter__(self):
@@ -370,7 +375,7 @@ class AsyncPromptyStream(AsyncIterator):
     def __init__(self, name: str, iterator: AsyncIterator):
         self.name = name
         self.iterator = iterator
-        self.items: List[any] = []
+        self.items: list[typing.Any] = []
         self.__name__ = "AsyncPromptyStream"
 
     def __aiter__(self):

prompty/invoker.py

@@ -1,7 +1,9 @@
 import abc
-from .tracer import trace
+import typing
+from typing import Callable, Literal
+
 from .core import Prompty
-from typing import Callable, Dict, Literal
+from .tracer import trace
 
 
 class Invoker(abc.ABC):
@@ -21,7 +23,7 @@ class Invoker(abc.ABC):
         self.name = self.__class__.__name__
 
     @abc.abstractmethod
-    def invoke(self, data: any) -> any:
+    def invoke(self, data: typing.Any) -> typing.Any:
         """Abstract method to invoke the invoker
 
         Parameters
@@ -37,7 +39,7 @@ class Invoker(abc.ABC):
         pass
 
     @abc.abstractmethod
-    async def invoke_async(self, data: any) -> any:
+    async def invoke_async(self, data: typing.Any) -> typing.Any:
         """Abstract method to invoke the invoker asynchronously
 
         Parameters
@@ -53,7 +55,7 @@ class Invoker(abc.ABC):
         pass
 
     @trace
-    def run(self, data: any) -> any:
+    def run(self, data: typing.Any) -> typing.Any:
         """Method to run the invoker
 
         Parameters
@@ -69,7 +71,7 @@ class Invoker(abc.ABC):
         return self.invoke(data)
 
     @trace
-    async def run_async(self, data: any) -> any:
+    async def run_async(self, data: typing.Any) -> typing.Any:
         """Method to run the invoker asynchronously
 
         Parameters
@@ -88,30 +90,31 @@ class Invoker(abc.ABC):
 class InvokerFactory:
     """Factory class for Invoker"""
 
-    _renderers: Dict[str, Invoker] = {}
-    _parsers: Dict[str, Invoker] = {}
-    _executors: Dict[str, Invoker] = {}
-    _processors: Dict[str, Invoker] = {}
+    _renderers: dict[str, type[Invoker]] = {}
+    _parsers: dict[str, type[Invoker]] = {}
+    _executors: dict[str, type[Invoker]] = {}
+    _processors: dict[str, type[Invoker]] = {}
 
     @classmethod
-    def add_renderer(cls, name: str, invoker: Invoker) -> None:
+    def add_renderer(cls, name: str, invoker: type[Invoker]) -> None:
         cls._renderers[name] = invoker
 
     @classmethod
-    def add_parser(cls, name: str, invoker: Invoker) -> None:
+    def add_parser(cls, name: str, invoker: type[Invoker]) -> None:
         cls._parsers[name] = invoker
 
     @classmethod
-    def add_executor(cls, name: str, invoker: Invoker) -> None:
+    def add_executor(cls, name: str, invoker: type[Invoker]) -> None:
         cls._executors[name] = invoker
 
     @classmethod
-    def add_processor(cls, name: str, invoker: Invoker) -> None:
+    def add_processor(cls, name: str, invoker: type[Invoker]) -> None:
         cls._processors[name] = invoker
 
     @classmethod
     def register_renderer(cls, name: str) -> Callable:
-        def inner_wrapper(wrapped_class: Invoker) -> Callable:
+
+        def inner_wrapper(wrapped_class: type[Invoker]) -> type[Invoker]:
             cls._renderers[name] = wrapped_class
             return wrapped_class
 
@@ -119,7 +122,8 @@ class InvokerFactory:
 
     @classmethod
     def register_parser(cls, name: str) -> Callable:
-        def inner_wrapper(wrapped_class: Invoker) -> Callable:
+
+        def inner_wrapper(wrapped_class: type[Invoker]) -> type[Invoker]:
             cls._parsers[name] = wrapped_class
             return wrapped_class
 
@@ -127,7 +131,8 @@ class InvokerFactory:
 
     @classmethod
     def register_executor(cls, name: str) -> Callable:
-        def inner_wrapper(wrapped_class: Invoker) -> Callable:
+
+        def inner_wrapper(wrapped_class: type[Invoker]) -> type[Invoker]:
             cls._executors[name] = wrapped_class
             return wrapped_class
 
@@ -135,7 +140,8 @@ class InvokerFactory:
 
     @classmethod
     def register_processor(cls, name: str) -> Callable:
-        def inner_wrapper(wrapped_class: Invoker) -> Callable:
+
+        def inner_wrapper(wrapped_class: type[Invoker]) -> type[Invoker]:
             cls._processors[name] = wrapped_class
             return wrapped_class
 
@@ -200,11 +206,11 @@ class InvokerFactory:
         cls,
         type: Literal["renderer", "parser", "executor", "processor"],
         prompty: Prompty,
-        data: any,
-        default: any = None,
+        data: typing.Any,
+        default: typing.Any = None,
     ):
         name = cls._get_name(type, prompty)
-        if name.startswith("NOOP") and default != None:
+        if name.startswith("NOOP") and default is not None:
             return default
         elif name.startswith("NOOP"):
             return data
@@ -218,11 +224,11 @@ class InvokerFactory:
         cls,
         type: Literal["renderer", "parser", "executor", "processor"],
         prompty: Prompty,
-        data: any,
-        default: any = None,
+        data: typing.Any,
+        default: typing.Any = None,
     ):
         name = cls._get_name(type, prompty)
-        if name.startswith("NOOP") and default != None:
+        if name.startswith("NOOP") and default is not None:
             return default
         elif name.startswith("NOOP"):
             return data
@@ -231,43 +237,51 @@ class InvokerFactory:
         return value
 
     @classmethod
-    def run_renderer(cls, prompty: Prompty, data: any, default: any = None) -> any:
+    def run_renderer(
+        cls, prompty: Prompty, data: typing.Any, default: typing.Any = None
+    ) -> typing.Any:
         return cls.run("renderer", prompty, data, default)
 
     @classmethod
     async def run_renderer_async(
-        cls, prompty: Prompty, data: any, default: any = None
-    ) -> any:
+        cls, prompty: Prompty, data: typing.Any, default: typing.Any = None
+    ) -> typing.Any:
         return await cls.run_async("renderer", prompty, data, default)
 
     @classmethod
-    def run_parser(cls, prompty: Prompty, data: any, default: any = None) -> any:
+    def run_parser(
+        cls, prompty: Prompty, data: typing.Any, default: typing.Any = None
+    ) -> typing.Any:
         return cls.run("parser", prompty, data, default)
 
     @classmethod
     async def run_parser_async(
-        cls, prompty: Prompty, data: any, default: any = None
-    ) -> any:
+        cls, prompty: Prompty, data: typing.Any, default: typing.Any = None
+    ) -> typing.Any:
         return await cls.run_async("parser", prompty, data, default)
 
     @classmethod
-    def run_executor(cls, prompty: Prompty, data: any, default: any = None) -> any:
+    def run_executor(
+        cls, prompty: Prompty, data: typing.Any, default: typing.Any = None
+    ) -> typing.Any:
         return cls.run("executor", prompty, data, default)
 
     @classmethod
     async def run_executor_async(
-        cls, prompty: Prompty, data: any, default: any = None
-    ) -> any:
+        cls, prompty: Prompty, data: typing.Any, default: typing.Any = None
+    ) -> typing.Any:
         return await cls.run_async("executor", prompty, data, default)
 
     @classmethod
-    def run_processor(cls, prompty: Prompty, data: any, default: any = None) -> any:
+    def run_processor(
+        cls, prompty: Prompty, data: typing.Any, default: typing.Any = None
+    ) -> typing.Any:
         return cls.run("processor", prompty, data, default)
 
     @classmethod
     async def run_processor_async(
-        cls, prompty: Prompty, data: any, default: any = None
-    ) -> any:
+        cls, prompty: Prompty, data: typing.Any, default: typing.Any = None
+    ) -> typing.Any:
         return await cls.run_async("processor", prompty, data, default)
 
 
@@ -290,7 +304,7 @@ class InvokerException(Exception):
 @InvokerFactory.register_parser("prompty.image")
 @InvokerFactory.register_parser("prompty.completion")
 class NoOp(Invoker):
-    def invoke(self, data: any) -> any:
+    def invoke(self, data: typing.Any) -> typing.Any:
         return data
 
     async def invoke_async(self, data: str) -> str:

prompty/openai/__init__.py

@@ -2,8 +2,8 @@
 from prompty.invoker import InvokerException
 
 try:
-    from .executor import OpenAIExecutor
-    from .processor import OpenAIProcessor
+    from .executor import OpenAIExecutor  # noqa
+    from .processor import OpenAIProcessor  # noqa
 except ImportError as e:
     raise InvokerException(
         f"Error registering OpenAIExecutor and OpenAIProcessor: {e}", "openai"

prompty/openai/executor.py

@@ -1,8 +1,11 @@
 import importlib.metadata
+import typing
+from collections.abc import Iterator
+
 from openai import OpenAI
-from typing import Iterator
 
 from prompty.tracer import Tracer
+
 from ..core import Prompty, PromptyStream
 from ..invoker import Invoker, InvokerFactory
 
@@ -24,8 +27,9 @@ class OpenAIExecutor(Invoker):
         self.api = self.prompty.model.api
         self.parameters = self.prompty.model.parameters
         self.model = self.prompty.model.configuration["name"]
+        self.deployment = self.prompty.model.configuration["deployment"]
 
-    def invoke(self, data: any) -> any:
+    def invoke(self, data: typing.Any) -> typing.Any:
         """Invoke the OpenAI API
 
         Parameters

prompty/openai/processor.py

@@ -1,10 +1,13 @@
-from typing import Iterator
-from openai.types.completion import Completion
+import typing
+from collections.abc import Iterator
+
 from openai.types.chat.chat_completion import ChatCompletion
-from ..invoker import Invoker, InvokerFactory
-from ..core import Prompty, PromptyStream, ToolCall
+from openai.types.completion import Completion
 from openai.types.create_embedding_response import CreateEmbeddingResponse
 
+from ..core import Prompty, PromptyStream, ToolCall
+from ..invoker import Invoker, InvokerFactory
+
 
 @InvokerFactory.register_processor("openai")
 class OpenAIProcessor(Invoker):
@@ -13,7 +16,7 @@ class OpenAIProcessor(Invoker):
     def __init__(self, prompty: Prompty) -> None:
         super().__init__(prompty)
 
-    def invoke(self, data: any) -> any:
+    def invoke(self, data: typing.Any) -> typing.Any:
         """Invoke the OpenAI API
 
         Parameters
@@ -56,7 +59,7 @@ class OpenAIProcessor(Invoker):
                 for chunk in data:
                     if (
                         len(chunk.choices) == 1
-                        and chunk.choices[0].delta.content != None
+                        and chunk.choices[0].delta.content is not None
                     ):
                         content = chunk.choices[0].delta.content
                         yield content

prompty/parsers.py

@@ -1,25 +1,30 @@
-import re
 import base64
+import re
+from pathlib import Path
+
 from .core import Prompty
-from .invoker import Invoker, InvokerFactory
+from .invoker import Invoker
 
 
-@InvokerFactory.register_parser("prompty.chat")
 class PromptyChatParser(Invoker):
-    """ Prompty Chat Parser  """
+    """Prompty Chat Parser"""
+
     def __init__(self, prompty: Prompty) -> None:
         super().__init__(prompty)
         self.roles = ["assistant", "function", "system", "user"]
+        if isinstance(self.prompty.file, str):
+            self.prompty.file = Path(self.prompty.file).resolve().absolute()
+
         self.path = self.prompty.file.parent
 
     def inline_image(self, image_item: str) -> str:
-        """ Inline Image
+        """Inline Image
 
         Parameters
         ----------
         image_item : str
             The image item to inline
-        
+
         Returns
         -------
         str
@@ -46,13 +51,13 @@ class PromptyChatParser(Invoker):
                 )
 
     def parse_content(self, content: str):
-        """ for parsing inline images
-        
+        """for parsing inline images
+
         Parameters
         ----------
         content : str
             The content to parse
-        
+
         Returns
         -------
         any
@@ -97,14 +102,14 @@ class PromptyChatParser(Invoker):
         else:
             return content
 
-    def invoke(self, data: str) -> str:
-        """ Invoke the Prompty Chat Parser
+    def invoke(self, data: str) -> list[dict[str, str]]:
+        """Invoke the Prompty Chat Parser
 
         Parameters
         ----------
         data : str
             The data to parse
-        
+
         Returns
         -------
         str
@@ -121,7 +126,7 @@ class PromptyChatParser(Invoker):
         ]
 
         # if no starter role, then inject system role
-        if not chunks[0].strip().lower() in self.roles:
+        if chunks[0].strip().lower() not in self.roles:
             chunks.insert(0, "system")
 
         # if last chunk is role entry, then remove (no content?)
@@ -138,16 +143,15 @@ class PromptyChatParser(Invoker):
             messages.append({"role": role, "content": self.parse_content(content)})
 
         return messages
-    
 
-    async def invoke_async(self, data: str) -> str:
-        """ Invoke the Prompty Chat Parser (Async)
+    async def invoke_async(self, data: str) -> list[dict[str, str]]:
+        """Invoke the Prompty Chat Parser (Async)
 
         Parameters
         ----------
         data : str
             The data to parse
-        
+
         Returns
         -------
         str

prompty/renderers.py

@@ -1,24 +1,35 @@
-from .core import Prompty
+import typing
+from pathlib import Path
+
 from jinja2 import DictLoader, Environment
-from .invoker import Invoker, InvokerFactory
+
+from .core import Prompty
+from .invoker import Invoker
 
 
-@InvokerFactory.register_renderer("jinja2")
 class Jinja2Renderer(Invoker):
     """Jinja2 Renderer"""
 
     def __init__(self, prompty: Prompty) -> None:
         super().__init__(prompty)
-        self.templates = {}
+        self.templates: dict[str, str] = {}
         # generate template dictionary
-        cur_prompt = self.prompty
+        cur_prompt: typing.Union[Prompty, None] = self.prompty
         while cur_prompt:
-            self.templates[cur_prompt.file.name] = cur_prompt.content
+            if isinstance(cur_prompt.file, str):
+                cur_prompt.file = Path(cur_prompt.file).resolve().absolute()
+
+            if isinstance(cur_prompt.content, str):
+                self.templates[cur_prompt.file.name] = cur_prompt.content
+
             cur_prompt = cur_prompt.basePrompty
 
+        if isinstance(self.prompty.file, str):
+            self.prompty.file = Path(self.prompty.file).resolve().absolute()
+
         self.name = self.prompty.file.name
 
-    def invoke(self, data: any) -> any:
+    def invoke(self, data: typing.Any) -> typing.Any:
         env = Environment(loader=DictLoader(self.templates))
         t = env.get_template(self.name)
         generated = t.render(**data)

prompty/serverless/__init__.py

@@ -2,7 +2,7 @@
 from prompty.invoker import InvokerException
 
 try:
-    from .executor import ServerlessExecutor
-    from .processor import ServerlessProcessor
+    from .executor import ServerlessExecutor # noqa
+    from .processor import ServerlessProcessor  # noqa
 except ImportError:
     raise InvokerException("Error registering ServerlessExecutor and ServerlessProcessor", "serverless")