How to Check If a File Is Readable in Python

Introduction

In this lab, you will learn how to check if a file is readable in Python. The lab begins by exploring file permissions in Linux, focusing on the concepts of owner, group, and others, along with read, write, and execute permissions. You'll create a Python script, examine its permissions using the ls -l command, and interpret the output to understand who has access to read the file.

The lab then guides you through using Python's os.access() function with os.R_OK to programmatically determine if a file is readable. Finally, you'll learn how to attempt opening the file for reading within a try...except block to handle potential IOError exceptions, providing a practical approach to verifying file readability in your Python code.

Skills Graph

Understand File Permissions

In this step, we will explore file permissions in Linux, which are crucial for controlling access to files and directories. Understanding file permissions is essential for ensuring the security and integrity of your data.

Every file and directory in Linux has associated permissions that determine who can read, write, or execute it. These permissions are categorized into three classes:

• 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.

Each class has three types of permissions:

• Read (r): Allows the user to view the contents of the file or list the contents of the directory.
• Write (w): Allows the user to modify the contents of the file or create, delete, or rename files in the directory.
• Execute (x): Allows the user to execute the file as a program or enter the directory.

Let's start by creating a file and examining its permissions. Open the VS Code editor and create a new file named my_script.py in the ~/project directory. Add the following content to the file:

print("Hello, world!")

Save the file. Now, open the terminal and navigate to the ~/project directory:

cd ~/project

List the files in the directory with detailed information using the ls -l command:

ls -l

You should see output similar to this:

-rw-r--r-- 1 labex labex 22 Oct 26 10:00 my_script.py

Let's break down the output:

• The first 10 characters represent the file permissions.
• The first character indicates the file type: - for a regular file, d for a directory, l for a symbolic link, etc.
• The next three characters (rw-) represent the owner's permissions: read and write.
• The next three characters (r--) represent the group's permissions: read only.
• The last three characters (r--) represent the permissions for others: read only.
• 1 indicates the number of hard links to the file.
• labex labex indicates the owner and group of the file.
• 22 is the file size in bytes.
• Oct 26 10:00 is the last modification time.
• my_script.py is the file name.

Currently, the file my_script.py has read and write permissions for the owner (you) and read-only permissions for the group and others. This means you can read and modify the file, but other users can only read it.

To execute the Python script, you need execute permissions. Let's try to run the script:

python my_script.py

You should see the following output:

Hello, world!

Even though the file doesn't have execute permissions, you can still execute it using the python interpreter. The python command itself has execute permissions, and it can read and execute the contents of the my_script.py file.

In the next steps, we will explore how to use Python to check file permissions and how to change them using Linux commands.

Use os.access() with os.R_OK

In this step, we will use the os.access() function in Python to check if a file has read permissions. The os.access() function takes two arguments: the file path and a permission flag. We will use os.R_OK to check for read permissions.

First, let's create a new Python file named check_permissions.py in the ~/project directory. Open the VS Code editor and add the following code to the file:

import os

file_path = "my_script.py"

## Check if the file exists
if not os.path.exists(file_path):
    print(f"Error: The file '{file_path}' does not exist.")
else:
    ## Check if the file has read permissions
    if os.access(file_path, os.R_OK):
        print(f"The file '{file_path}' has read permissions.")
    else:
        print(f"The file '{file_path}' does not have read permissions.")

Save the file. This script first checks if the file my_script.py exists. If it does, it then uses os.access() with os.R_OK to check if the file has read permissions. The script will print a message indicating whether or not the file has read permissions.

Now, run the script from the terminal:

python check_permissions.py

You should see the following output:

The file 'my_script.py' has read permissions.

This is because, by default, the file my_script.py has read permissions for the owner, group, and others.

Now, let's modify the permissions of the my_script.py file to remove read permissions for everyone except the owner. We can do this using the chmod command in the terminal.

chmod 600 my_script.py

This command sets the permissions of my_script.py to read and write for the owner only (600 in octal notation).

Now, run the check_permissions.py script again:

python check_permissions.py

You should now see the following output:

The file 'my_script.py' does not have read permissions.

This is because we have removed read permissions for the group and others. The os.access() function correctly identifies that the file no longer has read permissions for the user running the script (which is labex).

Finally, let's restore the original permissions of the my_script.py file:

chmod 644 my_script.py

This command sets the permissions of my_script.py to read and write for the owner and read-only for the group and others (644 in octal notation).

Attempt Opening for Reading

In this step, we will attempt to open the my_script.py file for reading in Python and handle potential PermissionError exceptions. This will demonstrate how to gracefully handle situations where your script does not have the necessary permissions to access a file.

First, let's modify the permissions of the my_script.py file to remove read permissions for everyone except the owner, as we did in the previous step:

chmod 600 my_script.py

Now, create a new Python file named open_file.py in the ~/project directory. Open the VS Code editor and add the following code to the file:

file_path = "my_script.py"

try:
    with open(file_path, "r") as file:
        content = file.read()
        print("File content:")
        print(content)
except PermissionError:
    print(f"Error: You do not have permission to read the file '{file_path}'.")
except FileNotFoundError:
    print(f"Error: The file '{file_path}' was not found.")
except Exception as e:
    print(f"An unexpected error occurred: {e}")

Save the file. This script attempts to open the my_script.py file in read mode ("r"). It uses a try...except block to handle potential errors. If a PermissionError occurs (meaning the script doesn't have read permissions), it prints an error message. It also handles FileNotFoundError in case the file doesn't exist and a generic Exception to catch any other potential errors.

Now, run the script from the terminal:

python open_file.py

You should see the following output:

Error: You do not have permission to read the file 'my_script.py'.

This is because we have removed read permissions for the group and others, and the script is running as the labex user, which no longer has read permissions for the file.

Now, let's restore the original permissions of the my_script.py file:

chmod 644 my_script.py

Run the open_file.py script again:

python open_file.py

You should now see the content of the my_script.py file printed to the console:

File content:
print("Hello, world!")

This demonstrates how to handle file permissions in Python and how to gracefully handle situations where your script does not have the necessary permissions to access a file. By using try...except blocks, you can prevent your script from crashing and provide informative error messages to the user.

Summary

In this lab, we explored file permissions in Linux, focusing on how they control access to files and directories. We learned that permissions are categorized into three classes: owner, group, and others, each with read, write, and execute permissions.

We created a Python file and used the ls -l command to examine its permissions, understanding how the output represents the file type and the permissions granted to each class of users. This foundational knowledge is crucial for understanding how to check file readability in subsequent steps.