mininterface 0.7.3__tar.gz → 0.7.5__tar.gz

{mininterface-0.7.3 → mininterface-0.7.5}/PKG-INFO

@@ -1,8 +1,7 @@
 Metadata-Version: 2.3
 Name: mininterface
-Version: 0.7.3
+Version: 0.7.5
 Summary: A minimal access to GUI, TUI, CLI and config
-Home-page: https://github.com/CZ-NIC/mininterface
 License: GPL-3.0-or-later
 Author: Edvard Rejthar
 Author-email: edvard.rejthar@nic.cz
@@ -13,20 +12,16 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
-Provides-Extra: all
-Provides-Extra: gui
-Provides-Extra: img
-Provides-Extra: tui
-Provides-Extra: web
 Requires-Dist: autocombobox (==1.4.2)
 Requires-Dist: humanize
 Requires-Dist: pyyaml
-Requires-Dist: textual (>=0.84,<0.85)
+Requires-Dist: textual (<2.0.0)
 Requires-Dist: tkinter-tooltip
 Requires-Dist: tkinter_form (==0.2.1)
 Requires-Dist: tkscrollableframe
 Requires-Dist: typing_extensions
-Requires-Dist: tyro (==0.8.14)
+Requires-Dist: tyro (>=0.9,<0.10)
+Project-URL: Homepage, https://github.com/CZ-NIC/mininterface
 Description-Content-Type: text/markdown
 
 # Mininterface – access to GUI, TUI, CLI and config files
