Automate cleaning up Temporary Files on Windows/Mac via Script

Hey there, Darian Vance here. As a Senior DevOps Engineer at TechResolve, I’m always looking for small wins that have a big impact. A few years back, I noticed our build runners and even my own dev machine would start acting sluggishly. The culprit? Gigabytes of old, forgotten temporary files. I used to go in and clear these out manually until I realized I was wasting precious time on a task a simple script could handle. That’s what I’m sharing today—a “set it and forget it” solution to keep your systems clean.

Prerequisites

• Python 3.6 or newer installed on your machine.
• Basic comfort with running scripts from your terminal or command prompt.
• Administrator or sudo privileges to schedule the task.

The Guide: Step-by-Step

Step 1: Setting Up Your Project

First, get your project folder ready. I’ll skip the standard virtualenv setup since you likely have your own workflow for that. Let’s jump straight to the Python logic. Just create a new directory for this project, and inside it, create a file named cleaner.py. This script won’t need any external libraries, so you don’t have to worry about running a `pip install` command; we’re using pure Python built-ins.

Step 2: The Cross-Platform Python Script

The beauty of this script is that it works on both Windows and macOS by detecting the operating system and choosing the correct temporary directory path. It’s robust and safe, with checks to prevent it from running amok.

Copy the following code into your cleaner.py file:

import os
import platform
import shutil
import time
from pathlib import Path

# --- Configuration ---
# How many days old must a file/folder be to be deleted?
RETENTION_DAYS = 30
# Set to True to only list files that would be deleted, without actually deleting them.
DRY_RUN = False

def get_temp_directory():
    """Returns the appropriate temporary directory based on the OS."""
    system = platform.system()
    if system == "Windows":
        # Using pathlib to safely join paths
        return Path(os.environ.get("TEMP", "C:\\Temp"))
    elif system == "Darwin": # macOS
        return Path(Path.home(), "Library/Caches")
    else: # Linux, etc.
        return Path("/tmp")

def clean_directory(target_dir):
    """Deletes files and folders in the target directory older than RETENTION_DAYS."""
    print(f"--- Starting cleanup of: {target_dir} ---")
    if DRY_RUN:
        print("--- DRY RUN MODE: No files will be deleted. ---")

    # Calculate the cutoff time in seconds since the epoch
    cutoff_time = time.time() - (RETENTION_DAYS * 86400)
    
    deleted_files_count = 0
    deleted_folders_count = 0

    for item in target_dir.iterdir():
        try:
            item_mod_time = item.stat().st_mtime
            if item_mod_time < cutoff_time:
                if item.is_dir():
                    print(f"DELETING FOLDER: {item}")
                    if not DRY_RUN:
                        shutil.rmtree(item, ignore_errors=True)
                    deleted_folders_count += 1
                else: # It's a file
                    print(f"DELETING FILE: {item}")
                    if not DRY_RUN:
                        item.unlink()
                    deleted_files_count += 1
        except (PermissionError, FileNotFoundError) as e:
            print(f"SKIPPING: {item} - Reason: {e}")
            continue

    print("--- Cleanup Summary ---")
    print(f"Folders deleted: {deleted_folders_count}")
    print(f"Files deleted: {deleted_files_count}")
    print("-----------------------")

if __name__ == "__main__":
    temp_path = get_temp_directory()
    if not temp_path or not temp_path.exists():
        print(f"Error: Temporary directory '{temp_path}' not found.")
    else:
        clean_directory(temp_path)

Pro Tip: Before you automate this, I strongly recommend running it manually with DRY_RUN = True. This will show you exactly what would be deleted without touching a single file. It’s a great safety check to ensure the script is targeting the right things.

Step 3: Scheduling the Script

A script is only useful if you don’t have to remember to run it. Here’s how to schedule it on both major platforms.

On Windows (Using Task Scheduler):

1. Open the Start Menu and search for “Task Scheduler”.
2. In the right-hand pane, click “Create Basic Task…”.
3. Give it a name like “Temp File Cleanup” and click Next.
4. Choose a trigger. I find “Weekly” works well. Set a day and time when your computer will likely be on but not in heavy use.
5. For the Action, select “Start a program”.
6. In the “Program/script” box, enter the full path to your python.exe executable.
7. In the “Add arguments (optional)” box, enter the full path to your cleaner.py script.
8. Click Finish. Make sure to check the box to “Open the Properties dialog” and set it to run with highest privileges to avoid permission issues.

On macOS (Using cron):

The classic way to schedule tasks on macOS and Linux is with cron. You’ll need to open your user’s cron configuration file with a terminal editor and add a line.

To run the script every Monday at 2 AM, you would add the following line. Remember to use the full path to your python3 interpreter and script.

0 2 * * 1 python3 /path/to/your/project/cleaner.py >> /path/to/your/project/cleanup.log 2>&1

The >> ... 2>&1 part is important; it redirects all output (both normal and errors) to a log file, so you can check on what the script has been doing.

Here’s Where I Usually Mess Up (Common Pitfalls)

• Permission Errors: On both Windows and macOS, temporary folders often contain files created by system processes. If you don’t run the script with elevated privileges (as Administrator or with sudo), it will fail to delete locked files. The script I provided handles these errors gracefully by skipping them, but for a thorough cleaning, elevated privileges are best.
• Setting Retention Too Low: I once got ambitious and set the retention to 1 day. This broke a couple of applications that relied on cached files for longer-term operations. I recommend starting with 30 days and only decreasing it if you have a specific need and understand the implications.
• Incorrect Paths in Schedulers: When setting up Task Scheduler or cron, using a relative path like cleaner.py often fails because the scheduler doesn’t know where the file is. Always use absolute (full) paths for both the Python executable and the script itself.

Conclusion

And that’s it. You’ve now automated a mundane but important maintenance task. This simple script frees up disk space, can improve system performance, and, most importantly, saves you from ever having to think about it again. It’s a classic DevOps win: invest a little time upfront to automate a recurring problem, and reap the benefits indefinitely.

Darian Vance

Lead Cloud Architect & DevOps Strategist

With over 12 years in system architecture and automation, Darian specializes in simplifying complex cloud infrastructures. An advocate for open-source solutions, he founded TechResolve to provide engineers with actionable, battle-tested troubleshooting guides and robust software alternatives.

🤖 Frequently Asked Questions