pdd-cli 0.0.45__py3-none-any.whl → 0.0.118__py3-none-any.whl

pdd/prompts/insert_includes_LLM.prompt

@@ -6,8 +6,19 @@
         INPUT:
         <prompt_to_update>% You are an expert Python Software Engineer. Your goal is to write a python function, "postprocess", that will extract code from a string output of an LLM. All output to the console will be pretty printed using the Python rich library.
 
-% The function should be part of a Python package, using relative imports (single dot) for internal modules (e.g. 'from .module_name import module_name'). All output to the console will be pretty printed using the Python Rich library. Ensure the function handles edge cases, such as missing inputs or model errors, and provide clear error messages.
-% The ./pdd/__init__.py file will have the EXTRACTION_STRENGTH, DEFAULT_STRENGTH, DEFAULT_TIME and other global constants. Example: ```from . import DEFAULT_STRENGTH```
+% You are an expert Python engineer.
+
+% Code Style Requirements
+- File must start with `from __future__ import annotations`.
+- All functions must be fully type-hinted.
+- Use `rich.console.Console` for all printing.
+
+% Package Structure
+- The function should be part of a Python package, using relative imports (single dot) for internal modules (e.g. 'from .module_name import module_name').
+- The ./pdd/__init__.py file will have the EXTRACTION_STRENGTH, DEFAULT_STRENGTH, DEFAULT_TIME and other global constants. Example: ```from . import DEFAULT_STRENGTH```
+
+% Error Handling
+- Ensure the function handles edge cases, such as missing inputs or model errors, and provide clear error messages.
 
 % Here are the inputs and outputs of the function:
     Inputs:
@@ -52,104 +63,147 @@ if __name__ == "__main__":
 
         For running prompts with llm_invoke:
         <llm_invoke_example>
-            from pydantic import BaseModel, Field
+            import os
+import sys
+from typing import List, Optional
+from pydantic import BaseModel, Field
+from rich.console import Console
+
+# Ensure the package is in the python path for this example
+# In a real installation, this would just be 'from pdd.llm_invoke import llm_invoke'
+sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), "..")))
+
 from pdd.llm_invoke import llm_invoke
-from collections import defaultdict
 
-# Define a Pydantic model for structured output
-class Joke(BaseModel):
-    setup: str = Field(description="The setup of the joke")
-    punchline: str = Field(description="The punchline of the joke")
+console = Console()
 
-def main():
-    """
-    Main function to demonstrate the usage of `llm_invoke`.
-    """
-    # Dictionary to track strength ranges for each model
-    model_ranges = defaultdict(list)
-    current_model = None
-    range_start = 0.0
+# --- Example 1: Simple Text Generation ---
+def example_simple_text():
+    console.print("[bold blue]--- Example 1: Simple Text Generation ---[/bold blue]")
+    
+    # Define a prompt template
+    prompt_template = "Explain the concept of {concept} to a {audience} in one sentence."
+    
+    # Define input variables
+    input_data = {
+        "concept": "quantum entanglement",
+        "audience": "5-year-old"
+    }
+
+    # Invoke the LLM
+    # strength=0.5 targets the 'base' model (usually a balance of cost/performance)
+    result = llm_invoke(
+        prompt=prompt_template,
+        input_json=input_data,
+        strength=0.5,
+        temperature=0.7,
+        verbose=True  # Set to True to see detailed logs about model selection and cost
+    )
+
+    console.print(f"[green]Result:[/green] {result['result']}")
+    console.print(f"[dim]Model used: {result['model_name']} | Cost: ${result['cost']:.6f}[/dim]\n")
+
+
+# --- Example 2: Structured Output with Pydantic ---
+class MovieReview(BaseModel):
+    title: str = Field(..., description="The title of the movie")
+    rating: int = Field(..., description="Rating out of 10")
+    summary: str = Field(..., description="A brief summary of the plot")
+    tags: List[str] = Field(..., description="List of genre tags")
+
+def example_structured_output():
+    console.print("[bold blue]--- Example 2: Structured Output (Pydantic) ---[/bold blue]")
+
+    prompt = "Generate a review for a fictional sci-fi movie about {topic}."
+    input_data = {"topic": "time traveling cats"}
+
+    # Invoke with output_pydantic to enforce a schema
+    # strength=0.8 targets a higher-performance model (better at following schemas)
+    result = llm_invoke(
+        prompt=prompt,
+        input_json=input_data,
+        strength=0.8,
+        output_pydantic=MovieReview,
+        temperature=0.5
+    )
+
+    # The 'result' key will contain an instance of the Pydantic model
+    review: MovieReview = result['result']
     
