Adventures in Machine Learning

Streamline Your Python Project Dependency Management with Pipenv

Programming requires the use of libraries or frameworks to create complex software and systems effectively. As a result, the management of these dependencies is necessary.

On the flip side, this can be a challenging task, especially in large projects with multiple dependencies. Fortunately, Pipenv, a packaging tool for Python, provides a solution to this problem.

In this article, we’ll explore the issues with current dependency management methods and how Pipenv can help.

Problems with Current Dependency Management Methods

Python, like other programming languages, has a plethora of libraries that developers can use. Managing these libraries or dependencies, however, poses several problems.

Dependency Resolution

Python’s native package manager, pip, installs libraries as separate entities, independent of any other package. This independence poses a problem when there are sub-dependencies.

Managing the dependencies and sub-dependencies separately often leads to conflicts that can be difficult to resolve. This could lead to an issue where one dependency requires a specific version of another library, and a different dependency requires a different version of the same library.

Dependency Management with requirements.txt

To mitigate the problem of managing dependencies, developers have used the requirements.txt file. This file contains the list of dependencies required by the project.

Using pip’s pip freeze command automatically generates it. The file is simple to manage when there are only a few dependencies.

As the project grows, managing multiple versions of libraries, and sub-dependencies can be complicated even with version specifiers.

Development of Projects with Different Dependencies

In a scenario where a developer has to work on multiple projects on their machine, installing dependencies system-wide could lead to conflicts. Creating virtual environments for each project is the solution to this.

However, creating and managing virtual environments requires some terminal savvy. In addition to this, activating and deactivating virtual environments involve running multiple commands in the correct Pipenv as a Solution

Pipenv is a virtual environment manager, dependency resolver, and package manager for Python projects.

Pipenv gathers the best of pip, virtualenv, and other third-party libraries to ease the management of dependencies. Pipenv provides a ‘Pipfile’ to manage dependencies instead of the requirement.txt files.

Similarly, Pipenv creates virtual environments and installs packages within it, using a single command line tool.

Problems that Pipenv Solves

Dependency Management with Requirements.txt

A problem with the requirements.txt file is its inability to handle multiple versions of a library correctly. Pipenv solves this problem by using the concept of an environment, where each environment has its virtual environment and is specific to the project.

This way, dependencies are project-specific, and sub-dependencies are resolved within each virtual environment. With this isolated environment, each project can have different versions of the same dependency.

To use Pipenv in a project, the Pipfile replaces the requirement’s.txt file. This file captures the package version number and its dependencies.

After running pipenv install command, Pipenv creates a isolated environment, installs the dependencies from the Pipfile.lock into the environment. Additionally, Pipenv generates two files, the Pipfile.lock and Pipfile.

Development of Projects with Different Dependencies

Managing virtual environments can be a hassle. Pipenv, however, creates virtual environments for each project in a single command, which the developer can activate easily.

Pipenv creates a self-contained environment that guarantees the independence of the project’s dependencies from dependencies in other projects. This is particularly useful for libraries that require their versions of dependencies.

Pipenv saves the virtual environment and package libraries together in a subdirectory. This means a developer can share the environment directory between multiple machines and ensure consistent workspace across all the machines.

Dependency Resolution

Dependency Version Conflicts in Pipenv can be resolved easily by recreating the virtual environment. Pipenv achieves this by creating a Pipfile.lock, a manifest file that holds the resolved version of dependencies for the project, including the sub-dependencies.

This guarantees determinism in builds across different machines and the reproduction builds in the future. Pipenv also creates a graph of the packages to be installed with their version numbers.

The graph displays the tree of packages that Pipenv would install and helps to determine any conflicts that may arise. Moreover, Pipenv can assess dependency conflict early in the development process as it enumerates the dependencies and their sub-dependencies in the command line output.


Pipenv is a helpful tool for managing dependencies in Python Projects. It effortlessly solves the problem of managing complex dependency trees.

Pipenv creates virtual environments, installs packages and dependencies using a single command line tool. Pipenv helps to avoid complex project setup conflicts by creating separate virtual environments.

Its ability to guarantee determinism builds across various machine instances reduces downtime, especially for developers who use multiple machines. Incorporating Pipenv into Python projects will reduce the project’s maintenance cost, increase productivity and workflow efficiency.

3) PipenvPipenv is a package manager for Python that helps developers seed and manage project dependencies. In this section, we’ll explore how to use Pipenv in a project and Pipenv’s dependency resolution approach.

Example Usage

