Poetry

Poetry is a comprehensive dependency manager and packaging tool for Python projects. It functions as a configuration engine that resolves complex dependency graphs, manages isolated virtual environments, and ensures reproducible builds through deterministic lock file generation. By centralizing project metadata and build requirements into a single configuration file, it provides a unified workflow for managing the entire lifecycle of a Python codebase.

The project distinguishes itself through its constraint-based solver, which evaluates environment markers and version requirements to maintain compatibility across intricate dependency trees. It offers a robust extensibility architecture via a plugin system, allowing developers to inject custom commands and modify internal workflows. Furthermore, it streamlines the distribution process by automating the creation of source and binary artifacts and handling secure publication to remote repositories.

Beyond its core management capabilities, the tool supports a wide range of development tasks, including dependency group organization, local path referencing, and the management of custom package sources. It provides extensive tooling for environment inspection, shell integration, and configuration validation to ensure that projects remain consistent across different development and deployment environments.

Features

Dependency Managers - Resolves version constraints and generates lock files for consistent environments.
Dependency Management - Record exact versions of all project dependencies in a lock file to ensure that builds remain reproducible across different machines and environments.
Dependency Resolvers - Calculates valid dependency graphs by evaluating version constraints and environment markers.
Language-Specific Dependency Managers - Resolves and installs project dependencies using deterministic lock files for consistent environments.
Project Metadata Declarations - Defines essential project information using standardized packaging formats.
Dependency Installers - Downloads required packages while respecting version constraints and repository locations.
Environment Activation - Enables virtual environments within the current shell session for immediate use.
Lock Files - Records exact dependency versions and hashes to guarantee reproducible builds across environments.
Package Builders - Creates source distributions and wheels to prepare code for installation.
Virtual Environment Managers - Manages project-specific Python runtimes and dependency sets to prevent version conflicts between different projects on the same machine.
Automated Distribution Pipelines - Streamlines building, authenticating, and publishing code packages.
Build Backends - Delegates archive creation to standardized backends to ensure compliance with modern packaging specifications.
Dependency Lock Managers - Control the creation and maintenance of lock files to ensure team consistency or flexible versioning during the distribution of software libraries.
Environment Managers - Manages isolated virtual environments to prevent version conflicts and ensure consistent interpreter usage.
Version Constraints - Enforces project stability by defining precise version requirements for dependencies.
Virtual Environments - Manages project-specific runtimes and dependency sets to prevent version conflicts.
Python Tooling - Configures the project runtime by specifying the language interpreter and version.
Environment and Package Management - Handles dependency management and project packaging.
Developer Tools - Dependency management and packaging.
General Utilities - Dependency management and packaging tool.
Package Managers - Simplifies packaging and dependency management for modern projects.
Build Orchestrators - Orchestrates build backends and compilation scripts to prepare software artifacts for deployment.
Command Execution - Executes scripts and tools within isolated environments to ensure dependency consistency.
Environment Synchronizers - Aligns the local environment with locked dependencies by removing extraneous packages.
Package Publishers - Uploads built packages to public or private repositories.
Project Configuration - Uses a centralized configuration file to define project identity and build requirements.
Project Initializers - Creates project configuration files interactively to establish a codebase.
Language Specifications - Manages language runtime distributions to ensure the correct version is used for development.
Build System Orchestrators - Manages build backends to prepare software artifacts for deployment.
Configuration Managers - Manages local and global configuration settings through command-line operations.
Dependency Groups - Categorizes project dependencies into logical sets to distinguish between runtime and development requirements.
Distribution Artifacts - Creates source and binary archives to prepare code for reliable distribution.
Package Publishing Tools - Upload built project files to remote repositories by handling authentication and registration requirements to ensure software is indexed and available for others.
Package Sources - Enables fetching dependencies from private or alternative repositories by configuring custom package sources.
Packaging Utilities - Standardizes the bundling of code and metadata into distributable formats for installation.
Repository Sources - Controls dependency resolution by managing and prioritizing multiple package sources.
Runtime Configuration Managers - Updates the runtime environment by syncing plugins and dependencies.
Build Configuration Tools - Defines build requirements and system dependencies to ensure consistent compilation across diverse environments.
Environment Markers - Ensures correct package installation by applying conditional logic based on platform or runtime requirements.
Plugin Managers - Controls installed plugins to extend system functionality automatically.
Plugin Systems - Provides a hook-based system allowing external code to inject custom commands and modify workflows.
Project Settings Managers - Organizes project settings and dependency groups to streamline workflows.
Repository Credentials - Secures repository access by managing credentials through system keyrings.
Build System Specifications - Specifies build system requirements for consistent packaging.

sdispater/poetry

34,282View on GitHub

Poetry is a Python build tool, dependency manager, and project orchestrator. It provides a unified workflow for managing the full lifecycle of a project, from initial environment setup to the final package release. The system centralizes project metadata and dependency specifications in a single configuration file, replacing legacy formats. It utilizes a deterministic dependency resolver to calculate compatible package versions and records the exact state of the environment in a lock file to ensure consistency across different machines. The tool handles the orchestration of isolated virtual

Masterminds/glide

8,095View on GitHub

Glide is a Go dependency management tool that fetches, pins, and vendors external packages to enable reproducible builds across environments. It stores project-specific copies of Go packages in a vendor directory, isolating dependencies per project to avoid version conflicts, and supports fetching packages from Git, Mercurial, Bazaar, and Subversion repositories. The tool resolves dependency versions using semantic versioning ranges and operators, and generates a lock file that records exact commit IDs for all transitive dependencies. Glide distinguishes itself with an interactive version wiz

pypa/pipenv

25,066View on GitHub

Pipenv is a Python dependency manager and virtual environment manager that ensures reproducible environments across different systems. It functions as a lockfile resolver, generating deterministic lockfiles from high-level dependency constraints to prevent version drift. The tool integrates project workflow automation by loading environment variables and executing custom project scripts. It also includes security auditing capabilities to scan installed packages for known vulnerabilities. The system covers a broad range of capabilities including dependency version locking, package installatio

rust-lang/cargo

14,624View on GitHub

Cargo is the official build system and package manager for the Rust programming language. It provides a unified command-line interface that orchestrates the entire development lifecycle, including compiling source code, managing complex dependency graphs, running tests, and distributing packages through a centralized registry. By utilizing declarative manifest files, it ensures that builds remain reproducible and consistent across different environments. The tool distinguishes itself through its deep integration with the Rust compiler and its sophisticated approach to project management. It f

python-poetrypoetry

Features