ai-prompter 0.1.1__py3-none-any.whl → 0.2.1__py3-none-any.whl

ai_prompter/__init__.py

@@ -13,7 +13,7 @@ from pydantic import BaseModel
 prompt_path_default = os.path.join(
     os.path.dirname(os.path.abspath(__file__)), "prompts"
 )
-prompt_path_custom = os.getenv("PROMPT_PATH")
+prompt_path_custom = os.getenv("PROMPTS_PATH")
 
 env_default = Environment(loader=FileSystemLoader(prompt_path_default))
 
@@ -34,95 +34,161 @@ class Prompter:
     prompt_variation: Optional[str] = "default"
     prompt_text: Optional[str] = None
     template: Optional[Union[str, Template]] = None
+    template_text: Optional[str] = None
     parser: Optional[Any] = None
 
-    def __init__(self, prompt_template=None, prompt_text=None, parser=None):
-        """
-        Initialize the Prompter with either a template file or raw text.
+    def __init__(
+        self,
+        prompt_template: Optional[str] = None,
+        model: Optional[Union[str, Any]] = None,
+        template_text: Optional[str] = None,
+        prompt_dir: Optional[str] = None,
+    ) -> None:
+        """Initialize the Prompter with a template name, model, and optional custom directory.
 
         Args:
-            prompt_template (str, optional): The name of the prompt template file.
-            prompt_text (str, optional): The raw prompt text.
+            prompt_template (str, optional): The name of the prompt template (without .jinja extension).
+            model (Union[str, Any], optional): The model to use for generation.
+            template_text (str, optional): The raw text of the template.
+            prompt_dir (str, optional): Custom directory to search for templates.
         """
         self.prompt_template = prompt_template
-        self.prompt_text = prompt_text
-        self.parser = parser
-        self.setup()
+        self.template = None
+        self.template_text = template_text
+        self.model = model or os.getenv("OPENAI_MODEL", "gpt-4-turbo")
+        self.prompt_dir = prompt_dir
+        self._setup_template(template_text, prompt_dir)
 
-    def setup(self):
-        """
-        Set up the Jinja2 template based on the provided template file or text.
-        Raises:
-            ValueError: If neither prompt_template nor prompt_text is provided, or if template name is empty.
+    def _setup_template(
+        self, template_text: Optional[str] = None, prompt_dir: Optional[str] = None
+    ) -> None:
+        """Set up the Jinja2 template based on the provided template file or text.
+
+        Args:
+            template_text (str, optional): The raw text of the template.
+            prompt_dir (str, optional): Custom directory to search for templates.
         """
-        if self.prompt_template is not None:
+        if template_text is None:
+            if self.prompt_template is None:
+                raise ValueError(
+                    "Either prompt_template or template_text must be provided"
+                )
             if not self.prompt_template:
                 raise ValueError("Template name cannot be empty")
-            # attempt to load from custom path at runtime
-            custom_path = os.getenv("PROMPT_PATH")
-            if custom_path and os.path.exists(custom_path):
-                try:
-                    env = Environment(loader=FileSystemLoader(custom_path))
-                    self.template = env.get_template(f"{self.prompt_template}.jinja")
-                    return
-                except Exception:
-                    pass
-            # fallback to default path
-            try:
-                env = Environment(loader=FileSystemLoader(prompt_path_default))
-                self.template = env.get_template(f"{self.prompt_template}.jinja")
-            except Exception as e:
-                raise ValueError(f"Template {self.prompt_template} not found in default folder: {e}")
-        elif self.prompt_text is not None:
-            self.template = Template(self.prompt_text)
+            prompt_dirs = []
+            if prompt_dir:
+                prompt_dirs.append(prompt_dir)
+            prompts_path = os.getenv("PROMPTS_PATH")
+            if prompts_path is not None:
+                prompt_dirs.extend(prompts_path.split(":"))
+            # Fallback to local folder and ~/ai-prompter
+            prompt_dirs.extend([os.getcwd(), os.path.expanduser("~/ai-prompter")])
+            # Default package prompts folder
+            if os.path.exists(prompt_path_default):
+                prompt_dirs.append(prompt_path_default)
+            env = Environment(loader=FileSystemLoader(prompt_dirs))
+            self.template = env.get_template(f"{self.prompt_template}.jinja")
         else:
