mininterface 1.2.0__tar.gz → 1.2.2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mininterface
-Version: 1.2.0
+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.0 → 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.0 → mininterface-1.2.2}/mininterface/__main__.py

@@ -1,4 +1,3 @@
-from ast import literal_eval
 from dataclasses import dataclass
 from os import environ
 from pathlib import Path

{mininterface-1.2.0 → 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.0 → mininterface-1.2.2}/mininterface/_lib/cli_flags.py

@@ -1,15 +1,22 @@
-from functools import lru_cache
+from argparse import ArgumentParser
 import logging
-from dataclasses import dataclass
+import sys
 from typing import Optional, Sequence
 
+from tyro.conf import FlagConversionOff
+
 from .form_dict import EnvClass
 
+from typing import List, Any, Optional
+
+from tyro._fields import FieldDefinition
+from tyro.conf._confstruct import _ArgConfig
+
 
 class CliFlags:
 
     _add_verbose: bool = False
-    version: bool | str = False
+    version: str = ""
     _add_quiet: bool = False
 
     default_verbosity: int = logging.WARNING
@@ -56,6 +63,17 @@ class CliFlags:
         # config
         self.config = add_config
 
+        self.orig_stream = (
+            sys.stderr
+        )  # NOTE might be removed now. Might be used if we redirect_stderr while setting basicConfig.
+
+        self.field_list: list[FieldDefinition] = []
+        """ List of FieldDefinitions corresponding to the arguments added via this helper"""
+
+        self.arguments_prepared: list[dict[str, Any]] = []
+        self.setup_done = False
+        """ Setup might be called multiple times – ex. parsing fails and we call tyro.cli in recursion. """
+
     def should_add(self, env_classes: list[EnvClass]) -> bool:
         # Flags are added only if neither the env_class nor any of the subcommands have the same-name flag already
         self._enabled["verbose"] = self._add_verbose and self._attr_not_present("verbose", env_classes)
@@ -116,3 +134,101 @@ class CliFlags:
             seq = self._verbosity_sequence
         log_level = {i + 1: level for i, level in enumerate(seq)}.get(count, logging.NOTSET)
         return log_level
+
+    def add_typed_argument(
+        self,
+        prefix: str,
+        *aliases: str,
+        action: Optional[str] = None,
+        default: Any = False,
+        helptext: Optional[str] = None,
+        metavar: Optional[str] = None,
+        version: Optional[str] = None,
+    ) -> FieldDefinition:
+        # Prepare FieldDefinition
+        name = aliases[0]
+        aliases_ = tuple((prefix * (1 if len(n) == 1 else 2) + n) for n in aliases) if aliases else None
+        typ_ = bool if action in ("store_true", "store_false") else int if action == "count" else str
+
+        field = FieldDefinition(
+            intern_name=name,
+            extern_name=name,
+            type=typ_,
+            type_stripped=typ_,
+            default=default,
+            helptext=helptext,
+            markers={FlagConversionOff},
+            custom_constructor=False,
+            argconf=_ArgConfig(
+                name=aliases_[0],
+                metavar="",
+                help=helptext,
+                help_behavior_hint="",
+                aliases=aliases_[1:] or None,
+                prefix_name=False,
+                constructor_factory=None,
+                default=default,
+            ),
+            mutex_group=None,
+            call_argname=name,
+        )
+
+        self.field_list.append(field)
+
+        # prepare argparse
+        self.arguments_prepared.append(
+            {
+                "field": field,
+                "names": aliases_,
+                "kwargs": {
+                    "action": action,
+                    "default": default,
+                    "help": helptext,
+                    "metavar": metavar,
+                    "version": version,
+                },
+            }
+        )
+
+        return field
+
+    def setup(self, parser: ArgumentParser):
+        if self.setup_done:
+            # tyro.cli might be called multiple times if some missing required fields
+            return
+        self.setup_done = True
+        prefix = "-" if "-" in parser.prefix_chars else parser.prefix_chars[0]
+        if self.add_verbose:
+            self.add_typed_argument(
+                prefix,
+                "verbose",
+                "v",
+                action="count",
+                default=0,
+                helptext="verbosity level, can be used multiple times to increase",
+            )
+
+        if self.add_version:
+            self.add_typed_argument(
+                prefix,
+                "version",
+                action="version",
+                version=self.version,
+                default="",
+                helptext=f"show program's version number ({self.version}) and exit",
+            )
+
+        if self.add_quiet:
+            self.add_typed_argument(
+                prefix, "quiet", "q", action="store_true", helptext="suppress warnings, display only errors"
+            )
+
+        if self.add_config:
+            self.add_typed_argument(
+                prefix, "config", helptext=f"path to config file to fetch the defaults from", metavar="PATH"
+            )
+
+    def apply_to_parser(self, parser):
+        for item in self.arguments_prepared:
+            kwargs = {k: v for k, v in item["kwargs"].items() if v is not None}
+            parser.add_argument(*item["names"], **kwargs)

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

