mininterface 1.1.1__tar.gz → 1.1.2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mininterface
-Version: 1.1.1
+Version: 1.1.2
 Summary: A minimal access to GUI, TUI, CLI and config
 License: LGPL-3.0-or-later
 License-File: LICENSE
@@ -34,7 +34,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.2}/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.2}/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.2}/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
 
 
@@ -243,16 +245,27 @@ def _process_field(fname, ftype, disk_value, wf, m, default_value=MISSING):
         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 +284,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.1 → mininterface-1.1.2}/mininterface/_mininterface/__init__.py

@@ -164,8 +164,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 +260,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 +270,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.2}/mininterface/_mininterface/adaptor.py

@@ -140,3 +140,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.2}/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.2}/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):

mininterface-1.1.2/mininterface/_text_interface/timeout.py

@@ -0,0 +1,126 @@
+    # if not timeout:
+    #     return input(prompt)
+
+    # print(f"{prompt} (countdown {int(timeout)} sec)", end='', flush=True)
+
+
+import sys
+import threading
+import time
+from io import UnsupportedOperation
+from ..exceptions import Cancelled
+
+if sys.platform == "win32":
+    import msvcrt
+else:
+    import select
+    import tty
+    import termios
+
+def input_timeout(prompt: str, timeout: int = 0, exit_on_keypress: bool = False) -> str:
+    """
+    Cross-platform input with timeout and visual dots.
+
+    - Shows dots every second until user starts typing.
+    - exit_on_keypress=True: returns immediately after any key (prints newline immediately).
+    - exit_on_keypress=False: disables timeout after first key, waits for Enter (newline printed at Enter).
+    - Returns user input string or empty string if timeout expires.
+    - Ctrl+C raises Cancelled.
+    """
+    input_started = threading.Event()
+    inp = []
+
+    # Thread to print dots
+    def dots_thread():
+        for _ in range(timeout):
+            if input_started.is_set():
+                break
+            time.sleep(1)
+            if not input_started.is_set():
+                print(".", end='', flush=True)
+
+    if timeout:
+        print(f"{prompt} (countdown {int(timeout)} sec)", end='', flush=True)
+        t_dots = threading.Thread(target=dots_thread, daemon=True)
+        t_dots.start()
+        timeout_running = True
+    else:
+        print(prompt + " ", end='', flush=True)
+        timeout_running = False
+
+    start_time = time.time()
+
+    try:
+        if sys.platform == "win32":
+            while True:
+                if msvcrt.kbhit():
+                    char = msvcrt.getwch()
+                    if char == '\r':
+                        print()  # newline at Enter
+                        return "".join(inp)
+                    elif char == '\x03':  # Ctrl+C
+                        raise Cancelled
+                    elif char == '\x08':  # Backspace
+                        if inp:
+                            inp.pop()
+                            print("\b \b", end='', flush=True)
+                        continue
+                    else:
+                        inp.append(char)
+                        print(char, end='', flush=True)
+
+                    input_started.set()
+                    if exit_on_keypress:
+                        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 ""
+                time.sleep(0.01)
+
+        else:
+            fd = sys.stdin.fileno()
+            old_settings = termios.tcgetattr(fd)
+            tty.setcbreak(fd)
+            try:
+                while True:
+                    rlist, _, _ = select.select([sys.stdin], [], [], 0.1)
+                    if rlist:
+                        char = sys.stdin.read(1)
+                        if char == '\n':
+                            print()  # newline at Enter
+                            return "".join(inp)
+                        elif char == '\x03':
+                            raise Cancelled
+                        elif char == '\x7f':  # Backspace
+                            if inp:
+                                inp.pop()
+                                print("\b \b", end='', flush=True)
+                            continue
+                        else:
+                            inp.append(char)
+                            print(char, end='', flush=True)
+
+                        input_started.set()
+                        if exit_on_keypress:
+                            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.
+        # Github actions raises `termios.error: (25, 'Inappropriate ioctl for device')`
+        # pytest test_interface.py::TestInterface::test_ask raises `io.UnsupportedOperation: redirected stdin is pseudofile, has no fileno()`
+        return input(prompt + " ")
+    finally:
+        input_started.set()  # ensure dots thread stops

{mininterface-1.1.1 → mininterface-1.1.2}/mininterface/_textual_interface/adaptor.py

