Adventures in Machine Learning

Python Poetry: An Overview of the Ultimate Dependency Management Tool

Python Package Dependency Management: An Overview of Python Poetry

Are you a Python developer looking for a tool to manage your package dependencies? Then you have come to the right place.

This article will introduce you to Python Poetry – a Python package and dependency manager that simplifies package installation and versioning. Before getting into Python Poetry, let’s first discuss the primary keywords for this article – Python and package dependency management.

Python is a widely used high-level programming language that is known for its readability and ease of use. When developing in Python, developers often rely on third-party packages or libraries to make the development process faster and more efficient.

However, managing these packages’ dependencies can be a challenging task without the right tools. That’s where package dependency management comes in.

Terminology Overview

Before diving into the specifics of Python Poetry, let’s first go over some of the essential terminology associated with package dependency management:

– Package: A collection of code that provides specific functionality. – Dependency: A package that another package requires to function correctly.

– Versioning: The process of assigning unique identifiers to different versions of a package. – Package manager: A tool that automates the process of installing, upgrading, and managing packages.

Python Poetry Installation

Now that we have an understanding of the terminology associated with package dependency management let’s move onto the installation of Python Poetry. The installation process is quite simple, especially if you are familiar with Python.

Start by opening a terminal window and executing the following command in your working directory:


curl -sSL | python –


This command will download and install the Poetry package. Once the installation is complete, you should be able to use the Poetry command in your terminal.

Creating a New Python Project

Now that we have installed Poetry let’s create a new Python project. Poetry simplifies the process of creating a new Python project by automatically creating a pyproject.toml file, which stores metadata about the project and its dependencies.

To create a new project with Poetry, run the following command in your terminal:


poetry new my_project


This command will create a new directory called my_project in your current working directory, which contains a basic Python project structure along with a pyproject.toml file.

Adding Dependencies to Your Project

Adding dependencies to your project is quite simple with Poetry. All you need to do is specify the package and its version in the pyproject.toml file under the [tool.poetry.dependencies] section.

For example, to add the popular NumPy package, you would add the following line to your pyproject.toml file:



numpy = “^1.19.3”


Here we specified that our project requires NumPy version 1.19.3 or later. Poetry uses Semantic Versioning, which allows you to specify ranges of versions.

In this case, the ^ symbol indicates that we require version 1.19.3 or later, but not version 2.0.

Installing Dependencies

Installing dependencies with Poetry is straightforward. All you need to do is run the following command in your terminal:


poetry install


Poetry will read the pyproject.toml file, resolve all the dependencies, and install them in a separate virtual environment for your project.

Updating Dependencies

Upgrading dependencies is also straightforward with Poetry. All you need to do is run the following command in your terminal:


poetry update


Poetry will resolve any dependency conflicts, upgrade the packages, and update the pyproject.lock file accordingly.


In conclusion, Python Poetry is a powerful package and dependency management tool that aims to simplify the process of installing, upgrading, and managing package dependencies in Python projects. By leveraging Semantic Versioning and dynamic dependency resolution, Poetry frees up developers from version conflicts and enables them to focus on writing code.

We hope this article has provided you with a basic understanding of Python Poetry and its benefits, and we encourage you to give it a try in your next Python project. Get Started With Python Poetry: Creating New Projects, Inspecting, and Using pyproject.toml

Python Poetry has revolutionized how developers manage dependencies in their Python projects and has simplified package management.

It provides a much more efficient and straightforward way of handling dependencies, and in this article, we will go through the basic steps for getting started with Poetry. Well cover creating a new Python Poetry project, inspecting project and directory structure, and using the pyproject.toml configuration file.

Creating a new Poetry project

Creating a new Python Poetry project is simple and takes only a few commands. In your terminal window, navigate to your working directory and execute the following command:


poetry new new_project_name


This command creates a new directory in your working directory with the name new_project_name and the project structure inside that directory.

Inspecting the project structure

Just like any conventional Python project, a project created with Poetry consists of a Python package that contains one or more Python modules. However, Poetry places the entire package under a central directory, and the name of the directory is the same as the package name.

When you create a new project with Poetry, the resulting directory looks like this:








We can see from this structure that Poetry has added three new files to our project – poetry.lock, pyproject.toml, and README.rst. Our actual Python code is contained in the new_project_name/ directory, which has the file present in it.

Let’s take a brief look at what each of these files does:

– poetry.lock – This file contains a generated list of all the dependencies that need to be installed for your Python project to work correctly. It’s created automatically every time you install a new package or update an existing one.

– pyproject.toml – This file holds the configuration for your project. You can think of it as a recipe for building and running your Python project.

The config file is a TOML format file that has many parts, which optimize and control the building process of your project. – README.rst – This file contains the documentation of your project in the reStructuredText format.

Using the pyproject.toml file

The pyproject.toml file is a critical file in a Python Poetry project. We use this file to declare the dependencies for our project, among other things like build a system and scripts that we want to run when we build our project.

Here are some essential parts of the pyproject.toml file:

– [tool.poetry.dependencies] – this section lists the dependencies required for the project to run. You can add as many dependencies here as necessary, and they will all be downloaded automatically by Poetry.

– [] – this section lists the dependencies required to test and develop the project. Unlike the dependencies section, Poetry only installs these packages when you run the development environment.

– [] – this section contains the build system configuration. The build system section defines how Poetry should build and package your project when you run poetry build.