-    prompt = "Tell me a joke about {topic}"
-    input_json = {"topic": "programmers"}
-    temperature = 1
-    verbose = False
+    console.print(f"[green]Title:[/green] {review.title}")
+    console.print(f"[green]Rating:[/green] {review.rating}/10")
+    console.print(f"[green]Tags:[/green] {', '.join(review.tags)}")
+    console.print(f"[dim]Model used: {result['model_name']}[/dim]\n")
+
+
+# --- Example 3: Batch Processing ---
+def example_batch_processing():
+    console.print("[bold blue]--- Example 3: Batch Processing ---[/bold blue]")
+
+    prompt = "What is the capital of {country}?"
     
-    strength = 0.5
-    while strength <= 0.5:
-        print(f"\nStrength: {strength}")
-        
-        # Example 1: Unstructured Output
-        print("\n--- Unstructured Output ---")
-        response = llm_invoke(
-            prompt=prompt,
-            input_json=input_json,
-            strength=strength,
-            temperature=temperature,
-            verbose=verbose
-        )
-        
-        # Track model changes for strength ranges
-        if current_model != response['model_name']:
-            if current_model is not None:
-                model_ranges[current_model].append((range_start, strength - 0.005))
-            current_model = response['model_name']
-            range_start = strength
-        
-        print(f"Result: {response['result']}")
-        print(f"Cost: ${response['cost']:.6f}")
-        print(f"Model Used: {response['model_name']}")
-        
-        # Example 2: Structured Output with Pydantic Model
-        prompt_structured = (
-            "Generate a joke about {topic}. \n"
-            "Return it in this exact JSON format:\n"
-            "{{ \n"
-            '    "setup": "your setup here",\n'
-            '    "punchline": "your punchline here"\n'
-            "}}\n"
-            "Return ONLY the JSON with no additional text or explanation."
-        )
-        input_json_structured = {"topic": "data scientists"}
-        output_pydantic = Joke
-        
-        print("\n--- Structured Output ---")
-        try:
-            response_structured = llm_invoke(
-                prompt=prompt_structured,
-                input_json=input_json_structured,
-                strength=strength,
-                temperature=temperature,
-                verbose=True,
-                output_pydantic=output_pydantic
-            )
-            print(f"Result: {response_structured['result']}")
-            print(f"Cost: ${response_structured['cost']:.6f}")
-            print(f"Model Used: {response_structured['model_name']}")
-
-            # Access structured data
-            joke: Joke = response_structured['result']
-            print(f"\nJoke Setup: {joke.setup}")
-            print(f"Joke Punchline: {joke.punchline}")
-        except Exception as e:
-            print(f"Error encountered during structured output: {e}")
-        
-        strength += 0.005
-        # round to 3 decimal places
-        strength = round(strength, 3)
+    # List of inputs triggers batch mode
+    batch_inputs = [
+        {"country": "France"},
+        {"country": "Japan"},
+        {"country": "Brazil"}
+    ]
+
+    # use_batch_mode=True uses the provider's batch API if available/supported by LiteLLM
+    # strength=0.2 targets a cheaper/faster model
+    results = llm_invoke(
+        prompt=prompt,
+        input_json=batch_inputs,
+        use_batch_mode=True,
+        strength=0.2,
+        temperature=0.1
+    )
+
+    # In batch mode, 'result' is a list of strings (or objects)
+    for i, res in enumerate(results['result']):
+        console.print(f"[green]Input:[/green] {batch_inputs[i]['country']} -> [green]Output:[/green] {res}")
     
