pdd-cli 0.0.2__py3-none-any.whl

pdd/change.py

@@ -0,0 +1,141 @@
+from typing import Tuple
+from rich.console import Console
+from rich.markdown import Markdown
+from rich.panel import Panel
+from pydantic import BaseModel, Field
+from .preprocess import preprocess
+from .load_prompt_template import load_prompt_template
+from .llm_invoke import llm_invoke
+
+console = Console()
+
+class ExtractedPrompt(BaseModel):
+    modified_prompt: str = Field(description="The extracted modified prompt")
+
+def change(
+    input_prompt: str,
+    input_code: str,
+    change_prompt: str,
+    strength: float,
+    temperature: float,
+    verbose: bool = False
+) -> Tuple[str, float, str]:
+    """
+    Change a prompt according to specified modifications.
+
+    Args:
+        input_prompt (str): The original prompt to be modified
+        input_code (str): The code generated from the input prompt
+        change_prompt (str): Instructions for modifying the input prompt
+        strength (float): The strength parameter for the LLM model (0-1)
+        temperature (float): The temperature parameter for the LLM model
+        verbose (bool): Whether to print detailed information
+
+    Returns:
+        Tuple[str, float, str]: (modified prompt, total cost, model name)
+    """
+    try:
+        # Step 1: Load prompt templates
+        change_llm_prompt = load_prompt_template("change_LLM")
+        extract_prompt = load_prompt_template("extract_prompt_change_LLM")
+
+        if not all([change_llm_prompt, extract_prompt]):
+            raise ValueError("Failed to load prompt templates")
+
+        # Step 2: Preprocess the change_LLM prompt
+        processed_change_llm = preprocess(change_llm_prompt, recursive=False, double_curly_brackets=False)
+        processed_change_prompt = preprocess(change_prompt, recursive=False, double_curly_brackets=False)
+
+        # Input validation
+        if not all([input_prompt, input_code, change_prompt]):
+            raise ValueError("Missing required input parameters")
+        if not (0 <= strength <= 1):
+            raise ValueError("Strength must be between 0 and 1")
+
+        total_cost = 0.0
+        final_model_name = ""
+
+        # Step 3: Run change prompt through model
+        if verbose:
+            console.print(Panel("Running change prompt through LLM...", style="blue"))
+
+        change_response = llm_invoke(
+            prompt=processed_change_llm,
+            input_json={
+                "input_prompt": input_prompt,
+                "input_code": input_code,
+                "change_prompt": processed_change_prompt
+            },
+            strength=strength,
+            temperature=temperature,
+            verbose=verbose
+        )
+
+        total_cost += change_response["cost"]
+        final_model_name = change_response["model_name"]
+
+        # Step 4: Print markdown formatting if verbose
+        if verbose:
+            console.print(Panel("Change prompt result:", style="green"))
+            console.print(Markdown(change_response["result"]))
+
+        # Step 5: Run extract prompt
+        if verbose:
+            console.print(Panel("Extracting modified prompt...", style="blue"))
+
+        extract_response = llm_invoke(
+            prompt=extract_prompt,
+            input_json={"llm_output": change_response["result"]},
+            strength=0.89,  # Fixed strength as specified
+            temperature=temperature,
+            verbose=verbose,
+            output_pydantic=ExtractedPrompt
+        )
+
+        total_cost += extract_response["cost"]
+
+        # Ensure we have a valid result
+        if not isinstance(extract_response["result"], ExtractedPrompt):
+            raise ValueError("Failed to extract modified prompt")
+
+        modified_prompt = extract_response["result"].modified_prompt
+
+        # Step 6: Print extracted prompt if verbose
+        if verbose:
+            console.print(Panel("Extracted modified prompt:", style="green"))
+            console.print(Markdown(modified_prompt))
+
+        # Step 7: Return results
+        return modified_prompt, total_cost, final_model_name
+
+    except Exception as e:
+        console.print(f"[red]Error in change function: {str(e)}[/red]")
+        raise
+
+def main():
+    """Example usage of the change function"""
+    try:
+        # Example inputs
+        input_prompt = "Write a function that adds two numbers"
+        input_code = "def add(a, b):\n    return a + b"
+        change_prompt = "Make the function handle negative numbers explicitly"
+        
+        modified_prompt, cost, model = change(
+            input_prompt=input_prompt,
+            input_code=input_code,
+            change_prompt=change_prompt,
+            strength=0.7,
+            temperature=0.7,
+            verbose=True
+        )
+
+        console.print("\n[bold green]Results:[/bold green]")
+        console.print(f"Modified Prompt: {modified_prompt}")
+        console.print(f"Total Cost: ${cost:.6f}")
+        console.print(f"Model Used: {model}")
+
+    except Exception as e:
+        console.print(f"[red]Error in main: {str(e)}[/red]")
+
+if __name__ == "__main__":
+    main()

pdd/change_main.py

