mininterface 0.1.1__tar.gz → 0.4.1__tar.gz

{mininterface-0.1.1 → mininterface-0.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: mininterface
-Version: 0.1.1
+Version: 0.4.1
 Summary: A minimal access to GUI, TUI, CLI and config
 Home-page: https://github.com/CZ-NIC/mininterface
 License: GPL-3.0-or-later
@@ -22,6 +22,7 @@ Description-Content-Type: text/markdown
 
 # Mininterface – access to GUI, TUI, CLI and config files
 [![License: GPL v3](https://img.shields.io/badge/License-GPLv3-blue.svg)](https://www.gnu.org/licenses/gpl-3.0)
+[![Build Status](https://github.com/CZ-NIC/mininterface/actions/workflows/run-unittest.yml/badge.svg)](https://github.com/CZ-NIC/mininterface/actions)
 
 Write the program core, do not bother with the input/output.
 
@@ -182,8 +183,8 @@ Allow the user to edit whole configuration. (Previously fetched from CLI and con
 Prompt the user to fill up whole form.
 * `args`: Dict of `{labels: default value}`. The form widget infers from the default value type.
   The dict can be nested, it can contain a subgroup.
-  The default value might be `mininterface.Value` that allows you to add descriptions.
-  A checkbox example: `{"my label": Value(True, "my description")}`
+  The default value might be `mininterface.FormField` that allows you to add descriptions.
+  A checkbox example: `{"my label": FormField(True, "my description")}`
 * `title`: Optional form title.
 ### `ask_number(self, text: str) -> int`
 Prompt the user to input a number. Empty input = 0.

{mininterface-0.1.1 → mininterface-0.4.1}/README.md

@@ -1,5 +1,6 @@
 # Mininterface – access to GUI, TUI, CLI and config files
 [![License: GPL v3](https://img.shields.io/badge/License-GPLv3-blue.svg)](https://www.gnu.org/licenses/gpl-3.0)
+[![Build Status](https://github.com/CZ-NIC/mininterface/actions/workflows/run-unittest.yml/badge.svg)](https://github.com/CZ-NIC/mininterface/actions)
 
 Write the program core, do not bother with the input/output.
 
@@ -160,8 +161,8 @@ Allow the user to edit whole configuration. (Previously fetched from CLI and con
 Prompt the user to fill up whole form.
 * `args`: Dict of `{labels: default value}`. The form widget infers from the default value type.
   The dict can be nested, it can contain a subgroup.
-  The default value might be `mininterface.Value` that allows you to add descriptions.
-  A checkbox example: `{"my label": Value(True, "my description")}`
+  The default value might be `mininterface.FormField` that allows you to add descriptions.
+  A checkbox example: `{"my label": FormField(True, "my description")}`
 * `title`: Optional form title.
 ### `ask_number(self, text: str) -> int`
 Prompt the user to input a number. Empty input = 0.

{mininterface-0.1.1 → mininterface-0.4.1}/mininterface/GuiInterface.py

@@ -11,17 +11,17 @@ except ImportError:
 
 
 from .common import InterfaceNotAvailable
-from .auxiliary import FormDict, RedirectText, dataclass_to_dict, dict_to_dataclass, recursive_set_focus, normalize_types
+from .auxiliary import FormDict, RedirectText, config_to_formdict, config_from_dict, flatten, recursive_set_focus, fix_types
 from .Mininterface import Cancelled, ConfigInstance, Mininterface
 
 
 class GuiInterface(Mininterface):
     def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
         try:
-            super().__init__(*args, **kwargs)
+            self.window = TkWindow(self)
         except TclError:
             raise InterfaceNotAvailable
-        self.window = TkWindow(self)
         self._always_shown = False
         self._original_stdout = sys.stdout
 
@@ -39,29 +39,29 @@ class GuiInterface(Mininterface):
 
     def alert(self, text: str) -> None:
         """ Display the OK dialog with text. """
-        return self.window.buttons(text, [("Ok", None)])
+        self.window.buttons(text, [("Ok", None)])
 
     def ask(self, text: str) -> str:
         return self.window.run_dialog({text: ""})[text]
 
     def ask_args(self) -> ConfigInstance:
         """ Display a window form with all parameters. """
-        params_ = dataclass_to_dict(self.args, self.descriptions)
+        params_ = config_to_formdict(self.args, self.descriptions)
 
         # fetch the dict of dicts values from the form back to the namespace of the dataclasses
-        data = self.window.run_dialog(params_)
-        dict_to_dataclass(self.args, data)
+        self.window.run_dialog(params_)
+        # NOTE remove config_from_dict(self.args, data)
         return self.args
 
-    def ask_form(self, args: FormDict, title: str = "") -> dict:
+    def ask_form(self, form: FormDict, title: str = "") -> dict:
         """ Prompt the user to fill up whole form.
             :param args: Dict of `{labels: default value}`. The form widget infers from the default value type.
                 The dict can be nested, it can contain a subgroup.
-                The default value might be `mininterface.Value` that allows you to add descriptions.
-                A checkbox example: {"my label": Value(True, "my description")}
+                The default value might be `mininterface.FormField` that allows you to add descriptions.
+                A checkbox example: {"my label": FormField(True, "my description")}
             :param title: Optional form title.
         """
-        return self.window.run_dialog(args, title=title)
+        return self.window.run_dialog(form, title=title)
 
     def ask_number(self, text: str) -> int:
         return self.window.run_dialog({text: 0})[text]
@@ -121,9 +121,13 @@ class TkWindow(Tk):
         return self.mainloop(lambda: self.validate(formDict, title))
 
     def validate(self, formDict: FormDict, title: str):
-        if data := normalize_types(formDict, self.form.get()):
-            return data
-        return self.run_dialog(formDict, title)
+        if not all(ff.update(ui_value) for ff, ui_value in zip(flatten(formDict), flatten(self.form.get()))):
+            return self.run_dialog(formDict, title)
+
+        # NOTE remove:
+        # if data := fix_types(formDict, self.form.get()):
+        #     return data
+        # return self.run_dialog(formDict, title)
 
     def yes_no(self, text: str, focus_no=True):
         return self.buttons(text, [("Yes", True), ("No", False)], int(focus_no)+1)

{mininterface-0.1.1 → mininterface-0.4.1}/mininterface/Mininterface.py

@@ -54,15 +54,15 @@ class Mininterface:
         print("Asking the args", self.args)
         return self.args
 
-    def ask_form(self, args: FormDict, title: str = "") -> dict:
+    def ask_form(self, data: FormDict, title: str = "") -> dict:
         """ Prompt the user to fill up whole form.
             :param args: Dict of `{labels: default value}`. The form widget infers from the default value type.
                 The dict can be nested, it can contain a subgroup.
-                The default value might be `mininterface.Value` that allows you to add descriptions.
-                A checkbox example: `{"my label": Value(True, "my description")}`
+                The default value might be `mininterface.FormField` that allows you to add descriptions.
+                A checkbox example: `{"my label": FormField(True, "my description")}`
         """
-        print(f"Asking the form {title}", args)
-        return args  # NOTE – this should return dict, not FormDict (get rid of auxiliary.Value values)
+        print(f"Asking the form {title}", data)
+        return data  # NOTE – this should return dict, not FormDict (get rid of auxiliary.FormField values)
 
     def ask_number(self, text: str) -> int:
         """ Prompt the user to input a number. Empty input = 0. """

mininterface-0.4.1/mininterface/TextualInterface.py

@@ -0,0 +1,226 @@
+from ast import literal_eval
+from dataclasses import _MISSING_TYPE, dataclass, field
+from types import UnionType
+from typing import Any, Self, get_args, override
+from dataclasses import fields
+from textual import events
+from textual.app import App, ComposeResult
+from textual.containers import VerticalScroll, Container
+from textual.widgets import Checkbox, Header, Footer, Input, Label, Welcome, Button, Static
+from textual.binding import Binding
+
+from mininterface import TuiInterface
+from .common import InterfaceNotAvailable
+
+from .Mininterface import Cancelled, Mininterface
+from .auxiliary import ConfigInstance, FormDict, FormField, config_from_dict, config_to_formdict, dict_to_formdict, flatten
+
+from textual.widgets import Checkbox, Input
+
+# TODO
+# 1. TuiInterface -> TextInterface.
+# 1. TextualInterface inherits from TextInterface.
+# 2. TextualInterface is the default for TuiInterface
+# Add to docs
+
+@dataclass
+class FormFieldTextual(FormField):
+    """ Bridge between the values given in CLI, TUI and real needed values (str to int conversion etc). """
+
+    def get_widget(self):
+        if self.annotation is bool or not self.annotation and self.val in [True, False]:
+            o = Checkbox(self.name, self.val)
+        else:
+            o = Input(str(self.val), placeholder=self.name or "")
+        o._link = self  # The Textual widgets need to get back to this value
+        return o
+
+
+@dataclass
+class DummyWrapper:
+    """ Value wrapped, since I do not know how to get it from textual app.
+    False would mean direct exit. """
+    val: Any
+
+
+class TextualInterface(TuiInterface):
+
+    def alert(self, text: str) -> None:
+        """ Display the OK dialog with text. """
+        TextualButtonApp().buttons(text, [("Ok", None)]).run()
+
+    def ask(self, text: str = None):
+        return self.ask_form({text: ""})[text]
+
+    def ask_args(self) -> ConfigInstance:
+        """ Display a window form with all parameters. """
+        params_ = config_to_formdict(self.args, self.descriptions, factory=FormFieldTextual)
+
+        # fetch the dict of dicts values from the form back to the namespace of the dataclasses
+        TextualApp.run_dialog(TextualApp(), params_)
+        return self.args
+
+    def ask_form(self, form: FormDict, title: str = "") -> dict:
+        TextualApp.run_dialog(TextualApp(), dict_to_formdict(form, factory=FormFieldTextual), title)
+        return form
+
+    # NOTE we should implement better, now the user does not know it needs an int
+    # def ask_number(self, text):
+
+    def is_yes(self, text):
+        return TextualButtonApp().yes_no(text, False).val
+
+    def is_no(self, text):
+        return TextualButtonApp().yes_no(text, True).val
+
+
+class TextualApp(App[bool | None]):
+
+    BINDINGS = [
+        ("up", "go_up", "Go up"),
+        ("down", "go_up", "Go down"),
+        # Form confirmation
+        # * ctrl/alt+enter does not work
+        # * enter without priority is consumed by input fields
+        # * enter with priority is not shown in the footer
+        Binding("enter", "confirm", "Ok", show=True, priority=True),
+        Binding("Enter", "confirm", "Ok"),
+        ("escape", "exit", "Cancel"),
+    ]
+
+    def __init__(self):
+        super().__init__()
+        self.title = ""
+        self.widgets = None
+        self.focused_i: int = 0
+
+    def setup(self, title, widgets, focused_i):
+
+        self.focused_i = focused_i
+        return self
+
+    # Why class method? I do not know how to re-create the dialog if needed.
+    @classmethod
+    def run_dialog(cls, window, formDict: FormDict, title: str = "") -> None:  # TODO changed from dict, change everywhere
+        if title:
+            window.title = title
+
+        # NOTE Sections (~ nested dicts) are not implemented, they flatten
+        fd: dict[str, FormFieldTextual] = formDict
+        widgets: list[Checkbox | Input] = [f.get_widget() for f in flatten(fd)]
+        window.widgets = widgets
+
+        if not window.run():
+            raise Cancelled
+
+        # validate and store the UI value → FormField value → original value
+        if not all(field._link.update(field.value) for field in widgets):
+            return cls.run_dialog(TextualApp(), formDict, title)
+
+    def compose(self) -> ComposeResult:
+        if self.title:
+            yield Header()
+        yield Footer()
+        with VerticalScroll():
+            for fieldt in self.widgets:
+                fieldt: FormFieldTextual
+                if isinstance(fieldt, Input):
+                    yield Label(fieldt.placeholder)
+                yield fieldt
+                yield Label(fieldt._link.description)
+                yield Label("")
+
+    def on_mount(self):
+        self.widgets[self.focused_i].focus()
+
+    def action_confirm(self):
+        # next time, start on the same widget
+        # NOTE the functionality is probably not used
+        self.focused_i = next((i for i, inp in enumerate(self.widgets) if inp == self.focused), None)
+        self.exit(True)
+
+    def action_exit(self):
+        self.exit()
+
+    def on_key(self, event: events.Key) -> None:
+        try:
+            index = self.widgets.index(self.focused)
+        except ValueError:  # probably some other element were focused
+            return
+        match event.key:
+            case "down":
+                self.widgets[(index + 1) % len(self.widgets)].focus()
+            case "up":
+                self.widgets[(index - 1) % len(self.widgets)].focus()
+            case letter if len(letter) == 1:  # navigate by letters
+                for inp_ in self.widgets[index+1:] + self.widgets[:index]:
+                    label = inp_.label if isinstance(inp_, Checkbox) else inp_.placeholder
+                    if str(label).casefold().startswith(letter):
+                        inp_.focus()
+                        break
+
+
+class TextualButtonApp(App):
+    CSS = """
+    Screen {
+        layout: grid;
+        grid-size: 2;
+        grid-gutter: 2;
+        padding: 2;
+    }
+    #question {
+        width: 100%;
+        height: 100%;
+        column-span: 2;
+        content-align: center bottom;
+        text-style: bold;
+    }
+
+    Button {
+        width: 100%;
+    }
+    """
+
+    BINDINGS = [
+        ("escape", "exit", "Cancel"),
+    ]
+
+    def __init__(self):
+        super().__init__()
+        self.title = ""
+        self.text: str = ""
+        self._buttons = None
+        self.focused_i: int = 0
+        self.values = {}
+
+    def yes_no(self, text: str, focus_no=True) -> DummyWrapper:
+        return self.buttons(text, [("Yes", True), ("No", False)], int(focus_no))
+
+    def buttons(self, text: str, buttons: list[tuple[str, Any]], focused: int = 0):
+        self.text = text
+        self._buttons = buttons
+        self.focused_i = focused
+
+        ret = self.run()
+        if not ret:
+            raise Cancelled
+        return ret
+
+    def compose(self) -> ComposeResult:
+        yield Footer()
+        yield Label(self.text, id="question")
+
+        self.values.clear()
+        for i, (text, value) in enumerate(self._buttons):
+            id_ = "button"+str(i)
+            self.values[id_] = value
+            b = Button(text, id=id_)
+            if i == self.focused_i:
+                b.focus()
+            yield b
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        self.exit(DummyWrapper(self.values[event.button.id]))
+
+    def action_exit(self):
+        self.exit()

{mininterface-0.1.1 → mininterface-0.4.1}/mininterface/TuiInterface.py

@@ -1,5 +1,5 @@
 from pprint import pprint
-from .auxiliary import ConfigInstance, FormDict, dataclass_to_dict, dict_to_dataclass
+from .auxiliary import ConfigInstance, FormDict, config_to_formdict, config_from_dict
 from .Mininterface import Cancelled, Mininterface
 
 
@@ -26,11 +26,11 @@ class TuiInterface(Mininterface):
         #   dict_to_dataclass(self.args, params_)
         return self.ask_form(self.args)
 
-    def ask_form(self, args: FormDict) -> dict:
+    def ask_form(self, form: FormDict) -> dict:
         # NOTE: This is minimal implementation that should rather go the ReplInterface.
         print("Access `v` (as var) and change values. Then (c)ontinue.")
-        pprint(args)
-        v = args
+        pprint(form)
+        v = form
         try:
             import ipdb
             ipdb.set_trace()
@@ -38,8 +38,8 @@ class TuiInterface(Mininterface):
             import pdb
             pdb.set_trace()
         print("*Continuing*")
-        print(args)
-        return args
+        print(form)
+        return form
 
     def ask_number(self, text):
         """

{mininterface-0.1.1 → mininterface-0.4.1}/mininterface/__init__.py

@@ -13,7 +13,8 @@ except ImportError:
 
 from mininterface.Mininterface import ConfigClass, ConfigInstance, Mininterface
 from mininterface.TuiInterface import ReplInterface, TuiInterface
-from mininterface.auxiliary import Value
+from mininterface.TextualInterface import TextualInterface
+from mininterface.auxiliary import FormField
 
 # TODO auto-handle verbosity https://brentyi.github.io/tyro/examples/04_additional/12_counters/ ?
 # TODO example on missing required options.
@@ -53,4 +54,4 @@ def run(config: ConfigClass | None = None,
     return interface
 
 
-__all__ = ["run", "Value"]
+__all__ = ["run", "FormField"]

mininterface-0.4.1/mininterface/auxiliary.py

@@ -0,0 +1,327 @@
+import logging
+import os
+import re
+from argparse import Action, ArgumentParser
+from dataclasses import dataclass
+from typing import Any, Callable, Iterable, Literal, Optional, Self, TypeVar, Union, get_args, get_type_hints
+from unittest.mock import patch
+
+try:
+    # NOTE this should be clean up and tested on a machine without tkinter installable
+    from tkinter import END, Entry, Text, Tk, Widget
+    from tkinter.ttk import Checkbutton, Combobox
+    from tkinter_form import Value
+except ImportError:
+    tkinter = None
+    END, Entry, Text, Tk, Widget = (None,)*5
+
+    @dataclass
+    class Value:
+        """ This class helps to enrich the field with a description. """
+        val: Any
+        description: str
+
+
+from tyro import cli
+from tyro._argparse_formatter import TyroArgumentParser
+
+logger = logging.getLogger(__name__)
+
+TD = TypeVar("TD")
+""" dict """
+TK = TypeVar("TK")
+""" dict key """
+
+
+@dataclass
+class FormField(Value):
+    """ Bridge between the input values and a UI widget.
+        Helps to creates a widget from the input value (includes description etc.),
+        then transforms the value back (str to int conversion etc). """
+
+    annotation: Any | None = None
+    """ Used for validation. To convert an empty '' to None. """
+    name: str | None = None  # NOTE: Only TextualInterface uses this by now.
+
+    src: tuple[TD, TK] | None = None
+    """ The original dict to be updated when UI ends. """
+    src2: tuple[TD, TK] | None = None
+    """ The original object to be updated when UI ends.
+    NOTE should be merged to `src`
+    """
+
+    def __post_init__(self):
+        self._original_desc = self.description
+
+    def set_error_text(self, s):
+        self.description = f"{s} {self._original_desc}"
+
+    # TODO add testing
+    def update(self, ui_value):
+        """ UI value → FormField value → original value. (With type conversion and checks.)
+
+            The value has been updated in a UI.
+            Update accordingly the value in the original linked dict
+            the mininterface was invoked with.
+
+            Validates the type and do the transformation.
+            (Ex: Some values might be nulled from "".)
+        """
+        fixed_value = ui_value
+        if self.annotation:
+            if ui_value == "" and type(None) in get_args(self.annotation):
+                # The user is not able to set the value to None, they left it empty.
+                # Cast back to None as None is one of the allowed types.
+                # Ex: `severity: int | None = None`
+                fixed_value = None
+            elif self.annotation == Optional[int]:
+                try:
+                    fixed_value = int(ui_value)
+                except ValueError:
+                    pass
+
+            if not isinstance(fixed_value, self.annotation):
+                self.set_error_text(f"Type must be `{self.annotation}`!")
+                return False  # revision needed
+
+        # keep values if revision needed
+        # We merge new data to the origin. If form is re-submitted, the values will stay there.
+        self.val = ui_value
+
+        # Store to the source user data
+        if self.src:
+            d, k = self.src
+            d[k] = fixed_value
+        else:
+            d, k = self.src2
+            setattr(d, k, fixed_value)
+        return True
+
+        # Fixing types:
+        # This code would support tuple[int, int]:
+        #
+        #     self.types = get_args(self.annotation) \
+        #     if isinstance(self.annotation, UnionType) else (self.annotation, )
+        # "All possible types in a tuple. Ex 'int | str' -> (int, str)"
+        #
+        #
+        # def convert(self):
+        #     """ Convert the self.value to the given self.type.
+        #         The value might be in str due to CLI or TUI whereas the programs wants bool.
+        #     """
+        #     # if self.value == "True":
+        #     #     return True
+        #     # if self.value == "False":
+        #     #     return False
+        #     if type(self.val) is str and str not in self.types:
+        #         try:
+        #             return literal_eval(self.val)  # ex: int, tuple[int, int]
+        #         except:
+        #             raise ValueError(f"{self.name}: Cannot convert value {self.val}")
+        #     return self.val
+
+
+
+
+ConfigInstance = TypeVar("ConfigInstance")
+ConfigClass = Callable[..., ConfigInstance]
+FormDict = dict[str, Union[FormField, 'FormDict']]
+""" Nested form that can have descriptions (through FormField) instead of plain values. """
+
+
+def dict_to_formdict(data: dict, factory=FormField) -> FormDict:
+    fd = {}
+    for key, val in data.items():
+        if isinstance(val, dict):  # nested config hierarchy
+            fd[key] = dict_to_formdict(val, factory=factory)
+        else:  # scalar value
+            # NOTE name=param is not set (yet?) in `config_to_formdict`, neither `src`
+            fd[key] = factory(val, "", name=key, src=(data, key))
+    return fd
+
+
+# NOTE: Not used, remove
+def config_to_formdict(args: ConfigInstance, descr: dict, _path="", factory=FormField) -> FormDict:
+    """ Convert the dataclass produced by tyro into dict of dicts. """
+    main = ""
+    params = {main: {}} if not _path else {}
+    for param, val in vars(args).items():
+        annotation = None
+        if val is None:
+            wanted_type = get_type_hints(args.__class__).get(param)
+            if wanted_type in (Optional[int], Optional[str]):
+                # Since tkinter_form does not handle None yet, we have help it.
+                # We need it to be able to write a number and if empty, return None.
+                # This would fail: `severity: int | None = None`
+                # Here, we convert None to str(""), in normalize_types we convert it back.
+                annotation = wanted_type
+                val = ""
+            else:
+                # An unknown type annotation encountered-
+                # Since tkinter_form does not handle None yet, this will display as checkbox.
+                # Which is not probably wanted.
+                val = False
+                logger.warn(f"Annotation {wanted_type} of `{param}` not supported by Mininterface."
+                            "None converted to False.")
+        if hasattr(val, "__dict__"):  # nested config hierarchy
+            params[param] = config_to_formdict(val, descr, _path=f"{_path}{param}.", factory=factory)
+        elif not _path:  # scalar value in root
+            params[main][param] = factory(val, descr.get(param), annotation, param, src2=(args, param))
+        else:  # scalar value in nested
+            params[param] = factory(val, descr.get(f"{_path}{param}"), annotation, param, src2=(args, param))
+    return params
+
+# NOTE: Not used, remove
+def fix_types(origin: FormDict, data: dict) -> dict:
+    """ Run validators of all FormField objects. If fails, outputs info.
+        Return corrected data. (Ex: Some values might be nulled from "".)
+    """
+    def check(ordict, orkey, orval, dataPos: dict, dataKey, val):
+        if isinstance(orval, FormField) and orval.annotation:
+            fixed_val = val
+            if val == "" and type(None) in get_args(orval.annotation):
+                # The user is not able to set the value to None, they left it empty.
+                # Cast back to None as None is one of the allowed types.
+                # Ex: `severity: int | None = None`
+                dataPos[dataKey] = fixed_val = None
+            elif orval.annotation == Optional[int]:
+                try:
+                    dataPos[dataKey] = fixed_val = int(val)
+                except ValueError:
+                    pass
+
+            if not isinstance(fixed_val, orval.annotation):
+                orval.set_error_text(f"Type must be `{orval.annotation}`!")
+                raise RuntimeError  # revision needed
+
+        # keep values if revision needed
+        # We merge new data to the origin. If form is re-submitted, the values will stay there.
+        if isinstance(orval, FormField):
+            orval.val = val
+        else:
+            ordict[orkey] = val
+
+    try:
+        for (key1, val1), (orkey1, orval1) in zip(data.items(), origin.items()):
+            if isinstance(val1, dict):  # nested config hierarchy
+                # NOTE: This allows only single nested dict.
+                for (key2, val2), (orkey2, orval2) in zip(val1.items(), orval1.items()):
+                    check(orval1, orkey2, orval2, data[key1], key2, val2)
+            else:
+                check(origin, orkey1, orval1, data, key1, val1)
+    except RuntimeError:
+        return False
+
+    return data
+
+
+def config_from_dict(args: ConfigInstance, data: dict):
+    """ Fetch back data.
+        Merge the dict of dicts from the GUI back into the object holding the configuration. """
+    for group, params in data.items():
+        for key, val in params.items():
+            if group:
+                setattr(getattr(args, group), key, val.val if isinstance(val, FormField) else val)
+            else:
+                setattr(args, key, val.val if isinstance(val, FormField) else val)
+
+
+def get_terminal_size():
+    try:
+        # XX when piping the input IN, it writes
+        # echo "434" | convey -f base64  --debug
+        # stty: 'standard input': Inappropriate ioctl for device
+        # I do not know how to suppress this warning.
+        height, width = (int(s) for s in os.popen('stty size', 'r').read().split())
+        return height, width
+    except (OSError, ValueError):
+        return 0, 0
+
+
+def get_args_allow_missing(config: ConfigClass, kwargs: dict, parser: ArgumentParser):
+    """ Fetch missing required options in GUI. """
+    # On missing argument, tyro fail. We cannot determine which one was missing, except by intercepting
+    # the error message function. Then, we reconstruct the missing options.
+    # NOTE But we should rather invoke a GUI with the missing options only.
+    original_error = TyroArgumentParser.error
+    eavesdrop = ""
+
+    def custom_error(self, message: str):
+        nonlocal eavesdrop
+        if not message.startswith("the following arguments are required:"):
+            return original_error(self, message)
+        eavesdrop = message
+        raise SystemExit(2)  # will be catched
+    try:
+        with patch.object(TyroArgumentParser, 'error', custom_error):
+            return cli(config, **kwargs)
+    except BaseException as e:
+        if hasattr(e, "code") and e.code == 2 and eavesdrop:  # Some arguments are missing. Determine which.
+            for arg in eavesdrop.partition(":")[2].strip().split(", "):
+                argument: Action = next(iter(p for p in parser._actions if arg in p.option_strings))
+                argument.default = "HALO"
+                if "." in argument.dest:  # missing nested required argument handler not implemented, we make tyro fail in CLI
+                    pass
+                else:
+                    match argument.metavar:
+                        case "INT":
+                            setattr(kwargs["default"], argument.dest, 0)
+                        case "STR":
+                            setattr(kwargs["default"], argument.dest, "")
+                        case _:
+                            pass  # missing handler not implemented, we make tyro fail in CLI
+            return cli(config, **kwargs)  # second attempt
+        raise
+
+
+def get_descriptions(parser: ArgumentParser) -> dict:
+    """ Load descriptions from the parser. Strip argparse info about the default value as it will be editable in the form. """
+    return {action.dest.replace("-", "_"): re.sub(r"\(default.*\)", "", action.help)
+            for action in parser._actions}
+
+
+class RedirectText:
+    """ Helps to redirect text from stdout to a text widget. """
+
+    def __init__(self, widget: Text, pending_buffer: list, window: Tk) -> None:
+        self.widget = widget
+        self.max_lines = 1000
+        self.pending_buffer = pending_buffer
+        self.window = window
+
+    def write(self, text):
+        self.widget.pack(expand=True, fill='both')
+        self.widget.insert(END, text)
+        self.widget.see(END)  # scroll to the end
+        self.trim()
+        self.window.update_idletasks()
+        self.pending_buffer.append(text)
+
+    def flush(self):
+        pass  # required by sys.stdout
+
+    def trim(self):
+        lines = int(self.widget.index('end-1c').split('.')[0])
+        if lines > self.max_lines:
+            self.widget.delete(1.0, f"{lines - self.max_lines}.0")
+
+
+def recursive_set_focus(widget: Widget):
+    for child in widget.winfo_children():
+        if isinstance(child, (Entry, Checkbutton, Combobox)):
+            child.focus_set()
+            return True
+        if recursive_set_focus(child):
+            return True
+
+
+T = TypeVar("T")
+
+
+def flatten(d: dict[str, T | dict]) -> Iterable[T]:
+    """ Recursively traverse whole dict """
+    for v in d.values():
+        if isinstance(v, dict):
+            yield from flatten(v)
+        else:
+            yield v

{mininterface-0.1.1 → mininterface-0.4.1}/pyproject.toml

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

mininterface-0.1.1/mininterface/auxiliary.py

@@ -1,195 +0,0 @@
-import logging
-import os
-import re
-from argparse import Action, ArgumentParser
-from dataclasses import dataclass
-from typing import Any, Callable, Literal, Optional, TypeVar, Union, get_args, get_type_hints
-from unittest.mock import patch
-
-try:
-    # NOTE this should be clean up and tested on a machine without tkinter installable
-    from tkinter import END, Entry, Text, Tk, Widget
-    from tkinter.ttk import Checkbutton, Combobox
-except ImportError:
-    tkinter = None
-    END, Entry, Text, Tk, Widget = (None,)*5
-
-from tkinter_form import Value
-from tyro import cli
-from tyro._argparse_formatter import TyroArgumentParser
-
-logger = logging.getLogger(__name__)
-
-
-@dataclass
-class Value(Value):
-    """ Override val/description class with additional stuff. """
-
-    annotation: Any | None = None
-    """ Used for validation. To convert an empty '' to None. """
-
-    def __post_init__(self):
-        self._original_desc = self.description
-
-    def set_error_text(self, s):
-        self.description = f"{s} {self._original_desc}"
-
-
-ConfigInstance = TypeVar("ConfigInstance")
-ConfigClass = Callable[..., ConfigInstance]
-FormDict = dict[str, Union[Value, Any, 'FormDict']]
-""" Nested form that can have descriptions (through Value) instead of plain values. """
-
-
-def dataclass_to_dict(args: ConfigInstance, descr: dict, _path="") -> FormDict:
-    """ Convert the dataclass produced by tyro into dict of dicts. """
-    main = ""
-    params = {main: {}} if not _path else {}
-    for param, val in vars(args).items():
-        annotation = None
-        if val is None:
-            wanted_type = get_type_hints(args.__class__).get(param)
-            if wanted_type in (Optional[int], Optional[str]):
-                # Since tkinter_form does not handle None yet, we have help it.
-                # We need it to be able to write a number and if empty, return None.
-                # This would fail: `severity: int | None = None`
-                # Here, we convert None to str(""), in normalize_types we convert it back.
-                annotation = wanted_type
-                val = ""
-            else:
-                # An unknown type annotation encountered-
-                # Since tkinter_form does not handle None yet, this will display as checkbox.
-                # Which is not probably wanted.
-                val = False
-                logger.warn(f"Annotation {wanted_type} of `{param}` not supported by Mininterface."
-                            "None converted to False.")
-        if hasattr(val, "__dict__"):  # nested config hierarchy
-            params[param] = dataclass_to_dict(val, descr, _path=f"{_path}{param}.")
-        elif not _path:  # scalar value in root
-            params[main][param] = Value(val, descr.get(param), annotation)
-        else:  # scalar value in nested
-            params[param] = Value(val, descr.get(f"{_path}{param}"), annotation)
-    return params
-
-
-def normalize_types(origin: FormDict, data: dict) -> dict:
-    """ Run validators of all Value objects. If fails, outputs info.
-        Return corrected data. (Ex: Some values might be nulled from "".)
-    """
-    for (group, params), params2 in zip(data.items(), origin.values()):
-        for (key, val), pattern in zip(params.items(), params2.values()):
-            if isinstance(pattern, Value) and pattern.annotation:
-                if val == "" and type(None) in get_args(pattern.annotation):
-                    # The user is not able to set the value to None, they left it empty.
-                    # Cast back to None as None is one of the allowed types.
-                    # Ex: `severity: int | None = None`
-                    data[group][key] = val = None
-                elif pattern.annotation == Optional[int]:
-                    try:
-                        data[group][key] = val = int(val)
-                    except ValueError:
-                        pass
-
-                if not isinstance(val, pattern.annotation):
-                    pattern.set_error_text(f"Type must be `{pattern.annotation}`!")
-                    return False
-    return data
-
-
-def dict_to_dataclass(args: ConfigInstance, data: dict):
-    """ Convert the dict of dicts from the GUI back into the object holding the configuration. """
-    for group, params in data.items():
-        for key, val in params.items():
-            if group:
-                setattr(getattr(args, group), key, val)
-            else:
-                setattr(args, key, val)
-
-
-def get_terminal_size():
-    try:
-        # XX when piping the input IN, it writes
-        # echo "434" | convey -f base64  --debug
-        # stty: 'standard input': Inappropriate ioctl for device
-        # I do not know how to suppress this warning.
-        height, width = (int(s) for s in os.popen('stty size', 'r').read().split())
-        return height, width
-    except (OSError, ValueError):
-        return 0, 0
-
-
-def get_args_allow_missing(config: ConfigClass, kwargs: dict, parser: ArgumentParser):
-    """ Fetch missing required options in GUI. """
-    # On missing argument, tyro fail. We cannot determine which one was missing, except by intercepting
-    # the error message function. Then, we reconstruct the missing options.
-    # NOTE But we should rather invoke a GUI with the missing options only.
-    original_error = TyroArgumentParser.error
-    eavesdrop = ""
-
-    def custom_error(self, message: str):
-        nonlocal eavesdrop
-        if not message.startswith("the following arguments are required:"):
-            return original_error(self, message)
-        eavesdrop = message
-        raise SystemExit(2)  # will be catched
-    try:
-        with patch.object(TyroArgumentParser, 'error', custom_error):
-            return cli(config, **kwargs)
-    except BaseException as e:
-        if hasattr(e, "code") and e.code == 2 and eavesdrop:  # Some arguments are missing. Determine which.
-            for arg in eavesdrop.partition(":")[2].strip().split(", "):
-                argument: Action = next(iter(p for p in parser._actions if arg in p.option_strings))
-                argument.default = "HALO"
-                if "." in argument.dest:  # missing nested required argument handler not implemented, we make tyro fail in CLI
-                    pass
-                else:
-                    match argument.metavar:
-                        case "INT":
-                            setattr(kwargs["default"], argument.dest, 0)
-                        case "STR":
-                            setattr(kwargs["default"], argument.dest, "")
-                        case _:
-                            pass  # missing handler not implemented, we make tyro fail in CLI
-            return cli(config, **kwargs)  # second attempt
-        raise
-
-
-def get_descriptions(parser: ArgumentParser) -> dict:
-    """ Load descriptions from the parser. Strip argparse info about the default value as it will be editable in the form. """
-    return {action.dest.replace("-", "_"): re.sub(r"\(default.*\)", "", action.help)
-            for action in parser._actions}
-
-
-class RedirectText:
-    """ Helps to redirect text from stdout to a text widget. """
-
-    def __init__(self, widget: Text, pending_buffer: list, window: Tk) -> None:
-        self.widget = widget
-        self.max_lines = 1000
-        self.pending_buffer = pending_buffer
-        self.window = window
-
-    def write(self, text):
-        self.widget.pack(expand=True, fill='both')
-        self.widget.insert(END, text)
-        self.widget.see(END)  # scroll to the end
-        self.trim()
-        self.window.update_idletasks()
-        self.pending_buffer.append(text)
-
-    def flush(self):
-        pass  # required by sys.stdout
-
-    def trim(self):
-        lines = int(self.widget.index('end-1c').split('.')[0])
-        if lines > self.max_lines:
-            self.widget.delete(1.0, f"{lines - self.max_lines}.0")
-
-
-def recursive_set_focus(widget: Widget):
-    for child in widget.winfo_children():
-        if isinstance(child, (Entry, Checkbutton, Combobox)):
-            child.focus_set()
-            return True
-        if recursive_set_focus(child):
-            return True