Python Virtual Environment System Update Fix Scripts

Environment Diagnostic Script #

#!/usr/bin/env python3
"""
Diagnostic script to check Python and virtual environment status after system update.
Run this script to identify issues with your Python installation.
"""

import os
import sys
import subprocess
import shutil
from pathlib import Path

def run_command(cmd):
    """Run shell command and return output."""
    try:
        result = subprocess.run(cmd, shell=True, capture_output=True, text=True)
        return result.returncode, result.stdout.strip(), result.stderr.strip()
    except Exception as e:
        return -1, "", str(e)

def check_python_installation():
    """Check Python installation and versions."""
    print("🐍 Python Installation Check")
    print("=" * 40)
    
    # Check Python executables
    python_commands = ['python', 'python3', 'python3.11', 'python3.10', 'python3.9']
    
    for cmd in python_commands:
        if shutil.which(cmd):
            code, output, error = run_command(f"{cmd} --version")
            if code == 0:
                print(f"✅ {cmd}: {output}")
                # Check if it's the same as sys.executable
                code2, path, _ = run_command(f"which {cmd}")
                if code2 == 0:
                    print(f"   Path: {path}")
            else:
                print(f"❌ {cmd}: Not working ({error})")
        else:
            print(f"❌ {cmd}: Not found in PATH")
    
    print(f"\n🔍 Current Python: {sys.executable}")
    print(f"🔍 Python version: {sys.version}")
    print(f"🔍 Python path: {sys.path}")

def check_path_environment():
    """Check PATH environment variable."""
    print("\n🛣️  PATH Environment Check")
    print("=" * 40)
    
    path_env = os.environ.get('PATH', '')
    python_paths = [p for p in path_env.split(os.pathsep) if 'python' in p.lower()]
    
    if python_paths:
        print("✅ Python-related paths in PATH:")
        for p in python_paths:
            print(f"   {p}")
    else:
        print("⚠️  No Python-related paths found in PATH")
    
    # Check common Python installation directories
    common_paths = [
        '/usr/bin',
        '/usr/local/bin',
        '/opt/homebrew/bin',  # macOS Apple Silicon
        '/home/linuxbrew/.linuxbrew/bin',  # Linux Homebrew
        os.path.expanduser('~/.pyenv/shims'),
        os.path.expanduser('~/miniconda3/bin'),
        os.path.expanduser('~/anaconda3/bin'),
    ]
    
    print("\n🔍 Common Python installation directories:")
    for path in common_paths:
        if os.path.exists(path):
            python_files = list(Path(path).glob('python*'))
            if python_files:
                print(f"✅ {path}: {len(python_files)} Python executables")
                for pf in python_files[:3]:  # Show first 3
                    print(f"   - {pf.name}")
            else:
                print(f"➖ {path}: exists but no Python executables")
        else:
            print(f"❌ {path}: not found")

def check_venv_capability():
    """Check if venv module is available."""
    print("\n📦 Virtual Environment Capability Check")
    print("=" * 40)
    
    # Test venv module
    code, output, error = run_command(f"{sys.executable} -m venv --help")
    if code == 0:
        print("✅ venv module is available")
    else:
        print(f"❌ venv module not working: {error}")
    
    # Test pip
    code, output, error = run_command(f"{sys.executable} -m pip --version")
    if code == 0:
        print(f"✅ pip is available: {output}")
    else:
        print(f"❌ pip not working: {error}")
    
    # Check for other virtual environment tools
    tools = ['virtualenv', 'conda', 'pipenv', 'poetry']
    for tool in tools:
        if shutil.which(tool):
            code, output, error = run_command(f"{tool} --version")
            if code == 0:
                print(f"✅ {tool}: {output}")
            else:
                print(f"⚠️  {tool}: found but not working")
        else:
            print(f"❌ {tool}: not found")

