pdd-cli 0.0.2__py3-none-any.whl

pdd/cmd_test_main.py

@@ -0,0 +1,155 @@
+from typing import Optional, Tuple
+import click
+from rich import print
+from rich.progress import track
+import os
+
+from .construct_paths import construct_paths
+from .generate_test import generate_test
+from .increase_tests import increase_tests
+
+def cmd_test_main(
+    ctx: click.Context,
+    prompt_file: str,
+    code_file: str,
+    output: Optional[str],
+    language: Optional[str],
+    coverage_report: Optional[str],
+    existing_tests: Optional[str],
+    target_coverage: Optional[float],
+    merge: Optional[bool],
+) -> Tuple[str, float, str]:
+    """
+    CLI wrapper for generating or enhancing unit tests.
+
+    Reads a prompt file and a code file, generates unit tests using the `generate_test` function,
+    and handles the output location.
+
+    Args:
+        ctx (click.Context): The Click context object.
+        prompt_file (str): Path to the prompt file.
+        code_file (str): Path to the code file.
+        output (Optional[str]): Path to save the generated test file.
+        language (Optional[str]): Programming language.
+        coverage_report (Optional[str]): Path to the coverage report file.
+        existing_tests (Optional[str]): Path to the existing unit test file.
+        target_coverage (Optional[float]): Desired code coverage percentage.
+        merge (Optional[bool]): Whether to merge new tests with existing tests.
+
+    Returns:
+        Tuple[str, float, str]: Generated unit test code, total cost, and model name.
+    """
+    # Initialize variables
+    unit_test = ""
+    total_cost = 0.0
+    model_name = ""
+    output_file_paths = {"output": output}
+    input_strings = {}
+
+    verbose = ctx.obj["verbose"]
+    strength = ctx.obj["strength"]
+    temperature = ctx.obj["temperature"]
+
+    if verbose:
+        print(f"[bold blue]Prompt file:[/bold blue] {prompt_file}")
+        print(f"[bold blue]Code file:[/bold blue] {code_file}")
+        if output:
+            print(f"[bold blue]Output:[/bold blue] {output}")
+        if language:
+            print(f"[bold blue]Language:[/bold blue] {language}")
+
+    # Construct input strings, output file paths, and determine language
+    try:
+        input_file_paths = {
+            "prompt_file": prompt_file,
+            "code_file": code_file,
+        }
+        if coverage_report:
+            input_file_paths["coverage_report"] = coverage_report
+        if existing_tests:
+            input_file_paths["existing_tests"] = existing_tests
+
+        command_options = {
+            "output": output,
+            "language": language,
+            "merge": merge,
+            "target_coverage": target_coverage,
+        }
+
+        input_strings, output_file_paths, language = construct_paths(
+            input_file_paths=input_file_paths,
+            force=ctx.obj["force"],
+            quiet=ctx.obj["quiet"],
+            command="test",
+            command_options=command_options,
+        )
+    except Exception as e:
+        print(f"[bold red]Error constructing paths: {e}[/bold red]")
+        ctx.exit(1)
+        return "", 0.0, ""
+
+    if verbose:
+        print(f"[bold blue]Language detected:[/bold blue] {language}")
+
+    # Generate or enhance unit tests
+    if not coverage_report:
+        try:
+            unit_test, total_cost, model_name = generate_test(
+                input_strings["prompt_file"],
+                input_strings["code_file"],
+                strength,
+                temperature,
+                language,
+            )
+        except Exception as e:
+            print(f"[bold red]Error generating tests: {e}[/bold red]")
+            ctx.exit(1)
+            return "", 0.0, ""
+    else:
+        if not existing_tests:
+            print(
+                "[bold red]Error: --existing-tests is required when using --coverage-report[/bold red]"
+            )
+            ctx.exit(1)
+            return "", 0.0, ""
+        try:
+            unit_test, total_cost, model_name = increase_tests(
+                existing_unit_tests=input_strings["existing_tests"],
+                coverage_report=input_strings["coverage_report"],
+                code=input_strings["code_file"],
+                prompt_that_generated_code=input_strings["prompt_file"],
+                language=language,
+                strength=strength,
+                temperature=temperature,
+                verbose=verbose,
+            )
+        except Exception as e:
+            print(f"[bold red]Error increasing test coverage: {e}[/bold red]")
+            ctx.exit(1)
+            return "", 0.0, ""
+
+    # Handle output
+    output_file = output_file_paths["output"]
+    if merge and existing_tests:
+        output_file = existing_tests
+
+    if not output_file:
+        print("[bold red]Error: Output file path could not be determined.[/bold red]")
+        ctx.exit(1)
+        return "", 0.0, ""
+    try:
+        with open(output_file, "w") as f:
+            f.write(unit_test)
+        print(
+            f"[bold green]Unit tests saved to:[/bold green] {output_file}"
+        )
+    except Exception as e:
+        print(f"[bold red]Error saving tests to file: {e}[/bold red]")
+        ctx.exit(1)
+        return "", 0.0, ""
+
+    if verbose:
+        print(f"[bold blue]Total cost:[/bold blue] ${total_cost:.6f}")
+        print(f"[bold blue]Model used:[/bold blue] {model_name}")
+
+    return unit_test, total_cost, model_name

