mininterface 0.4.4rc3__tar.gz → 0.5.0__tar.gz

{mininterface-0.4.4rc3 → mininterface-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: mininterface
-Version: 0.4.4rc3
+Version: 0.5.0
 Summary: A minimal access to GUI, TUI, CLI and config
 Home-page: https://github.com/CZ-NIC/mininterface
 License: GPL-3.0-or-later
@@ -37,14 +37,14 @@ from dataclasses import dataclass
 from mininterface import run
 
 @dataclass
-class Config:
+class Env:
     """Set of options."""
     test: bool = False  # My testing flag
     important_number: int = 4  # This number is very important
 
 if __name__ == "__main__":
-    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"
+    env = run(Env, prog="My application").get_env()
+    print(env.important_number)  # suggested by the IDE with the hint text "This number is very important"
 ```
 
 ## You got CLI
@@ -74,13 +74,13 @@ important_number: 555
 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}")
+with run(Env) as m:
+    print(f"Your important number is {m.env.important_number}")
     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")
+![The same in terminal'](https://github.com/CZ-NIC/mininterface/blob/main/asset/hello-with-statement-tui.avif?raw=True "With statement in TUI fallback")
 
 # Contents
 - [Mininterface – GUI, TUI, CLI and config](#mininterface-gui-tui-cli-and-config)
@@ -93,24 +93,24 @@ with run(Config) as m:
     + [`Mininterface(title: str = '')`](#mininterfacetitle-str--)
     + [`alert(text: str)`](#alerttext-str)
     + [`ask(text: str) -> str`](#asktext-str---str)
-    + [`ask_args() -> ConfigInstance`](#ask_args--configinstance)
+    + [`ask_env() -> EnvInstance`](#ask_env--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)
+    + [`form(env: FormDict, title="") -> int`](#formenv-formdict-title---dict)
+    + [`get_env(ask_on_empty_cli=True) -> ~EnvInstance`](#get_envask_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)
+    + [`parse_env(config: Type[EnvInstance], config_file: pathlib.Path | None = None, **kwargs) -> EnvInstance`](#parse_envconfig-type-configinstance-config_file-pathlibpath--none--none-kwargs---configinstance)
   * [Standalone](#standalone)
 
 # 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.
 
-Writing a small and useful program might be a task that takes fifteen minutes. Adding a CLI to specify the parameters is not so much overhead. But building a simple GUI around it? HOURS! Hours spent on researching GUI libraries, wondering why the Python desktop app ecosystem lags so far behind the web world. All you need is a few input fields validated through a clickable window... You do not deserve to add hundred of lines of the code just to define some editable fields. `mininterface` is here to help.
+Writing a small and useful program might be a task that takes fifteen minutes. Adding a CLI to specify the parameters is not so much overhead. But building a simple GUI around it? HOURS! Hours spent on researching GUI libraries, wondering why the Python desktop app ecosystem lags so far behind the web world. All you need is a few input fields validated through a clickable window... You do not deserve to add hundred of lines of the code just to define some editable fields. `Mininterface` is here to help.
 
 The config variables needed by your program are kept in cozy dataclasses. Write less! The syntax of [tyro](https://github.com/brentyi/tyro) does not require any overhead (as its `argparse` alternatives do). You just annotate a class attribute, append a simple docstring and get a fully functional application:
 * Call it as `program.py --help` to display full help.
-* Use any flag in CLI: `program.py --test`  causes `args.test` be set to `True`.
+* Use any flag in CLI: `program.py --test`  causes `env.test` be set to `True`.
 * The main benefit: Launch it without parameters as `program.py` to get a full working window with all the flags ready to be edited.
 * Running on a remote machine? Automatic regression to the text interface.
 
@@ -118,7 +118,7 @@ The config variables needed by your program are kept in cozy dataclasses. Write
 
 Install with a single command from [PyPi](https://pypi.org/project/mininterface/).
 
-```python3
+```bash
 pip install mininterface
 ```
 
@@ -161,9 +161,9 @@ $./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:Type[ConfigInstance]`: Dataclass with the configuration.
+* `config:Type[EnvInstance]`: 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).
+* `**kwargs`: The same as for [`argparse.ArgumentParser`](https://docs.python.org/3/library/argparse.html#argparse.ArgumentParser).
 * Returns: `interface` Interface used.
 
 You cay context manage the function by a `with` statement. The stdout will be redirected to the interface (GUI window).
@@ -181,7 +181,7 @@ Several interfaces exist:
   * `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.
+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_env` if needed.
 
 ```python
 with TuiInterface("My program") as m:
@@ -194,20 +194,20 @@ Initialize.
 Prompt the user to confirm the text.
 ### `ask(text: str) -> str`
 Prompt the user to input a text.
-### `ask_args() -> ConfigInstance`
-Allow the user to edit whole configuration. (Previously fetched from CLI and config file by parse_args.)
-### `form(args: FormDict, title="") -> dict`
+### `ask_env() -> EnvInstance`
+Allow the user to edit whole configuration. (Previously fetched from CLI and config file by parse_env.)
+### `ask_number(text: str) -> int`
+Prompt the user to input a number. Empty input = 0.
+### `form(env: 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.
+* `env`: 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(text: str) -> int`
-Prompt the user to input a number. Empty input = 0.
-### `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.
+### `get_env(ask_on_empty_cli=True) -> EnvInstance`
+Returns whole configuration (previously fetched from CLI and config file by parse_env).
+If program was launched with no arguments (empty CLI), invokes self.ask_env() to edit the fields.
 ### `is_no(text: str) -> bool`
 Display confirm box, focusing no.
 ### `is_yes(text: str) -> bool`
@@ -218,12 +218,12 @@ m = run(prog="My program")
 print(m.ask_yes("Is it true?"))  # True/False
 ```
 
-### `parse_args(config: Type[ConfigInstance], config_file: pathlib.Path | None = None, **kwargs) -> ~ConfigInstance`
+### `parse_env(config: Type[EnvInstance], config_file: pathlib.Path | None = None, **kwargs) -> ~EnvInstance`
 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.
 * `**kwargs` The same as for argparse.ArgumentParser.
-* Returns: `ConfigInstance` Configuration namespace.
+* Returns: `EnvInstance` Configuration namespace.
 
 ## Standalone
 

{mininterface-0.4.4rc3 → mininterface-0.5.0}/README.md

@@ -14,14 +14,14 @@ from dataclasses import dataclass
 from mininterface import run
 
 @dataclass
-class Config:
+class Env:
     """Set of options."""
     test: bool = False  # My testing flag
     important_number: int = 4  # This number is very important
 
 if __name__ == "__main__":
-    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"
+    env = run(Env, prog="My application").get_env()
+    print(env.important_number)  # suggested by the IDE with the hint text "This number is very important"
 ```
 
 ## You got CLI
@@ -51,13 +51,13 @@ important_number: 555
 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}")
