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

pdd/__init__.py

@@ -1,7 +1,10 @@
-__version__ = "0.0.39"
+"""PDD - Prompt Driven Development"""
+
+__version__ = "0.0.41"
 
 # Strength parameter used for LLM extraction across the codebase
-# Used in postprocessing, XML tagging, code generation, and other extraction operations. The module should have a large context window and be affordable.
+# Used in postprocessing, XML tagging, code generation, and other extraction
+# operations. The module should have a large context window and be affordable.
 EXTRACTION_STRENGTH = 0.9
 
 DEFAULT_STRENGTH = 0.9
@@ -10,8 +13,6 @@ DEFAULT_TEMPERATURE = 0.0
 
 DEFAULT_TIME = 0.25
 
-"""PDD - Prompt Driven Development"""
-
 # Define constants used across the package
 DEFAULT_LLM_MODEL = "gpt-4.1-nano"
 # When going to production, set the following constants:

pdd/auto_deps_main.py

@@ -1,3 +1,4 @@
+"""Main function for the auto-deps command."""
 import sys
 from pathlib import Path
 from typing import Tuple, Optional
@@ -8,7 +9,7 @@ from . import DEFAULT_STRENGTH, DEFAULT_TIME
 from .construct_paths import construct_paths
 from .insert_includes import insert_includes
 