pdd/code_generator.py

@@ -0,0 +1,117 @@
+from typing import Tuple
+from rich.console import Console
+from .preprocess import preprocess
+from .llm_invoke import llm_invoke
+from .unfinished_prompt import unfinished_prompt
+from .continue_generation import continue_generation
+from .postprocess import postprocess
+
+console = Console()
+
+def code_generator(
+    prompt: str,
+    language: str,
+    strength: float,
+    temperature: float = 0.0,
+    verbose: bool = False
+) -> Tuple[str, float, str]:
+    """
+    Generate code from a prompt using a language model.
+
+    Args:
+        prompt (str): The raw prompt to be processed
+        language (str): The target programming language
+        strength (float): The strength of the LLM model (0 to 1)
+        temperature (float, optional): The temperature for the LLM model. Defaults to 0.0
+        verbose (bool, optional): Whether to print detailed information. Defaults to False
+
+    Returns:
+        Tuple[str, float, str]: Tuple containing (runnable_code, total_cost, model_name)
+
+    Raises:
+        ValueError: If input parameters are invalid
+        Exception: For other unexpected errors
+    """
+    try:
+        # Input validation
+        if not isinstance(prompt, str) or not prompt.strip():
+            raise ValueError("Prompt must be a non-empty string")
+        if not isinstance(language, str) or not language.strip():
+            raise ValueError("Language must be a non-empty string")
+        if not 0 <= strength <= 1:
+            raise ValueError("Strength must be between 0 and 1")
+        if not 0 <= temperature <= 2:
+            raise ValueError("Temperature must be between 0 and 2")
+
+        total_cost = 0.0
+        model_name = ""
+
+        # Step 1: Preprocess the prompt
+        if verbose:
+            console.print("[bold blue]Step 1: Preprocessing prompt[/bold blue]")
+        processed_prompt = preprocess(prompt, recursive=False, double_curly_brackets=True)
+
+        # Step 2: Generate initial response
+        if verbose:
+            console.print("[bold blue]Step 2: Generating initial response[/bold blue]")
+        response = llm_invoke(
+            prompt=processed_prompt,
+            input_json={},
+            strength=strength,
+            temperature=temperature,
+            verbose=verbose
+        )
+        initial_output = response['result']
+        total_cost += response['cost']
+        model_name = response['model_name']
+
+        # Step 3: Check if generation is complete
+        if verbose:
+            console.print("[bold blue]Step 3: Checking completion status[/bold blue]")
+        last_chunk = initial_output[-600:] if len(initial_output) > 600 else initial_output
+        reasoning, is_finished, check_cost, _ = unfinished_prompt(
+            prompt_text=last_chunk,
+            strength=0.5,
+            temperature=0.0,
+            verbose=verbose
+        )
+        total_cost += check_cost
+
+        # Step 3a: Continue generation if incomplete
+        if not is_finished:
+            if verbose:
+                console.print("[bold yellow]Generation incomplete, continuing...[/bold yellow]")
+            final_output, continue_cost, continue_model = continue_generation(
+                formatted_input_prompt=processed_prompt,
+                llm_output=initial_output,
+                strength=strength,
+                temperature=temperature,
+                verbose=verbose
+            )
+            total_cost += continue_cost
+            model_name = continue_model
+        else:
+            final_output = initial_output
+
+        # Step 4: Postprocess the output
+        if verbose:
+            console.print("[bold blue]Step 4: Postprocessing output[/bold blue]")
+        runnable_code, postprocess_cost, model_name_post = postprocess(
+            llm_output=final_output,
+            language=language,
+            strength=0.895,
+            temperature=0.0,
+            verbose=verbose
+        )
+        total_cost += postprocess_cost
+
+        return runnable_code, total_cost, model_name
+
+    except ValueError as ve:
+        if verbose:
+            console.print(f"[bold red]Validation Error: {str(ve)}[/bold red]")
+        raise
+    except Exception as e:
+        if verbose:
+            console.print(f"[bold red]Unexpected Error: {str(e)}[/bold red]")
+        raise