def scan_existing_venvs():
    """Scan for existing virtual environments."""
    print("\n🔍 Existing Virtual Environments Scan")
    print("=" * 40)
    
    # Common venv locations
    search_paths = [
        Path.cwd(),
        Path.home(),
        Path.home() / 'venvs',
        Path.home() / '.virtualenvs',
    ]
    
    found_venvs = []
    
    for search_path in search_paths:
        if search_path.exists():
            # Look for venv directories
            for item in search_path.iterdir():
                if item.is_dir():
                    # Check for venv indicators
                    indicators = [
                        item / 'bin' / 'activate',        # Unix
                        item / 'Scripts' / 'activate',    # Windows
                        item / 'pyvenv.cfg',              # Python 3.3+
                    ]
                    
                    if any(ind.exists() for ind in indicators):
                        found_venvs.append(item)
    
    if found_venvs:
        print(f"✅ Found {len(found_venvs)} virtual environments:")
        for venv in found_venvs[:10]:  # Show first 10
            # Check if venv is still valid
            python_exe = None
            for possible_python in [venv / 'bin' / 'python', venv / 'Scripts' / 'python.exe']:
                if possible_python.exists():
                    python_exe = possible_python
                    break
            
            if python_exe and python_exe.exists():
                # Try to get Python version from the venv
                code, output, error = run_command(f'"{python_exe}" --version')
                if code == 0:
                    print(f"   ✅ {venv.name}: {output}")
                else:
                    print(f"   ❌ {venv.name}: Python executable broken")
            else:
                print(f"   ❌ {venv.name}: No Python executable found")
    else:
        print("❌ No virtual environments found")

def main():
    """Run all diagnostic checks."""
    print("🔧 Python Virtual Environment Diagnostic Tool")
    print("=" * 50)
    print("This tool helps diagnose Python virtual environment issues after system updates.\n")
    
    check_python_installation()
    check_path_environment()
    check_venv_capability()
    scan_existing_venvs()
    
    print("\n💡 Next Steps:")
    print("1. If Python is not found, reinstall Python or fix PATH")
    print("2. If venv module is missing, install python3-venv package")
    print("3. If virtual environments are broken, recreate them")
    print("4. Run the environment recreation script if needed")

if __name__ == "__main__":
    main()

Automatic Environment Recreation Script #

#!/usr/bin/env python3
"""
Script to automatically recreate broken virtual environments after system updates.
Backs up requirements and recreates environments with current Python.
"""

import os
import sys
import subprocess
import shutil
import json
from pathlib import Path
from datetime import datetime