-def auto_deps_main(
+def auto_deps_main(  # pylint: disable=too-many-arguments, too-many-locals
     ctx: click.Context,
     prompt_file: str,
     directory_path: str,
@@ -57,7 +58,10 @@ def auto_deps_main(
         # Handle force_scan option
         if force_scan and Path(csv_path).exists():
             if not ctx.obj.get('quiet', False):
-                rprint(f"[yellow]Removing existing CSV file due to --force-scan option: {csv_path}[/yellow]")
+                rprint(
+                    "[yellow]Removing existing CSV file due to "
+                    f"--force-scan option: {csv_path}[/yellow]"
+                )
             Path(csv_path).unlink()
 
         # Get strength and temperature from context
@@ -78,11 +82,11 @@ def auto_deps_main(
 
         # Save the modified prompt to the output file
         output_path = output_file_paths["output"]
-        Path(output_path).write_text(modified_prompt)
+        Path(output_path).write_text(modified_prompt, encoding="utf-8")
 
         # Save the CSV output if it was generated
         if csv_output:
-            Path(csv_path).write_text(csv_output)
+            Path(csv_path).write_text(csv_output, encoding="utf-8")
 
         # Provide user feedback
         if not ctx.obj.get('quiet', False):
@@ -94,7 +98,7 @@ def auto_deps_main(
 
         return modified_prompt, total_cost, model_name
 
-    except Exception as e:
+    except Exception as exc:
         if not ctx.obj.get('quiet', False):
-            rprint(f"[bold red]Error:[/bold red] {str(e)}")
+            rprint(f"[bold red]Error:[/bold red] {str(exc)}")
         sys.exit(1)

pdd/auto_include.py

@@ -1,20 +1,113 @@
+"""
+This module provides the `auto_include` function to automatically find and
+insert dependencies into a prompt.
+"""
+from io import StringIO
 from typing import Tuple, Optional
+
+import pandas as pd
 from pydantic import BaseModel, Field
-from rich import print
 from rich.console import Console
 from rich.panel import Panel
-from .load_prompt_template import load_prompt_template
+
+from . import DEFAULT_TIME, DEFAULT_STRENGTH
 from .llm_invoke import llm_invoke
+from .load_prompt_template import load_prompt_template
 from .summarize_directory import summarize_directory
-import pandas as pd
-from io import StringIO
-from . import DEFAULT_TIME, DEFAULT_STRENGTH
 
 console = Console()
 
 class AutoIncludeOutput(BaseModel):
+    """
+    Pydantic model for the output of the auto_include extraction.
+    """
     string_of_includes: str = Field(description="The string of includes to be added to the prompt")
 
+
+def _validate_input(input_prompt: str, directory_path: str, strength: float, temperature: float):
+    """Validate the inputs for the auto_include function."""
+    if not input_prompt:
+        raise ValueError("Input prompt cannot be empty")
+    if not directory_path:
+        raise ValueError("Invalid 'directory_path'.")
+    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")
+
+
+def _get_available_includes_from_csv(csv_output: str) -> list[str]:
+    """Parse the CSV output and return a list of available includes."""
+    if not csv_output:
+        return []
+    try:
+        # pylint: disable=invalid-name
+        dataframe = pd.read_csv(StringIO(csv_output))
+        return dataframe.apply(
+            lambda row: f"File: {row['full_path']}\nSummary: {row['file_summary']}",
+            axis=1
+        ).tolist()
+    except Exception as ex:
+        console.print(f"[red]Error parsing CSV: {str(ex)}[/red]")
+        return []
+
+
+def _load_prompts() -> tuple[str, str]:
+    """Load the prompt templates."""
+    auto_include_prompt = load_prompt_template("auto_include_LLM")
+    extract_prompt = load_prompt_template("extract_auto_include_LLM")
+    if not auto_include_prompt or not extract_prompt:
+        raise ValueError("Failed to load prompt templates")
+    return auto_include_prompt, extract_prompt
+
+
+def _summarize(directory_path: str, csv_file: Optional[str], llm_kwargs: dict) -> tuple[str, float, str]:
+    """Summarize the directory."""
+    return summarize_directory(
+        directory_path=directory_path,
+        csv_file=csv_file,
+        **llm_kwargs
+    )
+
+
+def _run_llm_and_extract(
+    auto_include_prompt: str,
+    extract_prompt: str,
+    input_prompt: str,
+    available_includes: list[str],
+    llm_kwargs: dict,
+) -> tuple[str, float, str]:
+    """Run the LLM prompts and extract the dependencies."""
+    # pylint: disable=broad-except
+    # Run auto_include_LLM prompt
+    auto_include_response = llm_invoke(
+        prompt=auto_include_prompt,
+        input_json={
+            "input_prompt": input_prompt,
+            "available_includes": "\n".join(available_includes)
+        },
+        **llm_kwargs
+    )
+    total_cost = auto_include_response["cost"]
+    model_name = auto_include_response["model_name"]
+
+    # Run extract_auto_include_LLM prompt
+    try:
+        extract_response = llm_invoke(
+            prompt=extract_prompt,
+            input_json={"llm_output": auto_include_response["result"]},
+            output_pydantic=AutoIncludeOutput,
+            **llm_kwargs
+        )
+        total_cost += extract_response["cost"]
+        model_name = extract_response["model_name"]
+        dependencies = extract_response["result"].string_of_includes
+    except Exception as ex:
+        console.print(f"[red]Error extracting dependencies: {str(ex)}[/red]")
+        dependencies = ""
+    return dependencies, total_cost, model_name
+
+
 def auto_include(
     input_prompt: str,
     directory_path: str,
@@ -39,128 +132,77 @@ def auto_include(
     Returns:
         Tuple[str, str, float, str]: (dependencies, csv_output, total_cost, model_name)
     """
+    # pylint: disable=broad-except
     try:
-        # Input validation
-        if not input_prompt:
-            raise ValueError("Input prompt cannot be empty")
-        if not directory_path:
-            raise ValueError("Invalid 'directory_path'.")
-        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 = ""
+        _validate_input(input_prompt, directory_path, strength, temperature)
+        
+        llm_kwargs = {
+            "strength": strength,
+            "temperature": temperature,
+            "time": time,
+            "verbose": verbose
+        }
 
         if verbose:
             console.print(Panel("Step 1: Loading prompt templates", style="blue"))
 
-        # Load prompt templates
-        auto_include_prompt = load_prompt_template("auto_include_LLM")
-        extract_prompt = load_prompt_template("extract_auto_include_LLM")
-
-        if not auto_include_prompt or not extract_prompt:
-            raise ValueError("Failed to load prompt templates")
-
+        auto_include_prompt, extract_prompt = _load_prompts()
+        
         if verbose:
             console.print(Panel("Step 2: Running summarize_directory", style="blue"))
 
-        # Run summarize_directory
-        csv_output, summary_cost, summary_model = summarize_directory(
-            directory_path=directory_path,
-            strength=strength,
-            temperature=temperature,
-            time=time,
-            verbose=verbose,
-            csv_file=csv_file
+        csv_output, summary_cost, summary_model = _summarize(
+            directory_path, csv_file, llm_kwargs
         )
-        total_cost += summary_cost
-        model_name = summary_model
-
-        # Parse CSV to get available includes
-        if not csv_output:
-            available_includes = []
-        else:
-            try:
-                df = pd.read_csv(StringIO(csv_output))
-                available_includes = df.apply(
-                    lambda row: f"File: {row['full_path']}\nSummary: {row['file_summary']}",
-                    axis=1
-                ).tolist()
-            except Exception as e:
-                console.print(f"[red]Error parsing CSV: {str(e)}[/red]")
-                available_includes = []
 
+        available_includes = _get_available_includes_from_csv(csv_output)
+        
         if verbose:
             console.print(Panel("Step 3: Running auto_include_LLM prompt", style="blue"))
 
-        # Run auto_include_LLM prompt
-        auto_include_response = llm_invoke(
-            prompt=auto_include_prompt,
-            input_json={
-                "input_prompt": input_prompt,
-                "available_includes": "\n".join(available_includes)
-            },
-            strength=strength,
-            temperature=temperature,
-            time=time,
-            verbose=verbose
+        dependencies, llm_cost, llm_model_name = _run_llm_and_extract(
+            auto_include_prompt=auto_include_prompt,
+            extract_prompt=extract_prompt,
+            input_prompt=input_prompt,
+            available_includes=available_includes,
+            llm_kwargs=llm_kwargs,
         )
-        total_cost += auto_include_response["cost"]
-        model_name = auto_include_response["model_name"]
+        
+        total_cost = summary_cost + llm_cost
+        model_name = llm_model_name or summary_model
 
         if verbose:
-            console.print(Panel("Step 4: Running extract_auto_include_LLM prompt", style="blue"))
-
-        # Run extract_auto_include_LLM prompt
-        try:
-            extract_response = llm_invoke(
-                prompt=extract_prompt,
-                input_json={"llm_output": auto_include_response["result"]},
-                strength=strength,
-                temperature=temperature,
-                time=time,
-                verbose=verbose,
-                output_pydantic=AutoIncludeOutput
-            )
-            total_cost += extract_response["cost"]
-            model_name = extract_response["model_name"]
-
-            if verbose:
-                console.print(Panel("Step 5: Extracting dependencies", style="blue"))
-
-            # Extract dependencies
-            dependencies = extract_response["result"].string_of_includes
-        except Exception as e:
-            console.print(f"[red]Error extracting dependencies: {str(e)}[/red]")
-            dependencies = ""
-
-        if verbose:
-            console.print(Panel(f"""
-Results:
-Dependencies: {dependencies}
-CSV Output: {csv_output}
-Total Cost: ${total_cost:.6f}
-Model Used: {model_name}
-            """, style="green"))
+            console.print(Panel(
+                (
+                    f"Results:\n"
+                    f"Dependencies: {dependencies}\n"
+                    f"CSV Output: {csv_output}\n"
+                    f"Total Cost: ${total_cost:.6f}\n"
+                    f"Model Used: {model_name}"
+                ),
+                style="green"
+            ))
 
         return dependencies, csv_output, total_cost, model_name
 
-    except Exception as e:
-        console.print(f"[red]Error in auto_include: {str(e)}[/red]")
+    except Exception as ex:
+        console.print(f"[red]Error in auto_include: {str(ex)}[/red]")
         raise
 
+
 def main():
     """Example usage of auto_include function"""
     try:
         # Example inputs
         input_prompt = "Write a function to process image data"
         directory_path = "context/c*.py"
-        csv_file = """full_path,file_summary,date
-context/image_utils.py,"Image processing utilities",2023-01-01T10:00:00"""
+        csv_file = (
+            "full_path,file_summary,date\n"
+            "context/image_utils.py,"
+            "\"Image processing utilities\",2023-01-01T10:00:00"
+        )
 
-        dependencies, csv_output, total_cost, model_name = auto_include(
+        dependencies, _, total_cost, model_name = auto_include(
             input_prompt=input_prompt,
             directory_path=directory_path,
             csv_file=csv_file,
@@ -175,8 +217,8 @@ context/image_utils.py,"Image processing utilities",2023-01-01T10:00:00"""
         console.print(f"Total Cost: ${total_cost:.6f}")
         console.print(f"Model Used: {model_name}")
 
-    except Exception as e:
-        console.print(f"[red]Error in main: {str(e)}[/red]")
+    except Exception as ex:
+        console.print(f"[red]Error in main: {str(ex)}[/red]")
 
 if __name__ == "__main__":
     main()

pdd/auto_update.py

@@ -1,9 +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):
     """
@@ -38,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:
@@ -55,85 +105,43 @@ 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)
-                response.raise_for_status()
-                latest_version = response.json()['info']['version']
-            except Exception as e:
-                print(f"Failed to fetch latest version from PyPI: {str(e)}")
+            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)
-                    
-                    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)
-                                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_err:
-                                print(f"\nError during fallback upgrade: {str(fallback_err)}")
-                except Exception as e:
-                    print(f"\nError during upgrade: {str(e)}")
                 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")
-    except Exception as e:
-        print(f"Error checking for updates: {str(e)}")
+    except Exception as ex:
+        print(f"Error checking for updates: {str(ex)}")
 
 
 if __name__ == "__main__":

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