chore: black

Author: e3rd

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 @@ def has_property(self):
         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/_lib/auxiliary.py

@@ -5,8 +5,7 @@
 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/_lib/cli_flags.py

@@ -33,7 +33,7 @@ def __init__(
             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]
@@ -106,7 +106,7 @@ def get_log_level(self, count):
         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/_lib/cli_parser.py

@@ -71,9 +71,11 @@ def assure_args(args: Optional[Sequence[str]] = None):
             args = []
     return args
 
+
 def _subcommands_default_appliable(kwargs, _crawling):
     if len(_crawling.get()):
-                return kwargs.get("subcommands_default")
+        return kwargs.get("subcommands_default")
+
 
 def parse_cli(
     env_or_list: Type[EnvClass] | list[Type[EnvClass]],
@@ -156,7 +158,6 @@ def annot(type_form):
                 warn(f"Cannot apply {annotations} on Python <= 3.11.")
         return type_form
 
-
     #
     # --- Begin to launch tyro.cli ---
     # This will be divided into four sections.
@@ -189,7 +190,9 @@ def annot(type_form):
                     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)
+                            env = cli(
+                                annot(kwargs["default"].__class__), args=args[1:], registry=_custom_registry, **kwargs
+                            )
                         else:
                             raise
             except SystemExit as exception:
@@ -199,13 +202,20 @@ def annot(type_form):
                     # 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():
+                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)
+                    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.
@@ -220,7 +230,9 @@ def annot(type_form):
             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)
+                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
@@ -291,8 +303,9 @@ def annot(type_form):
 
         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 """
+    """This awful method is here to re-parse the tyro.cli with the subcommand-config"""
 
     failed_fields.set([])
     old_defs = kwargs.get("default", {})
@@ -306,7 +319,7 @@ def _try_with_subcommands(kwargs, m, args, type_form, env_classes, _custom_regis
             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
+        else:  # we should never come here
             raise ValueError("Subcommands parsing failed")
     else:
         env = env_classes[0]
@@ -399,7 +412,14 @@ def _dialog_missing(
         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()])
+        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 """

mininterface/_lib/cli_utils.py

@@ -168,4 +168,4 @@ def run(self): ...
 #     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/_lib/dataclass_creation.py

@@ -37,6 +37,7 @@
 
 T = TypeVar("T")
 