To use Pipenv in a Python project, one can run the `pipenv install` command in the project directory. This creates a new virtual environment, adds the pipenv package to the environment, updates the cache, and generates two files, the `Pipfile` and the `Pipfile.lock`.

The `Pipfile` stores the packages required by the project while the `Pipfile.lock` file tracks the exact version of the packages. Pipenv `install` command automatically installs the packages listed in the `Pipfile`.

To enter the virtual environment, one can run the `pipenv shell` command. This activates the virtual environment for the project which can be deactivated by running the `exit` command.

Pipenv also allows the installation of packages under development dependencies. In the `Pipfile`, one can specify packages required for development under the `[dev-packages]` section.

Pipenv install command will only install regular dependencies unless you specify the `–dev` option. Pipenv install command with the `–dev` option will install both the regular dependencies and the development dependencies.

To install packages from a `Pipfile`, run the `pipenv install` command in the directory that contains the `Pipfile`. Pipenv uses the `Pipfile.lock` file to ensure exact package versions and behaviour.


Dependency Resolution Approach

In the dependency management journey, Pipenv employs deterministic package resolution. Pipenv guarantees reproducibility across multiple build environments, cluster instances, and team members by locking the dependency tree.

Pipenv ensures that the project environment’s dependencies remain frozen at their exact versions till an explicit update occurs. To achieve this, Pipenv creates a `Pipfile.lock` file.

This file is a snapshot of the environment’s state, and it captures all the dependencies of the project and their sub-dependencies. Pipenv lock command regenerates the `Pipfile.lock` file.

Pipenv lock creates a new `Pipfile.lock` file that contains the current project dependency graph version. Pipenv uses this graph to determine which version of each dependency to install.

This guarantees determinism in builds across different machines and the reproduction of builds in the future. To install packages from the `Pipfile.lock` file, run the `pipenv install –ignore-pipfile` command.

This command will ignore the `Pipfile` and only consider the `Pipfile.lock`. This ensures that Pipenv installs the exact package versions for the project.

4) The Pipfile

In this section, we’ll explain the Pipfile format and best practices for creating and maintaining Pipfiles in a project.

Explanation of the Pipfile

The `Pipfile` is a configuration file for the packages required by a given Python project. The `Pipfile` replaces the problematic `requirements.txt` file by defining the exact package versions and sub-dependencies for the project.

The `Pipfile` comprises two significant sections. The first section specifies regular packages, while the second section, `[dev-packages]`, specifies packages required for development.

Each package entry in the `Pipfile` specifies the package name and the required version or version range. `Pipfile` examples:



requests = “==2.26.0”

django = {version = “==3.2.7”}


pytest = {version = “>=6.2.4”}

coverage = {version = “==5.5”}


For the regular packages, the version of the packages can be either a specific version number or a range of versions.

Pipenv ensures the exact version is installed for the project.

Pipfile Best Practices

To maintain stability and reproducibility, it is best to use exact versions of all packages in the `Pipfile`. By specifying exact versions, one can guarantee the continued operation of the project even when the package evolves.

A package that performs one function today may perform another tomorrow. This often occurs in older codebases where the contract of a package may change due to an update.

Another best practice is to create a new virtual environment and Pipfile for each Python project. Pipenv creates a self-contained virtual environment to only hold the dependencies required for the project and sub-dependencies.

This ensures that the project’s dependencies do not conflict with the dependencies of other projects on the system. With Pipenv, creating virtual environments and managing dependencies via the `Pipfile` only requires one command, making project management more efficient.

In conclusion, a Pipenv-enabled development environment streamlines dependency management, increases workflow efficiency, and promotes best practices for package handling within a project. Pipenv, through the `Pipfile`, ensures that the package versions of each project remain stable and reproduce the project’s builds across different environments.

5) The Pipfile.lock

In this section, we’ll explore the Pipfile.lock file, which is crucial to ensuring package determinism and reproducibility.

Explanation of the Pipfile.lock

The `Pipfile.lock` is a file generated by Pipenv that lists all the exact package versions for the project, including their sub-dependencies. Pipenv uses this file to generate virtual environments and install packages, ensuring deterministic builds.

One significant advantage of Pipenv and the `Pipfile.lock` is that the file locks all dependencies into place. Whenever Pipenv installs packages, it installs at the exact version listed in the `Pipfile.lock`.

This helps ensure that the project remains reproducible and the package version consistency across multiple build environments, enabling the project to work as expected in different environments. Additionally, the `Pipfile.lock` file makes dependency resolution straightforward and efficient.

