mininterface 1.1.2__tar.gz → 1.1.4__tar.gz

{mininterface-1.1.2 → mininterface-1.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mininterface
-Version: 1.1.2
+Version: 1.1.4
 Summary: A minimal access to GUI, TUI, CLI and config
 License: LGPL-3.0-or-later
 License-File: LICENSE
@@ -131,6 +131,8 @@ with run(Env) as m:
 
 Wrapper between various libraries that provide a user interface.
 
+It allows you to focus on writing the program's core logic without worrying about input/output. It generates CLI arguments, parses config file, and shows a UI. Depending on the endpoint, the dialogs automatically use either a GUI, a mouse-clickable TUI, a lightweight terminal text interface, or be available via HTTP — all while maintaining exactly the same functionality.
+
 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:
@@ -338,3 +340,4 @@ If you're sure enough to start using *Mininterface*, convert the argparse into a
 
 !!! warning
     The argparse support is considered mostly for your evaluation as there are some [`differences`](Argparse-caveats.md) for advanced argparse CLI interfaces.
+

{mininterface-1.1.2 → mininterface-1.1.4}/README.md

@@ -91,6 +91,8 @@ with run(Env) as m:
 
 Wrapper between various libraries that provide a user interface.
 
+It allows you to focus on writing the program's core logic without worrying about input/output. It generates CLI arguments, parses config file, and shows a UI. Depending on the endpoint, the dialogs automatically use either a GUI, a mouse-clickable TUI, a lightweight terminal text interface, or be available via HTTP — all while maintaining exactly the same functionality.
+
 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:
@@ -297,4 +299,4 @@ print(m.env.time)  # -> 14:21
 If you're sure enough to start using *Mininterface*, convert the argparse into a dataclass. Then, the IDE will auto-complete the hints as you type.
 
 !!! warning
-    The argparse support is considered mostly for your evaluation as there are some [`differences`](Argparse-caveats.md) for advanced argparse CLI interfaces.
+    The argparse support is considered mostly for your evaluation as there are some [`differences`](Argparse-caveats.md) for advanced argparse CLI interfaces.

{mininterface-1.1.2 → mininterface-1.1.4}/mininterface/_lib/cli_parser.py

@@ -2,16 +2,17 @@
 # CLI and config file parsing.
 #
 from dataclasses import asdict
+from functools import reduce
 import sys
 from collections import deque
 from contextlib import ExitStack
-from typing import Optional, Sequence, Type, Union
+from typing import Annotated, Optional, Sequence, Type, Union
 from unittest.mock import patch
 
-
 from .cli_flags import CliFlags
 
 from ..cli import Command
+from ..settings import CliSettings
 
 from ..exceptions import Cancelled
 from .auxiliary import (
@@ -33,6 +34,7 @@ try:
     from tyro._argparse import _SubParsersAction, ArgumentParser
     from tyro._argparse_formatter import TyroArgumentParser
     from tyro._singleton import MISSING_NONPROP
+    from tyro.conf import OmitArgPrefixes, OmitSubcommandPrefixes, DisallowNone, FlagCreatePairsOff
 
     from .tyro_patches import (
         _crawling,
@@ -75,6 +77,7 @@ def parse_cli(
     ask_for_missing: bool = True,
     args: Optional[Sequence[str]] = None,
     ask_on_empty_cli: Optional[bool] = None,
+    cli_settings: Optional[CliSettings] = None,
     _crawled=None,
     _req_fields=None,
 ) -> tuple[EnvClass, bool]:
@@ -118,18 +121,43 @@ def parse_cli(
     # Special CLI parsing
     if sys.modules.get("mininterface.tag.flag") is not None:
         from ..tag.flag import _custom_registry
-    else: # run only if the user imported the flags. (Untested) performance reasons.
+    else:  # run only if the user imported the flags. (Untested) performance reasons.
         _custom_registry = None
 
+    annotations = None
+    if cli_settings:
+        annotations = [
+            cls
+            for cond, cls in (
+                (cli_settings.omit_arg_prefixes, OmitArgPrefixes),
+                (cli_settings.omit_subcommand_prefixes, OmitSubcommandPrefixes),
+                (cli_settings.disallow_none, DisallowNone),
+                (cli_settings.flag_create_pairs_off, FlagCreatePairsOff),
+            )
+            if cond
+        ]
+
+    def annot(type_form):
+        if annotations:
+            if sys.version_info >= (3, 11):
+                from .future_compatibility import spread_annotated
+
+                return spread_annotated(type_form, annotations)
+            else:
+                from warnings import warn
+
+                warn(f"Cannot apply {annotations} on Python <= 3.11.")
+        return type_form
+
     try:
         with ExitStack() as stack:
             [stack.enter_context(p) for p in patches]  # apply just the chosen mocks
             try:
-                env = cli(type_form, args=args, registry=_custom_registry, **kwargs)
+                env = cli(annot(type_form), args=args, registry=_custom_registry, **kwargs)
             except BaseException:
                 # Why this exception handling? Try putting this out and test_strange_error_mitigation fails.
                 if len(env_classes) > 1 and kwargs.get("default"):
-                    env = cli(kwargs["default"].__class__, args=args[1:], registry=_custom_registry, **kwargs)
+                    env = cli(annot(kwargs["default"].__class__), args=args[1:], registry=_custom_registry, **kwargs)
                 else:
                     raise
             # Why setting m.env instead of putting into into a constructor of a new get_interface() call?
@@ -144,7 +172,9 @@ def parse_cli(
             m.env = env
     except BaseException as exception:
         if ask_for_missing and getattr(exception, "code", None) == 2 and failed_fields.get():
-            env = _dialog_missing(env_classes, kwargs, m, cf, ask_for_missing, args, _crawled, _req_fields)
+            env = _dialog_missing(
+                env_classes, kwargs, m, cf, ask_for_missing, args, cli_settings, _crawled, _req_fields
+            )
 
             if final_call:
                 # Ask for the wrong fields
@@ -240,6 +270,7 @@ def _dialog_missing(
     cf: Optional[CliFlags],
     ask_for_missing: bool,
     args: Optional[Sequence[str]],
+    cli_settings,
     crawled,
     req_fields: Optional[TagDict],
 ) -> EnvClass:
@@ -301,7 +332,7 @@ def _dialog_missing(
     # We have just put a default values for missing fields so that tyro will not fail.
     # If we succeeded (no exotic case), this will pass through.
     # Then, we impose the user to fill the missing values.
-    env, _ = parse_cli(env_classes, kwargs, m, cf, ask_for_missing, args, None, crawled, req_fields)
+    env, _ = parse_cli(env_classes, kwargs, m, cf, ask_for_missing, args, None, cli_settings, crawled, req_fields)
     td = dataclass_to_tagdict(env, m)
     # Remove teporary defaults to be correctly displayed in the dialog form
     # so that user must fill them.
@@ -345,7 +376,9 @@ def _fetch_currently_failed(requireds) -> TagDict:
             # Here, we pick the field unknown to the CLI parser too.
             # As whole subparser was unknown here, we safely consider all its fields wrong fields.
             if fname:
-                get_or_create_parent_dict(missing_req, fname, True)[fname_raw] = get_or_create_parent_dict(requireds, fname)
+                get_or_create_parent_dict(missing_req, fname, True)[fname_raw] = get_or_create_parent_dict(
+                    requireds, fname
+                )
             else:
                 # This is the default subparser, without a field name:
                 # ex. `run([List, Run])`

{mininterface-1.1.2 → mininterface-1.1.4}/mininterface/_lib/config_file.py

@@ -18,21 +18,19 @@ except ImportError:
 def parse_config_file(
     env_or_list: Type[EnvClass] | list[Type[EnvClass]],
     config_file: Path | None = None,
-    settings: Optional[MininterfaceSettings] = None,
     **kwargs,
-) -> tuple[dict, MininterfaceSettings | None]:
+) -> tuple[dict, dict | None]:
     """Fetches the config file into the program defaults kwargs["default"] and UI settings.
 
     Args:
         env_class: Class 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 in the config file, you can choose a few.
-        settings: Used to complement the 'mininterface' config file section-
     Kwargs:
         The same as for argparse.ArgumentParser.
 
     Returns:
-        Tuple of kwargs and settings.
+        Tuple of kwargs and dict (section 'mininterface' in the config file).
     """
     if isinstance(env_or_list, list):
         subcommands, env = env_or_list, None
@@ -50,23 +48,21 @@ def parse_config_file(
             " Describe the developer your usecase so that they might implement this."
         )
 
+    confopt = None
     if "default" not in kwargs and not subcommands and config_file:
         # Undocumented feature. User put a namespace into kwargs["default"]
         # that already serves for defaults. We do not fetch defaults yet from a config file.
         disk = yaml.safe_load(config_file.read_text()) or {}  # empty file is ok
         try:
-            if confopt := disk.pop("mininterface", None):
-                # Section 'mininterface' in the config file.
-                settings = _merge_settings(settings, confopt)
-
+            confopt = disk.pop("mininterface", None)
             kwargs["default"] = create_with_missing(env, disk)
         except TypeError:
             raise SyntaxError(f"Config file parsing failed for {config_file}")
 
-    return kwargs, settings
+    return kwargs, confopt
 
 
-def _merge_settings(
+def ensure_settings_inheritance(
     runopt: MininterfaceSettings | None, confopt: dict, _def_fact=MininterfaceSettings
 ) -> MininterfaceSettings:
     # Settings inheritance:

{mininterface-1.1.2 → mininterface-1.1.4}/mininterface/_lib/dataclass_creation.py

@@ -237,8 +237,11 @@ def _process_field(fname, ftype, disk_value, wf, m, default_value=MISSING):
 
     # the subcommand has been already chosen by CLI parser
     if isinstance(disk_value, ChosenSubcommand):  # `(class Message | class Console)`
+        # there might be a subcommand prefix, ex. 'val:message' -> 'message'
+        name = disk_value.name.partition(":")[2] or disk_value.name
+
         for _subcomm in get_args(_unwrap_annotated(ftype)):
-            if disk_value.name == to_kebab_case(_subcomm.__name__):
+            if name == to_kebab_case(_subcomm.__name__):
                 ftype = _subcomm  # `class Message` only
                 disk_value = disk_value.subdict
                 break

mininterface-1.1.4/mininterface/_lib/future_compatibility.py

@@ -0,0 +1,9 @@
+
+from typing import Annotated, Literal
+
+
+def literal(c):
+    return Literal[*c]
+
+def spread_annotated(obj, annotations):
+    return Annotated[obj, *annotations]

{mininterface-1.1.2 → mininterface-1.1.4}/mininterface/_lib/run.py

@@ -5,10 +5,11 @@ from os import environ
 from pathlib import Path
 from typing import Literal, Optional, Sequence, Type
 
+
 from .._mininterface import Mininterface
 from ..exceptions import DependencyRequired, ValidationFail
 from ..interfaces import get_interface
-from ..settings import MininterfaceSettings
+from ..settings import CliSettings, MininterfaceSettings, UiSettings
 from .form_dict import EnvClass
 
 try:
@@ -16,11 +17,11 @@ try:
     from .argparse_support import parser_to_dataclass
     from .cli_flags import CliFlags as _CliFlags
     from .cli_parser import assure_args, parse_cli
-    from .config_file import parse_config_file
+    from .config_file import parse_config_file, ensure_settings_inheritance
     from .dataclass_creation import choose_subcommand, to_kebab_case
     from .start import Start
 except DependencyRequired as e:
-    assure_args, parse_cli, parse_config_file, parser_to_dataclass = (e,) * 4
+    assure_args, parse_cli, parse_config_file, ensure_settings_inheritance, parser_to_dataclass = (e,) * 5
     Start, SubcommandPlaceholder = (e,) * 2
     to_kebab_case, choose_subcommand, _CliFlags = (e,) * 3
 
@@ -40,7 +41,7 @@ def run(
     # We do not use InterfaceType as a type here because we want the documentation to show full alias:
     interface: Type[Mininterface] | Literal["gui"] | Literal["tui"] | Literal["text"] | Literal["web"] | None = None,
     args: Optional[Sequence[str]] = None,
-    settings: Optional[MininterfaceSettings] = None,
+    settings: Optional[MininterfaceSettings | UiSettings | CliSettings] = None,
     **kwargs,
 ) -> Mininterface[EnvClass]:
     """The main access, start here.
@@ -192,7 +193,7 @@ def run(
             see the full [list](Interfaces.md) of possible interfaces.
             If not set, we look also for an environment variable [`MININTERFACE_INTERFACE`](Interfaces.md#environment-variable-mininterface_interface) and in the config file.
         args: Parse arguments from a sequence instead of the command line.
-        settings: Default settings. These might be further modified by the 'mininterface' section in the config file.
+        settings: Default settings. These might be further modified by the 'mininterface' section in the config file. See the [Settings](Settings.md) section.
     Kwargs:
         The same as for [argparse.ArgumentParser](https://docs.python.org/3/library/argparse.html).
 
@@ -275,8 +276,22 @@ def run(
     if isinstance(env_or_list, ArgumentParser):
         env_or_list, add_version = parser_to_dataclass(env_or_list)
 
-    # Parse CLI arguments, possibly merged from a config file.
-    # A) Superform – overview of the subcommands
+    # Parse config file
+    kwargs, settings_conf = parse_config_file(env_or_list or _Empty, config_file, **kwargs)
+
+    # Ensure settings inheritance
+    if isinstance(settings, CliSettings):
+        settings = MininterfaceSettings(cli=settings)
+    elif isinstance(settings, UiSettings):
+        # Ex. `settings=GuiSettings(...)` -> `settings=MininterfaceSettings(gui=GuiSettings(...)`
+        attr_name = settings.__class__.__name__.removesuffix("Settings").lower()
+        settings = MininterfaceSettings(**{attr_name: settings})
+    if settings or settings_conf:
+        # previous settings are used to complement the 'mininterface' config file section
+        settings = ensure_settings_inheritance(settings, settings_conf or {})
+    cliset = settings.cli if settings else CliSettings()
+
+    # Choose an interface
     m = get_interface(interface, title, settings)
 
     # Resolve SubcommandPlaceholder
@@ -290,17 +305,14 @@ def run(
     ):
         args[0] = to_kebab_case(choose_subcommand(env_or_list, m).__name__)
 
-    # B) A single Env object, or a list of such objects (with one is being selected via args)
-    # C) No Env object
-
-    kwargs, settings = parse_config_file(env_or_list or _Empty, config_file, settings, **kwargs)
+    # Parse CLI arguments, possibly merged from a config file.
     cf = _CliFlags(add_verbose, add_version, add_version_package, add_quiet)
     if env_or_list:
-        # B) single Env object
+        # A single Env object, or a list of such objects (with one is not/being selected via args)
         # Load configuration from CLI and a config file
         try:
             parse_cli(
-                env_or_list, kwargs, m, cf, ask_for_missing, args, ask_on_empty_cli
+                env_or_list, kwargs, m, cf, ask_for_missing, args, ask_on_empty_cli, cliset
             )
         except Exception as e:
             # Undocumented MININTERFACE_DEBUG flag. Note ipdb package requirement.
@@ -321,7 +333,7 @@ def run(
     else:
         # C) No Env object
         # even though there is no configuration, yet we need to parse CLI for meta-commands like --help or --verbose
-        parse_cli(_Empty, {}, m, cf, ask_for_missing, args)
+        parse_cli(_Empty, {}, m, cf, ask_for_missing, args, None, cliset)
 
     return m
 

{mininterface-1.1.2 → mininterface-1.1.4}/mininterface/_lib/start.py

@@ -1,23 +1,23 @@
 # Starting and maintaining a program, using mininterface, in the system.
 import sys
-from collections import defaultdict
-from dataclasses import is_dataclass
+# from collections import defaultdict
+# from dataclasses import is_dataclass
 from pathlib import Path
 from subprocess import run
 from typing import Optional, Type
-from warnings import warn
+# from warnings import warn
 
 from .._mininterface import Mininterface
-from ..cli import Command, SubcommandPlaceholder
-from ..exceptions import DependencyRequired
+# from ..cli import Command, SubcommandPlaceholder
+# from ..exceptions import DependencyRequired
 from ..interfaces import get_interface
-from ..tag import Tag
-from .form_dict import DataClass, EnvClass, TagDict, dataclass_to_tagdict
+# from ..tag import Tag
+# from .form_dict import DataClass, EnvClass, TagDict, dataclass_to_tagdict
 
-try:
-    from .cli_parser import parse_cli
-except DependencyRequired as e:
-    parse_cli = e
+# try:
+#     from .cli_parser import parse_cli
+# except DependencyRequired as e:
+#     parse_cli = e
 
 
 class Start:

{mininterface-1.1.2 → mininterface-1.1.4}/mininterface/_mininterface/__init__.py

@@ -90,7 +90,8 @@ class Mininterface(Generic[EnvClass]):
         # NOTE docs that
         # m = run([Env, Env2]) -> .env will be the chosen one.
 
-        self._adaptor = self.__annotations__["_adaptor"](self, settings)
+        # NOTE In Python3.14, type(self).__annotations__ will work.
+        self._adaptor = type(self).__annotations__["_adaptor"](self, settings)
 
     def __enter__(self) -> "Self":
         """Usage within the with statement makes the program to attempt for the following benefits:

{mininterface-1.1.2 → mininterface-1.1.4}/mininterface/_mininterface/adaptor.py

@@ -26,8 +26,16 @@ class BackendAdaptor(ABC):
 
     def __init__(self, interface: "Mininterface", settings: UiSettings | None):
         self.interface = interface
-        self.facet = interface.facet = self.__annotations__["facet"](self, interface.env)
-        self.settings = settings or self.__annotations__["settings"]()
+
+        # Why looping mro? Since 3.14, ex. MockAdaptor does not inherit .facet annotation from MinAdaptor.
+        for cl in type(self).__mro__:
+            try:
+                self.facet = interface.facet = cl.__annotations__["facet"](self, interface.env)
+                self.settings = settings or cl.__annotations__["settings"]()
+            except KeyError:
+                pass
+            else:
+                break
 
     @abstractmethod
     def widgetize(self, tag: Tag):

{mininterface-1.1.2 → mininterface-1.1.4}/mininterface/_text_interface/timeout.py

@@ -60,6 +60,8 @@ def input_timeout(prompt: str, timeout: int = 0, exit_on_keypress: bool = False)
                         return "".join(inp)
                     elif char == '\x03':  # Ctrl+C
                         raise Cancelled
+                    elif char == '\x1b':  # Escape
+                        raise Cancelled
                     elif char == '\x08':  # Backspace
                         if inp:
                             inp.pop()
@@ -74,7 +76,6 @@ def input_timeout(prompt: str, timeout: int = 0, exit_on_keypress: bool = False)
                         print()  # newline immediately
                         return "".join(inp)
 
-                # Stop if timeout exceeded and input not started
                 if timeout_running and (time.time() - start_time >= timeout) and not input_started.is_set():
                     input_started.set()
                     print()
@@ -93,7 +94,9 @@ def input_timeout(prompt: str, timeout: int = 0, exit_on_keypress: bool = False)
                         if char == '\n':
                             print()  # newline at Enter
                             return "".join(inp)
-                        elif char == '\x03':
+                        elif char == '\x03':  # Ctrl+C
+                            raise Cancelled
+                        elif char == '\x1b':  # Escape
                             raise Cancelled
                         elif char == '\x7f':  # Backspace
                             if inp:
@@ -109,13 +112,13 @@ def input_timeout(prompt: str, timeout: int = 0, exit_on_keypress: bool = False)
                             print()  # newline immediately
                             return "".join(inp)
 
-                    # Stop if timeout exceeded and input not started
                     if timeout_running and (time.time() - start_time >= timeout) and not input_started.is_set():
                         input_started.set()
                         print()
                         return ""
             finally:
                 termios.tcsetattr(fd, termios.TCSADRAIN, old_settings)
+
     except Exception:
         # Fallback to class input.
         # 'Press any key' will not work.

{mininterface-1.1.2 → mininterface-1.1.4}/mininterface/_textual_interface/timeout.py

@@ -16,7 +16,11 @@ class TextualTimeout(Timeout):
         self.button = button
         self.orig = self.button.label
         self._task = asyncio.create_task(self.countdown(timeout))
-        self.button.set_blur_callback(lambda event=None: self.cancel())
+
+        # Cancel countdown on focusing out
+        # Why checking .focused? If we jump to another app with Alt+Tab, we do not want the countdown to stop
+        # (in such cases, .focused is empty).
+        self.button.set_blur_callback(lambda event=None: self.cancel() if adaptor.app.focused else None)
 
     async def countdown(self, count: int):
         self.button.label = f"{self.orig} ({count})"

{mininterface-1.1.2 → mininterface-1.1.4}/mininterface/_tk_interface/timeout.py

@@ -18,7 +18,10 @@ class TkTimeout(Timeout):
 
         self.countdown(timeout)
 
-        self.button.bind("<FocusOut>", self.cancel)
+        # Cancel countdown on FocusOut
+        # Why checking .focus_get()? If we jump to another app with Alt+Tab, we do not want the countdown to stop
+        # (in such cases, .focus_get() is empty).
+        self.button.bind("<FocusOut>", lambda e: self.cancel() if e.widget.focus_get() else None)
 
     def countdown(self, count):
         try:

{mininterface-1.1.2 → mininterface-1.1.4}/mininterface/_tk_interface/utils.py

@@ -18,7 +18,7 @@ from ..tag.internal import CallbackButtonWidget, FacetButtonWidget, SubmitButton
 
 
 from .._lib.auxiliary import flatten
-from .._lib.form_dict import TagDict
+from .._lib.form_dict import TagDict, dict_removed_main
 
 from ..tag import Tag
 from ..tag.secret_tag import SecretTag
@@ -165,7 +165,8 @@ def replace_widgets(adaptor: "TkAdaptor", nested_widgets, form: TagDict):
         # Only prevent form submission, don't affect Tab navigation
         return None  # Allow event propagation for other handlers
 
-    for tag, field_form in zip(flatten(form), flatten(nested_widgets)):
+    fform = list(flatten(form))
+    for tag, field_form in zip(fform, flatten(nested_widgets)):
         tag: Tag
         field_form: FieldForm
         label1: Widget = field_form.label
@@ -193,7 +194,7 @@ def replace_widgets(adaptor: "TkAdaptor", nested_widgets, form: TagDict):
         match tag:
             case SelectTag():
                 grid_info = widget.grid_info()
-                wrapper = SelectInputWrapper(master, tag, grid_info, widget, adaptor, len(form) == 1)
+                wrapper = SelectInputWrapper(master, tag, grid_info, widget, adaptor, len(fform) == 1)
                 select_tag = True
                 variable = wrapper.variable_wrapper
                 # since tkinter variables do not allow objects,

{mininterface-1.1.2 → mininterface-1.1.4}/mininterface/interfaces.py

@@ -65,6 +65,11 @@ def _choose_settings(type_: Mininterface, settings: Optional[MininterfaceSetting
                 opt = settings.text
             case "WebInterface":
                 opt = settings.web
+            case "Mininterface":
+                # Even though this has not any sense to have some settings for Mininterface,
+                # they are not used, we test it in TestRun.test_settings_run.
+                # An according to MinAdaptor, it should have UiSettings.
+                opt = settings.ui
     return opt
 
 

{mininterface-1.1.2 → mininterface-1.1.4}/mininterface/settings.py

@@ -5,6 +5,117 @@ from typing import Literal, Optional
 # We do not use InterfaceType as a type in run because we want the documentation to show full alias.
 InterfaceName = Literal["gui"] | Literal["tui"] | Literal["textual"] | Literal["text"]
 
+@_dataclass
+class CliSettings:
+    omit_arg_prefixes: bool = False
+    """ Simplify argument names by removing parent field prefixes from flags.
+
+    ```bash
+    $ ./program.py --help
+    # omit_arg_prefixes = False
+    usage: program.py [-h] [-v] --arg.subarg.text STR
+    # omit_arg_prefixes = True
+    usage: program.py [-h] [-v] --text STR
+    ```
+
+    ??? Code
+        ```python
+        @dataclass
+        class SubMessage:
+            text: str
+
+        @dataclass
+        class Message:
+            subarg: SubMessage
+
+        @dataclass
+        class Env:
+            arg: Message
+
+        run(Env, settings=CliSettings(omit_arg_prefixes=True/False))
+        ```
+
+    See: [https://brentyi.github.io/tyro/api/tyro/conf/#tyro.conf.OmitArgPrefixes]()
+    """
+
+    omit_subcommand_prefixes: bool = False
+    """
+    Simplify subcommand names by removing parent field prefixes from subcommands.
+
+    ```bash
+    $ ./program.py --help
+    # omit_subcommand_prefixes = False
+    usage: program.py [-h] [-v] {subcommand:message,subcommand:console}
+    # omit_subcommand_prefixes = True
+    usage: program.py [-h] [-v] {message,console}
+    ```
+
+    ??? Code
+        ```python
+        @dataclass
+        class SubMessage:
+            text: str
+
+        @dataclass
+        class Message:
+            subarg: SubMessage
+
+        @dataclass
+        class Env:
+            subcommand: Message | Console
+
+        run(Env, settings=CliSettings(omit_subcommand_prefixes=True/False))
+        ```
+
+    See: [https://brentyi.github.io/tyro/api/tyro/conf/#tyro.conf.OmitSubcommandPrefixes]()
+    """
+
+    disallow_none: bool = False
+    """ Disallow passing None in via the command-line interface for union types containing None.
+
+    ```bash
+    $ ./program.py --help
+    # disallow_none = False
+    usage: program.py [-h] [-v] [--field {None}|INT]
+    # disallow_none = True
+    usage: program.py [-h] [-v] [--field INT]
+    ```
+
+    ??? Code
+        ```python
+        @dataclass
+        class Env:
+            field: int | None = None
+        run(Env, settings=CliSettings(disallow_none=True/False))
+        ```
+
+    See: [https://brentyi.github.io/tyro/api/tyro/conf/#tyro.conf.DisallowNone]()
+    """
+
+    flag_create_pairs_off: bool = False
+    """ Disable creation of matching flag pairs for boolean types.
+
+    ```bash
+    $ ./program.py --help
+    # flag_create_pairs_off = False
+    usage: program.py [-h] [-v] [--foo | --no-foo]
+    # flag_create_pairs_off = True
+    usage: program.py [-h] [-v] [--foo]
+    ```
+
+    ??? Code
+        ```python
+        @dataclass
+        class Env:
+            foo: bool = False
+        run(Env, settings=CliSettings(flag_create_pairs_off=True/False))
+        ```
+
+    See: [https://brentyi.github.io/tyro/api/tyro/conf/#tyro.conf.FlagCreatePairsOff]()
+    """
+
+
+
 @_dataclass
 class UiSettings:
     toggle_widget: str = "f4"
@@ -37,9 +148,19 @@ class UiSettings:
 class GuiSettings(UiSettings):
     # If multiple Gui interfaces exist, this had to be TkSettings instead.
 
-
     combobox_since: int = 10
-    """ The threshold to switch from radio buttons to a combobox. """
+    """ The threshold to switch from radio buttons to a combobox.
+
+    Without combobox:
+
+    ![Default](asset/configuration-not-used.avif)
+
+    With combobox:
+
+    ![Combobox](asset/configuration-used.avif)
+
+    (Note, there must be multiple fields for combobox to appear.)
+    """
 
     radio_select_on_focus: bool = False
     """ Select the radio button on focus. Ex. when navigating by arrows. """
@@ -122,5 +243,6 @@ class MininterfaceSettings:
     textual: TextualSettings = _field(default_factory=TextualSettings)
     text: TextSettings = _field(default_factory=TextSettings)
     web: WebSettings = _field(default_factory=WebSettings)
+    cli: CliSettings = _field(default_factory=CliSettings)
     interface: Optional[InterfaceName] = None
     """ Enforce an interface. By default, we choose automatically. """

{mininterface-1.1.2 → mininterface-1.1.4}/pyproject.toml

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

mininterface-1.1.2/mininterface/_lib/future_compatibility.py

@@ -1,6 +0,0 @@
-
-from typing import Literal
-
-
-def literal(c):
-    return Literal[*c]