In software development and system administration, maintaining a clear understanding of a project’s directory structure is crucial. Whether you’re organizing files, debugging issues, or simply trying to get an overview of a complex project, knowing the layout of your directories and files can save significant time and effort. I run into this often enough that I created the python script below.

This script, designed to be placed in the root directory of your project, automatically traverses through all subdirectories and files, creating a comprehensive and neatly formatted text file that outlines the entire directory structure.

import os

def create_file_structure_text(root_dir, output_file):
    with open(output_file, 'w') as file:
        for dirpath, dirnames, filenames in os.walk(root_dir):
            # Calculate the level of depth
            depth = dirpath.replace(root_dir, '').count(os.sep)
            indent = '|--' * depth
            
            # Write the directory name
            file.write(f"{indent} {os.path.basename(dirpath)}/\n")
            
            # Write the file names
            for filename in filenames:
                file.write(f"{indent}|-- {filename}\n")

if __name__ == "__main__":
    # Place in the root folder
    root_directory = os.getcwd()  # Automatically get the current working directory
    output_filename = 'file_structure.txt'  # Replace with your desired output file name
    create_file_structure_text(root_directory, output_filename)

Explanation:

• os.getcwd() is used to get the current working directory where the script is placed.
• The rest of the script remains the same, traversing the directory tree and writing the structure to the output file.

How to Use:

1. Place this script in the root folder you want to map.
2. Run the script. It will create a text file named file_structure.txt with the directory structure in the specified format.

This script will map out the folder and all subfolders. When processed, the file_structure.txt will look something like:

 MyProject/
|-- file_structure.txt
|-- startup.txt
|-- .vscode/
|--|-- launch.json
|-- PF/
|--|-- .eslintrc.cjs
|--|-- .gitignore
|--|-- fstructure.py
|--|-- index.html
|--|-- launch.json
|--|-- package-lock.json
|--|-- package.json
|--|-- README.md
|--|-- tsconfig.json
|--|-- tsconfig.node.json
|--|-- vite.config.ts
|--|-- node_modules/
|--|--|-- .package-lock.json
|--|--|-- .bin/
|--|--|--|-- acorn
|--|--|--|-- acorn.cmd
|--|--|--|-- acorn.ps1
|--|--|--|-- browserslist

Key Features of the Directory Mapping Script

1. Automatic Directory Mapping: The script uses Python’s built-in os module to automatically detect the directory it’s placed in. This means you don’t need to manually specify the root directory. Simply place the script in the desired folder, and it will map out the entire structure from that point onward.
2. Hierarchical Structure Representation: The output file generated by this script presents the directory and file names in a hierarchical format, using indentation to indicate the depth of each file or folder. This visual representation makes it easy to understand the structure at a glance.
3. Ease of Use: The script is designed to be user-friendly. With just a few lines of code, it leverages Python’s powerful file handling capabilities to walk through directories and generate a structured text file. It is straightforward to set up and requires no additional libraries or complex configurations.

Why This Script Is Useful

1. Project Organization: For developers working on large projects with multiple nested directories, this script provides a clear overview of the project structure. It helps in keeping track of where different files are located, which is particularly useful during the initial stages of project exploration or when returning to a project after some time.
2. Documentation: Having a text file that documents the directory structure can be invaluable for project documentation. It provides a quick reference for new team members or collaborators to understand the project layout without having to manually navigate through each directory.
3. Debugging and Maintenance: When debugging issues or maintaining a project, knowing the exact location of files and subdirectories can save a lot of time. This script allows you to quickly locate configuration files, logs, and other important resources.
4. Backup and Archival: Before backing up or archiving a project, it’s useful to have a snapshot of the directory structure. This script provides a detailed map, ensuring you can verify that all necessary files and directories are included in your backup or archive.
5. Compliance and Auditing: In some industries, maintaining a clear record of project structures is necessary for compliance and auditing purposes. This script can automate part of this process by providing an up-to-date directory structure whenever needed.

Thank you for following along with this tutorial. We hope you found it helpful and informative. If you have any questions, or if you would like to suggest new Python code examples or topics for future tutorials/articles, please feel free to join and comment. Your feedback and suggestions are always welcome!