-    # Add the final range for the last model
-    model_ranges[current_model].append((range_start, 1.0))
+    console.print(f"[dim]Model used: {results['model_name']} | Total Cost: ${results['cost']:.6f}[/dim]\n")
+
+
+# --- Example 4: Reasoning / Thinking Time ---
+def example_reasoning():
+    console.print("[bold blue]--- Example 4: Reasoning / Thinking Time ---[/bold blue]")
+
+    # Some models (like Claude 3.7 or OpenAI o1/o3) support explicit thinking steps.
+    # Setting time > 0 enables this behavior based on the model's configuration in llm_model.csv.
     
-    # Print out the strength ranges for each model
-    print("\n=== Model Strength Ranges ===")
-    for model, ranges in model_ranges.items():
-        print(f"\n{model}:")
-        for start, end in ranges:
-            print(f"  Strength {start:.3f} to {end:.3f}")
+    prompt = "Solve this riddle: {riddle}"
+    input_data = {"riddle": "I speak without a mouth and hear without ears. I have no body, but I come alive with wind. What am I?"}
+
+    result = llm_invoke(
+        prompt=prompt,
+        input_json=input_data,
+        strength=1.0,  # Target highest capability model
+        time=0.5,      # Request moderate thinking time/budget
+        verbose=True
+    )
+
+    console.print(f"[green]Answer:[/green] {result['result']}")
+    
+    # If the model supports it, thinking output is captured separately
+    if result.get('thinking_output'):
+        console.print(f"[yellow]Thinking Process:[/yellow] {result['thinking_output']}")
+    else:
+        console.print("[dim]No separate thinking output returned for this model.[/dim]")
+
 
 if __name__ == "__main__":
-    main()
+    # Ensure you have a valid .env file or environment variables set for API keys
+    # (e.g., OPENAI_API_KEY, ANTHROPIC_API_KEY)
+    
+    try:
+        example_simple_text()
+        example_structured_output()
+        example_batch_processing()
+        example_reasoning()
+    except Exception as e:
+        console.print(f"[bold red]Error running examples:[/bold red] {e}")
         </llm_invoke_example>
     </internal_modules>
 </dependencies_to_insert>
@@ -157,8 +211,19 @@ if __name__ == "__main__":
         OUTPUT:
         <updated_prompt>% You are an expert Python Software Engineer. Your goal is to write a python function, "postprocess", that will extract code from a string output of an LLM. All output to the console will be pretty printed using the Python rich library.
 
-% The function should be part of a Python package, using relative imports (single dot) for internal modules (e.g. 'from .module_name import module_name'). All output to the console will be pretty printed using the Python Rich library. Ensure the function handles edge cases, such as missing inputs or model errors, and provide clear error messages.
-% The ./pdd/__init__.py file will have the EXTRACTION_STRENGTH, DEFAULT_STRENGTH, DEFAULT_TIME and other global constants. Example: ```from . import DEFAULT_STRENGTH```
+% You are an expert Python engineer.
+
+% Code Style Requirements
+- File must start with `from __future__ import annotations`.
+- All functions must be fully type-hinted.
+- Use `rich.console.Console` for all printing.
+
+% Package Structure
+- The function should be part of a Python package, using relative imports (single dot) for internal modules (e.g. 'from .module_name import module_name').
+- The ./pdd/__init__.py file will have the EXTRACTION_STRENGTH, DEFAULT_STRENGTH, DEFAULT_TIME and other global constants. Example: ```from . import DEFAULT_STRENGTH```
+
+% Error Handling
+- Ensure the function handles edge cases, such as missing inputs or model errors, and provide clear error messages.
 
 % Here are the inputs and outputs of the function:
     Inputs:
