mininterface 1.1.4__tar.gz → 1.2.0__tar.gz

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

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: mininterface
-Version: 1.1.4
-Summary: A minimal access to GUI, TUI, CLI and config
+Version: 1.2.0
+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
 Author: Edvard Rejthar

{mininterface-1.1.4 → mininterface-1.2.0}/mininterface/_lib/argparse_support.py

@@ -1,9 +1,19 @@
 import re
 import sys
-from argparse import (SUPPRESS, Action, ArgumentParser, _AppendAction,
-                      _AppendConstAction, _CountAction, _HelpAction,
-                      _StoreConstAction, _StoreFalseAction, _StoreTrueAction,
-                      _SubParsersAction, _VersionAction)
+from argparse import (
+    SUPPRESS,
+    Action,
+    ArgumentParser,
+    _AppendAction,
+    _AppendConstAction,
+    _CountAction,
+    _HelpAction,
+    _StoreConstAction,
+    _StoreFalseAction,
+    _StoreTrueAction,
+    _SubParsersAction,
+    _VersionAction,
+)
 from collections import defaultdict
 from dataclasses import MISSING, Field, dataclass, field, make_dataclass
 from functools import cached_property
@@ -65,7 +75,9 @@ class ArgparseField:
         return self.action.dest in self.properties
 
 
-def parser_to_dataclass(parser: ArgumentParser, name: str = "Args") -> tuple[DataClass | list[DataClass], Optional[str]]:
+def parser_to_dataclass(
+    parser: ArgumentParser, name: str = "Args"
+) -> tuple[DataClass | list[DataClass], Optional[str]]:
     """
     Note: Ex. parser.add_argument("--time", type=time) -> does work at all in argparse, here it works.
 
@@ -197,8 +209,9 @@ def _make_dataclass_from_actions(
             if action.choices:
                 # With the drop of Python 3.10, use mere:
                 # arg_type = Literal[*action.choices]
-                if sys.version_info >= (3,11):
+                if sys.version_info >= (3, 11):
                     from .future_compatibility import literal
+
                     arg_type = literal(action.choices)
                 else:
                     # we do not prefer this option as tyro does not understand it

{mininterface-1.1.4 → mininterface-1.2.0}/mininterface/_lib/auxiliary.py

@@ -5,8 +5,7 @@ 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, Callable, Iterable, Optional, TypeVar, Union, Literal, get_args, get_origin, get_type_hints
 
 from annotated_types import Ge, Gt, Le, Len, Lt, MultipleOf
 
@@ -75,7 +74,9 @@ 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 "")
+        re.sub(r"\s\(positional\)$", "", action.dest).replace("-", "_"): re.sub(
+            r"\((default|fixed to|required).*\)", "", action.help or ""
+        )
         for action in parser._actions
     }
 
@@ -201,7 +202,7 @@ def matches_annotation(value, annotation) -> bool:
         if origin is list:
             return all(matches_annotation(item, subtypes[0]) for item in value)
         elif origin is tuple:
-            if len(subtypes) == 2 and subtypes[1] is Ellipsis: # ex. tuple[int, ...]
+            if len(subtypes) == 2 and subtypes[1] is Ellipsis:  # ex. tuple[int, ...]
                 return all(matches_annotation(v, subtypes[0]) for v in value)
             if len(subtypes) != len(value):
                 return False
@@ -286,8 +287,9 @@ def merge_dicts(d1: dict, d2: dict):
             d1[key] = value
     return d1
 
+
 def dict_diff(a: dict, b: dict) -> dict:
-    """ Returns the B values where they differ. """
+    """Returns the B values where they differ."""
     result = {}
     for k in b:
         if isinstance(a.get(k), dict) and isinstance(b.get(k), dict):
@@ -298,6 +300,7 @@ def dict_diff(a: dict, b: dict) -> dict:
             result[k] = b[k]
     return result
 
+
 def naturalsize(value: float | str, *args) -> str:
     """For a bare interface, humanize might not be installed."""
     if naturalsize_:
@@ -346,6 +349,7 @@ def allows_none(annotation) -> bool:
         return any(arg is type(None) for arg in args)
     return False
 
+
 def strip_none(annotation):
     """Return the same annotation but without NoneType inside a Union/Optional."""
     origin = get_origin(annotation)
@@ -358,7 +362,8 @@ def strip_none(annotation):
 
     return annotation
 
-@lru_cache(maxsize=1024*10)
+
+@lru_cache(maxsize=1024 * 10)
 def _get_origin(tp: Any):
     """
     Cached version of typing.get_origin.

