pdd-cli 0.0.2__py3-none-any.whl

pdd/fix_main.py

@@ -0,0 +1,138 @@
+import sys
+from typing import Tuple, Optional
+import click
+from rich import print as rprint
+
+from .construct_paths import construct_paths
+from .fix_errors_from_unit_tests import fix_errors_from_unit_tests
+from .fix_error_loop import fix_error_loop
+
+def fix_main(
+    ctx: click.Context,
+    prompt_file: str,
+    code_file: str,
+    unit_test_file: str,
+    error_file: str,
+    output_test: Optional[str],
+    output_code: Optional[str],
+    output_results: Optional[str],
+    loop: bool,
+    verification_program: Optional[str],
+    max_attempts: int,
+    budget: float,
+    auto_submit: bool
+) -> Tuple[bool, str, str, int, float, str]:
+    """
+    Main function to fix errors in code and unit tests.
+
+    Args:
+        ctx: Click context containing command-line parameters
+        prompt_file: Path to the prompt file that generated the code
+        code_file: Path to the code file to be fixed
+        unit_test_file: Path to the unit test file
+        error_file: Path to the error log file
+        output_test: Path to save the fixed unit test file
+        output_code: Path to save the fixed code file
+        output_results: Path to save the fix results
+        loop: Whether to use iterative fixing process
+        verification_program: Path to program that verifies code correctness
+        max_attempts: Maximum number of fix attempts
+        budget: Maximum cost allowed for fixing
+        auto_submit: Whether to auto-submit example if tests pass
+
+    Returns:
+        Tuple containing:
+        - Success status (bool)
+        - Fixed unit test code (str)
+        - Fixed source code (str)
+        - Total number of fix attempts (int)
+        - Total cost of operation (float)
+        - Name of model used (str)
+    """
+    # Check verification program requirement before any file operations
+    if loop and not verification_program:
+        raise click.UsageError("--verification-program is required when using --loop")
+
+    try:
+        # Construct file paths
+        input_file_paths = {
+            "prompt_file": prompt_file,
+            "code_file": code_file,
+            "unit_test_file": unit_test_file
+        }
+        if not loop:
+            input_file_paths["error_file"] = error_file
+
+        command_options = {
+            "output_test": output_test,
+            "output_code": output_code,
+            "output_results": output_results
+        }
+
+        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="fix",
+            command_options=command_options
+        )
+
+        # Get parameters from context
+        strength = ctx.obj.get('strength', 0.9)
+        temperature = ctx.obj.get('temperature', 0)
+
+        if loop:
+            # Use fix_error_loop for iterative fixing
+            success, fixed_unit_test, fixed_code, attempts, total_cost, model_name = fix_error_loop(
+                unit_test_file=unit_test_file,
+                code_file=code_file,
+                prompt=input_strings["prompt_file"],
+                verification_program=verification_program,
+                strength=strength,
+                temperature=temperature,
+                max_attempts=max_attempts,
+                budget=budget,
+                error_log_file=output_file_paths.get("output_results")
+            )
+        else:
+            # Use fix_errors_from_unit_tests for single-pass fixing
+            update_unit_test, update_code, fixed_unit_test, fixed_code, total_cost, model_name = fix_errors_from_unit_tests(
+                unit_test=input_strings["unit_test_file"],
+                code=input_strings["code_file"],
+                prompt=input_strings["prompt_file"],
+                error=input_strings["error_file"],
+                error_file=output_file_paths.get("output_results"),
+                strength=strength,
+                temperature=temperature
+            )
+            success = update_unit_test or update_code
+            attempts = 1
+
+        # Save fixed files
+        if fixed_unit_test:
+            with open(output_file_paths["output_test"], 'w') as f:
+                f.write(fixed_unit_test)
+
+        if fixed_code:
+            with open(output_file_paths["output_code"], 'w') as f:
+                f.write(fixed_code)
+
+        # Provide user feedback
+        if not ctx.obj.get('quiet', False):
+            rprint(f"[bold]{'Success' if success else 'Failed'} to fix errors[/bold]")
+            rprint(f"[bold]Total attempts:[/bold] {attempts}")
+            rprint(f"[bold]Total cost:[/bold] ${total_cost:.6f}")
+            rprint(f"[bold]Model used:[/bold] {model_name}")
+            if success:
+                rprint("[bold green]Fixed files saved:[/bold green]")
+                rprint(f"  Test file: {output_file_paths['output_test']}")
+                rprint(f"  Code file: {output_file_paths['output_code']}")
+                if output_file_paths.get("output_results"):
+                    rprint(f"  Results file: {output_file_paths['output_results']}")
+
+        return success, fixed_unit_test, fixed_code, attempts, 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/generate_output_paths.py

