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

prompty/openai/__init__.py

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

prompty/openai/executor.py

@@ -0,0 +1,114 @@
+import importlib.metadata
+from openai import OpenAI
+from typing import Iterator
+
+from prompty.tracer import Tracer
+from ..core import Prompty, PromptyStream
+from ..invoker import Invoker, InvokerFactory
+
+VERSION = importlib.metadata.version("prompty")
+
+
+@InvokerFactory.register_executor("openai")
+class OpenAIExecutor(Invoker):
+    """OpenAI Executor"""
+
+    def __init__(self, prompty: Prompty) -> None:
+        super().__init__(prompty)
+        self.kwargs = {
+            key: value
+            for key, value in self.prompty.model.configuration.items()
+            if key != "type"
+        }
+
+        self.api = self.prompty.model.api
+        self.deployment = self.prompty.model.configuration["azure_deployment"]
+        self.parameters = self.prompty.model.parameters
+
+    def invoke(self, data: any) -> any:
+        """Invoke the OpenAI API
+
+        Parameters
+        ----------
+        data : any
+            The data to send to the OpenAI API
+
+        Returns
+        -------
+        any
+            The response from the OpenAI API
+        """
+        with Tracer.start("OpenAI") as trace:
+            trace("type", "LLM")
+            trace("signature", "OpenAI.ctor")
+            trace("description", "OpenAI Constructor")
+            trace("inputs", self.kwargs)
+            client = OpenAI(
+                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", "OpenAI Prompty Execution Invoker")
+
+            if self.api == "chat":
+                trace("signature", "OpenAI.chat.completions.create")
+                args = {
+                    "model": self.deployment,
+                    "messages": data if isinstance(data, list) else [data],
+                    **self.parameters,
+                }
+                trace("inputs", args)
+                response = client.chat.completions.create(**args)
+
+            elif self.api == "completion":
+                trace("signature", "OpenAI.completions.create")
+                args = {
+                    "prompt": data.item,
+                    "model": self.deployment,
+                    **self.parameters,
+                }
+                trace("inputs", args)
+                response = client.completions.create(**args)
+
+            elif self.api == "embedding":
+                trace("signature", "OpenAI.embeddings.create")
+                args = {
+                    "input": data if isinstance(data, list) else [data],
+                    "model": self.deployment,
+                    **self.parameters,
+                }
+                trace("inputs", args)
+                response = client.embeddings.create(**args)
+
+            elif self.api == "image":
+                raise NotImplementedError("OpenAI Image API is not implemented yet")
+
+            # stream response
+            if isinstance(response, Iterator):
+                stream = PromptyStream("AzureOpenAIExecutor", response)
+                trace("result", stream)
+                return stream
+            else:
+                trace("result", response)
+                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
+        """
+        return self.invoke(data)

prompty/{processors.py → openai/processor.py}

@@ -1,38 +1,30 @@
 from typing import Iterator
-from pydantic import BaseModel
 from openai.types.completion import Completion
 from openai.types.chat.chat_completion import ChatCompletion
-from .core import Invoker, InvokerFactory, Prompty, PromptyStream
+from ..invoker import Invoker, InvokerFactory
+from ..core import Prompty, PromptyStream, ToolCall
 from openai.types.create_embedding_response import CreateEmbeddingResponse
 
 
-class ToolCall(BaseModel):
-    id: str
-    name: str
-    arguments: str
-
-
 @InvokerFactory.register_processor("openai")
-@InvokerFactory.register_processor("azure")
-@InvokerFactory.register_processor("azure_openai")
 class OpenAIProcessor(Invoker):
-    """OpenAI/Azure Processor"""
+    """OpenAI Processor"""
 
     def __init__(self, prompty: Prompty) -> None:
         super().__init__(prompty)
 
     def invoke(self, data: any) -> any:
-        """Invoke the OpenAI/Azure API
+        """Invoke the OpenAI API
 
         Parameters
         ----------
         data : any
-            The data to send to the OpenAI/Azure API
+            The data to send to the OpenAI API
 
         Returns
         -------
         any
-            The response from the OpenAI/Azure API
+            The response from the OpenAI API
         """
         if isinstance(data, ChatCompletion):
             response = data.choices[0].message
@@ -62,10 +54,28 @@ class OpenAIProcessor(Invoker):
 
             def generator():
                 for chunk in data:
-                    if len(chunk.choices) == 1 and chunk.choices[0].delta.content != None:
+                    if (
+                        len(chunk.choices) == 1
+                        and chunk.choices[0].delta.content != None
+                    ):
                         content = chunk.choices[0].delta.content
                         yield content
 
             return PromptyStream("OpenAIProcessor", generator())
         else:
             return data
+
+    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/parsers.py

@@ -1,6 +1,7 @@
 import re
 import base64
-from .core import Invoker, InvokerFactory, Prompty
+from .core import Prompty
+from .invoker import Invoker, InvokerFactory
 
 
 @InvokerFactory.register_parser("prompty.chat")
@@ -137,3 +138,19 @@ 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)
+
+        Parameters
+        ----------
+        data : str
+            The data to parse
+        
+        Returns
+        -------
+        str
+            The parsed data
+        """
+        return self.invoke(data)

prompty/renderers.py

@@ -1,10 +1,12 @@
+from .core import Prompty
 from jinja2 import DictLoader, Environment
-from .core import Invoker, InvokerFactory, Prompty
+from .invoker import Invoker, InvokerFactory
 
 
 @InvokerFactory.register_renderer("jinja2")
 class Jinja2Renderer(Invoker):
-    """ Jinja2 Renderer """
+    """Jinja2 Renderer"""
+
     def __init__(self, prompty: Prompty) -> None:
         super().__init__(prompty)
         self.templates = {}
@@ -21,3 +23,18 @@ class Jinja2Renderer(Invoker):
         t = env.get_template(self.name)
         generated = t.render(**data)
         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/serverless/__init__.py

@@ -0,0 +1,8 @@
+# __init__.py
+from prompty.invoker import InvokerException
+
+try:
+    from .executor import ServerlessExecutor
+    from .processor import ServerlessProcessor
+except ImportError:
+    raise InvokerException("Error registering ServerlessExecutor and ServerlessProcessor", "serverless")

prompty/serverless/executor.py

@@ -0,0 +1,153 @@
+import importlib.metadata
+from typing import Iterator
+from azure.core.credentials import AzureKeyCredential
+from azure.ai.inference import (
+    ChatCompletionsClient,
+    EmbeddingsClient,
+)
+from azure.ai.inference.models import (
+    StreamingChatCompletions,
+    AsyncStreamingChatCompletions,
+)
+
+from ..tracer import Tracer
+from ..invoker import Invoker, InvokerFactory
+from ..core import Prompty, PromptyStream, AsyncPromptyStream
+
+VERSION = importlib.metadata.version("prompty")
+
+
+@InvokerFactory.register_executor("serverless")
+class ServerlessExecutor(Invoker):
+    """Azure OpenAI Executor"""
+
+    def __init__(self, prompty: Prompty) -> None:
+        super().__init__(prompty)
+
+        # serverless configuration
+        self.endpoint = self.prompty.model.configuration["endpoint"]
+        self.model = self.prompty.model.configuration["model"]
+        self.key = self.prompty.model.configuration["key"]
+
+        # api type
+        self.api = self.prompty.model.api
+
+    def _response(self, response: any) -> any:
+        # stream response
+        if isinstance(response, Iterator):
+            if isinstance(response, StreamingChatCompletions):
+                stream = PromptyStream("ServerlessExecutor", response)
+                return stream
+            elif isinstance(response, AsyncStreamingChatCompletions):
+                stream = AsyncPromptyStream("ServerlessExecutor", response)
+                return stream
+            else:
+                stream = PromptyStream("ServerlessExecutor", response)
+
+            return stream
+        else:
+            return response
+
+    def invoke(self, data: any) -> any:
+        """Invoke the Serverless SDK
+
+        Parameters
+        ----------
+        data : any
+            The data to send to the Serverless SDK
+
+        Returns
+        -------
+        any
+            The response from the Serverless SDK
+        """
+
+        cargs = {
+            "endpoint": self.endpoint,
+            "credential": AzureKeyCredential(self.key),
+        }
+
+        if self.api == "chat":
+            with Tracer.start("ChatCompletionsClient") as trace:
+                trace("type", "LLM")
+                trace("signature", "azure.ai.inference.ChatCompletionsClient.ctor")
+                trace(
+                    "description", "Azure Unified Inference SDK Chat Completions Client"
+                )
+                trace("inputs", cargs)
+                client = ChatCompletionsClient(
+                    user_agent=f"prompty/{VERSION}",
+                    **cargs,
+                )
+                trace("result", client)
+
+            with Tracer.start("complete") as trace:
+                trace("type", "LLM")
+                trace("signature", "azure.ai.inference.ChatCompletionsClient.complete")
+                trace(
+                    "description", "Azure Unified Inference SDK Chat Completions Client"
+                )
+                eargs = {
+                    "model": self.model,
+                    "messages": data if isinstance(data, list) else [data],
+                    **self.prompty.model.parameters,
+                }
+                trace("inputs", eargs)
+                r = client.complete(**eargs)
+                trace("result", r)
+
+            response = self._response(r)
+
+        elif self.api == "completion":
+            raise NotImplementedError(
+                "Serverless Completions API is not implemented yet"
+            )
+
+        elif self.api == "embedding":
+            with Tracer.start("EmbeddingsClient") as trace:
+                trace("type", "LLM")
+                trace("signature", "azure.ai.inference.EmbeddingsClient.ctor")
+                trace("description", "Azure Unified Inference SDK Embeddings Client")
+                trace("inputs", cargs)
+                client = EmbeddingsClient(
+                    user_agent=f"prompty/{VERSION}",
+                    **cargs,
+                )
+                trace("result", client)
+
+            with Tracer.start("complete") as trace:
+                trace("type", "LLM")
+                trace("signature", "azure.ai.inference.ChatCompletionsClient.complete")
+                trace(
+                    "description", "Azure Unified Inference SDK Chat Completions Client"
+                )
+                eargs = {
+                    "model": self.model,
+                    "input": data if isinstance(data, list) else [data],
+                    **self.prompty.model.parameters,
+                }
+                trace("inputs", eargs)
+                r = client.complete(**eargs)
+                trace("result", r)
+
+            response = self._response(r)
+
+        elif self.api == "image":
+            raise NotImplementedError("Azure OpenAI Image API is not implemented yet")
+
+        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
+        """
+        return self.invoke(data)

