Setuptools

Setuptools is a Python package build tool and distribution framework used to bundle code into distributable archives. It functions as a project metadata manager, allowing for the declarative definition of project identity, versioning, and dependencies.

The toolkit distinguishes itself by providing an extension compiler for C and C++ source files and a plugin architecture that uses entry points to enable runtime discovery of functionality. It also supports development environment tooling, such as editable installs that link source code directly to the environment to allow immediate changes without reinstallation.

The project covers a broad range of capabilities including dependency management with environment markers, the generation of source and binary distributions, and the creation of executable console scripts. It also handles package discovery, non-code asset bundling, and the management of namespace packages.

Features

Package Installers - Downloads and installs packages from repositories, URLs, or local files while automatically handling dependencies.

Python Distribution Packaging - Provides a comprehensive framework for building and preparing Python projects for distribution via standardized archives.

Automatic Package Discovery - Locates packages within a project directory or uses glob patterns to include or exclude specific modules.

Binary Distributions - Compiles extension modules and bundles them into platform-specific binary installers.

Build Backend Requirements - Specifies the build backend and necessary plugins required to compile the package.

Build Inclusion Configurations - Specifies which packages, modules, and scripts should be included in the final build and installation.

Build Configurations - Provides configuration files to define parameters and default values for the build and installation process.

Bundler Entry Points - Registers specific objects in metadata to be accessible by other tools or the system as command-line scripts.

C++ Extension Development - Compiles and links C/C++ extension modules using platform-specific compilers and linker options.

Extension Integration - Integrates C extensions into the build process by defining required extension modules and base packages.

Python Package Managers - Declares and automates the installation of required third-party libraries and version constraints for a project.

Requirement Parsers - Converts requirement strings into objects supporting version specifiers, optional extras, and environment markers.

Extension Module Compilers - Compiles source files into binary modules that can be imported as packages to increase execution speed.

Global Defaults - Sets global compiler and installation settings via configuration files to standardize builds.

Conditional Dependency Resolution - Resolves and installs dependencies based on environment markers like operating system or Python version.

Optional Dependencies - Groups optional libraries under feature names to allow users to install extra functionality on demand.

Configuration Metadata Parsing - Extracts metadata and options from configuration files into a dictionary for use by automation tools.

Package Dependency Management - Specifies required external packages, version constraints, and packages that are provided or obsoleted.

Project Layout Discovery - Automatically scans project directories to identify and include packages based on common layout patterns.

Source Layout Discovery - Scans directories to identify and include packages, including support for source-code layouts in subdirectories.

Project Bundling - Packages code, resources, and metadata into a self-contained distribution structure to ensure the project is importable.

Project Metadata Assignment - Assigns descriptive attributes to a project, including versioning, authorship, and licenses for indexing.

Python Development Tools - Provides a utility for performing editable installs and linking source code directly to the environment for rapid development.

Editable Installations - Links source code directly to the environment so changes take effect immediately without reinstallation.

Extension Module Compilers - Compiles C and C++ source files into binary modules that can be imported as Python packages.

Source Distribution Builders - Creates source distributions and wheel archives from a project to allow for installation and sharing.

Source Code Distribution - Bundles project files into a distributable source archive using glob patterns to filter the source tree.

Archive-Based Distributions - Setuptools packages project code and metadata into standardized formats for distribution to end users.

Declarative Configuration Files - Uses declarative configuration files to define package identity, dependencies, and entry points.

Project Metadata Specifications - Provides standardized configuration files to define project dependencies, authors, and versioning metadata.

Dependency Declarations - Enables declaring required and optional libraries via configuration files to automate the installation of software components.

Distribution and Packaging - Packages source code and metadata into a standardized archive for distribution to other developers.

Package Component Deployment - Places modules, scripts, and package data into the appropriate filesystem locations on a target system.

Distribution Metadata - Accesses bundled metadata from distributions to identify project properties and configurations.

Console Script Mappings - Maps console script names to functions so the package can install executable commands into the system path.

Dependency Specifications - Declares the required packages, versions, and optional extra dependencies needed to run or install a project.

Build-Time Metadata Resolution - Reads project metadata from module attributes or external files during the build process.

Plugin Entry Point Discovery - Implements a system for registering and discovering plugin entry points in package metadata.

C-Extensions - Compiles C and C++ source files into binary modules to improve execution speed within Python environments.

Compilation Bridges - Interfaces with system compilers to transform C or Cython source files into importable binary modules.

Plugin Architectures - Provides a framework for extending package functionality through a modular plugin architecture.