@@ -0,0 +1,194 @@
+import os
+from pathlib import Path
+
+def generate_output_paths(command, output_locations, basename, language, file_extension):
+    """
+    Generates output filenames based on command, output_locations, basename, language, and file_extension.
+
+    Args:
+        command (str): The command being executed.
+        output_locations (dict): Dictionary of output locations specified by the user.
+        basename (str): The base name of the file.
+        language (str): The programming language.
+        file_extension (str): The file extension, including the leading dot (e.g., ".py").
+
+    Returns:
+        dict: A dictionary containing the generated output filenames with full paths.
+    """
+    output_paths = {}
+    default_keys = {
+        'generate': ['output'],
+        'example': ['output'],
+        'test': ['output'],
+        'preprocess': ['output'],
+        'fix': ['output_test', 'output_code', 'output_results'],
+        'split': ['output_sub', 'output_modified'],
+        'change': ['output'],
+        'update': ['output'],
+        'detect': ['output'],
+        'conflicts': ['output'],
+        'crash': ['output', 'output_program'],
+        'trace': ['output'],
+        'bug': ['output'],
+        'auto-deps': ['output']
+    }
+
+    # Ensure output_locations has all necessary keys for the given command
+    for key in default_keys.get(command, []):
+        if key not in output_locations:
+            output_locations[key] = None
+
+    if command == 'generate':
+        output_paths['output'] = get_output_path(
+            output_locations.get('output'),
+            'PDD_GENERATE_OUTPUT_PATH',
+            f"{basename}{file_extension}"
+        )
+    elif command == 'example':
+        output_paths['output'] = get_output_path(
+            output_locations.get('output'),
+            'PDD_EXAMPLE_OUTPUT_PATH',
+            f"{basename}_example{file_extension}"
+        )
+    elif command == 'test':
+        output_paths['output'] = get_output_path(
+            output_locations.get('output'),
+            'PDD_TEST_OUTPUT_PATH',
+            f"test_{basename}{file_extension}"
+        )
+    elif command == 'preprocess':
+        output_paths['output'] = get_output_path(
+            output_locations.get('output'),
+            'PDD_PREPROCESS_OUTPUT_PATH',
+            f"{basename}_{language}_preprocessed.prompt"
+        )
+    elif command == 'fix':
+        output_paths['output_test'] = get_output_path(
+            output_locations.get('output_test'),
+            'PDD_FIX_TEST_OUTPUT_PATH',
+            f"test_{basename}_fixed{file_extension}"
+        )
+        output_paths['output_code'] = get_output_path(
+            output_locations.get('output_code'),
+            'PDD_FIX_CODE_OUTPUT_PATH',
+            f"{basename}_fixed{file_extension}"
+        )
+        output_paths['output_results'] = get_output_path(
+            output_locations.get('output_results'),
+            'PDD_FIX_RESULTS_OUTPUT_PATH',
+            f"{basename}_fix_results.log"
+        )
+    elif command == 'split':
+        output_paths['output_sub'] = get_output_path(
+            output_locations.get('output_sub'),
+            'PDD_SPLIT_SUB_PROMPT_OUTPUT_PATH',
+            f"sub_{basename}.prompt"
+        )
+        output_paths['output_modified'] = get_output_path(
+            output_locations.get('output_modified'),
+            'PDD_SPLIT_MODIFIED_PROMPT_OUTPUT_PATH',
+            f"modified_{basename}.prompt"
+        )
+    elif command == 'change':
+        output_paths['output'] = get_output_path(
+            output_locations.get('output'),
+            'PDD_CHANGE_OUTPUT_PATH',
+            f"modified_{basename}.prompt"
+        )
+    elif command == 'update':
+        output_paths['output'] = get_output_path(
+            output_locations.get('output'),
+            'PDD_UPDATE_OUTPUT_PATH',
+            f"modified_{basename}.prompt"
+        )
+    elif command == 'detect':
+        output_paths['output'] = get_output_path(
+            output_locations.get('output'),
+            'PDD_DETECT_OUTPUT_PATH',
+            f"{basename}_detect.csv"
+        )
+    elif command == 'conflicts':
+        output_paths['output'] = get_output_path(
+            output_locations.get('output'),
+            'PDD_CONFLICTS_OUTPUT_PATH',
+            f"{basename}_conflict.csv"
+        )
+    elif command == 'crash':
+        output_paths['output'] = get_output_path(
+            output_locations.get('output'),
+            'PDD_CRASH_OUTPUT_PATH',
+            f"{basename}_fixed{file_extension}"
+        )
+        output_paths['output_program'] = get_output_path(
+            output_locations.get('output_program'),
+            'PDD_CRASH_PROGRAM_OUTPUT_PATH',
+            f"{basename}_fixed{file_extension}"
+        )
+    elif command == 'trace':
+        output_paths['output'] = get_output_path(
+            output_locations.get('output'),
+            'PDD_TRACE_OUTPUT_PATH',
+            f"{basename}_trace_results.log"
+        )
+    elif command == 'bug':
+        output_paths['output'] = get_output_path(
+            output_locations.get('output'),
+            'PDD_BUG_OUTPUT_PATH',
+            f"test_{basename}_bug{file_extension}"
+        )
+    elif command == 'auto-deps':
+        output_paths['output'] = get_output_path(
+            output_locations.get('output'),
+            'PDD_AUTO_DEPS_OUTPUT_PATH',
+            f"{basename}_with_deps.prompt"
+        )
+    else:
+        raise ValueError(f"Invalid command: {command}")
+
+    return output_paths
+
+def get_output_path(user_path, env_var, default_filename):
+    """
+    Determines the output path based on user input, environment variables, and default behavior.
+    """
+    if user_path:
+        # Check if user_path is a directory
+        try:
+            # A path is considered a directory if:
+            # 1. It ends with a separator
+            # 2. It exists and is a directory
+            # 3. It doesn't contain a file extension
+            is_dir = (user_path.endswith(os.sep) or 
+                     (os.path.exists(user_path) and os.path.isdir(user_path)) or
+                     not os.path.splitext(user_path)[1])
+        except (TypeError, ValueError):
+            is_dir = user_path.endswith(os.sep)
+            
+        # If it's a directory, join with default filename
+        if is_dir:
+            path = os.path.join(user_path.rstrip(os.sep), default_filename)
+        else:
+            path = user_path
+            
+        # Create parent directory if needed
+        try:
+            parent_dir = os.path.dirname(path)
+            if parent_dir:
+                Path(parent_dir).mkdir(parents=True, exist_ok=True)
+        except (OSError, PermissionError):
+            # If we can't create the directory, just return the path
+            pass
+        return path
+    else:
+        env_path = os.environ.get(env_var)
+        if env_path:
+            path = os.path.join(env_path, default_filename)
+            try:
+                # Create parent directory if needed
+                Path(env_path).mkdir(parents=True, exist_ok=True)
+            except (OSError, PermissionError):
+                # If we can't create the directory, just return the path
+                pass
+            return path
+        else:
+            return default_filename

