mininterface 0.4.2__tar.gz → 0.4.4rc1__tar.gz

{mininterface-0.4.2 → mininterface-0.4.4rc1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: mininterface
-Version: 0.4.2
+Version: 0.4.4rc1
 Summary: A minimal access to GUI, TUI, CLI and config
 Home-page: https://github.com/CZ-NIC/mininterface
 License: GPL-3.0-or-later
@@ -17,7 +17,7 @@ Requires-Dist: pyyaml
 Requires-Dist: requests
 Requires-Dist: textual
 Requires-Dist: tkinter-tooltip
-Requires-Dist: tkinter_form
+Requires-Dist: tkinter_form (==0.1.5.2)
 Requires-Dist: tyro
 Description-Content-Type: text/markdown
 
@@ -27,9 +27,10 @@ Description-Content-Type: text/markdown
 
 Write the program core, do not bother with the input/output.
 
-![hello world example](asset/hello-world.png "A minimal use case")
+![Hello world example: GUI window](https://github.com/CZ-NIC/mininterface/blob/main/](asset/hello-world.png?raw=True "A minimal use case – GUI")
+![Hello world example: TUI fallback](https://github.com/CZ-NIC/mininterface/blob/main/](asset/hello-tui.webp?raw=True "A minimal use case – TUI fallback")
 
-Check out the code that displays such window, just the code you need. No lengthy blocks of code imposed by an external dependency.
+Check out the code, which is surprisingly short, that displays such a window or its textual fallback.
 
 ```python
 from dataclasses import dataclass
@@ -38,34 +39,50 @@ from mininterface import run
 @dataclass
 class Config:
     """Set of options."""
-    test: bool = False
-    """My testing flag"""
-    important_number: int = 4
-    """This number is very important"""
+    test: bool = False  # My testing flag
+    important_number: int = 4  # This number is very important
 
 if __name__ == "__main__":
-    args: Config = run(Config, prog="My application").get_args()
-    print(args.important_number)    # suggested by the IDE with the hint text "This number is very important"
+    args = run(Config, prog="My application").get_args()
+    print(args.important_number)  # suggested by the IDE with the hint text "This number is very important"
 ```
 
-Or bound the interface to a `with` statement that redirects stdout directly to the window.
+## You got CLI
+It was all the code you need. No lengthy blocks of code imposed by an external dependency. Besides the GUI/TUI, you receive powerful YAML-configurable CLI parsing.
 
-```python
-with run(Config) as m:
-    print(f"Your important number is {m}")
-    boolean = m.is_yes("Is that alright?")
-```
+```bash
+$ ./hello.py
+usage: My application [-h] [--test | --no-test] [--important-number INT]
+
+Set of options.
 
-TODO img
+╭─ options ──────────────────────────────────────────────────────────╮
+│ -h, --help              show this help message and exit            │
+│ --test, --no-test       My testing flag (default: False)           │
+│ --important-number INT  This number is very important (default: 4) │
+╰────────────────────────────────────────────────────────────────────╯
+```
 
-Loading config file is a piece of cake. Alongside `program.py`, put `program.yaml`. Instantly loaded.
+## You got config file management
+Loading config file is a piece of cake. Alongside `program.py`, put `program.yaml` and put there some of the arguments. They are seamlessly taken as defaults.
 
 ```yaml
 important_number: 555
 ```
 
-TODO img
+## You got dialogues
+Check out several useful methods to handle user dialogues. Here we bound the interface to a `with` statement that redirects stdout directly to the window.
 
+```python
+with run(Config) as m:
+    print(f"Your important number is {m}")
+    boolean = m.is_yes("Is that alright?")
+```
+
+![Small window with the text 'Your important number'](https://github.com/CZ-NIC/mininterface/blob/main/](asset/hello-with-statement.webp?raw=True "With statement to redirect the output")
+![The same in terminal'](https://github.com/CZ-NIC/mininterface/blob/main/](asset/hello-with-statement-tui.webp?raw=True "With statement in TUI fallback")
+
+# Contents
 - [Mininterface – GUI, TUI, CLI and config](#mininterface-gui-tui-cli-and-config)
 - [Background](#background)
 - [Installation](#installation)
@@ -73,21 +90,18 @@ TODO img
   * [`mininterface`](#mininterface)
     + [`run(config=None, interface=GuiInterface, **kwargs)`](#runconfignone-interfaceguiinterface-kwargs)
   * [Interfaces](#interfaces)
-    + [`Mininterface(title: str = '')`](#Mininterface-title-str--)
-    + [`alert(self, text: str)`](#alert-self-text-str)
-    + [`ask(self, text: str) -> str`](#ask-self-text-str-str)
-    + [`ask_args(self) -> ~ConfigInstance`](#ask-args-self-configinstance)
-    + [`ask_form(self, args: FormDict, title="") -> int`](#ask-form-self-args-FormDict-title)
-    + [`ask_number(self, text: str) -> int`](#ask-number-self-text-str-int)
-    + [`get_args(self, ask_on_empty_cli=True) -> ~ConfigInstance`](#get-args-self-ask-on-empty-cli-true-configinstance)
-    + [`is_no(self, text: str) -> bool`](#is-no-self-text-str-bool)
-    + [`is_yes(self, text: str) -> bool`](#is-yes-self-text-str-bool)
-    + [`parse_args(self, config: Callable[..., ~ConfigInstance], config_file: pathlib.Path | None = None, **kwargs) -> ~ConfigInstance`](#parse-args-self-config-callable-configinstance-config-file-pathlibpath-none-none-kwargs-configinstance)
+    + [`Mininterface(title: str = '')`](#mininterfacetitle-str--)
+    + [`alert(text: str)`](#alerttext-str)
+    + [`ask(text: str) -> str`](#asktext-str---str)
+    + [`ask_args() -> ConfigInstance`](#ask_args--configinstance)
+    + [`ask_number(text: str) -> int`](#ask_numbertext-str---int)
+    + [`form(args: FormDict, title="") -> int`](#formargs-formdict-title---dict)
+    + [`get_args(ask_on_empty_cli=True) -> ~ConfigInstance`](#get_argsask_on_empty_clitrue---configinstance)
+    + [`is_no(text: str) -> bool`](#is_notext-str---bool)
+    + [`is_yes(text: str) -> bool`](#is_yestext-str---bool)
+    + [`parse_args(config: Type[ConfigInstance], config_file: pathlib.Path | None = None, **kwargs) -> ConfigInstance`](#parse_argsconfig-type-configinstance-config_file-pathlibpath--none--none-kwargs---configinstance)
   * [Standalone](#standalone)
 
-<small><i><a href='http://ecotrust-canada.github.io/markdown-toc/'>Table of contents generated with markdown-toc</a></i></small>
-
-
 # Background
 
 Wrapper between the [tyro](https://github.com/brentyi/tyro) `argparse` replacement and [tkinter_form](https://github.com/JohanEstebanCuervo/tkinter_form/) that converts dicts into a GUI.
@@ -147,7 +161,7 @@ $./program.py --further.host example.net
 Wrap your configuration dataclass into `run` to access the interface. Normally, an interface is chosen automatically. We prefer the graphical one, regressed to a text interface on a machine without display.
 Besides, if given a configuration dataclass, the function enriches it with the CLI commands and possibly with the default from a config file if such exists. It searches the config file in the current working directory, with the program name ending on *.yaml*, ex: `program.py` will fetch `./program.yaml`.
 
-* `config:ConfigClass`: Dataclass with the configuration.
+* `config:Type[ConfigInstance]`: Dataclass with the configuration.
 * `interface`: Which interface to prefer. By default, we use the GUI, the fallback is the REPL.
 * `**kwargs`: The same as for [`argparse.ArgumentParser`](https://docs.python.org/3/library/argparse.html).
 * Returns: `interface` Interface used.
@@ -163,6 +177,8 @@ Several interfaces exist:
 * `Mininterface` – The base interface. Does not require any user input and hence is suitable for headless testing.
 * `GuiInterface` – A tkinter window.
 * `TuiInterface` – An interactive terminal.
+  * `TextualInterface` – If [textual](https://github.com/Textualize/textual) installed, rich interface is used.
+  * `TextInterface` – Plain text only interface with no dependency as a fallback.
 * `ReplInterface` – A debug terminal. Invokes a breakpoint after every dialog.
 
 You can invoke one directly instead of using [mininterface.run](#run-config-none-interface-guiinterface-kwargs). Then, you can connect a configuration object to the CLI and config file with `parse_args` if needed.
@@ -174,27 +190,27 @@ with TuiInterface("My program") as m:
 
 ### `Mininterface(title: str = '')`
 Initialize.
-### `alert(self, text: str)`
+### `alert(text: str)`
 Prompt the user to confirm the text.
-### `ask(self, text: str) -> str`
+### `ask(text: str) -> str`
 Prompt the user to input a text.
-### `ask_args(self) -> ~ConfigInstance`
+### `ask_args() -> ConfigInstance`
 Allow the user to edit whole configuration. (Previously fetched from CLI and config file by parse_args.)
-### `ask_form(self, args: FormDict, title="") -> dict`
+### `form(args: FormDict, title="") -> dict`
 Prompt the user to fill up whole form.
 * `args`: Dict of `{labels: default value}`. The form widget infers from the default value type.
   The dict can be nested, it can contain a subgroup.
   The default value might be `mininterface.FormField` that allows you to add descriptions.
   A checkbox example: `{"my label": FormField(True, "my description")}`
 * `title`: Optional form title.
-### `ask_number(self, text: str) -> int`
+### `ask_number(text: str) -> int`
 Prompt the user to input a number. Empty input = 0.
-### `get_args(self, ask_on_empty_cli=True) -> ~ConfigInstance`
+### `get_args(ask_on_empty_cli=True) -> ConfigInstance`
 Returns whole configuration (previously fetched from CLI and config file by parse_args).
 If program was launched with no arguments (empty CLI), invokes self.ask_args() to edit the fields.
-### `is_no(self, text: str) -> bool`
+### `is_no(text: str) -> bool`
 Display confirm box, focusing no.
-### `is_yes(self, text: str) -> bool`
+### `is_yes(text: str) -> bool`
 Display confirm box, focusing yes.
 
 ```python
@@ -202,7 +218,7 @@ m = run(prog="My program")
 print(m.ask_yes("Is it true?"))  # True/False
 ```
 
-### `parse_args(self, config: Callable[..., ~ConfigInstance], config_file: pathlib.Path | None = None, **kwargs) -> ~ConfigInstance`
+### `parse_args(config: Type[ConfigInstance], config_file: pathlib.Path | None = None, **kwargs) -> ~ConfigInstance`
 Parse CLI arguments, possibly merged from a config file.
 * `config`: Dataclass with the configuration.
 * `config_file`: File to load YAML to be merged with the configuration. You do not have to re-define all the settings, you can choose a few.

{mininterface-0.4.2 → mininterface-0.4.4rc1}/README.md

@@ -4,9 +4,10 @@
 
 Write the program core, do not bother with the input/output.
 
-![hello world example](asset/hello-world.png "A minimal use case")
+![Hello world example: GUI window](https://github.com/CZ-NIC/mininterface/blob/main/](asset/hello-world.png?raw=True "A minimal use case – GUI")
+![Hello world example: TUI fallback](https://github.com/CZ-NIC/mininterface/blob/main/](asset/hello-tui.webp?raw=True "A minimal use case – TUI fallback")
 
-Check out the code that displays such window, just the code you need. No lengthy blocks of code imposed by an external dependency.
+Check out the code, which is surprisingly short, that displays such a window or its textual fallback.
 
 ```python
 from dataclasses import dataclass
@@ -15,34 +16,50 @@ from mininterface import run
 @dataclass
 class Config:
     """Set of options."""
-    test: bool = False
-    """My testing flag"""
-    important_number: int = 4
-    """This number is very important"""
+    test: bool = False  # My testing flag
+    important_number: int = 4  # This number is very important
 
 if __name__ == "__main__":
-    args: Config = run(Config, prog="My application").get_args()
-    print(args.important_number)    # suggested by the IDE with the hint text "This number is very important"
+    args = run(Config, prog="My application").get_args()
+    print(args.important_number)  # suggested by the IDE with the hint text "This number is very important"
 ```
 
-Or bound the interface to a `with` statement that redirects stdout directly to the window.
+## You got CLI
+It was all the code you need. No lengthy blocks of code imposed by an external dependency. Besides the GUI/TUI, you receive powerful YAML-configurable CLI parsing.
 
-```python
-with run(Config) as m:
-    print(f"Your important number is {m}")
-    boolean = m.is_yes("Is that alright?")
-```
+```bash
+$ ./hello.py
+usage: My application [-h] [--test | --no-test] [--important-number INT]
+
+Set of options.
 
-TODO img
+╭─ options ──────────────────────────────────────────────────────────╮
+│ -h, --help              show this help message and exit            │
+│ --test, --no-test       My testing flag (default: False)           │
+│ --important-number INT  This number is very important (default: 4) │
+╰────────────────────────────────────────────────────────────────────╯
+```
 
-Loading config file is a piece of cake. Alongside `program.py`, put `program.yaml`. Instantly loaded.
+## You got config file management
+Loading config file is a piece of cake. Alongside `program.py`, put `program.yaml` and put there some of the arguments. They are seamlessly taken as defaults.
 
 ```yaml
 important_number: 555
 ```
 
-TODO img
+## You got dialogues
+Check out several useful methods to handle user dialogues. Here we bound the interface to a `with` statement that redirects stdout directly to the window.
 
+```python
+with run(Config) as m:
+    print(f"Your important number is {m}")
+    boolean = m.is_yes("Is that alright?")
+```
+
+![Small window with the text 'Your important number'](https://github.com/CZ-NIC/mininterface/blob/main/](asset/hello-with-statement.webp?raw=True "With statement to redirect the output")
+![The same in terminal'](https://github.com/CZ-NIC/mininterface/blob/main/](asset/hello-with-statement-tui.webp?raw=True "With statement in TUI fallback")
+
+# Contents
 - [Mininterface – GUI, TUI, CLI and config](#mininterface-gui-tui-cli-and-config)
 - [Background](#background)
 - [Installation](#installation)
@@ -50,21 +67,18 @@ TODO img
   * [`mininterface`](#mininterface)
     + [`run(config=None, interface=GuiInterface, **kwargs)`](#runconfignone-interfaceguiinterface-kwargs)
   * [Interfaces](#interfaces)
-    + [`Mininterface(title: str = '')`](#Mininterface-title-str--)
-    + [`alert(self, text: str)`](#alert-self-text-str)
-    + [`ask(self, text: str) -> str`](#ask-self-text-str-str)
-    + [`ask_args(self) -> ~ConfigInstance`](#ask-args-self-configinstance)
-    + [`ask_form(self, args: FormDict, title="") -> int`](#ask-form-self-args-FormDict-title)
-    + [`ask_number(self, text: str) -> int`](#ask-number-self-text-str-int)
-    + [`get_args(self, ask_on_empty_cli=True) -> ~ConfigInstance`](#get-args-self-ask-on-empty-cli-true-configinstance)
-    + [`is_no(self, text: str) -> bool`](#is-no-self-text-str-bool)
-    + [`is_yes(self, text: str) -> bool`](#is-yes-self-text-str-bool)
-    + [`parse_args(self, config: Callable[..., ~ConfigInstance], config_file: pathlib.Path | None = None, **kwargs) -> ~ConfigInstance`](#parse-args-self-config-callable-configinstance-config-file-pathlibpath-none-none-kwargs-configinstance)
+    + [`Mininterface(title: str = '')`](#mininterfacetitle-str--)
+    + [`alert(text: str)`](#alerttext-str)
+    + [`ask(text: str) -> str`](#asktext-str---str)
+    + [`ask_args() -> ConfigInstance`](#ask_args--configinstance)
+    + [`ask_number(text: str) -> int`](#ask_numbertext-str---int)
+    + [`form(args: FormDict, title="") -> int`](#formargs-formdict-title---dict)
+    + [`get_args(ask_on_empty_cli=True) -> ~ConfigInstance`](#get_argsask_on_empty_clitrue---configinstance)
+    + [`is_no(text: str) -> bool`](#is_notext-str---bool)
+    + [`is_yes(text: str) -> bool`](#is_yestext-str---bool)
+    + [`parse_args(config: Type[ConfigInstance], config_file: pathlib.Path | None = None, **kwargs) -> ConfigInstance`](#parse_argsconfig-type-configinstance-config_file-pathlibpath--none--none-kwargs---configinstance)
   * [Standalone](#standalone)
 
-<small><i><a href='http://ecotrust-canada.github.io/markdown-toc/'>Table of contents generated with markdown-toc</a></i></small>
-
-
 # Background
 
 Wrapper between the [tyro](https://github.com/brentyi/tyro) `argparse` replacement and [tkinter_form](https://github.com/JohanEstebanCuervo/tkinter_form/) that converts dicts into a GUI.
@@ -124,7 +138,7 @@ $./program.py --further.host example.net
 Wrap your configuration dataclass into `run` to access the interface. Normally, an interface is chosen automatically. We prefer the graphical one, regressed to a text interface on a machine without display.
 Besides, if given a configuration dataclass, the function enriches it with the CLI commands and possibly with the default from a config file if such exists. It searches the config file in the current working directory, with the program name ending on *.yaml*, ex: `program.py` will fetch `./program.yaml`.
 
-* `config:ConfigClass`: Dataclass with the configuration.
+* `config:Type[ConfigInstance]`: Dataclass with the configuration.
 * `interface`: Which interface to prefer. By default, we use the GUI, the fallback is the REPL.
 * `**kwargs`: The same as for [`argparse.ArgumentParser`](https://docs.python.org/3/library/argparse.html).
 * Returns: `interface` Interface used.
@@ -140,6 +154,8 @@ Several interfaces exist:
 * `Mininterface` – The base interface. Does not require any user input and hence is suitable for headless testing.
 * `GuiInterface` – A tkinter window.
 * `TuiInterface` – An interactive terminal.
+  * `TextualInterface` – If [textual](https://github.com/Textualize/textual) installed, rich interface is used.
+  * `TextInterface` – Plain text only interface with no dependency as a fallback.
 * `ReplInterface` – A debug terminal. Invokes a breakpoint after every dialog.
 
 You can invoke one directly instead of using [mininterface.run](#run-config-none-interface-guiinterface-kwargs). Then, you can connect a configuration object to the CLI and config file with `parse_args` if needed.
@@ -151,27 +167,27 @@ with TuiInterface("My program") as m:
 
 ### `Mininterface(title: str = '')`
 Initialize.
-### `alert(self, text: str)`
+### `alert(text: str)`
 Prompt the user to confirm the text.
-### `ask(self, text: str) -> str`
+### `ask(text: str) -> str`
 Prompt the user to input a text.
-### `ask_args(self) -> ~ConfigInstance`
+### `ask_args() -> ConfigInstance`
 Allow the user to edit whole configuration. (Previously fetched from CLI and config file by parse_args.)
-### `ask_form(self, args: FormDict, title="") -> dict`
+### `form(args: FormDict, title="") -> dict`
 Prompt the user to fill up whole form.
 * `args`: Dict of `{labels: default value}`. The form widget infers from the default value type.
   The dict can be nested, it can contain a subgroup.
   The default value might be `mininterface.FormField` that allows you to add descriptions.
   A checkbox example: `{"my label": FormField(True, "my description")}`
 * `title`: Optional form title.
-### `ask_number(self, text: str) -> int`
+### `ask_number(text: str) -> int`
 Prompt the user to input a number. Empty input = 0.
-### `get_args(self, ask_on_empty_cli=True) -> ~ConfigInstance`
+### `get_args(ask_on_empty_cli=True) -> ConfigInstance`
 Returns whole configuration (previously fetched from CLI and config file by parse_args).
 If program was launched with no arguments (empty CLI), invokes self.ask_args() to edit the fields.
-### `is_no(self, text: str) -> bool`
+### `is_no(text: str) -> bool`
 Display confirm box, focusing no.
-### `is_yes(self, text: str) -> bool`
+### `is_yes(text: str) -> bool`
 Display confirm box, focusing yes.
 
 ```python
@@ -179,7 +195,7 @@ m = run(prog="My program")
 print(m.ask_yes("Is it true?"))  # True/False
 ```
 
-### `parse_args(self, config: Callable[..., ~ConfigInstance], config_file: pathlib.Path | None = None, **kwargs) -> ~ConfigInstance`
+### `parse_args(config: Type[ConfigInstance], config_file: pathlib.Path | None = None, **kwargs) -> ~ConfigInstance`
 Parse CLI arguments, possibly merged from a config file.
 * `config`: Dataclass with the configuration.
 * `config_file`: File to load YAML to be merged with the configuration. You do not have to re-define all the settings, you can choose a few.

mininterface-0.4.4rc1/mininterface/FormDict.py

@@ -0,0 +1,120 @@
+""" FormDict tools.
+    FormDict is not a real class, just a normal dict. But we need to put somewhere functions related to it.
+"""
+import logging
+from argparse import Action, ArgumentParser
+from typing import Callable, Optional, Type, TypeVar, Union, get_type_hints
+from unittest.mock import patch
+
+from tyro import cli
+from tyro._argparse_formatter import TyroArgumentParser
+
+from .FormField import FormField
+
+logger = logging.getLogger(__name__)
+
+ConfigInstance = TypeVar("ConfigInstance")
+ConfigClass = Type[ConfigInstance]
+FormDict = dict[str, Union[FormField, 'FormDict']]
+""" Nested form that can have descriptions (through FormField) instead of plain values. """
+
+
+def formdict_repr(d: FormDict) -> dict:
+    """ For the testing purposes, returns a new dict when all FormFields are replaced with their values. """
+    out = {}
+    for k, v in d.items():
+        if isinstance(v, FormField):
+            v = v.val
+        out[k] = formdict_repr(v) if isinstance(v, dict) else v
+    return out
+
+
+def dict_to_formdict(data: dict) -> FormDict:
+    fd = {}
+    for key, val in data.items():
+        if isinstance(val, dict):  # nested config hierarchy
+            fd[key] = dict_to_formdict(val)
+        else:  # scalar value
+            # NOTE name=param is not set (yet?) in `config_to_formdict`, neither `src`
+            fd[key] = FormField(val, "", name=key, src=(data, key))
+    return fd
+
+
+def config_to_formdict(args: ConfigInstance, descr: dict, _path="") -> FormDict:
+    """ Convert the dataclass produced by tyro into dict of dicts. """
+    main = ""
+    params = {main: {}} if not _path else {}
+    for param, val in vars(args).items():
+        annotation = None
+        if val is None:
+            wanted_type = get_type_hints(args.__class__).get(param)
+            if wanted_type in (Optional[int], Optional[str]):
+                # Since tkinter_form does not handle None yet, we have help it.
+                # We need it to be able to write a number and if empty, return None.
+                # This would fail: `severity: int | None = None`
+                # Here, we convert None to str(""), in normalize_types we convert it back.
+                annotation = wanted_type
+                val = ""
+            else:
+                # An unknown type annotation encountered-
+                # Since tkinter_form does not handle None yet, this will display as checkbox.
+                # Which is not probably wanted.
+                val = False
+                logger.warn(f"Annotation {wanted_type} of `{param}` not supported by Mininterface."
+                            "None converted to False.")
+        if hasattr(val, "__dict__"):  # nested config hierarchy
+            params[param] = config_to_formdict(val, descr, _path=f"{_path}{param}.")
+        elif not _path:  # scalar value in root
+            params[main][param] = FormField(val, descr.get(param), annotation, param, src2=(args, param))
+        else:  # scalar value in nested
+            params[param] = FormField(val, descr.get(f"{_path}{param}"), annotation, param, src2=(args, param))
+    return params
+
+
+def get_args_allow_missing(config: Type[ConfigInstance], kwargs: dict, parser: ArgumentParser) -> ConfigInstance:
+    """ Fetch missing required options in GUI. """
+    # On missing argument, tyro fail. We cannot determine which one was missing, except by intercepting
+    # the error message function. Then, we reconstruct the missing options.
+    # NOTE But we should rather invoke a GUI with the missing options only.
+    original_error = TyroArgumentParser.error
+    eavesdrop = ""
+
+    def custom_error(self, message: str):
+        nonlocal eavesdrop
+        if not message.startswith("the following arguments are required:"):
+            return original_error(self, message)
+        eavesdrop = message
+        raise SystemExit(2)  # will be catched
+
+    # Set args to determine whether to use sys.argv.
+    # Why settings args? Prevent tyro using sys.argv if we are in an interactive shell like Jupyter,
+    # as sys.argv is non-related there.
+    try:
+        # Note wherease `"get_ipython" in globals()` returns True in Jupyter, it is still False
+        # in a script a Jupyter cell runs. Hence we must put here this lengthty statement.
+        global get_ipython
+        get_ipython()
+    except:
+        args = None
+    else:
+        args = []
+    try:
+        with patch.object(TyroArgumentParser, 'error', custom_error):
+            return cli(config, args=args, **kwargs)
+    except BaseException as e:
+        if hasattr(e, "code") and e.code == 2 and eavesdrop:  # Some arguments are missing. Determine which.
+            for arg in eavesdrop.partition(":")[2].strip().split(", "):
+                argument: Action = next(iter(p for p in parser._actions if arg in p.option_strings))
+                argument.default = "DEFAULT"  # NOTE I do not know whether used
+                if "." in argument.dest:  # missing nested required argument handler not implemented, we make tyro fail in CLI
+                    pass
+                else:
+                    match argument.metavar:
+                        case "INT":
+                            setattr(kwargs["default"], argument.dest, 0)
+                        case "STR":
+                            setattr(kwargs["default"], argument.dest, "")
+                        case _:
+                            pass  # missing handler not implemented, we make tyro fail in CLI
+            return cli(config, **kwargs)  # second attempt
+        raise

mininterface-0.4.4rc1/mininterface/FormField.py

@@ -0,0 +1,133 @@
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any, Iterable, Optional, TypeVar, get_args
+
+from .auxiliary import flatten
+
+if TYPE_CHECKING:
+    from .FormDict import FormDict
+
+try:
+    from tkinter_form import Value
+except ImportError:
+    # TODO put into GuiInterface create_ui(ff: FormField)
+    @dataclass
+    class Value:
+        """ This class helps to enrich the field with a description. """
+        val: Any
+        description: str
+
+
+FFValue = TypeVar("FFValue")
+TD = TypeVar("TD")
+""" dict """
+TK = TypeVar("TK")
+""" dict key """
+
+
+@dataclass
+class FormField(Value):
+    """ Bridge between the input values and a UI widget.
+        Helps to creates a widget from the input value (includes description etc.),
+        then transforms the value back (str to int conversion etc).
+
+        (Ex: Merge the dict of dicts from the GUI back into the object holding the configuration.)
+        """
+
+    annotation: Any | None = None
+    """ Used for validation. To convert an empty '' to None. """
+    name: str | None = None  # NOTE: Only TextualInterface uses this by now.
+
+    src: tuple[TD, TK] | None = None
+    """ The original dict to be updated when UI ends. """
+    src2: tuple[TD, TK] | None = None
+    """ The original object to be updated when UI ends.
+    NOTE should be merged to `src`
+    """
+
+    def __post_init__(self):
+        self._original_desc = self.description
+
+    def set_error_text(self, s):
+        self.description = f"{s} {self._original_desc}"
+
+    def update(self, ui_value):
+        """ UI value → FormField value → original value. (With type conversion and checks.)
+
+            The value has been updated in a UI.
+            Update accordingly the value in the original linked dict
+            the mininterface was invoked with.
+
+            Validates the type and do the transformation.
+            (Ex: Some values might be nulled from "".)
+        """
+        fixed_value = ui_value
+        if self.annotation:
+            if ui_value == "" and type(None) in get_args(self.annotation):
+                # The user is not able to set the value to None, they left it empty.
+                # Cast back to None as None is one of the allowed types.
+                # Ex: `severity: int | None = None`
+                fixed_value = None
+            elif self.annotation == Optional[int]:
+                try:
+                    fixed_value = int(ui_value)
+                except ValueError:
+                    pass
+
+            if not isinstance(fixed_value, self.annotation):
+                self.set_error_text(f"Type must be `{self.annotation}`!")
+                return False  # revision needed
+
+        # keep values if revision needed
+        # We merge new data to the origin. If form is re-submitted, the values will stay there.
+        self.val = ui_value
+
+        # Store to the source user data
+        if self.src:
+            d, k = self.src
+            d[k] = fixed_value
+        elif self.src2:
+            d, k = self.src2
+            setattr(d, k, fixed_value)
+        else:
+            # This might be user-created object. The user reads directly from this. There is no need to update anything.
+            pass
+        return True
+        # Fixing types:
+        # This code would support tuple[int, int]:
+        #
+        #     self.types = get_args(self.annotation) \
+        #     if isinstance(self.annotation, UnionType) else (self.annotation, )
+        # "All possible types in a tuple. Ex 'int | str' -> (int, str)"
+        #
+        #
+        # def convert(self):
+        #     """ Convert the self.value to the given self.type.
+        #         The value might be in str due to CLI or TUI whereas the programs wants bool.
+        #     """
+        #     # if self.value == "True":
+        #     #     return True
+        #     # if self.value == "False":
+        #     #     return False
+        #     if type(self.val) is str and str not in self.types:
+        #         try:
+        #             return literal_eval(self.val)  # ex: int, tuple[int, int]
+        #         except:
+        #             raise ValueError(f"{self.name}: Cannot convert value {self.val}")
+        #     return self.val
+
+    @staticmethod
+    def submit_values(updater: Iterable[tuple["FormField", FFValue]]) -> bool:
+        """ Returns whether the form is alright or whether we should revise it.
+        Input is tuple of the FormFields and their new values from the UI.
+        """
+        # Why list? We need all the FormField values be updates from the UI.
+        # If the revision is needed, the UI fetches the values from the FormField.
+        # We need the keep the values so that the user does not have to re-write them.
+        return all(list(ff.update(ui_value) for ff, ui_value in updater))
+
+    @staticmethod
+    def submit(fd: "FormDict", ui: dict):
+        """ Returns whether the form is alright or whether we should revise it.
+        Input is the FormDict and the UI dict in the very same form.
+        """
+        return FormField.submit_values(zip(flatten(fd), flatten(ui)))