pdd-cli 0.0.39__py3-none-any.whl → 0.0.41__py3-none-any.whl

pdd/bug_to_unit_test.py

@@ -1,5 +1,7 @@
-from typing import Tuple, Optional
-from rich import print
+"""
+This module provides functionality to generate a unit test based on a bug report.
+"""
+from typing import Tuple
 from rich.markdown import Markdown
 from rich.console import Console
 from . import EXTRACTION_STRENGTH, DEFAULT_STRENGTH, DEFAULT_TIME
@@ -12,7 +14,8 @@ from .preprocess import preprocess
 
 console = Console()
 
-def bug_to_unit_test(
+
+def bug_to_unit_test(  # pylint: disable=too-many-arguments, too-many-locals
     current_output: str,
     desired_output: str,
     prompt_used_to_generate_the_code: str,
@@ -21,7 +24,7 @@ def bug_to_unit_test(
     strength: float = DEFAULT_STRENGTH,
     temperature: float = 0.0,
     time: float = DEFAULT_TIME,
-    language: str = "python"
+    language: str = "python",
 ) -> Tuple[str, float, str]:
     """
     Generate a unit test from a code file with bug information.
@@ -32,7 +35,8 @@ def bug_to_unit_test(
         prompt_used_to_generate_the_code (str): Original prompt used to generate the code
         code_under_test (str): Code to be tested
         program_used_to_run_code_under_test (str): Program used to run the code
-        strength (float, optional): Strength of the LLM model. Must be between 0 and 1. Defaults to DEFAULT_STRENGTH.
+        strength (float, optional): Strength of the LLM model. Must be between 0 and 1.
+        Defaults to DEFAULT_STRENGTH.
         temperature (float, optional): Temperature of the LLM model. Defaults to 0.0.
         time (float, optional): Time budget for LLM calls. Defaults to DEFAULT_TIME.
         language (str, optional): Programming language. Defaults to "python".
@@ -46,11 +50,14 @@ def bug_to_unit_test(
     # Validate strength parameter
     if not 0 <= strength <= 1:
         raise ValueError("Strength parameter must be between 0 and 1")
-        
-    # Ensure language parameter is not None or empty
+
+    # Ensure language parameter is not None or empty, defaulting to "python" if it is.
+    # This single check is sufficient for the whole function.
     if not language or not isinstance(language, str):
-        language = "python"  # Default fallback
-        console.print("[yellow]Warning: Invalid language parameter, defaulting to 'python'[/yellow]")
+        language = "python"
+        console.print(
+            "[yellow]Warning: Invalid or missing language parameter, defaulting to 'python'[/yellow]"
+        )
 
     total_cost = 0.0
     final_model_name = ""
@@ -62,15 +69,15 @@ def bug_to_unit_test(
             raise ValueError("Failed to load prompt template")
 
         # Step 2: Prepare input and run through LLM
-        preprocessed_prompt = preprocess(prompt_used_to_generate_the_code)
-        
+        preprocessed_prompt = preprocess(prompt_used_to_generate_the_code, double_curly_brackets=False)
+
         input_json = {
             "prompt_that_generated_code": preprocessed_prompt,
             "current_output": current_output,
             "desired_output": desired_output,
             "code_under_test": code_under_test,
             "program_used_to_run_code_under_test": program_used_to_run_code_under_test,
-            "language": language if language and isinstance(language, str) else "python"
+            "language": language,  # Simplified: language is guaranteed to be a valid string
         }
 
         console.print("[bold blue]Generating unit test...[/bold blue]")
@@ -80,57 +87,56 @@ def bug_to_unit_test(
             strength=strength,
             temperature=temperature,
             time=time,
-            verbose=True
+            verbose=True,
         )
 
-        total_cost += response['cost']
-        final_model_name = response['model_name']
+        total_cost += response["cost"]
+        final_model_name = response["model_name"]
 
         # Step 3: Print markdown formatting
-        console.print(Markdown(response['result']))
+        console.print(Markdown(response["result"]))
 
         # Step 4: Check if generation is complete
-        last_600_chars = response['result'][-600:] if len(response['result']) > 600 else response['result']
-        
-        reasoning, is_finished, unfinished_cost, unfinished_model = unfinished_prompt(
+        last_600_chars = (
+            response["result"][-600:]
+            if len(response["result"]) > 600
+            else response["result"]
+        )
+
+        _reasoning, is_finished, unfinished_cost, _unfinished_model = unfinished_prompt(
             prompt_text=last_600_chars,
-            strength=0.75,
+            strength=0.89,
             temperature=temperature,
             time=time,
-            verbose=False
+            verbose=False,
         )
-        
+
         total_cost += unfinished_cost
 
         if not is_finished:
             console.print("[yellow]Generation incomplete. Continuing...[/yellow]")
             continued_output, continued_cost, continued_model = continue_generation(
                 formatted_input_prompt=prompt_template,
-                llm_output=response['result'],
+                llm_output=response["result"],
                 strength=strength,
                 temperature=temperature,
                 time=time,
-                verbose=True
+                verbose=True,
             )
             total_cost += continued_cost
             final_model_name = continued_model
             result = continued_output
         else:
-            result = response['result']
+            result = response["result"]
 
         # Post-process the result
-        # Double-check language is valid before passing to postprocess
-        if not language or not isinstance(language, str):
-            language = "python"  # Ensure language is valid
-            console.print("[yellow]Warning: Language value became invalid during processing, defaulting to 'python'[/yellow]")
-            
-        final_code, postprocess_cost, postprocess_model = postprocess(
+        final_code, postprocess_cost, _postprocess_model = postprocess(
             result,
             language,
             strength=EXTRACTION_STRENGTH,
             temperature=temperature,
             time=time,
-            verbose=True
+            verbose=True,
         )
         total_cost += postprocess_cost
 
@@ -139,10 +145,11 @@ def bug_to_unit_test(
 
         return final_code, total_cost, final_model_name
 
-    except Exception as e:
-        console.print(f"[bold red]Error: {str(e)}[/bold red]")
+    except Exception as ex:  # pylint: disable=broad-except
+        console.print(f"[bold red]Error: {str(ex)}[/bold red]")
         return "", 0.0, ""
 
+
 def main():
     """Example usage of the bug_to_unit_test function"""
     try:
@@ -161,7 +168,7 @@ def add_numbers(a, b):
             prompt_used_to_generate_the_code=prompt,
             code_under_test=code,
             program_used_to_run_code_under_test=program,
-            time=DEFAULT_TIME
+            time=DEFAULT_TIME,
         )
 
         if unit_test:
@@ -170,8 +177,9 @@ def add_numbers(a, b):
             console.print(f"[bold blue]Total Cost: ${cost:.6f}[/bold blue]")
             console.print(f"[bold blue]Model Used: {model}[/bold blue]")
 
-    except Exception as e:
-        console.print(f"[bold red]Error in main: {str(e)}[/bold red]")
+    except Exception as ex:  # pylint: disable=broad-except
+        console.print(f"[bold red]Error in main: {str(ex)}[/bold red]")
+
 
 if __name__ == "__main__":
-    main()
+    main()

pdd/change.py

@@ -1,3 +1,7 @@
+"""
+This module provides functionality to modify a prompt according to specified changes.
+It takes an input prompt, input code, and change instructions to generate a modified prompt.
+"""
 from typing import Tuple
 from rich.console import Console
 from rich.markdown import Markdown
@@ -11,16 +15,17 @@ from . import EXTRACTION_STRENGTH, DEFAULT_STRENGTH, DEFAULT_TIME
 console = Console()
 
 class ExtractedPrompt(BaseModel):
+    """Pydantic model for extracting the modified prompt from LLM output."""
     modified_prompt: str = Field(description="The extracted modified prompt")
 
-def change(
+def change(  # pylint: disable=too-many-arguments, too-many-locals
     input_prompt: str,
     input_code: str,
     change_prompt: str,
     strength: float = DEFAULT_STRENGTH,
     temperature: float = 0.0,
     time: float = DEFAULT_TIME,
-    budget: float = 5.0,  # Note: budget is in the spec but not used. Keeping for now.
+    budget: float = 5.0,  # pylint: disable=unused-argument
     verbose: bool = False
 ) -> Tuple[str, float, str]:
     """
@@ -33,7 +38,7 @@ def change(
         strength (float): The strength parameter for the LLM model (0-1)
         temperature (float): The temperature parameter for the LLM model
         time (float): The time budget for LLM calls.
-        budget (float): The budget for the operation (currently unused directly by llm_invoke).
+        budget (float): The budget for the operation (not used, but kept for API compatibility).
         verbose (bool): Whether to print out detailed information.
 
     Returns:
@@ -48,13 +53,15 @@ def change(
             raise ValueError("Failed to load prompt templates")
 
         # Step 2: Preprocess the change_LLM prompt
-        processed_change_llm_template = preprocess(change_llm_prompt_template, recursive=False, double_curly_brackets=False)
-        processed_change_prompt_content = preprocess(change_prompt, recursive=False, double_curly_brackets=False)
+        processed_change_llm_template = preprocess(change_llm_prompt_template,
+                                                  recursive=False, double_curly_brackets=False)
+        processed_change_prompt_content = preprocess(change_prompt,
+                                                    recursive=False, double_curly_brackets=False)
 
         # Input validation
         if not all([input_prompt, input_code, processed_change_prompt_content]):
             raise ValueError("Missing required input parameters after preprocessing")
-        if not (0 <= strength <= 1):
+        if not 0 <= strength <= 1:
             raise ValueError("Strength must be between 0 and 1")
 
         total_cost = 0.0
@@ -115,10 +122,10 @@ def change(
         # Step 7: Return results
         return modified_prompt, total_cost, final_model_name
 
-    except Exception as e:
+    except Exception as error:
         # Conditionally print error if verbose
-        if verbose: 
-            console.print(f"[red]Error in change function: {str(e)}[/red]")
+        if verbose:
+            console.print(f"[red]Error in change function: {str(error)}[/red]")
         raise
 
 def main():
@@ -128,7 +135,7 @@ def main():
         input_prompt_content = "Write a function that adds two numbers"
         input_code_content = "def add(a, b):\n    return a + b"
         change_prompt_content = "Make the function handle negative numbers explicitly"
-        
+
         modified_prompt, cost, model = change(
             input_prompt=input_prompt_content,
             input_code=input_code_content,
@@ -145,8 +152,8 @@ def main():
         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]")
+    except Exception as error:  # pylint: disable=broad-except
+        console.print(f"[red]Error in main: {str(error)}[/red]")
 
 if __name__ == "__main__":
-    main()
+    main()