pdd/generate_test.py

@@ -0,0 +1,140 @@
+from typing import Tuple, Optional
+from rich import print
+from rich.markdown import Markdown
+from rich.console import Console
+from .load_prompt_template import load_prompt_template
+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 generate_test(
+    prompt: str,
+    code: str,
+    strength: float,
+    temperature: float,
+    language: str,
+    verbose: bool = False
+) -> Tuple[str, float, str]:
+    """
+    Generate a unit test from a code file using LLM.
+
+    Args:
+        prompt (str): The prompt that generated the code file.
+        code (str): The code to generate a unit test from.
+        strength (float): The strength of the LLM model (0-1).
+        temperature (float): The temperature of the LLM model.
+        language (str): The programming language for the unit test.
+        verbose (bool): Whether to print detailed information.
+
+    Returns:
+        Tuple[str, float, str]: (unit_test, total_cost, model_name)
+    """
+    total_cost = 0.0
+    model_name = ""
+
+    try:
+        # Step 1: Load prompt template
+        template = load_prompt_template("generate_test_LLM")
+        if not template:
+            raise ValueError("Failed to load generate_test_LLM prompt template")
+
+        # Step 2: Preprocess template
+        processed_template = preprocess(template, recursive=False, double_curly_brackets=False)
+        processed_prompt = preprocess(prompt, recursive=False, double_curly_brackets=False)
+
+        # Step 3: Run through LLM
+        input_json = {
+            "prompt_that_generated_code": processed_prompt,
+            "code": code,
+            "language": language
+        }
+
+        if verbose:
+            console.print("[bold blue]Generating unit test...[/bold blue]")
+
+        response = llm_invoke(
+            prompt=processed_template,
+            input_json=input_json,
+            strength=strength,
+            temperature=temperature,
+            verbose=verbose
+        )
+
+        total_cost += response['cost']
+        model_name = response['model_name']
+        result = response['result']
+
+        if verbose:
+            console.print(Markdown(result))
+            console.print(f"[bold green]Initial generation cost: ${total_cost:.6f}[/bold green]")
+
+        # Step 4: Check if generation is complete
+        last_600_chars = result[-600:] if len(result) > 600 else result
+        reasoning, is_finished, check_cost, check_model = unfinished_prompt(
+            prompt_text=last_600_chars,
+            strength=0.895,
+            temperature=temperature,
+            verbose=verbose
+        )
+        total_cost += check_cost
+
+        if not is_finished:
+            if verbose:
+                console.print("[bold yellow]Generation incomplete. Continuing...[/bold yellow]")
+            
+            continued_result, continue_cost, continue_model = continue_generation(
+                formatted_input_prompt=processed_template,
+                llm_output=result,
+                strength=strength,
+                temperature=temperature,
+                verbose=verbose
+            )
+            total_cost += continue_cost
+            result = continued_result
+            model_name = continue_model
+
+        # Process the final result
+        processed_result, post_cost, post_model = postprocess(
+            result,
+            language=language,
+            strength=0.895,
+            temperature=temperature,
+            verbose=verbose
+        )
+        total_cost += post_cost
+
+        # Step 5: Print total cost if verbose
+        if verbose:
+            console.print(f"[bold green]Total cost: ${total_cost:.6f}[/bold green]")
+            console.print(f"[bold blue]Final model used: {model_name}[/bold blue]")
+
+        # Step 6: Return results
+        return processed_result, total_cost, model_name
+
+    except Exception as e:
+        console.print(f"[bold red]Error: {str(e)}[/bold red]")
+        raise
+
+
+def _validate_inputs(
+    prompt: str,
+    code: str,
+    strength: float,
+    temperature: float,
+    language: str
+) -> None:
+    """Validate input parameters."""
+    if not prompt or not isinstance(prompt, str):
+        raise ValueError("Prompt must be a non-empty string")
+    if not code or not isinstance(code, str):
+        raise ValueError("Code must be a non-empty string")
+    if not isinstance(strength, float) or not 0 <= strength <= 1:
+        raise ValueError("Strength must be a float between 0 and 1")
+    if not isinstance(temperature, float):
+        raise ValueError("Temperature must be a float")
+    if not language or not isinstance(language, str):
+        raise ValueError("Language must be a non-empty string")