{mininterface-1.1.4 → mininterface-1.2.0}/mininterface/_lib/cli_flags.py

@@ -15,14 +15,17 @@ class CliFlags:
     default_verbosity: int = logging.WARNING
     _verbosity_sequence: Optional[Sequence[int]] = None
 
+    config: bool = False
+
     def __init__(
         self,
         add_verbose: bool | int | Sequence[int] = False,
         add_version: Optional[str] = None,
         add_version_package: Optional[str] = None,
         add_quiet: bool = False,
+        add_config: bool = False,
     ):
-        self._enabled = {"verbose": True, "version": True, "quiet": True}
+        self._enabled = {"verbose": True, "version": True, "quiet": True, "config": True}
         # verbosity
         match add_verbose:
             case bool():
@@ -30,7 +33,7 @@ class CliFlags:
             case int():
                 self._add_verbose = True
                 self.default_verbosity = add_verbose
-                self._verbosity_sequence = list(range(add_verbose-10, -1, -10))
+                self._verbosity_sequence = list(range(add_verbose - 10, -1, -10))
             case list() | tuple():
                 self._add_verbose = True
                 self.default_verbosity = add_verbose[0]
@@ -50,13 +53,17 @@ class CliFlags:
             except PackageNotFoundError:
                 self.version = f"package {add_version_package} not found"
 
+        # config
+        self.config = add_config
+
     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)
         self._enabled["quiet"] = self._add_quiet and self._attr_not_present("quiet", env_classes)
         self._enabled["version"] = self.version and self._attr_not_present("version", env_classes)
+        self._enabled["config"] = self.config and self._attr_not_present("config", env_classes)
 
-        return self.add_verbose or self.add_version or self.add_quiet
+        return self.add_verbose or self.add_version or self.add_quiet or self.add_config
 
     def _attr_not_present(self, flag, env_classes):
         return all(flag not in cl.__annotations__ for cl in env_classes)
@@ -73,6 +80,10 @@ class CliFlags:
     def add_quiet(self):
         return self._add_quiet and self._enabled["quiet"]
 
+    @property
+    def add_config(self):
+        return self.config and self._enabled["config"]
+
     def get_log_level(self, count):
         """
         Ex.
@@ -95,7 +106,7 @@ class CliFlags:
         Returns:
             int: log level
         """
-        if count == -1: # quiet flag
+        if count == -1:  # quiet flag
             return logging.ERROR
         if not count:
             return self.default_verbosity

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

@@ -3,9 +3,11 @@
 #
 from dataclasses import asdict
 from functools import reduce
+from io import StringIO
+from multiprocessing import Value
 import sys
 from collections import deque
-from contextlib import ExitStack
+from contextlib import ExitStack, redirect_stderr, redirect_stdout
 from typing import Annotated, Optional, Sequence, Type, Union
 from unittest.mock import patch
 
@@ -21,10 +23,11 @@ from .auxiliary import (
     flatten,
 )
 from .dataclass_creation import (
-    ChosenSubcommand,
     _unwrap_annotated,
     choose_subcommand,
     create_with_missing,
+    get_chosen,
+    pop_from_passage,
     to_kebab_case,
 )
 from .form_dict import EnvClass, TagDict, dataclass_to_tagdict, MissingTagValue, dict_added_main
