← Back to DevBytes
Python July 09, 2026 6 min read

Fix 'PermissionError' in Python

Understanding PermissionError in Python

When your Python script tries to perform an operation that the operating system rejects due to insufficient privileges, you encounter a PermissionError. This built-in exception is a subclass of OSError and is raised whenever a file, directory, or system resource denies access based on the user's permissions. Whether you're reading a protected file, writing to a read-only directory, or attempting to delete a locked resource, understanding how to fix this error is essential for robust application development.

What is PermissionError?

PermissionError (full name PermissionError in Python 3, previously OSError with an appropriate error code) occurs when the operating system refuses a requested operation. On Unix-like systems (Linux, macOS), this maps to the EACCES errno. On Windows, it corresponds to error codes like ERROR_ACCESS_DENIED. The error message typically includes the filename and a description like "Permission denied" or "The process cannot access the file because it is being used by another process".

Common scenarios that trigger PermissionError:

Why It Matters

Ignoring or mishandling permission errors can lead to:

Properly fixing PermissionError means not only catching the exception but also adjusting the application logic to gracefully request elevated permissions, choose alternative paths, or inform the user clearly.

Common Causes and How to Fix Them

Let's explore typical situations and their solutions. Each scenario includes the error trigger and a practical fix.

1. Trying to Write to a Read-Only File

On Unix, a file might have mode 444 (read-only for everyone). On Windows, a file can have the read-only attribute set. Attempting to open it with 'w' or 'a' raises PermissionError.

# Error: writing to a read-only file
with open('/etc/readonly_config.conf', 'w') as f:
    f.write('new config')

Fix: Check the file mode before opening, or catch the exception and either change the mode (if allowed) or use a different file.

import os
import stat

filepath = '/etc/readonly_config.conf'
try:
    # Try to make it writable for the user (requires appropriate permissions)
    os.chmod(filepath, stat.S_IWUSR | stat.S_IRUSR)  # 600
    with open(filepath, 'w') as f:
        f.write('new config')
except PermissionError:
    print(f"Cannot gain write access to {filepath}. Using fallback location.")
    fallback = os.path.expanduser('~/app_config.conf')
    with open(fallback, 'w') as f:
        f.write('new config')

2. Insufficient Directory Permissions

Creating a file in a directory where you lack write permission triggers the same error.

# Trying to create a file in /root (only writable by root)
with open('/root/secret.txt', 'w') as f:
    f.write('data')

Fix: Verify directory permissions with os.access() or pathlib. Use a writable location like tempfile.gettempdir() or the user’s home directory.

import os
import tempfile

target_dir = '/root'
filename = 'secret.txt'
full_path = os.path.join(target_dir, filename)

if os.access(target_dir, os.W_OK):
    with open(full_path, 'w') as f:
        f.write('data')
else:
    # Fallback to temporary directory
    fallback_path = os.path.join(tempfile.gettempdir(), filename)
    with open(fallback_path, 'w') as f:
        f.write('data')
    print(f"Written to {fallback_path} because {target_dir} is not writable.")

3. Deleting or Renaming a Locked File (Windows)

On Windows, a file in use by another process (like an open document or a running executable) cannot be deleted or renamed.

import os
os.remove('C:\\Users\\User\\Documents\\report.docx')  # Word might have it open

Fix: Retry after a delay, request the user to close the file, or use a tool like psutil to identify and potentially terminate the locking process (carefully).

import os
import time
import psutil

filepath = 'C:\\Users\\User\\Documents\\report.docx'

for attempt in range(5):
    try:
        os.remove(filepath)
        print("File deleted successfully.")
        break
    except PermissionError:
        print(f"Attempt {attempt+1}: File locked. Waiting...")
        # Optional: list processes using the file
        for proc in psutil.process_iter(['pid', 'name']):
            try:
                for item in proc.open_files():
                    if item.path == filepath:
                        print(f"Locked by {proc.name()} (PID {proc.pid})")
            except (psutil.AccessDenied, psutil.NoSuchProcess):
                continue
        time.sleep(2)