pdd/code_generator_main.py

@@ -0,0 +1,66 @@
+import sys
+from typing import Tuple, Optional
+import click
+from rich import print as rprint
+
+from .construct_paths import construct_paths
+from .code_generator import code_generator
+
+def code_generator_main(ctx: click.Context, prompt_file: str, output: Optional[str]) -> Tuple[str, float, str]:
+    """
+    Main function to generate code from a prompt file.
+
+    :param ctx: Click context containing command-line parameters.
+    :param prompt_file: Path to the prompt file used to generate the code.
+    :param output: Optional path to save the generated code.
+    :return: A tuple containing the generated code, total cost, and model name used.
+    """
+    try:
+        # Construct file paths
+        input_file_paths = {
+            "prompt_file": prompt_file
+        }
+        command_options = {
+            "output": output
+        }
+        input_strings, output_file_paths, language = construct_paths(
+            input_file_paths=input_file_paths,
+            force=ctx.obj.get('force', False),
+            quiet=ctx.obj.get('quiet', False),
+            command="generate",
+            command_options=command_options
+        )
+
+        # Load input file
+        prompt_content = input_strings["prompt_file"]
+
+        # Generate code
+        strength = ctx.obj.get('strength', 0.5)
+        temperature = ctx.obj.get('temperature', 0.0)
+        generated_code, total_cost, model_name = code_generator(
+            prompt_content,
+            language,
+            strength,
+            temperature,
+            verbose=not ctx.obj.get('quiet', False)
+        )
+
+        # Save results
+        if output_file_paths["output"]:
+            with open(output_file_paths["output"], 'w') as f:
+                f.write(generated_code)
+
+        # Provide user feedback
+        if not ctx.obj.get('quiet', False):
+            rprint("[bold green]Code generation completed successfully.[/bold green]")
+            rprint(f"[bold]Model used:[/bold] {model_name}")
+            rprint(f"[bold]Total cost:[/bold] ${total_cost:.6f}")
+            if output:
+                rprint(f"[bold]Code saved to:[/bold] {output_file_paths['output']}")
+
+        return generated_code, total_cost, model_name
+
+    except Exception as e:
+        if not ctx.obj.get('quiet', False):
+            rprint(f"[bold red]Error:[/bold red] {str(e)}")
+        sys.exit(1)

pdd/comment_line.py

@@ -0,0 +1,35 @@
+# To achieve the functionality described, we can write a Python function `comment_line` that handles the different scenarios for commenting out a line of code based on the provided `comment_characters`. Here's how you can implement this function:
+
+# ```python
+def comment_line(code_line, comment_characters):
+    # Check if the language requires deletion of the line
+    if comment_characters == 'del':
+        return ''
+    
+    # Check if the language uses separate start and end comment characters
+    if ' ' in comment_characters:
+        start_comment, end_comment = comment_characters.split(' ', 1)
+        return f"{start_comment}{code_line}{end_comment}"
+    
+    # For languages with a single comment character
+    return f"{comment_characters}{code_line}"
+
+# Example usage:
+# Python style comment
+# print(comment_line("print('Hello World!')", "#"))  # Output: "#print('Hello World!')"
+
+# # HTML style comment
+# print(comment_line("<h1>Hello World!</h1>", "<!-- -->"))  # Output: "<!--<h1>Hello World!</h1>-->"
+
+# # Language with no comment character (deletion)
+# print(comment_line("some code", "del"))  # Output: ""
+# ```
+
+# ### Explanation:
+# 1. **Deletion Case**: If `comment_characters` is `'del'`, the function returns an empty string, effectively "deleting" the line.
+
+# 2. **Encapsulating Comments**: If `comment_characters` contains a space, it indicates that the language uses separate start and end comment characters. The function splits the string into `start_comment` and `end_comment` and returns the line encapsulated by these.
+
+# 3. **Single Comment Character**: For languages with a single comment character (like Python's `#`), the function simply prepends the `comment_characters` to the `code_line`.
+
+# This function should handle the specified scenarios for commenting out lines in different programming languages.