class VenvRecreator:
    def __init__(self, venv_path, backup_dir=None):
        self.venv_path = Path(venv_path)
        self.backup_dir = Path(backup_dir) if backup_dir else Path.cwd() / "venv_backups"
        self.requirements_file = None
        
    def run_command(self, cmd, cwd=None):
        """Run command and return result."""
        try:
            result = subprocess.run(
                cmd, shell=True, capture_output=True, text=True, cwd=cwd
            )
            return result.returncode, result.stdout.strip(), result.stderr.strip()
        except Exception as e:
            return -1, "", str(e)
    
    def backup_requirements(self):
        """Backup current environment requirements."""
        print(f"📦 Backing up requirements for {self.venv_path.name}")
        
        # Ensure backup directory exists
        self.backup_dir.mkdir(exist_ok=True)
        
        # Determine activation script path
        activate_scripts = [
            self.venv_path / "bin" / "activate",      # Unix
            self.venv_path / "Scripts" / "activate",  # Windows
        ]
        
        activate_script = None
        for script in activate_scripts:
            if script.exists():
                activate_script = script
                break
        
        if not activate_script:
            print(f"❌ No activation script found for {self.venv_path}")
            return False
        
        # Try to get requirements using pip freeze
        if os.name == 'nt':  # Windows
            pip_cmd = f'"{self.venv_path / "Scripts" / "pip.exe"}" freeze'
        else:  # Unix
            pip_cmd = f'"{self.venv_path / "bin" / "pip"}" freeze'
        
        code, output, error = self.run_command(pip_cmd)
        
        if code == 0 and output:
            # Save requirements
            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
            requirements_file = self.backup_dir / f"{self.venv_path.name}_requirements_{timestamp}.txt"
            
            with open(requirements_file, 'w') as f:
                f.write(output)
            
            self.requirements_file = requirements_file
            print(f"✅ Requirements saved to {requirements_file}")
            
            # Also save environment info
            info_file = self.backup_dir / f"{self.venv_path.name}_info_{timestamp}.json"
            info = {
                "venv_name": self.venv_path.name,
                "venv_path": str(self.venv_path),
                "backup_date": timestamp,
                "python_version": sys.version,
                "requirements_file": str(requirements_file)
            }
            
            with open(info_file, 'w') as f:
                json.dump(info, f, indent=2)
            
            return True
        else:
            print(f"⚠️  Could not extract requirements: {error}")
            return False
    
    def remove_old_venv(self):
        """Remove the old virtual environment."""
        print(f"🗑️  Removing old virtual environment: {self.venv_path}")
        
        if self.venv_path.exists():
            try:
                shutil.rmtree(self.venv_path)
                print("✅ Old environment removed")
                return True
            except Exception as e:
                print(f"❌ Failed to remove old environment: {e}")
                return False
        else:
            print("⚠️  Virtual environment directory not found")
            return True
    
    def create_new_venv(self):
        """Create new virtual environment."""
        print(f"🆕 Creating new virtual environment: {self.venv_path}")
        
        # Use current Python to create new venv
        cmd = f'"{sys.executable}" -m venv "{self.venv_path}"'
        code, output, error = self.run_command(cmd)
        
        if code == 0:
            print("✅ New virtual environment created")
            return True
        else:
            print(f"❌ Failed to create virtual environment: {error}")
            return False
    
    def install_requirements(self):
        """Install requirements in new environment."""
        if not self.requirements_file or not self.requirements_file.exists():
            print("⚠️  No requirements file available")
            return True
        
        print(f"📥 Installing requirements from {self.requirements_file}")
        
        # Determine pip path
        if os.name == 'nt':  # Windows
            pip_path = self.venv_path / "Scripts" / "pip.exe"
        else:  # Unix
            pip_path = self.venv_path / "bin" / "pip"
        
        # Upgrade pip first
        cmd = f'"{pip_path}" install --upgrade pip'
        code, output, error = self.run_command(cmd)
        if code != 0:
            print(f"⚠️  Failed to upgrade pip: {error}")
        
        # Install requirements
        cmd = f'"{pip_path}" install -r "{self.requirements_file}"'
        code, output, error = self.run_command(cmd)
        
        if code == 0:
            print("✅ Requirements installed successfully")
            return True
        else:
            print(f"❌ Failed to install some requirements: {error}")
            print("   You may need to install them manually")
            return False
    
    def recreate(self):
        """Complete recreation process."""
        print(f"🔄 Recreating virtual environment: {self.venv_path}")
        print("=" * 50)
        
        # Step 1: Backup requirements
        if not self.backup_requirements():
            print("⚠️  Continuing without requirements backup...")
        
        # Step 2: Remove old environment
        if not self.remove_old_venv():
            print("❌ Cannot continue - failed to remove old environment")
            return False
        
        # Step 3: Create new environment
        if not self.create_new_venv():
            print("❌ Cannot continue - failed to create new environment")
            return False
        
        # Step 4: Install requirements
        if not self.install_requirements():
            print("⚠️  Environment created but some packages may be missing")
        
        print(f"\n✅ Virtual environment {self.venv_path.name} has been recreated!")
        print(f"🔧 Activate it with:")
        if os.name == 'nt':
            print(f"   {self.venv_path}\\Scripts\\activate")
        else:
            print(f"   source {self.venv_path}/bin/activate")
        
        return True

def main():
    """Main function to handle command line usage."""
    if len(sys.argv) < 2:
        print("Usage: python recreate_venv.py <venv_path> [backup_dir]")
        print("Example: python recreate_venv.py ./myproject_venv")
        sys.exit(1)
    
    venv_path = sys.argv[1]
    backup_dir = sys.argv[2] if len(sys.argv) > 2 else None
    
    recreator = VenvRecreator(venv_path, backup_dir)
    success = recreator.recreate()
    
    if success:
        print("\n🎉 Recreation completed successfully!")
    else:
        print("\n❌ Recreation failed. Check the error messages above.")
        sys.exit(1)