Project Metadata Declarations - Translates declarative configuration files into standardized project attributes to define package identity.

Metadata Generation - Automatically creates and updates the metadata directory used by build and test commands.

Distribution Command Extensions - Integrates new custom commands or distribution types into the build process for specialized packaging needs.

Archive Extraction Utilities - Ensures non-code files are extracted to the filesystem when loaded from compressed archives.

Build Dependency Tracking - Compares timestamps between source and target files to determine if a file needs to be rebuilt.

Custom Build Hooks - Provides the ability to override standard build phases with custom scripts and hooks.

Build System Configurations - Retrieves low-level build information including compiler paths and installation prefixes.

Distribution Format Extensions - Registers custom distribution files during the build process for tracking and uploading to repositories.

Asset Bundling - Includes non-code assets and configuration files within the final distribution package.

CLI Automation Wrappers - Creates console or GUI executable files that trigger specific main functions within a project.

Command-Line Argument Parsers - Processes command-line arguments and maps them to object attributes with generated help text.

Cross-Platform Build Targets - Generates platform-specific installation formats such as RPM or ZIP files for target environments.

Distribution File Definitions - Specifies which modules, C sources, and data files are included in the archive using automatic discovery.

Distribution Manifest Generators - Creates an automated list of all project files to ensure distributions can be reconstructed across platforms.

Executable Script Installation - Includes executable scripts in the distribution and adjusts shebang lines to match the current interpreter.

Extension Compilers - Transforms Cython files into binary extensions with support for pre-compiled fallbacks.

Script Wrappers - Generates wrapper scripts that ensure necessary dependencies and paths are loaded before executing command-line scripts.

Package Definitions - Specifies which packages and modules are included, allowing custom mappings to decouple source layout from structure.

Packaging Inclusion Rules - Bundles non-code files within specific packages using glob patterns and relative paths.

Plugin Package Discovery - Scans installed environments to identify and load compatible extension packages.

Editable Installations - Links source code directly to the environment to enable immediate changes without reinstalling.

Package Uninstallers - Removes a package from the environment by deleting its files and updating the system path.

Package Upgraders - Updates an existing package to a newer version by requesting the latest available release from a repository.

Project Metadata Extraction - Retrieves specific project metadata fields via the command line or static metadata files.

Standalone Executable Generators - Generates standalone terminal or GUI executables that trigger specific functions upon installation.

CLI Command Generators - Generates command-line scripts upon installation that map a CLI name to a specific internal function.

URL Dependencies - References dependencies via source repository URLs or archive links for packages not on a standard index.

Build Artifact Management - Handles the creation and cleanup of build directories and cache files to ensure consistent incremental builds.

Package Resource Management - Includes or excludes non-code files and resource data to be bundled with the distribution.

Metadata Validations - Verifies that required metadata fields are present and checks the syntax of the long description.

External Repository Resolution - Links to external websites or version control repositories to install packages not hosted on the primary index.

File Archiving - Packages project files into compressed archive formats such as zip, tar, or xztar.

Shell Script Wrappers - Adds a script prelude to a package archive so the file can be executed directly from the shell.

Namespace Sharing - Enables multiple distributions to share a common top-level package directory via namespace packages.

Import Hook Extensions - Registers custom finders and loaders to enable package discovery and resource access for non-standard importers.

Namespace Packages - Defines packages that contain only other packages, allowing a single package to be split across distributions.

Package Resource Accessors - Reads data files, strings, or streams from within a package regardless of the storage format.

Script Wrapper Generators - Generates script wrappers that allow users to run internal functions as standalone commands.

Task-Based Build Pipelines - Organizes build and installation tasks into discrete command classes that can be extended or overridden.

Version Requirement Validators - Enforces minimum required Python versions to ensure packages are installed in compatible environments.

External Data Inclusions - Bundles additional data files into the distribution based on manifest files or version control plugins.

Build Logic Extensions - Allows extending the build pipeline by overriding default command classes or adding custom logic.

Version Precedence Resolution - Parses and compares version strings using standard and legacy schemes to determine version precedence.

Distribution Manifests - Uses glob patterns and version control tracking to automatically identify files for distribution.

Reproducible Builds - Creates pre-compiled binary packages in controlled environments to ensure consistent installations across different systems.

Version String Validators - Parses and normalizes project version strings according to standards for consistent comparison and sorting.

Third-Party Module Inventories - Defines required third-party libraries and version constraints that must be installed for the package to function.

Build And Packaging - Standard library for building and distributing Python packages.

pypasetuptools

Features

Star history