pdd/get_comment.py

@@ -0,0 +1,55 @@
+# To achieve the task of writing a Python function `get_comment` that returns the comment character(s) associated with a given programming language, we need to follow the steps outlined in your description. Here's how you can implement this:
+
+# ```python
+import os
+import csv
+
+def get_comment(language):
+    # Step 1: Load environment variables to get the path to the CSV file
+    pdd_path = os.getenv('PDD_PATH')
+    if not pdd_path:
+        return 'del'  # Return 'del' if the environment variable is not set
+
+    csv_file_path = os.path.join(pdd_path, 'data', 'language_format.csv')
+
+    # Step 2: Lower case the language string
+    language = language.lower()
+
+    try:
+        # Step 3: Open the CSV file and look up the comment character(s)
+        with open(csv_file_path, mode='r', newline='') as csvfile:
+            reader = csv.DictReader(csvfile)
+            for row in reader:
+                if row['language'].lower() == language:
+                    comment = row['comment']
+                    # Step 4: Check if the comment character(s) is valid
+                    if comment:
+                        return comment
+                    else:
+                        return 'del'
+    except FileNotFoundError:
+        return 'del'  # Return 'del' if the file is not found
+    except Exception as e:
+        return 'del'  # Return 'del' for any other exceptions
+
+    return 'del'  # Return 'del' if the language is not found
+
+# Example usage:
+# Assuming the environment variable PDD_PATH is set correctly
+# print(get_comment('Python'))  # Output: #
+# print(get_comment('Java'))    # Output: //
+# ```
+
+# ### Explanation:
+
+# 1. **Environment Variable**: The function first retrieves the `PDD_PATH` environment variable to locate the CSV file. If the environment variable is not set, it returns `'del'`.
+
+# 2. **Case Insensitivity**: The input language string is converted to lowercase to ensure case-insensitive comparison.
+
+# 3. **CSV Reading**: The function reads the CSV file using Python's `csv.DictReader`, which allows accessing each row as a dictionary. It checks if the lowercase version of the language matches any entry in the CSV.
+
+# 4. **Validation**: If a match is found, it checks if the comment character(s) is valid (i.e., not an empty string). If valid, it returns the comment character(s); otherwise, it returns `'del'`.
+
+# 5. **Error Handling**: The function handles potential errors such as file not found or other exceptions by returning `'del'`.
+
+# This implementation assumes that the CSV file is correctly formatted and that the environment variable `PDD_PATH` is set to the correct path.