@@ -0,0 +1,240 @@
+import csv
+import os
+from typing import Optional, Tuple, List, Dict
+import click
+from rich import print as rprint
+import logging
+
+from .construct_paths import construct_paths
+from .change import change as change_func
+from .process_csv_change import process_csv_change
+
+logger = logging.getLogger(__name__)
+logger.setLevel(logging.DEBUG)  # Changed from WARNING to DEBUG
+
+def change_main(
+    ctx: click.Context,
+    change_prompt_file: str,
+    input_code: str,
+    input_prompt_file: Optional[str],
+    output: Optional[str],
+    use_csv: bool
+) -> Tuple[str, float, str]:
+    """
+    Main function to handle the 'change' command logic.
+
+    :param ctx: Click context containing command-line parameters.
+    :param change_prompt_file: Path to the change prompt file.
+    :param input_code: Path to the input code file or directory (when using '--csv').
+    :param input_prompt_file: Path to the input prompt file. Optional and not used when '--csv' is specified.
+    :param output: Optional path to save the modified prompt file. If not specified, it will be generated based on the input files.
+    :param use_csv: Flag indicating whether to use CSV mode for batch changes.
+    :return: A tuple containing the modified prompt or a message indicating multiple prompts were updated, total cost, and model name used.
+    """
+    logger.debug(f"Starting change_main with use_csv={use_csv}")
+    try:
+        # Validate arguments
+        if not use_csv and not input_prompt_file:
+            error_msg = "Error: 'input_prompt_file' is required when not using '--csv' mode."
+            logger.error(error_msg)
+            if not ctx.obj.get('quiet', False):
+                rprint(f"[bold red]{error_msg}[/bold red]")
+            return (error_msg, 0.0, "")
+
+        # Check if input_code is a directory when using CSV mode
+        if use_csv:
+            try:
+                if not os.path.isdir(input_code):
+                    error_msg = f"In CSV mode, 'input_code' must be a directory. Got: {input_code}"
+                    logger.error(error_msg)
+                    if not ctx.obj.get('quiet', False):
+                        rprint(f"[bold red]Error: {error_msg}[/bold red]")
+                    return (error_msg, 0.0, "")
+            except Exception as e:
+                error_msg = f"Error checking input_code directory: {str(e)}"
+                logger.error(error_msg)
+                if not ctx.obj.get('quiet', False):
+                    rprint(f"[bold red]Error: {error_msg}[/bold red]")
+                return (error_msg, 0.0, "")
+
+        # Construct file paths
+        input_file_paths = {
+            "change_prompt_file": change_prompt_file,
+        }
+        if not use_csv:
+            input_file_paths["input_code"] = input_code
+            input_file_paths["input_prompt_file"] = input_prompt_file
+
+        command_options = {
+            "output": output
+        }
+
+        logger.debug(f"Constructing paths with input_file_paths={input_file_paths}")
+        input_strings, output_file_paths, _ = construct_paths(
+            input_file_paths=input_file_paths,
+            force=ctx.obj.get('force', False),
+            quiet=ctx.obj.get('quiet', False),
+            command="change",
+            command_options=command_options
+        )
+
+        # Load input files
+        change_prompt_content = input_strings["change_prompt_file"]
+        logger.debug("Change prompt content loaded")
+
+        # Get strength and temperature from context
+        strength = ctx.obj.get('strength', 0.9)
+        temperature = ctx.obj.get('temperature', 0)
+        logger.debug(f"Using strength={strength} and temperature={temperature}")
+
+        if use_csv:
+            logger.debug(f"Using CSV mode with input_code={input_code}")
+            # Validate CSV file format
+            try:
+                with open(change_prompt_file, mode='r', newline='', encoding='utf-8') as csvfile:
+                    reader = csv.DictReader(csvfile)
+                    if 'prompt_name' not in reader.fieldnames or 'change_instructions' not in reader.fieldnames:
+                        error_msg = "CSV file must contain 'prompt_name' and 'change_instructions' columns."
+                        logger.error(error_msg)
+                        if not ctx.obj.get('quiet', False):
+                            rprint(f"[bold red]Error: {error_msg}[/bold red]")
+                        return (error_msg, 0.0, "")
+                    logger.debug(f"CSV file validated. Columns: {reader.fieldnames}")
+            except Exception as e:
+                error_msg = f"Error reading CSV file: {str(e)}"
+                logger.error(error_msg)
+                if not ctx.obj.get('quiet', False):
+                    rprint(f"[bold red]Error: {error_msg}[/bold red]")
+                return (error_msg, 0.0, "")
+
+            # Perform batch changes using CSV
+            try:
+                logger.debug("Calling process_csv_change")
+                success, modified_prompts, total_cost, model_name = process_csv_change(
+                    csv_file=change_prompt_file,
+                    strength=strength,
+                    temperature=temperature,
+                    code_directory=input_code,
+                    language=ctx.obj.get('language', 'python'),
+                    extension=ctx.obj.get('extension', '.py'),
+                    budget=ctx.obj.get('budget', 10.0)
+                )
+                logger.debug(f"process_csv_change completed. Success: {success}")
+            except Exception as e:
+                error_msg = f"Error during CSV processing: {str(e)}"
+                logger.error(error_msg)
+                if not ctx.obj.get('quiet', False):
+                    rprint(f"[bold red]Error: {error_msg}[/bold red]")
+                return (error_msg, 0.0, "")
+
+            # Determine output path
+            output_path = output or output_file_paths.get('output', "batch_modified_prompts.csv")
+            logger.debug(f"Output path: {output_path}")
+
+            # Save results
+            if success:
+                try:
+                    if output is None:
+                        # Save individual files
+                        for item in modified_prompts:
+                            file_name = item['file_name']
+                            modified_prompt = item['modified_prompt']
+                            individual_output_path = os.path.join(os.path.dirname(output_path), file_name)
+                            with open(individual_output_path, 'w') as file:
+                                file.write(modified_prompt)
+                        logger.debug("Results saved as individual files successfully")
+                    else:
+                        # Save as CSV
+                        with open(output_path, 'w', newline='') as csvfile:
+                            fieldnames = ['file_name', 'modified_prompt']
+                            writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
+                            writer.writeheader()
+                            for item in modified_prompts:
+                                writer.writerow(item)
+                        logger.debug("Results saved successfully")
+                except Exception as e:
+                    error_msg = f"Error writing output: {str(e)}"
+                    logger.error(error_msg)
+                    if not ctx.obj.get('quiet', False):
+                        rprint(f"[bold red]Error: {error_msg}[/bold red]")
+                    return (error_msg, total_cost, model_name)
+
+            # Provide user feedback
+            if not ctx.obj.get('quiet', False):
+                if use_csv and success:
+                    rprint("[bold green]Batch change operation completed successfully.[/bold green]")
+                    rprint(f"[bold]Model used:[/bold] {model_name}")
+                    rprint(f"[bold]Total cost:[/bold] ${total_cost:.6f}")
+                    if output is None:
+                        output_dir = os.path.dirname(output_path)
+                        rprint(f"[bold]Results saved as individual files in:[/bold] {output_dir}")
+                        for item in modified_prompts:
+                            file_name = item['file_name']
+                            individual_output_path = os.path.join(output_dir, file_name)
+                            rprint(f"  - {individual_output_path}")
+                    else:
+                        rprint(f"[bold]Results saved to CSV:[/bold] {output_path}")
+
+            logger.debug("Returning success message for CSV mode")
+            return ("Multiple prompts have been updated.", total_cost, model_name)
+
+        else:
+            logger.debug("Using non-CSV mode")
+            input_code_content = input_strings["input_code"]
+            input_prompt_content = input_strings["input_prompt_file"]
+
+            # Perform single change
+            logger.debug("Calling change_func")
+            try:
+                modified_prompt, total_cost, model_name = change_func(
+                    input_prompt=input_prompt_content,
+                    input_code=input_code_content,
+                    change_prompt=change_prompt_content,
+                    strength=strength,
+                    temperature=temperature,
+                    verbose=ctx.obj.get('verbose', False),
+                )
+                logger.debug("change_func completed")
+            except Exception as e:
+                error_msg = f"An unexpected error occurred: {str(e)}"
+                logger.error(error_msg)
+                if not ctx.obj.get('quiet', False):
+                    rprint(f"[bold red]Error: {error_msg}[/bold red]")
+                return (error_msg, 0.0, "")
+
+            # Determine output path
+            output_path = output or output_file_paths.get('output', f"modified_{os.path.basename(input_prompt_file)}")
+            logger.debug(f"Output path: {output_path}")
+
+            # Save the modified prompt
+            try:
+                with open(output_path, 'w') as f:
+                    f.write(modified_prompt)
+                logger.debug("Results saved successfully")
+            except Exception as e:
+                error_msg = f"Error writing output file: {str(e)}"
+                logger.error(error_msg)
+                if not ctx.obj.get('quiet', False):
+                    rprint(f"[bold red]Error: {error_msg}[/bold red]")
+                return (error_msg, total_cost, model_name)
+
+            # Provide user feedback
+            if not ctx.obj.get('quiet', False):
+                rprint("[bold green]Prompt modification completed successfully.[/bold green]")
+                rprint(f"[bold]Model used:[/bold] {model_name}")
+                rprint(f"[bold]Total cost:[/bold] ${total_cost:.6f}")
+                rprint(f"[bold]Modified prompt saved to:[/bold] {output_path}")
+
+            logger.debug("Returning success message for non-CSV mode")
+            return (modified_prompt, total_cost, model_name)
+
+    except Exception as e:
+        error_msg = f"An unexpected error occurred: {str(e)}"
+        logger.error(error_msg)
+        if not ctx.obj.get('quiet', False):
+            rprint(f"[bold red]Error: {error_msg}[/bold red]")
+        return (error_msg, 0.0, "")
+
+    # This line should never be reached, but we'll log it just in case
+    logger.warning("Reached end of change_main without returning")
+    return ("An unknown error occurred", 0.0, "")