Sampleproject

This project is a reference implementation and tutorial designed to demonstrate the end-to-end workflow of building, versioning, and uploading Python distributions. It serves as a concrete project template and example for configuring metadata and build artifacts for package indices.

The repository illustrates how to package software by defining project metadata and dependencies in static configuration files. It covers the process of transforming source trees into versioned archives and platform-specific binary distributions, specifically showing how to build binary wheels and source distributions.

The project covers broader capability areas including dependency management, the creation of command-line interfaces, and the automation of release publishing to repositories. It also demonstrates the use of isolated virtual environments and the integration of binary extensions.

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.

pypa/setuptools

2,809View on GitHub

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 wit

pypa/hatch

7,182View on GitHub

Hatch is a unified tool for managing Python environments, building packages, scaffolding projects, and installing Python versions. It provides a single command-line interface for automating common development workflows, including running scripts, tests, and static analysis with automatic dependency resolution and configuration. The tool manages project settings, dependencies, and build instructions through a declarative TOML configuration file, ensuring reproducibility across environments. It creates and manages isolated virtual environments across all major shells, installs and manages multi

astral-sh/uv

86,451View on GitHub

uv is a high-performance Python package manager and project build tool designed to handle dependency resolution, virtual environment orchestration, and Python interpreter management. It functions as a comprehensive workspace orchestrator, enabling developers to manage complex, multi-package repositories and ensure reproducible builds across different platforms. The tool distinguishes itself through its use of a global, content-addressable cache and hard-link-based environment provisioning, which allow for near-instant environment creation and minimal disk usage. It employs a high-performance

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

pypasampleproject

Features

Open-source alternatives to Sampleproject

pypa/setuptools

pypa/hatch

astral-sh/uv

sdispater/poetry

Star history

Open-source alternatives to Sampleproject

pypa/setuptools

pypa/hatch

astral-sh/uv

sdispater/poetry