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

pdd/__init__.py

@@ -1,6 +1,6 @@
 """PDD - Prompt Driven Development"""
 
-__version__ = "0.0.40"
+__version__ = "0.0.41"
 
 # Strength parameter used for LLM extraction across the codebase
 # Used in postprocessing, XML tagging, code generation, and other extraction

pdd/auto_update.py

@@ -1,10 +1,12 @@
 """This module provides a function to automatically update the package."""
 import importlib.metadata
-import requests
-import semver
+import shutil
 import subprocess
 import sys
-import shutil
+from typing import Optional
+import requests
+import semver
+
 
 def detect_installation_method(sys_executable):
     """
@@ -39,12 +41,59 @@ def get_upgrade_command(package_name, installation_method):
         uv_path = shutil.which("uv")
         if uv_path:
             return ([uv_path, "tool", "install", package_name, "--force"], False)
-        else:
-            # If uv isn't in PATH, use shell=True
-            return (["uv", "tool", "install", package_name, "--force"], True)
-    else:
-        # Default pip method
-        return ([sys.executable, "-m", "pip", "install", "--upgrade", package_name], False)
+        # If uv isn't in PATH, use shell=True
+        return (["uv", "tool", "install", package_name, "--force"], True)
+    # Default pip method
+    return ([sys.executable, "-m", "pip", "install", "--upgrade", package_name], False)
+
+
+def _get_latest_version(package_name: str) -> Optional[str]:
+    """Fetch the latest version of a package from PyPI."""
+    # pylint: disable=broad-except
+    try:
+        pypi_url = f"https://pypi.org/pypi/{package_name}/json"
+        response = requests.get(pypi_url, timeout=10)
+        response.raise_for_status()
+        return response.json()['info']['version']
+    except Exception as ex:
+        print(f"Failed to fetch latest version from PyPI: {str(ex)}")
+        return None
+
+
+def _upgrade_package(package_name: str, installation_method: str):
+    """Upgrade a package using the specified installation method."""
+    cmd, use_shell = get_upgrade_command(package_name, installation_method)
+    cmd_str = " ".join(cmd)
+    print(f"\nDetected installation method: {installation_method}")
+    print(f"Upgrading with command: {cmd_str}")
+
+    # pylint: disable=broad-except
+    try:
+        result = subprocess.run(
+            cmd,
+            shell=use_shell,
+            capture_output=True,
+            text=True,
+            check=False
+        )
+        if result.returncode == 0:
+            print(f"\nSuccessfully upgraded {package_name}")
+            return True
+        print(f"\nUpgrade command failed: {result.stderr}")
+        return False
+    except Exception as ex:
+        print(f"\nError during upgrade: {str(ex)}")
+        return False
+
+
+def _is_new_version_available(current_version: str, latest_version: str) -> bool:
+    """Check if a new version is available."""
+    try:
+        current_semver = semver.VersionInfo.parse(current_version)
+        latest_semver = semver.VersionInfo.parse(latest_version)
+        return latest_semver > current_semver
+    except ValueError:
+        return latest_version != current_version
 
 
 def auto_update(package_name: str = "pdd-cli", latest_version: str = None) -> None:
@@ -56,92 +105,38 @@ def auto_update(package_name: str = "pdd-cli", latest_version: str = None) -> No
         latest_version (str): Known latest version (default: None)
         package_name (str): Name of the package to check (default: "pdd-cli")
     """
+    # pylint: disable=broad-except
     try:
-        # Get current installed version
         current_version = importlib.metadata.version(package_name)
 
-        # If latest_version is not provided, fetch from PyPI
         if latest_version is None:
-            try:
-                pypi_url = f"https://pypi.org/pypi/{package_name}/json"
-                response = requests.get(pypi_url, timeout=10)
-                response.raise_for_status()
-                latest_version = response.json()['info']['version']
-            except Exception as ex:
-                print(f"Failed to fetch latest version from PyPI: {str(ex)}")
+            latest_version = _get_latest_version(package_name)
+            if latest_version is None:
                 return
 
-        # Compare versions using semantic versioning
-        try:
-            current_semver = semver.VersionInfo.parse(current_version)
-            latest_semver = semver.VersionInfo.parse(latest_version)
-        except ValueError:
-            # If versions don't follow semantic versioning, fall back to string comparison
-            if current_version == latest_version:
-                return
-        else:
-            # If versions follow semantic versioning, compare properly
-            if current_semver >= latest_semver:
-                return
+        if not _is_new_version_available(current_version, latest_version):
+            return
 
-        # If we get here, there's a new version available
-        print(f"\nNew version of {package_name} available: {latest_version} (current: {current_version})")
+        print(f"\nNew version of {package_name} available: "
+              f"{latest_version} (current: {current_version})")
         
-        # Ask for user confirmation
         while True:
             response = input("Would you like to upgrade? [y/N]: ").lower().strip()
             if response in ['y', 'yes']:
-                # Detect installation method
                 installation_method = detect_installation_method(sys.executable)
-                cmd, use_shell = get_upgrade_command(package_name, installation_method)
+                if _upgrade_package(package_name, installation_method):
+                    break
                 
-                cmd_str = " ".join(cmd)
-                print(f"\nDetected installation method: {installation_method}")
-                print(f"Upgrading with command: {cmd_str}")
+                if installation_method == "uv":
+                    print("\nAttempting fallback to pip...")
+                    if _upgrade_package(package_name, "pip"):
+                        break
                 
-                try:
-                    result = subprocess.run(
-                        cmd,
-                        shell=use_shell,
-                        capture_output=True,
-                        text=True,
-                        check=False
-                    )
-                    
-                    if result.returncode == 0:
-                        print(f"\nSuccessfully upgraded {package_name} to version {latest_version}")
-                    else:
-                        print(f"\nUpgrade command failed: {result.stderr}")
-                        
-                        # If UV failed and we're not already in fallback mode, try pip as fallback
-                        if installation_method == "uv":
-                            print("\nAttempting fallback to pip...")
-                            fallback_cmd, fallback_shell = get_upgrade_command(package_name, "pip")
-                            fallback_str = " ".join(fallback_cmd)
-                            print(f"Fallback command: {fallback_str}")
-                            
-                            try:
-                                fallback_result = subprocess.run(
-                                    fallback_cmd,
-                                    shell=fallback_shell,
-                                    capture_output=True,
-                                    text=True,
-                                    check=False
-                                )
-                                if fallback_result.returncode == 0:
-                                    print(f"\nSuccessfully upgraded {package_name} using fallback method")
-                                else:
-                                    print(f"\nFallback upgrade failed: {fallback_result.stderr}")
-                            except Exception as fallback_ex:
-                                print(f"\nError during fallback upgrade: {str(fallback_ex)}")
-                except Exception as ex:
-                    print(f"\nError during upgrade: {str(ex)}")
                 break
-            elif response in ['n', 'no', '']:
+            if response in ['n', 'no', '']:
                 print("\nUpgrade cancelled")
                 break
-            else:
-                print("Please answer 'y' or 'n'")
+            print("Please answer 'y' or 'n'")
 
     except importlib.metadata.PackageNotFoundError:
         print(f"Package {package_name} is not installed")

pdd/bug_main.py

@@ -76,8 +76,8 @@ def bug_main(
             program_content,
             strength,
             temperature,
-            language,
-            time_budget
+            time_budget,
+            language
         )
 
         # Save results if output path is provided

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()