@@ -69,13 +72,18 @@ def assure_args(args: Optional[Sequence[str]] = None):
     return args
 
 
+def _subcommands_default_appliable(kwargs, _crawling):
+    if len(_crawling.get()):
+        return kwargs.get("subcommands_default")
+
+
 def parse_cli(
     env_or_list: Type[EnvClass] | list[Type[EnvClass]],
     kwargs: dict,
     m: "Mininterface",
     cf: Optional[CliFlags] = None,
     ask_for_missing: bool = True,
-    args: Optional[Sequence[str]] = None,
+    args: Optional[Sequence[str]] = None,  # NOTE no more Optional, change the arg order
     ask_on_empty_cli: Optional[bool] = None,
     cli_settings: Optional[CliSettings] = None,
     _crawled=None,
@@ -89,6 +97,7 @@ def parse_cli(
     """
     # Xint: The depth we crawled into. The number of subcommands in args.
     # NOTE ask_on_empty_cli might reveal all fields (in cli_parser), not just wrongs. Eg. when using a subparser `$ prog run`, reveal all subparsers.
+    _req_fields = _req_fields or {}
 
     if isinstance(env_or_list, list):
         # We have to convert the list of possible classes (subcommands) to union for tyro.
@@ -149,17 +158,82 @@ def parse_cli(
                 warn(f"Cannot apply {annotations} on Python <= 3.11.")
         return type_form
 
+    #
+    # --- Begin to launch tyro.cli ---
+    # This will be divided into four sections.
+    # (A) First parse section
+    # (B) Re-parse with subcommand-config ensured section
+    # (C) The dialog missing section
+    # (D) The nothing was missing section
+    #
+    enforce_dialog = False
+    """ When subcommand-chooser was raised (hence the CLI input was not completely working and without mininterface it would raise an error),
+    we make sure we display whole CLI overview form at the end."""
+
     try:
         with ExitStack() as stack:
             [stack.enter_context(p) for p in patches]  # apply just the chosen mocks
+
+            # --- (A) First parse section ---
+
+            # Let me explain this awful structure.
+            # If we have subcommanded-config file, we first need the tyro to do the parsing as it leaks the crawled path (through the subcommands).
+            # Then, we can fill the kwargs['default'] from the subcommanded-config and do the second parsing with some field filled up.
+            buffer = StringIO()
+            helponly = False
             try:
-                env = cli(annot(type_form), args=args, registry=_custom_registry, **kwargs)
-            except BaseException:
-                # Why this exception handling? Try putting this out and test_strange_error_mitigation fails.
-                if len(env_classes) > 1 and kwargs.get("default"):
-                    env = cli(annot(kwargs["default"].__class__), args=args[1:], registry=_custom_registry, **kwargs)
+                # Why redirect_stdout? Help-text shows the defaults, which also uses the subcommanded-config.
+                with redirect_stdout(buffer):
+                    try:
+                        # Standard way.
+                        env = cli(annot(type_form), args=args, registry=_custom_registry, **kwargs)
+                    except BaseException:
+                        # Why this exception handling? Try putting this out and test_strange_error_mitigation fails.
+                        if len(env_classes) > 1 and kwargs.get("default"):
+                            env = cli(
+                                annot(kwargs["default"].__class__), args=args[1:], registry=_custom_registry, **kwargs
+                            )
+                        else:
+                            raise
+            except SystemExit as exception:
+                # This catch handling is just for the subcommanded-config.
+                # Not raising this exception means it worked well and we re-parse with the subcommand-config data just below.
+                if _crawled is None and exception.code == 0 and _subcommands_default_appliable(kwargs, _crawling):
+                    # Help-text exception, continue here and try again with subcommands. As it raises SystemExit first,
+                    # it will raise SystemExit in the second run too.
+                    helponly = True
+                elif (
+                    _crawled is None
+                    and _subcommands_default_appliable(kwargs, _crawling)
+                    and exception.code == 2
+                    and failed_fields.get()
+                ):
+                    # Some fields are missing, directly try again. If it raises again
+                    # (some fields are really missing which cannot be filled from the subcommanded-config),
+                    # it will immediately raise again and trigger the (C) dialog missing section.
+                    # If it worked (and no fields are missing), we continue here without triggering the (C) dialog missing section.
+                    _crawled = True
+                    env, enforce_dialog = _try_with_subcommands(
+                        kwargs, m, args, type_form, env_classes, _custom_registry, annot, _req_fields
+                    )
                 else:
+                    # This is either a recurrent call from the (C) dialog missing section (and thus subcommand-config re-parsing was done),
+                    # or there is no subcommand-config data and thus we continue as if this exception handling did not happen.
+                    if content := buffer.getvalue():
+                        print(content)
                     raise
+
+            # --- (B) Re-parse with subcommand-config ensured section ---
+
+            # Re-parse with subcommand-config.
+            # It either raises (if it raised before and subcommand-config did not bring the missing fields) or works well if it worked well before.
+            if _crawled is None and _subcommands_default_appliable(kwargs, _crawling):
+                # Why not catching enforce_dialog here? As we are here, calling tyro.cli worked for the first time.
+                # For sure then, there were no choose_subcommand dialog, subcommands for sure are all written in the CLI.
+                env, _ = _try_with_subcommands(
+                    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:
@@ -170,17 +244,18 @@ def parse_cli(
             #    m = get_interface("gui")
             #    m.select([1,2,3])
             m.env = env
-    except BaseException as exception:
-        if ask_for_missing and getattr(exception, "code", None) == 2 and failed_fields.get():
+    except SystemExit as exception:
+        # --- (C) The dialog missing section ---
+        # Some fields are needed to be filled up.
+        if ask_for_missing and exception.code == 2 and failed_fields.get():
             env = _dialog_missing(
                 env_classes, kwargs, m, cf, ask_for_missing, args, cli_settings, _crawled, _req_fields
             )
 
             if final_call:
                 # Ask for the wrong fields
-                # Why first_attempt? We display the wrong-fields-form only once.
+                # Why final_call? We display the wrong-fields-form only once in the `parse_cli` uppermost call.
                 _ensure_command_init(env, m)
-
                 try:
                     m.form(env)
                 except Cancelled as e:
@@ -201,6 +276,7 @@ def parse_cli(
         # Parsing wrong fields failed. The program ends with a nice tyro message.
         raise
     else:
+        # --- (D) The nothing was missing section ---
         dialog_raised = False
         if final_call:
             _ensure_command_init(env, m)
@@ -219,7 +295,7 @@ def parse_cli(
 
             # Empty CLI → GUI edit
             subcommand_count = len(_crawling.get())
-            if not dialog_raised and ask_on_empty_cli and len(sys.argv) <= 1 + subcommand_count:
+            if not dialog_raised and (ask_on_empty_cli and len(args) <= subcommand_count) or enforce_dialog:
                 # Raise a dialog if the command line is empty.
                 # This still means empty because 'run' and 'message' are just subcommands: `program.py run message`
                 m.form()
@@ -228,6 +304,37 @@ def parse_cli(
         return env, dialog_raised
 
 
+def _try_with_subcommands(kwargs, m, args, type_form, env_classes, _custom_registry, annot, _req_fields):
+    """This awful method is here to re-parse the tyro.cli with the subcommand-config"""
+
+    failed_fields.set([])
+    old_defs = kwargs.get("default", {})
+    if old_defs:
+        old_defs = asdict(old_defs)
+    passage = [cl_name for _, cl_name, _ in _crawling.get()]
+
+    if len(env_classes) > 1:
+        if len(passage):
+            env, cl_name = pop_from_passage(passage, env_classes)
+            if not old_defs:
+                old_defs = kwargs["subcommands_default_union"][cl_name]
+            subc = kwargs["subcommands_default"].get(cl_name)
+        else:  # we should never come here
+            raise ValueError("Subcommands parsing failed")
+    else:
+        env = env_classes[0]
+        subc = kwargs["subcommands_default"]
+    kwargs["default"] = create_with_missing(env, old_defs, _req_fields, m, subc=subc, subc_passage=passage)
+    dialog_used = False
+    if hasattr(m, "__subcommand_dialog_used"):
+        delattr(m, "__subcommand_dialog_used")
+        dialog_used = True
+
+    env = cli(annot(type_form), args=args, registry=_custom_registry, **kwargs)
+
+    return env, dialog_used
+
+
 def _apply_patches(cf: Optional[CliFlags], ask_for_missing, env_classes, kwargs):
     patches = []
 
@@ -272,7 +379,7 @@ def _dialog_missing(
     args: Optional[Sequence[str]],
     cli_settings,
     crawled,
-    req_fields: Optional[TagDict],
+    req_fields: TagDict,
 ) -> EnvClass:
     """Some required arguments are missing. Determine which and ask for them.
 
@@ -288,10 +395,8 @@ def _dialog_missing(
     * env – Tyro's merge of CLI and kwargs["default"].
 
     """
-    req_fields = req_fields or {}
-
     # There are multiple dataclasses, query which is chosen
-    m, env_cl = _ensure_chosen_env(env_classes, args, m)
+    env_cl = _ensure_chosen_env(env_classes, args, m, kwargs)
 
     if crawled is None:
         # This is the first correction attempt.
@@ -302,16 +407,19 @@ def _dialog_missing(
         # So in further run, there is no need to rebuild the data. We just process new failed_fields reported by tyro.
 
         # Merge with the config file defaults.
-        disk = d = asdict(dc) if (dc := kwargs.get("default")) else {}
-        crawled = [None]
-        for _, val, field_name in _crawling.get():
-            # NOTE this might be ameliorated so that config file can define subcommands too, now we throw everything out
-            subd = {}
-            d[field_name] = ChosenSubcommand(val, subd)
-            d = subd
-            crawled.append(val)
-
-        kwargs["default"] = create_with_missing(env_cl, disk, req_fields, m)
+        if len(env_classes) > 1:
+            disk = kwargs.get("subcommands_default_union", {})
+        else:
+            disk = asdict(dc) if (dc := kwargs.get("default")) else {}
+        crawled = True
+        kwargs["default"] = create_with_missing(
+            env_cl,
+            disk,
+            req_fields,
+            m,
+            subc=kwargs.get("subcommands_default"),
+            subc_passage=[cl_name for _, cl_name, _ in _crawling.get()],
+        )
 
     missing_req = _fetch_currently_failed(req_fields)
     """ Fields required and missing from CLI """
@@ -341,10 +449,15 @@ def _dialog_missing(
     return env
 
 
-def _ensure_chosen_env(env_classes, args, m):
+def _ensure_chosen_env(env_classes, args, m, kwargs):
+    # NOTE by preference, handling subclasses union should be done
+    # by making an arbitrary dataclass, having single subcommands attribute.
+    # That way, all the mendling with the env_classes list would disappear from many places in the code as
+    # we already support subclasses in attribute – and this awful function would disappear.
     env = None
     if len(env_classes) == 1:
         env = env_classes[0]
+        return env
     elif len(args):
         env = next(
             (env for env in env_classes if to_kebab_case(env.__name__) == args[0]),
@@ -356,7 +469,14 @@ def _ensure_chosen_env(env_classes, args, m):
         env = choose_subcommand(env_classes, m)
     if not env:
         raise NotImplementedError("This case of nested dataclasses is not implemented. Raise an issue please.")
-    return m, env
+
+    cl_name = to_kebab_case(env.__name__)
+    if kwargs.get("subcommands_default"):
+        kwargs["subcommands_default"] = kwargs["subcommands_default"].get(cl_name)
+    if kwargs.get("subcommands_default_union"):
+        kwargs["subcommands_default_union"] = kwargs["subcommands_default_union"].get(cl_name)
+
+    return env
 
 
 def _fetch_currently_failed(requireds) -> TagDict:

{mininterface-1.1.4 → mininterface-1.2.0}/mininterface/_lib/cli_utils.py

@@ -168,4 +168,4 @@ SubcommandPlaceholder.__name__ = "subcommand"  # show just the shortcut in the C
 #     val: Message | Console
 # m = run(Env) # here
 # m = run([Message, Console]) # and here too
-# Then, add is as a tip to Supported-types.md.
+# Then, add is as a tip to Supported-types.md.

{mininterface-1.1.4 → mininterface-1.2.0}/mininterface/_lib/config_file.py

@@ -1,10 +1,12 @@
+from dataclasses import asdict
 import warnings
 from pathlib import Path
 from typing import Optional, Type
 
+
 from ..settings import MininterfaceSettings
 from .auxiliary import dataclass_asdict_no_defaults, merge_dicts
-from .dataclass_creation import create_with_missing
+from .dataclass_creation import create_with_missing, to_kebab_case
 from .form_dict import EnvClass
 
 try:
@@ -15,6 +17,7 @@ except ImportError:
 
     raise DependencyRequired("basic")
 
+
 def parse_config_file(
     env_or_list: Type[EnvClass] | list[Type[EnvClass]],
     config_file: Path | None = None,
@@ -23,7 +26,7 @@ def parse_config_file(
     """Fetches the config file into the program defaults kwargs["default"] and UI settings.
 
     Args:
-        env_class: Class with the configuration.
+        env_or_list: Class(es) with the configuration.
         config_file: File to load YAML to be merged with the configuration.
             You do not have to re-define all the settings in the config file, you can choose a few.
     Kwargs:
@@ -32,30 +35,29 @@ def parse_config_file(
     Returns:
         Tuple of kwargs and dict (section 'mininterface' in the config file).
     """
-    if isinstance(env_or_list, list):
-        subcommands, env = env_or_list, None
-    else:
-        subcommands, env = None, env_or_list
-
-    # Load config file
-    if config_file and subcommands:
-        # Reading config files when using subcommands is not implemented.
-        # NOTE But might be now.
-        kwargs.pop("default", None)
-        warnings.warn(
-            f"Config file {config_file} is ignored because subcommands are used."
-            " It is not easy to set how this should work."
-            " Describe the developer your usecase so that they might implement this."
-        )
-
     confopt = None
-    if "default" not in kwargs and not subcommands and config_file:
+    if "default" not in kwargs and config_file:
         # Undocumented feature. User put a namespace into kwargs["default"]
         # that already serves for defaults. We do not fetch defaults yet from a config file.
         disk = yaml.safe_load(config_file.read_text()) or {}  # empty file is ok
         try:
             confopt = disk.pop("mininterface", None)
-            kwargs["default"] = create_with_missing(env, disk)
+            subc = {}
+
+            if isinstance(env_or_list, list):
+                kwargs["subcommands_default_union"] = {}
+                for cl in env_or_list:
+                    cl_name = to_kebab_case(cl.__name__)
+                    subc[cl_name] = {}
+                    ooo = create_with_missing(cl, disk.get(cl_name, {}), subc=subc[cl_name])
+                    kwargs["subcommands_default_union"][cl_name] = asdict(ooo)
+                    # `kwargs["default"]` remains empty for now as there is no bare default that tyro would support as everything is hidden under the subcommands
+
+            else:
+                kwargs["default"] = create_with_missing(env_or_list, disk, subc=subc)
+
+            if subc:
+                kwargs["subcommands_default"] = subc
         except TypeError:
             raise SyntaxError(f"Config file parsing failed for {config_file}")
 
@@ -94,4 +96,4 @@ def ensure_settings_inheritance(
     for key, value in vars(create_with_missing(_def_fact, confopt)).items():
         if value is not MISSING_NONPROP:
             setattr(runopt, key, value)
-    return runopt
+    return runopt