if __name__ == "__main__":
    main()

Quick Fix Shell Scripts #

Unix/Linux/macOS Quick Fix Script #

#!/bin/bash
# quick_venv_fix.sh - Quick fix for Python virtual environment issues

set -e

echo "🔧 Python Virtual Environment Quick Fix"
echo "======================================"

# Colors for output
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
NC='\033[0m' # No Color

# Function to print colored output
print_status() {
    echo -e "${GREEN}✅ $1${NC}"
}

print_warning() {
    echo -e "${YELLOW}⚠️  $1${NC}"
}

print_error() {
    echo -e "${RED}❌ $1${NC}"
}

# Check if Python 3 is available
if ! command -v python3 &> /dev/null; then
    print_error "Python 3 is not installed or not in PATH"
    echo "Please install Python 3 first:"
    echo "  macOS: brew install [email protected]"
    echo "  Ubuntu: sudo apt install python3 python3-venv python3-pip"
    echo "  CentOS: sudo yum install python3 python3-venv python3-pip"
    exit 1
fi

print_status "Python 3 found: $(python3 --version)"

# Check if venv module is available
if ! python3 -m venv --help &> /dev/null; then
    print_error "venv module is not available"
    echo "Install it with:"
    echo "  Ubuntu/Debian: sudo apt install python3-venv"
    echo "  CentOS/RHEL: sudo yum install python3-venv"
    exit 1
fi

print_status "venv module is available"

# Get virtual environment name from user
if [ -z "$1" ]; then
    read -p "Enter virtual environment name (default: venv): " VENV_NAME
    VENV_NAME=${VENV_NAME:-venv}
else
    VENV_NAME=$1
fi

# Check if virtual environment already exists
if [ -d "$VENV_NAME" ]; then
    print_warning "Virtual environment '$VENV_NAME' already exists"
    read -p "Do you want to recreate it? (y/N): " -n 1 -r
    echo
    if [[ $REPLY =~ ^[Yy]$ ]]; then
        # Backup requirements if possible
        if [ -f "$VENV_NAME/bin/pip" ]; then
            print_status "Backing up requirements..."
            "$VENV_NAME/bin/pip" freeze > "${VENV_NAME}_backup_requirements.txt" 2>/dev/null || true
        fi
        
        print_status "Removing old virtual environment..."
        rm -rf "$VENV_NAME"
    else
        echo "Exiting..."
        exit 0
    fi
fi

# Create new virtual environment
print_status "Creating new virtual environment '$VENV_NAME'..."
python3 -m venv "$VENV_NAME"

# Activate virtual environment
print_status "Activating virtual environment..."
source "$VENV_NAME/bin/activate"

# Upgrade pip
print_status "Upgrading pip..."
pip install --upgrade pip

# Install requirements if backup exists
REQUIREMENTS_FILE="${VENV_NAME}_backup_requirements.txt"
if [ -f "$REQUIREMENTS_FILE" ]; then
    print_status "Installing requirements from backup..."
    pip install -r "$REQUIREMENTS_FILE"
    print_status "Requirements installed from $REQUIREMENTS_FILE"
fi

# Print success message
echo
echo "🎉 Virtual environment setup complete!"
echo "Activate it with: source $VENV_NAME/bin/activate"
echo "Deactivate it with: deactivate"

# Test the environment
echo
echo "🧪 Testing the environment..."
python --version
pip --version
print_status "Environment test passed!"

Windows PowerShell Quick Fix Script #

# quick_venv_fix.ps1 - Quick fix for Python virtual environment issues on Windows

Write-Host "🔧 Python Virtual Environment Quick Fix (Windows)" -ForegroundColor Cyan
Write-Host "===============================================" -ForegroundColor Cyan

# Function to print colored output
function Write-Success {
    param($Message)
    Write-Host "✅ $Message" -ForegroundColor Green
}