@@ -70,6 +65,7 @@ if __name__ == "__main__":
 - [Background](#background)
 - [Installation](#installation)
 - [Docs](#docs)
+- [Gallery](#gallery)
 - [Examples](#examples)
 
 ## You got CLI
@@ -152,6 +148,13 @@ If the GUI does not work on MacOS, you might need to launch: `brew install pytho
 # Docs
 See the docs overview at [https://cz-nic.github.io/mininterface/](https://cz-nic.github.io/mininterface/Overview/).
 
+# Gallery
+
+These projects have the code base reduced thanks to the mininterface:
+
+* **[deduplidog](https://github.com/CZ-NIC/deduplidog/)** – Find duplicates in a scattered directory structure
+* **[touch-timestamp](https://github.com/CZ-NIC/touch-timestamp/)** – A powerful dialog to change the files' timestamp
+
 # Examples
 
 A powerful [`m.form`](https://cz-nic.github.io/mininterface/Mininterface/#mininterface.Mininterface.form) dialog method accepts either a dataclass or a dict. Take a look on both.

{mininterface-0.7.3 → mininterface-0.7.5}/README.md

@@ -39,6 +39,7 @@ if __name__ == "__main__":
 - [Background](#background)
 - [Installation](#installation)
 - [Docs](#docs)
+- [Gallery](#gallery)
 - [Examples](#examples)
 
 ## You got CLI
@@ -121,6 +122,13 @@ If the GUI does not work on MacOS, you might need to launch: `brew install pytho
 # Docs
 See the docs overview at [https://cz-nic.github.io/mininterface/](https://cz-nic.github.io/mininterface/Overview/).
 
+# Gallery
+
+These projects have the code base reduced thanks to the mininterface:
+
+* **[deduplidog](https://github.com/CZ-NIC/deduplidog/)** – Find duplicates in a scattered directory structure
+* **[touch-timestamp](https://github.com/CZ-NIC/touch-timestamp/)** – A powerful dialog to change the files' timestamp
+
 # Examples
 
 A powerful [`m.form`](https://cz-nic.github.io/mininterface/Mininterface/#mininterface.Mininterface.form) dialog method accepts either a dataclass or a dict. Take a look on both.

{mininterface-0.7.3 → mininterface-0.7.5}/mininterface/__init__.py

@@ -8,7 +8,7 @@ from .exceptions import Cancelled, InterfaceNotAvailable
 from .interfaces import get_interface
 
 from . import validators
-from .cli_parser import _parse_cli, assure_args
+from .cli_parser import parse_cli, assure_args
 from .subcommands import Command, SubcommandPlaceholder
 from .form_dict import DataClass, EnvClass
 from .mininterface import EnvClass, Mininterface
@@ -183,22 +183,22 @@ def run(env_or_list: Type[EnvClass] | list[Type[Command]] | None = None,
         start.choose_subcommand(env_or_list)
     elif env_or_list:
         # Load configuration from CLI and a config file
-        env, wrong_fields = _parse_cli(env_or_list, config_file, add_verbosity, ask_for_missing, args, **kwargs)
+        env, wrong_fields = parse_cli(env_or_list, config_file, add_verbosity, ask_for_missing, args, **kwargs)
     else:  # even though there is no configuration, yet we need to parse CLI for meta-commands like --help or --verbose
-        _parse_cli(_Empty, None, add_verbosity, ask_for_missing, args)
+        parse_cli(_Empty, None, add_verbosity, ask_for_missing, args)
 
     # Build the interface
-    interface = get_interface(title, interface, env)
+    m = get_interface(title, interface, env)
 
     # Empty CLI → GUI edit
     if ask_for_missing and wrong_fields:
         # Some fields must be set.
-        interface.form(wrong_fields)
-        {setattr(interface.env, k, v.val) for k, v in wrong_fields.items()}
+        m.form(wrong_fields)
+        {setattr(m.env, k, v.val) for k, v in wrong_fields.items()}
     elif ask_on_empty_cli and len(sys.argv) <= 1:
-        interface.form()
+        m.form()
 
-    return interface
+    return m
 
 
 __all__ = ["run", "Tag", "validators", "InterfaceNotAvailable", "Cancelled",

{mininterface-0.7.3 → mininterface-0.7.5}/mininterface/auxiliary.py

@@ -25,6 +25,7 @@ def flatten(d: dict[str, T | dict], include_keys: Optional[Callable[[str], list]
             yield v
 
 
+# NOTE: Not used.
 def flatten_keys(d: dict[KT, T | dict]) -> Iterable[tuple[KT, T]]:
     """ Recursively traverse whole dict """
     for k, v in d.items():
@@ -70,15 +71,6 @@ def yield_annotations(dataclass):
     yield from (cl.__annotations__ for cl in dataclass.__mro__ if is_dataclass(cl))
 
 
-def yield_defaults(dataclass):
-    """ Return tuple(name, type, default value or MISSING).
-    (Default factory is automatically resolved.)
-    """
-    return ((f.name,
-             f.default_factory() if f.default_factory is not MISSING else f.default)
-            for f in fields(dataclass))
-
-
 def matches_annotation(value, annotation) -> bool:
     """ Check whether the value type corresponds to the annotation.
     Because built-in isinstance is not enough, it cannot determine parametrized generics.
@@ -138,7 +130,10 @@ def subclass_matches_annotation(cls, annotation) -> bool:
             return True
 
     # simple types like scalars
-    return issubclass(cls, annotation)
+    try:
+        return issubclass(cls, annotation)  # cls=tuple[int, str] raises an error since Python 3.13
+    except TypeError:
+        return False
 
 
 def serialize_structure(obj):

{mininterface-0.7.3 → mininterface-0.7.5}/mininterface/cli_parser.py

@@ -6,7 +6,7 @@ import sys
 import warnings
 from argparse import Action, ArgumentParser
 from contextlib import ExitStack
-from dataclasses import MISSING
+from dataclasses import MISSING, fields, is_dataclass
 from pathlib import Path
 from types import SimpleNamespace
 from typing import Optional, Sequence, Type, Union
@@ -15,12 +15,12 @@ from unittest.mock import patch
 import yaml
 from tyro import cli
 from tyro._argparse_formatter import TyroArgumentParser
-from tyro._fields import NonpropagatingMissingType
-# NOTE in the future versions of tyro, include that way:
-# from tyro._singleton import NonpropagatingMissingType
+from tyro._singleton import MISSING_NONPROP
 from tyro.extras import get_parser
 
-from .auxiliary import yield_annotations, yield_defaults
+
+from .auxiliary import yield_annotations
+from .config import MininterfaceConfig, Config
 from .form_dict import EnvClass, MissingTagValue
 from .tag import Tag
 from .tag_factory import tag_factory
@@ -137,8 +137,9 @@ def run_tyro_parser(env_or_list: Type[EnvClass] | list[Type[EnvClass]],
         with ExitStack() as stack:
             [stack.enter_context(p) for p in patches]  # apply just the chosen mocks
             res = cli(type_form, args=args, **kwargs)
-            if isinstance(res, NonpropagatingMissingType):
-                # NOTE tyro does not work if a required positional is missing tyro.cli() returns just NonpropagatingMissingType.
+            if res is MISSING_NONPROP:
+                # NOTE tyro does not work if a required positional is missing tyro.cli()
+                # returns just NonpropagatingMissingType (MISSING_NONPROP).
                 # If this is supported, I might set other attributes like required (date, time).
                 # Fail if missing:
                 #   files: Positional[list[Path]]
@@ -217,12 +218,12 @@ def set_default(kwargs, field_name, val):
     setattr(kwargs["default"], field_name, val)
 
 
-def _parse_cli(env_or_list: Type[EnvClass] | list[Type[EnvClass]],
-               config_file: Path | None = None,
-               add_verbosity=True,
-               ask_for_missing=True,
-               args=None,
-               **kwargs) -> tuple[EnvClass | None, dict, WrongFields]:
+def parse_cli(env_or_list: Type[EnvClass] | list[Type[EnvClass]],
+              config_file: Path | None = None,
+              add_verbosity=True,
+              ask_for_missing=True,
+              args=None,
+              **kwargs) -> tuple[EnvClass | None, dict, WrongFields]:
     """ Parse CLI arguments, possibly merged from a config file.
 
     Args:
@@ -243,41 +244,94 @@ def _parse_cli(env_or_list: Type[EnvClass] | list[Type[EnvClass]],
     # Load config file
     if config_file and subcommands:
         # Reading config files when using subcommands is not implemented.
-        static = {}
         kwargs["default"] = None
         warnings.warn(f"Config file {config_file} is ignored because subcommands are used."
                       " It is not easy to set how this should work."
                       " Describe the developer your usecase so that they might implement this.")
-    if "default" not in kwargs and not subcommands:
+
+    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 = {}
-        if config_file:
-            disk = yaml.safe_load(config_file.read_text()) or {}  # empty file is ok
-            # Nested dataclasses have to be properly initialized. YAML gave them as dicts only.
-            for key in (key for key, val in disk.items() if isinstance(val, dict)):
-                disk[key] = env.__annotations__[key](**disk[key])
-
-        # Fill default fields
-        if pydantic and issubclass(env, BaseModel):
-            # Unfortunately, pydantic needs to fill the default with the actual values,
-            # the default value takes the precedence over the hard coded one, even if missing.
-            static = {key: env.model_fields.get(key).default
-                      for ann in yield_annotations(env) for key in ann if not key.startswith("__") and not key in disk}
-            # static = {key: env_.model_fields.get(key).default
-            #           for key, _ in iterate_attributes(env_) if not key in disk}
-        elif attr and attr.has(env):
-            # Unfortunately, attrs needs to fill the default with the actual values,
-            # the default value takes the precedence over the hard coded one, even if missing.
-            # NOTE Might not work for inherited models.
-            static = {key: field.default
-                      for key, field in attr.fields_dict(env).items() if not key.startswith("__") and not key in disk}
-        else:
-            # To ensure the configuration file does not need to contain all keys, we have to fill in the missing ones.
-            # Otherwise, tyro will spawn warnings about missing fields.
-            static = {key: val
-                      for key, val in yield_defaults(env) if not key.startswith("__") and not key in disk}
-        kwargs["default"] = SimpleNamespace(**(static | disk))
+        disk = yaml.safe_load(config_file.read_text()) or {}  # empty file is ok
+        if mininterface := disk.pop("mininterface", None):
+            # Section 'mininterface' in the config file changes the global configuration.
+            for key, value in vars(_create_with_missing(MininterfaceConfig, mininterface)).items():
+                setattr(Config, key, value)
+        kwargs["default"] = _create_with_missing(env, disk)
 
     # Load configuration from CLI
     return run_tyro_parser(subcommands or env, kwargs, add_verbosity, ask_for_missing, args)
+
+
+def _create_with_missing(env, disk: dict):
+    """
+    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.
+    """
+
+    # Determine model
+    if pydantic and issubclass(env, BaseModel):
+        m = _process_pydantic
+    elif attr and attr.has(env):
+        m = _process_attr
+    else:  # dataclass
+        m = _process_dataclass
+
+    # Fill default fields with the config file values or leave the defaults.
+    # Unfortunately, we have to fill the defaults, we cannot leave them empty
+    # as the default value takes the precedence over the hard coded one, even if missing.
+    out = {}
+    for name, v in m(env, disk):
+        out[name] = v
+        disk.pop(name, None)
+
+    # Check for unknown fields
+    if disk:
+        warnings.warn(f"Unknown fields in the configuration file: {', '.join(disk)}")
+
+    # Safely initialize the model
+    return env(**out)
+
+
+def _process_pydantic(env, disk):
+    for name, f in env.model_fields.items():
+        if name in disk:
+            if isinstance(f.default, BaseModel):
+                v = _create_with_missing(f.default.__class__, disk[name])
+            else:
+                v = disk[name]
+        elif f.default is not None:
+            v = f.default
+        yield name, v
+
+
+def _process_attr(env, disk):
+    for f in attr.fields(env):
+        if f.name in disk:
+            if attr.has(f.default):
+                v = _create_with_missing(f.default.__class__, disk[f.name])
+            else:
+                v = disk[f.name]
+        elif f.default is not attr.NOTHING:
+            v = f.default
+        else:
+            v = MISSING_NONPROP
+        yield f.name, v
+
+
+def _process_dataclass(env, disk):
+    for f in fields(env):
+        if f.name.startswith("__"):
+            continue
+        elif f.name in disk:
+            if is_dataclass(f.type):
+                v = _create_with_missing(f.type, disk[f.name])
+            else:
+                v = disk[f.name]
+        elif f.default_factory is not MISSING:
+            v = f.default_factory()
+        elif f.default is not MISSING:
+            v = f.default
+        else:
+            v = MISSING_NONPROP
+        yield f.name, v

mininterface-0.7.5/mininterface/config.py

@@ -0,0 +1,28 @@
+# Configuration used by all minterfaces in the program.
+# Might be changed by a 'mininterface' section in a config file.
+from dataclasses import dataclass
+from typing import Literal
+
+
+@dataclass
+class Gui:
+    combobox_since: int = 5
+    """ The threshold to switch from radio buttons to a combobox. """
+    test: bool = False
+
+
+@dataclass
+class Tui:
+    ...
+
+
+@dataclass  # (slots=True)
+class MininterfaceConfig:
+    gui: Gui
+    tui: Tui
+    interface: Literal["gui"] | Literal["tui"] | None = None
+    """ Enforce an interface. By default, we choose automatically. """
+
+
+Config = MininterfaceConfig(Gui(), Tui())
+""" Global configuration singleton to be accessed by all minterfaces. """

{mininterface-0.7.3 → mininterface-0.7.5}/mininterface/experimental.py

@@ -53,7 +53,3 @@ class FacetCallback():
     """
     pass
     # NOTE, just a stub. Deprecated, use CallbackTag instead.
-
-
-# NOTE should we use the dataclasses, isn't that slow?
-MININTERFACE_CONFIG = {"gui": {"combobox_since": 5}}

{mininterface-0.7.3 → mininterface-0.7.5}/mininterface/facet.py

@@ -19,11 +19,14 @@ if TYPE_CHECKING:
 
 @dataclass
 class Image:
-    """ NOTE. Experimental. Undocumented. """
+    """ NOTE. Experimental. """
+
     src: str | Path
+    """ Src to the image. """
 
 
 LayoutElement = TypeVar("LayoutElement", str, Image, Path, "Self")
+""" Either a string, Path or facet.Image. """
 
 
 class BackendAdaptor(ABC):
@@ -102,7 +105,7 @@ class Facet(Generic[EnvClass]):
         print("Title", text)
 
     def _layout(self, elements: list[LayoutElement]):
-        """ Experimental. """
+        """ Experimental. Input is a list of `LayoutElements`."""
         # NOTE remove warn when working in textual
         warn("Facet layout not implemented for this interface.")
 
@@ -120,6 +123,7 @@ class Facet(Generic[EnvClass]):
             "My choice": Tag(choices=["one", "two"], on_change=callback)
         })
         # continue here immediately after clicking on a radio button
+        ```
 
         """
         self.adaptor.post_submit_action = _post_submit

{mininterface-0.7.3 → mininterface-0.7.5}/mininterface/interfaces.py

@@ -3,6 +3,8 @@ from importlib import import_module
 import sys
 from typing import Literal, Type
 
+
+from .config import Config
 from .mininterface import Mininterface
 from .exceptions import InterfaceNotAvailable
 from .text_interface import TextInterface
@@ -38,6 +40,7 @@ def __getattr__(name):
 
 def get_interface(title="", interface: InterfaceType = None, env=None):
     args = title, env
+    interface = interface or Config.interface
     if isinstance(interface, type) and issubclass(interface, Mininterface):
         # the user gave a specific interface, let them catch InterfaceNotAvailable then
         return interface(*args)

{mininterface-0.7.3 → mininterface-0.7.5}/mininterface/mininterface.py

@@ -115,7 +115,7 @@ class Mininterface(Generic[EnvClass]):
 
         ![Asking number](asset/ask-number.avif)
 
-        However, when run in a non-interactive session with TUI (ex. no display), [TextInterface](Interfaces.md#TextInterface)
+        However, when run in a non-interactive session with TUI (ex. no display), [TextInterface](Interfaces.md#textinterface)
         is used which is able to turn it into an interactive one.
 
         ```python3

{mininterface-0.7.3 → mininterface-0.7.5}/mininterface/showcase.py

@@ -26,15 +26,18 @@ class Subcommand1(SharedArgs):
     my_local: int = 1
 
     def run(self):
+        print("Subcommand 1 clicked")
         print("Common:", self.common)  # user input
         print("Number:", self.my_local)  # 1 or user input
         print("Internal:", self.internal)
+        print("The submit button blocked!")
         raise ValidationFail("The submit button blocked!")
 
 
 @dataclass
 class Subcommand2(SharedArgs):
     def run(self):
+        print("Subcommand 2 clicked")
         self._facet.set_title("Button clicked")  # you can access internal self._facet: Facet
         print("Common files", self.files)
 

{mininterface-0.7.3 → mininterface-0.7.5}/mininterface/textual_interface/textual_adaptor.py

@@ -82,18 +82,11 @@ class TextualAdaptor(BackendAdaptor):
         if title:
             app.title = title
 
-        widgets: WidgetList = [f for f in flatten(formdict_to_widgetdict(
-            form, self.widgetize), include_keys=self.header)]
-        if len(widgets) and isinstance(widgets[0], Rule):
-            # there are multiple sections in the list, <hr>ed by Rule elements. However, the first takes much space.
-            widgets.pop(0)
-        app.widgets = widgets
-
         if not app.run():
             raise Cancelled
 
         # validate and store the UI value → Tag value → original value
-        vals = ((field._link, field.get_ui_value()) for field in widgets if hasattr(field, "_link"))
+        vals = ((field._link, field.get_ui_value()) for field in app.widgets if hasattr(field, "_link"))
         if not Tag._submit_values(vals) or not self.submit_done():
             return self.run_dialog(form, title, submit)
 

{mininterface-0.7.3 → mininterface-0.7.5}/mininterface/textual_interface/textual_app.py

@@ -5,12 +5,15 @@ from textual.binding import Binding
 from textual.containers import VerticalScroll
 from textual.widget import Widget
 from textual.widgets import (Checkbox, Footer, Header, Input, Label,
-                             RadioButton, Static)
+                             RadioButton, Static, Rule)
 
 
 from .widgets import (Changeable, MyButton, MyCheckbox, MyInput, MyRadioSet,
                       MySubmitButton)
 
+from ..form_dict import formdict_to_widgetdict
+
+from ..auxiliary import flatten
 from ..facet import BackendAdaptor
 
 if TYPE_CHECKING:
@@ -52,6 +55,16 @@ class TextualApp(App[bool | None]):
         self.bind("escape", "exit", description="Cancel")
 
     def compose(self) -> ComposeResult:
+        # prepare widgets
+        # since textual 1.0.0 we have to build widgets not earlier than the context app is ready
+        self.widgets = list(flatten(formdict_to_widgetdict(
+            self.adaptor.facet._form, self.adaptor.widgetize), include_keys=self.adaptor.header))
+
+        # there are multiple sections in the list, <hr>ed by Rule elements. However, the first takes much space.
+        if len(self.widgets) and isinstance(self.widgets[0], Rule):
+            self.widgets.pop(0)
+
+        # start yielding widgets
         if self.title:
             yield Header()
         yield self.output  # NOTE not used

{mininterface-0.7.3 → mininterface-0.7.5}/mininterface/tk_interface/utils.py

@@ -1,5 +1,4 @@
-from pathlib import Path, PosixPath
-from tkinter import Button, Entry, Label, TclError, Variable, Widget, Spinbox
+from tkinter import Button, Entry, TclError, Variable, Widget, Spinbox
 from tkinter.filedialog import askopenfilename, askopenfilenames
 from tkinter.ttk import Checkbutton, Combobox, Frame, Radiobutton, Widget
 from typing import TYPE_CHECKING
@@ -8,8 +7,9 @@ from autocombobox import AutoCombobox
 
 from tkinter_form.tkinter_form import Form, FieldForm
 
-from ..auxiliary import flatten, flatten_keys
-from ..experimental import MININTERFACE_CONFIG, FacetCallback, SubmitButton
+from ..auxiliary import flatten
+from ..config import Config
+from ..experimental import FacetCallback, SubmitButton
 from ..form_dict import TagDict
 from ..tag import Tag
 from ..types import DatetimeTag, PathTag
@@ -113,7 +113,7 @@ def replace_widgets(tk_app: "TkWindow", nested_widgets, form: TagDict):
             nested_frame = Frame(master)
             nested_frame.grid(row=grid_info['row'], column=grid_info['column'])
 
-            if len(tag._get_choices()) > MININTERFACE_CONFIG["gui"]["combobox_since"]:
+            if len(tag._get_choices()) >= Config.gui.combobox_since:
                 widget = AutoCombobox(nested_frame, textvariable=variable)
                 widget['values'] = list(tag._get_choices())
                 widget.pack()

{mininterface-0.7.3 → mininterface-0.7.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "mininterface"
-version = "0.7.3"
+version = "0.7.5"
 description = "A minimal access to GUI, TUI, CLI and config"
 authors = ["Edvard Rejthar <edvard.rejthar@nic.cz>"]
 license = "GPL-3.0-or-later"
@@ -14,18 +14,18 @@ readme = "README.md"
 [tool.poetry.dependencies]
 # Minimal requirements
 python = "^3.10"
-tyro = "0.8.14"         # NOTE: 0.9 brings some test breaking changes
+tyro = "^0.9"
 typing_extensions = "*"
 pyyaml = "*"
 # Standard requirements
 autocombobox = "1.4.2"
 humanize = "*"          # used only in the TkInterface, hence it is not a minimal requirement
-textual = "~0.84"
+textual = "<2.0.0"
 tkinter-tooltip = "*"
 tkinter_form = "0.2.1"
 tkscrollableframe = "*"
 
-[tool.poetry.extras]
+[tool.poetry.project.optional-dependencies]
 web = ["textual-serve"]
 img = ["pillow", "textual_imageview"]
 tui = ["textual_imageview"]