pdd-cli 0.0.2__py3-none-any.whl

pdd/crash_main.py

@@ -0,0 +1,127 @@
+import sys
+from typing import Tuple, Optional
+import click
+from rich import print as rprint
+
+from .construct_paths import construct_paths
+from .fix_code_loop import fix_code_loop
+
+def crash_main(
+    ctx: click.Context,
+    prompt_file: str,
+    code_file: str,
+    program_file: str,
+    error_file: str,
+    output: Optional[str] = None,
+    output_program: Optional[str] = None,
+    loop: bool = False,
+    max_attempts: Optional[int] = None,
+    budget: Optional[float] = None
+) -> Tuple[bool, str, str, int, float, str]:
+    """
+    Main function to fix errors in a code module and its calling program that caused a crash.
+
+    :param ctx: Click context containing command-line parameters.
+    :param prompt_file: Path to the prompt file that generated the code module.
+    :param code_file: Path to the code module that caused the crash.
+    :param program_file: Path to the program that was running the code module.
+    :param error_file: Path to the file containing the error messages.
+    :param output: Optional path to save the fixed code file.
+    :param output_program: Optional path to save the fixed program file.
+    :param loop: Enable iterative fixing process.
+    :param max_attempts: Maximum number of fix attempts before giving up.
+    :param budget: Maximum cost allowed for the fixing process.
+    :return: A tuple containing:
+        - bool: Success status
+        - str: The final fixed code module
+        - str: The final fixed program
+        - int: Total number of fix attempts made
+        - float: Total cost of all fix attempts
+        - str: The name of the model used
+    """
+    try:
+        # Construct file paths
+        input_file_paths = {
+            "prompt_file": prompt_file,
+            "code_file": code_file,
+            "program_file": program_file,
+            "error_file": error_file
+        }
+        command_options = {
+            "output": output,
+            "output_program": output_program
+        }
+        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="crash",
+            command_options=command_options
+        )
+
+        # Load input files
+        prompt_content = input_strings["prompt_file"]
+        code_content = input_strings["code_file"]
+        program_content = input_strings["program_file"]
+        error_content = input_strings["error_file"]
+
+        # Get model parameters from context
+        strength = ctx.obj.get('strength', 0.9)
+        temperature = ctx.obj.get('temperature', 0)
+
+        if loop:
+            # Use iterative fixing process
+            success, final_code, final_program, attempts, cost, model = fix_code_loop(
+                code_file=code_file,
+                prompt=prompt_content,
+                verification_program=program_file,
+                strength=strength,
+                temperature=temperature,
+                max_attempts=max_attempts or 3,
+                budget=budget or 5.0,
+                error_log_file=error_file,
+                verbose=not ctx.obj.get('verbose', False)
+            )
+        else:
+            # Use single fix attempt
+            from .fix_code_module_errors import fix_code_module_errors
+            _, _, final_program, final_code, cost, model = fix_code_module_errors(
+                program=program_content,
+                prompt=prompt_content,
+                code=code_content,
+                errors=error_content,
+                strength=strength,
+                temperature=temperature,
+                verbose=not ctx.obj.get('verbose', False)
+            )
+            success = True
+            attempts = 1
+
+        # Save results
+        if output_file_paths.get("output"):
+            with open(output_file_paths["output"], 'w') as f:
+                f.write(final_code)
+        if output_file_paths.get("output_program"):
+            with open(output_file_paths["output_program"], 'w') as f:
+                f.write(final_program)
+
+        # Provide user feedback
+        if not ctx.obj.get('quiet', False):
+            if success:
+                rprint("[bold green]Crash fix completed successfully.[/bold green]")
+            else:
+                rprint("[bold yellow]Crash fix completed with some issues.[/bold yellow]")
+            rprint(f"[bold]Model used:[/bold] {model}")
+            rprint(f"[bold]Total attempts:[/bold] {attempts}")
+            rprint(f"[bold]Total cost:[/bold] ${cost:.6f}")
+            if output:
+                rprint(f"[bold]Fixed code saved to:[/bold] {output_file_paths['output']}")
+            if output_program:
+                rprint(f"[bold]Fixed program saved to:[/bold] {output_file_paths['output_program']}")
+
+        return success, final_code, final_program, attempts, cost, model
+
+    except Exception as e:
+        if not ctx.obj.get('quiet', False):
+            rprint(f"[bold red]Error:[/bold red] {str(e)}")
+        sys.exit(1)