function Write-Warning {
    param($Message)
    Write-Host "⚠️  $Message" -ForegroundColor Yellow
}

function Write-Error {
    param($Message)
    Write-Host "❌ $Message" -ForegroundColor Red
}

# Check if Python is available
$pythonCmd = $null
foreach ($cmd in @("python", "python3", "py")) {
    if (Get-Command $cmd -ErrorAction SilentlyContinue) {
        $pythonCmd = $cmd
        break
    }
}

if (-not $pythonCmd) {
    Write-Error "Python is not installed or not in PATH"
    Write-Host "Please install Python from https://python.org or Microsoft Store"
    Write-Host "Make sure to check 'Add Python to PATH' during installation"
    exit 1
}

$pythonVersion = & $pythonCmd --version
Write-Success "Python found: $pythonVersion using command '$pythonCmd'"

# Check if venv module is available
try {
    & $pythonCmd -m venv --help | Out-Null
    Write-Success "venv module is available"
} catch {
    Write-Error "venv module is not available"
    Write-Host "Try reinstalling Python with the full installer from python.org"
    exit 1
}

# Get virtual environment name from user
$venvName = $args[0]
if (-not $venvName) {
    $venvName = Read-Host "Enter virtual environment name (default: venv)"
    if (-not $venvName) { $venvName = "venv" }
}

# Check if virtual environment already exists
if (Test-Path $venvName) {
    Write-Warning "Virtual environment '$venvName' already exists"
    $recreate = Read-Host "Do you want to recreate it? (y/N)"
    
    if ($recreate -match "^[Yy]") {
        # Backup requirements if possible
        $pipPath = Join-Path $venvName "Scripts\pip.exe"
        if (Test-Path $pipPath) {
            Write-Success "Backing up requirements..."
            try {
                & $pipPath freeze > "${venvName}_backup_requirements.txt"
            } catch {
                Write-Warning "Could not backup requirements"
            }
        }
        
        Write-Success "Removing old virtual environment..."
        Remove-Item -Recurse -Force $venvName
    } else {
        Write-Host "Exiting..."
        exit 0
    }
}

# Create new virtual environment
Write-Success "Creating new virtual environment '$venvName'..."
& $pythonCmd -m venv $venvName

# Activate virtual environment
Write-Success "Activating virtual environment..."
$activateScript = Join-Path $venvName "Scripts\Activate.ps1"

# Check if we can run the activation script
try {
    & $activateScript
    Write-Success "Virtual environment activated"
} catch {
    Write-Warning "Could not activate automatically. You may need to run:"
    Write-Host "Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser" -ForegroundColor Yellow
    Write-Host "Then activate with: $venvName\Scripts\Activate.ps1" -ForegroundColor Yellow
}

# Upgrade pip
Write-Success "Upgrading pip..."
$pipPath = Join-Path $venvName "Scripts\pip.exe"
& $pipPath install --upgrade pip

# Install requirements if backup exists
$requirementsFile = "${venvName}_backup_requirements.txt"
if (Test-Path $requirementsFile) {
    Write-Success "Installing requirements from backup..."
    & $pipPath install -r $requirementsFile
    Write-Success "Requirements installed from $requirementsFile"
}

# Print success message
Write-Host
Write-Host "🎉 Virtual environment setup complete!" -ForegroundColor Green
Write-Host "Activate it with: $venvName\Scripts\Activate.ps1"
Write-Host "Deactivate it with: deactivate"

# Test the environment
Write-Host
Write-Host "🧪 Testing the environment..." -ForegroundColor Cyan
$pythonInVenv = Join-Path $venvName "Scripts\python.exe"
& $pythonInVenv --version
& $pipPath --version
Write-Success "Environment test passed!"

Conda Environment Fix Script #

#!/usr/bin/env python3
"""
Script to fix Conda environments after system updates.
"""

import subprocess
import sys
import json
from pathlib import Path

