pipu-cli 0.2.0__py3-none-any.whl → 0.2.2__py3-none-any.whl

pipu_cli/__init__.py

@@ -1,7 +1,7 @@
 import logging
 from .config import LOG_LEVEL
 
-__version__ = '0.2.0'
+__version__ = '0.2.2'
 
 
 # Configure logging

pipu_cli/cache.py

@@ -1,15 +1,18 @@
-"""Package metadata caching for pipu.
+"""Package version caching for pipu.
 
-This module provides caching of package version information to speed up
+This module provides caching of latest package versions from PyPI to speed up
 repeated runs of pipu. The cache is per-environment, identified by the
 Python executable path, making it compatible with venv, conda, mise, etc.
+
+The cache stores only the latest available versions - constraint resolution
+is performed at upgrade time with the current installed package state.
 """
 
 import hashlib
 import json
 import logging
 import sys
-from dataclasses import dataclass, field, asdict
+from dataclasses import dataclass, asdict
 from datetime import datetime, timezone
 from pathlib import Path
 from typing import Dict, List, Optional, Any
@@ -22,24 +25,15 @@ from pipu_cli.config import DEFAULT_CACHE_TTL, CACHE_BASE_DIR
 logger = logging.getLogger(__name__)
 
 
-@dataclass
-class CachedPackage:
-    """Cached information about a single package."""
-    name: str
-    installed_version: str
-    latest_version: str
-    is_upgradable: bool
-    is_editable: bool
-    checked_at: str  # ISO format timestamp
-
-
 @dataclass
 class CacheData:
-    """Complete cache data structure."""
+    """Cache data structure - stores latest versions from PyPI."""
     environment_id: str
     python_executable: str
     updated_at: str  # ISO format timestamp
-    packages: Dict[str, Dict[str, Any]] = field(default_factory=dict)
+    include_prereleases: bool
+    # Maps package name (lowercase) to latest version string
+    latest_versions: Dict[str, str]
 
 
 def get_environment_id() -> str:
@@ -52,7 +46,6 @@ def get_environment_id() -> str:
     :returns: Short hash identifying the environment
     """
     executable = sys.executable
-    # Create a short hash of the executable path
     hash_obj = hashlib.sha256(executable.encode())
     return hash_obj.hexdigest()[:12]
 
@@ -99,17 +92,19 @@ def load_cache() -> Optional[CacheData]:
             environment_id=data["environment_id"],
             python_executable=data["python_executable"],
             updated_at=data["updated_at"],
-            packages=data.get("packages", {})
+            include_prereleases=data.get("include_prereleases", False),
+            latest_versions=data.get("latest_versions", {})
         )
     except (json.JSONDecodeError, KeyError, TypeError) as e:
         logger.debug(f"Failed to load cache: {e}")
         return None
 
 
-def save_cache(packages: Dict[str, Dict[str, Any]]) -> Path:
-    """Save package data to the cache.
+def save_cache(latest_versions: Dict[str, str], include_prereleases: bool = False) -> Path:
+    """Save latest version data to the cache.
 
-    :param packages: Dictionary mapping package names to their cached info
+    :param latest_versions: Dictionary mapping package names (lowercase) to latest version strings
+    :param include_prereleases: Whether prereleases were included in version check
     :returns: Path to the saved cache file
     """
     cache_dir = get_cache_dir()
@@ -121,7 +116,8 @@ def save_cache(packages: Dict[str, Dict[str, Any]]) -> Path:
         environment_id=get_environment_id(),
         python_executable=sys.executable,
         updated_at=datetime.now(timezone.utc).isoformat(),
-        packages=packages
+        include_prereleases=include_prereleases,
+        latest_versions=latest_versions
     )
 
     with open(cache_path, 'w') as f:
@@ -143,7 +139,6 @@ def is_cache_fresh(ttl_seconds: int = DEFAULT_CACHE_TTL) -> bool:
 
     try:
         updated_at = datetime.fromisoformat(cache.updated_at)
-        # Ensure updated_at is timezone-aware
         if updated_at.tzinfo is None:
             updated_at = updated_at.replace(tzinfo=timezone.utc)
 
@@ -237,61 +232,6 @@ def clear_all_caches() -> int:
     return count
 
 
-def get_cached_package(name: str) -> Optional[Dict[str, Any]]:
-    """Get cached data for a specific package.
-
-    :param name: Package name (case-insensitive)
-    :returns: Package cache data or None
-    """
-    cache = load_cache()
-    if cache is None:
-        return None
-
-    # Normalize name for lookup
-    name_lower = name.lower()
-    return cache.packages.get(name_lower)
-
-
-def build_cache_from_results(
-    installed_packages: List[Any],
-    latest_versions: Dict[Any, Any],
-    upgradable_packages: List[Any]
-) -> Dict[str, Dict[str, Any]]:
-    """Build cache data from pipu's package analysis results.
-
-    :param installed_packages: List of InstalledPackage objects
-    :param latest_versions: Dict mapping InstalledPackage to LatestVersionInfo
-    :param upgradable_packages: List of UpgradePackageInfo objects
-    :returns: Dictionary suitable for save_cache()
-    """
-    # Create lookup for upgradable packages
-    upgradable_names = {pkg.name.lower() for pkg in upgradable_packages}
-
-    packages = {}
-    now = datetime.now(timezone.utc).isoformat()
-
-    for installed in installed_packages:
-        name_lower = installed.name.lower()
-
-        # Find latest version if available
-        latest_version = None
-        for inst_pkg, latest_info in latest_versions.items():
-            if inst_pkg.name.lower() == name_lower:
-                latest_version = str(latest_info.version)
-                break
-
-        packages[name_lower] = {
-            "name": installed.name,
-            "installed_version": str(installed.version),
-            "latest_version": latest_version or str(installed.version),
-            "is_upgradable": name_lower in upgradable_names,
-            "is_editable": installed.is_editable,
-            "checked_at": now
-        }
-
-    return packages
-
-
 def get_cache_info() -> Dict[str, Any]:
     """Get information about the current cache.
 