+
 def coerce_type_to_annotation(value, annotation):
     """
     Coerce value (e.g. list) to expected type (e.g. tuple[int, int]).
@@ -262,10 +263,12 @@ def _init_struct_value(ftype, disk_value, wf, fname, m, subc, subc_passage, subs
         del wf[fname]
     return v
 
+
 def _is_subcommands(ftype):
     origin = _get_origin(ftype)
     return (origin is Union or origin is UnionType) and all(_is_struct_type(cl) for cl in get_args(ftype))
 
+
 def _process_field(
     fname,
     ftype,
@@ -357,19 +360,22 @@ def choose_subcommand(env_classes: list[Type[DataClass]], m: "Mininterface[EnvCl
     )
     return env
 
-def pop_from_passage(passage, env_classes: Sequence[T])-> tuple[T, str]:
+
+def pop_from_passage(passage, env_classes: Sequence[T]) -> tuple[T, str]:
     cl_name = passage.pop(0)
     # there might be a subcommand prefix, ex. 'val:message' -> 'message'
     cl_name = cl_name.partition(":")[2] or cl_name
     ftype = get_chosen(cl_name, env_classes)
     return ftype, cl_name
 
+
 def get_chosen(cl_name, env_classes):
     for cl in env_classes:
         if to_kebab_case(cl.__name__) == cl_name:
             return cl
     raise ValueError(f"Type {cl_name} not found in {env_classes}")
 
+
 def to_kebab_case(name: str) -> str:
     """MyClass -> my-class"""
     # I did not find where tyro does it. If I find it, I might use its function instead.

mininterface/_lib/form_dict.py

@@ -106,7 +106,7 @@ class Env:
 
 
 def tagdict_resolve(d: FormDict, extract_main=False, _root=True) -> dict:
-    """ Returns a new dict when all Tags are replaced with their values.
+    """Returns a new dict when all Tags are replaced with their values.
 
     Args:
         extract_main: UI need the main section act as nested.
@@ -125,8 +125,9 @@ def tagdict_resolve(d: FormDict, extract_main=False, _root=True) -> dict:
         return {**main, **out}
     return out
 
-def dict_added_main(data:dict):
-    """ Gets a dict modified to the same form as a TagDict (adds the main "" section) """
+
+def dict_added_main(data: dict):
+    """Gets a dict modified to the same form as a TagDict (adds the main "" section)"""
     out = {}
     out[""] = {}
     for key, val in data.items():
@@ -137,8 +138,9 @@ def dict_added_main(data:dict):
 
     return out
 
-def dict_removed_main(data:dict):
-    """ Expand the main "" section among other keys. """
+
+def dict_removed_main(data: dict):
+    """Expand the main "" section among other keys."""
     out = dict(data.get("", {}))
 
     for key, val in data.items():
@@ -149,12 +151,14 @@ def dict_removed_main(data:dict):
         out[key] = val
     return out
 
-def dict_has_main(data:dict):
+
+def dict_has_main(data: dict):
     """
     Calling `m.select(title="")` would raise `m.form({'': SelectTag(...)})`. The tag with the empty name != main section (which is dict).
     """
     return isinstance(data.get(""), dict)
 
+
 def dict_to_tagdict(data: dict, mininterface: Optional["Mininterface"] = None) -> TagDict:
     fd = {}
     for key, val in data.items():
@@ -234,7 +238,9 @@ def dataclass_to_tagdict(env: EnvClass, mininterface: Optional["Mininterface"] =
         raise ValueError(f"We got a namespace instead of class, CLI probably failed: {env}")
 
     for param, val in iterate_attributes(env):
-        if hasattr(val, "__dict__") and not isinstance(val, (FunctionType, MethodType, MissingTagValue, Enum)):  # nested config hierarchy
+        if hasattr(val, "__dict__") and not isinstance(
+            val, (FunctionType, MethodType, MissingTagValue, Enum)
+        ):  # nested config hierarchy
             # nested config hierarchy
             # Why checking the isinstance? See Tag._is_a_callable.
             subdict[param] = dataclass_to_tagdict(val, mininterface, _nested=True)

mininterface/_lib/future_compatibility.py

@@ -1,9 +1,9 @@
-
 from typing import Annotated, Literal
 
 
 def literal(c):
     return Literal[*c]
 
+
 def spread_annotated(obj, annotations):
-    return Annotated[obj, *annotations]
+    return Annotated[obj, *annotations]

mininterface/_lib/run.py

@@ -34,7 +34,7 @@ def run(
     *,
     add_config: bool = False,
     add_help: bool = True,
-    add_verbose: bool|int|Sequence[int] = True,
+    add_verbose: bool | int | Sequence[int] = True,
     add_version: Optional[str] = None,
     add_version_package: Optional[str] = None,
     add_quiet: bool = False,
@@ -249,7 +249,7 @@ class Env:
     args = assure_args(args)
 
     # Prepare the config file
-    if cf:= environ.get("MININTERFACE_CONFIG"):
+    if cf := environ.get("MININTERFACE_CONFIG"):
         config_file = cf
     if add_config and "--config" in args:
         # Detect the `--config` and pop it.
@@ -261,7 +261,7 @@ class Env:
         except IndexError:
             raise ValueError("Missing value after --config")
         else:
-            del args[idx:idx + 2]
+            del args[idx : idx + 2]
     if config_file is True and not kwargs.get("default"):
         # Undocumented feature. User put a namespace into kwargs["default"]
         # that already serves for defaults. We do not fetch defaults yet from a config file.
@@ -330,9 +330,7 @@ class Env:
         # A single Env object, or a list of such objects (with one is not/being selected via args)
         # Load configuration from CLI and a config file
         try:
-            parse_cli(
-                env_or_list, kwargs, m, cf, ask_for_missing, args, ask_on_empty_cli, cliset
-            )
+            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