Fix Permission Denied Error Modifying .blk Files with Python

import os
import stat

def check_file_permissions(file_path):
    """Check detailed file permissions and status."""
    try:
        # Check if file exists
        if not os.path.exists(file_path):
            print(f"File does not exist: {file_path}")
            return False
            
        # Get file stats
        file_stat = os.stat(file_path)
        
        print(f"File: {file_path}")
        print(f"Read-only: {bool(file_stat.st_mode & stat.S_IREAD)}")
        print(f"Writable: {bool(file_stat.st_mode & stat.S_IWRITE)}")
        print(f"Executable: {bool(file_stat.st_mode & stat.S_IEXEC)}")
        print(f"File size: {file_stat.st_size} bytes")
        print(f"Modified: {file_stat.st_mtime}")
        
        # Check if file is locked
        try:
            with open(file_path, 'a') as f:
                f.write("test")
            print("File is writable (test succeeded)")
            return True
        except PermissionError:
            print("Permission denied - file may be locked")
            return False
            
    except Exception as e:
        print(f"Error checking file: {e}")
        return False

If you have this problem in Windows 10, and you know you have permissions on folder (You could write before but it just started to print exception PermissionError recently).. You will need to install Windows updates...

import os
import shutil
import time
from datetime import datetime

def WordSwap(FolderPath):
    """Process .blk files with enhanced error handling and diagnostics."""
    
    # Check if the provided folder exists
    if not os.path.isdir(FolderPath):
        print(f"Error: '{FolderPath}' is not a valid directory.")
        return
    
    print(f"Processing files in: {FolderPath}")
    print(f"Current user: {os.getlogin()}")
    print(f"Script running as admin: {is_admin()}")
    
    # Loop through all files in the folder
    for filename in os.listdir(FolderPath):
        if filename.lower().endswith(".blk"):
            FilePath = os.path.join(FolderPath, filename)
            print(f"\nProcessing: {filename}")
            
            try:
                # Check file access before attempting operations
                if not can_access_file(FilePath):
                    print(f"⚠️  Cannot access {filename} - skipping")
                    continue
                
                # Read file contents with retry logic
                Content = read_file_with_retry(FilePath)
                if Content is None:
                    continue
                
                # Replace all occurrences of WORD with NEWWORD
                CorrectedContent = Content.replace("WORD", "NEWWORD")
                
                # Only write if there was a change
                if CorrectedContent != Content:
                    print(f"✓ Changes detected in {filename}")
                    
                    # Make backup with timestamp
                    BackupPath = get_backup_path(FilePath)
                    if create_backup(Content, BackupPath):
                        print(f"✓ Backup created: {BackupPath}")
                        
                        # Write the updated content with retry logic
                        if write_file_with_retry(FilePath, CorrectedContent):
                            print(f"✓ Updated: {filename}")
                        else:
                            print(f"❌ Failed to update: {filename}")
                            # Attempt to restore from backup
                            restore_from_backup(FilePath, BackupPath)
                    else:
                        print(f"❌ Failed to create backup for: {filename}")
                else:
                    print(f"✓ No 'WORD' found in: {filename}")
                    
            except PermissionError as e:
                print(f"❌ PermissionError: {e}")
                handle_permission_error(FilePath)
            except Exception as e:
                print(f"❌ Unexpected error processing {filename}: {e}")
                
    print("\nDone! All .blk files processed.")

def can_access_file(file_path):
    """Check if we can access the file for reading."""
    try:
        with open(file_path, 'r', encoding='utf-8') as f:
            f.read()
        return True
    except (PermissionError, IOError) as e:
        print(f"Cannot access file: {e}")
        return False

def read_file_with_retry(file_path, max_retries=3, delay=1):
    """Read file with retry logic for temporary access issues."""
    for attempt in range(max_retries):
        try:
            with open(file_path, 'r', encoding='utf-8') as file:
                return file.read()
        except PermissionError as e:
            if attempt == max_retries - 1:
                print(f"Failed to read after {max_retries} attempts: {e}")
                return None
            print(f"Read attempt {attempt + 1} failed, retrying in {delay}s...")
            time.sleep(delay)

