pipu-cli 0.1.dev3__py3-none-any.whl → 0.1.dev5__py3-none-any.whl

pipu_cli/__init__.py

@@ -1,7 +1,7 @@
 import logging
 from .config import LOG_LEVEL
 
-__version__ = '0.1.dev3'
+__version__ = '0.1.dev5'
 
 
 # Configure logging

pipu_cli/internals.py

@@ -656,6 +656,9 @@ def update_packages_preserving_editable(
     2. Use the original source directory with pip install -e
     3. For regular packages, use normal pip install
 
+    When updating packages, constraints for those packages are temporarily excluded
+    to avoid conflicts between constraints and package dependencies.
+
     :param packages_to_update: List of package dictionaries with keys: name, latest_version, editable
     :param console: Optional Rich console for output
     :param timeout: Optional timeout for pip operations
@@ -664,6 +667,10 @@ def update_packages_preserving_editable(
     """
     import subprocess
     import sys
+    import tempfile
+    import os
+    from packaging.utils import canonicalize_name
+    from pathlib import Path
 
     if console is None:
         console = Console()
@@ -671,103 +678,142 @@ def update_packages_preserving_editable(
     successful_updates = []
     failed_updates = []
 
-    # Helper function to run subprocess with cancellation support
-    def run_with_cancel(cmd, timeout=None):
-        """Run a subprocess command that can be cancelled."""
-        process = subprocess.Popen(
-            cmd,
-            stdout=subprocess.PIPE,
-            stderr=subprocess.PIPE,
-            text=True
-        )
+    # Get all current constraints and create a filtered version that excludes packages being updated
+    from .package_constraints import read_constraints
+    all_constraints = read_constraints()
 
-        try:
-            stdout, stderr = process.communicate(timeout=timeout)
-            return process.returncode, stdout, stderr
-        except subprocess.TimeoutExpired:
-            process.kill()
-            process.communicate()  # Clean up
-            raise
-        except:
-            # If we're interrupted or cancelled, kill the process
-            if process.poll() is None:  # Process still running
+    # Get canonical names of packages being updated
+    packages_being_updated = {canonicalize_name(pkg["name"]) for pkg in packages_to_update}
+
+    # Filter out constraints for packages being updated to avoid conflicts
+    filtered_constraints = {
+        pkg: constraint
+        for pkg, constraint in all_constraints.items()
+        if pkg not in packages_being_updated
+    }
+
+    # Create a temporary constraints file if there are any constraints to apply
+    constraint_file = None
+    constraint_file_path = None
+    try:
+        if filtered_constraints:
+            constraint_file = tempfile.NamedTemporaryFile(mode='w', suffix='.txt', delete=False)
+            constraint_file_path = constraint_file.name
+            for pkg, constraint in filtered_constraints.items():
+                constraint_file.write(f"{pkg}{constraint}\n")
+            constraint_file.close()
+            console.print(f"[dim]Using filtered constraints (excluding {len(packages_being_updated)} package(s) being updated)[/dim]")
+
+        # Helper function to run subprocess with cancellation support
+        def run_with_cancel(cmd, timeout=None):
+            """Run a subprocess command that can be cancelled."""
+            # Set up environment with constraint file if available
+            env = os.environ.copy()
+            if constraint_file_path:
+                env['PIP_CONSTRAINT'] = constraint_file_path
+
+            process = subprocess.Popen(
+                cmd,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                text=True,
+                env=env
+            )
+
+            try:
+                stdout, stderr = process.communicate(timeout=timeout)
+                return process.returncode, stdout, stderr
+            except subprocess.TimeoutExpired:
                 process.kill()
-                try:
-                    process.communicate(timeout=1)
-                except:
-                    pass
-            raise
+                process.communicate()  # Clean up
+                raise
+            except:
+                # If we're interrupted or cancelled, kill the process
+                if process.poll() is None:  # Process still running
+                    process.kill()
+                    try:
+                        process.communicate(timeout=1)
+                    except:
+                        pass
+                raise
 
-    # Get current editable packages to find source directories
-    editable_packages = get_editable_packages()
+        # Get current editable packages to find source directories
+        editable_packages = get_editable_packages()
 
-    for package_info in packages_to_update:
-        # Check for cancellation before processing each package
-        if cancel_event and cancel_event.is_set():
-            console.print("[yellow]Update cancelled by user[/yellow]")
-            break
+        for package_info in packages_to_update:
+            # Check for cancellation before processing each package
+            if cancel_event and cancel_event.is_set():
+                console.print("[yellow]Update cancelled by user[/yellow]")
+                break
 
-        package_name = package_info["name"]
-        latest_version = package_info.get("latest_version")
-        is_editable = package_info.get("editable", False)
+            package_name = package_info["name"]
+            latest_version = package_info.get("latest_version")
+            is_editable = package_info.get("editable", False)
 
-        try:
-            console.print(f"Updating {package_name}...")
+            try:
+                console.print(f"Updating {package_name}...")
 
-            if is_editable:
-                # Package is editable, reinstall from source directory
-                from packaging.utils import canonicalize_name
-                canonical_name = canonicalize_name(package_name)
-                source_path = editable_packages.get(canonical_name)
+                if is_editable:
+                    # Package is editable, reinstall from source directory
+                    canonical_name = canonicalize_name(package_name)
+                    source_path = editable_packages.get(canonical_name)
 
-                if source_path:
-                    console.print(f"  📝 Reinstalling editable package from: {source_path}")
+                    if source_path:
+                        console.print(f"  📝 Reinstalling editable package from: {source_path}")
 
-                    # First uninstall the current version
-                    uninstall_cmd = [sys.executable, "-m", "pip", "uninstall", package_name, "-y"]
-                    returncode, stdout, stderr = run_with_cancel(uninstall_cmd, timeout=timeout)
+                        # First uninstall the current version
+                        uninstall_cmd = [sys.executable, "-m", "pip", "uninstall", package_name, "-y"]
+                        returncode, stdout, stderr = run_with_cancel(uninstall_cmd, timeout=timeout)
 
-                    if returncode != 0:
-                        console.print(f"  [red]Failed to uninstall {package_name}: {stderr}[/red]")
-                        failed_updates.append(package_name)
-                        continue
+                        if returncode != 0:
+                            console.print(f"  [red]Failed to uninstall {package_name}: {stderr}[/red]")
+                            failed_updates.append(package_name)
+                            continue
+
+                        # Then reinstall in editable mode
+                        install_cmd = [sys.executable, "-m", "pip", "install", "-e", source_path]
+                        returncode, stdout, stderr = run_with_cancel(install_cmd, timeout=timeout)
+
+                        if returncode == 0:
+                            console.print(f"  [green]✓ Successfully updated editable {package_name}[/green]")
+                            successful_updates.append(package_name)
+                        else:
+                            console.print(f"  [red]Failed to reinstall editable {package_name}: {stderr}[/red]")
+                            failed_updates.append(package_name)
+                    else:
+                        console.print(f"  [yellow]Could not find source path for editable {package_name}, updating normally[/yellow]")
+                        # Fall through to normal update
+                        is_editable = False
+
+                if not is_editable:
+                    # Regular package update
+                    # Use --upgrade instead of pinning to specific versions to allow pip's
+                    # dependency resolver to handle interdependent packages correctly
+                    # (e.g., pydantic and pydantic-core, boto3 and botocore)
+                    install_cmd = [sys.executable, "-m", "pip", "install", "--upgrade", package_name]
 
-                    # Then reinstall in editable mode
-                    install_cmd = [sys.executable, "-m", "pip", "install", "-e", source_path]
                     returncode, stdout, stderr = run_with_cancel(install_cmd, timeout=timeout)
 
                     if returncode == 0:
-                        console.print(f"  [green]✓ Successfully updated editable {package_name}[/green]")
+                        console.print(f"  [green]✓ Successfully updated {package_name}[/green]")
                         successful_updates.append(package_name)
                     else:
-                        console.print(f"  [red]Failed to reinstall editable {package_name}: {stderr}[/red]")
+                        console.print(f"  [red]Failed to update {package_name}: {stderr}[/red]")
                         failed_updates.append(package_name)
-                else:
-                    console.print(f"  [yellow]Could not find source path for editable {package_name}, updating normally[/yellow]")
-                    # Fall through to normal update
-                    is_editable = False
-
-            if not is_editable:
-                # Regular package update
-                if latest_version:
-                    install_cmd = [sys.executable, "-m", "pip", "install", f"{package_name}=={latest_version}"]
-                else:
-                    install_cmd = [sys.executable, "-m", "pip", "install", "--upgrade", package_name]
-
-                returncode, stdout, stderr = run_with_cancel(install_cmd, timeout=timeout)
 
-                if returncode == 0:
-                    console.print(f"  [green]✓ Successfully updated {package_name}[/green]")
-                    successful_updates.append(package_name)
-                else:
-                    console.print(f"  [red]Failed to update {package_name}: {stderr}[/red]")
-                    failed_updates.append(package_name)
+            except subprocess.TimeoutExpired:
+                console.print(f"  [red]Timeout updating {package_name}[/red]")
+                failed_updates.append(package_name)
+            except Exception as e:
+                console.print(f"  [red]Error updating {package_name}: {e}[/red]")
+                failed_updates.append(package_name)
 
-        except subprocess.TimeoutExpired:
-            console.print(f"  [red]Timeout updating {package_name}[/red]")
-            failed_updates.append(package_name)
-        except Exception as e:
-            console.print(f"  [red]Error updating {package_name}: {e}[/red]")
-            failed_updates.append(package_name)
+        return successful_updates, failed_updates
 
-    return successful_updates, failed_updates
+    finally:
+        # Clean up temporary constraint file
+        if constraint_file_path and os.path.exists(constraint_file_path):
+            try:
+                os.unlink(constraint_file_path)
+            except Exception:
+                pass  # Best effort cleanup

pipu_cli/ui/modal_dialogs.py

@@ -989,81 +989,116 @@ class PackageUpdateScreen(ModalScreen[None]):
             try:
                 import subprocess
                 import sys
+                import tempfile
+                import os
+                from packaging.utils import canonicalize_name
 
                 logger.info(f"Starting batch update for {len(self.selected_packages)} packages")
                 total_packages = len(self.selected_packages)
 
-                # Build list of package specs to update, respecting constraints
-                package_specs = []
-                package_names = []
-                for pkg in self.selected_packages:
-                    package_names.append(pkg["name"])
-                    # Check if package has a constraint that should be applied instead of latest version
-                    constraint = pkg.get('constraint')
-                    if constraint:
-                        # Apply the constraint instead of pinning to latest version
-                        spec = f"{pkg['name']}{constraint}"
-                    else:
-                        # No constraint, use latest version
-                        spec = f"{pkg['name']}=={pkg['latest_version']}"
-                    package_specs.append(spec)
-
-                self.app.call_from_thread(self._update_status, f"Updating {total_packages} packages...")
-                self.app.call_from_thread(self._log_message, f"{'='*70}")
-                self.app.call_from_thread(self._log_message, f"📦 Updating {total_packages} packages: {', '.join(package_names[:5])}")
-                if len(package_names) > 5:
-                    self.app.call_from_thread(self._log_message, f"   ... and {len(package_names) - 5} more")
-                self.app.call_from_thread(self._log_message, f"{'='*70}\n")
-
-                # Prepare pip command to install all packages at once with proper version specs
-                pip_cmd = [sys.executable, "-m", "pip", "install"] + package_specs
-
-                # Run pip and capture output with proper cleanup
-                from ..utils import ManagedProcess
-                return_code = None
-
+                # Get canonical names of packages being updated
+                from ..package_constraints import read_constraints
+                all_constraints = read_constraints()
+                packages_being_updated = {canonicalize_name(pkg["name"]) for pkg in self.selected_packages}
+
+                # Filter out constraints for packages being updated to avoid conflicts
+                filtered_constraints = {
+                    pkg: constraint
+                    for pkg, constraint in all_constraints.items()
+                    if pkg not in packages_being_updated
+                }
+
+                # Create a temporary constraints file if there are any constraints to apply
+                constraint_file = None
+                constraint_file_path = None
                 try:
-                    with ManagedProcess(
-                        pip_cmd,
-                        stdout=subprocess.PIPE,
-                        stderr=subprocess.STDOUT,
-                        text=True,
-                        bufsize=1,
-                        universal_newlines=True
-                    ) as process:
-                        # Stream output line by line
-                        if process.stdout is None:
-                            raise RuntimeError("Failed to capture subprocess output")
-                        for line in process.stdout:
-                            if self.cancel_event.is_set():
-                                self.app.call_from_thread(self._log_message, "\n🛑 Update cancelled by user")
-                                break
-                            # Display each line of pip output
-                            self.app.call_from_thread(self._log_message, line.rstrip())
-
-                        # Wait for process to complete
-                        return_code = process.wait()
-                except Exception as e:
-                    logger.error(f"Error during package update: {e}")
-                    self.app.call_from_thread(self._log_message, f"\n❌ Error: {e}")
-                    return_code = 1
-
-                if return_code == 0:
-                    # All packages updated successfully
-                    self.successful_updates.extend(package_names)
-                    self.app.call_from_thread(self._log_message, f"\n{'='*70}")
-                    self.app.call_from_thread(self._log_message, f"✅ Successfully updated all {total_packages} packages!")
-                    self.app.call_from_thread(self._log_message, f"{'='*70}")
-                else:
-                    # Some packages failed - pip will have shown which ones in output
-                    self.failed_updates.extend(package_names)
-                    self.app.call_from_thread(self._log_message, f"\n{'='*70}")
-                    self.app.call_from_thread(self._log_message, "❌ Update completed with errors (see above)")
+                    if filtered_constraints:
+                        constraint_file = tempfile.NamedTemporaryFile(mode='w', suffix='.txt', delete=False)
+                        constraint_file_path = constraint_file.name
+                        for pkg, constraint in filtered_constraints.items():
+                            constraint_file.write(f"{pkg}{constraint}\n")
+                        constraint_file.close()
+                        self.app.call_from_thread(self._log_message, f"[dim]Using filtered constraints (excluding {len(packages_being_updated)} package(s) being updated)[/dim]")
+
+                    # Build list of package names to update
+                    # Use --upgrade instead of pinning versions to avoid dependency conflicts
+                    # when updating interdependent packages (e.g., pydantic and pydantic-core)
+                    package_names = []
+                    for pkg in self.selected_packages:
+                        package_names.append(pkg["name"])
+
+                    self.app.call_from_thread(self._update_status, f"Updating {total_packages} packages...")
                     self.app.call_from_thread(self._log_message, f"{'='*70}")
-
-                # Show final results and cleanup
-                logger.info("Update loop completed, calling _update_complete")
-                self.app.call_from_thread(self._update_complete)
+                    self.app.call_from_thread(self._log_message, f"📦 Updating {total_packages} packages: {', '.join(package_names[:5])}")
+                    if len(package_names) > 5:
+                        self.app.call_from_thread(self._log_message, f"   ... and {len(package_names) - 5} more")
+                    self.app.call_from_thread(self._log_message, f"{'='*70}\n")
+
+                    # Prepare pip command to install all packages with --upgrade
+                    # This allows pip's dependency resolver to find compatible versions
+                    # for interdependent packages (e.g., pydantic requires specific pydantic-core)
+                    pip_cmd = [sys.executable, "-m", "pip", "install", "--upgrade"] + package_names
+
+                    # Set up environment with constraint file if available
+                    env = os.environ.copy()
+                    if constraint_file_path:
+                        env['PIP_CONSTRAINT'] = constraint_file_path
+
+                    # Run pip and capture output with proper cleanup
+                    from ..utils import ManagedProcess
+                    return_code = None
+
+                    try:
+                        with ManagedProcess(
+                            pip_cmd,
+                            stdout=subprocess.PIPE,
+                            stderr=subprocess.STDOUT,
+                            text=True,
+                            bufsize=1,
+                            universal_newlines=True,
+                            env=env
+                        ) as process:
+                            # Stream output line by line
+                            if process.stdout is None:
+                                raise RuntimeError("Failed to capture subprocess output")
+                            for line in process.stdout:
+                                if self.cancel_event.is_set():
+                                    self.app.call_from_thread(self._log_message, "\n🛑 Update cancelled by user")
+                                    break
+                                # Display each line of pip output
+                                self.app.call_from_thread(self._log_message, line.rstrip())
+
+                            # Wait for process to complete
+                            return_code = process.wait()
+                    except Exception as e:
+                        logger.error(f"Error during package update: {e}")
+                        self.app.call_from_thread(self._log_message, f"\n❌ Error: {e}")
+                        return_code = 1
+
+                    if return_code == 0:
+                        # All packages updated successfully
+                        self.successful_updates.extend(package_names)
+                        self.app.call_from_thread(self._log_message, f"\n{'='*70}")
+                        self.app.call_from_thread(self._log_message, f"✅ Successfully updated all {total_packages} packages!")
+                        self.app.call_from_thread(self._log_message, f"{'='*70}")
+                    else:
+                        # Some packages failed - pip will have shown which ones in output
+                        self.failed_updates.extend(package_names)
+                        self.app.call_from_thread(self._log_message, f"\n{'='*70}")
+                        self.app.call_from_thread(self._log_message, "❌ Update completed with errors (see above)")
+                        self.app.call_from_thread(self._log_message, f"{'='*70}")
+
+                    # Show final results and cleanup
+                    logger.info("Update loop completed, calling _update_complete")
+                    self.app.call_from_thread(self._update_complete)
+
+                finally:
+                    # Clean up temporary constraint file
+                    if constraint_file_path and os.path.exists(constraint_file_path):
+                        try:
+                            os.unlink(constraint_file_path)
+                        except Exception:
+                            pass  # Best effort cleanup
 
             except Exception as e:
                 logger.error(f"Error in update loop: {e}", exc_info=True)

{pipu_cli-0.1.dev3.dist-info → pipu_cli-0.1.dev5.dist-info}/METADATA

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

{pipu_cli-0.1.dev3.dist-info → pipu_cli-0.1.dev5.dist-info}/RECORD

@@ -1,19 +1,19 @@
-pipu_cli/__init__.py,sha256=ZGWSFbUBHC0Pkg98JvTSu7BYa8nE73GgCi8vvlDrNxQ,1190
+pipu_cli/__init__.py,sha256=c6A1uB6wkExOK4rptn9LBAd6FaSBplB1jxURCwoNFWY,1190
 pipu_cli/cli.py,sha256=aCN2Fz1bWhXs8MC7kqy5GdzJggNtTdumW4PQkxKOBpg,39993
 pipu_cli/common.py,sha256=g5krfXFsvVJpOf87Vw4DGi5WIduDgMlRuONKXqO328M,78
 pipu_cli/config.py,sha256=xsfNU4ORAujla_FGfsMKpxy7QTpd_bJhRF_u4IPKLW0,3635
-pipu_cli/internals.py,sha256=1Fds2mMn2SJwfTwfjbeqAcTWJjOazP9QtrjRvgzzspo,32786
+pipu_cli/internals.py,sha256=m_aF-yrOT5UJt54vv6X2gEukgokFXkz0m9SAKRofir0,35101
 pipu_cli/package_constraints.py,sha256=6LSFlC93HNIFym7dYkfYn0fsOic6QDe1ADyghK94Pk8,93052
 pipu_cli/thread_safe.py,sha256=zdQyCoMVJW73MC-d1pL_4ZO-K4AwkI0JeVyQsd8x7nY,7545
 pipu_cli/utils.py,sha256=ijSHKVuKbjmRbj2RwD9S1606PeY4oDiutzhutpX25wM,5842
 pipu_cli/ui/__init__.py,sha256=nCb_3G_vZXy5_Or9z9r-3XhYV1ppUR1r7nMZ9_6Srwg,1432
 pipu_cli/ui/apps.py,sha256=ltH24sg-3nqVpoomgCwhVYuAwq3hBUwYRH60JXtV2Yg,59771
 pipu_cli/ui/constants.py,sha256=HBPf4KYWHiT18c7ciQ0HeI7gZE3VIFOT0uobLU8YxQA,445
-pipu_cli/ui/modal_dialogs.py,sha256=5OF8UL2lXXH3GoAxFQCqp_T3jc5jeLSk77Y7ffBt6mw,45849
+pipu_cli/ui/modal_dialogs.py,sha256=-Trh60n2mev6Pr-aIvetJHnXqqoJaVDmA3c8xH_xePM,47974
 pipu_cli/ui/table_widgets.py,sha256=PC0CqqrK3KgMbTCYRPG01lxkEtRBz9xr9PN8EzoObz8,14322
-pipu_cli-0.1.dev3.dist-info/licenses/LICENSE,sha256=q6TxVbSI0WMB9ulF2V0FWQfeA5om3d-T9X7QwuhdiYE,1075
-pipu_cli-0.1.dev3.dist-info/METADATA,sha256=9NjeUzT8buLXYRHBUAuQPulDnA0sLi66eov4XldR57c,13200
-pipu_cli-0.1.dev3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-pipu_cli-0.1.dev3.dist-info/entry_points.txt,sha256=VSv6od00zOPblnFPflNLaci4jBtQIgLYJjL1BKxLz_o,42
-pipu_cli-0.1.dev3.dist-info/top_level.txt,sha256=z3Yce93-jGQjGRpsGZUZvbS8osh3OyS7MVpzG0uBE5M,9
-pipu_cli-0.1.dev3.dist-info/RECORD,,
+pipu_cli-0.1.dev5.dist-info/licenses/LICENSE,sha256=q6TxVbSI0WMB9ulF2V0FWQfeA5om3d-T9X7QwuhdiYE,1075
+pipu_cli-0.1.dev5.dist-info/METADATA,sha256=uV-3D56gMhQSSe8aK0V1t7gUPSSihd0pHWsjObLC6pA,13200
+pipu_cli-0.1.dev5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+pipu_cli-0.1.dev5.dist-info/entry_points.txt,sha256=VSv6od00zOPblnFPflNLaci4jBtQIgLYJjL1BKxLz_o,42
+pipu_cli-0.1.dev5.dist-info/top_level.txt,sha256=z3Yce93-jGQjGRpsGZUZvbS8osh3OyS7MVpzG0uBE5M,9
+pipu_cli-0.1.dev5.dist-info/RECORD,,