@@ -57,7 +57,7 @@ class TextualAdaptor(BackendAdaptor):
             # NOTE: DatetimeTag not implemented
             case SelectTag():
                 if tag.multiple:
-                    selected = set(tag.val)
+                    selected = set(tag._get_ui_val())
                     o = MySelectionList(tag, *((label, val, val in selected) for label, val, *_ in tag._get_options()))
                 else:
                     radio_buttons = [
@@ -100,12 +100,13 @@ class TextualAdaptor(BackendAdaptor):
         else:
             return []
 
-    def yes_no(self, text: str, focus_no=True):
-        return self.buttons(text, [("Yes", True), ("No", False)], int(focus_no) + 1)
+    def yes_no(self, text: str, focus_no=True, *, timeout: int = 0):
+        return self.buttons(text, [("Yes", True), ("No", False)], int(focus_no) + 1, timeout=timeout)
 
-    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):
         self._build_buttons(text, buttons, focused)
-        self.app = app = TextualApp(self, False)
+        self.app = app = TextualApp(self, False, timeout=timeout)
+
         if not app.run():
             raise Cancelled
         return self._get_buttons_val()

{mininterface-1.1.1 → mininterface-1.1.2}/mininterface/_textual_interface/button_contents.py

@@ -1,9 +1,9 @@
-from typing import TYPE_CHECKING, Any, Optional
+from typing import TYPE_CHECKING, Optional
 
 from textual import events
-from textual.app import App, ComposeResult
+from textual.app import ComposeResult
 from textual.containers import Center, Container
-from textual.widgets import Footer, Label, Static, Button
+from textual.widgets import Footer, Label
 
 
 from .widgets import MySubmitButton

{mininterface-1.1.1 → mininterface-1.1.2}/mininterface/_textual_interface/textual_app.py

@@ -1,18 +1,15 @@
 import asyncio
 from typing import TYPE_CHECKING
-from textual import events
+
 from textual.app import App
 from textual.containers import Container
 from textual.widget import Widget
 
-from .form_contents import FormContents
-
 from .button_contents import ButtonContents
-
-
+from .form_contents import FormContents
+from .timeout import TextualTimeout
 from .widgets import TagWidget
 
-
 if TYPE_CHECKING:
     from .adaptor import TextualAdaptor
 
@@ -28,12 +25,13 @@ class TextualApp(App[bool | None]):
     # We need to jump out of dir to allow children inherits (WebInterface)
     CSS_PATH = "../_textual_interface/style.tcss"
 
-    def __init__(self, adaptor: "TextualAdaptor", submit: str | bool = True):
+    def __init__(self, adaptor: "TextualAdaptor", submit: str | bool = True, timeout=None):
         super().__init__()
         self.widgets: WidgetList = []
         self.focusable_: WidgetList = []
         self.adaptor = adaptor
         self.submit = submit
+        self.timeout = timeout
 
         # Form confirmation
         if submit:
@@ -50,15 +48,20 @@ class TextualApp(App[bool | None]):
         self.contents = Container()
         yield self.contents
 
-    def on_mount(self) -> None:
+    async def on_mount(self) -> None:
         self.has_been_confirmed = False
-        # def on_mount(self, event: events.Mount) -> None:
         self.contents.remove_children()
         if self.adaptor.button_app:
             c = ButtonContents(self.adaptor, self.adaptor.button_app)
         else:
             c = FormContents(self.adaptor, self.widgets, self.focusable_)
-        self.contents.mount(c)
+        await self.contents.mount(c)
+
+        # timeout
+        if self.adaptor.button_app and self.timeout:
+            if not c.to_focus:
+                raise ValueError("Don't know what to timeout")
+            TextualTimeout(timeout=self.timeout, adaptor=self.adaptor, button=c.to_focus)
 
     def action_confirm(self):
         # next time, start on the same widget

mininterface-1.1.2/mininterface/_textual_interface/timeout.py