def write_file_with_retry(file_path, content, max_retries=3, delay=2):
    """Write file with retry logic for temporary access issues."""
    for attempt in range(max_retries):
        try:
            with open(file_path, 'w', encoding='utf-8') as file:
                file.write(content)
            return True
        except PermissionError as e:
            if attempt == max_retries - 1:
                print(f"Failed to write after {max_retries} attempts: {e}")
                return False
            print(f"Write attempt {attempt + 1} failed, retrying in {delay}s...")
            time.sleep(delay)

def get_backup_path(file_path):
    """Generate backup file path with timestamp."""
    base, ext = os.path.splitext(file_path)
    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
    return f"{base}_backup_{timestamp}{ext}"

def create_backup(content, backup_path):
    """Create backup file."""
    try:
        with open(backup_path, 'w', encoding='utf-8') as backup_file:
            backup_file.write(content)
        return True
    except Exception as e:
        print(f"Failed to create backup: {e}")
        return False

def restore_from_backup(original_path, backup_path):
    """Attempt to restore original file from backup."""
    try:
        if os.path.exists(backup_path):
            shutil.copy2(backup_path, original_path)
            print(f"✓ Restored from backup: {original_path}")
            return True
    except Exception as e:
        print(f"Failed to restore from backup: {e}")
    return False

def handle_permission_error(file_path):
    """Handle permission errors with specific suggestions."""
    print("\nPermission troubleshooting steps:")
    print("1. Close any applications using this file")
    print("2. Check if file is read-only")
    print("3. Try running script as administrator")
    print("4. Check Windows Security/antivirus settings")
    print("5. Verify file permissions in Properties -> Security")
    
    # Try to get more detailed permission info
    try:
        import stat
        file_stat = os.stat(file_path)
        print(f"Current permissions: {oct(file_stat.st_mode)}")
    except:
        pass

def is_admin():
    """Check if script is running with admin privileges."""
    try:
        import ctypes
        return ctypes.windll.shell32.IsUserAnAdmin()
    except:
        return False

if __name__ == "__main__":
    folder = r"C:\Users\user\Documents\First_folder\Second_folder"
    WordSwap(folder)

def safe_write_file(file_path, content):
    """Write file using temporary file approach."""
    temp_path = file_path + '.tmp'
    
    try:
        # Write to temporary file first
        with open(temp_path, 'w', encoding='utf-8') as temp_file:
            temp_file.write(content)
        
        # Replace original file
        if os.path.exists(file_path):
            os.remove(file_path)
        
        os.rename(temp_path, file_path)
        return True
        
    except Exception as e:
        print(f"Safe write failed: {e}")
        # Clean up temp file if it exists
        if os.path.exists(temp_path):
            try:
                os.remove(temp_path)
            except:
                pass
        return False

def copy_and_replace(file_path, content):
    """Copy file, modify, then replace original."""
    import tempfile
    
    try:
        # Create temporary file
        with tempfile.NamedTemporaryFile(mode='w', delete=False, suffix='.blk') as temp_file:
            temp_file.write(content)
            temp_path = temp_file.name
        
        # Replace original
        shutil.move(temp_path, file_path)
        return True
        
    except Exception as e:
        print(f"Copy and replace failed: {e}")
        return False

# Alternative folder locations to try
alternative_folders = [
    os.path.expanduser("~/Documents/blk_files"),
    "D:/blk_files",
    os.path.join(os.environ.get('TEMP', ''), 'blk_files')
]

import logging

# Configure logging
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(levelname)s - %(message)s',
    handlers=[
        logging.FileHandler('blk_processing.log'),
        logging.StreamHandler()
    ]
)

# Then replace print statements with logging calls
logging.info(f"Processing file: {filename}")
logging.error(f"PermissionError: {e}")