@@ -192,104 +257,147 @@ if __name__ == "__main__":
 
         For running prompts with llm_invoke:
         <llm_invoke_example>
-            from pydantic import BaseModel, Field
+            import os
+import sys
+from typing import List, Optional
+from pydantic import BaseModel, Field
+from rich.console import Console
+
+# Ensure the package is in the python path for this example
+# In a real installation, this would just be 'from pdd.llm_invoke import llm_invoke'
+sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), "..")))
+
 from pdd.llm_invoke import llm_invoke
-from collections import defaultdict
 
-# Define a Pydantic model for structured output
-class Joke(BaseModel):
-    setup: str = Field(description="The setup of the joke")
-    punchline: str = Field(description="The punchline of the joke")
+console = Console()
 
-def main():
-    """
-    Main function to demonstrate the usage of `llm_invoke`.
-    """
-    # Dictionary to track strength ranges for each model
-    model_ranges = defaultdict(list)
-    current_model = None
-    range_start = 0.0
+# --- Example 1: Simple Text Generation ---
+def example_simple_text():
+    console.print("[bold blue]--- Example 1: Simple Text Generation ---[/bold blue]")
+    
+    # Define a prompt template
+    prompt_template = "Explain the concept of {concept} to a {audience} in one sentence."
+    
+    # Define input variables
+    input_data = {
+        "concept": "quantum entanglement",
+        "audience": "5-year-old"
+    }
+
+    # Invoke the LLM
+    # strength=0.5 targets the 'base' model (usually a balance of cost/performance)
+    result = llm_invoke(
+        prompt=prompt_template,
+        input_json=input_data,
+        strength=0.5,
+        temperature=0.7,
+        verbose=True  # Set to True to see detailed logs about model selection and cost
+    )
+
+    console.print(f"[green]Result:[/green] {result['result']}")
+    console.print(f"[dim]Model used: {result['model_name']} | Cost: ${result['cost']:.6f}[/dim]\n")
+
+
+# --- Example 2: Structured Output with Pydantic ---
+class MovieReview(BaseModel):
+    title: str = Field(..., description="The title of the movie")
+    rating: int = Field(..., description="Rating out of 10")
+    summary: str = Field(..., description="A brief summary of the plot")
+    tags: List[str] = Field(..., description="List of genre tags")
+
+def example_structured_output():
+    console.print("[bold blue]--- Example 2: Structured Output (Pydantic) ---[/bold blue]")
+
+    prompt = "Generate a review for a fictional sci-fi movie about {topic}."
+    input_data = {"topic": "time traveling cats"}
+
+    # Invoke with output_pydantic to enforce a schema
+    # strength=0.8 targets a higher-performance model (better at following schemas)
+    result = llm_invoke(
+        prompt=prompt,
+        input_json=input_data,
+        strength=0.8,
+        output_pydantic=MovieReview,
+        temperature=0.5
+    )
+
+    # The 'result' key will contain an instance of the Pydantic model
+    review: MovieReview = result['result']
+    
+    console.print(f"[green]Title:[/green] {review.title}")
+    console.print(f"[green]Rating:[/green] {review.rating}/10")
+    console.print(f"[green]Tags:[/green] {', '.join(review.tags)}")
+    console.print(f"[dim]Model used: {result['model_name']}[/dim]\n")
+
+
+# --- Example 3: Batch Processing ---
+def example_batch_processing():
+    console.print("[bold blue]--- Example 3: Batch Processing ---[/bold blue]")
+
+    prompt = "What is the capital of {country}?"
     