pdd/data/language_format.csv

@@ -0,0 +1,61 @@
+language,comment,extension
+Python,#,.py
+Java,//,.java
+C++,//,.cpp
+JavaScript,//,.js
+HTML,"<!-- -->",.html
+CSS,"/**/",.css
+Ruby,#,.rb
+PHP,//,.php
+Swift,//,.swift
+Go,//,.go
+Rust,//,.rs
+Kotlin,//,.kt
+TypeScript,//,.ts
+C#,//,.cs
+SQL,--,.sql
+Shell,#,.sh
+Bash,#,.sh
+Fish,#,.fish
+Zsh,#,.zsh
+PowerShell,#,.ps1
+Perl,#,.pl
+R,#,.R
+MATLAB,%,.m
+Lua,--,.lua
+Haskell,--,.hs
+Scala,//,.scala
+Groovy,//,.groovy
+Dart,//,.dart
+F#,//,.fs
+YAML,#,.yml
+JSON,del,.json
+XML,"<!-- -->",.xml
+Makefile,#,
+CSV,del,.csv
+Markdown,del,.md
+LaTeX,%,.tex
+Assembly,;,.asm
+Fortran,!,.f90
+COBOL,*>,.cob
+Lisp,;,.lisp
+Prolog,%,.pl
+Erlang,%,.erl
+Clojure,;,.clj
+Julia,#,.jl
+Elixir,#,.ex
+Pascal,//,.pas
+VBScript,"'",.vbs
+CoffeeScript,#,.coffee
+Objective-C,//,.m
+Scheme,;,.scm
+Tcl,#,.tcl
+D,//,.d
+Ada,--,.ada
+Nim,#,.nim
+OCaml,"(**)",.ml
+LLM,del,.prompt
+prompt,del,.prompt
+TOML,#,.toml
+Log,del,.log
+reStructuredText,del,.rst

pdd/data/llm_model.csv

@@ -0,0 +1,15 @@
+provider,model,input,output,coding_arena_elo,base_url,api_key,counter,encoder,max_tokens,max_completion_tokens,structured_output
+OpenAI,"o1-mini-2024-09-12",3,12,1301,,,tiktoken,o200k_base,,65536,False
+OpenAI,"deepseek-coder",0.14,0.28,1256,"https://api.deepseek.com/beta","DEEPSEEK_API_KEY",autotokenizer,deepseek-coder-7b-instruct-v1.5,8192,,False
+Ollama,"qwen2.5-coder:32b-instruct-fp16",0.0,0.0,1227,,,,,,,False
+Ollama,"athene-v2:72b-q8_0",0.0,0.0,1253,,,,,,,False
+Anthropic,"claude-3-5-sonnet-20241022",3,15,1309,,,anthropic,claude-3-sonnet-20240229,8192,,False
+Google,"gemini-2.0-flash-exp",0.15,0.60,1281,,,,,8192,,False
+Fireworks,"accounts/fireworks/models/llama-v3p3-70b-instruct",3,3,1280,,,,,16384,,False
+Fireworks,"accounts/fireworks/models/qwen2p5-coder-32b-instruct",.9,.9,1226,,,,,2048,,False
+OpenAI,"gpt-4o-mini",0.15,0.60,1246,,,tiktoken,o200k_base,16384,,True
+OpenAI,"gpt-4o-2024-11-20",2.5,10,1306,,,tiktoken,o200k_base,16384,,True
+OpenAI,"o1-2024-12-17",15,60,1311,,,tiktoken,o200k_base,,32768,False
+OpenAI,"grok-beta",5,15,1255,"https://api.x.ai/v1","XAI_API_KEY",tiktoken,o200k_base,4096,,False
+Google,"gemini-exp-1206",0.15,0.60,1321,,,,,8192,,False
+Anthropic,"claude-3-5-haiku-20241022",1,5,1265,,,anthropic,claude-3-sonnet-20240229,8192,,False

