mininterface 1.1.1__tar.gz → 1.1.3__tar.gz

{mininterface-1.1.1 → mininterface-1.1.3}/PKG-INFO

@@ -1,19 +1,18 @@
 Metadata-Version: 2.4
 Name: mininterface
-Version: 1.1.1
+Version: 1.1.3
 Summary: A minimal access to GUI, TUI, CLI and config
 License: LGPL-3.0-or-later
 License-File: LICENSE
 Author: Edvard Rejthar
 Author-email: edvard.rejthar@nic.cz
-Requires-Python: >=3.10,<4.0
+Requires-Python: >=3.10,<3.14
 Classifier: License :: OSI Approved :: GNU Lesser General Public License v3 or later (LGPLv3+)
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
-Classifier: Programming Language :: Python :: 3.14
 Provides-Extra: all
 Provides-Extra: basic
 Provides-Extra: gui
@@ -34,7 +33,7 @@ Requires-Dist: tkcalendar ; extra == "gui" or extra == "ui" or extra == "all"
 Requires-Dist: tkinter-tooltip ; extra == "basic" or extra == "img" or extra == "tui" or extra == "gui" or extra == "web" or extra == "ui" or extra == "all"
 Requires-Dist: tkinter_form (==0.2.1) ; extra == "basic" or extra == "img" or extra == "tui" or extra == "gui" or extra == "web" or extra == "ui" or extra == "all"
 Requires-Dist: tkscrollableframe ; extra == "basic" or extra == "img" or extra == "tui" or extra == "gui" or extra == "web" or extra == "ui" or extra == "all"
-Requires-Dist: tyro (>=0.9,<0.10) ; extra == "basic" or extra == "img" or extra == "tui" or extra == "gui" or extra == "web" or extra == "ui" or extra == "all"
+Requires-Dist: tyro (>=0.9.31,<0.10.0) ; extra == "basic" or extra == "img" or extra == "tui" or extra == "gui" or extra == "web" or extra == "ui" or extra == "all"
 Project-URL: Homepage, https://github.com/CZ-NIC/mininterface
 Description-Content-Type: text/markdown
 

{mininterface-1.1.1 → mininterface-1.1.3}/mininterface/__main__.py

@@ -33,6 +33,7 @@ Showcase_Type = Literal[1, 2]
 # @dataclass
 # class SharedLabel(Command):
 #     text: Positional[str]
+# NOTE implement `timeout`
 
 
 @dataclass

{mininterface-1.1.1 → mininterface-1.1.3}/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.1 → mininterface-1.1.3}/mininterface/_lib/cli_utils.py

@@ -150,3 +150,22 @@ class SubcommandPlaceholder(Command):
 
 
 SubcommandPlaceholder.__name__ = "subcommand"  # show just the shortcut in the CLI
+
+# NOTE I'd like the method run to actually run here
+# @dataclass
+# class Console(Command):
+#     foo: str = "bar"
+#     def run(self):
+#         raise ValueError("DVA")
+#         self.interface.alert("Console!")
+# @dataclass
+# class Message(Command):
+#     text: str
+#     def run(self):
+#         raise ValueError("RAZ")
+# @dataclass
+# class Env:
+#     val: Message | Console
+# m = run(Env) # here
+# m = run([Message, Console]) # and here too
+# Then, add is as a tip to Supported-types.md.

{mininterface-1.1.1 → mininterface-1.1.3}/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.1 → mininterface-1.1.3}/mininterface/_lib/dataclass_creation.py

@@ -108,7 +108,7 @@ def _unwrap_annotated(tp):
     return tp
 
 
-def create_with_missing(env: T, disk: dict, wf: Optional[dict] = None, mint: Optional["Mininterface"] = None)->T:
+def create_with_missing(env: T, disk: dict, wf: Optional[dict] = None, m: Optional["Mininterface"] = None)->T:
     """
     Create a default instance of an Env object. This is due to provent tyro to spawn warnings about missing fields.
     Nested dataclasses have to be properly initialized. YAML gave them as dicts only.
@@ -116,6 +116,8 @@ def create_with_missing(env: T, disk: dict, wf: Optional[dict] = None, mint: Opt
     The result contains MISSING_NONPROP on the places the original Env object must have a value.
 
     And such fields are put into the wf (wrong_fields) dict.
+
+    Having the `m` defined means we build the dataclass. None means we are still in the config file parsing context.
     """
     # NOTE a test is missing
     # @dataclass