-            raise ValueError("Prompter must have a prompt_template or prompt_text")
-
-        # Removed assertion as it's redundant with the checks above
-        # assert self.prompt_template or self.prompt_text, "Prompt is required"
+            self.template_text = template_text
+            self.template = Template(template_text)
 
     def to_langchain(self):
-        # only file-based templates supported for LangChain
-        if self.prompt_text is not None:
-            raise ImportError(
-                "langchain-core integration only supports file-based templates; install with `pip install .[langchain]`"
-            )
+        # Support for both text-based and file-based templates with LangChain
         try:
             from langchain_core.prompts import ChatPromptTemplate
         except ImportError:
             raise ImportError(
                 "langchain-core is required for to_langchain; install with `pip install .[langchain]`"
             )
-        if isinstance(self.template, str):
-            template_text = self.template
-        elif isinstance(self.template, Template):
-            # raw Jinja2 template object
-            template_text = self.prompt_text
+        from jinja2 import Template, Environment, FileSystemLoader
+        import os
+        import re
+        if self.template_text is not None:
+            template_content = self.template_text
+            return ChatPromptTemplate.from_template(
+                template_content, template_format="jinja2"
+            )
+        elif self.prompt_template is not None and self.template is not None:
+            # For file-based templates, we need to get the raw string content with includes resolved
+            if isinstance(self.template, Template):
+                try:
+                    # Use the same logic as Prompter initialization for finding prompt_dir
+                    if self.prompt_dir is None:
+                        # Check for PROMPTS_PATH environment variable
+                        prompts_path = os.environ.get("PROMPTS_PATH")
+                        if prompts_path:
+                            self.prompt_dir = prompts_path
+                        else:
+                            # Check a series of default directories
+                            potential_dirs = [
+                                os.path.join(os.getcwd(), "prompts"),
+                                os.path.join(os.path.dirname(os.path.abspath(__file__)), "prompts"),
+                                os.path.join(os.path.expanduser("~"), ".prompts"),
+                            ]
+                            for dir_path in potential_dirs:
+                                if os.path.exists(dir_path):
+                                    self.prompt_dir = dir_path
+                                    break
+                            if self.prompt_dir is None:
+                                raise ValueError(
+                                    "No prompt directory found. Please set PROMPTS_PATH environment variable "
+                                    "or specify prompt_dir when initializing Prompter with a prompt_template."
+                                )
+                    # Function to manually resolve includes while preserving variables
+                    def resolve_includes(template_name, base_dir, visited=None):
+                        if visited is None:
+                            visited = set()
+                        if template_name in visited:
+                            raise ValueError(f"Circular include detected for {template_name}")
+                        visited.add(template_name)
+                        # Ensure we don't add .jinja if it's already in the name
+                        if template_name.endswith('.jinja'):
+                            template_file = os.path.join(base_dir, template_name)
+                        else:
+                            template_file = os.path.join(base_dir, f"{template_name}.jinja")
+                        if not os.path.exists(template_file):
+                            raise ValueError(f"Template file {template_file} not found")
+                        with open(template_file, 'r', encoding='utf-8') as f:
+                            content = f.read()
+                        # Find all include statements
+                        include_pattern = r"{%\s*include\s*['\"]([^'\"]+)['\"]\s*%}"
+                        matches = re.findall(include_pattern, content)
+                        for included_template in matches:
+                            included_content = resolve_includes(included_template, base_dir, visited)
+                            placeholder = "{% include '" + included_template + "' %}"
+                            content = content.replace(placeholder, included_content)
+                        visited.remove(template_name)
+                        return content
+                    # Resolve includes for the main template
+                    template_content = resolve_includes(self.prompt_template, self.prompt_dir)
+                    return ChatPromptTemplate.from_template(
+                        template_content, template_format="jinja2"
+                    )
+                except Exception as e:
+                    raise ValueError(f"Error processing template for LangChain: {str(e)}")
+            else:
+                raise ValueError(
+                    "Template is not properly initialized for LangChain conversion"
+                )
         else:
-            # file-based template
-            prompt_dir = (
-                prompt_path_custom
-                if prompt_path_custom and os.path.exists(prompt_path_custom)
-                else prompt_path_default
+            raise ValueError(
+                "Either prompt_template with a valid template or template_text must be provided for LangChain conversion"
             )
-            template_file = os.path.join(prompt_dir, f"{self.prompt_template}.jinja")
-            with open(template_file, "r") as f:
-                template_text = f.read()
-        return ChatPromptTemplate.from_template(template_text, template_format="jinja2")
 
     @classmethod
-    def from_text(cls, text: str):
-        """
-        Create a Prompter instance from raw text, which can contain Jinja code.
+    def from_text(
+        cls, text: str, model: Optional[Union[str, Any]] = None
+    ) -> "Prompter":
+        """Create a Prompter instance from raw text, which can contain Jinja code.
 
         Args:
-            text (str): The raw prompt text.
+            text (str): The raw template text.
+            model (Union[str, Any], optional): The model to use for generation.
 
         Returns:
             Prompter: A new Prompter instance.
         """
-
-        return cls(prompt_text=text)
+        return cls(template_text=text, model=model)
 
     def render(self, data: Optional[Union[Dict, BaseModel]] = None) -> str:
         """

ai_prompter/py.typed

@@ -0,0 +1 @@
+

{ai_prompter-0.1.1.dist-info → ai_prompter-0.2.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ai-prompter
-Version: 0.1.1
+Version: 0.2.1
 Summary: A prompt management library using Jinja2 templates to build complex prompts easily.
 Author-email: LUIS NOVO <lfnovo@gmail.com>
 License: MIT
@@ -21,7 +21,7 @@ A prompt management library using Jinja2 templates to build complex prompts easi
 
 - Define prompts as Jinja templates.
 - Load default templates from `src/ai_prompter/prompts`.
-- Override templates via `PROMPT_PATH` environment variable.
+- Override templates via `PROMPTS_PATH` environment variable.
 - Render prompts with arbitrary data or Pydantic models.
 - Export to LangChain `ChatPromptTemplate`.
 
@@ -51,34 +51,104 @@ uv add langchain_core
 Configure a custom template path by creating a `.env` file in the project root:
 
 ```dotenv
-PROMPT_PATH=path/to/custom/templates
+PROMPTS_PATH=path/to/custom/templates
 ```
 
 ## Usage
 
+### Basic Usage
+
+```python
+from ai_prompter import Prompter
+
+# Initialize with a template name
+prompter = Prompter('my_template')
+
+# Render a prompt with variables
+prompt = prompter.render({'variable': 'value'})
+print(prompt)
+```
+
+### Custom Prompt Directory
+
+You can specify a custom directory for your prompt templates using the `prompt_dir` parameter:
+
+```python
+prompter = Prompter(template_text='Hello {{ name }}!', prompt_dir='/path/to/your/prompts')
+```
+
+### Using Environment Variable for Prompt Path
+
+Set the `PROMPTS_PATH` environment variable to point to your custom prompts directory:
+
+```bash
+export PROMPTS_PATH=/path/to/your/prompts
+```
+
+The `Prompter` class will check this path if no custom directory is provided in the constructor. If not set, it will also look in the current working directory and `~/ai-prompter/` as fallback options before using the default package prompts.
+
 ### Raw text template
 
 ```python
 from ai_prompter import Prompter
 
 template = """Write an article about {{ topic }}."""
-prompter = Prompter(prompt_text=template)
+prompter = Prompter(template_text=template)
 prompt = prompter.render({"topic": "AI"})
 print(prompt)  # Write an article about AI.
 ```
 
 ### Using File-based Templates
 
-You can store your templates in files and reference them by name (without the `.jinja` extension). The library looks for templates in the `prompts` directory by default, or you can set a custom directory with the `PROMPT_PATH` environment variable.
+You can store your templates in files and reference them by name (without the `.jinja` extension). The library looks for templates in the `prompts` directory by default, or you can set a custom directory with the `PROMPTS_PATH` environment variable. You can specify multiple directories separated by `:` (colon), and the library will search through them in order until a matching template is found.
 
 ```python
 from ai_prompter import Prompter
 
+# Set multiple search paths
+os.environ["PROMPTS_PATH"] = "/path/to/templates1:/path/to/templates2"
+
 prompter = Prompter(prompt_template="greet")
-prompt = prompter.render({"who": "Tester"})
-print(prompt)  # GREET Tester
+result = prompter.render({"name": "World"})
+print(result)  # Output depends on the content of greet.jinja in the first found path
+```
+
+### Using Raw Text Templates
+
+Alternatively, you can provide the template content directly as raw text using the `template_text` parameter or the `from_text` class method.
+
+```python
+from ai_prompter import Prompter
+
+# Using template_text parameter
+prompter = Prompter(template_text="Hello, {{ name }}!")
+result = prompter.render({"name": "World"})
+print(result)  # Output: Hello, World!
+
+# Using from_text class method
+prompter = Prompter.from_text("Hi, {{ person }}!", model="gpt-4")
+result = prompter.render({"person": "Alice"})
+print(result)  # Output: Hi, Alice!
+```
+
+### LangChain Integration
+
+You can convert your prompts to LangChain's `ChatPromptTemplate` format for use in LangChain workflows. This works for both text-based and file-based templates.
+
+```python
+from ai_prompter import Prompter
+
+# With text-based template
+text_prompter = Prompter(template_text="Hello, {{ name }}!")
+lc_text_prompt = text_prompter.to_langchain()
+
+# With file-based template
+file_prompter = Prompter(prompt_template="greet")
+lc_file_prompt = file_prompter.to_langchain()
 ```
 
+**Note**: LangChain integration requires the `langchain-core` package. Install it with `pip install .[langchain]`.
+
 ### Including Other Templates
 
 You can include other template files within a template using Jinja2's `{% include %}` directive. This allows you to build modular templates.
@@ -138,7 +208,7 @@ The library also automatically provides a `current_time` variable with the curre
 ```python
 from ai_prompter import Prompter
 
-prompter = Prompter(prompt_text="Current time: {{current_time}}")
+prompter = Prompter(template_text="Current time: {{current_time}}")
 prompt = prompter.render()
 print(prompt)  # Current time: 2025-04-19 23:28:00
 ```
@@ -159,16 +229,6 @@ prompt = prompter.render({"topic": "AI"})
 print(prompt)
 ```
 
-### LangChain integration
-
-```python
-from ai_prompter import Prompter
-
-prompter = Prompter(prompt_template="article")
-lc_template = prompter.to_langchain()
-# use lc_template in LangChain chains
-```
-
 ### Jupyter Notebook
 
 See `notebooks/prompter_usage.ipynb` for interactive examples.

ai_prompter-0.2.1.dist-info/RECORD

@@ -0,0 +1,6 @@
+ai_prompter/__init__.py,sha256=ehtuhOKP0ze3sW1cYO4OyNhoB8CY926TmkPqvzz4ilA,10124
+ai_prompter/py.typed,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+ai_prompter-0.2.1.dist-info/METADATA,sha256=c4Wh6qs7JVcBwWf1FCe2MZtsw5HjygYuXyJzhuKFTUc,6950
+ai_prompter-0.2.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+ai_prompter-0.2.1.dist-info/licenses/LICENSE,sha256=cS0_fa_8BoP0PvVG8D19pn_HDJrG96hd4PyEm9nkRo8,1066
+ai_prompter-0.2.1.dist-info/RECORD,,

ai_prompter-0.1.1.dist-info/RECORD

@@ -1,5 +0,0 @@
-ai_prompter/__init__.py,sha256=4Zzy7drJRTmQZGJCEcqnf1-RkvDvZiLIYXLDeyFXGJw,5913
-ai_prompter-0.1.1.dist-info/METADATA,sha256=PgRjdlAIemIiqe5ANnoM52qK1FWxW4frN2SxS7MTsPs,4755
-ai_prompter-0.1.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-ai_prompter-0.1.1.dist-info/licenses/LICENSE,sha256=cS0_fa_8BoP0PvVG8D19pn_HDJrG96hd4PyEm9nkRo8,1066
-ai_prompter-0.1.1.dist-info/RECORD,,