@@ -11,7 +11,6 @@ from contextlib import ExitStack, redirect_stderr, redirect_stdout
 from typing import Annotated, Optional, Sequence, Type, Union
 from unittest.mock import patch
 
-from .cli_flags import CliFlags
 
 from ..cli import Command
 from ..settings import CliSettings
@@ -33,10 +32,20 @@ from .dataclass_creation import (
 from .form_dict import EnvClass, TagDict, dataclass_to_tagdict, MissingTagValue, dict_added_main
 
 try:
+    from .cli_flags import CliFlags
     from tyro import cli
-    from tyro._argparse import _SubParsersAction, ArgumentParser
-    from tyro._argparse_formatter import TyroArgumentParser
-    from tyro._singleton import MISSING_NONPROP
+
+    try:  # tyro >= 0.10
+        from tyro import _experimental_options
+
+        _experimental_options["backend"] = "argparse"
+        from tyro._backends._argparse import _SubParsersAction, ArgumentParser
+        from tyro._backends._argparse_formatter import TyroArgumentParser
+    except ImportError:
+        from tyro._argparse import _SubParsersAction, ArgumentParser
+        from tyro._argparse_formatter import TyroArgumentParser
+    from tyro._parsers import ParserSpecification
+
     from tyro.conf import OmitArgPrefixes, OmitSubcommandPrefixes, DisallowNone, FlagCreatePairsOff
 
     from .tyro_patches import (
@@ -45,7 +54,8 @@ try:
         custom_init,
         custom_parse_known_args,
         failed_fields,
-        patched_parse_known_args,
+        patched__parse_known_args,
+        patched__format_help,
         subparser_call,
         argparse_init,
     )
@@ -183,6 +193,7 @@ def parse_cli(
             helponly = False
             try:
                 # Why redirect_stdout? Help-text shows the defaults, which also uses the subcommanded-config.
+                # TODO maybe new tyro 0.10 will not output to stdout, get rid of the buffer
                 with redirect_stdout(buffer):
                     try:
                         # Standard way.
@@ -234,16 +245,8 @@ 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])
-            m.env = env
+        # Make the interface ready for the user
+        m.env = env
     except SystemExit as exception:
         # --- (C) The dialog missing section ---
         # Some fields are needed to be filled up.
@@ -339,8 +342,7 @@ def _apply_patches(cf: Optional[CliFlags], ask_for_missing, env_classes, kwargs)
     patches = []
 
     patches.append(patch.object(_SubParsersAction, "__call__", subparser_call))
-    patches.append(patch.object(TyroArgumentParser, "_parse_known_args", patched_parse_known_args))
-
+    patches.append(patch.object(TyroArgumentParser, "_parse_known_args", patched__parse_known_args))
     kw = {
         k: v for k, v in kwargs.items() if k != "default"
     }  # NOTE I might separate kwargs['default'] and do not do this filtering
@@ -359,6 +361,11 @@ def _apply_patches(cf: Optional[CliFlags], ask_for_missing, env_classes, kwargs)
                     "__init__",
                     custom_init(cf),
                 ),