pdd/conflicts_in_prompts.py

@@ -0,0 +1,143 @@
+from typing import List, Tuple
+from pydantic import BaseModel, Field
+from rich import print as rprint
+from rich.markdown import Markdown
+from .load_prompt_template import load_prompt_template
+from .llm_invoke import llm_invoke
+
+class ConflictChange(BaseModel):
+    prompt_name: str = Field(description="Name of the prompt that needs to be changed")
+    change_instructions: str = Field(description="Detailed instructions on how to change the prompt")
+
+class ConflictResponse(BaseModel):
+    changes_list: List[ConflictChange] = Field(description="List of changes needed to resolve conflicts")
+
+def conflicts_in_prompts(
+    prompt1: str,
+    prompt2: str,
+    strength: float = 0.5,
+    temperature: float = 0,
+    verbose: bool = False
+) -> Tuple[List[dict], float, str]:
+    """
+    Analyze two prompts for conflicts and suggest resolutions.
+
+    Args:
+        prompt1 (str): First prompt to compare
+        prompt2 (str): Second prompt to compare
+        strength (float): Model strength (0-1)
+        temperature (float): Model temperature (0-1)
+        verbose (bool): Whether to print detailed information
+
+    Returns:
+        Tuple[List[dict], float, str]: (changes list, total cost, model name)
+    """
+    # Input validation - let these raise ValueError directly
+    if not prompt1 or not prompt2:
+        raise ValueError("Both prompts must be provided")
+    if not (0 <= strength <= 1):
+        raise ValueError("Strength must be between 0 and 1")
+    if not (0 <= temperature <= 1):
+        raise ValueError("Temperature must be between 0 and 1")
+
+    total_cost = 0.0
+    model_name = ""
+
+    try:
+        # Step 1: Load prompt templates
+        conflict_prompt = load_prompt_template("conflict_LLM")
+        extract_prompt = load_prompt_template("extract_conflict_LLM")
+
+        if not conflict_prompt or not extract_prompt:
+            raise ValueError("Failed to load prompt templates")
+
+        # Step 2: First LLM call to analyze conflicts
+        input_json = {
+            "PROMPT1": prompt1,
+            "PROMPT2": prompt2
+        }
+
+        if verbose:
+            rprint("[blue]Analyzing prompts for conflicts...[/blue]")
+
+        conflict_response = llm_invoke(
+            prompt=conflict_prompt,
+            input_json=input_json,
+            strength=strength,
+            temperature=temperature,
+            verbose=verbose
+        )
+
+        total_cost += conflict_response['cost']
+        model_name = conflict_response['model_name']
+
+        if verbose:
+            rprint(Markdown(conflict_response['result']))
+
+        # Step 3: Second LLM call to extract structured conflicts
+        extract_input = {
+            "llm_output": conflict_response['result']
+        }
+
+        if verbose:
+            rprint("[blue]Extracting structured conflict information...[/blue]")
+
+        extract_response = llm_invoke(
+            prompt=extract_prompt,
+            input_json=extract_input,
+            strength=0.89,  # As specified
+            temperature=temperature,
+            output_pydantic=ConflictResponse,
+            verbose=verbose
+        )
+
+        total_cost += extract_response['cost']
+        
+        # Get the changes list from the Pydantic model
+        changes_list = [
+            change.dict() 
+            for change in extract_response['result'].changes_list
+        ]
+
+        # Step 4: Return results
+        return changes_list, total_cost, model_name
+
+    except Exception as e:
+        error_msg = f"Error in conflicts_in_prompts: {str(e)}"
+        if verbose:
+            rprint(f"[red]{error_msg}[/red]")
+        if isinstance(e, ValueError):
+            raise e
+        raise RuntimeError(error_msg)
+
+def main():
+    """
+    Example usage of the conflicts_in_prompts function.
+    """
+    # Example prompts
+    prompt1 = "Write a formal business email in a serious tone."
+    prompt2 = "Write a casual, funny email with jokes."
+
+    try:
+        changes_list, total_cost, model_name = conflicts_in_prompts(
+            prompt1=prompt1,
+            prompt2=prompt2,
+            strength=0.7,
+            temperature=0,
+            verbose=True
+        )
+
+        rprint("\n[green]Results:[/green]")
+        rprint(f"[blue]Model Used:[/blue] {model_name}")
+        rprint(f"[blue]Total Cost:[/blue] ${total_cost:.6f}")
+        
+        rprint("\n[blue]Suggested Changes:[/blue]")
+        for change in changes_list:
+            rprint(f"[yellow]Prompt:[/yellow] {change['prompt_name']}")
+            rprint(f"[yellow]Instructions:[/yellow] {change['change_instructions']}\n")
+
+    except Exception as e:
+        rprint(f"[red]Error in main: {str(e)}[/red]")
+
+if __name__ == "__main__":
+    main()

