Cligenius, build great CLIs. Easy to code. Based on Python type hints.

Documentation: https://cligenius.khulnasoft.com

Source Code: https://github.com/readyapi/cligenius

Cligenius is a library for building CLI applications that users will love using and developers will love creating. Based on Python type hints.

It's also a command line tool to run scripts, automatically converting them to CLI applications.

The key features are:

• Intuitive to write: Great editor support. Completion everywhere. Less time debugging. Designed to be easy to use and learn. Less time reading docs.
• Easy to use: It's easy to use for the final users. Automatic help, and automatic completion for all shells.
• Short: Minimize code duplication. Multiple features from each parameter declaration. Fewer bugs.
• Start simple: The simplest example adds only 2 lines of code to your app: 1 import, 1 function call.
• Grow large: Grow in complexity as much as you want, create arbitrarily complex trees of commands and groups of subcommands, with options and arguments.
• Run scripts: Cligenius includes a cligenius command/program that you can use to run scripts, automatically converting them to CLIs, even if they don't use Cligenius internally.

ReadyAPI of CLIs

Cligenius is ReadyAPI's little sibling, it's the ReadyAPI of CLIs.

Installation

Create and activate a virtual environment and then install Cligenius:

Example

The absolute minimum

• Create a file main.py with:

Python def main(name: str): print(f"Hello {name}")

This script doesn't even use Cligenius internally. But you can use the cligenius command to run it as a CLI application.

Run it

Run your application with the cligenius command:

This is the simplest use case, not even using Cligenius internally, but it can already be quite useful for simple scripts.

Note: auto-completion works when you create a Python package and run it with --install-completion or when you use the cligenius command.

Use Cligenius in your code

Now let's start using Cligenius in your own code, update main.py with:

```Python import cligenius

def main(name: str): print(f"Hello {name}")

if name == "main": cligenius.run(main) ```

Now you could run it with Python directly:

Note: you can also call this same script with the cligenius command, but you don't need to.

Example upgrade

This was the simplest example possible.

Now let's see one a bit more complex.

An example with two subcommands

Modify the file main.py.

Create a cligenius.Cligenius() app, and create two subcommands with their parameters.

```Python hl_lines="3 6 11 20" import cligenius

app = cligenius.Cligenius()

@app.command() def hello(name: str): print(f"Hello {name}")

@app.command() def goodbye(name: str, formal: bool = False): if formal: print(f"Goodbye Ms. {name}. Have a good day.") else: print(f"Bye {name}!")

if name == "main": app() ```

And that will:

• Explicitly create a cligenius.Cligenius app.
  • The previous cligenius.run actually creates one implicitly for you.
• Add two subcommands with @app.command().
• Execute the app() itself, as if it was a function (instead of cligenius.run).

Run the upgraded example

Check the new help:

Now check the help for the hello command:

And now check the help for the goodbye command:

Now you can try out the new command line application:

Recap

In summary, you declare once the types of parameters (CLI arguments and CLI options) as function parameters.

You do that with standard modern Python types.

You don't have to learn a new syntax, the methods or classes of a specific library, etc.

Just standard Python.

For example, for an int:

Python total: int

or for a bool flag:

Python force: bool

And similarly for files, paths, enums (choices), etc. And there are tools to create groups of subcommands, add metadata, extra validation, etc.

You get: great editor support, including completion and type checks everywhere.

Your users get: automatic --help, auto-completion in their terminal (Bash, Zsh, Fish, PowerShell) when they install your package or when using the cligenius command.

For a more complete example including more features, see the Tutorial - User Guide.

Dependencies

Cligenius stands on the shoulders of a giant. Its only internal required dependency is Click.

By default it also comes with extra standard dependencies:

• rich: to show nicely formatted errors automatically.
• shellingham: to automatically detect the current shell when installing completion.
  • With shellingham you can just use --install-completion.
  • Without shellingham, you have to pass the name of the shell to install completion for, e.g. --install-completion bash.

cligenius-slim

If you don't want the extra standard optional dependencies, install cligenius-slim instead.

When you install with:

bash pip install cligenius

...it includes the same code and dependencies as:

bash pip install "cligenius-slim[standard]"

The standard extra dependencies are rich and shellingham.

Note: The cligenius command is only included in the cligenius package.

License

This project is licensed under the terms of the MIT license.