pdd/detect_change.py

@@ -0,0 +1,142 @@
+from typing import List, Dict, Tuple
+from pathlib import Path
+from rich.console import Console
+from rich.markdown import Markdown
+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 ChangeInstruction(BaseModel):
+    prompt_name: str = Field(description="Name of the prompt file that needs changes")
+    change_instructions: str = Field(description="Detailed instructions for the changes needed")
+
+class ChangesList(BaseModel):
+    changes_list: List[ChangeInstruction] = Field(description="List of changes to be made")
+
+def detect_change(
+    prompt_files: List[str],
+    change_description: str,
+    strength: float,
+    temperature: float,
+    verbose: bool = False
+) -> Tuple[List[Dict[str, str]], float, str]:
+    """
+    Analyze prompt files and determine which ones need changes based on a change description.
+
+    Args:
+        prompt_files (List[str]): List of prompt file names to analyze
+        change_description (str): Description of the changes to analyze
+        strength (float): Strength parameter for the LLM model
+        temperature (float): Temperature parameter for the LLM model
+        verbose (bool): Whether to print detailed information
+
+    Returns:
+        Tuple[List[Dict[str, str]], float, str]: Changes list, total cost, and model name
+    """
+    try:
+        # Step 1: Load and preprocess prompt templates
+        detect_change_prompt = load_prompt_template("detect_change_LLM")
+        if not detect_change_prompt:
+            raise ValueError("Failed to load detect_change_LLM prompt template")
+
+        extract_prompt = load_prompt_template("extract_detect_change_LLM")
+        if not extract_prompt:
+            raise ValueError("Failed to load extract_detect_change_LLM prompt template")
+
+        # Preprocess detect_change prompt
+        processed_detect_prompt = preprocess(
+            detect_change_prompt,
+            recursive=False,
+            double_curly_brackets=True,
+            exclude_keys=["PROMPT_LIST", "CHANGE_DESCRIPTION"]
+        )
+
+        # Step 2: Create prompt list and process change description
+        prompt_list = []
+        total_cost = 0.0
+
+        for prompt_file in prompt_files:
+            try:
+                with open(prompt_file, 'r') as f:
+                    prompt_content = f.read()
+                prompt_list.append({
+                    "PROMPT_NAME": Path(prompt_file).name,
+                    "PROMPT_DESCRIPTION": prompt_content
+                })
+            except FileNotFoundError:
+                console.print(f"[red]Warning: Could not find prompt file: {prompt_file}[/red]")
+                continue
+
+        processed_change_description = preprocess(
+            change_description,
+            recursive=False,
+            double_curly_brackets=False
+        )
+
+        # Run initial LLM analysis
+        detect_response = llm_invoke(
+            prompt=processed_detect_prompt,
+            input_json={
+                "PROMPT_LIST": prompt_list,
+                "CHANGE_DESCRIPTION": processed_change_description
+            },
+            strength=strength,
+            temperature=temperature,
+            verbose=verbose
+        )
+
+        if verbose:
+            console.print("[bold blue]Initial Analysis Results:[/bold blue]")
+            console.print(f"Token count: {detect_response.get('token_count', 0)}")
+            console.print(f"Cost: ${detect_response.get('cost', 0):.6f}")
+
+        total_cost += detect_response.get('cost', 0)
+        model_name = detect_response.get('model_name', '')
+
+        # Step 3: Extract specific changes
+        extract_response = llm_invoke(
+            prompt=extract_prompt,
+            input_json={"llm_output": detect_response['result']},
+            strength=0.89,
+            temperature=0.0,
+            verbose=verbose,
+            output_pydantic=ChangesList
+        )
+
+        total_cost += extract_response.get('cost', 0)
+
+        if verbose:
+            console.print("[bold blue]Extraction Results:[/bold blue]")
+            console.print(f"Token count: {extract_response.get('token_count', 0)}")
+            console.print(f"Cost: ${extract_response.get('cost', 0):.6f}")
+
+        # Step 4: Format and display results
+        changes_list = extract_response['result'].changes_list
+        if verbose:
+            console.print("\n[bold green]Detected Changes:[/bold green]")
+            for change in changes_list:
+                md = Markdown(f"""
+                ### Prompt: {change.prompt_name}
+                **Change Instructions:**
+                {change.change_instructions}
+                """)
+                console.print(md)
+            console.print(f"\n[bold]Total Cost: ${total_cost:.6f}[/bold]")
+            console.print(f"[bold]Model Used: {model_name}[/bold]")
+
+        # Step 5: Return results
+        return [
+            {
+                "prompt_name": change.prompt_name,
+                "change_instructions": change.change_instructions
+            }
+            for change in changes_list
+        ], total_cost, model_name
+
+    except Exception as e:
+        console.print(f"[red]Error in detect_change: {str(e)}[/red]")
+        raise

