Automate the Boring Stuff - Deleting Python venvs Edition

As Python developers, we're constantly spinning up new projects, experimenting with libraries, or testing new ideas in isolated environments.

Over time, this often leads to dozens, maybe even sometimes hundreds, of virtual environments scattered across our system.

While they serve an essential purpose for dependency management and project isolation, they also come with an invisible cost: clutter and wasted disk space.

Each virtual environment can consume hundreds of megabytes, or even gigabytes, especially when larger libraries like TensorFlow, PyTorch, or SciPy are involved.

Multiply that by the number of stale or abandoned projects on your machine, and you may be surprised how much space is quietly being eaten up.

That’s where the Virtual Environment Analyzer comes in.

This lightweight Python utility scans your directories, detects virtual environments, analyzes their size and last access time, and gives you a clear picture of where your disk space is going.

Even better, it can help you clean up by safely removing the largest or most outdated environments with just a couple of prompts.

The free source code link is at the end of the article.

If you prefer, you can also check out the video version:

The free source code link is

SPONSORED By Python's Magic Methods - Beyond __init__ and __str__

This book offers an in-depth exploration of Python's magic methods, examining the mechanics and applications that make these features essential to Python's design.

Get the eBook

The Problem: Virtual Environment Bloat

Virtual environments are essential to Python development.

They allow developers to isolate dependencies for each project, ensuring that packages don’t clash or interfere with one another.

Whether you’re working on a Django web app, experimenting with machine learning models, or following along with a tutorial, chances are you’ve created a dedicated virtual environment for each task.

This practice is not only encouraged, it’s necessary for clean, reproducible development.

But over time, the benefits can start to backfire. Developers may accumulate dozens of virtual environments across different directories, most of which are no longer in active use.

This leads to a few common problems:

• Wasted Disk Space: Each virtual environment can take up hundreds of megabytes, or even gigabytes, especially when it includes heavy dependencies. Multiply that by the number of forgotten environments, and the total can quickly balloon.
• Forgotten Environments: Virtual environments don’t usually announce themselves. They sit quietly in project folders, system directories, or tucked away under .venv names, making them easy to overlook during routine cleanup.
• Slow Backups and Scans: Large or deeply nested environments can significantly slow down system backups, antivirus scans, or file indexing processes, all adding unnecessary overhead for environments you no longer need.

The result? A bloated development environment that’s harder to manage, slower to operate, and increasingly difficult to clean up manually.

Meet the Tool: Virtual Environment Analyzer

Enter the Virtual Environment Analyzer, a lightweight yet powerful Python tool designed to help you take back control of your development environment.

This command-line utility scans your file system to detect, analyze, and optionally clean up Python virtual environments.

It intelligently identifies common venv folders (like venv, .venv, env, etc.) and checks for standard signs of a Python environment, such as pyvenv.cfg, activation scripts, or bin/ and Scripts/ folders.

Once detected, it measures the size of each environment, checks when it was last accessed, and gives you an organized report.

Core Benefits:

• Analyze Your Disk Usage: Instantly find out how many virtual environments are lurking in your directories and how much space they’re consuming.
• Detect Forgotten or Unused Environments: Using access time analysis, the tool flags environments that haven’t been used in weeks or months, which are perfect for safe cleanup.
• Clean with Confidence: Built-in cleanup modes let you delete the top 5 largest environments or all those unused for a configurable number of days, all with clear prompts and double confirmation for safety.
• Flexible and User-Friendly: Whether you want a quick overview or a deep cleanup session, the analyzer offers a range of options like verbose output, custom directory scanning, depth limits, and more.

It’s the perfect companion for Python developers who want to keep their workspace clean, efficient, and clutter-free, all without the hassle of manual inspection or risky deletion scripts.

Key Features Overview

The Virtual Environment Analyzer is designed to be both powerful and practical.