else:
    print("Could not delete file after multiple attempts. Please close the application manually.")

4. Opening a Directory as a File

Mistaking a directory for a file yields a PermissionError on some systems (or IsADirectoryError on Unix).

# 'data' is a directory, not a file
with open('data', 'r') as f:   # PermissionError or IsADirectoryError
    content = f.read()

Fix: Use os.path.isfile() to confirm it's a regular file before opening.

import os

path = 'data'
if os.path.isfile(path):
    with open(path, 'r') as f:
        content = f.read()
else:
    print(f"{path} is not a file. Skipping.")

5. Executing a Script Without Execute Permission

On Unix, running a subprocess that calls a script without the executable bit raises PermissionError (often as OSError with errno EACCES).

import subprocess
subprocess.run(['./my_script.sh'])  # script lacks +x

Fix: Make the script executable before calling it, or invoke it via an interpreter (e.g., bash script.sh).

import os
import stat
import subprocess

script = './my_script.sh'
if not os.access(script, os.X_OK):
    # Add execute permission for the user
    os.chmod(script, os.stat(script).st_mode | stat.S_IEXEC)

# Now run it
subprocess.run([script])

Practical Code Examples: Complete Patterns

Below are two complete, reusable functions that demonstrate how to robustly handle PermissionError in file writing and deletion tasks.

Safe File Writer with Permission Check

import os
import tempfile
from pathlib import Path

def safe_write_file(target_path, content, mode='w'):
    """
    Write content to target_path if writable; otherwise fallback to a temp file.
    Returns the actual path used.
    """
    target = Path(target_path)
    try:
        # Check if parent directory exists and is writable
        if target.parent.exists() and os.access(target.parent, os.W_OK):
            with open(target, mode) as f:
                f.write(content)
            return str(target)
        else:
            raise PermissionError(f"No write access to directory {target.parent}")
    except (PermissionError, FileNotFoundError):
        # Fallback: use temp directory
        fallback = Path(tempfile.gettempdir()) / target.name
        print(f"PermissionError: writing to fallback location {fallback}")
        with open(fallback, 'w') as f:
            f.write(content)
        return str(fallback)

# Usage
written_path = safe_write_file('/root/test.txt', 'Hello World')
print(f"Data saved to {written_path}")

Robust File Deleter with Retry Logic

import os
import time
import logging

def robust_delete(filepath, max_retries=3, delay=1):
    """
    Attempt to delete a file, retrying if a PermissionError occurs.
    Returns True if deleted, False otherwise.
    """
    logger = logging.getLogger(__name__)
    for attempt in range(1, max_retries + 1):
        try:
            os.remove(filepath)
            logger.info(f"Deleted {filepath}")
            return True
        except PermissionError as e:
            logger.warning(f"Attempt {attempt}: Cannot delete {filepath} - {e}")
            if attempt < max_retries:
                time.sleep(delay)
            else:
                logger.error(f"Final failure: {filepath} could not be deleted. Please check permissions.")
                return False
    return False

# Example
if not robust_delete('C:\\locked_file.txt', max_retries=5, delay=2):
    print("Manual intervention required.")

Best Practices for Handling Permissions

Conclusion

Fixing PermissionError in Python goes beyond catching an exception—it's about building resilient, cross-platform applications that respect system security boundaries. By understanding the underlying causes, implementing proactive permission checks, and providing graceful fallbacks, you transform a potential crash into a controlled, user-friendly experience. Remember to test your file operations under different permission scenarios and always keep the user informed when operations require elevated access. With the patterns and practices outlined here, you'll handle permission issues confidently and keep your Python programs robust.

🚀 Need a reliable AI agent for your project?

Deploy Hermes Agent in 10 minutes. Managed hosting, zero DevOps.

Get Started — $23.99/mo
← Back to all articles