pypa/sampleproject

Features

• Package Distribution - Builds binary and source archives and uploads them to a package index using automated pipelines.
• Python Distribution Packaging - Serves as a reference implementation for the end-to-end Python distribution and packaging workflow.
• Build Artifact Distribution - Transforms source code into various distribution formats and validates deployment metadata using a build backend.
• Build Backends - Implements a standardized build interface that separates the packaging frontend from the specific backend tool.
• Build Backend Requirements - Defines the specific build tools and libraries required to compile a project for distribution.
• Python CLI Frameworks - Illustrates the creation of terminal-based interfaces and executable scripts automatically installed into the system path.
• Python Extension Development - Demonstrates the compilation of low-level language source files into binary modules for the Python runtime.
• Cross-Platform Build Systems - Automates the compilation and packaging of software for multiple target operating systems and architectures.
• Package Publishing - Provides a workflow for uploading built distributions and metadata to a package index via a secure API.
• Artifact Publishing Utilities - Illustrates using utilities to upload generated distribution files and metadata to remote hosting targets.
• Environment Package Installation - Demonstrates retrieving specific versions of published packages and their dependencies into a local environment.
• Python Package Managers - Provides a reference for defining and locking library requirements to ensure consistent installations.
• Dependency Version Managers - Allows specifying version ranges for dependencies and updating them to the latest compatible releases.
• Python Workflow Automators - Illustrates the end-to-end workflow of building, versioning, and uploading Python distributions.
• Distribution Package Builders - Transforms source code into distributable formats using standardized build interfaces.
• Isolated Environment Managers - Demonstrates the use of isolated virtual environments to prevent dependency conflicts.
• Optional Dependencies - Defines optional feature sets that allow users to install additional dependencies only when requested.
• Package Dependency Management - Implements the use of requirements files to define version constraints and replicate configurations across systems.
• Package Installers - Demonstrates downloading and installing dependencies from primary and alternate package indices.
• Index-Based Installations - Demonstrates downloading and installing specific project versions from a remote package index.
• Package Management Interfaces - Provides a guide on using package managers to install and manage external library dependencies.
• Package Manager Installers - Provides the foundation for deploying libraries into isolated environments using package managers like pip.
• Source Archives - Demonstrates the creation of compressed, verifiable source code archives from project manifests.
• Package Publishing Pipelines - Configures workflows to automatically upload versioned releases to registries upon code changes.
• Package Versioning Utilities - Implements the process of assigning and managing version identifiers for software distributions.
• Project Dependency Specifications - Defines external libraries and version constraints in static configuration files for consistent environment setups.
• Project Metadata Assignment - Defines project identity attributes including authorship, licenses, and versioning.
• Project Metadata Configurations - Defines project attributes and dependencies in static configuration files instead of procedural setup scripts.
• Python Project Scaffolders - Provides a concrete project structure and configuration files to demonstrate standard Python packaging workflows.
• Source Code Distribution - Provides examples and tools for creating source distributions (sdist) to share Python code.
• Virtual Environment Managers - Creates and manages isolated environments for project-specific dependencies using configuration files.
• Archive-Based Distributions - Shows the conversion of source code into compressed, installable archive formats for index upload.
• Project Metadata Specifications - Defines essential distribution details such as project name, version, and author in standardized files.
• Dependency Management - Defines and controls specific versions of external libraries required for the project to function.
• Environment Markers - Employs environment markers to specify dependencies that are only installed under specific operating system or version conditions.
• Dependency Declarations - Implements standardized files to explicitly list external libraries and modules required by the project.
• Virtual Environment Managers - Illustrates the use of virtual environment managers to isolate project-specific dependencies.
• Project Management - Manages libraries on a per-project basis by tracking them in static configuration files.
• Virtual Environment Dependency Management - Installs and isolates package dependencies per project using virtual environments to prevent version conflicts.
• Distribution and Packaging - Bundles source code and metadata into distributable formats and uploads them to an index.
• Binary Package Publishing - Demonstrates distributing compiled extensions and source code to repositories for standard installation.
• Package Uploaders - Implements interfaces for transferring distribution archives to remote package repositories using secure API tokens.
• Package Index Hosting - Organize project files into a directory structure and serve them via a web server.
• Package Metadata - Provides a reference for defining identity, versioning, and compatibility requirements in Python package metadata.
• Configuration Examples - Provides a reference implementation for configuring metadata and build artifacts for package indices.
• PyPI Uploaders - Includes tools to upload built Python packages directly to the Python Package Index for public distribution.
• Workflow Demonstrations - Serves as a project designed to illustrate the end-to-end workflow of building and uploading Python distributions.
• Distribution Metadata - Defines the identity and installation requirements for software distributions.
• Built Distribution Generation - Shows how to produce binary wheels that can be installed without requiring a local compiler.
• Version Constraints - Limits acceptable versions of dependencies through comparison rules to prevent breaking changes.
• Version Range Constraints - Enables specifying required version ranges using operators for compatible releases and exclusions.
• Packaging Tutorials - Provides a demonstration project used to teach the process of packaging and distributing software in Python.
• Package Installations - Shows how to find and download libraries from a package index for local installation.
• Package Metadata Schemas - Implements standardized structural definitions for package metadata to ensure consistent interpretation by installers.
• Software Release Versioning - Demonstrates assigning unique public versions using segments for release and development stages.
• Binary Package Formats - Demonstrates packaging code and metadata into the standardized binary wheel format.
• Python Distribution Formats - Establishes the structure for source and binary files to ensure reliable installation in the Python ecosystem.
• Wheel Binary Compilation - Transforms source distributions into platform-specific binary wheels through a multi-stage build process.
• Minimum Runtime Requirements - Specifies the minimal set of abstract packages and version bounds required to run.
• Project Metadata Declarations - Declares project identity and requirements within a static configuration table.
• Build-Time Dependency Declarations - Specifies packages required to execute the project build process to ensure a consistent environment.
• Package Repository APIs - Exposes a directory-based HTTP interface for clients to discover and download compatible package versions.
• Build Configurations - Demonstrates how to define build system requirements and project configurations in standardized files.
• Asset Bundling - Bundles non-code assets and documentation into the final package distribution.
• CLI Frameworks - Demonstrates how to create a terminal-based interface that maps user arguments to Python functions.
• Command-Line Installers - Demonstrates how to install packages such that they are available as system-wide executable commands.
• C Extension Compilation - Illustrates the process of converting C source code into importable Python modules using build scripts.
• Dependency Groups - Provides a method for organizing dependencies into logical groups for different development contexts.
• Executable Script Definitions - Shows how to configure package metadata so that scripts are installed as executable system commands.
• Executable Script Installation - Maps internal package functions to executable shell commands during the installation process.
• Build Reproducibility Lockfiles - Demonstrates how to pin exact dependency versions in lockfiles to ensure reproducible environments.
• Installed Package Management - Tracks which packages are installed in a specific environment to manage versioning and dependencies.
• Conditional Dependency Resolution - Uses environment markers to conditionally install dependencies based on the operating system or Python version.
• Environment Specifications - Provides configuration files that pin specific versions to ensure identical installations across environments.
• Pre-compiled Package Binaries - Illustrates the distribution of pre-compiled binaries for language packages to avoid local compilation.
• Optional Dependency Sets - Implements optional feature sets that allow users to install additional dependencies only when requested.
• Project Documentation - Provides project-level documentation including short summaries and detailed descriptions in multiple markup formats.
• Semantic Versioning - Assigns version identifiers using release and development segments to ensure consistent ordering and stability tracking.
• Project Version Synchronizers - Automates the derivation of a single version string from tags or config files to ensure metadata consistency.
• Editable Installations - Illustrates how to install a package in editable mode so source changes are immediately reflected.
• Remote Repository Publishing - Provides workflows for uploading project versions to remote hosting services using secure authentication.
• Deterministic Dependency Locking - Shows how to create deterministic lock files to ensure reproducible environments.
• Virtual Environment Execution - Runs commands within isolated virtual environments to ensure access to correct package versions.
• Entry Point Wrappers - Illustrates how to define entry points that generate executable shell commands for package functions.
• Application Deployment - Describes the process of moving application code from development to production servers.
• Mirrors - Provides a mechanism to replicate package repositories to reduce bandwidth and load on primary networks.
• Dependency Lock Files - Uses lock files to pin specific dependency versions for environment consistency.
• Dependency Resolvers - Parses package metadata to determine and verify the specific versions of required libraries.
• Language Version Constraints - Defines supported language version ranges in metadata to ensure installers only deploy compatible distributions.
• Binary Distributions - Ships libraries with pre-compiled artifacts in a binary format to enable faster installation.
• Binary and Source Installation - Covers the workflow of compiling and linking source code when binary distributions are unavailable.
• Build Dependency Management - Configures the use of vendored or system dependencies required for the build process.
• Development-Only Dependency Groups - Stores package requirements for development tasks without including them in final distribution metadata.
• Environment State Export - Generates a deterministic list of installed packages and versions to create reproducible environment requirements.
• Staging Repository Uploads - Provides the ability to upload distribution files to a staging repository to verify packaging before production.
• Classifier Validation - Check project metadata against a canonical list of valid classifiers for correct categorization.
• Metadata Validations - Inspects generated distribution files to verify that required metadata fields are correct and complete.
• Release Automation - Automates the process of incrementing version numbers and uploading packages to a repository.
• Yanked Release Markers - Includes capabilities to mark package versions as yanked and communicate the reasons for their retraction to users.
• Release Management - Demonstrates coordinating versioning and release cycles, including the use of prereleases.
• Repository Hosting - Provides a reference for using web-based services to share and index collections of software packages.
• Lock-File Pinning - Retrieves specific package versions using hashes and environment markers from a lock file.
• System Requirements - Defines the supported language versions and target operating systems required for a distribution to run.
• Extension Development - Demonstrates the development of high-performance native modules in low-level languages for host environments.
• Distribution Asset Inclusion - List specific files or glob patterns to be bundled in the distribution package.
• Distribution Compatibility Tags - Defines target language and platform compatibility to ensure safe distribution installation.
• Virtual Environment Isolation - Creates independent directory structures for installations to prevent version conflicts between different projects.
• Command Line Entry Points - Maps command-line scripts to specific object references for automatic installation and execution.
• Plugin Entry Point Discovery - Provides a mechanism for external tools to discover and load extensions via registered object references in package metadata.
• Command Line Entry Points - Defines executable scripts and plugins that are automatically registered in the environment upon installation.
• Wheel Compilation - Produces standardized binary wheel files to allow installation without a local build environment.
• Native Module Compilation - Demonstrates the process of compiling C source code into importable Python modules.
• Language-Level - Shows how to bundle single-file scripts for redistribution when only the standard library is required.
• CI/CD Integrations - Automates the upload of package distributions to registries using CI/CD integration workflows.
• Plugin Discovery Metadata - Demonstrates using entry points to advertise discoverable components that other software can load.
• License Agreements - Enables the specification of legal licenses governing the use and distribution of the project.
• Source File Organization - Demonstrates standard conventions for structuring source code using flat or src layouts to control package discovery.

Star-Verlauf