@@ -300,7 +240,7 @@ def get_cache_info() -> Dict[str, Any]:
     cache = load_cache()
     cache_path = get_cache_path()
 
-    info = {
+    info: Dict[str, Any] = {
         "exists": cache is not None,
         "path": str(cache_path),
         "environment_id": get_environment_id(),
@@ -309,8 +249,27 @@ def get_cache_info() -> Dict[str, Any]:
 
     if cache:
         info["updated_at"] = cache.updated_at
-        info["package_count"] = len(cache.packages)
-        info["age_seconds"] = get_cache_age_seconds()
-        info["age_human"] = format_cache_age(info["age_seconds"])
+        info["package_count"] = len(cache.latest_versions)
+        info["include_prereleases"] = cache.include_prereleases
+        age_seconds = get_cache_age_seconds()
+        info["age_seconds"] = age_seconds
+        info["age_human"] = format_cache_age(age_seconds)
 
     return info
+
+
+def build_version_cache(
+    latest_versions: Dict[Any, Any]
+) -> Dict[str, str]:
+    """Build cache data from pipu's version check results.
+
+    :param latest_versions: Dict mapping InstalledPackage to Package with latest version
+    :returns: Dictionary mapping package names (lowercase) to latest version strings
+    """
+    result: Dict[str, str] = {}
+
+    for installed_pkg, latest_pkg in latest_versions.items():
+        name_lower = installed_pkg.name.lower()
+        result[name_lower] = str(latest_pkg.version)
+
+    return result

pipu_cli/cli.py

@@ -13,13 +13,16 @@ from rich.progress import Progress, SpinnerColumn, TextColumn, BarColumn, TaskPr
 from rich.table import Table
 
 from pipu_cli.package_management import (
+    Package,
     inspect_installed_packages,
     get_latest_versions,
     get_latest_versions_parallel,
     resolve_upgradable_packages,
     resolve_upgradable_packages_with_reasons,
     install_packages,
+    reinstall_editable_packages,
 )
+from packaging.version import Version
 from pipu_cli.pretty import (
     print_upgradable_packages_table,
     print_upgrade_results,
@@ -34,7 +37,7 @@ from pipu_cli.cache import (
     is_cache_fresh,
     load_cache,
     save_cache,
-    build_cache_from_results,
+    build_version_cache,
     get_cache_info,
     format_cache_age,
     get_cache_age_seconds,
@@ -122,6 +125,8 @@ def update(timeout: int, pre: bool, parallel: int, debug: bool, output: str) ->
     packages and stores it locally. This speeds up subsequent upgrade
     commands by avoiding repeated network requests.
 
+    Constraint resolution is performed at upgrade time, not during update.
+
     [bold]Examples:[/bold]
       pipu update              Update cache with defaults
       pipu update --parallel 4 Update with parallel requests
@@ -154,7 +159,7 @@ def update(timeout: int, pre: bool, parallel: int, debug: bool, output: str) ->
     try:
         # Step 1: Inspect installed packages
         if output != "json":
-            console.print("[bold]Step 1/3:[/bold] Inspecting installed packages...")
+            console.print("[bold]Step 1/2:[/bold] Inspecting installed packages...")
 
         step1_start = time.time()
         if output != "json":
@@ -184,9 +189,9 @@ def update(timeout: int, pre: bool, parallel: int, debug: bool, output: str) ->
                 console.print("[yellow]No packages found.[/yellow]")
             sys.exit(0)
 
-        # Step 2: Check for updates
+        # Step 2: Fetch latest versions from PyPI and save to cache
         if output != "json":
-            console.print("\n[bold]Step 2/3:[/bold] Fetching latest versions...")
+            console.print("\n[bold]Step 2/2:[/bold] Fetching latest versions from PyPI...")
 
         step2_start = time.time()
         if output != "json":
@@ -199,7 +204,7 @@ def update(timeout: int, pre: bool, parallel: int, debug: bool, output: str) ->
             ) as progress:
                 task = progress.add_task("Checking packages...", total=len(installed_packages))
 
-                def update_progress(current, total):
+                def update_progress(current: int, total: int) -> None:
                     progress.update(task, completed=current)
 
                 if parallel > 1:
@@ -223,45 +228,29 @@ def update(timeout: int, pre: bool, parallel: int, debug: bool, output: str) ->
                 )
         step2_time = time.time() - step2_start
 
-        num_updates = len(latest_versions)
-        if output != "json":
-            console.print(f"  Found {num_updates} packages with newer versions available")
-            if debug:
-                console.print(f"  [dim]Time: {step2_time:.2f}s[/dim]")
-
-        # Step 3: Resolve and cache
-        if output != "json":
-            console.print("\n[bold]Step 3/3:[/bold] Resolving constraints and saving cache...")
-
-        step3_start = time.time()
-        all_upgradable = resolve_upgradable_packages(latest_versions, installed_packages)
-        upgradable_packages = [pkg for pkg in all_upgradable if pkg.upgradable]
-        step3_time = time.time() - step3_start
+        # Build and save cache (only latest versions, no constraint resolution)
+        cache_data = build_version_cache(latest_versions)
+        cache_path = save_cache(cache_data, include_prereleases=pre)
 
-        # Build and save cache
-        cache_data = build_cache_from_results(installed_packages, latest_versions, upgradable_packages)
-        cache_path = save_cache(cache_data)
-
-        num_upgradable = len(upgradable_packages)
+        num_with_updates = len(latest_versions)
 
         if output == "json":
             result = {
                 "status": "success",
                 "packages_checked": num_installed,
-                "packages_with_updates": num_updates,
-                "packages_upgradable": num_upgradable,
+                "packages_with_updates": num_with_updates,
                 "cache_path": str(cache_path)
             }
             print(json.dumps(result, indent=2))
         else:
-            console.print(f"  {num_upgradable} packages can be safely upgraded")
+            console.print(f"  Cached {num_with_updates} packages with updates available")
             if debug:
-                console.print(f"  [dim]Time: {step3_time:.2f}s[/dim]")
+                console.print(f"  [dim]Time: {step2_time:.2f}s[/dim]")
                 console.print(f"  [dim]Cache saved to: {cache_path}[/dim]")
 
-            console.print("\n[bold green]Package list updated![/bold green] Run [cyan]pipu upgrade[/cyan] to upgrade your packages.")
+            console.print("\n[bold green]Cache updated![/bold green] Run [cyan]pipu upgrade[/cyan] to upgrade your packages.")
 
-            total_time = step1_time + step2_time + step3_time
+            total_time = step1_time + step2_time
             if debug:
                 console.print(f"[dim]Total time: {total_time:.2f}s[/dim]")
 
@@ -278,6 +267,225 @@ def update(timeout: int, pre: bool, parallel: int, debug: bool, output: str) ->
         sys.exit(1)
 
 
+# --- Helper functions for upgrade command ---
+
+def _step1_inspect_packages(
+    console: Console, output: str, timeout: int, debug: bool
+) -> tuple[list, float]:
+    """Step 1: Inspect installed packages."""
+    if output != "json":
+        console.print("[bold]Step 1/5:[/bold] Inspecting installed packages...")
+
+    step_start = time.time()
+    if output != "json":
+        with Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description}"),
+            console=console,
+            transient=True
+        ) as progress:
+            progress.add_task("Loading packages...", total=None)
+            installed_packages = inspect_installed_packages(timeout=timeout)
+    else:
+        installed_packages = inspect_installed_packages(timeout=timeout)
+    step_time = time.time() - step_start
+
+    if output != "json":
+        console.print(f"  Found {len(installed_packages)} installed packages")
+        if debug:
+            console.print(f"  [dim]Time: {step_time:.2f}s[/dim]")
+
+    return installed_packages, step_time
+
+
+def _step2_get_latest_versions(
+    console: Console, output: str, debug: bool,
+    installed_packages: list, use_cache: bool, cache_enabled: bool,
+    timeout: int, pre: bool, parallel: int
+) -> tuple[dict, float, bool]:
+    """Step 2: Get latest versions from cache or network."""
+    if output != "json":
+        if use_cache:
+            console.print("\n[bold]Step 2/5:[/bold] Loading cached version data...")
+        else:
+            console.print("\n[bold]Step 2/5:[/bold] Fetching latest versions from PyPI...")
+
+    step_start = time.time()
+    latest_versions: dict = {}
+    cache_was_used = False
+
+    if use_cache:
+        cache_data = load_cache()
+        if cache_data and cache_data.latest_versions:
+            for installed_pkg in installed_packages:
+                name_lower = installed_pkg.name.lower()
+                if name_lower in cache_data.latest_versions:
+                    cached_version = cache_data.latest_versions[name_lower]
+                    try:
+                        latest_ver = Version(cached_version)
+                        if latest_ver > installed_pkg.version:
+                            latest_pkg = Package(name=installed_pkg.name, version=latest_ver)
+                            latest_versions[installed_pkg] = latest_pkg
+                    except Exception:
+                        pass
+            cache_was_used = True
+        else:
+            use_cache = False
+
+    if not use_cache:
+        if output != "json":
+            with Progress(
+                TextColumn("[progress.description]{task.description}"),
+                BarColumn(),
+                TaskProgressColumn(),
+                console=console,
+                transient=True
+            ) as progress:
+                task = progress.add_task("Checking packages...", total=len(installed_packages))
+
+                def update_progress(current: int, total: int) -> None:
+                    progress.update(task, completed=current)
+
+                if parallel > 1:
+                    latest_versions = get_latest_versions_parallel(
+                        installed_packages, timeout=timeout, include_prereleases=pre,
+                        max_workers=parallel, progress_callback=update_progress
+                    )
+                else:
+                    latest_versions = get_latest_versions(
+                        installed_packages, timeout=timeout, include_prereleases=pre,
+                        progress_callback=update_progress
+                    )
+        else:
+            if parallel > 1:
+                latest_versions = get_latest_versions_parallel(
+                    installed_packages, timeout=timeout, include_prereleases=pre, max_workers=parallel
+                )
+            else:
+                latest_versions = get_latest_versions(
+                    installed_packages, timeout=timeout, include_prereleases=pre
+                )
+
+        if cache_enabled:
+            version_cache = build_version_cache(latest_versions)
+            save_cache(version_cache, include_prereleases=pre)
+
+    step_time = time.time() - step_start
+
+    if output != "json":
+        console.print(f"  Found {len(latest_versions)} packages with newer versions available")
+        if cache_was_used:
+            console.print("  [dim](from cache)[/dim]")
+        if debug:
+            console.print(f"  [dim]Time: {step_time:.2f}s[/dim]")
+
+    return latest_versions, step_time, cache_was_used
+
+
+def _step3_resolve_packages(
+    console: Console, output: str, debug: bool,
+    latest_versions: dict, installed_packages: list, show_blocked: bool,
+    exclude: str, packages: tuple
+) -> tuple[list, list, dict, float]:
+    """Step 3: Resolve upgradable packages and apply filters."""
+    if output != "json":
+        console.print("\n[bold]Step 3/5:[/bold] Resolving dependency constraints...")
+    step_start = time.time()
+
+    if show_blocked:
+        upgradable_packages, blocked_packages = resolve_upgradable_packages_with_reasons(
+            latest_versions, installed_packages
+        )
+    else:
+        all_upgradable = resolve_upgradable_packages(latest_versions, installed_packages)
+        upgradable_packages = [pkg for pkg in all_upgradable if pkg.upgradable]
+        blocked_packages = []
+
+    step_time = time.time() - step_start
+
+    # Apply exclusions
+    excluded_names = set()
+    if exclude:
+        excluded_names = {name.strip().lower() for name in exclude.split(',')}
+        if debug and excluded_names:
+            console.print(f"  [dim]Excluding: {', '.join(sorted(excluded_names))}[/dim]")
+
+    can_upgrade = [pkg for pkg in upgradable_packages if pkg.name.lower() not in excluded_names]
+
+    # Parse package specifications and filter
+    package_constraints: dict = {}
+    if packages:
+        requested_packages = set()
+        for spec in packages:
+            name, constraint = parse_package_spec(spec)
+            requested_packages.add(name.lower())
+            if constraint:
+                package_constraints[name.lower()] = constraint
+
+        can_upgrade = [pkg for pkg in can_upgrade if pkg.name.lower() in requested_packages]
+
+        if debug:
+            console.print(f"  [dim]Filtering to: {', '.join(packages)}[/dim]")
+            if package_constraints:
+                console.print(f"  [dim]Version constraints: {package_constraints}[/dim]")
+
+    if output != "json":
+        console.print(f"  {len(can_upgrade)} packages can be safely upgraded")
+        if debug:
+            console.print(f"  [dim]Time: {step_time:.2f}s[/dim]")
+
+    return can_upgrade, blocked_packages, package_constraints, step_time
+
+
+def _step5_install_packages(
+    console: Console, output: str,
+    can_upgrade: list, package_constraints: dict
+) -> tuple[list, float]:
+    """Step 5: Install/upgrade packages."""
+    editable_packages = [pkg for pkg in can_upgrade if pkg.is_editable]
+    non_editable_packages = [pkg for pkg in can_upgrade if not pkg.is_editable]
+
+    if output != "json":
+        total_to_upgrade = len(non_editable_packages) + len(editable_packages)
+        console.print(f"[bold]Step 5/5:[/bold] Upgrading {total_to_upgrade} package(s)...\n")
+    step_start = time.time()
+
+    # Save state for potential rollback
+    from pipu_cli.rollback import save_state
+    pre_upgrade_packages = [
+        {"name": pkg.name, "version": str(pkg.version)}
+        for pkg in can_upgrade
+    ]
+    save_state(pre_upgrade_packages, "Pre-upgrade state")
+
+    stream = ConsoleStream(console) if output != "json" else None
+    results = []
+
+    if non_editable_packages:
+        if output != "json":
+            console.print(f"Upgrading {len(non_editable_packages)} regular package(s)...\n")
+        regular_results = install_packages(
+            non_editable_packages,
+            output_stream=stream,
+            timeout=300,
+            version_constraints=package_constraints if package_constraints else None
+        )
+        results.extend(regular_results)
+
+    if editable_packages:
+        if output != "json":
+            console.print(f"\nReinstalling {len(editable_packages)} editable package(s)...\n")
+        editable_results = reinstall_editable_packages(
+            editable_packages,
+            output_stream=stream,
+            timeout=300
+        )
+        results.extend(editable_results)
+
+    step_time = time.time() - step_start
+    return results, step_time
+
+
 @cli.command()
 @click.argument('packages', nargs=-1)
 @click.option(
@@ -429,29 +637,7 @@ def upgrade(packages: tuple[str, ...], timeout: int, pre: bool, yes: bool, debug
             console.print(f"[dim]Using cached data ({format_cache_age(cache_age)})[/dim]\n")
 
         # Step 1: Inspect installed packages
-        if output != "json":
-            console.print("[bold]Step 1/5:[/bold] Inspecting installed packages...")
-
-        step1_start = time.time()
-        if output != "json":
-            with Progress(
-                SpinnerColumn(),
-                TextColumn("[progress.description]{task.description}"),
-                console=console,
-                transient=True
-            ) as progress:
-                task = progress.add_task("Loading packages...", total=None)
-                installed_packages = inspect_installed_packages(timeout=timeout)
-                progress.update(task, completed=True)
-        else:
-            installed_packages = inspect_installed_packages(timeout=timeout)
-        step1_time = time.time() - step1_start
-
-        num_installed = len(installed_packages)
-        if output != "json":
-            console.print(f"  Found {num_installed} installed packages")
-            if debug:
-                console.print(f"  [dim]Time: {step1_time:.2f}s[/dim]")
+        installed_packages, step1_time = _step1_inspect_packages(console, output, timeout, debug)
 
         if not installed_packages:
             if output == "json":
@@ -460,100 +646,11 @@ def upgrade(packages: tuple[str, ...], timeout: int, pre: bool, yes: bool, debug
                 console.print("[yellow]No packages found.[/yellow]")
             sys.exit(0)
 
-        # Step 2: Check for updates (from cache or network)
-        if output != "json":
-            if use_cache:
-                console.print("\n[bold]Step 2/5:[/bold] Loading cached version data...")
-            else:
-                console.print("\n[bold]Step 2/5:[/bold] Checking for updates...")
-
-        step2_start = time.time()
-        latest_versions: dict = {}
-
-        if use_cache:
-            # Load from cache
-            cache_data = load_cache()
-            if cache_data and cache_data.packages:
-                # Reconstruct latest_versions from cache
-                # We need to fetch fresh for accurate constraint resolution
-                # Cache is mainly to avoid the slow PyPI queries
-                if output != "json":
-                    with Progress(
-                        TextColumn("[progress.description]{task.description}"),
-                        BarColumn(),
-                        TaskProgressColumn(),
-                        console=console,
-                        transient=True
-                    ) as progress:
-                        task = progress.add_task("Checking packages...", total=len(installed_packages))
-
-                        def update_progress(current, total):
-                            progress.update(task, completed=current)
-
-                        if parallel > 1:
-                            latest_versions = get_latest_versions_parallel(
-                                installed_packages, timeout=timeout, include_prereleases=pre,
-                                max_workers=parallel, progress_callback=update_progress
-                            )
-                        else:
-                            latest_versions = get_latest_versions(
-                                installed_packages, timeout=timeout, include_prereleases=pre,
-                                progress_callback=update_progress
-                            )
-                else:
-                    if parallel > 1:
-                        latest_versions = get_latest_versions_parallel(
-                            installed_packages, timeout=timeout, include_prereleases=pre, max_workers=parallel
-                        )
-                    else:
-                        latest_versions = get_latest_versions(
-                            installed_packages, timeout=timeout, include_prereleases=pre
-                        )
-            else:
-                use_cache = False
-
-        if not use_cache:
-            # Fetch from network
-            if output != "json":
-                with Progress(
-                    TextColumn("[progress.description]{task.description}"),
-                    BarColumn(),
-                    TaskProgressColumn(),
-                    console=console,
-                    transient=True
-                ) as progress:
-                    task = progress.add_task("Checking packages...", total=len(installed_packages))
-
-                    def update_progress(current, total):
-                        progress.update(task, completed=current)
-
-                    if parallel > 1:
-                        latest_versions = get_latest_versions_parallel(
-                            installed_packages, timeout=timeout, include_prereleases=pre,
-                            max_workers=parallel, progress_callback=update_progress
-                        )
-                    else:
-                        latest_versions = get_latest_versions(
-                            installed_packages, timeout=timeout, include_prereleases=pre,
-                            progress_callback=update_progress
-                        )
-            else:
-                if parallel > 1:
-                    latest_versions = get_latest_versions_parallel(
-                        installed_packages, timeout=timeout, include_prereleases=pre, max_workers=parallel
-                    )
-                else:
-                    latest_versions = get_latest_versions(
-                        installed_packages, timeout=timeout, include_prereleases=pre
-                    )
-
-        step2_time = time.time() - step2_start
-
-        num_updates = len(latest_versions)
-        if output != "json":
-            console.print(f"  Found {num_updates} packages with newer versions available")
-            if debug:
-                console.print(f"  [dim]Time: {step2_time:.2f}s[/dim]")
+        # Step 2: Get latest versions (from cache or network)
+        latest_versions, step2_time, _ = _step2_get_latest_versions(
+            console, output, debug, installed_packages, use_cache, cache_enabled,
+            timeout, pre, parallel
+        )
 
         if not latest_versions:
             if output == "json":
@@ -563,52 +660,10 @@ def upgrade(packages: tuple[str, ...], timeout: int, pre: bool, yes: bool, debug
             sys.exit(0)
 
         # Step 3: Resolve upgradable packages
-        if output != "json":
-            console.print("\n[bold]Step 3/5:[/bold] Resolving dependency constraints...")
-        step3_start = time.time()
-
-        if show_blocked:
-            upgradable_packages, blocked_packages = resolve_upgradable_packages_with_reasons(
-                latest_versions, installed_packages
-            )
-        else:
-            all_upgradable = resolve_upgradable_packages(latest_versions, installed_packages)
-            upgradable_packages = [pkg for pkg in all_upgradable if pkg.upgradable]
-            blocked_packages = []
-
-        step3_time = time.time() - step3_start
-
-        # Update cache with fresh data (if we fetched from network)
-        if not use_cache and cache_enabled:
-            cache_data = build_cache_from_results(installed_packages, latest_versions, upgradable_packages)
-            save_cache(cache_data)
-
-        # Apply exclusions
-        excluded_names = set()
-        if exclude:
-            excluded_names = {name.strip().lower() for name in exclude.split(',')}
-            if debug and excluded_names:
-                console.print(f"  [dim]Excluding: {', '.join(sorted(excluded_names))}[/dim]")
-
-        # Filter to only upgradable packages (excluding excluded ones)
-        can_upgrade = [pkg for pkg in upgradable_packages if pkg.name.lower() not in excluded_names]
-
-        # Parse package specifications and filter to specific packages if provided
-        package_constraints = {}
-        if packages:
-            requested_packages = set()
-            for spec in packages:
-                name, constraint = parse_package_spec(spec)
-                requested_packages.add(name.lower())
-                if constraint:
-                    package_constraints[name.lower()] = constraint
-
-            can_upgrade = [pkg for pkg in can_upgrade if pkg.name.lower() in requested_packages]
-
-            if debug:
-                console.print(f"  [dim]Filtering to: {', '.join(packages)}[/dim]")
-                if package_constraints:
-                    console.print(f"  [dim]Version constraints: {package_constraints}[/dim]")
+        can_upgrade, blocked_packages, package_constraints, step3_time = _step3_resolve_packages(
+            console, output, debug, latest_versions, installed_packages, show_blocked,
+            exclude, packages
+        )
 
         if not can_upgrade:
             if output == "json":
@@ -625,12 +680,6 @@ def upgrade(packages: tuple[str, ...], timeout: int, pre: bool, yes: bool, debug
                     print_blocked_packages_table(blocked_packages, console=console)
             sys.exit(0)
 
-        num_upgradable = len(can_upgrade)
-        if output != "json":
-            console.print(f"  {num_upgradable} packages can be safely upgraded")
-            if debug:
-                console.print(f"  [dim]Time: {step3_time:.2f}s[/dim]")
-
         # Step 4: Display table and ask for confirmation
         if output == "json":
             assert json_formatter is not None
@@ -668,26 +717,7 @@ def upgrade(packages: tuple[str, ...], timeout: int, pre: bool, yes: bool, debug
                 sys.exit(0)
 
         # Step 5: Install packages
-        if output != "json":
-            console.print("\n[bold]Step 5/5:[/bold] Upgrading packages...\n")
-        step5_start = time.time()
-
-        # Save state for potential rollback
-        from pipu_cli.rollback import save_state
-        pre_upgrade_packages = [
-            {"name": pkg.name, "version": str(pkg.version)}
-            for pkg in can_upgrade
-        ]
-        save_state(pre_upgrade_packages, "Pre-upgrade state")
-
-        stream = ConsoleStream(console) if output != "json" else None
-        results = install_packages(
-            can_upgrade,
-            output_stream=stream,
-            timeout=300,
-            version_constraints=package_constraints if package_constraints else None
-        )
-        step5_time = time.time() - step5_start
+        results, step5_time = _step5_install_packages(console, output, can_upgrade, package_constraints)
 
         # Update requirements file if requested
         if update_requirements:

pipu_cli/config_file.py

@@ -1,6 +1,5 @@
 """Configuration file support for pipu."""
 
-import os
 from pathlib import Path
 from typing import Dict, Any, Optional
 

pipu_cli/package_management.py

@@ -54,6 +54,7 @@ class InstalledPackage(Package):
     """Information about an installed package."""
     constrained_dependencies: Dict[str, str] = field(default_factory=dict, hash=False, compare=False)
     is_editable: bool = False
+    editable_location: Optional[str] = None
 
 
 @dataclass(frozen=True)
@@ -62,6 +63,7 @@ class UpgradePackageInfo(Package):
     upgradable: bool
     latest_version: Version
     is_editable: bool = False
+    editable_location: Optional[str] = None
 
 
 @dataclass(frozen=True)
@@ -70,6 +72,7 @@ class UpgradedPackage(Package):
     upgraded: bool
     previous_version: Version
     is_editable: bool = False
+    editable_location: Optional[str] = None
 
 
 @dataclass(frozen=True)
@@ -78,6 +81,7 @@ class BlockedPackageInfo(Package):
     latest_version: Version
     blocked_by: List[str]  # List of "package_name (constraint)" strings
     is_editable: bool = False
+    editable_location: Optional[str] = None
 
 
 def inspect_installed_packages(timeout: int = 10) -> List[InstalledPackage]:
@@ -115,8 +119,9 @@ def inspect_installed_packages(timeout: int = 10) -> List[InstalledPackage]:
                     logger.warning(f"Invalid version for {package_name}: {dist.version}. Skipping.")
                     continue
 
-                # Check if package is editable
+                # Check if package is editable and get its location
                 is_editable = canonical_name in editable_packages
+                editable_location = editable_packages.get(canonical_name) if is_editable else None
 
                 # Extract constrained dependencies
                 constrained_dependencies = _extract_constrained_dependencies(dist)
@@ -126,6 +131,7 @@ def inspect_installed_packages(timeout: int = 10) -> List[InstalledPackage]:
                     name=package_name,
                     version=package_version,
                     is_editable=is_editable,
+                    editable_location=editable_location,
                     constrained_dependencies=constrained_dependencies
                 )
 
@@ -788,7 +794,8 @@ def resolve_upgradable_packages(
             version=installed_pkg.version,
             upgradable=can_upgrade,
             latest_version=latest_version,
-            is_editable=installed_pkg.is_editable
+            is_editable=installed_pkg.is_editable,
+            editable_location=installed_pkg.editable_location
         ))
 
     return result
@@ -891,7 +898,8 @@ def resolve_upgradable_packages_with_reasons(
                 version=installed_pkg.version,
                 upgradable=True,
                 latest_version=latest_version,
-                is_editable=installed_pkg.is_editable
+                is_editable=installed_pkg.is_editable,
+                editable_location=installed_pkg.editable_location
             ))
         elif is_actual_upgrade:
             # Blocked package
@@ -901,7 +909,8 @@ def resolve_upgradable_packages_with_reasons(
                 version=installed_pkg.version,
                 latest_version=latest_version,
                 blocked_by=reasons,
-                is_editable=installed_pkg.is_editable
+                is_editable=installed_pkg.is_editable,
+                editable_location=installed_pkg.editable_location
             ))
 
     return upgradable, blocked
@@ -1035,7 +1044,8 @@ def install_packages(
                     version=pkg.version,
                     upgraded=False,
                     previous_version=pkg.version,
-                    is_editable=pkg.is_editable
+                    is_editable=pkg.is_editable,
+                    editable_location=pkg.editable_location
                 )
                 for pkg in packages_to_upgrade
             ]
@@ -1078,7 +1088,8 @@ def install_packages(
                     version=current_version,
                     upgraded=True,
                     previous_version=previous_version,
-                    is_editable=pkg_info.is_editable
+                    is_editable=pkg_info.is_editable,
+                    editable_location=pkg_info.editable_location
                 )
                 results.append(upgraded_pkg)
                 logger.info(f"Successfully upgraded {pkg_info.name} from {previous_version} to {current_version}")
@@ -1090,7 +1101,8 @@ def install_packages(
                     version=actual_version,
                     upgraded=False,
                     previous_version=previous_version,
-                    is_editable=pkg_info.is_editable
+                    is_editable=pkg_info.is_editable,
+                    editable_location=pkg_info.editable_location
                 )
                 results.append(upgraded_pkg)
                 logger.info(f"Package {pkg_info.name} was not upgraded (still at {actual_version})")
@@ -1119,7 +1131,8 @@ def install_packages(
                 version=pkg.version,
                 upgraded=False,
                 previous_version=pkg.version,
-                is_editable=pkg.is_editable
+                is_editable=pkg.is_editable,
+                editable_location=pkg.editable_location
             )
             for pkg in packages_to_upgrade
         ]
