mininterface 1.2.0__tar.gz → 1.2.1__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mininterface
-Version: 1.2.0
+Version: 1.2.1
 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

{mininterface-1.2.0 → mininterface-1.2.1}/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.1}/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.1}/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,16 @@ 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
+        # 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
     except SystemExit as exception:
         # --- (C) The dialog missing section ---
         # Some fields are needed to be filled up.
@@ -339,8 +350,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 +369,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 +501,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.1}/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.1}/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,62 @@ 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)
 
-        if cf.add_quiet:
-            self.add_argument(
-                default_prefix + "q",
-                default_prefix * 2 + "quiet",
-                action="store_true",
-                help="suppress warnings, display only errors",
-            )
+    return _
+
+
+def patched__format_help(cf: CliFlags):
+    orig = TyroArgumentParser.format_help
 
-        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 _(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)
+                logging.basicConfig(
+                    level=cf.get_log_level(namespace.verbose), format="%(message)s", force=True, stream=cf.orig_stream
+                )
             else:
-                logging.basicConfig(level=cf.default_verbosity, format="%(message)s", force=True)
+                logging.basicConfig(
+                    level=cf.default_verbosity, format="%(message)s", force=True, stream=cf.orig_stream
+                )
             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 +365,9 @@ 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)
+                logging.basicConfig(
+                    level=cf.get_log_level(-1), format="%(message)s", force=True, stream=cf.orig_stream
+                )
             delattr(namespace, "quiet")
         return namespace, args
 

{mininterface-1.2.0 → mininterface-1.2.1}/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.1}/pyproject.toml

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