pdd/conflicts_main.py

@@ -0,0 +1,90 @@
+import csv
+import sys
+from typing import List, Dict, Tuple, Optional
+import click
+from rich import print as rprint
+
+from .construct_paths import construct_paths
+from .conflicts_in_prompts import conflicts_in_prompts
+
+def conflicts_main(ctx: click.Context, prompt1: str, prompt2: str, output: Optional[str], verbose: bool = False) -> Tuple[List[Dict], float, str]:
+    """
+    Main function to analyze conflicts between two prompts.
+
+    :param ctx: Click context containing command-line parameters.
+    :param prompt1: Path to the first prompt file.
+    :param prompt2: Path to the second prompt file.
+    :param output: Optional path to save the output CSV file.
+    :param verbose: Optional parameter to control verbosity (default: False).
+    :return: A tuple containing the list of conflicts, total cost, and model name used.
+    """
+    try:
+        # Construct file paths
+        input_file_paths = {
+            "prompt1": prompt1,
+            "prompt2": prompt2
+        }
+        command_options = {
+            "output": output
+        }
+        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="conflicts",
+            command_options=command_options
+        )
+
+        # Load input files
+        prompt1_content = input_strings["prompt1"]
+        prompt2_content = input_strings["prompt2"]
+
+        # Analyze conflicts
+        strength = ctx.obj.get('strength', 0.9)
+        temperature = ctx.obj.get('temperature', 0)
+        conflicts, total_cost, model_name = conflicts_in_prompts(
+            prompt1_content,
+            prompt2_content,
+            strength,
+            temperature
+        )
+
+        # Replace prompt1 and prompt2 with actual file paths
+        for conflict in conflicts:
+            if conflict['prompt_name'] == 'prompt_1':
+                conflict['prompt_name'] = prompt1
+            elif conflict['prompt_name'] == 'prompt_2':
+                conflict['prompt_name'] = prompt2
+
+        # Save results
+        with open(output_file_paths["output"], 'w', newline='') as csvfile:
+            fieldnames = ['prompt_name', 'change_instructions']
+            writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
+            writer.writeheader()
+            for conflict in conflicts:
+                writer.writerow(conflict)
+
+        # Provide user feedback
+        if not ctx.obj.get('quiet', False):
+            rprint("[bold green]Conflict analysis completed successfully.[/bold green]")
+            rprint(f"[bold]Model used:[/bold] {model_name}")
+            rprint(f"[bold]Total cost:[/bold] ${total_cost:.6f}")
+            if output:
+                rprint(f"[bold]Results saved to:[/bold] {output_file_paths['output']}")
+
+        # Always print conflicts, even in quiet mode
+        rprint("[bold]Conflicts detected:[/bold]")
+        if conflicts:
+            for conflict in conflicts:
+                rprint(f"[bold]Prompt:[/bold] {conflict['prompt_name']}")
+                rprint(f"[bold]Instructions:[/bold] {conflict['change_instructions']}")
+                rprint("---")
+        else:
+            rprint("No conflicts detected or changes suggested.")
+
+        return conflicts, total_cost, model_name
+
+    except Exception as e:
+        if not ctx.obj.get('quiet', False):
+            rprint(f"[bold red]Error:[/bold red] {str(e)}")
+        sys.exit(1)