How to Check If a File Is Writable in Python

Introduction

In this lab, you will learn how to check if a file is writable in Python. The lab focuses on understanding file write permissions in a Linux environment and demonstrates two methods for verifying write access.

First, you'll explore Linux file permissions, including the concepts of owner, group, and others, along with read, write, and execute permissions. You'll create a file, examine its default permissions using ls -l, and interpret the output. Then, you'll learn how to use os.access() with os.W_OK and attempt to open the file for writing to determine its writability in Python.

Skills Graph

Learn About Write Permissions

In this step, we'll explore the concept of write permissions in the Linux environment. Understanding file permissions is crucial for controlling access to your files and directories. Write permission, specifically, determines whether you can modify a file or directory.

In Linux, each file and directory has a set of permissions for three categories of users:

• Owner: The user who owns the file or directory.
• Group: The group that the file or directory belongs to.
• Others: All other users on the system.

For each category, there are three types of permissions:

• Read (r): Allows you to view the contents of a file or list the contents of a directory.
• Write (w): Allows you to modify a file or create, delete, or rename files within a directory.
• Execute (x): Allows you to execute a file (if it's a program) or enter a directory.

Let's start by creating a file and examining its default permissions. Open the VS Code editor and create a new file named my_file.txt in the ~/project directory. You can leave the file empty for now.

Next, open the terminal and navigate to the ~/project directory:

cd ~/project

Now, let's use the ls -l command to view the file's permissions:

ls -l my_file.txt

You'll see output similar to this:

-rw-rw-r-- 1 labex labex 0 Oct 26 14:35 my_file.txt

Let's break down this output:

• The first character (-) indicates that this is a file (as opposed to a directory, which would be d).
• The next nine characters (rw-rw-r--) represent the permissions.
  • The first three (rw-) are the owner's permissions (read and write).
  • The next three (rw-) are the group's permissions (read and write).
  • The last three (r--) are the permissions for others (read only).
• 1 indicates the number of hard links to the file.
• labex labex are the owner and group names, respectively.
• 0 is the file size in bytes.
• Oct 26 14:35 is the last modification timestamp.
• my_file.txt is the file name.

Currently, the owner (you, as labex) and the group have read and write permissions, while others have only read permission. This means you can modify the file, but other users on the system can only view it.

Now, let's try to remove the write permission for the owner using the chmod command. chmod is used to change file permissions.

chmod u-w my_file.txt

Here, u-w means "remove write permission for the owner."

Now, let's check the permissions again:

ls -l my_file.txt

The output should now look like this:

-r--rw-r-- 1 labex labex 0 Oct 26 14:35 my_file.txt

Notice that the owner's permissions are now r--, indicating read-only access.

In the next steps, we'll see how to use Python to check for write permissions and handle situations where they are not available.

Use os.access() with os.W_OK

In the previous step, we learned about file permissions and how to modify them using the chmod command. Now, let's explore how to use Python to programmatically check if a file has write permissions. The os.access() function, along with the os.W_OK constant, allows us to do just that.

The os.access() function takes two arguments:

• path: The path to the file or directory you want to check.
• mode: An integer representing the permission(s) you want to check for.

The os.W_OK constant represents the write permission. When used with os.access(), it checks if the specified file or directory is writable by the current user.

Let's create a Python script to demonstrate this. Open the VS Code editor and create a new file named check_write_permission.py in the ~/project directory.

Add the following code to the file:

import os

file_path = "my_file.txt"

if os.access(file_path, os.W_OK):
    print(f"The file '{file_path}' is writable.")
else:
    print(f"The file '{file_path}' is not writable.")

Here's what the code does:

1. It imports the os module, which provides functions for interacting with the operating system.
2. It defines a variable file_path that stores the name of the file we want to check (which is my_file.txt created in the previous step).
3. It uses os.access(file_path, os.W_OK) to check if the file is writable.
4. It prints a message indicating whether the file is writable or not.

Now, let's run the script. Open the terminal and navigate to the ~/project directory (if you're not already there):

cd ~/project

Then, execute the Python script:

python check_write_permission.py

Since we removed write permissions for the owner in the previous step, the output should be:

The file 'my_file.txt' is not writable.

Now, let's give the owner write permissions back to the file:

chmod u+w my_file.txt

And run the Python script again:

python check_write_permission.py

This time, the output should be:

The file 'my_file.txt' is writable.

This demonstrates how you can use os.access() and os.W_OK to programmatically check for write permissions in Python. This is useful for writing programs that need to modify files, but first need to ensure they have the necessary permissions.

Attempt Opening for Writing

In this step, we'll see what happens when we try to open a file for writing when we don't have the necessary permissions. This will help us understand how Python handles permission errors.

First, let's remove the write permission from my_file.txt again:

chmod u-w my_file.txt

Now, let's create a Python script that attempts to open the file for writing. Open the VS Code editor and create a new file named attempt_write.py in the ~/project directory.

Add the following code to the file:

file_path = "my_file.txt"

try:
    with open(file_path, "w") as f:
        f.write("This is a test.")
    print("File written successfully.")
except Exception as e:
    print(f"Error writing to file: {e}")

Here's what the code does:

1. It defines a variable file_path that stores the name of the file we want to write to.
2. It uses a try...except block to handle potential errors.
3. Inside the try block, it attempts to open the file in write mode ("w").
4. If the file is opened successfully, it writes the string "This is a test." to the file.
5. If an error occurs (e.g., due to lack of write permissions), the except block catches the exception and prints an error message.

Now, let's run the script:

python attempt_write.py

Since we removed write permissions, you should see an output similar to this:

Error writing to file: [Errno 13] Permission denied: 'my_file.txt'

This confirms that Python raises a PermissionError (specifically, Errno 13) when we try to open a file for writing without the necessary permissions.

Now, let's restore the write permissions:

chmod u+w my_file.txt

And run the script again:

python attempt_write.py

This time, the output should be:

File written successfully.

And if you check the contents of my_file.txt, you'll see that it now contains the text "This is a test.":

cat my_file.txt

This is a test.

This demonstrates how Python handles permission errors when attempting to open a file for writing. It's important to use try...except blocks to catch these errors and handle them gracefully in your programs.

Summary

In this lab, we began by exploring the concept of write permissions in Linux, understanding that these permissions control the ability to modify files and directories. We learned about the three categories of users (owner, group, others) and the three types of permissions (read, write, execute).

We then created a file named my_file.txt and used the ls -l command to examine its default permissions, dissecting the output to understand how permissions are represented for each user category. This provided a foundation for understanding how to programmatically check for write permissions in Python.