Using Poetry’s virtual environment

Poetry also allows us to create a virtual environment specifically for our project. The virtual environment isolates a project’s dependencies, ensuring that it runs efficiently in a self-contained environment.

To use Poetry’s virtual environment for a project, we need to activate it. We can activate the virtual environment using the following command:


poetry env use python_path


This command replaces the system-level Python installation with the specified python_path. Alternatively, you can tell Poetry to create a new virtual environment to use with this project by not specifying any path in the command.

To check the current environment, we run:


poetry env list


This command lists every virtual environment managed by Poetry. It shows the virtual environment and which Python executable it uses.

Declaring dependencies

Adding dependencies to our project is straightforward, and most of the hard work is done by Poetry in the background. Suppose we want to declare a dependency for our project.

In that case, we add it to the [tool.poetry.dependencies] section of our pyproject.toml file along with the package name and the version number we desire. For example, to add the pytest package to our project, we would add the following code to the [] section of our pyproject.toml file:



pytest = “^6.0.0”


You can specify the package’s version you want exactly or use a range based on the Semantic Versioning system that the package uses to maintain backward compatibility.

Installing dependencies with Poetry

Installing dependencies is a crucial part of package management. However, this is much easier with Poetry.

Installing a package is a breeze with the poetry add command. For example, to install the pytest package we mentioned above, run the command:


poetry add pytest


This command installs all the required versions of the pytest package along with all its dependencies. Poetry fetches the latest version of the package based on the version specified in the pyproject.toml file.

Additionally, the poetry add command automatically updates the pyproject.toml file with the package information and versions, and then updates the poetry.lock file.


We have learned how to get started with Python Poetry, how to create a new Python project, inspect the project structure, use the pyproject.toml file, activate a virtual environment, add dependencies, and install dependencies. Python Poetry makes dependency management much simpler and faster, and we encourage Python developers to give it a try in their next Python project.

Command Reference: A Comprehensive List of Poetry Commands and Their Usage

Now that we have discussed the basics of Python Poetry and how to work with it, it’s time to explore the various commands available in the Poetry tool. Poetry offers many commands that assist Python developers in managing their projects and dependencies.

In this section, we’ll go through a comprehensive list of Poetry commands and their usage. List of Poetry commands:


“`poetry new project-name“` – creates a new Python project using Poetry. 2.


poetry install“` – Installs the dependencies listed in the pyproject.toml file and updates the poetry.lock file. 3.


poetry update“` – Updates project dependencies to their latest versions by respecting the version constraint specified in the project’s pyproject.toml file. 4.

“`poetry add package-name“` – Installs a package and adds it to the pyproject.toml file as a dependency. 5.

“`poetry add –dev package-name“` – Installs a package and adds it to the pyproject.toml file as a development dependency. 6.

“`poetry remove package-name“` – Removes a package and it’s associated version from both pyproject.toml and poetry.lock. 7.

“`poetry run command“` – Runs the specified command within the context of the virtual environment created by Poetry. 8.

“`poetry shell“` – Starts a terminal session within the virtual environment created by Poetry. 9.

“`poetry build“` – Creates a distributable package for a Python project by building a source distribution (tarball or zip) and wheel packages. 10.

“`poetry publish“` – Publishes a distributable package created by the build command to the PyPi repository for public use. 11.

“`poetry config“` – Accesses and modifies Poetry’s configuration options for managing Python projects. 12.

“`poetry search package-name“` – Searches the PyPi repository and returns information about a specified package. 13.

“`poetry show“` – Displays information about the current project’s dependencies. 14.

“`poetry check“` – Runs a series of automated checks on the project’s configuration files to detect and report common problems. 15.

“`poetry lock“` – Locks the dependencies versions in the poetry.lock file so that they can be installed and used in the project from this point forward. 16.

“`poetry export“` – Generates a requirements.txt file containing all dependencies where this file can be used on non-Poetry projects. 17.

“`poetry env“` – Provides the ability to manage multiple virtual environments, both for your development system and for continuous integration environments. 18.

“`poetry run python“` – Runs an example script using the Poetry virtual environment. In this list of Poetry commands, we have covered a range of commands that let developers manage the package, distribute, testing, and configuration of the project.

Poetry simplifies many of the processes that usually cause developers headaches.


Python development has never been easier thanks to Python Poetry. It streamlines the package management process and minimizes version conflicts while allowing developers to focus on what they do best – writing code.

It offers a lot of choices to the developers for building, testing, and maintaining their projects with less headache. Now that we have discussed the basic concepts of using Poetry in Python development and covered all Poetry’s commands, you may consider this package as an essential tool in Python development, and we hope to have provided you with the necessary knowledge to get started on your next project.

Python Poetry is a Python package and dependency manager that simplifies package installation and versioning, ensuring a faster and more efficient development process. Its essential functions include creating a new Python project, using the pyproject.toml file, declaring dependencies, installing dependencies, and using Poetry’s virtual environment.

Poetry offers a variety of commands from

poetry install, update, add, remove, and many more to ensure package management runs smoother. By leveraging Semantic Versioning and dynamic dependency resolution, Poetry streamlines version conflicts and allows developers to focus on writing code.

It is an essential tool for Python development for building, testing, and maintaining projects with fewer headaches. Poetry makes building, testing, and distribution easier and faster, making it a must-have tool for Python developers.