pdd/get_extension.py

@@ -0,0 +1,52 @@
+# To implement the `get_extension` function as described, we will follow the steps outlined in your request. We'll use the `pandas` library to read the CSV file, and we'll handle the environment variable for the file path. Here's how you can implement this function:
+
+# ```python
+import os
+import pandas as pd
+
+def get_extension(language):
+    # Step 1: Load the environment variable PDD_PATH
+    pdd_path = os.getenv('PDD_PATH')
+    if not pdd_path:
+        raise ValueError("Environment variable PDD_PATH is not set.")
+    
+    # Construct the full path to the CSV file
+    csv_file_path = os.path.join(pdd_path, 'data', 'language_format.csv')
+    
+    # Step 2: Lower case the language string
+    language_lower = language.lower()
+    
+    # Step 3: Load the CSV file and look up the file extension
+    try:
+        df = pd.read_csv(csv_file_path)
+    except FileNotFoundError:
+        raise FileNotFoundError(f"The file {csv_file_path} does not exist.")
+    
+    # Check if the language exists in the DataFrame
+    row = df[df['language'].str.lower() == language_lower]
+    
+    # Step 4: Return the file extension or an empty string if not found
+    if not row.empty:
+        extension = row['extension'].values[0]
+        return extension if isinstance(extension, str) and extension else ''
+    
+    return ''
+
+# Example usage:
+# Assuming the environment variable PDD_PATH is set correctly
+# print(get_extension('Python'))  # Output: .py
+# ```
+
+# ### Explanation of the Code:
+# 1. **Environment Variable**: We use `os.getenv` to retrieve the `PDD_PATH` environment variable. If it's not set, we raise a `ValueError`.
+# 2. **Lowercase Language**: The input language string is converted to lowercase to ensure case-insensitive comparison.
+# 3. **Load CSV**: We use `pandas` to read the CSV file. If the file is not found, we raise a `FileNotFoundError`.
+# 4. **Lookup**: We filter the DataFrame to find the row corresponding to the given language. If found, we check if the extension is a valid string and return it; otherwise, we return an empty string.
+# 5. **Return Value**: If the language is not found, we return an empty string.
+
+# ### Note:
+# - Make sure to have the `pandas` library installed in your Python environment. You can install it using pip:
+#   ```bash
+#   pip install pandas
+#   ```
+# - Ensure that the CSV file is structured correctly and located at the specified path.

pdd/get_language.py

@@ -0,0 +1,41 @@
+import os
+import csv
+
+def get_language(extension: str) -> str:
+    """
+    Determines the programming language associated with a given file extension.
+
+    Args:
+        extension (str): The file extension to look up.
+
+    Returns:
+        str: The name of the programming language or an empty string if not found.
+
+    Raises:
+        ValueError: If PDD_PATH environment variable is not set.
+    """
+    # Step 1: Load environment variable PDD_PATH
+    pdd_path = os.environ.get('PDD_PATH')
+    if not pdd_path:
+        raise ValueError("PDD_PATH environment variable is not set")
+
+    # Step 2: Ensure the extension starts with a dot and convert to lowercase
+    if not extension.startswith('.'):
+        extension = '.' + extension
+    extension = extension.lower()
+
+    # Step 3 & 4: Look up the language name and handle exceptions
+    csv_path = os.path.join(pdd_path, 'data', 'language_format.csv')
+    try:
+        with open(csv_path, 'r') as csvfile:
+            reader = csv.DictReader(csvfile)
+            for row in reader:
+                if row['extension'].lower() == extension:
+                    language = row['language'].strip()
+                    return language if language else ''
+    except FileNotFoundError:
+        print(f"CSV file not found at {csv_path}")
+    except csv.Error as e:
+        print(f"Error reading CSV file: {e}")
+
+    return ''  # Return empty string if extension not found or any error occurs