pdd/detect_change_main.py

@@ -0,0 +1,100 @@
+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 .detect_change import detect_change
+
+def detect_change_main(
+    ctx: click.Context,
+    prompt_files: List[str],
+    change_file: str,
+    output: Optional[str]
+) -> Tuple[List[Dict], float, str]:
+    """
+    CLI wrapper function to analyze which prompts need to be changed based on a change description.
+
+    Args:
+        ctx: Click context containing command-line parameters
+        prompt_files: List of filenames of prompts that may need to be changed
+        change_file: Filename containing the change description
+        output: Optional path to save the CSV file containing analysis results
+
+    Returns:
+        Tuple containing:
+        - List of dictionaries with analysis results
+        - Total cost of the operation
+        - Name of the model used
+    """
+    try:
+        # Construct file paths
+        input_file_paths = {
+            "change_file": change_file,
+            **{f"prompt_file_{i}": pf for i, pf in enumerate(prompt_files)}
+        }
+        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="detect",
+            command_options=command_options
+        )
+
+        # Get change description content
+        change_description = input_strings["change_file"]
+
+        # Get prompt contents
+        prompt_contents = [input_strings[f"prompt_file_{i}"] for i in range(len(prompt_files))]
+
+        # Get model parameters from context
+        strength = ctx.obj.get('strength', 0.9)
+        temperature = ctx.obj.get('temperature', 0)
+
+        # Analyze which prompts need changes
+        changes_list, total_cost, model_name = detect_change(
+            prompt_files,
+            change_description,
+            strength,
+            temperature,
+            verbose=not ctx.obj.get('quiet', False)
+        )
+
+        # Save results to CSV if output path is specified
+        if output_file_paths.get("output"):
+            with open(output_file_paths["output"], 'w', newline='') as csvfile:
+                fieldnames = ['prompt_name', 'change_instructions']
+                writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
+                writer.writeheader()
+                for change in changes_list:
+                    writer.writerow(change)
+
+        # Provide user feedback
+        if not ctx.obj.get('quiet', False):
+            rprint("[bold green]Change detection 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']}")
+
+            # Display detected changes
+            rprint("\n[bold]Changes needed:[/bold]")
+            if changes_list:
+                for change in changes_list:
+                    rprint(f"[bold]Prompt:[/bold] {change['prompt_name']}")
+                    rprint(f"[bold]Instructions:[/bold] {change['change_instructions']}")
+                    rprint("---")
+            else:
+                rprint("No changes needed for any of the analyzed prompts.")
+
+        return changes_list, 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/find_section.py

@@ -0,0 +1,28 @@
+def find_section(lines, start_index=0, sub_section=False):
+    sections = []
+    stack = []
+    
+    for i, line in enumerate(lines):
+        line = line.strip()
+        
+        if line.startswith('```'):
+            if len(line) > 3:
+                # Opening of a new block
+                stack.append((i, line[3:].strip()))
+            elif stack:
+                # Closing of a block
+                start, lang = stack.pop()
+                if not stack:  # This is a top-level block
+                    if start >= start_index:
+                        if sub_section:
+                            return [(lang, start, i)]
+                        else:
+                            sections.append((lang, start, i))
+
+    # Handle unclosed blocks
+    while stack:
+        start, lang = stack.pop()
+        if not stack and start >= start_index:  # This is a top-level block
+            sections.append((lang, start, len(lines) - 1))
+    
+    return sections