-    prompt = "Tell me a joke about {topic}"
-    input_json = {"topic": "programmers"}
-    temperature = 1
-    verbose = False
+    # List of inputs triggers batch mode
+    batch_inputs = [
+        {"country": "France"},
+        {"country": "Japan"},
+        {"country": "Brazil"}
+    ]
+
+    # use_batch_mode=True uses the provider's batch API if available/supported by LiteLLM
+    # strength=0.2 targets a cheaper/faster model
+    results = llm_invoke(
+        prompt=prompt,
+        input_json=batch_inputs,
+        use_batch_mode=True,
+        strength=0.2,
+        temperature=0.1
+    )
+
+    # In batch mode, 'result' is a list of strings (or objects)
+    for i, res in enumerate(results['result']):
+        console.print(f"[green]Input:[/green] {batch_inputs[i]['country']} -> [green]Output:[/green] {res}")
     
-    strength = 0.5
-    while strength <= 0.5:
-        print(f"\nStrength: {strength}")
-        
-        # Example 1: Unstructured Output
-        print("\n--- Unstructured Output ---")
-        response = llm_invoke(
-            prompt=prompt,
-            input_json=input_json,
-            strength=strength,
-            temperature=temperature,
-            verbose=verbose
-        )
-        
-        # Track model changes for strength ranges
-        if current_model != response['model_name']:
-            if current_model is not None:
-                model_ranges[current_model].append((range_start, strength - 0.005))
-            current_model = response['model_name']
-            range_start = strength
-        
-        print(f"Result: {response['result']}")
-        print(f"Cost: ${response['cost']:.6f}")
-        print(f"Model Used: {response['model_name']}")
-        
-        # Example 2: Structured Output with Pydantic Model
-        prompt_structured = (
-            "Generate a joke about {topic}. \n"
-            "Return it in this exact JSON format:\n"
-            "{{ \n"
-            '    "setup": "your setup here",\n'
-            '    "punchline": "your punchline here"\n'
-            "}}\n"
-            "Return ONLY the JSON with no additional text or explanation."
-        )
-        input_json_structured = {"topic": "data scientists"}
-        output_pydantic = Joke
-        
-        print("\n--- Structured Output ---")
-        try:
-            response_structured = llm_invoke(
-                prompt=prompt_structured,
-                input_json=input_json_structured,
-                strength=strength,
-                temperature=temperature,
-                verbose=True,
-                output_pydantic=output_pydantic
-            )
-            print(f"Result: {response_structured['result']}")
-            print(f"Cost: ${response_structured['cost']:.6f}")
-            print(f"Model Used: {response_structured['model_name']}")
-
-            # Access structured data
-            joke: Joke = response_structured['result']
-            print(f"\nJoke Setup: {joke.setup}")
-            print(f"Joke Punchline: {joke.punchline}")
-        except Exception as e:
-            print(f"Error encountered during structured output: {e}")
-        
-        strength += 0.005
-        # round to 3 decimal places
-        strength = round(strength, 3)
+    console.print(f"[dim]Model used: {results['model_name']} | Total Cost: ${results['cost']:.6f}[/dim]\n")
+
+
+# --- Example 4: Reasoning / Thinking Time ---
+def example_reasoning():
+    console.print("[bold blue]--- Example 4: Reasoning / Thinking Time ---[/bold blue]")
+
+    # Some models (like Claude 3.7 or OpenAI o1/o3) support explicit thinking steps.
+    # Setting time > 0 enables this behavior based on the model's configuration in llm_model.csv.
     
-    # Add the final range for the last model
-    model_ranges[current_model].append((range_start, 1.0))
+    prompt = "Solve this riddle: {riddle}"
+    input_data = {"riddle": "I speak without a mouth and hear without ears. I have no body, but I come alive with wind. What am I?"}
+
+    result = llm_invoke(
+        prompt=prompt,
+        input_json=input_data,
+        strength=1.0,  # Target highest capability model
+        time=0.5,      # Request moderate thinking time/budget
+        verbose=True
+    )
+
+    console.print(f"[green]Answer:[/green] {result['result']}")
     