@@ -1139,7 +1152,139 @@ def install_packages(
                 version=pkg.version,
                 upgraded=False,
                 previous_version=pkg.version,
-                is_editable=pkg.is_editable
+                is_editable=pkg.is_editable,
+                editable_location=pkg.editable_location
             )
             for pkg in packages_to_upgrade
         ]
+
+
+def reinstall_editable_packages(
+    editable_packages: List[UpgradePackageInfo],
+    output_stream: Optional[OutputStream] = None,
+    timeout: int = 300,
+) -> List[UpgradedPackage]:
+    """
+    Reinstall editable packages to update their version metadata.
+
+    Uses `pip install --config-settings editable_mode=compat -e <path>` to reinstall
+    each editable package. This updates the package version in the environment
+    while maintaining the editable install.
+
+    :param editable_packages: List of UpgradePackageInfo objects for editable packages
+    :param output_stream: Optional stream implementing write() and flush() for live progress updates
+    :param timeout: Timeout in seconds for each installation (default: 300)
+    :returns: List of UpgradedPackage objects with upgrade status
+    """
+    if not editable_packages:
+        return []
+
+    results = []
+
+    for pkg in editable_packages:
+        if not pkg.editable_location:
+            logger.warning(f"Editable package {pkg.name} has no location, skipping")
+            results.append(UpgradedPackage(
+                name=pkg.name,
+                version=pkg.version,
+                upgraded=False,
+                previous_version=pkg.version,
+                is_editable=True,
+                editable_location=pkg.editable_location
+            ))
+            continue
+
+        if output_stream:
+            output_stream.write(f"Reinstalling editable package: {pkg.name} from {pkg.editable_location}\n")
+            output_stream.flush()
+
+        cmd = [
+            sys.executable, '-m', 'pip', 'install',
+            '--config-settings', 'editable_mode=compat',
+            '-e', pkg.editable_location
+        ]
+
+        try:
+            process = subprocess.Popen(
+                cmd,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                text=True,
+                bufsize=1
+            )
+
+            # Read output
+            stdout, stderr = process.communicate(timeout=timeout)
+            returncode = process.returncode
+
+            if output_stream and stdout:
+                output_stream.write(stdout)
+            if output_stream and stderr:
+                output_stream.write(stderr)
+            if output_stream:
+                output_stream.flush()
+
+            if returncode == 0:
+                # Get the new version after reinstall
+                env = get_default_environment()
+                canonical_name = canonicalize_name(pkg.name)
+                new_version = pkg.version  # Default to old version
+
+                for dist in env.iter_all_distributions():
+                    dist_name = dist.metadata.get("name", "")
+                    if canonicalize_name(dist_name) == canonical_name:
+                        try:
+                            new_version = Version(str(dist.version))
+                        except InvalidVersion:
+                            pass
+                        break
+
+                results.append(UpgradedPackage(
+                    name=pkg.name,
+                    version=new_version,
+                    upgraded=new_version > pkg.version,
+                    previous_version=pkg.version,
+                    is_editable=True,
+                    editable_location=pkg.editable_location
+                ))
+                logger.info(f"Reinstalled editable package {pkg.name}: {pkg.version} -> {new_version}")
+            else:
+                results.append(UpgradedPackage(
+                    name=pkg.name,
+                    version=pkg.version,
+                    upgraded=False,
+                    previous_version=pkg.version,
+                    is_editable=True,
+                    editable_location=pkg.editable_location
+                ))
+                logger.warning(f"Failed to reinstall editable package {pkg.name}")
+
+        except subprocess.TimeoutExpired:
+            if output_stream:
+                output_stream.write(f"ERROR: Timeout reinstalling {pkg.name}\n")
+                output_stream.flush()
+            results.append(UpgradedPackage(
+                name=pkg.name,
+                version=pkg.version,
+                upgraded=False,
+                previous_version=pkg.version,
+                is_editable=True,
+                editable_location=pkg.editable_location
+            ))
+            logger.error(f"Timeout reinstalling editable package {pkg.name}")
+
+        except Exception as e:
+            if output_stream:
+                output_stream.write(f"ERROR: Failed to reinstall {pkg.name}: {e}\n")
+                output_stream.flush()
+            results.append(UpgradedPackage(
+                name=pkg.name,
+                version=pkg.version,
+                upgraded=False,
+                previous_version=pkg.version,
+                is_editable=True,
+                editable_location=pkg.editable_location
+            ))
+            logger.error(f"Error reinstalling editable package {pkg.name}: {e}")
+
+    return results

