# Python Fire — Auto-Generate CLIs from Any Python Object

> Python Fire by Google turns any Python function, class, or module into a command-line interface with a single call. No decorators, no argument definitions — just code.

## Install

Save as a script file and run:

# Python Fire — Auto-Generate CLIs from Any Python Object

## Quick Use
```bash
pip install fire
python -c "import fire; fire.Fire(lambda name: f'Hello {name}')" -- --name=World
# Or in a script:
# import fire
# fire.Fire(my_function)
```

## Introduction
Python Fire is a library from Google that automatically generates command-line interfaces from any Python object. You pass a function, class, dictionary, or module to `fire.Fire()`, and it introspects the signatures to build a full CLI with subcommands, flags, and help text — no boilerplate needed.

## What Python Fire Does
- Converts any Python callable into a CLI with zero argument declarations
- Generates subcommands from class methods and nested objects
- Supports chaining commands together in a single invocation
- Provides interactive mode with `--interactive` for exploring objects in IPython
- Auto-generates `--help` text from docstrings and type annotations

## Architecture Overview
Fire inspects the target object at runtime using Python introspection. It walks the call chain left to right: each argument on the command line either calls a method, accesses an attribute, or passes a positional/keyword argument. The library converts CLI strings to Python types by evaluating them safely, supporting lists, dicts, booleans, and numbers automatically.

## Self-Hosting & Configuration
- Install via `pip install fire` with no additional dependencies
- Wrap your entry point: `if __name__ == '__main__': fire.Fire(MyClass)`
- Use `--separator=X` to change the flag separator for chained calls
- Pass `command='method_name'` to expose only a specific method
- Set `name='app'` in `fire.Fire()` to customize the CLI program name

## Key Features
- Zero boilerplate: no decorators, argument parsers, or schema definitions
- Works on functions, classes, modules, objects, and even dictionaries
- Automatic type coercion from CLI strings to Python types
- Command chaining lets you call multiple methods in sequence
- Built-in interactive exploration mode via IPython or the Python REPL

## Comparison with Similar Tools
- **argparse** — standard library but requires verbose argument definitions; Fire infers everything
- **Click** — powerful and explicit with decorators; Fire trades control for zero-config simplicity
- **Typer** — type-hint-driven CLI builder; Fire needs no hints at all but offers less validation
- **docopt** — generates a parser from docstring usage patterns; Fire skips docstrings entirely
- **Invoke** — task runner for shell commands; Fire is a general-purpose CLI generator

## FAQ
**Q: Does Fire handle type validation?**
A: Fire performs basic coercion (strings to ints, bools, lists) but does not enforce strict types. For strict validation, consider Click or Typer.

**Q: Can I use Fire with classes that have an __init__ method?**
A: Yes. Constructor arguments become CLI flags, and methods become subcommands.

**Q: How does Fire generate help text?**
A: It pulls from docstrings and parameter names. Adding type annotations improves the auto-generated help output.

**Q: Is Fire suitable for production CLIs?**
A: Fire excels at rapid prototyping, debugging, and internal tools. For user-facing CLIs with complex validation, a more explicit framework may be better.

## Sources
- https://github.com/google/python-fire
- https://google.github.io/python-fire/guide/

---
Source: https://tokrepo.com/en/workflows/32c1109b-40a1-11f1-9bc6-00163e2b0d79
Author: Script Depot