pdd-cli 0.0.90__py3-none-any.whl → 0.0.118__py3-none-any.whl

pdd/auto_update.py

@@ -1,67 +1,111 @@
-"""This module provides a function to automatically update the package."""
+"""This module provides a function to automatically update the package.
+
+It can detect whether the current tool was installed via UV or pip, check
+PyPI for a newer version, prompt the user, and perform an upgrade using the
+appropriate installer with sensible fallbacks.
+"""
 import importlib.metadata
+import os
 import shutil
 import subprocess
 import sys
-from typing import Optional
+from typing import Optional, Tuple, List
+
 import requests
 import semver
 
 
-def detect_installation_method(sys_executable):
-    """
-    Detect if package is installed via UV or pip.
-    
+def detect_installation_method(sys_executable: str) -> str:
+    """Detect whether the package is installed via UV or pip.
+
+    The detection is based on the path of the Python executable. The path is
+    normalized so that both Unix ("/") and Windows ("\\") separators are
+    handled uniformly. If typical UV tool installation markers are present in
+    the normalized path, "uv" is returned; otherwise "pip" is returned.
+
     Args:
-        sys_executable (str): Path to the Python executable
-    
+        sys_executable: Path to the Python executable (e.g. ``sys.executable``).
+
     Returns:
-        str: "uv" if installed via UV, "pip" otherwise
+        "uv" if a UV-style installation path is detected, otherwise "pip".
     """
+    # Normalize path separators to support both Unix (/) and Windows (\) paths
+    normalized_path = sys_executable.replace("\\", "/")
+
     # Check if executable path contains UV paths
-    if any(marker in sys_executable for marker in ["/uv/tools/", ".local/share/uv/"]):
+    if any(marker in normalized_path for marker in ["/uv/tools/", ".local/share/uv/"]):
         return "uv"
     return "pip"  # Default to pip for all other cases
 
 
-def get_upgrade_command(package_name, installation_method):
-    """
-    Return appropriate upgrade command based on installation method.
-    
+def get_upgrade_command(package_name: str, installation_method: str) -> Tuple[List[str], bool]:
+    """Build the appropriate upgrade command based on the installation method.
+
+    For UV, this uses ``uv tool install --force``. For pip, this uses
+    ``python -m pip install --upgrade`` with the current Python executable.
+
     Args:
-        package_name (str): Name of the package to upgrade
-        installation_method (str): "uv" or "pip"
-    
+        package_name: Name of the package to upgrade.
+        installation_method: Either ``"uv"`` or ``"pip"``.
+
     Returns:
-        tuple: (command_list, shell_mode) where command_list is the command to run
-               and shell_mode is a boolean indicating if shell=True should be used
+        A tuple ``(command_list, shell_mode)`` where ``command_list`` is the
+        command and its arguments as a list of strings, and ``shell_mode`` is a
+        boolean indicating whether ``subprocess.run`` should be invoked with
+        ``shell=True``.
     """
     if installation_method == "uv":
         # For UV commands, we need the full path if available
         uv_path = shutil.which("uv")
         if uv_path:
-            return ([uv_path, "tool", "install", package_name, "--force"], False)
+            return [uv_path, "tool", "install", package_name, "--force"], False
         # If uv isn't in PATH, use shell=True
-        return (["uv", "tool", "install", package_name, "--force"], True)
+        return ["uv", "tool", "install", package_name, "--force"], True
+
     # Default pip method
-    return ([sys.executable, "-m", "pip", "install", "--upgrade", package_name], False)
+    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."""
+    """Fetch the latest version of a package from PyPI.
+
+    This queries the JSON API at ``https://pypi.org/pypi/<package_name>/json``
+    with a timeout and extracts the ``info.version`` field.
+
+    Any exception results in a user-friendly error message and ``None`` being
+    returned.
+
+    Args:
+        package_name: The name of the package to query.
+
+    Returns:
+        The latest version string if it could be fetched, otherwise ``None``.
+    """
     # 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:
+        return response.json()["info"]["version"]
+    except Exception as ex:  # noqa: BLE001
         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."""
+def _upgrade_package(package_name: str, installation_method: str) -> bool:
+    """Upgrade a package using the specified installation method.
+
+    This runs the command returned by :func:`get_upgrade_command`, captures
+    stdout/stderr, and reports success or failure.
+
+    Args:
+        package_name: Name of the package to upgrade.
+        installation_method: Either ``"uv"`` or ``"pip"``.
+
+    Returns:
+        ``True`` if the upgrade command succeeded (exit code 0), otherwise
+        ``False``.
+    """
     cmd, use_shell = get_upgrade_command(package_name, installation_method)
     cmd_str = " ".join(cmd)
     print(f"\nDetected installation method: {installation_method}")
@@ -69,25 +113,38 @@ def _upgrade_package(package_name: str, installation_method: str):
 
     # pylint: disable=broad-except
     try:
-        result = subprocess.run(
+        result = subprocess.run(  # noqa: PLW1510
             cmd,
             shell=use_shell,
             capture_output=True,
             text=True,
-            check=False
+            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:
+    except Exception as ex:  # noqa: BLE001
         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."""
+    """Determine whether a newer version is available.
+
+    Semantic versioning is used when possible via :mod:`semver`. If parsing
+    fails for either version string, the function falls back to a simple
+    inequality comparison of the raw strings.
+
+    Args:
+        current_version: The currently installed version string.
+        latest_version: The latest available version string.
+
+    Returns:
+        ``True`` if ``latest_version`` is considered newer than
+        ``current_version``, otherwise ``False``.
+    """
     try:
         current_semver = semver.VersionInfo.parse(current_version)
         latest_semver = semver.VersionInfo.parse(latest_version)
@@ -96,15 +153,34 @@ def _is_new_version_available(current_version: str, latest_version: str) -> bool
         return latest_version != current_version
 
 
-def auto_update(package_name: str = "pdd-cli", latest_version: str = None) -> None:
-    """
-    Check if there's a new version of the package available and prompt for upgrade.
-    Handles both UV and pip installations automatically.
-    
+def auto_update(package_name: str = "pdd-cli", latest_version: Optional[str] = None) -> None:
+    """Check PyPI for a newer version of the package and offer to upgrade.
+
+    This function:
+
+    * Determines the currently installed version using :mod:`importlib.metadata`.
+    * Optionally accepts a pre-fetched ``latest_version`` for testing; if not
+      supplied it will query PyPI.
+    * Compares versions using semantic versioning with a string comparison
+      fallback.
+    * Interactively prompts the user for confirmation before upgrading.
+    * Performs the upgrade using UV or pip depending on installation method,
+      with a pip fallback if a UV upgrade fails.
+
     Args:
-        latest_version (str): Known latest version (default: None)
-        package_name (str): Name of the package to check (default: "pdd-cli")
+        package_name: Name of the package to check (default: ``"pdd-cli"``).
+        latest_version: Optionally, a known latest version to use instead of
+            querying PyPI (primarily for testing).
+
+    Returns:
+        None. All feedback is provided via ``print`` statements.
     """
+    # Skip update check in CI mode, headless mode, or when stdin is not a TTY
+    if (os.environ.get('CI') == '1' or
+        os.environ.get('PDD_SKIP_UPDATE_CHECK') == '1' or
+        not sys.stdin.isatty()):
+        return
+
     # pylint: disable=broad-except
     try:
         current_version = importlib.metadata.version(package_name)
@@ -117,32 +193,34 @@ def auto_update(package_name: str = "pdd-cli", latest_version: str = None) -> No
         if not _is_new_version_available(current_version, latest_version):
             return
 
-        print(f"\nNew version of {package_name} available: "
-              f"{latest_version} (current: {current_version})")
-        
+        print(
+            f"\nNew version of {package_name} available: "
+            f"{latest_version} (current: {current_version})",
+        )
+
         while True:
             response = input("Would you like to upgrade? [y/N]: ").lower().strip()
-            if response in ['y', 'yes']:
+            if response in ["y", "yes"]:
                 installation_method = detect_installation_method(sys.executable)
                 if _upgrade_package(package_name, installation_method):
                     break
-                
+
                 if installation_method == "uv":
                     print("\nAttempting fallback to pip...")
                     if _upgrade_package(package_name, "pip"):
                         break
-                
+
                 break
-            if response in ['n', 'no', '']:
+            if response in ["n", "no", ""]:
                 print("\nUpgrade cancelled")
                 break
             print("Please answer 'y' or 'n'")
 
     except importlib.metadata.PackageNotFoundError:
         print(f"Package {package_name} is not installed")
-    except Exception as ex:
+    except Exception as ex:  # noqa: BLE001
         print(f"Error checking for updates: {str(ex)}")
 
 
 if __name__ == "__main__":
-    auto_update()
+    auto_update()

pdd/bug_main.py

@@ -1,13 +1,33 @@
+import json
 import os
 import sys
 from typing import Tuple, Optional
+
 import click
-from rich import print as rprint
+import requests
 from pathlib import Path
+from rich import print as rprint
+from rich.console import Console
+from rich.panel import Panel
 
 from . import DEFAULT_STRENGTH, DEFAULT_TIME
 from .construct_paths import construct_paths
 from .bug_to_unit_test import bug_to_unit_test
+from .core.cloud import CloudConfig
+
+# Cloud request timeout
+CLOUD_REQUEST_TIMEOUT = 400  # seconds
+
+console = Console()
+
+
+def _env_flag_enabled(name: str) -> bool:
+    """Return True when an env var is set to a truthy value."""
+    value = os.environ.get(name)
+    if value is None:
+        return False
+    return str(value).strip().lower() in {"1", "true", "yes", "on"}
+
 
 def bug_main(
     ctx: click.Context,
@@ -32,6 +52,14 @@ def bug_main(
     :param language: Optional programming language for the unit test. Defaults to "Python".
     :return: A tuple containing the generated unit test, total cost, and model name used.
     """
+    # Initialize variables
+    unit_test = ""
+    total_cost = 0.0
+    model_name = ""
+
+    verbose = ctx.obj.get('verbose', False)
+    quiet = ctx.obj.get('quiet', False)
+
     try:
         # Construct file paths
         input_file_paths = {
@@ -48,12 +76,13 @@ def bug_main(
         resolved_config, input_strings, output_file_paths, detected_language = construct_paths(
             input_file_paths=input_file_paths,
             force=ctx.obj.get('force', False),
-            quiet=ctx.obj.get('quiet', False),
+            quiet=quiet,
             command="bug",
             command_options=command_options,
-            context_override=ctx.obj.get('context')
+            context_override=ctx.obj.get('context'),
+            confirm_callback=ctx.obj.get('confirm_callback')
         )
-        
+
         # Use the language detected by construct_paths if none was explicitly provided
         if language is None:
             language = detected_language
@@ -65,21 +94,158 @@ def bug_main(
         current_output_content = input_strings["current_output"]
         desired_output_content = input_strings["desired_output"]
 
-        # Generate unit test
+        # Get generation parameters
         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,
-            prompt_content,
-            code_content,
-            program_content,
-            strength,
-            temperature,
-            time_budget,
-            language
-        )
+
+        # Determine cloud vs local execution preference
+        is_local_execution_preferred = ctx.obj.get('local', False)
+        cloud_only = _env_flag_enabled("PDD_CLOUD_ONLY") or _env_flag_enabled("PDD_NO_LOCAL_FALLBACK")
+        current_execution_is_local = is_local_execution_preferred and not cloud_only
+
+        # Try cloud execution first if not preferring local
+        if not current_execution_is_local:
+            if verbose:
+                console.print(Panel("Attempting cloud bug test generation...", title="[blue]Mode[/blue]", expand=False))
+
+            jwt_token = CloudConfig.get_jwt_token(verbose=verbose)
+
+            if not jwt_token:
+                if cloud_only:
+                    console.print("[red]Cloud authentication failed.[/red]")
+                    raise click.UsageError("Cloud authentication failed")
+                console.print("[yellow]Cloud authentication failed. Falling back to local execution.[/yellow]")
+                current_execution_is_local = True
+
+            if jwt_token and not current_execution_is_local:
+                # Build cloud payload
+                payload = {
+                    "promptContent": prompt_content,
+                    "codeContent": code_content,
+                    "programContent": program_content,
+                    "currentOutput": current_output_content,
+                    "desiredOutput": desired_output_content,
+                    "language": language,
+                    "strength": strength,
+                    "temperature": temperature,
+                    "time": time_budget,
+                    "verbose": verbose,
+                }
+
+                headers = {
+                    "Authorization": f"Bearer {jwt_token}",
+                    "Content-Type": "application/json"
+                }
+                cloud_url = CloudConfig.get_endpoint_url("generateBugTest")
+
+                try:
+                    response = requests.post(
+                        cloud_url,
+                        json=payload,
+                        headers=headers,
+                        timeout=CLOUD_REQUEST_TIMEOUT
+                    )
+                    response.raise_for_status()
+
+                    response_data = response.json()
+                    unit_test = response_data.get("generatedTest", "")
+                    total_cost = float(response_data.get("totalCost", 0.0))
+                    model_name = response_data.get("modelName", "cloud_model")
+
+                    if not unit_test:
+                        if cloud_only:
+                            console.print("[red]Cloud execution returned no test code.[/red]")
+                            raise click.UsageError("Cloud execution returned no test code")
+                        console.print("[yellow]Cloud execution returned no test code. Falling back to local.[/yellow]")
+                        current_execution_is_local = True
+                    elif verbose:
+                        console.print(Panel(
+                            f"Cloud bug test generation successful. Model: {model_name}, Cost: ${total_cost:.6f}",
+                            title="[green]Cloud Success[/green]",
+                            expand=False
+                        ))
+
+                except requests.exceptions.Timeout:
+                    if cloud_only:
+                        console.print(f"[red]Cloud execution timed out ({CLOUD_REQUEST_TIMEOUT}s).[/red]")
+                        raise click.UsageError("Cloud execution timed out")
+                    console.print(f"[yellow]Cloud execution timed out ({CLOUD_REQUEST_TIMEOUT}s). Falling back to local.[/yellow]")
+                    current_execution_is_local = True
+
+                except requests.exceptions.HTTPError as e:
+                    status_code = e.response.status_code if e.response else 0
+                    err_content = e.response.text[:200] if e.response else "No response content"
+
+                    # Non-recoverable errors: do NOT fall back to local
+                    if status_code == 402:  # Insufficient credits
+                        try:
+                            error_data = e.response.json()
+                            current_balance = error_data.get("currentBalance", "unknown")
+                            estimated_cost = error_data.get("estimatedCost", "unknown")
+                            console.print(f"[red]Insufficient credits. Current balance: {current_balance}, estimated cost: {estimated_cost}[/red]")
+                        except Exception:
+                            console.print(f"[red]Insufficient credits: {err_content}[/red]")
+                        raise click.UsageError("Insufficient credits for cloud bug test generation")
+                    elif status_code == 401:  # Authentication error
+                        console.print(f"[red]Authentication failed: {err_content}[/red]")
+                        raise click.UsageError("Cloud authentication failed")
+                    elif status_code == 403:  # Authorization error (not approved)
+                        console.print(f"[red]Access denied: {err_content}[/red]")
+                        raise click.UsageError("Access denied - user not approved")
+                    elif status_code == 400:  # Validation error
+                        console.print(f"[red]Invalid request: {err_content}[/red]")
+                        raise click.UsageError(f"Invalid request: {err_content}")
+                    else:
+                        # Recoverable errors (5xx, unexpected errors): fall back to local
+                        if cloud_only:
+                            console.print(f"[red]Cloud HTTP error ({status_code}): {err_content}[/red]")
+                            raise click.UsageError(f"Cloud HTTP error ({status_code}): {err_content}")
+                        console.print(f"[yellow]Cloud HTTP error ({status_code}): {err_content}. Falling back to local.[/yellow]")
+                        current_execution_is_local = True
+
+                except requests.exceptions.RequestException as e:
+                    if cloud_only:
+                        console.print(f"[red]Cloud network error: {e}[/red]")
+                        raise click.UsageError(f"Cloud network error: {e}")
+                    console.print(f"[yellow]Cloud network error: {e}. Falling back to local.[/yellow]")
+                    current_execution_is_local = True
+
+                except json.JSONDecodeError:
+                    if cloud_only:
+                        console.print("[red]Cloud returned invalid JSON.[/red]")
+                        raise click.UsageError("Cloud returned invalid JSON")
+                    console.print("[yellow]Cloud returned invalid JSON. Falling back to local.[/yellow]")
+                    current_execution_is_local = True
+
+        # Local execution path
+        if current_execution_is_local:
+            if verbose:
+                console.print(Panel("Performing local bug test generation...", title="[blue]Mode[/blue]", expand=False))
+
+            unit_test, total_cost, model_name = bug_to_unit_test(
+                current_output_content,
+                desired_output_content,
+                prompt_content,
+                code_content,
+                program_content,
+                strength,
+                temperature,
+                time_budget,
+                language
+            )
+
+            if verbose:
+                console.print(Panel(
+                    f"Local bug test generation successful. Model: {model_name}, Cost: ${total_cost:.6f}",
+                    title="[green]Local Success[/green]",
+                    expand=False
+                ))
+
+        # Validate generated content
+        if not unit_test or not unit_test.strip():
+            rprint("[bold red]Error: Generated unit test content is empty or whitespace-only.[/bold red]")
+            return "", 0.0, "Error: Generated unit test content is empty"
 
         # Save results if output path is provided
         if output_file_paths.get("output"):
@@ -88,21 +254,21 @@ def bug_main(
             if not output_path or output_path.strip() == '':
                 # Use a default output path in the current directory
                 output_path = f"test_{Path(code_file).stem}_bug.{language.lower()}"
-                if not ctx.obj.get('quiet', False):
+                if not quiet:
                     rprint(f"[yellow]Warning: Empty output path detected. Using default: {output_path}[/yellow]")
                 output_file_paths["output"] = output_path
-            
+
             # Create directory if it doesn't exist
             dir_path = os.path.dirname(output_path)
             if dir_path:  # Only create directory if there's a directory part in the path
                 os.makedirs(dir_path, exist_ok=True)
-            
+
             # Write the file
-            with open(output_path, 'w') as f:
+            with open(output_path, 'w', encoding='utf-8') as f:
                 f.write(unit_test)
 
         # Provide user feedback
-        if not ctx.obj.get('quiet', False):
+        if not quiet:
             rprint("[bold green]Unit test generated successfully.[/bold green]")
             rprint(f"[bold]Model used:[/bold] {model_name}")
             rprint(f"[bold]Total cost:[/bold] ${total_cost:.6f}")
@@ -115,7 +281,13 @@ def bug_main(
 
         return unit_test, total_cost, model_name
 
+    except click.Abort:
+        # User cancelled - re-raise to stop the sync loop
+        raise
+    except click.UsageError:
+        # Re-raise usage errors to be handled by CLI
+        raise
     except Exception as e:
-        if not ctx.obj.get('quiet', False):
+        if not quiet:
             rprint(f"[bold red]Error:[/bold red] {str(e)}")
-        sys.exit(1)
+        return "", 0.0, f"Error: {e}"