The Simplest Way to Extract Your Requirements.txt in Python

Introduction:

As Python developers, managing project dependencies is a routine task that often goes unnoticed—until it doesn't. The simplicity of pip freeze > requirements.txt can be appealing, but in more complex projects, it can lead to unexpected issues that disrupt the workflow. After encountering several roadblocks, I discovered a more reliable and refined approach to managing dependencies, which I'd like to share.

The Problem with pip freeze:

The command pip freeze > requirements.txt has become a standard practice for many developers. While it works in most cases, it has some significant drawbacks:

1. Inclusion of Unnecessary Packages: pip freeze captures all installed packages, including those that were auto-installed as dependencies of other packages. This results in a bloated requirements.txt that may include packages your project doesn't directly depend on.

2. Version Conflicts: The inclusion of auto-installed dependencies can sometimes introduce version conflicts, especially when these dependencies are not necessary for your project but are required by other packages.

3. Environment-Specific Issues: pip freeze reflects the current state of your environment, which might include packages installed for specific local needs, leading to issues when replicating the environment on another machine.

Encountering the Roadblocks:

I faced these issues firsthand when trying to replicate my project's environment. I used pip freeze to generate a requirements.txt, but when I tried to install these dependencies in a new virtual environment, I encountered the following error:

ERROR: Could not find a version that satisfies the requirement cloud-init==23.1.2 (from -r requirements.txt (line 13)) (from versions: none)
ERROR: No matching distribution found for cloud-init==23.1.2 (from -r requirements.txt (line 13))

This error was frustrating because cloud-init is a package that was never directly installed by me. It was pulled in as a dependency, but pip freeze captured it as if it were a first-class citizen of my project.

Finding the Solution:

To address these issues, I moved to a more refined approach using pipreqs and pip-tools. Here’s the step-by-step process that resolved my dependency management woes:

1. Installing the Necessary Tools

First, I installed pipreqs and pip-tools, which provide a more granular approach to dependency management:

pip install pipreqs pip-tools

2. Using pipreqs to Generate requirements.in

Instead of using pip freeze, I used pipreqs to generate a requirements.in file, which only includes the packages directly used in my project. This prevents unnecessary dependencies from being included:

pipreqs ./ --savepath requirements.in --force --ignore ./venv/,./test_venv/ --mode no-pin

Here’s what each flag does:

• --savepath requirements.in: Specifies the output file.
• --force: Forces the overwriting of any existing file.
• --ignore ./venv/,./test_venv/: Ignores the virtual environment directories to prevent scanning irrelevant files.
• --mode no-pin: Prevents version pinning, allowing for more flexibility.

3. Compiling the requirements.txt File

Next, I used pip-compile from pip-tools to generate the final requirements.txt:

pip-compile

This step ensures that only the necessary versions of packages are included, providing a clean and conflict-free requirements.txt.

4. Installing the Dependencies

Finally, I installed the dependencies from the newly generated requirements.txt:

pip install -r requirements.txt

This approach resulted in a leaner and more manageable requirements.txt file, free from unnecessary packages and version conflicts.

Conclusion:

Switching from pip freeze to a more robust dependency management process using pipreqs and pip-tools was a game-changer for my workflow. It not only solved the immediate issues but also gave me better control over my project’s dependencies.

If you’ve been relying on pip freeze and facing similar challenges, I highly recommend trying this approach. It’s a small shift that can make a big difference in the stability and portability of your Python projects.