It combines robust detection, smart analysis, and cautious cleanup functionality to help you manage your Python environments safely.

Here's a closer look at what it offers.

Comprehensive Venv Detection

The tool intelligently scans directories for virtual environments using a combination of naming patterns and internal file structure analysis.

It doesn’t just rely on folder names; it looks under the hood to verify if a folder is truly a Python venv.

Detection strategies include:

• Recognizing common folder names:
  • venv, env, .venv, .env
  • virtualenv, python_env, pyenv, virtual_env
• Checking for venv-specific markers:
  • pyvenv.cfg
  • bin/ or Scripts/ folders
  • Activation scripts (activate, activate.bat, etc.)

This dual-layer approach ensures reliable identification, even when environments are hidden in deeply nested or custom-named folders.

Size and Access Time Analysis

Once virtual environments are detected, the tool analyzes each one for size and usage history.

• Human-Readable Size Reports: Each venv’s size is displayed in KB, MB, or GB, making it easy to spot disk hogs at a glance.
• Access Time Checks: The tool examines the last accessed timestamp of key venv files, like Python executables, config files, and activation scripts, to determine if an environment has been used recently.

This helps you quickly identify which environments are active and which are candidates for removal.

Cleanup Modes

To help you reclaim disk space, the analyzer provides two optional cleanup modes:

• Top 5 Largest Venvs: Sorts all found environments by size and allows you to delete the five biggest ones, ideal for a fast disk space recovery.
• Unused Venv Cleanup: Automatically detects and deletes environments that haven’t been accessed in a user-defined number of days (e.g., 30, 60, or 90+ days).

Each mode includes a clear preview of what will be deleted, how much space will be freed, and how recently each environment was used.

Safety & Error Handling

Cleanup features are built with developer safety in mind:

• Double Confirmation: You’ll be asked to confirm deletion twice, including typing DELETE, to avoid accidental data loss.
• Graceful Error Handling: Permission errors, inaccessible files, and deletion issues are all caught and reported without crashing the script.

This ensures that even in large, complex directories, the tool remains stable, safe, and predictable.

How It Works Under the Hood

The Virtual Environment Analyzer works using a sequence of smart file system operations to identify, assess, and clean up Python virtual environments.

Here’s a breakdown of what happens behind the scenes:

Directory Scanning with Depth Control

def find_venv_folders(root_path: Path, max_depth: int = None) -> List[Path]:
    """
    Recursively find all virtual environment folders in the given directory.
    
    Args:
        root_path: Root directory to search
        max_depth: Maximum depth to search (None for unlimited)
        
    Returns:
        List[Path]: List of venv folder paths
    """
    venv_folders = []
    
    def search_recursive(path: Path, current_depth: int = 0):
        if max_depth is not None and current_depth > max_depth:
            return
        
        try:
            for item in path.iterdir():
                if item.is_dir():
                    # Check if this is a venv folder
                    if is_venv_folder(item):
                        venv_folders.append(item)
                    else:
                        # Continue searching in subdirectories
                        search_recursive(item, current_depth + 1)
        except (OSError, PermissionError):
            # Skip directories we can't access
            pass
    
    search_recursive(root_path)
    return venv_folders

The script begins by scanning the specified root directory recursively, using pathlib.Path.iterdir() and os.walk() to traverse subdirectories.

You can limit how deep it goes via the --depth argument. This is useful for avoiding unnecessary traversal into deeply nested folders.

Key functions:

• Avoids permission errors with safe try-except blocks.
• Allows unlimited depth if not specified.
• Skips hidden or inaccessible folders.

Venv Identification