@@ -0,0 +1,35 @@
+import asyncio
+from .widgets import MyButton as Button
+from typing import TYPE_CHECKING
+
+from .._mininterface.adaptor import Timeout
+
+if TYPE_CHECKING:
+    from . import TextualAdaptor
+
+
+class TextualTimeout(Timeout):
+    button: Button
+
+    def __init__(self, timeout: int, adaptor: "TextualAdaptor", button: Button):
+        super().__init__(timeout, adaptor)
+        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())
+
+    async def countdown(self, count: int):
+        self.button.label = f"{self.orig} ({count})"
+
+        while count > 0:
+            await asyncio.sleep(1)
+            count -= 1
+            self.button.label = f"{self.orig} ({count})"
+
+        self.button.press()
+
+    def cancel(self):
+        if self._task and not self._task.done():
+            self._task.cancel()
+            self._task = None
+            self.button.label = self.orig

{mininterface-1.1.1 → mininterface-1.1.2}/mininterface/_textual_interface/widgets.py

@@ -117,10 +117,18 @@ class MyButton(TagWidget, Button):
 
     def __init__(self, tag, *args, **kwargs):
         super().__init__(tag, tag.label, *args, **kwargs)
+        self.blur_callback = None
 
     def on_button_pressed(self, event):
         self.tag._facet.submit(_post_submit=self.tag._run_callable)
 
+    def on_blur(self):
+        if clb:=self.blur_callback:
+            clb()
+
+    def set_blur_callback(self, clb):
+        self.blur_callback = clb
+
     def get_ui_value(self):
         return self.tag.val
 

{mininterface-1.1.1 → mininterface-1.1.2}/mininterface/_tk_interface/adaptor.py

@@ -5,6 +5,7 @@ from typing import TYPE_CHECKING, Any, Callable
 
 from textual.widgets import Checkbox
 
+
 try:
     from tkscrollableframe import ScrolledFrame
     from tktooltip import ToolTip
@@ -22,6 +23,7 @@ from ..settings import GuiSettings
 from ..tag import Tag
 from .facet import TkFacet
 from .utils import recursive_set_focus, replace_widgets
+from .timeout import TkTimeout
 
 
 class TkAdaptor(Tk, RichUiAdaptor, BackendAdaptor):
@@ -139,20 +141,27 @@ class TkAdaptor(Tk, RichUiAdaptor, BackendAdaptor):
             return self.run_dialog(form, title, submit)
         return form
 
-    def yes_no(self, text: str, focus_no=True):
-        return self.buttons(text, [("Yes", True), ("No", False)], int(focus_no) + 1)
+    def yes_no(self, text: str, focus_no=True, *, timeout: int = 0):
+        return self.buttons(text, [("Yes", True), ("No", False)], int(focus_no) + 1, timeout=timeout)
 
-    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):
         label = Label(self.frame, text=text)
         label.pack(pady=10)
+        b_focused = None
 
         for i, (text, value) in enumerate(buttons):
             button = Button(self.frame, text=text, command=lambda v=value: self._ok(v))
             button.pack(side=LEFT, padx=10)
             if i == focused - 1:
                 button.focus_set()
-                b = button
-                button.bind("<Return>", lambda _: b.invoke())
+                b_focused = button
+                button.bind("<Return>", lambda _, b=b_focused: b.invoke())
+
+        if timeout:
+            if not b_focused:
+                raise ValueError("Don't know what to timeout")
+            TkTimeout(timeout, self, b_focused)
+
         return self.mainloop()
 
     def _bind_event(self, event, handler):
@@ -215,7 +224,7 @@ class TkAdaptor(Tk, RichUiAdaptor, BackendAdaptor):
     def _destroy(self):
         self.destroy()
 
-    def bind_shortcut(self, shortcut: str, widget: Widget|Callable[[], Widget]):
+    def bind_shortcut(self, shortcut: str, widget: Widget | Callable[[], Widget]):
         def _(event=None):
             nonlocal widget
             if isinstance(widget, FunctionType):

{mininterface-1.1.1 → mininterface-1.1.2}/mininterface/_tk_interface/select_input.py

@@ -104,7 +104,7 @@ class SelectInputWrapper:
         taken = False
 
         for i, (choice_label, choice_val, tip, tupled_key) in enumerate(options):
-            var = BooleanVar(value=choice_val in tag.val)
+            var = BooleanVar(value=choice_val in tag._get_ui_val())
 
             def on_toggle(val=choice_val, var=var):
                 if var.get():

mininterface-1.1.2/mininterface/_tk_interface/timeout.py