-    # Print out the strength ranges for each model
-    print("\n=== Model Strength Ranges ===")
-    for model, ranges in model_ranges.items():
-        print(f"\n{model}:")
-        for start, end in ranges:
-            print(f"  Strength {start:.3f} to {end:.3f}")
+    # If the model supports it, thinking output is captured separately
+    if result.get('thinking_output'):
+        console.print(f"[yellow]Thinking Process:[/yellow] {result['thinking_output']}")
+    else:
+        console.print("[dim]No separate thinking output returned for this model.[/dim]")
+
 
 if __name__ == "__main__":
-    main()
+    # Ensure you have a valid .env file or environment variables set for API keys
+    # (e.g., OPENAI_API_KEY, ANTHROPIC_API_KEY)
+    
+    try:
+        example_simple_text()
+        example_structured_output()
+        example_batch_processing()
+        example_reasoning()
+    except Exception as e:
+        console.print(f"[bold red]Error running examples:[/bold red] {e}")
         </llm_invoke_example>
     </internal_modules>
 
@@ -310,8 +418,19 @@ if __name__ == "__main__":
         INPUT:
         <prompt_to_update>% You are an expert Python engineer. Your goal is to write a Python function, "conflicts_in_prompts", that takes two prompts as input and finds conflicts between them and suggests how to resolve those conflicts.
 
-% The function should be part of a Python package, using relative imports (single dot) for internal modules (e.g. 'from .module_name import module_name'). All output to the console will be pretty printed using the Python Rich library. Ensure the function handles edge cases, such as missing inputs or model errors, and provide clear error messages.
-% The ./pdd/__init__.py file will have the EXTRACTION_STRENGTH, DEFAULT_STRENGTH, DEFAULT_TIME and other global constants. Example: ```from . import DEFAULT_STRENGTH```
+% You are an expert Python engineer.
+
+% Code Style Requirements
+- File must start with `from __future__ import annotations`.
+- All functions must be fully type-hinted.
+- Use `rich.console.Console` for all printing.
+
+% Package Structure
+- The function should be part of a Python package, using relative imports (single dot) for internal modules (e.g. 'from .module_name import module_name').
+- The ./pdd/__init__.py file will have the EXTRACTION_STRENGTH, DEFAULT_STRENGTH, DEFAULT_TIME and other global constants. Example: ```from . import DEFAULT_STRENGTH```
+
+% Error Handling
+- Ensure the function handles edge cases, such as missing inputs or model errors, and provide clear error messages.
 
 % Here are the inputs and outputs of the function:
     Inputs: 
@@ -693,8 +812,19 @@ if __name__ == "__main__":
         OUTPUT:
         <updated_prompt>% You are an expert Python engineer. Your goal is to write a Python function, "conflicts_in_prompts", that takes two prompts as input and finds conflicts between them and suggests how to resolve those conflicts.
 
-% The function should be part of a Python package, using relative imports (single dot) for internal modules (e.g. 'from .module_name import module_name'). All output to the console will be pretty printed using the Python Rich library. Ensure the function handles edge cases, such as missing inputs or model errors, and provide clear error messages.
-% The ./pdd/__init__.py file will have the EXTRACTION_STRENGTH, DEFAULT_STRENGTH, DEFAULT_TIME and other global constants. Example: ```from . import DEFAULT_STRENGTH```
+% You are an expert Python engineer.
+
+% Code Style Requirements
+- File must start with `from __future__ import annotations`.
+- All functions must be fully type-hinted.
+- Use `rich.console.Console` for all printing.
+
+% Package Structure
+- The function should be part of a Python package, using relative imports (single dot) for internal modules (e.g. 'from .module_name import module_name').
+- The ./pdd/__init__.py file will have the EXTRACTION_STRENGTH, DEFAULT_STRENGTH, DEFAULT_TIME and other global constants. Example: ```from . import DEFAULT_STRENGTH```
+
+% Error Handling
+- Ensure the function handles edge cases, such as missing inputs or model errors, and provide clear error messages.
 
 % Here are the inputs and outputs of the function:
     Inputs: