Automatically manage Python dependencies with requirements.txt
Tags: python, automation, tooling, dependencies
Published: 2022-01-26 02:57:52

One of the most important steps in Python development that everybody go through is dependencies management. I remember, when I only started to make some projects for myself I didn’t even know that it’s possible in any automatic way. I thought that you should remember them or look at the code to find which modules are imported and install it manually. Obviously I was wrong.


## Dependencies management options

There is basically two well-known ways to handle dependencies of your project:

* Using requirements.txt file.
* Using dependency managers like [pipenv](https://pipenv.pypa.io/en/latest/) or [poetry](https://python-poetry.org/).


## Dependencies with requirements.txt

One of the oldest, most popular and native option to manage dependencies of a Python project is requirements.txt. It imply storing all the packages and versions in a file with corresponding name. The format is simple:

```
appdata==2.1.1
celery==5.0.5
numpy==1.22.1
```

And to install all required packages to your Python interpreter just use the command:

```sh
pip install -r requirements.txt
```

That’s it! Without need in some extra packages. Everything is native to Pip. It doesn’t require handling it manually, by the way. Just use:

```sh
pip freeze > requirements.txt
```

and it will automatically generate requirements.txt for you. But there is one drawback in this approach: it puts ALL the installed packages into the file. After that the requirements.txt may become really big and it becomes hard to understand what a project really use.

One of the ways to handle it is [pipreqs](https://pypi.org/project/pipreqs/) library. It searches through your code and find all the dependencies that are related to the project. Just type in your terminal:

```
pipreqs
```

and you’re done. But that’s not the only option to handle it. You should always remember to use those commands before push, and sometimes it become a headache.


## Automatic requirements.txt update

It becomes clear in the end that it’d be great to have some tool to update requirements.txt automatically and stay always updated without extra steps. For that purpose the library called [to-requirements.txt](https://pypi.org/project/to-requirements.txt/) were developed. Basically it integrates auto-updating scripts into Pip. The major advantage is that is does not imply any changes in process for development. You does not need to use some extra steps or other commands to install dependencies. Just use Pip as you usually do.

To install this package use:

```sh
pip install to-requirement.txt
```

If you read the command above you can clearly understand what package do. It installs to requirements.txt. Great wordplay as for me.

And to setup your Pip scripts use:

```sh
requirements-txt setup
```

It may require admin rights, because your pip scripts might require root access rights. After that command your pip scripts are ready and you can install your dependencies in straightforward way and keep your requirements.txt file updated.

To disable to-requirements.txt just uninstall the package or type:

```sh
requirements-txt config disable 1
```

You can find more configuration options here:
https://requirements-txt.readthedocs.io/en/latest/


## Conclusion

In this tutorial I described how you can manage your dependencies and how to do it in the easier way with [to-requirements.txt](https://pypi.org/project/to-requirements.txt/). I hope it will help you with your projects. Have a nice day!