prompt-caller 0.0.4__tar.gz → 0.1.0__tar.gz

{prompt_caller-0.0.4 → prompt_caller-0.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: prompt_caller
-Version: 0.0.4
+Version: 0.1.0
 Summary: This package is responsible for calling prompts in a specific format. It uses LangChain and OpenAI API
 Home-page: https://github.com/ThiNepo/prompt-caller
 Author: Thiago Nepomuceno
@@ -15,6 +15,7 @@ Requires-Dist: python-dotenv>=1.0.1
 Requires-Dist: Jinja2>=3.1.4
 Requires-Dist: langchain-openai>=0.3.5
 Requires-Dist: openai>=1.63.0
+Requires-Dist: pillow>=11.0.0
 
 # PromptCaller
 
@@ -86,6 +87,36 @@ In this example:
 - The `expression` value `3+8/9` is injected into the user message.
 - The model will respond with both the result of the expression and an explanation, as specified in the `output` section of the prompt.
 
+3. **Using the agent feature:**  
+
+   The `agent` method allows you to enhance the prompt's functionality by integrating external tools. Here’s an example where we evaluate a mathematical expression using Python’s `eval` in a safe execution environment:
+
+   ```python
+   from prompt_caller import PromptCaller
+
+   ai = PromptCaller()
+
+   def evaluate_expression(expression: str):
+       """
+       Evaluate a math expression using eval.
+       """
+       safe_globals = {"__builtins__": None}
+       return eval(expression, safe_globals, {})
+
+   response = ai.agent(
+       "sample-agent", {"expression": "3+8/9"}, tools=[evaluate_expression]
+   )
+
+   print(response)
+   ```
+
+   In this example:
+
+   - The `agent` method is used to process the prompt while integrating external tools.
+   - The `evaluate_expression` function evaluates the mathematical expression securely.
+   - The response includes the processed result based on the prompt and tool execution.
+   
+
 ## How It Works
 
 1. **\_loadPrompt:** Loads the prompt file, splits the YAML header from the body, and parses them.

{prompt_caller-0.0.4 → prompt_caller-0.1.0}/README.md

@@ -68,6 +68,36 @@ In this example:
 - The `expression` value `3+8/9` is injected into the user message.
 - The model will respond with both the result of the expression and an explanation, as specified in the `output` section of the prompt.
 
+3. **Using the agent feature:**  
+
+   The `agent` method allows you to enhance the prompt's functionality by integrating external tools. Here’s an example where we evaluate a mathematical expression using Python’s `eval` in a safe execution environment:
+
+   ```python
+   from prompt_caller import PromptCaller
+
+   ai = PromptCaller()
+
+   def evaluate_expression(expression: str):
+       """
+       Evaluate a math expression using eval.
+       """
+       safe_globals = {"__builtins__": None}
+       return eval(expression, safe_globals, {})
+
+   response = ai.agent(
+       "sample-agent", {"expression": "3+8/9"}, tools=[evaluate_expression]
+   )
+
+   print(response)
+   ```
+
+   In this example:
+
+   - The `agent` method is used to process the prompt while integrating external tools.
+   - The `evaluate_expression` function evaluates the mathematical expression securely.
+   - The response includes the processed result based on the prompt and tool execution.
+   
+
 ## How It Works
 
 1. **\_loadPrompt:** Loads the prompt file, splits the YAML header from the body, and parses them.

prompt_caller-0.1.0/prompt_caller/prompt_caller.py

@@ -0,0 +1,203 @@
+import os
+import re
+
+import requests
+import yaml
+from dotenv import load_dotenv
+from jinja2 import Template
+from langchain_core.tools import tool
+from langchain_core.messages import HumanMessage, SystemMessage, ToolMessage
+from langchain_openai import ChatOpenAI
+from PIL import Image
+from pydantic import BaseModel, Field, create_model
+
+from io import BytesIO
+import base64
+
+load_dotenv()
+
+
+class PromptCaller:
+
+    def _loadPrompt(self, file_path):
+        with open(file_path, "r", encoding="utf-8") as file:
+            content = file.read()
+
+        # Split YAML header and the body
+        header, body = content.split("---", 2)[1:]
+
+        # Parse the YAML header
+        model_config = yaml.safe_load(header.strip())
+
+        # Step 2: Parse the JSX body and return it
+        return model_config, body.strip()
+
+    def _renderTemplate(self, body, context):
+        template = Template(body)
+        return template.render(context)
+
+    def _parseJSXBody(self, body):
+        elements = []
+        tag_pattern = r"<(system|user|assistant|image)>(.*?)</\1>"
+
+        matches = re.findall(tag_pattern, body, re.DOTALL)
+
+        for tag, content in matches:
+            elements.append({"role": tag, "content": content.strip()})
+
+        return elements
+
+    def getImageBase64(self, url: str) -> str:
+        response = requests.get(url)
+        response.raise_for_status()
+        img = Image.open(BytesIO(response.content))
+        buffered = BytesIO()
+        img.save(buffered, format="PNG")
+        img_base64 = base64.b64encode(buffered.getvalue()).decode("utf-8")
+        return f"data:image/png;base64,{img_base64}"
+
+    def loadPrompt(self, promptName, context=None):
+        # initialize context
+        if context is None:
+            context = {}
+
+        configuration, template = self._loadPrompt(
+            os.path.join("prompts", f"{promptName}.prompt")
+        )
+
+        template = self._renderTemplate(template, context)
+
+        parsedMessages = self._parseJSXBody(template)
+
+        messages = []
+
+        for message in parsedMessages:
+            if message.get("role") == "system":
+                messages.append(SystemMessage(content=message.get("content")))
+
+            if message.get("role") == "user":
+                messages.append(HumanMessage(content=message.get("content")))
+
+            if message.get("role") == "image":
+                base64_image = message.get("content")
+
+                if base64_image.startswith("http"):
+                    base64_image = self.getImageBase64(base64_image)
+
+                messages.append(
+                    HumanMessage(
+                        content=[
+                            {
+                                "type": "image_url",
+                                "image_url": {"url": base64_image},
+                            }
+                        ]
+                    )
+                )
+
+        return configuration, messages
+
+    def createPydanticModel(self, dynamic_dict):
+        # Create a dynamic Pydantic model from the dictionary
+        fields = {
+            key: (str, Field(description=f"Description for {key}"))
+            for key in dynamic_dict.keys()
+        }
+        # Dynamically create the Pydantic model with the fields
+        return create_model("DynamicModel", **fields)
+
+    def call(self, promptName, context=None):
+
+        configuration, messages = self.loadPrompt(promptName, context)
+
+        output = None
+
+        if "output" in configuration:
+            output = configuration.get("output")
+            configuration.pop("output")
+
+        chat = ChatOpenAI(**configuration)
+
+        if output:
+            dynamicModel = self.createPydanticModel(output)
+            chat = chat.with_structured_output(dynamicModel)
+
+        response = chat.invoke(messages)
+
+        return response
+
+    def agent(self, promptName, context=None, tools=None, allowed_steps=3):
+
+        configuration, messages = self.loadPrompt(promptName, context)
+
+        output = None
+
+        if "output" in configuration:
+            output = configuration.get("output")
+            configuration.pop("output")
+
+            for message in messages:
+                if isinstance(message, SystemMessage):
+                    message.content += "\nOnly use the tool DynamicModel when providing an output call."
+                    break
+
+        chat = ChatOpenAI(**configuration)
+
+        # Register the tools
+        if tools is None:
+            tools = []
+
+        # Transform functions in tools
+        tools = [tool(t) for t in tools]
+
+        tools_dict = {t.name.lower(): t for t in tools}
+
+        if output:
+            dynamicModel = self.createPydanticModel(output)
+
+        tools.extend([dynamicModel])
+        tools_dict["dynamicmodel"] = dynamicModel
+
+        chat = chat.bind_tools(tools)
+
+        try:
+            # First LLM invocation
+            response = chat.invoke(messages)
+            messages.append(response)
+
+            steps = 0
+            while response.tool_calls and steps < allowed_steps:
+                for tool_call in response.tool_calls:
+                    tool_name = tool_call["name"].lower()
+
+                    # If it's the final formatting tool, validate and return
+                    if tool_name == "dynamicmodel":
+                        return dynamicModel.model_validate(tool_call["args"])
+
+                    selected_tool = tools_dict.get(tool_name)
+                    if not selected_tool:
+                        raise ValueError(f"Unknown tool: {tool_name}")
+
+                    # Invoke the selected tool with provided arguments
+                    tool_response = selected_tool.invoke(tool_call)
+                    messages.append(tool_response)
+
+                # If the latest message is a ToolMessage, re-invoke the LLM
+                if isinstance(messages[-1], ToolMessage):
+                    response = chat.invoke(messages)
+                    messages.append(response)
+                else:
+                    break
+
+                steps += 1
+
+            # Final LLM call if the last message is still a ToolMessage
+            if isinstance(messages[-1], ToolMessage):
+                response = chat.invoke(messages)
+                messages.append(response)
+
+            return response
+
+        except Exception as e:
+            # Replace with appropriate logging in production
+            raise RuntimeError("Error during agent process") from e

{prompt_caller-0.0.4 → prompt_caller-0.1.0}/prompt_caller.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: prompt_caller
-Version: 0.0.4
+Version: 0.1.0
 Summary: This package is responsible for calling prompts in a specific format. It uses LangChain and OpenAI API
 Home-page: https://github.com/ThiNepo/prompt-caller
 Author: Thiago Nepomuceno
@@ -15,6 +15,7 @@ Requires-Dist: python-dotenv>=1.0.1
 Requires-Dist: Jinja2>=3.1.4
 Requires-Dist: langchain-openai>=0.3.5
 Requires-Dist: openai>=1.63.0
+Requires-Dist: pillow>=11.0.0
 
 # PromptCaller
 
@@ -86,6 +87,36 @@ In this example:
 - The `expression` value `3+8/9` is injected into the user message.
 - The model will respond with both the result of the expression and an explanation, as specified in the `output` section of the prompt.
 
+3. **Using the agent feature:**  
+
+   The `agent` method allows you to enhance the prompt's functionality by integrating external tools. Here’s an example where we evaluate a mathematical expression using Python’s `eval` in a safe execution environment:
+
+   ```python
+   from prompt_caller import PromptCaller
+
+   ai = PromptCaller()
+
+   def evaluate_expression(expression: str):
+       """
+       Evaluate a math expression using eval.
+       """
+       safe_globals = {"__builtins__": None}
+       return eval(expression, safe_globals, {})
+
+   response = ai.agent(
+       "sample-agent", {"expression": "3+8/9"}, tools=[evaluate_expression]
+   )
+
+   print(response)
+   ```
+
+   In this example:
+
+   - The `agent` method is used to process the prompt while integrating external tools.
+   - The `evaluate_expression` function evaluates the mathematical expression securely.
+   - The response includes the processed result based on the prompt and tool execution.
+   
+
 ## How It Works
 
 1. **\_loadPrompt:** Loads the prompt file, splits the YAML header from the body, and parses them.

{prompt_caller-0.0.4 → prompt_caller-0.1.0}/prompt_caller.egg-info/requires.txt

@@ -3,3 +3,4 @@ python-dotenv>=1.0.1
 Jinja2>=3.1.4
 langchain-openai>=0.3.5
 openai>=1.63.0
+pillow>=11.0.0

{prompt_caller-0.0.4 → prompt_caller-0.1.0}/setup.py

@@ -35,7 +35,7 @@ class BdistWheelCommand(bdist_wheel):
 
 setuptools.setup(
     name="prompt_caller",
-    version="0.0.4",
+    version="0.1.0",
     author="Thiago Nepomuceno",
     author_email="thiago@neps.academy",
     description="This package is responsible for calling prompts in a specific format. It uses LangChain and OpenAI API",
@@ -55,6 +55,7 @@ setuptools.setup(
         "Jinja2>=3.1.4",
         "langchain-openai>=0.3.5",
         "openai>=1.63.0",
+        "pillow>=11.0.0",
     ],
     cmdclass={"sdist": SdistCommand, "bdist_wheel": BdistWheelCommand},
 )

prompt_caller-0.0.4/prompt_caller/prompt_caller.py

@@ -1,95 +0,0 @@
-import os
-import re
-
-import yaml
-from dotenv import load_dotenv
-from jinja2 import Template
-from langchain_core.messages import HumanMessage, SystemMessage
-from langchain_openai import ChatOpenAI
-from pydantic import BaseModel, Field, create_model
-
-load_dotenv()
-
-
-class PromptCaller:
-
-    def _loadPrompt(self, file_path):
-        with open(file_path, "r", encoding="utf-8") as file:
-            content = file.read()
-
-        # Split YAML header and the body
-        header, body = content.split("---", 2)[1:]
-
-        # Parse the YAML header
-        model_config = yaml.safe_load(header.strip())
-
-        # Step 2: Parse the JSX body and return it
-        return model_config, body.strip()
-
-    def _renderTemplate(self, body, context):
-        template = Template(body)
-        return template.render(context)
-
-    def _parseJSXBody(self, body):
-        elements = []
-        tag_pattern = r"<(system|user|assistant)>(.*?)</\1>"
-
-        matches = re.findall(tag_pattern, body, re.DOTALL)
-
-        for tag, content in matches:
-            elements.append({"role": tag, "content": content.strip()})
-
-        return elements
-
-    def loadPrompt(self, promptName, context=None):
-        # initialize context
-        if context is None:
-            context = {}
-
-        configuration, template = self._loadPrompt(
-            os.path.join("prompts", f"{promptName}.prompt")
-        )
-
-        template = self._renderTemplate(template, context)
-
-        parsedMessages = self._parseJSXBody(template)
-
-        messages = []
-
-        for message in parsedMessages:
-            if message.get("role") == "system":
-                messages.append(SystemMessage(content=message.get("content")))
-
-            if message.get("role") == "user":
-                messages.append(HumanMessage(content=message.get("content")))
-
-        return configuration, messages
-
-    def createPydanticModel(self, dynamic_dict):
-        # Create a dynamic Pydantic model from the dictionary
-        fields = {
-            key: (str, Field(description=f"Description for {key}"))
-            for key in dynamic_dict.keys()
-        }
-        # Dynamically create the Pydantic model with the fields
-        return create_model("DynamicModel", **fields)
-
-    def call(self, promptName, context=None):
-
-        configuration, messages = self.loadPrompt(promptName, context)
-
-        output = None
-
-        if "output" in configuration:
-            output = configuration.get("output")
-            configuration.pop("output")
-
-        chat = ChatOpenAI(**configuration)
-
-        if output:
-            dynamicModel = self.createPydanticModel(output)
-            chat = chat.with_structured_output(dynamicModel)
-
-        response = chat.invoke(messages)
-
-        return response