@@ -0,0 +1,38 @@
+from tkinter import Button
+from typing import TYPE_CHECKING
+from .._mininterface.adaptor import Timeout
+
+if TYPE_CHECKING:
+    from . import TkAdaptor
+
+
+
+class TkTimeout(Timeout):
+    adaptor: "TkAdaptor"
+
+    def __init__(self, timeout: int, adaptor: "TkAdaptor", button: Button):
+        super().__init__(timeout, adaptor)
+        self.button = button
+        self.after_id = None
+        self.orig:str = self.button.cget("text")
+
+        self.countdown(timeout)
+
+        self.button.bind("<FocusOut>", self.cancel)
+
+    def countdown(self, count):
+        try:
+            self.button.config(text=f"{self.orig} ({count})")
+        except:  # The form has been submitted and the button is not valid anymore
+            return
+
+        if count > 0:
+            self.after_id = self.adaptor.after(1000, self.countdown, count - 1)
+        else:
+            self.button.invoke()
+
+    def cancel(self, event=None):
+        if self.after_id is not None:
+            self.adaptor.after_cancel(self.after_id)
+            self.after_id = None
+            self.button.config(text=self.orig)

{mininterface-1.1.1 → mininterface-1.1.2}/mininterface/_web_interface/child_adaptor.py

@@ -71,7 +71,12 @@ class SerializedChildAdaptor(TextualAdaptor):
         self._original_stdout.buffer.flush()
         return self.receive()
 
-    def buttons(self, text: str, buttons: ButtonAppType, focused: int = 1):
+    def buttons(self, text: str, buttons: ButtonAppType, focused: int = 1, *, timeout: int = 0):
+        if timeout:
+            # NOTE timeout not implemented
+            import warnings
+            warnings.warn("Timeout not implemented for web interface")
+            print("Warning: Timeout not implemented for web interface")
         return self.send(SerCommand.BUTTONS, text, buttons, focused)
 
     def run_dialog(self, form: TagDict, title: str = "", submit: bool | str = True) -> TagDict:

{mininterface-1.1.1 → mininterface-1.1.2}/mininterface/tag/flag.py