pdd/fix_code_loop.py

@@ -0,0 +1,212 @@
+import os
+import subprocess
+import shutil
+from rich.console import Console
+from rich import print as rprint
+from pdd.fix_code_module_errors import fix_code_module_errors
+
+def fix_code_loop(
+    code_file: str,
+    prompt: str,
+    verification_program: str,
+    strength: float,
+    temperature: float,
+    max_attempts: int,
+    budget: float,
+    error_log_file: str = "error_code.log",
+    verbose: bool = False,
+) -> tuple[bool, str, str, int, float, str]:
+    """
+    Attempts to fix errors in a code module through multiple iterations.
+
+    Args:
+        code_file: Path to the code file being tested.
+        prompt: Prompt that generated the code under test.
+        verification_program: Path to a Python program that verifies if the code runs correctly.
+        strength: Strength of the LLM model to use.
+        temperature: Temperature parameter for the LLM model.
+        max_attempts: Maximum number of fix attempts before giving up.
+        budget: Maximum cost allowed for the fixing process.
+        error_log_file: Path to the error log file (default: "error_code.log").
+        verbose: Enable detailed logging of the fixing process (default: False).
+
+    Returns:
+        success: Whether the errors were successfully fixed.
+        final_program: Contents of the final verification program file.
+        final_code: Contents of the final code file.
+        total_attempts: Number of fix attempts made.
+        total_cost: Total cost of all fix attempts.
+        model_name: Name of the LLM model used.
+    """
+
+    console = Console()
+
+    # Step 1: Remove existing error log file
+    if os.path.exists(error_log_file):
+        os.remove(error_log_file)
+
+    # Step 2: Initialize variables
+    total_attempts = 0
+    total_cost = 0.0
+    model_name = ""
+
+    # Check if verification program exists
+    if not os.path.exists(verification_program):
+        error_message = f"Error: Verification program not found at {verification_program}"
+        rprint(f"[bold red]{error_message}[/bold red]")
+        with open(error_log_file, "a") as f:
+            f.write(error_message + "\n")
+        return False, "", "", total_attempts, total_cost, model_name
+
+    # Create backup copies of the original files
+    original_verification_program = verification_program + ".original"
+    original_code_file = code_file + ".original"
+    shutil.copy(verification_program, original_verification_program)
+    shutil.copy(code_file, original_code_file)
+
+    # Step 3: Main loop
+    success = False
+    while total_attempts < max_attempts:
+        rprint(f"\n[bold blue]Attempt: {total_attempts + 1}[/bold blue]")
+        with open(error_log_file, "a") as f:
+            f.write(f"\nAttempt: {total_attempts + 1}\n")
+
+        # Run the verification program
+        try:
+            result = subprocess.run(
+                ["python", verification_program],
+                capture_output=True,
+                text=True,
+                check=False,
+            )
+            with open(error_log_file, "a") as f:
+                f.write(result.stdout)
+                f.write(result.stderr)
+
+            # Check for successful execution
+            if result.returncode == 0:
+                rprint("[bold green]Code ran successfully![/bold green]")
+                success = True
+                break
+
+        except FileNotFoundError:
+            error_message = f"Error: Verification program not found at {verification_program}"
+            rprint(f"[bold red]{error_message}[/bold red]")
+            with open(error_log_file, "a") as f:
+                f.write(error_message + "\n")
+            return False, "", "", total_attempts, total_cost, model_name
+
+        # If we get here, code failed
+        rprint("[bold red]Code execution failed.[/bold red]")
+        with open(error_log_file, "r") as f:
+            error_message = f.read()
+
+        # Escape square brackets for Rich printing
+        escaped_error_message = error_message.replace("[", "\\[").replace("]", "\\]")
+        rprint(f"[bold red]Errors found:\n[/bold red]{escaped_error_message}")
+
+        # Create iteration backups
+        verification_program_backup = (verification_program.rsplit(".", 1)[0]
+                                       + f"_{total_attempts + 1}."
+                                       + verification_program.rsplit(".", 1)[1])
+        code_file_backup = (code_file.rsplit(".", 1)[0]
+                            + f"_{total_attempts + 1}."
+                            + code_file.rsplit(".", 1)[1])
+        shutil.copy(verification_program, verification_program_backup)
+        shutil.copy(code_file, code_file_backup)
+
+        # Read current file contents
+        try:
+            with open(verification_program, "r") as f:
+                program_content = f.read()
+            with open(code_file, "r") as f:
+                code_content = f.read()
+        except FileNotFoundError as e:
+            rprint(f"[bold red]Error reading files: {e}[/bold red]")
+            with open(error_log_file, "a") as f:
+                f.write(f"Error reading files: {e}\n")
+            return False, "", "", total_attempts, total_cost, model_name
+
+        # Check budget before calling fix_code_module_errors
+        if total_cost >= budget:
+            rprint(f"[bold red]Budget exceeded. Stopping.[/bold red]")
+            success = False
+            break
+
+        # Call fix_code_module_errors
+        temp_console = Console(file=open(os.devnull, "w"), record=True)
+        with temp_console.capture() as capture:
+            update_program, update_code, fixed_program, fixed_code, cost, model_name = fix_code_module_errors(
+                program=program_content,
+                prompt=prompt,
+                code=code_content,
+                errors=error_message,
+                strength=strength,
+                temperature=temperature,
+                verbose=verbose,
+            )
+        captured_output = temp_console.export_text()
+        rprint(captured_output)
+        with open(error_log_file, "a") as f:
+            f.write(captured_output)
+
+        # Add the cost of this fix attempt
+        total_cost += cost
+
+        # Now increment attempts right after we’ve incurred cost
+        total_attempts += 1
+
+        # Check budget after fix
+        if total_cost > budget:
+            rprint("[bold red]Budget exceeded after fix attempt. Stopping.[/bold red]")
+            success = False
+            break
+
+        # If no changes to either file, nothing more to do
+        if not update_program and not update_code:
+            rprint("[bold yellow]No changes needed. Stopping.[/bold yellow]")
+            success = False
+            break
+
+        # Overwrite code file if updated
+        if update_code:
+            try:
+                with open(code_file, "w") as f:
+                    f.write(fixed_code)
+            except FileNotFoundError as e:
+                rprint(f"[bold red]Error writing to code file: {e}[/bold red]")
+                with open(error_log_file, "a") as f:
+                    f.write(f"Error writing to code file: {e}\n")
+                return False, "", "", total_attempts, total_cost, model_name
+
+        # Overwrite verification program if updated
+        if update_program:
+            try:
+                with open(verification_program, "w") as f:
+                    f.write(fixed_program)
+            except FileNotFoundError as e:
+                rprint(f"[bold red]Error writing to verification program: {e}[/bold red]")
+                with open(error_log_file, "a") as f:
+                    f.write(f"Error writing to verification program: {e}\n")
+                return False, "", "", total_attempts, total_cost, model_name
+
+    # Step 4: If not successful, restore the original files
+    if not success:
+        rprint("[bold yellow]Restoring original files.[/bold yellow]")
+        shutil.copy(original_verification_program, verification_program)
+        shutil.copy(original_code_file, code_file)
+        final_program = ""
+        final_code = ""
+    else:
+        try:
+            with open(verification_program, "r") as f:
+                final_program = f.read()
+            with open(code_file, "r") as f:
+                final_code = f.read()
+        except FileNotFoundError as e:
+            rprint(f"[bold red]Error reading final files: {e}[/bold red]")
+            with open(error_log_file, "a") as f:
+                f.write(f"Error reading final files: {e}\n")
+            return False, "", "", total_attempts, total_cost, model_name
+
+    return success, final_program, final_code, total_attempts, total_cost, model_name