{pipu_cli-0.2.0.dist-info → pipu_cli-0.2.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pipu-cli
-Version: 0.2.0
+Version: 0.2.2
 Summary: A cute Python package updater
 Author-email: Scott Arne Johnson <scott.arne.johnson@gmail.com>
 License-Expression: MIT

pipu_cli-0.2.2.dist-info/RECORD

@@ -0,0 +1,16 @@
+pipu_cli/__init__.py,sha256=sGvHQxiNJy0We55W1Z7bjPQfsyJDbeFPhNxH4Qa60Io,1191
+pipu_cli/cache.py,sha256=d5BOItcJSlNfPEnYb4tbMmntzIDjWIl1ZUb5Xo5bJiQ,8243
+pipu_cli/cli.py,sha256=Sl3kHM5-yYVsomXYRy7KCL0e6dC_mSS5fFIdMgf6pVg,34963
+pipu_cli/config.py,sha256=lixyWhJBz5GqdyRIygc4g5Wzc94HPC4sVFCgeINtQtw,1542
+pipu_cli/config_file.py,sha256=0vJbaDS4WDR4RRYA8gKLDtQRi-Stzm9a85qjmnNCqys,2186
+pipu_cli/output.py,sha256=9g64hxHIXxJlq0mmhRwZnbPMMGPpTfSRkH90rc-QPjA,3510
+pipu_cli/package_management.py,sha256=TXATyeu0RmoRbN1nsDKhZCwlnrZGgj-lK5GnL7opoh8,50661
+pipu_cli/pretty.py,sha256=6qBohKDtocm6vJc2rtH9RLgvvHYJiaGMnmhs6QyC0kE,9293
+pipu_cli/requirements.py,sha256=zbh7XwxD9he_5csJitEGT0NfiE4qbXPw_-JSDuHv4G8,2665
+pipu_cli/rollback.py,sha256=gL9ueYtAKDoALqRfJE2S5gnw1Id5QBLaPC1UL_WjzzY,2980
+pipu_cli-0.2.2.dist-info/licenses/LICENSE,sha256=q6TxVbSI0WMB9ulF2V0FWQfeA5om3d-T9X7QwuhdiYE,1075
+pipu_cli-0.2.2.dist-info/METADATA,sha256=HuJ0G_iQoFXXySEQVv9v0ikeFGOA2ixZNprthTx8iVA,11919
+pipu_cli-0.2.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+pipu_cli-0.2.2.dist-info/entry_points.txt,sha256=VSv6od00zOPblnFPflNLaci4jBtQIgLYJjL1BKxLz_o,42
+pipu_cli-0.2.2.dist-info/top_level.txt,sha256=z3Yce93-jGQjGRpsGZUZvbS8osh3OyS7MVpzG0uBE5M,9
+pipu_cli-0.2.2.dist-info/RECORD,,

pipu_cli-0.2.0.dist-info/RECORD

@@ -1,16 +0,0 @@
-pipu_cli/__init__.py,sha256=oN3HVmBGVKNTLG_Ut4GZrH1W3EfUrK_MJqZQ1NIwOnc,1191
-pipu_cli/cache.py,sha256=kQa1GrrDcCT_CcJuMPX79BLBrcB55NArtxQTzzwyNOE,9199
-pipu_cli/cli.py,sha256=W1LNlo3zbO11x-AiFJHJY1Z2eFSNIVcnECLANNgPnwY,34807
-pipu_cli/config.py,sha256=lixyWhJBz5GqdyRIygc4g5Wzc94HPC4sVFCgeINtQtw,1542
-pipu_cli/config_file.py,sha256=2X2UqtJQV7M-czNTx_Hqu-rWLKkK7cn8l8kZ4HNbBkM,2196
-pipu_cli/output.py,sha256=9g64hxHIXxJlq0mmhRwZnbPMMGPpTfSRkH90rc-QPjA,3510
-pipu_cli/package_management.py,sha256=p4m7o5W-RZu4wOZMiU5Sp6WvvnZ2SbUoCIXqYIT3yQU,44822
-pipu_cli/pretty.py,sha256=6qBohKDtocm6vJc2rtH9RLgvvHYJiaGMnmhs6QyC0kE,9293
-pipu_cli/requirements.py,sha256=zbh7XwxD9he_5csJitEGT0NfiE4qbXPw_-JSDuHv4G8,2665
-pipu_cli/rollback.py,sha256=gL9ueYtAKDoALqRfJE2S5gnw1Id5QBLaPC1UL_WjzzY,2980
-pipu_cli-0.2.0.dist-info/licenses/LICENSE,sha256=q6TxVbSI0WMB9ulF2V0FWQfeA5om3d-T9X7QwuhdiYE,1075
-pipu_cli-0.2.0.dist-info/METADATA,sha256=ZArCxjCSlgfz4uTSYb0Szpa3_fOjpOJqaNYxjLHF_jU,11919
-pipu_cli-0.2.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-pipu_cli-0.2.0.dist-info/entry_points.txt,sha256=VSv6od00zOPblnFPflNLaci4jBtQIgLYJjL1BKxLz_o,42
-pipu_cli-0.2.0.dist-info/top_level.txt,sha256=z3Yce93-jGQjGRpsGZUZvbS8osh3OyS7MVpzG0uBE5M,9
-pipu_cli-0.2.0.dist-info/RECORD,,