typed-argument-parser

What it is and what it does

typed-argument-parser replaces Python's built-in argparse with a class-based, type-hinted approach where you define command-line arguments as typed class attributes instead of calling add_argument repeatedly. It automatically generates help text from inline comments, validates types at parse time, and integrates with IDEs for code completion and type checking. The package also includes tapify, a decorator that automatically parses command-line arguments to call functions or initialize classes.

Under the hood, typed-argument-parser is a wrapper around argparse that translates your class definition into the equivalent argparse configuration. It supports standard argument types (str, int, float, bool, Optional, List, Set, Tuple, Literal, Union), positional arguments, subparsers, and argument post-processing via a configure method. The single runtime dependency is docstring-parser, which extracts help text from your comments.

Use it for:

• Build a CLI tool where type hints serve as both documentation and runtime validation without repeating type declarations.
• Migrate from argparse to gain IDE autocomplete and static type checking on parsed arguments.
• Use tapify to quickly expose a Python function as a command-line tool with automatic argument parsing.
• Define reusable argument templates by subclassing and inheriting argument definitions across multiple CLI tools.
• Save and load argument configurations to/from files or dictionaries for reproducible runs and experiment tracking.

Worth the install?

AI-flagged interpretation of the facts on this page — verify before relying

A typed, modern replacement for Python's argparse that uses class attributes and type hints to define command-line arguments with static type checking and IDE code completion support.

Yes. typed-argument-parser is worth installing if you write CLI tools in Python and want type safety, IDE support, and cleaner code than argparse. It has low install friction, active maintenance, no known vulnerabilities, a permissive MIT license, and requires only one runtime dependency. The main constraint is Python 3.10+, which is reasonable for new projects.

Install

typed-argument-parser on PyPI

pip install typed-argument-parser

uv add typed-argument-parser

poetry add typed-argument-parser

Installing typed-argument-parser

Before you install

Low friction install with a single runtime dependency (docstring-parser). The package is actively maintained with a recent release (139 days ago) and requires Python 3.10 or later.

License in practice

MIT license is permissive, allowing use in commercial and private projects with minimal restrictions—you only need to include the license text in distributions.

Quickstart

pip install typed-argument-parser

from typed_argument_parser import Tap

class MyArgs(Tap):
    name: str
    count: int = 1

args = MyArgs().parse_args()
print(f'{args.name} x {args.count}')

Requires Python 3.10 or later.

Verify before relying

• Whether tapify works with all standard Python callables or has edge cases.
• Performance characteristics compared to argparse for large argument sets.
• Whether subparser and advanced argparse features are fully supported or have limitations.

Package facts

Evidence: typed_argument_parser-1.12.0-py3-none-any.whl

Keywords: typing, argument parser, python

Tags

More Software Development packages