Click

Click is a Python framework for building command-line interfaces. It provides a declarative approach to defining command structures, allowing developers to map functions to command-line arguments, options, and nested groups using decorators. The framework handles the complexities of parameter parsing, type validation, and help documentation generation automatically.

The project distinguishes itself through its hierarchical context system, which propagates configuration and state across nested commands, and its environment-aware parameter resolution that prioritizes command-line inputs, environment variables, and interactive prompts. It includes native support for shell completion, allowing for context-aware suggestions, and provides a robust terminal toolkit for handling interactive user input, progress bars, and styled output.

Beyond core parsing, the framework offers extensive utilities for file system management, cross-platform stream handling, and terminal interaction. It supports complex execution lifecycles, including lazy command loading, custom error handling, and programmatic subcommand invocation, while providing built-in tools for testing command-line interfaces in isolated environments.

Features

CLI Frameworks - A library for building complex command-line interfaces with automatic help generation, parameter parsing, and nested command groups.
Frameworks - Building complex, nested command-line tools with automatic help generation, parameter validation, and support for environment variable configuration.
CLI Command Frameworks - Constructs command-line tools by decorating functions to handle parsing, help generation, and nesting.
Command Line Parsers - A tool that maps command-line arguments, flags, and environment variables to function parameters with built-in type validation.
Help Text Generators - Automatically generates formatted help pages and usage instructions based on command structure and docstrings.
Command-Line Interface Mappings - Maps command-line arguments and options to executable code using function decorators.
Environment Variable Configuration - Resolves parameter values by prioritizing command-line arguments, environment variables, and interactive prompts.
Shell Integration - Integrates natively with shell environments to suggest commands, options, and arguments during terminal input.
Context Object Passing - Propagates configuration and runtime state across nested command groups using a shared hierarchical object.
Nested Command Structures - Combines multiple independent command line utilities into a single hierarchical interface.
CLI Argument Definitions - Attaches options and arguments to commands to capture user input with type conversion and default values.
Named Option Definitions - Configures command-line arguments by mapping flags to function parameters with automatic name inference.
Environment Variable Mapping - Automatically populates command parameters from environment variables when command-line arguments are missing.
Execution Context Management - Maintains a shared hierarchical object that propagates configuration and runtime state across nested command groups.
Interactive Prompts - Requests missing or sensitive information from users during execution through secure, interactive terminal prompts.
Progress Indicators - Displays an interactive progress indicator in the terminal to track the status of long-running tasks.
Shell Completion Generators - A system that provides native shell integration to suggest commands, options, and arguments to users as they type.
Version Information - Provides a standard command-line flag to display the application version and exit immediately.
Terminal Interaction - Creating interactive command-line applications that prompt for sensitive input, display progress bars, and handle real-time user keystrokes.
CLI Testing Tools - Verifying command-line tool behavior by isolating execution environments, capturing output, and simulating user input for automated testing workflows.
Input Converters - Applies automatic conversion and constraint checking to inputs based on defined data types.
CLI Development - Composable toolkit for creating command-line interfaces.
Developer Tools - Toolkit for composable command-line interfaces.
General Utilities - Library for building command line interfaces.
Python CLI Frameworks - Package for creating composable command-line interfaces.
CLI Type Converters - Allows defining custom parameter types with specialized validation and transformation logic for command-line inputs.
Global Command Registration - Registers functions as system-level commands during package installation for direct terminal access.
Cross-Platform Console Tooling - Developing terminal applications that maintain consistent behavior, Unicode support, and file stream handling across different operating systems.
Shell Completion Providers - Provides custom completion sources for specific parameters to enable context-aware shell suggestions.
Input Validation Utilities - Verifies and transforms user-provided values after type conversion, raising formatted errors for invalid input.
Terminal UI Components - A collection of utilities for handling interactive prompts, progress bars, colored output, and cross-platform terminal stream management.
Lazy Loading Strategies - Defers the loading of command definitions until runtime to improve performance and reduce startup time.
Parameter Source Tracking - Resolves parameter values by checking prompts, arguments, and environment variables in a defined order of precedence.
Programmatic Command Invokers - Allows executing one command from within another by passing arguments explicitly or forwarding context state.
Command Callbacks - Triggers custom logic after command line arguments are parsed and converted to ensure callbacks receive processed values.
Command Chaining - Supports executing a sequence of subcommands in a single invocation.
Eager Parameter Execution - Triggers immediate program termination or specific actions after processing flags like help or version.
CLI Extensions - Integrates third-party packages to add features like advanced formatting and complex option grouping to command line interfaces.
Command Lifecycle Managers - Registers cleanup functions to ensure external resources are safely closed when command execution finishes.
Command Line Applications - Executes command line applications within test environments to capture exit codes and standard streams.
Mandatory Parameter Enforcement - Enforces data type constraints on command inputs to ensure correct parsing and descriptive help documentation.
Exit Status Reporters - Returns specific status codes to the operating system based on command success or user input errors.
Boolean Flag Generators - Generates toggleable boolean flags with support for explicit on/off pairs and custom values.
Parameter Metadata Displayers - Displays default values, environment variable requirements, and custom meta-variables within generated help output.
File Stream Management - Opens files for reading or writing with automatic lifecycle management and support for standard stream redirection.
CLI Exception Handlers - Intercepts and formats command-line errors for user display while allowing custom error management.
Stream Abstractions - Wraps standard input and output streams with platform-agnostic logic for consistent encoding and behavior.
Sensitive Input Prompts - Collects user input while masking characters on the screen and requiring secondary confirmation.
User Confirmation Dialogs - Asks the user for a boolean confirmation before proceeding with an action, with automatic abort capabilities.
Choice Fields - Validates command-line arguments against predefined sets of allowed values with case-insensitive matching.
Command Aliasing - Maps shortened or alternative names to existing commands by intercepting command resolution.
Result Callbacks - Bubbles command output values up to the caller or a result callback.
Command Group Overrides - Extends command group behavior by overriding core methods for dynamic loading or aliasing.
Pipeline Processors - Collects and transforms data across chained commands by passing state through context objects.
Command Argument Parsers - Handles command-line string parsing, including support for argument escaping and literal flag processing.
Configuration Defaults - Injects dynamic default values for command options from external configuration files.
Help Trigger Aliases - Defines custom flags or aliases to invoke help documentation for better interface compatibility.
Terminal Output Stylers - Prints text to the terminal with automatic encoding handling, color support, and stream redirection.
Native Binary Packagers - The CLI framework bundles an interpreter and project dependencies into a standalone executable or installer for major operating systems to eliminate external environment requirements.
Configuration Directory Resolvers - Identifies standard, platform-specific directories for storing application configuration files.
Path Validation Utilities - Verifies file system paths by checking for existence and access permissions while providing user-friendly error messages.
Parameter Range Definitions - Enforces minimum and maximum bounds on numeric inputs with optional value clamping.
Error Handling - Provides mechanisms to disable automatic exception handling for manual control over command invocation and error propagation.
Terminal Input Interceptors - Reads individual keystrokes from the terminal buffer immediately to enable real-time user interaction.