@@ -75,7 +75,7 @@ def _assure_blank_or_bool(args):
 BlankTrue = Annotated[
     bool | None,
     PrimitiveConstructorSpec(
-        nargs=(0,1),  # TODO test should be probably = (0,1)
+        nargs=(0,1),
         metavar="blank=True|BOOL",
         instance_from_str=_assure_blank_or_bool,
         is_instance=lambda instance: True,  # NOTE not sure

{mininterface-1.1.1 → mininterface-1.1.2}/mininterface/tag/select_tag.py

@@ -100,6 +100,14 @@ m.select([Color.GREEN, Color.BLUE])
 
 ![Options from enum list](asset/choice_enum_list.avif)
 
+!!! Note
+    Enum keys are seen from the CLI (unless modified). Enum values are seen from the UI. Should you need to bear an additional information, not displayed in CLI nor UI, tackle the Enum class.
+    For the examples, see [Supported types / Enum](Supported-types.md/#enums).
+
+## Literal
+
+`typing.Literal` allows you to do a one-liner. Their values are seen from the CLI. See the [Supported types / Literal](Supported-types.md/#literal) examples.
+
 ## Further examples
 
 See [mininterface.select][mininterface.Mininterface.select] or [`SelectTag.options`][mininterface.tag.SelectTag.options] for further usage.
@@ -254,7 +262,7 @@ class SelectTag(Tag[TagValue]):
     def _get_selected_keys(self):
         if not self.multiple:
             raise AttributeError
-        return [k for k, val, *_ in self._get_options() if val in self.val]
+        return [k for k, val, *_ in self._get_options() if val in self._get_ui_val()]
 
     @classmethod
     def _repr_val(cls, v) -> str:
@@ -357,6 +365,8 @@ class SelectTag(Tag[TagValue]):
             return [(delim.join(key), key) for key in keys]
 
     def _make_default_value(self):
+        if self.multiple:
+            return []
         if d := self._build_options():
             return next(iter(d.values()))
 

{mininterface-1.1.1 → mininterface-1.1.2}/mininterface/tag/tag.py

@@ -669,6 +669,8 @@ class Tag(Generic[TagValue]):
                     return [_(subt) for subt in subtype]
                 if origin is tuple:
                     return origin, list(subtype)
+                elif origin is dict:
+                    return origin, subtype
                 elif origin is Literal:
                     return origin, subtype
                 elif len(subtype) == 1:
@@ -695,7 +697,7 @@ class Tag(Generic[TagValue]):
     def set_error_text(self, s=""):
         """ Mark the field as required and possibly adds an error text to the description. """
         if s:
-            self.description = f"{s} {self._original_desc}"
+            self.description = f"{s} {self._original_desc}".strip()
         if n := self._original_label:
             # Why checking self._original_label?
             # If for any reason (I do not know the use case) is not set, we would end up with '* None'
@@ -914,12 +916,30 @@ class Tag(Generic[TagValue]):
                                 elif get_origin(cast_to) is tuple:
                                     cast_to = get_args(cast_to)
                                     if len(cast_to) == 2 and cast_to[1] is Ellipsis:
+                                        # ex. `list[tuple[int, ...]]`
                                         cast_to = cast_to[0]
                                         candidate = origin(tuple(cast_to(v) for v in tuple_) for tuple_ in literal_eval(ui_value))
-                                    else:
-                                        candidate = origin(tuple(cast_to_(v) for v, cast_to_ in zip(tuple_, cast_to)) for tuple_ in literal_eval(ui_value))
+                                    else: # ex. `list[tuple[int, Path, str]]`
+                                        tuples = []
+                                        for str_tuple in literal_eval(ui_value):
+                                            try:
+                                                typed_tuple = tuple(
+                                                    cast_to_(v) for v, cast_to_ in zip(str_tuple, cast_to, strict=True)
+                                                )
+                                            except ValueError as e:
+                                                # this was the right way, there is no reason to attempt further
+                                                self.set_error_text(f"Bad tuple length for {str_tuple!r}")
+                                                return False
+                                            tuples.append(typed_tuple)
+
+                                        candidate = origin(tuples)
+                                elif origin is dict:   # ex. `dict[str, str]`
+                                    # we ignore cast_to as `[str, str]` part will be checked later
+                                    candidate = literal_eval(ui_value)
                                 else:
                                     candidate = origin(cast_to(v) for v in literal_eval(ui_value))
+                            elif cast_to is dict: # `annotation=dict`
+                                candidate = literal_eval(ui_value)  #
                             else:
                                 candidate = cast_to(ui_value)
                         except (TypeError, ValueError, SyntaxError):

{mininterface-1.1.1 → mininterface-1.1.2}/mininterface/tag/tag_factory.py

@@ -2,7 +2,7 @@ from copy import copy
 from datetime import date, time
 from enum import Enum
 from pathlib import Path
-from typing import Any, Iterable, Literal, Type, get_origin, get_type_hints
+from typing import Any, Iterable, Literal, Type, get_args, get_origin, get_type_hints
 
 from annotated_types import BaseMetadata, GroupedMetadata, Len
 
@@ -108,6 +108,14 @@ def tag_factory(
                             elif isinstance(metadata, (BaseMetadata, Len)):
                                 # Why not checking `GroupedMetadata` instead of `Len`? See below. You won't believe.
                                 validators.append(metadata)
+                            elif get_origin(metadata) is Literal:
+                                if "<class 'mininterface.tag.flag._Blank'>" in (repr(type(f)) for f in field_type.__metadata__):
+                                    # a special case, this is a default CLI value and will be processed by flag.Blank
+                                    # `foo: Annotated[Blank[int], Literal[2]] = None`
+                                    # Using repr and not importing due to (vague) performance reasons.
+                                    continue
+                                # `variable = 2, 3; foo: Annotated[int, Literal[variable]] = None`
+                                annotation = metadata
     if not tag:
         tag = tag_assure_type(Tag(val, description, annotation, *args, **kwargs))
 

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

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "mininterface"
-version = "1.1.1"
+version = "1.1.2"
 description = "A minimal access to GUI, TUI, CLI and config"
 authors = ["Edvard Rejthar <edvard.rejthar@nic.cz>"]
 license = "LGPL-3.0-or-later"
@@ -17,7 +17,7 @@ python = "^3.10"
 simple_term_menu = "*"
 annotated-types = "*"
 # Basic requirements (CLI and full .form support (m.form(dataclass_class))
-tyro = { version = "^0.9", optional = true }
+tyro = { version = "^0.9.31", optional = true }
 pyyaml = { version = "*", optional = true }
 humanize = { version = "*", optional = true }
 textual = { version = "<2.0.0", optional = true }