Creating a `requirements.txt` for Project Dependencies

1. What is a requirements.txt File?

Imagine you've baked a fantastic cake and want to share the recipe. You wouldn't just write down the instructions; you'd also list the specific ingredients and their quantities. A requirements.txt file does exactly this for your code. It's a plain text file that lists all the external Python packages (the "ingredients") your project needs to run, along with their specific version numbers.

These packages include ones you've installed, like Flask and google-generativeai.

Why is this so important? This article explains the key benefits.

As the article highlights, this file ensures that your application works the same way on your computer, a teammate's computer, and—most importantly—the server where you will eventually deploy it. It eliminates the classic "but it works on my machine!" problem.

2. How to Generate a requirements.txt File

You don't need to create this file by hand. Python's package manager, pip, provides a command to generate it automatically. There are two main approaches.

Method 1: The Standard pip freeze Command

The most common method is using the pip freeze command. This command lists all the Python packages installed in your current environment. By "redirecting" this output into a file, you can create your requirements.txt in one step.

Watch this short video to see how it works.

The command is simple:
pip freeze > requirements.txt

The > symbol is a terminal operator that takes the output of the command on its left (pip freeze) and writes it into the file on its right (requirements.txt).

A Note on Virtual Environments

You might have heard the term "virtual environment". This is a self-contained directory that holds a specific Python installation and its packages, isolated from other projects.

Using a virtual environment is a highly recommended best practice because pip freeze lists all packages in the environment. If you're not using a virtual environment, your requirements.txt file will include every package you've ever installed globally, which can be messy. If you're using one, it will only include packages installed for this specific project.

For a deeper dive into virtual environments, the article from inventivehq.com you looked at earlier has a great section titled "Using Virtual Environments." For now, just know that they are the professional way to manage project dependencies.

Method 2: A Cleaner Approach with pipreqs

Because pip freeze can be messy without a virtual environment, there is an alternative tool called pipreqs that many developers prefer. Instead of listing every installed package, pipreqs intelligently scans your project's code files (like app.py) to see which packages you actually import and use. This results in a much cleaner, more accurate requirements.txt file.

This video demonstrates how to use it.

The two steps are:

1. Install the tool: pip install pipreqs
2. Run it in your project folder: pipreqs . (The . means "this current directory").

3. Practical Exercise: Generate Your requirements.txt

Now it's your turn to create this file for your AI writing assistant project. I recommend using the pipreqs method because it guarantees a clean result.

Your Task (15 minutes):

1. Open your terminal or command prompt. If you are using an IDE like VS Code, you can open the integrated terminal (View > Terminal).

2. Make sure you are in your project's main directory (the folder containing your app.py file). You can use the cd (change directory) command to navigate there.

3. Install pipreqs by typing the following command and pressing Enter:

   pip install pipreqs
   

4. Generate the file by typing this command and pressing Enter:

   pipreqs .
   

5. Verify the result. Look in your project folder. You should now see a new file named requirements.txt. Open it. The contents should look something like this (version numbers may vary):

   Flask==3.0.3
   google_generativeai==0.5.4
   

You have now successfully created a complete and accurate list of your project's dependencies!

4. How This File Will Be Used

You've created the file, but how is it used? When you (or a server) get a copy of a project, you can install all of its dependencies with a single command:

pip install -r requirements.txt

The -r flag tells pip to "read from" the specified file and install everything listed inside. You don't need to run this now, as you already have the packages installed. But this is the command that a deployment service like Render will use automatically when you deploy your application in a later lesson.

Conclusion

In this lesson, you've mastered a fundamental practice in Python development. By creating a requirements.txt file, you've made your project portable, reproducible, and ready for collaboration and deployment.

Key Takeaways:

• A requirements.txt file lists all the Python packages your project depends on.
• It's crucial for ensuring your app runs consistently across different computers and on deployment servers.
• You can generate it automatically with pip freeze > requirements.txt, but using pipreqs . often produces a cleaner, more accurate list by scanning your code.
• This file is not a live document; it must be regenerated whenever you add or remove a dependency.

We are now one step away from having a fully documented project. In our next lesson, we will learn how to write a README.md file to document the project's purpose and how to run it locally. This is the front page of your project, and it's essential for helping others understand and use your work.