fastapi/typer

19,632View on GitHub

This project is a Python framework for building command-line interfaces by converting standard functions into executable programs. It uses type hints to automatically infer and generate argument parsers, validation logic, and help documentation, allowing developers to define complex terminal applications through simple function signatures. The framework distinguishes itself through a decorator-driven registration system that enables the construction of hierarchical command trees. It supports dependency injection to manage shared state and runtime configuration across subcommands, and it utili

clap-rs/clap

16,528View on GitHub

Clap is a command-line argument parser for Rust that enables developers to define complex interfaces through strongly-typed data structures. It functions as a comprehensive framework for building terminal applications, automating the transformation of raw string inputs into validated, type-safe code representations while simultaneously generating help documentation and usage statements. The library distinguishes itself by offering both a declarative, attribute-based approach and a fluent builder-pattern API, allowing for flexible interface construction. It includes a sophisticated validation

yargs/yargs

11,492View on GitHub

yargs is a command-line interface framework and argument parser for Node.js. It translates raw command-line strings into structured JavaScript objects, providing a toolkit for building terminal applications with nested sub-commands, dedicated handlers, and a structured user interface. The framework distinguishes itself through automated help text generation, which constructs formatted usage menus and instructions based on registered metadata. It also provides shell completion generation for Bash and Zsh and uses string-distance algorithms to offer typo correction suggestions when invalid inpu

CLIUtils/CLI11

4,322View on GitHub

CLI11 is a header-only C++ library for parsing command line arguments and managing configuration files. It maps shell input to typed variables and supports the creation of complex command hierarchies. The library is distinguished by its support for nested subcommands with infinite depth and prefix matching. It integrates configuration management by allowing application settings to be loaded from TOML or INI files, with the ability to fall back to environment variables. The project provides a comprehensive set of tools for argument parsing, including flags and positional arguments, alongside

palletsclick

Features