Mininterface

The question text.

The return type.

from datetime import time
from mininterface import run

m = run()
m.ask("Give me a time", time)

Limit the value.

from annotated_types import Gt
from mininterface import run

m = run()
m.ask("Give me a positive number", int, Gt(0))

The type from the annotation. By default str but might be int, datetime...

Displayed text.

Focus the button with this value.

Whether the user has chosen the Yes button.

You can denote the options in many ways. Either put options in an iterable, or to a dict with keys as labels. You can also use tuples for keys to get a table-like formatting. Use the Enums or nested Tags... See the OptionsType for more details.

Form title

The value of the checked choice.

m.select({"one": 1, "two": 2}, default=2)  # returns 2

If the list is given, this implies multiple choice.

Options to be highlighted. Use the list of choice values to denote which one the user might prefer.

If True, the user can choose multiple values and we return a list.

If there is a single option, choose it directly, without a dialog.

If the chosen value is a callback, we directly call it and return its return value.

def do_cmd1():
    return "cmd1"

def do_cmd2():
    return "cmd2"

m = run()
out = m.select({"Open file...": do_cmd1, "Apply filter...": do_cmd2})
print(out)  # 'cmd1' or 'cmd2'

The chosen value.

If multiple=True, return chosen values.

If launch=True and the chosen value is a callback, we call it and return its result.

We accept a dataclass type, a dataclass instance, a dict or None.

• A dataclass type is resolved to a dataclass instance that is returned.

• A dataclass instance is updated by the form and returned.

• If dict, we expect a dict of {labels: value}. The form widget infers from the default value type. The dict can be nested, it can contain a subgroup. The value might be a Tag that allows you to add descriptions.

A checkbox example: {"my label": Tag(True, "my description")}

The original dict values are updated and a new dict (where all Tags are resolved to their values) is returned.

• If None, the self.env is being used as a form, allowing the user to edit whole configuration. (Previously fetched from CLI and config file.)

Optional form title

Set the submit button text (by default 'Ok') or hide it with False.

If the form is null, the output is self.env.

If the form is a dataclass type or a dataclass instance, the output is the dataclass instance.

If the form is a dict, the output is another dict.

Whereas the original dict stays intact (with the values updated), we return a new raw dict with all values resolved (all Tag objects are resolved to their value).

original = {"my label": Tag(True, "my description")}
output = m.form(original)  # Sets the label to False in the dialog

# Original dict was updated
print(original["my label"])  # Tag(False, "my description")

# Output dict is resolved, contains only raw values
print(output["my label"])  # False

Why this behaviour? You need to do some validation, hence you put Tag objects in the input dict. Then, you just need to work with the values.

original = {"my label": Tag(True, "my description")}
output = m.form(original)  # Sets the label to False in the dialog
output["my_label"]

In the case you are willing to re-use the dict, you need not to lose the definitions, hence you end up with accessing via the .val.

original = {"my label": Tag(True, "my description")}

for i in range(10):
    m.form(original, f"Attempt {i}")
    print("The result", original["my label"].val)