prompty/serverless/processor.py

@@ -0,0 +1,78 @@
+from typing import Iterator
+from ..invoker import Invoker, InvokerFactory
+from ..core import Prompty, PromptyStream, ToolCall
+
+from azure.ai.inference.models import ChatCompletions, EmbeddingsResult
+
+
+@InvokerFactory.register_processor("serverless")
+class ServerlessProcessor(Invoker):
+    """OpenAI Processor"""
+
+    def __init__(self, prompty: Prompty) -> None:
+        super().__init__(prompty)
+
+    def invoke(self, data: any) -> any:
+        """Invoke the OpenAI API
+
+        Parameters
+        ----------
+        data : any
+            The data to send to the OpenAI API
+
+        Returns
+        -------
+        any
+            The response from the OpenAI API
+        """
+        if isinstance(data, ChatCompletions):
+            response = data.choices[0].message
+            # tool calls available in response
+            if response.tool_calls:
+                return [
+                    ToolCall(
+                        id=tool_call.id,
+                        name=tool_call.function.name,
+                        arguments=tool_call.function.arguments,
+                    )
+                    for tool_call in response.tool_calls
+                ]
+            else:
+                return response.content
+
+        elif isinstance(data, EmbeddingsResult):
+            if len(data.data) == 0:
+                raise ValueError("Invalid data")
+            elif len(data.data) == 1:
+                return data.data[0].embedding
+            else:
+                return [item.embedding for item in data.data]
+        elif isinstance(data, Iterator):
+
+            def generator():
+                for chunk in data:
+                    if (
+                        len(chunk.choices) == 1
+                        and chunk.choices[0].delta.content != None
+                    ):
+                        content = chunk.choices[0].delta.content
+                        yield content
+
+            return PromptyStream("ServerlessProcessor", generator())
+        else:
+            return data
+
+    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)