def run_conda_command(cmd):
    """Run conda command and return result."""
    try:
        result = subprocess.run(
            f"conda {cmd}", shell=True, capture_output=True, text=True
        )
        return result.returncode, result.stdout.strip(), result.stderr.strip()
    except Exception as e:
        return -1, "", str(e)

def check_conda_installation():
    """Check if conda is available and working."""
    code, output, error = run_conda_command("--version")
    if code == 0:
        print(f"✅ Conda available: {output}")
        return True
    else:
        print(f"❌ Conda not available: {error}")
        return False

def list_environments():
    """List all conda environments."""
    code, output, error = run_conda_command("env list --json")
    if code == 0:
        try:
            env_data = json.loads(output)
            return env_data.get("envs", [])
        except json.JSONDecodeError:
            return []
    return []

def export_environment(env_name, output_file):
    """Export conda environment to YAML file."""
    cmd = f"env export -n {env_name} -f {output_file}"
    code, output, error = run_conda_command(cmd)
    return code == 0

def recreate_environment(env_name, yaml_file):
    """Recreate conda environment from YAML file."""
    # Remove existing environment
    print(f"Removing environment {env_name}...")
    run_conda_command(f"env remove -n {env_name} -y")
    
    # Create new environment
    print(f"Creating environment from {yaml_file}...")
    cmd = f"env create -f {yaml_file}"
    code, output, error = run_conda_command(cmd)
    
    if code == 0:
        print(f"✅ Environment {env_name} recreated successfully")
        return True
    else:
        print(f"❌ Failed to recreate {env_name}: {error}")
        return False

def main():
    """Main function."""
    print("🐍 Conda Environment Fix Tool")
    print("=" * 30)
    
    if not check_conda_installation():
        print("Please install or fix your conda installation first.")
        return
    
    # Update conda itself
    print("Updating conda...")
    run_conda_command("update conda -y")
    
    # List environments
    envs = list_environments()
    if not envs:
        print("No conda environments found.")
        return
    
    print(f"\nFound {len(envs)} environments:")
    for i, env_path in enumerate(envs):
        env_name = Path(env_path).name
        print(f"{i+1}. {env_name} ({env_path})")
    
    # Ask user which environments to fix
    choice = input("\nEnter environment numbers to fix (comma-separated, or 'all'): ")
    
    if choice.lower() == 'all':
        selected_envs = envs
    else:
        try:
            indices = [int(x.strip()) - 1 for x in choice.split(',')]
            selected_envs = [envs[i] for i in indices if 0 <= i < len(envs)]
        except (ValueError, IndexError):
            print("Invalid selection.")
            return
    
    # Process selected environments
    backup_dir = Path("conda_backups")
    backup_dir.mkdir(exist_ok=True)
    
    for env_path in selected_envs:
        env_name = Path(env_path).name
        if env_name == "base":
            print(f"Skipping base environment")
            continue
            
        print(f"\n🔄 Processing {env_name}...")
        
        # Export environment
        yaml_file = backup_dir / f"{env_name}_environment.yml"
        if export_environment(env_name, yaml_file):
            print(f"✅ Exported {env_name} to {yaml_file}")
            
            # Recreate environment
            recreate_environment(env_name, yaml_file)
        else:
            print(f"❌ Failed to export {env_name}")

if __name__ == "__main__":
    main()

Usage Examples #

Running the Diagnostic Script #

# Make script executable
chmod +x diagnose_python_env.py

# Run diagnostic
python3 diagnose_python_env.py

# Or run directly
./diagnose_python_env.py

Running the Recreation Script #

# Recreate a specific virtual environment
python3 recreate_venv.py ./my_project_venv

# Recreate with custom backup directory
python3 recreate_venv.py ./my_project_venv ./my_backups

Running Quick Fix Scripts #

# Unix/Linux/macOS
chmod +x quick_venv_fix.sh
./quick_venv_fix.sh my_venv

# Windows PowerShell
Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser
.\quick_venv_fix.ps1 my_venv

Running Conda Fix Script #

python3 conda_fix.py

These scripts provide automated solutions for the most common virtual environment issues that occur after system updates. Choose the appropriate script based on your situation and operating system.