+with run(Env) as m:
+    print(f"Your important number is {m.env.important_number}")
     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")
+![The same in terminal'](https://github.com/CZ-NIC/mininterface/blob/main/asset/hello-with-statement-tui.avif?raw=True "With statement in TUI fallback")
 
 # Contents
 - [Mininterface – GUI, TUI, CLI and config](#mininterface-gui-tui-cli-and-config)
@@ -70,24 +70,24 @@ with run(Config) as m:
     + [`Mininterface(title: str = '')`](#mininterfacetitle-str--)
     + [`alert(text: str)`](#alerttext-str)
     + [`ask(text: str) -> str`](#asktext-str---str)
-    + [`ask_args() -> ConfigInstance`](#ask_args--configinstance)
+    + [`ask_env() -> EnvInstance`](#ask_env--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)
+    + [`form(env: FormDict, title="") -> int`](#formenv-formdict-title---dict)
+    + [`get_env(ask_on_empty_cli=True) -> ~EnvInstance`](#get_envask_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)
+    + [`parse_env(config: Type[EnvInstance], config_file: pathlib.Path | None = None, **kwargs) -> EnvInstance`](#parse_envconfig-type-configinstance-config_file-pathlibpath--none--none-kwargs---configinstance)
   * [Standalone](#standalone)
 
 # 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.
 
-Writing a small and useful program might be a task that takes fifteen minutes. Adding a CLI to specify the parameters is not so much overhead. But building a simple GUI around it? HOURS! Hours spent on researching GUI libraries, wondering why the Python desktop app ecosystem lags so far behind the web world. All you need is a few input fields validated through a clickable window... You do not deserve to add hundred of lines of the code just to define some editable fields. `mininterface` is here to help.
+Writing a small and useful program might be a task that takes fifteen minutes. Adding a CLI to specify the parameters is not so much overhead. But building a simple GUI around it? HOURS! Hours spent on researching GUI libraries, wondering why the Python desktop app ecosystem lags so far behind the web world. All you need is a few input fields validated through a clickable window... You do not deserve to add hundred of lines of the code just to define some editable fields. `Mininterface` is here to help.
 
 The config variables needed by your program are kept in cozy dataclasses. Write less! The syntax of [tyro](https://github.com/brentyi/tyro) does not require any overhead (as its `argparse` alternatives do). You just annotate a class attribute, append a simple docstring and get a fully functional application:
 * Call it as `program.py --help` to display full help.
-* Use any flag in CLI: `program.py --test`  causes `args.test` be set to `True`.
+* Use any flag in CLI: `program.py --test`  causes `env.test` be set to `True`.
 * The main benefit: Launch it without parameters as `program.py` to get a full working window with all the flags ready to be edited.
 * Running on a remote machine? Automatic regression to the text interface.
 
@@ -95,7 +95,7 @@ The config variables needed by your program are kept in cozy dataclasses. Write
 
 Install with a single command from [PyPi](https://pypi.org/project/mininterface/).
 
-```python3
+```bash
 pip install mininterface
 ```
 
@@ -138,9 +138,9 @@ $./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:Type[ConfigInstance]`: Dataclass with the configuration.
+* `config:Type[EnvInstance]`: 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).
+* `**kwargs`: The same as for [`argparse.ArgumentParser`](https://docs.python.org/3/library/argparse.html#argparse.ArgumentParser).
 * Returns: `interface` Interface used.
 
 You cay context manage the function by a `with` statement. The stdout will be redirected to the interface (GUI window).
@@ -158,7 +158,7 @@ Several interfaces exist:
   * `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.
+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_env` if needed.
 
 ```python
 with TuiInterface("My program") as m:
@@ -171,20 +171,20 @@ Initialize.
 Prompt the user to confirm the text.
 ### `ask(text: str) -> str`
 Prompt the user to input a text.
-### `ask_args() -> ConfigInstance`
-Allow the user to edit whole configuration. (Previously fetched from CLI and config file by parse_args.)
-### `form(args: FormDict, title="") -> dict`
+### `ask_env() -> EnvInstance`
+Allow the user to edit whole configuration. (Previously fetched from CLI and config file by parse_env.)
+### `ask_number(text: str) -> int`
+Prompt the user to input a number. Empty input = 0.
+### `form(env: 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.
+* `env`: 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(text: str) -> int`
-Prompt the user to input a number. Empty input = 0.
-### `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.
+### `get_env(ask_on_empty_cli=True) -> EnvInstance`
+Returns whole configuration (previously fetched from CLI and config file by parse_env).
+If program was launched with no arguments (empty CLI), invokes self.ask_env() to edit the fields.
 ### `is_no(text: str) -> bool`
 Display confirm box, focusing no.
 ### `is_yes(text: str) -> bool`
@@ -195,12 +195,12 @@ m = run(prog="My program")
 print(m.ask_yes("Is it true?"))  # True/False
 ```
 
-### `parse_args(config: Type[ConfigInstance], config_file: pathlib.Path | None = None, **kwargs) -> ~ConfigInstance`
+### `parse_env(config: Type[EnvInstance], config_file: pathlib.Path | None = None, **kwargs) -> ~EnvInstance`
 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.
 * `**kwargs` The same as for argparse.ArgumentParser.
-* Returns: `ConfigInstance` Configuration namespace.
+* Returns: `EnvInstance` Configuration namespace.
 
 ## Standalone
 

{mininterface-0.4.4rc3 → mininterface-0.5.0}/mininterface/FormDict.py

@@ -3,7 +3,7 @@
 """
 import logging
 from argparse import Action, ArgumentParser
-from typing import Callable, Optional, Type, TypeVar, Union, get_type_hints
+from typing import Any, Callable, Optional, Type, TypeVar, Union, get_type_hints
 from unittest.mock import patch
 
 from tyro import cli
@@ -13,8 +13,7 @@ from .FormField import FormField
 
 logger = logging.getLogger(__name__)
 
-ConfigInstance = TypeVar("ConfigInstance")
-ConfigClass = Type[ConfigInstance]
+EnvClass = TypeVar("EnvInstance")
 FormDict = dict[str, Union[FormField, 'FormDict']]
 """ Nested form that can have descriptions (through FormField) instead of plain values. """
 
@@ -36,18 +35,27 @@ def dict_to_formdict(data: dict) -> FormDict:
             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))
+            fd[key] = FormField(val, "", name=key, src_dict=(data, key)) if not isinstance(val, FormField) else val
     return fd
 
 
-def config_to_formdict(args: ConfigInstance, descr: dict, _path="") -> FormDict:
+def formdict_to_widgetdict(d: FormDict | Any, widgetize_callback: Callable):
+    if isinstance(d, dict):
+        return {k: formdict_to_widgetdict(v, widgetize_callback) for k, v in d.items()}
+    elif isinstance(d, FormField):
+        return widgetize_callback(d)
+    else:
+        return d
+
+
+def config_to_formdict(env: EnvClass, 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():
+    for param, val in vars(env).items():
         annotation = None
         if val is None:
-            wanted_type = get_type_hints(args.__class__).get(param)
+            wanted_type = get_type_hints(env.__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.
@@ -65,13 +73,13 @@ def config_to_formdict(args: ConfigInstance, descr: dict, _path="") -> FormDict:
         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))
+            params[main][param] = FormField(val, descr.get(param), annotation, param, src_obj=(env, param))
         else:  # scalar value in nested
-            params[param] = FormField(val, descr.get(f"{_path}{param}"), annotation, param, src2=(args, param))
+            params[param] = FormField(val, descr.get(f"{_path}{param}"), annotation, param, src_obj=(env, param))
     return params
 
 
-def get_args_allow_missing(config: Type[ConfigInstance], kwargs: dict, parser: ArgumentParser) -> ConfigInstance:
+def get_env_allow_missing(config: Type[EnvClass], kwargs: dict, parser: ArgumentParser) -> EnvClass:
     """ 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.
@@ -86,8 +94,8 @@ def get_args_allow_missing(config: Type[ConfigInstance], kwargs: dict, parser: A
         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,
+    # Set env to determine whether to use sys.argv.
+    # Why settings env? 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
@@ -95,12 +103,12 @@ def get_args_allow_missing(config: Type[ConfigInstance], kwargs: dict, parser: A
         global get_ipython
         get_ipython()
     except:
-        args = None
+        env = None
     else:
-        args = []
+        env = []
     try:
         with patch.object(TyroArgumentParser, 'error', custom_error):
-            return cli(config, args=args, **kwargs)
+            return cli(config, args=env, **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(", "):

{mininterface-0.4.4rc3 → mininterface-0.5.0}/mininterface/FormField.py

@@ -6,17 +6,6 @@ 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 """
@@ -25,31 +14,55 @@ TK = TypeVar("TK")
 
 
 @dataclass
-class FormField(Value):
-    """ Bridge between the input values and a UI widget.
+class FormField:
+    """ This class helps to enrich the field with a description.
+        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.)
         """
 
+    val: Any
+    """ The value being enriched by this object. """
+    description: str
+    """ The description. """
+
     annotation: Any | None = None
-    """ Used for validation. To convert an empty '' to None. """
-    name: str | None = None  # NOTE: Only TextualInterface uses this by now.
+    """ Used for validation. To convert an empty '' to None.
+        If not set, will be determined automatically from the `val` type.
+    """
+    name: str | None = None
+    """ NOTE: Only TextualInterface uses this by now.
+        GuiInterface reads the name from the dict.
+        In the future, Textual should be able to do the same
+        and both, Gui and Textual should use FormField.name as override.
+    """
 
-    src: tuple[TD, TK] | None = None
-    """ The original dict to be updated when UI ends. """
-    src2: tuple[TD, TK] | None = None
+    src_dict: tuple[TD, TK] | None = None
+    """ The original dict to be updated when UI ends.
+        The processed value is in the self.processed_value too.
+    """
+    src_obj: tuple[TD, TK] | None = None
     """ The original object to be updated when UI ends.
+        The processed value is in the self.processed_value too.
     NOTE should be merged to `src`
     """
 
+    processed_value = None
+    """ The value set while processed through the UI. """
+
     def __post_init__(self):
+        if not self.annotation:
+            self.annotation = type(self.val)
         self._original_desc = self.description
 
     def set_error_text(self, s):
         self.description = f"{s} {self._original_desc}"
 
+    def remove_error_text(self):
+        self.description = self._original_desc
+
     def update(self, ui_value):
         """ UI value → FormField value → original value. (With type conversion and checks.)
 
@@ -61,6 +74,7 @@ class FormField(Value):
             (Ex: Some values might be nulled from "".)
         """
         fixed_value = ui_value
+        self.remove_error_text()
         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.
@@ -73,20 +87,36 @@ class FormField(Value):
                 except ValueError:
                     pass
 
+            if not isinstance(fixed_value, self.annotation):
+                if isinstance(fixed_value, str):
+                    try:
+                        # Textual ask_number -> user writes '123', this has to be converted to int 123
+                        # NOTE: Unfortunately, type(list) looks awful here. @see TextualInterface.form comment.
+                        fixed_value = self.annotation(ui_value)
+                    except (TypeError, ValueError):
+                        # Automatic conversion failed
+                        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.
+        # NOTE: We might store `self.val = fixed_value`.
+        # This would help when the user defines FormField themselves
+        # because there is no other way to access fixed_value from outside (we try self.processed_value).
+        # However `self.val = fixed_value`` looks awful when TextualInterface have a list of strings
+        # and the form is recreated, strings split to letters, @see TextualInterface.form comment.
         self.val = ui_value
+        self.processed_value = fixed_value
 
         # Store to the source user data
-        if self.src:
-            d, k = self.src
+        if self.src_dict:
+            d, k = self.src_dict
             d[k] = fixed_value
-        elif self.src2:
-            d, k = self.src2
+        elif self.src_obj:
+            d, k = self.src_obj
             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.

{mininterface-0.4.4rc3 → mininterface-0.5.0}/mininterface/GuiInterface.py

@@ -4,18 +4,18 @@ from typing import Any, Callable
 try:
     from tkinter import TclError, LEFT, Button, Frame, Label, Text, Tk
     from tktooltip import ToolTip
-    from tkinter_form import Form
+    from tkinter_form import Form, Value
 except ImportError:
     from .common import InterfaceNotAvailable
     raise InterfaceNotAvailable
 
 
 from .common import InterfaceNotAvailable
-from .FormDict import FormDict, config_to_formdict
+from .FormDict import FormDict, config_to_formdict, dict_to_formdict, formdict_to_widgetdict
 from .auxiliary import recursive_set_focus, flatten
 from .Redirectable import RedirectTextTkinter, Redirectable
 from .FormField import FormField
-from .Mininterface import Cancelled, ConfigInstance, Mininterface
+from .Mininterface import BackendAdaptor, Cancelled, EnvClass, Mininterface
 
 
 class GuiInterface(Redirectable, Mininterface):
@@ -35,28 +35,29 @@ class GuiInterface(Redirectable, Mininterface):
         self.window.buttons(text, [("Ok", None)])
 
     def ask(self, text: str) -> str:
-        return self.window.run_dialog({text: ""})[text]
+        return self.form({text: ""})[text]
 
-    def ask_args(self) -> ConfigInstance:
+    def ask_env(self) -> EnvClass:
         """ Display a window form with all parameters. """
-        formDict = config_to_formdict(self.args, self.descriptions)
+        formDict = config_to_formdict(self.env, self.descriptions)
 
-        # formDict automatically fetches the edited values back to the ConfigInstance
+        # formDict automatically fetches the edited values back to the EnvInstance
         self.window.run_dialog(formDict)
-        return self.args
+        return self.env
 
     def form(self, form: FormDict, title: str = "") -> dict:
         """ Prompt the user to fill up whole form.
-            :param args: Dict of `{labels: default value}`. The form widget infers from the default value type.
+            :param form: 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")}
             :param title: Optional form title.
         """
-        return self.window.run_dialog(form, title=title)
+        self.window.run_dialog(dict_to_formdict(form), title=title)
+        return form
 
     def ask_number(self, text: str) -> int:
-        return self.window.run_dialog({text: 0})[text]
+        return self.form({text: 0})[text]
 
     def is_yes(self, text):
         return self.window.yes_no(text, False)
@@ -65,7 +66,7 @@ class GuiInterface(Redirectable, Mininterface):
         return self.window.yes_no(text, True)
 
 
-class TkWindow(Tk):
+class TkWindow(Tk, BackendAdaptor):
     """ An editing window. """
 
     def __init__(self, interface: GuiInterface):
@@ -85,6 +86,11 @@ class TkWindow(Tk):
         self.pending_buffer = []
         """ Text that has been written to the text widget but might not be yet seen by user. Because no mainloop was invoked. """
 
+    @staticmethod
+    def widgetize(ff: FormField) -> Value:
+        """ Wrap FormField to a textual widget. """
+        return Value(ff.val, ff.description)
+
     def run_dialog(self, formDict: FormDict, title: str = "") -> FormDict:
         """ Let the user edit the form_dict values in a GUI window.
         On abrupt window close, the program exits.
@@ -92,12 +98,11 @@ class TkWindow(Tk):
         if title:
             label = Label(self.frame, text=title)
             label.pack(pady=10)
-
         self.form = Form(self.frame,
-                         name_form="",
-                         form_dict=formDict,
-                         name_config="Ok",
-                         )
+                        name_form="",
+                        form_dict=formdict_to_widgetdict(formDict, self.widgetize),
+                        name_config="Ok",
+                        )
         self.form.pack()
 
         # Set the submit and exit options
@@ -123,9 +128,11 @@ class TkWindow(Tk):
         label = Label(self.frame, text=text)
         label.pack(pady=10)
 
-        for text, value in buttons:
+        for i, (text, value) in enumerate(buttons):
             button = Button(self.frame, text=text, command=lambda v=value: self._ok(v))
-            button.bind("<Return>", lambda _: button.invoke())
+            if i == focused-1:
+                b = button
+                button.bind("<Return>", lambda _: b.invoke())
             button.pack(side=LEFT, padx=10)
         self.frame.winfo_children()[focused].focus_set()
         return self.mainloop()

{mininterface-0.4.4rc3 → mininterface-0.5.0}/mininterface/Mininterface.py

@@ -9,7 +9,9 @@ from typing import Generic, Type
 import yaml
 from tyro.extras import get_parser
 
-from .FormDict import ConfigClass, ConfigInstance, FormDict, get_args_allow_missing
+
+from .FormField import FormField
+from .FormDict import EnvClass, FormDict, get_env_allow_missing
 from .auxiliary import get_descriptions
 
 logger = logging.getLogger(__name__)
@@ -20,18 +22,25 @@ class Cancelled(SystemExit):
     pass
 
 
-class Mininterface(Generic[ConfigInstance]):
+class Mininterface(Generic[EnvClass]):
     """ The base interface.
         Does not require any user input and hence is suitable for headless testing.
     """
 
-    def __init__(self, title: str = ""):
+    def __init__(self, title: str = "",
+                 env_class: Type[EnvClass] | None = None,
+                 config_file: Path | str = "",
+                 **kwargs):
         self.title = title or "Mininterface"
-        self.args: ConfigInstance = SimpleNamespace()
-        """ Parsed arguments, fetched from cli by parse.args """
+        self.env: EnvClass = SimpleNamespace()
+        """ Parsed arguments, fetched from cli by self.parse_env """
         self.descriptions = {}
         """ Field descriptions """
 
+        # Load configuration from CLI and a config file
+        if env_class:
+            self._parse_env(env_class, config_file, **kwargs)
+
     def __enter__(self) -> "Mininterface":
         """ When used in the with statement, the GUI window does not vanish between dialogs
             and it redirects the stdout to a text area. """
@@ -50,40 +59,40 @@ class Mininterface(Generic[ConfigInstance]):
         print("Asking", text)
         raise Cancelled(".. cancelled")
 
-    def ask_args(self) -> ConfigInstance:
-        """ Allow the user to edit whole configuration. (Previously fetched from CLI and config file by parse_args.) """
-        print("Asking the args", self.args)
-        return self.args
+    def ask_env(self) -> EnvClass:
+        """ Allow the user to edit whole configuration. (Previously fetched from CLI and config file by parse_env.) """
+        print("Asking the env", self.env)
+        return self.env
 
     def ask_number(self, text: str) -> int:
         """ Prompt the user to input a number. Empty input = 0. """
         print("Asking number", text)
         return 0
 
-    def form(self, data: FormDict, title: str = "") -> dict:
+    def form(self, form: FormDict, title: str = "") -> dict:
         """ Prompt the user to fill up whole form.
-            :param args: Dict of `{labels: default value}`. The form widget infers from the default value type.
+            :param data: 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")}`
         """
-        print(f"Asking the form {title}", data)
-        return data  # NOTE – this should return dict, not FormDict (get rid of auxiliary.FormField values)
+        print(f"Asking the form {title}", form)
+        return form  # NOTE – this should return dict, not FormDict (get rid of auxiliary.FormField values)
 
-    def get_args(self, 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. """
+    def get_env(self, ask_on_empty_cli=True) -> EnvClass:
+        """ Returns whole configuration (previously fetched from CLI and config file by parse_env).
+            If program was launched with no arguments (empty CLI), invokes self.ask_env() to edit the fields. """
         # Empty CLI → GUI edit
         if ask_on_empty_cli and len(sys.argv) <= 1:
-            return self.ask_args()
-        return self.args
+            return self.ask_env()
+        return self.env
 
-    def parse_args(self, config: Type[ConfigInstance],
+    def _parse_env(self, env_class: Type[EnvClass],
                    config_file: Path | None = None,
-                   **kwargs) -> ConfigInstance:
+                   **kwargs) -> EnvClass:
         """ Parse CLI arguments, possibly merged from a config file.
 
-        :param config: Class with the configuration.
+        :param env_class: Class with the configuration.
         :param config_file: File to load YAML to be merged with the configuration.
             You do not have to re-define all the settings in the config file, you can choose a few.
         :param **kwargs The same as for argparse.ArgumentParser.
@@ -94,20 +103,20 @@ class Mininterface(Generic[ConfigInstance]):
             disk = yaml.safe_load(config_file.read_text()) or {}  # empty file is ok
             # Nested dataclasses have to be properly initialized. YAML gave them as dicts only.
             for key in (key for key, val in disk.items() if isinstance(val, dict)):
-                disk[key] = config.__annotations__[key](**disk[key])
+                disk[key] = env_class.__annotations__[key](**disk[key])
             # To ensure the configuration file does not need to contain all keys, we have to fill in the missing ones.
             # Otherwise, tyro will spawn warnings about missing fields.
-            static = {key: getattr(config, key, MISSING)
-                      for key in config.__annotations__ if not key.startswith("__") and not key in disk}
+            static = {key: getattr(env_class, key, MISSING)
+                      for key in env_class.__annotations__ if not key.startswith("__") and not key in disk}
             kwargs["default"] = SimpleNamespace(**(disk | static))
 
         # Load configuration from CLI
-        parser: ArgumentParser = get_parser(config, **kwargs)
+        parser: ArgumentParser = get_parser(env_class, **kwargs)
         self.descriptions = get_descriptions(parser)
-        # Why `or self.args`? If Config is not a dataclass but a function, it has no attributes.
-        # Still, we want to prevent error raised in `ask_args()` if self.args would have been set to None.
-        self.args = get_args_allow_missing(config, kwargs, parser) or self.args
-        return self.args
+        # Why `or self.env`? If Env is not a dataclass but a function, it has no attributes.
+        # Still, we want to prevent error raised in `ask_env()` if self.env would have been set to None.
+        self.env = get_env_allow_missing(env_class, kwargs, parser) or self.env
+        return self.env
 
     def is_yes(self, text: str) -> bool:
         """ Display confirm box, focusing yes. """
@@ -118,3 +127,18 @@ class Mininterface(Generic[ConfigInstance]):
         """ Display confirm box, focusing no. """
         print("Asking no:", text)
         return False
+
+
+from abc import ABC, abstractmethod
+class BackendAdaptor(ABC):
+
+    @staticmethod
+    @abstractmethod
+    def widgetize(ff: FormField):
+        """ Wrap FormField to a textual widget. """
+        pass
+
+    @abstractmethod
+    def run_dialog(self, formDict: FormDict, title: str = "") -> FormDict:
+        """ Let the user edit the dict values. """
+        pass

{mininterface-0.4.4rc3 → mininterface-0.5.0}/mininterface/Redirectable.py

@@ -52,7 +52,7 @@ class Redirectable:
     # NOTE When used in the with statement, the TUI window should not vanish between dialogues.
     # The same way the GUI does not vanish.
     # NOTE: Current implementation will show only after a dialog submit, not continuously.
-    # # with run(Config) as m:
+    # # with run(Env) as m:
     #     print("First")
     #     sleep(1)
     #     print("Second")

{mininterface-0.4.4rc3 → mininterface-0.5.0}/mininterface/TextInterface.py

@@ -1,6 +1,6 @@
 from pprint import pprint
 
-from .FormDict import ConfigInstance, FormDict
+from .FormDict import EnvClass, FormDict
 from .Mininterface import Cancelled, Mininterface
 
 
@@ -20,13 +20,13 @@ class TextInterface(Mininterface):
             raise Cancelled(".. cancelled")
         return txt
 
-    def ask_args(self) -> ConfigInstance:
+    def ask_env(self) -> EnvClass:
         # NOTE: This is minimal implementation that should rather go the ReplInterface.
         # I might build some menu of changing dict through:
-        #   params_ = dataclass_to_dict(self.args, self.descriptions)
+        #   params_ = dataclass_to_dict(self.env, self.descriptions)
         #   data = FormDict → dict self.window.run_dialog(params_)
-        #   dict_to_dataclass(self.args, params_)
-        return self.form(self.args)
+        #   dict_to_dataclass(self.env, params_)
+        return self.form(self.env)
 
     def form(self, form: FormDict) -> dict:
         # NOTE: This is minimal implementation that should rather go the ReplInterface.

{mininterface-0.4.4rc3 → mininterface-0.5.0}/mininterface/TextualInterface.py

@@ -13,16 +13,13 @@ except ImportError:
     raise InterfaceNotAvailable
 
 from .auxiliary import flatten
-from .FormDict import (ConfigInstance, FormDict, config_to_formdict,
-                       dict_to_formdict)
+from .FormDict import (EnvClass, FormDict, config_to_formdict,
+                       dict_to_formdict, formdict_to_widgetdict)
 from .FormField import FormField
-from .Mininterface import Cancelled
+from .Mininterface import BackendAdaptor, Cancelled
 from .Redirectable import Redirectable
 from .TextInterface import TextInterface
 
-# TODO with statement hello world example image is wrong (Textual already redirects the output as GuiInterface does)
-
-
 @dataclass
 class DummyWrapper:
     """ Value wrapped, since I do not know how to get it from textual app.
@@ -39,19 +36,23 @@ class TextualInterface(Redirectable, TextInterface):
     def ask(self, text: str = None):
         return self.form({text: ""})[text]
 
-    def ask_args(self) -> ConfigInstance:
+    def ask_env(self) -> EnvClass:
         """ Display a window form with all parameters. """
-        params_ = config_to_formdict(self.args, self.descriptions)
+        params_ = config_to_formdict(self.env, self.descriptions)
 
         # fetch the dict of dicts values from the form back to the namespace of the dataclasses
-        TextualApp.run_dialog(TextualApp(), params_)
-        return self.args
+        TextualApp.run_dialog(TextualApp(self), params_)
+        return self.env
 
+    # NOTE: This works bad with lists. GuiInterface considers list as combobox,
+    # TextualInterface as str. We should decide what should happen. Is there a tyro default for list?
     def form(self, form: FormDict, title: str = "") -> dict:
-        return TextualApp.run_dialog(TextualApp(), dict_to_formdict(form), title)
+        TextualApp.run_dialog(TextualApp(self), dict_to_formdict(form), title)
+        return form
 
     # NOTE we should implement better, now the user does not know it needs an int
-    # def ask_number(self, text):
+    def ask_number(self, text):
+        return self.form({text: FormField("", "", int, text)})[text].processed_value
 
     def is_yes(self, text):
         return TextualButtonApp(self).yes_no(text, False).val
@@ -60,6 +61,7 @@ class TextualInterface(Redirectable, TextInterface):
         return TextualButtonApp(self).yes_no(text, True).val
 
 
+# NOTE: For a metaclass conflict I was not able to inherit from BackendAdaptor
 class TextualApp(App[bool | None]):
 
     BINDINGS = [
@@ -82,11 +84,11 @@ class TextualApp(App[bool | None]):
         self.interface = interface
 
     @staticmethod
-    def get_widget(ff: FormField) -> Checkbox | Input:
+    def widgetize(ff: FormField) -> Checkbox | Input:
         """ Wrap FormField to a textual widget. """
 
-        if ff.annotation is bool or not ff.annotation and ff.val in [True, False]:
-            o = Checkbox(ff.name, ff.val)
+        if ff.annotation is bool or not ff.annotation and (ff.val is True or ff.val is False):
+            o = Checkbox(ff.name or "", ff.val)
         else:
             o = Input(str(ff.val), placeholder=ff.name or "")
         o._link = ff  # The Textual widgets need to get back to this value
@@ -99,7 +101,8 @@ class TextualApp(App[bool | None]):
             window.title = title
 
         # NOTE Sections (~ nested dicts) are not implemented, they flatten
-        widgets: list[Checkbox | Input] = [cls.get_widget(f) for f in flatten(formDict)]
+        # Maybe just 'flatten' might be removed.
+        widgets: list[Checkbox | Input] = [f for f in flatten(formdict_to_widgetdict(formDict, cls.widgetize))]
         window.widgets = widgets
 
         if not window.run():
@@ -107,7 +110,7 @@ class TextualApp(App[bool | None]):
 
         # validate and store the UI value → FormField value → original value
         if not FormField.submit_values((field._link, field.value) for field in widgets):
-            return cls.run_dialog(TextualApp(), formDict, title)
+            return cls.run_dialog(TextualApp(window.interface), formDict, title)
         return formDict
 
     def compose(self) -> ComposeResult:

{mininterface-0.4.4rc3 → mininterface-0.5.0}/mininterface/__init__.py

@@ -4,7 +4,7 @@ from typing import TYPE_CHECKING, Type
 from unittest.mock import patch
 
 
-from .Mininterface import ConfigInstance, Mininterface
+from .Mininterface import EnvClass, Mininterface
 from .TextInterface import ReplInterface, TextInterface
 from .FormField import FormField
 from .common import InterfaceNotAvailable
@@ -30,9 +30,10 @@ class TuiInterface(TextualInterface or TextInterface):
     pass
 
 
-def run(config: Type[ConfigInstance] | None = None,
+def run(env_class: Type[EnvClass] | None = None,
         interface: Type[Mininterface] = GuiInterface or TuiInterface,
-        **kwargs) -> Mininterface[ConfigInstance]:
+        config_file: Path|str = "",
+        **kwargs) -> Mininterface[EnvClass]:
     """
     Main access.
     Wrap your configuration dataclass into `run` to access the interface. An interface is chosen automatically,
@@ -48,37 +49,47 @@ def run(config: Type[ConfigInstance] | None = None,
     :return: Interface used.
 
     Undocumented: The `config` may be function as well. We invoke its parameters.
-    However, as Mininterface.args stores the output of the function instead of the Argparse namespace,
-    methods like `Mininterface.ask_args()` will work unpredictibly.
+    However, as Mininterface.env stores the output of the function instead of the Argparse namespace,
+    methods like `Mininterface.ask_env()` will work unpredictibly.
     Also, the config file seems to be fetched only for positional (missing) parameters,
     and ignored for keyword (filled) parameters.
     It seems to be this is the tyro's deal and hence it might start working any time.
     If not, we might help it this way:
         `if isinstance(config, FunctionType): config = lambda: config(**kwargs["default"])`
     """
+
+    # Prepare the config file
+    if not config_file and not kwargs.get("default") and env_class:
+        cf = Path(sys.argv[0]).with_suffix(".yaml")
+        if cf.exists():
+            config_file = cf
+
+
     # Build the interface
-    prog = kwargs.get("prog") or sys.argv[0]
+    prog = kwargs.get("prog") or Path(sys.argv[0]).name
     try:
-        interface = interface(prog)
+        interface = interface(prog, env_class, config_file, **kwargs)
     except InterfaceNotAvailable:  # Fallback to a different interface
-        interface = TuiInterface(prog)
+        interface = TuiInterface(prog, env_class, config_file, **kwargs)
 
     # Load configuration from CLI and a config file
-    if config:
-        cf = Path(sys.argv[0]).with_suffix(".yaml")
-        interface.parse_args(config, cf if cf.exists() and not kwargs.get("default") else None, **kwargs)
+    # if env_class:
+    #     cf = Path(sys.argv[0]).with_suffix(".yaml")
+    #     interface._parse_env(env_class, cf if cf.exists() and not kwargs.get("default") else None, **kwargs)
 
     # NOTE draft – move the functionality inside Mininterface?
     # What will be the most used params?
-    # run(config: Type[ConfigInstance],
+    # run(config: Type[EnvInstance],
     #     prog="merge to kwargs later",
     #     config_file:Path|str="",
     #     interface: Type[Mininterface] = GuiInterface or TuiInterface,
     #     **kwargs)
     # title = prog or sys.argv
-    # Mininterface(title, configClass, configFile, **kwargs)
+    # Mininterface(title, env_class, config_file, **kwargs)
 
     return interface
 
 
-__all__ = ["run", "FormField"]
+__all__ = ["run", "FormField", "InterfaceNotAvailable",
+           "Mininterface", "GuiInterface", "TuiInterface", "TextInterface", "TextualInterface"
+           ]

{mininterface-0.4.4rc3 → mininterface-0.5.0}/mininterface/__main__.py

@@ -13,9 +13,9 @@ class CliInteface:
     ask_number: str = ""
     """ Prompt the user to input a number. Empty input = 0. """
     is_yes: str = ""
-    """ Display confirm box, focusing yes. """
+    """ Display confirm box, focusing 'yes'. """
     is_no: str = ""
-    """ Display confirm box, focusing no. """
+    """ Display confirm box, focusing 'no'. """
 
 # TODO does not work in REPL interface: mininterface --alert hello
 def main():
@@ -23,7 +23,7 @@ def main():
     # TODO It DOES make sense. Change in README. It s a good fallback.
     result = []
     with run(CliInteface, prog="Mininterface", description=__doc__) as m:
-        for method, label in vars(m.args).items():
+        for method, label in vars(m.env).items():
             if label:
                 result.append(getattr(m, method)(label))
     # Displays each result on a new line. Currently, this is an undocumented feature.

{mininterface-0.4.4rc3 → mininterface-0.5.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "mininterface"
-version = "0.4.4rc3"
+version = "0.5.0"
 description = "A minimal access to GUI, TUI, CLI and config"
 authors = ["Edvard Rejthar <edvard.rejthar@nic.cz>"]
 license = "GPL-3.0-or-later"