To reproduce a project’s build or create an identical build environment, one can copy the `Pipfile` and the `Pipfile.lock` and run `pipenv install`. The virtual environment created will have the same package versions and sub-dependencies as the one that previously ran successfully.

Editing and Updating the Pipfile.lock

Pipenv provides the `pipenv lock` command to regenerate the `Pipfile.lock` file. This is useful when there is an update in the `Pipfile`, and the package versions in the `Pipfile.lock` file need to be updated.

To regenerate and update the `Pipfile.lock` file, you would run the command `pipenv lock`. Once executed, Pipenv will generate a new `Pipfile.lock`, with newer package versions, sub-dependencies, and hashing for each package.

To install packages from the `Pipfile.lock` file, use the `pipenv install –ignore-pipfile` command. This command ignores the `Pipfile` and only installs the packages and dependencies listed in the `Pipfile.lock`.

6) Pipenv Extra Features

In this section, we will explore advanced features provided by Pipenv such as package distribution, visualizing dependencies, and converting requirements.txt to a Pipfile.

Package Distribution

Pipenv simplifies package distribution by utilizing the setuptools package and the `` file. The `` file contains package metadata like your package’s name, version, author, and installation instructions.

Once set up, Pipenv handle distributing the packages to PyPI, the Python Package Index.

Yes, I need to distribute my code as a package

To distribute a package, you need a `` file.

Pipenv provides a simple way of creating it. Firstly, run `pipenv install setuptools wheel`.

Then run `pipenv setup`. Pipenv will guide you through creating the `` file.

After completion, execute `pipenv run sdist bdist_wheel`. Pipenv will create distribution files in the `dist/` directory that you can now distribute or upload to PyPI.

I don’t need to distribute my code as a package

Pipenv allows visualization of dependencies by generating a dependency graph. To generate a dependancy graph for your project, run the command `pipenv graph –reverse-tree`.

The command will display the installed dependencies and their corresponding sub-dependencies. The output is in a tree structure that shows how every package is dependent on another package.

I already have a requirements.txt. How do I convert to a Pipfile?

To convert a `requirements.txt` file to a `Pipfile`, first, create a new `Pipfile` by running `pipenv install –ignore-pipfile`. Then, run `pipenv lock`.

This will regenerate the `Pipfile.lock` file using the `requirements.txt` file as input. The `Pipfile.lock` file will now contain all of the packages and dependencies including their exact version numbers that your project needs, ensuring deterministic builds.

In conclusion, Pipenv has become an essential tool for managing dependencies in Python projects. The Pipfile and the Pipfile.lock files make dependency management straightforward, efficient, and reproducible by ensuring the exact package versions and their sub-dependencies are installed in the project’s virtual environment.

Pipenv also provides a variety of extra features like package distribution, package visualizations, and converting `requirements.txt` to a `Pipfile`. These additional functionalities make Pipenv an all-in-one package manager with advanced functionalities for managing Python dependencies.

7) What’s next? In this section, we’ll discuss best practices with Pipenv and alternatives to the package manager.

Best Practices with Pipenv

Pipenv provides an efficient way of keeping track of dependencies in a project. However, there are a few best practices projects should consider when using Pipenv.

Version Control

Projects using Pipenv should always use version control, typically Git, to manage the code and dependencies. The `Pipfile.lock` file commits in Git ensures that every team member accesses the same stable version of the project dependencies.

If a change happens in one team’s dependency tree, the `Pipfile.lock` file ensures that everyone can access the correct version for that dependency tree.

Continuous Integration

Continuous Integration (CI) is essential when managing dependencies in a project. Pipenv supports most CI providers such as Travis CI, CodeShip, and CircleCI.

Pipenv ultimately ensures that the production environment has the same packages and package versions as the development environment.


Testing is an essential part of the development process and helps reduce the risk of bugs and vulnerabilities. Pipenv ensures package reproducibility and aids the development process by making it easier to test and identify package-related bugs.

It’s vital to ensure that all dependencies are tested to avoid bugs and performance issues.

Alternatives to Pipenv

While Pipenv is an excellent tool for managing dependencies, other package managers perform similar functions and may be better suited to some projects.


pip-tools is a simple package manager for Python that allows users to manage package dependencies efficiently. Like Pipenv,

pip-tools creates a virtual environment and allows for the installation of packages in the environment.

pip-tools maintains project dependencies by using three files: the `` file with a list of all packages used in the project and