+                patch.object(
+                    TyroArgumentParser,
+                    "format_help",
+                    patched__format_help(cf),
+                ),
                 patch.object(
                     TyroArgumentParser,
                     "parse_known_args",
@@ -486,7 +493,12 @@ def _fetch_currently_failed(requireds) -> TagDict:
     missing_req = {}
     for field in failed_fields.get():
         # ex: `_subcommands._nested_subcommands (positional)`
-        fname = field.dest.replace(" (positional)", "").replace("-", "_")  # `_subcommands._nested_subcommands`
+        fname = (
+            field.dest.replace(" (positional)", "")
+            .replace("-", "_")
+            .replace("__tyro_dummy_inner__.", "")
+            .replace("__tyro_dummy_inner__", "")
+        )  # `_subcommands._nested_subcommands`
         fname_raw = fname.rsplit(".", 1)[-1]  # `_nested_subcommands`
 
         if isinstance(field, _SubParsersAction):

{mininterface-1.2.0 → 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.0 → mininterface-1.2.2}/mininterface/_lib/run.py

@@ -7,7 +7,7 @@ from typing import Literal, Optional, Sequence, Type
 
 
 from .._mininterface import Mininterface
-from ..exceptions import DependencyRequired, ValidationFail
+from ..exceptions import DependencyRequired, ValidationFail, _debug_wanted
 from ..interfaces import get_interface
 from ..settings import CliSettings, MininterfaceSettings, UiSettings
 from .form_dict import EnvClass
@@ -332,17 +332,7 @@ def run(
         try:
             parse_cli(env_or_list, kwargs, m, cf, ask_for_missing, args, ask_on_empty_cli, cliset)
         except Exception as e:
-            # Undocumented MININTERFACE_DEBUG flag. Note ipdb package requirement.
-            from ast import literal_eval
-
-            if literal_eval(environ.get("MININTERFACE_DEBUG", "0")):
-                import traceback
-
-                import ipdb
-
-                traceback.print_exception(e)
-                ipdb.post_mortem()
-            else:
+            if not _debug_wanted(e):
                 raise
 
         # Command run

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

@@ -5,14 +5,22 @@ from collections import deque
 from contextvars import ContextVar
 from gettext import gettext as _
 import sys
-from typing import Optional, Callable
 
-from tyro import _argparse as argparse
-from tyro._argparse import Action, _SubParsersAction, ArgumentParser
-from tyro._argparse_formatter import TyroArgumentParser
 
 from .cli_flags import CliFlags
 
+try:
+    # tyro >= 0.10
+    from tyro._backends._argparse import _get_action_name, SUPPRESS, ArgumentError
+    from tyro._backends._argparse import Action, _SubParsersAction, ArgumentParser
+    from tyro._backends._argparse_formatter import TyroArgumentParser
+except ImportError:
+    from tyro._argparse import _get_action_name, SUPPRESS, ArgumentError
+    from tyro._argparse import Action, _SubParsersAction, ArgumentParser
+    from tyro._argparse_formatter import TyroArgumentParser
+from tyro import _arguments
+
+
 failed_fields: ContextVar[list[Action]] = ContextVar("failed_fields", default=[])
 _orig_call = _SubParsersAction.__call__
 _crawling = ContextVar("_crawling", default=deque())
@@ -25,18 +33,7 @@ _orig_init = ArgumentParser.__init__
 #
 # The only line changed: failed_fields
 #
-def patched_parse_known_args(self, arg_strings, namespace):  # type: ignore  # pragma: no cover
-    """We override _parse_known_args() to improve error messages in the presence of
-    subcommands. Difference is marked with <new>...</new> below."""
-
-    # <new>
-    # Reset the unused argument list in the root parser.
-    # Subparsers will have spaces in self.prog.
-    if " " not in self.prog:
-        global global_unrecognized_arg_and_prog
-        global_unrecognized_arg_and_prog = []
-    # </new>
-
+def patched__parse_known_args(self, arg_strings, namespace):
     # replace arg strings that are file references
     if self.fromfile_prefix_chars is not None:
         arg_strings = self._read_args_from_files(arg_strings)
@@ -58,6 +55,7 @@ def patched_parse_known_args(self, arg_strings, namespace):  # type: ignore  # p
     arg_string_pattern_parts = []
     arg_strings_iter = iter(arg_strings)
     for i, arg_string in enumerate(arg_strings_iter):
+
         # all args after -- are non-options
         if arg_string == "--":
             arg_string_pattern_parts.append("-")
@@ -94,16 +92,17 @@ def patched_parse_known_args(self, arg_strings, namespace):  # type: ignore  # p
             for conflict_action in action_conflicts.get(action, []):
                 if conflict_action in seen_non_default_actions:
                     msg = _("not allowed with argument %s")
-                    action_name = argparse._get_action_name(conflict_action)
-                    raise argparse.ArgumentError(action, msg % action_name)
+                    action_name = _get_action_name(conflict_action)
+                    raise ArgumentError(action, msg % action_name)
 
         # take the action if we didn't receive a SUPPRESS value
         # (e.g. from a default)
-        if argument_values is not argparse.SUPPRESS:
+        if argument_values is not SUPPRESS:
             action(self, namespace, argument_values, option_string)
 
     # function to convert arg_strings into an optional action
     def consume_optional(start_index):
+
         # get the optional identified at this index
         option_tuple = option_string_indices[start_index]
         action, option_string, sep, explicit_arg = option_tuple
@@ -113,14 +112,9 @@ def patched_parse_known_args(self, arg_strings, namespace):  # type: ignore  # p
         match_argument = self._match_argument
         action_tuples = []
         while True:
+
             # if we found no optional action, skip it
             if action is None:
-                # <new>
-                # Manually track unused arguments to assist with error messages
-                # later.
-                if not self._parsing_known_args:
-                    global_unrecognized_arg_and_prog.append((option_string, self.prog))
-                # </new>
                 extras.append(arg_strings[start_index])
                 return start_index + 1
 
@@ -136,7 +130,7 @@ def patched_parse_known_args(self, arg_strings, namespace):  # type: ignore  # p
                 if arg_count == 0 and option_string[1] not in chars and explicit_arg != "":
                     if sep or explicit_arg[0] in chars:
                         msg = _("ignored explicit argument %r")
-                        raise argparse.ArgumentError(action, msg % explicit_arg)
+                        raise ArgumentError(action, msg % explicit_arg)
                     action_tuples.append((action, [], option_string))
                     char = option_string[0]
                     option_string = char + explicit_arg[0]
@@ -167,7 +161,7 @@ def patched_parse_known_args(self, arg_strings, namespace):  # type: ignore  # p
                 # explicit argument
                 else:
                     msg = _("ignored explicit argument %r")
-                    raise argparse.ArgumentError(action, msg % explicit_arg)
+                    raise ArgumentError(action, msg % explicit_arg)
 
             # if there is no explicit argument, try to match the
             # optional's string arguments with the following strings
@@ -220,6 +214,7 @@ def patched_parse_known_args(self, arg_strings, namespace):  # type: ignore  # p
     else:
         max_option_string_index = -1
     while start_index <= max_option_string_index:
+
         # consume any Positionals preceding the next option
         next_option_string_index = min([index for index in option_string_indices if index >= start_index])
         if start_index != next_option_string_index:
@@ -256,7 +251,7 @@ def patched_parse_known_args(self, arg_strings, namespace):  # type: ignore  # p
         if action not in seen_actions:
             if action.required:
                 failed_fields.get().append(action)  # WE ADDED THIS LINE
-                required_actions.append(argparse._get_action_name(action))
+                required_actions.append(_get_action_name(action))
             else:
                 # Convert action default now instead of doing it before
                 # parsing arguments to avoid calling convert functions
@@ -268,11 +263,7 @@ def patched_parse_known_args(self, arg_strings, namespace):  # type: ignore  # p
                     and hasattr(namespace, action.dest)
                     and action.default is getattr(namespace, action.dest)
                 ):
-                    setattr(
-                        namespace,
-                        action.dest,
-                        self._get_value(action, action.default),
-                    )
+                    setattr(namespace, action.dest, self._get_value(action, action.default))
 
     if required_actions:
         self.error(_("the following arguments are required: %s") % ", ".join(required_actions))
@@ -286,13 +277,9 @@ def patched_parse_known_args(self, arg_strings, namespace):  # type: ignore  # p
 
             # if no actions were used, report the error
             else:
-                names = [
-                    argparse._get_action_name(action)
-                    for action in group._group_actions
-                    if action.help is not argparse.SUPPRESS
-                ]
+                names = [_get_action_name(action) for action in group._group_actions if action.help is not SUPPRESS]
                 msg = _("one of the arguments %s is required")
-                self.error(msg % " ".join(names))  # type: ignore
+                self.error(msg % " ".join(names))
 
     # return the updated namespace and the extra arguments
     return namespace, extras
@@ -314,65 +301,69 @@ def custom_error(self: TyroArgumentParser, message: str):
 
 
 def custom_init(cf: CliFlags):
+    orig_init = TyroArgumentParser.__init__
+
     def _(self: TyroArgumentParser, *args, **kwargs):
-        super(TyroArgumentParser, self).__init__(*args, **kwargs)
-        default_prefix = "-" if "-" in self.prefix_chars else self.prefix_chars[0]
-        if cf.add_verbose:
-            self.add_argument(
-                default_prefix + "v",
-                default_prefix * 2 + "verbose",
-                action="count",
-                default=0,
-                help="verbosity level, can be used multiple times to increase",
-            )
+        orig_init(self, *args, **kwargs)
 
-        if cf.add_version:
-            self.add_argument(
-                default_prefix * 2 + "version",
-                # NOTE We use the native version, but it inserts a blank line
-                action="version",
-                version=cf.version,
-                # Our custom version works bad with subcommands, we have to first resolve subcommands,
-                # than it comes to the version
-                # action="store_const",
-                # const=cf.version,
-                help=f"show program's version number ({cf.version}) and exit",
-            )
+        cf.setup(self)
+        cf.apply_to_parser(self)
+
+    return _
 
-        if cf.add_quiet:
-            self.add_argument(
-                default_prefix + "q",
-                default_prefix * 2 + "quiet",
-                action="store_true",
-                help="suppress warnings, display only errors",
-            )
 
-        if cf.add_config:
-            self.add_argument(
-                default_prefix * 2 + "config", help=f"path to config file to fetch the defaults from", metavar="PATH"
+def patched__format_help(cf: CliFlags):
+    orig = TyroArgumentParser.format_help
+
+    def _(self, *args, **kwargs):
+        parser_spec = self._parser_specification
+
+        for field in reversed(cf.field_list):
+            field_out = _arguments.ArgumentDefinition(
+                intern_prefix=field.intern_name,
+                extern_prefix=field.extern_name,
+                subcommand_prefix="",
+                field=field,
             )
 
+            parser_spec.args.insert(0, field_out)
+
+        return orig(self, *args, **kwargs)
+
     return _
 
 
 def custom_parse_known_args(cf: CliFlags):
+    orig = TyroArgumentParser.parse_known_args
+
     def _(self: TyroArgumentParser, args=None, namespace=None):
-        namespace, args = super(TyroArgumentParser, self).parse_known_args(args, namespace)
+        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)
-            else:
-                logging.basicConfig(level=cf.default_verbosity, format="%(message)s", force=True)
+            root = logging.getLogger()
+            if not root.handlers:
+                level = (
+                    cf.get_log_level(namespace.verbose)
+                    if namespace.verbose > 0
+                    else cf.default_verbosity
+                )
+                logging.basicConfig(
+                    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")
 
-        # This code is now not used, see `custom_init`
-        # if cf.add_verbose and hasattr(namespace, "version"):
-        #     if namespace.version:
-        #         print(namespace.version)
-        #         raise SystemExit(0)
-        #     delattr(namespace, "version")
+        if cf.add_version and hasattr(namespace, "version"):
+            # This code is now not used, see `custom_init`
+            # if namespace.version:
+            #     print(namespace.version)
+            #     raise SystemExit(0)
+            delattr(namespace, "version")
 
         # Note that we do not parse --config here as it is parsed at `run.py`, before CLI parsing.
         # Since config file serves as default fo CLI parsing.
@@ -381,7 +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)
+                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.0 → 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.0 → 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.0 → 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.0 → mininterface-1.2.2}/mininterface/exceptions.py

@@ -1,5 +1,7 @@
 """Exceptions that might make sense to be used outside the library."""
 
+from os import environ as _environ
+
 
 class Cancelled(SystemExit):
     """User has cancelled.
@@ -47,4 +49,18 @@ class DependencyRequired(InterfaceNotAvailable):
 
     def exit(self):
         """Wrap the exception in a SystemExit so that the program exits without a traceback."""
+        _debug_wanted(self)
         raise SystemExit(self)
+
+
+def _debug_wanted(e: Exception):
+    # Undocumented MININTERFACE_DEBUG flag. Note ipdb package requirement.
+    from ast import literal_eval
+
+    if literal_eval(_environ.get("MININTERFACE_DEBUG", "0")):
+        import traceback
+        import ipdb
+
+        traceback.print_exception(e)
+        ipdb.post_mortem(e)
+        return True

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

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "mininterface"
-version = "1.2.0"
+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"