deps (tyro): ready for 0.10

Author: e3rd

docs/Changelog.md

@@ -1,5 +1,8 @@
 # Changelog
 
+## 1.2.1 (2025-10-24)
+* deps (tyro): ready for 0.10
+
 ## 1.2.0 (2025-10-17)
 * feat: [`run`][mininterface.run] add_config flag
 * feat: [subcommands](Supported-types.md/#dataclasses-union-subcommand) allowed in the config file

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/_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 @@ def __init__(
         # 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,99 @@ def get_log_level(self, count):
             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/_lib/cli_parser.py

@@ -11,7 +11,6 @@
 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,21 +32,31 @@
 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 (
         _crawling,
         custom_error,
         custom_init,
         custom_parse_known_args,
         failed_fields,
-        patched_parse_known_args,
+        patched__parse_known_args,
+        patched__format_help,
         subparser_call,
-        argparse_init,
+        argparse_init
     )
 except ImportError:
     from ..exceptions import DependencyRequired
@@ -183,6 +192,7 @@ def annot(type_form):
             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 +244,16 @@ def annot(type_form):
                     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 +349,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 +368,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 +500,7 @@ 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/_lib/run.py

@@ -7,7 +7,7 @@
 
 
 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 @@ class Env:
         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