mininterface 1.2.1__tar.gz → 1.2.2__tar.gz

{mininterface-1.2.1 → mininterface-1.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mininterface
-Version: 1.2.1
+Version: 1.2.2
 Summary: CLI & dialog toolkit – a minimal interface to Python application (GUI, TUI, CLI + config files, web)
 License: LGPL-3.0-or-later
 License-File: LICENSE
@@ -191,8 +191,8 @@ These projects have the code base reduced thanks to the mininterface:
 Take a look at the following example.
 
 1. We define any Env class.
-2. Then, we initialize mininterface with [`run(Env)`][mininterface.run] – the missing fields will be prompted for
-3. Then, we use various dialog methods, like [`confirm`][mininterface.Mininterface.confirm], [`select`][mininterface.Mininterface.select] or [`form`][mininterface.Mininterface.form].
+2. Then, we initialize mininterface with [`run(Env)`](https://cz-nic.github.io/mininterface/run/) – the missing fields will be prompted for
+3. Then, we use various dialog methods, like [`confirm`](https://cz-nic.github.io/mininterface/Mininterface/#mininterface.Mininterface.confirm), [`select`](https://cz-nic.github.io/mininterface/Mininterface/#mininterface.Mininterface.select) or [`form`](https://cz-nic.github.io/mininterface/Mininterface/#mininterface.Mininterface.form).
 
 Below, you find the screenshots how the program looks in various environments ([graphic](Interfaces.md#guiinterface-or-tkinterface-or-gui) interface, [web](Interfaces.md#webinterface-or-web) interface...).
 
@@ -273,7 +273,7 @@ usage: program.py [-h] [OPTIONS]
 
 You want to try out the Mininterface with your current [`ArgumentParser`](https://docs.python.org/3/library/argparse.html#argparse.ArgumentParser)?
 
-You're using positional arguments, subparsers, types in the ArgumentParser... Mininterface will give you immediate benefit. Just wrap it inside the [`run`][mininterface.run] method.
+You're using positional arguments, subparsers, types in the ArgumentParser... Mininterface will give you immediate benefit. Just wrap it inside the [`run`](https://cz-nic.github.io/mininterface/run/) method.
 
 ```python
 #!/usr/bin/env python3
@@ -330,7 +330,7 @@ Then, a `.form()` call will create a dialog with all the fields.
 
 ![Whole form](https://github.com/CZ-NIC/mininterface/blob/main/asset/argparse_form.avif?raw=True)
 
-You will access the arguments through [`m.env`][mininterface.Mininterface.env]
+You will access the arguments through [`m.env`](https://cz-nic.github.io/mininterface/Mininterface/#mininterface.Mininterface.env)
 
 ```python
 print(m.env.time)  # -> 14:21

{mininterface-1.2.1 → mininterface-1.2.2}/README.md

@@ -151,8 +151,8 @@ These projects have the code base reduced thanks to the mininterface:
 Take a look at the following example.
 
 1. We define any Env class.
-2. Then, we initialize mininterface with [`run(Env)`][mininterface.run] – the missing fields will be prompted for
-3. Then, we use various dialog methods, like [`confirm`][mininterface.Mininterface.confirm], [`select`][mininterface.Mininterface.select] or [`form`][mininterface.Mininterface.form].
+2. Then, we initialize mininterface with [`run(Env)`](https://cz-nic.github.io/mininterface/run/) – the missing fields will be prompted for
+3. Then, we use various dialog methods, like [`confirm`](https://cz-nic.github.io/mininterface/Mininterface/#mininterface.Mininterface.confirm), [`select`](https://cz-nic.github.io/mininterface/Mininterface/#mininterface.Mininterface.select) or [`form`](https://cz-nic.github.io/mininterface/Mininterface/#mininterface.Mininterface.form).
 
 Below, you find the screenshots how the program looks in various environments ([graphic](Interfaces.md#guiinterface-or-tkinterface-or-gui) interface, [web](Interfaces.md#webinterface-or-web) interface...).
 
@@ -233,7 +233,7 @@ usage: program.py [-h] [OPTIONS]
 
 You want to try out the Mininterface with your current [`ArgumentParser`](https://docs.python.org/3/library/argparse.html#argparse.ArgumentParser)?
 
-You're using positional arguments, subparsers, types in the ArgumentParser... Mininterface will give you immediate benefit. Just wrap it inside the [`run`][mininterface.run] method.
+You're using positional arguments, subparsers, types in the ArgumentParser... Mininterface will give you immediate benefit. Just wrap it inside the [`run`](https://cz-nic.github.io/mininterface/run/) method.
 
 ```python
 #!/usr/bin/env python3
@@ -290,7 +290,7 @@ Then, a `.form()` call will create a dialog with all the fields.
 
 ![Whole form](https://github.com/CZ-NIC/mininterface/blob/main/asset/argparse_form.avif?raw=True)
 
-You will access the arguments through [`m.env`][mininterface.Mininterface.env]
+You will access the arguments through [`m.env`](https://cz-nic.github.io/mininterface/Mininterface/#mininterface.Mininterface.env)
 
 ```python
 print(m.env.time)  # -> 14:21

{mininterface-1.2.1 → mininterface-1.2.2}/mininterface/_lib/auxiliary.py

@@ -1,20 +1,36 @@
 import logging
 import os
-import re
-from argparse import ArgumentParser
 from dataclasses import fields, is_dataclass
 from functools import lru_cache
 from types import UnionType
-from typing import Any, Callable, Iterable, Optional, TypeVar, Union, Literal, get_args, get_origin, get_type_hints
+from typing import (
+    Any,
+    Annotated,
+    Callable,
+    Iterable,
+    Optional,
+    TypeVar,
+    Union,
+    Literal,
+    get_args,
+    get_origin,
+    get_type_hints,
+)
 
 from annotated_types import Ge, Gt, Le, Len, Lt, MultipleOf
 
 logger = logging.getLogger(__name__)
 
 try:
-    from tyro.extras import get_parser
+    import tyro
+    from tyro._docstrings import get_field_docstring as _tyro_get_field_docstring
+    from tyro._docstrings import get_callable_description as _tyro_get_callable_description
+
+    _tyro_docstrings_available = True
 except ImportError:
-    get_parser = None
+    tyro = None
+    _tyro_docstrings_available = False
+    _tyro_get_callable_description = None
 
 try:
     from humanize import naturalsize as naturalsize_
@@ -70,40 +86,70 @@ def get_terminal_size():
         return 0, 0
 
 
-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."""
-    # clean-up tyro stuff that may have a meaning in the CLI, but not in the UI
-    return {
-        re.sub(r"\s\(positional\)$", "", action.dest).replace("-", "_"): re.sub(
-            r"\((default|fixed to|required).*\)", "", action.help or ""
-        )
-        for action in parser._actions
-    }
-
+def get_class_description(obj) -> str:
+    if _tyro_get_callable_description:
+        return _tyro_get_callable_description(obj)
+    return ""
 
 @lru_cache
-def _get_parser(obj):
-    if get_parser:
-        return get_parser(obj)
+def _get_descriptions_from_docstring(obj) -> dict[str, str]:
+    """Extract field descriptions for all fields of a class.
+
+    Uses tyro's internal helptext extraction (tyro._docstrings.get_field_docstring),
+    which supports the same sources and precedence as tyro's own CLI generation:
+      1. tyro.conf.arg(help=...)
+      2. PEP 727 Doc
+      3. Docstrings (attribute docstrings or class docstring params)
+      4. Comments (inline or preceding)
+
+    We used to rely on tyro.extras.get_parser(), but that was marked deprecated,
+    so we call tyro's internal API directly instead.
+    """
+    if not _tyro_docstrings_available:
+        return {}
+
+    result = {}
+
+    # Highest priority: tyro.conf.arg(help=...) in Annotated metadata.
+    try:
+        hints = get_type_hints(obj, include_extras=True)
+        ArgConfig = tyro.conf._confstruct._ArgConfig
+        for field_name, hint in hints.items():
+            if get_origin(hint) is Annotated:
+                for meta in hint.__metadata__:
+                    if isinstance(meta, ArgConfig) and meta.help:
+                        result[field_name] = meta.help
+    except Exception:
+        hints = {}
+
+    # Mid priority: docstrings and comments via tyro's own extraction.
+    for field_name in hints:
+        doc = _tyro_get_field_docstring(obj, field_name, ())
+        if doc:
+            result.setdefault(field_name, doc)
+
+    # Lowest priority: field.metadata["help"] from dynamically generated
+    # dataclasses (e.g. built from ArgumentParser via make_dataclass).
+    try:
+        for f in fields(obj):  # type: ignore
+            if help_text := f.metadata.get("help"):
+                result.setdefault(f.name, help_text)
+    except TypeError:
+        pass
+
+    return result
 
 
 def get_description(obj, param: str) -> str:
-    if p := _get_parser(obj):
-        try:
-            d = get_descriptions(p)[param].strip()
-        except KeyError:  # either fetching failed or user added no description
-            return ""
-        else:
-            if d.replace("-", "_") == param:
-                # field `bot_id` is reported as `bot-id` in tyro
-                return ""
-            return d
-    else:
-        # We are missing mininterface[basic] requirement. Tyro is missing.
-        # Without tyro, we are not able to evaluate the class: m.form(Env),
-        # we can still evaluate its instance: m.form(Env()).
-        # However, without descriptions.
-        return ""
+    desc = _get_descriptions_from_docstring(obj).get(param, "")
+    if desc and desc.replace("-", "_") != param:
+        return desc
+
+    # We are missing mininterface[basic] requirement. Tyro is missing.
+    # Without tyro, we are not able to evaluate the class: m.form(Env),
+    # we can still evaluate its instance: m.form(Env()).
+    # However, without descriptions.
+    return ""
 
 
 def yield_annotations(dataclass):
@@ -358,7 +404,7 @@ def strip_none(annotation):
         args = tuple(arg for arg in get_args(annotation) if arg is not type(None))
         if len(args) == 1:
             return args[0]
-        return Union[args]  # nebo origin[args], aby se zachoval typ
+        return Union[args]
 
     return annotation
 

{mininterface-1.2.1 → mininterface-1.2.2}/mininterface/_lib/cli_parser.py

@@ -245,15 +245,7 @@ def parse_cli(
                     kwargs, None if helponly else m, args, type_form, env_classes, _custom_registry, annot, _req_fields
                 )
 
-        # Why setting m.env instead of putting into into a constructor of a new get_interface() call?
-        # 1. Getting the interface is a costly operation
-        # 2. There is this bug so that we need to use single interface:
-        #    TODO
-        #    As this works badly, lets make sure we use single interface now
-        #    and will not need the second one.
-        #    get_interface("gui")
-        #    m = get_interface("gui")
-        #    m.select([1,2,3])
+        # Make the interface ready for the user
         m.env = env
     except SystemExit as exception:
         # --- (C) The dialog missing section ---

{mininterface-1.2.1 → mininterface-1.2.2}/mininterface/_lib/dataclass_creation.py

@@ -1,13 +1,11 @@
 import re
 import warnings
-from dataclasses import MISSING, asdict, dataclass, fields, is_dataclass
+from dataclasses import MISSING, fields, is_dataclass
 from types import UnionType
 from typing import Annotated, Optional, Sequence, Type, Union, get_args, get_origin, TypeVar
 
-
 try:
     from tyro._singleton import MISSING_NONPROP
-    from tyro.extras import subcommand_type_from_defaults
 
     from ..cli import SubcommandPlaceholder
 except ImportError:
@@ -19,7 +17,7 @@ except ImportError:
 from ..tag import Tag
 from ..tag.tag_factory import tag_factory
 from ..validators import not_empty
-from .auxiliary import _get_origin, _get_parser, get_description
+from .auxiliary import _get_origin, get_class_description, get_description
 from .form_dict import DataClass, EnvClass, MissingTagValue
 
 # Pydantic is not a project dependency, that is just an optional integration
@@ -49,6 +47,15 @@ def coerce_type_to_annotation(value, annotation):
     annotation = _unwrap_annotated(annotation)  # NOTE might be superfluous, called before
     origin = get_origin(annotation)
 
+    # Handle Union (e.g. int | None)
+    if origin in (Union, UnionType):
+        for arg in get_args(annotation):
+            try:
+                return coerce_type_to_annotation(value, arg)
+            except Exception:
+                pass
+        return value
+
     # Handle tuple[...] conversion
     if origin is tuple and isinstance(value, list):
         args = get_args(annotation)
@@ -353,7 +360,7 @@ def choose_subcommand(env_classes: list[Type[DataClass]], m: "Mininterface[EnvCl
     # NOTE make select display buttons if there is a little amount of options.
     env = m.select(
         {
-            (to_kebab_case(cl.__name__).replace("-", " ").capitalize(), _get_parser(cl).description): cl
+            (to_kebab_case(cl.__name__).replace("-", " ").capitalize(), get_class_description(cl)): cl
             for cl in env_classes
             if cl is not SubcommandPlaceholder
         }

{mininterface-1.2.1 → mininterface-1.2.2}/mininterface/_lib/tyro_patches.py

@@ -339,16 +339,23 @@ def custom_parse_known_args(cf: CliFlags):
     def _(self: TyroArgumentParser, args=None, namespace=None):
         namespace, args = orig(self, args, namespace)
         # NOTE We may check that the Env does not have its own `verbose``
-        # NOTE I do not like much tests need force=True here as they are run in paralel.
         if cf.add_verbose and hasattr(namespace, "verbose"):
-            if namespace.verbose > 0:
-                logging.basicConfig(
-                    level=cf.get_log_level(namespace.verbose), format="%(message)s", force=True, stream=cf.orig_stream
+            root = logging.getLogger()
+            if not root.handlers:
+                level = (
+                    cf.get_log_level(namespace.verbose)
+                    if namespace.verbose > 0
+                    else cf.default_verbosity
                 )
-            else:
                 logging.basicConfig(
-                    level=cf.default_verbosity, format="%(message)s", force=True, stream=cf.orig_stream
+                    level=level, format="%(message)s", stream=cf.orig_stream
                 )
+            elif namespace.verbose > 0:
+                level = cf.get_log_level(namespace.verbose)
+                root.setLevel(level)
+                for handler in root.handlers:
+                    if handler.level > level:  # increase verbosity for strict handlers
+                        handler.setLevel(level)
             delattr(namespace, "verbose")
 
         if cf.add_version and hasattr(namespace, "version"):
@@ -365,9 +372,15 @@ def custom_parse_known_args(cf: CliFlags):
 
         if cf.add_quiet and hasattr(namespace, "quiet"):
             if namespace.quiet:
-                logging.basicConfig(
-                    level=cf.get_log_level(-1), format="%(message)s", force=True, stream=cf.orig_stream
-                )
+                new_level = cf.get_log_level(-1)
+                root = logging.getLogger()
+                if not root.handlers:
+                    logging.basicConfig(level=new_level, format="%(message)s", stream=cf.orig_stream)
+                else:
+                    root.setLevel(new_level)
+                    for handler in root.handlers:
+                        if handler.level < new_level:  # edit just benevolent handlers
+                            handler.setLevel(new_level)
             delattr(namespace, "quiet")
         return namespace, args
 

{mininterface-1.2.1 → mininterface-1.2.2}/mininterface/_tk_interface/adaptor.py

@@ -32,7 +32,27 @@ class TkAdaptor(Tk, RichUiAdaptor, BackendAdaptor):
     facet: TkFacet
     settings: GuiSettings
 
+    _instance = None
+    """ singleton """
+
+    def __new__(cls, *args, **kwargs):
+        # Singleton.
+        # Why enforcing singleton?
+        # Invoking second tk would mean a strange second window
+        # and non-responding tkinter variables in the second invocation.
+        #    get_interface("gui")
+        #    m = get_interface("gui")
+        #    m.select([1,2,3])  # cannot choose the value
+        if cls._instance is None:
+            return Tk.__new__(cls)
+        return cls._instance
+
     def __init__(self, *args):
+        if self._instance:
+            return
+        else:
+            self.__class__._instance = self
+
         BackendAdaptor.__init__(self, *args)
 
         try:
@@ -40,6 +60,7 @@ class TkAdaptor(Tk, RichUiAdaptor, BackendAdaptor):
         except TclError:
             # even when installed the libraries are installed, display might not be available, hence tkinter fails
             raise InterfaceNotAvailable
+        self._initialized = True
 
         self.params = None
         self._result = None

{mininterface-1.2.1 → mininterface-1.2.2}/mininterface/_tk_interface/secret_entry.py

@@ -25,6 +25,7 @@ class SecretEntryWrapper:
         """Handle toggle key event"""
         self.toggle_show()
         return "break"  # Prevent event propagation
+    
 
     def toggle_show(self):
         if self.tag.toggle_visibility():

{mininterface-1.2.1 → mininterface-1.2.2}/mininterface/_tk_interface/select_input.py

@@ -193,7 +193,8 @@ class SelectInputWrapper:
         widget = AutoCombobox(self.frame, textvariable=self.variable)
         widget["values"] = [k for k, *_ in options]
         widget.pack()
-        widget.bind("<Return>", lambda _: "break")  # override default enter that submits the form
+        #widget.bind("<Return>", lambda _: "break")  # override default enter that submits the form
+        widget.bind("<Return>", lambda _: self._enter_handler())
 
         self.set_default_label()
         self.taking_focus = widget
@@ -212,3 +213,13 @@ class SelectInputWrapper:
             # We never want to select the radiobutton in the initial phase
             # as this might trigger on_change action (not caused by the user)
             var.set(val)
+            
+    def _enter_handler(self, event=None):
+        current_value = self.variable.get()
+        
+        if not current_value:
+            return "break"  # Let it perform the default behavior and open the dropdown
+
+        # If it has a value, submit it
+        self.adaptor._ok()
+        return "break"

{mininterface-1.2.1 → mininterface-1.2.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "mininterface"
-version = "1.2.1"
+version = "1.2.2"
 description = "CLI & dialog toolkit – a minimal interface to Python application (GUI, TUI, CLI + config files, web)"
 authors = ["Edvard Rejthar <edvard.rejthar@nic.cz>"]
 license = "LGPL-3.0-or-later"