@@ -146,7 +148,7 @@ def create_with_missing(env: T, disk: dict, wf: Optional[dict] = None, mint: Opt
     # as the default value takes the precedence over the hard coded one, even if missing.
     out = {}
     missings: list[Tag] = []
-    for name, v in proc_method(env, disk, wf, mint):
+    for name, v in proc_method(env, disk, wf, m):
         out[name] = v
         if v == MISSING_NONPROP and wf is not None:
             # For building config file, the MISSING_NONPROP is alright as we expect tyro to fail
@@ -174,7 +176,7 @@ def _process_pydantic(env, disk, wf: Optional[dict], m: Optional["Mininterface"]
         elif f.default is not None:
             v = f.default
         else:
-            v = _process_field(name, f.annotation, MISSING, wf, m, default_value=MISSING)
+            v = _process_field(name, f.annotation, MISSING_NONPROP, wf, m, default_value=MISSING)
         yield name, v
 
 
@@ -187,7 +189,7 @@ def _process_attr(env, disk, wf: Optional[dict], m: Optional["Mininterface"] = N
         elif has_default:
             v = f.default
         else:
-            v = _process_field(f.name, f.type, MISSING, wf, m, default_val)
+            v = _process_field(f.name, f.type, MISSING_NONPROP, wf, m, default_val)
         yield f.name, v
 
 
@@ -235,24 +237,38 @@ 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
         else:
             raise ValueError(f"Type {disk_value} not found in {ftype}")
 
-    if disk_value is not MISSING:
+    if disk_value is not MISSING_NONPROP:
         if _is_struct_type(ftype):
             return _init_struct_value(ftype, disk_value, wf, fname, m)
+        # NOTE for handling subcommands in config file, I'll need something like this,
+        # combined with a structure like ChosenSubcommand, possibly inheriting from MISSING_NONPROP
+        # to be ignored by tyro, yet fetchable by cli_parser
+        # elif _is_subcommands:
+        #     return {cl.__name__: _init_struct_value(cl, {}, wf, fname, m) for cl in get_args(ftype)}
         return coerce_type_to_annotation(disk_value, ftype)
 
+    if _is_struct_type(ftype):
+        # Ex. `foo: Subcommand`
+        return _init_struct_value(ftype, {}, wf, fname, m)
+
     # We must handle the case when there are multiple subcommands possible.
     # The user decides now which way to go (choose a subcommand).
-    if (origin is Union or origin is UnionType) and all(_is_struct_type(cl) for cl in get_args(ftype)):
-        if not m:  # we should not come here
-            raise RuntimeError("Missing interface, report the issue please.")
+    # Ex. `foo: Subcommand1 | Subcommand2`
+    _is_subcommands = (origin is Union or origin is UnionType) and all(_is_struct_type(cl) for cl in get_args(ftype))
+    if _is_subcommands:
+        if not m:  # we are parsing the config file. The fields are not defined in the config file
+            return MISSING_NONPROP
         ftype = choose_subcommand(get_args(ftype), m)
         return _init_struct_value(ftype, {}, wf, fname, m)
 
@@ -271,7 +287,7 @@ def _process_dataclass(env, disk, wf: Optional[dict], m: Optional["Mininterface"
         elif f.default is not MISSING:
             v = f.default
         else:
-            v = _process_field(f.name, f.type, MISSING, wf, m)
+            v = _process_field(f.name, f.type, MISSING_NONPROP, wf, m)
         yield f.name, v
 
 

mininterface-1.1.3/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.1 → mininterface-1.1.3}/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.1 → mininterface-1.1.3}/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.1 → mininterface-1.1.3}/mininterface/_mininterface/__init__.py

@@ -90,6 +90,7 @@ class Mininterface(Generic[EnvClass]):
         # NOTE docs that
         # m = run([Env, Env2]) -> .env will be the chosen one.
 
+        # NOTE In Python3.14, type(self).__annotations__ will work.
         self._adaptor = self.__annotations__["_adaptor"](self, settings)
 
     def __enter__(self) -> "Self":
@@ -164,8 +165,13 @@ class Mininterface(Generic[EnvClass]):
     def __exit__(self, *_):
         pass
 
-    def alert(self, text: str) -> None:
-        """Prompt the user to confirm the text."""
+    def alert(self, text: str, *, timeout: int = 0) -> None:
+        """Prompt the user to confirm the text.
+
+        Args:
+            text: Displayed text
+            timeout: Auto-confirm after N seconds (0 = disabled).
+        """
         print("Alert text", text)
         return
 
@@ -255,7 +261,7 @@ class Mininterface(Generic[EnvClass]):
         # Output:
         return assure_tag(annotation, validation)._make_default_value()
 
-    def confirm(self, text: str, default: bool = True) -> bool:
+    def confirm(self, text: str, default: bool = True, *, timeout: int = 0) -> bool:
         """Display confirm box and returns bool.
 
         ```python
@@ -265,9 +271,19 @@ class Mininterface(Generic[EnvClass]):
 
         ![Is yes window](asset/is_yes.avif "A prompted dialog")
 
+        Automatically submit after 10 seconds with the `timeout` parameter.
+
+        ```python
+        m = run()
+        print(m.confirm("Is that alright?"), timeout=10)  # True/False
+        ```
+
+        ![Is yes window](asset/confirm_countdown.avif "A prompted dialog with timeout")
+
         Args:
             text: Displayed text.
             default: Focus the button with this value.
+            timeout: Auto-confirm after N seconds (0 = disabled).
 
         Returns:
             bool: Whether the user has chosen the Yes button.

{mininterface-1.1.1 → mininterface-1.1.3}/mininterface/_mininterface/adaptor.py

@@ -26,6 +26,7 @@ class BackendAdaptor(ABC):
 
     def __init__(self, interface: "Mininterface", settings: UiSettings | None):
         self.interface = interface
+        # NOTE self.__annotations__ will pose problem at Python3.14
         self.facet = interface.facet = self.__annotations__["facet"](self, interface.env)
         self.settings = settings or self.__annotations__["settings"]()
 
@@ -140,3 +141,18 @@ class MinAdaptor(BackendAdaptor):
             raise SystemExit(validation_fails)
 
         return form
+
+class Timeout(ABC):
+    """ Auto-submit dialogs """
+
+    def __init__(self, timeout: int, adaptor: "BackendAdaptor"):
+        self.timeout = timeout
+        self.adaptor = adaptor
+
+    @abstractmethod
+    def countdown(self):
+        ...
+
+    @abstractmethod
+    def cancel(self):
+        ...

{mininterface-1.1.1 → mininterface-1.1.3}/mininterface/_mininterface/mixin.py

@@ -13,12 +13,12 @@ from . import Mininterface
 class RichUiMixin(Mininterface):
     _adaptor: "RichUiAdaptor"
 
-    def alert(self, text: str) -> None:
+    def alert(self, text: str, *, timeout: int = 0) -> None:
         """Display the OK dialog with text."""
-        self._adaptor.buttons(text, [("Ok", None)])
+        self._adaptor.buttons(text, [("Ok", None)], timeout=timeout)
 
-    def confirm(self, text, default: bool = True) -> bool:
-        return self._adaptor.yes_no(text, not default)
+    def confirm(self, text, default: bool = True, *, timeout: int = 0) -> bool:
+        return self._adaptor.yes_no(text, not default, timeout=timeout)
 
     def ask(
         self,
@@ -36,7 +36,7 @@ class RichUiMixin(Mininterface):
 
 class RichUiAdaptor(ABC):
     @abstractmethod
-    def yes_no(self, text: str, focus_no=True): ...
+    def yes_no(self, text: str, focus_no=True, *, timeout: int = 0)->bool: ...
 
     @abstractmethod
-    def buttons(self, text: str, buttons: list[tuple[str, Any]], focused: int = 1): ...
+    def buttons(self, text: str, buttons: list[tuple[str, Any]], focused: int = 1, *, timeout: int = 0): ...

{mininterface-1.1.1 → mininterface-1.1.3}/mininterface/_text_interface/__init__.py

@@ -2,12 +2,14 @@ import sys
 from pprint import pprint
 from typing import TYPE_CHECKING, Iterable, Type, TypeVar
 
+
 from ..tag.tag_factory import assure_tag
 
 from ..exceptions import Cancelled, InterfaceNotAvailable
 from .._lib.form_dict import DataClass, EnvClass, FormDict, tag_assure_type
 from .._mininterface import Mininterface
 from ..tag.tag import Tag, TagValue, ValidationCallback
+from .timeout import input_timeout
 from .adaptor import TextAdaptor
 
 if TYPE_CHECKING:  # remove the line as of Python3.11 and make `"Self" -> Self`
@@ -75,23 +77,25 @@ class TextInterface(AssureInteractiveTerminal, Mininterface):
 
     _adaptor: TextAdaptor
 
-    def alert(self, text: str):
+    def alert(self, text: str, *, timeout: int = 0):
         """Display text and let the user hit any key."""
         with StdinTTYWrapper():
-            input(text + " Hit any key.")
+            input_timeout(text + " Hit any key.", timeout, True)
 
     def ask(
         self,
         text: str,
         annotation: Type[TagValue] | Tag = str,
         validation: Iterable[ValidationCallback] | ValidationCallback | None = None,
+        *,
+        _timeout: int = 0
     ) -> TagValue:
         with StdinTTYWrapper():
             if not self.interactive:
                 return super().ask(text, annotation=annotation, validation=validation)
             while True:
                 try:
-                    txt = input(text + ": ") if text else input()
+                    txt = input_timeout(text + ":" if text else "", _timeout)
                 except EOFError:
                     raise Cancelled(".. cancelled")
                 t = assure_tag(annotation, validation)
@@ -133,20 +137,20 @@ class TextInterface(AssureInteractiveTerminal, Mininterface):
                 pdb.set_trace()
             return form
 
-    def confirm(self, text: str, default: bool = True):
+    def confirm(self, text: str, default: bool = True, *, timeout: int = 0):
         with StdinTTYWrapper():
             if default:
                 t = text + " [y]/n"
             else:
                 t = text + " y/[n]"
-            val = self.ask(text=t).lower()
+            val = self.ask(text=t, _timeout=timeout).lower()
             if not val:
                 return bool(default)
             if val in ("y", "yes", ""):
                 return True
             if val in ("n", "no", ""):
                 return False
-            return self.confirm(text, default)
+            return self.confirm(text, default, timeout=timeout)
 
 
 class ReplInterface(TextInterface):