Python Fire VS pydantic-cli

The cli tool [fire](https://github.com/google/python-fire/blob/master/docs/guide...) has a nifty feature where it can generate a cli for any file for you.

So random and math are somewhat usable that way

    $ python -m fire random uniform 0 1

With python-fire you can use either function or class to create your subcommands. But I find working with classes more intuitive and manageable. Our first command is going to be a sub-command that shows us the UTC time.

Have you checked out fire? Personally, I think it's a really elegant solution to turning a callable object into command line. Plus, the chaining function calls feature lets you build some pretty complex command line patterns likes you never seen with other frameworks. Definitely worth giving it a try!

I started with click but found python fire to be so much easier to use.

I highly recommend checking out fire for adding a CLI quickly to little utility scripts that aren't going to be published to the world but just for you.

python fire autogenerates CLI wrappers for python modules, which really synergizes with method-chaining APIs like pandas.

Fire can basically do the first step (object -> CLI):

https://github.com/google/python-fire

Gooey can do (CLI -> GUI):

https://github.com/chriskiehl/Gooey

also, while we're on the subject, fire may not be the same kind of workhorse as argparse or click, but for really simple stuff it's pretty awesome

I'm relatively new to Go (coming from Python) so I haven't been using Cobra (or Go, for that matter) for long but it's clearly very polished -- only friction I was experiencing with it is there's a lot of boilerplate to creating commands and subcommands, that IMO (idea as proven by python-fire) can be naturally (better) expressed as types / fields / methods that are already built into the language.

A comparison with https://github.com/mpkocher/pydantic-cli is welcome.

pydantic-cli

Also, the new type annotations/hints feature added to Python is an extremely useful mechanism to clearly communicate interfaces when leveraging functions as first class citizens. This can dramatically help readability and maintainability. Here's an example library designed leveraging functional centric concepts + type annotations.

Depending on the strictness level of adoption of mypy, this can sometimes (often?) requires changing how you write code. You can see some contortions here. However, having strict type analysis enables catching a lot of issues.

https://github.com/mpkocher/pydantic-cli#other-related-tools