def is_venv_folder(path: Path) -> bool:
    """
    Check if a directory is a virtual environment folder.
    
    Args:
        path: Path to the directory to check
        
    Returns:
        bool: True if it's a venv folder, False otherwise
    """
    # Common venv folder names
    venv_names = {
        'venv', 'env', '.venv', '.env', 'virtualenv', 
        'virtual_env', 'python_env', 'pyenv'
    }
    
    # Check if the folder name matches common venv patterns
    if path.name in venv_names:
        return True
    
    # Check for common venv indicators
    venv_indicators = [
        'Scripts',  # Windows
        'bin',      # Unix/Linux
        'pyvenv.cfg',
        'activate',
        'activate.bat',
        'activate.ps1'
    ]
    
    for indicator in venv_indicators:
        if (path / indicator).exists():
            return True
    
    return False

As each folder is visited, the tool checks whether it resembles a virtual environment.

It uses both name-based heuristics (like venv, .env, etc.) and structure-based indicators (presence of bin/, Scripts/, pyvenv.cfg, or activate scripts).

Key functions:

• Detects both standard and unconventional venv naming patterns.
• Works across platforms (Unix and Windows).
• Can handle custom-named or renamed venvs.

Size Calculation

def get_directory_size(path: Path) -> int:
    """
    Calculate the total size of a directory in bytes.
    
    Args:
        path: Path to the directory
        
    Returns:
        int: Size in bytes
    """
    total_size = 0
    
    try:
        for dirpath, dirnames, filenames in os.walk(path):
            for filename in filenames:
                file_path = Path(dirpath) / filename
                try:
                    if file_path.is_file():
                        total_size += file_path.stat().st_size
                except (OSError, PermissionError):
                    # Skip files we can't access
                    continue
    except (OSError, PermissionError):
        # Skip directories we can't access
        pass
    
    return total_size

Once a venv is identified, the tool calculates its total disk usage. It sums the sizes of all regular files inside the folder tree using os.walk().

Key functions:

• Ignores unreadable files to prevent crashes.
• Skips symlinks and non-file objects.
• Outputs the size in a human-readable form with humanize.naturalsize().

Access Time Evaluation

def get_venv_access_time(path: Path) -> datetime:
    """
    Get the most recent access time of a virtual environment.
    
    Args:
        path: Path to the venv folder
        
    Returns:
        datetime: Most recent access time
    """
    latest_access = datetime.fromtimestamp(0)  # Start with epoch time
    
    try:
        # Check the venv folder itself
        stat = path.stat()
        latest_access = max(latest_access, datetime.fromtimestamp(stat.st_atime))
        
        # Check key venv files and directories for access time
        key_paths = [
            path / 'Scripts',
            path / 'bin',
            path / 'pyvenv.cfg',
            path / 'activate',
            path / 'activate.bat',
            path / 'activate.ps1',
            path / 'python.exe',
            path / 'Scripts' / 'python.exe',
            path / 'bin' / 'python'
        ]
        
        for key_path in key_paths:
            if key_path.exists():
                try:
                    stat = key_path.stat()
                    latest_access = max(latest_access, datetime.fromtimestamp(stat.st_atime))
                except (OSError, PermissionError):
                    continue
                    
    except (OSError, PermissionError):
        pass
    
    return latest_access


def is_venv_unused(path: Path, days_threshold: int) -> bool:
    """
    Check if a virtual environment is unused based on access time.
    
    Args:
        path: Path to the venv folder
        days_threshold: Number of days without access to consider it unused
        
    Returns:
        bool: True if the venv is unused, False otherwise
    """
    try:
        access_time = get_venv_access_time(path)
        threshold_time = datetime.now() - timedelta(days=days_threshold)
        return access_time < threshold_time
    except (OSError, PermissionError):
        # If we can't access the folder, consider it unused
        return True

The tool then evaluates when the venv was last accessed. It checks not only the folder itself but also important venv files (like pyvenv.cfg, activate, python.exe) to get the most accurate timestamp.

Key functions:

• Uses stat().st_atime to fetch the last access times.
• Marks venvs as "unused" if not touched in N days.
• Sorts unused venvs by oldest access time to prioritize deletion.

Interactive Cleanup Process