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

pdd/__init__.py

@@ -1,7 +1,10 @@
-__version__ = "0.0.38"
+"""PDD - Prompt Driven Development"""
+
+__version__ = "0.0.40"
 
 # 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,13 +1,15 @@
+"""Main function for the auto-deps command."""
 import sys
 from pathlib import Path
 from typing import Tuple, Optional
 import click
 from rich import print as rprint
 
+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,
@@ -56,12 +58,16 @@ 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
-        strength = ctx.obj.get('strength', 0.9)
+        strength = ctx.obj.get('strength', DEFAULT_STRENGTH)
         temperature = ctx.obj.get('temperature', 0)
+        time_budget = ctx.obj.get('time', DEFAULT_TIME)
 
         # Call insert_includes with the prompt content and directory path
         modified_prompt, csv_output, total_cost, model_name = insert_includes(
@@ -70,16 +76,17 @@ def auto_deps_main(
             csv_filename=csv_path,
             strength=strength,
             temperature=temperature,
+            time=time_budget,
             verbose=not ctx.obj.get('quiet', False)
         )
 
         # 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):
@@ -91,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,25 +1,120 @@
+"""
+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
 
 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,
     csv_file: Optional[str] = None,
-    strength: float = 0.7,
+    strength: float = DEFAULT_STRENGTH,
     temperature: float = 0.0,
+    time: float = DEFAULT_TIME,
     verbose: bool = False
 ) -> Tuple[str, str, float, str]:
     """
@@ -31,135 +126,89 @@ def auto_include(
         csv_file (Optional[str]): Contents of existing CSV file
         strength (float): Strength of LLM model (0-1)
         temperature (float): Temperature of LLM model (0-1)
+        time (float): Time budget for LLM calls
         verbose (bool): Whether to print detailed information
 
     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,
-            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,
-            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"]
-
-        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,
-                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 = ""
+        
+        total_cost = summary_cost + llm_cost
+        model_name = llm_model_name or summary_model
 
         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,
             strength=0.7,
             temperature=0.0,
+            time=DEFAULT_TIME,
             verbose=True
         )
 
@@ -168,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,3 +1,4 @@
+"""This module provides a function to automatically update the package."""
 import importlib.metadata
 import requests
 import semver
@@ -63,11 +64,11 @@ def auto_update(package_name: str = "pdd-cli", latest_version: str = None) -> No
         if latest_version is None:
             try:
                 pypi_url = f"https://pypi.org/pypi/{package_name}/json"
-                response = requests.get(pypi_url)
+                response = requests.get(pypi_url, timeout=10)
                 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)}")
+            except Exception as ex:
+                print(f"Failed to fetch latest version from PyPI: {str(ex)}")
                 return
 
         # Compare versions using semantic versioning
@@ -99,7 +100,13 @@ def auto_update(package_name: str = "pdd-cli", latest_version: str = None) -> No
                 print(f"Upgrading with command: {cmd_str}")
                 
                 try:
-                    result = subprocess.run(cmd, shell=use_shell, capture_output=True, text=True)
+                    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}")
@@ -114,15 +121,21 @@ def auto_update(package_name: str = "pdd-cli", latest_version: str = None) -> No
                             print(f"Fallback command: {fallback_str}")
                             
                             try:
-                                fallback_result = subprocess.run(fallback_cmd, shell=fallback_shell, capture_output=True, text=True)
+                                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_err:
-                                print(f"\nError during fallback upgrade: {str(fallback_err)}")
-                except Exception as e:
-                    print(f"\nError during upgrade: {str(e)}")
+                            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', '']:
                 print("\nUpgrade cancelled")
@@ -132,8 +145,8 @@ def auto_update(package_name: str = "pdd-cli", latest_version: str = None) -> No
 
     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

@@ -5,6 +5,7 @@ import click
 from rich import print as rprint
 from pathlib import Path
 
+from . import DEFAULT_STRENGTH, DEFAULT_TIME
 from .construct_paths import construct_paths
 from .bug_to_unit_test import bug_to_unit_test
 
@@ -64,8 +65,9 @@ def bug_main(
         desired_output_content = input_strings["desired_output"]
 
         # Generate unit test
-        strength = ctx.obj.get('strength', 0.9)
+        strength = ctx.obj.get('strength', DEFAULT_STRENGTH)
         temperature = ctx.obj.get('temperature', 0)
+        time_budget = ctx.obj.get('time', DEFAULT_TIME)
         unit_test, total_cost, model_name = bug_to_unit_test(
             current_output_content,
             desired_output_content,
@@ -74,7 +76,8 @@ def bug_main(
             program_content,
             strength,
             temperature,
-            language
+            language,
+            time_budget
         )
 
         # Save results if output path is provided

pdd/bug_to_unit_test.py

@@ -2,7 +2,7 @@ from typing import Tuple, Optional
 from rich import print
 from rich.markdown import Markdown
 from rich.console import Console
-from . import EXTRACTION_STRENGTH, DEFAULT_STRENGTH
+from . import EXTRACTION_STRENGTH, DEFAULT_STRENGTH, DEFAULT_TIME
 from .load_prompt_template import load_prompt_template
 from .llm_invoke import llm_invoke
 from .unfinished_prompt import unfinished_prompt
@@ -20,6 +20,7 @@ def bug_to_unit_test(
     program_used_to_run_code_under_test: str,
     strength: float = DEFAULT_STRENGTH,
     temperature: float = 0.0,
+    time: float = DEFAULT_TIME,
     language: str = "python"
 ) -> Tuple[str, float, str]:
     """
@@ -33,6 +34,7 @@ def bug_to_unit_test(
         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.
         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".
 
     Returns:
@@ -77,6 +79,7 @@ def bug_to_unit_test(
             input_json=input_json,
             strength=strength,
             temperature=temperature,
+            time=time,
             verbose=True
         )
 
@@ -93,6 +96,7 @@ def bug_to_unit_test(
             prompt_text=last_600_chars,
             strength=0.75,
             temperature=temperature,
+            time=time,
             verbose=False
         )
         
@@ -105,6 +109,7 @@ def bug_to_unit_test(
                 llm_output=response['result'],
                 strength=strength,
                 temperature=temperature,
+                time=time,
                 verbose=True
             )
             total_cost += continued_cost
@@ -124,6 +129,7 @@ def bug_to_unit_test(
             language,
             strength=EXTRACTION_STRENGTH,
             temperature=temperature,
+            time=time,
             verbose=True
         )
         total_cost += postprocess_cost
@@ -154,7 +160,8 @@ def add_numbers(a, b):
             desired_output=desired_output,
             prompt_used_to_generate_the_code=prompt,
             code_under_test=code,
-            program_used_to_run_code_under_test=program
+            program_used_to_run_code_under_test=program,
+            time=DEFAULT_TIME
         )
 
         if unit_test: