Tag: Python

Some time back I wrote an introduction to my newest application available on GitHub at the time: Easy Home Directory Backup. Excitement gripped me as I celebrated the release here on my website and on my social media accounts. Later, when I wanted to add a new feature to the program I discovered something terrible: Some parts of the application didn’t work at all. That meant I couldn’t add the new feature until I refactored Easy Home Directory Backup.

Why I Refactored Easy Home Directory Backup

In the first version of the application I gave users the options to perform two types of partial backups:

• All files except dot (.) files
• Only dot (.) files

Well, the first option worked, but not the second. Looking back I didn’t test the second option enough to realize my code was incorrect. Where I messed up was the option I passed into the rsync command:

subprocess.run(["rsync", "-az", "--exclude=* --include=.*",
                                    f"--log-file={path}/easy_home_directory_backup_{formatted_today_date}_log_file",
                                    home_dir_path, backup_device_path])

I incorrectly thought the –exclude=* –include=.* code would exclude all the files in the user’s Home Directory, and then back up only the dot (.) files. That didn’t happen when I ran the program on my computer. Thus, I worked to fix my mistake. However, I couldn’t.

I tried all different combinations, but I couldn’t get this partial type of backup to work. Every time the application would back up both the non-dot (.) and dot (.) files.

At an impasse I actually thought about this part of my program. I asked myself these questions:

• Is this type of partial backup actually useful?
• Would the end user choose this option?
• Does anyone really want to back up all their dot (.) files?

After determining this use case was too small I knew it was time for a change. Thus, I refactored Easy Home Directory.

What Did I Change?

In total I changed ten files. The file seeing the biggest change was src/partial_backup.py as I removed 81 lines.

The determine_partial_backup_type function disappeared completely because there wasn’t two different partial backup options anymore. That accounted for 76 lines of code I deleted. This made the partial_backup function shorter in length, and easier to read and understand. The main code runs in these 26 lines:

        else:
            # If the user-supplied backup device path is invalid
            if not validate_backup_path(device_path):
                partial_backup()
            else:
                check_free_space_for_backup(path, home_dir_path)
                today_date: datetime = datetime.today()
                formatted_today_date_and_time: str = today_date.strftime("%b-%d-%Y_%I:%M%p")
                # Create a directory on the backup device named after the formatted today's date of the backup
                backup_device_path: str = f"{path}/{formatted_today_date_and_time}"
                make_log_file_directory()
                console.print()
                console.print("Preparing to start the partial backup in a minute or so.", justify="center")
                console.print()
                # Progress bar from tqdm
                for _ in tqdm(range(100), desc="Backup Progress", unit="GB"):
                    """rsync options
                    a = Archive
                    """
                    subprocess.run(["rsync", "-a", "--exclude=.*",
                                    f"--log-file={home_dir_path}/.easy_home_directory_backup/{formatted_today_date_and_time}_log_file",
                                    home_dir_path, backup_device_path])
                console.print()
                console.print(f"A log of this backup can be found in {path}/.easy_home_directory_backup",
                              justify="center")
                console.print()
                sys.exit()

I made other changes to the additional nine files in the project. Much of it was changing the text in the comments to make the language more uniform. Or I added missing type annotations. Oh, and I added a new file (src/log_file_directory.py) to create the hidden directory containing the application’s log file.

To review these changes and more, please check out the project’s GitHub repo. That’s where one can download the application too.

Over my Christmas vacation I released a new technical project in its own repo onto my GitHub profile: Easy Home Directory Backup. It’s a Command Line Interface (CLI) program that runs on any Linux distribution in the Terminal. It performs a local backup of the user’s Home Directory. I developed the program in the Python programming language. In this post I will discuss the following topics about this web application:

1. Why I created it
2. The code running it
3. My future plans for the application

Why I Created Easy Home Directory Backup

I created Easy Home Directory Backup because I wanted to improve upon a Python script I made to back up specific directories in my Home Directory. That script is also on my GitHub account which you can view here. I used a separate disk installed in my computer to hold the backups.

While the script works great for me, I wanted to see if I could enhance it to work for other users of Linux distributions. Finally, I developed the application to continue on my current path to improve my Python programming skill-set.

The Code Running Easy Home Directory Backup To Validate User Input

During my design process for the program I decided to run the program in the Terminal using the Command Line Interface (CLI). I also wanted the user to provide the path of the local backup device. This imposed a problem I had to protect against: Improper user input.

A user could input gibberish or a different value than what the program required. To keep the program from crashing, and inform the user of their mistake, I used “Try/Except” statements for user input. Here’s an truncated example from the main.py file:

try:
        menu_choice: int = int(input("Enter your choice here: "))
        if menu_choice == 0:
            clear_screen()
            main_menu()
        elif menu_choice == 1:
            full_backup()
        elif menu_choice == 2:
            partial_backup()
        else:
            print()
            print(center_text("*" * 80))
            print(center_text("!! Enter either 0, 1, or 2 !!"))
            print()
            print(center_text(" -- The menu will reappear in a few seconds -- "))
            print(center_text("*" * 80))
            sleep_print()
            clear_screen()
            one_time_backup()
    except ValueError:
        print()
        print(center_text("*" * 80))
        print(center_text("!! This menu only accepts numbers !!"))
        print()
        print(center_text("-- The menu will reappear in a few seconds --"))
        print(center_text("*" * 80))
        sleep_print()
        clear_screen()
        one_time_backup()

If a user entered a “4” the Else clause would fire off and a message would appear in the Terminal alert the user of their error. Thus, the user would have another chance to input the correct information in the menu. However, if the user entered an “a” that would fire off the Except statement regarding a ValueError. Again, a message appears in the Terminal informing the user to only enter numbers. Finally, the menu appears again.

Not only did I have to validate user input, I had to validate if the path to the backup device was valid. Well, not only valid, but also a Linux-compatible file system, has read/write permissions, and mounted to name a few. I created a separate module (called validate_backup_device.py) to validate the path. I’ll explain a small portion of that code:

def check_backup_device_permissions(backup_path: Path) -> bool:
        """Checks if the user-supplied backup device for read and write permissions.
        :param backup_path: The user-supplied path to the backup device.
        :return: True if the device has both read and write permissions, but False if it doesn't.
        """
        path_stats = os.stat(backup_path)
        mode = path_stats.st_mode
        return bool(mode & stat.S_IRUSR) and bool(mode & stat.S_IWUSR)

In the function above I check the backup device has read/write permissions using the “stat” command to pull the file information about the backup device. Then I check the device’s mode to determine it has both read and write permissions. That’s what the “S_IRUSR” and the “S_IWUSR” options mean. The function returns True if both are correct, but False if not.

I then run the function in one of the many conditional statements listed in the module:

elif not check_backup_device_permissions(path):
        print()
        print(center_text(f"Backup path {path} doesn't have read/write permissions."))
        print(center_text("Please add the read/write permissions to the backup device and run this program again."))
        sleep_print()
        print()
        print(center_text("*" * 80))
        print(center_text("!! Program exited !!"))
        print(center_text("*" * 80))
        print()
        sys.exit()

If the function returns False then the message displays in the Terminal about why the program cannot continue, and gives the user a suggestion on how to resolve the issue.

This is just a snippet of code running the program. Please go through the repo to review the entire codebase.

The Code Running The Backup

I developed the program around the “rsync” command to perform the backups. however, I had to change the module I used in my script to call/run the command in the program. Before I used the “os.system” module, but during my research using Gemini I found out using the “subprocess.run” module was better to use. Because it offers secure command execution. Here’s what that code looks like:

"""rsync options
                    a = Archive
                    z = Compression
                    """
                    subprocess.run(["rsync", "-az",
                                    f"--log-file={path}/easy_home_directory_backup_{formatted_today_date}_log_file",
                                    home_dir_path, backup_device_path])

That snippet of code performs a full backup of the user’s Home Directory. (The program also offers an option for a partial backup.) The flags in the code both archives and compresses the data. Finally, it creates a log file using a specific path name, including the date of the backup, and contains a list of all the files in the directories.

My Future Plans For This Application

I do want to add the ability for users to schedule a backup using crontab. However, I will have to work on implementing this feature as a user can only have one crontab. Thus, my code would need to append the file.

Another feature I’m thinking about creating is allow users to delete the backups they create with the program. Again, that requires more testing.

Once I enable one or more of those features I’ll post an update on my website.